@cloudbase/oauth 0.1.1-alpha.5 → 0.1.1-alpha.6

package/packages/container/node_modules/@cloudbase/utilities/dist/cjs/libs/cache.js

@@ -0,0 +1,261 @@
+"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);
+        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;
+        this.platformInfo = platformInfo;
+        if (!this.storage) {
+            this.persistenceTag = this.platformInfo.adapter.primaryStorage || persistence;
+            this.storage = createStorage(this.persistenceTag, this.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.persistenceTag;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    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 { 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    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 persistenceTag: Persistence\n  private platformInfo: ICloudbasePlatformInfo\n  private storage: StorageInterface\n\n  constructor(config: ICacheConfig) {\n    const { persistence, platformInfo = {}, keys = {} } = config\n    this.platformInfo = platformInfo\n    if (!this.storage) {\n      this.persistenceTag = this.platformInfo.adapter.primaryStorage || persistence\n      this.storage = createStorage(this.persistenceTag, this.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.persistenceTag\n  }\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/packages/container/node_modules/@cloudbase/utilities/dist/cjs/libs/events.d.ts

@@ -0,0 +1,27 @@
+import { ICloudbaseEventEmitter } from '@cloudbase/types/events';
+interface IEvent {
+    name: string;
+    target: any;
+    data: any;
+}
+export declare class CloudbaseEvent implements IEvent {
+    readonly name: string;
+    target: any;
+    data: any;
+    constructor(name: string, data: any);
+}
+export declare class IErrorEvent extends CloudbaseEvent {
+    readonly error: Error;
+    constructor(error: Error, data?: any);
+}
+export declare class CloudbaseEventEmitter implements ICloudbaseEventEmitter {
+    private readonly listeners;
+    on(name: string, listener: Function): this;
+    off(name: string, listener: Function): this;
+    fire(event: string | CloudbaseEvent, data?: any): this;
+    private listens;
+}
+export declare function addEventListener(event: string, callback: Function): void;
+export declare function activateEvent(event: string, data?: any): void;
+export declare function removeEventListener(event: string, callback: Function): void;
+export {};

package/packages/container/node_modules/@cloudbase/utilities/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 customeAddEventListener(name, listener, listeners) {
+    listeners[name] = listeners[name] || [];
+    listeners[name].push(listener);
+}
+function customRemoveEventListener(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) {
+        customeAddEventListener(name, listener, this.listeners);
+        return this;
+    };
+    CloudbaseEventEmitter.prototype.off = function (name, listener) {
+        customRemoveEventListener(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 customeAddEventListener(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 customRemoveEventListener(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    customeAddEventListener(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    customRemoveEventListener(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"]}

package/packages/container/node_modules/@cloudbase/utilities/dist/cjs/libs/util.d.ts

@@ -0,0 +1,35 @@
+import { KV } from '@cloudbase/types';
+export declare function isArray(val: any): boolean;
+export declare function isString(val: any): boolean;
+export declare function isUndefined(val: any): boolean;
+export declare function isPalinObject(val: any): boolean;
+export declare function isNull(val: any): boolean;
+export declare function isInstanceOf(instance: any, construct: any): boolean;
+export declare function isFormData(val: any): boolean;
+export declare function genSeqId(): string;
+export declare function formatUrl(PROTOCOL: string, url: string, query?: KV<any>): string;
+export declare function createSign(payload: KV<any>, secret: string): string;
+export declare function toQueryString(query?: KV<any>): string;
+export declare function getQuery(name: string, url?: string): string | false;
+export declare const getHash: (name: string) => string;
+export declare function removeParam(key: string, sourceURL: string): string;
+export declare function createPromiseCallback(): any;
+export declare function execCallback(fn: Function | null | undefined, err: any, data?: any): any;
+export declare function printWarn(error: string, msg: string): void;
+export declare function printError(error: string, msg: string): void;
+export declare function printInfo(error: string, msg: string): void;
+export declare function throwError(error: string, msg: string): void;
+interface IPrintGroupLogOptions {
+    title: string;
+    subtitle: string | object;
+    content: {
+        type: 'info' | 'warn' | 'error';
+        body: string | Error;
+    }[];
+    printTrace?: boolean;
+    collapsed?: boolean;
+}
+export declare function printGroupLog(options: IPrintGroupLogOptions): void;
+export declare const sleep: (ms?: number) => Promise<unknown>;
+export declare function transformPhone(phoneNumber: string): string;
+export {};