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

package/umd/es6/persisters/persister-durable-object-storage/index.js

@@ -1,707 +0,0 @@
-(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.TinyBasePersisterDurableObjectStorage = {})));
-})(this, function (exports) {
-  'use strict';
-
-  const EMPTY_STRING = '';
-  const T = 't';
-  const V = 'v';
-  const UNDEFINED = '\uFFFC';
-  const strStartsWith = (str, prefix) => str.startsWith(prefix);
-
-  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 slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
-  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 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 objHas = (obj, id) => id in obj;
-  const objForEach = (obj, cb) =>
-    arrayForEach(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 collSize = (coll) => {
-    var _a;
-    return (_a = coll == null ? void 0 : coll.size) != null ? _a : 0;
-  };
-  const collHas = (coll, keyOrValue) => {
-    var _a;
-    return (_a = coll == null ? void 0 : coll.has(keyOrValue)) != null
-      ? _a
-      : false;
-  };
-  const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
-  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 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());
-    } else {
-      hadExistingValue == null ? void 0 : hadExistingValue(mapGet(map, key));
-    }
-    return mapGet(map, key);
-  };
-  const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
-    const obj = {};
-    collForEach(map, (mapValue, id) => {
-      {
-        const objValue = mapValue;
-        {
-          obj[id] = objValue;
-        }
-      }
-    });
-    return obj;
-  };
-  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 == null ? void 0 : 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 stampNewWithHash = (value, time, hash) => [value, time, hash];
-  const stampUpdate = (stamp, time, hash) => {
-    if (time > stamp[1]) {
-      stamp[1] = time;
-    }
-    stamp[2] = hash >>> 0;
-  };
-
-  const setNew = (entryOrEntries) =>
-    new Set(
-      isArray(entryOrEntries) || isUndefined(entryOrEntries)
-        ? entryOrEntries
-        : [entryOrEntries],
-    );
-  const setAdd = (set, value) => (set == null ? void 0 : set.add(value));
-
-  const INTEGER = /^\d+$/;
-  const getPoolFunctions = () => {
-    const pool = [];
-    let nextId = 0;
-    return [
-      (reuse) => {
-        var _a;
-        return (_a = reuse ? arrayShift(pool) : null) != null
-          ? _a
-          : 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 != null ? thing : (thing = getThing());
-      const id = getId(1);
-      mapSet(allListeners, id, [
-        listener,
-        idSetNode,
-        path,
-        pathGetters,
-        extraArgsGetter,
-      ]);
-      setAdd(
-        visitTree(idSetNode, path != null ? 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 != null ? ids : []),
-            ...extraArgs,
-          ),
-        ),
-      );
-    const delListener = (id) =>
-      ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
-        visitTree(
-          idSetNode,
-          idOrNulls != null ? 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) => {
-            var _a, _b;
-            const index = size(ids);
-            if (index == size(path)) {
-              listener(thing, ...ids, ...extraArgsGetter(ids));
-            } else if (isUndefined(path[index])) {
-              arrayForEach(
-                (_b =
-                  (_a = pathGetters[index]) == null
-                    ? void 0
-                    : _a.call(pathGetters, ...ids)) != null
-                  ? _b
-                  : [],
-                (id2) => callWithIds(...ids, id2),
-              );
-            } else {
-              callWithIds(...ids, path[index]);
-            }
-          };
-          callWithIds();
-        },
-      );
-    return [addListener, callListeners, delListener, callListener];
-  };
-
-  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 = (
-    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$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 (status != 2 /* Saving */) {
-          setStatus(1 /* Loading */);
-          loads++;
-          yield schedule(() =>
-            __async$1(void 0, null, function* () {
-              try {
-                const content = yield getPersisted();
-                if (isArray(content)) {
-                  setContentOrChanges(content);
-                } else if (initialContent) {
-                  setDefaultContent(initialContent);
-                } else {
-                  errorNew(`Content is not an array: ${content}`);
-                }
-              } catch (error) {
-                onIgnoredError == null ? void 0 : onIgnoredError(error);
-                if (initialContent) {
-                  setDefaultContent(initialContent);
-                }
-              }
-              setStatus(0 /* Idle */);
-            }),
-          );
-        }
-        return persister;
-      });
-    const startAutoLoad = (initialContent) =>
-      __async$1(void 0, null, function* () {
-        stopAutoLoad();
-        yield load(initialContent);
-        try {
-          autoLoadHandle = yield addPersisterListener((content, changes) =>
-            __async$1(void 0, null, function* () {
-              if (changes || content) {
-                /* istanbul ignore else */
-                if (status != 2 /* Saving */) {
-                  setStatus(1 /* Loading */);
-                  loads++;
-                  setContentOrChanges(changes != null ? changes : content);
-                  setStatus(0 /* Idle */);
-                }
-              } else {
-                yield load();
-              }
-            }),
-          );
-        } catch (error) {
-          /* istanbul ignore next */
-          onIgnoredError == null ? void 0 : onIgnoredError(error);
-        }
-        return persister;
-      });
-    const stopAutoLoad = () => {
-      if (autoLoadHandle) {
-        autoLoadHandle = void 0;
-      }
-      return persister;
-    };
-    const isAutoLoading = () => !isUndefined(autoLoadHandle);
-    const save = (changes) =>
-      __async$1(void 0, null, function* () {
-        /* istanbul ignore else */
-        if (status != 1 /* Loading */) {
-          setStatus(2 /* Saving */);
-          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);
-              }
-              setStatus(0 /* Idle */);
-            }),
-          );
-        }
-        return persister;
-      });
-    const startAutoSave = () =>
-      __async$1(void 0, null, function* () {
-        stopAutoSave();
-        yield 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 = (...actions) =>
-      __async$1(void 0, null, function* () {
-        arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
-        yield run();
-        return persister;
-      });
-    const getStore = () => store;
-    const destroy = () => {
-      arrayClear(mapGet(scheduleActions, scheduleId));
-      return stopAutoLoad().stopAutoSave();
-    };
-    const getStats = () => ({loads, saves});
-    const persister = __spreadValues(
-      {
-        load,
-        startAutoLoad,
-        stopAutoLoad,
-        isAutoLoading,
-        save,
-        startAutoSave,
-        stopAutoSave,
-        isAutoSaving,
-        getStatus,
-        addStatusListener,
-        delListener,
-        schedule,
-        getStore,
-        destroy,
-        getStats,
-      },
-      extra,
-    );
-    return objFreeze(persister);
-  };
-
-  const jsonString = JSON.stringify;
-  const jsonStringWithUndefined = (obj) =>
-    jsonString(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
-
-  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 stampNewObjectWithHash = () => stampNewWithHash({}, EMPTY_STRING, 0);
-  const createDurableObjectStoragePersister = (
-    store,
-    storage,
-    storagePrefix = EMPTY_STRING,
-    onIgnoredError,
-  ) => {
-    const constructKey = (type, ...ids) =>
-      storagePrefix + type + slice(jsonStringWithUndefined(ids), 1, -1);
-    const deconstructKey = (key) => {
-      if (strStartsWith(key, storagePrefix)) {
-        const type = slice(key, storagePrefix.length, 1);
-        return type == T || type == V
-          ? [
-              type,
-              ...JSON.parse('[' + slice(key, storagePrefix.length + 1) + ']'),
-            ]
-          : void 0;
-      }
-    };
-    const getPersisted = () =>
-      __async(void 0, null, function* () {
-        const tables = stampNewObjectWithHash();
-        const values = stampNewObjectWithHash();
-        (yield storage.list({prefix: storagePrefix})).forEach((_0, _1) =>
-          __async(
-            void 0,
-            [_0, _1],
-            function* ([zeroOrCellOrValue, time, hash], key) {
-              return ifNotUndefined(deconstructKey(key), ([type, ...ids]) =>
-                type == T
-                  ? ifNotUndefined(
-                      ids[0],
-                      (tableId) => {
-                        const table = objEnsure(
-                          tables[0],
-                          tableId,
-                          stampNewObjectWithHash,
-                        );
-                        ifNotUndefined(
-                          ids[1],
-                          (rowId) => {
-                            const row = objEnsure(
-                              table[0],
-                              rowId,
-                              stampNewObjectWithHash,
-                            );
-                            ifNotUndefined(
-                              ids[2],
-                              (cellId) =>
-                                (row[0][cellId] = [
-                                  zeroOrCellOrValue,
-                                  time,
-                                  hash,
-                                ]),
-                              () => stampUpdate(row, time, hash),
-                            );
-                          },
-                          () => stampUpdate(table, time, hash),
-                        );
-                      },
-                      () => stampUpdate(tables, time, hash),
-                    )
-                  : type == V
-                    ? ifNotUndefined(
-                        ids[0],
-                        (valueId) =>
-                          (values[0][valueId] = [
-                            zeroOrCellOrValue,
-                            time,
-                            hash,
-                          ]),
-                        () => stampUpdate(values, time, hash),
-                      )
-                    : 0,
-              );
-            },
-          ),
-        );
-        return [tables, values];
-      });
-    const setPersisted = (_0, ..._1) =>
-      __async(
-        void 0,
-        [_0, ..._1],
-        function* (
-          getContent,
-          [
-            [tablesObj, tablesTime, tablesHash],
-            [valuesObj, valuesTime, valuesHash],
-          ] = getContent(),
-        ) {
-          const keysToSet = mapNew();
-          mapSet(keysToSet, constructKey(T), [0, tablesTime, tablesHash]);
-          objForEach(tablesObj, ([tableObj, tableTime, tableHash], tableId) => {
-            mapSet(keysToSet, constructKey(T, tableId), [
-              0,
-              tableTime,
-              tableHash,
-            ]);
-            objForEach(tableObj, ([rowObj, rowTime, rowHash], rowId) => {
-              mapSet(keysToSet, constructKey(T, tableId, rowId), [
-                0,
-                rowTime,
-                rowHash,
-              ]);
-              objForEach(rowObj, (cellStamp, cellId) =>
-                mapSet(
-                  keysToSet,
-                  constructKey(T, tableId, rowId, cellId),
-                  cellStamp,
-                ),
-              );
-            });
-          });
-          mapSet(keysToSet, constructKey(V), [0, valuesTime, valuesHash]);
-          objForEach(valuesObj, (valueStamp, valueId) =>
-            mapSet(keysToSet, constructKey(V, valueId), valueStamp),
-          );
-          yield storage.put(mapToObj(keysToSet));
-        },
-      );
-    const addPersisterListener = () => {};
-    const delPersisterListener = () => {};
-    return createCustomPersister(
-      store,
-      getPersisted,
-      setPersisted,
-      addPersisterListener,
-      delPersisterListener,
-      onIgnoredError,
-      2,
-      // MergeableStoreOnly,
-      {getStorage: () => storage},
-    );
-  };
-
-  exports.createDurableObjectStoragePersister =
-    createDurableObjectStoragePersister;
-});