@soffinal/stream 0.1.4 → 0.2.0

package/dist/stream.d.ts

@@ -1,8 +1,4 @@
 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"];
 /**
  * A reactive streaming library that provides async-first data structures with built-in event streams.
  *
@@ -152,7 +148,7 @@ 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.
      *
@@ -173,111 +169,6 @@ 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.
      *
@@ -312,173 +203,4 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      */
     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>;
-}
-/**
- * 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;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;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,CAAC,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;IACxE,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;;gBAES,WAAW,EAAE,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;IAK1D;;;;;;;;;;;;;;OAcG;IACH,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED;;;;;;;;;;OAUG;IACH,IAAI,aAAa,IAAI,MAAM,CAAC,IAAI,CAAC,CAGhC;IAED;;;;;;;;;;;OAWG;IACH,IAAI,eAAe,IAAI,MAAM,CAAC,IAAI,CAAC,CAGlC;IACM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;IAsB5D;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAS5C;;;;;;;;;;;;;;;;;;;;;;OAsBG;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;;;;;;;;;;;;;;;;;;OAkBG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;CAGrF"}

package/dist/transformers/filter.d.ts

@@ -0,0 +1,64 @@
+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()`
+ *
+ * @example
+ * // Simple filtering
+ * stream.pipe(filter({}, (_, value) => [value > 0, {}]))
+ *
+ * @example
+ * // Async filtering
+ * stream.pipe(
+ *   filter({}, async (_, value) => {
+ *     const valid = await validate(value);
+ *     return [valid, {}];
+ *   })
+ * )
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMER: simpleFilter() - Simple predicate filtering
+ * const simpleFilter = <T>(predicate: (value: T) => boolean | Promise<boolean>) =>
+ *   filter<T, {}>({}, async (_, value) => {
+ *     const shouldPass = await predicate(value);
+ *     return [shouldPass, {}];
+ *   });
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMER: take(n) - Limit to N items
+ * const take = <T>(n: number) =>
+ *   filter<T, { count: number }>({ count: 0 }, (state, value) => {
+ *     if (state.count >= n) return;
+ *     return [true, { count: state.count + 1 }];
+ *   });
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMER: skip(n) - Skip first N items
+ * const skip = <T>(n: number) =>
+ *   filter<T, { count: number }>({ count: 0 }, (state, value) => {
+ *     const newCount = state.count + 1;
+ *     return [newCount > n, { count: newCount }];
+ *   });
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMER: distinct() - Remove duplicates
+ * 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];
+ *   });
+ *
+ */
+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;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,29 @@
+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
+ *
+ * @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;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;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"}

package/dist/transformers/map.d.ts

@@ -0,0 +1,64 @@
+import { Stream } from "../stream.ts";
+/**
+ * Adaptive map transformer that transforms values while maintaining state.
+ *
+ * @template VALUE - The type of input values
+ * @template STATE - The type of the internal state object
+ * @template MAPPED - The type of output values after transformation
+ *
+ * @param initialState - Initial state object for the transformer
+ * @param predicate - Function that transforms values and updates state
+ *   - Must return `[transformedValue, newState]`
+ *   - Can be async for complex transformations
+ *   - Preserves order even with async operations
+ *
+ * @returns A transformer function that can be used with `.pipe()`
+ *
+ * @example
+ * // Simple transformation
+ * stream.pipe(map({}, (_, value) => [value * 2, {}]))
+ *
+ * @example
+ * // Async transformation
+ * stream.pipe(
+ *   map({}, async (_, value) => {
+ *     const result = await process(value);
+ *     return [result, {}];
+ *   })
+ * )
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMER: simpleMap() - Simple transformation
+ * const simpleMap = <T, U>(fn: (value: T) => U | Promise<U>) =>
+ *   map<T, {}, U>({}, async (_, value) => {
+ *     const result = await fn(value);
+ *     return [result, {}];
+ *   });
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMER: withIndex() - Add index to values
+ * const withIndex = <T>() =>
+ *   map<T, { index: number }, { value: T; index: number }>(
+ *     { index: 0 },
+ *     (state, value) => [
+ *       { value, index: state.index },
+ *       { index: state.index + 1 }
+ *     ]
+ *   );
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMER: delay(ms) - Delay each value
+ * const delay = <T>(ms: number) =>
+ *   map<T, {}, T>({}, async (_, value) => {
+ *     await new Promise(resolve => setTimeout(resolve, ms));
+ *     return [value, {}];
+ *   });
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMER: pluck(key) - Extract property
+ * const pluck = <T, K extends keyof T>(key: K) =>
+ *   map<T, {}, T[K]>({}, (_, value) => [value[key], {}]);
+ *
+ */
+export declare function map<VALUE, STATE extends Record<string, unknown>, MAPPED>(initialState: STATE, predicate: (state: STATE, value: VALUE) => [MAPPED, STATE] | Promise<[MAPPED, STATE]>): (stream: Stream<VALUE>) => Stream<MAPPED>;
+//# sourceMappingURL=map.d.ts.map

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

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

package/dist/transformers/merge.d.ts

@@ -0,0 +1,33 @@
+import { Stream } from "../stream.ts";
+type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never;
+/**
+ * Merge multiple streams into a single stream with temporal ordering.
+ *
+ * @template VALUE - The type of values from the source stream
+ * @template STREAMS - Tuple type of additional streams to merge
+ *
+ * @param streams - Additional streams to merge with the source stream
+ *
+ * @returns A transformer that merges all streams into one with union types
+ *
+ * @example
+ * // Basic merge with type safety
+ * const numbers = new Stream<number>();
+ * const strings = new Stream<string>();
+ * const merged = numbers.pipe(merge(strings));
+ * // Type: Stream<number | string>
+ *
+ * @example
+ * // Multiple streams
+ * const stream1 = new Stream<number>();
+ * const stream2 = new Stream<string>();
+ * const stream3 = new Stream<boolean>();
+ *
+ * const combined = stream1.pipe(merge(stream2, stream3));
+ * // Type: Stream<number | string | boolean>
+ *
+
+ */
+export declare function merge<VALUE, STREAMS extends [Stream<any>, ...Stream<any>[]]>(...streams: STREAMS): (stream: Stream<VALUE>) => Stream<VALUE | ValueOf<STREAMS[number]>>;
+export {};
+//# sourceMappingURL=merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/transformers/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,KAAK,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAC1E,GAAG,OAAO,EAAE,OAAO,GAClB,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CA0BrE"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@soffinal/stream",
   "module": "./dist/index.js",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "A reactive event streaming library for TypeScript/JavaScript",
   "type": "module",
   "devDependencies": {
@@ -10,12 +10,6 @@
   "peerDependencies": {
     "typescript": "^5.9.2"
   },
-  "scripts": {
-    "clean": "rm -rf dist",
-    "build": "bun run clean && bun build src/index.ts --outdir dist --target node --format esm --sourcemap --minify && bun run build:types",
-    "build:types": "tsc --emitDeclarationOnly --allowImportingTsExtensions --noEmit false",
-    "release": " git add . && git commit -m \"Release v$(node -p 'require(\"./package.json\").version')\" && git tag v$(node -p 'require(\"./package.json\").version')"
-  },
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -29,7 +23,8 @@
     "typescript",
     "event",
     "observable",
-    "emitter"
+    "emitter",
+    "adaptive constraints"
   ],
   "author": "Soffinal <smari.sofiane@gmail.com>",
   "license": "MIT",
@@ -41,7 +36,9 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
+    "src/transformers/*.md",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ]
 }