tinybase 4.0.0-beta.0 → 4.0.0-beta.1

package/lib/debug/persister-browser.js

@@ -0,0 +1,148 @@
+const EMPTY_STRING = '';
+
+const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
+
+const jsonString = (obj) =>
+  JSON.stringify(obj, (_key, value) =>
+    isInstanceOf(value, Map)
+      ? arrayReduce(
+          [...value],
+          (obj2, [key, value2]) => {
+            obj2[key] = value2;
+            return obj2;
+          },
+          {},
+        )
+      : value,
+  );
+const isInstanceOf = (thing, cls) => thing instanceof cls;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+
+const object = Object;
+const objFreeze = object.freeze;
+
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+) => {
+  let listenerId;
+  let loadSave = 0;
+  let loads = 0;
+  let saves = 0;
+  let listening = false;
+  let listeningHandle;
+  const persister = {
+    load: async (initialTables, initialValues) => {
+      /* istanbul ignore else */
+      if (loadSave != 2) {
+        loadSave = 1;
+        {
+          loads++;
+        }
+        const body = await getPersisted();
+        if (!isUndefined(body) && body != EMPTY_STRING) {
+          store.setJson(body);
+        } else {
+          store.setContent([initialTables, initialValues]);
+        }
+        loadSave = 0;
+      }
+      return persister;
+    },
+    startAutoLoad: async (initialTables, initialValues) => {
+      persister.stopAutoLoad();
+      await persister.load(initialTables, initialValues);
+      listening = true;
+      listeningHandle = addPersisterListener(async (content) => {
+        if (isUndefined(content)) {
+          await persister.load();
+        } else {
+          /* istanbul ignore else */
+          if (loadSave != 2) {
+            loadSave = 1;
+            {
+              loads++;
+            }
+            store.setContent(content);
+            loadSave = 0;
+          }
+        }
+      });
+      return persister;
+    },
+    stopAutoLoad: () => {
+      if (listening) {
+        delPersisterListener(listeningHandle);
+        listeningHandle = void 0;
+        listening = false;
+      }
+      return persister;
+    },
+    save: async () => {
+      /* istanbul ignore else */
+      if (loadSave != 1) {
+        loadSave = 2;
+        {
+          saves++;
+        }
+        await setPersisted(store.getContent);
+        loadSave = 0;
+      }
+      return persister;
+    },
+    startAutoSave: async () => {
+      await persister.stopAutoSave().save();
+      listenerId = store.addDidFinishTransactionListener(persister.save);
+      return persister;
+    },
+    stopAutoSave: () => {
+      ifNotUndefined(listenerId, store.delListener);
+      return persister;
+    },
+    getStore: () => store,
+    destroy: () => persister.stopAutoLoad().stopAutoSave(),
+    getStats: () => ({loads, saves}),
+  };
+  return objFreeze(persister);
+};
+
+const STORAGE = 'storage';
+const WINDOW = globalThis.window;
+const getStoragePersister = (store, storageName, storage) => {
+  const getPersisted = async () => storage.getItem(storageName);
+  const setPersisted = async (getContent) =>
+    storage.setItem(storageName, jsonString(getContent()));
+  const addPersisterListener = (listener) => {
+    const storeListener = (event) => {
+      if (event.storageArea === storage && event.key === storageName) {
+        let newValue;
+        try {
+          newValue = JSON.parse(event.newValue);
+        } catch {}
+        listener(newValue);
+      }
+    };
+    WINDOW.addEventListener(STORAGE, storeListener);
+    return storeListener;
+  };
+  const delPersisterListener = (storeListener) =>
+    WINDOW.removeEventListener(STORAGE, storeListener);
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+  );
+};
+const createLocalPersister = (store, storageName) =>
+  getStoragePersister(store, storageName, localStorage);
+const createSessionPersister = (store, storageName) =>
+  getStoragePersister(store, storageName, sessionStorage);
+
+export {createLocalPersister, createSessionPersister};

package/lib/debug/persister-file.js

@@ -0,0 +1,140 @@
+import {readFile, writeFile} from 'fs/promises';
+import {watch} from 'fs';
+
+const EMPTY_STRING = '';
+const UTF8 = 'utf8';
+
+const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
+
+const jsonString = (obj) =>
+  JSON.stringify(obj, (_key, value) =>
+    isInstanceOf(value, Map)
+      ? arrayReduce(
+          [...value],
+          (obj2, [key, value2]) => {
+            obj2[key] = value2;
+            return obj2;
+          },
+          {},
+        )
+      : value,
+  );
+const isInstanceOf = (thing, cls) => thing instanceof cls;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+
+const object = Object;
+const objFreeze = object.freeze;
+
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+) => {
+  let listenerId;
+  let loadSave = 0;
+  let loads = 0;
+  let saves = 0;
+  let listening = false;
+  let listeningHandle;
+  const persister = {
+    load: async (initialTables, initialValues) => {
+      /* istanbul ignore else */
+      if (loadSave != 2) {
+        loadSave = 1;
+        {
+          loads++;
+        }
+        const body = await getPersisted();
+        if (!isUndefined(body) && body != EMPTY_STRING) {
+          store.setJson(body);
+        } else {
+          store.setContent([initialTables, initialValues]);
+        }
+        loadSave = 0;
+      }
+      return persister;
+    },
+    startAutoLoad: async (initialTables, initialValues) => {
+      persister.stopAutoLoad();
+      await persister.load(initialTables, initialValues);
+      listening = true;
+      listeningHandle = addPersisterListener(async (content) => {
+        if (isUndefined(content)) {
+          await persister.load();
+        } else {
+          /* istanbul ignore else */
+          if (loadSave != 2) {
+            loadSave = 1;
+            {
+              loads++;
+            }
+            store.setContent(content);
+            loadSave = 0;
+          }
+        }
+      });
+      return persister;
+    },
+    stopAutoLoad: () => {
+      if (listening) {
+        delPersisterListener(listeningHandle);
+        listeningHandle = void 0;
+        listening = false;
+      }
+      return persister;
+    },
+    save: async () => {
+      /* istanbul ignore else */
+      if (loadSave != 1) {
+        loadSave = 2;
+        {
+          saves++;
+        }
+        await setPersisted(store.getContent);
+        loadSave = 0;
+      }
+      return persister;
+    },
+    startAutoSave: async () => {
+      await persister.stopAutoSave().save();
+      listenerId = store.addDidFinishTransactionListener(persister.save);
+      return persister;
+    },
+    stopAutoSave: () => {
+      ifNotUndefined(listenerId, store.delListener);
+      return persister;
+    },
+    getStore: () => store,
+    destroy: () => persister.stopAutoLoad().stopAutoSave(),
+    getStats: () => ({loads, saves}),
+  };
+  return objFreeze(persister);
+};
+
+const createFilePersister = (store, filePath) => {
+  const getPersisted = async () => {
+    try {
+      return await readFile(filePath, UTF8);
+    } catch {}
+  };
+  const setPersisted = async (getContent) => {
+    try {
+      await writeFile(filePath, jsonString(getContent()), UTF8);
+    } catch {}
+  };
+  const addPersisterListener = (listener) => watch(filePath, () => listener());
+  const delPersisterListener = (watcher) => watcher?.close();
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+  );
+};
+
+export {createFilePersister};

package/lib/debug/persister-remote.js

@@ -0,0 +1,156 @@
+const EMPTY_STRING = '';
+
+const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
+
+const jsonString = (obj) =>
+  JSON.stringify(obj, (_key, value) =>
+    isInstanceOf(value, Map)
+      ? arrayReduce(
+          [...value],
+          (obj2, [key, value2]) => {
+            obj2[key] = value2;
+            return obj2;
+          },
+          {},
+        )
+      : value,
+  );
+const isInstanceOf = (thing, cls) => thing instanceof cls;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+
+const object = Object;
+const objFreeze = object.freeze;
+
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+) => {
+  let listenerId;
+  let loadSave = 0;
+  let loads = 0;
+  let saves = 0;
+  let listening = false;
+  let listeningHandle;
+  const persister = {
+    load: async (initialTables, initialValues) => {
+      /* istanbul ignore else */
+      if (loadSave != 2) {
+        loadSave = 1;
+        {
+          loads++;
+        }
+        const body = await getPersisted();
+        if (!isUndefined(body) && body != EMPTY_STRING) {
+          store.setJson(body);
+        } else {
+          store.setContent([initialTables, initialValues]);
+        }
+        loadSave = 0;
+      }
+      return persister;
+    },
+    startAutoLoad: async (initialTables, initialValues) => {
+      persister.stopAutoLoad();
+      await persister.load(initialTables, initialValues);
+      listening = true;
+      listeningHandle = addPersisterListener(async (content) => {
+        if (isUndefined(content)) {
+          await persister.load();
+        } else {
+          /* istanbul ignore else */
+          if (loadSave != 2) {
+            loadSave = 1;
+            {
+              loads++;
+            }
+            store.setContent(content);
+            loadSave = 0;
+          }
+        }
+      });
+      return persister;
+    },
+    stopAutoLoad: () => {
+      if (listening) {
+        delPersisterListener(listeningHandle);
+        listeningHandle = void 0;
+        listening = false;
+      }
+      return persister;
+    },
+    save: async () => {
+      /* istanbul ignore else */
+      if (loadSave != 1) {
+        loadSave = 2;
+        {
+          saves++;
+        }
+        await setPersisted(store.getContent);
+        loadSave = 0;
+      }
+      return persister;
+    },
+    startAutoSave: async () => {
+      await persister.stopAutoSave().save();
+      listenerId = store.addDidFinishTransactionListener(persister.save);
+      return persister;
+    },
+    stopAutoSave: () => {
+      ifNotUndefined(listenerId, store.delListener);
+      return persister;
+    },
+    getStore: () => store,
+    destroy: () => persister.stopAutoLoad().stopAutoSave(),
+    getStats: () => ({loads, saves}),
+  };
+  return objFreeze(persister);
+};
+
+const getETag = (response) => response.headers.get('ETag');
+const createRemotePersister = (
+  store,
+  loadUrl,
+  saveUrl,
+  autoLoadIntervalSeconds,
+) => {
+  let lastEtag;
+  const getPersisted = async () => {
+    const response = await fetch(loadUrl);
+    lastEtag = getETag(response);
+    return response.text();
+  };
+  const setPersisted = async (getContent) =>
+    await fetch(saveUrl, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: jsonString(getContent()),
+    });
+  const addPersisterListener = (listener) =>
+    setInterval(async () => {
+      const response = await fetch(loadUrl, {method: 'HEAD'});
+      const currentEtag = getETag(response);
+      if (
+        !isUndefined(lastEtag) &&
+        !isUndefined(currentEtag) &&
+        currentEtag != lastEtag
+      ) {
+        lastEtag = currentEtag;
+        listener();
+      }
+    }, autoLoadIntervalSeconds * 1e3);
+  const delPersisterListener = (interval) => clearInterval(interval);
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+  );
+};
+
+export {createRemotePersister};

package/lib/debug/persister-yjs.js

@@ -11,11 +11,10 @@ const createCustomPersister = (
   store,
   getPersisted,
   setPersisted,
-  startListeningToPersisted,
-  stopListeningToPersisted,
+  addPersisterListener,
+  delPersisterListener,
 ) => {
-  let tablesListenerId;
-  let valuesListenerId;
+  let listenerId;
   let loadSave = 0;
   let loads = 0;
   let saves = 0;
@@ -33,9 +32,7 @@ const createCustomPersister = (
         if (!isUndefined(body) && body != EMPTY_STRING) {
           store.setJson(body);
         } else {
-          store.transaction(() =>
-            store.setTables(initialTables).setValues(initialValues),
-          );
+          store.setContent([initialTables, initialValues]);
         }
         loadSave = 0;
       }
@@ -45,12 +42,26 @@ const createCustomPersister = (
       persister.stopAutoLoad();
       await persister.load(initialTables, initialValues);
       listening = true;
-      listeningHandle = startListeningToPersisted(persister.load);
+      listeningHandle = addPersisterListener(async (content) => {
+        if (isUndefined(content)) {
+          await persister.load();
+        } else {
+          /* istanbul ignore else */
+          if (loadSave != 2) {
+            loadSave = 1;
+            {
+              loads++;
+            }
+            store.setContent(content);
+            loadSave = 0;
+          }
+        }
+      });
       return persister;
     },
     stopAutoLoad: () => {
       if (listening) {
-        stopListeningToPersisted(listeningHandle);
+        delPersisterListener(listeningHandle);
         listeningHandle = void 0;
         listening = false;
       }
@@ -63,20 +74,18 @@ const createCustomPersister = (
         {
           saves++;
         }
-        await setPersisted(store.getJson());
+        await setPersisted(store.getContent);
         loadSave = 0;
       }
       return persister;
     },
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
-      tablesListenerId = store.addTablesListener(persister.save);
-      valuesListenerId = store.addValuesListener(persister.save);
+      listenerId = store.addDidFinishTransactionListener(persister.save);
       return persister;
     },
     stopAutoSave: () => {
-      ifNotUndefined(tablesListenerId, store.delListener);
-      ifNotUndefined(valuesListenerId, store.delListener);
+      ifNotUndefined(listenerId, store.delListener);
       return persister;
     },
     getStore: () => store,
@@ -89,21 +98,21 @@ const createCustomPersister = (
 const createYjsPersister = (store, yDoc) => {
   const map = yDoc.getMap('tinybase/store');
   const getPersisted = async () => map.get('json');
-  const setPersisted = async (json) => {
-    map.set('json', json);
+  const setPersisted = async (getContent) => {
+    map.set('json', JSON.stringify(getContent()));
   };
-  const startListeningToPersisted = (didChange) => {
-    const observer = () => didChange();
+  const addPersisterListener = (listener) => {
+    const observer = () => listener();
     map.observe(observer);
     return observer;
   };
-  const stopListeningToPersisted = (observer) => map.unobserve(observer);
+  const delPersisterListener = (observer) => map.unobserve(observer);
   return createCustomPersister(
     store,
     getPersisted,
     setPersisted,
-    startListeningToPersisted,
-    stopListeningToPersisted,
+    addPersisterListener,
+    delPersisterListener,
   );
 };