@cascateer/core 2.3.0 → 2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascateer/core",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/cascateer/core.git"
@@ -26,6 +26,7 @@
     "lodash": "^4.17.21",
     "object-hash": "^3.0.0",
     "rxjs": "^7.8.2",
+    "ts-brand": "^0.2.0",
     "uuid": "^13.0.0"
   }
 }

package/src/index.ts

@@ -3,6 +3,7 @@ export { App } from "./app";
 export { createComponent } from "./component";
 export { defineCustomProperties } from "./dom";
 export { createElement, createFragment } from "./jsx-runtime";
+export { BrandedSerializer, Serializable } from "./serializable";
 export { createSlice } from "./slice";
 export { type StoreEffect } from "./store";
 export { type TerminalEffect } from "./terminal";

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/serializable.spec.ts

@@ -0,0 +1,29 @@
+import { BrandedSerializer, Serializable } from "./serializable";
+
+interface SquareObject {
+  x: number;
+  y: number;
+}
+
+export interface Square extends SquareObject {}
+
+export class Square implements Serializable<SquareObject> {
+  constructor({ x, y }: SquareObject) {
+    this.x = x;
+    this.y = y;
+  }
+
+  static fromObject(obj: SquareObject): Square {
+    return new Square(obj);
+  }
+
+  toObject(): SquareObject {
+    return { x: this.x, y: this.y };
+  }
+
+  toJSON: BrandedSerializer<SquareObject> = Serializable.toJSON(Square, this);
+}
+
+Serializable.fromJSON<Square, SquareObject>(
+  JSON.stringify(new Square({ x: 2, y: 24 })),
+).then(console.log);

package/src/serializable.ts

@@ -0,0 +1,58 @@
+import { Dictionary, get, isObject, isString } from "lodash";
+import { Brand, identity } from "ts-brand";
+import { v4 } from "uuid";
+
+export interface Serializer<O> {
+  (): O & { $ref: string };
+}
+
+enum SerializerBrand {}
+
+export type BrandedSerializer<O> = Brand<Serializer<O>, SerializerBrand>;
+
+interface SerializableConstructor<T, O> {
+  name: string;
+  fromObject(obj: O): T;
+}
+
+export abstract class Serializable<O> {
+  static readonly importMap: Dictionary<
+    SerializableConstructor<unknown, unknown>
+  > = {};
+
+  static async fromJSON<T, O>(value: string): Promise<T> {
+    const obj: O = JSON.parse(value);
+
+    if (isObject(obj) && "$ref" in obj && isString(obj.$ref)) {
+      const [url, path] = obj.$ref.split(/#\/?/);
+
+      if (url != null && path != null) {
+        return import(url).then((module) =>
+          (
+            get(module, path.split("/")) as SerializableConstructor<T, O>
+          ).fromObject(obj),
+        );
+      }
+    }
+
+    throw new Error(`${value} deserialization failed`);
+  }
+
+  static toJSON<T, O>(
+    ctor: SerializableConstructor<T, O>,
+    value: Serializable<O>,
+  ): BrandedSerializer<O> {
+    const importMap = "importMap" satisfies keyof typeof Serializable;
+    const id = v4();
+
+    this[importMap][id] = ctor;
+
+    return identity<BrandedSerializer<O>>(() => ({
+      ...value.toObject(),
+      $ref: [`${import.meta.url}#`, this.name, importMap, id].join("/"),
+    }));
+  }
+
+  abstract toObject(): O;
+  abstract toJSON: BrandedSerializer<O>;
+}

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;
-}