@legendapp/state 3.0.0-beta.4 → 3.0.0-beta.41

package/index.js

@@ -146,6 +146,16 @@ function isEvent(value$) {
   var _a;
   return value$ && ((_a = value$[symbolGetNode]) == null ? void 0 : _a.isEvent);
 }
+function setNewValue(parentValue, key, newValue, useSetFn, useMapFn) {
+  if (useSetFn) {
+    parentValue.add(newValue);
+  } else if (useMapFn) {
+    parentValue.set(key, newValue);
+  } else {
+    parentValue[key] = newValue;
+  }
+  return newValue;
+}
 function setNodeValue(node, newValue) {
   var _a;
   const parentNode = (_a = node.parent) != null ? _a : node;
@@ -169,19 +179,13 @@ function setNodeValue(node, newValue) {
           delete parentValue[key];
         }
       } else {
-        if (useSetFn) {
-          parentValue.add(newValue);
-        } else if (useMapFn) {
-          parentValue.set(key, newValue);
-        } else {
-          parentValue[key] = newValue;
-        }
+        setNewValue(parentValue, key, newValue, useSetFn, useMapFn);
       }
     } finally {
       parentNode.isSetting--;
     }
   }
-  return { prevValue, newValue };
+  return { prevValue, newValue, parentValue };
 }
 var arrNodeKeys = [];
 function getNodeValue(node) {
@@ -194,7 +198,7 @@ function getNodeValue(node) {
   let child = node.root._;
   for (let i = count - 1; child && i >= 0; i--) {
     const key = arrNodeKeys[i];
-    child = key !== "size" && (isMap(child) || child instanceof WeakMap) ? child.get(key) : child[key];
+    child = key !== "size" && isMap(child) ? child.get(key) : child[key];
   }
   return child;
 }
@@ -229,7 +233,9 @@ function ensureNodeValue(node) {
   if (!value || isFunction(value)) {
     if (isChildNode(node)) {
       const parent = ensureNodeValue(node.parent);
-      value = parent[node.key] = {};
+      const useSetFn = isSet(parent);
+      const useMapFn = isMap(parent);
+      value = setNewValue(parent, node.key, {}, useSetFn, useMapFn);
     } else {
       value = node.root._ = {};
     }
@@ -257,6 +263,9 @@ function extractFunction(node, key, fnOrComputed) {
 function equals(a, b) {
   return a === b || isDate(a) && isDate(b) && +a === +b;
 }
+function getKeys(obj, isArr, isMap2, isSet2) {
+  return isArr ? void 0 : obj ? isSet2 ? Array.from(obj) : isMap2 ? Array.from(obj.keys()) : Object.keys(obj) : [];
+}
 
 // src/ObservableHint.ts
 function addSymbol(value, symbol) {
@@ -276,16 +285,27 @@ var ObservableHint = {
   },
   plain: function plainObject(value) {
     return addSymbol(value, symbolPlain);
+  },
+  function: function plainObject2(value) {
+    return addSymbol(value, symbolPlain);
   }
 };
 
+// src/checkPlain.ts
+function checkPlain(node, value) {
+  var _a;
+  if (!node.isPlain && (((_a = node.parent) == null ? void 0 : _a.isPlain) || isHintPlain(value))) {
+    node.isPlain = true;
+  }
+}
+
 // src/helpers.ts
-function computeSelector(selector, e, retainObservable) {
+function computeSelector(selector, getOptions, e, retainObservable) {
   let c = selector;
   if (!isObservable(c) && isFunction(c)) {
     c = e ? c(e) : c();
   }
-  return isObservable(c) && !retainObservable ? c.get() : c;
+  return isObservable(c) && !retainObservable ? c.get(getOptions) : c;
 }
 function getObservableIndex(value$) {
   const node = getNode(value$);
@@ -384,7 +404,7 @@ function _mergeIntoObservable(target, source, levelsDeep) {
   const isSourceSet = isSet(source);
   if (isSourceSet && isSet(targetValue)) {
     target.set(/* @__PURE__ */ new Set([...source, ...targetValue]));
-  } else if (isTargetObj && isObject(source) && !isEmpty(targetValue) || isTargetArr && targetValue.length > 0) {
+  } else if (isTargetObj && isObject(source) || isTargetArr && targetValue.length > 0) {
     const keys = isSourceMap || isSourceSet ? Array.from(source.keys()) : Object.keys(source);
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
@@ -590,6 +610,7 @@ function computeChangesAtNode(changesInBatch, node, isFromPersist, isFromSync, v
       if (!isArraySubset(changes[0].path, change.path)) {
         changes.push(change);
         changeInBatch.level = Math.min(changeInBatch.level, level);
+        changeInBatch.whenOptimizedOnlyIf || (changeInBatch.whenOptimizedOnlyIf = whenOptimizedOnlyIf);
       }
     } else {
       changesInBatch.set(node, {
@@ -604,37 +625,39 @@ function computeChangesAtNode(changesInBatch, node, isFromPersist, isFromSync, v
   }
 }
 function computeChangesRecursive(changesInBatch, node, loading, remote, value, path, pathTypes, valueAtPath, prevAtPath, immediate, level, whenOptimizedOnlyIf) {
-  computeChangesAtNode(
-    changesInBatch,
-    node,
-    loading,
-    remote,
-    value,
-    path,
-    pathTypes,
-    valueAtPath,
-    prevAtPath,
-    immediate,
-    level,
-    whenOptimizedOnlyIf
-  );
-  if (node.linkedFromNodes) {
-    for (const linkedFromNode of node.linkedFromNodes) {
-      const childNode = getNodeAtPath(linkedFromNode, path);
-      computeChangesRecursive(
-        changesInBatch,
-        childNode,
-        loading,
-        remote,
-        valueAtPath,
-        [],
-        [],
-        valueAtPath,
-        prevAtPath,
-        immediate,
-        0,
-        whenOptimizedOnlyIf
-      );
+  if (node.numListenersRecursive > 0) {
+    computeChangesAtNode(
+      changesInBatch,
+      node,
+      loading,
+      remote,
+      value,
+      path,
+      pathTypes,
+      valueAtPath,
+      prevAtPath,
+      immediate,
+      level,
+      whenOptimizedOnlyIf
+    );
+    if (node.linkedFromNodes) {
+      for (const linkedFromNode of node.linkedFromNodes) {
+        const childNode = getNodeAtPath(linkedFromNode, path);
+        computeChangesRecursive(
+          changesInBatch,
+          childNode,
+          loading,
+          remote,
+          valueAtPath,
+          [],
+          [],
+          valueAtPath,
+          prevAtPath,
+          immediate,
+          0,
+          whenOptimizedOnlyIf
+        );
+      }
     }
   }
   if (node.parent) {
@@ -811,6 +834,109 @@ function linked(params, options) {
   return ret;
 }
 
+// src/middleware.ts
+var nodeMiddlewareHandlers = /* @__PURE__ */ new WeakMap();
+var queuedNodes = [];
+var queuedListeners = [];
+var queuedTypes = [];
+var queueSize = 0;
+var isMicrotaskScheduled = false;
+function registerMiddleware(node, type, handler) {
+  let handlersMap = nodeMiddlewareHandlers.get(node);
+  if (!handlersMap) {
+    handlersMap = /* @__PURE__ */ new Map();
+    nodeMiddlewareHandlers.set(node, handlersMap);
+  }
+  let handlers = handlersMap.get(type);
+  if (!handlers) {
+    handlers = /* @__PURE__ */ new Set();
+    handlersMap.set(type, handlers);
+  }
+  handlers.add(handler);
+  return () => {
+    const handlersMap2 = nodeMiddlewareHandlers.get(node);
+    if (!handlersMap2)
+      return;
+    const handlers2 = handlersMap2.get(type);
+    if (!handlers2)
+      return;
+    handlers2.delete(handler);
+    if (handlers2.size === 0) {
+      handlersMap2.delete(type);
+      if (handlersMap2.size === 0) {
+        nodeMiddlewareHandlers.delete(node);
+      }
+    }
+  };
+}
+function dispatchMiddlewareEvent(node, listener, type) {
+  const handlersMap = nodeMiddlewareHandlers.get(node);
+  if (!handlersMap || !handlersMap.has(type)) {
+    return;
+  }
+  const handlers = handlersMap.get(type);
+  if (!handlers || handlers.size === 0) {
+    return;
+  }
+  queuedNodes[queueSize] = node;
+  queuedListeners[queueSize] = listener;
+  queuedTypes[queueSize] = type;
+  queueSize++;
+  if (!isMicrotaskScheduled) {
+    isMicrotaskScheduled = true;
+    queueMicrotask(processQueuedEvents);
+  }
+}
+var eventObj = {
+  type: "listener-added",
+  node: null,
+  listener: void 0,
+  timestamp: 0
+};
+function processQueuedEvents() {
+  isMicrotaskScheduled = false;
+  const timestamp = typeof performance !== "undefined" ? performance.now() : Date.now();
+  eventObj.timestamp = timestamp;
+  for (let i = 0; i < queueSize; i++) {
+    const node = queuedNodes[i];
+    const listener = queuedListeners[i];
+    const type = queuedTypes[i];
+    const handlersMap = nodeMiddlewareHandlers.get(node);
+    if (!handlersMap)
+      continue;
+    const handlers = handlersMap.get(type);
+    if (!handlers || handlers.size === 0)
+      continue;
+    const nodeListeners = node.listeners;
+    const nodeListenersImmediate = node.listenersImmediate;
+    if (!nodeListeners && !nodeListenersImmediate) {
+      continue;
+    }
+    let isValid = false;
+    if (type === "listener-added") {
+      isValid = !!(nodeListeners == null ? void 0 : nodeListeners.has(listener)) || !!(nodeListenersImmediate == null ? void 0 : nodeListenersImmediate.has(listener));
+    } else if (type === "listener-removed") {
+      isValid = !(nodeListeners == null ? void 0 : nodeListeners.has(listener)) && !(nodeListenersImmediate == null ? void 0 : nodeListenersImmediate.has(listener));
+    } else {
+      isValid = !(nodeListeners == null ? void 0 : nodeListeners.size) && !(nodeListenersImmediate == null ? void 0 : nodeListenersImmediate.size);
+    }
+    if (isValid) {
+      eventObj.type = type;
+      eventObj.node = node;
+      eventObj.listener = listener;
+      const iterableHandlers = Array.from(handlers);
+      for (let j = 0; j < iterableHandlers.length; j++) {
+        try {
+          iterableHandlers[j](eventObj);
+        } catch (error) {
+          console.error(`Error in middleware handler for ${type}:`, error);
+        }
+      }
+    }
+  }
+  queueSize = 0;
+}
+
 // src/onChange.ts
 function onChange(node, callback, options = {}, fromLinks) {
   var _a;
@@ -881,6 +1007,7 @@ function onChange(node, callback, options = {}, fromLinks) {
     pathParent = [parent.key, ...pathParent];
     parent = parent.parent;
   }
+  dispatchMiddlewareEvent(node, listener, "listener-added");
   return () => {
     listeners.delete(listener);
     extraDisposes == null ? void 0 : extraDisposes.forEach((fn) => fn());
@@ -889,6 +1016,10 @@ function onChange(node, callback, options = {}, fromLinks) {
       parent2.numListenersRecursive--;
       parent2 = parent2.parent;
     }
+    dispatchMiddlewareEvent(node, listener, "listener-removed");
+    if (listeners.size === 0) {
+      dispatchMiddlewareEvent(node, void 0, "listeners-cleared");
+    }
   };
 }
 function createCb(linkedFromNode, path, callback) {
@@ -969,13 +1100,13 @@ function updateTracking(node, track) {
 }
 
 // src/trackSelector.ts
-function trackSelector(selector, update, observeEvent, observeOptions, createResubscribe) {
+function trackSelector(selector, update, getOptions, observeEvent, observeOptions, createResubscribe) {
   var _a;
   let dispose;
   let resubscribe;
   let updateFn = update;
   beginTracking();
-  const value = selector ? computeSelector(selector, observeEvent, observeOptions == null ? void 0 : observeOptions.fromComputed) : selector;
+  const value = selector ? computeSelector(selector, getOptions, observeEvent, observeOptions == null ? void 0 : observeOptions.fromComputed) : selector;
   const tracker = tracking.current;
   const nodes = tracker.nodes;
   endTracking();
@@ -1023,7 +1154,11 @@ function observe(selectorOrRun, reactionOrOptions, options) {
     beginBatch();
     delete e.value;
     dispose == null ? void 0 : dispose();
-    const { dispose: _dispose, value, nodes } = trackSelector(selectorOrRun, update, e, options);
+    const {
+      dispose: _dispose,
+      value,
+      nodes
+    } = trackSelector(selectorOrRun, update, void 0, e, options);
     dispose = _dispose;
     e.value = value;
     e.nodes = nodes;
@@ -1068,10 +1203,13 @@ function _when(predicate, effect, checkReady) {
       let isOk = true;
       if (isArray(ret)) {
         for (let i = 0; i < ret.length; i++) {
-          if (isObservable(ret[i])) {
-            ret[i] = computeSelector(ret[i]);
+          let item = ret[i];
+          if (isObservable(item)) {
+            item = computeSelector(item);
+          } else if (isFunction(item)) {
+            item = item();
           }
-          isOk = isOk && !!(checkReady ? isObservableValueReady(ret[i]) : ret[i]);
+          isOk = isOk && !!(checkReady ? isObservableValueReady(item) : item);
         }
       } else {
         isOk = checkReady ? isObservableValueReady(ret) : ret;
@@ -1170,9 +1308,6 @@ function collectionSetter(node, target, prop, ...args) {
     return ret;
   }
 }
-function getKeys(obj, isArr, isMap2) {
-  return isArr ? void 0 : obj ? isMap2 ? Array.from(obj.keys()) : Object.keys(obj) : [];
-}
 function updateNodes(parent, obj, prevValue) {
   var _a, _b, _c;
   if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && typeof __devUpdateNodes !== "undefined" && isObject(obj)) {
@@ -1201,9 +1336,11 @@ function updateNodes(parent, obj, prevValue) {
   let prevChildrenById;
   let moved;
   const isCurMap = isMap(obj);
+  const isCurSet = isSet(obj);
   const isPrevMap = isMap(prevValue);
-  const keys = getKeys(obj, isArr, isCurMap);
-  const keysPrev = getKeys(prevValue, isArr, isPrevMap);
+  const isPrevSet = isSet(prevValue);
+  const keys = getKeys(obj, isArr, isCurMap, isCurSet);
+  const keysPrev = getKeys(prevValue, isArr, isPrevMap, isPrevSet);
   const length = ((_a = keys || obj) == null ? void 0 : _a.length) || 0;
   const lengthPrev = ((_b = keysPrev || prevValue) == null ? void 0 : _b.length) || 0;
   let idField;
@@ -1436,7 +1573,8 @@ var proxyHandler = {
     }
     if (isNullOrUndefined(value) && vProp === void 0 && (ArrayModifiers.has(p) || ArrayLoopers.has(p))) {
       value = [];
-      setNodeValue(node, value);
+      if (ArrayModifiers.has(p))
+        setNodeValue(node, value);
       vProp = value[p];
     }
     if (isFunction(vProp)) {
@@ -1515,7 +1653,11 @@ var proxyHandler = {
       return { configurable: false, enumerable: false };
     }
     const value = getNodeValue(node);
-    return isPrimitive(value) ? void 0 : Reflect.getOwnPropertyDescriptor(value, prop);
+    if (isPrimitive(value)) {
+      return void 0;
+    }
+    const descriptor = Reflect.getOwnPropertyDescriptor(value, prop);
+    return descriptor ? { ...descriptor, configurable: true } : void 0;
   },
   set(node, prop, value) {
     if (node.isSetting) {
@@ -1553,7 +1695,9 @@ var proxyHandler = {
     if (isObservable(thisArg)) {
       thisArg = thisArg.peek();
     }
-    return Reflect.apply(target.lazyFn || target, thisArg, argArray);
+    const fnRaw = getNodeValue(target);
+    const fn = isFunction(fnRaw) ? fnRaw : target.lazyFn || target;
+    return Reflect.apply(fn, thisArg, argArray);
   }
 };
 function set(node, newValue) {
@@ -1578,6 +1722,7 @@ function setKey(node, key, newValue, level) {
     }
   }
   const isRoot = !node.parent && key === "_";
+  checkPlain(node, newValue);
   if (node.parent && !getNodeValue(node) && !isFunction(newValue)) {
     set(node, { [key]: newValue });
   }
@@ -1585,8 +1730,8 @@ function setKey(node, key, newValue, level) {
   if (isObservable(newValue)) {
     setToObservable(childNode, newValue);
   } else {
-    const { newValue: savedValue, prevValue } = setNodeValue(childNode, newValue);
-    const isPrim = isPrimitive(savedValue) || savedValue instanceof Date;
+    const { newValue: savedValue, prevValue, parentValue } = setNodeValue(childNode, newValue);
+    const isPrim = isPrimitive(prevValue) || prevValue instanceof Date || isPrimitive(savedValue) || savedValue instanceof Date;
     if (!isPrim) {
       let parent = childNode;
       do {
@@ -1595,9 +1740,19 @@ function setKey(node, key, newValue, level) {
       } while (parent = parent.parent);
     }
     const notify2 = !equals(savedValue, prevValue);
-    const forceNotify = !notify2 && childNode.isComputing && !isPrim;
-    if (notify2 || forceNotify) {
-      updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level, forceNotify);
+    const forceNotify = !notify2 && childNode.isComputing && !isPrim && !childNode.isPlain;
+    if ((notify2 || forceNotify) && !(childNode.isComputing && childNode.isPlain && node.numListenersRecursive === 0)) {
+      updateNodesAndNotify(
+        node,
+        savedValue,
+        prevValue,
+        childNode,
+        parentValue,
+        isPrim,
+        isRoot,
+        level,
+        forceNotify
+      );
     }
     extractFunctionOrComputed(node, key, savedValue);
   }
@@ -1652,7 +1807,7 @@ function handlerMapSet(node, p, value) {
   } else if (isFunction(vProp)) {
     return function(a, b, c) {
       const l = arguments.length;
-      const valueMap = value;
+      const valueMapOrSet = value;
       if (p === "get") {
         if (l > 0 && typeof a !== "boolean" && a !== optimized) {
           return getProxy(node, a);
@@ -1666,14 +1821,14 @@ function handlerMapSet(node, p, value) {
         return getProxy(node);
       } else if (p === "delete") {
         if (l > 0) {
-          const prev = value.get ? valueMap.get(a) : a;
+          const prev = value.get ? valueMapOrSet.get(a) : a;
           deleteFn(node, a);
           return prev !== void 0;
         }
       } else if (p === "clear") {
-        const prev = new Map(valueMap);
-        const size = valueMap.size;
-        valueMap.clear();
+        const prev = isSet(valueMapOrSet) ? new Set(valueMapOrSet) : new Map(valueMapOrSet);
+        const size = valueMapOrSet.size;
+        valueMapOrSet.clear();
         if (size) {
           updateNodesAndNotify(node, value, prev);
         }
@@ -1704,7 +1859,7 @@ function handlerMapSet(node, p, value) {
     };
   }
 }
-function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRoot, level, forceNotify) {
+function updateNodesAndNotify(node, newValue, prevValue, childNode, parentValue, isPrim, isRoot, level, forceNotify) {
   if (!childNode)
     childNode = node;
   beginBatch();
@@ -1713,15 +1868,29 @@ function updateNodesAndNotify(node, newValue, prevValue, childNode, isPrim, isRo
   }
   let hasADiff = forceNotify || isPrim;
   let whenOptimizedOnlyIf = false;
+  let valueAsArr;
+  let valueAsMap;
   if (!isPrim || prevValue && !isPrimitive(prevValue)) {
     if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") && typeof __devUpdateNodes !== "undefined") {
       __devUpdateNodes.clear();
     }
     hasADiff = hasADiff || updateNodes(childNode, newValue, prevValue);
     if (isArray(newValue)) {
-      whenOptimizedOnlyIf = (newValue == null ? void 0 : newValue.length) !== (prevValue == null ? void 0 : prevValue.length);
+      valueAsArr = newValue;
+    } else if (isMap(newValue) || isSet(newValue)) {
+      valueAsMap = newValue;
     }
   }
+  if (isArray(parentValue)) {
+    valueAsArr = parentValue;
+  } else if (isMap(parentValue) || isSet(parentValue)) {
+    valueAsMap = parentValue;
+  }
+  if (valueAsArr) {
+    whenOptimizedOnlyIf = (valueAsArr == null ? void 0 : valueAsArr.length) !== (prevValue == null ? void 0 : prevValue.length);
+  } else if (valueAsMap) {
+    whenOptimizedOnlyIf = (valueAsMap == null ? void 0 : valueAsMap.size) !== (prevValue == null ? void 0 : prevValue.size);
+  }
   if (isPrim || !newValue || isEmpty(newValue) && !isEmpty(prevValue) ? newValue !== prevValue : hasADiff) {
     notify(
       isPrim && isRoot ? node : childNode,
@@ -1803,7 +1972,7 @@ function peekInternal(node, activateRecursive) {
   }
   isFlushing = false;
   let value = getNodeValue(node);
-  if (!globalState.isLoadingLocal) {
+  if (!node.root.isLoadingLocal && !node.isPlain) {
     value = checkLazy(node, value, !!activateRecursive);
   }
   return value;
@@ -1834,7 +2003,8 @@ function checkLazy(node, value, activateRecursive) {
       value = extractFunctionOrComputed(node.parent, node.key, value);
     }
   }
-  if ((lazy || node.needsExtract) && !isObservable(value) && !isPrimitive(value)) {
+  checkPlain(node, value);
+  if ((lazy || node.needsExtract) && !node.isPlain && !isObservable(value) && !isPrimitive(value)) {
     if (activateRecursive) {
       recursivelyAutoActivate(value, node);
     }
@@ -1857,11 +2027,14 @@ function checkProperty(value, key) {
     return value[key];
   }
 }
-function reactivateNode(node, lazyFn) {
+function deactivateNode(node) {
   var _a, _b;
   (_a = node.activatedObserveDispose) == null ? void 0 : _a.call(node);
   (_b = node.linkedToNodeDispose) == null ? void 0 : _b.call(node);
   node.activatedObserveDispose = node.linkedToNodeDispose = node.linkedToNode = void 0;
+}
+function reactivateNode(node, lazyFn) {
+  deactivateNode(node);
   node.lazyFn = lazyFn;
   node.lazy = true;
 }
@@ -1909,7 +2082,7 @@ function activateNodeFunction(node, lazyFn) {
     node.dirtyFn = refreshFn;
     globalState.dirtyNodes.add(node);
   }
-  node.activatedObserveDispose = observe(
+  const observeDispose = observe(
     () => {
       var _a, _b, _c, _d;
       if (isFirst) {
@@ -1963,6 +2136,9 @@ function activateNodeFunction(node, lazyFn) {
           value = (_d = (_c = activated2.get) == null ? void 0 : _c.call(activated2)) != null ? _d : activated2.initial;
         }
       }
+      if (ignoreThisUpdate) {
+        activatedValue = value;
+      }
       wasPromise = wasPromise || isPromise(value);
       return value;
     },
@@ -2009,6 +2185,10 @@ function activateNodeFunction(node, lazyFn) {
     },
     { fromComputed: true }
   );
+  node.activatedObserveDispose = () => {
+    observeDispose == null ? void 0 : observeDispose();
+    disposes.forEach((fn) => fn());
+  };
   return activatedValue;
 }
 function activateNodeBase(node, value) {
@@ -2274,7 +2454,14 @@ function syncState(obs) {
         syncCount: 0,
         resetPersistence: void 0,
         reset: () => Promise.resolve(),
-        sync: () => Promise.resolve(),
+        sync: () => {
+          var _a;
+          obs.peek();
+          if ((_a = node.state) == null ? void 0 : _a.isGetting.peek()) {
+            return when(node.state.isLoaded);
+          }
+          return Promise.resolve();
+        },
         getPendingChanges: () => ({}),
         // TODOV3 remove
         clearPersist: void 0
@@ -2288,10 +2475,13 @@ function syncState(obs) {
 var internal = {
   createPreviousHandler,
   clone,
+  deactivateNode,
   deepMerge,
   ensureNodeValue,
   findIDKey,
   get,
+  getChildNode,
+  getKeys,
   getNode,
   getNodeValue,
   getPathType,
@@ -2304,6 +2494,8 @@ var internal = {
   observableFns,
   optimized,
   peek,
+  reactivateNode,
+  registerMiddleware,
   safeParse,
   safeStringify,
   set,