memorio 4.9.30 → 4.9.35

package/modules/redux.js

@@ -942,246 +942,6 @@ var schema = {
   get: getSchema
 };
 
-// functions/state/index.ts
-init_env();
-var TARGET = /* @__PURE__ */ Symbol("memorio.target");
-var wrapperCache = /* @__PURE__ */ new WeakMap();
-var deepRaw = /* @__PURE__ */ __name((val, seen = null) => {
-  if (val === null || typeof val !== "object") return val;
-  if (val[TARGET] !== void 0) return deepRaw(val[TARGET], seen);
-  if (seen) {
-    if (seen.has(val)) return val;
-    seen.add(val);
-  }
-  const ctor = val.constructor?.name;
-  if (ctor !== "Object" && ctor !== "Array") return val;
-  const copy = Array.isArray(val) ? [] : {};
-  for (const k of Reflect.ownKeys(val)) {
-    copy[k] = deepRaw(val[k], seen);
-  }
-  return copy;
-}, "deepRaw");
-var objPath = /* @__PURE__ */ __name((prop, object, separator = ".") => {
-  return object.concat(prop).join(separator);
-}, "objPath");
-var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
-  const event = /* @__PURE__ */ __name((name) => {
-    try {
-      dispatch.set(name, { detail: { name } });
-    } catch (err) {
-      if (DEV) console.warn("[memorio state] event dispatch failed:", err);
-    }
-    return;
-  }, "event");
-  return new Proxy(
-    obj,
-    {
-      get(target, prop) {
-        if (prop === "__path") {
-          return tree.length > 0 ? "state." + tree.join(".") : "state";
-        }
-        if (prop === TARGET) {
-          return target;
-        }
-        if (target[TARGET] !== void 0) {
-          return target;
-        }
-        if (prop === "list") {
-          message_default('Some state could be hidden when you use "state.list". Use "state" to see the complete list ');
-          return deepRaw(target, /* @__PURE__ */ new WeakSet());
-        }
-        if (typeof prop === "string") {
-          const path2 = tree.length > 0 ? "state." + tree.concat(prop).join(".") : "state." + prop;
-          internal_default.lastAccessedPath = path2;
-          if (internal_default.tracking) {
-            internal_default.trackedPaths.add(path2);
-          }
-        }
-        if (prop === "_lastPath") {
-          return internal_default.lastAccessedPath;
-        }
-        if (prop === "remove") {
-          return (key) => {
-            delete target[key];
-            return true;
-          };
-        }
-        if (prop === "removeAll") {
-          return () => {
-            try {
-              for (const key in target) {
-                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock"].includes(key)) {
-                  delete target[key];
-                }
-              }
-            } catch (error) {
-              console.error(error);
-            }
-            return;
-          };
-        }
-        if (Object.isFrozen(target[prop])) return target[prop];
-        if (prop === "lock" || prop === "unlock") {
-          const value = Reflect.get(target, prop);
-          if (value) return value;
-        }
-        try {
-          const value = Reflect.get(target, prop);
-          if (value && typeof value === "object" && ["Array", "Object"].includes(value.constructor.name)) {
-            let wrapper = wrapperCache.get(value);
-            if (!wrapper) {
-              wrapper = buildProxy(value, callback, tree.concat(prop));
-              wrapperCache.set(value, wrapper);
-            }
-            return wrapper;
-          }
-          return value;
-        } catch (error) {
-          console.error("Error: ", error);
-          return void 0;
-        }
-      },
-      set(target, key, value) {
-        if (internal_default.locked) {
-          console.error("Error: state is locked. Use state.unlock() to enable modifications.");
-          return false;
-        }
-        if (protect.includes(key)) {
-          console.error("key " + key + " is protected");
-          return false;
-        }
-        if (target[key] && typeof target[key] === "object" && Object.isFrozen(target[key])) {
-          console.error(`Error: state '${key}' is locked`);
-          return false;
-        }
-        if (target[key] && typeof target[key] === "object" && target[key].__locked) {
-          console.error(`Error: state '${key}' is locked. Use state.${key}.unlock() to enable modifications.`);
-          return false;
-        }
-        try {
-          const path2 = objPath(key, tree);
-          const rawValue = deepRaw(value);
-          const _schemaResult = schema.validate(path2, rawValue);
-          if (!_schemaResult.valid) {
-            if (DEV && internal_default.debug) {
-              console.error(
-                `[memorio schema] Validation failed for '${path2}':`,
-                _schemaResult.errors
-              );
-            }
-            message_default(
-              `[memorio schema] Validation failed for '${path2}': ` + (_schemaResult.errors?.join(", ") || "unknown error")
-            );
-            return false;
-          }
-          callback(
-            {
-              action: "set",
-              path: path2,
-              target,
-              newValue: rawValue,
-              previousValue: Reflect.get(target, key)
-            }
-          );
-          event("state." + path2);
-          Reflect.set(target, key, rawValue);
-          internal_default.bumpStateVersion();
-          if (target[key] && typeof target[key] === "object") {
-            const lockValue = target[key];
-            if (lockValue && typeof lockValue === "object") {
-              try {
-                Object.defineProperty(lockValue, "__locked", {
-                  writable: true,
-                  enumerable: false,
-                  configurable: false,
-                  value: false
-                });
-                Object.defineProperty(lockValue, "lock", {
-                  writable: false,
-                  enumerable: false,
-                  configurable: false,
-                  value: /* @__PURE__ */ __name(() => {
-                    Object.defineProperty(lockValue, "__locked", {
-                      writable: true,
-                      enumerable: false,
-                      configurable: false,
-                      value: true
-                    });
-                    message_default(`State '${key}' is now locked.`);
-                  }, "value")
-                });
-                Object.defineProperty(lockValue, "unlock", {
-                  writable: false,
-                  enumerable: false,
-                  configurable: false,
-                  value: /* @__PURE__ */ __name(() => {
-                    Object.defineProperty(lockValue, "__locked", {
-                      writable: true,
-                      enumerable: false,
-                      configurable: false,
-                      value: false
-                    });
-                    message_default(`State '${key}' is now unlocked.`);
-                  }, "value")
-                });
-              } catch (err) {
-                if (DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", err);
-              }
-            }
-          }
-          return true;
-        } catch (error) {
-          console.error("Error in set trap:", error);
-          return false;
-        }
-      },
-      deleteProperty(target, prop) {
-        try {
-          const path2 = objPath(prop, tree);
-          const previousValue = Reflect.get(target, prop);
-          callback({ action: "delete", path: path2, target, previousValue });
-          return Reflect.deleteProperty(target, prop);
-        } catch (error) {
-          console.error("Error in deleteProperty trap:", error);
-          return false;
-        }
-      },
-      ownKeys(target) {
-        return Reflect.ownKeys(target);
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        return Reflect.getOwnPropertyDescriptor(target, prop);
-      }
-    }
-  );
-}, "buildProxy");
-var STATE_INSTANCE_KEY = "__memorio_state_instance__";
-var state2;
-if (globalThis[STATE_INSTANCE_KEY]) {
-  state2 = globalThis[STATE_INSTANCE_KEY];
-} else {
-  state2 = buildProxy({}, (mutation) => {
-    if (internal_default.historyEnabled) {
-      internal_default.recordMutation({
-        path: mutation.path,
-        action: mutation.action,
-        newValue: mutation.newValue,
-        previousValue: mutation.previousValue,
-        timestamp: Date.now()
-      });
-    }
-  });
-  state2.lock = () => {
-    internal_default.locked = true;
-    message_default("State is now locked. All modifications are blocked.");
-  };
-  state2.unlock = () => {
-    internal_default.locked = false;
-    message_default("State is now unlocked. Modifications are allowed.");
-  };
-  globalThis[STATE_INSTANCE_KEY] = state2;
-}
-
 // functions/store/index.ts
 init_esm_shims();
 init_platform();
@@ -1454,6 +1214,280 @@ if (globalThis[STORE_INSTANCE_KEY]) {
   globalThis[STORE_INSTANCE_KEY] = store;
 }
 
+// functions/state/index.ts
+init_env();
+var TARGET = /* @__PURE__ */ Symbol("memorio.target");
+var wrapperCache = /* @__PURE__ */ new WeakMap();
+var deepRaw = /* @__PURE__ */ __name((val, seen = null) => {
+  if (val === null || typeof val !== "object") return val;
+  if (val[TARGET] !== void 0) return deepRaw(val[TARGET], seen);
+  if (seen) {
+    if (seen.has(val)) return val;
+    seen.add(val);
+  }
+  const ctor = val.constructor?.name;
+  if (ctor !== "Object" && ctor !== "Array") return val;
+  const copy = Array.isArray(val) ? [] : {};
+  for (const k of Reflect.ownKeys(val)) {
+    if (!Object.prototype.propertyIsEnumerable.call(val, k)) continue;
+    copy[k] = deepRaw(val[k], seen);
+  }
+  return copy;
+}, "deepRaw");
+var objPath = /* @__PURE__ */ __name((prop, object, separator = ".") => {
+  return object.concat(prop).join(separator);
+}, "objPath");
+var buildProxy = /* @__PURE__ */ __name((obj, callback, tree = []) => {
+  const event = /* @__PURE__ */ __name((name) => {
+    try {
+      dispatch.set(name, { detail: { name } });
+    } catch (err) {
+      if (DEV) console.warn("[memorio state] event dispatch failed:", err);
+    }
+    return;
+  }, "event");
+  return new Proxy(
+    obj,
+    {
+      get(target, prop) {
+        if (prop === "__path") {
+          return tree.length > 0 ? "state." + tree.join(".") : "state";
+        }
+        if (prop === TARGET) {
+          return target;
+        }
+        if (target[TARGET] !== void 0) {
+          return target;
+        }
+        if (prop === "list") {
+          message_default('Some state could be hidden when you use "state.list". Use "state" to see the complete list ');
+          return deepRaw(target, /* @__PURE__ */ new WeakSet());
+        }
+        if (typeof prop === "string") {
+          const path2 = tree.length > 0 ? "state." + tree.concat(prop).join(".") : "state." + prop;
+          internal_default.lastAccessedPath = path2;
+          if (internal_default.tracking) {
+            internal_default.trackedPaths.add(path2);
+          }
+        }
+        if (prop === "_lastPath") {
+          return internal_default.lastAccessedPath;
+        }
+        if (prop === "remove") {
+          return (key) => {
+            delete target[key];
+            return true;
+          };
+        }
+        if (prop === "removeAll") {
+          return () => {
+            try {
+              for (const key in target) {
+                if (typeof target[key] !== "function" && !["list", "remove", "removeAll", "lock", "unlock"].includes(key)) {
+                  delete target[key];
+                }
+              }
+            } catch (error) {
+              console.error(error);
+            }
+            return;
+          };
+        }
+        if (Object.isFrozen(target[prop])) return target[prop];
+        if (prop === "lock" || prop === "unlock") {
+          const value = Reflect.get(target, prop);
+          if (value) return value;
+        }
+        try {
+          const value = Reflect.get(target, prop);
+          if (value && typeof value === "object" && ["Array", "Object"].includes(value.constructor.name)) {
+            let wrapper = wrapperCache.get(value);
+            if (!wrapper) {
+              wrapper = buildProxy(value, callback, tree.concat(prop));
+              wrapperCache.set(value, wrapper);
+            }
+            return wrapper;
+          }
+          return value;
+        } catch (error) {
+          console.error("Error: ", error);
+          return void 0;
+        }
+      },
+      set(target, key, value) {
+        if (internal_default.locked) {
+          console.error("Error: state is locked. Use state.unlock() to enable modifications.");
+          return false;
+        }
+        if (protect.includes(key)) {
+          console.error("key " + key + " is protected");
+          return false;
+        }
+        if (target[key] && typeof target[key] === "object" && Object.isFrozen(target[key])) {
+          console.error(`Error: state '${key}' is locked`);
+          return false;
+        }
+        if (target[key] && typeof target[key] === "object" && target[key].__locked) {
+          console.error(`Error: state '${key}' is locked. Use state.${key}.unlock() to enable modifications.`);
+          return false;
+        }
+        try {
+          const path2 = objPath(key, tree);
+          const rawValue = deepRaw(value);
+          const _schemaResult = schema.validate(path2, rawValue);
+          if (!_schemaResult.valid) {
+            if (DEV && internal_default.debug) {
+              console.error(
+                `[memorio schema] Validation failed for '${path2}':`,
+                _schemaResult.errors
+              );
+            }
+            message_default(
+              `[memorio schema] Validation failed for '${path2}': ` + (_schemaResult.errors?.join(", ") || "unknown error")
+            );
+            return false;
+          }
+          callback(
+            {
+              action: "set",
+              path: path2,
+              target,
+              newValue: rawValue,
+              previousValue: Reflect.get(target, key)
+            }
+          );
+          event("state." + path2);
+          Reflect.set(target, key, rawValue);
+          internal_default.bumpStateVersion();
+          if (target[key] && typeof target[key] === "object") {
+            const lockValue = target[key];
+            if (lockValue && typeof lockValue === "object") {
+              try {
+                Object.defineProperty(lockValue, "__locked", {
+                  writable: true,
+                  enumerable: false,
+                  configurable: false,
+                  value: false
+                });
+                Object.defineProperty(lockValue, "lock", {
+                  writable: false,
+                  enumerable: false,
+                  configurable: false,
+                  value: /* @__PURE__ */ __name(() => {
+                    Object.defineProperty(lockValue, "__locked", {
+                      writable: true,
+                      enumerable: false,
+                      configurable: false,
+                      value: true
+                    });
+                    message_default(`State '${key}' is now locked.`);
+                  }, "value")
+                });
+                Object.defineProperty(lockValue, "unlock", {
+                  writable: false,
+                  enumerable: false,
+                  configurable: false,
+                  value: /* @__PURE__ */ __name(() => {
+                    Object.defineProperty(lockValue, "__locked", {
+                      writable: true,
+                      enumerable: false,
+                      configurable: false,
+                      value: false
+                    });
+                    message_default(`State '${key}' is now unlocked.`);
+                  }, "value")
+                });
+              } catch (err) {
+                if (DEV) console.warn("[memorio state] lock/unlock defineProperty failed:", err);
+              }
+            }
+          }
+          return true;
+        } catch (error) {
+          console.error("Error in set trap:", error);
+          return false;
+        }
+      },
+      deleteProperty(target, prop) {
+        try {
+          const path2 = objPath(prop, tree);
+          const previousValue = Reflect.get(target, prop);
+          callback({ action: "delete", path: path2, target, previousValue });
+          return Reflect.deleteProperty(target, prop);
+        } catch (error) {
+          console.error("Error in deleteProperty trap:", error);
+          return false;
+        }
+      },
+      ownKeys(target) {
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+    }
+  );
+}, "buildProxy");
+var STATE_INSTANCE_KEY = "__memorio_state_instance__";
+var state2;
+if (globalThis[STATE_INSTANCE_KEY]) {
+  state2 = globalThis[STATE_INSTANCE_KEY];
+} else {
+  state2 = buildProxy({}, (mutation) => {
+    if (internal_default.historyEnabled) {
+      internal_default.recordMutation({
+        path: mutation.path,
+        action: mutation.action,
+        newValue: mutation.newValue,
+        previousValue: mutation.previousValue,
+        timestamp: Date.now()
+      });
+    }
+  });
+  state2.lock = () => {
+    internal_default.locked = true;
+    message_default("State is now locked. All modifications are blocked.");
+  };
+  state2.unlock = () => {
+    internal_default.locked = false;
+    message_default("State is now unlocked. Modifications are allowed.");
+  };
+  state2.persist = (path2) => {
+    if (typeof path2 !== "string" || !path2.length) {
+      if (DEV) console.warn('[memorio state] state.persist() requires a non-empty path string (e.g. "state.user")');
+      return () => {
+      };
+    }
+    const normalized = path2.startsWith("state.") ? path2 : "state." + path2;
+    const key = normalized.replace(/^state\./, "");
+    const segments = key.split(".");
+    const initial = store.get(key);
+    if (initial !== void 0 && initial !== null) {
+      let acc = state2;
+      for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if (i === segments.length - 1) {
+          acc[seg] = deepRaw(initial);
+        } else {
+          if (acc[seg] === void 0 || acc[seg] === null) acc[seg] = {};
+          acc = acc[seg];
+        }
+      }
+    }
+    const handler = /* @__PURE__ */ __name(() => {
+      let current = state2;
+      for (const seg of segments) {
+        current = current === void 0 || current === null ? void 0 : current[seg];
+      }
+      store.set(key, deepRaw(current));
+    }, "handler");
+    const off = dispatch.listen(normalized, handler);
+    return typeof off === "function" ? off : () => {
+    };
+  };
+  globalThis[STATE_INSTANCE_KEY] = state2;
+}
+
 // functions/session/index.ts
 init_esm_shims();
 init_platform();