@cspell/cspell-pipe 6.18.0 → 6.19.0

package/dist/cjs/internalTypes.d.ts

@@ -0,0 +1,17 @@
+export interface PipeFnSync<T, U> {
+    (iter: Iterable<T>): Iterable<U>;
+    /** This is just to help TypeScript figure out the type. */
+    __PipeFnSync__?: [T, U];
+}
+export interface PipeFnAsync<T, U> {
+    (iter: AsyncIterable<T>): AsyncIterable<U>;
+    /** This is just to help TypeScript figure out the type. */
+    __PipeFnAsync__?: [T, U];
+}
+export type PipeFn<T, U> = PipeFnSync<T, U> & PipeFnAsync<T, U>;
+export type PsFn<T, U> = PipeFnSync<T, U> | ((i: Iterable<T>) => Iterable<U>);
+export type AnyIterable<T> = Iterable<T> | AsyncIterable<T> | Promise<Iterable<T>> | Iterable<Promise<T>>;
+export type PaFn<T, U> = PipeFnAsync<T, U> | ((i: AsyncIterable<T>) => AsyncIterable<U>);
+export type PipeAsyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PaFn<Left, Right>, ...PipeAsyncTx<[Right, ...Rest]>] : [PaFn<Left, Right>] : never;
+export type PipeSyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PsFn<Left, Right>, ...PipeSyncTx<[Right, ...Rest]>] : [PsFn<Left, Right>] : never;
+//# sourceMappingURL=internalTypes.d.ts.map

package/dist/{operators/append.js → cjs/operators/append.cjs}

@@ -1,7 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.opAppend = exports.opAppendSync = exports.opAppendAsync = void 0;
-const helpers_1 = require("../helpers");
+'use strict';
+
+function isAsyncIterable(i) {
+    return typeof i[Symbol.asyncIterator] === 'function';
+}
+
 /**
  * Append values onto the end of an iterable.
  * @param iterablesToAppend - the iterables in the order to be appended.
@@ -16,7 +18,6 @@ function opAppendAsync(...iterablesToAppend) {
     }
     return fn;
 }
-exports.opAppendAsync = opAppendAsync;
 /**
  * Append values onto the end of an iterable.
  * @param iterablesToAppend - the iterables in the order to be appended.
@@ -31,12 +32,13 @@ function opAppendSync(...iterablesToAppend) {
     }
     return fn;
 }
-exports.opAppendSync = opAppendSync;
 function opAppend(...iterablesToAppend) {
     function _(i) {
-        return (0, helpers_1.isAsyncIterable)(i) ? opAppendAsync(...iterablesToAppend)(i) : opAppendSync(...iterablesToAppend)(i);
+        return isAsyncIterable(i) ? opAppendAsync(...iterablesToAppend)(i) : opAppendSync(...iterablesToAppend)(i);
     }
     return _;
 }
+
 exports.opAppend = opAppend;
-//# sourceMappingURL=append.js.map
+exports.opAppendAsync = opAppendAsync;
+exports.opAppendSync = opAppendSync;

package/dist/cjs/operators/append.d.ts

@@ -0,0 +1,15 @@
+import type { PipeFn } from '../internalTypes.js';
+/**
+ * Append values onto the end of an iterable.
+ * @param iterablesToAppend - the iterables in the order to be appended.
+ * @returns
+ */
+export declare function opAppendAsync<T>(...iterablesToAppend: (AsyncIterable<T> | Iterable<T>)[]): (iter: AsyncIterable<T> | Iterable<T>) => AsyncIterable<T>;
+/**
+ * Append values onto the end of an iterable.
+ * @param iterablesToAppend - the iterables in the order to be appended.
+ * @returns
+ */
+export declare function opAppendSync<T>(...iterablesToAppend: Iterable<T>[]): (iter: Iterable<T>) => Iterable<T>;
+export declare function opAppend<T>(...iterablesToAppend: Iterable<T>[]): PipeFn<T, T>;
+//# sourceMappingURL=append.d.ts.map

package/dist/{operators/await.js → cjs/operators/await.cjs}

@@ -1,6 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.opAwaitAsync = void 0;
+'use strict';
+
 async function* _asyncAwait(iter) {
     for await (const v of iter) {
         yield v;
@@ -9,5 +8,5 @@ async function* _asyncAwait(iter) {
 function opAwaitAsync() {
     return _asyncAwait;
 }
+
 exports.opAwaitAsync = opAwaitAsync;
-//# sourceMappingURL=await.js.map

package/dist/cjs/operators/await.d.ts

@@ -0,0 +1,2 @@
+export declare function opAwaitAsync<T>(): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
+//# sourceMappingURL=await.d.ts.map

package/dist/{operators/combine.js → cjs/operators/combine.cjs}

@@ -1,6 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.opCombineSync = exports.opCombineAsync = void 0;
+'use strict';
+
 function opCombineAsync(...fns) {
     function combine(iter) {
         for (const fn of fns) {
@@ -10,7 +9,6 @@ function opCombineAsync(...fns) {
     }
     return combine;
 }
-exports.opCombineAsync = opCombineAsync;
 function opCombineSync(...fns) {
     function combine(iter) {
         for (const fn of fns) {
@@ -20,5 +18,6 @@ function opCombineSync(...fns) {
     }
     return combine;
 }
+
+exports.opCombineAsync = opCombineAsync;
 exports.opCombineSync = opCombineSync;
-//# sourceMappingURL=combine.js.map

package/dist/cjs/operators/combine.d.ts

@@ -0,0 +1,23 @@
+import type { PaFn, PipeAsyncTx, PipeSyncTx, PsFn } from '../internalTypes.js';
+import type { OperatorAsync, OperatorSync } from './types.js';
+export declare function opCombineAsync<T>(): OperatorAsync<T>;
+export declare function opCombineAsync<T, T0>(...f: PipeAsyncTx<[T, T0]>): OperatorAsync<T0>;
+export declare function opCombineAsync<T, T0, T1>(...f: PipeAsyncTx<[T, T0, T1]>): OperatorAsync<T1>;
+export declare function opCombineAsync<T, T0, T1, T2>(...f: PipeAsyncTx<[T, T0, T1, T2]>): OperatorAsync<T2>;
+export declare function opCombineAsync<T, T0, T1, T2, T3>(...f: PipeAsyncTx<[T, T0, T1, T2, T3]>): OperatorAsync<T3>;
+export declare function opCombineAsync<T, T0, T1, T2, T3, T4>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4]>): OperatorAsync<T4>;
+export declare function opCombineAsync<T, T0, T1, T2, T3, T4, T5>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5]>): OperatorAsync<T5>;
+export declare function opCombineAsync<T, T0, T1, T2, T3, T4, T5, T6>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5, T6]>): OperatorAsync<T6>;
+export declare function opCombineAsync<T, T0, T1, T2, T3, T4, T5, T6, T7>(...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5, T6, T7]>): OperatorAsync<T7>;
+export declare function opCombineAsync<T>(...fns: PaFn<T, T>[]): OperatorAsync<T>;
+export declare function opCombineSync<T>(): OperatorSync<T>;
+export declare function opCombineSync<T, T0 = T>(...f: PipeSyncTx<[T, T0]>): OperatorSync<T0>;
+export declare function opCombineSync<T, T0, T1>(...f: PipeSyncTx<[T, T0, T1]>): OperatorSync<T1>;
+export declare function opCombineSync<T, T0, T1, T2>(...f: PipeSyncTx<[T, T0, T1, T2]>): OperatorSync<T2>;
+export declare function opCombineSync<T, T0, T1, T2, T3>(...f: PipeSyncTx<[T, T0, T1, T2, T3]>): OperatorSync<T3>;
+export declare function opCombineSync<T, T0, T1, T2, T3, T4>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4]>): OperatorSync<T4>;
+export declare function opCombineSync<T, T0, T1, T2, T3, T4, T5>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5]>): OperatorSync<T5>;
+export declare function opCombineSync<T, T0, T1, T2, T3, T4, T5, T6>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5, T6]>): OperatorSync<T6>;
+export declare function opCombineSync<T, T0, T1, T2, T3, T4, T5, T6, T7>(...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5, T6, T7]>): OperatorSync<T7>;
+export declare function opCombineSync<T>(...fns: PsFn<T, T>[]): OperatorSync<T>;
+//# sourceMappingURL=combine.d.ts.map

package/dist/{operators/concatMap.js → cjs/operators/concatMap.cjs}

@@ -1,7 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.opConcatMap = exports.opConcatMapSync = exports.opConcatMapAsync = void 0;
-const util_1 = require("../helpers/util");
+'use strict';
+
+function toPipeFn(syncFn, asyncFn) {
+    function _(i) {
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
+    }
+    return _;
+}
+function isAsyncIterable(i) {
+    return typeof i[Symbol.asyncIterator] === 'function';
+}
+
 function opConcatMapAsync(mapFn) {
     async function* fn(iter) {
         for await (const v of iter) {
@@ -10,7 +18,6 @@ function opConcatMapAsync(mapFn) {
     }
     return fn;
 }
-exports.opConcatMapAsync = opConcatMapAsync;
 function opConcatMapSync(mapFn) {
     function* fn(iter) {
         for (const v of iter) {
@@ -19,7 +26,8 @@ function opConcatMapSync(mapFn) {
     }
     return fn;
 }
-exports.opConcatMapSync = opConcatMapSync;
-const opConcatMap = (fn) => (0, util_1.toPipeFn)(opConcatMapSync(fn), opConcatMapAsync(fn));
+const opConcatMap = (fn) => toPipeFn(opConcatMapSync(fn), opConcatMapAsync(fn));
+
 exports.opConcatMap = opConcatMap;
-//# sourceMappingURL=concatMap.js.map
+exports.opConcatMapAsync = opConcatMapAsync;
+exports.opConcatMapSync = opConcatMapSync;

package/dist/cjs/operators/concatMap.d.ts

@@ -0,0 +1,4 @@
+export declare function opConcatMapAsync<T, U = T>(mapFn: (v: T) => AsyncIterable<U> | Iterable<U>): (iter: AsyncIterable<T>) => AsyncIterable<U>;
+export declare function opConcatMapSync<T, U = T>(mapFn: (v: T) => Iterable<U>): (iter: Iterable<T>) => Iterable<U>;
+export declare const opConcatMap: <T, U>(fn: (v: T) => Iterable<U>) => import("../internalTypes.js").PipeFn<T, U>;
+//# sourceMappingURL=concatMap.d.ts.map

package/dist/{operators/filter.js → cjs/operators/filter.cjs}

@@ -1,7 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.opFilter = exports.opFilterSync = exports.opFilterAsync = void 0;
-const util_1 = require("../helpers/util");
+'use strict';
+
+function isAsyncIterable(i) {
+    return typeof i[Symbol.asyncIterator] === 'function';
+}
+
 // prettier-ignore
 function opFilterAsync(filterFn) {
     async function* fn(iter) {
@@ -13,7 +15,6 @@ function opFilterAsync(filterFn) {
     }
     return fn;
 }
-exports.opFilterAsync = opFilterAsync;
 function opFilterSync(filterFn) {
     function* fn(iter) {
         for (const v of iter) {
@@ -23,14 +24,15 @@ function opFilterSync(filterFn) {
     }
     return fn;
 }
-exports.opFilterSync = opFilterSync;
 function opFilter(fn) {
     const asyncFn = opFilterAsync(fn);
     const syncFn = opFilterSync(fn);
     function _(i) {
-        return (0, util_1.isAsyncIterable)(i) ? asyncFn(i) : syncFn(i);
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
     }
     return _;
 }
+
 exports.opFilter = opFilter;
-//# sourceMappingURL=filter.js.map
+exports.opFilterAsync = opFilterAsync;
+exports.opFilterSync = opFilterSync;

package/dist/cjs/operators/filter.d.ts

@@ -0,0 +1,10 @@
+import type { PipeFn } from '../internalTypes.js';
+export declare function opFilterAsync<T, S extends T>(filterFn: (v: T) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
+export declare function opFilterAsync<T, S extends Awaited<T>>(filterFn: (v: Awaited<T>) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
+export declare function opFilterAsync<T>(filterFn: (v: Awaited<T>) => boolean): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
+export declare function opFilterAsync<T>(filterFn: (v: Awaited<T>) => Promise<boolean>): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
+export declare function opFilterSync<T, S extends T>(filterFn: (v: T) => v is S): (iter: Iterable<T>) => Iterable<S>;
+export declare function opFilterSync<T>(filterFn: (v: T) => boolean): (iter: Iterable<T>) => Iterable<T>;
+export declare function opFilter<T, S extends T>(fn: (v: T) => v is S): PipeFn<T, S>;
+export declare function opFilter<T>(fn: (v: T) => boolean): PipeFn<T, T>;
+//# sourceMappingURL=filter.d.ts.map

package/dist/{operators/first.js → cjs/operators/first.cjs}

@@ -1,7 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.opFirst = exports.opFirstSync = exports.opFirstAsync = void 0;
-const util_1 = require("../helpers/util");
+'use strict';
+
+function isAsyncIterable(i) {
+    return typeof i[Symbol.asyncIterator] === 'function';
+}
+
 // prettier-ignore
 function opFirstAsync(firstFn) {
     async function* fn(iter) {
@@ -15,7 +17,6 @@ function opFirstAsync(firstFn) {
     }
     return fn;
 }
-exports.opFirstAsync = opFirstAsync;
 function opFirstSync(firstFn) {
     function* fn(iter) {
         for (const v of iter) {
@@ -27,14 +28,15 @@ function opFirstSync(firstFn) {
     }
     return fn;
 }
-exports.opFirstSync = opFirstSync;
 function opFirst(fn) {
     const asyncFn = opFirstAsync(fn);
     const syncFn = opFirstSync(fn);
     function _(i) {
-        return (0, util_1.isAsyncIterable)(i) ? asyncFn(i) : syncFn(i);
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
     }
     return _;
 }
+
 exports.opFirst = opFirst;
-//# sourceMappingURL=first.js.map
+exports.opFirstAsync = opFirstAsync;
+exports.opFirstSync = opFirstSync;

package/dist/cjs/operators/first.d.ts

@@ -0,0 +1,10 @@
+import type { PipeFn } from '../internalTypes.js';
+export declare function opFirstAsync<T, S extends T>(firstFn: (v: T) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
+export declare function opFirstAsync<T, S extends Awaited<T>>(firstFn: (v: Awaited<T>) => v is S): (iter: AsyncIterable<T>) => AsyncIterable<S>;
+export declare function opFirstAsync<T>(firstFn: (v: Awaited<T>) => boolean): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
+export declare function opFirstAsync<T>(firstFn: (v: Awaited<T>) => Promise<boolean>): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
+export declare function opFirstSync<T, S extends T>(firstFn: (v: T) => v is S): (iter: Iterable<T>) => Iterable<S>;
+export declare function opFirstSync<T>(firstFn: (v: T) => boolean): (iter: Iterable<T>) => Iterable<T>;
+export declare function opFirst<T, S extends T>(fn: (v: T) => v is S): PipeFn<T, S>;
+export declare function opFirst<T>(fn: (v: T) => boolean): PipeFn<T, T>;
+//# sourceMappingURL=first.d.ts.map

package/dist/{operators/flatten.js → cjs/operators/flatten.cjs}

@@ -1,7 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.opFlatten = exports.opFlattenSync = exports.opFlattenAsync = void 0;
-const util_1 = require("../helpers/util");
+'use strict';
+
+function toPipeFn(syncFn, asyncFn) {
+    function _(i) {
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
+    }
+    return _;
+}
+function isAsyncIterable(i) {
+    return typeof i[Symbol.asyncIterator] === 'function';
+}
+
 function opFlattenAsync() {
     async function* fn(iter) {
         for await (const v of iter) {
@@ -10,7 +18,6 @@ function opFlattenAsync() {
     }
     return fn;
 }
-exports.opFlattenAsync = opFlattenAsync;
 function opFlattenSync() {
     function* fn(iter) {
         for (const v of iter) {
@@ -19,7 +26,8 @@ function opFlattenSync() {
     }
     return fn;
 }
-exports.opFlattenSync = opFlattenSync;
-const opFlatten = () => (0, util_1.toPipeFn)(opFlattenSync(), opFlattenAsync());
+const opFlatten = () => toPipeFn(opFlattenSync(), opFlattenAsync());
+
 exports.opFlatten = opFlatten;
-//# sourceMappingURL=flatten.js.map
+exports.opFlattenAsync = opFlattenAsync;
+exports.opFlattenSync = opFlattenSync;

package/dist/cjs/operators/flatten.d.ts

@@ -0,0 +1,4 @@
+export declare function opFlattenAsync<T>(): (iter: AsyncIterable<AsyncIterable<T> | Iterable<T>>) => AsyncIterable<T>;
+export declare function opFlattenSync<T>(): (iter: Iterable<Iterable<T>>) => Iterable<T>;
+export declare const opFlatten: <T>() => import("../internalTypes.js").PipeFn<Iterable<T>, T>;
+//# sourceMappingURL=flatten.d.ts.map

package/dist/cjs/operators/helpers/distribute.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Allows an iterable to be shared by multiple consumers.
+ * Each consumer takes from the iterable.
+ * @param iterable - the iterable to share
+ */
+export declare function toDistributableIterableSync<T>(iterable: Iterable<T>): Iterable<T>;
+/**
+ * Allows an iterable to be shared by multiple consumers.
+ * Each consumer takes from the iterable.
+ * @param iterable - the iterable to share
+ */
+export declare const toDistributableIterable: typeof toDistributableIterableSync;
+//# sourceMappingURL=distribute.d.ts.map

package/dist/cjs/operators/helpers/index.d.ts

@@ -0,0 +1,7 @@
+export { toDistributableIterable } from './distribute.js';
+export { interleave } from './interleave.js';
+export { asyncIteratorToAsyncIterable, iteratorToIterable } from './iteratorToIterable.js';
+export { toArray } from './toArray.js';
+export { toAsyncIterable } from './toAsyncIterable.js';
+export { isAsyncIterable } from './util.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/operators/helpers/interleave.d.ts

@@ -0,0 +1,2 @@
+export declare function interleave<T>(a: Iterable<T>, b: Iterable<T>): Iterable<T>;
+//# sourceMappingURL=interleave.d.ts.map

package/dist/cjs/operators/helpers/iteratorToIterable.d.ts

@@ -0,0 +1,3 @@
+export declare function iteratorToIterable<T>(iterator: Iterator<T>): Iterable<T>;
+export declare function asyncIteratorToAsyncIterable<T>(iterator: AsyncIterator<T> | Iterator<T>): AsyncIterable<T>;
+//# sourceMappingURL=iteratorToIterable.d.ts.map

package/dist/cjs/operators/helpers/toArray.d.ts

@@ -0,0 +1,6 @@
+export declare function toArray<T>(i: AsyncIterable<T>): Promise<Awaited<T>[]>;
+export declare function toArray<T>(i: Iterable<T>): T[];
+export declare function toArray<T>(i: Iterable<T> | AsyncIterable<T>): T[] | Promise<Awaited<T>[]>;
+export declare function toArraySync<T>(iter: Iterable<T>): T[];
+export declare function toArrayAsync<T>(iter: AsyncIterable<T>): Promise<Awaited<T>[]>;
+//# sourceMappingURL=toArray.d.ts.map

package/dist/cjs/operators/helpers/toAsyncIterable.d.ts

@@ -0,0 +1,11 @@
+import type { AnyIterable } from '../internalTypes.js';
+export declare function mergeAsyncIterables<T>(iter: Iterable<T>): AsyncIterable<T>;
+export declare function mergeAsyncIterables<T>(iter: AsyncIterable<T>): AsyncIterable<T>;
+export declare function mergeAsyncIterables<T>(iter: Promise<Iterable<T>>): AsyncIterable<T>;
+export declare function mergeAsyncIterables<T>(iter: AnyIterable<T>): AsyncIterable<T>;
+export declare function mergeAsyncIterables<T>(iter: AnyIterable<T>, ...rest: AnyIterable<T>[]): AsyncIterable<T>;
+/**
+ * Convert one or more iterables to an AsyncIterable
+ */
+export declare const toAsyncIterable: typeof mergeAsyncIterables;
+//# sourceMappingURL=toAsyncIterable.d.ts.map

package/dist/cjs/operators/helpers/util.d.ts

@@ -0,0 +1,4 @@
+import type { AnyIterable, PipeFn, PipeFnAsync, PipeFnSync } from '../internalTypes.js';
+export declare function toPipeFn<T, U = T>(syncFn: PipeFnSync<T, U>, asyncFn: PipeFnAsync<T, U>): PipeFn<T, U>;
+export declare function isAsyncIterable<T>(i: AnyIterable<T>): i is AsyncIterable<T>;
+//# sourceMappingURL=util.d.ts.map