mini-semaphore 1.3.4 → 1.3.10

package/esm/{deque.js → deque.mjs}

@@ -1,9 +1,22 @@
-const am = (src, si, dst, di, len) => {
+/**
+ * arrayMove
+ *
+ * @param src
+ * @param si
+ * @param dst
+ * @param di
+ * @param len
+ */
+const am = /* istanbul ignore next */ (src, si, dst, di, len) => {
     for (let j = 0; j < len; ++j) {
         dst[j + di] = src[j + si];
         src[j + si] = void 0;
     }
 };
+/**
+ * pow2AtLeast
+ * @param n
+ */
 const p2l = (n) => {
     n = n >>> 0;
     n = n - 1;
@@ -14,16 +27,34 @@ const p2l = (n) => {
     n = n | (n >> 16);
     return n + 1;
 };
+/**
+ * getCapacity
+ * @param n
+ */
 const gc = (n) => {
+    // @ts-ignore typescript cannot allow (undefined | 0) expression
     return p2l(Math.min(Math.max(16, n | 0), 1073741824));
 };
+/**
+ * ### Implementation restricted to FIFO
+ *
+ * this class is based on https://github.com/petkaantonov/deque/blob/master/js/deque.js
+ * Released under the MIT License: https://github.com/petkaantonov/deque/blob/master/LICENSE
+ */
 export class Deque {
+    /**
+     * default capacity `16`
+     * @param ic initial capacity
+     */
     constructor(ic) {
         this._c = gc(ic);
         this._l = 0;
         this._f = 0;
         this._a = [];
     }
+    /**
+     * @param s subject
+     */
     push(s) {
         const l = this._l;
         if (this._c < l + 1) {
@@ -35,6 +66,7 @@ export class Deque {
     }
     shift() {
         const l = this._l;
+        /* istanbul ignore if */
         if (l === 0) {
             return void 0;
         }
@@ -49,13 +81,19 @@ export class Deque {
         return this._l;
     }
 }
+/**
+ * resize to
+ *
+ * @param n expected capacity
+ */
 const rt = (dis, n) => {
     const oc = dis._c;
     dis._c = n;
     const f = dis._f;
     const l = dis._l;
+    /* istanbul ignore next */
     if (f + l > oc) {
         const mc = (f + l) & (oc - 1);
         am(dis._a, 0, dis._a, oc, mc);
     }
-};
+};

package/esm/{extras.js → extras.mjs}

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

package/esm/{flow-restrictor.js → flow-restrictor.mjs}

@@ -1,9 +1,39 @@
-import * as c from "./class";
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2020 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file Utility module using `MiniSemaphore`
+ * @author jeffy-g <hirotom1107@gmail.com>
+ * @version 1.0
+ */
+import * as c from "./class.mjs";
+/**
+ * @typedef {string | number} TLockRecordKey
+ */
+/**
+ * Flow Restriction
+ */
 export var restrictor;
 (function (restrictor) {
     const { MiniSemaphore: MS } = c;
+    /**
+     * @internal
+     */
     const internalLock = new MS(1);
+    /**
+     *
+     */
     let locks = Object.create(null);
+    /**
+     *
+     * @param {TLockRecordKey} key
+     * @param {number} restriction
+     * @throws when different restriction
+     */
     const get = async (key, restriction) => {
         await internalLock.acquire(false);
         let lock = locks[key];
@@ -17,12 +47,28 @@ export var restrictor;
         internalLock.release();
         return lock;
     };
+    /**
+     * get the semaphore associated with the value of `key`
+     *
+     *   + ⚠️ The object to be retrieved with `key` must already be created with `multi` ore `one`
+     *
+     * @param {TLockRecordKey} key
+     * @returns `IFlowableLock` instance or `undefined`
+     */
     restrictor.getLockByKey = async (key) => {
         await internalLock.acquire(false);
         const l = locks[key];
         internalLock.release();
         return l;
     };
+    /**
+     * Eliminate unused instances for the `timeSpan` seconds
+     *
+     * @param {number} timeSpan specify unit as seconds
+     * @param {true} [debug] enable debug
+     * @returns {Promise<number>} eliminated count
+     * @date 2020/6/19
+     */
     restrictor.cleanup = async (timeSpan, debug) => {
         await internalLock.acquire(false);
         const currentLocks = locks;
@@ -30,7 +76,7 @@ export var restrictor;
         const keys = Object.keys(currentLocks);
         let eliminatedCount = 0;
         let eliminatedKeys;
-        !timeSpan && (timeSpan = 1);
+        !timeSpan && /* istanbul ignore next */ (timeSpan = 1);
         timeSpan *= 1000;
         if (debug) {
             eliminatedKeys = [];
@@ -56,6 +102,14 @@ export var restrictor;
         }
         return eliminatedCount;
     };
+    /**
+     * Allocate a semaphore for each `key`, and limit the number of shares with the value of `restriction`
+     *
+     * @template {any} T
+     * @param {TLockRecordKey} key number or string as tag
+     * @param {number} restriction number of process restriction
+     * @param {() => Promise<T>} pb the process body
+     */
     async function multi(key, restriction, pb) {
         const s = await get(key, restriction);
         const result = s.flow(pb);
@@ -63,8 +117,18 @@ export var restrictor;
         return result;
     }
     restrictor.multi = multi;
+    /**
+     * synonym of `multi(key, 1, pb)`
+     *
+     *  + use case
+     *    * Avoid concurrent requests to the same url
+     *
+     * @template {any} T
+     * @param {TLockRecordKey} key number or string as tag
+     * @param {() => Promise<T>} pb the process body
+     */
     async function one(key, pb) {
         return multi(key, 1, pb);
     }
     restrictor.one = one;
-})(restrictor || (restrictor = {}));
+})(restrictor || (restrictor = {}));

package/esm/index.d.ts

@@ -94,8 +94,6 @@ 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;
 
 
 /**

package/esm/index.mjs

@@ -0,0 +1,12 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2020 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+export { MiniSemaphore } from "./class.mjs";
+export { create } from "./object.mjs";
+export { Deque } from "./deque.mjs";
+export { restrictor } from "./flow-restrictor.mjs";
+export const version = "v1.3.10";

package/esm/object.mjs

@@ -0,0 +1,67 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2020 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file minimal implementation of semaphore (object implementation
+ * @author jeffy-g <hirotom1107@gmail.com>
+ * @version 1.0
+ */
+import * as core from "./core.mjs";
+import { Deque } from "./deque.mjs";
+const a = core.acquire;
+const r = core.release;
+/**
+ * object implementation of `IFlowableLock`
+ *
+ *   + constructs a semaphore object limited at `capacity`
+ *
+ * @param {number} capacity limitation of concurrent async by `capacity`
+ * @date 2020/2/7
+ * @version 1.0
+ */
+export const create = (capacity) => {
+    return {
+        capacity,
+        limit: capacity,
+        q: new Deque(capacity),
+        /**
+         *
+         * @param {boolean} [lazy]
+         * @returns {Promise<void>}
+         */
+        acquire(lazy) {
+            return a(this, lazy);
+        },
+        release() {
+            r(this);
+        },
+        /**
+         * @param {number} restriction
+         */
+        setRestriction(restriction) {
+            this.limit = this.capacity = restriction;
+        },
+        get pending() {
+            return this.q.length;
+        },
+        /**
+         * @template {any} T
+         * @param {() => Promise<T>} process
+         * @param {boolean} [lazy]
+         * @returns {Promise<T>}
+         */
+        async flow(process, lazy) {
+            await a(this, lazy);
+            try {
+                return await process();
+            }
+            finally {
+                r(this);
+            }
+        }
+    };
+};

package/index.d.ts

@@ -94,8 +94,6 @@ 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;
 
 
 /**

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "mini-semaphore",
-  "version": "1.3.4",
+  "version": "1.3.10",
   "description": "A lightweight version of Semaphore",
   "private": false,
   "main": "./cjs/index.js",
-  "module": "./esm/index.js",
+  "module": "./esm/index.mjs",
   "unpkg": "./umd/index.js",
   "sideEffects": false,
   "types": "./index.d.ts",
-  "typings": "./index.d.ts",
   "author": "jeffy-g",
   "license": "MIT",
   "bugs": {
@@ -20,7 +19,7 @@
     "url": "git+https://github.com/jeffy-g/mini-semaphore.git"
   },
   "engines": {
-    "node": ">=10",
+    "node": ">=v12.22.10",
     "yarn": "^1.22.4"
   },
   "files": [
@@ -31,9 +30,11 @@
     "esm",
     "umd",
     "webpack",
+    "webpack-esm",
     "*.d.ts"
   ],
   "keywords": [
+    "async",
     "lock",
     "mutex",
     "promise",

package/umd/index.d.ts

@@ -94,8 +94,6 @@ 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;
 
 
 /**

package/umd/index.js

@@ -1,158 +1,7 @@
-!function(t, e) {
- 'object' == typeof exports && 'object' == typeof module ? module.exports = e() : 'function' == typeof define && define.amd ? define([], e) : 'object' == typeof exports ? exports.MiniSema = e() : t.MiniSema = e();
-}(self, (function() {
- return (() => {
-  "use strict";
-  var t = {
-   d: (e, i) => {
-    for (var n in i) t.o(i, n) && !t.o(e, n) && Object.defineProperty(e, n, {
-     enumerable: !0,
-     get: i[n]
-    });
-   },
-   o: (t, e) => Object.prototype.hasOwnProperty.call(t, e),
-   r: t => {
-    'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(t, Symbol.toStringTag, {
-     value: 'Module'
-    }), Object.defineProperty(t, '__esModule', {
-     value: !0
-    });
-   }
-  }, e = {};
-  t.r(e), t.d(e, {
-   Deque: () => o,
-   MiniSemaphore: () => f,
-   create: () => m,
-   restrictor: () => _
-  });
-  var i = {};
-  t.r(i), t.d(i, {
-   MiniSemaphore: () => f
-  });
-  const n = () => {
-   throw new Error("mini-semaphore: inconsistent occurred");
-  }, r = (t, e) => {
-   t.capacity > 0 ? (t.capacity--, e()) : t.q.push(e);
-  }, s = (t, e = !0) => new Promise((i => {
-   e ? setTimeout((() => r(t, i)), 4) : r(t, i);
-  })), a = t => {
-   t.capacity++, t.q.length && (t.capacity -= 1, (t.q.shift() || n)()), t.capacity > t.limit && (console.warn("inconsistent release!"), 
-   t.capacity = t.limit);
-  }, c = t => (t => (t >>>= 0, t -= 1, t |= t >> 1, t |= t >> 2, t |= t >> 4, t |= t >> 8, 
-  1 + (t |= t >> 16)))(Math.min(Math.max(16, 0 | t), 1073741824));
-  class o {
-   constructor(t) {
-    this._c = c(t), this._l = 0, this._f = 0, this._a = [];
-   }
-   push(t) {
-    const e = this._l;
-    this._c < e + 1 && l(this, c(1.5 * this._c + 16));
-    const i = this._f + e & this._c - 1;
-    this._a[i] = t, this._l = e + 1;
-   }
-   shift() {
-    const t = this._l;
-    if (0 === t) return;
-    const e = this._f, i = this._a[e];
-    return this._a[e] = void 0, this._f = e + 1 & this._c - 1, this._l = t - 1, i;
-   }
-   get length() {
-    return this._l;
-   }
-  }
-  const l = (t, e) => {
-   const i = t._c;
-   t._c = e;
-   const n = t._f, r = t._l;
-   if (n + r > i) {
-    const e = n + r & i - 1;
-    ((t, e, i, n, r) => {
-     for (let s = 0; s < r; ++s) i[s + n] = t[s + e], t[s + e] = void 0;
-    })(t._a, 0, t._a, i, e);
-   }
-  }, h = s, u = a;
-  class f {
-   constructor(t) {
-    this.limit = this.capacity = t, this.q = new o(t);
-   }
-   acquire(t) {
-    return h(this, t);
-   }
-   release() {
-    u(this);
-   }
-   setRestriction(t) {
-    this.limit = this.capacity = t;
-   }
-   get pending() {
-    return this.q.length;
-   }
-   async flow(t, e) {
-    await h(this, e);
-    try {
-     return await t();
-    } finally {
-     u(this);
-    }
-   }
-  }
-  const y = s, p = a, m = t => ({
-   capacity: t,
-   limit: t,
-   q: new o(t),
-   acquire(t) {
-    return y(this, t);
-   },
-   release() {
-    p(this);
-   },
-   setRestriction(t) {
-    this.limit = this.capacity = t;
-   },
-   get pending() {
-    return this.q.length;
-   },
-   async flow(t, e) {
-    await y(this, e);
-    try {
-     return await t();
-    } finally {
-     p(this);
-    }
-   }
-  });
-  var _;
-  return function(t) {
-   const {MiniSemaphore: e} = i, n = new e(1);
-   let r = Object.create(null);
-   async function s(t, i, s) {
-    const a = await (async (t, i) => {
-     await n.acquire(!1);
-     let s = r[t];
-     if (s || (r[t] = s = new e(i)), s.limit !== i) throw n.release(), new ReferenceError(`Cannot get object with different restriction: key: '${t}', lock.limit: ${s.limit} <-> restriction: ${i},`);
-     return n.release(), s;
-    })(t, i), c = a.flow(s);
-    return a.last = Date.now(), c;
-   }
-   t.getLockByKey = async t => {
-    await n.acquire(!1);
-    const e = r[t];
-    return n.release(), e;
-   }, t.cleanup = async (t, e) => {
-    await n.acquire(!1);
-    const i = r, s = Object.create(null), a = Object.keys(i);
-    let c, o = 0;
-    !t && (t = 1), t *= 1e3, e && (c = []);
-    for (let n = 0, r = a.length; n < r; ) {
-     const r = a[n++], l = i[r];
-     l.last && Date.now() - l.last >= t ? (o++, e && c.push(r)) : s[r] = l;
-    }
-    return r = s, n.release(), e && console.log(`eliminated: [\n${c.join(",\n")}\n]\nlived: [\n${Object.keys(s).join(",\n")}\n]`), 
-    o;
-   }, t.multi = s, t.one = async function(t, e) {
-    return s(t, 1, e);
-   };
-  }(_ || (_ = {})), e;
- })();
-}));
-//# sourceMappingURL=index.js.map
+/*! For license information please see index.js.LICENSE.txt */
+!function(e,t){'object'==typeof exports&&'object'==typeof module?module.exports=t():'function'==typeof define&&define.amd?define([],t):'object'==typeof exports?exports.MiniSema=t():e.MiniSema=t()}(globalThis,(()=>(()=>{"use strict";var e={518:(e,t,i)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.MiniSemaphore=void 0;const r=i(461),n=i(761),s=r.acquire,o=r.release;t.MiniSemaphore=class{constructor(e){this.limit=this.capacity=e,this.q=new n.Deque(e)}acquire(e){return s(this,e)}release(){o(this)}setRestriction(e){this.limit=this.capacity=e}get pending(){return this.q.length}async flow(e,t){await s(this,t);try{return await e()}finally{o(this)}}}},461:(e,t,i)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.release=t.acquire=void 0;const r=i(669),n=(e,t)=>{e.capacity>0?(e.capacity--,
+t()):e.q.push(t)};t.acquire=(e,t=!0)=>new Promise((i=>{t?setTimeout((()=>n(e,i)),4):n(e,i)}));t.release=e=>{e.capacity++,e.q.length&&(e.capacity-=1,(e.q.shift()||r.THROW)()),e.capacity>e.limit&&(console.warn("inconsistent release!"),e.capacity=e.limit)}},761:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.Deque=void 0;const i=e=>(e=>(e>>>=0,e-=1,e|=e>>1,e|=e>>2,e|=e>>4,e|=e>>8,1+(e|=e>>16)))(Math.min(Math.max(16,0|e),1073741824));t.Deque=class{constructor(e){this._c=i(e),this._l=0,this._f=0,this._a=[]}push(e){const t=this._l;this._c<t+1&&r(this,i(1.5*this._c+16));const n=this._f+t&this._c-1;this._a[n]=e,this._l=t+1}shift(){const e=this._l;if(0===e)return;const t=this._f,i=this._a[t];return this._a[t]=void 0,this._f=t+1&this._c-1,this._l=e-1,i}get length(){return this._l}}
+;const r=(e,t)=>{const i=e._c;e._c=t;const r=e._f,n=e._l;if(r+n>i){const t=r+n&i-1;((e,t,i,r,n)=>{for(let s=0;s<n;++s)i[s+r]=e[s+t],e[s+t]=void 0})(e._a,0,e._a,i,t)}}},669:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.THROW=void 0;t.THROW=()=>{throw new Error("mini-semaphore: inconsistent occurred")}},464:(e,t,i)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.restrictor=void 0;const r=i(518);(e=>{const{MiniSemaphore:t}=r,i=new t(1);let n=Object.create(null);async function s(e,r,s){const o=await(async(e,r)=>{await i.acquire(!1);let s=n[e];if(s||(n[e]=s=new t(r)),s.limit!==r)throw i.release(),new ReferenceError(`Cannot get object with different restriction: key: '${e}', lock.limit: ${s.limit} <-> restriction: ${r},`);return i.release(),s})(e,r),c=o.flow(s)
+;return o.last=Date.now(),c}e.getLockByKey=async e=>{await i.acquire(!1);const t=n[e];return i.release(),t},e.cleanup=async(e,t)=>{await i.acquire(!1);const r=n,s=Object.create(null),o=Object.keys(r);let c,a=0;!e&&(e=1),e*=1e3,t&&(c=[]);for(let i=0,n=o.length;i<n;){const n=o[i++],l=r[n];l.last&&Date.now()-l.last>=e?(a++,t&&c.push(n)):s[n]=l}return n=s,i.release(),t&&console.log(`eliminated: [\n${c.join(",\n")}\n]\nlived: [\n${Object.keys(s).join(",\n")}\n]`),a},e.multi=s,e.one=async function(e,t){return s(e,1,t)}})(t.restrictor||(t.restrictor={}))},139:(e,t,i)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.create=void 0;const r=i(461),n=i(761),s=r.acquire,o=r.release;t.create=e=>({capacity:e,limit:e,q:new n.Deque(e),acquire(e){return s(this,e)},release(){o(this)},setRestriction(e){
+this.limit=this.capacity=e},get pending(){return this.q.length},async flow(e,t){await s(this,t);try{return await e()}finally{o(this)}}})}},t={};function i(r){var n=t[r];if(void 0!==n)return n.exports;var s=t[r]={exports:{}};return e[r](s,s.exports,i),s.exports}var r={};return(()=>{var e=r;Object.defineProperty(e,"__esModule",{value:!0}),e.version=e.restrictor=e.Deque=e.create=e.MiniSemaphore=void 0;var t=i(518);Object.defineProperty(e,"MiniSemaphore",{enumerable:!0,get:function(){return t.MiniSemaphore}});var n=i(139);Object.defineProperty(e,"create",{enumerable:!0,get:function(){return n.create}});var s=i(761);Object.defineProperty(e,"Deque",{enumerable:!0,get:function(){return s.Deque}});var o=i(464);Object.defineProperty(e,"restrictor",{enumerable:!0,get:function(){return o.restrictor}
+}),e.version="v1.3.10"})(),r})()));

package/umd/index.js.LICENSE.txt

@@ -0,0 +1,7 @@
+/*!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2020 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/

package/webpack/index.d.ts

@@ -94,8 +94,6 @@ 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;
 
 
 /**