@legendapp/state 3.0.0-beta.3 → 3.0.0-beta.30

package/index.mjs

@@ -179,7 +179,7 @@ function setNodeValue(node, newValue) {
       parentNode.isSetting--;
     }
   }
-  return { prevValue, newValue };
+  return { prevValue, newValue, parentValue };
 }
 var arrNodeKeys = [];
 function getNodeValue(node) {
@@ -255,6 +255,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) {
@@ -274,16 +277,19 @@ var ObservableHint = {
   },
   plain: function plainObject(value) {
     return addSymbol(value, symbolPlain);
+  },
+  function: function plainObject2(value) {
+    return addSymbol(value, symbolPlain);
   }
 };
 
 // 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$);
@@ -382,7 +388,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];
@@ -588,6 +594,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, {
@@ -809,6 +816,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;
@@ -879,6 +989,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());
@@ -887,6 +998,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) {
@@ -967,13 +1082,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();
@@ -1021,7 +1136,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;
@@ -1066,10 +1185,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;
@@ -1168,9 +1290,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)) {
@@ -1199,9 +1318,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;
@@ -1551,7 +1672,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) {
@@ -1583,8 +1706,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,7 +1718,17 @@ function setKey(node, key, newValue, level) {
     const notify2 = !equals(savedValue, prevValue);
     const forceNotify = !notify2 && childNode.isComputing && !isPrim;
     if (notify2 || forceNotify) {
-      updateNodesAndNotify(node, savedValue, prevValue, childNode, isPrim, isRoot, level, forceNotify);
+      updateNodesAndNotify(
+        node,
+        savedValue,
+        prevValue,
+        childNode,
+        parentValue,
+        isPrim,
+        isRoot,
+        level,
+        forceNotify
+      );
     }
     extractFunctionOrComputed(node, key, savedValue);
   }
@@ -1650,7 +1783,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);
@@ -1664,14 +1797,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);
         }
@@ -1702,7 +1835,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();
@@ -1711,15 +1844,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,
@@ -1786,7 +1933,7 @@ function peek(node) {
 }
 var isFlushing = false;
 function peekInternal(node, activateRecursive) {
-  var _a;
+  var _a, _b;
   isFlushing = true;
   if (activateRecursive && ((_a = node.dirtyChildren) == null ? void 0 : _a.size)) {
     const dirty = Array.from(node.dirtyChildren);
@@ -1801,7 +1948,10 @@ function peekInternal(node, activateRecursive) {
   }
   isFlushing = false;
   let value = getNodeValue(node);
-  if (!globalState.isLoadingLocal) {
+  if (((_b = node.parent) == null ? void 0 : _b.isPlain) || isHintPlain(value)) {
+    node.isPlain = true;
+  }
+  if (!node.root.isLoadingLocal && !node.isPlain) {
     value = checkLazy(node, value, !!activateRecursive);
   }
   return value;
@@ -1961,6 +2111,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;
     },
@@ -2272,7 +2425,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
@@ -2290,6 +2450,7 @@ var internal = {
   ensureNodeValue,
   findIDKey,
   get,
+  getKeys,
   getNode,
   getNodeValue,
   getPathType,
@@ -2302,6 +2463,7 @@ var internal = {
   observableFns,
   optimized,
   peek,
+  registerMiddleware,
   safeParse,
   safeStringify,
   set,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/state",
-  "version": "3.0.0-beta.3",
+  "version": "3.0.0-beta.30",
   "description": "legend-state",
   "sideEffects": false,
   "private": false,
@@ -13,6 +13,14 @@
   "dependencies": {
     "use-sync-external-store": "^1.2.2"
   },
+  "peerDependencies": {
+    "expo-sqlite": "^15.0.0"
+  },
+  "peerDependenciesMeta": {
+    "expo-sqlite": {
+      "optional": true
+    }
+  },
   "author": "Legend <contact@legendapp.com> (https://github.com/LegendApp)",
   "keywords": [
     "react",
@@ -48,6 +56,12 @@
     "./types/babel": {
       "types": "./types/babel.d.ts"
     },
+    "./types/reactive-web": {
+      "types": "./types/reactive-web.d.ts"
+    },
+    "./types/reactive-native": {
+      "types": "./types/reactive-native.d.ts"
+    },
     ".": {
       "import": "./index.mjs",
       "require": "./index.js",
@@ -63,6 +77,16 @@
       "require": "./react.js",
       "types": "./react.d.ts"
     },
+    "./react-native": {
+      "import": "./react-native.mjs",
+      "require": "./react-native.js",
+      "types": "./react-native.d.ts"
+    },
+    "./react-web": {
+      "import": "./react-web.mjs",
+      "require": "./react-web.js",
+      "types": "./react-web.d.ts"
+    },
     "./trace": {
       "import": "./trace.mjs",
       "require": "./trace.js",
@@ -73,6 +97,11 @@
       "require": "./react-reactive/enableReactive.js",
       "types": "./react-reactive/enableReactive.d.ts"
     },
+    "./react-reactive/Components": {
+      "import": "./react-reactive/Components.mjs",
+      "require": "./react-reactive/Components.js",
+      "types": "./react-reactive/Components.d.ts"
+    },
     "./react-reactive/enableReactComponents": {
       "import": "./react-reactive/enableReactComponents.mjs",
       "require": "./react-reactive/enableReactComponents.js",
@@ -228,6 +257,11 @@
       "require": "./persist-plugins/local-storage.js",
       "types": "./persist-plugins/local-storage.d.ts"
     },
+    "./persist-plugins/expo-sqlite": {
+      "import": "./persist-plugins/expo-sqlite.mjs",
+      "require": "./persist-plugins/expo-sqlite.js",
+      "types": "./persist-plugins/expo-sqlite.d.ts"
+    },
     "./persist-plugins/async-storage": {
       "import": "./persist-plugins/async-storage.mjs",
       "require": "./persist-plugins/async-storage.js",

package/persist-plugins/async-storage.js

@@ -21,7 +21,10 @@ var ObservablePersistAsyncStorage = class {
         if (preload === true) {
           tables = await AsyncStorage.getAllKeys();
         } else if (state.isArray(preload)) {
-          tables = preload;
+          const metadataTables = preload.map(
+            (table) => table.endsWith(MetadataSuffix) ? void 0 : table + MetadataSuffix
+          );
+          tables = [...preload, ...metadataTables.filter(Boolean)];
         }
         if (tables) {
           const values = await AsyncStorage.multiGet(tables);
@@ -38,14 +41,19 @@ var ObservablePersistAsyncStorage = class {
   }
   loadTable(table) {
     if (this.data[table] === void 0) {
-      try {
-        return (async () => {
-          const value = await AsyncStorage.getItem(table);
-          this.data[table] = value ? safeParse(value) : void 0;
-        })();
-      } catch (e) {
-        console.error("[legend-state] ObservablePersistLocalAsyncStorage failed to parse", table);
-      }
+      return AsyncStorage.multiGet([table, table + MetadataSuffix]).then((values) => {
+        try {
+          values.forEach(([table2, value]) => {
+            this.data[table2] = value ? safeParse(value) : void 0;
+          });
+        } catch (err) {
+          console.error("[legend-state] ObservablePersistLocalAsyncStorage failed to parse", table, err);
+        }
+      }).catch((err) => {
+        if ((err == null ? void 0 : err.message) !== "window is not defined") {
+          console.error("[legend-state] AsyncStorage.multiGet failed", table, err);
+        }
+      });
     }
   }
   // Gets

package/persist-plugins/async-storage.mjs

@@ -19,7 +19,10 @@ var ObservablePersistAsyncStorage = class {
         if (preload === true) {
           tables = await AsyncStorage.getAllKeys();
         } else if (isArray(preload)) {
-          tables = preload;
+          const metadataTables = preload.map(
+            (table) => table.endsWith(MetadataSuffix) ? void 0 : table + MetadataSuffix
+          );
+          tables = [...preload, ...metadataTables.filter(Boolean)];
         }
         if (tables) {
           const values = await AsyncStorage.multiGet(tables);
@@ -36,14 +39,19 @@ var ObservablePersistAsyncStorage = class {
   }
   loadTable(table) {
     if (this.data[table] === void 0) {
-      try {
-        return (async () => {
-          const value = await AsyncStorage.getItem(table);
-          this.data[table] = value ? safeParse(value) : void 0;
-        })();
-      } catch (e) {
-        console.error("[legend-state] ObservablePersistLocalAsyncStorage failed to parse", table);
-      }
+      return AsyncStorage.multiGet([table, table + MetadataSuffix]).then((values) => {
+        try {
+          values.forEach(([table2, value]) => {
+            this.data[table2] = value ? safeParse(value) : void 0;
+          });
+        } catch (err) {
+          console.error("[legend-state] ObservablePersistLocalAsyncStorage failed to parse", table, err);
+        }
+      }).catch((err) => {
+        if ((err == null ? void 0 : err.message) !== "window is not defined") {
+          console.error("[legend-state] AsyncStorage.multiGet failed", table, err);
+        }
+      });
     }
   }
   // Gets

package/persist-plugins/expo-sqlite.d.mts

@@ -0,0 +1,19 @@
+import { Change } from '@legendapp/state';
+import { ObservablePersistPlugin, PersistMetadata } from '@legendapp/state/sync';
+import { SQLiteStorage } from 'expo-sqlite/kv-store';
+
+declare class ObservablePersistSqlite implements ObservablePersistPlugin {
+    private data;
+    private storage;
+    constructor(storage: SQLiteStorage);
+    getTable(table: string, init: any): any;
+    getMetadata(table: string): PersistMetadata;
+    set(table: string, changes: Change[]): void;
+    setMetadata(table: string, metadata: PersistMetadata): void;
+    deleteTable(table: string): undefined;
+    deleteMetadata(table: string): void;
+    private save;
+}
+declare function observablePersistSqlite(storage: SQLiteStorage): ObservablePersistSqlite;
+
+export { ObservablePersistSqlite, observablePersistSqlite };

package/persist-plugins/expo-sqlite.d.ts

@@ -0,0 +1,19 @@
+import { Change } from '@legendapp/state';
+import { ObservablePersistPlugin, PersistMetadata } from '@legendapp/state/sync';
+import { SQLiteStorage } from 'expo-sqlite/kv-store';
+
+declare class ObservablePersistSqlite implements ObservablePersistPlugin {
+    private data;
+    private storage;
+    constructor(storage: SQLiteStorage);
+    getTable(table: string, init: any): any;
+    getMetadata(table: string): PersistMetadata;
+    set(table: string, changes: Change[]): void;
+    setMetadata(table: string, metadata: PersistMetadata): void;
+    deleteTable(table: string): undefined;
+    deleteMetadata(table: string): void;
+    private save;
+}
+declare function observablePersistSqlite(storage: SQLiteStorage): ObservablePersistSqlite;
+
+export { ObservablePersistSqlite, observablePersistSqlite };

package/persist-plugins/expo-sqlite.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var state = require('@legendapp/state');
+
+// src/persist-plugins/expo-sqlite.ts
+var { safeParse, safeStringify } = state.internal;
+var MetadataSuffix = "__m";
+var ObservablePersistSqlite = class {
+  constructor(storage) {
+    this.data = {};
+    if (!storage) {
+      console.error(
+        "[legend-state] ObservablePersistSqlite failed to initialize. You need to pass the SQLiteStorage instance."
+      );
+    }
+    this.storage = storage;
+  }
+  getTable(table, init) {
+    if (!this.storage)
+      return void 0;
+    if (this.data[table] === void 0) {
+      try {
+        const value = this.storage.getItemSync(table);
+        this.data[table] = value ? safeParse(value) : init;
+      } catch (e) {
+        console.error("[legend-state] ObservablePersistSqlite failed to parse", table);
+      }
+    }
+    return this.data[table];
+  }
+  getMetadata(table) {
+    return this.getTable(table + MetadataSuffix, {});
+  }
+  set(table, changes) {
+    if (!this.data[table]) {
+      this.data[table] = {};
+    }
+    this.data[table] = state.applyChanges(this.data[table], changes);
+    this.save(table);
+  }
+  setMetadata(table, metadata) {
+    table = table + MetadataSuffix;
+    this.data[table] = metadata;
+    this.save(table);
+  }
+  deleteTable(table) {
+    if (!this.storage)
+      return void 0;
+    delete this.data[table];
+    this.storage.removeItemSync(table);
+  }
+  deleteMetadata(table) {
+    this.deleteTable(table + MetadataSuffix);
+  }
+  // Private
+  save(table) {
+    if (!this.storage)
+      return void 0;
+    const v = this.data[table];
+    if (v !== void 0 && v !== null) {
+      this.storage.setItemSync(table, safeStringify(v));
+    } else {
+      this.storage.removeItemSync(table);
+    }
+  }
+};
+function observablePersistSqlite(storage) {
+  return new ObservablePersistSqlite(storage);
+}
+
+exports.ObservablePersistSqlite = ObservablePersistSqlite;
+exports.observablePersistSqlite = observablePersistSqlite;