fib-pool 1.7.0 → 1.7.1

package/Readme.md

@@ -12,7 +12,7 @@ npm install fib-pool [--save]
 
 ```sh
 npm test        # fibjs test
-npm run typecheck   # fibjs --check
+npm run typecheck   # fibjs --check, including test/types.ts
 ```
 
 ## Creating a pool
@@ -113,6 +113,19 @@ var res = p("test", (conn) => {
 | `retry` | positive integer | `1` | how many times `create` is attempted before giving up |
 | `strict` | boolean | `true` | see below |
 
+The pooled item is unconstrained: `create` may return an object, a class
+instance, a function, or a primitive. The default `destroy` calls whichever of
+`close` / `destroy` / `dispose` the item provides and ignores items that have
+none of them.
+
+```js
+var p = Pool(() => 10);                // a primitive item
+p((v) => v + 1);
+
+var q = Pool(() => ({ value: 1 }));    // a plain object, nothing to destroy
+q((o) => o.value);
+```
+
 Invalid `maxsize`, `timeout` and `retry` values throw a `TypeError` when the
 pool is created rather than being silently coerced:
 

package/package.json

@@ -1,9 +1,22 @@
 {
     "name": "fib-pool",
-    "version": "1.7.0",
+    "version": "1.7.1",
     "description": "Generic resource pooling for fibjs",
-    "main": "./src/index.ts",
+    "main": "./src/index.cts",
+    "types": "./src/index.ts",
     "type": "module",
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./src/index.ts",
+                "default": "./src/index.ts"
+            },
+            "require": {
+                "types": "./src/index.d.cts",
+                "default": "./src/index.cts"
+            }
+        }
+    },
     "repository": "git://github.com/fibjs/fib-pool.git",
     "author": "Liu Hu <lion@9465.net>",
     "homepage": "https://github.com/fibjs/fib-pool",

package/src/index.cts

@@ -0,0 +1,18 @@
+/**
+ * CommonJS entry point.
+ *
+ * The pool is implemented in `index.ts` as an ES module, so requiring that
+ * file yields the module namespace object (`{ default, __esModule }`) rather
+ * than the factory. Callers of `require('fib-pool')` expect the export to *be*
+ * the factory function, so this bridge unwraps the default export.
+ *
+ * A static `import` is not an option here: this file is CommonJS, so it must
+ * load the implementation through `require` to get the namespace object.
+ *
+ * `module.exports =` is used instead of `export =` because fibjs runs
+ * TypeScript in strip-only mode, which rejects export assignments. The type of
+ * this file is described by the sibling `index.d.cts`.
+ */
+const impl = require('./index.ts');
+
+module.exports = impl.default;

package/src/index.d.cts

@@ -0,0 +1,3 @@
+import Pool from './index.ts';
+
+export = Pool;

package/src/index.ts

@@ -3,9 +3,17 @@ 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.
+     * The shape the default destroy looks for. All three members are optional:
+     * it calls whichever of them the item actually provides, and a non-function
+     * value (a plain property) is ignored.
+     *
+     * This is deliberately *not* a constraint on the pooled item. Every member
+     * is optional, which makes it a weak type, and TypeScript rejects any type
+     * without a property in common with a weak type. Constraining the item to
+     * it would reject the perfectly valid `Pool(() => 10)` and
+     * `Pool(() => ({ value: 1 }))`, so the constraint is absent and the cast to
+     * this shape happens only inside the default destroy, where a primitive
+     * simply has no such member to call.
      */
     interface DippedItemStruct {
         close?: unknown;
@@ -13,7 +21,11 @@ declare namespace FibPoolNS {
         dispose?: unknown;
     }
 
-    interface FibPoolOptionArgs<T extends DippedItemStruct = {}> {
+    /**
+     * `T` is the pooled item and may be anything `create` returns, including a
+     * primitive. It is only inferred, never constrained.
+     */
+    interface FibPoolOptionArgs<T = any> {
         create: (name: string) => T;
         destroy?: (item?: T) => any;
         maxsize?: number;
@@ -147,8 +159,8 @@ function wrapStrict<T extends object>(item: () => T | undefined): T {
 }
 
 export default function GetPool<
-    T_CREATED_ITEM extends FibPoolNS.DippedItemStruct,
-    T_POOL_FUNC_RETURN
+    T_CREATED_ITEM,
+    T_POOL_FUNC_RETURN = any
 > (
     _opt: FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM> | FibPoolNS.FibPoolOptionArgs<T_CREATED_ITEM>['create'],
     maxsize?: number,
@@ -168,15 +180,20 @@ export default function GetPool<
     }
 
     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 */
+    const destroy = opt.destroy || ((o: unknown) => {
+        /* create may return null/undefined or any primitive: there is nothing
+           to destroy then. Functions are kept, since they can carry members. */
         if (o === null || o === undefined)
             return;
 
-        callIfFunction(o.close);
-        callIfFunction(o.destroy);
-        callIfFunction(o.dispose);
+        if (typeof o !== 'object' && typeof o !== 'function')
+            return;
+
+        const item = o as FibPoolNS.DippedItemStruct;
+
+        callIfFunction(item.close);
+        callIfFunction(item.destroy);
+        callIfFunction(item.dispose);
     });
 
     const maxsizeValue = opt.maxsize === undefined ? 10 : toPositiveInteger(opt.maxsize, 'maxsize');