@typexim/web-sdk 0.0.6 → 0.0.8-alpha.1

package/dist-test/modules/FeedCache.js

@@ -0,0 +1,211 @@
+import { FeedType } from '../enums/index.js';
+import { withResolvers } from '../utils/promise.js';
+export default class FeedCache {
+    constructor() {
+        Object.defineProperty(this, "syncCompleted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // feed_id -> Feed
+        Object.defineProperty(this, "map", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // chat_id -> feed_id
+        Object.defineProperty(this, "chatMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // thread_id -> feed_id
+        Object.defineProperty(this, "threadMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // target_id -> feed_id
+        Object.defineProperty(this, "targetMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "list", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "waitMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.syncCompleted = false;
+        this.map = new Map();
+        this.chatMap = new Map();
+        this.threadMap = new Map();
+        this.targetMap = new Map();
+        this.waitMap = new Map();
+        this.list = [];
+    }
+    getAll() {
+        const result = [];
+        for (const id of this.list) {
+            const feed = this.map.get(id);
+            if (feed) {
+                result.push(feed);
+            }
+        }
+        return result;
+    }
+    get(feedId) {
+        return this.map.get(feedId) ?? null;
+    }
+    getByChat(chatId, threadId) {
+        let feedId;
+        if (threadId && threadId !== '0') {
+            feedId = this.threadMap.get(threadId);
+        }
+        else {
+            feedId = this.chatMap.get(chatId);
+        }
+        if (feedId !== undefined) {
+            return this.get(feedId);
+        }
+        return null;
+    }
+    getByTargetId(targetId) {
+        const set = this.targetMap.get(targetId);
+        if (set === undefined) {
+            return [];
+        }
+        const list = [];
+        for (const id of set) {
+            const feed = this.get(id);
+            if (feed !== null) {
+                list.push(feed);
+            }
+        }
+        return list;
+    }
+    async waitFor(feedId) {
+        const feed = this.get(feedId);
+        if (feed) {
+            return feed;
+        }
+        if (this.syncCompleted) {
+            return null;
+        }
+        let resolver = this.waitMap.get(feedId);
+        if (!resolver) {
+            resolver = withResolvers();
+            this.waitMap.set(feedId, resolver);
+        }
+        await resolver.promise;
+        return this.get(feedId);
+    }
+    resolveWait(feedId) {
+        const resolver = this.waitMap.get(feedId);
+        if (resolver) {
+            resolver.resolve();
+            this.waitMap.delete(feedId);
+        }
+    }
+    removeFromList(feedId) {
+        const index = this.list.indexOf(feedId);
+        if (index > -1) {
+            this.list.splice(index, 1);
+        }
+    }
+    remove(feedId) {
+        const feed = this.map.get(feedId);
+        if (feed) {
+            this.map.delete(feedId);
+            if (feed.feed_type === FeedType.thread) {
+                this.threadMap.delete(feed.thread_id);
+            }
+            else {
+                this.chatMap.delete(feed.chat_id);
+                if (feed.target_id && feed.target_id !== '0') {
+                    const set = this.targetMap.get(feed.target_id);
+                    if (set !== undefined) {
+                        set.delete(feed.id);
+                        if (set.size === 0) {
+                            this.targetMap.delete(feed.target_id);
+                        }
+                    }
+                }
+            }
+            this.removeFromList(feedId);
+            return true;
+        }
+        return false;
+    }
+    beforeSave(feed) {
+        if (this.map.has(feed.id)) {
+            this.removeFromList(feed.id);
+        }
+        else {
+            if (feed.feed_type === FeedType.thread) {
+                this.threadMap.set(feed.thread_id, feed.id);
+            }
+            else {
+                this.chatMap.set(feed.chat_id, feed.id);
+                if (feed.target_id && feed.target_id !== '0') {
+                    if (!this.targetMap.has(feed.target_id)) {
+                        const set = new Set();
+                        this.targetMap.set(feed.target_id, set);
+                    }
+                    this.targetMap.get(feed.target_id)?.add(feed.id);
+                }
+            }
+        }
+        this.map.set(feed.id, feed);
+    }
+    afterSave(feed) {
+        this.resolveWait(feed.id);
+    }
+    push(feed) {
+        this.beforeSave(feed);
+        this.list.push(feed.id);
+        this.afterSave(feed);
+    }
+    unshift(feed) {
+        this.beforeSave(feed);
+        this.list.unshift(feed.id);
+        this.afterSave(feed);
+    }
+    update(feed) {
+        if (!this.map.has(feed.id)) {
+            return;
+        }
+        this.map.set(feed.id, feed);
+    }
+    markSyncComplete() {
+        this.syncCompleted = true;
+        for (const [_, resolver] of this.waitMap) {
+            resolver.resolve();
+        }
+        this.waitMap.clear();
+    }
+    isSyncCompleted() {
+        return this.syncCompleted;
+    }
+    reset() {
+        this.syncCompleted = false;
+        this.map.clear();
+        this.chatMap.clear();
+        this.threadMap.clear();
+        this.targetMap.clear();
+        this.waitMap.clear();
+        this.list = [];
+    }
+}

package/dist-test/modules/HttpClient.js

@@ -0,0 +1,104 @@
+import axios from 'axios';
+import { HttpClientResponseCode } from '../enums/index.js';
+import { createErrorResponse } from '../utils/http.js';
+import makeSign from '../utils/makeSign.js';
+function createMakeSignErrorResponse() {
+    return createErrorResponse(HttpClientResponseCode.MAKE_SIGN_FAIL, 'make sign fail');
+}
+export default class HttpClient {
+    constructor(config) {
+        Object.defineProperty(this, "api", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.api = axios.create({
+            baseURL: config.host,
+            headers: {
+                'x-developer': config.developer,
+            },
+            withCredentials: true,
+        });
+        this.context = config.context;
+        this.logger = config.logger;
+    }
+    async request(config) {
+        try {
+            const { needSign = true, ...axiosConfig } = config;
+            if (!axiosConfig.headers) {
+                axiosConfig.headers = {};
+            }
+            axiosConfig.headers['platform'] = 'web';
+            if (needSign &&
+                config.method?.toUpperCase() === 'POST' &&
+                axiosConfig.data) {
+                if (this.context.loginUser === null) {
+                    this.logger.warn('HttpClient needs make sign but not login');
+                    return createMakeSignErrorResponse();
+                }
+                try {
+                    const sign = await makeSign(axiosConfig.data, this.context.loginUser.secretKey);
+                    axiosConfig.headers['sign'] = sign;
+                }
+                catch (e) {
+                    this.logger.error('HttpClient make sign error', e);
+                    return createMakeSignErrorResponse();
+                }
+            }
+            if (this.context.loginUser) {
+                axiosConfig.headers['X-Sid'] = this.context.loginUser.sessionId;
+            }
+            const res = await this.api(axiosConfig);
+            const body = res.data;
+            if (body.code === HttpClientResponseCode.SUCCESS) {
+                return {
+                    ok: true,
+                    data: body.data,
+                };
+            }
+            this.logger.info('HttpClient server error', res);
+            return {
+                ok: false,
+                code: body.code,
+                msg: body.msg,
+                msg_i18n: body.msg_i18n,
+            };
+        }
+        catch {
+            return {
+                ok: false,
+                code: HttpClientResponseCode.NETWORK_ERROR,
+                msg: 'network error',
+            };
+        }
+    }
+    get(url, params, config) {
+        return this.request({
+            url,
+            method: 'GET',
+            params,
+            ...config,
+        });
+    }
+    post(url, data, config) {
+        return this.request({
+            url,
+            method: 'POST',
+            data,
+            ...config,
+        });
+    }
+}

package/dist-test/modules/Logger.js

@@ -0,0 +1,73 @@
+import { LogLevel } from '../enums/index.js';
+function padNumStart(num) {
+    return `${num}`.padStart(2, '0');
+}
+export default class Logger {
+    constructor() {
+        Object.defineProperty(this, "level", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.level = LogLevel.error;
+        this.logHandler = this.createLogHandler();
+    }
+    getPriority(level) {
+        switch (level) {
+            case LogLevel.error:
+                return 3;
+            case LogLevel.warning:
+                return 2;
+            case LogLevel.info:
+                return 1;
+            default:
+                return 0;
+        }
+    }
+    createLogHandler() {
+        return (level, ...args) => {
+            const date = new Date();
+            const timestamp = `${date.getFullYear()}-${padNumStart(date.getMonth() + 1)}-${padNumStart(date.getDate())} ${padNumStart(date.getHours())}:${padNumStart(date.getMinutes())}:${padNumStart(date.getSeconds())}.${date.getMilliseconds()}`;
+            const prefix = `TypeX >> [${timestamp}]`;
+            switch (level) {
+                case LogLevel.error:
+                    console.error(prefix, '[ERR]', ...args);
+                    break;
+                case LogLevel.warning:
+                    console.warn(prefix, '[WARN]', ...args);
+                    break;
+                case LogLevel.info:
+                    console.info(prefix, '[INFO]', ...args);
+                    break;
+                default:
+                    console.log(prefix, ...args);
+            }
+        };
+    }
+    log(level, ...args) {
+        if (this.getPriority(level) >= this.getPriority(this.level)) {
+            this.logHandler(level, ...args);
+        }
+    }
+    setLogLevel(level) {
+        this.level = level;
+        // 重新创建logHandler以确保使用新的日志级别
+        this.logHandler = this.createLogHandler();
+    }
+    info(...args) {
+        this.log(LogLevel.info, ...args);
+    }
+    warn(...args) {
+        this.log(LogLevel.warning, ...args);
+    }
+    error(...args) {
+        this.log(LogLevel.error, ...args);
+    }
+}