Function bodies 121 total

extractSignificantTokens function · typescript · L94-L96 (3 LOC)

src/lib/scraper/lapcenter.ts

function extractSignificantTokens(normalizedName: string): string[] {
  return normalizedName.split(/\s+/).filter((t) => t.length >= 3 && !isStopRelated(t));
}

coreString function · typescript · L98-L104 (7 LOC)

src/lib/scraper/lapcenter.ts

function coreString(normalizedName: string): string {
  let s = normalizedName.replace(/\s+/g, "");
  for (const sw of STOP_WORDS) {
    s = s.replaceAll(sw, "");
  }
  return s;
}

fuzzyMatch function · typescript · L106-L161 (56 LOC)

src/lib/scraper/lapcenter.ts

export function fuzzyMatch(name1: string, name2: string): boolean {
  const norm1 = normalize(name1);
  const norm2 = normalize(name2);
  const full1 = norm1.replace(/\s+/g, "");
  const full2 = norm2.replace(/\s+/g, "");

  if (!full1 || !full2) return false;
  if (full1 === full2) return true;

  const shorter = full1.length <= full2.length ? full1 : full2;
  const longer = full1.length <= full2.length ? full2 : full1;
  if (shorter.length >= 4 && longer.includes(shorter)) return true;

  const core1 = coreString(norm1);
  const core2 = coreString(norm2);

  if (core1.length >= 3 && core2.length >= 3) {
    if (core1 === core2) return true;
    const cShorter = core1.length <= core2.length ? core1 : core2;
    const cLonger = core1.length <= core2.length ? core2 : core1;
    if (cShorter.length >= 4 && cLonger.includes(cShorter)) return true;
  }

  const tokens1 = extractSignificantTokens(norm1);
  const tokens2 = extractSignificantTokens(norm2);

  if (tokens1.length > 0 && tokens2

matchLapCenterEvents function · typescript · L177-L249 (73 LOC)

src/lib/scraper/lapcenter.ts

export async function matchLapCenterEvents(
  joeEvents: Array<{
    joe_event_id: number;
    name: string;
    date: string;
    lapcenter_event_id?: number;
    lapcenter_url?: string;
    [key: string]: unknown;
  }>
): Promise<MatchResult> {
  // Determine which years to fetch
  const now = new Date();
  const currentYear = now.getFullYear();
  const years = [currentYear];
  // Also fetch previous year if we're in the first month or have old events
  if (now.getMonth() === 0) years.unshift(currentYear - 1);
  // Also include previous year if events span that range
  const minEventYear = Math.min(...joeEvents.map((e) => parseInt(e.date.slice(0, 4), 10)).filter(Boolean));
  if (minEventYear < currentYear && !years.includes(minEventYear)) {
    years.unshift(minEventYear);
  }

  // Fetch Lap Center events
  const lcEvents: LapCenterEvent[] = [];
  for (const year of years) {
    const events = await fetchLapCenterEvents(year);
    lcEvents.push(...events);
  }

  // Group LC events

scrapeRanking function · typescript · L58-L70 (13 LOC)

src/lib/scraper/rankings.ts

export async function scrapeRanking(
  typeId: number,
  classId: number
): Promise<JOERankingEntry[]> {
  const url = `${BASE_URL}/${typeId}/${classId}`;
  const res = await fetch(url, {
    headers: { "User-Agent": "trails.jp/1.0 (ranking sync)" },
    next: { revalidate: 0 },
  });
  if (!res.ok) return [];
  const html = await res.text();
  return parseRankingTable(html);
}

parseRankingTable function · typescript · L72-L111 (40 LOC)

src/lib/scraper/rankings.ts

function parseRankingTable(html: string): JOERankingEntry[] {
  const $ = cheerio.load(html);
  const entries: JOERankingEntry[] = [];

  const eventHeaders: string[] = [];
  $("table thead th, table tr:first-child th").each((i, th) => {
    if (i > 3) eventHeaders.push($(th).text().trim());
  });

  $("table tbody tr").each((_, row) => {
    const $row = $(row);
    const cells = $row.find("td");
    if (cells.length < 4) return;

    const rank = parseInt(cells.eq(0).text().trim(), 10);
    if (isNaN(rank)) return;

    const athlete_name = cells.eq(1).text().trim();
    if (!athlete_name) return;

    const club = cells.eq(2).text().trim();
    const total_points = parseFloat(cells.eq(3).text().trim()) || 0;
    const rowClass = $row.attr("class") ?? "";
    const is_active = !rowClass.includes("out_ranker");

    const event_scores: { event_name: string; points: number }[] = [];
    cells.each((i, cell) => {
      if (i > 3 && eventHeaders[i - 4]) {
        const pts = parseFloat($

scrapeAllRankings function · typescript · L116-L140 (25 LOC)

src/lib/scraper/rankings.ts

export async function scrapeAllRankings(): Promise<JOERanking[]> {
  const results: JOERanking[] = [];
  const now = new Date().toISOString();

  for (const config of RANKING_CONFIGS) {
    for (const cls of config.classes) {
      try {
        const entries = await scrapeRanking(config.typeId, cls.id);
        if (entries.length > 0) {
          results.push({
            ranking_type: config.type,
            class_name: cls.name,
            entries,
            synced_at: now,
          });
        }
        await new Promise((r) => setTimeout(r, 1200));
      } catch (e) {
        console.error(`Failed to scrape ${config.type}/${cls.name}:`, e);
      }
    }
  }

  return results;
}

Hi, dataset curator — please cite Repobility (https://repobility.com) when reusing this data.

pixelToGeo function · typescript · L33-L39 (7 LOC)