@art-ws/common 1.0.3-rc.6 → 2.0.1

package/dist/{cancellation → es/cancellation}/cancellation-token-source.d.ts

@@ -1,4 +1,4 @@
-import { ICancellationToken, ICancellationTokenSource, OnCancelCallback } from "./interfaces";
+import type { ICancellationToken, ICancellationTokenSource, OnCancelCallback } from "./interfaces";
 export declare class CancellationTokenSource implements ICancellationTokenSource {
     private _token;
     isCancellationRequested: boolean;
@@ -8,4 +8,3 @@ export declare class CancellationTokenSource implements ICancellationTokenSource
     token(): ICancellationToken;
     dispose(): void;
 }
-//# sourceMappingURL=cancellation-token-source.d.ts.map

package/dist/es/cancellation/cancellation-token-source.js

@@ -0,0 +1,24 @@
+import { EventEmitter } from "events";
+import { CancellationToken } from "./cancellation-token";
+const ON_CANCEL = "ON_CANCEL";
+export class CancellationTokenSource {
+    _token = null;
+    isCancellationRequested = false;
+    eventEmitter = new EventEmitter();
+    cancel(reason) {
+        this.isCancellationRequested = true;
+        this.eventEmitter.emit(ON_CANCEL, { reason });
+    }
+    onCancel(callback) {
+        this.eventEmitter.addListener(ON_CANCEL, callback);
+    }
+    token() {
+        if (!this._token) {
+            this._token = new CancellationToken(this);
+        }
+        return this._token;
+    }
+    dispose() {
+        this.eventEmitter.removeAllListeners();
+    }
+}

package/dist/{cancellation → es/cancellation}/cancellation-token.d.ts

@@ -1,4 +1,4 @@
-import { ICancellationToken, ICancellationTokenSource, OnCancelCallback } from "./interfaces";
+import type { ICancellationToken, ICancellationTokenSource, OnCancelCallback } from "./interfaces";
 export declare class CancellationToken implements ICancellationToken {
     private readonly source;
     constructor(source: ICancellationTokenSource);
@@ -6,4 +6,3 @@ export declare class CancellationToken implements ICancellationToken {
     onCancel(callback: OnCancelCallback): void;
     throwIfCancellationRequested(): void;
 }
-//# sourceMappingURL=cancellation-token.d.ts.map

package/dist/{cancellation → es/cancellation}/cancellation-token.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CancellationToken = void 0;
-const interfaces_1 = require("./interfaces");
-class CancellationToken {
+import { ErrorCancelled } from "./interfaces";
+export class CancellationToken {
+    source;
     constructor(source) {
         this.source = source;
     }
@@ -14,9 +12,7 @@ class CancellationToken {
     }
     throwIfCancellationRequested() {
         if (this.isCancellationRequested()) {
-            throw new interfaces_1.ErrorCancelled();
+            throw new ErrorCancelled();
         }
     }
 }
-exports.CancellationToken = CancellationToken;
-//# sourceMappingURL=cancellation-token.js.map

package/dist/{cancellation → es/cancellation}/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./cancellation-token-source";
 export * from "./cancellation-token";
 export * from "./interfaces";
-//# sourceMappingURL=index.d.ts.map

package/dist/es/cancellation/index.js

@@ -0,0 +1,4 @@
+// created from 'create-ts-index'
+export * from "./cancellation-token-source";
+export * from "./cancellation-token";
+export * from "./interfaces";

package/dist/{cancellation → es/cancellation}/interfaces.d.ts

@@ -1,4 +1,4 @@
-export declare type OnCancelCallback = (arg?: {
+export type OnCancelCallback = (arg?: {
     reason?: unknown;
 }) => void;
 export interface ICancellationTokenSource {
@@ -16,4 +16,3 @@ export interface ICancellationToken {
 export declare class ErrorCancelled extends Error {
     constructor();
 }
-//# sourceMappingURL=interfaces.d.ts.map

package/dist/es/cancellation/interfaces.js

@@ -0,0 +1,5 @@
+export class ErrorCancelled extends Error {
+    constructor() {
+        super("Cancelled");
+    }
+}

package/dist/{heart-beat → es/heart-beat}/heart-beat.class.d.ts

@@ -1,4 +1,4 @@
-import { HeartBeat } from "./heart-beat.types";
+import type { HeartBeat } from "./heart-beat.types";
 export declare class HeartBeatBase implements HeartBeat.IHeartBeat {
     logger: import("@art-ws/slf").Logger;
     private id;
@@ -15,4 +15,3 @@ export declare class HeartBeatBase implements HeartBeat.IHeartBeat {
     isActive(): boolean;
     onTick(handler: HeartBeat.Handler, options?: Partial<HeartBeat.SubscribeOptions>): HeartBeat.Subscription;
 }
-//# sourceMappingURL=heart-beat.class.d.ts.map

package/dist/{heart-beat → es/heart-beat}/heart-beat.class.js

@@ -1,26 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HeartBeatBase = void 0;
-const slf_1 = require("@art-ws/slf");
-const events_1 = require("events");
+import { getLogger } from "@art-ws/slf";
+import { EventEmitter } from "events";
 const TICK_EVENT = "TICK_EVENT";
 const DEFAULT_INTERVAL = 5 * 1000;
-class HeartBeatBase {
+export class HeartBeatBase {
+    logger = getLogger("HeartBeatBase");
+    id = 0;
+    interval = DEFAULT_INTERVAL;
+    active = false;
+    emitter = new EventEmitter();
     constructor(options) {
-        this.logger = slf_1.getLogger(HeartBeatBase);
-        this.id = 0;
-        this.interval = DEFAULT_INTERVAL;
-        this.active = false;
-        this.emitter = new events_1.EventEmitter();
-        this.timeout = null;
         const o = options ?? {};
         if (o.interval) {
-            this.interval = options.interval;
+            this.interval = options?.interval ?? DEFAULT_INTERVAL;
         }
         if (o.autostart) {
             this.up();
         }
     }
+    timeout = null;
     stop() {
         if (this.timeout) {
             clearTimeout(this.timeout);
@@ -75,5 +72,3 @@ class HeartBeatBase {
         };
     }
 }
-exports.HeartBeatBase = HeartBeatBase;
-//# sourceMappingURL=heart-beat.class.js.map

package/dist/{heart-beat → es/heart-beat}/heart-beat.types.d.ts

@@ -17,4 +17,3 @@ export declare namespace HeartBeat {
         onTick: (handler: Handler, options?: Partial<SubscribeOptions>) => Subscription;
     }
 }
-//# sourceMappingURL=heart-beat.types.d.ts.map

package/dist/es/heart-beat/heart-beat.types.js

@@ -0,0 +1 @@
+export {};

package/dist/{heart-beat → es/heart-beat}/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./heart-beat.class";
 export * from "./heart-beat.types";
-//# sourceMappingURL=index.d.ts.map

package/dist/es/heart-beat/index.js

@@ -0,0 +1,3 @@
+// created from 'create-ts-index'
+export * from "./heart-beat.class";
+export * from "./heart-beat.types";

package/dist/{hr-time.d.ts → es/hr-time.d.ts}

@@ -2,8 +2,7 @@ interface HighResolutionTimeStruct {
     sec: number;
     ms: number;
 }
-export declare type HRTime = number[];
+export type HRTime = number[];
 export declare function hrTimeToToHighResolutionTime(hrTime: HRTime): HighResolutionTimeStruct;
 export declare function hrTimeToMilli(hrTime: HRTime): number;
 export {};
-//# sourceMappingURL=hr-time.d.ts.map

package/dist/es/hr-time.js

@@ -0,0 +1,9 @@
+export function hrTimeToToHighResolutionTime(hrTime) {
+    const sec = Number(hrTime[0]);
+    const ms = Math.floor(hrTime[1] / 1000000);
+    return { sec, ms };
+}
+export function hrTimeToMilli(hrTime) {
+    const t = hrTimeToToHighResolutionTime(hrTime);
+    return t.sec * 1000 + t.ms;
+}

package/dist/{index.d.ts → es/index.d.ts}

@@ -2,6 +2,7 @@ export * from "./cancellation";
 export * from "./heart-beat";
 export * from "./managed-pool";
 export * from "./mem-cache";
+export * from "./object-hash";
 export * from "./shared";
 export * from "./hr-time";
 export * from "./interpolate";
@@ -9,4 +10,3 @@ export * from "./json-file-loader";
 export * from "./json-refs-resolver";
 export * from "./managed-promise";
 export * from "./node-zone";
-//# sourceMappingURL=index.d.ts.map

package/dist/es/index.js

@@ -0,0 +1,13 @@
+// created from 'create-ts-index'
+export * from "./cancellation";
+export * from "./heart-beat";
+export * from "./managed-pool";
+export * from "./mem-cache";
+export * from "./object-hash";
+export * from "./shared";
+export * from "./hr-time";
+export * from "./interpolate";
+export * from "./json-file-loader";
+export * from "./json-refs-resolver";
+export * from "./managed-promise";
+export * from "./node-zone";

package/dist/es/interpolate.d.ts

@@ -0,0 +1,5 @@
+export declare function iterpolate(vars: Record<string, any>, template: string): string;
+export type ResolveVarFunction<T = any> = (key: string) => Promise<T>;
+export declare function iterpolateObject(data: Record<string, any>, vars?: Record<string, any>): Record<string, any>;
+export declare function iterpolateAsync(template: string, varsSource: ResolveVarFunction): Promise<string>;
+export declare function iterpolateObjectAsync(data: Record<string, any>, varsSource?: ResolveVarFunction): Promise<Record<string, any>>;

package/dist/es/interpolate.js

@@ -0,0 +1,150 @@
+import _ from "lodash";
+const e = {
+    RE: /{{(\w|\.)+}}/gi,
+    RE_ASYNC: /{{([^\{\}])+}}/gi,
+    B: "{{",
+    E: "}}",
+    DEF_DELIMITER: "||",
+};
+const isEmpty = (v) => v === undefined || v === null || Number.isNaN(v);
+export function iterpolate(vars, template) {
+    let tpl = template;
+    let n = 0;
+    const MAX_CYCLES = 100;
+    while (true) {
+        n++;
+        const s = tpl;
+        const keys = {};
+        let match;
+        while ((match = e.RE.exec(tpl))) {
+            let s = match[0];
+            s = s.substring(e.B.length, s.length - e.E.length);
+            keys[s] = true;
+        }
+        Object.keys(keys).forEach((key) => {
+            const expr = e.B + key + e.E;
+            const val = _.get(vars, key);
+            const value = isEmpty(val) ? expr : `${val}`;
+            tpl = tpl.split(expr).join(value);
+        });
+        if (s === tpl)
+            break;
+        if (!isInterpolationRequired(tpl))
+            break;
+        if (n > MAX_CYCLES)
+            break;
+    }
+    return tpl;
+}
+function isInterpolationRequired(s) {
+    return s && typeof s === "string" && s.includes(e.B) && s.includes(e.E);
+}
+const walk = (o, fn, depth, parentPath) => {
+    if (!o)
+        return;
+    Object.keys(o).forEach((key) => {
+        if (typeof o[key] === "object") {
+            walk(o[key], fn, depth + 1, [...parentPath, key]);
+        }
+        else {
+            fn(o, key, parentPath);
+        }
+    });
+};
+export function iterpolateObject(data, vars) {
+    if (vars) {
+        vars = iterpolateObject(vars);
+    }
+    else {
+        vars = data;
+    }
+    const interpolateKeys = () => {
+        walk(data, (o, key) => {
+            if (isInterpolationRequired(key)) {
+                const newKey = iterpolate(vars, key);
+                const val = o[key];
+                delete o[key];
+                o[newKey] = val;
+            }
+        }, 0, []);
+    };
+    const interpolateValues = () => {
+        walk(data, (o, key) => {
+            const val = o[key];
+            if (isInterpolationRequired(val)) {
+                const newVal = iterpolate(vars, val);
+                o[key] = newVal;
+            }
+        }, 0, []);
+    };
+    interpolateKeys();
+    interpolateValues();
+    return data;
+}
+const getDefaults = (s) => {
+    let expr = s;
+    let defaults = null;
+    const D = e.DEF_DELIMITER;
+    if (s && typeof s === "string" && s.includes(D)) {
+        const [e1, e2] = s.split(D);
+        expr = (e1 || "").trim();
+        defaults = (e2 || "").trim() || null;
+    }
+    return [expr, defaults];
+};
+export async function iterpolateAsync(template, varsSource) {
+    let tpl = template;
+    let n = 0;
+    const MAX_CYCLES = 10;
+    while (true) {
+        n++;
+        const s = tpl;
+        const keys = {};
+        let match;
+        while ((match = e.RE_ASYNC.exec(tpl))) {
+            let s = match[0];
+            s = s.substring(e.B.length, s.length - e.E.length);
+            keys[s] = true;
+        }
+        for (const keyExpr of Object.keys(keys)) {
+            const fullExpr = e.B + keyExpr + e.E;
+            const [e1, e2] = getDefaults(keyExpr);
+            const key = e1;
+            const val = (varsSource ? await varsSource(key) : undefined) || e2;
+            const value = isEmpty(val) ? fullExpr : `${val}`;
+            tpl = tpl.split(fullExpr).join(value);
+        }
+        if (s === tpl)
+            break;
+        if (!isInterpolationRequired(tpl))
+            break;
+        if (n > MAX_CYCLES)
+            break;
+    }
+    return tpl;
+}
+const walkAsync = async (o, fn, depth, parentPath) => {
+    if (!o)
+        return;
+    for (const key of Object.keys(o)) {
+        if (typeof o[key] === "object") {
+            await walkAsync(o[key], fn, depth + 1, [...parentPath, key]);
+        }
+        else {
+            await fn(o, key, parentPath);
+        }
+    }
+};
+export async function iterpolateObjectAsync(data, varsSource) {
+    const interpolateValues = async () => {
+        await walkAsync(data, async (o, key) => {
+            const val = o[key];
+            if (isInterpolationRequired(val)) {
+                const newVal = await iterpolateAsync(val, varsSource);
+                o[key] = newVal;
+            }
+        }, 0, []);
+    };
+    await interpolateValues();
+    return data;
+}

package/dist/es/json-file-loader.d.ts

@@ -0,0 +1,25 @@
+import type { ResolveVarFunction } from "./interpolate";
+import type { DeReferenceOptions } from "./json-refs-resolver";
+export declare const YAML_EXT: string[];
+export declare const JSON_EXT: string[];
+export declare const JS_EXT: string[];
+export declare function saveJsonableFile(obj: any, filename: string): void;
+export declare function loadJsonableFile<T>(filename: string): Promise<T>;
+export declare function parseJsonableData<T>(args: {
+    source: string;
+    nameWithExt: string;
+}): Promise<T>;
+export declare function lookupJsonableFile(cwd: string, candidates: string[]): string | undefined;
+export declare function lookupAndLoadJsonableFile<T>(cwd: string, candidates: string[]): Promise<{
+    filename: string;
+    data: T;
+}>;
+export interface JsonableDataDeReferenceOptions extends DeReferenceOptions {
+    resolveVar?: ResolveVarFunction;
+}
+export declare function resolveJsonableData<T>(args: JsonableDataDeReferenceOptions): Promise<T>;
+export declare function resolveJsonableFile<T>(filename: string): Promise<T>;
+export declare function lookupAndResolveJsonableFile<T>(cwd: string, candidates: string[]): Promise<{
+    filename: string;
+    data: T;
+}>;

package/dist/es/json-file-loader.js

@@ -0,0 +1,108 @@
+import fs from "fs-extra";
+import yaml from "js-yaml";
+import JSON5 from "json5";
+import _ from "lodash";
+import path from "path";
+import { iterpolateObjectAsync } from "./interpolate";
+import { resolveJsonRefs } from "./json-refs-resolver";
+export const YAML_EXT = ["yaml", "yml"];
+export const JSON_EXT = ["json", "json5"];
+export const JS_EXT = ["js"];
+const isRemoteWithExt = (uri, ext) => uri.startsWith("http") && uri.includes(`.${ext}`);
+const isAnyExt = (s, extensions) => Boolean(extensions.find((ext) => (typeof s === "string" && s && s.endsWith(`.${ext}`)) ||
+    isRemoteWithExt(s, ext)));
+const isYamlFile = (s) => isAnyExt(s, YAML_EXT);
+const isJsonFile = (s) => isAnyExt(s, JSON_EXT);
+const isJsFile = (s) => isAnyExt(s, JS_EXT);
+const parseJSON = (data) => (data ? JSON5.parse(data) : null);
+const parseYaml = (data) => (data ? yaml.load(data) : null);
+const loadAndParseFile = (filename, parser) => parser(fs.readFileSync(filename, { encoding: "utf-8" }));
+export function saveJsonableFile(obj, filename) {
+    let content;
+    const indent = 2;
+    if (isYamlFile(filename)) {
+        content = yaml.dump(obj, { indent });
+    }
+    else {
+        content = JSON5.stringify(obj, null, indent);
+    }
+    fs.writeFileSync(filename, content, { encoding: "utf-8" });
+}
+export async function loadJsonableFile(filename) {
+    if (isJsFile(filename)) {
+        const module = await import(filename);
+        return module.default || module;
+    }
+    else if (isYamlFile(filename)) {
+        return loadAndParseFile(filename, parseYaml);
+    }
+    else if (isJsonFile(filename)) {
+        return loadAndParseFile(filename, parseJSON);
+    }
+    throw new Error(`File '${filename}' format not supported`);
+}
+export async function parseJsonableData(args) {
+    const { source, nameWithExt: ext } = args;
+    if (isYamlFile(ext)) {
+        return parseYaml(source);
+    }
+    else if (isJsonFile(ext)) {
+        return parseJSON(source);
+    }
+    throw new Error(`Extension '${ext}' not supported`);
+}
+const EXTENSIONS = [...YAML_EXT, ...JSON_EXT, ...JS_EXT];
+export function lookupJsonableFile(cwd, candidates) {
+    const filenames = candidates
+        .map((name) => path.extname(name) ? [name] : EXTENSIONS.map((ext) => `${name}.${ext}`))
+        .flat()
+        .map((filename) => path.join(cwd, filename));
+    const filename = filenames.find((filename) => fs.existsSync(filename));
+    return filename;
+}
+export async function lookupAndLoadJsonableFile(cwd, candidates) {
+    const filename = lookupJsonableFile(cwd, candidates);
+    if (!filename) {
+        return { filename: null, data: null };
+    }
+    const data = await loadJsonableFile(filename);
+    return { filename, data };
+}
+export async function resolveJsonableData(args) {
+    const { data, baseUrl, resolveVar } = args;
+    const varResolver = (context) => {
+        return async (key) => {
+            let val = undefined;
+            if (context)
+                val = _.get(context, key);
+            if (!val && resolveVar) {
+                val = await resolveVar(key);
+            }
+            return val;
+        };
+    };
+    const data1 = await iterpolateObjectAsync(data, varResolver(data));
+    const data2 = await resolveJsonRefs({ baseUrl, data: data1 });
+    const data3 = await iterpolateObjectAsync(data2, varResolver(data2));
+    return data3;
+}
+export async function resolveJsonableFile(filename) {
+    const rawData = await loadJsonableFile(filename);
+    const data = await resolveJsonableData({
+        data: rawData,
+        baseUrl: filename,
+    });
+    return data;
+}
+export async function lookupAndResolveJsonableFile(cwd, candidates) {
+    const result = await lookupAndLoadJsonableFile(cwd, candidates);
+    if (result.filename) {
+        let { data } = result;
+        data = await resolveJsonableData({
+            data: data,
+            baseUrl: result.filename,
+        });
+        return { filename: result.filename, data: data };
+    }
+    return { filename: null, data: null };
+}

package/dist/es/json-refs-resolver.d.ts

@@ -0,0 +1,6 @@
+export interface DeReferenceOptions {
+    data?: Record<string, any>;
+    baseUrl?: string;
+}
+export declare function doDereference(args: DeReferenceOptions): Promise<Record<string, any>>;
+export declare function resolveJsonRefs(args: DeReferenceOptions): Promise<Record<string, any>>;

package/dist/{json-refs-resolver.js → es/json-refs-resolver.js}

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveJsonRefs = exports.doDereference = void 0;
-const tslib_1 = require("tslib");
-const json_schema_ref_parser_1 = tslib_1.__importDefault(require("@apidevtools/json-schema-ref-parser"));
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
+import $RefParser from "@apidevtools/json-schema-ref-parser";
+import _ from "lodash";
 const walk = async (o, fn, depth) => {
     for (const key in o) {
-        if (typeof o[key] === "object" && !Array.isArray(o[key])) {
+        if (typeof o[key] === "object" &&
+            !Array.isArray(o[key])) {
             await walk(o[key], fn, depth + 1);
         }
         else {
@@ -33,7 +30,7 @@ async function deRefs(data, baseUrl) {
             });
             const deRefs = await Promise.all(refsPromises);
             deRefs.forEach((deRef) => {
-                o = lodash_1.default.merge(o, deRef);
+                o = _.merge(o, deRef);
             });
         }
     }, 0);
@@ -42,27 +39,25 @@ async function deRefs(data, baseUrl) {
 const SUPPORTED_EXTENSIONS = [".json", ".yaml", ".yml"];
 // https://apitools.dev/json-schema-ref-parser/
 // https://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
-async function doDereference(args) {
+export async function doDereference(args) {
     const { data, baseUrl = "" } = args;
-    if (baseUrl && SUPPORTED_EXTENSIONS.find((x) => baseUrl.includes(x))) {
-        const rp = new json_schema_ref_parser_1.default();
+    if ((baseUrl && SUPPORTED_EXTENSIONS.find((x) => baseUrl.includes(x))) ||
+        baseUrl === "") {
+        const rp = new $RefParser();
         if (data) {
             return await rp.dereference(baseUrl, data, {});
         }
         else if (baseUrl) {
             return await rp.dereference(baseUrl);
         }
-        return data;
+        return data ?? {};
     }
-    return data;
+    return data ?? {};
 }
-exports.doDereference = doDereference;
-async function resolveJsonRefs(args) {
+export async function resolveJsonRefs(args) {
     const { data, baseUrl = "" } = args;
-    const json1 = data ? await deRefs(data, baseUrl) : null;
+    const json1 = data ? await deRefs(data, baseUrl) : {};
     const json2 = await doDereference({ data: json1, baseUrl });
     const json3 = await deRefs(json2, baseUrl);
     return json3;
 }
-exports.resolveJsonRefs = resolveJsonRefs;
-//# sourceMappingURL=json-refs-resolver.js.map

package/dist/es/managed-pool/index.d.ts

@@ -0,0 +1 @@
+export * from "./managed-pool";

package/dist/es/managed-pool/index.js

@@ -0,0 +1,2 @@
+// created from 'create-ts-index'
+export * from "./managed-pool";

package/dist/{managed-pool → es/managed-pool}/managed-pool.d.ts

@@ -21,4 +21,3 @@ export declare class ManagedPool<T, A, C> {
     acquireManaged(args: A): Promise<IManageItem<T>>;
     close(): void;
 }
-//# sourceMappingURL=managed-pool.d.ts.map

package/dist/{managed-pool → es/managed-pool}/managed-pool.js

@@ -1,19 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManagedPool = exports.DEFAULT_TIME_TO_IDLE = void 0;
-const slf_1 = require("@art-ws/slf");
-exports.DEFAULT_TIME_TO_IDLE = 2 * 60 * 1000;
-class ManagedPool {
+import { MemoryCacheBase } from "../mem-cache";
+import { getLogger } from "@art-ws/slf";
+export const DEFAULT_TIME_TO_IDLE = 2 * 60 * 1000;
+export class ManagedPool {
+    adapter;
+    cache;
+    logger = getLogger("ManagedPool");
+    poolCacheOptions;
     constructor(adapter, cache) {
         this.adapter = adapter;
         this.cache = cache;
-        this.logger = slf_1.getLogger(ManagedPool);
         const canRemove = (item) => this.adapter.canDestroy(item);
         const onRemove = (item) => {
             this.adapter.destroy(item);
         };
         const opts = this.adapter.getCacheOptions();
-        opts.timeToIdle = opts.timeToIdle || exports.DEFAULT_TIME_TO_IDLE;
+        opts.timeToIdle = opts.timeToIdle || DEFAULT_TIME_TO_IDLE;
         this.poolCacheOptions = { ...opts, onRemove, canRemove };
     }
     async acquire(args) {
@@ -42,5 +43,3 @@ class ManagedPool {
         this.cache.clear();
     }
 }
-exports.ManagedPool = ManagedPool;
-//# sourceMappingURL=managed-pool.js.map

package/dist/{managed-promise.d.ts → es/managed-promise.d.ts}

@@ -1,4 +1,5 @@
 export interface ManagedPromise<T> extends Promise<T> {
+    resolvedValue: unknown;
     resolve: (result?: unknown) => void;
     reject: (reason?: unknown) => void;
     cancel: () => void;
@@ -6,4 +7,3 @@ export interface ManagedPromise<T> extends Promise<T> {
 export declare function ManagedPromise<T>(args?: {
     onCancel?: () => void;
 }): ManagedPromise<T>;
-//# sourceMappingURL=managed-promise.d.ts.map