mini-semaphore 1.3.0 → 1.3.7

package/README.md

@@ -1,4 +1,5 @@
-[![Build Status](https://travis-ci.com/jeffy-g/mini-semaphore.svg?branch=master)](https://travis-ci.com/jeffy-g/mini-semaphore) ![GitHub](https://img.shields.io/github/license/jeffy-g/mini-semaphore?style=plastic)
+[![CircleCI](https://circleci.com/gh/jeffy-g/mini-semaphore/tree/master.svg?style=svg)](https://circleci.com/gh/jeffy-g/mini-semaphore/tree/master)
+![GitHub](https://img.shields.io/github/license/jeffy-g/mini-semaphore?style=plastic)
 
 # Mini Semaphore (mini-semaphore
 

package/cjs/core.js

@@ -10,7 +10,7 @@ const box = (z, r) => {
         z.q.push(r);
     }
 };
-exports.acquire = (dis, lazy = true) => {
+const acquire = (dis, lazy = true) => {
     return new Promise(r => {
         if (!lazy) {
             box(dis, r);
@@ -20,7 +20,8 @@ exports.acquire = (dis, lazy = true) => {
         }
     });
 };
-exports.release = (dis) => {
+exports.acquire = acquire;
+const release = (dis) => {
     dis.capacity++;
     if (dis.q.length) {
         dis.capacity -= 1, (dis.q.shift() || extras_1.THROW)();
@@ -30,3 +31,4 @@ exports.release = (dis) => {
         dis.capacity = dis.limit;
     }
 };
+exports.release = release;

package/cjs/deque.js

@@ -35,7 +35,6 @@ class Deque {
         const i = (this._f + l) & (this._c - 1);
         this._a[i] = s;
         this._l = l + 1;
-        return l + 1;
     }
     shift() {
         const l = this._l;
@@ -49,17 +48,6 @@ class Deque {
         this._l = l - 1;
         return r;
     }
-    clear() {
-        const l = this._l;
-        const f = this._f;
-        const c = this._c;
-        const a = this._a;
-        for (let j = 0; j < l; ++j) {
-            a[(f + j) & (c - 1)] = void 0;
-        }
-        this._l = 0;
-        this._f = 0;
-    }
     get length() {
         return this._l;
     }

package/cjs/extras.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.THROW = void 0;
-exports.THROW = () => {
+const THROW = () => {
     throw new Error("mini-semaphore: inconsistent occurred");
 };
+exports.THROW = THROW;

package/cjs/flow-restrictor.js

@@ -2,24 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.restrictor = void 0;
 const c = require("./class");
-const { MiniSemaphore: MS } = c;
-const internalLock = new MS(1);
-let locks = Object.create(null);
-const get = async (key, restriction) => {
-    await internalLock.acquire(false);
-    let lock = locks[key];
-    if (!lock) {
-        locks[key] = lock = new MS(restriction);
-    }
-    if (lock.limit !== restriction) {
-        internalLock.release();
-        throw new ReferenceError(`Cannot get object with different restriction: key: '${key}', lock.limit: ${lock.limit} <-> restriction: ${restriction},`);
-    }
-    internalLock.release();
-    return lock;
-};
 var restrictor;
 (function (restrictor) {
+    const { MiniSemaphore: MS } = c;
+    const internalLock = new MS(1);
+    let locks = Object.create(null);
+    const get = async (key, restriction) => {
+        await internalLock.acquire(false);
+        let lock = locks[key];
+        if (!lock) {
+            locks[key] = lock = new MS(restriction);
+        }
+        if (lock.limit !== restriction) {
+            internalLock.release();
+            throw new ReferenceError(`Cannot get object with different restriction: key: '${key}', lock.limit: ${lock.limit} <-> restriction: ${restriction},`);
+        }
+        internalLock.release();
+        return lock;
+    };
     restrictor.getLockByKey = async (key) => {
         await internalLock.acquire(false);
         const l = locks[key];
@@ -31,19 +31,20 @@ var restrictor;
         const currentLocks = locks;
         const newLocks = Object.create(null);
         const keys = Object.keys(currentLocks);
-        let purgeCount = 0;
-        let purgedKeys;
+        let eliminatedCount = 0;
+        let eliminatedKeys;
+        !timeSpan && (timeSpan = 1);
         timeSpan *= 1000;
         if (debug) {
-            purgedKeys = [];
+            eliminatedKeys = [];
         }
         for (let i = 0, end = keys.length; i < end;) {
             const key = keys[i++];
             const s = currentLocks[key];
             if (s.last && Date.now() - s.last >= timeSpan) {
-                purgeCount++;
+                eliminatedCount++;
                 if (debug) {
-                    purgedKeys.push(key);
+                    eliminatedKeys.push(key);
                 }
                 continue;
             }
@@ -52,24 +53,21 @@ var restrictor;
         locks = newLocks;
         internalLock.release();
         if (debug) {
-            console.log(`purged: [\n${purgedKeys.join(",\n")}\n]` +
+            console.log(`eliminated: [\n${eliminatedKeys.join(",\n")}\n]` +
                 "\n" +
-                `lived:  [\n${Object.keys(newLocks).join(",\n")}\n]`);
+                `lived: [\n${Object.keys(newLocks).join(",\n")}\n]`);
         }
-        return purgeCount;
+        return eliminatedCount;
     };
-    const fire = async (key, restriction, pb) => {
+    async function multi(key, restriction, pb) {
         const s = await get(key, restriction);
         const result = s.flow(pb);
         s.last = Date.now();
         return result;
-    };
-    async function multi(key, restriction, pb) {
-        return fire(key, restriction, pb);
     }
     restrictor.multi = multi;
     async function one(key, pb) {
-        return fire(key, 1, pb);
+        return multi(key, 1, pb);
     }
     restrictor.one = one;
 })(restrictor = exports.restrictor || (exports.restrictor = {}));

package/cjs/index.d.ts

@@ -32,8 +32,8 @@ export declare class Deque<T extends any> {
     /**
      * @param s subject
      */
-    push(s: T): number;
-    shift(): T | undefined;
+    push(s: T): void;
+    // shift(): T | undefined;
     clear(): void;
     get length(): number;
 }
@@ -94,8 +94,8 @@ export declare type TFlowableLock<T = TVoidFunction> = IFlowableLock & {
     readonly q: Deque<T>;
 };
 export declare type TVoidFunction = () => void;
-export declare const acquire: (dis: TFlowableLock<TVoidFunction>, lazy?: boolean) => Promise<void>;
-export declare const release: (dis: TFlowableLock<TVoidFunction>) => void;
+// export declare const acquire: (dis: TFlowableLock<TVoidFunction>, lazy?: boolean) => Promise<void>;
+// export declare const release: (dis: TFlowableLock<TVoidFunction>) => void;
 
 
 /**
@@ -173,6 +173,14 @@ export declare class MiniSemaphore implements TFlowableLock {
 export declare const create: (capacity: number) => IFlowableLock;
 
 declare namespace fr {
+    /**
+     * Eliminate unused instances for the `timeSpan` seconds
+     * 
+     * @param timeSpan specify unit as seconds
+     * @returns {Promise<number>} eliminated count
+     * @date 2020/6/19
+     */
+    const cleanup: (timeSpan: number, debug?: true | undefined) => Promise<number>;
     /**
      * get the semaphore associated with the value of `key`
      *
@@ -181,7 +189,7 @@ declare namespace fr {
      * @param key
      * @returns `IFlowableLock` instance or `undefined`
      */
-    export const getLockByKey: (key: string | number) => IFlowableLock;
+    export const getLockByKey: (key: string | number) => Promise<IFlowableLock>;
     /**
      * Allocate a semaphore for each `key`, and limit the number of shares with the value of `restriction`
      *

package/cjs/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.restrictor = exports.Deque = exports.create = exports.MiniSemaphore = void 0;
 var class_1 = require("./class");
 Object.defineProperty(exports, "MiniSemaphore", { enumerable: true, get: function () { return class_1.MiniSemaphore; } });
 var object_1 = require("./object");

package/cjs/object.js

@@ -5,7 +5,7 @@ const core = require("./core");
 const deque_1 = require("./deque");
 const a = core.acquire;
 const r = core.release;
-exports.create = (capacity) => {
+const create = (capacity) => {
     return {
         capacity,
         limit: capacity,
@@ -33,3 +33,4 @@ exports.create = (capacity) => {
         }
     };
 };
+exports.create = create;

package/esm/class.js

@@ -28,4 +28,4 @@ export class MiniSemaphore {
             r(this);
         }
     }
-}
+}

package/esm/core.js

@@ -26,4 +26,4 @@ export const release = (dis) => {
         console.warn("inconsistent release!");
         dis.capacity = dis.limit;
     }
-};
+};

package/esm/deque.js

@@ -15,6 +15,7 @@ const p2l = (n) => {
     return n + 1;
 };
 const gc = (n) => {
+    // @ts-ignore typescript cannot allow (undefined | 0) expression
     return p2l(Math.min(Math.max(16, n | 0), 1073741824));
 };
 export class Deque {
@@ -32,7 +33,6 @@ export class Deque {
         const i = (this._f + l) & (this._c - 1);
         this._a[i] = s;
         this._l = l + 1;
-        return l + 1;
     }
     shift() {
         const l = this._l;
@@ -46,17 +46,6 @@ export class Deque {
         this._l = l - 1;
         return r;
     }
-    clear() {
-        const l = this._l;
-        const f = this._f;
-        const c = this._c;
-        const a = this._a;
-        for (let j = 0; j < l; ++j) {
-            a[(f + j) & (c - 1)] = void 0;
-        }
-        this._l = 0;
-        this._f = 0;
-    }
     get length() {
         return this._l;
     }
@@ -70,4 +59,4 @@ const rt = (dis, n) => {
         const mc = (f + l) & (oc - 1);
         am(dis._a, 0, dis._a, oc, mc);
     }
-};
+};

package/esm/extras.js

@@ -1,3 +1,3 @@
 export const THROW = () => {
     throw new Error("mini-semaphore: inconsistent occurred");
-};
+};

package/esm/flow-restrictor.js

@@ -1,22 +1,22 @@
 import * as c from "./class";
-const { MiniSemaphore: MS } = c;
-const internalLock = new MS(1);
-let locks = Object.create(null);
-const get = async (key, restriction) => {
-    await internalLock.acquire(false);
-    let lock = locks[key];
-    if (!lock) {
-        locks[key] = lock = new MS(restriction);
-    }
-    if (lock.limit !== restriction) {
-        internalLock.release();
-        throw new ReferenceError(`Cannot get object with different restriction: key: '${key}', lock.limit: ${lock.limit} <-> restriction: ${restriction},`);
-    }
-    internalLock.release();
-    return lock;
-};
 export var restrictor;
 (function (restrictor) {
+    const { MiniSemaphore: MS } = c;
+    const internalLock = new MS(1);
+    let locks = Object.create(null);
+    const get = async (key, restriction) => {
+        await internalLock.acquire(false);
+        let lock = locks[key];
+        if (!lock) {
+            locks[key] = lock = new MS(restriction);
+        }
+        if (lock.limit !== restriction) {
+            internalLock.release();
+            throw new ReferenceError(`Cannot get object with different restriction: key: '${key}', lock.limit: ${lock.limit} <-> restriction: ${restriction},`);
+        }
+        internalLock.release();
+        return lock;
+    };
     restrictor.getLockByKey = async (key) => {
         await internalLock.acquire(false);
         const l = locks[key];
@@ -28,19 +28,20 @@ export var restrictor;
         const currentLocks = locks;
         const newLocks = Object.create(null);
         const keys = Object.keys(currentLocks);
-        let purgeCount = 0;
-        let purgedKeys;
+        let eliminatedCount = 0;
+        let eliminatedKeys;
+        !timeSpan && (timeSpan = 1);
         timeSpan *= 1000;
         if (debug) {
-            purgedKeys = [];
+            eliminatedKeys = [];
         }
         for (let i = 0, end = keys.length; i < end;) {
             const key = keys[i++];
             const s = currentLocks[key];
             if (s.last && Date.now() - s.last >= timeSpan) {
-                purgeCount++;
+                eliminatedCount++;
                 if (debug) {
-                    purgedKeys.push(key);
+                    eliminatedKeys.push(key);
                 }
                 continue;
             }
@@ -49,24 +50,21 @@ export var restrictor;
         locks = newLocks;
         internalLock.release();
         if (debug) {
-            console.log(`purged: [\n${purgedKeys.join(",\n")}\n]` +
+            console.log(`eliminated: [\n${eliminatedKeys.join(",\n")}\n]` +
                 "\n" +
-                `lived:  [\n${Object.keys(newLocks).join(",\n")}\n]`);
+                `lived: [\n${Object.keys(newLocks).join(",\n")}\n]`);
         }
-        return purgeCount;
+        return eliminatedCount;
     };
-    const fire = async (key, restriction, pb) => {
+    async function multi(key, restriction, pb) {
         const s = await get(key, restriction);
         const result = s.flow(pb);
         s.last = Date.now();
         return result;
-    };
-    async function multi(key, restriction, pb) {
-        return fire(key, restriction, pb);
     }
     restrictor.multi = multi;
     async function one(key, pb) {
-        return fire(key, 1, pb);
+        return multi(key, 1, pb);
     }
     restrictor.one = one;
-})(restrictor || (restrictor = {}));
+})(restrictor || (restrictor = {}));

package/esm/index.d.ts

@@ -32,8 +32,8 @@ export declare class Deque<T extends any> {
     /**
      * @param s subject
      */
-    push(s: T): number;
-    shift(): T | undefined;
+    push(s: T): void;
+    // shift(): T | undefined;
     clear(): void;
     get length(): number;
 }
@@ -94,8 +94,8 @@ export declare type TFlowableLock<T = TVoidFunction> = IFlowableLock & {
     readonly q: Deque<T>;
 };
 export declare type TVoidFunction = () => void;
-export declare const acquire: (dis: TFlowableLock<TVoidFunction>, lazy?: boolean) => Promise<void>;
-export declare const release: (dis: TFlowableLock<TVoidFunction>) => void;
+// export declare const acquire: (dis: TFlowableLock<TVoidFunction>, lazy?: boolean) => Promise<void>;
+// export declare const release: (dis: TFlowableLock<TVoidFunction>) => void;
 
 
 /**
@@ -173,6 +173,14 @@ export declare class MiniSemaphore implements TFlowableLock {
 export declare const create: (capacity: number) => IFlowableLock;
 
 declare namespace fr {
+    /**
+     * Eliminate unused instances for the `timeSpan` seconds
+     * 
+     * @param timeSpan specify unit as seconds
+     * @returns {Promise<number>} eliminated count
+     * @date 2020/6/19
+     */
+    const cleanup: (timeSpan: number, debug?: true | undefined) => Promise<number>;
     /**
      * get the semaphore associated with the value of `key`
      *
@@ -181,7 +189,7 @@ declare namespace fr {
      * @param key
      * @returns `IFlowableLock` instance or `undefined`
      */
-    export const getLockByKey: (key: string | number) => IFlowableLock;
+    export const getLockByKey: (key: string | number) => Promise<IFlowableLock>;
     /**
      * Allocate a semaphore for each `key`, and limit the number of shares with the value of `restriction`
      *

package/esm/index.js

@@ -1,4 +1,4 @@
 export { MiniSemaphore } from "./class";
 export { create } from "./object";
 export { Deque } from "./deque";
-export { restrictor } from "./flow-restrictor";
+export { restrictor } from "./flow-restrictor";

package/esm/object.js

@@ -29,4 +29,4 @@ export const create = (capacity) => {
             }
         }
     };
-};
+};

package/index.d.ts

@@ -32,8 +32,8 @@ export declare class Deque<T extends any> {
     /**
      * @param s subject
      */
-    push(s: T): number;
-    shift(): T | undefined;
+    push(s: T): void;
+    // shift(): T | undefined;
     clear(): void;
     get length(): number;
 }
@@ -94,8 +94,8 @@ export declare type TFlowableLock<T = TVoidFunction> = IFlowableLock & {
     readonly q: Deque<T>;
 };
 export declare type TVoidFunction = () => void;
-export declare const acquire: (dis: TFlowableLock<TVoidFunction>, lazy?: boolean) => Promise<void>;
-export declare const release: (dis: TFlowableLock<TVoidFunction>) => void;
+// export declare const acquire: (dis: TFlowableLock<TVoidFunction>, lazy?: boolean) => Promise<void>;
+// export declare const release: (dis: TFlowableLock<TVoidFunction>) => void;
 
 
 /**
@@ -173,6 +173,14 @@ export declare class MiniSemaphore implements TFlowableLock {
 export declare const create: (capacity: number) => IFlowableLock;
 
 declare namespace fr {
+    /**
+     * Eliminate unused instances for the `timeSpan` seconds
+     * 
+     * @param timeSpan specify unit as seconds
+     * @returns {Promise<number>} eliminated count
+     * @date 2020/6/19
+     */
+    const cleanup: (timeSpan: number, debug?: true | undefined) => Promise<number>;
     /**
      * get the semaphore associated with the value of `key`
      *
@@ -181,7 +189,7 @@ declare namespace fr {
      * @param key
      * @returns `IFlowableLock` instance or `undefined`
      */
-    export const getLockByKey: (key: string | number) => IFlowableLock;
+    export const getLockByKey: (key: string | number) => Promise<IFlowableLock>;
     /**
      * Allocate a semaphore for each `key`, and limit the number of shares with the value of `restriction`
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-semaphore",
-  "version": "1.3.0",
+  "version": "1.3.7",
   "description": "A lightweight version of Semaphore",
   "private": false,
   "main": "./cjs/index.js",
@@ -20,7 +20,7 @@
     "url": "git+https://github.com/jeffy-g/mini-semaphore.git"
   },
   "engines": {
-    "node": ">=10",
+    "node": ">=v12.22.10",
     "yarn": "^1.22.4"
   },
   "files": [

package/umd/index.d.ts

@@ -32,8 +32,8 @@ export declare class Deque<T extends any> {
     /**
      * @param s subject
      */
-    push(s: T): number;
-    shift(): T | undefined;
+    push(s: T): void;
+    // shift(): T | undefined;
     clear(): void;
     get length(): number;
 }
@@ -94,8 +94,8 @@ export declare type TFlowableLock<T = TVoidFunction> = IFlowableLock & {
     readonly q: Deque<T>;
 };
 export declare type TVoidFunction = () => void;
-export declare const acquire: (dis: TFlowableLock<TVoidFunction>, lazy?: boolean) => Promise<void>;
-export declare const release: (dis: TFlowableLock<TVoidFunction>) => void;
+// export declare const acquire: (dis: TFlowableLock<TVoidFunction>, lazy?: boolean) => Promise<void>;
+// export declare const release: (dis: TFlowableLock<TVoidFunction>) => void;
 
 
 /**
@@ -173,6 +173,14 @@ export declare class MiniSemaphore implements TFlowableLock {
 export declare const create: (capacity: number) => IFlowableLock;
 
 declare namespace fr {
+    /**
+     * Eliminate unused instances for the `timeSpan` seconds
+     * 
+     * @param timeSpan specify unit as seconds
+     * @returns {Promise<number>} eliminated count
+     * @date 2020/6/19
+     */
+    const cleanup: (timeSpan: number, debug?: true | undefined) => Promise<number>;
     /**
      * get the semaphore associated with the value of `key`
      *
@@ -181,7 +189,7 @@ declare namespace fr {
      * @param key
      * @returns `IFlowableLock` instance or `undefined`
      */
-    export const getLockByKey: (key: string | number) => IFlowableLock;
+    export const getLockByKey: (key: string | number) => Promise<IFlowableLock>;
     /**
      * Allocate a semaphore for each `key`, and limit the number of shares with the value of `restriction`
      *