@smartico/public-api 0.0.387 → 0.0.388

package/dist/index.modern.mjs

@@ -2082,33 +2082,33 @@ const pointsRewardTransform = reward_points => {
 };
 const getLeaderBoardPlayerTransformed = (user, isMe) => {
   if (user) {
-    const x = {
+    return {
       public_username: (user == null ? void 0 : user.public_username) || user.user_alt_name,
       avatar_url: user.avatar_url,
+      level_id: user.level_id,
       position: user.position_in_board,
       points: user.points_accumulated,
-      is_me: user.is_me
+      // The `me` entry is the current user by definition, so force `true`
+      // there; list rows carry the server-provided flag.
+      is_me: isMe ? true : user.is_me
     };
-    if (isMe) {
-      delete x.is_me;
-    }
-    return x;
   }
   return null;
 };
 const getLeaderBoardTransform = board => {
   if (board) {
-    const x = {
+    return {
       board_id: board.board_id,
       name: board.board_public_meta.name,
       description: board.board_public_meta.description,
       rules: board.board_public_meta.rules,
       period_type_id: board.period_type_id,
+      version_id: board.versiod_id,
+      create_date: board.create_date,
       rewards: pointsRewardTransform(board.reward_points),
-      users: board.positions.map(p => getLeaderBoardPlayerTransformed(p)),
+      users: (board.positions || []).map(p => getLeaderBoardPlayerTransformed(p)),
       me: getLeaderBoardPlayerTransformed(board.userPosition, true)
     };
-    return x;
   }
   return null;
 };
@@ -8307,7 +8307,9 @@ class WSAPILeaderBoard extends WSAPIGamePick {
    *
    * The leaderboard for each period type is configured separately by
    * the operator. A label may have any combination of DAILY, WEEKLY,
-   * and MONTHLY boards configured (or none).
+   * and MONTHLY boards configured (or none). To discover which boards
+   * exist before loading any standings, call {@link getLeaderBoards}
+   * (metadata only) and drive the tab selector from its `period_type_id`s.
    *
    * @remarks
    * **Return value note** — the runtime may return `undefined` if no
@@ -8319,10 +8321,13 @@ class WSAPILeaderBoard extends WSAPIGamePick {
    * Pass a `periodType` from {@link LeaderBoardPeriodType}
    * (`DAILY = 1`, `WEEKLY = 2`, `MONTHLY = 3`). Pass
    * `getPreviousPeriod: true` to fetch the most-recently-ended
-   * period's snapshot (yesterday's results, last week's results,
-   * last month's results) instead of the current live period. The
-   * SDK only exposes one period back — older snapshots are not
-   * reachable through this method.
+   * period's snapshot (yesterday's / last week's / last month's
+   * results) instead of the current live period. To reach older
+   * snapshots, pass a number instead of a boolean: `1` = previous
+   * period, `2` = the one before that, and so on (`0` / `false` =
+   * current). Use the snapshot's `create_date` / `version_id` to label
+   * which historical run a previous-period board is. How far back
+   * snapshots are retained is operator-configured.
    *
    * **Top-20 cap**
    * The server hard-caps `users[]` at 20 entries, ordered by
@@ -8376,10 +8381,11 @@ class WSAPILeaderBoard extends WSAPIGamePick {
    *                           Selects which pre-configured board to
    *                           fetch; the board itself is bound to one
    *                           period by the operator.
-   * @param getPreviousPeriod  When `true`, returns the most recent
-   *                           finalized snapshot for that period type
-   *                           (e.g. last week's results). Defaults to
-   *                           `false` (current in-progress period).
+   * @param getPreviousPeriod  Which period to fetch. `false` (default)
+   *                           = current in-progress period; `true` =
+   *                           the most recent finalized snapshot; a
+   *                           number `n` = the n-th previous snapshot
+   *                           (`1` = previous, `2` = the one before, …).
    * @returns                  Promise resolving to `LeaderBoardDetailsT`.
    *                           **At runtime, may resolve to `undefined`**
    *                           when no board is configured for the
@@ -8423,10 +8429,75 @@ class WSAPILeaderBoard extends WSAPIGamePick {
    * ```
    */
   async getLeaderBoard(periodType, getPreviousPeriod) {
-    // Cache per (periodType, current/previous) so switching tabs or
-    // current↔previous within the TTL doesn't return a colliding board.
-    const cacheKey = `${onUpdateContextKey.LeaderBoards}:${periodType}:${getPreviousPeriod ? 1 : 0}`;
-    return OCache.use(cacheKey, ECacheContext.WSAPI, () => this.api.leaderboardsGetT(this.userExtId, periodType, getPreviousPeriod), CACHE_DATA_SEC);
+    // Resolve the snapshot offset: false/omitted → 0 (current), true → 1
+    // (previous), or an explicit number for older snapshots.
+    const offset = typeof getPreviousPeriod === 'number' ? getPreviousPeriod : getPreviousPeriod ? 1 : 0;
+    // Cache per (periodType, offset) so switching tabs or period within the
+    // TTL doesn't return a colliding board.
+    const cacheKey = `${onUpdateContextKey.LeaderBoards}:${periodType}:${offset}`;
+    return OCache.use(cacheKey, ECacheContext.WSAPI, () => this.api.leaderboardsGetT(this.userExtId, periodType, offset), CACHE_DATA_SEC);
+  }
+  /**
+   * Returns the list of leaderboards the operator has configured for this
+   * label — **metadata only, without participants**. Use it to discover
+   * which boards exist (and their period types) so you can render the
+   * board/tab selector, then load a specific board's standings on demand
+   * with {@link getLeaderBoard}.
+   *
+   * This is the lightweight discovery counterpart to {@link getLeaderBoard}:
+   * it issues one round-trip that returns every board's identity, name,
+   * description, rules, `period_type_id`, and prize table, but **not** the
+   * ranked players. Fetching the full standings for one board (the top-20
+   * `users[]` and the caller's own `me` entry) is what {@link getLeaderBoard}
+   * does per period.
+   *
+   * @remarks
+   * **Returned shape**
+   * An array of `LeaderBoardDetailsT`, one per configured board, ordered by
+   * `period_type_id` ascending (DAILY, WEEKLY, MONTHLY, …). On every entry
+   * `users` is an empty array and `me` is `undefined` — this call never
+   * carries participant data. Read `period_type_id` from each entry and pass
+   * it to {@link getLeaderBoard} to load that board's standings.
+   *
+   * **Empty result**
+   * Resolves to an empty array when the label has no leaderboards configured
+   * — treat that as "hide the leaderboard surface".
+   *
+   * **Cache TTL**
+   * Cached for 30 seconds under a dedicated key (independent of
+   * {@link getLeaderBoard}'s per-period cache). Repeated calls within the
+   * window return the cached list without a round-trip.
+   *
+   * **Refresh model**: one-shot fetch — no subscription, no push. Board
+   * configuration changes surface on the next cache miss.
+   *
+   * **Idempotency / Side effects**: safe. Read-only.
+   *
+   * **Visitor mode**: supported. Returns the brand's public board list.
+   *
+   * @returns Promise resolving to the array of configured boards
+   *          (metadata only). Empty array when none are configured.
+   *
+   * @example
+   * ```ts
+   * const boards = await window._smartico.api.getLeaderBoards();
+   *
+   * if (boards.length === 0) {
+   *   console.log('[smartico] no leaderboards configured — hide the leaderboard surface');
+   *   return;
+   * }
+   *
+   * // Render one tab per board from the lightweight list (no players yet).
+   * console.log('[smartico] render leaderboard tabs:', boards.map(b => b.name));
+   *
+   * // When the user opens a tab, load that board's standings on demand.
+   * const first = boards[0];
+   * const full = await window._smartico.api.getLeaderBoard(first.period_type_id);
+   * console.log('[smartico] loaded standings for', first.name, '—', full?.users.length ?? 0, 'players');
+   * ```
+   */
+  async getLeaderBoards() {
+    return OCache.use(`${onUpdateContextKey.LeaderBoards}:list`, ECacheContext.WSAPI, () => this.api.leaderboardsGetListT(this.userExtId), CACHE_DATA_SEC);
   }
 }
 
@@ -9209,6 +9280,7 @@ var LiquidEntityData;
   LiquidEntityData[LiquidEntityData["Tournament"] = 10] = "Tournament";
   LiquidEntityData[LiquidEntityData["Raffles"] = 11] = "Raffles";
   LiquidEntityData[LiquidEntityData["SingleRaffle"] = 12] = "SingleRaffle";
+  LiquidEntityData[LiquidEntityData["Clans"] = 13] = "Clans";
 })(LiquidEntityData || (LiquidEntityData = {}));
 
 const UICustomSectionTransform = response => {
@@ -10067,9 +10139,12 @@ class SmarticoAPI {
   }
   async leaderboardGet(user_ext_id, period_type_id, prevPeriod = false, force_language) {
     var _response$map$boardKe, _response$map$boardKe2;
+    // boolean keeps back-compat (false → current, true → previous);
+    // a number selects an arbitrary snapshot offset (1 = previous, 2 = the one before, …).
+    const snapshot_offset = typeof prevPeriod === 'number' ? prevPeriod : prevPeriod ? 1 : 0;
     const message = this.buildMessage(user_ext_id, ClassId.GET_LEADERS_BOARD_REQUEST, {
       period_type_id,
-      snapshot_offset: prevPeriod ? 1 : 0,
+      snapshot_offset,
       include_users: true
     });
     const response = await this.send(message, ClassId.GET_LEADERS_BOARD_RESPONSE, force_language);
@@ -10090,6 +10165,20 @@ class SmarticoAPI {
   async leaderboardsGetT(user_ext_id, period_type_id = LeaderBoardPeriodType.DAILY, prevPeriod = false) {
     return getLeaderBoardTransform(await this.leaderboardGet(user_ext_id, period_type_id, prevPeriod));
   }
+  async leaderboardsGetList(user_ext_id, force_language) {
+    const message = this.buildMessage(user_ext_id, ClassId.GET_LEADERS_BOARD_REQUEST, {
+      // No period_type_id → the server returns every configured board.
+      // include_users: false → board metadata only (no positions / userPosition).
+      snapshot_offset: 0,
+      include_users: false
+    });
+    const response = await this.send(message, ClassId.GET_LEADERS_BOARD_RESPONSE, force_language);
+    // map is keyed by period_type_id; integer-like keys iterate in ascending order.
+    return Object.values(response.map || {});
+  }
+  async leaderboardsGetListT(user_ext_id) {
+    return (await this.leaderboardsGetList(user_ext_id)).map(getLeaderBoardTransform);
+  }
   async levelsGet(user_ext_id, force_language) {
     const message = this.buildMessage(user_ext_id, ClassId.GET_LEVEL_MAP_REQUEST);
     return await this.send(message, ClassId.GET_LEVEL_MAP_RESPONSE, force_language);