ali-skills 0.0.21 → 0.0.23

package/node_modules/sdk-base/index.js

@@ -0,0 +1,251 @@
+const co = require('co');
+const util = require('util');
+const assert = require('assert');
+const awaitEvent = require('await-event');
+const awaitFirst = require('await-first');
+const { EventEmitter } = require('events');
+const pTimeout = require('p-timeout');
+const CLOSE_PROMISE = Symbol('base#closePromise');
+
+function isGeneratorFunction(obj) {
+  return obj &&
+    obj.constructor &&
+    obj.constructor.name === 'GeneratorFunction';
+}
+
+function isPromise(obj) {
+  return obj &&
+    typeof obj.then === 'function';
+}
+
+class Base extends EventEmitter {
+  constructor(options) {
+    super();
+
+    if (options && options.initMethod) {
+      assert(typeof this[options.initMethod] === 'function',
+        `[sdk-base] this.${options.initMethod} should be a function.`);
+
+      process.nextTick(() => {
+        if (isGeneratorFunction(this[options.initMethod])) {
+          this[options.initMethod] = co.wrap(this[options.initMethod]);
+        }
+        const ret = this[options.initMethod]();
+        assert(isPromise(ret), `[sdk-base] this.${options.initMethod} should return either a promise or a generator`);
+        ret.then(() => this.ready(true))
+          .catch(err => this.ready(err));
+      });
+    }
+    this.options = options || {};
+    this._ready = false;
+    this._readyError = null;
+    this._readyCallbacks = [];
+    this._closed = false;
+
+    // support `await this.await('event')`
+    this.await = awaitEvent;
+    this.awaitFirst = awaitFirst;
+
+    this.on('error', err => { this._defaultErrorHandler(err); });
+  }
+
+  _wrapListener(eventName, listener) {
+    if (isGeneratorFunction(listener)) {
+      assert(eventName !== 'error', '[sdk-base] `error` event should not have a generator listener.');
+
+      const newListener = (...args) => {
+        co(function* () {
+          yield listener(...args);
+        }).catch(err => {
+          err.name = 'EventListenerProcessError';
+          this.emit('error', err);
+        });
+      };
+      newListener.original = listener;
+      return newListener;
+    }
+    return listener;
+  }
+
+  addListener(eventName, listener) {
+    return super.addListener(eventName, this._wrapListener(eventName, listener));
+  }
+
+  on(eventName, listener) {
+    return super.on(eventName, this._wrapListener(eventName, listener));
+  }
+
+  once(eventName, listener) {
+    return super.once(eventName, this._wrapListener(eventName, listener));
+  }
+
+  prependListener(eventName, listener) {
+    return super.prependListener(eventName, this._wrapListener(eventName, listener));
+  }
+
+  prependOnceListener(eventName, listener) {
+    return super.prependOnceListener(eventName, this._wrapListener(eventName, listener));
+  }
+
+  removeListener(eventName, listener) {
+    let target = listener;
+    if (isGeneratorFunction(listener)) {
+      const listeners = this.listeners(eventName);
+      for (const fn of listeners) {
+        if (fn.original === listener) {
+          target = fn;
+          break;
+        }
+      }
+    }
+    return super.removeListener(eventName, target);
+  }
+
+  /**
+   * detect sdk start ready or not
+   * @return {Boolean} ready status
+   */
+  get isReady() {
+    return this._ready;
+  }
+
+  /**
+   * get AsyncLocalStorage from options
+   * @return {AsyncLocalStorage} asyncLocalStorage instance or undefined
+   */
+  get localStorage() {
+    return this.options.localStorage;
+  }
+
+  /**
+   * set ready state or onready callback
+   *
+   * @param {Boolean|Error|Function} flagOrFunction - ready state or callback function
+   * @return {void|Promise} ready promise
+   */
+  ready(flagOrFunction) {
+    if (arguments.length === 0) {
+      // return a promise
+      // support `this.ready().then(onready);` and `await this.ready()`;
+      return new Promise((resolve, reject) => {
+        if (this._ready) {
+          return resolve();
+        } else if (this._readyError) {
+          return reject(this._readyError);
+        }
+        this._readyCallbacks.push(err => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+    } else if (typeof flagOrFunction === 'function') {
+      this._readyCallbacks.push(flagOrFunction);
+    } else if (flagOrFunction instanceof Error) {
+      this._ready = false;
+      this._readyError = flagOrFunction;
+      if (!this._readyCallbacks.length) {
+        this.emit('error', flagOrFunction);
+      }
+    } else {
+      this._ready = flagOrFunction;
+    }
+
+    if (this._ready || this._readyError) {
+      this._readyCallbacks.splice(0, this._readyCallbacks.length).forEach(callback => {
+        process.nextTick(() => {
+          callback(this._readyError);
+        });
+      });
+    }
+  }
+
+  async readyOrTimeout(milliseconds) {
+    if (this._ready) {
+      return;
+    } else if (this._readyError) {
+      throw this._readyError;
+    }
+    let readyWithTimeoutCallback;
+    const waitForReady = new Promise((resolve, reject) => {
+      readyWithTimeoutCallback = err => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      };
+      this._readyCallbacks.push(readyWithTimeoutCallback);
+    });
+    try {
+      await pTimeout(waitForReady, milliseconds);
+    } catch (err) {
+      for (const [ index, callback ] of this._readyCallbacks.entries()) {
+        if (callback === readyWithTimeoutCallback) {
+          // remove timeout readyCallback
+          this._readyCallbacks.splice(index, 1);
+          break;
+        }
+      }
+      throw err;
+    }
+  }
+
+  _defaultErrorHandler(err) {
+    if (this.listeners('error').length > 1) {
+      // ignore defaultErrorHandler
+      return;
+    }
+    console.error('\n[%s][pid: %s][%s] %s: %s \nError Stack:\n  %s',
+      Date(), process.pid, this.constructor.name, err.name,
+      err.message, err.stack);
+
+    // try to show addition property on the error object
+    // e.g.: `err.data = {url: '/foo'};`
+    const additions = [];
+    for (const key in err) {
+      if (key === 'name' || key === 'message') {
+        continue;
+      }
+
+      additions.push(util.format('  %s: %j', key, err[key]));
+    }
+    if (additions.length) {
+      console.error('Error Additions:\n%s', additions.join('\n'));
+    }
+    console.error();
+  }
+
+  close() {
+    if (this._closed) {
+      return Promise.resolve();
+    }
+    if (this[CLOSE_PROMISE]) {
+      return this[CLOSE_PROMISE];
+    }
+    if (!this._close) {
+      this._closed = true;
+      return Promise.resolve();
+    }
+    let closeFunc = this._close;
+    if (isGeneratorFunction(closeFunc)) {
+      closeFunc = co.wrap(closeFunc);
+    }
+    this[CLOSE_PROMISE] = closeFunc.apply(this);
+    assert(isPromise(this[CLOSE_PROMISE]), '[sdk-base] this._close should return either a promise or a generator');
+    return this[CLOSE_PROMISE]
+      .then(() => {
+        this._closed = true;
+      })
+      .catch(err => {
+        this._closed = true;
+        this.emit('error', err);
+      });
+  }
+}
+
+module.exports = Base;
+// support es module
+module.exports.default = Base;

package/node_modules/sdk-base/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "sdk-base",
+  "version": "4.2.1",
+  "description": "a base class for sdk with default error handler",
+  "main": "index.js",
+  "scripts": {
+    "lint": "eslint --ext .js .",
+    "tsd": "tsd",
+    "test": "npm run lint && npm run tsd && npm run test-local",
+    "test-local": "egg-bin test -r co-mocha",
+    "cov": "egg-bin cov -r co-mocha",
+    "ci": "npm run lint && npm run tsd && npm run cov",
+    "contributor": "git-contributor"
+  },
+  "keywords": [
+    "sdk",
+    "error"
+  ],
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "author": {
+    "name": "dead_horse",
+    "email": "dead_horse@qq.com",
+    "url": "http://deadhorse.me"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:node-modules/sdk-base"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "await-event": "^2.1.0",
+    "await-first": "^1.0.0",
+    "co": "^4.6.0",
+    "p-timeout": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^14.18.34",
+    "co-mocha": "^1.2.2",
+    "egg-bin": "^5.5.0",
+    "eslint": "^8.29.0",
+    "eslint-config-egg": "^12.1.0",
+    "git-contributor": "^1.1.0",
+    "pedding": "^1.1.0",
+    "runscript": "^1.3.0",
+    "tsd": "^0.25.0",
+    "typescript": "^4.9.3"
+  },
+  "engine": {
+    "node": ">= 14.0.0"
+  }
+}

package/node_modules/serialize-json/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 node_modules
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/serialize-json/README.md

@@ -0,0 +1,74 @@
+# serialize-json
+A serialize algorithm for JSON
+
+[![NPM version][npm-image]][npm-url]
+[![build status][travis-image]][travis-url]
+[![Test coverage][codecov-image]][codecov-url]
+[![David deps][david-image]][david-url]
+[![Known Vulnerabilities][snyk-image]][snyk-url]
+[![npm download][download-image]][download-url]
+
+[npm-image]: https://img.shields.io/npm/v/serialize-json.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/serialize-json
+[travis-image]: https://img.shields.io/travis/node-modules/serialize-json.svg?style=flat-square
+[travis-url]: https://travis-ci.org/node-modules/serialize-json
+[codecov-image]: https://codecov.io/gh/node-modules/serialize-json/branch/master/graph/badge.svg
+[codecov-url]: https://codecov.io/gh/node-modules/serialize-json
+[david-image]: https://img.shields.io/david/node-modules/serialize-json.svg?style=flat-square
+[david-url]: https://david-dm.org/node-modules/serialize-json
+[snyk-image]: https://snyk.io/test/npm/serialize-json/badge.svg?style=flat-square
+[snyk-url]: https://snyk.io/test/npm/serialize-json
+[download-image]: https://img.shields.io/npm/dm/serialize-json.svg?style=flat-square
+[download-url]: https://npmjs.org/package/serialize-json
+
+## Introduction
+
+- Support serialize JSON to Buffer, and deserialize Buffer to JSON
+  - [√] Boolean
+  - [√] String
+  - [√] Number
+  - [√] Null
+  - [√] Undefined
+  - [√] Date
+  - [√] Buffer
+  - [√] Error
+  - [√] Plain Object
+  - [×] Function
+  - [×] RegExp
+  - [×] Symbol
+
+- Inspire by [jsonpack](https://github.com/sapienlab/jsonpack), it can compress to 55% of original size if the data has a recursive structure
+
+## Install
+
+```bash
+$ npm install serialize-json --save
+```
+
+Node.js >= 4.0.0 required
+
+## Usage
+
+```js
+let json = {
+  a: 'a',
+  b: 123,
+  c: 123.456,
+  d: [ 1, 2, 3 ],
+  e: true,
+  f: null,
+  g: undefined,
+  h: new Date(),
+  i: new Buffer('this is a buffer'),
+  j: new Error('this is a error'),
+};
+const buf = JSON.encode(json);
+const result = JSON.decode(buf);
+assert.deepEqual(result, json);
+```
+
+## API
+
+- `encode(json)` serialize a json object
+- `decode(buf)` deserialize a buffer to json
+

package/node_modules/serialize-json/lib/decoder.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const debug = require('debug')('serialize-json#JSONDecoder');
+
+const TOKEN_TRUE = -1;
+const TOKEN_FALSE = -2;
+const TOKEN_NULL = -3;
+const TOKEN_EMPTY_STRING = -4;
+const TOKEN_UNDEFINED = -5;
+
+const REG_STR_REPLACER = /\+|%2B|%7C|%5E|%25/g;
+const DECODER_REPLACER = {
+  '+': ' ',
+  '%2B': '+',
+  '%7C': '|',
+  '%5E': '^',
+  '%25': '%',
+};
+const TOKEN_SET = new Set([ '|', '$', '@', '*', '#', ']' ]);
+
+class JSONDecoder {
+  constructor() {
+    this.dictionary = [];
+    this.tokens = [];
+    this.tokensIndex = 0;
+  }
+
+  _decodeString(str) {
+    // avoid Parent in (sliced string)
+    // https://github.com/nodejs/help/issues/711
+    // https://stackoverflow.com/questions/31712808/how-to-force-javascript-to-deep-copy-a-string
+    const r = str.replace(REG_STR_REPLACER, a => DECODER_REPLACER[a]);
+    return (' ' + r).slice(1);
+  }
+
+  _decodeDate(str) {
+    return new Date(this._base36To10(str));
+  }
+
+  _base36To10(num) {
+    return parseInt(num, 36);
+  }
+
+  _unpack() {
+    const token = this.tokens[this.tokensIndex];
+    switch (token) {
+      case '@': // array
+      {
+        debug('--> unpack array begin');
+        const arr = [];
+        const tokensLen = this.tokens.length;
+        for (this.tokensIndex++; this.tokensIndex < tokensLen; this.tokensIndex++) {
+          const token = this.tokens[this.tokensIndex];
+          if (token === ']') {
+            debug('--> unpack array end, %j', arr);
+            return arr;
+          }
+          arr.push(this._unpack());
+        }
+        return arr;
+      }
+      case '$': // object
+      {
+        debug('--> unpack plain object begin');
+        const obj = {};
+        const tokensLen = this.tokens.length;
+        for (this.tokensIndex++; this.tokensIndex < tokensLen; this.tokensIndex++) {
+          const token = this.tokens[this.tokensIndex];
+          if (token === ']') {
+            debug('--> unpack plain object end, %j', obj);
+            return obj;
+          }
+          const key = this._unpack();
+          this.tokensIndex++;
+          obj[key] = this._unpack();
+        }
+        return obj;
+      }
+      case '*': // buffer
+      {
+        debug('--> unpack buffer begin');
+        const arr = [];
+        const tokensLen = this.tokens.length;
+        for (this.tokensIndex++; this.tokensIndex < tokensLen; this.tokensIndex++) {
+          const token = this.tokens[this.tokensIndex];
+          if (token === ']') {
+            debug('--> unpack buffer end, %j', arr);
+            return Buffer.from(arr);
+          }
+          arr.push(this._unpack());
+        }
+        return Buffer.from(arr);
+      }
+      case '#': // error
+      {
+        debug('--> unpack error begin');
+        const obj = {};
+        const tokensLen = this.tokens.length;
+        for (this.tokensIndex++; this.tokensIndex < tokensLen; this.tokensIndex++) {
+          const token = this.tokens[this.tokensIndex];
+          if (token === ']') {
+            const err = new Error(obj.message);
+            Object.assign(err, obj);
+            debug('--> unpack error end, %j', err);
+            return err;
+          }
+          const key = this._unpack();
+          this.tokensIndex++;
+          obj[key] = this._unpack();
+        }
+        const err = new Error(obj.message);
+        Object.assign(err, obj);
+        return err;
+      }
+      case TOKEN_TRUE:
+        return true;
+      case TOKEN_FALSE:
+        return false;
+      case TOKEN_NULL:
+        return null;
+      case TOKEN_EMPTY_STRING:
+        return '';
+      case TOKEN_UNDEFINED:
+        return undefined;
+      default:
+        return this.dictionary[token];
+    }
+  }
+
+  decode(buf) {
+    this.dictionary = [];
+    this.tokens = [];
+    this.tokensIndex = 0;
+
+    const packed = buf.toString();
+    const arr = packed.split('^');
+
+    if (arr[0]) {
+      const strArr = arr[0].split('|');
+      for (const str of strArr) {
+        this.dictionary.push(this._decodeString(str));
+      }
+    }
+
+    if (arr[1]) {
+      const intArr = arr[1].split('|');
+      for (const int of intArr) {
+        this.dictionary.push(this._base36To10(int));
+      }
+    }
+
+    if (arr[2]) {
+      const floatArr = arr[2].split('|');
+      for (const float of floatArr) {
+        this.dictionary.push(parseFloat(float));
+      }
+    }
+
+    if (arr[3]) {
+      const dateArr = arr[3].split('|');
+      for (const date of dateArr) {
+        this.dictionary.push(this._decodeDate(date));
+      }
+    }
+
+    debug('decode packed json => %s, with dictionary %j', packed, this.dictionary);
+
+    let tmp = '';
+    for (let i = 0, len = arr[4].length; i < len; ++i) {
+      const symbol = arr[4][i];
+      if (TOKEN_SET.has(symbol)) {
+        if (tmp) {
+          this.tokens.push(this._base36To10(tmp));
+          tmp = '';
+        }
+        if (symbol !== '|') {
+          this.tokens.push(symbol);
+        }
+      } else {
+        tmp += symbol;
+      }
+    }
+    if (tmp) {
+      this.tokens.push(this._base36To10(tmp));
+    }
+    return this._unpack();
+  }
+}
+
+module.exports = JSONDecoder;