@heybox/hb-sdk 0.1.3 → 0.2.0-alpha.1

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

@@ -0,0 +1,975 @@
+/** 小程序沙盒通信命名空间，父容器与 iframe 内 SDK 必须保持一致。 */
+const MINI_PROGRAM_MESSAGE_NAMESPACE = 'heybox:miniprogram';
+/** 小程序沙盒通信协议版本。 */
+const MINI_PROGRAM_MESSAGE_VERSION = 1;
+/** 父容器注入到小程序 URL 上的通信 nonce 参数名。 */
+const MINI_PROGRAM_BRIDGE_NONCE_PARAM = 'hb_mini_bridge_nonce';
+
+/**
+ * 登录授权能力方法名。
+ *
+ * @remarks
+ * 供 SDK 与父容器 runtime 共享同一 bridge method 标识。
+ */
+const AUTH_LOGIN_METHOD = 'auth.login';
+/**
+ * 用户信息能力方法名。
+ *
+ * @remarks
+ * 供 SDK 与父容器 runtime 共享同一 bridge method 标识。
+ */
+const USER_GET_INFO_METHOD = 'user.getInfo';
+/**
+ * 展示分享面板能力方法名。
+ *
+ * @remarks
+ * 供 SDK 与父容器 runtime 共享同一 bridge method 标识。
+ */
+const SHARE_SHOW_SHARE_MENU_METHOD = 'share.showShareMenu';
+/**
+ * 截图分享能力方法名。
+ *
+ * @remarks
+ * 供 SDK 与父容器 runtime 共享同一 bridge method 标识。
+ */
+const SHARE_SCREENSHOT_METHOD = 'share.screenshot';
+/**
+ * 视口窗口信息能力方法名。
+ *
+ * @remarks
+ * 供 SDK 与父容器 runtime 共享同一 bridge method 标识。
+ */
+const VIEWPORT_GET_WINDOW_INFO_METHOD = 'viewport.getWindowInfo';
+/**
+ * 读取小程序隔离 storage 能力方法名。
+ *
+ * @remarks
+ * 供 SDK 与父容器 runtime 共享同一 bridge method 标识。
+ */
+const STORAGE_GET_STORAGE_METHOD = 'storage.getStorage';
+/**
+ * 写入小程序隔离 storage 能力方法名。
+ *
+ * @remarks
+ * 供 SDK 与父容器 runtime 共享同一 bridge method 标识。
+ */
+const STORAGE_SET_STORAGE_METHOD = 'storage.setStorage';
+/**
+ * 发起网络请求能力方法名。
+ *
+ * @remarks
+ * 供 SDK 与父容器 runtime 共享同一 bridge method 标识。
+ */
+const NETWORK_REQUEST_METHOD = 'network.request';
+/**
+ * 小程序开放能力目录。
+ *
+ * @remarks
+ * 新增 bridge method 时应先更新这里，再分别补齐 SDK 模块、runtime handler 与测试。
+ */
+const MINI_PROGRAM_PROTOCOL_CAPABILITIES = [
+    {
+        method: AUTH_LOGIN_METHOD,
+        module: 'auth',
+        capability: AUTH_LOGIN_METHOD,
+        permission: 'auth.login',
+        risk: 'medium',
+    },
+    {
+        method: USER_GET_INFO_METHOD,
+        module: 'user',
+        capability: USER_GET_INFO_METHOD,
+        permission: 'user.getInfo',
+        risk: 'medium',
+    },
+    {
+        method: SHARE_SHOW_SHARE_MENU_METHOD,
+        module: 'share',
+        capability: SHARE_SHOW_SHARE_MENU_METHOD,
+        permission: 'share.basic',
+        risk: 'low',
+    },
+    {
+        method: SHARE_SCREENSHOT_METHOD,
+        module: 'share',
+        capability: SHARE_SCREENSHOT_METHOD,
+        permission: 'share.screenshot',
+        risk: 'medium',
+    },
+    {
+        method: VIEWPORT_GET_WINDOW_INFO_METHOD,
+        module: 'viewport',
+        capability: VIEWPORT_GET_WINDOW_INFO_METHOD,
+        permission: 'viewport.windowInfo',
+        risk: 'low',
+    },
+    {
+        method: STORAGE_GET_STORAGE_METHOD,
+        module: 'storage',
+        capability: STORAGE_GET_STORAGE_METHOD,
+        permission: 'storage.read',
+        risk: 'low',
+    },
+    {
+        method: STORAGE_SET_STORAGE_METHOD,
+        module: 'storage',
+        capability: STORAGE_SET_STORAGE_METHOD,
+        permission: 'storage.write',
+        risk: 'medium',
+    },
+    {
+        method: NETWORK_REQUEST_METHOD,
+        module: 'network',
+        capability: NETWORK_REQUEST_METHOD,
+        permission: 'network.request',
+        risk: 'high',
+    },
+];
+
+const MINI_PROGRAM_URL_QUERY_PARAM = 'mini_url';
+const MINI_PROGRAM_DEV_QUERY_PARAM = 'hb_mini_dev';
+const MINI_PROGRAM_DETAIL_URL = 'https://www.xiaoheihe.cn/tools/user_miniprogram/detail';
+function createMacAppProtocol(appUrl) {
+    const detailUrl = new URL(MINI_PROGRAM_DETAIL_URL);
+    detailUrl.searchParams.set(MINI_PROGRAM_URL_QUERY_PARAM, appUrl);
+    detailUrl.searchParams.set(MINI_PROGRAM_DEV_QUERY_PARAM, '1');
+    const protocolPayload = {
+        protocol_type: 'openWindow',
+        full_screen: true,
+        mini_program: '1',
+        webview: {
+            url: detailUrl.toString(),
+            pull: false,
+            refresh: false,
+        },
+    };
+    return `heybox://${encodeURIComponent(JSON.stringify(protocolPayload))}`;
+}
+
+const DEFAULT_STORAGE_KEY_MAX_LENGTH = 128;
+const STORAGE_KEY_CHAR_RE = /^[A-Za-z0-9_-]+$/;
+const NETWORK_REQUEST_ALLOWED_KEYS = new Set([
+    'url',
+    'method',
+    'params',
+    'data',
+    'headers',
+    'timeout',
+    'withCredentials',
+]);
+const NETWORK_HTTP_METHODS = new Set([
+    'GET',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'HEAD',
+    'OPTIONS',
+]);
+function createMiniProgramRuntimeBridgeError(code, message, data) {
+    return {
+            code,
+            message,
+        }
+        ;
+}
+function isMiniProgramRuntimeRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertMiniProgramRuntimeRecord(value, message) {
+    if (!isMiniProgramRuntimeRecord(value)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', message);
+    }
+}
+function readMiniProgramRuntimeRequiredString(value, message) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', message);
+    }
+    return value;
+}
+function readMiniProgramRuntimeBoolean(value, message) {
+    if (typeof value !== 'boolean') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', message);
+    }
+    return value;
+}
+function readMiniProgramRuntimeHttpUrl(value, message) {
+    const urlValue = readMiniProgramRuntimeRequiredString(value, message);
+    try {
+        const url = new URL(urlValue);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            throw new Error('invalid protocol');
+        }
+        return urlValue;
+    }
+    catch {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', message);
+    }
+}
+function readMiniProgramRuntimeNonNegativeNumber(value, message) {
+    const numberValue = Number(value);
+    if (!Number.isFinite(numberValue) || numberValue < 0) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', message);
+    }
+    return numberValue;
+}
+function readMiniProgramRuntimePositiveNumber(value, message) {
+    const numberValue = Number(value);
+    if (!Number.isFinite(numberValue) || numberValue <= 0) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', message);
+    }
+    return numberValue;
+}
+function readMiniProgramRuntimeStorageKey(value, methodName, maxKeyLength = DEFAULT_STORAGE_KEY_MAX_LENGTH) {
+    if (typeof value !== 'string') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', `${methodName} key 必须是字符串`);
+    }
+    if (!value || value.length > maxKeyLength || !STORAGE_KEY_CHAR_RE.test(value)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', `storage key 仅支持 1-${maxKeyLength} 位字母、数字、下划线和连字符`);
+    }
+    return value;
+}
+function getMiniProgramRuntimeUtf8ByteLength(value) {
+    return new TextEncoder().encode(value).length;
+}
+function stringifyMiniProgramRuntimeJsonData(data, options) {
+    let value;
+    try {
+        value = JSON.stringify(data);
+    }
+    catch {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', options.invalidMessage);
+    }
+    if (typeof value !== 'string') {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', options.invalidMessage);
+    }
+    if (options.maxValueBytes !== undefined && getMiniProgramRuntimeUtf8ByteLength(value) > options.maxValueBytes) {
+        throw createMiniProgramRuntimeBridgeError('STORAGE_QUOTA_EXCEEDED', `storage.setStorage data 超出 ${options.maxValueBytes} 字节限制`);
+    }
+    return value;
+}
+async function getMiniProgramRuntimeUserInfo(platformAdapter) {
+    const userId = await resolveCurrentUserId(platformAdapter);
+    if (!userId) {
+        return {
+            isLogin: false,
+            userInfo: null,
+        };
+    }
+    const result = await platformAdapter.user.getUserBasicInfo(userId);
+    return {
+        isLogin: true,
+        userInfo: {
+            heybox_id: userId,
+            nickname: result?.nickname || '',
+            avatar: result?.avatar || '',
+        },
+    };
+}
+async function loginAndGetMiniProgramRuntimeUserInfo(platformAdapter) {
+    await platformAdapter.auth.login();
+    return getMiniProgramRuntimeUserInfo(platformAdapter);
+}
+function getMiniProgramRuntimeWindowInfo(platformAdapter) {
+    const metrics = platformAdapter.viewport.getViewportMetrics();
+    const windowWidth = getViewportWidth(metrics);
+    const windowHeight = getViewportHeight(metrics);
+    const screenWidth = getPositiveNumber(metrics.screenWidth, windowWidth);
+    const screenHeight = getPositiveNumber(metrics.screenHeight, windowHeight);
+    const navigationBarHeight = getNavigationBarHeight(platformAdapter);
+    const safeAreaHeight = Math.max(windowHeight - navigationBarHeight, 0);
+    return {
+        pixelRatio: getPositiveNumber(metrics.pixelRatio, 1),
+        screenWidth,
+        screenHeight,
+        windowWidth,
+        windowHeight,
+        statusBarHeight: navigationBarHeight,
+        safeArea: {
+            left: 0,
+            right: windowWidth,
+            top: navigationBarHeight,
+            bottom: windowHeight,
+            width: windowWidth,
+            height: safeAreaHeight,
+        },
+        screenTop: navigationBarHeight,
+    };
+}
+function showMiniProgramRuntimeShareMenu(payload, platformAdapter) {
+    return platformAdapter.share.showShareMenu(readMiniProgramRuntimeShareMenuOptions(payload));
+}
+function shareMiniProgramRuntimeScreenshot(payload, platformAdapter) {
+    const options = readMiniProgramRuntimeScreenshotOptions(payload);
+    const rect = options.rect || getViewportRect(platformAdapter);
+    return platformAdapter.share.shareScreenshot({
+        rect,
+        delay: options.delay,
+        saveToAlbum: options.saveToAlbum,
+    });
+}
+function getMiniProgramRuntimeStorage(payload, options, platformAdapter) {
+    const { key } = readMiniProgramRuntimeGetStoragePayload(payload, options.maxKeyLength);
+    const storageValue = platformAdapter.storage.getStorage({
+        key: createMiniProgramRuntimeStorageKey(key, options.scope || getMiniProgramRuntimeStorageScope(undefined, platformAdapter), options.maxKeyLength),
+    });
+    return {
+        data: parseStorageData(storageValue),
+    };
+}
+async function setMiniProgramRuntimeStorage(payload, options, platformAdapter) {
+    const { key, data } = readMiniProgramRuntimeSetStoragePayload(payload, options.maxKeyLength);
+    await platformAdapter.storage.setStorage({
+        key: createMiniProgramRuntimeStorageKey(key, options.scope || getMiniProgramRuntimeStorageScope(undefined, platformAdapter), options.maxKeyLength),
+        value: stringifyMiniProgramRuntimeJsonData(data, {
+            invalidMessage: 'storage.setStorage data 必须可 JSON 序列化',
+            maxValueBytes: options.maxValueBytes,
+        }),
+    });
+}
+function getMiniProgramRuntimeStorageScope(href, platformAdapter) {
+    const currentHref = platformAdapter.app.getCurrentHref();
+    try {
+        const url = new URL(currentHref);
+        const miniProgramId = url.searchParams.get('mini_program_id')?.trim();
+        if (miniProgramId) {
+            return `id_${toStorageScopeToken(miniProgramId)}`;
+        }
+        const miniUrl = url.searchParams.get('mini_url')?.trim();
+        if (miniUrl) {
+            return `url_${hashString(miniUrl)}`;
+        }
+        return `url_${hashString(`${url.origin}${url.pathname}`)}`;
+    }
+    catch {
+        return `url_${hashString(currentHref)}`;
+    }
+}
+function createMiniProgramRuntimeStorageKey(key, storageScope, maxKeyLength) {
+    readMiniProgramRuntimeStorageKey(key, 'storage.setStorage', maxKeyLength);
+    return `hb_miniprogram_${storageScope}_${key}`;
+}
+async function requestMiniProgramRuntimeNetwork(payload, platformAdapter) {
+    return platformAdapter.network.request(readMiniProgramRuntimeNetworkRequest(payload));
+}
+function readMiniProgramRuntimeNetworkRequest(payload) {
+    assertMiniProgramRuntimeRecord(payload, 'network.request 参数必须是对象');
+    assertNetworkAllowedKeys(payload);
+    const request = {
+        url: readMiniProgramRuntimeHttpUrl(payload.url, 'network.request url 必须是 HTTP(S) URL'),
+    };
+    if (payload.method !== undefined) {
+        request.method = readNetworkMethod(payload.method);
+    }
+    if (payload.params !== undefined) {
+        request.params = readUnknownRecord(payload.params, 'network.request params 必须是对象');
+    }
+    if (payload.data !== undefined) {
+        request.data = payload.data;
+    }
+    if (payload.headers !== undefined) {
+        request.headers = readStringRecord(payload.headers, 'network.request headers 必须是 Record<string, string>');
+    }
+    if (payload.timeout !== undefined) {
+        request.timeout = readMiniProgramRuntimeNonNegativeNumber(payload.timeout, 'network.request timeout 必须是非负数字');
+    }
+    if (payload.withCredentials !== undefined) {
+        request.withCredentials = readMiniProgramRuntimeBoolean(payload.withCredentials, 'network.request withCredentials 必须是布尔值');
+    }
+    return request;
+}
+function readMiniProgramRuntimeShareMenuOptions(payload) {
+    assertMiniProgramRuntimeRecord(payload, 'share.showShareMenu 参数必须是对象');
+    const title = readMiniProgramRuntimeRequiredString(payload.title, 'share.showShareMenu title 必须是非空字符串');
+    const desc = readMiniProgramRuntimeRequiredString(payload.desc, 'share.showShareMenu desc 必须是非空字符串');
+    const url = readMiniProgramRuntimeHttpUrl(payload.url, 'share.showShareMenu url 必须是 HTTP(S) URL');
+    const imageUrl = payload.imageUrl === undefined
+        ? undefined
+        : readMiniProgramRuntimeHttpUrl(payload.imageUrl, 'share.showShareMenu imageUrl 必须是 HTTP(S) URL');
+    const channel = payload.channel;
+    if (channel !== undefined && !isShareChannel(channel)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'share.showShareMenu channel 不合法');
+    }
+    return {
+        title,
+        desc,
+        url,
+        imageUrl,
+        channel,
+    };
+}
+function readMiniProgramRuntimeScreenshotOptions(payload) {
+    if (payload === undefined || payload === null) {
+        return {};
+    }
+    assertMiniProgramRuntimeRecord(payload, 'share.screenshot 参数必须是对象');
+    const options = {};
+    if (payload.rect !== undefined) {
+        options.rect = readScreenshotRect(payload.rect);
+    }
+    if (payload.delay !== undefined) {
+        options.delay = readMiniProgramRuntimeNonNegativeNumber(payload.delay, 'share.screenshot delay 必须是非负数字');
+    }
+    if (payload.saveToAlbum !== undefined) {
+        options.saveToAlbum = readMiniProgramRuntimeBoolean(payload.saveToAlbum, 'share.screenshot saveToAlbum 必须是布尔值');
+    }
+    return options;
+}
+function readScreenshotRect(value) {
+    assertMiniProgramRuntimeRecord(value, 'share.screenshot rect 必须是对象');
+    const left = readMiniProgramRuntimeNonNegativeNumber(value.left, 'share.screenshot rect.left 必须是非负数字');
+    const top = readMiniProgramRuntimeNonNegativeNumber(value.top, 'share.screenshot rect.top 必须是非负数字');
+    const width = readMiniProgramRuntimePositiveNumber(value.width, 'share.screenshot rect.width 必须是正数');
+    const height = readMiniProgramRuntimePositiveNumber(value.height, 'share.screenshot rect.height 必须是正数');
+    return {
+        left,
+        top,
+        width,
+        height,
+    };
+}
+function readMiniProgramRuntimeGetStoragePayload(payload, maxKeyLength) {
+    if (!isMiniProgramRuntimeRecord(payload)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'storage.getStorage 参数必须是对象');
+    }
+    const key = readMiniProgramRuntimeStorageKey(payload.key, 'storage.getStorage', maxKeyLength);
+    return {
+        key,
+    };
+}
+function readMiniProgramRuntimeSetStoragePayload(payload, maxKeyLength) {
+    if (!isMiniProgramRuntimeRecord(payload)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'storage.setStorage 参数必须是对象');
+    }
+    const key = readMiniProgramRuntimeStorageKey(payload.key, 'storage.setStorage', maxKeyLength);
+    return {
+        key,
+        data: payload.data,
+    };
+}
+function assertNetworkAllowedKeys(payload) {
+    const invalidKeys = Object.keys(payload).filter(key => !NETWORK_REQUEST_ALLOWED_KEYS.has(key));
+    if (invalidKeys.length > 0) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', `network.request 不支持字段: ${invalidKeys.join(', ')}`);
+    }
+}
+function readNetworkMethod(value) {
+    const method = readMiniProgramRuntimeRequiredString(value, 'network.request method 必须是字符串').trim().toUpperCase();
+    if (!NETWORK_HTTP_METHODS.has(method)) {
+        throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', 'network.request method 不合法');
+    }
+    return method;
+}
+function readUnknownRecord(value, message) {
+    assertMiniProgramRuntimeRecord(value, message);
+    return { ...value };
+}
+function readStringRecord(value, message) {
+    assertMiniProgramRuntimeRecord(value, message);
+    return Object.entries(value).reduce((headers, [key, headerValue]) => {
+        if (!key.trim() || typeof headerValue !== 'string') {
+            throw createMiniProgramRuntimeBridgeError('INVALID_PARAMS', message);
+        }
+        headers[key] = headerValue;
+        return headers;
+    }, {});
+}
+function resolveCurrentUserId(platformAdapter) {
+    return platformAdapter.auth.getCurrentUserId()
+        .then(userId => (userId ? String(userId) : ''))
+        .catch(() => '');
+}
+function getNavigationBarHeight(platformAdapter) {
+    try {
+        return platformAdapter.viewport.getNavigationBarHeight();
+    }
+    catch {
+        return 0;
+    }
+}
+function getViewportRect(platformAdapter) {
+    const metrics = platformAdapter.viewport.getViewportMetrics();
+    const width = getPositiveNumber(metrics.innerWidth, getPositiveNumber(metrics.documentElementClientWidth, 0));
+    const height = getPositiveNumber(metrics.innerHeight, getPositiveNumber(metrics.documentElementClientHeight, 0));
+    return {
+        left: 0,
+        top: 0,
+        width,
+        height,
+    };
+}
+function getViewportWidth(metrics) {
+    return getPositiveNumber(metrics.innerWidth, getPositiveNumber(metrics.documentElementClientWidth, 0));
+}
+function getViewportHeight(metrics) {
+    return getPositiveNumber(metrics.innerHeight, getPositiveNumber(metrics.documentElementClientHeight, 0));
+}
+function getPositiveNumber(value, fallback) {
+    const numberValue = Number(value);
+    if (!Number.isFinite(numberValue) || numberValue <= 0) {
+        return fallback;
+    }
+    return numberValue;
+}
+function parseStorageData(value) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function toStorageScopeToken(value) {
+    if (/^[A-Za-z0-9_-]{1,64}$/.test(value)) {
+        return value;
+    }
+    return hashString(value);
+}
+function hashString(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+}
+function isShareChannel(value) {
+    return (value === 'wechatSession' ||
+        value === 'wechatTimeline' ||
+        value === 'qqFriend' ||
+        value === 'qzone' ||
+        value === 'weibo');
+}
+
+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(),
+    [USER_GET_INFO_METHOD]: runtime => runtime.getUserInfo(),
+    [SHARE_SHOW_SHARE_MENU_METHOD]: (runtime, payload) => runtime.showShareMenu(payload),
+    [SHARE_SCREENSHOT_METHOD]: (runtime, payload) => runtime.shareScreenshot(payload),
+    [VIEWPORT_GET_WINDOW_INFO_METHOD]: runtime => runtime.getWindowInfo(),
+    [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),
+};
+class MiniProgramMockRuntime {
+    adapter;
+    options;
+    constructor(adapter, options = {}) {
+        this.adapter = adapter;
+        this.options = options;
+    }
+    async runMethod(method, payload) {
+        if (!isMiniProgramMockRuntimeMethod(method)) {
+            throw createMockBridgeError('METHOD_NOT_FOUND', `未开放小程序能力: ${method}`);
+        }
+        const handler = MINI_PROGRAM_MOCK_RUNTIME_METHOD_HANDLERS[method];
+        return handler(this, payload);
+    }
+    async login() {
+        const result = await loginAndGetMiniProgramRuntimeUserInfo(this.adapter);
+        this.options.onAuthChange?.(result);
+        return result;
+    }
+    async getUserInfo() {
+        return getMiniProgramRuntimeUserInfo(this.adapter);
+    }
+    showShareMenu(payload) {
+        return showMiniProgramRuntimeShareMenu(payload, this.adapter);
+    }
+    shareScreenshot(payload) {
+        return shareMiniProgramRuntimeScreenshot(payload, this.adapter);
+    }
+    getWindowInfo() {
+        return getMiniProgramRuntimeWindowInfo(this.adapter);
+    }
+    getStorage(payload) {
+        return getMiniProgramRuntimeStorage(payload, this.options.storage || {}, this.adapter);
+    }
+    async setStorage(payload) {
+        await setMiniProgramRuntimeStorage(payload, this.options.storage || {}, this.adapter);
+    }
+    requestNetwork(payload) {
+        return requestMiniProgramRuntimeNetwork(payload, this.adapter);
+    }
+}
+function isMiniProgramMockRuntimeMethod(method) {
+    return MINI_PROGRAM_MOCK_RUNTIME_METHODS.includes(method);
+}
+function createMockBridgeError(code, message, data) {
+    return data === undefined
+        ? {
+            code,
+            message,
+        }
+        : {
+            code,
+            message,
+            data,
+        };
+}
+function toMockBridgeError(error) {
+    if (isObjectLike(error) && typeof error.code === 'string' && typeof error.message === 'string') {
+        return {
+            code: error.code,
+            message: error.message,
+            ...(Object.prototype.hasOwnProperty.call(error, 'data') ? { data: error.data } : {}),
+        };
+    }
+    return createMockBridgeError('MOCK_RUNTIME_ERROR', error instanceof Error ? error.message : String(error));
+}
+function isObjectLike(value) {
+    return (typeof value === 'object' || typeof value === 'function') && value !== null;
+}
+
+const NETWORK_PROXY_PATH = '/__hb_sdk_mock_network__';
+const params = new URL(location.href).searchParams;
+const miniUrl = params.get('mini_url');
+const nonce = createNonce();
+const storage = new Map();
+const logs = [];
+let handshaken = false;
+let currentUser = {
+    heybox_id: 'debug_user',
+    nickname: 'PC Debug User',
+    avatar: '',
+};
+const elements = {
+    bridgeStatus: queryElement('#bridge-status'),
+    device: queryElement('#device'),
+    logs: queryElement('#logs'),
+    macAppButton: queryElement('#mac-app-button'),
+    macAppStatus: queryElement('#mac-app-status'),
+    miniUrl: queryElement('#mini-url'),
+    nicknameInput: queryElement('#nickname-input'),
+    storageSnapshot: queryElement('#storage-snapshot'),
+    userStatus: queryElement('#user-status'),
+};
+if (!miniUrl) {
+    elements.device.innerHTML = '<div class="error">Missing mini_url query.</div>';
+    throw new Error('Missing mini_url query.');
+}
+const miniProgramUrl = miniUrl;
+const iframe = document.createElement('iframe');
+iframe.src = appendNonce(miniProgramUrl, nonce);
+iframe.allow = 'clipboard-read; clipboard-write';
+elements.device.appendChild(iframe);
+elements.miniUrl.textContent = miniProgramUrl;
+const runtime = new MiniProgramMockRuntime(createBrowserMockRuntimeAdapter(), {
+    onAuthChange: result => postEvent('authChange', result),
+});
+updateUserStatus();
+updateStorageSnapshot();
+window.addEventListener('message', handleMessage);
+window.addEventListener('beforeunload', () => {
+    postEvent('unload', { timestamp: Date.now() });
+});
+queryElement('#login-button').addEventListener('click', () => {
+    void runtime.login();
+});
+queryElement('#logout-button').addEventListener('click', () => {
+    currentUser = null;
+    updateUserStatus();
+    postEvent('authChange', createUserInfoResult());
+});
+queryElement('#show-button').addEventListener('click', () => {
+    postEvent('show', { timestamp: Date.now(), source: 'mock-host' });
+});
+queryElement('#hide-button').addEventListener('click', () => {
+    postEvent('hide', { timestamp: Date.now(), source: 'mock-host' });
+});
+elements.macAppButton.addEventListener('click', () => {
+    elements.macAppStatus.textContent = '已尝试唤起 Mac 版 APP';
+    window.location.href = createMacAppProtocol(miniProgramUrl);
+});
+function createBrowserMockRuntimeAdapter() {
+    return {
+        app: {
+            getCurrentHref() {
+                return location.href;
+            },
+        },
+        launch: {
+            async getMiniProgramInfo() {
+                return {
+                    pageUrl: miniProgramUrl,
+                };
+            },
+        },
+        auth: {
+            async getCurrentUserId() {
+                return currentUser?.heybox_id;
+            },
+            async login() {
+                currentUser = createUserFromForm();
+                updateUserStatus();
+            },
+        },
+        user: {
+            async getUserBasicInfo(userId) {
+                if (!currentUser || currentUser.heybox_id !== userId) {
+                    return undefined;
+                }
+                return {
+                    nickname: currentUser.nickname,
+                    avatar: currentUser.avatar,
+                };
+            },
+        },
+        share: {
+            async showShareMenu(options) {
+                return {
+                    ok: true,
+                    platform: 'hb-sdk-mock-host',
+                    type: 'showShareMenu',
+                    params: options,
+                };
+            },
+            async shareScreenshot(options) {
+                return {
+                    ok: true,
+                    platform: 'hb-sdk-mock-host',
+                    type: 'screenshot',
+                    params: options,
+                };
+            },
+        },
+        viewport: {
+            setDocumentTitle(title) {
+                document.title = title;
+            },
+            getViewportMetrics() {
+                const rect = iframe.getBoundingClientRect();
+                const width = Math.max(1, Math.round(rect.width));
+                const height = Math.max(1, Math.round(rect.height));
+                return {
+                    innerWidth: width,
+                    innerHeight: height,
+                    documentElementClientWidth: width,
+                    documentElementClientHeight: height,
+                    screenWidth: window.screen.width || width,
+                    screenHeight: window.screen.height || height,
+                    pixelRatio: window.devicePixelRatio || 1,
+                };
+            },
+            getNavigationBarHeight() {
+                return 0;
+            },
+        },
+        storage: {
+            getStorage({ key }) {
+                return storage.get(key);
+            },
+            async setStorage({ key, value }) {
+                storage.set(key, value);
+                updateStorageSnapshot();
+            },
+        },
+        network: {
+            request: requestNetwork,
+        },
+    };
+}
+function handleMessage(event) {
+    if (event.source !== iframe.contentWindow || !isBridgeMessage(event.data)) {
+        return;
+    }
+    const message = event.data;
+    if (message.type === 'handshake') {
+        handleHandshake();
+        return;
+    }
+    if (message.type === 'request') {
+        void handleRequest(message);
+    }
+}
+function handleHandshake() {
+    const firstHandshake = !handshaken;
+    handshaken = true;
+    elements.bridgeStatus.textContent = 'ready';
+    if (firstHandshake) {
+        postEvent('launch', {
+            timestamp: Date.now(),
+            url: iframe.src,
+        });
+    }
+    postEvent('ready', {
+        timestamp: Date.now(),
+    });
+    pushLog('sdk.handshake', { firstHandshake });
+}
+async function handleRequest(message) {
+    if (!message.id || !message.method) {
+        return;
+    }
+    try {
+        const payload = await runtime.runMethod(message.method, message.payload);
+        postResponse(message, payload);
+        pushLog(message.method, { payload: message.payload, result: payload });
+    }
+    catch (error) {
+        const bridgeError = toMockBridgeError(error);
+        postResponse(message, undefined, bridgeError);
+        postEvent('error', bridgeError);
+        pushLog(message.method, { payload: message.payload, error: bridgeError });
+    }
+}
+async function requestNetwork(config) {
+    const response = await fetch(NETWORK_PROXY_PATH, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify(createNetworkProxyPayload(config)),
+    });
+    const payload = await readNetworkProxyResponse(response);
+    if (!response.ok) {
+        throw payload;
+    }
+    return payload;
+}
+async function readNetworkProxyResponse(response) {
+    const text = await response.text();
+    if (!text.trim()) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw {
+            code: response.status === 404 ? 'MOCK_NETWORK_PROXY_NOT_FOUND' : 'MOCK_NETWORK_PROXY_ERROR',
+            message: response.status === 404
+                ? 'mock network proxy 不可用，请重启 hb-sdk dev'
+                : text,
+        };
+    }
+}
+function createNetworkProxyPayload(config) {
+    const url = new URL(config.url, iframe.src);
+    if (config.params && typeof config.params === 'object') {
+        Object.entries(config.params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                url.searchParams.set(key, String(value));
+            }
+        });
+    }
+    return {
+        url: url.toString(),
+        method: config.method,
+        data: config.data,
+        headers: config.headers,
+        timeout: config.timeout,
+        withCredentials: config.withCredentials,
+    };
+}
+function postEvent(method, payload) {
+    postMessageToMiniProgram({
+        namespace: MINI_PROGRAM_MESSAGE_NAMESPACE,
+        version: MINI_PROGRAM_MESSAGE_VERSION,
+        nonce,
+        type: 'event',
+        method,
+        payload,
+    });
+}
+function postResponse(request, payload, error) {
+    postMessageToMiniProgram({
+        namespace: MINI_PROGRAM_MESSAGE_NAMESPACE,
+        version: MINI_PROGRAM_MESSAGE_VERSION,
+        nonce,
+        type: 'response',
+        id: request.id,
+        method: request.method,
+        payload,
+        error,
+    });
+}
+function postMessageToMiniProgram(message) {
+    iframe.contentWindow?.postMessage(message, readTargetOrigin());
+}
+function isBridgeMessage(message) {
+    return Boolean(message &&
+        typeof message === 'object' &&
+        'namespace' in message &&
+        'version' in message &&
+        'nonce' in message &&
+        message.namespace === MINI_PROGRAM_MESSAGE_NAMESPACE &&
+        message.version === MINI_PROGRAM_MESSAGE_VERSION &&
+        message.nonce === nonce);
+}
+function createUserInfoResult() {
+    return {
+        isLogin: Boolean(currentUser),
+        userInfo: currentUser ? { ...currentUser } : null,
+    };
+}
+function createUserFromForm() {
+    return {
+        heybox_id: 'debug_user',
+        nickname: elements.nicknameInput.value.trim() || 'PC Debug User',
+        avatar: '',
+    };
+}
+function updateUserStatus() {
+    elements.userStatus.textContent = currentUser ? currentUser.nickname : '未登录';
+}
+function updateStorageSnapshot() {
+    elements.storageSnapshot.textContent = JSON.stringify(Object.fromEntries(Array.from(storage.entries()).map(([key, value]) => [key, safeJsonParse(value)])), null, 2);
+}
+function pushLog(method, detail) {
+    logs.unshift({
+        method,
+        detail,
+        timestamp: new Date().toLocaleTimeString(),
+    });
+    logs.splice(30);
+    elements.logs.innerHTML = logs
+        .map(log => `<article class="log"><strong>${escapeHtml(log.method)} · ${escapeHtml(log.timestamp)}</strong><pre>${escapeHtml(JSON.stringify(log.detail, null, 2))}</pre></article>`)
+        .join('');
+}
+function appendNonce(input, value) {
+    const url = new URL(input, location.href);
+    url.searchParams.set(MINI_PROGRAM_BRIDGE_NONCE_PARAM, value);
+    return url.toString();
+}
+function readTargetOrigin() {
+    try {
+        return new URL(iframe.src).origin;
+    }
+    catch {
+        return '*';
+    }
+}
+function createNonce() {
+    if (globalThis.crypto?.randomUUID) {
+        return globalThis.crypto.randomUUID();
+    }
+    return `mock_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+function queryElement(selector) {
+    const element = document.querySelector(selector);
+    if (!element) {
+        throw new Error(`Missing mock host element: ${selector}`);
+    }
+    return element;
+}
+function safeJsonParse(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function escapeHtml(value) {
+    return String(value)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}