v0.0.8

dist/lib/contracts.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

dist/lib/contracts.d.ts

@@ -0,0 +1 @@
+export declare type FuncAny = (...args: any[]) => any;

dist/lib/contracts.mjs

@@ -0,0 +1 @@
+

dist/lib/index.cjs

@@ -8,7 +8,7 @@ var pool_PoolRunner = require('./pool/PoolRunner.cjs');
 var pool_PoolWrapper = require('./pool/PoolWrapper.cjs');
 var pool_PoolHoldError = require('./pool/PoolHoldError.cjs');
 var pool_poolRunWait = require('./pool/poolRunWait.cjs');
-var pool_poolRunThrow = require('./pool/poolRunThrow.cjs');
+var pool_toFuncWithPoolThrow = require('./pool/toFuncWithPoolThrow.cjs');
 var objectPool_StackPool = require('./object-pool/StackPool.cjs');
 var objectPool_ObjectPool = require('./object-pool/ObjectPool.cjs');
 var objectPool_ObjectPoolWrapper = require('./object-pool/ObjectPoolWrapper.cjs');
@@ -25,8 +25,8 @@ exports.Pools = pool_Pools.Pools;
 exports.PoolRunner = pool_PoolRunner.PoolRunner;
 exports.PoolWrapper = pool_PoolWrapper.PoolWrapper;
 exports.PoolHoldError = pool_PoolHoldError.PoolHoldError;
-exports.poolRunWait = pool_poolRunWait.poolRunWait;
-exports.poolRunThrow = pool_poolRunThrow.poolRunThrow;
+exports.runPoolWait = pool_poolRunWait.runPoolWait;
+exports.runPoolThrow = pool_toFuncWithPoolThrow.runPoolThrow;
 exports.StackPool = objectPool_StackPool.StackPool;
 exports.ObjectPool = objectPool_ObjectPool.ObjectPool;
 exports.ObjectPoolWrapper = objectPool_ObjectPoolWrapper.ObjectPoolWrapper;

dist/lib/index.mjs

@@ -3,8 +3,8 @@ export { Pools } from './pool/Pools.mjs';
 export { PoolRunner } from './pool/PoolRunner.mjs';
 export { PoolWrapper } from './pool/PoolWrapper.mjs';
 export { PoolHoldError } from './pool/PoolHoldError.mjs';
-export { poolRunWait } from './pool/poolRunWait.mjs';
-export { poolRunThrow } from './pool/poolRunThrow.mjs';
+export { runPoolWait } from './pool/poolRunWait.mjs';
+export { runPoolThrow } from './pool/toFuncWithPoolThrow.mjs';
 export { StackPool } from './object-pool/StackPool.mjs';
 export { ObjectPool } from './object-pool/ObjectPool.mjs';
 export { ObjectPoolWrapper } from './object-pool/ObjectPoolWrapper.mjs';

dist/lib/pool/index.cjs

@@ -8,7 +8,7 @@ var pool_PoolRunner = require('./PoolRunner.cjs');
 var pool_PoolWrapper = require('./PoolWrapper.cjs');
 var pool_PoolHoldError = require('./PoolHoldError.cjs');
 var pool_poolRunWait = require('./poolRunWait.cjs');
-var pool_poolRunThrow = require('./poolRunThrow.cjs');
+var pool_toFuncWithPoolThrow = require('./toFuncWithPoolThrow.cjs');
 require('tslib');
 require('@flemist/async-utils');
 require('@flemist/priority-queue');
@@ -21,5 +21,5 @@ exports.Pools = pool_Pools.Pools;
 exports.PoolRunner = pool_PoolRunner.PoolRunner;
 exports.PoolWrapper = pool_PoolWrapper.PoolWrapper;
 exports.PoolHoldError = pool_PoolHoldError.PoolHoldError;
-exports.poolRunWait = pool_poolRunWait.poolRunWait;
-exports.poolRunThrow = pool_poolRunThrow.poolRunThrow;
+exports.runPoolWait = pool_poolRunWait.runPoolWait;
+exports.runPoolThrow = pool_toFuncWithPoolThrow.runPoolThrow;

dist/lib/pool/index.d.ts

@@ -4,4 +4,4 @@ export * from './PoolRunner';
 export * from './PoolWrapper';
 export * from './PoolHoldError';
 export * from './poolRunWait';
-export * from './poolRunThrow';
+export { runPoolThrow } from './toFuncWithPoolThrow';

dist/lib/pool/index.mjs

@@ -3,8 +3,8 @@ export { Pools } from './Pools.mjs';
 export { PoolRunner } from './PoolRunner.mjs';
 export { PoolWrapper } from './PoolWrapper.mjs';
 export { PoolHoldError } from './PoolHoldError.mjs';
-export { poolRunWait } from './poolRunWait.mjs';
-export { poolRunThrow } from './poolRunThrow.mjs';
+export { runPoolWait } from './poolRunWait.mjs';
+export { runPoolThrow } from './toFuncWithPoolThrow.mjs';
 import 'tslib';
 import '@flemist/async-utils';
 import '@flemist/priority-queue';

dist/lib/pool/poolRunWait.cjs

@@ -5,21 +5,21 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var tslib = require('tslib');
 var pool_Pool = require('./Pool.cjs');
 require('@flemist/priority-queue');
-require('@flemist/async-utils');
+var asyncUtils = require('@flemist/async-utils');
 require('@flemist/time-controller');
 
-function poolRunWait({ pool, count, func, priority, abortSignal, awaitPriority, }) {
+function runPoolWait({ pool, count, func, priority, abortSignal, awaitPriority, }) {
     return tslib.__awaiter(this, void 0, void 0, function* () {
-        yield pool.holdWait(count, priority, abortSignal, awaitPriority);
-        try {
-            const holdPool = new pool_Pool.Pool(count);
-            const result = yield func(holdPool, abortSignal);
-            return result;
-        }
-        finally {
-            void this._pool.release(count);
-        }
+        return asyncUtils.toFuncWithFinally(function funcWithPoolThrow() {
+            return tslib.__awaiter(this, void 0, void 0, function* () {
+                yield pool.holdWait(count, priority, abortSignal, awaitPriority);
+                const holdPool = new pool_Pool.Pool(count);
+                return func(holdPool, abortSignal);
+            });
+        }, () => {
+            void pool.release(count);
+        })();
     });
 }
 
-exports.poolRunWait = poolRunWait;
+exports.runPoolWait = runPoolWait;

dist/lib/pool/poolRunWait.d.ts

@@ -10,4 +10,4 @@ export declare type PoolRunWaitArgs<T> = {
     abortSignal?: IAbortSignalFast;
     awaitPriority?: AwaitPriority;
 };
-export declare function poolRunWait<T>({ pool, count, func, priority, abortSignal, awaitPriority, }: PoolRunWaitArgs<T>): Promise<T>;
+export declare function runPoolWait<T>({ pool, count, func, priority, abortSignal, awaitPriority, }: PoolRunWaitArgs<T>): Promise<T>;

dist/lib/pool/poolRunWait.mjs

@@ -1,21 +1,21 @@
 import { __awaiter } from 'tslib';
 import { Pool } from './Pool.mjs';
 import '@flemist/priority-queue';
-import '@flemist/async-utils';
+import { toFuncWithFinally } from '@flemist/async-utils';
 import '@flemist/time-controller';
 
-function poolRunWait({ pool, count, func, priority, abortSignal, awaitPriority, }) {
+function runPoolWait({ pool, count, func, priority, abortSignal, awaitPriority, }) {
     return __awaiter(this, void 0, void 0, function* () {
-        yield pool.holdWait(count, priority, abortSignal, awaitPriority);
-        try {
-            const holdPool = new Pool(count);
-            const result = yield func(holdPool, abortSignal);
-            return result;
-        }
-        finally {
-            void this._pool.release(count);
-        }
+        return toFuncWithFinally(function funcWithPoolThrow() {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield pool.holdWait(count, priority, abortSignal, awaitPriority);
+                const holdPool = new Pool(count);
+                return func(holdPool, abortSignal);
+            });
+        }, () => {
+            void pool.release(count);
+        })();
     });
 }
 
-export { poolRunWait };
+export { runPoolWait };

dist/lib/pool/toFuncWithPoolThrow.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var asyncUtils = require('@flemist/async-utils');
+var pool_PoolHoldError = require('./PoolHoldError.cjs');
+
+function toFuncWithPoolThrow(pool, count, func) {
+    return asyncUtils.toFuncWithFinally(function funcWithPoolThrow() {
+        const hold = pool.hold(count);
+        if (!hold) {
+            throw new pool_PoolHoldError.PoolHoldError(count);
+        }
+        return func.apply(this, arguments);
+    }, () => {
+        void pool.release(count);
+    });
+}
+function runPoolThrow(pool, count, func) {
+    return toFuncWithPoolThrow(pool, count, func)();
+}
+
+exports.runPoolThrow = runPoolThrow;
+exports.toFuncWithPoolThrow = toFuncWithPoolThrow;

dist/lib/pool/toFuncWithPoolThrow.d.ts

@@ -0,0 +1,4 @@
+import { IPool } from "./..";
+import { FuncAny } from "../contracts";
+export declare function toFuncWithPoolThrow<TFunc extends FuncAny>(pool: IPool, count: number, func: TFunc): TFunc;
+export declare function runPoolThrow<T>(pool: IPool, count: number, func: () => T): T;

dist/lib/pool/toFuncWithPoolThrow.mjs

@@ -0,0 +1,19 @@
+import { toFuncWithFinally } from '@flemist/async-utils';
+import { PoolHoldError } from './PoolHoldError.mjs';
+
+function toFuncWithPoolThrow(pool, count, func) {
+    return toFuncWithFinally(function funcWithPoolThrow() {
+        const hold = pool.hold(count);
+        if (!hold) {
+            throw new PoolHoldError(count);
+        }
+        return func.apply(this, arguments);
+    }, () => {
+        void pool.release(count);
+    });
+}
+function runPoolThrow(pool, count, func) {
+    return toFuncWithPoolThrow(pool, count, func)();
+}
+
+export { runPoolThrow, toFuncWithPoolThrow };

src/pool/Pool.ts

@@ -95,7 +95,7 @@ export class Pool implements IPool {
     return count
   }
 
-  private _tickPromise: CustomPromise<void> = new CustomPromise()
+  private _tickPromise: CustomPromise = new CustomPromise()
   tick(abortSignal?: IAbortSignalFast): Promise<void> | void {
     if (this._size > 0) {
       return