tinybase 5.0.0-beta.6 → 5.0.0-beta.7

package/lib/debug/synchronizers/synchronizer-local.js

@@ -0,0 +1,502 @@
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const strCharCodeAt = (str, position) => str.charCodeAt(position);
+
+const promise = Promise;
+const mathMax = Math.max;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isString = (thing) => getTypeOf(thing) == STRING;
+const size = (arrayOrString) => arrayOrString.length;
+const promiseNew = (resolver) => new promise(resolver);
+
+const arrayForEach = (array, cb) => array.forEach(cb);
+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 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 scheduleRunning = mapNew();
+const scheduleActions = mapNew();
+const getStoreFunctions = (supportsMergeableStore, store) =>
+  !supportsMergeableStore || isUndefined(store.getMergeableContent)
+    ? [
+        0,
+        store.getContent,
+        store.getTransactionChanges,
+        ([changedTables, changedValues]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+      ]
+    : [
+        1,
+        store.getMergeableContent,
+        store.getTransactionMergeableChanges,
+        ([, [[, changedTables], [, changedValues]]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+      ];
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+  onIgnoredError,
+  supportsMergeableStore,
+  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] =
+    getStoreFunctions(supportsMergeableStore, 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 loadLock = async (actions) => {
+    /* istanbul ignore else */
+    if (loadSave != 2) {
+      loadSave = 1;
+      {
+        loads++;
+      }
+      await persister.schedule(async () => {
+        await actions();
+        loadSave = 0;
+      });
+    }
+    return persister;
+  };
+  const setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore && isString(contentOrChanges?.[0])
+      ? contentOrChanges?.[1][2] === 1
+        ? store.applyMergeableChanges
+        : store.setMergeableContent
+      : contentOrChanges?.[2] === 1
+        ? store.applyChanges
+        : store.setContent)(contentOrChanges);
+  };
+  const persister = {
+    load: async (initialTables, initialValues) =>
+      await loadLock(async () => {
+        try {
+          setContentOrChanges(await getPersisted());
+        } catch (error) {
+          onIgnoredError?.(error);
+          store.setContent([initialTables, initialValues]);
+        }
+      }),
+    startAutoLoad: async (initialTables = {}, initialValues = {}) => {
+      await persister.stopAutoLoad().load(initialTables, initialValues);
+      autoLoadHandle = addPersisterListener(
+        async (getContent2, getChanges2) => {
+          const changes = getChanges2?.();
+          await loadLock(async () => {
+            try {
+              setContentOrChanges(
+                changes ?? getContent2?.() ?? (await getPersisted()),
+              );
+            } catch (error) {
+              onIgnoredError?.(error);
+            }
+          });
+        },
+      );
+      return persister;
+    },
+    stopAutoLoad: () => {
+      if (autoLoadHandle) {
+        delPersisterListener(autoLoadHandle);
+        autoLoadHandle = void 0;
+      }
+      return persister;
+    },
+    isAutoLoading: () => !isUndefined(autoLoadHandle),
+    save: async (getChanges2) => {
+      /* istanbul ignore else */
+      if (loadSave != 1) {
+        loadSave = 2;
+        {
+          saves++;
+        }
+        await persister.schedule(async () => {
+          try {
+            await setPersisted(getContent, getChanges2);
+          } catch (error) {
+            /* istanbul ignore next */
+            onIgnoredError?.(error);
+          }
+          loadSave = 0;
+        });
+      }
+      return persister;
+    },
+    startAutoSave: async () => {
+      await persister.stopAutoSave().save();
+      autoSaveListenerId = store.addDidFinishTransactionListener(() => {
+        const changes = getChanges();
+        if (hasChanges(changes)) {
+          persister.save(() => changes);
+        }
+      });
+      return persister;
+    },
+    stopAutoSave: () => {
+      ifNotUndefined(autoSaveListenerId, store.delListener);
+      autoSaveListenerId = void 0;
+      return persister;
+    },
+    isAutoSaving: () => !isUndefined(autoSaveListenerId),
+    schedule: async (...actions) => {
+      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
+      await run();
+      return persister;
+    },
+    getStore: () => store,
+    destroy: () => persister.stopAutoLoad().stopAutoSave(),
+    getStats: () => ({loads, saves}),
+    ...extra,
+  };
+  return objFreeze(persister);
+};
+
+const textEncoder = new globalThis.TextEncoder();
+const getHash = (value) => {
+  let hash = 2166136261;
+  arrayForEach(textEncoder.encode(value), (char) => {
+    hash ^= char;
+    hash +=
+      (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  });
+  return hash >>> 0;
+};
+
+const MASK6 = 63;
+const SHIFT36 = 2 ** 36;
+const SHIFT30 = 2 ** 30;
+const SHIFT24 = 2 ** 24;
+const SHIFT18 = 2 ** 18;
+const SHIFT12 = 2 ** 12;
+const SHIFT6 = 2 ** 6;
+const toB64 = (num) => String.fromCharCode(48 + (num & MASK6));
+const fromB64 = (str, pos) => strCharCodeAt(str, pos) - 48;
+const encodeHlc = (logicalTime42, counter24, clientHash30) =>
+  toB64(logicalTime42 / SHIFT36) +
+  toB64(logicalTime42 / SHIFT30) +
+  toB64(logicalTime42 / SHIFT24) +
+  toB64(logicalTime42 / SHIFT18) +
+  toB64(logicalTime42 / SHIFT12) +
+  toB64(logicalTime42 / SHIFT6) +
+  toB64(logicalTime42) +
+  toB64(counter24 / SHIFT18) +
+  toB64(counter24 / SHIFT12) +
+  toB64(counter24 / SHIFT6) +
+  toB64(counter24) +
+  toB64(clientHash30 / SHIFT24) +
+  toB64(clientHash30 / SHIFT18) +
+  toB64(clientHash30 / SHIFT12) +
+  toB64(clientHash30 / SHIFT6) +
+  toB64(clientHash30);
+const decodeHlc = (hlc16) => [
+  fromB64(hlc16, 0) * SHIFT36 +
+    fromB64(hlc16, 1) * SHIFT30 +
+    fromB64(hlc16, 2) * SHIFT24 +
+    fromB64(hlc16, 3) * SHIFT18 +
+    fromB64(hlc16, 4) * SHIFT12 +
+    fromB64(hlc16, 5) * SHIFT6 +
+    fromB64(hlc16, 6),
+  fromB64(hlc16, 7) * SHIFT18 +
+    fromB64(hlc16, 8) * SHIFT12 +
+    fromB64(hlc16, 9) * SHIFT6 +
+    fromB64(hlc16, 10),
+  fromB64(hlc16, 11) * SHIFT24 +
+    fromB64(hlc16, 12) * SHIFT18 +
+    fromB64(hlc16, 13) * SHIFT12 +
+    fromB64(hlc16, 14) * SHIFT6 +
+    fromB64(hlc16, 15),
+];
+const getHlcFunctions = (uniqueId) => {
+  let logicalTime = 0;
+  let lastCounter = -1;
+  const uniqueIdHash = getHash(uniqueId);
+  const getHlc = () => {
+    seenHlc();
+    return encodeHlc(logicalTime, ++lastCounter, uniqueIdHash);
+  };
+  const seenHlc = (hlc) => {
+    const previousLogicalTime = logicalTime;
+    const [remoteLogicalTime, remoteCounter] =
+      isUndefined(hlc) || hlc == '' ? [0, 0] : decodeHlc(hlc);
+    logicalTime = mathMax(
+      previousLogicalTime,
+      remoteLogicalTime,
+      globalThis.HLC_TIME ?? Date.now(),
+    );
+    lastCounter =
+      logicalTime == previousLogicalTime
+        ? logicalTime == remoteLogicalTime
+          ? mathMax(lastCounter, remoteCounter)
+          : lastCounter
+        : logicalTime == remoteLogicalTime
+          ? remoteCounter
+          : -1;
+  };
+  return [getHlc, seenHlc];
+};
+
+const RESPONSE = 0;
+const CONTENT_HASHES = 1;
+const GET_CONTENT_HASHES = 2;
+const GET_TABLE_IDS_DIFF = 3;
+const GET_ROW_IDS_DIFF = 4;
+const GET_TABLES_CHANGES = 5;
+const GET_VALUES_CHANGES = 6;
+const createCustomSynchronizer = (
+  store,
+  send,
+  onReceive,
+  destroy,
+  requestTimeoutSeconds = 1,
+  onIgnoredError,
+) => {
+  let persisterListener;
+  let sends = 0;
+  let receives = 0;
+  const [getHlc] = getHlcFunctions(store.getId());
+  const pendingRequests = mapNew();
+  onReceive((fromClientId, requestId, messageType, messageBody) => {
+    {
+      receives++;
+    }
+    if (messageType == RESPONSE) {
+      ifNotUndefined(
+        mapGet(pendingRequests, requestId),
+        ([toClientId, handleResponse]) =>
+          isUndefined(toClientId) || toClientId == fromClientId
+            ? handleResponse(messageBody, fromClientId)
+            : /* istanbul ignore next */
+              0,
+      );
+    } else if (messageType == CONTENT_HASHES && persister.isAutoLoading()) {
+      getChangesFromOtherStore(fromClientId, messageBody).then((changes) =>
+        persisterListener?.(void 0, () => changes),
+      );
+    } else {
+      ifNotUndefined(
+        messageType == GET_CONTENT_HASHES && persister.isAutoSaving()
+          ? store.getMergeableContentHashes()
+          : messageType == GET_TABLE_IDS_DIFF
+            ? store.getMergeableTableIdsDiff(messageBody)
+            : messageType == GET_ROW_IDS_DIFF
+              ? store.getMergeableRowIdsDiff(messageBody)
+              : messageType == GET_TABLES_CHANGES
+                ? store.getMergeableTablesChanges(messageBody)
+                : messageType == GET_VALUES_CHANGES
+                  ? store.getMergeableValuesChanges(messageBody)
+                  : void 0,
+        (response) => {
+          {
+            sends++;
+          }
+          send(fromClientId, requestId, RESPONSE, response);
+        },
+      );
+    }
+  });
+  const request = async (toClientId, messageType, messageBody = EMPTY_STRING) =>
+    promiseNew((resolve, reject) => {
+      const requestId = getHlc();
+      const timeout = setTimeout(() => {
+        collDel(pendingRequests, requestId);
+        reject(
+          `No response from ${toClientId ?? 'anyone'} to '${messageType}'`,
+        );
+      }, requestTimeoutSeconds * 1e3);
+      mapSet(pendingRequests, requestId, [
+        toClientId,
+        (response, fromClientId) => {
+          clearTimeout(timeout);
+          collDel(pendingRequests, requestId);
+          resolve([response, fromClientId]);
+        },
+      ]);
+      {
+        sends++;
+      }
+      send(toClientId, requestId, messageType, messageBody);
+    });
+  const getChangesFromOtherStore = async (
+    otherClientId = null,
+    otherContentHashes,
+  ) => {
+    if (isUndefined(otherContentHashes)) {
+      [otherContentHashes, otherClientId] = await request(
+        otherClientId,
+        GET_CONTENT_HASHES,
+      );
+    }
+    const [otherContentTime, [otherTablesHash, otherValuesHash]] =
+      otherContentHashes;
+    const [, [tablesHash, valuesHash]] = store.getMergeableContentHashes();
+    const changes = [EMPTY_STRING, [[EMPTY_STRING, {}], [EMPTY_STRING, {}], 1]];
+    if (tablesHash != otherTablesHash) {
+      changes[0] = otherContentTime;
+      changes[1][0] = (
+        await request(
+          otherClientId,
+          GET_TABLES_CHANGES,
+          store.getMergeableCellHashes(
+            (
+              await request(
+                otherClientId,
+                GET_ROW_IDS_DIFF,
+                store.getMergeableRowHashes(
+                  (
+                    await request(
+                      otherClientId,
+                      GET_TABLE_IDS_DIFF,
+                      store.getMergeableTableHashes(),
+                    )
+                  )[0],
+                ),
+              )
+            )[0],
+          ),
+        )
+      )[0];
+    }
+    if (valuesHash != otherValuesHash) {
+      changes[0] = otherContentTime;
+      changes[1][1] = (
+        await request(
+          otherClientId,
+          GET_VALUES_CHANGES,
+          store.getMergeableValuesHashes(),
+        )
+      )[0];
+    }
+    return changes;
+  };
+  const getPersisted = async () => {
+    const changes = await getChangesFromOtherStore();
+    return changes[0] != EMPTY_STRING ? changes : void 0;
+  };
+  const setPersisted = async () => {
+    {
+      sends++;
+    }
+    send(null, null, CONTENT_HASHES, store.getMergeableContentHashes());
+  };
+  const addPersisterListener = (listener) => (persisterListener = listener);
+  const delPersisterListener = () => (persisterListener = void 0);
+  const persister = createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    true,
+    {
+      startSync: async () =>
+        await (await persister.startAutoLoad()).startAutoSave(),
+      stopSync: () => persister.stopAutoLoad().stopAutoSave(),
+      destroy: () => {
+        destroy();
+        return persister.stopSync();
+      },
+      getSynchronizerStats: () => ({sends, receives}),
+    },
+  );
+  return persister;
+};
+
+const clients = mapNew();
+const createLocalSynchronizer = (store, onIgnoredError) => {
+  const clientId = '' + Math.random();
+  const onReceive = (receive) => {
+    mapSet(clients, clientId, receive);
+  };
+  const send = (toClientId, requestId, messageType, messageBody) => {
+    isUndefined(toClientId)
+      ? mapForEach(clients, (otherClientId, receive) =>
+          otherClientId != clientId
+            ? receive(clientId, requestId, messageType, messageBody)
+            : 0,
+        )
+      : mapGet(clients, toClientId)?.(
+          clientId,
+          requestId,
+          messageType,
+          messageBody,
+        );
+  };
+  const destroy = () => {
+    collDel(clients, clientId);
+  };
+  return createCustomSynchronizer(
+    store,
+    send,
+    onReceive,
+    destroy,
+    1e-3,
+    onIgnoredError,
+  );
+};
+
+export {createLocalSynchronizer};