@pluve/logger-sdk 0.0.1 → 0.0.3

package/lib/loggerSDK.js

@@ -0,0 +1,571 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import IDBQueue from './dbQueue';
+import { defaultTransport } from './transportAdapter';
+import { isBrowser, isIndexedDBAvailable, isWeChatMiniProgram, now, safeStringify } from './utils';
+import { browserStorage, wechatStorage } from './storeAdapter';
+var LoggerSDK = /** @class */ (function () {
+    function LoggerSDK(options) {
+        var _this = this;
+        this.inMemoryQueue = [];
+        this.seq = 0;
+        this.timerId = null;
+        this.storage = null;
+        this.closed = false;
+        this.idbQueue = null;
+        this.flushing = false;
+        var defaults = {
+            endpoints: options.endpoints || {},
+            appId: options.appId || '',
+            env: options.env ||
+                (function () {
+                    if (isWeChatMiniProgram())
+                        return 'wechat';
+                    if (isBrowser())
+                        return 'h5';
+                    return 'unknown';
+                })(),
+            batchSize: options.batchSize || 10,
+            flushInterval: options.flushInterval || 5000,
+            retryCount: options.retryCount || 3,
+            retryBase: options.retryBase || 300,
+            storageKey: options.storageKey || 'logger_sdk_cache_v2',
+            maxCacheSize: options.maxCacheSize || 2000,
+            timeout: options.timeout || 10000,
+            debug: !!options.debug,
+            transport: options.transport || defaultTransport,
+            globalHeaders: options.globalHeaders || {},
+            enableAutoPV: options.enableAutoPV !== false,
+            enablePerf: options.enablePerf !== false,
+            usePixel: options.usePixel || false,
+            pixelParam: options.pixelParam || 'data',
+            maxPixelUrlLen: options.maxPixelUrlLen || 1900,
+        };
+        this.opts = Object.assign(defaults, options);
+        this.env = this.opts.env;
+        // choose storage
+        if (this.env === 'wechat')
+            this.storage = wechatStorage(this.opts.storageKey);
+        else if (this.env === 'h5')
+            this.storage = browserStorage(this.opts.storageKey);
+        else
+            this.storage = null;
+        // idb queue
+        if (isBrowser() && isIndexedDBAvailable()) {
+            this.idbQueue = new IDBQueue('logger_sdk_db', 'queue');
+            this.idbQueue.open().catch(function () {
+                _this.idbQueue = null;
+            });
+        }
+        // load existing persisted items (localStorage)
+        this.loadFromStorage().then(function () {
+            if (_this.opts.flushInterval > 0)
+                _this.startTimer();
+        });
+        // attach error handlers
+        this.attachGlobalHandlers();
+        // auto PV
+        if (this.opts.enableAutoPV && this.env === 'h5')
+            this.installAutoPV();
+        // collect perf once on load
+        if (this.opts.enablePerf && this.env === 'h5') {
+            if (document.readyState === 'complete')
+                this.collectPerf();
+            else
+                window.addEventListener('load', function () { return _this.collectPerf(); });
+        }
+    }
+    LoggerSDK.prototype.logDebug = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.opts.debug)
+            console.debug.apply(console, __spreadArray(['[LoggerSDK]'], args, false));
+    };
+    LoggerSDK.prototype.loadFromStorage = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var raw, arr, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.storage)
+                            return [2 /*return*/];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.storage.get()];
+                    case 2:
+                        raw = _a.sent();
+                        if (raw) {
+                            arr = JSON.parse(raw);
+                            this.inMemoryQueue = arr.concat(this.inMemoryQueue).slice(-this.opts.maxCacheSize);
+                            this.logDebug('loaded persisted queue', this.inMemoryQueue.length);
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        this.logDebug('load persisted fail', e_1);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LoggerSDK.prototype.persistToStorage = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var e_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.storage)
+                            return [2 /*return*/];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.storage.set(safeStringify(this.inMemoryQueue))];
+                    case 2:
+                        _a.sent();
+                        this.logDebug('persisted queue', this.inMemoryQueue.length);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_2 = _a.sent();
+                        this.logDebug('persist fail', e_2);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LoggerSDK.prototype.startTimer = function () {
+        var _this = this;
+        if (this.timerId)
+            return;
+        this.timerId = setInterval(function () { return _this.flush().catch(function () { }); }, this.opts.flushInterval);
+    };
+    LoggerSDK.prototype.stopTimer = function () {
+        if (!this.timerId)
+            return;
+        clearInterval(this.timerId);
+        this.timerId = null;
+    };
+    // 将事件入队（先到内存，再持久化）
+    LoggerSDK.prototype.track = function (event, headers) {
+        return __awaiter(this, void 0, void 0, function () {
+            var e, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.closed)
+                            return [2 /*return*/];
+                        this.seq += 1;
+                        e = {
+                            type: event.type || 'custom',
+                            time: event.time || now(),
+                            user: event.user || undefined,
+                            ctx: event.ctx || {},
+                            level: event.level || 'info',
+                            seq: this.seq,
+                        };
+                        this.inMemoryQueue.push(e);
+                        this.logDebug('enqueue', e);
+                        // persist to local storage
+                        return [4 /*yield*/, this.persistToStorage()];
+                    case 1:
+                        // persist to local storage
+                        _a.sent();
+                        if (!this.idbQueue) return [3 /*break*/, 5];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.idbQueue.add(e)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        this.logDebug('idb add fail', err_1);
+                        return [3 /*break*/, 5];
+                    case 5:
+                        if (!(this.inMemoryQueue.length >= this.opts.batchSize)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.flush(headers).catch(function () { })];
+                    case 6:
+                        _a.sent();
+                        _a.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // flush：从队列中取一批发送（按 level 分 endpoint，支持部分成功剔除）
+    LoggerSDK.prototype.flush = function (extraHeaders) {
+        return __awaiter(this, void 0, void 0, function () {
+            var batch, groups_1, delay_1, sendGroup_1, results, successLevels_1, allOk, removeSeq_1, e_3;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.closed)
+                            return [2 /*return*/];
+                        if (this.inMemoryQueue.length === 0)
+                            return [2 /*return*/];
+                        if (this.flushing)
+                            return [2 /*return*/];
+                        this.flushing = true;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 8, 9]);
+                        batch = this.inMemoryQueue.slice(0, this.opts.batchSize);
+                        groups_1 = {};
+                        batch.forEach(function (ev) {
+                            var level = (ev.level || 'info');
+                            (groups_1[level] = groups_1[level] || []).push(ev);
+                        });
+                        delay_1 = function (ms) { return new Promise(function (r) { return setTimeout(r, ms); }); };
+                        sendGroup_1 = function (level, events) {
+                            var endpoint = _this.opts.endpoints[level] || _this.opts.endpoints.default;
+                            var payload = { appId: _this.opts.appId, env: _this.env, ts: now(), level: level, events: events };
+                            var maxTry = _this.opts.retryCount;
+                            var attemptOnce = function (attempt) {
+                                var transportOpts = __assign(__assign({}, _this.opts), { endpoint: endpoint, headers: __assign(__assign({}, (_this.opts.globalHeaders || {})), (extraHeaders || {})) });
+                                return _this.opts.transport(payload, transportOpts)
+                                    .then(function () { return true; })
+                                    .catch(function (err) { return __awaiter(_this, void 0, void 0, function () {
+                                    var next, wait;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                next = attempt + 1;
+                                                this.logDebug('send fail', level, next, err);
+                                                if (next > maxTry)
+                                                    return [2 /*return*/, false];
+                                                wait = (this.opts.retryBase || 300) * Math.pow(2, (next - 1));
+                                                return [4 /*yield*/, delay_1(wait)];
+                                            case 1:
+                                                _a.sent();
+                                                return [2 /*return*/, attemptOnce(next)];
+                                        }
+                                    });
+                                }); });
+                            };
+                            return attemptOnce(0).then(function (ok) { return ({ ok: ok, level: level, events: events }); });
+                        };
+                        return [4 /*yield*/, Promise.all(Object.keys(groups_1).map(function (level) { return sendGroup_1(level, groups_1[level]); }))];
+                    case 2:
+                        results = _a.sent();
+                        successLevels_1 = new Set(results.filter(function (r) { return r.ok; }).map(function (r) { return r.level; }));
+                        allOk = results.length > 0 && results.every(function (r) { return r.ok; });
+                        if (!allOk && successLevels_1.size === 0) {
+                            // 全部失败：保留队列，等待下次重试
+                            this.logDebug('batch send failed, keep batch in queue');
+                            return [2 /*return*/];
+                        }
+                        removeSeq_1 = new Set(batch.filter(function (e) { return successLevels_1.has((e.level || 'info')); }).map(function (e) { return e.seq; }));
+                        this.inMemoryQueue = this.inMemoryQueue.filter(function (x) { return !removeSeq_1.has(x.seq); });
+                        return [4 /*yield*/, this.persistToStorage()];
+                    case 3:
+                        _a.sent();
+                        if (!(allOk && this.idbQueue)) return [3 /*break*/, 7];
+                        _a.label = 4;
+                    case 4:
+                        _a.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, this.idbQueue.clear()];
+                    case 5:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 6:
+                        e_3 = _a.sent();
+                        this.logDebug('idb clear fail', e_3);
+                        return [3 /*break*/, 7];
+                    case 7: return [3 /*break*/, 9];
+                    case 8:
+                        this.flushing = false;
+                        return [7 /*endfinally*/];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // 将队列尽力全部发送（分批轮询 + 安全阈值）
+    LoggerSDK.prototype.flushAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var safety;
+            var _this = this;
+            return __generator(this, function (_a) {
+                safety = 0;
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var tick = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        // 安全阈值，避免异常情况下无限循环
+                                        safety += 1;
+                                        if (this.inMemoryQueue.length === 0 || safety >= 200)
+                                            return [2 /*return*/, resolve()];
+                                        if (!!this.flushing) return [3 /*break*/, 4];
+                                        _b.label = 1;
+                                    case 1:
+                                        _b.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, this.flush()];
+                                    case 2:
+                                        _b.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        _a = _b.sent();
+                                        return [3 /*break*/, 4];
+                                    case 4:
+                                        setTimeout(tick, 50);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        tick();
+                    })];
+            });
+        });
+    };
+    LoggerSDK.prototype.identify = function (user) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.opts.appId = (user && user.appId) || this.opts.appId;
+                this.logDebug('identify', user);
+                return [2 /*return*/];
+            });
+        });
+    };
+    LoggerSDK.prototype.setCommon = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                Object.assign(this.opts, params);
+                this.logDebug('setCommon', params);
+                return [2 /*return*/];
+            });
+        });
+    };
+    LoggerSDK.prototype.destroy = function () {
+        this.stopTimer();
+        this.closed = true;
+    };
+    // ========== 自动采集与错误处理 ===========
+    LoggerSDK.prototype.attachGlobalHandlers = function () {
+        var _this = this;
+        if (this.env === 'h5' && typeof window !== 'undefined') {
+            var win = window;
+            // JS 错误
+            win.addEventListener &&
+                win.addEventListener('error', function (ev) {
+                    try {
+                        _this.track({ type: 'error', level: 'error', ctx: { message: ev.message, filename: ev.filename, lineno: ev.lineno, colno: ev.colno, stack: ev.error && ev.error.stack } });
+                    }
+                    catch (_a) {
+                        //
+                    }
+                });
+            // Promise 未捕获
+            win.addEventListener &&
+                win.addEventListener('unhandledrejection', function (ev) {
+                    try {
+                        _this.track({ type: 'error', level: 'error', ctx: { reason: ev.reason && (ev.reason.stack || ev.reason) } });
+                    }
+                    catch (_a) {
+                        //
+                    }
+                });
+            // Resource 加载错误（img/script/link）
+            win.addEventListener &&
+                win.addEventListener('error', function (ev) {
+                    if (ev.target && (ev.target.src || ev.target.href)) {
+                        try {
+                            _this.track({ type: 'error', level: 'warn', ctx: { resource: ev.target.src || ev.target.href, tag: ev.target.tagName } });
+                        }
+                        catch (_a) {
+                            //
+                        }
+                    }
+                }, true);
+            document.addEventListener &&
+                document.addEventListener('visibilitychange', function () {
+                    try {
+                        if (document.visibilityState === 'hidden')
+                            _this.flushBeacon();
+                    }
+                    catch (_a) {
+                        //
+                    }
+                });
+            win.addEventListener &&
+                win.addEventListener('pagehide', function () {
+                    try {
+                        _this.flushBeacon();
+                    }
+                    catch (_a) {
+                        //
+                    }
+                });
+            win.addEventListener &&
+                win.addEventListener('beforeunload', function () {
+                    try {
+                        _this.flushBeacon();
+                    }
+                    catch (_a) {
+                        //
+                    }
+                });
+        }
+    };
+    // 自动 PV（single-page 支持简单的 history 池监听）
+    LoggerSDK.prototype.installAutoPV = function () {
+        var _this = this;
+        // 仅在浏览器环境安装 PV 监听，避免 SSR/Node 触发 window 访问错误
+        if (!isBrowser())
+            return;
+        var history = window.history, location = window.location;
+        var pushState = history.pushState;
+        var replaceState = history.replaceState;
+        var onUrlChange = function () {
+            try {
+                _this.track({ type: 'pageview', level: 'info', ctx: { path: location.pathname + location.search, title: document.title } });
+            }
+            catch (_a) {
+                //
+            }
+        };
+        // 包装原生 history 方法，正确转发所有参数并派发自定义事件
+        history.pushState = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            // @ts-ignore
+            pushState.apply(this, args);
+            window.dispatchEvent(new Event('locationchange'));
+        };
+        history.replaceState = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            // @ts-ignore
+            replaceState.apply(this, args);
+            window.dispatchEvent(new Event('locationchange'));
+        };
+        window.addEventListener('popstate', function () { return window.dispatchEvent(new Event('locationchange')); });
+        window.addEventListener('locationchange', onUrlChange);
+        // 首次 PV
+        onUrlChange();
+    };
+    // 性能采集（Navigation timing + Paint）
+    LoggerSDK.prototype.collectPerf = function () {
+        if (!isBrowser() || !('performance' in window))
+            return;
+        try {
+            var perf = window.performance;
+            var nav = perf.getEntriesByType && perf.getEntriesByType('navigation') && perf.getEntriesByType('navigation')[0];
+            var paints = perf.getEntriesByType ? perf.getEntriesByType('paint') : [];
+            var data_1 = {};
+            if (nav) {
+                data_1.ttfb = nav.responseStart - nav.requestStart;
+                data_1.domContentLoaded = nav.domContentLoadedEventEnd - nav.startTime;
+                data_1.load = nav.loadEventEnd - nav.startTime;
+            }
+            else if (perf.timing) {
+                var t = perf.timing;
+                data_1.ttfb = t.responseStart - t.requestStart;
+                data_1.domContentLoaded = t.domContentLoadedEventEnd - t.navigationStart;
+                data_1.load = t.loadEventEnd - t.navigationStart;
+            }
+            if (paints && paints.length) {
+                paints.forEach(function (p) {
+                    data_1[p.name] = p.startTime;
+                });
+            }
+            this.track({ type: 'perf', level: 'info', ctx: data_1 });
+        }
+        catch (e) {
+            this.logDebug('collect perf fail', e);
+        }
+    };
+    LoggerSDK.prototype.flushBeacon = function () {
+        var _this = this;
+        if (!isBrowser())
+            return;
+        if (this.inMemoryQueue.length === 0)
+            return;
+        var groups = {};
+        this.inMemoryQueue.forEach(function (ev) {
+            var level = (ev.level || 'info');
+            (groups[level] = groups[level] || []).push(ev);
+        });
+        Object.keys(groups).forEach(function (level) {
+            var events = groups[level];
+            var endpoint = _this.opts.endpoints[level] || _this.opts.endpoints.default;
+            var payload = { appId: _this.opts.appId, env: _this.env, ts: now(), level: level, events: events };
+            var transportOpts = __assign(__assign({}, _this.opts), { endpoint: endpoint, headers: __assign({}, (_this.opts.globalHeaders || {})), useBeacon: true, usePixel: _this.opts.usePixel, pixelParam: _this.opts.pixelParam, maxPixelUrlLen: _this.opts.maxPixelUrlLen });
+            try {
+                _this.opts.transport(payload, transportOpts);
+            }
+            catch (_a) {
+                //
+            }
+        });
+    };
+    return LoggerSDK;
+}());
+export { LoggerSDK };
+// 兼容导出（UMD/ESM）
+export default LoggerSDK;

package/lib/storeAdapter.js

@@ -0,0 +1,99 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// 浏览器环境：使用 localStorage 简单持久化
+export function browserStorage(key) {
+    return {
+        get: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, Promise.resolve(localStorage.getItem(key))];
+                });
+            });
+        },
+        set: function (val) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    localStorage.setItem(key, val);
+                    return [2 /*return*/, Promise.resolve()];
+                });
+            });
+        },
+        remove: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    localStorage.removeItem(key);
+                    return [2 /*return*/, Promise.resolve()];
+                });
+            });
+        },
+    };
+}
+// 微信小程序环境：封装 wx.*Storage API
+export function wechatStorage(key) {
+    return {
+        get: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, new Promise(function (res) {
+                            // @ts-ignore
+                            wx.getStorage({ key: key, success: function (r) { return res(r.data); }, fail: function () { return res(null); } });
+                        })];
+                });
+            });
+        },
+        set: function (val) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, new Promise(function (res) {
+                            // @ts-ignore
+                            wx.setStorage({ key: key, data: val, success: function () { return res(undefined); }, fail: function () { return res(undefined); } });
+                        })];
+                });
+            });
+        },
+        remove: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, new Promise(function (res) {
+                            // @ts-ignore
+                            wx.removeStorage({ key: key, success: function () { return res(undefined); }, fail: function () { return res(undefined); } });
+                        })];
+                });
+            });
+        },
+    };
+}