@effectionx/stream-helpers 0.1.0

package/esm/test-helpers/faucet.d.ts

@@ -0,0 +1,78 @@
+import { type Operation, type Stream } from "effection";
+/**
+ * Interface of the stream returned by `useFaucet`.
+ */
+export interface Faucet<T> extends Stream<T, never> {
+    /**
+     * Pour items to the stream synchronously.
+     * @param items - The items to pour to the stream.
+     */
+    pour(items: T[]): Operation<void>;
+    /**
+     * Pour items to the stream using an operation that can be asynchronous.
+     * @param op - The generator function to pour items to the stream.
+     */
+    pour(op: (send: (item: T) => Operation<void>) => Operation<void>): Operation<void>;
+    /**
+     * Open the stream to allow items to be sent to the stream.
+     */
+    open(): void;
+    /**
+     * Close the stream to prevent items from being sent to the stream.
+     */
+    close(): void;
+}
+/**
+ * Options for the faucet.
+ */
+export interface FaucetOptions {
+    /**
+     * Whether the faucet is open when created.
+     */
+    open?: boolean;
+}
+/**
+ * Creates a stream that can be used to test the behavior of streams that use backpressure.
+ * It's useful in tests where it can be used as a source stream. This function is used to create
+ * the stream.
+ *
+ * The returned stream has `pour` method that can be used to send items to the stream.
+ * It can accept an array of items or a generator function that will be called with a function
+ * to send items to the stream.
+ *
+ * ```typescript
+ * import { useFaucet } from "@effectionx/stream-helpers/test-helpers";
+ * import { run, each, spawn } from "effection";
+ *
+ * await run(function* () {
+ *   const faucet = yield* useFaucet({ open: true });
+ *
+ *   // Remember to spawn the stream subscription before sending items to the stream
+ *   yield* spawn(function* () {
+ *     for (let i of yield* each(faucet)) {
+ *       console.log(i);
+ *       yield* each.next();
+ *     }
+ *   });
+ *
+ *   // Pass an array of items to send items to the stream one at a time synchronously
+ *   yield* faucet.pour([1, 2, 3]);
+ *
+ *   // Pass an operation to control the rate at which items are sent to the stream
+ *   yield* faucet.pour(function* (send) {
+ *     yield* sleep(10);
+ *     send(5);
+ *     yield* sleep(30);
+ *     send(6);
+ *     yield* sleep(10);
+ *     send(7);
+ *   });
+ * });
+ *
+ * ```
+ * @param options - The options for the faucet.
+ * @param options.open - Whether the faucet is open.
+ * @returns stream of items coming from the faucet
+ */
+export declare function useFaucet<T>(options: FaucetOptions): Operation<Faucet<T>>;
+//# sourceMappingURL=faucet.d.ts.map

package/esm/test-helpers/faucet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faucet.d.ts","sourceRoot":"","sources":["../../src/test-helpers/faucet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,SAAS,EAAE,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAGtE;;GAEG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC;IACjD;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAClC;;;OAGG;IACH,IAAI,CACF,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC,GAC1D,SAAS,CAAC,IAAI,CAAC,CAAC;IACnB;;OAEG;IACH,IAAI,IAAI,IAAI,CAAC;IACb;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAiB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CA0B1E"}

package/esm/test-helpers/faucet.js

@@ -0,0 +1,72 @@
+import { createSignal } from "effection";
+import { createBoolean, is } from "../signals.js";
+/**
+ * Creates a stream that can be used to test the behavior of streams that use backpressure.
+ * It's useful in tests where it can be used as a source stream. This function is used to create
+ * the stream.
+ *
+ * The returned stream has `pour` method that can be used to send items to the stream.
+ * It can accept an array of items or a generator function that will be called with a function
+ * to send items to the stream.
+ *
+ * ```typescript
+ * import { useFaucet } from "@effectionx/stream-helpers/test-helpers";
+ * import { run, each, spawn } from "effection";
+ *
+ * await run(function* () {
+ *   const faucet = yield* useFaucet({ open: true });
+ *
+ *   // Remember to spawn the stream subscription before sending items to the stream
+ *   yield* spawn(function* () {
+ *     for (let i of yield* each(faucet)) {
+ *       console.log(i);
+ *       yield* each.next();
+ *     }
+ *   });
+ *
+ *   // Pass an array of items to send items to the stream one at a time synchronously
+ *   yield* faucet.pour([1, 2, 3]);
+ *
+ *   // Pass an operation to control the rate at which items are sent to the stream
+ *   yield* faucet.pour(function* (send) {
+ *     yield* sleep(10);
+ *     send(5);
+ *     yield* sleep(30);
+ *     send(6);
+ *     yield* sleep(10);
+ *     send(7);
+ *   });
+ * });
+ *
+ * ```
+ * @param options - The options for the faucet.
+ * @param options.open - Whether the faucet is open.
+ * @returns stream of items coming from the faucet
+ */
+export function* useFaucet(options) {
+    let signal = createSignal();
+    let open = yield* createBoolean(options.open);
+    return {
+        [Symbol.iterator]: signal[Symbol.iterator],
+        *pour(items) {
+            if (Array.isArray(items)) {
+                for (let i of items) {
+                    yield* is(open, (open) => open);
+                    signal.send(i);
+                }
+            }
+            else {
+                yield* items(function* (item) {
+                    yield* is(open, (open) => open);
+                    signal.send(item);
+                });
+            }
+        },
+        close() {
+            open.set(false);
+        },
+        open() {
+            open.set(true);
+        },
+    };
+}

package/esm/test-helpers.d.ts

@@ -0,0 +1,2 @@
+export * from "./test-helpers/faucet.js";
+//# sourceMappingURL=test-helpers.d.ts.map

package/esm/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../src/test-helpers.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/esm/test-helpers.js

@@ -0,0 +1 @@
+export * from "./test-helpers/faucet.js";

package/esm/tracker.d.ts

@@ -0,0 +1,24 @@
+import { type Operation, type Stream } from "effection";
+export interface Tracker extends Operation<void> {
+    /**
+     * Returns a stream helper that doesn't modify the items passing through the stream,
+     * but will capture a reference to the item. Call the `markOne` or `markMany` methods
+     * with the item to indicate that it has exited the stream.
+     */
+    passthrough(): <T>(stream: Stream<T, never>) => Stream<T, never>;
+    /**
+     * Call this method with an item that has passed through the stream to indicate that it has exited the stream.
+     */
+    markOne(item: unknown): void;
+    /**
+     * Call this method with an iterable of items that have passed through the stream to indicate that they have exited the stream.
+     */
+    markMany(items: Iterable<unknown>): void;
+}
+/**
+ * Creates a tracker that can be used to verify that all items that entered the stream
+ * eventually exit the stream. This is helpful when you want to ensure that all items
+ * were processed before terminating the operation that created the stream.
+ */
+export declare function createTracker(): Operation<Tracker>;
+//# sourceMappingURL=tracker.d.ts.map

package/esm/tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracker.d.ts","sourceRoot":"","sources":["../src/tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAY,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAGlE,MAAM,WAAW,OAAQ,SAAQ,SAAS,CAAC,IAAI,CAAC;IAC9C;;;;OAIG;IACH,WAAW,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACjE;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC1C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,IAAI,SAAS,CAAC,OAAO,CAAC,CAiClD"}

package/esm/tracker.js

@@ -0,0 +1,39 @@
+import { resource } from "effection";
+import { createSetSignal, is } from "./signals.js";
+/**
+ * Creates a tracker that can be used to verify that all items that entered the stream
+ * eventually exit the stream. This is helpful when you want to ensure that all items
+ * were processed before terminating the operation that created the stream.
+ */
+export function createTracker() {
+    return resource(function* (provide) {
+        const tracked = yield* createSetSignal();
+        yield* provide({
+            *[Symbol.iterator]() {
+                yield* is(tracked, (set) => set.size === 0);
+            },
+            passthrough() {
+                return function (stream) {
+                    return {
+                        *[Symbol.iterator]() {
+                            const subscription = yield* stream;
+                            return {
+                                *next() {
+                                    const next = yield* subscription.next();
+                                    tracked.add(next.value);
+                                    return next;
+                                },
+                            };
+                        },
+                    };
+                };
+            },
+            markOne(item) {
+                tracked.delete(item);
+            },
+            markMany(items) {
+                tracked.difference(items);
+            },
+        });
+    });
+}

package/esm/valve.d.ts

@@ -0,0 +1,22 @@
+import { type Operation, type Stream } from "effection";
+export interface ValveOptions {
+    openAt: number;
+    closeAt: number;
+    open(): Operation<void>;
+    close(): Operation<void>;
+}
+/**
+ * This function buffers incoming items, if the upstream is producing faster than the downstream
+ * can consume, the buffer will grow. If the buffer size exceeds the `closeAt` threshold, the
+ * `close` operation will be called which is expected to pause the upstream. The buffer will
+ * drain until the buffer size is less than the `openAt` threshold, at which point the `open`
+ * operation will be called to resume the upstream.
+ *
+ * @param options.open - The operation to resume the upstream.
+ * @param options.openAt - The buffer size at which the upstream will be resumed.
+ * @param options.close - The operation to pause the upstream.
+ * @param options.closeAt - The buffer size at which the upstream will be paused.
+ * @returns A stream with backpressure applied.
+ */
+export declare function valve(options: ValveOptions): <T>(stream: Stream<T, never>) => Stream<T, never>;
+//# sourceMappingURL=valve.d.ts.map

package/esm/valve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valve.d.ts","sourceRoot":"","sources":["../src/valve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,SAAS,EAAS,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAGrE,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC;IACxB,KAAK,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,YAAY,GACpB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAkCnD"}

package/esm/valve.js

@@ -0,0 +1,48 @@
+import { each, spawn } from "effection";
+import { createArraySignal } from "./signals.js";
+/**
+ * This function buffers incoming items, if the upstream is producing faster than the downstream
+ * can consume, the buffer will grow. If the buffer size exceeds the `closeAt` threshold, the
+ * `close` operation will be called which is expected to pause the upstream. The buffer will
+ * drain until the buffer size is less than the `openAt` threshold, at which point the `open`
+ * operation will be called to resume the upstream.
+ *
+ * @param options.open - The operation to resume the upstream.
+ * @param options.openAt - The buffer size at which the upstream will be resumed.
+ * @param options.close - The operation to pause the upstream.
+ * @param options.closeAt - The buffer size at which the upstream will be paused.
+ * @returns A stream with backpressure applied.
+ */
+export function valve(options) {
+    return function (stream) {
+        return {
+            *[Symbol.iterator]() {
+                const buffer = yield* createArraySignal([]);
+                let open = true;
+                yield* spawn(function* () {
+                    for (const item of yield* each(stream)) {
+                        buffer.push(item);
+                        if (open && buffer.length >= options.closeAt) {
+                            yield* options.close();
+                            open = false;
+                        }
+                        yield* each.next();
+                    }
+                });
+                return {
+                    *next() {
+                        if (!open && buffer.length <= options.openAt) {
+                            yield* options.open();
+                            open = true;
+                        }
+                        const value = yield* buffer.shift();
+                        return {
+                            done: false,
+                            value,
+                        };
+                    },
+                };
+            },
+        };
+    };
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@effectionx/stream-helpers",
+  "version": "0.1.0",
+  "author": "engineering@frontside.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thefrontside/effectionx.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thefrontside/effectionx/issues"
+  },
+  "main": "./script/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    },
+    "./test-helpers": {
+      "import": "./esm/test-helpers.js",
+      "require": "./script/test-helpers.js"
+    }
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "sideEffects": false,
+  "_generatedBy": "dnt@dev"
+}

package/script/batch.d.ts

@@ -0,0 +1,21 @@
+import { type Stream } from "effection";
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+export interface BatchOptions {
+    readonly maxTime: number;
+    readonly maxSize: number;
+}
+/**
+ * Creates batches of items from the source stream. The batches can be created either by
+ * specifying a maximum time or a maximum size. If both are specified, the batch will be
+ * created when either condition is met.
+ *
+ * @param options - The options for the batch.
+ * @param options.maxTime - The maximum time to wait for a batch.
+ * @param options.maxSize - The maximum size of a batch.
+ * @returns A stream of arrays of items from the source stream.
+ */
+export declare function batch(options: RequireAtLeastOne<BatchOptions>): <T>(stream: Stream<T, never>) => Stream<T[], never>;
+export {};
+//# sourceMappingURL=batch.d.ts.map

package/script/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../src/batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAGlE,KAAK,iBAAiB,CAAC,CAAC,EAAE,IAAI,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IACpD,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,GAC/B;KACC,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,IAAI,CAAC,CAAC;AAEV,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,iBAAiB,CAAC,YAAY,CAAC,GACvC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,CAAC,CA4CrD"}

package/script/batch.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batch = batch;
+const effection_1 = require("effection");
+const signals_js_1 = require("./signals.js");
+/**
+ * Creates batches of items from the source stream. The batches can be created either by
+ * specifying a maximum time or a maximum size. If both are specified, the batch will be
+ * created when either condition is met.
+ *
+ * @param options - The options for the batch.
+ * @param options.maxTime - The maximum time to wait for a batch.
+ * @param options.maxSize - The maximum size of a batch.
+ * @returns A stream of arrays of items from the source stream.
+ */
+function batch(options) {
+    return function (stream) {
+        return {
+            *[Symbol.iterator]() {
+                let batch = yield* (0, signals_js_1.createArraySignal)([]);
+                yield* (0, effection_1.spawn)(function* () {
+                    for (let item of yield* (0, effection_1.each)(stream)) {
+                        batch.push(item);
+                        if (options.maxSize && batch.length >= options.maxSize) {
+                            // wait until it's drained
+                            yield* (0, signals_js_1.is)(batch, (batch) => batch.length === 0);
+                        }
+                        yield* effection_1.each.next();
+                    }
+                });
+                function drain() {
+                    let value = batch.valueOf();
+                    batch.set([]);
+                    return value;
+                }
+                return {
+                    *next() {
+                        yield* (0, signals_js_1.is)(batch, (batch) => batch.length >= 1);
+                        if (options.maxTime && options.maxSize) {
+                            yield* (0, effection_1.race)([
+                                (0, signals_js_1.is)(batch, (batch) => batch.length === options.maxSize),
+                                (0, effection_1.sleep)(options.maxTime),
+                            ]);
+                        }
+                        else if (options.maxTime) {
+                            yield* (0, effection_1.sleep)(options.maxTime);
+                        }
+                        else if (options.maxSize) {
+                            yield* (0, signals_js_1.is)(batch, (batch) => batch.length === options.maxSize);
+                        }
+                        return { done: false, value: drain() };
+                    },
+                };
+            },
+        };
+    };
+}

package/script/filter.d.ts

@@ -0,0 +1,23 @@
+import type { Operation, Stream } from "effection";
+/**
+ * Filters items from the stream based on a predicate function.
+ *
+ * @param predicate - The function to test each item
+ * @returns A stream transformer that only emits items that pass the predicate
+ *
+ * @example
+ * ```typescript
+ * import { filter } from "@effectionx/stream-helpers";
+ * import { run, each } from "effection";
+ *
+ * await run(function* () {
+ *   const stream = filter((x: number) => x > 5)(sourceStream);
+ *
+ *   for (const value of yield* each(stream)) {
+ *     console.log(value); // Only values > 5
+ *   }
+ * });
+ * ```
+ */
+export declare function filter<T>(predicate: (value: T) => Operation<boolean>): <TDone>(stream: Stream<T, TDone>) => Stream<T, TDone>;
+//# sourceMappingURL=filter.d.ts.map

package/script/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../src/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,SAAS,CAAC,OAAO,CAAC,GAC1C,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAyBvD"}

package/script/filter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filter = filter;
+/**
+ * Filters items from the stream based on a predicate function.
+ *
+ * @param predicate - The function to test each item
+ * @returns A stream transformer that only emits items that pass the predicate
+ *
+ * @example
+ * ```typescript
+ * import { filter } from "@effectionx/stream-helpers";
+ * import { run, each } from "effection";
+ *
+ * await run(function* () {
+ *   const stream = filter((x: number) => x > 5)(sourceStream);
+ *
+ *   for (const value of yield* each(stream)) {
+ *     console.log(value); // Only values > 5
+ *   }
+ * });
+ * ```
+ */
+function filter(predicate) {
+    return function (stream) {
+        return {
+            *[Symbol.iterator]() {
+                const subscription = yield* stream;
+                return {
+                    *next() {
+                        while (true) {
+                            const next = yield* subscription.next();
+                            if (next.done) {
+                                return next;
+                            }
+                            if (yield* predicate(next.value)) {
+                                return {
+                                    done: false,
+                                    value: next.value,
+                                };
+                            }
+                        }
+                    },
+                };
+            },
+        };
+    };
+}

package/script/map.d.ts

@@ -0,0 +1,9 @@
+import type { Operation, Stream } from "effection";
+/**
+ * Transforms each item in the stream using the provided function.
+ *
+ * @param fn - The function to transform each item
+ * @returns A stream transformer that applies the function to each item
+ */
+export declare function map<A, B>(fn: (value: A) => Operation<B>): <TClose>(stream: Stream<A, TClose>) => Stream<B, TClose>;
+//# sourceMappingURL=map.d.ts.map

package/script/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../src/map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EACtB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,GAC7B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAsB1D"}

package/script/map.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = map;
+/**
+ * Transforms each item in the stream using the provided function.
+ *
+ * @param fn - The function to transform each item
+ * @returns A stream transformer that applies the function to each item
+ */
+function map(fn) {
+    return function (stream) {
+        return {
+            *[Symbol.iterator]() {
+                const subscription = yield* stream;
+                return {
+                    *next() {
+                        const next = yield* subscription.next();
+                        if (next.done) {
+                            return next;
+                        }
+                        return {
+                            done: false,
+                            value: yield* fn(next.value),
+                        };
+                    },
+                };
+            },
+        };
+    };
+}

package/script/mod.d.ts

@@ -0,0 +1,6 @@
+export * from "./batch.js";
+export * from "./valve.js";
+export * from "./map.js";
+export * from "./filter.js";
+export * from "./tracker.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/script/mod.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./batch.js"), exports);
+__exportStar(require("./valve.js"), exports);
+__exportStar(require("./map.js"), exports);
+__exportStar(require("./filter.js"), exports);
+__exportStar(require("./tracker.js"), exports);

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/signals.d.ts

@@ -0,0 +1,23 @@
+import { type Operation, type Stream } from "effection";
+interface ValueStream<T> extends Stream<T, void> {
+    valueOf(): T;
+}
+interface Settable<T> {
+    set(value: T): T;
+}
+export interface SettableValue<T> extends Settable<T>, ValueStream<T> {
+}
+interface ArraySignal<T> extends SettableValue<T[]> {
+    push(item: T): number;
+    shift(): Operation<T>;
+    valueOf(): T[];
+    get length(): number;
+}
+export declare function createArraySignal<T>(initial: Iterable<T>): Operation<ArraySignal<T>>;
+export declare function is<T>(array: ValueStream<T>, predicate: (item: T) => boolean): Generator<any, void, any>;
+export interface BooleanSignal extends SettableValue<boolean> {
+}
+export declare function createBoolean(initial?: boolean): any;
+export declare function createSetSignal<T>(initial?: Array<T>): any;
+export {};
+//# sourceMappingURL=signals.d.ts.map

package/script/signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../src/signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EAEd,KAAK,MAAM,EACZ,MAAM,WAAW,CAAC;AAGnB,UAAU,WAAW,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;IAC9C,OAAO,IAAI,CAAC,CAAC;CACd;AAED,UAAU,QAAQ,CAAC,CAAC;IAClB,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC;CAClB;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;CAAG;AAExE,UAAU,WAAW,CAAC,CAAC,CAAE,SAAQ,aAAa,CAAC,CAAC,EAAE,CAAC;IACjD,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAC;IACtB,KAAK,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC;IACtB,OAAO,IAAI,CAAC,EAAE,CAAC;IACf,IAAI,MAAM,IAAI,MAAM,CAAC;CACtB;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,GACnB,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAwC3B;AAED,wBAAiB,EAAE,CAAC,CAAC,EACnB,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,6BAahC;AAED,MAAM,WAAW,aAAc,SAAQ,aAAa,CAAC,OAAO,CAAC;CAC5D;AAED,wBAAgB,aAAa,CAAC,OAAO,GAAE,OAAe,OA0BrD;AASD,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,GAAE,KAAK,CAAC,CAAC,CAAM,OAwCxD"}