@youngspe/async-scope 0.1.0-dev.0 → 0.1.0-dev.1

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@youngspe/async-scope",
-  "version": "0.1.0-dev.0",
+  "version": "0.1.0-dev.1",
   "main": "./dist/index.js",
   "exports": {
     ".": "./dist/index.js",
     "./events": "./dist/events.js"
   },
   "type": "module",
+  "dependencies": {
+    "@youngspe/async-iter-utils": "0.1.0-dev.0",
+    "@youngspe/async-scope-common": "0.1.0-dev.0",
+    "@youngspe/common-async-utils": "0.1.0-dev.0"
+  },
   "devDependencies": {
     "knip": "^6.3.0"
   },

package/dist/join.d.ts

@@ -1,16 +0,0 @@
-import type { Awaitable, Falsy, OptionalUndefinedParams } from './types.ts';
-type Operation<T, U> = ((value: T, index: number) => Awaitable<U>) | ([T] extends [U] ? null | undefined : never);
-export declare function joinPromises<T, U = T, Out = never, Out2 = never>(src: Iterable<Awaitable<T>> | AsyncIterable<T>, ...[operation, onResolve, onReject]: OptionalUndefinedParams<[
-    operation: Operation<T, U>,
-    onResolve: ((value: U, index: number) => Awaitable<Out | Falsy>) | null | undefined,
-    onReject: ((reason: unknown, index: number) => Awaitable<Out2 | Falsy>) | null | undefined
-]>): Promise<NonNullable<Out | Out2> | undefined>;
-/**
- * Like `Promise.allSettled()`, this waits until all promises have settled. Like `Promise.all()`, this rejects if any promise rejects.
- */
-export declare function whenAllSettled<T, U = T, Out = never>(src: Iterable<Awaitable<T>> | AsyncIterable<T>, ...[operation, onResolve]: OptionalUndefinedParams<[
-    operation: Operation<T, U>,
-    onResolve: ((value: U, index: number) => Awaitable<Out | Falsy>) | null | undefined
-]>): Promise<Out | undefined>;
-export {};
-//# sourceMappingURL=join.d.ts.map

package/dist/join.js

@@ -1,85 +0,0 @@
-import { isIterable, isPromiseLike } from './utils.js';
-export async function joinPromises(src, ...[operation, onResolve, onReject]) {
-    return new Promise((_resolve, _reject) => {
-        let done = false;
-        let count = 1;
-        const resolve = (value) => {
-            if (value || --count === 0) {
-                done = true;
-                _resolve(value || undefined);
-            }
-        };
-        const reject = (e) => ((done = true), _reject(e));
-        const processItem = async (_value, index) => {
-            try {
-                if (done)
-                    return;
-                let awaited;
-                try {
-                    const value = isPromiseLike(_value) ? await _value : _value;
-                    if (operation) {
-                        if (done)
-                            return;
-                        const ret = operation(value, index);
-                        awaited = isPromiseLike(ret) ? await ret : ret;
-                        if (done)
-                            return;
-                    }
-                    else {
-                        awaited = value;
-                    }
-                }
-                catch (e) {
-                    if (!onReject)
-                        return reject(e);
-                    if (done)
-                        return;
-                    return resolve(await onReject(e, index));
-                }
-                return resolve(await onResolve?.(awaited, index));
-            }
-            catch (e) {
-                return reject(e);
-            }
-        };
-        void (async () => {
-            try {
-                let i = 0;
-                if (isIterable(src)) {
-                    for (const item of src) {
-                        ++count;
-                        void processItem(item, i++);
-                        if (done)
-                            break;
-                    }
-                }
-                else {
-                    for await (const item of src) {
-                        ++count;
-                        void processItem(item, i++);
-                        if (done)
-                            break;
-                    }
-                }
-                return resolve(undefined);
-            }
-            catch (e) {
-                return reject(e);
-            }
-        })();
-    });
-}
-/**
- * Like `Promise.allSettled()`, this waits until all promises have settled. Like `Promise.all()`, this rejects if any promise rejects.
- */
-export async function whenAllSettled(src, ...[operation, onResolve]) {
-    const errors = new Set();
-    const out = await joinPromises(src, operation, onResolve, e => void errors.add(e));
-    if (out !== undefined)
-        return out;
-    if (errors.size > 1)
-        throw new AggregateError(errors);
-    if (errors.size === 1)
-        throw errors.values().next().value;
-}
-//# sourceMappingURL=join.js.map

package/dist/timer.d.ts

@@ -1,13 +0,0 @@
-import type { CancellableOptions } from './cancel.ts';
-interface Clock {
-    setTimeout: typeof globalThis.setTimeout;
-    setInterval: typeof globalThis.setInterval;
-    clearTimeout: typeof globalThis.clearTimeout;
-    clearInterval: typeof globalThis.clearInterval;
-}
-interface TimerOptions extends CancellableOptions {
-    clock?: Clock | undefined;
-}
-export declare function delay(ms: number, options?: TimerOptions): Promise<void>;
-export {};
-//# sourceMappingURL=timer.d.ts.map

package/dist/utils.d.ts

@@ -1,51 +0,0 @@
-import type { Awaitable, UnlessNeverElse } from './types.ts';
-/**
- * Gets the base {@link Iterable} types for each constituent of union type `I` that is an iterable.
- * Discards all non-iterable constituents.
- *
- * This is a helper for {@linkcode AsIterable}.
- */
-type ExtractIterable<I> = I extends Iterable<infer X, infer Y, infer Z> ? Iterable<X, Y, Z> : never;
-/**
- * If `I` or any of its union constituents extend {@link Iterable}, evaluates to the base iterable
- * type of `I` or its constituents.
- * Otherwise, evaluates to {@linkcode Iterable|Iterable<unknown, unknown, any>}.
- *
- * This is used in the predicate type of {@linkcode isIterable} to narrow a type down to
- * {@link Iterable} while preserving the most likely `yield`, `return`, and `next` types.
- */
-type AsIterable<I> = UnlessNeverElse<ExtractIterable<I>, Iterable<unknown, unknown, any>>;
-export declare function isIterable<T>(value: T | AsIterable<T> | null | undefined): value is AsIterable<T>;
-export declare function isPromiseLike<T>(value: Awaitable<T> | null | undefined): value is PromiseLike<T>;
-/** @returns `true` if `value` has a {@linkcode Symbol.dispose} method. */
-export declare function isDisposable(value: unknown): value is Disposable;
-/** @returns `true` if `value` has a {@linkcode Symbol.asyncDispose} method. */
-export declare function isAsyncDisposable(value: unknown): value is AsyncDisposable;
-/**
- * Gets the base {@link Array} types for each constituent of union type `I` that is an array.
- * Discards all non-array constituents.
- *
- * This is a helper for {@linkcode AsArray}.
- */
-type ExtractArray<I> = I extends Array<infer X> ? X[] : I extends ReadonlyArray<infer X> ? readonly X[] : never;
-/**
- * If `I` or any of its union constituents extend {@link Array} or {@link ReadonlyArray}, evaluates
- * to the base array type of `I` or its constituents.
- * Otherwise, evaluates to `unknown[]`.
- *
- * This is used in the predicate type of {@linkcode isArray} to narrow a type down to {@link Array}
- * while preserving the most likely element type.
- */
-type AsArray<I> = UnlessNeverElse<ExtractArray<I>, unknown[]>;
-interface IsArrayFunction {
-    <I>(value: I | AsArray<I> | null | undefined): value is AsArray<I>;
-}
-/**
- * @returns `true` if {@link value} is an array.
- *
- * @remarks
- * This is an alias for {@link Array.isArray} but the types work out better for readonly arrays.
- */
-export declare const isArray: IsArrayFunction;
-export {};
-//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -1,20 +0,0 @@
-export function isIterable(value) {
-    return typeof value?.[Symbol.iterator] === 'function';
-}
-export function isPromiseLike(value) {
-    return typeof value?.then === 'function';
-}
-export function isDisposable(value) {
-    return typeof value?.[Symbol.dispose] === 'function';
-}
-export function isAsyncDisposable(value) {
-    return typeof value?.[Symbol.asyncDispose] === 'function';
-}
-/**
- * @returns `true` if {@link value} is an array.
- *
- * @remarks
- * This is an alias for {@link Array.isArray} but the types work out better for readonly arrays.
- */
-export const isArray = Array.isArray.bind(Array);
-//# sourceMappingURL=utils.js.map