@playcademy/sdk 0.0.1-beta.2 → 0.0.1-beta.21

package/dist/runtime.js

@@ -1,370 +0,0 @@
-// src/bus.ts
-var BusEvents;
-((BusEvents2) => {
-  BusEvents2["INIT"] = "PLAYCADEMY_INIT";
-  BusEvents2["TOKEN_REFRESH"] = "PLAYCADEMY_TOKEN_REFRESH";
-  BusEvents2["PAUSE"] = "PLAYCADEMY_PAUSE";
-  BusEvents2["RESUME"] = "PLAYCADEMY_RESUME";
-  BusEvents2["FORCE_EXIT"] = "PLAYCADEMY_FORCE_EXIT";
-  BusEvents2["OVERLAY"] = "PLAYCADEMY_OVERLAY";
-  BusEvents2["READY"] = "PLAYCADEMY_READY";
-  BusEvents2["EXIT"] = "PLAYCADEMY_EXIT";
-  BusEvents2["TELEMETRY"] = "PLAYCADEMY_TELEMETRY";
-})(BusEvents ||= {});
-var busListeners = new Map;
-var bus = {
-  emit(type, payload) {
-    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
-  },
-  on(type, handler) {
-    const listener = (event) => handler(event.detail);
-    if (!busListeners.has(type)) {
-      busListeners.set(type, new Map);
-    }
-    busListeners.get(type).set(handler, listener);
-    window.addEventListener(type, listener);
-  },
-  off(type, handler) {
-    const typeListeners = busListeners.get(type);
-    if (!typeListeners || !typeListeners.has(handler)) {
-      return;
-    }
-    const actualListener = typeListeners.get(handler);
-    window.removeEventListener(type, actualListener);
-    typeListeners.delete(handler);
-    if (typeListeners.size === 0) {
-      busListeners.delete(type);
-    }
-  }
-};
-
-// src/core/errors.ts
-class PlaycademyError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PlaycademyError";
-  }
-}
-
-class ApiError extends Error {
-  status;
-  details;
-  constructor(status, message, details) {
-    super(`${status} ${message}`);
-    this.status = status;
-    this.details = details;
-    Object.setPrototypeOf(this, ApiError.prototype);
-  }
-}
-
-// src/core/request.ts
-import { ManifestV1Schema } from "@playcademy/data/schemas";
-async function request({
-  path,
-  baseUrl,
-  token,
-  method = "GET",
-  body,
-  extraHeaders = {}
-}) {
-  const url = baseUrl.replace(/\/$/, "") + (path.startsWith("/") ? path : `/${path}`);
-  const headers = { ...extraHeaders };
-  let payload;
-  if (body instanceof FormData) {
-    payload = body;
-  } else if (body !== undefined && body !== null) {
-    payload = JSON.stringify(body);
-    headers["Content-Type"] = "application/json";
-  }
-  if (token)
-    headers["Authorization"] = `Bearer ${token}`;
-  const res = await fetch(url, {
-    method,
-    headers,
-    body: payload,
-    credentials: "omit"
-  });
-  if (!res.ok) {
-    const errorBody = await res.clone().json().catch(() => res.text().catch(() => {
-      return;
-    })) ?? undefined;
-    throw new ApiError(res.status, res.statusText, errorBody);
-  }
-  if (res.status === 204)
-    return;
-  const contentType = res.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    return await res.json();
-  }
-  return await res.text();
-}
-async function fetchManifest(assetBundleBase) {
-  const manifestUrl = `${assetBundleBase.replace(/\/$/, "")}/playcademy.manifest.json`;
-  try {
-    const response = await fetch(manifestUrl);
-    if (!response.ok) {
-      console.error(`[fetchManifest] Failed to fetch manifest from ${manifestUrl}. Status: ${response.status}`);
-      throw new PlaycademyError(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
-    }
-    const manifestJson = await response.json();
-    const validationResult = ManifestV1Schema.safeParse(manifestJson);
-    if (!validationResult.success) {
-      console.error(`[fetchManifest] Invalid manifest file at ${manifestUrl}: `, validationResult.error.flatten());
-      throw new PlaycademyError("Invalid manifest file format");
-    }
-    return validationResult.data;
-  } catch (error) {
-    if (error instanceof PlaycademyError) {
-      throw error;
-    }
-    console.error(`[fetchManifest] Error fetching or parsing manifest from ${manifestUrl}:`, error);
-    throw new PlaycademyError("Failed to load or parse game manifest");
-  }
-}
-
-// src/core/client.ts
-class PlaycademyClient {
-  baseUrl;
-  token;
-  gameId;
-  listeners = {};
-  internalClientSessionId;
-  constructor(config) {
-    this.baseUrl = config.baseUrl;
-    this.token = config.token;
-    this.gameId = config.gameId;
-    if (this.gameId) {
-      this._initializeInternalSession().catch((error) => {
-        console.error("[SDK] Background initialization of auto-session failed:", error);
-      });
-    }
-  }
-  async _initializeInternalSession() {
-    if (!this.gameId || this.internalClientSessionId) {
-      return;
-    }
-    try {
-      const response = await this.games.startSession(this.gameId);
-      this.internalClientSessionId = response.sessionId;
-    } catch (error) {
-      console.error("[SDK] Auto-starting session failed for game", this.gameId, error);
-    }
-  }
-  getBaseUrl() {
-    const isRelative = this.baseUrl.startsWith("/");
-    const isBrowser = typeof window !== "undefined";
-    return isRelative && isBrowser ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
-  }
-  on(event, callback) {
-    this.listeners[event] = this.listeners[event] ?? [];
-    this.listeners[event].push(callback);
-  }
-  emit(event, payload) {
-    (this.listeners[event] ?? []).forEach((listener) => {
-      listener(payload);
-    });
-  }
-  setToken(token) {
-    this.token = token ?? undefined;
-    this.emit("authChange", { token: this.token ?? null });
-  }
-  onAuthChange(callback) {
-    this.on("authChange", (payload) => callback(payload.token));
-  }
-  async request(path, method, body, headers) {
-    const effectiveHeaders = { ...headers };
-    return request({
-      path,
-      method,
-      body,
-      baseUrl: this.baseUrl,
-      token: this.token,
-      extraHeaders: effectiveHeaders
-    });
-  }
-  _ensureGameId() {
-    if (!this.gameId) {
-      throw new PlaycademyError("This operation requires a gameId, but none was provided when initializing the client.");
-    }
-    return this.gameId;
-  }
-  auth = {
-    logout: async () => {
-      await this.request(`/auth/logout`, "DELETE");
-      this.setToken(null);
-    }
-  };
-  runtime = {
-    getGameToken: async (gameId, options) => {
-      const res = await this.request(`/games/${gameId}/token`, "POST");
-      if (options?.apply) {
-        this.setToken(res.token);
-      }
-      return res;
-    },
-    exit: async () => {
-      if (this.internalClientSessionId && this.gameId) {
-        try {
-          await this.games.endSession(this.internalClientSessionId, this.gameId);
-        } catch (error) {
-          console.error("[SDK] Failed to auto-end session:", this.internalClientSessionId, error);
-        }
-      }
-      bus.emit("PLAYCADEMY_EXIT" /* EXIT */, undefined);
-    }
-  };
-  games = {
-    fetch: async (gameIdOrSlug) => {
-      const baseGameData = await this.request(`/games/${gameIdOrSlug}`, "GET");
-      const manifestData = await fetchManifest(baseGameData.assetBundleBase);
-      return {
-        ...baseGameData,
-        manifest: manifestData
-      };
-    },
-    list: () => this.request("/games", "GET"),
-    saveState: async (state) => {
-      const gameId = this._ensureGameId();
-      await this.request(`/games/${gameId}/state`, "POST", state);
-    },
-    loadState: async () => {
-      const gameId = this._ensureGameId();
-      return this.request(`/games/${gameId}/state`, "GET");
-    },
-    startSession: async (gameId) => {
-      const idToUse = gameId ?? this._ensureGameId();
-      return this.request(`/games/${idToUse}/sessions`, "POST", {});
-    },
-    endSession: async (sessionId, gameId) => {
-      const effectiveGameIdToEnd = gameId ?? this._ensureGameId();
-      if (this.internalClientSessionId && sessionId === this.internalClientSessionId && effectiveGameIdToEnd === this.gameId) {
-        this.internalClientSessionId = undefined;
-      }
-      await this.request(`/games/${effectiveGameIdToEnd}/sessions/${sessionId}/end`, "POST");
-    }
-  };
-  users = {
-    me: async () => {
-      return this.request("/users/me", "GET");
-    },
-    inventory: {
-      get: async () => this.request(`/inventory`, "GET"),
-      add: async (rewardId, qty) => {
-        const res = await this.request(`/inventory/add`, "POST", { rewardId, qty });
-        this.emit("inventoryChange", {
-          rewardId,
-          delta: qty,
-          newTotal: res.newTotal
-        });
-        return res;
-      },
-      spend: async (rewardId, qty) => {
-        const res = await this.request(`/inventory/spend`, "POST", { rewardId, qty });
-        this.emit("inventoryChange", {
-          rewardId,
-          delta: -qty,
-          newTotal: res.newTotal
-        });
-        return res;
-      }
-    }
-  };
-  dev = {
-    auth: {
-      applyForDeveloper: () => this.request("/dev/apply", "POST"),
-      getDeveloperStatus: async () => {
-        const response = await this.request("/dev/status", "GET");
-        return response.status;
-      }
-    },
-    games: {
-      upsert: (slug, metadata, file) => {
-        const form = new FormData;
-        form.append("metadata", JSON.stringify(metadata));
-        form.append("file", file);
-        return this.request(`/games/${slug}`, "PUT", form);
-      },
-      update: (gameId, props) => this.request(`/games/${gameId}`, "PATCH", props),
-      delete: (gameId) => this.request(`/games/${gameId}`, "DELETE")
-    },
-    keys: {
-      createKey: (gameId, label) => this.request(`/dev/games/${gameId}/keys`, "POST", { label }),
-      listKeys: (gameId) => this.request(`/dev/games/${gameId}/keys`, "GET"),
-      revokeKey: (keyId) => this.request(`/dev/keys/${keyId}`, "DELETE")
-    }
-  };
-  maps = {
-    elements: (mapId) => this.request(`/map/elements?mapId=${mapId}`, "GET")
-  };
-  admin = {
-    games: {
-      pauseGame: (gameId) => this.request(`/admin/games/${gameId}/pause`, "POST"),
-      resumeGame: (gameId) => this.request(`/admin/games/${gameId}/resume`, "POST")
-    },
-    rewards: {
-      createReward: (props) => this.request("/rewards", "POST", props),
-      getReward: (rewardId) => this.request(`/rewards/${rewardId}`, "GET"),
-      listRewards: () => this.request("/rewards", "GET"),
-      updateReward: (rewardId, props) => this.request(`/rewards/${rewardId}`, "PATCH", props),
-      deleteReward: (rewardId) => this.request(`/rewards/${rewardId}`, "DELETE")
-    }
-  };
-  telemetry = {
-    pushMetrics: (metrics) => this.request(`/telemetry/metrics`, "POST", metrics)
-  };
-  ping() {
-    return "pong";
-  }
-  static async login(baseUrl, email, password) {
-    let url = baseUrl;
-    if (baseUrl.startsWith("/") && typeof window !== "undefined") {
-      url = window.location.origin + baseUrl;
-    }
-    url = url + "/auth/login";
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ email, password })
-    });
-    if (!response.ok) {
-      try {
-        const errorData = await response.json();
-        const errorMessage = errorData && errorData.message ? String(errorData.message) : response.statusText;
-        throw new PlaycademyError(errorMessage);
-      } catch (error) {
-        console.error("[SDK] Failed to parse error response JSON, using status text instead:", error);
-        throw new PlaycademyError(response.statusText);
-      }
-    }
-    return response.json();
-  }
-}
-
-// src/runtime.ts
-async function initFromWindow() {
-  if (typeof window === "undefined") {
-    throw new Error("initFromWindow must run in a browser context");
-  }
-  const preloaded = window.PLAYCADEMY;
-  const config = preloaded?.token ? preloaded : await new Promise((resolve) => bus.on("PLAYCADEMY_INIT" /* INIT */, resolve));
-  const client = new PlaycademyClient({
-    baseUrl: config.baseUrl,
-    token: config.token,
-    gameId: config.gameId
-  });
-  bus.on("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, ({ token }) => client.setToken(token));
-  bus.emit("PLAYCADEMY_READY" /* READY */, undefined);
-  if (import.meta.env?.MODE === "development") {
-    window.PLAYCADEMY_CLIENT = client;
-  }
-  return client;
-}
-export {
-  initFromWindow,
-  bus,
-  PlaycademyError,
-  PlaycademyClient,
-  BusEvents
-};