@fncts/observable 0.0.2 → 0.0.3

package/BehaviorSubject.d.ts

@@ -1,6 +1,6 @@
 import { Subject } from "@fncts/observable/Subject";
 import { Subscriber } from "@fncts/observable/Subscriber";
-export declare class BehaviorSubject<E, A> extends Subject<E, A> {
+export declare class BehaviorSubject<R, E, A> extends Subject<R, E, A> {
     private _value;
     constructor(_value: A);
     get value(): A;

package/Notification.d.ts

@@ -1,4 +1,4 @@
-import { Cause } from "@fncts/base/data/Cause";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import { Observer } from "@fncts/observable/Observer";
 export declare const NextTypeId: unique symbol;
 export declare type NextTypeId = typeof NextTypeId;

package/Observable/api/connect.d.ts

@@ -7,4 +7,4 @@ export interface ConnectConfig<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>;
+export declare function connect<R, E, A, R1, E1, B>(fa: Observable<R, E, A>, selector: (shared: Observable<R, E, A>) => ObservableInput<R1, E1, B>, config?: ConnectConfig<E, A>): Observable<R | R1, E | E1, B>;

package/Observable/api/connectable.d.ts

@@ -1,24 +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> {
+export interface ConnectableLike<R, E, A> extends Observable<R, 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> {
+export declare class Connectable<R, E, A> extends Observable<R, E, A> implements ConnectableLike<R, E, A> {
     protected connection: Subscription | null;
     protected connector: () => SubjectLike<E, A>;
     protected resetOnDisconnect: boolean;
-    protected source: Observable<E, A>;
+    protected source: Observable<R, E, A>;
     protected subject: SubjectLike<E, A>;
-    constructor(source: ObservableInput<E, A>, config: ConnectableConfig<E, A>);
+    constructor(source: ObservableInput<R, 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>;
+export declare function connectable<R, E, A>(source: ObservableInput<R, E, A>, config?: ConnectableConfig<E, A>): Connectable<R, E, A>;

package/Observable/api/fromCallback.d.ts

@@ -3,9 +3,9 @@ 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>;
+export declare function fromCallback<A extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown>>(callbackFunc: (...args: [...A, (...res: R) => void]) => void): (...args: A) => Observable<never, 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>;
+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<never, Exclude<E, null | undefined>, R extends [] ? void : R extends [any] ? R[0] : R>;

package/Observable/api/fromEvent.d.ts

@@ -1,4 +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 declare function fromEvent<A extends ReadonlyArray<unknown>>(addHandler: (handler: (...args: A) => void) => any, removeHandler?: (handler: EventHandler, signal?: any) => void): Observable<never, never, A extends [infer X] ? X : A>;
 export {};

package/Observable/api/race.d.ts

@@ -5,5 +5,5 @@ 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;
+export declare function race<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: O): Observable<Observable.EnvironmentOf<O[number]>, Observable.ErrorOf<O[number]>, Observable.TypeOf<O[number]>>;
+export declare function raceInit<R, E, A>(sources: ReadonlyArray<ObservableInput<R, E, A>>): (subscriber: Subscriber<E, A>) => void;

package/Observable/api/raceWith.d.ts

@@ -3,4 +3,4 @@ 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]>>;
+export declare function raceWith_<R, E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(fa: Observable<R, E, A>, ...sources: O): Observable<R | Observable.EnvironmentOf<O[number]>, E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>>;

package/Observable/api/repeatWhen.d.ts

@@ -1,5 +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>;
+export declare function repeatWhen_<R, E, A, R1, E1>(fa: Observable<R, E, A>, notifier: (notifications: Observable<never, never, void>) => Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function repeatWhen<R1, E1>(notifier: (notifications: Observable<never, never, void>) => Observable<R1, E1, any>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R | R1, E | E1, A>;

package/Observable/api/retryWhen.d.ts

@@ -1,10 +1,10 @@
 import { Observable } from "@fncts/observable/Observable";
-import { Cause } from "@fncts/base/data/Cause";
+import { Cause } from "@fncts/base/data/Cause/definition";
 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>;
+export declare function retryWhen_<R, E, A, R1, E1>(fa: Observable<R, E, A>, notifier: (errors: Observable<never, never, Cause<E>>) => Observable<R1, E1, any>): Observable<R | R1, E | E1, A>;
+export declare function retryWhen<R1, E1>(notifier: (errors: Observable<never, never, any>) => Observable<R1, E1, any>): <R, E, A>(fa: Observable<R, E, A>) => Observable<R | R1, E | E1, A>;

package/Observable/api/share.d.ts

@@ -2,15 +2,14 @@ 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> {
+export interface ShareConfig<R, E, A, R1 = never, E1 = never, R2 = never, E2 = never, R3 = 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>);
+    readonly resetOnDefect?: boolean | ((err: unknown) => Observable<R1, E1, any>);
+    readonly resetOnComplete?: boolean | (() => Observable<R2, E2, any>);
+    readonly resetOnRefCountZero?: boolean | (() => Observable<R3, 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>;
+export declare function share_<R, E, A, R1 = never, E1 = never, R2 = never, E2 = never, R3 = never, E3 = never>(fa: Observable<R, E, A>, options?: ShareConfig<R, E, A, R1, E1, R2, E2, R3, E3>): Observable<R | R1 | R2, E | E1 | E2 | E3, A>;

package/Observable/api/window.d.ts

@@ -1,8 +1,8 @@
 import { Observable } from "@fncts/observable/Observable";
 import { Subject } from "@fncts/observable/Subject";
-import { Cause } from "@fncts/base/data/Cause";
+import { Cause } from "@fncts/base/data/Cause/definition";
 /**
  * @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>>;
+export declare function window_<R, E, A>(fa: Observable<R, E, A>, windowBoundaries: Observable<never, never, any>): Observable<R, E, Observable<never, E, A>>;

package/Observable/api/windowCount.d.ts

@@ -3,4 +3,4 @@ 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>>;
+export declare function windowCount_<R, E, A>(fa: Observable<R, E, A>, windowSize: number, startWindowEvery?: number): Observable<R, E, Observable<never, E, A>>;

package/Observable/api/windowTime.d.ts

@@ -7,6 +7,6 @@ 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>>;
+export declare function windowTime_<R, E, A>(fa: Observable<R, E, A>, windowTimeSpan: number, scheduler?: SchedulerLike): Observable<R, E, Observable<never, E, A>>;
+export declare function windowTime_<R, E, A>(fa: Observable<R, E, A>, windowTimeSpan: number, windowCreationInterval: number, scheduler?: SchedulerLike): Observable<R, E, Observable<never, E, A>>;
+export declare function windowTime_<R, E, A>(fa: Observable<R, E, A>, windowTimeSpan: number, windowCreationInterval: number, maxWindowSize: number, scheduler?: SchedulerLike): Observable<R, E, Observable<never, E, A>>;

package/Observable/api/windowToggle.d.ts

@@ -1,8 +1,8 @@
 import { Observable, ObservableInput } from "@fncts/observable/Observable";
 import { Subject } from "@fncts/observable/Subject";
-import { Cause } from "@fncts/base/data/Cause";
+import { Cause } from "@fncts/base/data/Cause/definition";
 /**
  * @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>>;
+export declare function windowToggle_<R, E, A, R1, E1, B, R2, E2>(fa: Observable<R, E, A>, openings: ObservableInput<R1, E1, B>, closingSelector: (openValue: B) => ObservableInput<R2, E2, any>): Observable<R | R1 | R2, E | E1 | E2, Observable<never, E, A>>;

package/Observable/api/windowWhen.d.ts

@@ -1,9 +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";
+import { Cause } from "@fncts/base/data/Cause/definition";
 /**
  * @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>>;
+export declare function windowWhen_<R, E, A>(fa: Observable<R, E, A>, closingSelector: () => ObservableInput<never, never, any>): Observable<R, E, Observable<never, E, A>>;