castle-web-sdk 0.4.5 → 0.4.7

package/src/errors.ts

@@ -1,32 +0,0 @@
-export interface GraphqlErrorPayload {
-  message?: string;
-  extensions?: Record<string, unknown>;
-  path?: Array<string | number>;
-}
-
-interface CastleErrorInput {
-  code: string;
-  message: string;
-  operation?: string;
-  status?: number;
-  extensions?: Record<string, unknown>;
-  errors?: GraphqlErrorPayload[];
-}
-
-export class CastleError extends Error {
-  code: string;
-  operation?: string;
-  status?: number;
-  extensions?: Record<string, unknown>;
-  errors?: GraphqlErrorPayload[];
-
-  constructor(input: CastleErrorInput) {
-    super(input.message);
-    this.name = "CastleError";
-    this.code = input.code;
-    this.operation = input.operation;
-    this.status = input.status;
-    this.extensions = input.extensions;
-    this.errors = input.errors;
-  }
-}

package/src/leaderboard.ts

@@ -1,348 +0,0 @@
-import {
-  type RawLeaderboard,
-  type RawLeaderboardEntry,
-} from "./commands";
-import { isEdit } from "./context";
-import { CastleError } from "./errors";
-import { hostRequest } from "./transport";
-
-export type LeaderboardSort = "high" | "low";
-export type LeaderboardScope = string;
-
-export interface LeaderboardOptions {
-  scope?: LeaderboardScope | null;
-}
-
-export interface LeaderboardEntry {
-  place: number;
-  value: number;
-  username: string;
-  userId?: string;
-}
-
-export interface LeaderboardData {
-  list: LeaderboardEntry[];
-  playerRank?: number;
-  playerValue?: number;
-}
-
-interface PendingLeaderboardWrite {
-  variable: string;
-  scope: string | null;
-  highScore: number;
-  lowScore: number;
-  isHighDirty: boolean;
-  isLowDirty: boolean;
-}
-
-interface LeaderboardWriteJob {
-  record: PendingLeaderboardWrite;
-  type: "high" | "low" | "both";
-  score: number;
-}
-
-const LEADERBOARD_FLUSH_INTERVAL_MS = 5000;
-
-// Host stamps deckId, so one deck session = one set of leaderboards; key by
-// variable+scope only and keep the best high/low score per key until flush.
-const leaderboardWrites = new Map<string, PendingLeaderboardWrite>();
-let leaderboardFlushTimer: ReturnType<typeof setTimeout> | null = null;
-let leaderboardFlushPromise: Promise<void> | null = null;
-let leaderboardUnloadHooked = false;
-
-export const Leaderboard = {
-  write(
-    variable: string,
-    score: number,
-    options: LeaderboardOptions = {},
-  ): void {
-    writeLeaderboard(variable, score, options);
-  },
-
-  fetch(
-    variable: string,
-    type: LeaderboardSort,
-    options: LeaderboardOptions = {},
-  ): Promise<LeaderboardData> {
-    return fetchLeaderboardData(variable, type, options);
-  },
-} as const;
-
-function writeLeaderboard(
-  variable: string,
-  score: number,
-  options: LeaderboardOptions,
-): void {
-  if (isEdit()) return;
-  try {
-    bufferLeaderboardWrite(variable, score, options);
-  } catch (error) {
-    reportLeaderboardError(error);
-  }
-}
-
-async function fetchLeaderboardData(
-  variable: string,
-  type: LeaderboardSort,
-  options: LeaderboardOptions,
-): Promise<LeaderboardData> {
-  assertLeaderboardVariable(variable, "Leaderboard.fetch");
-  assertLeaderboardType(type, "Leaderboard.fetch");
-  const scope = leaderboardScope(options);
-  // If the deck has written a score for this variable+scope this session, send
-  // it so the host writes-and-reads via leaderboardV2 and the player's own
-  // score shows up immediately (mirrors getLeaderboard in
-  // core/src/leaderboards.cpp — presence of a buffered score, not dirtiness,
-  // gates the write-through). Otherwise a plain read of the settled board.
-  const record = leaderboardWrites.get(leaderboardWriteKey(variable, scope));
-  const score = record
-    ? type === "high"
-      ? record.highScore
-      : record.lowScore
-    : null;
-  const { leaderboard, currentUserId } = await hostRequest("leaderboard.fetch", {
-    variable,
-    type,
-    scope,
-    ...(score === null ? {} : { score }),
-  });
-  if (record && score !== null) {
-    clearLeaderboardDirtyAfterFetch(record, type, score);
-  }
-  return normalizeLeaderboard(leaderboard, currentUserId);
-}
-
-// After a write-through fetch, clear the dirty flag for the side we just sent
-// (so the periodic flush won't re-send it via saveVariableToLeaderboard). If
-// the other side's buffered value matches what we sent (the common single-score
-// case where high == low), clear it too. The equality guards skip clearing if a
-// concurrent write bumped the buffered score while the fetch was in flight —
-// that newer score still needs flushing. Mirrors leaderboards.cpp.
-function clearLeaderboardDirtyAfterFetch(
-  record: PendingLeaderboardWrite,
-  type: LeaderboardSort,
-  sentScore: number,
-): void {
-  if (type === "high") {
-    if (record.highScore === sentScore) {
-      record.isHighDirty = false;
-      if (record.lowScore === sentScore) record.isLowDirty = false;
-    }
-  } else {
-    if (record.lowScore === sentScore) {
-      record.isLowDirty = false;
-      if (record.highScore === sentScore) record.isHighDirty = false;
-    }
-  }
-}
-
-function bufferLeaderboardWrite(
-  variable: string,
-  score: number,
-  options: LeaderboardOptions,
-): void {
-  assertLeaderboardVariable(variable, "Leaderboard.write");
-  assertLeaderboardScore(score, "Leaderboard.write");
-  const scope = leaderboardScope(options);
-  const key = leaderboardWriteKey(variable, scope);
-  const record = leaderboardWrites.get(key);
-  if (record) {
-    updatePendingLeaderboardWrite(record, score);
-  } else {
-    leaderboardWrites.set(key, newPendingLeaderboardWrite(variable, scope, score));
-  }
-  ensureLeaderboardUnloadFlush();
-  scheduleLeaderboardFlush();
-}
-
-function newPendingLeaderboardWrite(
-  variable: string,
-  scope: string | null,
-  score: number,
-): PendingLeaderboardWrite {
-  return {
-    variable,
-    scope,
-    highScore: score,
-    lowScore: score,
-    isHighDirty: true,
-    isLowDirty: true,
-  };
-}
-
-function updatePendingLeaderboardWrite(
-  record: PendingLeaderboardWrite,
-  score: number,
-): void {
-  if (score > record.highScore) {
-    record.highScore = score;
-    record.isHighDirty = true;
-  }
-  if (score < record.lowScore) {
-    record.lowScore = score;
-    record.isLowDirty = true;
-  }
-}
-
-function scheduleLeaderboardFlush(): void {
-  if (leaderboardFlushTimer) return;
-  leaderboardFlushTimer = setTimeout(() => {
-    leaderboardFlushTimer = null;
-    void flushLeaderboardWrites().catch(reportLeaderboardError);
-  }, LEADERBOARD_FLUSH_INTERVAL_MS);
-}
-
-function ensureLeaderboardUnloadFlush(): void {
-  if (leaderboardUnloadHooked || typeof window === "undefined") return;
-  leaderboardUnloadHooked = true;
-  window.addEventListener("pagehide", () => {
-    void flushLeaderboardWrites().catch(reportLeaderboardError);
-  });
-}
-
-async function flushLeaderboardWrites(): Promise<void> {
-  if (leaderboardFlushPromise) return leaderboardFlushPromise;
-  leaderboardFlushPromise = flushLeaderboardWritesOnce().finally(() => {
-    leaderboardFlushPromise = null;
-    if (hasDirtyLeaderboardWrites()) scheduleLeaderboardFlush();
-  });
-  return leaderboardFlushPromise;
-}
-
-async function flushLeaderboardWritesOnce(): Promise<void> {
-  for (const job of leaderboardWriteJobs()) {
-    await saveLeaderboardScore(job.record, job.score);
-    markLeaderboardWriteClean(job);
-  }
-}
-
-function leaderboardWriteJobs(): LeaderboardWriteJob[] {
-  const jobs: LeaderboardWriteJob[] = [];
-  for (const record of leaderboardWrites.values()) {
-    if (
-      record.isHighDirty &&
-      record.isLowDirty &&
-      record.highScore === record.lowScore
-    ) {
-      jobs.push({ record, type: "both", score: record.highScore });
-    } else {
-      if (record.isHighDirty)
-        jobs.push({ record, type: "high", score: record.highScore });
-      if (record.isLowDirty)
-        jobs.push({ record, type: "low", score: record.lowScore });
-    }
-  }
-  return jobs;
-}
-
-function markLeaderboardWriteClean(job: LeaderboardWriteJob): void {
-  const { record, score, type } = job;
-  if ((type === "high" || type === "both") && record.highScore === score) {
-    record.isHighDirty = false;
-  }
-  if ((type === "low" || type === "both") && record.lowScore === score) {
-    record.isLowDirty = false;
-  }
-}
-
-function hasDirtyLeaderboardWrites(): boolean {
-  for (const record of leaderboardWrites.values()) {
-    if (record.isHighDirty || record.isLowDirty) return true;
-  }
-  return false;
-}
-
-async function saveLeaderboardScore(
-  record: PendingLeaderboardWrite,
-  score: number,
-): Promise<void> {
-  await hostRequest("leaderboard.save", {
-    variable: record.variable,
-    score,
-    scope: record.scope,
-  });
-}
-
-function normalizeLeaderboard(
-  leaderboard: RawLeaderboard,
-  userId: string | null,
-): LeaderboardData {
-  const list = (leaderboard.list ?? []).map(normalizeLeaderboardEntry);
-  const playerRank = playerRankFromList(list, userId);
-  const playerValue = scoreNumber(leaderboard.yourScore?.score);
-  return {
-    list,
-    ...(playerRank === undefined ? {} : { playerRank }),
-    ...(playerValue === undefined ? {} : { playerValue }),
-  };
-}
-
-function normalizeLeaderboardEntry(
-  entry: RawLeaderboardEntry,
-): LeaderboardEntry {
-  const userId = entry.user?.userId ?? undefined;
-  return {
-    place: scoreNumber(entry.place) ?? 0,
-    value: scoreNumber(entry.score) ?? 0,
-    username: entry.user?.username ?? "",
-    ...(userId ? { userId } : {}),
-  };
-}
-
-function playerRankFromList(
-  list: LeaderboardEntry[],
-  userId: string | null,
-): number | undefined {
-  return userId
-    ? list.find((entry) => entry.userId === userId)?.place
-    : undefined;
-}
-
-function scoreNumber(
-  value: string | number | null | undefined,
-): number | undefined {
-  if (typeof value === "number")
-    return Number.isFinite(value) ? value : undefined;
-  if (typeof value !== "string") return undefined;
-  const parsed = Number.parseFloat(value);
-  return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-function leaderboardWriteKey(variable: string, scope: string | null): string {
-  return `${variable}${scope ? `::${scope}` : ""}`;
-}
-
-function leaderboardScope(options: LeaderboardOptions): string | null {
-  return options.scope ?? null;
-}
-
-function assertLeaderboardVariable(variable: string, operation: string): void {
-  if (variable.trim().length > 0) return;
-  throw new CastleError({
-    code: "INVALID_LEADERBOARD_VARIABLE",
-    message: "Leaderboard variable must be a non-empty string.",
-    operation,
-  });
-}
-
-function assertLeaderboardScore(score: number, operation: string): void {
-  if (Number.isFinite(score)) return;
-  throw new CastleError({
-    code: "INVALID_LEADERBOARD_SCORE",
-    message: "Leaderboard score must be a finite number.",
-    operation,
-  });
-}
-
-function assertLeaderboardType(type: LeaderboardSort, operation: string): void {
-  if (type === "high" || type === "low") return;
-  throw new CastleError({
-    code: "INVALID_LEADERBOARD_TYPE",
-    message: "Leaderboard type must be high or low.",
-    operation,
-  });
-}
-
-function reportLeaderboardError(error: unknown): void {
-  console.warn("Castle leaderboard request failed", error);
-}

package/src/passes.ts

@@ -1,95 +0,0 @@
-// Pass — a deck-facing capability for selling a creator "pass" to the player.
-//
-// The deck stays capability-AGNOSTIC: it just offers a pass to the player and
-// gets back one normalized outcome regardless of platform. The host decides what
-// UI to show and whether a real transaction can happen:
-//   - mobile app : renders the native bricks purchase sheet over the deck
-//   - web player : shows an "open in the app" upsell, returns `unavailable`
-//   - dev CLI    : no host UI surface, so the SDK shows a minimal in-page
-//                  notice itself (kept deliberately tiny), returns `unavailable`
-// There is no capability check for the deck to make — every platform returns a
-// PassOfferResult, so a single code path handles them all.
-
-import type { PassOfferResult, PassOfferStatus } from "./commands";
-import { CastleError } from "./errors";
-import { getCommandChannel, hostRequest } from "./transport";
-
-export type { PassOfferResult, PassOfferStatus } from "./commands";
-
-export interface CastlePassApi {
-  has(passId: string): Promise<boolean>;
-  offer(passId: string): Promise<PassOfferResult>;
-}
-
-export const Pass: CastlePassApi = {
-  has,
-  offer,
-};
-
-// Pure read — does the current player already own this pass? No UI, every
-// platform answers it the same way (a GraphQL query). Use it to gate content or
-// to decide whether to bother calling `offer`.
-async function has(passId: string): Promise<boolean> {
-  if (typeof passId !== "string" || passId.length === 0) {
-    throw new CastleError({
-      code: "INVALID_ARGUMENT",
-      message: "Pass.has requires a passId.",
-      operation: "Pass.has",
-    });
-  }
-  const { hasPass } = await hostRequest("pass.has", { passId });
-  return hasPass;
-}
-
-async function offer(passId: string): Promise<PassOfferResult> {
-  if (typeof passId !== "string" || passId.length === 0) {
-    throw new CastleError({
-      code: "INVALID_ARGUMENT",
-      message: "Pass.offer requires a passId.",
-      operation: "Pass.offer",
-    });
-  }
-  const result = await hostRequest("pass.offer", { passId });
-  // On the dev server there's no host chrome to explain why nothing happened,
-  // so surface a small built-in notice. The mobile/web hosts render their own
-  // UI, so the SDK stays silent there.
-  if (result.status === "unavailable" && getCommandChannel() === "local") {
-    showDevUnavailableNotice();
-  }
-  return result;
-}
-
-let devNoticeEl: HTMLDivElement | null = null;
-let devNoticeTimer: ReturnType<typeof setTimeout> | null = null;
-
-// Minimal, dependency-free toast. Dev-only affordance — not the place for a
-// designed purchase UI.
-function showDevUnavailableNotice(): void {
-  if (typeof document === "undefined") return;
-  if (!devNoticeEl) {
-    devNoticeEl = document.createElement("div");
-    devNoticeEl.textContent = "Passes can only be purchased in the Castle app.";
-    devNoticeEl.style.cssText = [
-      "position:fixed",
-      "left:50%",
-      "bottom:24px",
-      "transform:translateX(-50%)",
-      "max-width:80vw",
-      "padding:10px 16px",
-      "border-radius:8px",
-      "background:rgba(0,0,0,0.82)",
-      "color:#fff",
-      "font:500 13px/1.4 system-ui,sans-serif",
-      "text-align:center",
-      "z-index:2147483647",
-      "pointer-events:none",
-      "transition:opacity 0.3s ease",
-    ].join(";");
-    document.body.appendChild(devNoticeEl);
-  }
-  devNoticeEl.style.opacity = "1";
-  if (devNoticeTimer) clearTimeout(devNoticeTimer);
-  devNoticeTimer = setTimeout(() => {
-    if (devNoticeEl) devNoticeEl.style.opacity = "0";
-  }, 3200);
-}