@soffinal/stream 0.1.0

package/dist/stream.d.ts

@@ -0,0 +1,480 @@
+export type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never;
+/**
+ * A reactive streaming library that provides async-first data structures with built-in event streams.
+ *
+ * @template VALUE - The type of values that flow through the stream
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const stream = new Stream<number>();
+ * stream.listen(value => console.log(value));
+ * stream.push(1, 2, 3);
+ *
+ * // With async generator
+ * const timerStream = new Stream(async function* () {
+ *   let count = 0;
+ *   while (count < 5) {
+ *     yield count++;
+ *     await new Promise(resolve => setTimeout(resolve, 1000));
+ *   }
+ * });
+ *
+ * // Async iteration
+ * for await (const value of stream) {
+ *   console.log(value);
+ *   if (value === 10) break;
+ * }
+ * ```
+ */
+export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
+    protected _listeners: Set<(value: VALUE) => void>;
+    protected _generatorFn: (() => AsyncGenerator<VALUE, void>) | undefined;
+    protected _generator: AsyncGenerator<VALUE, void> | undefined;
+    protected _listenerAdded: Stream<void> | undefined;
+    protected _listenerRemoved: Stream<void> | undefined;
+    /**
+     * Creates a new Stream instance.
+     *
+     * @param generatorFn - Optional async generator function to produce values you can use it for creating stream with custom transformation
+     *
+     * @example
+     * ```typescript
+     * // Empty stream
+     * const stream = new Stream<string>();
+     *
+     * // Stream with generator
+     * const countdown = new Stream(async function* () {
+     *   for (let i = 5; i > 0; i--) {
+     *     yield i;
+     *     await new Promise(resolve => setTimeout(resolve, 1000));
+     *   }
+     * });
+     *
+     * // Stream with custom transformer
+     * function filter<VALUE>(source:Stream<VALUE>,predicate:(value:VALUE) => boolean):Stream<VALUE>{
+     *  return new Stream<VALUE>(async function* () {
+     *   for await (const value of source) {
+     *     if (predicate(value)) yield value ;
+     *   }
+     *  });
+     * }
+     * const source = new Stream<number>();
+     * const even = filter(source,v=> v % 2 === 0)
+     * even.listen(console.log);
+     * source.push(1, 2, 3, 4); // 2,4
+     * ```
+     */
+    constructor();
+    constructor(generatorFn: () => AsyncGenerator<VALUE, void>);
+    /**
+     * Returns true if the stream has active listeners.
+     *
+     * @example
+     * ```typescript
+     * const stream = new Stream<number>();
+     * console.log(stream.hasListeners); // false
+     *
+     * const cleanup = stream.listen(value => console.log(value));
+     * console.log(stream.hasListeners); // true
+     *
+     * cleanup();
+     * console.log(stream.hasListeners); // false
+     * ```
+     */
+    get hasListeners(): boolean;
+    /**
+     * Stream that emits when a listener is added.
+     *
+     * @example
+     * ```typescript
+     * const stream = new Stream<number>();
+     * stream.listenerAdded.listen(() => console.log('Listener added'));
+     *
+     * stream.listen(value => console.log(value)); // Triggers 'Listener added'
+     * ```
+     */
+    get listenerAdded(): Stream<void>;
+    /**
+     * Stream that emits when a listener is removed.
+     *
+     * @example
+     * ```typescript
+     * const stream = new Stream<number>();
+     * stream.listenerRemoved.listen(() => console.log('Listener removed'));
+     *
+     * const cleanup = stream.listen(value => console.log(value));
+     * cleanup(); // Triggers 'Listener removed'
+     * ```
+     */
+    get listenerRemoved(): Stream<void>;
+    [Symbol.asyncIterator](): AsyncGenerator<VALUE, void>;
+    /**
+     * Pushes one or more values to all listeners.
+     *
+     * @param value - The first value to push
+     * @param values - Additional values to push
+     *
+     * @example
+     * ```typescript
+     * const stream = new Stream<number>();
+     * stream.listen(value => console.log('Received:', value));
+     *
+     * stream.push(1); // Received: 1
+     * stream.push(2, 3, 4); // Received: 2, Received: 3, Received: 4
+     * ```
+     */
+    push(value: VALUE, ...values: VALUE[]): void;
+    /**
+     * Adds a listener to the stream.
+     *
+     * @param listener - Function to call when values are pushed
+     * @param signal - Optional AbortSignal for cleanup
+     * @returns Cleanup function to remove the listener
+     *
+     * @example
+     * ```typescript
+     * const stream = new Stream<string>();
+     *
+     * // Basic listener
+     * const cleanup = stream.listen(value => console.log(value));
+     *
+     * // With AbortSignal
+     * const controller = new AbortController();
+     * stream.listen(value => console.log(value), controller.signal);
+     * controller.abort(); // Removes listener
+     *
+     * // Manual cleanup
+     * cleanup();
+     * ```
+     */
+    listen(listener: (value: VALUE) => void, signal?: AbortSignal): () => void;
+    /**
+     * Promise-like interface that resolves with the next value.
+     *
+     * @param onfulfilled - Optional transformation function
+     * @returns Promise that resolves with the first value
+     *
+     * @example
+     * ```typescript
+     * const stream = new Stream<number>();
+     *
+     * setTimeout(()=>{
+     *  stream.push(5);
+     * })
+     * // Wait for first value
+     * const firstValue = await stream; // Resolves promises with 5
+     *
+     *
+     * ```
+     */
+    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
+     *
+     * @example
+     * ```typescript
+     * const numbers = new Stream<number>();
+     *
+     * // Using built-in transformers
+     * const result = numbers
+     *   .pipe(filter(n => n > 0))
+     *   .pipe(map(n => n * 2))
+     *   .pipe(group(batch => batch.length >= 3));
+     *
+     * // Custom transformer
+     * const throttle = <T>(ms: number) => (stream: Stream<T>) =>
+     *   new Stream<T>(async function* () {
+     *     let lastEmit = 0;
+     *     for await (const value of stream) {
+     *       const now = Date.now();
+     *       if (now - lastEmit >= ms) {
+     *         yield value;
+     *         lastEmit = now;
+     *       }
+     *     }
+     *   });
+     *
+     * numbers.pipe(throttle(1000));
+     * ```
+     */
+    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

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"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"}