@typexim/web-sdk 0.0.7 → 0.0.8

package/dist-test/modules/TabSessionCoordinator.js

@@ -0,0 +1,289 @@
+const CHANNEL_NAME = 'typex-sdk-tab-session';
+const STORAGE_KEY = '__typex_sdk_tab_session_message__';
+function createTabId() {
+    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
+        return crypto.randomUUID();
+    }
+    return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function isCoordinatorMessage(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const message = value;
+    if (typeof message.senderTabId !== 'string') {
+        return false;
+    }
+    if (message.type === 'session-request') {
+        return (typeof message.requestId === 'string' &&
+            typeof message.createdAt === 'number');
+    }
+    if (message.type === 'session-response') {
+        return (typeof message.requesterTabId === 'string' &&
+            typeof message.requestId === 'string' &&
+            typeof message.createdAt === 'number' &&
+            isTransferableLoginSession(message.session));
+    }
+    if (message.type === 'logout') {
+        return (typeof message.logoutId === 'string' &&
+            typeof message.createdAt === 'number');
+    }
+    if (message.type === 'login') {
+        return (typeof message.loginId === 'string' &&
+            typeof message.createdAt === 'number' &&
+            isTransferableLoginSession(message.session));
+    }
+    return false;
+}
+function isTransferableLoginSession(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const session = value;
+    const loginUser = session.loginUser;
+    return ((session.deviceId === null || typeof session.deviceId === 'string') &&
+        !!loginUser &&
+        typeof loginUser.userId === 'string' &&
+        typeof loginUser.secretKey === 'string' &&
+        typeof loginUser.sessionId === 'string');
+}
+export default class TabSessionCoordinator {
+    constructor(config = {}) {
+        Object.defineProperty(this, "tabId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "channel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "handledSessionRequestIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "handledLogoutIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "handledLoginIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pendingSessionRequests", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "getCurrentSession", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "onLogoutBroadcast", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "onLoginBroadcast", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.tabId = createTabId();
+        this.channel = null;
+        this.closed = false;
+        this.handledSessionRequestIds = new Set();
+        this.handledLogoutIds = new Set();
+        this.handledLoginIds = new Set();
+        this.pendingSessionRequests = new Map();
+        this.getCurrentSession = config.getCurrentSession ?? null;
+        this.onLogoutBroadcast = config.onLogoutBroadcast ?? null;
+        this.onLoginBroadcast = config.onLoginBroadcast ?? null;
+        this.logger = config.logger ?? null;
+        this.handleBroadcastMessage = this.handleBroadcastMessage.bind(this);
+        this.handleStorageMessage = this.handleStorageMessage.bind(this);
+        if (typeof BroadcastChannel !== 'undefined') {
+            this.channel = new BroadcastChannel(CHANNEL_NAME);
+            this.channel.onmessage = this.handleBroadcastMessage;
+        }
+        if (typeof window !== 'undefined') {
+            window.addEventListener('storage', this.handleStorageMessage);
+        }
+    }
+    publishLogout() {
+        this.publish({
+            type: 'logout',
+            senderTabId: this.tabId,
+            logoutId: createTabId(),
+            createdAt: Date.now(),
+        });
+    }
+    publishLogin(session) {
+        this.publish({
+            type: 'login',
+            senderTabId: this.tabId,
+            loginId: createTabId(),
+            createdAt: Date.now(),
+            session,
+        });
+    }
+    requestCurrentSession(timeoutMs = 500) {
+        if (this.closed) {
+            return Promise.resolve(null);
+        }
+        const requestId = createTabId();
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                this.pendingSessionRequests.delete(requestId);
+                resolve(null);
+            }, timeoutMs);
+            this.pendingSessionRequests.set(requestId, {
+                resolve,
+                timeout,
+            });
+            this.publish({
+                type: 'session-request',
+                senderTabId: this.tabId,
+                requestId,
+                createdAt: Date.now(),
+            });
+        });
+    }
+    destroy() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.pendingSessionRequests.forEach((request) => {
+            clearTimeout(request.timeout);
+            request.resolve(null);
+        });
+        this.pendingSessionRequests.clear();
+        if (this.channel) {
+            this.channel.close();
+            this.channel = null;
+        }
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('storage', this.handleStorageMessage);
+        }
+    }
+    publish(message) {
+        if (this.closed) {
+            return;
+        }
+        if (this.channel) {
+            this.channel.postMessage(message);
+        }
+        // Never persist messages that contain secretKey to localStorage.
+        if (message.type === 'session-response' || message.type === 'login') {
+            return;
+        }
+        if (typeof localStorage !== 'undefined') {
+            try {
+                localStorage.setItem(STORAGE_KEY, JSON.stringify({
+                    ...message,
+                    storageNonce: createTabId(),
+                }));
+            }
+            catch (e) {
+                this.logger?.warn('TabSessionCoordinator storage publish failed', e);
+            }
+        }
+    }
+    handleBroadcastMessage(event) {
+        this.handleMessage(event.data);
+    }
+    handleStorageMessage(event) {
+        if (event.key !== STORAGE_KEY || !event.newValue) {
+            return;
+        }
+        try {
+            this.handleMessage(JSON.parse(event.newValue));
+        }
+        catch (e) {
+            this.logger?.warn('TabSessionCoordinator storage parse failed', e);
+        }
+    }
+    handleMessage(message) {
+        if (this.closed || !isCoordinatorMessage(message)) {
+            return;
+        }
+        if (message.senderTabId === this.tabId) {
+            return;
+        }
+        if (message.type === 'logout') {
+            if (this.handledLogoutIds.has(message.logoutId)) {
+                return;
+            }
+            this.handledLogoutIds.add(message.logoutId);
+            void this.onLogoutBroadcast?.();
+            return;
+        }
+        if (message.type === 'login') {
+            if (this.handledLoginIds.has(message.loginId)) {
+                return;
+            }
+            this.handledLoginIds.add(message.loginId);
+            void this.onLoginBroadcast?.(message.session);
+            return;
+        }
+        if (message.type === 'session-request') {
+            const sessionRequestKey = `${message.senderTabId}:${message.requestId}`;
+            if (this.handledSessionRequestIds.has(sessionRequestKey)) {
+                return;
+            }
+            this.handledSessionRequestIds.add(sessionRequestKey);
+            const session = this.getCurrentSession?.();
+            if (!session) {
+                return;
+            }
+            this.publish({
+                type: 'session-response',
+                senderTabId: this.tabId,
+                requesterTabId: message.senderTabId,
+                requestId: message.requestId,
+                createdAt: Date.now(),
+                session,
+            });
+            return;
+        }
+        if (message.type === 'session-response') {
+            if (message.requesterTabId !== this.tabId) {
+                return;
+            }
+            const pendingRequest = this.pendingSessionRequests.get(message.requestId);
+            if (!pendingRequest) {
+                return;
+            }
+            clearTimeout(pendingRequest.timeout);
+            this.pendingSessionRequests.delete(message.requestId);
+            pendingRequest.resolve(message.session);
+        }
+    }
+}

package/dist-test/modules/Version.js

@@ -0,0 +1,20 @@
+export default class Version {
+    constructor() {
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.version = 0;
+    }
+    increment() {
+        this.version++;
+    }
+    get() {
+        return this.version;
+    }
+    check(curVersion) {
+        return curVersion === this.version;
+    }
+}

package/dist-test/utils/date.js

@@ -0,0 +1,4 @@
+export function getCurrentISOString() {
+    const d = new Date();
+    return d.toISOString();
+}

package/dist-test/utils/http.js

@@ -0,0 +1,13 @@
+export function createErrorResponse(code, msg) {
+    return {
+        ok: false,
+        code,
+        msg,
+    };
+}
+export function createOkResponse(data) {
+    return {
+        ok: true,
+        data,
+    };
+}

package/dist-test/utils/makeSign.js

@@ -0,0 +1,79 @@
+import CryptoJS from 'crypto-js';
+/**
+ * 将字符串转换为 ArrayBuffer
+ * @param str 输入字符串
+ * @returns ArrayBuffer
+ */
+function stringToArrayBuffer(str) {
+    return new TextEncoder().encode(str).buffer;
+}
+async function generateSignatureWebCrypto(message, secretKey) {
+    const keyBuffer = stringToArrayBuffer(secretKey);
+    const messageBuffer = stringToArrayBuffer(message);
+    // 导入密钥
+    const key = await crypto.subtle.importKey('raw', keyBuffer, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign']);
+    // 生成签名
+    const signature = await crypto.subtle.sign('HMAC', key, messageBuffer);
+    // 转换签名为十六进制字符串
+    return Array.from(new Uint8Array(signature))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * 使用 CryptoJS 生成 HMAC 签名（降级方案）
+ * @param message 待签名的消息
+ * @param secretKey 密钥
+ * @returns 签名字符串（十六进制格式）
+ */
+function generateSignatureCryptoJS(message, secretKey) {
+    const hash = CryptoJS.HmacSHA256(message, secretKey);
+    return hash.toString(CryptoJS.enc.Hex);
+}
+/**
+ * 生成 HMAC 签名（兼容降级）
+ * @param message 待签名的消息
+ * @returns 签名字符串（十六进制格式）
+ */
+async function generateSignature(message, secretKey) {
+    if (window.crypto && window.crypto.subtle) {
+        // 优先使用 Web Crypto API
+        return await generateSignatureWebCrypto(message, secretKey);
+    }
+    // 降级到 CryptoJS
+    return generateSignatureCryptoJS(message, secretKey);
+}
+const sortedJSON = (obj) => {
+    if (obj === null || obj === undefined) {
+        return '';
+    }
+    if (typeof obj === 'object' && !Array.isArray(obj)) {
+        // 处理对象 (map)
+        const keys = Object.keys(obj).sort(); // 对键进行字典序排序
+        let str = '';
+        for (const key of keys) {
+            str += sortedJSON(obj[key]);
+        }
+        return str;
+    }
+    else if (Array.isArray(obj)) {
+        // 处理数组
+        let str = '';
+        for (const item of obj) {
+            str += sortedJSON(item);
+        }
+        return str;
+    }
+    else if (typeof obj === 'string') {
+        // 处理字符串
+        return obj;
+    }
+    else {
+        // 处理其他基础类型 (数字、布尔值等)
+        return String(obj);
+    }
+};
+const makeSign = async (data, secretKey) => {
+    const message = await sortedJSON(data);
+    return await generateSignature(message, secretKey);
+};
+export default makeSign;

package/dist-test/utils/message.js

@@ -0,0 +1,146 @@
+import { RequestDirection } from '../enums/index.js';
+import { jsonParse } from './misc.js';
+export const makePositions = (config) => {
+    const positions = [];
+    if (config.direction === RequestDirection.up) {
+        let curPosition = config.startPosition ?? config.maxPosition;
+        while (positions.length < config.limit &&
+            curPosition >= config.minPosition) {
+            positions.push(curPosition);
+            curPosition--;
+        }
+        const hasMore = curPosition >= config.minPosition;
+        let nextPosition = undefined;
+        if (hasMore) {
+            nextPosition = curPosition;
+        }
+        return {
+            positions,
+            nextPosition,
+            hasMore,
+        };
+    }
+    else {
+        let curPosition = config.startPosition ?? config.minPosition;
+        while (positions.length < config.limit &&
+            curPosition <= config.maxPosition) {
+            positions.push(curPosition);
+            curPosition++;
+        }
+        const hasMore = curPosition <= config.maxPosition;
+        let nextPosition = undefined;
+        if (hasMore) {
+            nextPosition = curPosition;
+        }
+        return {
+            positions,
+            nextPosition,
+            hasMore,
+        };
+    }
+};
+export const stringifyCustomMessageContent = (payload) => {
+    return JSON.stringify({
+        client_msg_id: payload.client_msg_id,
+        content: JSON.stringify(payload.content),
+    });
+};
+/**
+ * 解析message_type_id为MessageType.custom的消息内容
+ */
+export const parseCustomMessageContent = (str) => {
+    const json = jsonParse(str);
+    if (json !== null) {
+        let parsedContent = undefined;
+        if (json.content != null) {
+            parsedContent = jsonParse(json.content) ?? undefined;
+        }
+        return {
+            client_msg_id: json.client_msg_id,
+            content: parsedContent,
+        };
+    }
+    return {};
+};
+/**
+ * 解析message_kind_id为MessageKind.system，message_type_id为MessageType.text的消息内容
+ */
+export const parseSystemMessageContent = (str) => {
+    const json = jsonParse(str);
+    if (json !== null) {
+        return {
+            text: json.text,
+            text_i18n: json.text_i18n,
+        };
+    }
+    return {};
+};
+/**
+ * 解析message_kind_id为MessageKind.text，message_type_id为MessageType.text的消息内容
+ */
+export const parseTextMessageContent = (str) => {
+    const json = jsonParse(str);
+    if (json !== null) {
+        return {
+            text: json.text,
+            client_msg_id: json.client_msg_id,
+        };
+    }
+    return {};
+};
+const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * 向URL添加查询参数
+ * @param url
+ * @param key
+ * @param value
+ * @returns
+ */
+export const appendQueryParam = (url, key, value) => {
+    const encodedKey = encodeURIComponent(key);
+    const encodedValue = encodeURIComponent(value);
+    const hashIndex = url.indexOf('#');
+    const baseUrl = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+    const hash = hashIndex >= 0 ? url.slice(hashIndex) : '';
+    const existsReg = new RegExp(`([?&])${escapeRegExp(encodedKey)}=[^&#]*`);
+    if (existsReg.test(baseUrl)) {
+        return baseUrl.replace(existsReg, `$1${encodedKey}=${encodedValue}`) + hash;
+    }
+    const separator = baseUrl.includes('?') ? '&' : '?';
+    return `${baseUrl}${separator}${encodedKey}=${encodedValue}${hash}`;
+};
+/**
+ * 按域名匹配 JSON 字符串中的 URL
+ * 同时支持：
+ * - https://api-coco.typex.im/...
+ * - https:\/\/api-coco.typex.im\/...
+ */
+export const createDomainUrlRegex = (domain) => new RegExp(`https?:\\\\?/\\\\?/${escapeRegExp(domain)}(?:\\\\.|[^"\\\\\\s])*`, 'g');
+const decodeJsonString = (encoded) => {
+    try {
+        return JSON.parse(`"${encoded}"`);
+    }
+    catch {
+        return encoded;
+    }
+};
+const encodeJsonString = (decoded) => {
+    return JSON.stringify(decoded).slice(1, -1);
+};
+/**
+ * 替换消息 content(JSON 字符串)里指定域名的 URL
+ */
+export const replaceDomainUrlsInContent = (content, domain, replaceUrl) => {
+    if (!content || typeof content !== 'string') {
+        return content;
+    }
+    const regex = createDomainUrlRegex(domain);
+    return content.replace(regex, (rawUrl) => {
+        const currentUrl = decodeJsonString(rawUrl);
+        const nextUrl = replaceUrl(currentUrl);
+        if (typeof nextUrl !== 'string' || nextUrl === currentUrl) {
+            return rawUrl;
+        }
+        return encodeJsonString(nextUrl);
+    });
+};

package/dist-test/utils/misc.js

@@ -0,0 +1,13 @@
+export const jsonParse = (content) => {
+    try {
+        if (content == null ||
+            typeof content !== 'string' ||
+            content.length === 0) {
+            return null;
+        }
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+};

package/dist-test/utils/promise.js

@@ -0,0 +1,10 @@
+export const withResolvers = () => {
+    let resolver = () => { };
+    const promise = new Promise((resolve) => {
+        resolver = resolve;
+    });
+    return {
+        promise,
+        resolve: resolver,
+    };
+};

package/dist-test/utils/sleep.js

@@ -0,0 +1,3 @@
+export default (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};

package/dist-test/utils/websocket.js

@@ -0,0 +1,24 @@
+export const WEBSOCKET_AUTH_PROTOCOL = 'typex.im.auth.v1';
+export function encodeTokenForWebSocketProtocol(token) {
+    const bytes = new TextEncoder().encode(token);
+    let binary = '';
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary)
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+}
+export function buildWebSocketAuthProtocols(token) {
+    return [
+        WEBSOCKET_AUTH_PROTOCOL,
+        `typex.im.auth.b64url.${encodeTokenForWebSocketProtocol(token)}`,
+    ];
+}
+export function buildWebSocketConnectUrl(url, options = {}) {
+    const wsUrl = new URL(url);
+    wsUrl.searchParams.set('platform', options.platform ?? 'web');
+    wsUrl.searchParams.set('ws_route', options.wsRoute ?? '');
+    return wsUrl.toString();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typexim/web-sdk",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "private": false,
   "repository": {
     "type": "git",