@cascateer/core 2.3.15 → 2.3.16

package/package.json

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

package/src/serializable.ts

@@ -1,4 +1,5 @@
 import { Dictionary, get } from "lodash";
+import { concatAll, defer, endWith, from, lastValueFrom } from "rxjs";
 import { Brand, identity } from "ts-brand";
 import { v4 } from "uuid";
 
@@ -56,6 +57,33 @@ export abstract class Serializable<O> {
     }));
   }
 
+  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 (node.key && value[node.key] === node.value) {
+          node.parent = value;
+        }
+      }
+
+      nodes.unshift({ key, value });
+
+      return value;
+    });
+
+    return lastValueFrom(
+      from(
+        nodes.toReversed().map((node) =>
+          defer(() =>
+            Serializable.fromJSON(JSON.stringify(node.value))
+              .catch(() => node.value)
+              .then((value) => node.key && (node.parent[node.key] = value)),
+          ),
+        ),
+      ).pipe(concatAll(), endWith(obj)),
+    );
+  }
+
   abstract toObject(): O;
   abstract toJSON: BrandedSerializer<O>;
 }

package/src/store.ts

@@ -16,7 +16,8 @@ import {
   MulticastSubject,
   sequence,
 } from "./operators";
-import { Action, MaybePromise, Transform } from "./types";
+import { Serializable } from "./serializable";
+import { Action, Transform } from "./types";
 
 export type StoreEffect<Result> = () => Signal<Result>;
 
@@ -69,7 +70,7 @@ export class ExtendableStoreAdapter<
             },
             void
           >;
-          register: UnaryFunction<(args: any) => Promise<Transform<any>>, void>;
+          register: UnaryFunction<(args: any) => Transform<any>, void>;
         }
       >;
     },
@@ -114,7 +115,7 @@ export class ExtendableStoreAdapter<
                     ? T
                     : never,
                 >(
-                  predicate: UnaryFunction<Args, MaybePromise<Transform<T>>>,
+                  predicate: UnaryFunction<Args, Transform<T>>,
                   config?: { sameOrigin?: boolean },
                 ) => Action<Args, any>;
               };
@@ -141,8 +142,8 @@ export class ExtendableStoreAdapter<
                       (signal) => ({
                         update: (predicate, config = {}) =>
                           thru(this.context.transform(key), (transform) => {
-                            transform.register(async (args) =>
-                              signal.reflector.predicate(await predicate(args)),
+                            transform.register((args) =>
+                              signal.reflector.predicate(predicate(args)),
                             );
 
                             return (args) =>
@@ -170,14 +171,15 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
     >();
     const seedActions: Observable<MulticastAction<Data, "seedAction">> =
       actions.pipe(
-        flatMap((event) =>
+        mergeMap(async (event) =>
           event.type === "seedAction"
             ? {
                 ...event,
-                predicate: constant(JSON.parse(event.data.seed)),
+                predicate: constant(await Serializable.parse(event.data.seed)),
               }
-            : [],
+            : Promise.resolve([]),
         ),
+        flatMap(identity),
       );
 
     const callbacks = new Map<string, UnaryFunction<unknown, void>>();
@@ -210,8 +212,8 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
                   ) {
                     return {
                       ...event,
-                      predicate: await transform(
-                        JSON.parse(event.data.args ?? null),
+                      predicate: transform(
+                        await Serializable.parse(event.data.args ?? null),
                       ),
                       callback: callbacks.get(event.id),
                     };

package/src/types.ts

@@ -68,8 +68,6 @@ export interface Action<Args, Result> extends UnaryFunction<
 
 export type MaybeArray<T> = T | T[];
 
-export type MaybePromise<T> = T | Promise<T>;
-
 export type MaybeObservable<T> = T | Observable<T>;
 
 export type MaybeObservableInput<T> = T | ObservableInput<T>;