@vatvaghool/create-ipl-dashboard 0.1.0

package/template/packages/ipl-dashboard-utils/src/transform.ts

@@ -0,0 +1,687 @@
+import type {
+  DailyChartRow,
+  DashboardData,
+  OverallChartItem,
+  RawApiUser,
+  RawUsersSyncResult,
+  ScrapedDashboardPayload,
+  ScrapedLeaderboardItem,
+  ScrapedSquadPlayer,
+  TransformOptions,
+} from "./types.js";
+
+const DEFAULT_TOTAL_TRANSFERS = 160;
+const FLOAT_TOLERANCE = 0.01;
+
+const RAW_TEAM_ALIASES: Record<string, string> = {
+  "Pankaj Konde": "PKs11",
+  "Rishikesh Shinde": "Watapi",
+  "Rushabh Shah": "RushS01",
+  "Vijay Swami": "VATVAGHOOL XI",
+  "Aditya Raut": "SquadSeven9",
+  "Nilesh Birajdar": "Nilesh Birajdar",
+  "Ravi Kiran Guthula": "RKs Stallions",
+  "Rahul Sharma": "RSAwesome 11",
+  "Raviteja Jakkani": "Bat Bowl XI",
+};
+
+const resolveTeamName = (
+  name: string,
+  aliases: Record<string, string> | undefined,
+) => aliases?.[name] ?? RAW_TEAM_ALIASES[name] ?? name;
+
+const normalizeTeamName = (name: string) =>
+  name.toLowerCase().replace(/[^a-z0-9]/g, "");
+
+const calculateTotalPoints = (user: RawApiUser) =>
+  user.matches.reduce((sum, match) => sum + match.points, 0);
+
+const roundPoint = (value: number) => Math.round(value * 10) / 10;
+
+const compareLeadersByPoints = (
+  a: Pick<ScrapedLeaderboardItem, "name" | "points" | "rank">,
+  b: Pick<ScrapedLeaderboardItem, "name" | "points" | "rank">,
+) => {
+  const pointDifference = b.points - a.points;
+  if (pointDifference !== 0) {
+    return pointDifference;
+  }
+
+  const rankDifference =
+    (a.rank ?? Number.MAX_SAFE_INTEGER) - (b.rank ?? Number.MAX_SAFE_INTEGER);
+  if (rankDifference !== 0) {
+    return rankDifference;
+  }
+
+  return a.name.localeCompare(b.name);
+};
+
+const getLatestMatchIdFromDaily = (daily: DailyChartRow[]) =>
+  daily.reduce((latest, row) => {
+    const match = row.day.match(/^Match\s+(\d+)$/i);
+    const matchId = match ? Number(match[1]) : Number.NaN;
+
+    return Number.isFinite(matchId) ? Math.max(latest, matchId) : latest;
+  }, 0);
+
+const findRawUserIndex = (
+  users: RawApiUser[],
+  scrapedName: string,
+  aliases: Record<string, string> | undefined,
+) => {
+  const target = normalizeTeamName(resolveTeamName(scrapedName, aliases));
+  return users.findIndex((user) => normalizeTeamName(user.temname) === target);
+};
+
+const normalizeSquadPlayer = (value: unknown): ScrapedSquadPlayer | null => {
+  if (typeof value === "string") {
+    const name = value.trim();
+    return name ? { name } : null;
+  }
+
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+
+  const item = value as Record<string, unknown>;
+  const rawName = [item.name, item.playerName, item.fullName].find(
+    (entry): entry is string =>
+      typeof entry === "string" && entry.trim().length > 0,
+  );
+
+  if (!rawName) {
+    return null;
+  }
+
+  const rawNumber = [item.number, item.id, item.playerId].find(
+    (entry): entry is string | number =>
+      (typeof entry === "string" && entry.trim().length > 0) ||
+      typeof entry === "number",
+  );
+  const rawPoints = [item.points, item.playerPoints, item.pts].find(
+    (entry) => entry !== undefined && entry !== null,
+  );
+
+  return {
+    name: rawName.trim(),
+    number: rawNumber === undefined ? undefined : String(rawNumber).trim(),
+    points: toFiniteNumber(rawPoints),
+  };
+};
+
+export const toFiniteNumber = (value: unknown) => {
+  const numeric =
+    typeof value === "string"
+      ? Number(value.replace(/,/g, ""))
+      : typeof value === "number"
+        ? value
+        : Number.NaN;
+
+  return Number.isFinite(numeric) ? numeric : undefined;
+};
+
+export const addLeaderboardMetrics = (
+  leaders: ScrapedLeaderboardItem[],
+  options: TransformOptions = {},
+): OverallChartItem[] => {
+  const totalTransfers = options.totalTransfers ?? DEFAULT_TOTAL_TRANSFERS;
+  const sorted = [...leaders]
+    .filter((leader) => Number.isFinite(leader.points))
+    .sort(compareLeadersByPoints);
+  const previousRankMap = new Map(
+    sorted
+      .map((leader) => ({
+        name: leader.name,
+        previousPoints:
+          leader.netPoints ?? leader.points - (leader.lastMatchPoints ?? 0),
+      }))
+      .sort((a, b) => b.previousPoints - a.previousPoints)
+      .map((leader, index) => [leader.name, index + 1]),
+  );
+  const maxLastMatchPoints = Math.max(
+    ...sorted.map((leader) => leader.lastMatchPoints ?? 0),
+  );
+  const leaderboardRange = sorted.length
+    ? sorted[0].points - sorted[sorted.length - 1].points
+    : 0;
+
+  return sorted.map((leader, index) => {
+    const rank = index + 1;
+    const previousRank = leader.netRank ?? previousRankMap.get(leader.name);
+    const nextLeader = sorted[index + 1];
+    const gapToNext = nextLeader ? leader.points - nextLeader.points : 0;
+    const usedTransfers =
+      typeof leader.transfersLeft === "number"
+        ? totalTransfers - leader.transfersLeft
+        : 0;
+
+    return {
+      name: leader.name,
+      points: leader.points,
+      rank,
+      previousRank,
+      previousPoints:
+        leader.netPoints ?? leader.points - (leader.lastMatchPoints ?? 0),
+      lastMatchPoints: leader.lastMatchPoints,
+      gapToNext,
+      gapPercent: leaderboardRange ? (gapToNext / leaderboardRange) * 100 : 0,
+      movement:
+        previousRank === undefined
+          ? "new"
+          : rank < previousRank
+            ? "up"
+            : rank > previousRank
+              ? "down"
+              : "same",
+      transfersLeft: leader.transfersLeft,
+      transfersUsed: leader.transfersUsed,
+      totalTransfers: leader.totalTransfers,
+      boostersUsed: leader.boostersUsed,
+      efficiency:
+        usedTransfers > 0
+          ? Number((leader.points / usedTransfers).toFixed(2))
+          : undefined,
+      isLastMatchLeader:
+        (leader.lastMatchPoints ?? 0) > 0 &&
+        leader.lastMatchPoints === maxLastMatchPoints,
+      captain: leader.captain,
+      viceCaptain: leader.viceCaptain,
+      players: leader.players,
+    };
+  });
+};
+
+export const buildManualDashboard = (
+  users: RawApiUser[],
+  options: TransformOptions = {},
+): DashboardData => {
+  const latestMatchId = users.reduce((latest, user) => {
+    const userLatest = user.matches.reduce(
+      (max, match) => Math.max(max, match.matchId),
+      0,
+    );
+
+    return Math.max(latest, userLatest);
+  }, 0);
+  const sortedByPoints = [...users].sort((a, b) => b.points - a.points);
+  const leaders = sortedByPoints.map((user, index) => ({
+    rank: index + 1,
+    name: user.temname,
+    points: user.points,
+    lastMatchPoints:
+      user.matches.find((match) => match.matchId === latestMatchId)?.points ??
+      0,
+  }));
+
+  const daily: DailyChartRow[] = Array.from(
+    { length: latestMatchId },
+    (_, i) => {
+      const matchId = i + 1;
+      const matchScores = users
+        .map((user) => ({
+          team: user.temname,
+          points:
+            user.matches.find((match) => match.matchId === matchId)?.points ??
+            0,
+        }))
+        .sort((a, b) => b.points - a.points);
+      const row: DailyChartRow = { day: `Match ${matchId}` };
+
+      matchScores.forEach(({ team, points }) => {
+        row[team] = points;
+      });
+
+      return row;
+    },
+  );
+
+  return {
+    overall: addLeaderboardMetrics(leaders, options),
+    daily,
+    completedMatches: latestMatchId || undefined,
+    source: "database",
+  };
+};
+
+export const normalizePayload = (
+  payload: unknown,
+  options: TransformOptions = {},
+): ScrapedDashboardPayload | null => {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+
+  const payloadObject = payload as {
+    leaders?: unknown;
+    completedMatches?: unknown;
+    updatedAt?: unknown;
+    dailyTransferUpdatedAt?: unknown;
+    match?: unknown;
+    time?: unknown;
+    Data?: {
+      Value?: unknown;
+      FeedTime?: {
+        UTCTime?: unknown;
+        ISTTime?: unknown;
+      };
+    };
+    Meta?: {
+      Timestamp?: {
+        UTCTime?: unknown;
+        ISTTime?: unknown;
+      };
+    };
+  };
+
+  const leaders = Array.isArray(payload)
+    ? payload
+    : Array.isArray(payloadObject.leaders)
+      ? payloadObject.leaders
+      : Array.isArray(payloadObject.Data?.Value)
+        ? payloadObject.Data.Value
+        : undefined;
+
+  if (!Array.isArray(leaders)) {
+    return null;
+  }
+
+  const normalized = leaders
+    .map((leader): ScrapedLeaderboardItem | null => {
+      if (!leader || typeof leader !== "object") {
+        return null;
+      }
+
+      const item = leader as Record<string, unknown>;
+      const rank = toFiniteNumber(item.rank);
+      const points = toFiniteNumber(item.points);
+      const nameCandidates = [item.name, item.temname, item.usrname].filter(
+        (value): value is string => typeof value === "string",
+      );
+      const name =
+        nameCandidates
+          .map((value) => value.trim())
+          .find(Boolean)
+          ?.trim() ?? "";
+      const lastMatchPoints = toFiniteNumber(item.lastMatchPoints ?? item.last);
+      const netPoints = toFiniteNumber(item.netPoints);
+      const netRank = toFiniteNumber(item.netRank);
+      const transfersLeft = toFiniteNumber(item.transfersLeft);
+      const transfersUsed = toFiniteNumber(item.transfersUsed);
+      const totalTransfers = toFiniteNumber(item.totalTransfers);
+      const captain = normalizeSquadPlayer(item.captain ?? item.c);
+      const viceCaptain = normalizeSquadPlayer(item.viceCaptain ?? item.v);
+      const captainPoints = toFiniteNumber(item.cPoints);
+      const viceCaptainPoints = toFiniteNumber(item.vPoints);
+      const boostersValue = [item.boostersUsed, item.boosters].find(
+        (entry) => entry !== undefined && entry !== null,
+      );
+      const players = Array.isArray(item.players)
+        ? item.players
+            .map((player) => normalizeSquadPlayer(player))
+            .filter((player): player is NonNullable<typeof player> =>
+              Boolean(player),
+            )
+        : undefined;
+
+      if (!name || points === undefined || rank === undefined) {
+        return null;
+      }
+
+      return {
+        rank: rank ?? Number.MAX_SAFE_INTEGER,
+        name: resolveTeamName(name, options.teamAliases),
+        points,
+        lastMatchPoints,
+        netPoints,
+        netRank,
+        transfersLeft,
+        transfersUsed,
+        totalTransfers,
+        boostersUsed:
+          typeof boostersValue === "string"
+            ? boostersValue.trim()
+            : typeof boostersValue === "number" &&
+                Number.isFinite(boostersValue)
+              ? String(boostersValue)
+              : undefined,
+        captain:
+          captain && captainPoints !== undefined
+            ? { ...captain, points: captainPoints }
+            : captain,
+        viceCaptain:
+          viceCaptain && viceCaptainPoints !== undefined
+            ? { ...viceCaptain, points: viceCaptainPoints }
+            : viceCaptain,
+        players,
+      };
+    })
+    .filter((leader): leader is ScrapedLeaderboardItem => Boolean(leader))
+    .sort(compareLeadersByPoints)
+    .map((leader, index) => ({
+      ...leader,
+      rank: index + 1,
+    }));
+
+  const updatedAtValue = [
+    payloadObject.updatedAt,
+    payloadObject.dailyTransferUpdatedAt,
+    payloadObject.time,
+    payloadObject.Data?.FeedTime?.UTCTime,
+    payloadObject.Data?.FeedTime?.ISTTime,
+    payloadObject.Meta?.Timestamp?.UTCTime,
+    payloadObject.Meta?.Timestamp?.ISTTime,
+  ].find((value) => value !== undefined && value !== null);
+  const completedMatches = [
+    payloadObject.completedMatches,
+    payloadObject.match,
+    String(payloadObject.Data?.FeedTime?.UTCTime ?? "").match(
+      /Match\s*(\d{1,2})/i,
+    )?.[1],
+  ]
+    .map((value) => toFiniteNumber(value))
+    .find((value) => value !== undefined);
+
+  const updatedAt =
+    typeof updatedAtValue === "string" &&
+    !Number.isNaN(Date.parse(updatedAtValue))
+      ? new Date(updatedAtValue).toISOString()
+      : updatedAtValue instanceof Date &&
+          !Number.isNaN(updatedAtValue.getTime())
+        ? updatedAtValue.toISOString()
+        : new Date().toISOString();
+
+  return normalized.length
+    ? {
+        updatedAt,
+        dailyTransferUpdatedAt:
+          typeof payloadObject.dailyTransferUpdatedAt === "string" &&
+          !Number.isNaN(Date.parse(payloadObject.dailyTransferUpdatedAt))
+            ? new Date(payloadObject.dailyTransferUpdatedAt).toISOString()
+            : undefined,
+        completedMatches:
+          completedMatches !== undefined && completedMatches > 0
+            ? Math.floor(completedMatches)
+            : undefined,
+        leaders: normalized,
+      }
+    : null;
+};
+
+export const normalizeRawApiUsers = (payload: unknown): RawApiUser[] | null => {
+  if (!Array.isArray(payload)) {
+    return null;
+  }
+
+  const normalized = payload
+    .map((user): RawApiUser | null => {
+      if (!user || typeof user !== "object") {
+        return null;
+      }
+
+      const item = user as Record<string, unknown>;
+      const rno = toFiniteNumber(item.rno);
+      const temname =
+        typeof item.temname === "string" ? item.temname.trim() : "";
+      const matches = Array.isArray(item.matches)
+        ? item.matches
+            .map((match) => {
+              if (!match || typeof match !== "object") {
+                return null;
+              }
+
+              const matchItem = match as Record<string, unknown>;
+              const matchId = toFiniteNumber(matchItem.matchId);
+              const points = toFiniteNumber(matchItem.points);
+
+              if (matchId === undefined || points === undefined) {
+                return null;
+              }
+
+              return { matchId, points };
+            })
+            .filter(
+              (
+                match,
+              ): match is {
+                matchId: number;
+                points: number;
+              } => Boolean(match),
+            )
+            .sort((a, b) => a.matchId - b.matchId)
+        : [];
+
+      if (rno === undefined || !temname || !matches.length) {
+        return null;
+      }
+
+      return {
+        rno,
+        temname,
+        matches,
+        points: matches.reduce((sum, match) => sum + match.points, 0),
+      };
+    })
+    .filter((user): user is RawApiUser => Boolean(user))
+    .sort((a, b) => a.rno - b.rno);
+
+  return normalized.length ? normalized : null;
+};
+
+export const buildDashboardFromSnapshot = (
+  snapshot: ScrapedDashboardPayload,
+  manualDashboard: DashboardData,
+  options: TransformOptions = {},
+): DashboardData => {
+  const liveDaily: DailyChartRow | null = snapshot.leaders.some(
+    (leader) => typeof leader.lastMatchPoints === "number",
+  )
+    ? snapshot.leaders.reduce<DailyChartRow>(
+        (row, leader) => {
+          row[leader.name] = leader.lastMatchPoints ?? 0;
+          return row;
+        },
+        { day: "Live Update" },
+      )
+    : null;
+  const manualCompletedMatches =
+    manualDashboard.completedMatches ??
+    getLatestMatchIdFromDaily(manualDashboard.daily);
+  const completedMatches =
+    typeof snapshot.completedMatches === "number" &&
+    snapshot.completedMatches > 0
+      ? snapshot.completedMatches
+      : liveDaily
+        ? (manualCompletedMatches ?? 0) + 1
+        : manualCompletedMatches;
+
+  return {
+    overall: addLeaderboardMetrics(snapshot.leaders, options),
+    daily: liveDaily
+      ? [...manualDashboard.daily, liveDaily]
+      : manualDashboard.daily,
+    updatedAt: snapshot.updatedAt,
+    dailyTransferUpdatedAt: snapshot.dailyTransferUpdatedAt,
+    completedMatches,
+    source: "database",
+    snapshot,
+  };
+};
+
+export const syncRawUsersWithSnapshot = (
+  users: RawApiUser[],
+  snapshot: ScrapedDashboardPayload,
+  options: TransformOptions = {},
+): RawUsersSyncResult => {
+  const clonedUsers = users.map((user) => ({
+    ...user,
+    matches: user.matches.map((match) => ({ ...match })),
+  }));
+  const maxMatchId = clonedUsers.reduce(
+    (max, user) => Math.max(max, ...user.matches.map((match) => match.matchId)),
+    0,
+  );
+  const completedMatches =
+    typeof snapshot.completedMatches === "number" &&
+    Number.isFinite(snapshot.completedMatches) &&
+    snapshot.completedMatches > 0
+      ? Math.floor(snapshot.completedMatches)
+      : undefined;
+  const unmatchedNames: string[] = [];
+  const updates = snapshot.leaders.flatMap((leader) => {
+    const userIndex = findRawUserIndex(
+      clonedUsers,
+      leader.name,
+      options.teamAliases,
+    );
+
+    if (userIndex < 0) {
+      unmatchedNames.push(leader.name);
+      return [];
+    }
+
+    const user = clonedUsers[userIndex];
+    const currentTotal = calculateTotalPoints(user);
+    const delta = roundPoint(leader.points - currentTotal);
+    const latestMatch = user.matches.find(
+      (match) => match.matchId === maxMatchId,
+    );
+
+    return [
+      {
+        userIndex,
+        delta,
+        latestMatchPoints: leader.lastMatchPoints,
+        currentLatestPoints: latestMatch?.points ?? 0,
+      },
+    ];
+  });
+
+  if (!updates.length) {
+    return {
+      status: "skipped",
+      users: clonedUsers,
+      unmatchedNames,
+    };
+  }
+
+  const changedUpdates = updates.filter(
+    (update) => Math.abs(update.delta) > FLOAT_TOLERANCE,
+  );
+
+  if (!changedUpdates.length) {
+    return {
+      status: "unchanged",
+      users: clonedUsers,
+      matchId: maxMatchId,
+      completedMatches,
+      unmatchedNames,
+    };
+  }
+
+  const hasFutureReportedMatch =
+    typeof completedMatches === "number" && completedMatches > maxMatchId;
+  const shouldForceUpdateLatest =
+    typeof completedMatches === "number" && completedMatches === maxMatchId;
+  const updatesFitLatestMatch = changedUpdates.every((update) => {
+    if (typeof update.latestMatchPoints !== "number") {
+      return false;
+    }
+
+    return (
+      Math.abs(
+        update.currentLatestPoints + update.delta - update.latestMatchPoints,
+      ) <= FLOAT_TOLERANCE
+    );
+  });
+  const mode =
+    (updatesFitLatestMatch || shouldForceUpdateLatest) &&
+    !hasFutureReportedMatch
+      ? "update-latest"
+      : "append";
+  const matchId =
+    mode === "append"
+      ? Math.max(maxMatchId + 1, completedMatches ?? maxMatchId + 1)
+      : maxMatchId;
+
+  changedUpdates.forEach((update) => {
+    const user = clonedUsers[update.userIndex];
+
+    if (mode === "update-latest") {
+      const latestMatch = user.matches.find(
+        (match) => match.matchId === matchId,
+      );
+
+      if (latestMatch) {
+        latestMatch.points = roundPoint(latestMatch.points + update.delta);
+      } else {
+        user.matches.push({ matchId, points: update.delta });
+      }
+    } else if (matchId > maxMatchId + 1) {
+      const gapStart = maxMatchId + 1;
+      const latestPoints =
+        typeof update.latestMatchPoints === "number"
+          ? roundPoint(update.latestMatchPoints)
+          : undefined;
+      const catchupPoints =
+        latestPoints !== undefined
+          ? roundPoint(update.delta - latestPoints)
+          : roundPoint(update.delta);
+
+      user.matches.push({ matchId: gapStart, points: catchupPoints });
+
+      for (let id = gapStart + 1; id < matchId; id += 1) {
+        user.matches.push({ matchId: id, points: 0 });
+      }
+
+      if (latestPoints !== undefined) {
+        user.matches.push({ matchId, points: latestPoints });
+      }
+    } else {
+      user.matches.push({ matchId, points: update.delta });
+    }
+
+    user.matches.sort((a, b) => a.matchId - b.matchId);
+    user.points = calculateTotalPoints(user);
+  });
+
+  return {
+    status: "updated",
+    users: clonedUsers,
+    matchId,
+    mode,
+    completedMatches,
+    unmatchedNames,
+  };
+};
+
+export const serializeRawApiUsersModule = (users: RawApiUser[]) => {
+  const usersForSource = users.map((user) => ({
+    rno: user.rno,
+    temname: user.temname,
+    points: 0,
+    matches: [...user.matches].sort((a, b) => a.matchId - b.matchId),
+  }));
+
+  return `export type RawApiUser = {
+  rno: number;
+  temname: string;
+  points: number;
+  matches: Array<{
+    matchId: number;
+    points: number;
+  }>;
+};
+
+const calculateTotalPoints = (
+  matches: Array<{ matchId: number; points: number }>,
+): number => {
+  return matches.reduce((sum, match) => sum + match.points, 0);
+};
+
+export const rawApiUsers: RawApiUser[] = ${JSON.stringify(usersForSource, null, 2)}
+  .map((user) => ({
+    ...user,
+    points: calculateTotalPoints(user.matches),
+  }));
+`;
+};