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

package/es6/debug/persisters/persister-automerge/index.js

@@ -0,0 +1,474 @@
+const TINYBASE = 'tinybase';
+
+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 arrayMap = (array, cb) => array.map(cb);
+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 objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+const objHas = (obj, id) => id in obj;
+const objDel = (obj, id) => {
+  delete obj[id];
+  return 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 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 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 ensureDocContent = (doc, docObjName) => {
+  if (objIsEmpty(doc[docObjName])) {
+    doc[docObjName] = {t: {}, v: {}};
+  }
+};
+const getDocContent = (doc, docObjName) => [
+  doc[docObjName].t,
+  doc[docObjName].v,
+];
+const applyChangesToDoc = (doc, docObjName, getContent, changes) => {
+  ensureDocContent(doc, docObjName);
+  const [docTables, docValues] = getDocContent(doc, docObjName);
+  const changesDidFail = () => {
+    changesFailed = 1;
+  };
+  let changesFailed = 1;
+  ifNotUndefined(changes, ([cellChanges, valueChanges]) => {
+    changesFailed = 0;
+    objToArray(cellChanges, (table, tableId) =>
+      changesFailed
+        ? 0
+        : isUndefined(table)
+          ? objDel(docTables, tableId)
+          : ifNotUndefined(
+              docTables[tableId],
+              (docTable) =>
+                objToArray(table, (row, rowId) =>
+                  changesFailed
+                    ? 0
+                    : isUndefined(row)
+                      ? objDel(docTable, rowId)
+                      : ifNotUndefined(
+                          objGet(docTable, rowId),
+                          (docRow) =>
+                            objToArray(row, (cell, cellId) =>
+                              isUndefined(cell)
+                                ? objDel(docRow, cellId)
+                                : (docRow[cellId] = cell),
+                            ),
+                          changesDidFail,
+                        ),
+                ),
+              changesDidFail,
+            ),
+    );
+    objToArray(valueChanges, (value, valueId) =>
+      changesFailed
+        ? 0
+        : isUndefined(value)
+          ? objDel(docValues, valueId)
+          : (docValues[valueId] = value),
+    );
+  });
+  if (changesFailed) {
+    const [tables, values] = getContent();
+    docObjMatch(docTables, void 0, tables, (_, tableId, table) =>
+      docObjMatch(docTables, tableId, table, (docTable, rowId, row) =>
+        docObjMatch(docTable, rowId, row, (docRow, cellId, cell) => {
+          if (objGet(docRow, cellId) !== cell) {
+            docRow[cellId] = cell;
+            return 1;
+          }
+        }),
+      ),
+    );
+    docObjMatch(docValues, void 0, values, (_, valueId, value) => {
+      if (objGet(docValues, valueId) !== value) {
+        docValues[valueId] = value;
+      }
+    });
+  }
+};
+const docObjMatch = (docObjOrParent, idInParent, obj, set) => {
+  const docObj = isUndefined(idInParent)
+    ? docObjOrParent
+    : objEnsure(docObjOrParent, idInParent, () => ({}));
+  let changed;
+  objToArray(obj, (value, id) => {
+    if (set(docObj, id, value)) {
+      changed = 1;
+    }
+  });
+  objToArray(docObj, (_, id) => {
+    if (!objHas(obj, id)) {
+      objDel(docObj, id);
+      changed = 1;
+    }
+  });
+  if (!isUndefined(idInParent) && objIsEmpty(docObj)) {
+    objDel(docObjOrParent, idInParent);
+  }
+  return changed;
+};
+const createAutomergePersister = (
+  store,
+  docHandle,
+  docObjName = TINYBASE,
+  onIgnoredError,
+) => {
+  docHandle.change((doc) => (doc[docObjName] = {}));
+  const getPersisted = () =>
+    __async(void 0, null, function* () {
+      const doc = yield docHandle.doc();
+      return objSize(doc == null ? void 0 : doc[docObjName]) == 2
+        ? getDocContent(doc, docObjName)
+        : void 0;
+    });
+  const setPersisted = (getContent, changes) =>
+    __async(void 0, null, function* () {
+      return docHandle.change((doc) =>
+        applyChangesToDoc(doc, docObjName, getContent, changes),
+      );
+    });
+  const addPersisterListener = (listener) => {
+    const observer = ({doc}) => listener(getDocContent(doc, docObjName));
+    docHandle.on('change', observer);
+    return observer;
+  };
+  const delPersisterListener = (observer) => {
+    docHandle.removeListener('change', observer);
+  };
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    1,
+    {getDocHandle: () => docHandle},
+  );
+};
+
+export {createAutomergePersister};