@smartico/public-api 0.0.425 → 0.0.427

package/dist/index.modern.mjs

@@ -886,6 +886,8 @@ var PublicLabelSettings;
   PublicLabelSettings["GAMIFICATION_UI_WIDGET"] = "GAMIFICATION_UI_WIDGET";
   PublicLabelSettings["GAMIFICATION_UI_MINI_GAME"] = "GAMIFICATION_UI_MINI_GAME";
   PublicLabelSettings["GAMIFICATION_UI_SETTINGS"] = "GAMIFICATION_UI_SETTINGS";
+  PublicLabelSettings["GAMIFICATION_UI_SETTINGS_V2"] = "GAMIFICATION_UI_SETTINGS_V2";
+  PublicLabelSettings["GAMIFICATION_UI_SETTINGS_TEST_V2"] = "GAMIFICATION_UI_SETTINGS_TEST_V2";
   PublicLabelSettings["GAMIFICATION_UI_MAIN_TEST"] = "GAMIFICATION_UI_MAIN_TEST";
   PublicLabelSettings["GAMIFICATION_UI_WIDGET_TEST"] = "GAMIFICATION_UI_WIDGET_TEST";
   PublicLabelSettings["GAMIFICATION_UI_SETTINGS_TEST"] = "GAMIFICATION_UI_SETTINGS_TEST";
@@ -1288,6 +1290,11 @@ var BadgesTimeLimitStates;
   BadgesTimeLimitStates[BadgesTimeLimitStates["AfterEndDateNotStarted"] = 4] = "AfterEndDateNotStarted";
   /** After End Date (player has some progress, but not completed) */
   BadgesTimeLimitStates[BadgesTimeLimitStates["AfterEndDateWithProgress"] = 5] = "AfterEndDateWithProgress";
+  /**
+   * After Start Date, player has some progress, and the badge has no End Date.
+   * The badge is still earnable — do not render it as expired.
+   */
+  BadgesTimeLimitStates[BadgesTimeLimitStates["AfterStartDateWithProgress"] = 6] = "AfterStartDateWithProgress";
 })(BadgesTimeLimitStates || (BadgesTimeLimitStates = {}));
 
 var _MissionUtils;
@@ -1554,8 +1561,7 @@ MissionUtils.determineBadgeState = badge => {
     if (progress === 0) {
       return BadgesTimeLimitStates.AfterStartDateNoProgress;
     }
-    // If infinite and with progress → this state does not exist in enum
-    // (but if needed we can add one)
+    return BadgesTimeLimitStates.AfterStartDateWithProgress;
   }
   // 3. AFTER START, BEFORE END DATE
   if (now < active_till_ts) {
@@ -1930,6 +1936,7 @@ const TournamentItemsTransform = items => {
       prize_pool_short: r.publicMeta.prize_pool_short,
       custom_price_text: r.publicMeta.custom_price_text,
       custom_section_id: r.publicMeta.custom_section_id,
+      only_in_custom_section: r.publicMeta.only_in_custom_section,
       custom_data: IntUtils.JsonOrText(r.publicMeta.custom_data),
       is_featured: r.publicMeta.featured,
       ribbon: r.publicMeta.label_tag === 'custom' ? r.publicMeta.custom_label_tag : r.publicMeta.label_tag,
@@ -2287,6 +2294,7 @@ const prizeTransform = items => {
       description: item.public_meta.description,
       image_url: item.public_meta.image_url,
       custom_data: item.public_meta.custom_data,
+      hide_chance_to_win: item.public_meta.hide_chance_to_win,
       prizes_per_run: item.prizes_per_run,
       prizes_per_run_actual: item.prizes_per_run_actual,
       chances_to_win_perc: item.chances_to_win_perc,
@@ -2345,6 +2353,7 @@ const raffleTransform = items => {
       custom_section_id: item.public_meta.custom_section_id,
       image_url: item.public_meta.image_url,
       image_url_mobile: item.public_meta.image_url_mobile,
+      hint_text: item.public_meta.hint_text,
       custom_data: item.public_meta.custom_data,
       start_date: item.start_date_ts,
       end_date: item.end_date_ts,
@@ -2408,19 +2417,25 @@ var RaffleDrawInstanceState;
   RaffleDrawInstanceState[RaffleDrawInstanceState["WinnerSelection"] = 2] = "WinnerSelection";
   /** Draw is executed and the winners are selected */
   RaffleDrawInstanceState[RaffleDrawInstanceState["Executed"] = 3] = "Executed";
+  /**
+   * Draw was cancelled and will never be executed.
+   * Treat it as a terminal state: stop any polling of the draw run
+   * and do not show the winner-selection progress UI.
+   */
+  RaffleDrawInstanceState[RaffleDrawInstanceState["Cancelled"] = 4] = "Cancelled";
 })(RaffleDrawInstanceState || (RaffleDrawInstanceState = {}));
 var RaffleDrawTypeExecution;
 (function (RaffleDrawTypeExecution) {
   /** Draw is executed only once */
-  RaffleDrawTypeExecution[RaffleDrawTypeExecution["ExecDate"] = 0] = "ExecDate";
+  RaffleDrawTypeExecution[RaffleDrawTypeExecution["ExecDate"] = 1] = "ExecDate";
   /** Draw is executed on a recurring basis */
-  RaffleDrawTypeExecution[RaffleDrawTypeExecution["Recurring"] = 1] = "Recurring";
+  RaffleDrawTypeExecution[RaffleDrawTypeExecution["Recurring"] = 2] = "Recurring";
   /**
    * Draw is executed once and is marked as grand.
    * This means it is a special or significant draw,
    * often with larger prizes or more importance.
    */
-  RaffleDrawTypeExecution[RaffleDrawTypeExecution["Grand"] = 2] = "Grand";
+  RaffleDrawTypeExecution[RaffleDrawTypeExecution["Grand"] = 3] = "Grand";
 })(RaffleDrawTypeExecution || (RaffleDrawTypeExecution = {}));
 
 /** @hidden */
@@ -3442,7 +3457,11 @@ class WSAPIMissions extends WSAPIGeneral {
    * as undefined / default. Time windows are absolute calendar timestamps
    * (`active_from_ts` / `active_till_ts`), not opt-in-relative durations —
    * drive availability chips from the SDK-computed `badgeTimeLimitState`
-   * (enum {@link BadgesTimeLimitStates}), not `time_limit_ms`. Locking for
+   * (enum {@link BadgesTimeLimitStates}), not `time_limit_ms`. A badge
+   * with no `active_till_ts` is open-ended and never reaches the
+   * "after end date" states — it reports `AfterStartDateNoProgress`
+   * or `AfterStartDateWithProgress` — so it must never be rendered as
+   * expired. Locking for
    * badges is purely time-based: `is_locked` is `true` only when
    * `badgeTimeLimitState === BadgesTimeLimitStates.BeforeStartDate` (the
    * time window hasn't started yet). The primary navigation field is
@@ -4820,6 +4839,12 @@ class WSAPITournaments extends WSAPIStore {
    * tournaments not yet published. SDK consumers receive only items
    * the user is eligible to see; no client-side gating is required.
    *
+   * Client-side filtering you may still want: tournaments with
+   * `only_in_custom_section: true` are intended for their custom-section
+   * view only and should be hidden from the main lobby list — including
+   * from any per-tab counters rendered next to the tab labels, otherwise
+   * the counts disagree with the number of cards the user can see.
+   *
    * **Reading state from the returned item**
    * Drive list bucketing and CTA labels from the SDK-computed booleans
    * (`is_active`, `is_can_register`, `is_cancelled`, `is_finished`,
@@ -4884,19 +4909,22 @@ class WSAPITournaments extends WSAPIStore {
    *   },
    * });
    *
+   * // Main lobby list — custom-section-only tournaments belong to that section's own view.
+   * const lobby = tournaments.filter(t => !t.only_in_custom_section);
+   *
    * // Bucket items by lifecycle state for a tabbed UI.
-   * const live = tournaments.filter(t => t.is_in_progress);
-   * const upcoming = tournaments
+   * const live = lobby.filter(t => t.is_in_progress);
+   * const upcoming = lobby
    *   .filter(t => t.is_upcoming && !t.is_user_registered)
    *   .sort((a, b) => a.start_time - b.start_time);
-   * const mine = tournaments.filter(t => t.is_user_registered);
-   * const finished = tournaments.filter(t => t.is_finished);
+   * const mine = lobby.filter(t => t.is_user_registered);
+   * const finished = lobby.filter(t => t.is_finished);
    *
    * console.log('[smartico] render lobby tabs with these counts: live=', live.length,
    *   'upcoming=', upcoming.length, 'mine=', mine.length, 'finished=', finished.length);
    *
    * // Featured tournament: pin to position 0 of the Overview/Top tabs.
-   * const featured = tournaments.find(t => t.is_featured && !t.is_cancelled);
+   * const featured = lobby.find(t => t.is_featured && !t.is_cancelled);
    * if (featured) {
    *   console.log('[smartico] featured tournament — pin to position 0 of the Overview tab:', featured.name);
    * }
@@ -6154,8 +6182,12 @@ class WSAPIRaffles extends WSAPIJackpots {
    *   sold-out message).
    * - Within each draw, `current_state`
    *   ({@link RaffleDrawInstanceState}) buckets the draw into Open
-   *   (accepting tickets), WinnerSelection (currently drawing), or
-   *   Executed (winners selected).
+   *   (accepting tickets), WinnerSelection (currently drawing),
+   *   Executed (winners selected), or Cancelled (will never run).
+   *   Treat every state other than Open and WinnerSelection as
+   *   terminal — stop polling the draw run and clear any
+   *   "drawing in progress" indicator, otherwise a cancelled draw
+   *   leaves the UI spinning forever.
    * - `execution_type` ({@link RaffleDrawTypeExecution}) distinguishes
    *   one-shot (`ExecDate`), repeating (`Recurring`), or special
    *   one-shot (`Grand`) draws. Recurring draws share a stable
@@ -8739,6 +8771,56 @@ class WSAPILeaderBoard extends WSAPIGamePick {
   async getLeaderBoards() {
     return OCache.use(`${onUpdateContextKey.LeaderBoards}:list`, ECacheContext.WSAPI, () => this.api.leaderboardsGetListT(this.userExtId), CACHE_DATA_SEC);
   }
+  /**
+   * Returns the operator's privacy configuration for leaderboard rendering.
+   * Apply it to every leaderboard row you draw — the standings returned by
+   * {@link getLeaderBoard} always carry `avatar_url`, `level_id` and
+   * `points`, so honouring these flags is the consumer's responsibility.
+   * Ignoring them surfaces data the operator asked to keep private.
+   *
+   * @remarks
+   * **Flags** — each is `true` when the corresponding data must be hidden:
+   * - `hide_avatars` — draw rows without the player avatar.
+   * - `hide_levels` — draw rows without the player's level name.
+   * - `hide_other_points` — hide `points` for every row except the current
+   *   user's. The current user always sees their own points.
+   *
+   * **Defaults on an unconfigured label** — `hide_avatars` and
+   * `hide_levels` default to `false` (show), while `hide_other_points`
+   * defaults to `true` (hide) unless the operator explicitly turned it off.
+   * The asymmetry is intentional: it matches the default Smartico UI, so a
+   * consumer rendering its own leaderboard next to the built-in one agrees
+   * with it rather than exposing points the built-in surface hides.
+   *
+   * **Synchronous** — the settings arrive with the session handshake, so
+   * this returns immediately and never issues a round-trip. Call it on
+   * every render rather than caching the result yourself.
+   *
+   * **Idempotency / Side effects**: safe. Read-only.
+   *
+   * **Visitor mode**: supported. Returns the same label-level configuration.
+   *
+   * @returns The resolved leaderboard privacy flags. Never `null`.
+   *
+   * @example
+   * ```ts
+   * import { LeaderBoardPeriodType } from '@smartico/public-api';
+   *
+   * const settings = window._smartico.api.getLeaderBoardSettings();
+   * const board = await window._smartico.api.getLeaderBoard(LeaderBoardPeriodType.WEEKLY);
+   *
+   * for (const row of board?.users ?? []) {
+   *   const showPoints = row.is_me || !settings.hide_other_points;
+   *
+   *   console.log('[smartico] render row', row.position, row.public_username,
+   *     settings.hide_avatars ? '(no avatar)' : row.avatar_url,
+   *     showPoints ? row.points : '(points hidden)');
+   * }
+   * ```
+   */
+  getLeaderBoardSettings() {
+    return this.api.leaderboardsGetSettings();
+  }
 }
 
 /** @group Inbox */
@@ -10470,6 +10552,43 @@ class SmarticoAPI {
   async leaderboardsGetListT(user_ext_id) {
     return (await this.leaderboardsGetList(user_ext_id)).map(getLeaderBoardTransform);
   }
+  leaderboardsGetSettings() {
+    // Defaults match the default Smartico UI when the operator has not
+    // configured the gamification UI settings: avatars and levels are
+    // shown, other players' points are not.
+    const settings = this.getGamificationUISettings();
+    return {
+      hide_avatars: (settings == null ? void 0 : settings.hide_avatars_leaderboards) === true,
+      hide_levels: (settings == null ? void 0 : settings.leaderboard_hide_levels) === true,
+      // Deliberately asymmetric: points stay hidden unless the operator
+      // explicitly opted in by setting the flag to false. This mirrors the
+      // default Smartico UI, so a consumer rendering both surfaces agrees
+      // with it on an unconfigured label.
+      hide_other_points: (settings == null ? void 0 : settings.leaderboard_hide_other_points) !== false
+    };
+  }
+  getGamificationUISettings() {
+    var _this$tracker$userPub;
+    if (!this.tracker) {
+      return null;
+    }
+    const parse = raw => {
+      if (typeof raw !== 'string' || raw.length === 0) {
+        return null;
+      }
+      try {
+        const parsed = JSON.parse(raw);
+        return parsed && Object.keys(parsed).length ? parsed : null;
+      } catch (e) {
+        return null;
+      }
+    };
+    // Test accounts read the operator's test variant when one is configured;
+    // everyone else reads the live settings.
+    const isTestAccount = ((_this$tracker$userPub = this.tracker.userPublicProps) == null ? void 0 : _this$tracker$userPub.core_is_test_account) === true;
+    const testSettings = isTestAccount ? parse(this.tracker.getLabelSetting(PublicLabelSettings.GAMIFICATION_UI_SETTINGS_TEST_V2)) : null;
+    return testSettings || parse(this.tracker.getLabelSetting(PublicLabelSettings.GAMIFICATION_UI_SETTINGS_V2));
+  }
   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);
@@ -10592,11 +10711,11 @@ class SmarticoAPI {
     return await this.send(message, ClassId.MARK_INBOX_DELETED_RESPONSE);
   }
   buildGamesApiParams() {
-    var _this$tracker$userPub, _this$tracker$userPub2;
+    var _this$tracker$userPub2, _this$tracker$userPub3;
     const params = Object.assign({}, this.baseRgApiParams, {
-      ext_user_id: (_this$tracker$userPub = this.tracker.userPublicProps) == null ? void 0 : _this$tracker$userPub.user_id,
+      ext_user_id: (_this$tracker$userPub2 = this.tracker.userPublicProps) == null ? void 0 : _this$tracker$userPub2.user_id,
       smartico_ext_user_id: this.tracker.getExtUserId(),
-      lang: (_this$tracker$userPub2 = this.tracker.userPublicProps) == null ? void 0 : _this$tracker$userPub2.core_user_language
+      lang: (_this$tracker$userPub3 = this.tracker.userPublicProps) == null ? void 0 : _this$tracker$userPub3.core_user_language
     });
     return params;
   }