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

package/dist/index.js

@@ -0,0 +1,584 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core/errors.ts
+var PlaycademyError, ApiError;
+var init_errors = __esm(() => {
+  PlaycademyError = class PlaycademyError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "PlaycademyError";
+    }
+  };
+  ApiError = 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
+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}`);
+    }
+    return await response.json();
+  } 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");
+  }
+}
+var init_request = __esm(() => {
+  init_errors();
+  init_errors();
+});
+
+// src/core/namespaces/auth.ts
+function createAuthNamespace(client) {
+  return {
+    logout: async () => {
+      await client["request"](`/auth/logout`, "DELETE");
+      client.setToken(null);
+    }
+  };
+}
+
+// src/messaging.ts
+class PlaycademyMessaging {
+  listeners = new Map;
+  send(type, payload, options) {
+    if (options?.target) {
+      this.sendViaPostMessage(type, payload, options.target, options.origin || "*");
+      return;
+    }
+    const context = this.getMessagingContext(type);
+    if (context.shouldUsePostMessage) {
+      this.sendViaPostMessage(type, payload, context.target, context.origin);
+    } else {
+      this.sendViaCustomEvent(type, payload);
+    }
+  }
+  listen(type, handler) {
+    const postMessageListener = (event) => {
+      const messageEvent = event;
+      if (messageEvent.data?.type === type) {
+        handler(messageEvent.data.payload || messageEvent.data);
+      }
+    };
+    const customEventListener = (event) => {
+      handler(event.detail);
+    };
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, new Map);
+    }
+    const listenerMap = this.listeners.get(type);
+    listenerMap.set(handler, {
+      postMessage: postMessageListener,
+      customEvent: customEventListener
+    });
+    window.addEventListener("message", postMessageListener);
+    window.addEventListener(type, customEventListener);
+  }
+  unlisten(type, handler) {
+    const typeListeners = this.listeners.get(type);
+    if (!typeListeners || !typeListeners.has(handler)) {
+      return;
+    }
+    const listeners = typeListeners.get(handler);
+    window.removeEventListener("message", listeners.postMessage);
+    window.removeEventListener(type, listeners.customEvent);
+    typeListeners.delete(handler);
+    if (typeListeners.size === 0) {
+      this.listeners.delete(type);
+    }
+  }
+  getMessagingContext(eventType) {
+    const isIframe = typeof window !== "undefined" && window.self !== window.top;
+    const iframeToParentEvents = [
+      "PLAYCADEMY_READY" /* READY */,
+      "PLAYCADEMY_EXIT" /* EXIT */,
+      "PLAYCADEMY_TELEMETRY" /* TELEMETRY */
+    ];
+    const shouldUsePostMessage = isIframe && iframeToParentEvents.includes(eventType);
+    return {
+      shouldUsePostMessage,
+      target: shouldUsePostMessage ? window.parent : undefined,
+      origin: "*"
+    };
+  }
+  sendViaPostMessage(type, payload, target = window.parent, origin = "*") {
+    const messageData = { type };
+    if (payload !== undefined) {
+      messageData.payload = payload;
+    }
+    target.postMessage(messageData, origin);
+  }
+  sendViaCustomEvent(type, payload) {
+    window.dispatchEvent(new CustomEvent(type, { detail: payload }));
+  }
+}
+var MessageEvents, messaging;
+var init_messaging = __esm(() => {
+  ((MessageEvents2) => {
+    MessageEvents2["INIT"] = "PLAYCADEMY_INIT";
+    MessageEvents2["TOKEN_REFRESH"] = "PLAYCADEMY_TOKEN_REFRESH";
+    MessageEvents2["PAUSE"] = "PLAYCADEMY_PAUSE";
+    MessageEvents2["RESUME"] = "PLAYCADEMY_RESUME";
+    MessageEvents2["FORCE_EXIT"] = "PLAYCADEMY_FORCE_EXIT";
+    MessageEvents2["OVERLAY"] = "PLAYCADEMY_OVERLAY";
+    MessageEvents2["READY"] = "PLAYCADEMY_READY";
+    MessageEvents2["EXIT"] = "PLAYCADEMY_EXIT";
+    MessageEvents2["TELEMETRY"] = "PLAYCADEMY_TELEMETRY";
+  })(MessageEvents ||= {});
+  messaging = new PlaycademyMessaging;
+});
+
+// src/core/namespaces/runtime.ts
+function createRuntimeNamespace(client) {
+  return {
+    getGameToken: async (gameId, options) => {
+      const res = await client["request"](`/games/${gameId}/token`, "POST");
+      if (options?.apply) {
+        client.setToken(res.token);
+      }
+      return res;
+    },
+    exit: async () => {
+      if (client["internalClientSessionId"] && client["gameId"]) {
+        try {
+          await client.games.endSession(client["internalClientSessionId"], client["gameId"]);
+        } catch (error) {
+          console.error("[SDK] Failed to auto-end session:", client["internalClientSessionId"], error);
+        }
+      }
+      messaging.send("PLAYCADEMY_EXIT" /* EXIT */, undefined);
+    }
+  };
+}
+var init_runtime = __esm(() => {
+  init_messaging();
+});
+
+// src/core/namespaces/games.ts
+function createGamesNamespace(client) {
+  return {
+    fetch: async (gameIdOrSlug) => {
+      const baseGameData = await client["request"](`/games/${gameIdOrSlug}`, "GET");
+      const manifestData = await fetchManifest(baseGameData.assetBundleBase);
+      return {
+        ...baseGameData,
+        manifest: manifestData
+      };
+    },
+    list: () => client["request"]("/games", "GET"),
+    saveState: async (state) => {
+      const gameId = client["_ensureGameId"]();
+      await client["request"](`/games/${gameId}/state`, "POST", state);
+    },
+    loadState: async () => {
+      const gameId = client["_ensureGameId"]();
+      return client["request"](`/games/${gameId}/state`, "GET");
+    },
+    startSession: async (gameId) => {
+      const idToUse = gameId ?? client["_ensureGameId"]();
+      return client["request"](`/games/${idToUse}/sessions`, "POST", {});
+    },
+    endSession: async (sessionId, gameId) => {
+      const effectiveGameIdToEnd = gameId ?? client["_ensureGameId"]();
+      if (client["internalClientSessionId"] && sessionId === client["internalClientSessionId"] && effectiveGameIdToEnd === client["gameId"]) {
+        client["internalClientSessionId"] = undefined;
+      }
+      await client["request"](`/games/${effectiveGameIdToEnd}/sessions/${sessionId}/end`, "POST");
+    }
+  };
+}
+var init_games = __esm(() => {
+  init_request();
+});
+
+// src/core/namespaces/users.ts
+function createUsersNamespace(client) {
+  return {
+    me: async () => {
+      return client["request"]("/users/me", "GET");
+    },
+    inventory: {
+      get: async () => client["request"](`/inventory`, "GET"),
+      add: async (itemId, qty) => {
+        const res = await client["request"](`/inventory/add`, "POST", { itemId, qty });
+        client["emit"]("inventoryChange", {
+          itemId,
+          delta: qty,
+          newTotal: res.newTotal
+        });
+        return res;
+      },
+      spend: async (itemId, qty) => {
+        const res = await client["request"](`/inventory/spend`, "POST", { itemId, qty });
+        client["emit"]("inventoryChange", {
+          itemId,
+          delta: -qty,
+          newTotal: res.newTotal
+        });
+        return res;
+      }
+    }
+  };
+}
+
+// src/core/namespaces/dev.ts
+function createDevNamespace(client) {
+  return {
+    auth: {
+      applyForDeveloper: () => client["request"]("/dev/apply", "POST"),
+      getDeveloperStatus: async () => {
+        const response = await client["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 client["request"](`/games/${slug}`, "PUT", form);
+      },
+      update: (gameId, props) => client["request"](`/games/${gameId}`, "PATCH", props),
+      delete: (gameId) => client["request"](`/games/${gameId}`, "DELETE")
+    },
+    keys: {
+      createKey: (gameId, label) => client["request"](`/dev/games/${gameId}/keys`, "POST", { label }),
+      listKeys: (gameId) => client["request"](`/dev/games/${gameId}/keys`, "GET"),
+      revokeKey: (keyId) => client["request"](`/dev/keys/${keyId}`, "DELETE")
+    }
+  };
+}
+
+// src/core/namespaces/maps.ts
+function createMapsNamespace(client) {
+  return {
+    elements: (mapId) => client["request"](`/map/elements?mapId=${mapId}`, "GET")
+  };
+}
+
+// src/core/namespaces/admin.ts
+function createAdminNamespace(client) {
+  return {
+    games: {
+      pauseGame: (gameId) => client["request"](`/admin/games/${gameId}/pause`, "POST"),
+      resumeGame: (gameId) => client["request"](`/admin/games/${gameId}/resume`, "POST")
+    },
+    items: {
+      create: (props) => client["request"]("/items", "POST", props),
+      get: (itemId) => client["request"](`/items/${itemId}`, "GET"),
+      list: () => client["request"]("/items", "GET"),
+      update: (itemId, props) => client["request"](`/items/${itemId}`, "PATCH", props),
+      delete: (itemId) => client["request"](`/items/${itemId}`, "DELETE")
+    },
+    currencies: {
+      create: (props) => client["request"]("/currencies", "POST", props),
+      get: (currencyId) => client["request"](`/currencies/${currencyId}`, "GET"),
+      list: () => client["request"]("/currencies", "GET"),
+      update: (currencyId, props) => client["request"](`/currencies/${currencyId}`, "PATCH", props),
+      delete: (currencyId) => client["request"](`/currencies/${currencyId}`, "DELETE")
+    },
+    shopListings: {
+      create: (props) => client["request"]("/shop-listings", "POST", props),
+      get: (listingId) => client["request"](`/shop-listings/${listingId}`, "GET"),
+      list: () => client["request"]("/shop-listings", "GET"),
+      update: (listingId, props) => client["request"](`/shop-listings/${listingId}`, "PATCH", props),
+      delete: (listingId) => client["request"](`/shop-listings/${listingId}`, "DELETE")
+    }
+  };
+}
+
+// src/core/namespaces/shop.ts
+function createShopNamespace(client) {
+  return {
+    view: () => {
+      return client["request"]("/shop/view", "GET");
+    }
+  };
+}
+
+// src/core/namespaces/telemetry.ts
+function createTelemetryNamespace(client) {
+  return {
+    pushMetrics: (metrics) => client["request"](`/telemetry/metrics`, "POST", metrics)
+  };
+}
+
+// src/core/namespaces/index.ts
+var init_namespaces = __esm(() => {
+  init_runtime();
+  init_games();
+});
+
+// src/core/static/init.ts
+async function getPlaycademyConfig() {
+  const preloaded = window.PLAYCADEMY;
+  if (preloaded?.token) {
+    return preloaded;
+  }
+  if (window.self !== window.top) {
+    return await waitForPlaycademyInit();
+  } else {
+    return createStandaloneConfig();
+  }
+}
+async function waitForPlaycademyInit() {
+  return new Promise((resolve, reject) => {
+    let contextReceived = false;
+    const timeoutDuration = 5000;
+    const handleMessage = (event) => {
+      if (event.data?.type === "PLAYCADEMY_INIT" /* INIT */) {
+        contextReceived = true;
+        window.removeEventListener("message", handleMessage);
+        clearTimeout(timeoutId);
+        window.PLAYCADEMY = event.data.payload;
+        resolve(event.data.payload);
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    const timeoutId = setTimeout(() => {
+      if (!contextReceived) {
+        window.removeEventListener("message", handleMessage);
+        reject(new Error(`${"PLAYCADEMY_INIT" /* INIT */} not received within ${timeoutDuration}ms`));
+      }
+    }, timeoutDuration);
+  });
+}
+function createStandaloneConfig() {
+  const mockConfig = {
+    baseUrl: "/api",
+    token: "mock-game-token-for-local-dev",
+    gameId: "mock-game-id-from-template"
+  };
+  window.PLAYCADEMY = mockConfig;
+  return mockConfig;
+}
+async function init() {
+  const { PlaycademyClient } = await Promise.resolve().then(() => (init_client(), exports_client));
+  if (typeof window === "undefined") {
+    throw new Error("Playcademy SDK must run in a browser context");
+  }
+  const config = await getPlaycademyConfig();
+  const client = new PlaycademyClient({
+    baseUrl: config.baseUrl,
+    token: config.token,
+    gameId: config.gameId
+  });
+  messaging.listen("PLAYCADEMY_TOKEN_REFRESH" /* TOKEN_REFRESH */, ({ token }) => client.setToken(token));
+  messaging.send("PLAYCADEMY_READY" /* READY */, undefined);
+  if (import.meta.env?.MODE === "development") {
+    window.PLAYCADEMY_CLIENT = client;
+  }
+  return client;
+}
+var init_init = __esm(() => {
+  init_messaging();
+});
+
+// src/core/static/login.ts
+async function 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();
+}
+var init_login = __esm(() => {
+  init_errors();
+});
+
+// src/core/static/index.ts
+var init_static = __esm(() => {
+  init_init();
+  init_login();
+});
+
+// src/core/client.ts
+var exports_client = {};
+__export(exports_client, {
+  PlaycademyClient: () => PlaycademyClient
+});
+var PlaycademyClient;
+var init_client = __esm(() => {
+  init_errors();
+  init_request();
+  init_namespaces();
+  init_static();
+  PlaycademyClient = class PlaycademyClient {
+    baseUrl;
+    token;
+    gameId;
+    listeners = {};
+    internalClientSessionId;
+    constructor(config) {
+      if (!config) {
+        this.baseUrl = "/api";
+        this.token = undefined;
+        this.gameId = undefined;
+      } else {
+        this.baseUrl = config.baseUrl || "/api";
+        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);
+        });
+      }
+    }
+    getBaseUrl() {
+      const isRelative = this.baseUrl.startsWith("/");
+      const isBrowser = typeof window !== "undefined";
+      return isRelative && isBrowser ? `${window.location.origin}${this.baseUrl}` : this.baseUrl;
+    }
+    ping() {
+      return "pong";
+    }
+    setToken(token) {
+      this.token = token ?? undefined;
+      this.emit("authChange", { token: this.token ?? null });
+    }
+    onAuthChange(callback) {
+      this.on("authChange", (payload) => callback(payload.token));
+    }
+    on(event, callback) {
+      this.listeners[event] = this.listeners[event] ?? [];
+      this.listeners[event].push(callback);
+    }
+    emit(event, payload) {
+      (this.listeners[event] ?? []).forEach((listener) => {
+        listener(payload);
+      });
+    }
+    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;
+    }
+    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);
+      }
+    }
+    auth = createAuthNamespace(this);
+    runtime = createRuntimeNamespace(this);
+    games = createGamesNamespace(this);
+    users = createUsersNamespace(this);
+    dev = createDevNamespace(this);
+    maps = createMapsNamespace(this);
+    admin = createAdminNamespace(this);
+    shop = createShopNamespace(this);
+    telemetry = createTelemetryNamespace(this);
+    static init = init;
+    static login = login;
+  };
+});
+
+// src/index.ts
+init_client();
+init_messaging();
+export {
+  messaging,
+  PlaycademyClient,
+  MessageEvents
+};