tinybase 6.0.0-beta.0 → 6.0.0-beta.1

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

@@ -1,606 +0,0 @@
-(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.TinyBasePersisterYjs = {}), global.yjs));
-})(this, function (exports, yjs) {
-  'use strict';
-
-  const TINYBASE = 'tinybase';
-  const EMPTY_STRING = '';
-  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 test = (regex, subject) => regex.test(subject);
-  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 arrayClear = (array, to) => array.splice(0, to);
-  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 objMap = (obj, cb) =>
-    objNew(objToArray(obj, (value, id) => [id, 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 collSize = (coll) => coll?.size ?? 0;
-  const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
-  const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
-  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());
-    } else {
-      hadExistingValue?.(mapGet(map, key));
-    }
-    return mapGet(map, key);
-  };
-  const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
-    ifNotUndefined(
-      (ensureLeaf ? mapEnsure : mapGet)(
-        node,
-        path[p],
-        p > size(path) - 2 ? ensureLeaf : mapNew,
-      ),
-      (nodeOrLeaf) => {
-        if (p > size(path) - 2) {
-          if (pruneLeaf?.(nodeOrLeaf)) {
-            mapSet(node, path[p]);
-          }
-          return nodeOrLeaf;
-        }
-        const leaf = visitTree(nodeOrLeaf, path, ensureLeaf, pruneLeaf, p + 1);
-        if (collIsEmpty(nodeOrLeaf)) {
-          mapSet(node, path[p]);
-        }
-        return leaf;
-      },
-    );
-
-  const setNew = (entryOrEntries) =>
-    new Set(
-      isArray(entryOrEntries) || isUndefined(entryOrEntries)
-        ? entryOrEntries
-        : [entryOrEntries],
-    );
-  const setAdd = (set, value) => set?.add(value);
-
-  const INTEGER = /^\d+$/;
-  const getPoolFunctions = () => {
-    const pool = [];
-    let nextId = 0;
-    return [
-      (reuse) => (reuse ? arrayShift(pool) : null) ?? EMPTY_STRING + nextId++,
-      (id) => {
-        if (test(INTEGER, id) && size(pool) < 1e3) {
-          arrayPush(pool, id);
-        }
-      },
-    ];
-  };
-
-  const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
-    const leaves = [];
-    const deep = (node, p) =>
-      p == size(path)
-        ? arrayPush(leaves, node)
-        : path[p] === null
-          ? collForEach(node, (node2) => deep(node2, p + 1))
-          : arrayForEach([path[p], null], (id) =>
-              deep(mapGet(node, id), p + 1),
-            );
-    deep(deepIdSet, 0);
-    return leaves;
-  };
-  const getListenerFunctions = (getThing) => {
-    let thing;
-    const [getId, releaseId] = getPoolFunctions();
-    const allListeners = mapNew();
-    const addListener = (
-      listener,
-      idSetNode,
-      path,
-      pathGetters = [],
-      extraArgsGetter = () => [],
-    ) => {
-      thing ??= getThing();
-      const id = getId(1);
-      mapSet(allListeners, id, [
-        listener,
-        idSetNode,
-        path,
-        pathGetters,
-        extraArgsGetter,
-      ]);
-      setAdd(visitTree(idSetNode, path ?? [EMPTY_STRING], setNew), id);
-      return id;
-    };
-    const callListeners = (idSetNode, ids, ...extraArgs) =>
-      arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
-        collForEach(set, (id) =>
-          mapGet(allListeners, id)[0](thing, ...(ids ?? []), ...extraArgs),
-        ),
-      );
-    const delListener = (id) =>
-      ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
-        visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], void 0, (idSet) => {
-          collDel(idSet, id);
-          return collIsEmpty(idSet) ? 1 : 0;
-        });
-        mapSet(allListeners, id);
-        releaseId(id);
-        return idOrNulls;
-      });
-    const callListener = (id) =>
-      ifNotUndefined(
-        mapGet(allListeners, id),
-        ([listener, , path = [], pathGetters, extraArgsGetter]) => {
-          const callWithIds = (...ids) => {
-            const index = size(ids);
-            if (index == size(path)) {
-              listener(thing, ...ids, ...extraArgsGetter(ids));
-            } else if (isUndefined(path[index])) {
-              arrayForEach(pathGetters[index]?.(...ids) ?? [], (id2) =>
-                callWithIds(...ids, id2),
-              );
-            } else {
-              callWithIds(...ids, path[index]);
-            }
-          };
-          callWithIds();
-        },
-      );
-    return [addListener, callListeners, delListener, callListener];
-  };
-
-  const scheduleRunning = mapNew();
-  const scheduleActions = mapNew();
-  const getStoreFunctions = (
-    persist = 1 /* StoreOnly */,
-    store,
-    isSynchronizer,
-  ) =>
-    persist != 1 /* StoreOnly */ && store.isMergeable()
-      ? [
-          1,
-          store.getMergeableContent,
-          () => store.getTransactionMergeableChanges(!isSynchronizer),
-          ([[changedTables], [changedValues]]) =>
-            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
-          store.setDefaultContent,
-        ]
-      : persist != 2 /* MergeableStoreOnly */
-        ? [
-            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,
-    persist,
-    extra = {},
-    isSynchronizer = 0,
-    scheduleId = [],
-  ) => {
-    let status = 0; /* Idle */
-    let loads = 0;
-    let saves = 0;
-    let action;
-    let autoLoadHandle;
-    let autoSaveListenerId;
-    mapEnsure(scheduleRunning, scheduleId, () => 0);
-    mapEnsure(scheduleActions, scheduleId, () => []);
-    const statusListeners = mapNew();
-    const [
-      isMergeableStore,
-      getContent,
-      getChanges,
-      hasChanges,
-      setDefaultContent,
-    ] = getStoreFunctions(persist, store, isSynchronizer);
-    const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
-      () => persister,
-    );
-    const setStatus = (newStatus) => {
-      if (newStatus != status) {
-        status = newStatus;
-        callListeners(statusListeners, void 0, status);
-      }
-    };
-    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 (status != 2 /* Saving */) {
-        setStatus(1 /* Loading */);
-        loads++;
-        await schedule(async () => {
-          try {
-            const content = await getPersisted();
-            if (isArray(content)) {
-              setContentOrChanges(content);
-            } else if (initialContent) {
-              setDefaultContent(initialContent);
-            } else {
-              errorNew(`Content is not an array: ${content}`);
-            }
-          } catch (error) {
-            onIgnoredError?.(error);
-            if (initialContent) {
-              setDefaultContent(initialContent);
-            }
-          }
-          setStatus(0 /* Idle */);
-        });
-      }
-      return persister;
-    };
-    const startAutoLoad = async (initialContent) => {
-      stopAutoLoad();
-      await load(initialContent);
-      try {
-        autoLoadHandle = await addPersisterListener(
-          async (content, changes) => {
-            if (changes || content) {
-              /* istanbul ignore else */
-              if (status != 2 /* Saving */) {
-                setStatus(1 /* Loading */);
-                loads++;
-                setContentOrChanges(changes ?? content);
-                setStatus(0 /* Idle */);
-              }
-            } else {
-              await load();
-            }
-          },
-        );
-      } catch (error) {
-        /* istanbul ignore next */
-        onIgnoredError?.(error);
-      }
-      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 (status != 1 /* Loading */) {
-        setStatus(2 /* Saving */);
-        saves++;
-        await schedule(async () => {
-          try {
-            await setPersisted(getContent, changes);
-          } catch (error) {
-            /* istanbul ignore next */
-            onIgnoredError?.(error);
-          }
-          setStatus(0 /* Idle */);
-        });
-      }
-      return persister;
-    };
-    const startAutoSave = async () => {
-      stopAutoSave();
-      await save();
-      autoSaveListenerId = store.addDidFinishTransactionListener(() => {
-        const changes = getChanges();
-        if (hasChanges(changes)) {
-          save(changes);
-        }
-      });
-      return persister;
-    };
-    const stopAutoSave = () => {
-      if (autoSaveListenerId) {
-        store.delListener(autoSaveListenerId);
-        autoSaveListenerId = void 0;
-      }
-      return persister;
-    };
-    const isAutoSaving = () => !isUndefined(autoSaveListenerId);
-    const getStatus = () => status;
-    const addStatusListener = (listener) =>
-      addListener(listener, statusListeners);
-    const delListener = (listenerId) => {
-      delListenerImpl(listenerId);
-      return store;
-    };
-    const schedule = async (...actions) => {
-      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
-      await run();
-      return persister;
-    };
-    const getStore = () => store;
-    const destroy = () => {
-      arrayClear(mapGet(scheduleActions, scheduleId));
-      return stopAutoLoad().stopAutoSave();
-    };
-    const getStats = () => ({loads, saves});
-    const persister = {
-      load,
-      startAutoLoad,
-      stopAutoLoad,
-      isAutoLoading,
-      save,
-      startAutoSave,
-      stopAutoSave,
-      isAutoSaving,
-      getStatus,
-      addStatusListener,
-      delListener,
-      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;
-      objMap(cellChanges, (table, tableId) =>
-        changesFailed
-          ? 0
-          : isUndefined(table)
-            ? yTables.delete(tableId)
-            : ifNotUndefined(
-                yTables.get(tableId),
-                (yTable) =>
-                  objMap(table, (row, rowId) =>
-                    changesFailed
-                      ? 0
-                      : isUndefined(row)
-                        ? yTable.delete(rowId)
-                        : ifNotUndefined(
-                            yTable.get(rowId),
-                            (yRow) =>
-                              objMap(row, (cell, cellId) =>
-                                isUndefined(cell)
-                                  ? yRow.delete(cellId)
-                                  : yRow.set(cellId, cell),
-                              ),
-                            changesDidFail,
-                          ),
-                  ),
-                changesDidFail,
-              ),
-      );
-      objMap(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;
-    objMap(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,
-      // StoreOnly,
-      {getYDoc: () => yDoc},
-    );
-  };
-
-  exports.createYjsPersister = createYjsPersister;
-});