ResourcePool: expose using-capable borrow()

jest.config.js

@@ -1,14 +1,20 @@
 module.exports = {
-  preset: 'ts-jest',
+  preset: 'ts-jest/presets/js-with-ts',
   roots: ['src'],
   transformIgnorePatterns: ['<rootDir>/node_modules/.*\\.js', '<rootDir>/build/.*\\.js'],
+  transform: {
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        tsconfig: {
+          target: 'es2022',
+        },
+      },
+    ],
+  },
   testMatch: ['**/__test__/*\\.(ts|js|tsx|jsx)', '**/*\\.(spec|test)\\.(ts|js|tsx|jsx)'],
   collectCoverageFrom: ['src/**/*.(ts|tsx)', '!build/', '!**/node_modules', '!/coverage'],
   moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
   coverageReporters: ['json', 'lcov', 'text', 'html'],
-  globals: {
-    'ts-jest': {
-      isolatedModules: true,
-    },
-  },
+  setupFiles: ['core-js'],
 };

package.json

@@ -42,6 +42,7 @@
     "@types/node": "^18",
     "@types/react": "latest",
     "@types/react-dom": "latest",
+    "core-js": "^3.36.1",
     "eventemitter3": "^4",
     "fp-ts": "^2",
     "gts": "^5.2.0",

src/concurrency/lazy-thenable.spec.ts

@@ -13,12 +13,13 @@ describe(lazyThenable, () => {
     await wait(0);
     expect(called).toEqual(1);
     expect(await converted).toEqual(1);
+    expect(await lazy1).toEqual(1);
     expect(called).toEqual(1);
   });
 
   it('run actual action at most once', async () => {
     let called = 0;
-    const lazy2 = lazyThenable(async () => ++called);
+    const lazy2 = lazyThenable(() => ++called);
 
     expect(await lazy2).toEqual(1);
     for (let i = 0; i < 10; i++) {

src/concurrency/lazy-thenable.ts

@@ -1,11 +1,16 @@
-export function lazyThenable<T>(action: () => PromiseLike<T>): PromiseLike<T> {
-  let r: null | Promise<T> = null;
+/**
+ * create a lazy PromiseLike to run {@name io} at most once and only after being awaited
+ * @param io
+ * @return
+ */
+export function lazyThenable<T>(io: () => T): PromiseLike<Awaited<T>> {
+  let r: null | Promise<Awaited<T>> = null;
   return {
     then<TResult1, TResult2 = never>(
-      onfulfilled?: ((value: T) => PromiseLike<TResult1> | TResult1) | undefined | null,
+      onfulfilled?: ((value: Awaited<T>) => PromiseLike<TResult1> | TResult1) | undefined | null,
       onrejected?: ((reason: any) => PromiseLike<TResult2> | TResult2) | undefined | null,
     ): PromiseLike<TResult1 | TResult2> {
-      return (r ??= Promise.resolve(action())).then(onfulfilled, onrejected);
+      return (r ??= Promise.resolve(io())).then(onfulfilled, onrejected);
     },
   };
 }

src/concurrency/lease.ts

@@ -0,0 +1,8 @@
+/**
+ * An acquired lock or resource
+ */
+export interface Lease<T> {
+  value: T;
+  dispose(): PromiseLike<void>;
+  [Symbol.asyncDispose](): PromiseLike<void>;
+}

src/concurrency/resource-pool.ts

@@ -5,6 +5,8 @@
  * - NOT supported: replace / refresh / timeout of tasks
  */
 import { wait } from './timing';
+import { Lease } from './lease';
+import { lazyThenable } from './lazy-thenable';
 
 export class ResourcePool<T> {
   // can be used as a mutex
@@ -37,17 +39,12 @@
     return this.consumers.length;
   }
 
-  async use<R>(task: (res: T) => R): Promise<R> {
-    const r = await this.borrow();
-    try {
-      return await task(r);
-    } finally {
-      this.resources.push(r);
-      this.balance();
-    }
+  async use<R>(task: (res: T) => R): Promise<Awaited<R>> {
+    await using lease = await this.borrow();
+    return /* must not omit 'await' here */ await task(lease.value);
   }
 
-  tryUse<R>(task: (res: T | null) => R): R | Promise<R> {
+  tryUse<R>(task: (res: T | null) => R): R | Promise<Awaited<R>> {
     if (/** some resource is immediately available */ this.freeCount > 0) {
       return this.use(task);
     } else {
@@ -88,17 +85,39 @@
     }
   }
 
-  private borrow(): Promise<T> {
+  async borrow(): Promise<Lease<T>> {
+    // TODO: implement timeout
+    const v = await this._borrow();
+
+    const _return = lazyThenable(() => this._return(v));
+
+    return {
+      value: v,
+      async dispose(): Promise<void> {
+        return _return;
+      },
+      [Symbol.asyncDispose]() {
+        return _return;
+      },
+    };
+  }
+
+  private _borrow(): Promise<T> {
     return new Promise<T>((f) => {
       this.consumers.push(f);
       this.balance();
     });
   }
 
+  private _return(value: T): void {
+    this.resources.push(value);
+    this.balance();
+  }
+
   private balance(): void {
     while (this.resources.length && this.consumers.length) {
       const r = this.resources.shift()!;
       const c = this.consumers.shift()!;
       c(r);
     }
   }

tsconfig.json

@@ -4,7 +4,7 @@
     "jsx": "preserve",
     "module": "commonjs",
     "moduleResolution": "node",
-    "target": "es2021",
+    "target": "es2022",
     "skipLibCheck": true,
     "rootDir": "src",
     "outDir": "lib"

yarn.lock

@@ -1228,6 +1228,11 @@ convert-source-map@^2.0.0:
   resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-2.0.0.tgz#4b560f649fc4e918dd0ab75cf4961e8bc882d82a"
   integrity sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==
 
+core-js@^3.36.1:
+  version "3.36.1"
+  resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.36.1.tgz#c97a7160ebd00b2de19e62f4bbd3406ab720e578"
+  integrity sha512-BTvUrwxVBezj5SZ3f10ImnX2oRByMxql3EimVqMysepbC9EeMUOpLwdy6Eoili2x6E4kf+ZUB5k/+Jv55alPfA==
+
 create-jest@^29.7.0:
   version "29.7.0"
   resolved "https://registry.yarnpkg.com/create-jest/-/create-jest-29.7.0.tgz#a355c5b3cb1e1af02ba177fe7afd7feee49a5320"