@endgame45/nodescript 1.0.1 → 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 horizonstudios
+
+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/README.md

@@ -0,0 +1,85 @@
+# nodescript
+
+Node.js logging and scheduling utility with easy chalk styling.
+
+Features
+- Simple styled logging: nsc.log, nsc.info, nsc.warn, nsc.error, nsc.debug
+- Namespaced loggers: nsc.create(namespace, opts)
+- Auto color detection (respects NO_COLOR and TTY)
+- Timestamping (ISO/local/custom)
+- Color parsing: hex, rgb/rgba, hsl/hsla, CSS keywords (alpha blended)
+- Themes and tagged-template styling
+- Flow control utilities: debounce, throttle, retry/backoff, pLimit
+- Looping helpers with concurrency
+
+Installation
+
+npm install nodescript
+
+Quick examples
+
+Basic logging
+
+```javascript
+const nsc = require('nodescript');
+nsc.info('Hello %s', 'world');
+nsc.warn('This is a warning');
+nsc.error('Oops: %s', 'failure');
+
+// change global level
+nsc.level = 'debug';
+```
+
+Namespaced logger
+
+```javascript
+const db = nsc.create('db', { textColor: 'cyan', level: 'debug', timestamp: { enabled: true } });
+db.debug('Connected to %s', 'postgres://...');
+```
+
+Themes
+
+```javascript
+nsc.registerTheme('errorTheme', { textColor: '#ff4444', font: 'bold', level: 'error' });
+const err = nsc.useTheme('errorTheme');
+err.error('Fatal: %s', 'something broke');
+```
+
+Tagged template styling
+
+```javascript
+const name = 'Alice';
+console.log(nsc.style`Hello, ${name}!`);
+nsc.tagLog`Processed ${42} items for ${() => name}`;
+```
+
+Looping and concurrency
+
+```javascript
+// run task 50 times with up to 5 concurrent executions
+await nsc.loop.duration('200ms').call(asyncTask).concurrency(5).times(50);
+
+// start infinite loop with 2 workers
+const ctl = nsc.loop.duration('1s').call(task).concurrency(2).start();
+// stop
+ctl.stop();
+await ctl.done;
+```
+
+Utilities
+
+```javascript
+const deb = nsc.debounce(() => console.log('debounced'), 200);
+deb();
+
+const safe = await nsc.retry(async () => fetchSomething(), { retries: 5 });
+await safe();
+
+const limit = nsc.pLimit(3);
+const limited = limit(async (id) => fetch(id));
+await Promise.all(ids.map(id => limited(id)));
+```
+
+License
+
+MIT — see LICENSE file.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@endgame45/nodescript",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "main": "src/nodescript.js",
   "files": [
     "src"
@@ -24,8 +24,10 @@
     "eslint": "^7.32.0"
   },
   "url": {
-    "repository": "npmjs.com/package/@endgame45/nodescript",
+    "repository": "https://npmjs.com/package/@endgame45/nodescript",
     "type": "git",
-    "url": "github.com/horizon-std/nodescript"
-  }
+    "url": "https://github.com/horizon-std/nodescript"
+  },
+  "bugs": "https://github.com/horizon-std/nodescript/issues",
+  "readme": ""
 }

package/src/nodescript.js

@@ -1,29 +1,80 @@
 const util = require('util');
 const chalk = require('chalk');
+const utils = require('./utils');
 
 const SUPPORTED_FONTS = new Set([
     'bold', 'dim', 'italic', 'underline', 'inverse', 'hidden', 'strikethrough'
 ]);
 
+function clamp(v, a = 0, b = 255) {
+    return Math.min(b, Math.max(a, Math.round(Number(v) || 0)));
+}
+
+function hslToRgb(h, s, l) {
+    // h: 0-360, s,l: 0-1
+    h = ((h % 360) + 360) % 360;
+    s = Math.max(0, Math.min(1, s));
+    l = Math.max(0, Math.min(1, l));
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+    const m = l - c / 2;
+    let r1 = 0; let g1 = 0; let b1 = 0;
+    if (h < 60) { r1 = c; g1 = x; b1 = 0; }
+    else if (h < 120) { r1 = x; g1 = c; b1 = 0; }
+    else if (h < 180) { r1 = 0; g1 = c; b1 = x; }
+    else if (h < 240) { r1 = 0; g1 = x; b1 = c; }
+    else if (h < 300) { r1 = x; g1 = 0; b1 = c; }
+    else { r1 = c; g1 = 0; b1 = x; }
+    return [ clamp((r1 + m) * 255), clamp((g1 + m) * 255), clamp((b1 + m) * 255) ];
+}
+
+function blendOverBg(r, g, b, a, bgR = 0, bgG = 0, bgB = 0) {
+    // alpha in 0..1
+    const alpha = Math.max(0, Math.min(1, Number(a) || 0));
+    const rr = Math.round((1 - alpha) * bgR + alpha * r);
+    const gg = Math.round((1 - alpha) * bgG + alpha * g);
+    const bb = Math.round((1 - alpha) * bgB + alpha * b);
+    return [clamp(rr), clamp(gg), clamp(bb)];
+}
+
 function parseColor(styler, color, isBg = false) {
     if (!color) return styler;
     const c = String(color).trim();
+    // hex
+    if (/^#([0-9a-f]{3}|[0-9a-f]{6})$/i.test(c)) {
+        return isBg ? styler.bgHex(c) : styler.hex(c);
+    }
+    // rgb() or rgba()
+    const rgbMatch = c.match(/^rgba?\s*\(([^)]+)\)$/i);
+    if (rgbMatch) {
+        const parts = rgbMatch[1].split(',').map(s => s.trim());
+        const r = parseInt(parts[0], 10) || 0;
+        const g = parseInt(parts[1], 10) || 0;
+        const b = parseInt(parts[2], 10) || 0;
+        const a = parts[3] !== undefined ? parseFloat(parts[3]) : 1;
+        if (a >= 1) return isBg ? styler.bgRgb(r, g, b) : styler.rgb(r, g, b);
+        // blend alpha over background if provided via isBg===false and styler has bgColor; we don't know bg, assume black
+        const [rr, gg, bb] = blendOverBg(r, g, b, a, 0, 0, 0);
+        return isBg ? styler.bgRgb(rr, gg, bb) : styler.rgb(rr, gg, bb);
+    }
+    // hsl() or hsla()
+    const hslMatch = c.match(/^hsla?\s*\(([^)]+)\)$/i);
+    if (hslMatch) {
+        const parts = hslMatch[1].split(',').map(s => s.trim());
+        const h = parseFloat(parts[0]) || 0;
+        const s = (String(parts[1]).replace('%', '') || 0) / 100;
+        const l = (String(parts[2]).replace('%', '') || 0) / 100;
+        const a = parts[3] !== undefined ? parseFloat(parts[3]) : 1;
+        const [r, g, b] = hslToRgb(h, s, l);
+        if (a >= 1) return isBg ? styler.bgRgb(r, g, b) : styler.rgb(r, g, b);
+        const [rr, gg, bb] = blendOverBg(r, g, b, a, 0, 0, 0);
+        return isBg ? styler.bgRgb(rr, gg, bb) : styler.rgb(rr, gg, bb);
+    }
+    // fallback to CSS keyword (named color)
     try {
-        if (/^#/.test(c)) {
-            return isBg ? styler.bgHex(c) : styler.hex(c);
-        }
-        if (/^rgb\(/i.test(c)) {
-            const nums = c
-                .replace(/^[^(]*\(/, '')
-                .replace(/\).*/, '')
-                .split(',')
-                .map(n => parseInt(n, 10) || 0);
-            return isBg ? styler.bgRgb(nums[0], nums[1], nums[2]) : styler.rgb(nums[0], nums[1], nums[2]);
-        }
-        // fallback to CSS keyword (named color)
         return isBg ? styler.bgKeyword(c) : styler.keyword(c);
     } catch (e) {
-        return styler; // if chalk call fails, return base styler
+        return styler;
     }
 }
 
@@ -111,6 +162,7 @@ class LoopBuilder {
         this.fn = null;
         this.fnArgs = [];
         this._stopped = false;
+        this.concurrency = 1;
     }
 
     // set duration (accepts same inputs as parseDuration)
@@ -120,6 +172,12 @@ class LoopBuilder {
     }
     every(d) { return this.duration(d); }
 
+    // set concurrency for parallel execution (for times/start)
+    concurrency(n) {
+        this.concurrency = Math.max(1, Math.floor(Number(n) || 1));
+        return this;
+    }
+
     // set target function to call; fn can be sync or async
     call(fn, ...args) {
         if (typeof fn !== 'function') {
@@ -146,12 +204,41 @@ class LoopBuilder {
         if (!Number.isFinite(n) || n < 0) throw new TypeError('times(n) expects a non-negative number');
 
         this._stopped = false;
-        for (let i = 0; i < n; i++) {
-            if (this._stopped) break;
-            const res = this.fn(...this.fnArgs);
-            if (res && typeof res.then === 'function') await res;
-            if (i < n - 1 && this.durationMs > 0) await sleep(this.durationMs);
+        if (!this.concurrency || this.concurrency <= 1) {
+            for (let i = 0; i < n; i++) {
+                if (this._stopped) break;
+                const res = this.fn(...this.fnArgs);
+                if (res && typeof res.then === 'function') await res;
+                if (i < n - 1 && this.durationMs > 0) await sleep(this.durationMs);
+            }
+            return this;
         }
+
+        // concurrency > 1: launch up to concurrency parallel runners
+        let launched = 0;
+        const errors = [];
+
+        const runner = async () => {
+            while (!this._stopped) {
+                const idx = launched++;
+                if (idx >= n) break;
+                try {
+                    const res = this.fn(...this.fnArgs);
+                    if (res && typeof res.then === 'function') await res;
+                } catch (err) {
+                    errors.push(err);
+                    this._stopped = true;
+                    break;
+                }
+                if (this.durationMs > 0 && launched < n) await sleep(this.durationMs);
+            }
+        };
+
+        const runners = [];
+        const concurrency = Math.min(this.concurrency, n);
+        for (let i = 0; i < concurrency; i++) runners.push(runner());
+        await Promise.all(runners);
+        if (errors.length) throw errors[0];
         return this;
     }
 
@@ -199,9 +286,10 @@ class LoopBuilder {
     start() {
         if (!this.fn) throw new Error('No function set. Use .call(fn) before .start()');
         this._stopped = false;
-        const done = (async () => {
-            try {
-                // run forever until stopped
+        const runners = [];
+        const concurrency = Math.max(1, this.concurrency || 1);
+        for (let i = 0; i < concurrency; i++) {
+            const p = (async () => {
                 while (!this._stopped) {
                     const res = this.fn(...this.fnArgs);
                     if (res && typeof res.then === 'function') await res;
@@ -209,14 +297,12 @@ class LoopBuilder {
                         await Promise.race([sleep(this.durationMs), new Promise(r => { this._stopResolve = r; })]);
                     }
                 }
-            } finally {
-                // noop
-            }
-        })();
-        return {
-            stop: () => this.stop(),
-            done
-        };
+            })();
+            runners.push(p);
+        }
+
+        const done = Promise.all(runners).then(() => undefined);
+        return { stop: () => this.stop(), done };
     }
 }
 
@@ -225,8 +311,35 @@ const nsc = {
     textColor: null,
     bgColor: null,
     font: null,
+    namespace: null,
+    // logging level: error, warn, info, debug
+    level: 'info',
+    levels: { error: 0, warn: 1, info: 2, debug: 3 },
+    // auto color detection (respects NO_COLOR and TTY)
+    autoColor: true,
+    // timestamping options: { enabled: false, format: 'iso'|'local'|function }
+    timestamp: { enabled: false, format: 'iso' },
+
+    _colorEnabled() {
+        if (!this.autoColor) return false;
+        if (process && process.env && process.env.NO_COLOR) return false;
+        return Boolean(process && process.stdout && process.stdout.isTTY);
+    },
 
     _getStyler() {
+        if (!this._colorEnabled()) {
+            // minimal no-color styler that mimics chalk chaining API
+            const noColor = (s) => String(s);
+            const fonts = ['bold', 'dim', 'italic', 'underline', 'inverse', 'hidden', 'strikethrough'];
+            for (const f of fonts) noColor[f] = noColor;
+            noColor.hex = () => noColor;
+            noColor.bgHex = () => noColor;
+            noColor.rgb = () => noColor;
+            noColor.bgRgb = () => noColor;
+            noColor.keyword = () => noColor;
+            noColor.bgKeyword = () => noColor;
+            return noColor;
+        }
         return buildStyler({
             textColor: this.textColor,
             bgColor: this.bgColor,
@@ -234,36 +347,81 @@ const nsc = {
         });
     },
 
-    // nsc.log can be used in two ways:
-    // 1) nsc.log('a', 'b', 123)
-    // 2) nsc.log(() => { console.log('inside will be styled') })   <-- temporary override of console.log
-    log(...args) {
-        // callback-mode: override console.log while invoking the function
+    _formatPrefix(level) {
+        const parts = [];
+        if (this.timestamp && this.timestamp.enabled) {
+            const fmt = this.timestamp.format;
+            let ts = '';
+            if (typeof fmt === 'function') ts = String(fmt());
+            else if (fmt === 'local') ts = new Date().toLocaleString();
+            else ts = new Date().toISOString();
+            parts.push(ts);
+        }
+        if (this.namespace) parts.push(this.namespace);
+        if (level) parts.push(level.toUpperCase());
+        return parts.length ? '[' + parts.join('] [') + '] ' : '';
+    },
+
+    _shouldLog(level) {
+        const cur = this.levels[this.level] ?? 2;
+        const lvl = this.levels[level] ?? 2;
+        return lvl <= cur;
+    },
+
+    _printStyled(text, level) {
+        // choose effective color without mutating instance
+        let defaultColor;
+        switch (level) {
+            case 'error': defaultColor = 'red'; break;
+            case 'warn': defaultColor = 'yellow'; break;
+            case 'info': defaultColor = 'cyan'; break;
+            case 'debug': defaultColor = 'magenta'; break;
+            default: defaultColor = null; break;
+        }
+        let styler;
+        if (!this._colorEnabled()) {
+            const noColor = (s) => String(s);
+            const fonts = ['bold', 'dim', 'italic', 'underline', 'inverse', 'hidden', 'strikethrough'];
+            for (const f of fonts) noColor[f] = noColor;
+            noColor.hex = () => noColor;
+            noColor.bgHex = () => noColor;
+            noColor.rgb = () => noColor;
+            noColor.bgRgb = () => noColor;
+            noColor.keyword = () => noColor;
+            noColor.bgKeyword = () => noColor;
+            styler = noColor;
+        } else {
+            styler = buildStyler({
+                textColor: this.textColor || defaultColor,
+                bgColor: this.bgColor,
+                font: this.font
+            });
+        }
+        const out = styler(text);
+        console.log(out);
+    },
+
+    // low-level logging method used by level helpers
+    _log(level, ...args) {
+        if (level && !this._shouldLog(level)) return;
+        // support callback-mode where a function temporarily overrides console.log
         if (args.length === 1 && typeof args[0] === 'function') {
             const fn = args[0];
             const originalLog = console.log;
+            const prefix = this._formatPrefix(level);
             const styler = this._getStyler();
 
             console.log = (...innerArgs) => {
                 const out = util.format(...innerArgs);
-                originalLog(styler(out));
+                originalLog(prefix + styler(out));
             };
 
             try {
                 const result = fn();
-                // support async callbacks (promises)
                 if (result && typeof result.then === 'function') {
-                    return result
-                        .then(res => {
-                            console.log = originalLog;
-                            return res;
-                        })
-                        .catch(err => {
-                            console.log = originalLog;
-                            throw err;
-                        });
+                    return result.then((res) => { console.log = originalLog; return res; })
+                        .catch((err) => { console.log = originalLog; throw err; });
                 }
-                // sync
                 console.log = originalLog;
                 return result;
             } catch (err) {
@@ -272,12 +430,99 @@ const nsc = {
             }
         }
 
-        // normal-mode: format args and print styled
+        const prefix = this._formatPrefix(level);
+        const message = util.format(...args);
+        // combine prefix and message
+        const full = prefix + message;
+        this._printStyled(full, level);
+    },
+
+    // public API: default log (info-level)
+    log(...args) { return this._log('info', ...args); },
+
+    info(...args) { return this._log('info', ...args); },
+    warn(...args) { return this._log('warn', ...args); },
+    error(...args) { return this._log('error', ...args); },
+    debug(...args) { return this._log('debug', ...args); },
+
+    // create a namespaced logger instance with optional defaults
+    create(namespace, opts = {}) {
+        const inst = Object.create(this);
+        inst.namespace = namespace || null;
+        if (opts.textColor) inst.textColor = opts.textColor;
+        if (opts.bgColor) inst.bgColor = opts.bgColor;
+        if (opts.font) inst.font = opts.font;
+        if (opts.level) inst.level = opts.level;
+        if (typeof opts.autoColor === 'boolean') inst.autoColor = opts.autoColor;
+        if (opts.timestamp) inst.timestamp = Object.assign({}, inst.timestamp, opts.timestamp);
+        // bind methods to instance for convenience
+        inst.log = inst.log.bind(inst);
+        inst.info = inst.info.bind(inst);
+        inst.warn = inst.warn.bind(inst);
+        inst.error = inst.error.bind(inst);
+        inst.debug = inst.debug.bind(inst);
+        inst.create = inst.create.bind(inst);
+        return inst;
+    },
+    // theme registry
+    _themes: new Map(),
+    registerTheme(name, opts) {
+        if (!name || typeof name !== 'string') throw new TypeError('theme name must be a string');
+        if (!opts || typeof opts !== 'object') throw new TypeError('theme opts must be an object');
+        // store a shallow copy
+        this._themes.set(name, Object.assign({}, opts));
+        return this;
+    },
+    getTheme(name) {
+        return this._themes.get(name) || null;
+    },
+    // apply theme to this instance (mutates)
+    applyTheme(name) {
+        const t = this.getTheme(name);
+        if (!t) throw new Error('unknown theme: ' + name);
+        if (t.textColor) this.textColor = t.textColor;
+        if (t.bgColor) this.bgColor = t.bgColor;
+        if (t.font) this.font = t.font;
+        if (t.level) this.level = t.level;
+        if (t.timestamp) this.timestamp = Object.assign({}, this.timestamp, t.timestamp);
+        return this;
+    },
+    // return a new instance pre-configured with theme
+    useTheme(name) {
+        const t = this.getTheme(name);
+        if (!t) throw new Error('unknown theme: ' + name);
+        return this.create(null, t);
+    },
+
+    // tagged template helper: returns styled string (does not log)
+    style(strings, ...values) {
+        // combine template parts, evaluating functions
+        const parts = [];
+        for (let i = 0; i < strings.length; i++) {
+            parts.push(strings[i]);
+            if (i < values.length) {
+                const v = values[i];
+                if (typeof v === 'function') parts.push(String(v()));
+                else parts.push(String(v));
+            }
+        }
+        const full = parts.join('');
         const styler = this._getStyler();
-        const out = util.format(...args);
-        console.log(styler(out));
+        return styler(full);
     },
 
+    // convenience: styled log via template tag
+    tagLog(strings, ...values) {
+        const s = this.style(strings, ...values);
+        console.log(s);
+    },
+
+    // utilities: debounce/throttle/retry/pLimit
+    debounce: utils.debounce,
+    throttle: utils.throttle,
+    retry: utils.retry,
+    pLimit: utils.pLimit,
+
     /**
      * Wait for the given duration and resolve the returned Promise.
      * - numeric values are treated as seconds

package/src/utils.js

@@ -0,0 +1,135 @@
+// Utility helpers: debounce, throttle, retry/backoff, pLimit
+'use strict';
+
+function debounce(fn, wait = 0, options = {}) {
+  let timer = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let resolveFlush = null;
+
+  const debounced = function (...args) {
+    lastArgs = args;
+    lastThis = this;
+    if (timer) clearTimeout(timer);
+    if (options.leading && !timer) {
+      fn.apply(lastThis, lastArgs);
+    }
+    return new Promise((resolve) => {
+      resolveFlush = resolve;
+      timer = setTimeout(() => {
+        timer = null;
+        if (!options.leading) fn.apply(lastThis, lastArgs);
+        if (resolveFlush) {
+          resolveFlush();
+          resolveFlush = null;
+        }
+      }, wait);
+    });
+  };
+  debounced.cancel = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+    lastArgs = null;
+    lastThis = null;
+    if (resolveFlush) { resolveFlush(); resolveFlush = null; }
+  };
+  debounced.flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+      if (!options.leading && lastArgs) fn.apply(lastThis, lastArgs);
+      if (resolveFlush) { resolveFlush(); resolveFlush = null; }
+    }
+  };
+  return debounced;
+}
+
+function throttle(fn, wait = 0, options = {}) {
+  let lastCall = 0;
+  let timer = null;
+  let lastArgs = null;
+  let lastThis = null;
+
+  const throttled = function (...args) {
+    const now = Date.now();
+    const remaining = wait - (now - lastCall);
+    lastArgs = args;
+    lastThis = this;
+    if (remaining <= 0 || remaining > wait) {
+      if (timer) { clearTimeout(timer); timer = null; }
+      lastCall = now;
+      fn.apply(lastThis, lastArgs);
+    } else if (!timer && options.trailing !== false) {
+      timer = setTimeout(() => {
+        lastCall = Date.now();
+        timer = null;
+        fn.apply(lastThis, lastArgs);
+      }, remaining);
+    }
+  };
+  throttled.cancel = () => { if (timer) clearTimeout(timer); timer = null; };
+  return throttled;
+}
+
+async function retry(fn, opts = {}) {
+  const retries = Number(opts.retries == null ? 3 : opts.retries);
+  const minDelay = Number(opts.minDelay == null ? 100 : opts.minDelay);
+  const maxDelay = Number(opts.maxDelay == null ? 1000 : opts.maxDelay);
+  const factor = Number(opts.factor == null ? 2 : opts.factor);
+  const jitter = opts.jitter !== false;
+
+  let attempt = 0;
+  const exec = async (...args) => {
+    let lastErr;
+    while (attempt <= retries) {
+      try {
+        return await fn(...args);
+      } catch (err) {
+        lastErr = err;
+        if (attempt === retries) break;
+        attempt += 1;
+        let delay = Math.min(maxDelay, minDelay * Math.pow(factor, attempt - 1));
+        if (jitter) delay = Math.random() * delay;
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+    throw lastErr;
+  };
+  return exec;
+}
+
+function pLimit(concurrency = 1) {
+  const queue = [];
+  let activeCount = 0;
+
+  const next = () => {
+    if (queue.length === 0) return;
+    if (activeCount >= concurrency) return;
+    activeCount += 1;
+    const item = queue.shift();
+    const { fn, resolve, reject } = item;
+    (async () => {
+      try {
+        const result = await fn();
+        resolve(result);
+      } catch (e) {
+        reject(e);
+      } finally {
+        activeCount -= 1;
+        next();
+      }
+    })();
+  };
+
+  return (fn) => (...args) => new Promise((resolve, reject) => {
+    queue.push({ fn: () => fn(...args), resolve, reject });
+    next();
+  });
+}
+
+module.exports = {
+  debounce,
+  throttle,
+  retry,
+  pLimit
+};