@cascateer/core 2.3.1 → 2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascateer/core",
-  "version": "2.3.1",
+  "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/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>;
+}