@fncts/observable 0.0.1 → 0.0.4

package/_src/Observable/api/fromCallback.ts

@@ -3,7 +3,7 @@
  */
 export function fromCallback<A extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown>>(
   callbackFunc: (...args: [...A, (...res: R) => void]) => void,
-): (...args: A) => Observable<unknown, R> {
+): (...args: A) => Observable<never, unknown, R> {
   // @ts-expect-error
   return fromCallbackInternal(false, callbackFunc);
 }
@@ -13,14 +13,17 @@ export function fromCallback<A extends ReadonlyArray<unknown>, R extends Readonl
  */
 export 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> {
+): (...args: A) => Observable<never, Exclude<E, null | undefined>, R extends [] ? void : R extends [any] ? R[0] : R> {
   // @ts-expect-error
   return fromCallbackInternal(true, callbackFunc);
 }
 
-function fromCallbackInternal(isNodeStyle: boolean, callbackFunc: any): (...args: any[]) => Observable<unknown, any> {
-  return function (this: any, ...args: any[]): Observable<unknown, any> {
-    const subject     = new AsyncSubject<any, any>();
+function fromCallbackInternal(
+  isNodeStyle: boolean,
+  callbackFunc: any,
+): (...args: any[]) => Observable<never, unknown, any> {
+  return function (this: any, ...args: any[]): Observable<never, unknown, any> {
+    const subject     = new AsyncSubject<never, any, any>();
     let uninitialized = true;
     return new Observable((subscriber) => {
       const subs = subject.subscribe(subscriber);

package/_src/Observable/api/fromEvent.ts

@@ -3,7 +3,7 @@ type EventHandler = (...args: any[]) => void;
 export 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> {
+): Observable<never, never, A extends [infer X] ? X : A> {
   return new Observable((subscriber) => {
     const handler  = (...e: any[]) => subscriber.next(e.length === 1 ? e[0] : e);
     const retValue = addHandler(handler as any);

package/_src/Observable/api/race.ts

@@ -3,11 +3,11 @@
  */
 export function race<O extends ReadonlyArray<ObservableInput<any, any>>>(
   ...sources: O
-): Observable<Observable.ErrorOf<O[number]>, Observable.TypeOf<O[number]>> {
+): Observable<Observable.EnvironmentOf<O[number]>, Observable.ErrorOf<O[number]>, Observable.TypeOf<O[number]>> {
   return sources.length === 1 ? Observable.from(sources[0]!) : new Observable(raceInit(sources));
 }
 
-export function raceInit<E, A>(sources: ReadonlyArray<ObservableInput<E, A>>) {
+export function raceInit<R, E, A>(sources: ReadonlyArray<ObservableInput<R, E, A>>) {
   return (subscriber: Subscriber<E, A>) => {
     let subscriptions: Subscription[] = [];
     for (let i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) {

package/_src/Observable/api/raceWith.ts

@@ -3,10 +3,14 @@ import { raceInit } from "./race.js";
 /**
  * @tsplus fluent fncts.observable.Observablen raceWith
  */
-export function raceWith_<E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(
-  fa: Observable<E, A>,
+export function raceWith_<R, E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(
+  fa: Observable<R, E, A>,
   ...sources: O
-): Observable<E | Observable.ErrorOf<O[number]>, A | Observable.TypeOf<O[number]>> {
+): Observable<
+  R | Observable.EnvironmentOf<O[number]>,
+  E | Observable.ErrorOf<O[number]>,
+  A | Observable.TypeOf<O[number]>
+> {
   return !sources.length
     ? fa
     : fa.operate((source, subscriber) => {

package/_src/Observable/api/repeatWhen.ts

@@ -1,11 +1,11 @@
-export function repeatWhen_<E, A, E1>(
-  fa: Observable<E, A>,
-  notifier: (notifications: Observable<never, void>) => Observable<E1, any>,
-): Observable<E | E1, A> {
+export 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> {
   return fa.operate((source, subscriber) => {
     let innerSub: Subscription | null;
     let syncResub = false;
-    let completions$: Subject<never, void>;
+    let completions$: Subject<never, never, void>;
     let isNotifierComplete = false;
     let isMainComplete     = false;
 
@@ -56,8 +56,8 @@ export function repeatWhen_<E, A, E1>(
   });
 }
 
-export function repeatWhen<E1>(
-  notifier: (notifications: Observable<never, void>) => Observable<E1, any>,
-): <E, A>(fa: Observable<E, A>) => Observable<E | E1, A> {
+export 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> {
   return (fa) => repeatWhen_(fa, notifier);
 }

package/_src/Observable/api/retryWhen.ts

@@ -1,14 +1,14 @@
 /**
  * @tsplus fluent fncts.observable.Observable retryWhen
  */
-export function retryWhen_<E, A, E1>(
-  fa: Observable<E, A>,
-  notifier: (errors: Observable<never, Cause<E>>) => Observable<E1, any>,
-): Observable<E | E1, A> {
+export 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> {
   return operate_(fa, (source, subscriber) => {
     let innerSub: Subscription | null;
     let syncResub = false;
-    let defects$: Subject<never, any>;
+    let defects$: Subject<never, never, any>;
 
     const loop = () => {
       innerSub = source.subscribe(
@@ -40,8 +40,8 @@ export function retryWhen_<E, A, E1>(
   });
 }
 
-export function retryWhen<E1>(
-  notifier: (errors: Observable<never, any>) => Observable<E1, any>,
-): <E, A>(fa: Observable<E, A>) => Observable<E | E1, A> {
+export 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> {
   return (fa) => retryWhen_(fa, notifier);
 }

package/_src/Observable/api/share.ts

@@ -1,19 +1,19 @@
-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
  */
-export 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 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> {
   const {
-    connector = () => new Subject<E, A>(),
+    connector = () => new Subject<R, E, A>(),
     resetOnDefect = true,
     resetOnComplete = true,
     resetOnRefCountZero = true,
@@ -81,15 +81,9 @@ export function share_<E, A, E1 = never, E2 = never, E3 = never>(
   });
 }
 
-export function share<E, A, E1, E2, E3>(
-  options: ShareConfig<E, A, E1, E2, E3> = {},
-): (fa: Observable<E, A>) => Observable<E | E1 | E2 | E3, A> {
-  return (fa) => share_(fa, options);
-}
-
 function handleReset<T extends unknown[] = never[]>(
   reset: () => void,
-  on: boolean | ((...args: T) => Observable<any, any>),
+  on: boolean | ((...args: T) => Observable<any, any, any>),
   ...args: T
 ): Subscription | null {
   if (on === true) {

package/_src/Observable/api/window.ts

@@ -1,12 +1,12 @@
 /**
  * @tsplus fluent fncts.observable.Observable window
  */
-export function window_<E, A>(
-  fa: Observable<E, A>,
-  windowBoundaries: Observable<never, any>,
-): Observable<E, Observable<E, A>> {
+export function window_<R, E, A>(
+  fa: Observable<R, E, A>,
+  windowBoundaries: Observable<never, never, any>,
+): Observable<R, E, Observable<never, E, A>> {
   return operate_(fa, (source, subscriber) => {
-    let windowSubject: Subject<E, A> = new Subject();
+    let windowSubject: Subject<never, E, A> = new Subject();
     subscriber.next(windowSubject.asObservable());
 
     const errorHandler = (err: Cause<E>) => {

package/_src/Observable/api/windowCount.ts

@@ -1,15 +1,15 @@
 /**
  * @tsplus fluent fncts.observable.Observable windowCount
  */
-export function windowCount_<E, A>(
-  fa: Observable<E, A>,
+export function windowCount_<R, E, A>(
+  fa: Observable<R, E, A>,
   windowSize: number,
   startWindowEvery = 0,
-): Observable<E, Observable<E, A>> {
+): Observable<R, E, Observable<never, E, A>> {
   const startEvery = startWindowEvery > 0 ? startWindowEvery : windowSize;
 
   return operate_(fa, (source, subscriber) => {
-    let windows = [new Subject<E, A>()];
+    let windows = [new Subject<never, E, A>()];
     let count   = 0;
 
     subscriber.next(windows[0]!.asObservable());
@@ -29,7 +29,7 @@ export function windowCount_<E, A>(
             }
 
             if (++count && startEvery === 0) {
-              const window = new Subject<E, A>();
+              const window = new Subject<never, E, A>();
               windows.push(window);
               subscriber.next(window.asObservable());
             }

package/_src/Observable/api/windowTime.ts

@@ -1,46 +1,46 @@
 import { popScheduler } from "@fncts/observable/internal/args";
 import { arrayRemove } from "@fncts/observable/internal/util";
 
-interface WindowRecord<E, A> {
+interface WindowRecord<R, E, A> {
   seen: number;
-  window: Subject<E, A>;
+  window: Subject<R, E, A>;
   subs: Subscription;
 }
 
 /**
  * @tsplus fluent fncts.observable.Observable windowTime
  */
-export function windowTime_<E, A>(
-  fa: Observable<E, A>,
+export function windowTime_<R, E, A>(
+  fa: Observable<R, E, A>,
   windowTimeSpan: number,
   scheduler?: SchedulerLike,
-): Observable<E, Observable<E, A>>;
-export function windowTime_<E, A>(
-  fa: Observable<E, A>,
+): Observable<R, E, Observable<never, E, A>>;
+export function windowTime_<R, E, A>(
+  fa: Observable<R, E, A>,
   windowTimeSpan: number,
   windowCreationInterval: number,
   scheduler?: SchedulerLike,
-): Observable<E, Observable<E, A>>;
-export function windowTime_<E, A>(
-  fa: Observable<E, A>,
+): Observable<R, E, Observable<never, E, A>>;
+export function windowTime_<R, E, A>(
+  fa: Observable<R, E, A>,
   windowTimeSpan: number,
   windowCreationInterval: number,
   maxWindowSize: number,
   scheduler?: SchedulerLike,
-): Observable<E, Observable<E, A>>;
-export function windowTime_<E, A>(
-  fa: Observable<E, A>,
+): Observable<R, E, Observable<never, E, A>>;
+export function windowTime_<R, E, A>(
+  fa: Observable<R, E, A>,
   windowTimeSpan: number,
   ...args: any[]
-): Observable<E, Observable<E, A>> {
+): Observable<R, E, Observable<never, E, A>> {
   const scheduler = popScheduler(args) ?? asyncScheduler;
   const windowCreationInterval: number | null = args[0] ?? null;
   const maxWindowSize: number                 = args[1] || Infinity;
 
   return operate_(fa, (source, subscriber) => {
-    let windowRecords: WindowRecord<E, A>[] | null = [];
+    let windowRecords: WindowRecord<never, E, A>[] | null = [];
     let restartOnClose = false;
-    const closeWindow  = (record: { window: Subject<E, A>; subs: Subscription }) => {
+    const closeWindow  = (record: { window: Subject<never, E, A>; subs: Subscription }) => {
       const { window, subs } = record;
       window.complete();
       subs.unsubscribe();
@@ -51,7 +51,7 @@ export function windowTime_<E, A>(
       if (windowRecords) {
         const subs = new Subscription();
         subscriber.add(subs);
-        const window = new Subject<E, A>();
+        const window = new Subject<never, E, A>();
         const record = {
           window,
           subs,
@@ -74,7 +74,7 @@ export function windowTime_<E, A>(
 
     startWindow();
 
-    const loop = (cb: (record: WindowRecord<E, A>) => void) => windowRecords!.slice().forEach(cb);
+    const loop = (cb: (record: WindowRecord<never, E, A>) => void) => windowRecords!.slice().forEach(cb);
 
     const terminate = (cb: (consumer: Observer<E, any>) => void) => {
       loop(({ window }) => cb(window));

package/_src/Observable/api/windowToggle.ts

@@ -3,13 +3,13 @@ import { arrayRemove } from "@fncts/observable/internal/util";
 /**
  * @tsplus fluent fncts.observable.Observable windowToggle
  */
-export 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 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>> {
   return operate_(fa, (source, subscriber) => {
-    const windows: Subject<E, A>[] = [];
+    const windows: Subject<never, E, A>[] = [];
 
     const handleError = (err: Cause<E>) => {
       while (0 < windows.length) {
@@ -21,7 +21,7 @@ export function windowToggle_<E, A, E1, B, E2>(
     Observable.from(openings).subscribe(
       operatorSubscriber(subscriber, {
         next: (openValue) => {
-          const window = new Subject<E, A>();
+          const window = new Subject<never, E, A>();
           windows.push(window);
           const closingSubscription = new Subscription();
           const closeWindow         = () => {
@@ -30,7 +30,7 @@ export function windowToggle_<E, A, E1, B, E2>(
             closingSubscription.unsubscribe();
           };
 
-          let closingNotifier: Observable<E2, any>;
+          let closingNotifier: Observable<R2, E2, any>;
 
           try {
             closingNotifier = Observable.from(closingSelector(openValue));

package/_src/Observable/api/windowWhen.ts

@@ -1,12 +1,12 @@
 /**
  * @tsplus fluent fncts.observable.Observable windowWhen
  */
-export function windowWhen_<E, A>(
-  fa: Observable<E, A>,
-  closingSelector: () => ObservableInput<never, any>,
-): Observable<E, Observable<E, A>> {
+export function windowWhen_<R, E, A>(
+  fa: Observable<R, E, A>,
+  closingSelector: () => ObservableInput<never, never, any>,
+): Observable<R, E, Observable<never, E, A>> {
   return operate_(fa, (source, subscriber) => {
-    let window: Subject<E, A> | null;
+    let window: Subject<never, E, A> | null;
     let closingSubscriber: Subscriber<E, any> | undefined;
 
     const handleError = (err: Cause<E>) => {
@@ -19,7 +19,7 @@ export function windowWhen_<E, A>(
       window?.complete();
       window = new Subject();
       subscriber.next(window.asObservable());
-      let closingNotifier: Observable<never, any>;
+      let closingNotifier: Observable<never, never, any>;
       try {
         closingNotifier = Observable.from(closingSelector());
       } catch (err) {