tinybase 9.5.0 → 9.6.0-beta.1

package/persisters/persister-supabase/index.js

@@ -0,0 +1,883 @@
+const getTypeOf = (thing) => typeof thing;
+const TINYBASE = 'tinybase';
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const UNDEFINED = '\uFFFC';
+const strSplit = (str, separator = EMPTY_STRING, limit) =>
+  str.split(separator, limit);
+
+const promise = Promise;
+const math = Math;
+const getIfNotFunction = (predicate) => (value, then, otherwise) =>
+  predicate(value)
+    ? /* istanbul ignore next */
+      otherwise?.()
+    : then(value);
+const GLOBAL = globalThis;
+const THOUSAND = 1e3;
+const startInterval = (callback, sec, immediate) => {
+  return setInterval(callback, sec * THOUSAND);
+};
+const stopInterval = (interval) => clearInterval(interval);
+const mathFloor = math.floor;
+const mathRandom = math.random;
+const isNullish = (thing) => thing == null;
+const isUndefined = (thing) => thing === void 0;
+const isNull = (thing) => thing === null;
+const ifNotNullish = getIfNotFunction(isNullish);
+const ifNotUndefined = getIfNotFunction(isUndefined);
+const isString = (thing) => getTypeOf(thing) == STRING;
+const isArray = (thing) => Array.isArray(thing);
+const size = (thing) => thing.length;
+const isEmpty = (thing) => size(thing) == 0;
+const test = (regex, subject) => regex.test(subject);
+const promiseNew = (resolver) => new promise(resolver);
+
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arrayMap = (array, cb) => array.map(cb);
+const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
+const arrayFilter = (array, cb) => array.filter(cb);
+const arrayClear = (array, to = size(array)) => array.splice(0, to);
+const arrayPush = (array, ...values) => array.push(...values);
+const arrayShift = (array) => array.shift();
+
+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 object = Object;
+const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
+const isObject = (obj) =>
+  !isNullish(obj) &&
+  ifNotNullish(
+    getPrototypeOf(obj),
+    (objPrototype) =>
+      objPrototype == object.prototype ||
+      isNullish(getPrototypeOf(objPrototype)),
+
+    /* istanbul ignore next */
+    () => true,
+  );
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objSet = (obj, id, value) => {
+  object.defineProperty(obj, id, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true,
+  });
+  return value;
+};
+const objNew = (entries = []) => {
+  const obj = object.create(null);
+  arrayForEach(entries, ([id, value]) => objSet(obj, id, value));
+  return obj;
+};
+const objForEach = (obj, cb) =>
+  arrayForEach(objIds(obj), (id) => cb(obj[id], id));
+const objMap = (obj, cb) => {
+  const mapped = objNew();
+  objForEach(obj, (value, id) => objSet(mapped, id, cb(value, id)));
+  return mapped;
+};
+const objSize = (obj) => size(objIds(obj));
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+
+const map = Map;
+const mapNew = (entries) => new map(entries);
+const mapGet = (map2, key) => map2?.get(key);
+const mapSet = (map2, key, value) =>
+  isUndefined(value) ? (collDel(map2, key), map2) : map2?.set(key, value);
+const mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {
+  let value = mapGet(map2, key);
+  if (collHas(map2, key)) {
+    hadExistingValue?.(value);
+  } else {
+    mapSet(map2, key, (value = getDefaultValue()));
+  }
+  return value;
+};
+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 MASK6 = 63;
+const ENCODE = strSplit(
+  '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz',
+);
+mapNew(arrayMap(ENCODE, (char, index) => [char, index]));
+const encode = (num) => ENCODE[num & MASK6];
+const getRandomValues = GLOBAL.crypto
+  ? (array) => GLOBAL.crypto.getRandomValues(array)
+  : /* istanbul ignore next */
+    (array) => arrayMap(array, () => mathFloor(mathRandom() * 256));
+const getUniqueId = (length = 16) =>
+  arrayReduce(
+    getRandomValues(new Uint8Array(length)),
+    (uniqueId, number) => uniqueId + encode(number),
+    EMPTY_STRING,
+  );
+
+const jsonString = JSON.stringify;
+const jsonParse = JSON.parse;
+const jsonStringWithUndefined = (obj) =>
+  jsonString(obj, (_key, value) => (isUndefined(value) ? UNDEFINED : value));
+const jsonParseWithUndefined = (str) =>
+  // JSON.parse reviver removes properties with undefined values
+  replaceUndefinedString(jsonParse(str));
+const replaceUndefinedString = (obj) =>
+  obj === UNDEFINED
+    ? void 0
+    : isArray(obj)
+      ? arrayMap(obj, replaceUndefinedString)
+      : isObject(obj)
+        ? objMap(obj, replaceUndefinedString)
+        : obj;
+
+const ERROR_STORE_TYPE = 0;
+const ERROR_CONTENT = 1;
+const errorNew = (code, details) =>
+  new Error(
+    TINYBASE +
+      ':' +
+      code +
+      (isUndefined(details)
+        ? EMPTY_STRING
+        : /* istanbul ignore next */
+          ':' + details),
+  );
+const errorThrow = (code, details) => {
+  throw errorNew(code, details);
+};
+const tryCatch = async (action, onError) => {
+  try {
+    return await action();
+  } catch (error) {
+    /* istanbul ignore next */
+    onError?.(error);
+  }
+};
+const tryCatchIgnore = (action, onIgnoredError) =>
+  tryCatch(action, (error) => void tryCatch(() => onIgnoredError?.(error)));
+const tryCatchSync = (action, onError) => {
+  try {
+    return action();
+  } catch (error) {
+    onError?.(error);
+  }
+};
+const tryFinally = (action, finallyAction) => {
+  try {
+    return action();
+  } finally {
+    finallyAction();
+  }
+};
+const tryFinallyAsync = async (action, finallyAction) => {
+  try {
+    return await action();
+  } finally {
+    await finallyAction();
+  }
+};
+
+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 setNew = (entryOrEntries) =>
+  new Set(
+    isArray(entryOrEntries) || isUndefined(entryOrEntries)
+      ? entryOrEntries
+      : [entryOrEntries],
+  );
+const setAdd = (set, value) => set?.add(value);
+
+const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
+  const leaves = [];
+  const deep = (node, p) =>
+    p == size(path)
+      ? arrayPush(leaves, node)
+      : isNull(path[p])
+        ? 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 callListenersImpl = (continueAfterError, idSetNode, ids, extraArgs) => {
+    let errorToThrow;
+    let failed = false;
+    arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
+      collForEach(set, (id) => {
+        const callListener2 = () =>
+          mapGet(allListeners, id)[0](thing, ...(ids ?? []), ...extraArgs);
+        if (continueAfterError) {
+          tryCatchSync(callListener2, (error) => {
+            if (!failed) {
+              errorToThrow = error;
+            }
+            failed = true;
+          });
+        } else {
+          callListener2();
+        }
+      }),
+    );
+    if (failed) {
+      throw errorToThrow;
+    }
+  };
+  const callListeners = (idSetNode, ids, ...extraArgs) =>
+    callListenersImpl(false, idSetNode, ids, extraArgs);
+  const callListenersThenThrow = (idSetNode, ids, ...extraArgs) =>
+    callListenersImpl(true, idSetNode, 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 (isNull(path[index])) {
+            arrayForEach(pathGetters[index]?.(...ids) ?? [], (id2) =>
+              callWithIds(...ids, id2),
+            );
+          } else {
+            callWithIds(...ids, path[index]);
+          }
+        };
+        callWithIds();
+      },
+    );
+  return [
+    addListener,
+    callListeners,
+    delListener,
+    callListener,
+    callListenersThenThrow,
+  ];
+};
+
+const scheduleRunning = mapNew();
+const scheduleActions = mapNew();
+const scheduleReferences = mapNew();
+const getStoreFunctions = (
+  persist = 1 /* StoreOnly */,
+  store,
+  isSynchronizer,
+) =>
+  persist != 1 /* StoreOnly */ && store.isMergeable()
+    ? [
+        1,
+        store.__[1],
+        () => store.__[2](!isSynchronizer),
+        ([[changedTables], [changedValues]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+        store.setDefaultContent,
+      ]
+    : persist != 2 /* MergeableStoreOnly */
+      ? [
+          0,
+          store._[7],
+          store._[8],
+          ([changedTables, changedValues]) =>
+            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+          store.setContent,
+        ]
+      : errorThrow(ERROR_STORE_TYPE);
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  addPersisterListener,
+  delPersisterListener,
+  onIgnoredError,
+  persist,
+  extra = {},
+  isSynchronizer = 0,
+  scheduleId = [],
+) => {
+  let status = 0; /* Idle */
+  let loads = 0;
+  let saves = 0;
+  let autoLoadHandle;
+  let autoLoadPromise;
+  let autoLoadGeneration = 0;
+  let pendingAutoLoads = 0;
+  let pendingScheduledAutoLoads = 0;
+  let autoLoadAfterSaveGeneration = 0;
+  let autoSaveListenerId;
+  let autoSaveGeneration = 0;
+  let destroyed = 0;
+  let destroying;
+  let activeAction;
+  const scheduleOwner = {};
+  const extraDestroy = extra.destroy;
+  mapEnsure(scheduleRunning, scheduleId, () => 0);
+  mapEnsure(scheduleActions, scheduleId, () => []);
+  mapSet(
+    scheduleReferences,
+    scheduleId,
+    (mapGet(scheduleReferences, scheduleId) ?? 0) + 1,
+  );
+  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);
+      const scheduledActions = mapGet(scheduleActions, scheduleId);
+      let actionIndex = 0;
+      await tryFinallyAsync(
+        async () => {
+          while (actionIndex < size(scheduledActions)) {
+            const scheduledAction = scheduledActions[actionIndex++];
+            scheduledAction[2] = void 0;
+            await scheduledAction[0]();
+          }
+        },
+        () => {
+          arrayClear(scheduledActions, actionIndex);
+          mapSet(scheduleRunning, scheduleId, 0);
+          pruneSchedule();
+        },
+      );
+    }
+  };
+  const pruneSchedule = () => {
+    if (
+      !mapGet(scheduleReferences, scheduleId) &&
+      !mapGet(scheduleRunning, scheduleId) &&
+      isEmpty(mapGet(scheduleActions, scheduleId) ?? [])
+    ) {
+      mapSet(scheduleRunning, scheduleId);
+      mapSet(scheduleActions, scheduleId);
+      mapSet(scheduleReferences, scheduleId);
+    }
+  };
+  const setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore && isArray(contentOrChanges?.[0])
+      ? contentOrChanges?.[2] === 1
+        ? store.__[4]
+        : store.__[3]
+      : contentOrChanges?.[2] === 1
+        ? store._[10]
+        : store._[9])(contentOrChanges);
+  };
+  const saveAfterMutated = async () => {
+    if (isAutoSaving() && store.__?.[0]?.()) {
+      await save();
+    }
+  };
+  const trackAutoLoadPromise = (newAutoLoadPromise) =>
+    tryFinallyAsync(
+      () => (autoLoadPromise = newAutoLoadPromise),
+      () => {
+        if (autoLoadPromise == newAutoLoadPromise) {
+          autoLoadPromise = void 0;
+        }
+      },
+    );
+  const load = async (initialContent) => {
+    /* istanbul ignore else */
+    if (status != 2 /* Saving */) {
+      await tryFinallyAsync(
+        async () => {
+          setStatus(1 /* Loading */);
+          loads++;
+          await schedule(() =>
+            tryCatch(
+              async () => {
+                const content = await getPersisted();
+                if (isArray(content)) {
+                  setContentOrChanges(content);
+                } else if (isUndefined(content) && initialContent) {
+                  setDefaultContent(initialContent);
+                } else if (!isUndefined(content)) {
+                  errorThrow(ERROR_CONTENT, content);
+                }
+              },
+              (error) => {
+                onIgnoredError?.(error);
+                if (initialContent) {
+                  setDefaultContent(initialContent);
+                }
+              },
+            ),
+          );
+        },
+        () => setStatus(0 /* Idle */),
+      );
+      await saveAfterMutated();
+    }
+    return persister;
+  };
+  const runAutoLoadAfterSave = async () => {
+    const generation = autoLoadAfterSaveGeneration;
+    autoLoadAfterSaveGeneration = 0;
+    if (generation && generation == autoLoadGeneration && !destroyed) {
+      if (status == 2 /* Saving */) {
+        autoLoadAfterSaveGeneration = generation;
+      } else {
+        await load();
+      }
+    }
+  };
+  const startAutoLoad = async (initialContent) => {
+    const generation = ++autoLoadGeneration;
+    let initialLoadPending = true;
+    await stopAutoLoad(true);
+    if (generation == autoLoadGeneration && !destroyed) {
+      const listenerPromise = tryCatch(async () => {
+        const handle = await addPersisterListener(async (content, changes) => {
+          if (generation == autoLoadGeneration && !destroyed) {
+            if (changes || content) {
+              const shouldSchedule =
+                initialLoadPending ||
+                status == 2 /* Saving */ ||
+                !!pendingScheduledAutoLoads;
+              pendingAutoLoads++;
+              if (shouldSchedule) {
+                pendingScheduledAutoLoads++;
+              }
+              await tryFinallyAsync(
+                async () => {
+                  setStatus(1 /* Loading */);
+                  loads++;
+                  await (shouldSchedule
+                    ? schedule(() => setContentOrChanges(changes ?? content))
+                    : tryFinally(
+                        () => setContentOrChanges(changes ?? content),
+                        () => setStatus(0 /* Idle */),
+                      ));
+                },
+                () => {
+                  if (shouldSchedule) {
+                    pendingScheduledAutoLoads--;
+                  }
+                  if (!--pendingAutoLoads) {
+                    setStatus(0 /* Idle */);
+                  }
+                },
+              );
+              if (!pendingAutoLoads) {
+                await saveAfterMutated();
+              }
+            } else if (status == 2 /* Saving */) {
+              autoLoadAfterSaveGeneration = generation;
+            } else {
+              await load();
+            }
+          }
+        });
+        if (generation == autoLoadGeneration && !destroyed) {
+          autoLoadHandle = handle;
+        } else if (!isUndefined(handle)) {
+          await delPersisterListener(handle);
+        }
+      }, onIgnoredError);
+      await trackAutoLoadPromise(listenerPromise);
+      if (generation == autoLoadGeneration && !destroyed) {
+        await tryFinallyAsync(
+          () => load(initialContent),
+          () => {
+            initialLoadPending = false;
+          },
+        );
+      }
+    }
+    return persister;
+  };
+  const stopAutoLoad = async (keepGeneration = false) => {
+    autoLoadAfterSaveGeneration = 0;
+    if (!keepGeneration) {
+      autoLoadGeneration++;
+    }
+    const listenerPromise = autoLoadPromise;
+    const handle = autoLoadHandle;
+    autoLoadHandle = void 0;
+    await trackAutoLoadPromise(
+      tryFinallyAsync(
+        async () => {
+          await listenerPromise;
+        },
+        async () => {
+          if (!isUndefined(handle)) {
+            await tryCatch(() => delPersisterListener(handle), onIgnoredError);
+          }
+        },
+      ),
+    );
+    return persister;
+  };
+  const isAutoLoading = () => !isUndefined(autoLoadHandle);
+  const save = async (changes) => {
+    /* istanbul ignore else */
+    if (status != 1 /* Loading */) {
+      await tryFinallyAsync(
+        () =>
+          tryFinallyAsync(
+            async () => {
+              setStatus(2 /* Saving */);
+              saves++;
+              await schedule(() =>
+                tryCatch(
+                  () => setPersisted(getContent, changes),
+                  onIgnoredError,
+                ),
+              );
+            },
+            () => setStatus(0 /* Idle */),
+          ),
+        runAutoLoadAfterSave,
+      );
+    }
+    return persister;
+  };
+  const startAutoSave = async () => {
+    const generation = ++autoSaveGeneration;
+    await stopAutoSave(true);
+    if (generation == autoSaveGeneration && !destroyed) {
+      await save();
+      if (generation == autoSaveGeneration && !destroyed) {
+        autoSaveListenerId = store.addDidFinishTransactionListener(() => {
+          if (generation == autoSaveGeneration && !destroyed) {
+            const changes = getChanges();
+            if (hasChanges(changes)) {
+              void tryCatch(() => save(changes));
+            }
+          }
+        });
+      }
+    }
+    return persister;
+  };
+  const stopAutoSave = async (keepGeneration = false) => {
+    if (!keepGeneration) {
+      autoSaveGeneration++;
+    }
+    const listenerId = autoSaveListenerId;
+    autoSaveListenerId = void 0;
+    if (!isUndefined(listenerId)) {
+      store.delListener(listenerId);
+    }
+    return persister;
+  };
+  const isAutoSaving = () => !isUndefined(autoSaveListenerId);
+  const startAutoPersisting = async (
+    initialContent,
+    startSaveFirst = false,
+  ) => {
+    const [call1, call2, stop1, stop2] = startSaveFirst
+      ? [startAutoSave, startAutoLoad, stopAutoSave, stopAutoLoad]
+      : [startAutoLoad, startAutoSave, stopAutoLoad, stopAutoSave];
+    const start1 = call1(initialContent);
+    const generation1 = startSaveFirst
+      ? autoSaveGeneration
+      : autoLoadGeneration;
+    await start1;
+    const start2 = call2(initialContent);
+    const generation2 = startSaveFirst
+      ? autoLoadGeneration
+      : autoSaveGeneration;
+    try {
+      await start2;
+    } catch (error) {
+      if (
+        generation2 ==
+        (startSaveFirst ? autoLoadGeneration : autoSaveGeneration)
+      ) {
+        await tryCatchIgnore(stop2);
+      }
+      if (
+        generation1 ==
+        (startSaveFirst ? autoSaveGeneration : autoLoadGeneration)
+      ) {
+        await tryCatchIgnore(stop1);
+      }
+      throw error;
+    }
+    return persister;
+  };
+  const stopAutoPersisting = async (stopSaveFirst = false) => {
+    const [call1, call2] = stopSaveFirst
+      ? [stopAutoSave, stopAutoLoad]
+      : [stopAutoLoad, stopAutoSave];
+    await tryFinallyAsync(
+      () => call1(),
+      async () => {
+        await call2();
+      },
+    );
+    return persister;
+  };
+  const getStatus = () => status;
+  const addStatusListener = (listener) =>
+    addListener(listener, statusListeners);
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return store;
+  };
+  const schedule = async (...actions) => {
+    let failed = false;
+    let firstError;
+    const completion = promiseNew((resolve) =>
+      !isEmpty(actions)
+        ? arrayPush(
+            mapGet(scheduleActions, scheduleId),
+            ...arrayMap(actions, (action, index) => {
+              const last = index == size(actions) - 1;
+              return [
+                async () => {
+                  let completeActiveAction;
+                  activeAction = promiseNew(
+                    (resolve2) => (completeActiveAction = resolve2),
+                  );
+                  await tryFinallyAsync(
+                    async () => {
+                      try {
+                        await tryCatch(action, onIgnoredError);
+                      } catch (error) {
+                        if (!failed) {
+                          failed = true;
+                          firstError = error;
+                        }
+                      }
+                      if (last) {
+                        resolve();
+                      }
+                    },
+                    () => {
+                      activeAction = void 0;
+                      completeActiveAction();
+                    },
+                  );
+                },
+                last ? resolve : void 0,
+                scheduleOwner,
+              ];
+            }),
+          )
+        : resolve(),
+    );
+    await run();
+    await completion;
+    if (failed) {
+      throw firstError;
+    }
+    return persister;
+  };
+  const getStore = () => store;
+  const destroy = async () => {
+    if (isUndefined(destroying)) {
+      destroyed = 1;
+      destroying = (async () => {
+        const scheduledActions = mapGet(scheduleActions, scheduleId);
+        const remainingActions = arrayFilter(
+          scheduledActions,
+          ([, complete, owner]) => {
+            if (owner == scheduleOwner) {
+              complete?.();
+              return false;
+            }
+            return true;
+          },
+        );
+        const actionToAwait = activeAction;
+        arrayClear(scheduledActions);
+        arrayPush(scheduledActions, ...remainingActions);
+        await tryFinallyAsync(
+          () =>
+            tryFinallyAsync(
+              () => tryFinallyAsync(stopAutoPersisting, () => actionToAwait),
+              () => extraDestroy?.(),
+            ),
+          () => {
+            const references =
+              (mapGet(scheduleReferences, scheduleId) ?? 1) - 1;
+            mapSet(scheduleReferences, scheduleId, references || void 0);
+            pruneSchedule();
+          },
+        );
+      })();
+    }
+    await destroying;
+    return persister;
+  };
+  const getStats = () => ({loads, saves});
+  const persister = {
+    load,
+    startAutoLoad,
+    stopAutoLoad,
+    isAutoLoading,
+    save,
+    startAutoSave,
+    stopAutoSave,
+    isAutoSaving,
+    startAutoPersisting,
+    stopAutoPersisting,
+    getStatus,
+    addStatusListener,
+    delListener,
+    schedule,
+    getStore,
+    getStats,
+    ...extra,
+    destroy,
+  };
+  return objFreeze(persister);
+};
+
+const SINGLE_ROW_ID = '_';
+const DEFAULT_ROW_ID_COLUMN_NAME = '_id';
+
+const STORE_COLUMN_NAME = 'store';
+const PUBLIC_SCHEMA = 'public';
+const createSupabasePersister = (
+  store,
+  supabase,
+  configOrStoreTableName,
+  onIgnoredError,
+) => {
+  const config = isString(configOrStoreTableName)
+    ? {storeTableName: configOrStoreTableName}
+    : (configOrStoreTableName ?? {});
+  const storeTableName = config.storeTableName ?? TINYBASE;
+  const storeIdColumnName =
+    config.storeIdColumnName ?? DEFAULT_ROW_ID_COLUMN_NAME;
+  const storeColumnName = config.storeColumnName ?? STORE_COLUMN_NAME;
+  const {autoLoadIntervalSeconds} = config;
+  const getPersisted = async () => {
+    const {data, error} = await supabase
+      .from(storeTableName)
+      .select(storeColumnName)
+      .eq(storeIdColumnName, SINGLE_ROW_ID)
+      .maybeSingle();
+    if (error) {
+      throw error;
+    }
+    return jsonParseWithUndefined(data?.[storeColumnName] ?? 'null');
+  };
+  const setPersisted = async (getContent) => {
+    const {error} = await supabase.from(storeTableName).upsert(
+      {
+        [storeIdColumnName]: SINGLE_ROW_ID,
+        [storeColumnName]: jsonStringWithUndefined(getContent() ?? null),
+      },
+      {onConflict: storeIdColumnName},
+    );
+    if (error) {
+      throw error;
+    }
+  };
+  const addPersisterListener = (listener) => [
+    supabase
+      .channel(TINYBASE + '_' + storeTableName + '_' + getUniqueId())
+      .on(
+        'postgres_changes',
+        {event: '*', schema: PUBLIC_SCHEMA, table: storeTableName},
+        () => void listener(),
+      )
+      .subscribe((_status, error) => (error ? onIgnoredError?.(error) : 0)),
+    isUndefined(autoLoadIntervalSeconds)
+      ? void 0
+      : startInterval(() => void listener(), autoLoadIntervalSeconds),
+  ];
+  const delPersisterListener = async ([channel, interval]) => {
+    stopInterval(interval);
+    await supabase.removeChannel(channel);
+  };
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    addPersisterListener,
+    delPersisterListener,
+    onIgnoredError,
+    3,
+    // StoreOrMergeableStore,
+    {getSupabase: () => supabase},
+  );
+};
+
+export {createSupabasePersister};