@cascateer/core 2.1.14 → 2.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascateer/core",
-  "version": "2.1.14",
+  "version": "2.1.15",
   "repository": {
     "type": "git",
     "url": "https://github.com/cascateer/core.git"

package/src/api.ts

@@ -5,12 +5,12 @@ import {
   isEqual,
   isFunction,
   memoize,
+  thru,
 } from "lodash";
 import objectHash from "object-hash";
 import {
   BehaviorSubject,
   combineLatest,
-  defer,
   filter,
   finalize,
   lastValueFrom,
@@ -20,11 +20,12 @@ import {
   repeat,
   shareReplay,
   Subject,
+  tap,
   UnaryFunction,
 } from "rxjs";
 import { asObservable, ExtendableDictionary, property } from "./lib";
-import { AsyncObservable } from "./observable";
-import { Action, AsyncEffect, MaybeArray, MaybeObservable } from "./types";
+import { ProxyObservable } from "./observable";
+import { Action, MaybeArray, MaybeObservable, ProxyEffect } from "./types";
 
 interface TagsConstructor<Args, Result> {
   (args: Args, result: Result): string[];
@@ -39,7 +40,7 @@ class Memoizable<Args, Result> {
   predicate: UnaryFunction<Args, Observable<Result>>;
   tags: TagsConstructor<Args, Result>;
 
-  subscribe: UnaryFunction<Observable<string[]>, AsyncEffect<Args, Result>>;
+  subscribe: UnaryFunction<Observable<string[]>, ProxyEffect<Args, Result>>;
 
   share: UnaryFunction<NextObserver<string[]>, Action<Args, Result>>;
 
@@ -49,52 +50,40 @@ class Memoizable<Args, Result> {
     this.tags = isFunction(tags) ? tags : constant([tags ?? []].flat());
 
     this.subscribe = (invalidatedTags) => {
-      const memoizedEffect: AsyncEffect<Args, Result> = memoize(
-        (args) => {
-          const pending = new BehaviorSubject(false);
-
-          return new (class
-            extends Observable<Result>
-            implements AsyncObservable<Result>
-          {
-            pending: Observable<boolean>;
-
-            constructor(
-              source: Observable<Result>,
-              tags: TagsConstructor<Args, Result>,
-            ) {
-              super((subscriber) =>
-                defer(
-                  () => (
-                    pending.next(true),
-                    source.pipe(
-                      finalize(() => pending.next(false)),
-                      repeat({
-                        delay: () =>
-                          combineLatest([
-                            memoizedEffect(args).pipe(
-                              map((result) => tags(args, result)),
-                            ),
-                            invalidatedTags,
-                          ]).pipe(
-                            filter(([tags, invalidatedTags]) =>
-                              isEqual(
-                                tags,
-                                intersectionWith(tags, invalidatedTags),
-                              ),
+      const memoizedEffect: ProxyEffect<Args, Result> = memoize(
+        (args) =>
+          thru(
+            new BehaviorSubject(false),
+            (pending) =>
+              new ProxyObservable(
+                this.predicate(args),
+                (source) =>
+                  source.pipe(
+                    tap({
+                      subscribe: () => pending.next(true),
+                    }),
+                    finalize(() => pending.next(false)),
+                    repeat({
+                      delay: () =>
+                        combineLatest([
+                          memoizedEffect(args).pipe(
+                            map((result) => this.tags(args, result)),
+                          ),
+                          invalidatedTags,
+                        ]).pipe(
+                          filter(([tags, invalidatedTags]) =>
+                            isEqual(
+                              tags,
+                              intersectionWith(tags, invalidatedTags),
                             ),
                           ),
-                      }),
-                      shareReplay({ bufferSize: 1, refCount: false }),
-                    )
+                        ),
+                    }),
+                    shareReplay({ bufferSize: 1, refCount: false }),
                   ),
-                ).subscribe(subscriber),
-              );
-
-              this.pending = pending;
-            }
-          })(this.predicate(args), this.tags);
-        },
+                pending,
+              ),
+          ),
         (args) => objectHash(args ?? null),
       );
 
@@ -108,7 +97,7 @@ class Memoizable<Args, Result> {
   }
 }
 
-export interface ApiEffect<Args, Result> extends AsyncEffect<Args, Result> {}
+export interface ApiEffect<Args, Result> extends ProxyEffect<Args, Result> {}
 
 type ApiAdapterPropertyConstructor<Source, Type extends "effect" | "action"> = {
   [T in Type]: <Args, Result>(

package/src/observable/ProxyObservable.ts

@@ -6,9 +6,17 @@ export interface ProxyObservableHandler<T, U> {
 }
 
 export class ProxyObservable<T, U = T> extends Observable<U> {
-  constructor(target: Observable<T>, handler: ProxyObservableHandler<T, U>) {
+  pending: Observable<boolean>;
+
+  constructor(
+    target: Observable<T>,
+    handler: ProxyObservableHandler<T, U>,
+    pending: Observable<boolean>,
+  ) {
     handler = once(handler);
 
     super((subscriber) => handler(target).subscribe(subscriber));
+
+    this.pending = pending;
   }
 }

package/src/observable/Signal.ts

@@ -1,6 +1,6 @@
 import { clone, identity, isEqual, memoize } from "lodash";
 import { distinctUntilChanged, map, Observable, of, UnaryFunction } from "rxjs";
-import { AsyncObservable, ProxyObservable } from ".";
+import { ProxyObservable } from ".";
 import {
   asEnumerable,
   EnumerableItem,
@@ -33,12 +33,7 @@ class SignalReflector<T> {
     new SignalReflector((transform) => this.predicate(lift(transform)));
 }
 
-export class Signal<T>
-  extends ProxyObservable<T>
-  implements AsyncObservable<T>
-{
-  pending = of(false);
-
+export class Signal<T> extends ProxyObservable<T> {
   clone(): Signal<T> {
     return this;
   }
@@ -59,7 +54,7 @@ export class Signal<T>
     enumerator?: SignalEnumerator<T>;
     reflector?: SignalReflector<T>;
   }) {
-    super(value, identity);
+    super(value, identity, of(false));
 
     this.enumerator = enumerator;
     this.reflector = reflector;

package/src/observable/index.ts

@@ -1,4 +1,3 @@
-export { AsyncObservable } from "./AsyncObservable";
 export { Future } from "./Future";
 export { ProxyObservable } from "./ProxyObservable";
 export { ProxySubject } from "./ProxySubject";

package/src/terminal.ts

@@ -6,13 +6,13 @@ import { ComputedSignal } from "./observable";
 import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
 import {
   Action,
-  AsyncEffect,
-  AsyncEffectInterceptor,
-  AsyncEffects,
   Effect,
+  ProxyEffect,
+  ProxyEffectInterceptor,
+  ProxyEffects,
 } from "./types";
 
-export interface TerminalEffect<Args, Result> extends AsyncEffect<
+export interface TerminalEffect<Args, Result> extends ProxyEffect<
   Args,
   Result
 > {}
@@ -64,10 +64,10 @@ export class ExtendableTerminalAdapter<
                 effects: StoreEffects<StoreSignals>;
               };
               api: {
-                effects: AsyncEffects<ApiEffects>;
+                effects: ProxyEffects<ApiEffects>;
               };
               terminal: {
-                effects: AsyncEffects<Effects>;
+                effects: ProxyEffects<Effects>;
               };
             },
             Effect<Args, Result>
@@ -80,7 +80,7 @@ export class ExtendableTerminalAdapter<
     return new ExtendableTerminalAdapter(
       this.context,
       this.extendableEffects.extend((currentEffects) => () => {
-        const interceptor = new AsyncEffectInterceptor();
+        const interceptor = new ProxyEffectInterceptor();
         const source = {
           store: {
             effects: asStoreEffects(this.context.store.signals),
@@ -94,8 +94,7 @@ export class ExtendableTerminalAdapter<
         };
 
         return effects({
-          effect: (constructor) =>
-            interceptor.toAsyncEffect(constructor(source)),
+          effect: (constructor) => interceptor.proxy(constructor(source)),
         });
       }),
       this.extendableActions,

package/src/types.ts

@@ -10,7 +10,7 @@ import {
 } from "rxjs";
 import { Observable } from "rxjs/internal/Observable";
 import { ObservableInput } from "rxjs/internal/types";
-import { AsyncObservable, ProxyObservable } from "./observable";
+import { ProxyObservable } from "./observable";
 import { concat } from "./operators";
 
 export interface Effect<Args, Result> extends UnaryFunction<
@@ -18,59 +18,50 @@ export interface Effect<Args, Result> extends UnaryFunction<
   Observable<Result>
 > {}
 
-export interface AsyncEffect<Args, Result> extends UnaryFunction<
+export interface ProxyEffect<Args, Result> extends UnaryFunction<
   Args,
-  AsyncObservable<Result>
+  ProxyObservable<Result>
 > {}
 
-export type AsyncEffects<Effects extends Dictionary<AsyncEffect<any, any>>> = {
+export type ProxyEffects<Effects extends Dictionary<ProxyEffect<any, any>>> = {
   [K in keyof Effects]: ReturnType<
     <
-      Args extends Effects[K] extends AsyncEffect<infer Args, infer _>
+      Args extends Effects[K] extends ProxyEffect<infer Args, infer _>
         ? Args
         : never,
-      Result extends Effects[K] extends AsyncEffect<infer _, infer Result>
+      Result extends Effects[K] extends ProxyEffect<infer _, infer Result>
         ? Result
         : never,
-    >() => AsyncEffect<Args, Result>
+    >() => ProxyEffect<Args, Result>
   >;
 };
 
-export class AsyncEffectInterceptor extends ReplaySubject<
-  AsyncObservable<any>
+export class ProxyEffectInterceptor extends ReplaySubject<
+  ProxyObservable<any>
 > {
-  intercept<Effects extends Dictionary<AsyncEffect<any, any>>>(
+  intercept<Effects extends Dictionary<ProxyEffect<any, any>>>(
     effects: Effects,
-  ): AsyncEffects<Effects> {
+  ): ProxyEffects<Effects> {
     return mapValues(
       effects,
       (effect) => (args) => tap(effect(args), (source) => this.next(source)),
     );
   }
 
-  toAsyncEffect<Args, Result>(
-    effect: Effect<Args, Result>,
-  ): AsyncEffect<Args, Result> {
+  proxy<Args, Result>(effect: Effect<Args, Result>): ProxyEffect<Args, Result> {
     return (args) =>
-      new (class
-        extends ProxyObservable<Result>
-        implements AsyncObservable<Result>
-      {
-        pending: Observable<boolean>;
-
-        constructor(interceptor: AsyncEffectInterceptor) {
-          super(effect(args), identity);
-
-          this.pending = interceptor.pipe(
-            distinct(),
-            concat(),
-            switchMap((sources) =>
-              combineLatest(sources.map((source) => source.pending)),
-            ),
-            map((values) => values.some(Boolean)),
-          );
-        }
-      })(this);
+      new ProxyObservable(
+        effect(args),
+        identity,
+        this.pipe(
+          distinct(),
+          concat(),
+          switchMap((sources) =>
+            combineLatest(sources.map((source) => source.pending)),
+          ),
+          map((values) => values.some(Boolean)),
+        ),
+      );
   }
 }
 

package/src/observable/AsyncObservable.ts

@@ -1,33 +0,0 @@
-import { constant } from "lodash";
-import {
-  BehaviorSubject,
-  defer,
-  finalize,
-  isObservable,
-  Observable,
-  UnaryFunction,
-} from "rxjs";
-import { ProxyObservable } from "./ProxyObservable";
-
-export interface AsyncObservable<T> {
-  pending: Observable<boolean>;
-}
-
-export class AsyncObservable<T> extends ProxyObservable<T> {
-  constructor(
-    source: Observable<T> | UnaryFunction<() => void, Observable<T>>,
-  ) {
-    const pending = new BehaviorSubject(false);
-    const complete = () => pending.next(false);
-
-    if (isObservable(source)) {
-      source = constant(source);
-    }
-
-    super(source(complete), (source) =>
-      defer(() => (pending.next(true), source)).pipe(finalize(complete)),
-    );
-
-    this.pending = pending;
-  }
-}