fib-pool 1.6.1 → 1.7.0

package/Readme.md

@@ -1,8 +1,6 @@
 ## Generic resource pooling for fibjs
 
 [![NPM version](https://img.shields.io/npm/v/fib-pool.svg)](https://www.npmjs.org/package/fib-pool)
-[![Build Status](https://travis-ci.org/fibjs/fib-pool.svg)](https://travis-ci.org/fibjs/fib-pool)
-[![Build status](https://ci.appveyor.com/api/projects/status/p662f7ulpc4asu8s?svg=true)](https://ci.appveyor.com/project/richardo2016/fib-pool)
 
 ## Install
 
@@ -13,7 +11,8 @@ npm install fib-pool [--save]
 ## Test
 
 ```sh
-npm run ci
+npm test        # fibjs test
+npm run typecheck   # fibjs --check
 ```
 
 ## Creating a pool
@@ -103,6 +102,90 @@ var res = p("test", (conn) => {
 
 ```
 
+## Options
+
+| option | type | default | notes |
+|---|---|---|---|
+| `create` | `(name) => item` | — | required; throwing is a failure, retried up to `retry` times |
+| `destroy` | `(item) => void` | close/destroy/dispose | defaults to calling whichever of those three the item provides |
+| `maxsize` | positive integer | `10` | caps both concurrency and the number of idle items |
+| `timeout` | positive number (ms) | `60000` | how long an idle item is kept |
+| `retry` | positive integer | `1` | how many times `create` is attempted before giving up |
+| `strict` | boolean | `true` | see below |
+
+Invalid `maxsize`, `timeout` and `retry` values throw a `TypeError` when the
+pool is created rather than being silently coerced:
+
+```js
+Pool({ create: () => ({}), maxsize: 0 });      // TypeError: maxsize must be a positive integer, received 0
+Pool({ create: () => ({}), timeout: -5 });     // TypeError: timeout must be a positive number, received -5
+Pool({ create: () => ({}), retry: true });     // TypeError: retry must be a positive integer, received true
+```
+
+The idle list is capped by `maxsize` as well: a pool used with more names than
+that evicts the least recently used item (and destroys it) instead of keeping
+one idle item per name.
+
+## Reentrancy
+
+A pool cannot be acquired twice from the same fiber. The inner call would wait
+for a permit that the outer call is holding, which never arrives, so it is
+rejected instead of deadlocking:
+
+```js
+var p = Pool({ create: () => ({}), maxsize: 1 });
+
+p(() => {
+    p(() => {}); // Error: Cannot pool again from the same fiber
+});
+```
+
+Nesting different pools, or acquiring the same pool from another fiber, works as
+expected.
+
+## Strict mode (default: enabled)
+
+By default, the pool uses strict mode to prevent accessing pooled objects outside of the callback function. This helps prevent resource leaks and ensures proper resource management.
+
+```js
+var Pool = require("fib-pool");
+
+var p = Pool({
+    create: () => {
+        return { value: 1, getValue: function() { return this.value; } };
+    }
+});
+
+var leaked;
+p((obj) => {
+    leaked = obj;
+    // This works inside the pool callback
+    console.log(obj.getValue()); // OK
+});
+
+// This will throw an error: "access object outside of pool scope"
+leaked.getValue(); // Error!
+```
+
+The guarded object behaves like the item for reading and inspection —
+`key in obj`, `Object.keys(obj)`, `for...in`, `JSON.stringify(obj)` and
+`util.inspect(obj)` all report the item's own members — while the guards remain:
+
+- Setting properties on pooled objects
+- Calling `close()`, `destroy()`, or `dispose()` methods directly
+- Extracting a method and calling it after the callback returned
+
+To disable strict mode:
+
+```js
+var p = Pool({
+    create: () => {
+        return { value: 1 };
+    },
+    strict: false
+});
+```
+
 ## Clear a pool
 
 Simple example.

package/package.json

@@ -1,17 +1,11 @@
 {
     "name": "fib-pool",
-    "version": "1.6.1",
+    "version": "1.7.0",
     "description": "Generic resource pooling for fibjs",
-    "main": "./lib",
-    "types": "typings/index.d.ts",
+    "main": "./src/index.ts",
+    "type": "module",
     "repository": "git://github.com/fibjs/fib-pool.git",
     "author": "Liu Hu <lion@9465.net>",
-    "contributors": [
-        {
-            "name": "Richard",
-            "email": "richardo2016@gmail.com"
-        }
-    ],
     "homepage": "https://github.com/fibjs/fib-pool",
     "license": "MIT",
     "keywords": [
@@ -20,30 +14,7 @@
         "fibjs"
     ],
     "scripts": {
-        "build": "ftsc ./src/* --outDir lib",
         "test": "fibjs test",
-        "ci": "npm run build && npm run test",
-        "prepublishOnly": "npm run build"
-    },
-    "devDependencies": {
-        "@fibjs/ci": "^2.3.0",
-        "@fibjs/types": "^0.27.1",
-        "fib-typify": "^0.8.4"
-    },
-    "ci": {
-        "type": "travis, appveyor",
-        "version": [
-            "0.21.0",
-            "0.22.0",
-            "0.23.0",
-            "0.24.0",
-            "0.25.0",
-            "0.26.0",
-            "0.26.1",
-            "0.27.0",
-            "0.28.0",
-            "0.29.0",
-            "0.30.0"
-        ]
+        "typecheck": "fibjs --check"
     }
 }

package/src/index.ts

@@ -0,0 +1,416 @@
+import * as coroutine from 'coroutine';
+import * as util from 'util';
+
+declare namespace FibPoolNS {
+    /**
+     * The shape `create` must return. All three members are optional: the
+     * default destroy calls whichever of them the item actually provides, and
+     * a non-function value (a plain property) is ignored.
+     */
+    interface DippedItemStruct {
+        close?: unknown;
+        destroy?: unknown;
+        dispose?: unknown;
+    }
+
+    interface FibPoolOptionArgs<T extends DippedItemStruct = {}> {
+        create: (name: string) => T;
+        destroy?: (item?: T) => any;
+        maxsize?: number;
+        timeout?: number;
+        retry?: number;
+        strict?: boolean;
+    }
+
+    interface FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> {
+        (o: T_CREATED_ITEM): T_POOL_FUNC_RETURN
+    }
+
+    type FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> = {
+        <T_RETURN = T_POOL_FUNC_RETURN>(name: string, func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN
+        <T_RETURN = T_POOL_FUNC_RETURN>(func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN
+    } & {
+        connections(): number;
+        info(): {
+            maxsize: number;
+            count: number;
+            running: number;
+            wait: number;
+            timeout: number;
+        };
+        clear(): void;
+    }
+}
+
+/**
+ * Calls the value when it is a function and ignores it otherwise: a pooled item
+ * may expose a plain property named close/destroy/dispose.
+ */
+function callIfFunction(v: unknown) {
+    if (util.isFunction(v))
+        (v as (...args: any[]) => any)();
+}
+
+/**
+ * `maxsize` and `retry` are counts, `timeout` is a duration. Both are rejected
+ * up front instead of being silently coerced into a default or handed to the
+ * semaphore, which would fail far from the option that is wrong.
+ */
+function toPositiveInteger(value: unknown, name: string): number {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0 || Math.floor(value) !== value)
+        throw new TypeError(`${name} must be a positive integer, received ${String(value)}`);
+
+    return value;
+}
+
+function toPositiveNumber(value: unknown, name: string): number {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+        throw new TypeError(`${name} must be a positive number, received ${String(value)}`);
+
+    return value;
+}
+
+/**
+ * The pool always hands out an Error: `create` or the callback may throw a
+ * string, a number, or nothing at all, and the caller expects to be able to
+ * read `.message`. A thrown falsy value (0, '', false, null, undefined) is still
+ * a failure and must not be mistaken for a successful create, so this returns an
+ * Error for every input.
+ */
+function toError(e: unknown): Error {
+    if (e instanceof Error)
+        return e;
+
+    if (typeof e === 'string')
+        return new Error(e);
+
+    return new Error(String(e));
+}
+
+/**
+ * Guards a pooled item while the callback runs. The item is read through a
+ * getter rather than captured by value: once it goes back to the pool the
+ * handle must stop working, which is what the "outside of pool scope" error
+ * reports.
+ *
+ * The reflection traps matter as much as the getter: without them `key in obj`,
+ * `Object.keys`, `for...in` and `JSON.stringify` all see the empty proxy target
+ * instead of the item.
+ */
+function wrapStrict<T extends object>(item: () => T | undefined): T {
+    const current = () => {
+        const o = item();
+        if (o === undefined)
+            throw new Error("access object outside of pool scope");
+
+        return o;
+    };
+
+    return new Proxy({}, {
+        get(target, prop) {
+            if (prop === 'close' || prop === 'destroy' || prop === 'dispose')
+                throw new Error("Cannot close/destroy/dispose");
+
+            const o = current();
+            const value = (o as any)[prop];
+            if (typeof value === 'function') {
+                /* the item is resolved again when the method runs: a method
+                   extracted inside the callback and called after it returned
+                   must not keep the item alive outside its scope */
+                return function () {
+                    const self = current();
+                    return (self as any)[prop].apply(self, arguments);
+                }
+            }
+            return value;
+        },
+        has(target, prop) {
+            /* no close/destroy/dispose refusal here: the key is reported like
+               any other (ownKeys lists it too), only reading or calling those
+               members is refused, in `get` */
+            return Reflect.has(current() as object, prop);
+        },
+        ownKeys() {
+            return Reflect.ownKeys(current() as object);
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            const d = Reflect.getOwnPropertyDescriptor(current() as object, prop);
+
+            /* every key of the proxy target is configurable: a descriptor that
+               claims otherwise would break the proxy invariants */
+            return d && Object.assign(d, { configurable: true });
+        },
+        set() {
+            throw new Error("Cannot set property");
+        }
+    }) as T;
+}
+
+export default function GetPool<
+    T_CREATED_ITEM extends FibPoolNS.DippedItemStruct,
+    T_POOL_FUNC_RETURN
+> (
+    _opt: FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM> | FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM>['create'],
+    maxsize?: number,
+    timeout?: number
+): FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN> {
+    /* clean input arguments :start */
+    let opt: FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM>;
+
+    if (util.isFunction(_opt)) {
+        opt = {
+            create: _opt as (name: string) => T_CREATED_ITEM,
+            maxsize: maxsize,
+            timeout: timeout
+        };
+    } else {
+        opt = _opt as FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM>;
+    }
+
+    const create = opt.create;
+    const destroy = opt.destroy || ((o: FibPoolNS.DippedItemStruct | undefined) => {
+        /* create is allowed to return null/undefined: there is nothing to
+           destroy then */
+        if (o === null || o === undefined)
+            return;
+
+        callIfFunction(o.close);
+        callIfFunction(o.destroy);
+        callIfFunction(o.dispose);
+    });
+
+    const maxsizeValue = opt.maxsize === undefined ? 10 : toPositiveInteger(opt.maxsize, 'maxsize');
+    let timeoutValue = opt.timeout === undefined ? 60000 : toPositiveNumber(opt.timeout, 'timeout');
+
+    /* the idle scan runs at a tenth of the timeout, but never more often than
+       every 10ms */
+    let tm = timeoutValue / 10;
+    if (tm < 10)
+        tm = 10;
+
+    const retry = opt.retry === undefined ? 1 : toPositiveInteger(opt.retry, 'retry');
+    const strictMode = opt.strict === undefined ? true : opt.strict;
+    /* clean input arguments :end */
+
+    let pools = <{
+        o: T_CREATED_ITEM;
+        name: string;
+        time: Date;
+    }[]>[];
+
+    const jobs = <{
+        name: string;
+        ev: Class_Event;
+        o?: T_CREATED_ITEM;
+        e?: Error;
+    }[]>[];
+
+    let count = 0;
+    let running = 0;
+
+    const sem = new coroutine.Semaphore(maxsizeValue);
+    let clearTimer: Class_Timer | null = null;
+
+    function clearPool() {
+        const d = new Date().getTime();
+
+        while (count) {
+            const c = pools[0];
+
+            if (d - c.time.getTime() > timeoutValue) {
+                pools = pools.slice(1);
+                count--;
+
+                if (c.o !== undefined)
+                    coroutine.start(destroy, c.o);
+            } else
+                break;
+        }
+
+        if (!count) {
+            if (clearTimer) {
+                clearTimer.clear();
+                clearTimer = null;
+            }
+        } else if (!clearTimer) {
+            /* the timer must not hold the process alive: the pool is idle
+               between uses */
+            clearTimer = setInterval(clearPool, tm).unref();
+        }
+    }
+
+    /**
+     * Hand the item back: wake the first waiter bound to `name`, or park the
+     * item in the idle list. An errored item is never parked, but a successful
+     * create may legitimately produce `undefined` and is parked as is.
+     */
+    function putback(
+        name: string,
+        o: T_CREATED_ITEM | undefined,
+        e?: Error
+    ) {
+        for (let i = 0; i < jobs.length; i++) {
+            const job = jobs[i];
+            if (job.name === name) {
+                jobs.splice(i, 1);
+                job.o = o;
+                job.e = e;
+                job.ev.set();
+                return;
+            }
+        }
+
+        if (e === undefined) {
+            /* The idle list is capped by maxsize: a pool used with more names
+               than that would otherwise keep one idle item per name and grow
+               without bound. The oldest idle item gives way to the one just
+               returned, so the most recently used names stay cached. */
+            if (count >= maxsizeValue && count) {
+                const evicted = pools[0];
+                pools = pools.slice(1);
+                count--;
+                coroutine.start(destroy, evicted.o);
+            }
+
+            pools[count++] = {
+                o: o as T_CREATED_ITEM,
+                name: name,
+                time: new Date()
+            };
+        }
+    }
+
+    function connect(name: string) {
+        let o: T_CREATED_ITEM | undefined;
+        let err: Error | undefined;
+
+        for (let cn = 1; ; cn++) {
+            try {
+                o = create(name);
+                break;
+            } catch (e) {
+                /* any thrown value is a failure, including 0 or '' */
+                if (cn >= retry) {
+                    err = toError(e);
+                    break;
+                }
+            }
+        }
+
+        putback(name, o, err);
+    }
+
+    /* The fiber is used as fiber-local storage: it is the only place a marker
+       can live without leaking between fibers. A fiber that already holds an
+       item from this pool would wait on itself when it asks again, which the
+       semaphore can never satisfy once every permit is out. */
+    const fiberDepth = Symbol('fib-pool depth');
+
+    type FiberState = Class_Fiber & { [fiberDepth]?: true };
+
+    function enterFiber(): FiberState {
+        const fiber = coroutine.current() as FiberState;
+
+        if (fiber[fiberDepth])
+            throw new Error("Cannot pool again from the same fiber: the pool is already held by this callback");
+
+        fiber[fiberDepth] = true;
+
+        return fiber;
+    }
+
+    function leaveFiber(fiber: FiberState) {
+        delete fiber[fiberDepth];
+    }
+
+    const pool = ((
+        name: string | FibPoolNS.FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN>,
+        func?: FibPoolNS.FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN>
+    ) => {
+        if (typeof name === 'function') {
+            func = name;
+            name = "";
+        }
+
+        const dip = func as FibPoolNS.FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN>;
+
+        let r: T_POOL_FUNC_RETURN;
+        let o: T_CREATED_ITEM | undefined;
+        let reused = false;
+        const fiber = enterFiber();
+
+        try {
+            clearPool();
+            sem.acquire();
+
+            if (count) {
+                for (let i = count - 1; i >= 0; i--)
+                    if (pools[i].name === name) {
+                        reused = true
+                        o = pools[i].o;
+                        pools.splice(i, 1);
+                        count--;
+                        break;
+                    }
+            }
+
+            if (!reused) {
+                coroutine.start(connect, name);
+
+                const job: typeof jobs[any] = {
+                    name: name,
+                    ev: new coroutine.Event()
+                };
+                jobs.push(job);
+
+                job.ev.wait();
+                if (job.e) {
+                    sem.post();
+                    throw job.e;
+                }
+                o = job.o;
+            }
+
+            running++;
+            try {
+                const po = (strictMode && o !== null && typeof o === 'object')
+                    ? wrapStrict<T_CREATED_ITEM & object>(() => o as T_CREATED_ITEM & object)
+                    : o as T_CREATED_ITEM;
+
+                r = dip(po);
+                putback(name, o);
+                o = undefined;
+            } catch (e) {
+                if (o !== undefined)
+                    coroutine.start(destroy, o);
+                o = undefined;
+                throw toError(e);
+            } finally {
+                running--;
+                sem.post();
+                clearPool();
+            }
+
+            return r;
+        } finally {
+            leaveFiber(fiber);
+        }
+    }) as FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN>;
+
+    pool.connections = () => count
+
+    pool.info = () => ({
+        maxsize: maxsizeValue,
+        count: count,
+        running: running,
+        wait: sem.count(),
+        timeout: timeoutValue
+    })
+
+    pool.clear = () => {
+        timeoutValue = -1;
+        clearPool();
+    }
+
+    return pool;
+}

package/tsconfig.json

@@ -1,13 +1,13 @@
 {
     "compilerOptions": {
-        "target": "es6",
+        // `fibjs --check` derives its default lib from the target: with es6
+        // that is lib.dom, which collides with the fibjs built-in types.
+        // es2020 is the lowest target whose default lib stays es-only.
+        "target": "es2020",
         "module": "commonjs",
-        "alwaysStrict": false,
-        "removeComments": true,
-        "declaration": true,
-        "declarationDir": "typings",
-        "types": [
-            "@fibjs/types"
-        ]
-    }
-}
+        "noEmit": true
+    },
+    "exclude": [
+        "node_modules"
+    ]
+}

package/.travis.yml

@@ -1,99 +0,0 @@
-language: node_js
-node_js: '6'
-matrix:
-  include:
-    - os: linux
-      env:
-        - VERSION=0.21.0
-    - os: linux
-      env:
-        - VERSION=0.22.0
-    - os: linux
-      env:
-        - VERSION=0.23.0
-    - os: linux
-      env:
-        - VERSION=0.24.0
-    - os: linux
-      env:
-        - VERSION=0.25.0
-    - os: linux
-      env:
-        - VERSION=0.26.0
-    - os: linux
-      env:
-        - VERSION=0.26.1
-    - os: linux
-      env:
-        - VERSION=0.27.0
-    - os: linux
-      env:
-        - VERSION=0.28.0
-    - os: linux
-      env:
-        - VERSION=0.29.0
-    - os: linux
-      env:
-        - VERSION=0.30.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.21.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.22.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.23.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.24.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.25.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.26.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.26.1
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.27.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.28.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.29.0
-    - os: osx
-      osx_image: xcode9
-      env:
-        - VERSION=0.30.0
-before_install:
-  - OS=linux
-  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then
-      rvm install ruby-2.4.0;
-      rvm --default use 2.4.0;
-      ruby -v;
-      brew update;
-      brew install xz;
-      OS=darwin;
-    fi
-script:
-  - npm i
-  - mkdir -p ./node_modules/.bin
-  - rm -rf ./node_modules/.bin/fibjs
-  - curl -SL "https://github.com/fibjs/fibjs/releases/download/v${VERSION}/fibjs-v${VERSION}-${OS}-x64.xz" -o ./node_modules/.bin/fibjs.xz
-  - xz -d ./node_modules/.bin/fibjs.xz
-  - chmod a+x ./node_modules/.bin/fibjs
-  - npm run ci

package/appveyor.yml

@@ -1,26 +0,0 @@
-environment:
-  nodejs_version: '6'
-  matrix:
-    - VERSION: 0.21.0
-    - VERSION: 0.22.0
-    - VERSION: 0.23.0
-    - VERSION: 0.24.0
-    - VERSION: 0.25.0
-    - VERSION: 0.26.0
-    - VERSION: 0.26.1
-    - VERSION: 0.27.0
-    - VERSION: 0.28.0
-    - VERSION: 0.29.0
-    - VERSION: 0.30.0
-
-install:
-  - ps: Install-Product node $env:nodejs_version
-  - npm i
-  - If Not Exist "node_modules\.bin" (mkdir node_modules\.bin)
-  - curl -fsSL -o node_modules\.bin\fibjs.cab "https://github.com/fibjs/fibjs/releases/download/v%VERSION%/fibjs-v%VERSION%-windows-x64.cab"
-  - expand node_modules\.bin\fibjs.cab node_modules\.bin\fibjs.exe
-
-test_script:
-  - npm run ci
-
-build: off

package/lib/index.js

@@ -1,164 +0,0 @@
-"use strict";
-const coroutine = require("coroutine");
-const util = require("util");
-function ensureError(e) {
-    if (typeof e === 'string')
-        e = new Error(e);
-    return e;
-}
-module.exports = function GetPool(_opt, maxsize, timeout) {
-    let opt = _opt;
-    if (util.isFunction(_opt)) {
-        opt = {
-            create: _opt,
-            maxsize: maxsize,
-            timeout: timeout
-        };
-    }
-    const create = opt.create;
-    const destroy = opt.destroy || ((o) => {
-        if (util.isFunction(o.close))
-            o.close();
-        if (util.isFunction(o.destroy))
-            o.destroy();
-        if (util.isFunction(o.dispose))
-            o.dispose();
-    });
-    maxsize = opt.maxsize || 10;
-    timeout = opt.timeout || 60000;
-    let tm = timeout / 10;
-    if (tm < 10)
-        tm = 10;
-    const retry = opt.retry || 1;
-    let pools = [];
-    const jobs = [];
-    let count = 0;
-    let running = 0;
-    const sem = new coroutine.Semaphore(maxsize);
-    let clearTimer;
-    function clearPool() {
-        let c;
-        const d = new Date().getTime();
-        while (count) {
-            c = pools[0];
-            if (d - c.time.getTime() > timeout) {
-                pools = pools.slice(1);
-                count--;
-                if (c.o !== undefined)
-                    coroutine.start(destroy, c.o);
-            }
-            else
-                break;
-        }
-        if (!count) {
-            if (clearTimer) {
-                clearTimer.clear();
-                clearTimer = null;
-            }
-        }
-        else if (!clearTimer)
-            clearTimer = setInterval(clearPool, tm);
-    }
-    function putback(name, o, e) {
-        e = ensureError(e);
-        for (let i = 0; i < jobs.length; i++) {
-            const job = jobs[i];
-            if (job.name === name) {
-                jobs.splice(i, 1);
-                job.o = o;
-                job.e = e;
-                job.ev.set();
-                return;
-            }
-        }
-        if (e === undefined)
-            pools[count++] = {
-                o: o,
-                name: name,
-                time: new Date()
-            };
-    }
-    function connect(name) {
-        let o;
-        let cn = 0;
-        let err;
-        while (true) {
-            try {
-                o = create(name);
-                break;
-            }
-            catch (e) {
-                console.log(e);
-                if (++cn >= retry) {
-                    err = e;
-                    break;
-                }
-            }
-        }
-        putback(name, o, err);
-    }
-    const pool = (name, func) => {
-        if (typeof name === 'function') {
-            func = name;
-            name = "";
-        }
-        let r;
-        let o;
-        let p = false;
-        clearPool();
-        sem.acquire();
-        if (count) {
-            for (let i = count - 1; i >= 0; i--)
-                if (pools[i].name === name) {
-                    p = true;
-                    o = pools[i].o;
-                    pools.splice(i, 1);
-                    count--;
-                    break;
-                }
-        }
-        if (!p) {
-            coroutine.start(connect, name);
-            const job = {
-                name: name,
-                ev: new coroutine.Event()
-            };
-            jobs.push(job);
-            job.ev.wait();
-            if (job.e) {
-                sem.post();
-                throw ensureError(job.e);
-            }
-            o = job.o;
-        }
-        running++;
-        try {
-            r = func(o);
-            putback(name, o);
-        }
-        catch (e) {
-            if (o !== undefined)
-                coroutine.start(destroy, o);
-            throw ensureError(e);
-        }
-        finally {
-            running--;
-            sem.post();
-            clearPool();
-        }
-        return r;
-    };
-    pool.connections = () => count;
-    pool.info = () => ({
-        maxsize: maxsize,
-        count: count,
-        running: running,
-        wait: sem.count(),
-        timeout: timeout
-    });
-    pool.clear = () => {
-        timeout = -1;
-        clearPool();
-    };
-    return pool;
-};

package/typings/index.d.ts

@@ -1,41 +0,0 @@
-declare namespace FibPoolNS {
-    type FirstParameter<T> = T extends (arg: infer T, ...args: any[]) => any ? T : never;
-    interface DippedItemStruct {
-        close?: FibPoolOptionResult['destroy'];
-        destroy?: FibPoolOptionResult['destroy'];
-        dispose?: FibPoolOptionResult['destroy'];
-    }
-    interface FibPoolOptionArgs<T extends DippedItemStruct = {}> {
-        create: (name: string) => T;
-        destroy?: (item?: T) => any;
-        maxsize?: number;
-        timeout?: number;
-        retry?: number | boolean;
-    }
-    interface FibPoolOptionResult<T extends DippedItemStruct = {}> {
-        create: FibPoolOptionArgs<T>['create'];
-        destroy: FibPoolOptionArgs<T>['destroy'];
-        maxsize: FibPoolOptionArgs<T>['maxsize'];
-        timeout: FibPoolOptionArgs<T>['timeout'];
-        retry: FibPoolOptionArgs<T>['retry'];
-    }
-    interface FibPoolDipperFn<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> {
-        (o: T_CREATED_ITEM): T_POOL_FUNC_RETURN;
-    }
-    type FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN = any> = {
-        <T_RETURN = T_POOL_FUNC_RETURN>(name: string, func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN;
-        <T_RETURN = T_POOL_FUNC_RETURN>(func: FibPoolDipperFn<T_CREATED_ITEM, T_RETURN>): T_RETURN;
-    } & {
-        connections?(): number;
-        info?(): {
-            maxsize: number;
-            count: number;
-            running: number;
-            wait: number;
-            timeout: number;
-        };
-        clear?(): void;
-    };
-}
-declare const _default: <T_CREATED_ITEM extends FibPoolNS.DippedItemStruct, T_POOL_FUNC_RETURN>(_opt: FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM> | ((name: string) => T_CREATED_ITEM), maxsize?: number, timeout?: number) => FibPoolNS.FibPool<T_CREATED_ITEM, T_POOL_FUNC_RETURN>;
-export = _default;