ali-skills 0.0.21 → 0.0.22

package/node_modules/heartbeats/test/benchmark.js

@@ -0,0 +1,138 @@
+var heartbeats = require('../main');
+var Benchmark = require('benchmark');
+
+var heart = {};
+var pulse = {};
+var action = false;
+
+var cycleCount = 0;
+
+var suite = new Benchmark.Suite('HeartBeats Performance Test');
+
+suite.on('start', function() {
+    action = false;
+    cycleCount = 0;
+});
+
+suite.on('cycle', function(event) {
+    console.log('\n', String(event.target));
+});
+
+suite.on('complete', function() {
+    var fastest = this.filter('fastest');
+    var slowest = this.filter('slowest');
+
+    var fastestSpeed = fastest[0].stats.mean;
+    var slowestSpeed = slowest[0].stats.mean;
+
+    // console.log(fastest.pluck('name')[0], 'is the Fastest at ', fastestSpeed, 'per cycle');
+    // console.log(slowest.pluck('name')[0], 'is the Slowest at ', slowestSpeed, 'per cycle');
+
+    // console.log(fastest.pluck('name')[0], 'is', slowestSpeed / fastestSpeed, 'times faster than', slowest.pluck('name')[0]);
+
+});
+
+suite.on('error', function(e) {
+    console.log('Benchmark ERROR:', e);
+});
+
+suite.add({
+    name: 'Pulse with heartbeats',
+    fn: function() {
+        pulse.beat();
+        // if (pulse.missedBeats >= 5) {
+        //     action = true;
+        // }
+    },
+    onStart: function() {
+        heart = heartbeats.createHeart(1000, 'heartA');
+        pulse = heart.createPulse('pulseA');
+        cycleCount = 0;
+        console.log('Starting:', this.name);
+    },
+    onCycle: function() {
+        process.stdout.write('\r Cycle:' + cycleCount++);
+    },
+    onComplete: function() {
+        pulse.kill();
+        heart.kill();
+        pulse = undefined;
+        heart = undefined;
+    }
+});
+
+suite.add({
+    name: 'Pulse with Date',
+    fn: function() {
+        pulse.time = new Date().getTime();
+        // if (pulse - heart >= 5000) {
+        //     action = true;
+        // }
+    },
+    onStart: function() {
+        pulse = {
+            time: new Date().getTime()
+        };
+        cycleCount = 0;
+        console.log('Starting:', this.name);
+    },
+    onCycle: function() {
+        process.stdout.write('\r Cycle:' + cycleCount++);
+    },
+    onComplete: function() {
+        pulse = undefined;
+        heart = undefined;
+    }
+});
+
+suite.add({
+    name: 'Time Differential with heartbeats',
+    fn: function() {
+        if (pulse.missedBeats >= 5) {
+            action = true;
+        }
+    },
+    onStart: function() {
+        heart = heartbeats.createHeart(1000, 'heartA');
+        pulse = heart.createPulse('pulseA');
+        cycleCount = 0;
+        console.log('Starting:', this.name);
+    },
+    onCycle: function() {
+        process.stdout.write('\r Cycle:' + cycleCount++);
+    },
+    onComplete: function() {
+        pulse.kill();
+        heart.kill();
+        pulse = undefined;
+        heart = undefined;
+    }
+});
+
+suite.add({
+    name: 'Time Differential with Date',
+    fn: function() {
+        if (pulse.time - new Date().getTime() >= 5000) {
+            action = true;
+        }
+    },
+    onStart: function() {
+        pulse = {
+            time: new Date().getTime()
+        };
+        cycleCount = 0;
+        console.log('Starting:', this.name);
+    },
+    onCycle: function() {
+        process.stdout.write('\r Cycle:' + cycleCount++);
+    },
+    onComplete: function() {
+        pulse = undefined;
+        heart = undefined;
+    }
+});
+
+
+suite.run({
+    'async': false
+});

package/node_modules/heartbeats/test/spawn.js

@@ -0,0 +1,16 @@
+var heartbeats = require('../main');
+var heart = heartbeats.createHeart(1000);
+
+heart.createEvent(1, {repeat: 3}, function() {
+    console.log('testing unref... 1 repeat 3');
+});
+
+heart.createEvent(2, {repeat: 2}, function() {
+    console.log('testing unref... 2 repeat 2');
+});
+
+heart.createEvent(3, {repeat: 1}, function() {
+    console.log('testing unref... 3 repeat 1');
+});
+
+// should exit after 4 seconds

package/node_modules/heartbeats/test/test.js

@@ -0,0 +1,158 @@
+var heartbeats = require('../main');
+var spawn = require('child_process').spawn;
+
+exports.unrefHeart = function(test) {
+
+    test.expect(1);
+
+    var unref_test = spawn('node', ['./test/spawn.js'], {
+        stdio: 'inherit'
+    });
+
+    unref_test.on('exit', function(code) {
+        test.equal(code, 0);
+        test.done();
+    });
+};
+
+exports.newHeart = function(test) {
+    test.expect(2);
+    var heart = heartbeats.createHeart(1000, 'globalBeat');
+    test.equal((heartbeats.heart('globalBeat') !== undefined), true);
+    test.equal((heartbeats.heart('globalBeat') === heart), true);
+    test.done();
+};
+
+exports.heartAge = function(test) {
+    test.expect(1);
+
+    var heart = heartbeats.heart('globalBeat');
+    var iA = setTimeout(function() {
+        test.equal(heart.age, 3);
+        test.done();
+    }, 3500);
+};
+
+exports.testPulses = function(test) {
+
+    var heart = heartbeats.createHeart(1000, 'globalBeat');
+
+    test.expect(1);
+
+    var obj = {
+        pulseA: heart.createPulse(),
+        pulseB: heart.createPulse(),
+    };
+
+    var iA = setInterval(function() {
+        obj.pulseA.beat();
+    }, 500);
+
+    var iB = setInterval(function() {
+        obj.pulseB.beat();
+    }, 5000);
+
+    var iC = setInterval(function() {
+        for (var pulse in obj) {
+            if (obj[pulse].missedBeats > 3) {
+                console.log(pulse, 'lag is over 3000ms:', obj[pulse].lag, 'missedBeats:', obj[pulse].missedBeats);
+                test.equal(true, true);
+                clearInterval(iA);
+                clearInterval(iB);
+                clearInterval(iC);
+                test.done();
+            } else {
+                console.log(pulse, 'lag is', obj[pulse].lag, 'missedBeats:', obj[pulse].missedBeats);
+            }
+        }
+    }, 500);
+};
+
+exports.addEvent = function(test) {
+    test.expect(3);
+
+    var presentInit = heartbeats.heart('globalBeat').heartbeat;
+
+    heartbeats.heart('globalBeat').createEvent(3, function(heartbeat) {
+        console.log('onBeat 3', heartbeat);
+        test.equal(true, true);
+    });
+
+    heartbeats.heart('globalBeat').createEvent(7, function(heartbeat) {
+        console.log('onBeat 7', heartbeat);
+        test.equal(true, true);
+        test.done();
+    });
+
+    setTimeout(function() {}, 7500);
+};
+
+exports.removeEvents = function(test) {
+    test.expect(1);
+
+    heartbeats.heart('globalBeat').killAllEvents();
+
+    test.equal(heartbeats.heart('globalBeat').events.length, 0);
+    test.done();
+};
+
+exports.addSingleEvent = function(test) {
+    test.expect(4);
+
+    var presentInit = heartbeats.heart('globalBeat').heartbeat;
+
+    heartbeats.heart('globalBeat').createEvent(1, {
+        repeat: 5
+    }, function(heartbeat) {
+        console.log('FiveTimesOnBeat 1', heartbeat);
+        if(heartbeat === 5){
+            test.equal(true, true);
+            test.done();
+        }
+    });
+
+    heartbeats.heart('globalBeat').createEvent(2, {
+        repeat: 1,
+        name: 'TwoBeat'
+    }, function(heartbeat) {
+        console.log('onceOnBeat 2', heartbeat);
+        test.equal(true, true);
+    });
+
+    heartbeats.heart('globalBeat').createEvent(2, {
+        repeat: 1
+    }, function(heartbeat) {
+        console.log('onceOnBeat 2', heartbeat);
+        test.equal(true, true);
+    });
+
+    heartbeats.heart('globalBeat').createEvent(3, {
+        repeat: 1
+    }, function(heartbeat) {
+        console.log('onceOnBeat 3', heartbeat);
+        test.equal(true, true);        
+    });
+
+    setTimeout(function() {}, 3500);
+};
+
+exports.removeEvents = function(test) {
+    test.expect(1);
+
+    heartbeats.heart('globalBeat').killAllEvents();
+
+    test.equal(heartbeats.heart('globalBeat').events.length, 0);
+    test.done();
+};
+
+exports.removeHeart = function(test) {
+    test.expect(1);
+
+    heartbeats.killHeart('globalBeat');
+    test.equal((heartbeats.heart('globalBeat') === undefined), true);
+    test.done();
+};
+
+exports.tearDown = function(done) {
+    done();
+};

package/node_modules/httpx/README.md

@@ -0,0 +1,96 @@
+# httpx
+
+http(s) module with power.
+
+[![NPM version][npm-image]][npm-url]
+[![Node.js CI](https://github.com/JacksonTian/httpx/actions/workflows/node.js.yml/badge.svg)](https://github.com/JacksonTian/httpx/actions/workflows/node.js.yml)
+[![codecov][cov-image]][cov-url]
+[![npm download][download-image]][download-url]
+
+[npm-image]: https://img.shields.io/npm/v/httpx.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/httpx
+[cov-image]: https://codecov.io/gh/JacksonTian/httpx/branch/master/graph/badge.svg
+[cov-url]: https://codecov.io/gh/JacksonTian/httpx
+[download-image]: https://img.shields.io/npm/dm/httpx.svg?style=flat-square
+[download-url]: https://npmjs.org/package/httpx
+
+## Installation
+
+```bash
+npm install httpx --save
+```
+
+## Usage
+
+### Request URL
+
+```js
+(async function () {
+  const response = await httpx.request('http://www.baidu.com/');
+  const body = await httpx.read(response, 'utf-8');
+  console.log(body);
+})();
+```
+
+### Request SSE URL
+
+```js
+(async function () {
+  const response = await httpx.request('sse url');
+  for await (const event of httpx.readAsSSE(response)) {
+    console.log(event);
+  }
+})();
+```
+
+## API
+
+### `httpx.request(url[, options])`
+
+It returns `Promise<Response>`.
+
+Requests the url with options, then return the response.
+
+- **url** String | Object - The URL to request, either a String or a Object that return by [url.parse](http://nodejs.org/api/url.html#url_url_parse_urlstr_parsequerystring_slashesdenotehost).
+- ***options*** Object - Optional
+  - ***method*** String - Request method, defaults to `GET`. Could be `GET`, `POST`, `DELETE` or `PUT`.
+  - ***data*** String | [Buffer](http://nodejs.org/api/buffer.html) | Readable - Manually set the content of payload.
+  - ***headers*** Object - Request headers.
+  - ***timeout*** Number - Request timeout in milliseconds. Defaults to 3000. When timeout happen, will return `RequestTimeout`.
+  - ***agent*** [http.Agent](http://nodejs.org/api/http.html#http_class_http_agent) - HTTP/HTTPS Agent object.
+      Set `false` if you does not use agent.
+  - ***beforeRequest*** Function - Before request hook, you can change every thing here.
+  - ***compression*** Boolean - Enable compression support. Tell server side responses compressed data
+
+### `httpx.read(response[, encoding])`
+
+It returns `Promise<Buffer | String>`.
+
+Consume the response and read all data from the response.
+
+- **response** Response - the Client response. Don't setEncoding() for the response.
+- **encoding** String - Optional. If specify the encoding, will return String. If not specify encoding, return the buffer.
+
+### `httpx.readAsSSE(response)`
+
+It returns `AsyncGenerator<Event, void, unknown>`.
+
+Consume the response data with async iterator.
+
+- **response** Response - the Client response. Don't setEncoding() for the response.
+
+## Using with http proxy
+
+```js
+const { SocksProxyAgent } = require('socks-proxy-agent');
+const httpx = require('httpx');
+
+httpx.request('http://www.baidu.com/', {
+  // pass a http proxy agent
+  agent: new SocksProxyAgent('socks://your_proxy_server:3001')
+});
+```
+
+## License
+
+The MIT license

package/node_modules/httpx/lib/index.d.ts

@@ -0,0 +1,31 @@
+import { IncomingMessage, Agent, OutgoingHttpHeaders } from "http";
+import { Readable } from "stream";
+
+export interface Options {
+    'method'?: string;
+    'readTimeout'?: number;
+    'connectTimeout'?: number;
+    'timeout'?: number;
+    'agent'?: Agent;
+    'headers'?: OutgoingHttpHeaders;
+    'rejectUnauthorized'?: boolean;
+    'compression'?: boolean;
+    'beforeRequest'?(options: Options): void;
+    'data'?: string | Buffer | Readable | undefined;
+    'key'?: string;
+    'cert'?: string;
+    'ca'?: string;
+}
+
+export function request(url: string, options: Options): Promise<IncomingMessage>;
+
+export function read(response: IncomingMessage, encoding: string): Promise<string|Buffer>;
+
+export interface Event {
+    'data'?: string;
+    'id'?: string;
+    'event'?: string;
+    'retry'?: number;
+}
+
+export function readAsSSE(response: IncomingMessage): AsyncGenerator<Event, void, unknown>;