tinybase 5.0.0-beta.19 → 5.0.0-beta.20

package/umd/debug/persisters/persister-yjs/with-schemas/index.js

@@ -0,0 +1,439 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined'
+    ? factory(exports, require('yjs'))
+    : typeof define === 'function' && define.amd
+      ? define(['exports', 'yjs'], factory)
+      : ((global =
+          typeof globalThis !== 'undefined' ? globalThis : global || self),
+        factory((global.TinyBasePersisterYjsDebug = {}), global.yjs));
+})(this, function (exports, yjs) {
+  'use strict';
+
+  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 yjs.Map());
+      yContent.set(V, new yjs.Map());
+    }
+    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 yjs.Map());
+    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},
+    );
+  };
+
+  exports.createYjsPersister = createYjsPersister;
+});

package/umd/debug/persisters/with-schemas/index.js

@@ -0,0 +1,242 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined'
+    ? factory(exports)
+    : typeof define === 'function' && define.amd
+      ? define(['exports'], factory)
+      : ((global =
+          typeof globalThis !== 'undefined' ? globalThis : global || self),
+        factory((global.TinyBasePersistersDebug = {})));
+})(this, function (exports) {
+  'use strict';
+
+  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 arrayPush = (array, ...values) => array.push(...values);
+  const arrayShift = (array) => array.shift();
+
+  const object = Object;
+  const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+  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 objSize = (obj) => size(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, 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);
+  };
+
+  exports.createCustomPersister = createCustomPersister;
+});