@m4trix/core 0.5.0 → 0.6.0

package/dist/stream/index.d.cts

@@ -1,304 +0,0 @@
-/**
- * StreamChunk is the base interface for all streams.
- * It can hold voice and text chunks.
- *
- * @template T The type of data contained in the chunk
- */
-interface StreamChunk<T> {
-    sequence: number;
-    data: T;
-    done: boolean;
-}
-/**
- * MessageStream represents an asynchronous iterable stream of chunks.
- * Used as the core stream representation throughout the Pump library.
- *
- * @template T The type of data contained in the chunks of the stream
- */
-type MessageStream<T> = AsyncIterable<StreamChunk<T>>;
-/**
- * Represents any source that can be converted to a stream.
- * This includes AsyncIterable and ReadableStream sources.
- *
- * @template T The type of data contained in the source
- */
-type Source<T> = AsyncIterable<T> | ReadableStream<T> | NodeJS.ReadableStream;
-/**
- * A transformer for stream data that also provides a response.
- * Used primarily to transform and consume stream data while producing a response object.
- *
- * @template T The type of data being transformed
- * @template R The type of the response (defaults to Response)
- */
-type StreamTransformer<T, R = Response> = {
-    transform(data: T): T;
-    close(): void;
-    response: R;
-};
-/**
- * Pump is an asynchronous stream processing pipeline with fluent operators.
- * It provides a comprehensive set of operations for transforming, filtering, batching,
- * combining, and consuming stream data.
- *
- * The Pump class follows a builder pattern where each operation returns a new Pump instance,
- * allowing for chaining of operations to build complex stream processing pipelines.
- *
- * @template T The type of data contained in the stream
- */
-declare class Pump<T> {
-    private readonly src;
-    constructor(src: MessageStream<T>);
-    /**
-     * Wrap an existing AsyncIterable or Readable stream into a Pump
-     *
-     * @template U The type of data in the source stream
-     * @param source The source stream to convert to a Pump (AsyncIterable, ReadableStream, or NodeJS.ReadableStream)
-     * @returns A new Pump instance that wraps the source
-     */
-    static from<U>(source: Source<U>): Pump<U>;
-    /**
-     * Sync or async map over the data portion of each chunk
-     *
-     * @template U The output type after transformation
-     * @param fn The mapping function that transforms each chunk
-     * @returns A new Pump instance with the transformed data
-     */
-    map<U>(fn: (data: T) => U | Promise<U>): Pump<U>;
-    /**
-     * Stateful map allows processing stream chunks with a persistent context object.
-     *
-     * The context is initialized when the first chunk arrives and can be updated with each chunk.
-     * This is useful for maintaining state across the stream processing.
-     *
-     * If you plan to use sockets you should rather opt for asyncStatefulMap.
-     *
-     * The pipe closes only after all processing is complete, including any final operations in onClose.
-     *
-     * TODO: Un-tested
-     *
-     * @param handlers Object containing callback functions for stream processing
-     * @param handlers.onFirstChunk Function called when the first chunk arrives, initializes the context
-     * @param handlers.onChunk Function called for each subsequent chunk, updates the context
-     * @param handlers.onClose Optional function called when the stream closes, allows final processing
-     * @returns A new Pump instance with transformed data
-     */
-    statefulMap<Context, U = T>(handlers: {
-        onFirstChunk(chunk: T, yieldData: (data: U) => void): Context | Promise<Context>;
-        onChunk(chunk: T, context: Context, yieldData: (data: U) => void): Context | Promise<Context>;
-        onClose?(lastChunk: T | undefined, context: Context, yieldData: (data: U) => void): void | Promise<void>;
-    }): Pump<U>;
-    /**
-     * Async map means that each incoming chunk is causing an async operation that when it completes
-     * should yield a new chunk.
-     * The pipe closes only after you unlock the pipe by using the unlockCloseEvent callback.
-     *
-     * Stateful refers to the fact that you can create your own small context object that is passed in the subsequent callbacks.
-     * This allows you to keep track of things like a socket connection.
-     *
-     * Why is this nice? Well if you use things like a socket the pipe might have received the close event,
-     * before you got any or all of your socket responses. Sockets don't fit into the standard promise pattern,
-     * which makes it harder to wait for them.
-     *
-     * TODO: Un-tested
-     *
-     * @param handlers Object containing callback functions for stream processing
-     * @param handlers.onFirstChunk Function called when the first chunk arrives, initializes the context
-     * @param handlers.onChunk Function called for each subsequent chunk, updates the context
-     * @param handlers.onClose Optional function called when the stream closes, allows final processing
-     * @returns A new Pump instance with transformed data
-     */
-    asyncStatefulMap<Context, U = T>(handlers: {
-        onFirstChunk(chunk: T, yieldData: (data: U) => void, unlockCloseEvent: () => void): Context | Promise<Context>;
-        onChunk(chunk: T, context: Context, yieldData: (data: U) => void, unlockCloseEvent: () => void): Context | Promise<Context>;
-        onClose?(lastChunk: T | undefined, context: Context, yieldData: (data: U) => void, unlockCloseEvent: () => void): void | Promise<void>;
-    }): Pump<U>;
-    /**
-     * Filter items based on a predicate
-     *
-     * @param predicate A function that determines whether to keep each chunk
-     * @returns A new Pump instance containing only chunks that passed the predicate
-     */
-    filter(predicate: (data: T) => boolean | Promise<boolean>): Pump<T>;
-    /**
-     * Bundles (accumulates) chunks together based on a condition rather than a fixed size.
-     *
-     * This is useful when you need to group chunks dynamically based on their content or other criteria.
-     *
-     * Example: Bundling text chunks with a maximum character limit
-     *
-     * Input chunks: ["Hello", " this", " is", " a few", " chunks", " of text"]
-     * With max size of 10 characters:
-     * - First bundle: ["Hello", " this"] (10 chars)
-     * - Second bundle: [" is", " a few"] (8 chars)
-     * - Third bundle: [" chunks", " of text"] (13 chars)
-     *
-     * @param closeBundleCondition - Function that determines when to close the current bundle
-     *                              Returns true when the current bundle should be emitted
-     *                              Parameters:
-     *                              - chunk: The current chunk being processed
-     *                              - accumulatedChunks: Array of chunks in the current bundle
-     *
-     * @returns A pump that emits arrays of bundled items
-     */
-    bundle(closeBundleCondition: (chunk: T, accumulatedChunks: Array<T>) => boolean | Promise<boolean>): Pump<Array<T>>;
-    /**
-     * Tap into each chunk without altering it
-     *
-     * @param fn A function that receives each chunk but doesn't affect the stream
-     * @returns The same pump instance with unmodified data
-     */
-    onChunk(fn: (chunk: T) => void | Promise<void>): Pump<T>;
-    /**
-     * Collect all chunks in the stream and run a callback when the stream is done.
-     * The callback receives an array of all chunks that passed through.
-     *
-     * This is useful for analytics, logging, or processing the complete stream history
-     * after all chunks have been received.
-     *
-     * @param fn - Callback function that receives the array of all chunks when the stream is complete
-     * @returns The same pump, for chaining
-     */
-    onClose(fn: (history: T[]) => void | Promise<void>): Pump<T>;
-    /**
-     * Batch `n` chunks into arrays before emitting
-     *
-     * @param n The number of chunks to batch together
-     * @returns A new Pump instance that emits arrays of batched chunks
-     */
-    batch(n: number): Pump<Array<T>>;
-    /**
-     * If you want to prevent chunk starvation, you can buffer the chunks.
-     * Chunks will not be bundled into arrays or object but kept as is,
-     * but the pipeline will not progress at that segment until the buffer is filled up.
-     * Once a buffer is filled up it will drain and never buffer again.
-     *
-     * @param n The number of chunks to buffer before processing continues
-     * @returns A new Pump instance with buffering behavior
-     */
-    buffer(n: number): Pump<T>;
-    /**
-     * Rechunk the stream: transform one chunk into zero, one, or many output chunks.
-     * The handler function receives the current buffer of chunks, a push function to emit new chunks,
-     * and a flag indicating if this is the last chunk in the stream.
-     *
-     * @param handler Function that transforms chunks and pushes new ones
-     * @returns A new Pump instance with rechunked data
-     */
-    rechunk(handler: (params: {
-        buffer: T[];
-        push: (chunk: T) => void;
-        lastChunk: boolean;
-        setBuffer: (buffer: T[]) => void;
-    }) => void | Promise<void>): Pump<T>;
-    /**
-     * Emit sliding windows of the last `size` items with step `step`.
-     * Each window is an array [current, previous1, ..., previous(size-1)].
-     * Optionally, map each window through a function.
-     *
-     * | Step | Window | Resulting Window |
-     * |------|--------|------------------|
-     * | 1    | ▪︎▪︎[▪︎▫︎▫︎] | ▪︎▫︎▫︎ |
-     * | 2    | ▪︎[▪︎▪︎▫︎] | ▪︎▪︎▫︎ |
-     * | 3    | [▪︎▪︎▪︎] | ▪︎▪︎▪︎ |
-     * | 4    | [▫︎▪︎▪︎] | ▫︎▪︎▪︎ |
-     * | 5    | [▫︎▫︎▪︎] | ▫︎▫︎▪ |
-     *
-     * @param size The size of each window
-     * @param step The number of items to move between windows
-     * @returns A Pump that emits arrays representing sliding windows
-     */
-    slidingWindow(size: number, step: number): Pump<Array<T | undefined>>;
-    /**
-     * Emit sliding windows of the last `size` items with step `step`,
-     * and map each window using the provided function.
-     *
-     * @template N The size type parameter (extends number)
-     * @template U The output type after window transformation
-     * @param size The size of each window
-     * @param step The number of items to move between windows
-     * @param fn A function to transform each window
-     * @returns A Pump that emits transformed sliding windows
-     */
-    slidingWindow<N extends number, U>(size: N, step: number, fn: (window: Array<T | undefined>) => U | Promise<U>): Pump<U>;
-    /**
-     * Sequentially flatten inner stream sources emitted by the pipeline.
-     * Works with any Source type (AsyncIterable or ReadableStream).
-     * This method is only available when the current Pump contains Source elements.
-     *
-     * @template U The type of data in the inner streams
-     * @template F The type of inner stream source (extends Source<U>)
-     * @returns A Pump instance with flattened stream data
-     */
-    sequenceStreams<U, F extends Source<U>>(this: Pump<F>): Pump<U>;
-    /**
-     * Fork the stream: two independent Pump<T> consumers
-     * Both resulting Pumps will receive the same data, allowing for divergent processing paths.
-     *
-     * @returns An array containing two independent Pump instances with the same source data
-     */
-    fork(): [Pump<T>, Pump<T>];
-    /**
-     * Drain the pipeline, consuming all chunks.
-     * Returns a Promise that resolves when all chunks have been consumed.
-     *
-     * @returns A Promise that resolves when all chunks have been consumed
-     */
-    drain(): Promise<void>;
-    /**
-     * Drain the pipeline to a StreamTransformer.
-     * Applies transform() to each data chunk, then closes the transformer,
-     * and returns its response (which can be of any type defined by the transformer).
-     *
-     * Example with httpStreamResponse:
-     * ```
-     * const { transform, response, close } = httpStreamResponse(options);
-     * return Pump.from(messageStream).drainTo({ transform, close, response });
-     * ```
-     *
-     * @template U The type of data expected by the transformer (extends T)
-     * @template R The response type produced by the transformer
-     * @param transformer The StreamTransformer to drain to
-     * @returns The response from the transformer
-     */
-    drainTo<U extends T, R>(transformer: StreamTransformer<U, R>): R;
-}
-
-interface HttpStreamOptions<T> {
-    /** HTTP ResponseInit (status, headers, etc.) */
-    init?: ResponseInit;
-    /** Encode each chunk of type T into bytes or string */
-    encoder?: (data: T) => Uint8Array | string;
-}
-/**
- * Create a streaming HTTP response transformer.
- * Returns an object with:
- * - transform: function to write each chunk into the response
- * - response: the Fetch API Response ready to return
- * - close: function to close the stream when done
- *
- * Usage in a Next.js route:
- * ```
- * // With the new drainTo API:
- * const transformer = httpStreamResponse(options);
- * return Pump.from(messageStream).drainTo(transformer);
- *
- * // Or with manual control:
- * const { transform, response, close } = httpStreamResponse(options);
- * await Pump.from(messageStream).map(transform).drain();
- * close();
- * return response;
- * ```
- */
-declare function httpStreamResponse<T>(options?: HttpStreamOptions<T>): StreamTransformer<T, Response>;
-
-/**
- * A helper to be used with Pump.rechunk that ensures full word chunks.
- * Aggregates incoming chunks and emits only when a full word boundary is reached.
- */
-declare function ensureFullWords({ buffer, push, lastChunk, }: {
-    buffer: string[];
-    push: (chunk: string) => void;
-    lastChunk: boolean;
-}): Promise<void>;
-
-export { type HttpStreamOptions, type MessageStream, Pump, type Source, type StreamChunk, type StreamTransformer, ensureFullWords, httpStreamResponse };

package/dist/ui/index.d.cts

@@ -1,30 +0,0 @@
-type Selector = string;
-type CursorTarget = HTMLElement | Selector | [number, number];
-/**
- * The AiCursor is a class that is used to create a cursor element and acts an interface to control the cursor.
- * It is used to move the cursor to a target, show or hide the cursor, and to schedule moves.
- *
- * @example
- * ```ts
- * const cursor = AiCursor.spawn();
- * cursor.moveTo('#target-element');
- * ```
- *
- * @author @Pascal-Lohscheidt
- */
-declare class AiCursor {
-    private setPosition?;
-    private addPositionToQueue?;
-    private playQueue?;
-    private setShowCursor?;
-    constructor();
-    static spawn(): AiCursor;
-    jumpTo(target: CursorTarget): void;
-    moveTo(target: CursorTarget): void;
-    scheduleMoves(targets: CursorTarget[]): void;
-    show(): void;
-    hide(): void;
-    private mount;
-}
-
-export { AiCursor };