@fncts/observable 0.0.26 → 0.0.28

package/_src/Observable/api/race.ts

@@ -10,7 +10,7 @@ export function race<O extends ReadonlyArray<ObservableInput<any, any>>>(
 export function raceInit<R, E, A>(sources: ReadonlyArray<ObservableInput<R, E, A>>) {
   return (subscriber: Subscriber<E, A>, environment: Environment<R>) => {
     let subscriptions: Subscription[] = [];
-    for (let i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) {
+    for (let i = 0; subscriptions && !subscriber._closed && i < sources.length; i++) {
       subscriptions.push(
         Observable.from(sources[i]!)
           .provideEnvironment(environment)

package/_src/Observable/api/raceWith.ts

@@ -11,10 +11,7 @@ export function raceWith<O extends ReadonlyArray<ObservableInput<any, any>>>(...
     E | Observable.ErrorOf<O[number]>,
     A | Observable.TypeOf<O[number]>
   > => {
-    return !sources.length
-      ? fa
-      : fa.operate((source, subscriber, environment) => {
-          raceInit([source, ...sources])(subscriber as Subscriber<any, any>, environment);
-        });
+    // @ts-expect-error
+    return !sources.length ? fa : new Observable(raceInit([fa, ...sources]));
   };
 }

package/_src/Observable/api/repeatWhen.ts

@@ -1,11 +1,11 @@
 /**
  * @tsplus pipeable fncts.observable.Observable repeatWhen
  */
-export function repeatWhen<R, E, A, R1, E1>(
+export function repeatWhen<R1, E1>(
   notifier: (notifications: Observable<never, never, void>) => Observable<R1, E1, any>,
 ) {
   return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
-    return fa.operate((source, subscriber, environment) => {
+    return new Observable((subscriber, environment) => {
       let innerSub: Subscription | null;
       let syncResub = false;
       let completions$: Subject<never, never, void>;
@@ -37,8 +37,8 @@ export function repeatWhen<R, E, A, R1, E1>(
       };
       const loop = () => {
         isMainComplete = false;
-        innerSub       = source.provideEnvironment(environment).subscribe(
-          operatorSubscriber(subscriber, {
+        innerSub       = fa.provideEnvironment(environment).subscribe(
+          subscriber.operate({
             complete: () => {
               isMainComplete = true;
               !checkComplete() && getCompletionSubject().next();

package/_src/Observable/api/retryWhen.ts

@@ -5,13 +5,13 @@ export function retryWhen<E, R1, E1>(
   notifier: (errors: Observable<never, never, Cause<E>>) => Observable<R1, E1, any>,
 ) {
   return <R, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
-    return fa.operate((source, subscriber, environment) => {
+    return new Observable((subscriber, environment) => {
       let innerSub: Subscription | null;
       let syncResub = false;
       let defects$: Subject<never, never, any>;
       const loop    = () => {
-        innerSub = source.provideEnvironment(environment).subscribe(
-          operatorSubscriber(subscriber, {
+        innerSub = fa.provideEnvironment(environment).subscribe(
+          subscriber.operate({
             error: (err) => {
               if (!defects$) {
                 defects$ = new Subject();

package/_src/Observable/api/share.ts

@@ -18,9 +18,9 @@ export function share<R, E, A, R1 = never, E1 = never, R2 = never, E2 = never, R
       resetOnComplete = true,
       resetOnRefCountZero = true,
     } = options;
-    let connection: SafeSubscriber<E, A> | null = null;
-    let resetConnection: Subscription | null    = null;
-    let subject: Subject<R, E, A> | null        = null;
+    let connection: Subscriber<E, A> | null  = null;
+    let resetConnection: Subscription | null = null;
+    let subject: Subject<R, E, A> | null     = null;
     let refCount      = 0;
     let hasCompleted  = false;
     let hasErrored    = false;
@@ -38,7 +38,7 @@ export function share<R, E, A, R1 = never, E1 = never, R2 = never, E2 = never, R
       reset();
       conn?.unsubscribe();
     };
-    return fa.operate((source, subscriber, environment) => {
+    return new Observable((subscriber, environment) => {
       refCount++;
       if (!hasErrored && !hasCompleted) {
         cancelReset();
@@ -52,7 +52,7 @@ export function share<R, E, A, R1 = never, E1 = never, R2 = never, E2 = never, R
       });
       dest.provideEnvironment(environment).subscribe(subscriber);
       if (!connection) {
-        connection = new SafeSubscriber({
+        connection = new Subscriber({
           next: (value) => dest.next(value),
           error: (defect) => {
             hasErrored = true;
@@ -67,7 +67,7 @@ export function share<R, E, A, R1 = never, E1 = never, R2 = never, E2 = never, R
             dest.complete();
           },
         });
-        Observable.from(source).provideEnvironment(environment).subscribe(connection);
+        Observable.from(fa).provideEnvironment(environment).subscribe(connection);
       }
     });
   };

package/_src/Observable/api/window.ts

@@ -3,15 +3,15 @@
  */
 export function window(windowBoundaries: Observable<never, never, any>) {
   return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, Observable<never, E, A>> => {
-    return fa.operate((source, subscriber, environment) => {
+    return new Observable((subscriber, environment) => {
       let windowSubject: Subject<never, E, A> = new Subject();
       subscriber.next(windowSubject.asObservable());
       const errorHandler = (err: Cause<E>) => {
         windowSubject.error(err);
         subscriber.error(err);
       };
-      source.provideEnvironment(environment).subscribe(
-        operatorSubscriber(subscriber, {
+      fa.provideEnvironment(environment).subscribe(
+        subscriber.operate({
           next: (value) => windowSubject.next(value),
           error: errorHandler,
           complete: () => {

package/_src/Observable/api/windowCount.ts

@@ -4,45 +4,42 @@
 export function windowCount(windowSize: number, startWindowEvery = 0) {
   return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, Observable<never, E, A>> => {
     const startEvery = startWindowEvery > 0 ? startWindowEvery : windowSize;
-    return fa.operate((source, subscriber, environment) => {
+    return new Observable((subscriber, environment) => {
       let windows = [new Subject<never, E, A>()];
       let count   = 0;
       subscriber.next(windows[0]!.asObservable());
-      source.provideEnvironment(environment).subscribe(
-        operatorSubscriber(
-          subscriber,
-          {
-            next: (value) => {
-              for (const window of windows) {
-                window.next(value);
-              }
-              const c = count - windowSize + 1;
-              if (c >= 0 && c % startEvery === 0) {
-                windows.shift()!.complete();
-              }
-              if (++count && startEvery === 0) {
-                const window = new Subject<never, E, A>();
-                windows.push(window);
-                subscriber.next(window.asObservable());
-              }
-            },
-            complete: () => {
-              while (windows.length > 0) {
-                windows.shift()!.complete();
-              }
-              subscriber.complete();
-            },
-            error: (err) => {
-              while (windows.length > 0) {
-                windows.shift()!.error(err);
-              }
-              subscriber.error(err);
-            },
+      fa.provideEnvironment(environment).subscribe(
+        subscriber.operate({
+          next: (value) => {
+            for (const window of windows) {
+              window.next(value);
+            }
+            const c = count - windowSize + 1;
+            if (c >= 0 && c % startEvery === 0) {
+              windows.shift()!.complete();
+            }
+            if (++count && startEvery === 0) {
+              const window = new Subject<never, E, A>();
+              windows.push(window);
+              subscriber.next(window.asObservable());
+            }
           },
-          () => {
+          complete: () => {
+            while (windows.length > 0) {
+              windows.shift()!.complete();
+            }
+            subscriber.complete();
+          },
+          error: (err) => {
+            while (windows.length > 0) {
+              windows.shift()!.error(err);
+            }
+            subscriber.error(err);
+          },
+          finalize: () => {
             windows = null!;
           },
-        ),
+        }),
       );
     });
   };

package/_src/Observable/api/windowTime.ts

@@ -30,7 +30,7 @@ export function windowTime(windowTimeSpan: number, ...args: any[]) {
     const scheduler = popScheduler(args) ?? asyncScheduler;
     const windowCreationInterval: number | null = args[0] ?? null;
     const maxWindowSize: number                 = args[1] || Infinity;
-    return fa.operate((source, subscriber, environment) => {
+    return new Observable((subscriber, environment) => {
       let windowRecords: WindowRecord<never, E, A>[] | null = [];
       let restartOnClose = false;
       const closeWindow  = (record: { window: Subject<never, E, A>; subs: Subscription }) => {
@@ -59,7 +59,7 @@ export function windowTime(windowTimeSpan: number, ...args: any[]) {
         ? subscriber.add(
             scheduler.schedule(function () {
               startWindow();
-              !this.closed && subscriber.add(this.schedule(null, windowCreationInterval));
+              !this._closed && subscriber.add(this.schedule(null, windowCreationInterval));
             }, windowCreationInterval),
           )
         : (restartOnClose = true);
@@ -70,8 +70,8 @@ export function windowTime(windowTimeSpan: number, ...args: any[]) {
         cb(subscriber);
         subscriber.unsubscribe();
       };
-      source.provideEnvironment(environment).subscribe(
-        operatorSubscriber(subscriber, {
+      fa.provideEnvironment(environment).subscribe(
+        subscriber.operate({
           next: (value) => {
             loop((record) => {
               record.window.next(value);

package/_src/Observable/api/windowToggle.ts

@@ -8,7 +8,7 @@ export function windowToggle<R1, E1, B, R2, E2>(
   closingSelector: (openValue: B) => ObservableInput<R2, E2, any>,
 ) {
   return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1 | R2, E | E1 | E2, Observable<never, E, A>> => {
-    return fa.operate((source, subscriber, environment) => {
+    return new Observable((subscriber, environment) => {
       const windows: Subject<never, E, A>[] = [];
       const handleError                     = (err: Cause<E>) => {
         while (0 < windows.length) {
@@ -19,7 +19,7 @@ export function windowToggle<R1, E1, B, R2, E2>(
       Observable.from(openings)
         .provideEnvironment(environment)
         .subscribe(
-          operatorSubscriber(subscriber, {
+          subscriber.operate({
             next: (openValue) => {
               const window = new Subject<never, E, A>();
               windows.push(window);
@@ -50,30 +50,28 @@ export function windowToggle<R1, E1, B, R2, E2>(
             complete: noop,
           }),
         );
-      source.provideEnvironment(environment).subscribe(
-        operatorSubscriber(
-          subscriber,
-          {
-            next: (value) => {
-              const windowsCopy = windows.slice();
-              for (const window of windowsCopy) {
-                window.next(value);
-              }
-            },
-            error: handleError,
-            complete: () => {
-              while (0 < windows.length) {
-                windows.shift()!.complete();
-              }
-              subscriber.complete();
-            },
+      fa.provideEnvironment(environment).subscribe(
+        subscriber.operate({
+          next: (value) => {
+            const windowsCopy = windows.slice();
+            for (const window of windowsCopy) {
+              window.next(value);
+            }
           },
-          () => {
+          error: handleError,
+          complete: () => {
+            while (0 < windows.length) {
+              windows.shift()!.complete();
+            }
+            subscriber.complete();
+          },
+
+          finalize: () => {
             while (0 < windows.length) {
               windows.shift()!.unsubscribe();
             }
           },
-        ),
+        }),
       );
     });
   };

package/_src/Observable/api/windowWhen.ts

@@ -3,7 +3,7 @@
  */
 export function windowWhen(closingSelector: () => ObservableInput<never, never, any>) {
   return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, Observable<never, E, A>> => {
-    return fa.operate((source, subscriber, environment) => {
+    return new Observable((subscriber, environment) => {
       let window: Subject<never, E, A> | null;
       let closingSubscriber: Subscriber<E, any> | undefined;
       const handleError = (err: Cause<E>) => {
@@ -31,22 +31,19 @@ export function windowWhen(closingSelector: () => ObservableInput<never, never,
         );
       };
       openWindow();
-      source.provideEnvironment(environment).subscribe(
-        operatorSubscriber(
-          subscriber,
-          {
-            next: (value) => window!.next(value),
-            error: handleError,
-            complete: () => {
-              window!.complete();
-              subscriber.complete();
-            },
+      fa.provideEnvironment(environment).subscribe(
+        subscriber.operate({
+          next: (value) => window!.next(value),
+          error: handleError,
+          complete: () => {
+            window!.complete();
+            subscriber.complete();
           },
-          () => {
+          finalize: () => {
             closingSubscriber?.unsubscribe();
             window = null!;
           },
-        ),
+        }),
       );
     });
   };