@bbk47/toolbox 1.0.4 → 1.0.6-beta.1

package/lib/deferred.js

@@ -0,0 +1,8 @@
+module.exports = function deferred(){
+    const defer = {};
+    defer.promise = new Promise((resolve,reject)=>{
+        defer.resolve=resolve;
+        defer.reject=reject;
+    });
+    return defer;
+}

package/lib/index.js

@@ -3,3 +3,6 @@ exports.logger = require('./logger');
 exports.md5 = require('./md5');
 exports.socks5 = require('./socks5');
 exports.uuid = require('./uuid');
+exports.retry = require('./retry');
+exports.deferred = require('./deferred');
+exports.merge = require('./merge');

package/lib/merge.js

@@ -1,29 +1,18 @@
-function factory(overide) {
-    return function assign(target) {
-        target = target || {};
-        var args = [].slice.call(arguments, 1);
-        args.forEach((temp) => {
-            if (temp) {
-                Object.keys(temp).forEach((key) => {
-                    if (overide) {
-                        target[key] = temp[key];
-                    } else if (temp[key]) {
-                        target[key] = temp[key];
-                    }
-                });
-            }
-        });
-        return target;
-    };
-}
-
 function merge(target) {
-    return factory(false).apply(target, arguments);
+    target = target || {};
+    var args = [].slice.call(arguments, 1);
+    args.forEach((temp) => {
+        if (temp) {
+            Object.keys(temp).forEach((key) => {
+                if (temp[key]) {
+                    target[key] = temp[key];
+                }
+            });
+        }
+    });
+    return target;
 }
 
-function assign(target) {
-    return factory(true).apply(target, arguments);
-}
+module.exports = merge;
 
-exports.objectMerge = merge;
-exports.objectAssign = assign;
+// console.log(merge({}, { sss: 123 }, { bb: 456 },{sss:null}));

package/lib/retry.js

@@ -0,0 +1,25 @@
+var timeoutPromise = (time) =>
+    new Promise((resolve) => setTimeout(resolve, time));
+
+function retryPromise(fn, opts = {}, errcall) {
+    var retryCount = opts.times || 5;
+
+    function invoker(idx) {
+        if (idx >= retryCount) {
+            return Promise.reject(
+                Error(`expect retryCount ${retryCount} is attached!`)
+            );
+        }
+        return fn.call(null).catch((err) => {
+            errcall && errcall(err);
+            if (opts.interval) {
+                return timeoutPromise(opts.interval).then(() => invoker(idx + 1));
+            } else {
+                return invoker(idx + 1);
+            }
+        });
+    }
+    return invoker(0);
+}
+
+module.exports = retryPromise;

package/lib/uuid.js

@@ -1,7 +1,40 @@
-const uuid = require('uuid').v4;
+// const uuid = require('uuid').v4;
+
+var lut = [];
+for (var i = 0; i < 256; i++) {
+    lut[i] = (i < 16 ? '0' : '') + i.toString(16);
+}
+function e7() {
+    var d0 = (Math.random() * 0xffffffff) | 0;
+    var d1 = (Math.random() * 0xffffffff) | 0;
+    var d2 = (Math.random() * 0xffffffff) | 0;
+    var d3 = (Math.random() * 0xffffffff) | 0;
+    return (
+        lut[d0 & 0xff] +
+        lut[(d0 >> 8) & 0xff] +
+        lut[(d0 >> 16) & 0xff] +
+        lut[(d0 >> 24) & 0xff] +
+        '-' +
+        lut[d1 & 0xff] +
+        lut[(d1 >> 8) & 0xff] +
+        '-' +
+        lut[((d1 >> 16) & 0x0f) | 0x40] +
+        lut[(d1 >> 24) & 0xff] +
+        '-' +
+        lut[(d2 & 0x3f) | 0x80] +
+        lut[(d2 >> 8) & 0xff] +
+        '-' +
+        lut[(d2 >> 16) & 0xff] +
+        lut[(d2 >> 24) & 0xff] +
+        lut[d3 & 0xff] +
+        lut[(d3 >> 8) & 0xff] +
+        lut[(d3 >> 16) & 0xff] +
+        lut[(d3 >> 24) & 0xff]
+    );
+}
 
 function getRamdomUUID() {
-    const id = uuid();
+    const id = e7();
     return id.replace(/-/g, '');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bbk47/toolbox",
-    "version": "1.0.4",
+    "version": "1.0.6-beta.1",
     "description": "toolbox for bbk",
     "main": "lib/index.js",
     "scripts": {
@@ -17,8 +17,7 @@
     },
     "homepage": "https://github.com/bbk47/toolboxjs#readme",
     "dependencies": {
-        "date-format": "^3.0.0",
-        "uuid": "^8.3.2"
+        "date-format": "^3.0.0"
     },
     "devDependencies": {
         "mocha": "^5.2.0"

package/test/deferred.js

@@ -0,0 +1,24 @@
+const assert = require('assert');
+const deferred = require('../lib/deferred');
+const { describe } = require('mocha');
+
+describe('deferred', function () {
+    it('test deferred resolve', function () {
+        var defer = deferred();
+        setTimeout(() => {
+            defer.resolve("okok")
+        }, 10);
+        return defer.promise.then(ret => {
+            assert.equal(ret, "okok");
+        });
+    });
+    it('test deferred reject', function () {
+        var defer = deferred();
+        setTimeout(() => {
+            defer.reject("err111");
+        }, 10);
+        return defer.promise.catch(err => {
+            assert.equal(err, "err111")
+        });
+    });
+});

package/test/merge.js

@@ -4,14 +4,8 @@ const { describe } = require('mocha');
 
 describe('socks5', function () {
     it('test object merge', function () {
-        var obj = merge.objectMerge({ sss: 1 }, { sss: 123 }, { bb: 456 }, { sss: null });
+        var obj = merge({ sss: 1 }, { sss: 123 }, { bb: 456 }, { sss: null });
         assert.equal(obj.sss, 123);
         assert.equal(obj.bb, 456);
     });
-
-    it('test object assign', function () {
-        var obj = merge.objectAssign({ sss: 12 }, { sss: 123 }, { bb: 456 }, { sss: null ,bb:789});
-        assert.equal(obj.sss, null);
-        assert.equal(obj.bb, 789);
-    });
 });

package/test/retry.js

@@ -0,0 +1,61 @@
+const assert = require('assert');
+const retry = require('../lib/retry');
+const { describe } = require('mocha');
+
+describe('retry', function () {
+    it('test retry max count', function () {
+        const awaitErrorTask = () => {
+            return new Promise((s, reject) => reject('xxxxxx'));
+        }
+        return retry(awaitErrorTask).then(() => {
+            throw Error("unexcept exec");
+        }).catch(err => {
+            assert.equal("expect retryCount 5 is attached!", err.message);
+        });
+
+    });
+
+    it('test retry custom max count', function () {
+        let maxcount = 10;
+        const taskfn = () => {
+            return new Promise((s, reject) => reject('err'));
+        }
+        return retry(taskfn, { times: maxcount }).then(() => {
+            throw Error("unexcept exec");
+        }).catch(err => {
+            assert.equal("expect retryCount 10 is attached!", err.message);
+        });
+    });
+
+    it('test retry errorcall', function () {
+        let maxcount = 10;
+        let start = 0;
+        const taskfn = () => {
+            start++;
+            return new Promise((s, reject) => reject(Error('retryerr:' + start)));
+        }
+        return retry(taskfn, { times: maxcount }, function (err) {
+            assert.equal("retryerr:" + start, err.message);
+        }).then(() => {
+            throw Error("unexcept exec");
+        }).catch(err => {
+            assert.equal("expect retryCount 10 is attached!", err.message);
+        });
+    });
+
+    it('test retry interval args', function (done) {
+        let start = 0;
+        const taskfn = () => {
+            start++;
+            return new Promise((s, reject) => reject(Error('retryerr:' + start)));
+        }
+        let startTime =Date.now();
+        retry(taskfn, { interval: 100 }, function (err) {
+            assert.equal("retryerr:" + start, err.message);
+        }).catch(err => {
+            assert.equal(Date.now()-startTime > 5*100,true);
+            assert.equal("expect retryCount 5 is attached!", err.message);
+            done();
+        });
+    });
+});