@cascateer/core 2.3.0 → 2.3.1

package/package.json

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

package/src/lib/ExtendableDictionary.ts

@@ -1,6 +1,5 @@
-import { Dictionary } from "lodash";
-import { UnaryFunction } from "rxjs";
-import { Future } from "../observable";
+import { Dictionary, once } from "lodash";
+import { AsyncSubject, lastValueFrom, UnaryFunction } from "rxjs";
 import { keys } from "./keys";
 
 export type Extend<T, U> = Omit<T, keyof U> & U;
@@ -8,12 +7,15 @@ export type Extend<T, U> = Omit<T, keyof U> & U;
 export class ExtendableDictionary<T, U extends Dictionary<T>> {
   constructor(
     public currentValue: U,
-    private value = new Future<Dictionary<T>>(),
+    private value = new AsyncSubject<Dictionary<T>>(),
   ) {}
 
-  complete(): U {
-    return this.value.completeWith(this.currentValue);
-  }
+  complete = once((): U => {
+    this.value.next(this.currentValue);
+    this.value.complete();
+
+    return this.currentValue;
+  });
 
   extend<V extends Dictionary<T>>(
     value: (
@@ -30,7 +32,7 @@ export class ExtendableDictionary<T, U extends Dictionary<T>> {
         ...value(this.currentValue)({
           property: (constructor) => {
             const property = constructor(
-              this.value.once(
+              lastValueFrom(this.value).then(
                 (value) =>
                   new Promise<string>((resolve, reject) => {
                     for (const key of keys(value)) {

package/src/multicast.ts

@@ -13,7 +13,7 @@ import {
 import { v4 } from "uuid";
 import { property } from "./lib";
 import {
-  concat,
+  accumulate,
   exchangeWith,
   flatMap,
   MulticastActionMessage,
@@ -93,7 +93,7 @@ self.addEventListener("connect", ({ ports }) => {
         map(({ origin, ...message }) => message),
         exchangeWith<MulticastClientMessage, MulticastActionMessage<any>>(port),
         map((message) => ({ ...message, origin: port })),
-        concat(),
+        accumulate(),
         flatMap((messages) =>
           thru(
             partition(messages, (message) => message.type === "connect"),

package/src/observable/index.ts

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

package/src/operators/{concat.ts → accumulate.ts}

@@ -1,6 +1,6 @@
 import { OperatorFunction, scan } from "rxjs";
 
-export const concat =
+export const accumulate =
   <T>(): OperatorFunction<T | T[], T[]> =>
   (source) =>
     source.pipe(scan((acc, curr) => acc.concat(curr), new Array<T>()));

package/src/operators/index.ts

@@ -1,4 +1,4 @@
-export { concat } from "./concat";
+export { accumulate } from "./accumulate";
 export { every } from "./every";
 export { exchangeWith } from "./exchangeWith";
 export { flatMap } from "./flatMap";

package/src/types.ts

@@ -4,7 +4,7 @@ import { Observable } from "rxjs/internal/Observable";
 import { ObservableInput } from "rxjs/internal/types";
 import { memoizeHashed } from "./lib/memoizeHashed";
 import { ProxyObservable } from "./observable";
-import { concat, every, some } from "./operators";
+import { accumulate, every, some } from "./operators";
 
 export interface Effect<Args, Result> extends UnaryFunction<
   Args,
@@ -51,7 +51,7 @@ export class ProxyEffectInterceptor extends ReplaySubject<
     return (args) =>
       new ProxyObservable(effect(args), () =>
         this.pipe(
-          concat(),
+          accumulate(),
           switchMap((sources) =>
             combineLatest(sources.map((source) => source.pending)),
           ),

package/src/observable/Future.ts

@@ -1,17 +0,0 @@
-import { once } from "lodash";
-import { AsyncSubject, lastValueFrom, UnaryFunction } from "rxjs";
-
-export class Future<T> extends AsyncSubject<T> {
-  completeWith = once(<U extends T>(value: U): U => {
-    this.next(value);
-    this.complete();
-
-    return value;
-  });
-
-  once<U>(predicate: UnaryFunction<T, U | PromiseLike<U>>): Promise<U> {
-    return lastValueFrom(this).then(predicate);
-  }
-
-  then = this.once;
-}