@vatvaghool/create-ipl-dashboard 0.1.0

package/template/tests/upcoming-matches.test.ts

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { parseUpcomingMatches } from "../app/lib/upcomingMatches.ts";
+
+describe("upcoming matches parser", () => {
+  it("parses business-standard schedule chunks into ticker fixtures", () => {
+    const html = `
+      <div>Match 51 Scheduled DC KKR Fri 8th May, 7:30 pm IST, Delhi</div>
+      <div>Delhi Capitals</div>
+      <div>VS</div>
+      <div>Kolkata Knight Riders</div>
+      <div>Match 52 Scheduled RR GT Sat 9th May, 7:30 pm IST, Jaipur</div>
+      <div>Rajasthan Royals</div>
+      <div>VS</div>
+      <div>Gujarat Titans</div>
+    `;
+
+    assert.deepEqual(parseUpcomingMatches(html), [
+      {
+        id: 51,
+        team1: "DC",
+        team2: "KKR",
+        date: "2026-05-08T14:00:00.000Z",
+      },
+      {
+        id: 52,
+        team1: "RR",
+        team2: "GT",
+        date: "2026-05-09T14:00:00.000Z",
+      },
+    ]);
+  });
+});

package/template/tests/utils-and-cache.test.ts

@@ -0,0 +1,267 @@
+import assert from "node:assert/strict";
+import { afterEach, describe, it, mock } from "node:test";
+
+import { readDashboardCache, writeDashboardCache } from "../app/hooks/dashboardCache.ts";
+import { readSnapshotCache, writeSnapshotCache } from "../app/hooks/snapshotCache.ts";
+import {
+  getDisplayLiveMatchId,
+  getLiveUpdateRow,
+  getPlayedMatchRows,
+  hasMeaningfulMatchData,
+  parseMatchId,
+} from "../app/lib/dashboardData.ts";
+import { getMatchViewState } from "../app/lib/dashboardView.ts";
+import { getLatestMatchRow, hasLiveMatchRow } from "../app/lib/dashboardView.ts";
+import { matches } from "../app/lib/matches.ts";
+import { getDiff } from "../app/lib/utils/diff.ts";
+import { getStdDeviation } from "../app/lib/utils/getStdDeviation.ts";
+import { formatMatchTime, getMatchStatus, getTimeLeft } from "../app/lib/utils/time.ts";
+import { splitTeamName, trimTeamName } from "../app/lib/utils.ts";
+
+const createStorage = () => {
+  const store = new Map<string, string>();
+
+  return {
+    getItem: (key: string) => store.get(key) ?? null,
+    setItem: (key: string, value: string) => {
+      store.set(key, value);
+    },
+    removeItem: (key: string) => {
+      store.delete(key);
+    },
+    clear: () => {
+      store.clear();
+    },
+  };
+};
+
+describe("utility and cache coverage", () => {
+  afterEach(() => {
+    delete (globalThis as { window?: unknown }).window;
+    mock.timers.reset();
+  });
+
+  it("trims and splits team names across all branches", () => {
+    assert.equal(trimTeamName("Short"), "Short");
+    assert.equal(trimTeamName("VeryLongTeamName", 8), "VeryLong...");
+    assert.deepEqual(splitTeamName("Alpha"), ["Alpha", ""]);
+    assert.deepEqual(splitTeamName("Alpha Beta", 7), ["Alpha", "Beta"]);
+    assert.deepEqual(splitTeamName("NoSpacesHere", 4), ["NoSp", "acesHere"]);
+    assert.deepEqual(
+      splitTeamName("A very very long team name", 8),
+      ["A very", "very lon..."],
+    );
+  });
+
+  it("computes diffs and standard deviation", () => {
+    assert.deepEqual(
+      getDiff(
+        { a: 1, nested: { left: 2, same: 1 } },
+        { a: 2, nested: { left: 3, same: 1 }, added: true },
+      ),
+      {
+        a: 2,
+        "nested.left": 3,
+        added: true,
+      },
+    );
+    assert.equal(getStdDeviation([2, 4, 4, 4, 5, 5, 7, 9]), 2);
+  });
+
+  it("formats match times and covers all time status helpers", () => {
+    mock.timers.enable({ apis: ["Date"], now: new Date("2026-04-28T10:00:00.000Z") });
+
+    assert.match(
+      formatMatchTime("2026-04-28T14:00:00.000Z", "UTC"),
+      /28 Apr.*02:00 pm/i,
+    );
+    assert.equal(getMatchStatus("2026-04-28T05:30:00.000Z"), "ENDED");
+    assert.equal(getMatchStatus("2026-04-28T09:30:00.000Z"), "LIVE");
+    assert.equal(getMatchStatus("2026-04-28T10:20:00.000Z"), "STARTING SOON");
+    assert.equal(getMatchStatus("2026-04-28T12:00:00.000Z"), "UPCOMING");
+    assert.equal(getTimeLeft("2026-04-28T09:59:00.000Z"), "Started");
+    assert.equal(getTimeLeft("2026-04-28T10:45:00.000Z"), "45m");
+    assert.equal(getTimeLeft("2026-04-28T12:15:00.000Z"), "2h 15m");
+  });
+
+  it("normalizes dashboard daily rows for played matches and live match labels", () => {
+    const daily = [
+      { day: "Match 1", Alpha: 120, Beta: 90 },
+      { day: "Match 2", Alpha: 0, Beta: 0 },
+      { day: "Match 3", Alpha: 65, Beta: 55 },
+      { day: "Live Update", Alpha: 20, Beta: 18 },
+    ];
+
+    assert.equal(parseMatchId("Match 12"), 12);
+    assert.equal(parseMatchId("Live Update"), undefined);
+    assert.equal(hasMeaningfulMatchData(daily[0]), true);
+    assert.equal(hasMeaningfulMatchData(daily[1]), false);
+    assert.deepEqual(
+      getPlayedMatchRows(daily).map((row) => row.day),
+      ["Match 1", "Match 3"],
+    );
+    assert.equal(getLiveUpdateRow(daily)?.day, "Live Update");
+    assert.equal(getDisplayLiveMatchId(daily), 4);
+  });
+
+  it("falls back to the latest played row when no live match row exists", () => {
+    const daily = [
+      { day: "Match 1", Alpha: 10, Beta: 20 },
+      { day: "Match 2", Alpha: 15, Beta: 12 },
+    ];
+
+    assert.equal(hasLiveMatchRow(daily), false);
+    assert.equal(getLatestMatchRow(daily)?.day, "Match 2");
+    assert.equal(getMatchViewState(daily).isLive, false);
+    assert.equal(getMatchViewState(daily).latestRow?.day, "Match 2");
+    assert.equal(getMatchViewState(daily).hasMatches, true);
+  });
+
+  it("reads and writes dashboard cache with invalid payload safeguards", () => {
+    assert.equal(readDashboardCache(), null);
+    assert.doesNotThrow(() =>
+      writeDashboardCache({
+        source: "database",
+        overall: [],
+        daily: [],
+      }),
+    );
+
+    const storage = createStorage();
+    (globalThis as { window?: unknown }).window = {
+      localStorage: storage,
+    };
+
+    assert.equal(readDashboardCache(), null);
+
+    writeDashboardCache({
+      source: "database",
+      updatedAt: "2026-04-28T09:20:00.000Z",
+      snapshot: {
+        updatedAt: "2026-04-28T09:20:00.000Z",
+        leaders: [{ rank: 1, name: "Alpha", points: 120 }],
+      },
+      overall: [{ rank: 1, name: "Alpha", points: 120 }],
+      daily: [{ day: "Match 1", Alpha: 120 }],
+    });
+    const cached = readDashboardCache();
+    assert.ok(cached);
+    assert.equal(cached.data.overall[0].name, "Alpha");
+    assert.ok(cached.cachedAt);
+
+    storage.setItem(
+      "ipl:dashboard-cache:v1",
+      JSON.stringify({
+        data: { source: "database", overall: [], daily: [] },
+      }),
+    );
+    const fallbackCached = readDashboardCache();
+    assert.ok(fallbackCached);
+    assert.equal(typeof fallbackCached.cachedAt, "string");
+
+    storage.setItem(
+      "ipl:dashboard-cache:v1",
+      JSON.stringify({
+        cachedAt: "2026-04-28T09:20:00.000Z",
+        data: {
+          source: "database",
+          updatedAt: "2026-04-28T09:20:00.000Z",
+          overall: [],
+          daily: [],
+        },
+      }),
+    );
+    assert.equal(readDashboardCache(), null);
+
+    storage.setItem("ipl:dashboard-cache:v1", "{\"cachedAt\":1}");
+    assert.equal(readDashboardCache(), null);
+
+    storage.setItem("ipl:dashboard-cache:v1", "null");
+    assert.equal(readDashboardCache(), null);
+
+    storage.setItem("ipl:dashboard-cache:v1", "1");
+    assert.equal(readDashboardCache(), null);
+
+    storage.setItem("ipl:dashboard-cache:v1", JSON.stringify({ data: 1 }));
+    assert.equal(readDashboardCache(), null);
+
+    storage.setItem("ipl:dashboard-cache:v1", "not-json");
+    assert.equal(readDashboardCache(), null);
+  });
+
+  it("reads and writes snapshot cache with fallback timestamps", () => {
+    assert.equal(readSnapshotCache(), null);
+    assert.doesNotThrow(() =>
+      writeSnapshotCache({
+        leaders: [],
+      }),
+    );
+
+    const storage = createStorage();
+    (globalThis as { window?: unknown }).window = {
+      localStorage: storage,
+    };
+
+    assert.equal(readSnapshotCache(), null);
+
+    writeSnapshotCache({
+      updatedAt: "2026-04-28T09:15:00.000Z",
+      completedMatches: 41,
+      leaders: [{ rank: 1, name: "Alpha", points: 110 }],
+    });
+    const cached = readSnapshotCache();
+    assert.ok(cached);
+    assert.equal(cached.snapshot.leaders[0].name, "Alpha");
+    assert.ok(cached.cachedAt);
+
+    storage.setItem(
+      "ipl:snapshot-cache:v1",
+      JSON.stringify({
+        snapshot: { updatedAt: "2026-04-28T09:15:00.000Z", leaders: [] },
+      }),
+    );
+    const fallbackCached = readSnapshotCache();
+    assert.ok(fallbackCached);
+    assert.equal(typeof fallbackCached.cachedAt, "string");
+
+    storage.setItem("ipl:snapshot-cache:v1", "{\"cachedAt\":1}");
+    assert.equal(readSnapshotCache(), null);
+
+    storage.setItem("ipl:snapshot-cache:v1", "1");
+    assert.equal(readSnapshotCache(), null);
+
+    storage.setItem("ipl:snapshot-cache:v1", JSON.stringify({ snapshot: 1 }));
+    assert.equal(readSnapshotCache(), null);
+
+    storage.setItem("ipl:snapshot-cache:v1", "not-json");
+    assert.equal(readSnapshotCache(), null);
+  });
+
+  it("gracefully ignores cache write failures and exposes upcoming match data", () => {
+    (globalThis as { window?: unknown }).window = {
+      localStorage: {
+        getItem: () => null,
+        setItem: () => {
+          throw new Error("quota");
+        },
+      },
+    };
+
+    assert.doesNotThrow(() =>
+      writeDashboardCache({
+        source: "database",
+        overall: [],
+        daily: [],
+      }),
+    );
+    assert.doesNotThrow(() =>
+      writeSnapshotCache({
+        leaders: [],
+      }),
+    );
+
+    assert.equal(matches[0].id, 51);
+    assert.equal(matches.at(-1)?.id, 70);
+    assert.equal(matches.every((match) => match.team1 && match.team2 && match.date), true);
+  });
+});

package/template/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}

package/template/vercel.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "framework": "nextjs",
+  "github": {
+    "enabled": true
+  }
+}