@cascateer/core 2.3.39 → 2.3.41

package/package.json

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

package/src/serializable.ts

@@ -1,6 +1,7 @@
-import { Dictionary, get } from "lodash";
+import { Dictionary, isString } from "lodash";
 import { Brand, identity } from "ts-brand";
 import { v4 } from "uuid";
+import * as module from ".";
 
 interface SerializerResult<O> {
   value: O;
@@ -25,78 +26,43 @@ export abstract class Serializable<O> {
     SerializableConstructor<unknown, unknown>
   > = {};
 
-  static async fromJSON<T, O>(json: string): Promise<T> {
-    console.warn("fromJSON", this);
+  static fromJSON<T, O>(json: string): T {
+    try {
+      const { $ref, value }: SerializerResult<O> = JSON.parse(json),
+        [url, pointer] = $ref.split(/#\/?/);
 
-    const { $ref, value }: SerializerResult<O> = JSON.parse(json),
-      [url, path] = $ref.split(/#\/?/);
+      if (url === import.meta.url) {
+        const [a, b, c] = pointer?.split("/") ?? [];
 
-    console.warn("fromJSON", url, this);
-
-    if (url != null && path != null) {
-      console.log(
-        Object.entries(
-          import.meta.glob("/node_modules/@cascateer/core/src/*.ts"),
-        ),
-      );
-      return import(url).then(
-        (module) => (
-          console.warn("FOOBAR", module, path.split("/")),
-          (
-            get(module, path.split("/")) as SerializableConstructor<T, O>
-          ).fromObject(value)
-        ),
-      );
-    }
+        if (a === "Serializable" && b === "importMap" && isString(c)) {
+          return (module[a][b][c] as SerializableConstructor<T, O>).fromObject(
+            value,
+          );
+        }
+      }
+    } catch {}
 
-    throw new Error(`${json} deserialization failed`);
+    return JSON.parse(json);
   }
 
   static toJSON<T, O>(
     ctor: SerializableConstructor<T, O>,
     value: Serializable<O>,
   ): BrandedSerializer<O> {
-    const importMap = "importMap" satisfies keyof typeof Serializable;
-    const id = v4();
+    const IMPORT_MAP = "importMap",
+      UUID = v4();
 
-    this[importMap][id] = ctor;
-
-    console.log("toJSON", import.meta.url, this);
+    this[IMPORT_MAP][UUID] = ctor;
 
     return identity<BrandedSerializer<O>>(() => ({
       value: value.toObject(),
-      $ref: [`${import.meta.url}#`, this.name, importMap, id].join("/"),
+      $ref: `${import.meta.url}#${[this.name, IMPORT_MAP, UUID].join("/")}`,
     }));
   }
 
-  static async parse(text: string) {
-    const nodes: { key: string; value: any; parent?: any }[] = [];
-    const obj = JSON.parse(text, (key, value) => {
-      for (const node of nodes) {
-        if (value[node.key] === node.value) {
-          node.parent = value;
-        }
-      }
-
-      nodes.push({ key, value });
-
-      return value;
-    });
-
-    return nodes.reduce(
-      (value, node) =>
-        value.then(() =>
-          Serializable.fromJSON(JSON.stringify(node.value))
-            .catch((error) => (console.error(error), node.value))
-            .then((value) => {
-              if (node.parent != null) {
-                node.parent[node.key] = value;
-              }
-
-              return value;
-            }),
-        ),
-      Promise.resolve(obj),
+  static parse(text: string) {
+    return JSON.parse(text, (_, value) =>
+      Serializable.fromJSON(JSON.stringify(value)),
     );
   }
 

package/src/store.ts

@@ -171,15 +171,14 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
     >();
     const seedActions: Observable<MulticastAction<Data, "seedAction">> =
       actions.pipe(
-        mergeMap(async (event) =>
+        flatMap((event) =>
           event.type === "seedAction"
             ? {
                 ...event,
-                predicate: constant(await Serializable.parse(event.data.seed)),
+                predicate: constant(Serializable.parse(event.data.seed)),
               }
             : [],
         ),
-        flatMap(identity),
       );
 
     const callbacks = new Map<string, UnaryFunction<unknown, void>>();
@@ -213,7 +212,7 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
                     return {
                       ...event,
                       predicate: transform(
-                        await Serializable.parse(event.data.args ?? null),
+                        Serializable.parse(event.data.args ?? null),
                       ),
                       callback: callbacks.get(event.id),
                     };