@looplay/sdk 0.1.0

package/README.md

@@ -0,0 +1,3 @@
+# Looplay
+
+API Reference: https://docs.looplay.gg/build-on-loopplay/looplay-sdk

package/dist/looplay-sdk.cjs.js

@@ -0,0 +1,638 @@
+'use strict';
+
+// src/errors.ts
+var LooplaySDKError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LooplaySDKError";
+  }
+};
+var NotInitializedError = class extends LooplaySDKError {
+  constructor() {
+    super("LooplaySDK not initialized. Call init({ gameId }) first.");
+    this.name = "NotInitializedError";
+  }
+};
+var MissingBaseUrlError = class extends LooplaySDKError {
+  constructor() {
+    super("Missing baseUrl. Provide `baseUrl` to enable HTTP integration.");
+    this.name = "MissingBaseUrlError";
+  }
+};
+var MissingAuthError = class extends LooplaySDKError {
+  constructor() {
+    super("Missing auth. Provide `auth` options to enable user login/session.");
+    this.name = "MissingAuthError";
+  }
+};
+var NotAuthenticatedError = class extends LooplaySDKError {
+  constructor() {
+    super("Not authenticated. Login is required for this operation.");
+    this.name = "NotAuthenticatedError";
+  }
+};
+
+// src/auth/storage.ts
+var MemoryAuthStorage = class {
+  map = /* @__PURE__ */ new Map();
+  async getItem(key) {
+    return this.map.has(key) ? this.map.get(key) : null;
+  }
+  async setItem(key, value) {
+    this.map.set(key, value);
+  }
+  async removeItem(key) {
+    this.map.delete(key);
+  }
+};
+var BrowserLocalStorageAuthStorage = class {
+  async getItem(key) {
+    if (typeof window === "undefined" || !window.localStorage) return null;
+    return window.localStorage.getItem(key);
+  }
+  async setItem(key, value) {
+    if (typeof window === "undefined" || !window.localStorage) return;
+    window.localStorage.setItem(key, value);
+  }
+  async removeItem(key) {
+    if (typeof window === "undefined" || !window.localStorage) return;
+    window.localStorage.removeItem(key);
+  }
+};
+
+// src/auth/looplay-auth.ts
+var InvalidSessionError = class extends LooplaySDKError {
+  constructor() {
+    super("Invalid session returned by auth provider");
+    this.name = "InvalidSessionError";
+  }
+};
+var LooplayAuth = class {
+  provider;
+  storage;
+  key;
+  session = null;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.provider = options.provider;
+    this.storage = options.storage ?? new MemoryAuthStorage();
+    this.key = `${options.storageKeyPrefix ?? "looplay"}:auth:session`;
+  }
+  async init() {
+    await this.provider.init?.();
+    await this.restoreFromStorage();
+    await this.provider.onSessionChanged?.(this.session);
+  }
+  getSession() {
+    return this.session;
+  }
+  async login(params) {
+    const result = await this.provider.login(params);
+    if (!result?.session?.user?.id) {
+      throw new InvalidSessionError();
+    }
+    await this.setSession(result.session, "login");
+    return result.session;
+  }
+  async logout() {
+    await this.provider.logout();
+    await this.setSession(null, "logout");
+  }
+  async getAccessToken() {
+    if (!this.session) return void 0;
+    const now = Date.now();
+    const isExpired = typeof this.session.expiresAt === "number" && this.session.expiresAt <= now;
+    if (!isExpired) return this.session.accessToken;
+    if (!this.provider.refresh) return this.session.accessToken;
+    const refreshed = await this.provider.refresh();
+    const next = { ...this.session, ...refreshed };
+    await this.setSession(next, "sessionChanged");
+    return next.accessToken;
+  }
+  on(eventName, listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  async restoreFromStorage() {
+    const raw = await this.storage.getItem(this.key);
+    if (!raw) return;
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed?.user?.id) {
+        this.session = parsed;
+      }
+    } catch {
+      await this.storage.removeItem(this.key);
+    }
+  }
+  async setSession(next, event) {
+    this.session = next;
+    await this.provider.onSessionChanged?.(this.session);
+    if (next) {
+      await this.storage.setItem(this.key, JSON.stringify(next));
+    } else {
+      await this.storage.removeItem(this.key);
+    }
+    for (const listener of this.listeners) {
+      listener(this.session);
+    }
+  }
+};
+
+// src/apps/http.ts
+var HttpError = class extends Error {
+  status;
+  bodyText;
+  constructor(message, status, bodyText) {
+    super(message);
+    this.name = "HttpError";
+    this.status = status;
+    this.bodyText = bodyText;
+  }
+};
+var HttpClient = class {
+  baseUrl;
+  fetchFn;
+  defaultHeaders;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.fetchFn = options.fetch ?? fetch;
+    this.defaultHeaders = options.defaultHeaders ?? {};
+  }
+  async request(method, path, options) {
+    const url = this.buildUrl(path, options?.query);
+    const headers = this.mergeHeaders(
+      this.defaultHeaders,
+      options?.headers
+    );
+    if (options?.bearerToken) {
+      headers.Authorization = `Bearer ${options.bearerToken}`;
+    }
+    let body;
+    if (options?.body !== void 0) {
+      headers["Content-Type"] = headers["Content-Type"] ?? "application/json";
+      body = JSON.stringify(options.body);
+    }
+    const res = await this.fetchFn(url, { method, headers, body });
+    if (!res.ok) {
+      const text2 = await this.safeText(res);
+      throw new HttpError(`HTTP ${res.status} ${res.statusText}`, res.status, text2);
+    }
+    const text = await this.safeText(res);
+    if (!text) return void 0;
+    return JSON.parse(text);
+  }
+  mergeHeaders(...sources) {
+    const result = {};
+    for (const src of sources) {
+      if (!src) continue;
+      for (const [key, value] of Object.entries(src)) {
+        if (value === void 0) continue;
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  buildUrl(path, query) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(`${this.baseUrl}${normalizedPath}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0) continue;
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  async safeText(res) {
+    try {
+      return await res.text();
+    } catch {
+      return "";
+    }
+  }
+};
+
+// src/apps/service-client.ts
+var ServiceClient = class {
+  http;
+  constructor(options) {
+    this.http = new HttpClient(options);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Auth
+  // ─────────────────────────────────────────────────────────────────────────────
+  async telegramLogin(telegramInitData) {
+    const body = { telegramInitData };
+    return this.http.request("POST", "/account/telegram-login", { body });
+  }
+  async refresh(refreshToken) {
+    const body = { refreshToken };
+    return this.http.request("POST", "/account/refresh", { body });
+  }
+  async logout(refreshToken) {
+    const body = { refreshToken };
+    return this.http.request("POST", "/account/logout", { body });
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Games
+  // ─────────────────────────────────────────────────────────────────────────────
+  async listGames(query) {
+    return this.http.request("GET", "/games", { query });
+  }
+  async getGameDetail(gameId, bearerToken) {
+    return this.http.request("GET", `/games/${encodeURIComponent(gameId)}`, {
+      bearerToken
+    });
+  }
+  async listRecentPlayed(bearerToken, query) {
+    return this.http.request("GET", "/games/recent-play", { bearerToken, query });
+  }
+  async trackPlay(bearerToken, gameId, playTimeSeconds) {
+    const body = { playTimeSeconds };
+    await this.http.request("POST", `/games/${encodeURIComponent(gameId)}/play`, {
+      bearerToken,
+      body
+    });
+    return true;
+  }
+  async trackMatchEnd(bearerToken, gameId, body) {
+    await this.http.request("POST", `/games/${encodeURIComponent(gameId)}/end`, {
+      bearerToken,
+      body
+    });
+    return true;
+  }
+  async emitGameEvent(bearerToken, gameId, body) {
+    return this.http.request("POST", `/games/${encodeURIComponent(gameId)}/emit`, {
+      bearerToken,
+      body
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Balance
+  // ─────────────────────────────────────────────────────────────────────────────
+  async getBalances(bearerToken, query) {
+    return this.http.request("GET", "/balance", { bearerToken, query });
+  }
+  async getBalanceHistory(bearerToken, query) {
+    return this.http.request("GET", "/balance/history", { bearerToken, query });
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // User
+  // ─────────────────────────────────────────────────────────────────────────────
+  async getMyProfile(bearerToken) {
+    return this.http.request("GET", "/user/profile", { bearerToken });
+  }
+  async getMyBalance(bearerToken) {
+    return this.http.request("GET", "/user/balance", { bearerToken });
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Referrals
+  // ─────────────────────────────────────────────────────────────────────────────
+  async listReferrals(bearerToken, query) {
+    return this.http.request("GET", "/referrals", { bearerToken, query });
+  }
+  async setReferral(bearerToken, body) {
+    return this.http.request("POST", "/referrals/set", { bearerToken, body });
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tasks / Quests
+  // ─────────────────────────────────────────────────────────────────────────────
+  async listTasks(bearerToken) {
+    return this.http.request("GET", "/task", { bearerToken });
+  }
+  async listFinishedTasks(bearerToken) {
+    return this.http.request("GET", "/task/finished", { bearerToken });
+  }
+  async startTask(bearerToken, body) {
+    return this.http.request("POST", "/task/start", { bearerToken, body });
+  }
+  async claimTask(bearerToken, body) {
+    return this.http.request("POST", "/task/claim", { bearerToken, body });
+  }
+  async getPlatformQuests(bearerToken, query) {
+    return this.http.request("GET", "/quest/platform", { bearerToken, query });
+  }
+  async getCampaignQuests(bearerToken, query) {
+    return this.http.request("GET", "/quest/campaign", { bearerToken, query });
+  }
+  async claimQuest(bearerToken, questProgressId) {
+    return this.http.request("POST", `/quest/${encodeURIComponent(questProgressId)}/claim`, {
+      bearerToken
+    });
+  }
+  async claimMilestone(bearerToken, milestoneId, body) {
+    return this.http.request(
+      "POST",
+      `/quest/milestone/${encodeURIComponent(milestoneId)}/claim`,
+      {
+        bearerToken,
+        body
+      }
+    );
+  }
+};
+
+// src/apps/api-client.ts
+var ApiClient = class {
+  raw;
+  getAccessToken;
+  constructor(options) {
+    if (!options.baseUrl) throw new MissingBaseUrlError();
+    this.raw = new ServiceClient({
+      baseUrl: options.baseUrl,
+      fetch: options.fetch,
+      defaultHeaders: options.defaultHeaders
+    });
+    this.getAccessToken = options.getAccessToken;
+  }
+  /** Expose the underlying route-level client (requires manual bearerToken passing). */
+  unsafeRaw() {
+    return this.raw;
+  }
+  // Public endpoints
+  async listGames(query) {
+    return this.raw.listGames(query);
+  }
+  // Authenticated endpoints
+  async requireToken() {
+    const token = await this.getAccessToken?.();
+    if (!token) throw new NotAuthenticatedError();
+    return token;
+  }
+  async getGameDetail(gameId) {
+    const token = await this.requireToken();
+    return this.raw.getGameDetail(gameId, token);
+  }
+  async listRecentPlayed(query) {
+    const token = await this.requireToken();
+    return this.raw.listRecentPlayed(token, query);
+  }
+  async trackPlay(gameId, playTimeSeconds) {
+    const token = await this.requireToken();
+    return this.raw.trackPlay(token, gameId, playTimeSeconds);
+  }
+  async trackMatch(gameId, body) {
+    const token = await this.requireToken();
+    return this.raw.trackMatchEnd(token, gameId, body);
+  }
+  async emit(gameId, actionCode, opts) {
+    const token = await this.requireToken();
+    const body = {
+      actionCode,
+      value: opts?.value,
+      refId: opts?.refId,
+      payload: opts?.payload
+    };
+    return this.raw.emitGameEvent(token, gameId, body);
+  }
+  async getMyProfile() {
+    const token = await this.requireToken();
+    return this.raw.getMyProfile(token);
+  }
+  async getMyBalance() {
+    const token = await this.requireToken();
+    return this.raw.getMyBalance(token);
+  }
+  async getBalances(query) {
+    const token = await this.requireToken();
+    return this.raw.getBalances(token, query);
+  }
+  async getBalanceHistory(query) {
+    const token = await this.requireToken();
+    return this.raw.getBalanceHistory(token, query);
+  }
+  async listReferrals(query) {
+    const token = await this.requireToken();
+    return this.raw.listReferrals(token, query);
+  }
+  async setReferral(body) {
+    const token = await this.requireToken();
+    return this.raw.setReferral(token, body);
+  }
+  async listTasks() {
+    const token = await this.requireToken();
+    return this.raw.listTasks(token);
+  }
+  async listFinishedTasks() {
+    const token = await this.requireToken();
+    return this.raw.listFinishedTasks(token);
+  }
+  async startTask(body) {
+    const token = await this.requireToken();
+    return this.raw.startTask(token, body);
+  }
+  async claimTask(body) {
+    const token = await this.requireToken();
+    return this.raw.claimTask(token, body);
+  }
+  async getPlatformQuests(query) {
+    const token = await this.requireToken();
+    return this.raw.getPlatformQuests(token, query);
+  }
+  async getCampaignQuests(query) {
+    const token = await this.requireToken();
+    return this.raw.getCampaignQuests(token, query);
+  }
+  async claimQuest(questProgressId) {
+    const token = await this.requireToken();
+    return this.raw.claimQuest(token, questProgressId);
+  }
+  async claimMilestone(milestoneId, body) {
+    const token = await this.requireToken();
+    return this.raw.claimMilestone(token, milestoneId, body);
+  }
+};
+
+// src/looplay-sdk.ts
+var LooplaySDK = class {
+  auth;
+  api;
+  gameId;
+  initialized = false;
+  constructor(options = {}) {
+    const { auth, baseUrl, fetch: fetch2, defaultHeaders } = options;
+    if (auth) {
+      this.auth = new LooplayAuth(auth);
+    }
+    if (baseUrl) {
+      this.api = new ApiClient({
+        baseUrl,
+        fetch: fetch2,
+        defaultHeaders,
+        getAccessToken: async () => this.auth?.getAccessToken()
+      });
+    }
+  }
+  async init(params) {
+    this.gameId = params.gameId;
+    await this.auth?.init();
+    await this.verifyGameId(params);
+    this.initialized = true;
+  }
+  async getAccessToken() {
+    return this.auth?.getAccessToken();
+  }
+  getGameId() {
+    return this.gameId;
+  }
+  async getMyProfile() {
+    this.assertInitialized();
+    if (!this.api) throw new MissingBaseUrlError();
+    return this.api.getMyProfile();
+  }
+  async trackPlay(playTimeSeconds) {
+    this.assertInitialized();
+    if (!this.api) throw new MissingBaseUrlError();
+    if (!this.gameId) throw new NotInitializedError();
+    return this.api.trackPlay(this.gameId, playTimeSeconds);
+  }
+  /**
+   * Report that a match/round ended.
+   * Maps to PLAY_MATCH (and WIN_MATCH when isWin=true).
+   * matchId is the idempotency anchor — safe to call twice with the same matchId.
+   */
+  async trackMatch(matchId, opts) {
+    this.assertInitialized();
+    if (!this.api) throw new MissingBaseUrlError();
+    if (!this.gameId) throw new NotInitializedError();
+    return this.api.trackMatch(this.gameId, {
+      matchId,
+      matchDurationSeconds: opts.durationSeconds,
+      isCompleted: opts.isCompleted,
+      isWin: opts.isWin
+    });
+  }
+  /**
+   * Emit a custom action event (CUSTOM_ACTION metric).
+   * Use GameEventKey for platform-defined codes; custom strings for game-specific quests.
+   * Pass refId to make the call idempotent — same refId = same event, dedup-safe.
+   */
+  async emit(actionCode, opts) {
+    this.assertInitialized();
+    if (!this.api) throw new MissingBaseUrlError();
+    if (!this.gameId) throw new NotInitializedError();
+    return this.api.emit(this.gameId, actionCode, opts);
+  }
+  assertInitialized() {
+    if (!this.initialized) throw new NotInitializedError();
+  }
+  async verifyGameId(params) {
+    if ((params.verifyMode ?? "none") === "none") return;
+    if (!this.auth) throw new MissingAuthError();
+    if (!this.api) throw new MissingBaseUrlError();
+    await this.api.getGameDetail(params.gameId);
+  }
+};
+
+// src/auth/providers/telegram-auth-provider.ts
+var MissingTelegramInitDataError = class extends LooplaySDKError {
+  constructor() {
+    super("Missing Telegram init data");
+    this.name = "MissingTelegramInitDataError";
+  }
+};
+var MissingRefreshTokenError = class extends LooplaySDKError {
+  constructor() {
+    super("Missing refresh token");
+    this.name = "MissingRefreshTokenError";
+  }
+};
+function decodeJwtExpMs(token) {
+  if (!token) return void 0;
+  const parts = token.split(".");
+  if (parts.length < 2) return void 0;
+  try {
+    const payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = payload + "===".slice((payload.length + 3) % 4);
+    if (typeof globalThis.atob !== "function") return void 0;
+    const json = globalThis.atob(padded);
+    const parsed = JSON.parse(json);
+    if (typeof parsed.exp !== "number") return void 0;
+    return parsed.exp * 1e3;
+  } catch {
+    return void 0;
+  }
+}
+var TelegramAuthProvider = class {
+  id = "telegram";
+  client;
+  getTelegramInitData;
+  mapUser;
+  session = null;
+  constructor(options) {
+    this.client = new ServiceClient(options);
+    this.getTelegramInitData = options.getTelegramInitData;
+    this.mapUser = options.mapUser;
+  }
+  onSessionChanged = (session) => {
+    this.session = session;
+  };
+  async login(params) {
+    const initData = params?.telegramInitData ?? this.getTelegramInitData?.() ?? globalThis?.Telegram?.WebApp?.initData;
+    if (!initData) throw new MissingTelegramInitDataError();
+    const result = await this.client.telegramLogin(initData);
+    const rawUser = result.user ?? {};
+    const user = this.mapUser ? this.mapUser(rawUser) : this.defaultMapUser(rawUser);
+    const session = {
+      user,
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken,
+      expiresAt: decodeJwtExpMs(result.accessToken)
+    };
+    this.session = session;
+    return { session };
+  }
+  async refresh() {
+    const currentSession = this.session;
+    const refreshToken = currentSession?.refreshToken;
+    if (!currentSession || !refreshToken) throw new MissingRefreshTokenError();
+    const result = await this.client.refresh(refreshToken);
+    const next = {
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken,
+      expiresAt: decodeJwtExpMs(result.accessToken)
+    };
+    this.session = { ...currentSession, ...next };
+    return next;
+  }
+  async logout() {
+    const refreshToken = this.session?.refreshToken;
+    if (refreshToken) {
+      try {
+        await this.client.logout(refreshToken);
+      } catch {
+      }
+    }
+    this.session = null;
+  }
+  defaultMapUser(raw) {
+    const id = raw.id ?? raw._id ?? raw.userId ?? raw.telegramId;
+    if (id === void 0 || id === null || String(id).trim() === "") {
+      throw new LooplaySDKError("Missing user id from auth response");
+    }
+    return {
+      id: String(id),
+      displayName: raw.displayName ?? raw.username ?? raw.name,
+      avatarUrl: raw.avatarUrl ?? raw.photoUrl ?? raw.avatar
+    };
+  }
+};
+
+exports.ApiClient = ApiClient;
+exports.BrowserLocalStorageAuthStorage = BrowserLocalStorageAuthStorage;
+exports.HttpClient = HttpClient;
+exports.HttpError = HttpError;
+exports.LooplayAuth = LooplayAuth;
+exports.LooplaySDK = LooplaySDK;
+exports.LooplaySDKError = LooplaySDKError;
+exports.MemoryAuthStorage = MemoryAuthStorage;
+exports.MissingAuthError = MissingAuthError;
+exports.MissingBaseUrlError = MissingBaseUrlError;
+exports.NotAuthenticatedError = NotAuthenticatedError;
+exports.NotInitializedError = NotInitializedError;
+exports.ServiceClient = ServiceClient;
+exports.TelegramAuthProvider = TelegramAuthProvider;
+//# sourceMappingURL=looplay-sdk.cjs.js.map
+//# sourceMappingURL=looplay-sdk.cjs.js.map