@mearie/core 0.0.1-next.5 → 0.1.2

package/dist/index-BJ3Ktp8q.d.ts

@@ -0,0 +1,405 @@
+//#region src/stream/types.d.ts
+/**
+ * Subscription allows cancelling a stream and cleaning up resources.
+ */
+type Subscription = {
+  /**
+   * Cancel the stream and clean up resources.
+   */
+  unsubscribe(): void;
+};
+/**
+ * Sink receives values from a Source.
+ */
+type Sink<T> = {
+  /**
+   * Receive a data value.
+   * @param value - The data value.
+   */
+  next(value: T): void;
+  /**
+   * Receive completion signal.
+   */
+  complete(): void;
+};
+/**
+ * Source is a function that accepts a Sink and returns a Subscription.
+ * When called, it starts pushing values to the sink.
+ * @returns A subscription that can be used to cancel the stream.
+ */
+type Source<T> = (sink: Sink<T>) => Subscription;
+/**
+ * Operator transforms one Source into another.
+ */
+type Operator<T, R = T> = (source: Source<T>) => Source<R>;
+//#endregion
+//#region src/stream/pipe.d.ts
+/**
+ * Pipes a source through a series of operators.
+ * @param source - The source stream.
+ * @returns The source itself.
+ */
+declare function pipe<A>(source: Source<A>): Source<A>;
+/**
+ * @param source - The source stream.
+ * @param op1 - The operator or sink.
+ * @returns The result of the operator/sink.
+ */
+declare function pipe<A, B>(source: Source<A>, op1: (source: Source<A>) => B): B;
+/**
+ * @param source - The source stream.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator or sink.
+ * @returns The result of the last operator/sink.
+ */
+declare function pipe<A, B, C>(source: Source<A>, op1: Operator<A, B>, op2: (source: Source<B>) => C): C;
+/**
+ * @param source - The source stream.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator or sink.
+ * @returns The result of the last operator/sink.
+ */
+declare function pipe<A, B, C, D>(source: Source<A>, op1: Operator<A, B>, op2: Operator<B, C>, op3: (source: Source<C>) => D): D;
+/**
+ * @param source - The source stream.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator or sink.
+ * @returns The result of the last operator/sink.
+ */
+declare function pipe<A, B, C, D, E>(source: Source<A>, op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: (source: Source<D>) => E): E;
+/**
+ * @param source - The source stream.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator.
+ * @param op5 - The fifth operator or sink.
+ * @returns The result of the last operator/sink.
+ */
+declare function pipe<A, B, C, D, E, F>(source: Source<A>, op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: (source: Source<E>) => F): F;
+/**
+ * @param source - The source stream.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator.
+ * @param op5 - The fifth operator.
+ * @param op6 - The sixth operator or sink.
+ * @returns The result of the last operator/sink.
+ */
+declare function pipe<A, B, C, D, E, F, G>(source: Source<A>, op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>, op6: (source: Source<F>) => G): G;
+/**
+ * @param source - The source stream.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator.
+ * @param op5 - The fifth operator.
+ * @param op6 - The sixth operator.
+ * @param op7 - The seventh operator or sink.
+ * @returns The result of the last operator/sink.
+ */
+declare function pipe<A, B, C, D, E, F, G, H>(source: Source<A>, op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>, op6: Operator<F, G>, op7: (source: Source<G>) => H): H;
+/**
+ * @param source - The source stream.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator.
+ * @param op5 - The fifth operator.
+ * @param op6 - The sixth operator.
+ * @param op7 - The seventh operator.
+ * @param op8 - The eighth operator or sink.
+ * @returns The result of the last operator/sink.
+ */
+declare function pipe<A, B, C, D, E, F, G, H, I>(source: Source<A>, op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>, op6: Operator<F, G>, op7: Operator<G, H>, op8: (source: Source<H>) => I): I;
+//#endregion
+//#region src/stream/compose.d.ts
+/**
+ * Composes a single operator.
+ * @param op1 - The operator.
+ * @returns The operator itself.
+ */
+declare function compose<A, B>(op1: Operator<A, B>): Operator<A, B>;
+/**
+ * Composes two operators into one.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @returns A composed operator.
+ */
+declare function compose<A, B, C>(op1: Operator<A, B>, op2: Operator<B, C>): Operator<A, C>;
+/**
+ * Composes three operators into one.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @returns A composed operator.
+ */
+declare function compose<A, B, C, D>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>): Operator<A, D>;
+/**
+ * Composes four operators into one.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator.
+ * @returns A composed operator.
+ */
+declare function compose<A, B, C, D, E>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>): Operator<A, E>;
+/**
+ * Composes five operators into one.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator.
+ * @param op5 - The fifth operator.
+ * @returns A composed operator.
+ */
+declare function compose<A, B, C, D, E, F>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>): Operator<A, F>;
+/**
+ * Composes six operators into one.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator.
+ * @param op5 - The fifth operator.
+ * @param op6 - The sixth operator.
+ * @returns A composed operator.
+ */
+declare function compose<A, B, C, D, E, F, G>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>, op6: Operator<F, G>): Operator<A, G>;
+/**
+ * Composes seven operators into one.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator.
+ * @param op5 - The fifth operator.
+ * @param op6 - The sixth operator.
+ * @param op7 - The seventh operator.
+ * @returns A composed operator.
+ */
+declare function compose<A, B, C, D, E, F, G, H>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>, op6: Operator<F, G>, op7: Operator<G, H>): Operator<A, H>;
+/**
+ * Composes eight operators into one.
+ * @param op1 - The first operator.
+ * @param op2 - The second operator.
+ * @param op3 - The third operator.
+ * @param op4 - The fourth operator.
+ * @param op5 - The fifth operator.
+ * @param op6 - The sixth operator.
+ * @param op7 - The seventh operator.
+ * @param op8 - The eighth operator.
+ * @returns A composed operator.
+ */
+declare function compose<A, B, C, D, E, F, G, H, I>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>, op6: Operator<F, G>, op7: Operator<G, H>, op8: Operator<H, I>): Operator<A, I>;
+//#endregion
+//#region src/stream/sinks/subscribe.d.ts
+/**
+ * Observer pattern for consuming values from a Source.
+ */
+type Observer<T> = {
+  /**
+   * Called when the source emits a value.
+   * @param value - The emitted value.
+   */
+  next?: (value: T) => void;
+  /**
+   * Called when the source completes.
+   */
+  complete?: () => void;
+};
+/**
+ * Subscribe to a Source with an Observer.
+ * This is a terminal operator that starts the source execution.
+ * @param observer - The observer to receive values.
+ * @returns A function that takes a source and returns a subscription.
+ */
+declare const subscribe: <T>(observer: Observer<T>) => (source: Source<T>) => (() => void);
+//#endregion
+//#region src/stream/sinks/publish.d.ts
+declare const publish: <T>(source: Source<T>) => void;
+//#endregion
+//#region src/stream/sinks/collect.d.ts
+/**
+ * Collects the last value emitted by a source.
+ * This is a terminal operator that returns the last emitted value.
+ * Rejects if the source completes without emitting any values.
+ * @param source - The source to collect from.
+ * @returns A promise that resolves with the last emitted value.
+ */
+declare const collect: <T>(source: Source<T>) => Promise<T>;
+//#endregion
+//#region src/stream/sinks/collect-all.d.ts
+/**
+ * Collects all values from a source into an array.
+ * This is a terminal operator that accumulates all emitted values.
+ * @param source - The source to collect values from.
+ * @returns A promise that resolves with an array of all emitted values.
+ */
+declare const collectAll: <T>(source: Source<T>) => Promise<T[]>;
+//#endregion
+//#region src/stream/sinks/peek.d.ts
+/**
+ * Synchronously reads the first value from a source and immediately unsubscribes.
+ * This is useful for reading the current state without maintaining a long-lived subscription.
+ * Throws if the source does not emit a value synchronously.
+ * @param source - The source to peek from.
+ * @returns The first value emitted by the source.
+ */
+declare const peek: <T>(source: Source<T>) => T;
+//#endregion
+//#region src/stream/operators/map.d.ts
+/**
+ * Maps each value from the source through a transformation function.
+ * @param fn - The transformation function.
+ * @returns An operator that maps values.
+ */
+declare const map: <A, B>(fn: (value: A) => B) => Operator<A, B>;
+//#endregion
+//#region src/stream/operators/filter.d.ts
+/**
+ *
+ * @param predicate - The predicate function.
+ * @returns An operator that filters values.
+ */
+declare function filter<T, S extends T>(predicate: (value: T) => value is S): Operator<T, S>;
+declare function filter<T>(predicate: (value: T) => boolean): Operator<T>;
+//#endregion
+//#region src/stream/operators/take.d.ts
+/**
+ * Takes only the first N values from the source and completes.
+ * @param count - The number of values to take.
+ * @returns An operator that takes values.
+ */
+declare const take: <T>(count: number) => Operator<T>;
+//#endregion
+//#region src/stream/operators/take-until.d.ts
+/**
+ * Emits values from the source until the notifier source emits a value.
+ * When the notifier emits, the source is cancelled and completes immediately.
+ * @param notifier - Source that signals when to complete.
+ * @returns Operator that completes when notifier emits.
+ */
+declare const takeUntil: <T>(notifier: Source<unknown>) => Operator<T>;
+//#endregion
+//#region src/stream/operators/share.d.ts
+/**
+ * Shares a single source across multiple subscribers (multicast).
+ * The source is only executed once, and all subscribers receive the same values.
+ * This is essential for deduplication and caching scenarios.
+ * @returns An operator that shares the source.
+ */
+declare const share: <T>() => Operator<T>;
+//#endregion
+//#region src/stream/operators/merge.d.ts
+/**
+ * Merges multiple sources into a single source.
+ * Values are emitted as soon as they arrive from any source.
+ * Completes when all sources complete.
+ * @param sources - The sources to merge.
+ * @returns A merged source.
+ */
+declare const merge: <T extends readonly Source<unknown>[]>(...sources: T) => Source<T[number] extends Source<infer U> ? U : never>;
+//#endregion
+//#region src/stream/operators/merge-map.d.ts
+/**
+ * Maps each value to a source and flattens all sources into a single output source.
+ * Similar to flatMap. Values from all inner sources are merged concurrently.
+ * @param fn - Function that returns a source for each value.
+ * @returns An operator that flattens mapped sources.
+ */
+declare const mergeMap: <A, B>(fn: (value: A) => Source<B>) => Operator<A, B>;
+//#endregion
+//#region src/stream/operators/switch-map.d.ts
+declare const switchMap: <A, B>(fn: (value: A) => Source<B>) => Operator<A, B>;
+//#endregion
+//#region src/stream/operators/tap.d.ts
+/**
+ * Executes a side effect for each value without modifying the stream.
+ * Useful for debugging, logging, or triggering side effects.
+ * @param fn - The side effect function.
+ * @returns An operator that taps into the stream.
+ */
+declare const tap: <T>(fn: (value: T) => void) => Operator<T>;
+//#endregion
+//#region src/stream/operators/initialize.d.ts
+/**
+ * Executes a side effect when the source is initialized (being subscribed to).
+ * @param fn - The side effect function.
+ * @returns An operator that executes the side effect when the source is initialized.
+ */
+declare const initialize: <T>(fn: () => void) => Operator<T>;
+//#endregion
+//#region src/stream/operators/finalize.d.ts
+/**
+ * Executes a side effect when the source terminates (completes or unsubscribes).
+ * @param fn - The side effect function.
+ * @returns An operator that executes the side effect when the source terminates.
+ */
+declare const finalize: <T>(fn: () => void) => Operator<T>;
+//#endregion
+//#region src/stream/sources/from-value.d.ts
+/**
+ * Creates a source that emits a single value and completes.
+ * @param value - The value to emit.
+ * @returns A source containing the single value.
+ */
+declare const fromValue: <T>(value: T) => Source<T>;
+//#endregion
+//#region src/stream/sources/from-array.d.ts
+/**
+ * Creates a source that emits values from an array and completes.
+ * @param values - The array of values to emit.
+ * @returns A source containing the array values.
+ */
+declare const fromArray: <T>(values: T[]) => Source<T>;
+//#endregion
+//#region src/stream/sources/make-subject.d.ts
+/**
+ * Subject is both a Source and an imperative push API.
+ */
+type Subject<T> = {
+  /**
+   * The source that can be subscribed to.
+   */
+  source: Source<T>;
+  /**
+   * Push a value to all subscribers.
+   * @param value - The value to push.
+   */
+  next: (value: T) => void;
+  /**
+   * Complete all subscribers.
+   */
+  complete: () => void;
+};
+/**
+ * Creates a new Subject which can be used as an IO event hub.
+ * @returns A new Subject.
+ */
+declare const makeSubject: <T>() => Subject<T>;
+//#endregion
+//#region src/stream/sources/from-subscription.d.ts
+declare const fromSubscription: <T>(pull: () => T, poke: (signal: () => void) => () => void) => Source<T>;
+//#endregion
+//#region src/stream/sources/from-promise.d.ts
+declare const fromPromise: <T>(promise: Promise<T>) => Source<T>;
+//#endregion
+//#region src/stream/sources/make.d.ts
+/**
+ * Creates a new Source from scratch from a passed subscriber function.
+ *
+ * The subscriber function receives an observer with next and complete callbacks.
+ * It must return a teardown function which is called when the source is cancelled.
+ * @internal
+ * @param subscriber - A callback that is called when the Source is subscribed to.
+ * @returns A Source created from the subscriber parameter.
+ */
+declare const make: <T>(subscriber: (observer: {
+  next: (value: T) => void;
+  complete: () => void;
+}) => () => void) => Source<T>;
+//#endregion
+export { Subscription as A, Observer as C, Operator as D, pipe as E, Sink as O, publish as S, compose as T, filter as _, makeSubject as a, collectAll as b, finalize as c, switchMap as d, mergeMap as f, take as g, takeUntil as h, Subject as i, Source as k, initialize as l, share as m, fromPromise as n, fromArray as o, merge as p, fromSubscription as r, fromValue as s, make as t, tap as u, map as v, subscribe as w, collect as x, peek as y };