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

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

@@ -0,0 +1,534 @@
+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 == null ? void 0 : 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) => {
+  var _a;
+  return (_a = coll == null ? void 0 : coll.has(keyOrValue)) != null
+    ? _a
+    : false;
+};
+const collForEach = (coll, cb) => (coll == null ? void 0 : coll.forEach(cb));
+const collDel = (coll, keyOrValue) =>
+  coll == null ? void 0 : coll.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapGet = (map, key) => (map == null ? void 0 : 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 == null
+      ? void 0
+      : map.set(key, value);
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
+  if (!collHas(map, key)) {
+    mapSet(map, key, getDefaultValue());
+  }
+  return mapGet(map, key);
+};
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) =>
+  key in obj
+    ? __defProp(obj, key, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value,
+      })
+    : (obj[key] = value);
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async$1 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) =>
+      x.done
+        ? resolve(x.value)
+        : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+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$1(void 0, null, function* () {
+      /* istanbul ignore else */
+      if (!mapGet(scheduleRunning, scheduleId)) {
+        mapSet(scheduleRunning, scheduleId, 1);
+        while (
+          !isUndefined(
+            (action = arrayShift(mapGet(scheduleActions, scheduleId))),
+          )
+        ) {
+          try {
+            yield action();
+          } catch (error) {
+            /* istanbul ignore next */
+            onIgnoredError == null ? void 0 : onIgnoredError(error);
+          }
+        }
+        mapSet(scheduleRunning, scheduleId, 0);
+      }
+    });
+  const setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore &&
+      isArray(contentOrChanges == null ? void 0 : contentOrChanges[0])
+      ? (contentOrChanges == null ? void 0 : contentOrChanges[2]) === 1
+        ? store.applyMergeableChanges
+        : store.setMergeableContent
+      : (contentOrChanges == null ? void 0 : contentOrChanges[2]) === 1
+        ? store.applyChanges
+        : store.setContent)(contentOrChanges);
+  };
+  const load = (initialContent) =>
+    __async$1(void 0, null, function* () {
+      /* istanbul ignore else */
+      if (loadSave != 2) {
+        loadSave = 1;
+        {
+          loads++;
+        }
+        yield schedule(() =>
+          __async$1(void 0, null, function* () {
+            try {
+              setContentOrChanges(yield getPersisted());
+            } catch (error) {
+              onIgnoredError == null ? void 0 : onIgnoredError(error);
+              if (initialContent) {
+                setDefaultContent(initialContent);
+              }
+            }
+            loadSave = 0;
+          }),
+        );
+      }
+      return persister;
+    });
+  const startAutoLoad = (initialContent) =>
+    __async$1(void 0, null, function* () {
+      yield stopAutoLoad().load(initialContent);
+      autoLoadHandle = addPersisterListener((content, changes) =>
+        __async$1(void 0, null, function* () {
+          if (changes || content) {
+            /* istanbul ignore else */
+            if (loadSave != 2) {
+              loadSave = 1;
+              {
+                loads++;
+              }
+              setContentOrChanges(changes != null ? changes : content);
+              loadSave = 0;
+            }
+          } else {
+            yield load();
+          }
+        }),
+      );
+      return persister;
+    });
+  const stopAutoLoad = () => {
+    if (autoLoadHandle) {
+      delPersisterListener(autoLoadHandle);
+      autoLoadHandle = void 0;
+    }
+    return persister;
+  };
+  const isAutoLoading = () => !isUndefined(autoLoadHandle);
+  const save = (changes) =>
+    __async$1(void 0, null, function* () {
+      /* istanbul ignore else */
+      if (loadSave != 1) {
+        loadSave = 2;
+        {
+          saves++;
+        }
+        yield schedule(() =>
+          __async$1(void 0, null, function* () {
+            try {
+              yield setPersisted(getContent, changes);
+            } catch (error) {
+              /* istanbul ignore next */
+              onIgnoredError == null ? void 0 : onIgnoredError(error);
+            }
+            loadSave = 0;
+          }),
+        );
+      }
+      return persister;
+    });
+  const startAutoSave = () =>
+    __async$1(void 0, null, function* () {
+      yield 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 = (...actions) =>
+    __async$1(void 0, null, function* () {
+      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
+      yield run();
+      return persister;
+    });
+  const getStore = () => store;
+  const destroy = () => stopAutoLoad().stopAutoSave();
+  const getStats = () => ({loads, saves});
+  const persister = __spreadValues(
+    {
+      load,
+      startAutoLoad,
+      stopAutoLoad,
+      isAutoLoading,
+      save,
+      startAutoSave,
+      stopAutoSave,
+      isAutoSaving,
+      schedule,
+      getStore,
+      destroy,
+      getStats,
+    },
+    extra,
+  );
+  return objFreeze(persister);
+};
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) =>
+      x.done
+        ? resolve(x.value)
+        : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+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}) => {
+                  var _a;
+                  return (table[rowId] =
+                    action == DELETE
+                      ? null
+                      : (_a = yTable.get(rowId)) == null
+                        ? void 0
+                        : _a.toJSON());
+                }),
+            );
+          },
+          () =>
+            mapForEach(keys, (tableId, {action}) => {
+              var _a;
+              return (tables[tableId] =
+                action == DELETE
+                  ? null
+                  : (_a = yTables.get(tableId)) == null
+                    ? void 0
+                    : _a.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) => {
+  var _a;
+  const yMap = isUndefined(idInParent)
+    ? yMapOrParent
+    : (_a = yMapOrParent.get(idInParent)) != null
+      ? _a
+      : 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(void 0, null, function* () {
+      return yContent.size
+        ? [yContent.get(T).toJSON(), yContent.get(V).toJSON()]
+        : void 0;
+    });
+  const setPersisted = (getContent, changes) =>
+    __async(void 0, null, function* () {
+      return 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};