simply-observe 1.0.0

package/README.md

@@ -0,0 +1,103 @@
+# Simply Observe
+
+A lightweight, dependency-free reactive primitives library for TypeScript/JavaScript — `Observer`, `Subject`, and a set of combinators for working with streams of values over time.
+
+Inspired by RxJS, built from scratch with a smaller surface area and no external dependencies.
+
+## Install
+
+```bash
+npm install simply-observe
+```
+
+## Quick start
+
+### Observer
+
+An `Observer` wraps a task function that receives `next`, `error`, and `complete` dispatchers. Subscribers are added lazily — the task only runs once something subscribes.
+
+```ts
+import { Observer } from 'simply-observe';
+
+const observer = new Observer<number>((next, error, complete) => {
+  next(1);
+  next(2);
+  complete();
+
+  // optional teardown, called on unsubscribe/close
+  return () => {
+    console.log('cleaned up');
+  };
+});
+
+observer.subscribe(
+  (value) => console.log('next:', value),
+  (err) => console.log('error:', err),
+  () => console.log('complete')
+);
+```
+
+### Subject
+
+A `Subject` is both an Observer and a dispatcher — call `.next()`, `.error()`, or `.complete()` on it directly to push values to its subscribers.
+
+```ts
+import { Subject } from 'simply-observe';
+
+const subject = new Subject<number>(0);
+
+subject.subscribe((value) => console.log('got:', value));
+
+subject.next(1);
+subject.next(2);
+subject.complete();
+```
+
+Late subscribers (subscribing after `error()`, `complete()`, or `close()` has already fired) immediately receive that terminal event rather than hanging silently.
+
+## Combinators
+
+Static methods on `Observer` for combining multiple sources. Each accepts an array of `Observer`s and, where sources have different value types, infers a tuple so per-position types are preserved (`Observer.all([numberObs, stringObs])` returns `Observer<[number, string]>`, not `Observer<number | string>`).
+
+| Method | Behavior |
+|---|---|
+| `Observer.all(observers)` | Waits for every source to complete, then emits one array of their final values. |
+| `Observer.partial(observers)` | Emits a snapshot array after each individual source completes. |
+| `Observer.latest(observers)` | Emits an updated array every time any source emits (`combineLatest`-style, may include `undefined` for sources that haven't emitted yet). |
+| `Observer.zip(observers)` | Pairs values positionally — emits once every source has produced a value at that index. |
+| `Observer.sequent(observers)` | Subscribes to sources one at a time, in order, emitting each one's value as it completes before moving to the next. |
+| `Observer.race(observers)` | Mirrors whichever source emits or errors first; all others are unsubscribed. |
+| `Observer.flat(observers)` | Merges all sources into a single stream, emitting values as they arrive from any source. |
+
+```ts
+import { Observer, of } from 'simply-observe';
+
+Observer.zip([of(1, 2, 3), of('a', 'b', 'c')]).subscribe((pair) => {
+  console.log(pair); // [1, 'a'], then [2, 'b'], then [3, 'c']
+});
+```
+
+## `of(...)`
+
+Constructs an `Observer` that synchronously emits the given values, in order, then completes.
+
+```ts
+import { of } from 'simply-observe';
+
+of(1, 2, 3).subscribe((v) => console.log(v));
+```
+
+## Unsubscribing
+
+`subscribe()` returns a `Subscription`. Call `.unsubscribe()` to stop receiving values and run any teardown logic.
+
+```ts
+const sub = observer.subscribe((v) => console.log(v));
+sub.unsubscribe();
+```
+
+Subscriptions can be linked together — `subscription.add(other)` ties `other`'s lifecycle to `subscription`'s, so unsubscribing the parent tears down every linked child.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,189 @@
+type Flat<T extends readonly unknown[]> = T extends [infer F, ...infer R] ? F extends readonly unknown[] ? [...F, ...Flat<R>] : [F, ...Flat<R>] : [];
+type Pop<T extends readonly unknown[]> = T extends [...infer R, infer _] ? R : never;
+type ObserverRef = ReturnType<Crypto["randomUUID"]>;
+type ObserverTaskFunction<T> = (...args: ObserverTaskParameters<T>) => any;
+type ObserverTaskParameters<T> = [update: UpdateDispatcher<T>, error: ErrorDispatcher, complete: CompleteDispatcher<T>];
+type UpdateDispatcher<T> = (next: T) => any;
+type ErrorDispatcher = (err: any) => any;
+type CompleteDispatcher<T> = (final?: T) => void;
+type SubscriptionFunction<T> = (...args: SubscriptionParameters<T>) => Subscription<T>;
+type SubscriptionParameters<T> = [next: NextHandler<T>, error?: ErrorHandler, complete?: CompleteHandler<T>];
+type SubscriptionHandlers<T> = {
+    next: NextHandler<T>;
+    error?: ErrorHandler;
+    complete?: CompleteHandler<T>;
+};
+type UnsubscribeHandler$1 = () => boolean;
+type NextHandler<T> = UpdateDispatcher<T>;
+type ErrorHandler = ErrorDispatcher;
+type CompleteHandler<T> = CompleteDispatcher<T>;
+type CloseHandler = () => void;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type CatchUnknown<T> = IsAny<T> extends true ? any : unknown extends T ? never : T;
+type extractUnknown<T> = T extends CatchUnknown<infer U> ? U : T;
+type extractType<T> = T extends Observer<infer U>[] ? U : never;
+type extractInputTuple<T> = {
+    [K in keyof T]: Observer<T[K]>;
+};
+
+type UnsubscribeHandler = () => boolean;
+interface SubscriptionConstructor {
+    new <T>(_unsubscribe?: UnsubscribeHandler): Subscription<T>;
+}
+interface Subscribable<T> {
+    subscribe: SubscriptionFunction<T>;
+}
+interface Subscription<T> {
+    ref: ObserverRef;
+    closed: boolean;
+    parents: Subscription<unknown>[] | null;
+    unsubscribe(): void;
+    add<U>(subscription: Subscription<U>): void;
+    remove<U>(subscription: Subscription<U>): void;
+}
+declare const Subscription: SubscriptionConstructor;
+
+interface ObserverContextConstructor {
+    new <T>(): ObserverContext<T>;
+}
+interface ObserverContext<T> {
+    add(subscriber: SubscriptionHandlers<T>): () => boolean;
+    invoke(task: ObserverTaskFunction<T>): void;
+    update(value?: T): void;
+    error(value?: unknown): void;
+    complete(final?: T): void;
+    close(): void;
+    active: boolean;
+    invoked: boolean;
+}
+declare const ObserverContext: ObserverContextConstructor;
+
+type OperatorFunction<T, R> = (source: Observer<T>) => Observer<R>;
+declare function map<T, R>(fn: (value: T) => R): OperatorFunction<T, R>;
+declare function filter<T>(predicate: (value: T) => boolean): OperatorFunction<T, T>;
+declare function tap<T>(fn: (value: T) => void): OperatorFunction<T, T>;
+declare function catchError<T>(handler: (err: any) => Observer<T>): OperatorFunction<T, T>;
+declare function retry<T>(count: number): OperatorFunction<T, T>;
+declare function take<T>(count: number): OperatorFunction<T, T>;
+declare function takeUntil<T>(notifier: Observer<T>): OperatorFunction<T, T>;
+declare function skip<T>(count: number): OperatorFunction<T, T>;
+declare function debounce<T>(value: number): OperatorFunction<T, T>;
+declare function toPipe<T, R>(operators: OperatorFunction<T, R>[]): OperatorFunction<T, R>;
+type OpArgs<T, Args extends readonly unknown[]> = Flat<OpChain<Pop<[T, ...Args]>, Args>>;
+type OpChain<A extends readonly unknown[], B extends readonly unknown[]> = {
+    [K in keyof A]: K extends keyof B ? [op: OperatorFunction<A[K], B[K]>] : never;
+};
+interface Pipeable<T> {
+    pipe(): Observer<T>;
+    pipe<A>(...args: OpArgs<T, [A]>): Observer<A>;
+    pipe<A, B>(...args: OpArgs<T, [A, B]>): Observer<B>;
+    pipe<A, B, C>(...args: OpArgs<T, [A, B, C]>): Observer<C>;
+    pipe<A, B, C, D>(...args: OpArgs<T, [A, B, C, D]>): Observer<D>;
+    pipe<A, B, C, D, E>(...args: OpArgs<T, [A, B, C, D, E]>): Observer<E>;
+    pipe<A, B, C, D, E, F>(...args: OpArgs<T, [A, B, C, D, E, F]>): Observer<F>;
+    pipe<A, B, C, D, E, F, G>(...args: OpArgs<T, [A, B, C, D, E, F, G]>): Observer<G>;
+    pipe<A, B, C, D, E, F, G, H>(...args: OpArgs<T, [A, B, C, D, E, F, G, H]>): Observer<H>;
+    pipe<A, B, C, D, E, F, G, H, I>(...args: OpArgs<T, [A, B, C, D, E, F, G, H, I]>): Observer<I>;
+    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observer<unknown>;
+    pipe(...operators: OperatorFunction<any, any>[]): Observer<any>;
+}
+
+interface ObserverConstructor {
+    new <T extends any = never>(context: ObserverTaskFunction<T>): Observer<T>;
+}
+declare class ObserverLike<T> {
+    readonly ref: `${string}-${string}-${string}-${string}-${string}`;
+    protected _context: ObserverContext<T>;
+    get closed(): boolean;
+}
+interface Observer<T> extends Subscribable<T>, Pipeable<T> {
+}
+declare const Observer: ObserverConstructor;
+
+interface SubjectConstructor {
+    new <T extends any = never>(initial?: T): Subject<T>;
+}
+interface Subject<T> extends Subscribable<T> {
+    close(): void;
+    next(value: T): void;
+    error(value: any): void;
+    complete(final?: T): void;
+    asObservable(): Observer<T>;
+}
+declare const Subject: SubjectConstructor;
+
+declare function of(value?: undefined): Observer<undefined>;
+declare function of(value: null): Observer<null>;
+declare function of<T>(...args: CatchUnknown<T>[]): Observer<T>;
+declare function timeout<T>(value: T, delay?: number | undefined): Observer<T>;
+declare function interval(delay?: number | undefined): Observer<number>;
+/**
+     * Returns an Observer that emits an array containing the latest emmited\
+     * values of all inner Observers, in the order of the Observer array given,\
+     * when the inner Observer completes. All inner Observer must emmit a complete\
+     * message for the outer observer to emmit its value.
+     *
+     * @param observers Observer array
+     * @returns  An Observer that subscribes to all inner Observers
+     */
+declare function all<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T>;
+/**
+ * Returns an Observer that emits an array containing the\
+ * emmited values of all inner Observers, as they are completed,\
+ * in the order of the Observer array given. This streams all\
+ * inner Observer's latest values as they are individualy completed.
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function partial<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T>;
+/**
+ * Returns an Observer that emits an array containing the\
+ * emmited values of all inner Observers. This streams all\
+ * inner Observer's latest values as they are individualy emmited.
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function latest<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T>;
+/**
+ * Returns an Observer that emits an array containing the\
+ * emmited values of all inner Observers, in the order of the\
+ * Observer array given. When the previous Observer completes,\
+ * the next one is subscribed to, unsubscribing from the previous.\
+ * Once all inner Observers are completed, all values are emmited\
+ * by the outer Observer.
+ *
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function sequent<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T[number]>;
+/**
+ * Returns an Observer that mirrors the first inner Observer\
+ * to emmit a value. All other Observers are ignored.
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function race<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T[number]>;
+/**
+ * Returns an Observer that merges the emmited values of the\
+ * inner Observers as a single stream.
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function flat<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T[number]>;
+/**
+ * Returns an Observer that merges the emmited values of the\
+ * inner Observers at the same index. The outer Observer waits\
+ * for a complete set before emmiting the values. If the inner\
+ * Observers
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function zip<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T>;
+
+export { type CatchUnknown, type CloseHandler, type CompleteDispatcher, type CompleteHandler, type ErrorDispatcher, type ErrorHandler, type Flat, type IsAny, type NextHandler, Observer, type ObserverConstructor, ObserverLike, type ObserverRef, type ObserverTaskFunction, type ObserverTaskParameters, type OperatorFunction, type Pipeable, type Pop, Subject, type SubjectConstructor, type SubscriptionFunction, type SubscriptionHandlers, type SubscriptionParameters, type UnsubscribeHandler$1 as UnsubscribeHandler, type UpdateDispatcher, all, catchError, debounce, type extractInputTuple, type extractType, type extractUnknown, filter, flat, interval, latest, map, of, partial, race, retry, sequent, skip, take, takeUntil, tap, timeout, toPipe, zip };

package/dist/index.d.ts

@@ -0,0 +1,189 @@
+type Flat<T extends readonly unknown[]> = T extends [infer F, ...infer R] ? F extends readonly unknown[] ? [...F, ...Flat<R>] : [F, ...Flat<R>] : [];
+type Pop<T extends readonly unknown[]> = T extends [...infer R, infer _] ? R : never;
+type ObserverRef = ReturnType<Crypto["randomUUID"]>;
+type ObserverTaskFunction<T> = (...args: ObserverTaskParameters<T>) => any;
+type ObserverTaskParameters<T> = [update: UpdateDispatcher<T>, error: ErrorDispatcher, complete: CompleteDispatcher<T>];
+type UpdateDispatcher<T> = (next: T) => any;
+type ErrorDispatcher = (err: any) => any;
+type CompleteDispatcher<T> = (final?: T) => void;
+type SubscriptionFunction<T> = (...args: SubscriptionParameters<T>) => Subscription<T>;
+type SubscriptionParameters<T> = [next: NextHandler<T>, error?: ErrorHandler, complete?: CompleteHandler<T>];
+type SubscriptionHandlers<T> = {
+    next: NextHandler<T>;
+    error?: ErrorHandler;
+    complete?: CompleteHandler<T>;
+};
+type UnsubscribeHandler$1 = () => boolean;
+type NextHandler<T> = UpdateDispatcher<T>;
+type ErrorHandler = ErrorDispatcher;
+type CompleteHandler<T> = CompleteDispatcher<T>;
+type CloseHandler = () => void;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type CatchUnknown<T> = IsAny<T> extends true ? any : unknown extends T ? never : T;
+type extractUnknown<T> = T extends CatchUnknown<infer U> ? U : T;
+type extractType<T> = T extends Observer<infer U>[] ? U : never;
+type extractInputTuple<T> = {
+    [K in keyof T]: Observer<T[K]>;
+};
+
+type UnsubscribeHandler = () => boolean;
+interface SubscriptionConstructor {
+    new <T>(_unsubscribe?: UnsubscribeHandler): Subscription<T>;
+}
+interface Subscribable<T> {
+    subscribe: SubscriptionFunction<T>;
+}
+interface Subscription<T> {
+    ref: ObserverRef;
+    closed: boolean;
+    parents: Subscription<unknown>[] | null;
+    unsubscribe(): void;
+    add<U>(subscription: Subscription<U>): void;
+    remove<U>(subscription: Subscription<U>): void;
+}
+declare const Subscription: SubscriptionConstructor;
+
+interface ObserverContextConstructor {
+    new <T>(): ObserverContext<T>;
+}
+interface ObserverContext<T> {
+    add(subscriber: SubscriptionHandlers<T>): () => boolean;
+    invoke(task: ObserverTaskFunction<T>): void;
+    update(value?: T): void;
+    error(value?: unknown): void;
+    complete(final?: T): void;
+    close(): void;
+    active: boolean;
+    invoked: boolean;
+}
+declare const ObserverContext: ObserverContextConstructor;
+
+type OperatorFunction<T, R> = (source: Observer<T>) => Observer<R>;
+declare function map<T, R>(fn: (value: T) => R): OperatorFunction<T, R>;
+declare function filter<T>(predicate: (value: T) => boolean): OperatorFunction<T, T>;
+declare function tap<T>(fn: (value: T) => void): OperatorFunction<T, T>;
+declare function catchError<T>(handler: (err: any) => Observer<T>): OperatorFunction<T, T>;
+declare function retry<T>(count: number): OperatorFunction<T, T>;
+declare function take<T>(count: number): OperatorFunction<T, T>;
+declare function takeUntil<T>(notifier: Observer<T>): OperatorFunction<T, T>;
+declare function skip<T>(count: number): OperatorFunction<T, T>;
+declare function debounce<T>(value: number): OperatorFunction<T, T>;
+declare function toPipe<T, R>(operators: OperatorFunction<T, R>[]): OperatorFunction<T, R>;
+type OpArgs<T, Args extends readonly unknown[]> = Flat<OpChain<Pop<[T, ...Args]>, Args>>;
+type OpChain<A extends readonly unknown[], B extends readonly unknown[]> = {
+    [K in keyof A]: K extends keyof B ? [op: OperatorFunction<A[K], B[K]>] : never;
+};
+interface Pipeable<T> {
+    pipe(): Observer<T>;
+    pipe<A>(...args: OpArgs<T, [A]>): Observer<A>;
+    pipe<A, B>(...args: OpArgs<T, [A, B]>): Observer<B>;
+    pipe<A, B, C>(...args: OpArgs<T, [A, B, C]>): Observer<C>;
+    pipe<A, B, C, D>(...args: OpArgs<T, [A, B, C, D]>): Observer<D>;
+    pipe<A, B, C, D, E>(...args: OpArgs<T, [A, B, C, D, E]>): Observer<E>;
+    pipe<A, B, C, D, E, F>(...args: OpArgs<T, [A, B, C, D, E, F]>): Observer<F>;
+    pipe<A, B, C, D, E, F, G>(...args: OpArgs<T, [A, B, C, D, E, F, G]>): Observer<G>;
+    pipe<A, B, C, D, E, F, G, H>(...args: OpArgs<T, [A, B, C, D, E, F, G, H]>): Observer<H>;
+    pipe<A, B, C, D, E, F, G, H, I>(...args: OpArgs<T, [A, B, C, D, E, F, G, H, I]>): Observer<I>;
+    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observer<unknown>;
+    pipe(...operators: OperatorFunction<any, any>[]): Observer<any>;
+}
+
+interface ObserverConstructor {
+    new <T extends any = never>(context: ObserverTaskFunction<T>): Observer<T>;
+}
+declare class ObserverLike<T> {
+    readonly ref: `${string}-${string}-${string}-${string}-${string}`;
+    protected _context: ObserverContext<T>;
+    get closed(): boolean;
+}
+interface Observer<T> extends Subscribable<T>, Pipeable<T> {
+}
+declare const Observer: ObserverConstructor;
+
+interface SubjectConstructor {
+    new <T extends any = never>(initial?: T): Subject<T>;
+}
+interface Subject<T> extends Subscribable<T> {
+    close(): void;
+    next(value: T): void;
+    error(value: any): void;
+    complete(final?: T): void;
+    asObservable(): Observer<T>;
+}
+declare const Subject: SubjectConstructor;
+
+declare function of(value?: undefined): Observer<undefined>;
+declare function of(value: null): Observer<null>;
+declare function of<T>(...args: CatchUnknown<T>[]): Observer<T>;
+declare function timeout<T>(value: T, delay?: number | undefined): Observer<T>;
+declare function interval(delay?: number | undefined): Observer<number>;
+/**
+     * Returns an Observer that emits an array containing the latest emmited\
+     * values of all inner Observers, in the order of the Observer array given,\
+     * when the inner Observer completes. All inner Observer must emmit a complete\
+     * message for the outer observer to emmit its value.
+     *
+     * @param observers Observer array
+     * @returns  An Observer that subscribes to all inner Observers
+     */
+declare function all<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T>;
+/**
+ * Returns an Observer that emits an array containing the\
+ * emmited values of all inner Observers, as they are completed,\
+ * in the order of the Observer array given. This streams all\
+ * inner Observer's latest values as they are individualy completed.
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function partial<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T>;
+/**
+ * Returns an Observer that emits an array containing the\
+ * emmited values of all inner Observers. This streams all\
+ * inner Observer's latest values as they are individualy emmited.
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function latest<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T>;
+/**
+ * Returns an Observer that emits an array containing the\
+ * emmited values of all inner Observers, in the order of the\
+ * Observer array given. When the previous Observer completes,\
+ * the next one is subscribed to, unsubscribing from the previous.\
+ * Once all inner Observers are completed, all values are emmited\
+ * by the outer Observer.
+ *
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function sequent<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T[number]>;
+/**
+ * Returns an Observer that mirrors the first inner Observer\
+ * to emmit a value. All other Observers are ignored.
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function race<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T[number]>;
+/**
+ * Returns an Observer that merges the emmited values of the\
+ * inner Observers as a single stream.
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function flat<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T[number]>;
+/**
+ * Returns an Observer that merges the emmited values of the\
+ * inner Observers at the same index. The outer Observer waits\
+ * for a complete set before emmiting the values. If the inner\
+ * Observers
+ *
+ * @param observers Observer array
+ * @returns  An Observer that subscribes to all inner Observers
+ */
+declare function zip<T extends readonly unknown[]>(observers: extractInputTuple<T>): Observer<T>;
+
+export { type CatchUnknown, type CloseHandler, type CompleteDispatcher, type CompleteHandler, type ErrorDispatcher, type ErrorHandler, type Flat, type IsAny, type NextHandler, Observer, type ObserverConstructor, ObserverLike, type ObserverRef, type ObserverTaskFunction, type ObserverTaskParameters, type OperatorFunction, type Pipeable, type Pop, Subject, type SubjectConstructor, type SubscriptionFunction, type SubscriptionHandlers, type SubscriptionParameters, type UnsubscribeHandler$1 as UnsubscribeHandler, type UpdateDispatcher, all, catchError, debounce, type extractInputTuple, type extractType, type extractUnknown, filter, flat, interval, latest, map, of, partial, race, retry, sequent, skip, take, takeUntil, tap, timeout, toPipe, zip };