@fncts/observable 0.0.1

package/Action.d.ts

@@ -0,0 +1,6 @@
+import { Subscription } from "@fncts/observable/Subscription";
+import { Scheduler, SchedulerAction } from "@fncts/observable/Scheduler";
+export declare class Action<A> extends Subscription {
+    constructor(scheduler: Scheduler, work: (this: SchedulerAction<A>, state?: A) => void);
+    schedule(state?: A, delay?: number): Subscription;
+}

package/AnimationFrameAction.d.ts

@@ -0,0 +1,11 @@
+import { AsyncAction } from "@fncts/observable/AsyncAction";
+import { AnimationFrameScheduler } from "@fncts/observable/AnimationFrameScheduler";
+import { SchedulerAction } from "@fncts/observable/Scheduler";
+import { animationFrameProvider } from "@fncts/observable/internal/animationFrameProvider";
+export declare class AnimationFrameAction<A> extends AsyncAction<A> {
+    protected scheduler: AnimationFrameScheduler;
+    protected work: (this: SchedulerAction<A>, state?: A) => void;
+    constructor(scheduler: AnimationFrameScheduler, work: (this: SchedulerAction<A>, state?: A) => void);
+    protected requestAsyncId(scheduler: AnimationFrameScheduler, delay?: number): any;
+    protected recycleAsyncId(scheduler: AnimationFrameScheduler, id?: any, delay?: number): any;
+}

package/AnimationFrameScheduler.d.ts

@@ -0,0 +1,6 @@
+import { AsyncScheduler } from "@fncts/observable/AsyncScheduler";
+import { AsyncAction } from "@fncts/observable/AsyncAction";
+export declare class AnimationFrameScheduler extends AsyncScheduler {
+    flush(action?: AsyncAction<any>): void;
+}
+export declare const animationFrameScheduler: AnimationFrameScheduler;

package/AsyncAction.d.ts

@@ -0,0 +1,19 @@
+import { Action } from "@fncts/observable/Action";
+import { AsyncScheduler } from "@fncts/observable/AsyncScheduler";
+import { SchedulerAction } from "@fncts/observable/Scheduler";
+import { Subscription } from "@fncts/observable/Subscription";
+export declare class AsyncAction<A> extends Action<A> {
+    protected scheduler: AsyncScheduler;
+    protected work: (this: SchedulerAction<A>, state?: A) => void;
+    id: any;
+    state?: A;
+    delay: number | undefined;
+    protected pending: boolean;
+    constructor(scheduler: AsyncScheduler, work: (this: SchedulerAction<A>, state?: A) => void);
+    schedule(state?: A, delay?: number): Subscription;
+    protected requestAsyncId(scheduler: AsyncScheduler, _id: any, delay?: number): any;
+    protected recycleAsyncId(_scheduler: AsyncScheduler, id: any, delay?: number | null): any;
+    execute(state: A, delay: number): unknown;
+    protected executeInternal(state: A, _delay: number): unknown;
+    unsubscribe(): void;
+}

package/AsyncScheduler.d.ts

@@ -0,0 +1,11 @@
+import { Scheduler } from "@fncts/observable/Scheduler";
+import { AsyncAction } from "@fncts/observable/AsyncAction";
+import { Action } from "@fncts/observable/Action";
+export declare class AsyncScheduler extends Scheduler {
+    actions: Array<AsyncAction<any>>;
+    active: boolean;
+    scheduled: any;
+    constructor(actionConstructor: typeof Action, now?: () => number);
+    flush(action: AsyncAction<any>): void;
+}
+export declare const asyncScheduler: AsyncScheduler;

package/BehaviorSubject.d.ts

@@ -0,0 +1,10 @@
+import { Subject } from "@fncts/observable/Subject";
+import { Subscriber } from "@fncts/observable/Subscriber";
+export declare class BehaviorSubject<E, A> extends Subject<E, A> {
+    private _value;
+    constructor(_value: A);
+    get value(): A;
+    getValue(): A;
+    protected subscribeInternal(subscriber: Subscriber<E, A>): import("./Subscription").Subscription;
+    next(value: A): void;
+}

package/Notification.d.ts

@@ -0,0 +1,59 @@
+import { Cause } from "@fncts/base/data/Cause";
+import { Observer } from "@fncts/observable/Observer";
+export declare const NextTypeId: unique symbol;
+export declare type NextTypeId = typeof NextTypeId;
+export declare class Next<A> {
+    readonly value: A;
+    readonly _tag = "Next";
+    readonly [NextTypeId]: NextTypeId;
+    constructor(value: A);
+}
+export declare const FailTypeId: unique symbol;
+export declare type FailTypeId = typeof FailTypeId;
+export declare class Fail<E> {
+    readonly error: Cause<E>;
+    readonly _tag = "Fail";
+    readonly [FailTypeId]: FailTypeId;
+    constructor(error: Cause<E>);
+}
+export declare const CompleteTypeId: unique symbol;
+export declare type CompleteTypeId = typeof CompleteTypeId;
+export declare class Complete {
+    readonly _tag = "Complete";
+    readonly [CompleteTypeId]: CompleteTypeId;
+}
+/**
+ * @tsplus type fncts.observable.Notification
+ */
+export declare type Notification<E, A> = Next<A> | Fail<E> | Complete;
+/**
+ * @tsplus type fncts.observable.NotificationOps
+ */
+export interface NotificationOps {
+}
+export declare const Notification: NotificationOps;
+/**
+ * @tsplus static fncts.observable.NotificationOps next
+ * @tsplus location "@fncts/observable/Notification"
+ */
+export declare function next<E = never, A = never>(value: A): Notification<E, A>;
+/**
+ * @tsplus static fncts.observable.NotificationOps error
+ * @tsplus location "@fncts/observable/Notification"
+ */
+export declare function error<E = never, A = never>(error: Cause<E>): Notification<E, A>;
+/**
+ * @tsplus static fncts.observable.NotificationOps complete
+ * @tsplus location "@fncts/observable/Notification"
+ */
+export declare function complete<E = never, A = never>(): Notification<E, A>;
+/**
+ * @tsplus fluent fncts.observable.Notification match
+ * @tsplus location "@fncts/observable/Notification"
+ */
+export declare function match_<E, A, B, C, D, F>(fa: Notification<E, A>, onNext: (a: A) => B, onFail: (e: Cause<E>) => C, onComplete: () => F): B | C | D | F;
+/**
+ * @tsplus fluent fncts.observable.Notification observe
+ * @tsplus location "@fncts/observable/Notification"
+ */
+export declare function observe_<E, A>(notification: Notification<E, A>, observer: Partial<Observer<E, A>>): void;

package/Observable/api/connect.d.ts

@@ -0,0 +1,10 @@
+import { SubjectLike } from "@fncts/observable/Subject";
+import { Observable, ObservableInput } from "@fncts/observable/Observable";
+export interface ConnectConfig<E, A> {
+    readonly connector: () => SubjectLike<E, A>;
+}
+/**
+ * @tsplus fluent fncts.observable.Observable connect
+ * @tsplus location "@fncts/observable/Observable/api/connect"
+ */
+export declare function connect<E, A, E1, B>(fa: Observable<E, A>, selector: (shared: Observable<E, A>) => ObservableInput<E1, B>, config?: ConnectConfig<E, A>): Observable<E | E1, B>;

package/Observable/api/connectable.d.ts

@@ -0,0 +1,24 @@
+import { Observable, ObservableInput } from "@fncts/observable/Observable";
+import { Subscription } from "@fncts/observable/Subscription";
+import { SubjectLike } from "@fncts/observable/Subject";
+export interface ConnectableLike<E, A> extends Observable<E, A> {
+    connect(): Subscription;
+}
+export interface ConnectableConfig<E, A> {
+    readonly connector: () => SubjectLike<E, A>;
+    readonly resetOnDisconnect?: boolean;
+}
+export declare class Connectable<E, A> extends Observable<E, A> implements ConnectableLike<E, A> {
+    protected connection: Subscription | null;
+    protected connector: () => SubjectLike<E, A>;
+    protected resetOnDisconnect: boolean;
+    protected source: Observable<E, A>;
+    protected subject: SubjectLike<E, A>;
+    constructor(source: ObservableInput<E, A>, config: ConnectableConfig<E, A>);
+    connect(): import("../../Subscription").Subscription;
+}
+/**
+ * @tsplus fluent fncts.observable.Observable connectable
+ * @tsplus location "@fncts/observable/Observable/api/connectable"
+ */
+export declare function connectable<E, A>(source: ObservableInput<E, A>, config?: ConnectableConfig<E, A>): Connectable<E, A>;

package/Observable/api/fromCallback.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from "@fncts/observable/Observable";
+/**
+ * @tsplus static fncts.observable.ObservableOps fromCallback
+ * @tsplus location "@fncts/observable/Observable/api/fromCallback"
+ */
+export declare function fromCallback<A extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown>>(callbackFunc: (...args: [...A, (...res: R) => void]) => void): (...args: A) => Observable<unknown, R>;
+/**
+ * @tsplus static fncts.observable.ObservableOps fromNodeCallback
+ * @tsplus location "@fncts/observable/Observable/api/fromCallback"
+ */
+export declare function fromNodeCallback<E, A extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown>>(callbackFunc: (...args: [...A, (err: E, ...res: R) => void]) => void): (...args: A) => Observable<Exclude<E, null | undefined>, R extends [] ? void : R extends [any] ? R[0] : R>;

package/Observable/api/fromEvent.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from "@fncts/observable/Observable";
+declare type EventHandler = (...args: any[]) => void;
+export declare function fromEvent<A extends ReadonlyArray<unknown>>(addHandler: (handler: (...args: A) => void) => any, removeHandler?: (handler: EventHandler, signal?: any) => void): Observable<never, A extends [infer X] ? X : A>;
+export {};

package/Observable/api/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./connect.js";
+export * from "./connectable.js";
+export * from "./fromCallback.js";
+export * from "./fromEvent.js";
+export * from "./race.js";
+export * from "./raceWith.js";
+export * from "./repeatWhen.js";
+export * from "./retryWhen.js";
+export * from "./share.js";
+export * from "./window.js";
+export * from "./windowCount.js";
+export * from "./windowTime.js";
+export * from "./windowToggle.js";
+export * from "./windowWhen.js";

package/Observable/api/race.d.ts

@@ -0,0 +1,9 @@
+import { ObservableInput, Observable } from "@fncts/observable/Observable";
+import { Subscriber } from "@fncts/observable/Subscriber";
+import { Subscription } from "@fncts/observable/Subscription";
+/**
+ * @tsplus static fncts.observable.ObservableOps race
+ * @tsplus location "@fncts/observable/Observable/api/race"
+ */
+export declare function race<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: O): Observable<Observable.ErrorOf<O[number]>, Observable.TypeOf<O[number]>>;
+export declare function raceInit<E, A>(sources: ReadonlyArray<ObservableInput<E, A>>): (subscriber: Subscriber<E, A>) => void;

package/Observable/api/raceWith.d.ts

@@ -0,0 +1,6 @@
+import { ObservableInput, Observable } from "@fncts/observable/Observable";
+/**
+ * @tsplus fluent fncts.observable.Observablen raceWith
+ * @tsplus location "@fncts/observable/Observable/api/raceWith"
+ */
+export declare function raceWith_<E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(fa: Observable<E, A>, ...sources: O): Observable<E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>>;

package/Observable/api/repeatWhen.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from "@fncts/observable/Observable";
+import { Subscription } from "@fncts/observable/Subscription";
+import { Subject } from "@fncts/observable/Subject";
+export declare function repeatWhen_<E, A, E1>(fa: Observable<E, A>, notifier: (notifications: Observable<never, void>) => Observable<E1, any>): Observable<E | E1, A>;
+export declare function repeatWhen<E1>(notifier: (notifications: Observable<never, void>) => Observable<E1, any>): <E, A>(fa: Observable<E, A>) => Observable<E | E1, A>;

package/Observable/api/retryWhen.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from "@fncts/observable/Observable";
+import { Cause } from "@fncts/base/data/Cause";
+import { Subscription } from "@fncts/observable/Subscription";
+import { Subject } from "@fncts/observable/Subject";
+/**
+ * @tsplus fluent fncts.observable.Observable retryWhen
+ * @tsplus location "@fncts/observable/Observable/api/retryWhen"
+ */
+export declare function retryWhen_<E, A, E1>(fa: Observable<E, A>, notifier: (errors: Observable<never, Cause<E>>) => Observable<E1, any>): Observable<E | E1, A>;
+export declare function retryWhen<E1>(notifier: (errors: Observable<never, any>) => Observable<E1, any>): <E, A>(fa: Observable<E, A>) => Observable<E | E1, A>;

package/Observable/api/share.d.ts

@@ -0,0 +1,16 @@
+import { SubjectLike } from "@fncts/observable/Subject";
+import { Observable } from "@fncts/observable/Observable";
+import { SafeSubscriber } from "@fncts/observable/Subscriber";
+import { Subscription } from "@fncts/observable/Subscription";
+export interface ShareConfig<E, A, E1 = never, E2 = never, E3 = never> {
+    readonly connector?: () => SubjectLike<E, A>;
+    readonly resetOnDefect?: boolean | ((err: unknown) => Observable<E1, any>);
+    readonly resetOnComplete?: boolean | (() => Observable<E2, any>);
+    readonly resetOnRefCountZero?: boolean | (() => Observable<E3, any>);
+}
+/**
+ * @tsplus fluent fncts.observable.Observable share
+ * @tsplus location "@fncts/observable/Observable/api/share"
+ */
+export declare function share_<E, A, E1 = never, E2 = never, E3 = never>(fa: Observable<E, A>, options?: ShareConfig<E, A, E1, E2, E3>): Observable<E | E1 | E2 | E3, A>;
+export declare function share<E, A, E1, E2, E3>(options?: ShareConfig<E, A, E1, E2, E3>): (fa: Observable<E, A>) => Observable<E | E1 | E2 | E3, A>;

package/Observable/api/window.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "@fncts/observable/Observable";
+import { Subject } from "@fncts/observable/Subject";
+import { Cause } from "@fncts/base/data/Cause";
+/**
+ * @tsplus fluent fncts.observable.Observable window
+ * @tsplus location "@fncts/observable/Observable/api/window"
+ */
+export declare function window_<E, A>(fa: Observable<E, A>, windowBoundaries: Observable<never, any>): Observable<E, Observable<E, A>>;

package/Observable/api/windowCount.d.ts

@@ -0,0 +1,6 @@
+import { Observable } from "@fncts/observable/Observable";
+/**
+ * @tsplus fluent fncts.observable.Observable windowCount
+ * @tsplus location "@fncts/observable/Observable/api/windowCount"
+ */
+export declare function windowCount_<E, A>(fa: Observable<E, A>, windowSize: number, startWindowEvery?: number): Observable<E, Observable<E, A>>;

package/Observable/api/windowTime.d.ts

@@ -0,0 +1,12 @@
+import { Subject } from "@fncts/observable/Subject";
+import { Subscription } from "@fncts/observable/Subscription";
+import { Observable } from "@fncts/observable/Observable";
+import { SchedulerLike } from "@fncts/observable/Scheduler";
+import { Observer } from "@fncts/observable/Observer";
+/**
+ * @tsplus fluent fncts.observable.Observable windowTime
+ * @tsplus location "@fncts/observable/Observable/api/windowTime"
+ */
+export declare function windowTime_<E, A>(fa: Observable<E, A>, windowTimeSpan: number, scheduler?: SchedulerLike): Observable<E, Observable<E, A>>;
+export declare function windowTime_<E, A>(fa: Observable<E, A>, windowTimeSpan: number, windowCreationInterval: number, scheduler?: SchedulerLike): Observable<E, Observable<E, A>>;
+export declare function windowTime_<E, A>(fa: Observable<E, A>, windowTimeSpan: number, windowCreationInterval: number, maxWindowSize: number, scheduler?: SchedulerLike): Observable<E, Observable<E, A>>;

package/Observable/api/windowToggle.d.ts

@@ -0,0 +1,8 @@
+import { Observable, ObservableInput } from "@fncts/observable/Observable";
+import { Subject } from "@fncts/observable/Subject";
+import { Cause } from "@fncts/base/data/Cause";
+/**
+ * @tsplus fluent fncts.observable.Observable windowToggle
+ * @tsplus location "@fncts/observable/Observable/api/windowToggle"
+ */
+export declare function windowToggle_<E, A, E1, B, E2>(fa: Observable<E, A>, openings: ObservableInput<E1, B>, closingSelector: (openValue: B) => ObservableInput<E2, any>): Observable<E | E1 | E2, Observable<E, A>>;

package/Observable/api/windowWhen.d.ts

@@ -0,0 +1,9 @@
+import { Observable, ObservableInput } from "@fncts/observable/Observable";
+import { Subject } from "@fncts/observable/Subject";
+import { Subscriber } from "@fncts/observable/Subscriber";
+import { Cause } from "@fncts/base/data/Cause";
+/**
+ * @tsplus fluent fncts.observable.Observable windowWhen
+ * @tsplus location "@fncts/observable/Observable/api/windowWhen"
+ */
+export declare function windowWhen_<E, A>(fa: Observable<E, A>, closingSelector: () => ObservableInput<never, any>): Observable<E, Observable<E, A>>;