tinybase 5.0.0-beta.18 → 5.0.0-beta.19

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

@@ -0,0 +1,424 @@
+import {Map as Map$1} from 'yjs';
+
+const TINYBASE = 'tinybase';
+const T = 't';
+const V = 'v';
+
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isArray = (thing) => Array.isArray(thing);
+const size = (arrayOrString) => arrayOrString.length;
+const errorNew = (message) => {
+  throw new Error(message);
+};
+
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arrayMap = (array, cb) => array.map(cb);
+const arrayIsEmpty = (array) => size(array) == 0;
+const arrayPush = (array, ...values) => array.push(...values);
+const arrayShift = (array) => array.shift();
+
+const object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+const objEntries = object.entries;
+const isObject = (obj) =>
+  !isUndefined(obj) &&
+  ifNotUndefined(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isUndefined(getPrototypeOf(objPrototype)),
+
+    /* istanbul ignore next */
+    () => true,
+  );
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objNew = (entries = []) => object.fromEntries(entries);
+const objHas = (obj, id) => id in obj;
+const objToArray = (obj, cb) =>
+  arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
+const objSize = (obj) => size(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+const objEnsure = (obj, id, getDefaultValue) => {
+  if (!objHas(obj, id)) {
+    obj[id] = getDefaultValue();
+  }
+  return obj[id];
+};
+
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapGet = (map, key) => map?.get(key);
+const mapForEach = (map, cb) =>
+  collForEach(map, (value, key) => cb(key, value));
+const mapSet = (map, key, value) =>
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map, key)) {
+    mapSet(map, key, getDefaultValue());
+  }
+  return mapGet(map, key);
+};
+
+const scheduleRunning = mapNew();
+const scheduleActions = mapNew();
+const getStoreFunctions = (supportedStoreType = 1, store) =>
+  supportedStoreType > 1 && store.isMergeable()
+    ? [
+        1,
+        store.getMergeableContent,
+        store.getTransactionMergeableChanges,
+        ([[changedTables], [changedValues]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+        store.setDefaultContent,
+      ]
+    : supportedStoreType != 2
+      ? [
+          0,
+          store.getContent,
+          store.getTransactionChanges,
+          ([changedTables, changedValues]) =>
+            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+          store.setContent,
+        ]
+      : errorNew('Store type not supported by this Persister');
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+  onIgnoredError,
+  supportedStoreType,
+  extra = {},
+  scheduleId = [],
+) => {
+  let loadSave = 0;
+  let loads = 0;
+  let saves = 0;
+  let action;
+  let autoLoadHandle;
+  let autoSaveListenerId;
+  mapEnsure(scheduleRunning, scheduleId, () => 0);
+  mapEnsure(scheduleActions, scheduleId, () => []);
+  const [
+    isMergeableStore,
+    getContent,
+    getChanges,
+    hasChanges,
+    setDefaultContent,
+  ] = getStoreFunctions(supportedStoreType, store);
+  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 setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore && isArray(contentOrChanges?.[0])
+      ? contentOrChanges?.[2] === 1
+        ? store.applyMergeableChanges
+        : store.setMergeableContent
+      : contentOrChanges?.[2] === 1
+        ? store.applyChanges
+        : store.setContent)(contentOrChanges);
+  };
+  const load = async (initialContent) => {
+    /* istanbul ignore else */
+    if (loadSave != 2) {
+      loadSave = 1;
+      {
+        loads++;
+      }
+      await schedule(async () => {
+        try {
+          setContentOrChanges(await getPersisted());
+        } catch (error) {
+          onIgnoredError?.(error);
+          if (initialContent) {
+            setDefaultContent(initialContent);
+          }
+        }
+        loadSave = 0;
+      });
+    }
+    return persister;
+  };
+  const startAutoLoad = async (initialContent) => {
+    await stopAutoLoad().load(initialContent);
+    autoLoadHandle = addPersisterListener(async (content, changes) => {
+      if (changes || content) {
+        /* istanbul ignore else */
+        if (loadSave != 2) {
+          loadSave = 1;
+          {
+            loads++;
+          }
+          setContentOrChanges(changes ?? content);
+          loadSave = 0;
+        }
+      } else {
+        await load();
+      }
+    });
+    return persister;
+  };
+  const stopAutoLoad = () => {
+    if (autoLoadHandle) {
+      delPersisterListener(autoLoadHandle);
+      autoLoadHandle = void 0;
+    }
+    return persister;
+  };
+  const isAutoLoading = () => !isUndefined(autoLoadHandle);
+  const save = async (changes) => {
+    /* istanbul ignore else */
+    if (loadSave != 1) {
+      loadSave = 2;
+      {
+        saves++;
+      }
+      await schedule(async () => {
+        try {
+          await setPersisted(getContent, changes);
+        } catch (error) {
+          /* istanbul ignore next */
+          onIgnoredError?.(error);
+        }
+        loadSave = 0;
+      });
+    }
+    return persister;
+  };
+  const startAutoSave = async () => {
+    await stopAutoSave().save();
+    autoSaveListenerId = store.addDidFinishTransactionListener(() => {
+      const changes = getChanges();
+      if (hasChanges(changes)) {
+        save(changes);
+      }
+    });
+    return persister;
+  };
+  const stopAutoSave = () => {
+    ifNotUndefined(autoSaveListenerId, store.delListener);
+    autoSaveListenerId = void 0;
+    return persister;
+  };
+  const isAutoSaving = () => !isUndefined(autoSaveListenerId);
+  const schedule = async (...actions) => {
+    arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
+    await run();
+    return persister;
+  };
+  const getStore = () => store;
+  const destroy = () => stopAutoLoad().stopAutoSave();
+  const getStats = () => ({loads, saves});
+  const persister = {
+    load,
+    startAutoLoad,
+    stopAutoLoad,
+    isAutoLoading,
+    save,
+    startAutoSave,
+    stopAutoSave,
+    isAutoSaving,
+    schedule,
+    getStore,
+    destroy,
+    getStats,
+    ...extra,
+  };
+  return objFreeze(persister);
+};
+
+const DELETE = 'delete';
+const getYContent = (yContent) => [yContent.get(T), yContent.get(V)];
+const getChangesFromYDoc = (yContent, events) => {
+  if (size(events) == 1 && arrayIsEmpty(events[0].path)) {
+    return [yContent.get(T).toJSON(), yContent.get(V).toJSON(), 1];
+  }
+  const [yTables, yValues] = getYContent(yContent);
+  const tables = {};
+  const values = {};
+  arrayForEach(events, ({path, changes: {keys}}) =>
+    arrayShift(path) == T
+      ? ifNotUndefined(
+          arrayShift(path),
+          (yTableId) => {
+            const table = objEnsure(tables, yTableId, objNew);
+            const yTable = yTables.get(yTableId);
+            ifNotUndefined(
+              arrayShift(path),
+              (yRowId) => {
+                const row = objEnsure(table, yRowId, objNew);
+                const yRow = yTable.get(yRowId);
+                mapForEach(
+                  keys,
+                  (cellId, {action}) =>
+                    (row[cellId] = action == DELETE ? null : yRow.get(cellId)),
+                );
+              },
+              () =>
+                mapForEach(
+                  keys,
+                  (rowId, {action}) =>
+                    (table[rowId] =
+                      action == DELETE ? null : yTable.get(rowId)?.toJSON()),
+                ),
+            );
+          },
+          () =>
+            mapForEach(
+              keys,
+              (tableId, {action}) =>
+                (tables[tableId] =
+                  action == DELETE ? null : yTables.get(tableId)?.toJSON()),
+            ),
+        )
+      : mapForEach(
+          keys,
+          (valueId, {action}) =>
+            (values[valueId] = action == DELETE ? null : yValues.get(valueId)),
+        ),
+  );
+  return [tables, values, 1];
+};
+const applyChangesToYDoc = (yContent, getContent, changes) => {
+  if (!yContent.size) {
+    yContent.set(T, new Map$1());
+    yContent.set(V, new Map$1());
+  }
+  const [yTables, yValues] = getYContent(yContent);
+  const changesDidFail = () => {
+    changesFailed = 1;
+  };
+  let changesFailed = 1;
+  ifNotUndefined(changes, ([cellChanges, valueChanges]) => {
+    changesFailed = 0;
+    objToArray(cellChanges, (table, tableId) =>
+      changesFailed
+        ? 0
+        : isUndefined(table)
+          ? yTables.delete(tableId)
+          : ifNotUndefined(
+              yTables.get(tableId),
+              (yTable) =>
+                objToArray(table, (row, rowId) =>
+                  changesFailed
+                    ? 0
+                    : isUndefined(row)
+                      ? yTable.delete(rowId)
+                      : ifNotUndefined(
+                          yTable.get(rowId),
+                          (yRow) =>
+                            objToArray(row, (cell, cellId) =>
+                              isUndefined(cell)
+                                ? yRow.delete(cellId)
+                                : yRow.set(cellId, cell),
+                            ),
+                          changesDidFail,
+                        ),
+                ),
+              changesDidFail,
+            ),
+    );
+    objToArray(valueChanges, (value, valueId) =>
+      changesFailed
+        ? 0
+        : isUndefined(value)
+          ? yValues.delete(valueId)
+          : yValues.set(valueId, value),
+    );
+  });
+  if (changesFailed) {
+    const [tables, values] = getContent();
+    yMapMatch(yTables, void 0, tables, (_, tableId, table) =>
+      yMapMatch(yTables, tableId, table, (yTable, rowId, row) =>
+        yMapMatch(yTable, rowId, row, (yRow, cellId, cell) => {
+          if (yRow.get(cellId) !== cell) {
+            yRow.set(cellId, cell);
+            return 1;
+          }
+        }),
+      ),
+    );
+    yMapMatch(yValues, void 0, values, (_, valueId, value) => {
+      if (yValues.get(valueId) !== value) {
+        yValues.set(valueId, value);
+      }
+    });
+  }
+};
+const yMapMatch = (yMapOrParent, idInParent, obj, set) => {
+  const yMap = isUndefined(idInParent)
+    ? yMapOrParent
+    : yMapOrParent.get(idInParent) ?? yMapOrParent.set(idInParent, new Map$1());
+  let changed;
+  objToArray(obj, (value, id) => {
+    if (set(yMap, id, value)) {
+      changed = 1;
+    }
+  });
+  yMap.forEach((_, id) => {
+    if (!objHas(obj, id)) {
+      yMap.delete(id);
+      changed = 1;
+    }
+  });
+  if (!isUndefined(idInParent) && !yMap.size) {
+    yMapOrParent.delete(idInParent);
+  }
+  return changed;
+};
+const createYjsPersister = (
+  store,
+  yDoc,
+  yMapName = TINYBASE,
+  onIgnoredError,
+) => {
+  const yContent = yDoc.getMap(yMapName);
+  const getPersisted = async () =>
+    yContent.size
+      ? [yContent.get(T).toJSON(), yContent.get(V).toJSON()]
+      : void 0;
+  const setPersisted = async (getContent, changes) =>
+    yDoc.transact(() => applyChangesToYDoc(yContent, getContent, changes));
+  const addPersisterListener = (listener) => {
+    const observer = (events) =>
+      listener(void 0, getChangesFromYDoc(yContent, events));
+    yContent.observeDeep(observer);
+    return observer;
+  };
+  const delPersisterListener = (observer) => {
+    yContent.unobserveDeep(observer);
+  };
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    1,
+    {getYDoc: () => yDoc},
+  );
+};
+
+export {createYjsPersister};