tinybase 4.2.0-beta.0 → 4.2.0

package/lib/debug/persisters/persister-indexed-db.js

@@ -0,0 +1,272 @@
+const T = 't';
+const V = 'v';
+
+const arrayMap = (array, cb) => array.map(cb);
+const arrayLength = (array) => array.length;
+const arrayPush = (array, ...values) => array.push(...values);
+const arrayShift = (array) => array.shift();
+
+const promise = Promise;
+const startInterval = setInterval;
+const stopInterval = clearInterval;
+const isInstanceOf = (thing, cls) => thing instanceof cls;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const promiseNew = (resolver) => new promise(resolver);
+const promiseAll = async (promises) => promise.all(promises);
+
+const object = Object;
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const isObject = (obj) =>
+  isInstanceOf(obj, object) && obj.constructor == object;
+const objNew = (entries = []) => object.fromEntries(entries);
+const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+const objHas = (obj, id) => !isUndefined(objGet(obj, id));
+const objMap = (obj, cb) =>
+  arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
+const objSize = (obj) => arrayLength(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapGet = (map, key) => map?.get(key);
+const mapSet = (map, key, value) =>
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
+const mapEnsure = (map, key, getDefaultValue) => {
+  if (!collHas(map, key)) {
+    mapSet(map, key, getDefaultValue());
+  }
+  return mapGet(map, key);
+};
+
+const scheduleRunning = mapNew();
+const scheduleActions = mapNew();
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+  onIgnoredError,
+  scheduleId = [],
+) => {
+  let listenerId;
+  let loadSave = 0;
+  let loads = 0;
+  let saves = 0;
+  let listening = 0;
+  let action;
+  let listeningHandle;
+  mapEnsure(scheduleRunning, scheduleId, () => 0);
+  mapEnsure(scheduleActions, scheduleId, () => []);
+  const run = async () => {
+    /* istanbul ignore else */
+    if (!mapGet(scheduleRunning, scheduleId)) {
+      mapSet(scheduleRunning, scheduleId, 1);
+      while (
+        !isUndefined((action = arrayShift(mapGet(scheduleActions, scheduleId))))
+      ) {
+        try {
+          await action();
+        } catch (error) {
+          /* istanbul ignore next */
+          onIgnoredError?.(error);
+        }
+      }
+      mapSet(scheduleRunning, scheduleId, 0);
+    }
+  };
+  const loadLock = async (actions) => {
+    /* istanbul ignore else */
+    if (loadSave != 2) {
+      loadSave = 1;
+      {
+        loads++;
+      }
+      await persister.schedule(async () => {
+        await actions();
+        loadSave = 0;
+      });
+    }
+    return persister;
+  };
+  const persister = {
+    load: async (initialTables, initialValues) =>
+      await loadLock(async () => {
+        try {
+          store.setContent(await getPersisted());
+        } catch {
+          store.setContent([initialTables, initialValues]);
+        }
+      }),
+    startAutoLoad: async (initialTables = {}, initialValues = {}) => {
+      persister.stopAutoLoad();
+      await persister.load(initialTables, initialValues);
+      listening = 1;
+      listeningHandle = addPersisterListener(
+        async (getContent, getTransactionChanges) => {
+          if (getTransactionChanges) {
+            const transactionChanges = getTransactionChanges();
+            await loadLock(async () =>
+              store.setTransactionChanges(transactionChanges),
+            );
+          } else {
+            await loadLock(async () => {
+              try {
+                store.setContent(getContent?.() ?? (await getPersisted()));
+              } catch (error) {
+                onIgnoredError?.(error);
+              }
+            });
+          }
+        },
+      );
+      return persister;
+    },
+    stopAutoLoad: () => {
+      if (listening) {
+        delPersisterListener(listeningHandle);
+        listeningHandle = void 0;
+        listening = 0;
+      }
+      return persister;
+    },
+    save: async (getTransactionChanges) => {
+      /* istanbul ignore else */
+      if (loadSave != 1) {
+        loadSave = 2;
+        {
+          saves++;
+        }
+        await persister.schedule(async () => {
+          try {
+            await setPersisted(store.getContent, getTransactionChanges);
+          } catch (error) {
+            /* istanbul ignore next */
+            onIgnoredError?.(error);
+          }
+          loadSave = 0;
+        });
+      }
+      return persister;
+    },
+    startAutoSave: async () => {
+      await persister.stopAutoSave().save();
+      listenerId = store.addDidFinishTransactionListener(
+        (_store, getTransactionChanges) => {
+          const [tableChanges, valueChanges] = getTransactionChanges();
+          if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
+            persister.save(() => [tableChanges, valueChanges]);
+          }
+        },
+      );
+      return persister;
+    },
+    stopAutoSave: () => {
+      ifNotUndefined(listenerId, store.delListener);
+      return persister;
+    },
+    schedule: async (...actions) => {
+      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
+      await run();
+      return persister;
+    },
+    getStore: () => store,
+    destroy: () => persister.stopAutoLoad().stopAutoSave(),
+    getStats: () => ({loads, saves}),
+  };
+  return objFreeze(persister);
+};
+
+const WINDOW = globalThis.window;
+const OBJECT_STORE_NAMES = [T, V];
+const KEY_PATH = {keyPath: 'k'};
+const objectStoreMatch = async (objectStore, obj) => {
+  const actions = objMap(obj, (v, k) =>
+    execObjectStore(objectStore, 'put', {k, v}),
+  );
+  arrayMap(await execObjectStore(objectStore, 'getAllKeys'), (id) =>
+    objHas(obj, id)
+      ? 0
+      : arrayPush(actions, execObjectStore(objectStore, 'delete', id)),
+  );
+  await promiseAll(actions);
+};
+const execObjectStore = async (objectStore, func, arg) =>
+  promiseNew((resolve, reject) => {
+    const request = objectStore[func](arg);
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(`objectStore.${func} error`);
+  });
+const createIndexedDbPersister = (
+  store,
+  dbName,
+  autoLoadIntervalSeconds = 1,
+  onIgnoredError,
+) => {
+  const forObjectStores = async (forObjectStore, args = [], create = 0) =>
+    promiseNew((resolve, reject) => {
+      const request = WINDOW.indexedDB.open(dbName, 1);
+      request.onupgradeneeded = () =>
+        create &&
+        arrayMap(OBJECT_STORE_NAMES, (objectStoreName) =>
+          request.result.createObjectStore(objectStoreName, KEY_PATH),
+        );
+      request.onsuccess = async () => {
+        try {
+          const transaction = request.result.transaction(
+            OBJECT_STORE_NAMES,
+            'readwrite',
+          );
+          const result = await promiseAll(
+            arrayMap(
+              OBJECT_STORE_NAMES,
+              async (objectStoreName, index) =>
+                await forObjectStore(
+                  transaction.objectStore(objectStoreName),
+                  args[index],
+                ),
+            ),
+          );
+          request.result.close();
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+      };
+      request.onerror = () => reject('indexedDB.open error');
+    });
+  const getPersisted = async () =>
+    await forObjectStores(async (objectStore) =>
+      objNew(
+        arrayMap(await execObjectStore(objectStore, 'getAll'), ({k, v}) => [
+          k,
+          v,
+        ]),
+      ),
+    );
+  const setPersisted = async (getContent) =>
+    await forObjectStores(
+      async (objectStore, content) =>
+        await objectStoreMatch(objectStore, content),
+      getContent(),
+      1,
+    );
+  const addPersisterListener = (listener) =>
+    startInterval(listener, autoLoadIntervalSeconds * 1e3);
+  const delPersisterListener = (interval) => stopInterval(interval);
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+  );
+};
+
+export {createIndexedDbPersister, objectStoreMatch};

package/lib/debug/persisters/persister-remote.js

@@ -181,7 +181,7 @@ const createRemotePersister = (
   store,
   loadUrl,
   saveUrl,
-  autoLoadIntervalSeconds,
+  autoLoadIntervalSeconds = 5,
   onIgnoredError,
 ) => {
   let lastEtag;

package/lib/debug/persisters/persister-yjs.js

@@ -1,6 +1,8 @@
 import {Map as Map$1} from 'yjs';
 
 const TINYBASE = 'tinybase';
+const T = 't';
+const V = 'v';
 
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayMap = (array, cb) => array.map(cb);
@@ -189,28 +191,17 @@ const createCustomPersister = (
   return objFreeze(persister);
 };
 
-const tablesKey = 't';
-const valuesKey = 'v';
 const DELETE = 'delete';
-const ensureYContent = (yContent) => {
-  if (!yContent.size) {
-    yContent.set(tablesKey, new Map$1());
-    yContent.set(valuesKey, new Map$1());
-  }
-};
-const getYContent = (yContent) => [
-  yContent.get(tablesKey),
-  yContent.get(valuesKey),
-];
+const getYContent = (yContent) => [yContent.get(T), yContent.get(V)];
 const getTransactionChangesFromYDoc = (yContent, events) => {
   if (arrayLength(events) == 1 && arrayIsEmpty(events[0].path)) {
-    return [yContent.get('t').toJSON(), yContent.get('v').toJSON()];
+    return [yContent.get(T).toJSON(), yContent.get(V).toJSON()];
   }
   const [yTables, yValues] = getYContent(yContent);
   const tables = {};
   const values = {};
   arrayForEach(events, ({path, changes: {keys}}) =>
-    arrayShift(path) == tablesKey
+    arrayShift(path) == T
       ? ifNotUndefined(
           arrayShift(path),
           (yTableId) => {
@@ -257,7 +248,10 @@ const setTransactionChangesToYDoc = (
   getContent,
   getTransactionChanges,
 ) => {
-  ensureYContent(yContent);
+  if (!yContent.size) {
+    yContent.set(T, new Map$1());
+    yContent.set(V, new Map$1());
+  }
   const [yTables, yValues] = getYContent(yContent);
   const transactionChangesDidFail = () => {
     transactionChangesFailed = 1;
@@ -349,7 +343,7 @@ const createYjsPersister = (
   const yContent = yDoc.getMap(yMapName);
   const getPersisted = async () =>
     yContent.size
-      ? [yContent.get(tablesKey).toJSON(), yContent.get(valuesKey).toJSON()]
+      ? [yContent.get(T).toJSON(), yContent.get(V).toJSON()]
       : void 0;
   const setPersisted = async (getContent, getTransactionChanges) =>
     yDoc.transact(() =>

package/lib/debug/tools.js

@@ -23,12 +23,14 @@ const VALUE = 'Value';
 const VALUES = VALUE + 's';
 const VALUE_IDS = VALUE + IDS;
 
+const promise = Promise;
 const isFiniteNumber = isFinite;
 const isInstanceOf = (thing, cls) => thing instanceof cls;
 const isUndefined = (thing) => thing == void 0;
 const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
 const isString = (thing) => getTypeOf(thing) == STRING;
 const isArray = (thing) => Array.isArray(thing);
+const promiseAll = async (promises) => promise.all(promises);
 
 const getCellOrValueType = (cell) => {
   const type = getTypeOf(cell);
@@ -2832,6 +2834,8 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
 
 const jsonParse = JSON.parse;
 
+const PRETTIER = 'prettier/';
+const PRETTIER_PLUGINS = PRETTIER + 'plugins/';
 const prettierConfig = {
   parser: 'typescript',
   singleQuote: true,
@@ -2932,15 +2936,27 @@ const createTools = getCreateFunction((store) => {
     getStoreApi(getStoreTablesSchema(), getStoreValuesSchema(), module);
   const getPrettyStoreApi = async (module) => {
     const extensions = ['d.ts', 'ts', 'd.ts', 'tsx'];
+    const plugins = [];
     let format;
     try {
-      format = (await import('prettier')).format;
+      format = (await import(PRETTIER + 'standalone')).format;
+      arrayPush(
+        plugins,
+        await import(PRETTIER_PLUGINS + 'estree'),
+        await import(PRETTIER_PLUGINS + 'typescript'),
+      );
     } catch (e) {
-      format = (str) => str;
+      format = async (str) => str;
     }
-    return arrayMap(getStoreApi$1(module), (file, f) =>
-      formatJsDoc(
-        format(file, {...prettierConfig, filepath: `_.${extensions[f]}`}),
+    return await promiseAll(
+      arrayMap(getStoreApi$1(module), async (file, f) =>
+        formatJsDoc(
+          await format(file, {
+            ...prettierConfig,
+            plugins,
+            filepath: `_.${extensions[f]}`,
+          }),
+        ),
       ),
     );
   };