akanjs 3.0.0-alpha.7 → 3.0.0-alpha.8

package/common/deepObjectify.ts

@@ -1,9 +1,16 @@
 import { isDayjs } from "./isDayjs";
 
-export const deepObjectify = <T = unknown>(
-  obj: T | null | undefined,
-  option: { serializable?: boolean; convertDate?: "string" | "number" } = {},
-): T => {
+interface DeepObjectifyOption {
+  serializable?: boolean;
+  convertDate?: "string" | "number";
+}
+
+const objectifyChild = (value: unknown, option: DeepObjectifyOption): unknown => {
+  const modelValue = value as { __ModelType__?: string } | null | undefined;
+  return modelValue?.__ModelType__ && !option.serializable ? value : deepObjectify(value, option);
+};
+
+export const deepObjectify = <T = unknown>(obj: T | null | undefined, option: DeepObjectifyOption = {}): T => {
   if (isDayjs(obj) || obj?.constructor === Date) {
     if (!option.serializable && !option.convertDate) return obj as T;
     if (option.convertDate === "string") return obj.toISOString() as T;
@@ -12,13 +19,20 @@ export const deepObjectify = <T = unknown>(
     else return (isDayjs(obj) ? obj.toDate() : obj) as T;
   } else if (Array.isArray(obj)) {
     return obj.map((o: unknown) => deepObjectify(o, option)) as T;
+  } else if (obj instanceof Map) {
+    
+    const entries = [...obj.entries()].map(
+      ([key, value]: [string, unknown]) => [key, objectifyChild(value, option)] as const,
+    );
+    return (option.serializable ? Object.fromEntries(entries) : new Map(entries)) as T;
+  } else if (obj instanceof Set) {
+    const values = [...obj.values()].map((value: unknown) => objectifyChild(value, option));
+    return (option.serializable ? values : new Set(values)) as T;
   } else if (obj && typeof obj === "object") {
     const val: Record<string, unknown> = {};
     const objRecord = obj as Record<string, unknown>;
     Object.keys(obj).forEach((key) => {
-      const fieldValue = objRecord[key] as { __ModelType__: string } | null | undefined;
-      if (fieldValue?.__ModelType__ && !option.serializable) val[key] = fieldValue;
-      else if (typeof objRecord[key] !== "function") val[key] = deepObjectify(fieldValue, option);
+      if (typeof objRecord[key] !== "function") val[key] = objectifyChild(objRecord[key], option);
     });
     return val as T;
   } else {

package/common/pathSet.ts

@@ -1,16 +1,28 @@
 type MutableIndexable = Record<string | number, unknown>;
 type PathSegment = string | number;
+type Container = MutableIndexable | Map<PathSegment, unknown>;
 
 const toPathSegments = (path: string | readonly PathSegment[]) =>
   Array.isArray(path) ? [...path] : path.toString().match(/[^.[\]]+/g) || [];
 
+const readChild = (container: Container, key: PathSegment) =>
+  container instanceof Map ? container.get(key) : container[key];
+
+const writeChild = (container: Container, key: PathSegment, value: unknown) => {
+  if (container instanceof Map) container.set(key, value);
+  else container[key] = value;
+};
+
 export const pathSet = <T>(obj: T, path: string | readonly PathSegment[], value: unknown): T => {
   if (Object(obj) !== obj) return obj;
   const pathSegments = toPathSegments(path);
-  pathSegments.slice(0, -1).reduce<MutableIndexable>((a, c, i) => {
-    if (Object(a[c]) === a[c]) return a[c] as MutableIndexable;
-    a[c] = Math.abs(Number(pathSegments[i + 1])) >> 0 === +pathSegments[i + 1] ? [] : {};
-    return a[c] as MutableIndexable;
-  }, obj as MutableIndexable)[pathSegments[pathSegments.length - 1]] = value;
+  const parent = pathSegments.slice(0, -1).reduce<Container>((a, c, i) => {
+    const child = readChild(a, c);
+    if (Object(child) === child) return child as Container;
+    const created = Math.abs(Number(pathSegments[i + 1])) >> 0 === +pathSegments[i + 1] ? [] : {};
+    writeChild(a, c, created);
+    return created as unknown as Container;
+  }, obj as Container);
+  writeChild(parent, pathSegments[pathSegments.length - 1], value);
   return obj;
 };

package/constant/crystalize.ts

@@ -30,8 +30,10 @@ export const crystalize = (field: FieldProps, value: unknown): unknown => {
       isArray: false,
       arrDepth: 0,
     };
+    
+    const entries = value instanceof Map ? [...value.entries()] : Object.entries(value as Record<string, unknown>);
     return new Map(
-      Object.entries(value as Record<string, unknown>).map(([key, val]) => [
+      entries.map(([key, val]: [string, unknown]) => [
         key,
         field.of
           ? applyFnToArrayObjects(val, (v: never) => crystalize(mapValueField, v))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.7",
+  "version": "3.0.0-alpha.8",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/store/action.ts

@@ -751,7 +751,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       const id = typeof modelOrId === "string" ? modelOrId : modelOrId.id;
       this.set({ [names.modelFormLoading]: id, [names.modelModal]: modal ?? "edit" });
       const model = await (fetch[names.model] as (...args: any[]) => Promise<Full>)(id, { onError });
-      const modelForm = deepObjectify<Input>(model as unknown as Input);
+      const modelForm = immerify(modelRef, deepObjectify<Input>(model as unknown as Input) as object) as Input;
       this.set({
         [names.model]: model,
         [names.modelFormLoading]: false,

package/store/storeInstance.ts

@@ -1,13 +1,15 @@
 import { ACTION_META, STATE_DERIVED_META, STATE_INIT_META } from "akanjs/base";
 import { Translator } from "akanjs/client";
 import { capitalize, Logger, parseAkanI18nEnv } from "akanjs/common";
-import { produce } from "immer";
+import { enableMapSet, produce } from "immer";
 import type { RefObject } from "react";
 import { useEffect, useRef, useSyncExternalStore } from "./hooks";
 import type { RootStoreCls } from "./rootStore";
 import type { SliceStateKey } from "./state";
 import { evaluateInitializers, type SearchParamsState, type StateDerivedMeta } from "./stateBuilder";
 
+enableMapSet();
+
 type StoreStateRecord = Record<string, unknown>;
 type StoreAction = (...args: unknown[]) => unknown;
 type TranslationParam = Record<string, string | number>;

package/types/common/deepObjectify.d.ts

@@ -1,4 +1,6 @@
-export declare const deepObjectify: <T = unknown>(obj: T | null | undefined, option?: {
+interface DeepObjectifyOption {
     serializable?: boolean;
     convertDate?: "string" | "number";
-}) => T;
+}
+export declare const deepObjectify: <T = unknown>(obj: T | null | undefined, option?: DeepObjectifyOption) => T;
+export {};