@heybox/hb-sdk 0.5.9 → 0.5.11

package/dist/devtools/mock-host/main.js

@@ -94,6 +94,16 @@ const NAVIGATION_CLOSE_METHOD = 'navigation.close';
 const NAVIGATION_RELOAD_METHOD = 'navigation.reload';
 /** 打开黑盒 App 页面能力方法名。 */
 const NAVIGATION_OPEN_APP_PAGE_METHOD = 'navigation.openAppPage';
+/** 提交当前用户排行榜分数能力方法名。 */
+const CLOUD_LEADERBOARD_SUBMIT_METHOD = 'cloud.leaderboard.submit';
+/** 读取排行榜列表能力方法名。 */
+const CLOUD_LEADERBOARD_GET_LIST_METHOD = 'cloud.leaderboard.getList';
+/** 读取当前用户排行榜记录能力方法名。 */
+const CLOUD_LEADERBOARD_GET_CURRENT_USER_ENTRY_METHOD = 'cloud.leaderboard.getCurrentUserEntry';
+/** 删除当前用户排行榜记录能力方法名。 */
+const CLOUD_LEADERBOARD_DELETE_CURRENT_USER_ENTRY_METHOD = 'cloud.leaderboard.deleteCurrentUserEntry';
+/** 读取排行榜基础信息能力方法名。 */
+const CLOUD_LEADERBOARD_GET_INFO_METHOD = 'cloud.leaderboard.getInfo';
 /**
  * 小程序开放能力目录。
  *
@@ -255,6 +265,41 @@ const MINI_PROGRAM_PROTOCOL_CAPABILITIES = [
         permission: 'navigation.openAppPage',
         risk: 'medium',
     },
+    {
+        method: CLOUD_LEADERBOARD_SUBMIT_METHOD,
+        module: 'cloud',
+        capability: CLOUD_LEADERBOARD_SUBMIT_METHOD,
+        permission: 'cloud.leaderboard.write',
+        risk: 'medium',
+    },
+    {
+        method: CLOUD_LEADERBOARD_GET_LIST_METHOD,
+        module: 'cloud',
+        capability: CLOUD_LEADERBOARD_GET_LIST_METHOD,
+        permission: 'cloud.leaderboard.read',
+        risk: 'low',
+    },
+    {
+        method: CLOUD_LEADERBOARD_GET_CURRENT_USER_ENTRY_METHOD,
+        module: 'cloud',
+        capability: CLOUD_LEADERBOARD_GET_CURRENT_USER_ENTRY_METHOD,
+        permission: 'cloud.leaderboard.currentUserEntry.read',
+        risk: 'medium',
+    },
+    {
+        method: CLOUD_LEADERBOARD_DELETE_CURRENT_USER_ENTRY_METHOD,
+        module: 'cloud',
+        capability: CLOUD_LEADERBOARD_DELETE_CURRENT_USER_ENTRY_METHOD,
+        permission: 'cloud.leaderboard.currentUserEntry.delete',
+        risk: 'medium',
+    },
+    {
+        method: CLOUD_LEADERBOARD_GET_INFO_METHOD,
+        module: 'cloud',
+        capability: CLOUD_LEADERBOARD_GET_INFO_METHOD,
+        permission: 'cloud.leaderboard.info.read',
+        risk: 'low',
+    },
 ];
 
 var browser = {};
@@ -3447,6 +3492,196 @@ function stringifyMiniProgramRuntimeJsonData(data, options) {
     return value;
 }
 
+const LEADERBOARD_KEY_RE = /^[A-Za-z0-9_-]{1,64}$/;
+const DEFAULT_LEADERBOARD_LIST_LIMIT = 20;
+const MAX_LEADERBOARD_LIST_LIMIT = 100;
+const MAX_LEADERBOARD_EXTRA_BYTES = 2048;
+const MAX_LEADERBOARD_SAFE_SCORE = Number.MAX_SAFE_INTEGER;
+/** 提交当前用户排行榜分数。 */
+async function submitMiniProgramRuntimeLeaderboardEntry(payload, options) {
+    const request = readLeaderboardPayload(payload, 'cloud.leaderboard.submit', 'submit');
+    const userId = await readCurrentUserId(options.platformAdapter);
+    const entry = await options.platformAdapter.cloud.leaderboard.submit({
+        ...request,
+        miniProgramId: options.identity?.miniProgramId,
+        userId,
+    });
+    assertLeaderboardEntry(entry, 'cloud.leaderboard.submit');
+    return entry;
+}
+/** 读取排行榜列表。 */
+async function getMiniProgramRuntimeLeaderboardList(payload, options) {
+    const request = readLeaderboardPayload(payload, 'cloud.leaderboard.getList', 'list');
+    const result = await options.platformAdapter.cloud.leaderboard.getList({
+        ...request,
+        miniProgramId: options.identity?.miniProgramId,
+    });
+    assertMiniProgramRuntimeRecord(result, 'cloud.leaderboard.getList 返回值必须是对象');
+    if (!Array.isArray(result.entries)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', 'cloud.leaderboard.getList 返回的 entries 必须是数组');
+    }
+    result.entries.forEach((entry) => assertLeaderboardEntry(entry, 'cloud.leaderboard.getList'));
+    if (result.cursor !== undefined && typeof result.cursor !== 'string') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', 'cloud.leaderboard.getList 返回的 cursor 必须是字符串');
+    }
+    if (typeof result.hasMore !== 'boolean') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', 'cloud.leaderboard.getList 返回的 hasMore 必须是布尔值');
+    }
+    return result;
+}
+/** 读取当前用户在排行榜中的记录。 */
+async function getMiniProgramRuntimeCurrentUserLeaderboardEntry(payload, options) {
+    const request = readLeaderboardPayload(payload, 'cloud.leaderboard.getCurrentUserEntry', 'keyOnly');
+    const userId = await readCurrentUserId(options.platformAdapter);
+    const entry = await options.platformAdapter.cloud.leaderboard.getCurrentUserEntry({
+        ...request,
+        miniProgramId: options.identity?.miniProgramId,
+        userId,
+    });
+    if (entry !== undefined) {
+        assertLeaderboardEntry(entry, 'cloud.leaderboard.getCurrentUserEntry');
+    }
+    return entry;
+}
+/** 删除当前用户在排行榜中的记录。 */
+async function deleteMiniProgramRuntimeCurrentUserLeaderboardEntry(payload, options) {
+    const request = readLeaderboardPayload(payload, 'cloud.leaderboard.deleteCurrentUserEntry', 'keyOnly');
+    const userId = await readCurrentUserId(options.platformAdapter);
+    const result = await options.platformAdapter.cloud.leaderboard.deleteCurrentUserEntry({
+        ...request,
+        miniProgramId: options.identity?.miniProgramId,
+        userId,
+    });
+    assertMiniProgramRuntimeRecord(result, 'cloud.leaderboard.deleteCurrentUserEntry 返回值必须是对象');
+    if (typeof result.deleted !== 'boolean') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', 'cloud.leaderboard.deleteCurrentUserEntry 返回的 deleted 必须是布尔值');
+    }
+    return result;
+}
+/** 读取排行榜基础信息。 */
+async function getMiniProgramRuntimeLeaderboardInfo(payload, options) {
+    const request = readLeaderboardPayload(payload, 'cloud.leaderboard.getInfo', 'keyOnly');
+    const info = await options.platformAdapter.cloud.leaderboard.getInfo({
+        ...request,
+        miniProgramId: options.identity?.miniProgramId,
+    });
+    assertMiniProgramRuntimeRecord(info, 'cloud.leaderboard.getInfo 返回值必须是对象');
+    if (request.key !== undefined && info.key !== request.key) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', 'cloud.leaderboard.getInfo 返回的 key 与请求不一致');
+    }
+    if (info.order !== 'asc' && info.order !== 'desc') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', 'cloud.leaderboard.getInfo 返回的 order 必须是 asc 或 desc');
+    }
+    if (!Number.isInteger(info.rankLimit) || info.rankLimit < 0) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', 'cloud.leaderboard.getInfo 返回的 rankLimit 必须是非负整数');
+    }
+    return info;
+}
+function readLeaderboardPayload(payload, methodName, shape) {
+    if (payload === undefined && shape !== 'submit') {
+        return shape === 'list' ? { limit: DEFAULT_LEADERBOARD_LIST_LIMIT } : {};
+    }
+    assertMiniProgramRuntimeRecord(payload, `${methodName} 参数必须是对象`);
+    const allowedKeys = shape === 'submit' ? ['key', 'score', 'extra'] : shape === 'list' ? ['key', 'limit', 'cursor'] : ['key'];
+    const unknownKey = Object.keys(payload).find((key) => !allowedKeys.includes(key));
+    if (unknownKey) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', `${methodName} 不支持参数 ${unknownKey}`);
+    }
+    const key = payload.key === undefined ? undefined : readLeaderboardKey(payload.key, methodName);
+    if (shape === 'keyOnly') {
+        return key === undefined ? {} : { key };
+    }
+    if (shape === 'list') {
+        return {
+            ...(key === undefined ? {} : { key }),
+            limit: readLeaderboardListLimit(payload.limit),
+            ...(payload.cursor === undefined ? {} : { cursor: readLeaderboardCursor(payload.cursor) }),
+        };
+    }
+    const score = readLeaderboardScore(payload.score);
+    return {
+        ...(key === undefined ? {} : { key }),
+        score,
+        ...(payload.extra === undefined ? {} : { extra: readLeaderboardExtra(payload.extra) }),
+    };
+}
+function assertLeaderboardEntry(value, methodName) {
+    assertMiniProgramRuntimeRecord(value, `${methodName} 返回的 entry 必须是对象`);
+    const { rank, ranked, userId, score, extra, createdAt, updatedAt } = value;
+    if (typeof ranked !== 'boolean') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', `${methodName} 返回的 ranked 必须是布尔值`);
+    }
+    const validRank = typeof rank === 'number' && Number.isInteger(rank) && (ranked ? rank > 0 : rank === 0);
+    if (!validRank) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', `${methodName} 返回的 rank/ranked 不合法`);
+    }
+    if (typeof userId !== 'string' || !userId) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', `${methodName} 返回的 userId 必须是非空字符串`);
+    }
+    if (typeof score !== 'number' || !Number.isFinite(score)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', `${methodName} 返回的 score 必须是有限数字`);
+    }
+    if (!isMiniProgramRuntimeRecord(extra)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', `${methodName} 返回的 extra 必须是对象`);
+    }
+    if (typeof createdAt !== 'number' || typeof updatedAt !== 'number' || !Number.isFinite(createdAt) || !Number.isFinite(updatedAt)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_RESPONSE', `${methodName} 返回的时间字段必须是有限数字`);
+    }
+}
+async function readCurrentUserId(platformAdapter) {
+    const userId = await platformAdapter.auth.getCurrentUserId();
+    if (userId === undefined || userId === null || `${userId}`.trim() === '') {
+        throw createMiniProgramRuntimeBridgeError('UNAUTHORIZED', '当前用户未登录');
+    }
+    return `${userId}`;
+}
+function readLeaderboardKey(value, methodName) {
+    if (typeof value !== 'string' || !LEADERBOARD_KEY_RE.test(value)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', `${methodName} key 仅支持 1-64 位字母、数字、下划线和连字符`);
+    }
+    return value;
+}
+function readLeaderboardExtra(value) {
+    if (!isMiniProgramRuntimeRecord(value)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'cloud.leaderboard.submit extra 必须是对象');
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'cloud.leaderboard.submit extra 必须可序列化');
+    }
+    if (typeof serialized !== 'string') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'cloud.leaderboard.submit extra 必须可序列化');
+    }
+    if (new TextEncoder().encode(serialized).length > MAX_LEADERBOARD_EXTRA_BYTES) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', `cloud.leaderboard.submit extra 不能超过 ${MAX_LEADERBOARD_EXTRA_BYTES} 字节`);
+    }
+    return value;
+}
+function readLeaderboardScore(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || Math.abs(value) > MAX_LEADERBOARD_SAFE_SCORE) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'cloud.leaderboard.submit score 必须是有限安全数字');
+    }
+    return value;
+}
+function readLeaderboardListLimit(value) {
+    if (value === undefined) {
+        return DEFAULT_LEADERBOARD_LIST_LIMIT;
+    }
+    if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0 || value > MAX_LEADERBOARD_LIST_LIMIT) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'cloud.leaderboard.getList limit 必须是 1-100 的整数');
+    }
+    return value;
+}
+function readLeaderboardCursor(value) {
+    if (typeof value !== 'string') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'cloud.leaderboard.getList cursor 必须是字符串');
+    }
+    return value;
+}
+
 const GAME_DETAIL_GAME_TYPES = ['pc', 'console', 'mobile'];
 const GAME_DETAIL_PAGES = ['game', 'wiki'];
 function toOpenAppPagePlatformOptions(payload) {
@@ -4703,6 +4938,9 @@ function isNavigationBarForegroundStyle(value) {
     return value === 'light' || value === 'dark';
 }
 
+const MOCK_DEFAULT_LEADERBOARD_KEY = 'default';
+const MOCK_LEADERBOARD_CACHE_MAX_ENTRIES = 500;
+const MOCK_LEADERBOARD_CURRENT_ENTRY_RANK_COUNT_LIMIT = 5000;
 const MINI_PROGRAM_MOCK_RUNTIME_METHODS = MINI_PROGRAM_PROTOCOL_CAPABILITIES.map((capability) => capability.method);
 const MINI_PROGRAM_MOCK_RUNTIME_METHOD_HANDLERS = {
     [AUTH_LOGIN_METHOD]: (runtime) => runtime.login(),
@@ -4719,6 +4957,11 @@ const MINI_PROGRAM_MOCK_RUNTIME_METHOD_HANDLERS = {
     [STORAGE_GET_STORAGE_METHOD]: (runtime, payload) => runtime.getStorage(payload),
     [STORAGE_SET_STORAGE_METHOD]: (runtime, payload) => runtime.setStorage(payload),
     [NETWORK_REQUEST_METHOD]: (runtime, payload) => runtime.requestNetwork(payload),
+    [CLOUD_LEADERBOARD_SUBMIT_METHOD]: (runtime, payload) => runtime.submitLeaderboardEntry(payload),
+    [CLOUD_LEADERBOARD_GET_LIST_METHOD]: (runtime, payload) => runtime.getLeaderboardList(payload),
+    [CLOUD_LEADERBOARD_GET_CURRENT_USER_ENTRY_METHOD]: (runtime, payload) => runtime.getCurrentUserLeaderboardEntry(payload),
+    [CLOUD_LEADERBOARD_DELETE_CURRENT_USER_ENTRY_METHOD]: (runtime, payload) => runtime.deleteCurrentUserLeaderboardEntry(payload),
+    [CLOUD_LEADERBOARD_GET_INFO_METHOD]: (runtime, payload) => runtime.getLeaderboardInfo(payload),
     [UI_SHOW_TOAST_METHOD]: (runtime, payload) => runtime.showToast(payload),
     [UI_SHOW_LOADING_METHOD]: (runtime, payload) => runtime.showLoading(payload),
     [UI_HIDE_LOADING_METHOD]: (runtime, payload) => runtime.hideLoading(payload),
@@ -4729,6 +4972,7 @@ const MINI_PROGRAM_MOCK_RUNTIME_METHOD_HANDLERS = {
     [NAVIGATION_OPEN_APP_PAGE_METHOD]: (runtime, payload) => runtime.openAppPage(payload),
 };
 function createBrowserMockRuntimePlatformAdapter(options) {
+    const leaderboards = createMockLeaderboardBoards(options.leaderboards);
     return {
         app: {
             getCurrentHref: options.getCurrentHref,
@@ -4844,6 +5088,31 @@ function createBrowserMockRuntimePlatformAdapter(options) {
         network: {
             request: options.requestNetwork,
         },
+        cloud: {
+            leaderboard: {
+                async submit(request) {
+                    return getMockLeaderboardBoard(leaderboards, resolveMockLeaderboardKey(request.key)).submit(request.userId, request.score, request.extra);
+                },
+                async getList(request) {
+                    return getMockLeaderboardBoard(leaderboards, resolveMockLeaderboardKey(request.key)).getList(request.limit, request.cursor);
+                },
+                async getCurrentUserEntry(request) {
+                    return getMockLeaderboardBoard(leaderboards, resolveMockLeaderboardKey(request.key)).getCurrentUserEntry(request.userId);
+                },
+                async deleteCurrentUserEntry(request) {
+                    return getMockLeaderboardBoard(leaderboards, resolveMockLeaderboardKey(request.key)).deleteCurrentUserEntry(request.userId);
+                },
+                async getInfo(request) {
+                    const key = resolveMockLeaderboardKey(request.key);
+                    const board = getMockLeaderboardBoard(leaderboards, key);
+                    return {
+                        key,
+                        order: board.order,
+                        rankLimit: board.rankLimit,
+                    };
+                },
+            },
+        },
     };
 }
 class MiniProgramMockRuntime {
@@ -4970,6 +5239,21 @@ class MiniProgramMockRuntime {
     requestNetwork(payload) {
         return requestMiniProgramRuntimeNetwork(payload, this.adapter);
     }
+    submitLeaderboardEntry(payload) {
+        return submitMiniProgramRuntimeLeaderboardEntry(payload, { platformAdapter: this.adapter });
+    }
+    getLeaderboardList(payload) {
+        return getMiniProgramRuntimeLeaderboardList(payload, { platformAdapter: this.adapter });
+    }
+    getCurrentUserLeaderboardEntry(payload) {
+        return getMiniProgramRuntimeCurrentUserLeaderboardEntry(payload, { platformAdapter: this.adapter });
+    }
+    deleteCurrentUserLeaderboardEntry(payload) {
+        return deleteMiniProgramRuntimeCurrentUserLeaderboardEntry(payload, { platformAdapter: this.adapter });
+    }
+    getLeaderboardInfo(payload) {
+        return getMiniProgramRuntimeLeaderboardInfo(payload, { platformAdapter: this.adapter });
+    }
     async showToast(payload) {
         const toast = readShowToastPayload(payload);
         this.toasts.unshift(toast);
@@ -5263,6 +5547,312 @@ function createVibratePattern(intensity) {
             return 10;
     }
 }
+function resolveMockLeaderboardKey(key) {
+    return key || MOCK_DEFAULT_LEADERBOARD_KEY;
+}
+function createMockLeaderboardBoards(configs = []) {
+    return configs.reduce((boards, config) => {
+        const key = resolveMockLeaderboardKey(config.key);
+        boards.set(key, new MockLeaderboardBoard({
+            ...config,
+            key,
+        }));
+        return boards;
+    }, new Map());
+}
+function getMockLeaderboardBoard(boards, key) {
+    const board = boards.get(key);
+    if (board) {
+        return board;
+    }
+    if (key === MOCK_DEFAULT_LEADERBOARD_KEY) {
+        throw createMockBridgeError('LEADERBOARD_DEFAULT_NOT_FOUND', '默认排行榜不存在');
+    }
+    throw createMockBridgeError('NotFound', '排行榜不存在');
+}
+class MockLeaderboardBoard {
+    constructor(config) {
+        this.entries = new Map();
+        this.key = config.key;
+        this.order = readMockLeaderboardOrder(config.order);
+        this.rankLimit = readMockLeaderboardRankLimit(config.rankLimit);
+        config.entries?.forEach(entry => {
+            const now = Date.now();
+            this.entries.set(entry.userId, {
+                userId: readMockLeaderboardUserId(entry.userId),
+                score: readMockLeaderboardScore(entry.score),
+                extra: cloneMockRecord(entry.extra || {}),
+                createdAt: entry.createdAt ?? now,
+                updatedAt: entry.updatedAt ?? entry.createdAt ?? now,
+            });
+        });
+    }
+    submit(userId, score, extra) {
+        const now = Date.now();
+        const existing = this.entries.get(userId);
+        if (existing && !this.isBetterScore(score, existing.score)) {
+            return this.getCurrentUserEntry(userId);
+        }
+        this.entries.set(userId, {
+            userId,
+            score,
+            extra: extra === undefined ? cloneMockRecord(existing?.extra || {}) : cloneMockRecord(extra),
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        });
+        this.clearListCache();
+        return this.getCurrentUserEntry(userId);
+    }
+    getList(limit, cursor) {
+        const listCursor = this.readListCursor(cursor);
+        const startRank = listCursor ? listCursor.rank + 1 : 1;
+        if (this.rankLimit > 0 && startRank > this.rankLimit) {
+            return {
+                entries: [],
+                hasMore: false,
+            };
+        }
+        const cachedResponse = this.getCachedListResponse(listCursor, limit);
+        if (cachedResponse) {
+            return cachedResponse;
+        }
+        if (!listCursor) {
+            this.refreshListCache();
+            const freshCachedResponse = this.getCachedListResponse(undefined, limit);
+            if (freshCachedResponse) {
+                return freshCachedResponse;
+            }
+        }
+        const entriesAfterCursor = this.getListEntries()
+            .filter(entry => listCursor ? this.isAfterCursor(entry, listCursor) : true);
+        const entries = entriesAfterCursor.slice(0, limit);
+        const hasMore = entries.length < entriesAfterCursor.length;
+        return this.createListResponse(entries, startRank, hasMore);
+    }
+    getCurrentUserEntry(userId) {
+        const orderedEntries = this.getOrderedEntries();
+        const index = orderedEntries.findIndex(entry => entry.userId === userId);
+        if (index < 0) {
+            return undefined;
+        }
+        const rank = index + 1;
+        const ranked = this.isCurrentUserRanked(rank);
+        const entry = orderedEntries[index];
+        return {
+            rank: ranked ? rank : 0,
+            ranked,
+            ...entry,
+            extra: cloneMockRecord(entry.extra),
+        };
+    }
+    deleteCurrentUserEntry(userId) {
+        const deleted = this.entries.delete(userId);
+        if (deleted) {
+            this.clearListCache();
+        }
+        return {
+            deleted,
+        };
+    }
+    getCachedListResponse(cursor, limit) {
+        if (!this.cachedList) {
+            return undefined;
+        }
+        let start = 0;
+        let startRank = 1;
+        if (cursor) {
+            const cursorIndex = this.cachedList.entries.findIndex(entry => (entry.score === cursor.score &&
+                entry.updatedAt === cursor.update_time &&
+                entry.userId === cursor.user_id));
+            if (cursorIndex < 0) {
+                return undefined;
+            }
+            start = cursorIndex + 1;
+            startRank = cursor.rank + 1;
+        }
+        if (start >= this.cachedList.entries.length) {
+            return this.cachedList.complete
+                ? {
+                    entries: [],
+                    hasMore: false,
+                }
+                : undefined;
+        }
+        const end = Math.min(start + limit, this.cachedList.entries.length);
+        const hasMore = end < this.cachedList.entries.length || !this.cachedList.complete;
+        return this.createListResponse(this.cachedList.entries.slice(start, end), startRank, hasMore);
+    }
+    refreshListCache() {
+        const cacheLimit = this.rankLimit > 0 && this.rankLimit < MOCK_LEADERBOARD_CACHE_MAX_ENTRIES
+            ? this.rankLimit
+            : MOCK_LEADERBOARD_CACHE_MAX_ENTRIES;
+        const rankedEntries = this.getListEntries();
+        this.cachedList = {
+            entries: rankedEntries.slice(0, cacheLimit).map(entry => ({
+                ...entry,
+                extra: cloneMockRecord(entry.extra),
+            })),
+            complete: rankedEntries.length <= cacheLimit,
+        };
+    }
+    clearListCache() {
+        this.cachedList = undefined;
+    }
+    createListResponse(entries, startRank, hasMore) {
+        const pageEntries = entries.map((entry, index) => ({
+            rank: startRank + index,
+            ranked: true,
+            ...entry,
+            extra: cloneMockRecord(entry.extra),
+        }));
+        return {
+            entries: pageEntries,
+            ...(hasMore && pageEntries.length > 0 ? { cursor: this.createListCursor(pageEntries[pageEntries.length - 1]) } : {}),
+            hasMore,
+        };
+    }
+    getOrderedEntries() {
+        return Array.from(this.entries.values())
+            .sort((left, right) => {
+            if (left.score !== right.score) {
+                return this.order === 'asc' ? left.score - right.score : right.score - left.score;
+            }
+            if (left.updatedAt !== right.updatedAt) {
+                return left.updatedAt - right.updatedAt;
+            }
+            return left.userId.localeCompare(right.userId);
+        })
+            .map(entry => ({
+            ...entry,
+            extra: cloneMockRecord(entry.extra),
+        }));
+    }
+    getListEntries() {
+        return this.getOrderedEntries().filter((_entry, index) => this.isWithinRankLimit(index + 1));
+    }
+    isBetterScore(nextScore, currentScore) {
+        return this.order === 'desc' ? nextScore > currentScore : nextScore < currentScore;
+    }
+    readListCursor(cursor) {
+        const raw = cursor?.trim();
+        if (!raw) {
+            return undefined;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(decodeMockLeaderboardCursor(raw));
+        }
+        catch {
+            throw createMockBridgeError('INVALID_PARAMS', 'cloud.leaderboard.getList cursor 不合法');
+        }
+        if (!isPlainRecord(parsed)) {
+            throw createMockBridgeError('INVALID_PARAMS', 'cloud.leaderboard.getList cursor 不合法');
+        }
+        const listCursor = parsed;
+        const isValid = typeof listCursor.rank === 'number' &&
+            Number.isSafeInteger(listCursor.rank) &&
+            listCursor.rank >= 1 &&
+            typeof listCursor.user_id === 'string' &&
+            listCursor.user_id !== '' &&
+            typeof listCursor.update_time === 'number' &&
+            Number.isFinite(listCursor.update_time) &&
+            listCursor.update_time > 0 &&
+            typeof listCursor.score === 'number' &&
+            Number.isFinite(listCursor.score);
+        if (!isValid) {
+            throw createMockBridgeError('INVALID_PARAMS', 'cloud.leaderboard.getList cursor 不合法');
+        }
+        return listCursor;
+    }
+    createListCursor(entry) {
+        return encodeMockLeaderboardCursor(JSON.stringify({
+            rank: entry.rank,
+            score: entry.score,
+            update_time: entry.updatedAt,
+            user_id: entry.userId,
+        }));
+    }
+    isAfterCursor(entry, cursor) {
+        if (entry.score !== cursor.score) {
+            return this.order === 'asc' ? entry.score > cursor.score : entry.score < cursor.score;
+        }
+        if (entry.updatedAt !== cursor.update_time) {
+            return entry.updatedAt > cursor.update_time;
+        }
+        return entry.userId.localeCompare(cursor.user_id) > 0;
+    }
+    isWithinRankLimit(rank) {
+        return this.rankLimit <= 0 || rank <= this.rankLimit;
+    }
+    isCurrentUserRanked(rank) {
+        return rank <= this.getCurrentUserRankCountLimit();
+    }
+    getCurrentUserRankCountLimit() {
+        return this.rankLimit > 0 && this.rankLimit < MOCK_LEADERBOARD_CURRENT_ENTRY_RANK_COUNT_LIMIT
+            ? this.rankLimit
+            : MOCK_LEADERBOARD_CURRENT_ENTRY_RANK_COUNT_LIMIT;
+    }
+}
+function readMockLeaderboardOrder(value) {
+    if (value === undefined) {
+        return 'desc';
+    }
+    if (value !== 'asc' && value !== 'desc') {
+        throw createMockBridgeError('INVALID_PARAMS', 'mock leaderboard order 必须是 asc 或 desc');
+    }
+    return value;
+}
+function readMockLeaderboardRankLimit(value) {
+    if (value === undefined) {
+        return 0;
+    }
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+        throw createMockBridgeError('INVALID_PARAMS', 'mock leaderboard rankLimit 必须是非负整数');
+    }
+    return value;
+}
+function readMockLeaderboardUserId(value) {
+    if (typeof value !== 'string' || !value) {
+        throw createMockBridgeError('INVALID_PARAMS', 'mock leaderboard entry userId 必须是非空字符串');
+    }
+    return value;
+}
+function readMockLeaderboardScore(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw createMockBridgeError('INVALID_PARAMS', 'mock leaderboard entry score 必须是有限数字');
+    }
+    return value;
+}
+function cloneMockRecord(record) {
+    try {
+        return JSON.parse(JSON.stringify(record));
+    }
+    catch {
+        return { ...record };
+    }
+}
+function encodeMockLeaderboardCursor(value) {
+    const bytes = new TextEncoder().encode(value);
+    let binary = '';
+    bytes.forEach((byte) => {
+        binary += String.fromCharCode(byte);
+    });
+    if (typeof btoa !== 'function') {
+        throw createMockBridgeError('MOCK_RUNTIME_ERROR', '当前环境不支持排行榜 cursor 编码');
+    }
+    const base64 = btoa(binary);
+    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+function decodeMockLeaderboardCursor(value) {
+    const base64 = value.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), '=');
+    if (typeof atob !== 'function') {
+        throw createMockBridgeError('INVALID_PARAMS', 'cloud.leaderboard.getList cursor 不合法');
+    }
+    const binary = atob(padded);
+    const bytes = Uint8Array.from(binary, char => char.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}
 function createMockRuntimeUserHomeV2Result(userInfo) {
     const heyboxId = userInfo.heybox_id || 'debug_user';
     const nickname = userInfo.nickname || 'PC Debug User';