@legendapp/state 3.0.0-alpha.1 → 3.0.0-alpha.3

package/persist-plugins/async-storage.js

@@ -2,97 +2,90 @@
 
 var state = require('@legendapp/state');
 
-const MetadataSuffix = '__m';
-let AsyncStorage;
-const { safeParse, safeStringify } = state.internal;
-class ObservablePersistAsyncStorage {
-    constructor() {
-        this.data = {};
-    }
-    // Init
-    async initialize(config) {
-        let tables = [];
-        const storageConfig = config.asyncStorage;
-        if (storageConfig) {
-            AsyncStorage = storageConfig.AsyncStorage;
-            const { preload } = storageConfig;
-            try {
-                if (preload === true) {
-                    // If preloadAllKeys, load all keys and preload tables on startup
-                    tables = await AsyncStorage.getAllKeys();
-                }
-                else if (state.isArray(preload)) {
-                    // If preloadKeys, preload load the tables on startup
-                    tables = preload;
-                }
-                if (tables) {
-                    const values = await AsyncStorage.multiGet(tables);
-                    values.forEach(([table, value]) => {
-                        this.data[table] = value ? safeParse(value) : undefined;
-                    });
-                }
-            }
-            catch (e) {
-                console.error('[legend-state] ObservablePersistAsyncStorage failed to initialize', e);
-            }
-        }
-        else {
-            console.error('[legend-state] Missing asyncStorage configuration');
+// src/persist-plugins/async-storage.ts
+var MetadataSuffix = "__m";
+var AsyncStorage;
+var { safeParse, safeStringify } = state.internal;
+var ObservablePersistAsyncStorage = class {
+  constructor() {
+    this.data = {};
+  }
+  // Init
+  async initialize(config) {
+    let tables = [];
+    const storageConfig = config.asyncStorage;
+    if (storageConfig) {
+      AsyncStorage = storageConfig.AsyncStorage;
+      const { preload } = storageConfig;
+      try {
+        if (preload === true) {
+          tables = await AsyncStorage.getAllKeys();
+        } else if (state.isArray(preload)) {
+          tables = preload;
         }
-    }
-    loadTable(table) {
-        if (this.data[table] === undefined) {
-            try {
-                return (async () => {
-                    const value = await AsyncStorage.getItem(table);
-                    this.data[table] = value ? safeParse(value) : undefined;
-                })();
-            }
-            catch (_a) {
-                console.error('[legend-state] ObservablePersistLocalAsyncStorage failed to parse', table);
-            }
+        if (tables) {
+          const values = await AsyncStorage.multiGet(tables);
+          values.forEach(([table, value]) => {
+            this.data[table] = value ? safeParse(value) : void 0;
+          });
         }
+      } catch (e) {
+        console.error("[legend-state] ObservablePersistAsyncStorage failed to initialize", e);
+      }
+    } else {
+      console.error("[legend-state] Missing asyncStorage configuration");
     }
-    // Gets
-    getTable(table, init) {
-        var _a, _b;
-        return (_b = (_a = this.data[table]) !== null && _a !== void 0 ? _a : init) !== null && _b !== void 0 ? _b : {};
-    }
-    getMetadata(table) {
-        return this.getTable(table + MetadataSuffix, {});
-    }
-    // Sets
-    set(table, changes) {
-        if (!this.data[table]) {
-            this.data[table] = {};
-        }
-        this.data[table] = state.applyChanges(this.data[table], changes);
-        return this.save(table);
+  }
+  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);
+      }
     }
-    setMetadata(table, metadata) {
-        return this.setValue(table + MetadataSuffix, metadata);
+  }
+  // Gets
+  getTable(table, init) {
+    var _a, _b;
+    return (_b = (_a = this.data[table]) != null ? _a : init) != null ? _b : {};
+  }
+  getMetadata(table) {
+    return this.getTable(table + MetadataSuffix, {});
+  }
+  // Sets
+  set(table, changes) {
+    if (!this.data[table]) {
+      this.data[table] = {};
     }
-    async deleteTable(table) {
-        return AsyncStorage.removeItem(table);
-    }
-    deleteMetadata(table) {
-        return this.deleteTable(table + MetadataSuffix);
-    }
-    // Private
-    async setValue(table, value) {
-        this.data[table] = value;
-        await this.save(table);
-    }
-    async save(table) {
-        const v = this.data[table];
-        if (v !== undefined && v !== null) {
-            return AsyncStorage.setItem(table, safeStringify(v));
-        }
-        else {
-            return AsyncStorage.removeItem(table);
-        }
+    this.data[table] = state.applyChanges(this.data[table], changes);
+    return this.save(table);
+  }
+  setMetadata(table, metadata) {
+    return this.setValue(table + MetadataSuffix, metadata);
+  }
+  async deleteTable(table) {
+    return AsyncStorage.removeItem(table);
+  }
+  deleteMetadata(table) {
+    return this.deleteTable(table + MetadataSuffix);
+  }
+  // Private
+  async setValue(table, value) {
+    this.data[table] = value;
+    await this.save(table);
+  }
+  async save(table) {
+    const v = this.data[table];
+    if (v !== void 0 && v !== null) {
+      return AsyncStorage.setItem(table, safeStringify(v));
+    } else {
+      return AsyncStorage.removeItem(table);
     }
-}
+  }
+};
 
 exports.ObservablePersistAsyncStorage = ObservablePersistAsyncStorage;
-//# sourceMappingURL=async-storage.js.map

package/persist-plugins/async-storage.mjs

@@ -1,96 +1,89 @@
 import { isArray, applyChanges, internal } from '@legendapp/state';
 
-const MetadataSuffix = '__m';
-let AsyncStorage;
-const { safeParse, safeStringify } = internal;
-class ObservablePersistAsyncStorage {
-    constructor() {
-        this.data = {};
-    }
-    // Init
-    async initialize(config) {
-        let tables = [];
-        const storageConfig = config.asyncStorage;
-        if (storageConfig) {
-            AsyncStorage = storageConfig.AsyncStorage;
-            const { preload } = storageConfig;
-            try {
-                if (preload === true) {
-                    // If preloadAllKeys, load all keys and preload tables on startup
-                    tables = await AsyncStorage.getAllKeys();
-                }
-                else if (isArray(preload)) {
-                    // If preloadKeys, preload load the tables on startup
-                    tables = preload;
-                }
-                if (tables) {
-                    const values = await AsyncStorage.multiGet(tables);
-                    values.forEach(([table, value]) => {
-                        this.data[table] = value ? safeParse(value) : undefined;
-                    });
-                }
-            }
-            catch (e) {
-                console.error('[legend-state] ObservablePersistAsyncStorage failed to initialize', e);
-            }
-        }
-        else {
-            console.error('[legend-state] Missing asyncStorage configuration');
+// src/persist-plugins/async-storage.ts
+var MetadataSuffix = "__m";
+var AsyncStorage;
+var { safeParse, safeStringify } = internal;
+var ObservablePersistAsyncStorage = class {
+  constructor() {
+    this.data = {};
+  }
+  // Init
+  async initialize(config) {
+    let tables = [];
+    const storageConfig = config.asyncStorage;
+    if (storageConfig) {
+      AsyncStorage = storageConfig.AsyncStorage;
+      const { preload } = storageConfig;
+      try {
+        if (preload === true) {
+          tables = await AsyncStorage.getAllKeys();
+        } else if (isArray(preload)) {
+          tables = preload;
         }
-    }
-    loadTable(table) {
-        if (this.data[table] === undefined) {
-            try {
-                return (async () => {
-                    const value = await AsyncStorage.getItem(table);
-                    this.data[table] = value ? safeParse(value) : undefined;
-                })();
-            }
-            catch (_a) {
-                console.error('[legend-state] ObservablePersistLocalAsyncStorage failed to parse', table);
-            }
+        if (tables) {
+          const values = await AsyncStorage.multiGet(tables);
+          values.forEach(([table, value]) => {
+            this.data[table] = value ? safeParse(value) : void 0;
+          });
         }
+      } catch (e) {
+        console.error("[legend-state] ObservablePersistAsyncStorage failed to initialize", e);
+      }
+    } else {
+      console.error("[legend-state] Missing asyncStorage configuration");
     }
-    // Gets
-    getTable(table, init) {
-        var _a, _b;
-        return (_b = (_a = this.data[table]) !== null && _a !== void 0 ? _a : init) !== null && _b !== void 0 ? _b : {};
-    }
-    getMetadata(table) {
-        return this.getTable(table + MetadataSuffix, {});
-    }
-    // Sets
-    set(table, changes) {
-        if (!this.data[table]) {
-            this.data[table] = {};
-        }
-        this.data[table] = applyChanges(this.data[table], changes);
-        return this.save(table);
+  }
+  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);
+      }
     }
-    setMetadata(table, metadata) {
-        return this.setValue(table + MetadataSuffix, metadata);
+  }
+  // Gets
+  getTable(table, init) {
+    var _a, _b;
+    return (_b = (_a = this.data[table]) != null ? _a : init) != null ? _b : {};
+  }
+  getMetadata(table) {
+    return this.getTable(table + MetadataSuffix, {});
+  }
+  // Sets
+  set(table, changes) {
+    if (!this.data[table]) {
+      this.data[table] = {};
     }
-    async deleteTable(table) {
-        return AsyncStorage.removeItem(table);
-    }
-    deleteMetadata(table) {
-        return this.deleteTable(table + MetadataSuffix);
-    }
-    // Private
-    async setValue(table, value) {
-        this.data[table] = value;
-        await this.save(table);
-    }
-    async save(table) {
-        const v = this.data[table];
-        if (v !== undefined && v !== null) {
-            return AsyncStorage.setItem(table, safeStringify(v));
-        }
-        else {
-            return AsyncStorage.removeItem(table);
-        }
+    this.data[table] = applyChanges(this.data[table], changes);
+    return this.save(table);
+  }
+  setMetadata(table, metadata) {
+    return this.setValue(table + MetadataSuffix, metadata);
+  }
+  async deleteTable(table) {
+    return AsyncStorage.removeItem(table);
+  }
+  deleteMetadata(table) {
+    return this.deleteTable(table + MetadataSuffix);
+  }
+  // Private
+  async setValue(table, value) {
+    this.data[table] = value;
+    await this.save(table);
+  }
+  async save(table) {
+    const v = this.data[table];
+    if (v !== void 0 && v !== null) {
+      return AsyncStorage.setItem(table, safeStringify(v));
+    } else {
+      return AsyncStorage.removeItem(table);
     }
-}
+  }
+};
 
 export { ObservablePersistAsyncStorage };
-//# sourceMappingURL=async-storage.mjs.map

package/persist-plugins/indexeddb.d.mts

@@ -0,0 +1,29 @@
+import { Change } from '@legendapp/state';
+import { ObservablePersistPlugin, ObservablePersistPluginOptions, PersistOptions, PersistMetadata } from '@legendapp/state/sync';
+
+declare class ObservablePersistIndexedDB implements ObservablePersistPlugin {
+    private tableData;
+    private tableMetadata;
+    private tablesAdjusted;
+    private db;
+    private isSaveTaskQueued;
+    private pendingSaves;
+    private promisesQueued;
+    constructor();
+    initialize(config: ObservablePersistPluginOptions): Promise<void>;
+    loadTable(table: string, config: PersistOptions): void | Promise<void>;
+    getTable(table: string, init: object, config: PersistOptions): any;
+    getMetadata(table: string, config: PersistOptions): any;
+    setMetadata(table: string, metadata: PersistMetadata, config: PersistOptions): Promise<IDBRequest<IDBValidKey>>;
+    deleteMetadata(table: string, config: PersistOptions): Promise<void>;
+    set(table: string, changes: Change[], config: PersistOptions): Promise<void>;
+    private doSave;
+    deleteTable(table: string, config: PersistOptions): Promise<void>;
+    private getMetadataTableName;
+    private initTable;
+    private transactionStore;
+    private _setItem;
+    private _setTable;
+}
+
+export { ObservablePersistIndexedDB };

package/persist-plugins/indexeddb.d.ts

@@ -1,6 +1,7 @@
-import type { Change } from '@legendapp/state';
-import type { ObservablePersistPluginOptions, ObservablePersistPlugin, PersistMetadata, PersistOptions } from '@legendapp/state/sync';
-export declare class ObservablePersistIndexedDB implements ObservablePersistPlugin {
+import { Change } from '@legendapp/state';
+import { ObservablePersistPlugin, ObservablePersistPluginOptions, PersistOptions, PersistMetadata } from '@legendapp/state/sync';
+
+declare class ObservablePersistIndexedDB implements ObservablePersistPlugin {
     private tableData;
     private tableMetadata;
     private tablesAdjusted;
@@ -24,3 +25,5 @@ export declare class ObservablePersistIndexedDB implements ObservablePersistPlug
     private _setItem;
     private _setTable;
 }
+
+export { ObservablePersistIndexedDB };