@cspell/cspell-pipe 8.12.1 → 8.13.1

package/dist/operators/append.js

@@ -5,13 +5,13 @@ import { isAsyncIterable } from '../helpers/index.js';
  * @returns
  */
 export function opAppendAsync(...iterablesToAppend) {
-    async function* fn(iter) {
+    async function* fnAppend(iter) {
         yield* iter;
         for (const i of iterablesToAppend) {
             yield* i;
         }
     }
-    return fn;
+    return fnAppend;
 }
 /**
  * Append values onto the end of an iterable.
@@ -19,13 +19,13 @@ export function opAppendAsync(...iterablesToAppend) {
  * @returns
  */
 export function opAppendSync(...iterablesToAppend) {
-    function* fn(iter) {
+    function* fnAppend(iter) {
         yield* iter;
         for (const i of iterablesToAppend) {
             yield* i;
         }
     }
-    return fn;
+    return fnAppend;
 }
 export function opAppend(...iterablesToAppend) {
     function _(i) {

package/dist/operators/buffer.js

@@ -5,7 +5,7 @@ import { isAsyncIterable } from '../helpers/util.js';
  * @returns A function that takes an async iterable and returns an async iterable of arrays of the given size.
  */
 export function opBufferAsync(size) {
-    async function* fn(iter) {
+    async function* fnBuffer(iter) {
         let buffer = [];
         for await (const v of iter) {
             buffer.push(v);
@@ -18,14 +18,14 @@ export function opBufferAsync(size) {
             yield buffer;
         }
     }
-    return fn;
+    return fnBuffer;
 }
 /**
  * @param size - The size of the buffer.
  * @returns A function that takes an iterable and returns an iterable of arrays of the given size.
  */
 export function opBufferSync(size) {
-    function* fn(iter) {
+    function* fnBuffer(iter) {
         let buffer = [];
         for (const v of iter) {
             buffer.push(v);
@@ -38,7 +38,7 @@ export function opBufferSync(size) {
             yield buffer;
         }
     }
-    return fn;
+    return fnBuffer;
 }
 export function opBuffer(size) {
     const asyncFn = opBufferAsync(size);

package/dist/operators/concatMap.d.ts

@@ -1,4 +1,5 @@
 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 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/concatMap.js

@@ -8,12 +8,43 @@ export function opConcatMapAsync(mapFn) {
     return fn;
 }
 export function opConcatMapSync(mapFn) {
-    function* fn(iter) {
+    function fnConcatMapSync(iterable) {
+        function opConcatMapIterator() {
+            const iter = iterable[Symbol.iterator]();
+            let resultsIter = undefined;
+            function nextConcatMap() {
+                while (true) {
+                    if (resultsIter) {
+                        const { done, value } = resultsIter.next();
+                        if (!done) {
+                            return { value };
+                        }
+                        resultsIter = undefined;
+                    }
+                    const { done, value } = iter.next();
+                    if (done) {
+                        return { done, value: undefined };
+                    }
+                    resultsIter = mapFn(value)[Symbol.iterator]();
+                }
+            }
+            return {
+                next: nextConcatMap,
+            };
+        }
+        return {
+            [Symbol.iterator]: opConcatMapIterator,
+        };
+    }
+    return fnConcatMapSync;
+}
+export function _opConcatMapSync(mapFn) {
+    function* fnConcatMapSync(iter) {
         for (const v of iter) {
             yield* mapFn(v);
         }
     }
-    return fn;
+    return fnConcatMapSync;
 }
 export const opConcatMap = (fn) => toPipeFn(opConcatMapSync(fn), opConcatMapAsync(fn));
 //# sourceMappingURL=concatMap.js.map

package/dist/operators/filter.d.ts

@@ -5,6 +5,8 @@ export declare function opFilterAsync<T>(filterFn: (v: Awaited<T>) => boolean):
 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 _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/filter.js

@@ -1,23 +1,46 @@
 import { isAsyncIterable } from '../helpers/util.js';
 // prettier-ignore
 export function opFilterAsync(filterFn) {
-    async function* fn(iter) {
+    async function* genFilter(iter) {
         for await (const v of iter) {
             const pass = await filterFn(v);
             if (pass)
                 yield v;
         }
     }
-    return fn;
+    return genFilter;
 }
 export function opFilterSync(filterFn) {
-    function* fn(iter) {
+    function opFilterIterable(iterable) {
+        function opFilterIterator() {
+            const iter = iterable[Symbol.iterator]();
+            function nextOpFilter() {
+                while (true) {
+                    const { done, value } = iter.next();
+                    if (done)
+                        return { done, value: undefined };
+                    if (filterFn(value))
+                        return { value };
+                }
+            }
+            return {
+                next: nextOpFilter,
+            };
+        }
+        return {
+            [Symbol.iterator]: opFilterIterator,
+        };
+    }
+    return opFilterIterable;
+}
+export function _opFilterSync(filterFn) {
+    function* genFilter(iter) {
         for (const v of iter) {
             if (filterFn(v))
                 yield v;
         }
     }
-    return fn;
+    return genFilter;
 }
 export function opFilter(fn) {
     const asyncFn = opFilterAsync(fn);

package/dist/operators/map.d.ts

@@ -1,4 +1,5 @@
 export declare function opMapAsync<T, U = T>(mapFn: (v: T) => U): (iter: AsyncIterable<T>) => AsyncIterable<U>;
-export declare function opMapSync<T, U = T>(mapFn: (v: T) => U): (iter: Iterable<T>) => Iterable<U>;
+export declare function _opMapSync<T, U = T>(mapFn: (v: T) => U): (iter: Iterable<T>) => Iterable<U>;
+export declare function opMapSync<T, U = T>(mapFn: (v: T) => U): (iterable: Iterable<T>) => Iterable<U>;
 export declare const opMap: <T, U>(fn: (v: T) => U) => import("../internalTypes.js").PipeFn<T, U>;
 //# sourceMappingURL=map.d.ts.map

package/dist/operators/map.js

@@ -1,19 +1,39 @@
 import { toPipeFn } from '../helpers/util.js';
 export function opMapAsync(mapFn) {
-    async function* fn(iter) {
+    async function* genMap(iter) {
         for await (const v of iter) {
             yield mapFn(v);
         }
     }
-    return fn;
+    return genMap;
 }
-export function opMapSync(mapFn) {
-    function* fn(iter) {
+export function _opMapSync(mapFn) {
+    function* genMap(iter) {
         for (const v of iter) {
             yield mapFn(v);
         }
     }
-    return fn;
+    return genMap;
+}
+export function opMapSync(mapFn) {
+    function opMapIterable(iterable) {
+        function opMapIterator() {
+            const iter = iterable[Symbol.iterator]();
+            function nextOpMap() {
+                const { done, value } = iter.next();
+                if (done)
+                    return { done, value: undefined };
+                return { value: mapFn(value) };
+            }
+            return {
+                next: nextOpMap,
+            };
+        }
+        return {
+            [Symbol.iterator]: opMapIterator,
+        };
+    }
+    return opMapIterable;
 }
 export const opMap = (fn) => toPipeFn(opMapSync(fn), opMapAsync(fn));
 //# sourceMappingURL=map.js.map

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "8.12.1",
+  "version": "8.13.1",
   "description": "Library to make working with Iterators/AsyncIterators easier.",
   "keywords": [
     "cspell",
@@ -99,18 +99,21 @@
     "!**/*.tsbuildInfo",
     "!**/__mocks__",
     "!**/*.spec.*",
+    "!**/*.perf.*",
     "!**/*.test.*",
+    "!**/perf/**",
     "!**/test/**",
     "!**/*.map"
   ],
   "scripts": {
-    "build": "tsc -b . -f",
-    "watch": "tsc -b . -w -f",
+    "build": "tsc -p .",
+    "watch": "tsc -p . -w",
     "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
     "clean-build": "pnpm run clean && pnpm run build",
     "coverage": "vitest run --coverage",
     "test-watch": "vitest",
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:perf": "NODE_ENV=production insight --register ts-node/esm --file \"**/*.perf.{mts,ts}\""
   },
   "repository": {
     "type": "git",
@@ -124,7 +127,8 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "globby": "^14.0.2"
+    "globby": "^14.0.2",
+    "perf-insight": "^1.2.0"
   },
-  "gitHead": "2b9d2fd6fb3a228886016f897c40e8b926e063ab"
+  "gitHead": "99cdb4e3e6579c57de1014b0cd3c168188b9c1f5"
 }