@cloudbase/utilities 1.4.2-alpha.0 → 1.8.1

package/dist/cjs/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpers = exports.utils = exports.events = exports.cache = exports.adapters = exports.constants = void 0;
+var constants = __importStar(require("./constants"));
+exports.constants = constants;
+var adapters = __importStar(require("./adapters"));
+exports.adapters = adapters;
+var cache = __importStar(require("./libs/cache"));
+exports.cache = cache;
+var events = __importStar(require("./libs/events"));
+exports.events = events;
+var utils = __importStar(require("./libs/util"));
+exports.utils = utils;
+var helpers = __importStar(require("./helpers"));
+exports.helpers = helpers;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxxREFBeUM7QUFRdkMsOEJBQVM7QUFQWCxtREFBdUM7QUFRckMsNEJBQVE7QUFQVixrREFBc0M7QUFRcEMsc0JBQUs7QUFQUCxvREFBd0M7QUFRdEMsd0JBQU07QUFQUixpREFBcUM7QUFRbkMsc0JBQUs7QUFQUCxpREFBcUM7QUFRbkMsMEJBQU8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBjb25zdGFudHMgZnJvbSAnLi9jb25zdGFudHMnO1xuaW1wb3J0ICogYXMgYWRhcHRlcnMgZnJvbSAnLi9hZGFwdGVycyc7XG5pbXBvcnQgKiBhcyBjYWNoZSBmcm9tICcuL2xpYnMvY2FjaGUnO1xuaW1wb3J0ICogYXMgZXZlbnRzIGZyb20gJy4vbGlicy9ldmVudHMnO1xuaW1wb3J0ICogYXMgdXRpbHMgZnJvbSAnLi9saWJzL3V0aWwnO1xuaW1wb3J0ICogYXMgaGVscGVycyBmcm9tICcuL2hlbHBlcnMnO1xuXG5leHBvcnQge1xuICBjb25zdGFudHMsXG4gIGFkYXB0ZXJzLFxuICBjYWNoZSxcbiAgZXZlbnRzLFxuICB1dGlscyxcbiAgaGVscGVycyxcbn07XG4iXX0=

package/dist/cjs/libs/cache.js

@@ -0,0 +1,338 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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;
+    return g = { next: verb(0), "throw": verb(1), "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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudbaseCache = void 0;
+var adapter_interface_1 = require("@cloudbase/adapter-interface");
+var util_1 = require("./util");
+var constants_1 = require("../constants");
+var TcbCacheObject = (function (_super) {
+    __extends(TcbCacheObject, _super);
+    function TcbCacheObject(root) {
+        var _this = _super.call(this) || this;
+        _this._root = root;
+        if (!root.tcbCacheObject) {
+            root.tcbCacheObject = {};
+        }
+        return _this;
+    }
+    TcbCacheObject.prototype.setItem = function (key, value) {
+        this._root.tcbCacheObject[key] = value;
+    };
+    TcbCacheObject.prototype.getItem = function (key) {
+        return this._root.tcbCacheObject[key];
+    };
+    TcbCacheObject.prototype.removeItem = function (key) {
+        delete this._root.tcbCacheObject[key];
+    };
+    TcbCacheObject.prototype.clear = function () {
+        delete this._root.tcbCacheObject;
+    };
+    return TcbCacheObject;
+}(adapter_interface_1.AbstractStorage));
+function createStorage(persistence, adapter) {
+    switch (persistence) {
+        case 'local':
+            if (!adapter.localStorage) {
+                (0, util_1.printWarn)(constants_1.ERRORS.INVALID_PARAMS, 'localStorage is not supported on current platform');
+                return new TcbCacheObject(adapter.root);
+            }
+            return adapter.localStorage;
+        case 'none':
+            return new TcbCacheObject(adapter.root);
+        case 'session':
+            if (!adapter.sessionStorage) {
+                (0, util_1.printWarn)(constants_1.ERRORS.INVALID_PARAMS, 'sessionStorage is not supported on current platform');
+                return new TcbCacheObject(adapter.root);
+            }
+            return adapter.sessionStorage;
+        default:
+            if (!adapter.localStorage) {
+                (0, util_1.printWarn)(constants_1.ERRORS.INVALID_PARAMS, 'localStorage is not supported on current platform');
+                return new TcbCacheObject(adapter.root);
+            }
+            return adapter.localStorage;
+    }
+}
+var CloudbaseCache = (function () {
+    function CloudbaseCache(config) {
+        this.keys = {};
+        var persistence = config.persistence, _a = config.platformInfo, platformInfo = _a === void 0 ? {} : _a, _b = config.keys, keys = _b === void 0 ? {} : _b, _c = config.alwaysLocalKeys, alwaysLocalKeys = _c === void 0 ? [] : _c;
+        this._platformInfo = platformInfo;
+        this._alwaysLocalKeys = alwaysLocalKeys;
+        if (!this._storage) {
+            this._persistence = platformInfo.adapter.primaryStorage || persistence;
+            this._storage = createStorage(this._persistence, platformInfo.adapter);
+            this.keys = keys;
+        }
+    }
+    Object.defineProperty(CloudbaseCache.prototype, "mode", {
+        get: function () {
+            return this._storage.mode || 'sync';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CloudbaseCache.prototype, "persistence", {
+        get: function () {
+            return this._persistence;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CloudbaseCache.prototype.updatePersistence = function (persistence) {
+        if (this.mode === 'async') {
+            (0, util_1.printWarn)(constants_1.ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use updatePersistenceAsync insteed');
+            return;
+        }
+        if (persistence === this._persistence) {
+            return;
+        }
+        var isCurrentLocal = this._persistence === 'local';
+        this._persistence = persistence;
+        var storage = createStorage(persistence, this._platformInfo.adapter);
+        for (var key in this.keys) {
+            var name_1 = this.keys[key];
+            if (isCurrentLocal && this._alwaysLocalKeys.includes(key)) {
+                continue;
+            }
+            var val = this._storage.getItem(name_1);
+            if (!(0, util_1.isUndefined)(val) && !(0, util_1.isNull)(val)) {
+                storage.setItem(name_1, val);
+                this._storage.removeItem(name_1);
+            }
+        }
+        this._storage = storage;
+    };
+    CloudbaseCache.prototype.updatePersistenceAsync = function (persistence) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isCurrentLocal, storage, _a, _b, _c, _i, key, name_2, val;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (persistence === this._persistence) {
+                            return [2];
+                        }
+                        isCurrentLocal = this._persistence === 'local';
+                        this._persistence = persistence;
+                        storage = createStorage(persistence, this._platformInfo.adapter);
+                        _a = this.keys;
+                        _b = [];
+                        for (_c in _a)
+                            _b.push(_c);
+                        _i = 0;
+                        _d.label = 1;
+                    case 1:
+                        if (!(_i < _b.length)) return [3, 5];
+                        _c = _b[_i];
+                        if (!(_c in _a)) return [3, 4];
+                        key = _c;
+                        name_2 = this.keys[key];
+                        if (isCurrentLocal && this._alwaysLocalKeys.includes(key)) {
+                            return [3, 4];
+                        }
+                        return [4, this._storage.getItem(name_2)];
+                    case 2:
+                        val = _d.sent();
+                        if (!(!(0, util_1.isUndefined)(val) && !(0, util_1.isNull)(val))) return [3, 4];
+                        storage.setItem(name_2, val);
+                        return [4, this._storage.removeItem(name_2)];
+                    case 3:
+                        _d.sent();
+                        _d.label = 4;
+                    case 4:
+                        _i++;
+                        return [3, 1];
+                    case 5:
+                        this._storage = storage;
+                        return [2];
+                }
+            });
+        });
+    };
+    CloudbaseCache.prototype.setStore = function (key, value, version) {
+        if (this.mode === 'async') {
+            (0, util_1.printWarn)(constants_1.ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use setStoreAsync insteed');
+            return;
+        }
+        if (!this._storage) {
+            return;
+        }
+        try {
+            var val = {
+                version: version || 'localCachev1',
+                content: value,
+            };
+            this._storage.setItem(key, JSON.stringify(val));
+        }
+        catch (e) {
+            throw new Error(JSON.stringify({
+                code: constants_1.ERRORS.OPERATION_FAIL,
+                msg: "[".concat((0, constants_1.getSdkName)(), "][").concat(constants_1.ERRORS.OPERATION_FAIL, "]setStore failed"),
+                info: e,
+            }));
+        }
+        return;
+    };
+    CloudbaseCache.prototype.setStoreAsync = function (key, value, version) {
+        return __awaiter(this, void 0, void 0, function () {
+            var val, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._storage) {
+                            return [2];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        val = {
+                            version: version || 'localCachev1',
+                            content: value,
+                        };
+                        return [4, this._storage.setItem(key, JSON.stringify(val))];
+                    case 2:
+                        _a.sent();
+                        return [3, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        return [2];
+                    case 4: return [2];
+                }
+            });
+        });
+    };
+    CloudbaseCache.prototype.getStore = function (key, version) {
+        var _a;
+        if (this.mode === 'async') {
+            (0, util_1.printWarn)(constants_1.ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use getStoreAsync insteed');
+            return;
+        }
+        try {
+            if (typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.tcb_token)) {
+                return process.env.tcb_token;
+            }
+            if (!this._storage) {
+                return '';
+            }
+        }
+        catch (e) {
+            return '';
+        }
+        version = version || 'localCachev1';
+        var content = this._storage.getItem(key);
+        if (!content) {
+            return '';
+        }
+        if (content.indexOf(version) >= 0) {
+            var d = JSON.parse(content);
+            return d.content;
+        }
+        return '';
+    };
+    CloudbaseCache.prototype.getStoreAsync = function (key, version) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var content, d;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        try {
+                            if (typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.tcb_token)) {
+                                return [2, process.env.tcb_token];
+                            }
+                            if (!this._storage) {
+                                return [2, ''];
+                            }
+                        }
+                        catch (e) {
+                            return [2, ''];
+                        }
+                        version = version || 'localCachev1';
+                        return [4, this._storage.getItem(key)];
+                    case 1:
+                        content = _b.sent();
+                        if (!content) {
+                            return [2, ''];
+                        }
+                        if (content.indexOf(version) >= 0) {
+                            d = JSON.parse(content);
+                            return [2, d.content];
+                        }
+                        return [2, ''];
+                }
+            });
+        });
+    };
+    CloudbaseCache.prototype.removeStore = function (key) {
+        if (this.mode === 'async') {
+            (0, util_1.printWarn)(constants_1.ERRORS.INVALID_OPERATION, 'current platform\'s storage is asynchronous, please use removeStoreAsync insteed');
+            return;
+        }
+        this._storage.removeItem(key);
+    };
+    CloudbaseCache.prototype.removeStoreAsync = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this._storage.removeItem(key)];
+                    case 1:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        });
+    };
+    return CloudbaseCache;
+}());
+exports.CloudbaseCache = CloudbaseCache;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/libs/cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { StorageInterface, AbstractStorage, SDKAdapterInterface } from '@cloudbase/adapter-interface';\nimport { ICloudbaseCache, ICacheConfig } from '@cloudbase/types/cache';\nimport { KV, Persistence, ICloudbasePlatformInfo } from '@cloudbase/types';\nimport { isUndefined, isNull, printWarn } from './util';\nimport { ERRORS, getSdkName } from '../constants';\n\n/**\n * persitence=none时登录态保存在内存中\n */\nclass TcbCacheObject extends AbstractStorage {\n  private readonly _root: any;\n  constructor(root: any) {\n    super();\n    this._root = root;\n    if (!root.tcbCacheObject) {\n      root.tcbCacheObject = {};\n    }\n  }\n  public setItem(key: string, value: any) {\n    this._root.tcbCacheObject[key] = value;\n  }\n  public getItem(key: string) {\n    return this._root.tcbCacheObject[key];\n  }\n  public removeItem(key: string) {\n    delete this._root.tcbCacheObject[key];\n  }\n  public clear() {\n    delete this._root.tcbCacheObject;\n  }\n}\n/**\n * 工厂函数\n */\nfunction createStorage(persistence: Persistence, adapter: SDKAdapterInterface): StorageInterface {\n  switch (persistence) {\n    case 'local':\n      if (!adapter.localStorage) {\n        printWarn(ERRORS.INVALID_PARAMS, 'localStorage is not supported on current platform');\n        // 不支持localstorage的平台降级为none\n        return new TcbCacheObject(adapter.root);\n      }\n      return adapter.localStorage;\n    case 'none':\n      return new TcbCacheObject(adapter.root);\n    case 'session':\n      if (!adapter.sessionStorage) {\n        printWarn(ERRORS.INVALID_PARAMS, 'sessionStorage is not supported on current platform');\n        // 不支持localstorage的平台降级为none\n        return new TcbCacheObject(adapter.root);\n      }\n      return adapter.sessionStorage;\n    default:\n      if (!adapter.localStorage) {\n        printWarn(ERRORS.INVALID_PARAMS, 'localStorage is not supported on current platform');\n        // 不支持localstorage的平台降级为none\n        return new TcbCacheObject(adapter.root);\n      }\n      return adapter.localStorage;\n  }\n}\n\nexport class CloudbaseCache implements ICloudbaseCache {\n  public keys: KV<string> = {};\n\n  private _persistence: Persistence;\n  private _platformInfo: ICloudbasePlatformInfo;\n  private _storage: StorageInterface;\n  // 始终存储在localstorage中的key集合\n  private _alwaysLocalKeys: string[];\n\n  constructor(config: ICacheConfig) {\n    const { persistence, platformInfo = {}, keys = {}, alwaysLocalKeys = [] } = config;\n    this._platformInfo = platformInfo;\n    this._alwaysLocalKeys = alwaysLocalKeys;\n    if (!this._storage) {\n      this._persistence = platformInfo.adapter.primaryStorage || persistence;\n      this._storage = createStorage(this._persistence, platformInfo.adapter);\n      this.keys = keys;\n    }\n  }\n  /**\n   * @getter storage模式-同步/异步\n   */\n  get mode() {\n    return this._storage.mode || 'sync';\n  }\n  get persistence(): Persistence {\n    return this._persistence;\n  }\n  /**\n   * 在不同persistence之间迁移数据\n   * @param persistence\n   */\n  public updatePersistence(persistence: Persistence) {\n    if (this.mode === 'async') {\n      printWarn(ERRORS.INVALID_OPERATION, 'current platform\\'s storage is asynchronous, please use updatePersistenceAsync insteed');\n      return;\n    }\n    if (persistence === this._persistence) {\n      return;\n    }\n    const isCurrentLocal = this._persistence === 'local';\n    this._persistence = persistence;\n    const storage = createStorage(persistence, this._platformInfo.adapter);\n    // 切换persistence重新创建storage对象\n    for (const key in this.keys) {\n      const name = this.keys[key];\n      // 如果当前为local并且key被设定为始终存储在localstorage中，则不迁移\n      if (isCurrentLocal && this._alwaysLocalKeys.includes(key)) {\n        continue;\n      }\n      const val = this._storage.getItem(name);\n      if (!isUndefined(val) && !isNull(val)) {\n        storage.setItem(name, val);\n        this._storage.removeItem(name);\n      }\n    }\n    this._storage = storage;\n  }\n  public async updatePersistenceAsync(persistence: Persistence) {\n    if (persistence === this._persistence) {\n      return;\n    }\n    const isCurrentLocal = this._persistence === 'local';\n    this._persistence = persistence;\n    const storage = createStorage(persistence, this._platformInfo.adapter);\n    // 切换persistence重新创建storage对象\n    for (const key in this.keys) {\n      const name = this.keys[key];\n      // 如果当前为local并且key被设定为始终存储在localstorage中，则不迁移\n      if (isCurrentLocal && this._alwaysLocalKeys.includes(key)) {\n        continue;\n      }\n      const val = await this._storage.getItem(name);\n      if (!isUndefined(val) && !isNull(val)) {\n        storage.setItem(name, val);\n        await this._storage.removeItem(name);\n      }\n    }\n    this._storage = storage;\n  }\n  public setStore(key: string, value: any, version?: any) {\n    if (this.mode === 'async') {\n      printWarn(ERRORS.INVALID_OPERATION, 'current platform\\'s storage is asynchronous, please use setStoreAsync insteed');\n      return;\n    }\n    if (!this._storage) {\n      return;\n    }\n\n    try {\n      const val = {\n        version: version || 'localCachev1',\n        content: value,\n      };\n      this._storage.setItem(key, JSON.stringify(val));\n    } catch (e) {\n      throw new Error(JSON.stringify({\n        code: ERRORS.OPERATION_FAIL,\n        msg: `[${getSdkName()}][${ERRORS.OPERATION_FAIL}]setStore failed`,\n        info: e,\n      }));\n    }\n\n    return;\n  }\n  public async setStoreAsync(key: string, value: any, version?: any) {\n    if (!this._storage) {\n      return;\n    }\n\n    try {\n      const val = {\n        version: version || 'localCachev1',\n        content: value,\n      };\n      await this._storage.setItem(key, JSON.stringify(val));\n    } catch (e) {\n      return;\n    }\n\n    return;\n  }\n  public getStore(key: string, version?: string) {\n    if (this.mode === 'async') {\n      printWarn(ERRORS.INVALID_OPERATION, 'current platform\\'s storage is asynchronous, please use getStoreAsync insteed');\n      return;\n    }\n    try {\n      // 测试用例使用\n      if (typeof process !== 'undefined' && process.env?.tcb_token) {\n        return process.env.tcb_token;\n      }\n\n      if (!this._storage) {\n        return '';\n      }\n    } catch (e) {\n      return '';\n    }\n\n    version = version || 'localCachev1';\n\n    const content = this._storage.getItem(key);\n    if (!content) {\n      return '';\n    }\n\n    if (content.indexOf(version) >= 0) {\n      const d = JSON.parse(content);\n      return d.content;\n    }\n    return '';\n  }\n  public async getStoreAsync(key: string, version?: string) {\n    try {\n      // 测试用例使用\n      if (typeof process !== 'undefined' && process.env?.tcb_token) {\n        return process.env.tcb_token;\n      }\n\n      if (!this._storage) {\n        return '';\n      }\n    } catch (e) {\n      return '';\n    }\n\n    version = version || 'localCachev1';\n\n    const content = await this._storage.getItem(key);\n    if (!content) {\n      return '';\n    }\n\n    if (content.indexOf(version) >= 0) {\n      const d = JSON.parse(content);\n      return d.content;\n    }\n    return '';\n  }\n  public removeStore(key: string) {\n    if (this.mode === 'async') {\n      printWarn(ERRORS.INVALID_OPERATION, 'current platform\\'s storage is asynchronous, please use removeStoreAsync insteed');\n      return;\n    }\n    this._storage.removeItem(key);\n  }\n  public async removeStoreAsync(key: string) {\n    await this._storage.removeItem(key);\n  }\n}\n"]}

package/dist/cjs/libs/events.js

@@ -0,0 +1,108 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeEventListener = exports.activateEvent = exports.addEventListener = exports.CloudbaseEventEmitter = exports.IErrorEvent = exports.CloudbaseEvent = void 0;
+var util_1 = require("./util");
+function _addEventListener(name, listener, listeners) {
+    listeners[name] = listeners[name] || [];
+    listeners[name].push(listener);
+}
+function _removeEventListener(name, listener, listeners) {
+    if (listeners === null || listeners === void 0 ? void 0 : listeners[name]) {
+        var index = listeners[name].indexOf(listener);
+        if (index !== -1) {
+            listeners[name].splice(index, 1);
+        }
+    }
+}
+var CloudbaseEvent = (function () {
+    function CloudbaseEvent(name, data) {
+        this.data = data || null;
+        this.name = name;
+    }
+    return CloudbaseEvent;
+}());
+exports.CloudbaseEvent = CloudbaseEvent;
+var IErrorEvent = (function (_super) {
+    __extends(IErrorEvent, _super);
+    function IErrorEvent(error, data) {
+        var _this = _super.call(this, 'error', { error: error, data: data }) || this;
+        _this.error = error;
+        return _this;
+    }
+    return IErrorEvent;
+}(CloudbaseEvent));
+exports.IErrorEvent = IErrorEvent;
+var CloudbaseEventEmitter = (function () {
+    function CloudbaseEventEmitter() {
+        this._listeners = {};
+    }
+    CloudbaseEventEmitter.prototype.on = function (name, listener) {
+        _addEventListener(name, listener, this._listeners);
+        return this;
+    };
+    CloudbaseEventEmitter.prototype.off = function (name, listener) {
+        _removeEventListener(name, listener, this._listeners);
+        return this;
+    };
+    CloudbaseEventEmitter.prototype.fire = function (event, data) {
+        if ((0, util_1.isInstanceOf)(event, IErrorEvent)) {
+            console.error(event.error);
+            return this;
+        }
+        var ev = (0, util_1.isString)(event) ? new CloudbaseEvent(event, data || {}) : event;
+        var name = ev.name;
+        if (this._listens(name)) {
+            ev.target = this;
+            var handlers = this._listeners[name] ? __spreadArray([], this._listeners[name], true) : [];
+            for (var _i = 0, handlers_1 = handlers; _i < handlers_1.length; _i++) {
+                var fn = handlers_1[_i];
+                fn.call(this, ev);
+            }
+        }
+        return this;
+    };
+    CloudbaseEventEmitter.prototype._listens = function (name) {
+        return this._listeners[name] && this._listeners[name].length > 0;
+    };
+    return CloudbaseEventEmitter;
+}());
+exports.CloudbaseEventEmitter = CloudbaseEventEmitter;
+var eventEmitter = new CloudbaseEventEmitter();
+function addEventListener(event, callback) {
+    eventEmitter.on(event, callback);
+}
+exports.addEventListener = addEventListener;
+function activateEvent(event, data) {
+    if (data === void 0) { data = {}; }
+    eventEmitter.fire(event, data);
+}
+exports.activateEvent = activateEvent;
+function removeEventListener(event, callback) {
+    eventEmitter.off(event, callback);
+}
+exports.removeEventListener = removeEventListener;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events.js","sourceRoot":"","sources":["../../../src/libs/events.ts"],"names":[],"mappings":"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","sourcesContent":["import { isString, isInstanceOf } from './util';\nimport { Listeners, ICloudbaseEventEmitter } from '@cloudbase/types/events';\n\n\n/**\n * @private\n * @function _addEventListener - 添加监听\n * @param {string} name - event名称\n * @param {Function} listener - 响应函数\n * @param {Listeners} listeners - 已存响应函数集合\n */\nfunction _addEventListener(name: string, listener: Function, listeners: Listeners) {\n  listeners[name] = listeners[name] || [];\n  listeners[name].push(listener);\n}\n/**\n * @private\n * @function _removeEventListener - 移除监听\n * @param {string} name - event名称\n * @param {Function} listener - 响应函数\n * @param {Listeners} listeners - 已存响应函数集合\n */\nfunction _removeEventListener(name: string, listener: Function, listeners: Listeners) {\n  if (listeners?.[name]) {\n    const index = listeners[name].indexOf(listener);\n    if (index !== -1) {\n      listeners[name].splice(index, 1);\n    }\n  }\n}\ninterface IEvent {\n  name: string;\n  target: any;\n  data: any;\n}\n/**\n * 自定义事件\n * @class CloudbaseEvent\n * @param {string} name - 类型\n * @param {any} data - 数据\n */\nexport class CloudbaseEvent implements IEvent {\n  public readonly name: string;\n  public target: any;\n  public data: any;\n\n  constructor(name: string, data: any) {\n    this.data = data || null;\n    this.name = name;\n  }\n}\n/**\n * 自定义错误事件\n * @class IErrorEvent\n * @extends CloudbaseEvent\n * @param {Error} error - 错误信息对象\n * @param {any} data  - 数据\n */\nexport class IErrorEvent extends CloudbaseEvent {\n  public readonly error: Error;\n  constructor(error: Error, data?: any) {\n    super('error', { error, data });\n    this.error = error;\n  }\n}\n\n/**\n * @class CloudbaseEventEmitter\n */\nexport class CloudbaseEventEmitter implements ICloudbaseEventEmitter {\n  /**\n   * @private\n   * @readonly\n   * @property {Listeners} _listeners - 响应函数集合\n   * @default `{}`\n   */\n  private readonly _listeners: Listeners = {};\n\n  /**\n   * @public\n   * @method on - 添加监听\n   * @param {string} name - event名称\n   * @param {Function} listener - 响应函数\n   * @return `this`\n   */\n  public on(name: string, listener: Function): this {\n    _addEventListener(name, listener, this._listeners);\n    return this;\n  }\n  /**\n   * @public\n   * @method off - 移除监听\n   * @param {string} name - event名称\n   * @param {Function} listener - 响应函数\n   * @return `this`\n   */\n  public off(name: string, listener: Function): this {\n    _removeEventListener(name, listener, this._listeners);\n    return this;\n  }\n  /**\n   * @public\n   * @method fire - 触发事件\n   * @param {string|CloudbaseEvent} event - event\n   * @return `this`\n   */\n  public fire(event: string | CloudbaseEvent, data?: any): this {\n    // 打印错误信息\n    if (isInstanceOf(event, IErrorEvent)) {\n      console.error((event as IErrorEvent).error);\n      return this;\n    }\n\n    const ev: CloudbaseEvent = isString(event) ? new CloudbaseEvent(event as string, data || {}) : event as CloudbaseEvent;\n\n    const { name } = ev;\n\n    if (this._listens(name)) {\n      ev.target = this;\n\n      const handlers = this._listeners[name] ? [...this._listeners[name]] : [];\n      for (const fn of handlers) {\n        fn.call(this, ev);\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * @private\n   * @method _listens - 判断是否监听了name事件\n   * @param {string} name - event名称\n   * @return `boolean`\n   */\n  private _listens(name: string): boolean {\n    return this._listeners[name] && this._listeners[name].length > 0;\n  }\n}\n\n\nconst eventEmitter = new CloudbaseEventEmitter();\n\nexport function addEventListener(event: string, callback: Function) {\n  eventEmitter.on(event, callback);\n}\n\nexport function activateEvent(event: string, data: any = {}) {\n  eventEmitter.fire(event, data);\n}\n\nexport function removeEventListener(event: string, callback: Function) {\n  eventEmitter.off(event, callback);\n}\n"]}