@soffinal/stream 0.1.4 → 0.2.1

package/dist/{state.d.ts → reactive/state.d.ts}

@@ -1,9 +1,11 @@
-import { Stream } from "./stream.ts";
+import { FunctionGenerator, Stream } from "../stream.ts";
 /**
  * A reactive state container that extends Stream to provide stateful value management.
  *
  * @template VALUE - The type of the state value
  *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
  * @example
  * ```typescript
  * // Basic state
@@ -11,35 +13,29 @@ import { Stream } from "./stream.ts";
  * counter.listen(value => console.log('Counter:', value));
  * counter.value = 5; // Counter: 5
  *
- * // Complex state
- * interface User { id: string; name: string; }
- * const user = new State<User | null>(null);
+ * // State from stream
+ * const source = new Stream<number>();
+ * const state = new State(0, source);
+ * state.listen(value => console.log('State:', value));
+ * source.push(1, 2, 3); // State: 1, State: 2, State: 3
  *
- * user.listen(u => console.log('User:', u?.name || 'None'));
- * user.value = { id: '1', name: 'Alice' }; // User: Alice
+ * // State from transformed stream
+ * const filtered = source.pipe(filter({}, (_, v) => [v > 0, {}]));
+ * const derivedState = new State(-1, filtered);
  * ```
  */
 export declare class State<VALUE> extends Stream<VALUE> {
     protected _value: VALUE;
-    /**
-     * Creates a new State with an initial value.
-     *
-     * @param initialValue - The initial state value
-     *
-     * @example
-     * ```typescript
-     * const count = new State(0);
-     * const theme = new State<'light' | 'dark'>('light');
-     * const user = new State<User | null>(null);
-     * ```
-     */
     constructor(initialValue: VALUE);
+    constructor(initialValue: VALUE, stream: FunctionGenerator<VALUE> | Stream<VALUE>);
     /**
      * Updates the state with one or more values sequentially.
      * Each value triggers listeners and updates the current state.
      *
      * @param values - Values to set as state
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const state = new State(0);
@@ -53,6 +49,8 @@ export declare class State<VALUE> extends Stream<VALUE> {
     /**
      * Gets the current state value.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const state = new State('hello');
@@ -65,6 +63,8 @@ export declare class State<VALUE> extends Stream<VALUE> {
      *
      * @param value - The new state value
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const state = new State(0);

package/dist/reactive/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/reactive/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,MAAM,CAAC,KAAK,CAAC;IAC7C,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC;gBACZ,YAAY,EAAE,KAAK;gBACnB,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAmBjF;;;;;;;;;;;;;;;;OAgBG;IACM,IAAI,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAKvC;;;;;;;;;;OAUG;IACH,IAAI,KAAK,IAAI,KAAK,CAEjB;IACD;;;;;;;;;;;;;;;OAeG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,KAAK,EAGrB;CACF"}

package/dist/stream.d.ts

@@ -1,8 +1,5 @@
 export type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never;
-export type FlatArray<Arr, Depth extends number> = {
-    "done": Arr;
-    "recur": Arr extends ReadonlyArray<infer InnerArr> ? FlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]> : Arr;
-}[Depth extends -1 ? "done" : "recur"];
+export type FunctionGenerator<VALUE> = () => AsyncGenerator<VALUE, void>;
 /**
  * A reactive streaming library that provides async-first data structures with built-in event streams.
  *
@@ -30,10 +27,74 @@ export type FlatArray<Arr, Depth extends number> = {
  *   if (value === 10) break;
  * }
  * ```
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMERS LIBRARY - Essential transformers for immediate use
+ *
+ * // FILTERING TRANSFORMERS
+ * const simpleFilter = <T>(predicate: (value: T) => boolean | Promise<boolean>) =>
+ *   filter<T, {}>({}, async (_, value) => {
+ *     const shouldPass = await predicate(value);
+ *     return [shouldPass, {}];
+ *   });
+ *
+ * const take = <T>(n: number) =>
+ *   filter<T, { count: number }>({ count: 0 }, (state, value) => {
+ *     if (state.count >= n) return;
+ *     return [true, { count: state.count + 1 }];
+ *   });
+ *
+ * const distinct = <T>() =>
+ *   filter<T, { seen: Set<T> }>({ seen: new Set() }, (state, value) => {
+ *     if (state.seen.has(value)) return [false, state];
+ *     state.seen.add(value);
+ *     return [true, state];
+ *   });
+ *
+ * const tap = <T>(fn: (value: T) => void | Promise<void>) =>
+ *   filter<T, {}>({}, async (_, value) => {
+ *     await fn(value);
+ *     return [true, {}];
+ *   });
+ *
+ * // MAPPING TRANSFORMERS
+ * const simpleMap = <T, U>(fn: (value: T) => U | Promise<U>) =>
+ *   map<T, {}, U>({}, async (_, value) => {
+ *     const result = await fn(value);
+ *     return [result, {}];
+ *   });
+ *
+ * const withIndex = <T>() =>
+ *   map<T, { index: number }, { value: T; index: number }>(
+ *     { index: 0 },
+ *     (state, value) => [
+ *       { value, index: state.index },
+ *       { index: state.index + 1 }
+ *     ]
+ *   );
+ *
+ * const delay = <T>(ms: number) =>
+ *   map<T, {}, T>({}, async (_, value) => {
+ *     await new Promise(resolve => setTimeout(resolve, ms));
+ *     return [value, {}];
+ *   });
+ *
+ * const scan = <T, U>(fn: (acc: U, value: T) => U, initial: U) =>
+ *   map<T, { acc: U }, U>({ acc: initial }, (state, value) => {
+ *     const newAcc = fn(state.acc, value);
+ *     return [newAcc, { acc: newAcc }];
+ *   });
+ *
+ * // STATE CONVERTER
+ * const toState = <T>(initialValue: T) => (stream: Stream<T>) => {
+ *   return new State(initialValue, stream);
+ * };
+ *
+ * // Usage: stream.pipe(simpleFilter(x => x > 0)).pipe(take(5)).pipe(toState(0));
  */
 export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
     protected _listeners: Set<(value: VALUE) => void>;
-    protected _generatorFn: (() => AsyncGenerator<VALUE, void>) | undefined;
+    protected _generatorFn: FunctionGenerator<VALUE> | undefined;
     protected _generator: AsyncGenerator<VALUE, void> | undefined;
     protected _listenerAdded: Stream<void> | undefined;
     protected _listenerRemoved: Stream<void> | undefined;
@@ -42,6 +103,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      *
      * @param generatorFn - Optional async generator function to produce values you can use it for creating stream with custom transformation
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * // Empty stream
@@ -70,10 +133,12 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * ```
      */
     constructor();
-    constructor(generatorFn: () => AsyncGenerator<VALUE, void>);
+    constructor(stream: FunctionGenerator<VALUE> | Stream<VALUE>);
     /**
      * Returns true if the stream has active listeners.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<number>();
@@ -90,6 +155,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
     /**
      * Stream that emits when a listener is added.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<number>();
@@ -102,6 +169,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
     /**
      * Stream that emits when a listener is removed.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<number>();
@@ -116,6 +185,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
     /**
      * Pushes one or more values to all listeners.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @param value - The first value to push
      * @param values - Additional values to push
      *
@@ -136,6 +207,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * @param signal - Optional AbortSignal for cleanup
      * @returns Cleanup function to remove the listener
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<string>();
@@ -152,13 +225,15 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * cleanup();
      * ```
      */
-    listen(listener: (value: VALUE) => void, signal?: AbortSignal): () => void;
+    listen(listener: (value: VALUE) => void, signal?: AbortSignal | Stream<any>): () => void;
     /**
      * Promise-like interface that resolves with the next value.
      *
      * @param onfulfilled - Optional transformation function
      * @returns Promise that resolves with the first value
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<number>();
@@ -173,126 +248,23 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * ```
      */
     then(onfulfilled?: ((value: VALUE) => VALUE | PromiseLike<VALUE>) | null): Promise<VALUE>;
-    /**
-     * Filters values based on a predicate function.
-     *
-     * @param predicate - Function to test each value
-     * @returns New stream with filtered values
-     *
-     * @example
-     * ```typescript
-     * const numbers = new Stream<number>();
-     * const evens = numbers.filter(n => n % 2 === 0);
-     *
-     * evens.listen(n => console.log('Even:', n));
-     * numbers.push(1, 2, 3, 4); // Even: 2, Even: 4
-     *
-     * // With accumulator
-     * const increasing = numbers.filter(0, (prev, curr) =>
-     *   [curr > prev, Math.max(prev, curr)]
-     * );
-     * ```
-     */
-    filter<FILTERED extends VALUE>(predicate: (value: VALUE) => value is FILTERED): Stream<FILTERED>;
-    filter<FILTERED extends VALUE>(predicate: (value: VALUE) => boolean | Promise<boolean>): Stream<FILTERED>;
-    filter<FILTERED extends VALUE, ACC>(initialValue: ACC, predicate: (accumulator: ACC, value: VALUE) => [boolean, ACC] | Promise<[boolean, ACC]>): Stream<FILTERED>;
-    /**
-     * Transforms values using a mapper function.
-     *
-     * @param mapper - Function to transform each value
-     * @returns New stream with transformed values
-     *
-     * @example
-     * ```typescript
-     * const numbers = new Stream<number>();
-     * const doubled = numbers.map(n => n * 2);
-     *
-     * doubled.listen(n => console.log('Doubled:', n));
-     * numbers.push(1, 2, 3); // Doubled: 2, Doubled: 4, Doubled: 6
-     *
-     * // With accumulator (running sum)
-     * const sums = numbers.map(0, (sum, n) => [sum + n, sum + n]);
-     * ```
-     */
-    map<MAPPED>(mapper: (value: VALUE) => MAPPED | Promise<MAPPED>): Stream<MAPPED>;
-    map<MAPPED, ACC>(initialValue: ACC, mapper: (accumulator: ACC, value: VALUE) => [MAPPED, ACC] | Promise<[MAPPED, ACC]>): Stream<MAPPED>;
-    /**
-     * Groups values into batches based on a predicate.
-     *
-     * @param predicate - Function to determine when to emit a group
-     * @returns New stream with grouped values
-     *
-     * @example
-     * ```typescript
-     * const numbers = new Stream<number>();
-     * const batches = numbers.group(batch => batch.length === 3);
-     *
-     * batches.listen(batch => console.log('Batch:', batch));
-     * numbers.push(1, 2, 3, 4, 5, 6); // Batch: [1,2,3], Batch: [4,5,6]
-     *
-     * // With accumulator (sum-based grouping)
-     * const sumGroups = numbers.group(0, (sum, n) =>
-     *   sum + n >= 10 ? [true, 0] : [false, sum + n]
-     * );
-     * ```
-     */
-    group(predicate: (accumulator: VALUE[], value: VALUE) => boolean | Promise<boolean>): Stream<VALUE[]>;
-    group<ACC>(initialValue: ACC, predicate: (accumulator: ACC, value: VALUE) => [boolean, ACC] | Promise<[boolean, ACC]>): Stream<ACC>;
-    /**
-     * Merges this stream with other streams.
-     *
-     * @param streams - Other streams to merge with
-     * @returns New stream with values from all streams
-     *
-     * @example
-     * ```typescript
-     * const stream1 = new Stream<string>();
-     * const stream2 = new Stream<number>();
-     * const merged = stream1.merge(stream2);
-     *
-     * merged.listen(msg => console.log('Merged:', msg));
-     *
-     * stream1.push('from stream1');
-     * stream2.push(42);
-     * // Output: Merged: from stream1,  Merged: 42
-     * ```
-     */
-    merge<STREAMS extends [Stream<any>, ...Stream<any>[]]>(...streams: STREAMS): Stream<VALUE | ValueOf<STREAMS[number]>>;
-    /**
-     * Flattens array values in the stream.
-     *
-     * @param depth - Depth to flatten (default: 0)
-     * @returns New stream with flattened values
-     *
-     * @example
-     * ```typescript
-     * const arrays = new Stream<number[]>();
-     * const flattened = arrays.flat();
-     *
-     * flattened.listen(n => console.log('Flat:', n));
-     * arrays.push([1, 2], [3, 4]); // Flat: 1, Flat: 2, Flat: 3, Flat: 4
-     *
-     * // Deep flattening
-     * const nested = new Stream<number[][][]>();
-     * const deepFlat = nested.flat(2);
-     * ```
-     */
-    flat<DEPTH extends number = 0>(depth?: DEPTH): Stream<FlatArray<VALUE, DEPTH>>;
     /**
      * Applies a transformer function to this stream, enabling functional composition.
      *
-     * @param transformer - Function that takes a stream and returns a transformed stream
-     * @returns New stream with the transformation applied
+     * @param transformer - Function that takes a stream and returns any output type
+     * @returns The result of the transformer function
+     *
+     * @see {@link Stream} - Complete copy-paste transformers library
      *
      * @example
      * ```typescript
      * const numbers = new Stream<number>();
      *
-     * // Using built-in transformers
+     * // Chain transformers
      * const result = numbers
-     *   .pipe(filter(n => n > 0))
-     *   .pipe(map(n => n * 2))
-     *   .pipe(group(batch => batch.length >= 3));
+     *   .pipe(filter({}, (_, n) => [n > 0, {}]))
+     *   .pipe(map({}, (_, n) => [n * 2, {}]))
+     *   .pipe(toState(0));
      *
      * // Custom transformer
      * const throttle = <T>(ms: number) => (stream: Stream<T>) =>
@@ -307,178 +279,11 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      *     }
      *   });
      *
-     * numbers.pipe(throttle(1000));
+     * // Transform to any type
+     * const stringResult = numbers.pipe(throttle(1000));
+     * const stateResult = numbers.pipe(toState(0));
      * ```
      */
-    pipe<OUTPUT>(transformer: (stream: Stream<VALUE>) => Stream<OUTPUT>): Stream<OUTPUT>;
-}
-/**
- * Transformer function interface for mapping stream values.
- * Supports both simple mapping and stateful mapping with accumulators.
- */
-export interface MapFunction {
-    <VALUE, MAPPED>(mapper: (value: VALUE) => MAPPED | Promise<MAPPED>): (stream: Stream<VALUE>) => Stream<MAPPED>;
-    <VALUE, MAPPED, ACC>(initialValue: ACC, mapper: (accumulator: ACC, value: VALUE) => [MAPPED, ACC] | Promise<[MAPPED, ACC]>): (stream: Stream<VALUE>) => Stream<MAPPED>;
-}
-/**
- * Creates a map transformer for use with pipe().
- *
- * @param mapper - Function to transform each value, or initial accumulator value
- * @param mapper - Optional mapper function when using accumulator
- * @returns Transformer function for pipe()
- *
- * @example
- * ```typescript
- * const numbers = new Stream<number>();
- *
- * // Simple mapping
- * const doubled = numbers.pipe(map(n => n * 2));
- *
- * // Stateful mapping (running sum)
- * const sums = numbers.pipe(map(0, (sum, n) => [sum + n, sum + n]));
- *
- * // Async mapping
- * const enriched = numbers.pipe(map(async n => {
- *   const data = await fetchData(n);
- *   return { value: n, data };
- * }));
- * ```
- */
-export declare const map: MapFunction;
-/**
- * Transformer function interface for filtering stream values.
- * Supports type guards, boolean predicates, and stateful filtering.
- */
-export interface FilterFunction {
-    <VALUE, FILTERED extends VALUE>(predicate: (value: VALUE) => value is FILTERED): (stream: Stream<VALUE>) => Stream<FILTERED>;
-    <VALUE>(predicate: (value: VALUE) => boolean | Promise<boolean>): (stream: Stream<VALUE>) => Stream<VALUE>;
-    <VALUE, ACC>(initialValue: ACC, predicate: (accumulator: ACC, value: VALUE) => [boolean, ACC] | Promise<[boolean, ACC]>): (stream: Stream<VALUE>) => Stream<VALUE>;
+    pipe<OUTPUT extends Stream<any>>(transformer: (stream: this) => OUTPUT): OUTPUT;
 }
-/**
- * Creates a filter transformer for use with pipe().
- *
- * @param predicate - Function to test each value, or initial accumulator value
- * @param predicate - Optional predicate function when using accumulator
- * @returns Transformer function for pipe()
- *
- * @example
- * ```typescript
- * const numbers = new Stream<number>();
- *
- * // Simple filtering
- * const positives = numbers.pipe(filter(n => n > 0));
- *
- * // Type guard filtering
- * const strings = mixed.pipe(filter((x): x is string => typeof x === 'string'));
- *
- * // Stateful filtering (only increasing values)
- * const increasing = numbers.pipe(filter(0, (prev, curr) =>
- *   [curr > prev, Math.max(prev, curr)]
- * ));
- * ```
- */
-export declare const filter: FilterFunction;
-/**
- * Transformer function interface for grouping stream values into batches.
- * Supports both simple batching and stateful grouping with accumulators.
- */
-export interface GroupFunction {
-    <VALUE>(predicate: (accumulator: VALUE[], value: VALUE) => boolean | Promise<boolean>): (stream: Stream<VALUE>) => Stream<VALUE[]>;
-    <VALUE, ACC>(initialValue: ACC, predicate: (accumulator: ACC, value: VALUE) => [boolean, ACC] | Promise<[boolean, ACC]>): (stream: Stream<VALUE>) => Stream<ACC>;
-}
-/**
- * Creates a group transformer for use with pipe().
- *
- * @param predicate - Function to determine when to emit a group, or initial accumulator value
- * @param predicate - Optional predicate function when using accumulator
- * @returns Transformer function for pipe()
- *
- * @example
- * ```typescript
- * const numbers = new Stream<number>();
- *
- * // Group by count
- * const batches = numbers.pipe(group(batch => batch.length >= 5));
- *
- * // Group by sum
- * const sumGroups = numbers.pipe(group(0, (sum, n) =>
- *   sum + n >= 100 ? [true, 0] : [false, sum + n]
- * ));
- *
- * // Time-based grouping
- * const timeGroups = events.pipe(group([], (window, event) => {
- *   const now = Date.now();
- *   const recent = window.filter(e => now - e.timestamp < 5000);
- *   return [recent.length >= 10, [...recent, event]];
- * }));
- * ```
- */
-export declare const group: GroupFunction;
-/**
- * Transformer function interface for merging multiple streams.
- * Combines values from all streams into a single output stream.
- */
-export interface MergeFunction {
-    <STREAMS extends [Stream<any>, ...Stream<any>[]]>(...streams: STREAMS): <VALUE>(stream: Stream<VALUE>) => Stream<VALUE | ValueOf<STREAMS[number]>>;
-}
-/**
- * Creates a merge transformer for use with pipe().
- *
- * @param streams - Additional streams to merge with the source stream
- * @returns Transformer function for pipe()
- *
- * @example
- * ```typescript
- * const stream1 = new Stream<string>();
- * const stream2 = new Stream<number>();
- * const stream3 = new Stream<boolean>();
- *
- * // Merge multiple streams
- * const merged = stream1.pipe(merge(stream2, stream3));
- * // Type: Stream<string | number | boolean>
- *
- * merged.listen(value => {
- *   console.log('Received:', value); // Could be string, number, or boolean
- * });
- *
- * stream1.push('hello');
- * stream2.push(42);
- * stream3.push(true);
- * ```
- */
-export declare const merge: MergeFunction;
-/**
- * Transformer function interface for flattening array values in streams.
- * Supports configurable depth for nested array flattening.
- */
-export interface FlatFunction {
-    (): <VALUE>(stream: Stream<VALUE>) => Stream<FlatArray<VALUE, 0>>;
-    <DEPTH extends number>(depth: DEPTH): <VALUE>(stream: Stream<VALUE>) => Stream<FlatArray<VALUE, DEPTH>>;
-}
-/**
- * Creates a flat transformer for use with pipe().
- *
- * @param depth - Optional depth to flatten (default: 0 for single level)
- * @returns Transformer function for pipe()
- *
- * @example
- * ```typescript
- * const arrays = new Stream<number[]>();
- *
- * // Flatten single level
- * const flattened = arrays.pipe(flat());
- * arrays.push([1, 2], [3, 4]); // Emits: 1, 2, 3, 4
- *
- * // Flatten multiple levels
- * const nested = new Stream<number[][][]>();
- * const deepFlat = nested.pipe(flat(2));
- * nested.push([[[1, 2]], [[3, 4]]]); // Emits: 1, 2, 3, 4
- *
- * // Mixed content (non-arrays pass through)
- * const mixed = new Stream<number | number[]>();
- * const result = mixed.pipe(flat());
- * mixed.push(1, [2, 3], 4); // Emits: 1, 2, 3, 4
- * ```
- */
-export declare const flat: FlatFunction;
 //# sourceMappingURL=stream.d.ts.map

package/dist/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AACjF,MAAM,MAAM,iBAAiB,CAAC,KAAK,IAAI,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,qBAAa,MAAM,CAAC,KAAK,GAAG,OAAO,CAAE,YAAW,aAAa,CAAC,KAAK,CAAC;IAClE,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,CAAqC;IACtF,SAAS,CAAC,YAAY,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAC7D,SAAS,CAAC,UAAU,EAAE,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC;IAC9D,SAAS,CAAC,cAAc,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IACnD,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;;gBAES,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAK5D;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,aAAa,IAAI,MAAM,CAAC,IAAI,CAAC,CAGhC;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,eAAe,IAAI,MAAM,CAAC,IAAI,CAAC,CAGlC;IACM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;IAsB5D;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAS5C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,IAAI;IAoCxF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC;IASzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,IAAI,CAAC,MAAM,SAAS,MAAM,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK,MAAM,GAAG,MAAM;CAGhF"}

package/dist/transformers/filter.d.ts

@@ -0,0 +1,35 @@
+import { Stream } from "../stream.ts";
+/**
+ * Adaptive filter transformer that maintains state and can terminate streams.
+ *
+ * @template VALUE - The type of values flowing through the stream
+ * @template STATE - The type of the internal state object
+ *
+ * @param initialState - Initial state object for the transformer
+ * @param predicate - Function that determines if a value should pass through
+ *   - Returns `[boolean, newState]` to continue with updated state
+ *   - Returns `void` or `undefined` to terminate the stream
+ *   - Can be async for complex filtering logic
+ *
+ * @returns A transformer function that can be used with `.pipe()`
+ *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
+ * @example
+ * // Simple filtering
+ * stream.pipe(filter({}, (_, value) => [value > 0, {}]))
+ *
+ * @example
+ * // Async filtering
+ * stream.pipe(
+ *   filter({}, async (_, value) => {
+ *     const valid = await validate(value);
+ *     return [valid, {}];
+ *   })
+ * )
+ *
+
+ *
+ */
+export declare function filter<VALUE, STATE extends Record<string, unknown> = {}>(initialState: STATE, predicate: (state: STATE, value: VALUE) => [boolean, STATE] | void | Promise<[boolean, STATE] | void>): (stream: Stream<VALUE>) => Stream<VALUE>;
+//# sourceMappingURL=filter.d.ts.map

package/dist/transformers/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/transformers/filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EACtE,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,GACpG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,KAAK,CAAC,CAe1C"}

package/dist/transformers/flat.d.ts

@@ -0,0 +1,31 @@
+import { Stream } from "../stream.ts";
+/**
+ * Flatten arrays in a stream, converting 1 array event into N individual events.
+ *
+ * @template VALUE - The type of values in the stream (should be arrays)
+ * @template DEPTH - The depth of flattening (0 = one level, 1 = two levels, etc.)
+ *
+ * @param depth - How many levels deep to flatten (default: 0 = one level)
+ *
+ * @returns A transformer that flattens array values into individual events
+ *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
+ * @example
+ * // Basic flattening - 1 array → N events
+ * const arrayStream = new Stream<number[]>();
+ * const individualNumbers = arrayStream.pipe(flat());
+ *
+ * arrayStream.push([1, 2, 3]); // Emits: 1, 2, 3 as separate events
+ *
+ * @example
+ * // Deep flattening
+ * const deepArrays = new Stream<number[][]>();
+ * const flattened = deepArrays.pipe(flat(1)); // Flatten 2 levels
+ *
+ * deepArrays.push([[1, 2], [3, 4]]);
+ * // Emits: 1, 2, 3, 4 as separate events
+ *
+ */
+export declare function flat<VALUE, DEPTH extends number = 0>(depth?: DEPTH): (stream: Stream<VALUE>) => Stream<FlatArray<VALUE, DEPTH>>;
+//# sourceMappingURL=flat.d.ts.map

package/dist/transformers/flat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat.d.ts","sourceRoot":"","sources":["../../src/transformers/flat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,GAAG,CAAC,EAClD,KAAK,GAAE,KAAkB,GACxB,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAe5D"}

package/dist/transformers/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./filter.ts";
+export * from "./map.ts";
+export * from "./merge.ts";
+export * from "./flat.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/transformers/index.d.ts.map

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