tinybase 5.0.0-beta.2 → 5.0.0-beta.21

package/debug/ui-react/with-schemas/index.js

@@ -0,0 +1,1984 @@
+import React from 'react';
+
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const FUNCTION = getTypeOf(getTypeOf);
+const LISTENER = 'Listener';
+const RESULT = 'Result';
+const GET = 'get';
+const ADD = 'add';
+const HAS = 'Has';
+const _HAS = 'has';
+const IDS = 'Ids';
+const TABLE = 'Table';
+const TABLES = TABLE + 's';
+const TABLE_IDS = TABLE + IDS;
+const ROW = 'Row';
+const ROW_COUNT = ROW + 'Count';
+const ROW_IDS = ROW + IDS;
+const SORTED_ROW_IDS = 'Sorted' + ROW + IDS;
+const CELL = 'Cell';
+const CELL_IDS = CELL + IDS;
+const VALUE = 'Value';
+const VALUES = VALUE + 's';
+const VALUE_IDS = VALUE + IDS;
+
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isString = (thing) => getTypeOf(thing) == STRING;
+const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
+const isArray = (thing) => Array.isArray(thing);
+const size = (arrayOrString) => arrayOrString.length;
+const getUndefined = () => void 0;
+
+const arrayEvery = (array, cb) => array.every(cb);
+const arrayIsEqual = (array1, array2) =>
+  size(array1) === size(array2) &&
+  arrayEvery(array1, (value1, index) => array2[index] === value1);
+const arrayMap = (array, cb) => array.map(cb);
+const arrayIsEmpty = (array) => size(array) == 0;
+
+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 objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+const objDel = (obj, id) => {
+  delete obj[id];
+  return obj;
+};
+const objSize = (obj) => size(objIds(obj));
+const objIsEqual = (obj1, obj2) => {
+  const entries1 = objEntries(obj1);
+  return (
+    size(entries1) === objSize(obj2) &&
+    arrayEvery(entries1, ([index, value1]) =>
+      isObject(value1)
+        ? isObject(obj2[index])
+          ? objIsEqual(obj2[index], value1)
+          : false
+        : obj2[index] === value1,
+    )
+  );
+};
+
+const {createContext, useContext: useContext$1, useEffect: useEffect$1} = React;
+const Context = createContext([]);
+const useThing = (id, offset) => {
+  const contextValue = useContext$1(Context);
+  return isUndefined(id)
+    ? contextValue[offset]
+    : isString(id)
+      ? objGet(contextValue[offset + 1] ?? {}, id)
+      : id;
+};
+const useThingOrThingById = (thingOrThingId, offset) => {
+  const thing = useThing(thingOrThingId, offset);
+  return isUndefined(thingOrThingId) || isString(thingOrThingId)
+    ? thing
+    : thingOrThingId;
+};
+const useThingIds = (offset) => objIds(useContext$1(Context)[offset] ?? {});
+const useStore = (id) => useThing(id, 0);
+const useStoreOrStoreById = (storeOrStoreId) =>
+  useThingOrThingById(storeOrStoreId, 0);
+const useProvideStore = (storeId, store) => {
+  const {12: addExtraStore, 13: delExtraStore} = useContext$1(Context);
+  useEffect$1(() => {
+    addExtraStore?.(storeId, store);
+    return () => delExtraStore?.(storeId);
+  }, [addExtraStore, storeId, store, delExtraStore]);
+};
+const useMetrics = (id) => useThing(id, 2);
+const useMetricsOrMetricsById = (metricsOrMetricsId) =>
+  useThingOrThingById(metricsOrMetricsId, 2);
+const useIndexes = (id) => useThing(id, 4);
+const useIndexesOrIndexesById = (indexesOrIndexesId) =>
+  useThingOrThingById(indexesOrIndexesId, 4);
+const useRelationships = (id) => useThing(id, 6);
+const useRelationshipsOrRelationshipsById = (relationshipsOrRelationshipsId) =>
+  useThingOrThingById(relationshipsOrRelationshipsId, 6);
+const useQueries = (id) => useThing(id, 8);
+const useQueriesOrQueriesById = (queriesOrQueriesId) =>
+  useThingOrThingById(queriesOrQueriesId, 8);
+const useCheckpoints = (id) => useThing(id, 10);
+const useCheckpointsOrCheckpointsById = (checkpointsOrCheckpointsId) =>
+  useThingOrThingById(checkpointsOrCheckpointsId, 10);
+
+const lower = (str) => str.toLowerCase();
+lower(LISTENER);
+const TRANSACTION = 'Transaction';
+lower(TRANSACTION);
+
+const {
+  useCallback: useCallback$2,
+  useEffect,
+  useMemo: useMemo$1,
+  useLayoutEffect: useLayoutEffect$1,
+  useRef: useRef$1,
+  useState: useState$2,
+  useSyncExternalStore,
+} = React;
+const EMPTY_ARRAY = [];
+const DEFAULTS = [{}, [], [EMPTY_ARRAY, void 0, EMPTY_ARRAY], void 0, false, 0];
+const IS_EQUAL = (thing1, thing2) => thing1 === thing2;
+const IS_EQUALS = [
+  objIsEqual,
+  arrayIsEqual,
+  (
+    [backwardIds1, currentId1, forwardIds1],
+    [backwardIds2, currentId2, forwardIds2],
+  ) =>
+    currentId1 === currentId2 &&
+    arrayIsEqual(backwardIds1, backwardIds2) &&
+    arrayIsEqual(forwardIds1, forwardIds2),
+];
+const useCreate = (store, create, createDeps = EMPTY_ARRAY) => {
+  const [, rerender] = useState$2();
+  const [thing, setThing] = useState$2();
+  useEffect(
+    () => {
+      const newThing = store ? create(store) : void 0;
+      setThing(newThing);
+      rerender([]);
+      return newThing?.destroy;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [store, ...createDeps],
+  );
+  return thing;
+};
+const addAndDelListener = (thing, listenable, ...args) => {
+  const listenerId = thing?.[ADD + listenable + LISTENER]?.(...args);
+  return () => thing?.delListener(listenerId);
+};
+const useListenable = (listenable, thing, type, args = EMPTY_ARRAY) => {
+  const lastResult = useRef$1(DEFAULTS[type]);
+  const getResult = useCallback$2(
+    () => {
+      const nextResult =
+        thing?.[(type == 4 ? _HAS : GET) + listenable]?.(...args) ??
+        DEFAULTS[type];
+      return !(IS_EQUALS[type] ?? IS_EQUAL)(nextResult, lastResult.current)
+        ? (lastResult.current = nextResult)
+        : lastResult.current;
+    },
+    /* eslint-disable-next-line react-hooks/exhaustive-deps */
+    [thing, type, listenable, ...args],
+  );
+  const subscribe = useCallback$2(
+    (listener) =>
+      addAndDelListener(
+        thing,
+        (type == 4 ? HAS : EMPTY_STRING) + listenable,
+        ...args,
+        listener,
+      ),
+    /* eslint-disable-next-line react-hooks/exhaustive-deps */
+    [thing, type, listenable, ...args],
+  );
+  const result = useSyncExternalStore(subscribe, getResult);
+  return type == 0 ? {...result} : type < 3 ? [...result] : result;
+};
+const useListener = (
+  listenable,
+  thing,
+  listener,
+  listenerDeps = EMPTY_ARRAY,
+  preArgs = EMPTY_ARRAY,
+  ...postArgs
+) =>
+  useLayoutEffect$1(
+    () =>
+      addAndDelListener(thing, listenable, ...preArgs, listener, ...postArgs),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [thing, listenable, ...preArgs, ...listenerDeps, ...postArgs],
+  );
+const useSetCallback = (
+  storeOrStoreId,
+  settable,
+  get,
+  getDeps = EMPTY_ARRAY,
+  then = getUndefined,
+  thenDeps = EMPTY_ARRAY,
+  ...args
+) => {
+  const store = useStoreOrStoreById(storeOrStoreId);
+  return useCallback$2(
+    (parameter) =>
+      ifNotUndefined(store, (store2) =>
+        ifNotUndefined(get(parameter, store2), (thing) =>
+          then(
+            store2['set' + settable](
+              ...arrayMap(args, (arg) =>
+                isFunction(arg) ? arg(parameter, store2) : arg,
+              ),
+              thing,
+            ),
+            thing,
+          ),
+        ),
+      ),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [store, settable, ...getDeps, ...thenDeps, ...args],
+  );
+};
+const useDel = (
+  storeOrStoreId,
+  deletable,
+  then = getUndefined,
+  thenDeps = EMPTY_ARRAY,
+  ...args
+) => {
+  const store = useStoreOrStoreById(storeOrStoreId);
+  return useCallback$2(
+    () => then(store?.['del' + deletable](...args)),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [store, deletable, ...thenDeps, ...args],
+  );
+};
+const useCheckpointAction = (checkpointsOrCheckpointsId, action, arg) => {
+  const checkpoints = useCheckpointsOrCheckpointsById(
+    checkpointsOrCheckpointsId,
+  );
+  return useCallback$2(
+    () => checkpoints?.[action](arg),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [checkpoints, action, arg],
+  );
+};
+const useCreateStore = (create, createDeps = EMPTY_ARRAY) =>
+  useMemo$1(create, createDeps);
+const useCreateMergeableStore = (create, createDeps = EMPTY_ARRAY) =>
+  useMemo$1(create, createDeps);
+const useStoreIds = () => useThingIds(1);
+const useHasTables = (storeOrStoreId) =>
+  useListenable(TABLES, useStoreOrStoreById(storeOrStoreId), 4, []);
+const useTables = (storeOrStoreId) =>
+  useListenable(TABLES, useStoreOrStoreById(storeOrStoreId), 0);
+const useTableIds = (storeOrStoreId) =>
+  useListenable(TABLE_IDS, useStoreOrStoreById(storeOrStoreId), 1);
+const useHasTable = (tableId, storeOrStoreId) =>
+  useListenable(TABLE, useStoreOrStoreById(storeOrStoreId), 4, [tableId]);
+const useTable = (tableId, storeOrStoreId) =>
+  useListenable(TABLE, useStoreOrStoreById(storeOrStoreId), 0, [tableId]);
+const useTableCellIds = (tableId, storeOrStoreId) =>
+  useListenable(TABLE + CELL_IDS, useStoreOrStoreById(storeOrStoreId), 1, [
+    tableId,
+  ]);
+const useHasTableCell = (tableId, cellId, storeOrStoreId) =>
+  useListenable(TABLE + CELL, useStoreOrStoreById(storeOrStoreId), 4, [
+    tableId,
+    cellId,
+  ]);
+const useRowCount = (tableId, storeOrStoreId) =>
+  useListenable(ROW_COUNT, useStoreOrStoreById(storeOrStoreId), 5, [tableId]);
+const useRowIds = (tableId, storeOrStoreId) =>
+  useListenable(ROW_IDS, useStoreOrStoreById(storeOrStoreId), 1, [tableId]);
+const useSortedRowIds = (
+  tableId,
+  cellId,
+  descending,
+  offset = 0,
+  limit,
+  storeOrStoreId,
+) =>
+  useListenable(SORTED_ROW_IDS, useStoreOrStoreById(storeOrStoreId), 1, [
+    tableId,
+    cellId,
+    descending,
+    offset,
+    limit,
+  ]);
+const useHasRow = (tableId, rowId, storeOrStoreId) =>
+  useListenable(ROW, useStoreOrStoreById(storeOrStoreId), 4, [tableId, rowId]);
+const useRow = (tableId, rowId, storeOrStoreId) =>
+  useListenable(ROW, useStoreOrStoreById(storeOrStoreId), 0, [tableId, rowId]);
+const useCellIds = (tableId, rowId, storeOrStoreId) =>
+  useListenable(CELL_IDS, useStoreOrStoreById(storeOrStoreId), 1, [
+    tableId,
+    rowId,
+  ]);
+const useHasCell = (tableId, rowId, cellId, storeOrStoreId) =>
+  useListenable(CELL, useStoreOrStoreById(storeOrStoreId), 4, [
+    tableId,
+    rowId,
+    cellId,
+  ]);
+const useCell = (tableId, rowId, cellId, storeOrStoreId) =>
+  useListenable(CELL, useStoreOrStoreById(storeOrStoreId), 3, [
+    tableId,
+    rowId,
+    cellId,
+  ]);
+const useHasValues = (storeOrStoreId) =>
+  useListenable(VALUES, useStoreOrStoreById(storeOrStoreId), 4, []);
+const useValues = (storeOrStoreId) =>
+  useListenable(VALUES, useStoreOrStoreById(storeOrStoreId), 0);
+const useValueIds = (storeOrStoreId) =>
+  useListenable(VALUE_IDS, useStoreOrStoreById(storeOrStoreId), 1);
+const useHasValue = (valueId, storeOrStoreId) =>
+  useListenable(VALUE, useStoreOrStoreById(storeOrStoreId), 4, [valueId]);
+const useValue = (valueId, storeOrStoreId) =>
+  useListenable(VALUE, useStoreOrStoreById(storeOrStoreId), 3, [valueId]);
+const useSetTablesCallback = (
+  getTables,
+  getTablesDeps,
+  storeOrStoreId,
+  then,
+  thenDeps,
+) =>
+  useSetCallback(
+    storeOrStoreId,
+    TABLES,
+    getTables,
+    getTablesDeps,
+    then,
+    thenDeps,
+  );
+const useSetTableCallback = (
+  tableId,
+  getTable,
+  getTableDeps,
+  storeOrStoreId,
+  then,
+  thenDeps,
+) =>
+  useSetCallback(
+    storeOrStoreId,
+    TABLE,
+    getTable,
+    getTableDeps,
+    then,
+    thenDeps,
+    tableId,
+  );
+const useSetRowCallback = (
+  tableId,
+  rowId,
+  getRow,
+  getRowDeps,
+  storeOrStoreId,
+  then,
+  thenDeps,
+) =>
+  useSetCallback(
+    storeOrStoreId,
+    ROW,
+    getRow,
+    getRowDeps,
+    then,
+    thenDeps,
+    tableId,
+    rowId,
+  );
+const useAddRowCallback = (
+  tableId,
+  getRow,
+  getRowDeps = EMPTY_ARRAY,
+  storeOrStoreId,
+  then = getUndefined,
+  thenDeps = EMPTY_ARRAY,
+  reuseRowIds = true,
+) => {
+  const store = useStoreOrStoreById(storeOrStoreId);
+  return useCallback$2(
+    (parameter) =>
+      ifNotUndefined(store, (store2) =>
+        ifNotUndefined(getRow(parameter, store2), (row) =>
+          then(
+            store2.addRow(
+              isFunction(tableId) ? tableId(parameter, store2) : tableId,
+              row,
+              reuseRowIds,
+            ),
+            store2,
+            row,
+          ),
+        ),
+      ),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [store, tableId, ...getRowDeps, ...thenDeps, reuseRowIds],
+  );
+};
+const useSetPartialRowCallback = (
+  tableId,
+  rowId,
+  getPartialRow,
+  getPartialRowDeps,
+  storeOrStoreId,
+  then,
+  thenDeps,
+) =>
+  useSetCallback(
+    storeOrStoreId,
+    'PartialRow',
+    getPartialRow,
+    getPartialRowDeps,
+    then,
+    thenDeps,
+    tableId,
+    rowId,
+  );
+const useSetCellCallback = (
+  tableId,
+  rowId,
+  cellId,
+  getCell,
+  getCellDeps,
+  storeOrStoreId,
+  then,
+  thenDeps,
+) =>
+  useSetCallback(
+    storeOrStoreId,
+    CELL,
+    getCell,
+    getCellDeps,
+    then,
+    thenDeps,
+    tableId,
+    rowId,
+    cellId,
+  );
+const useSetValuesCallback = (
+  getValues,
+  getValuesDeps,
+  storeOrStoreId,
+  then,
+  thenDeps,
+) =>
+  useSetCallback(
+    storeOrStoreId,
+    VALUES,
+    getValues,
+    getValuesDeps,
+    then,
+    thenDeps,
+  );
+const useSetPartialValuesCallback = (
+  getPartialValues,
+  getPartialValuesDeps,
+  storeOrStoreId,
+  then,
+  thenDeps,
+) =>
+  useSetCallback(
+    storeOrStoreId,
+    'PartialValues',
+    getPartialValues,
+    getPartialValuesDeps,
+    then,
+    thenDeps,
+  );
+const useSetValueCallback = (
+  valueId,
+  getValue,
+  getValueDeps,
+  storeOrStoreId,
+  then,
+  thenDeps,
+) =>
+  useSetCallback(
+    storeOrStoreId,
+    VALUE,
+    getValue,
+    getValueDeps,
+    then,
+    thenDeps,
+    valueId,
+  );
+const useDelTablesCallback = (storeOrStoreId, then, thenDeps) =>
+  useDel(storeOrStoreId, TABLES, then, thenDeps);
+const useDelTableCallback = (tableId, storeOrStoreId, then, thenDeps) =>
+  useDel(storeOrStoreId, TABLE, then, thenDeps, tableId);
+const useDelRowCallback = (tableId, rowId, storeOrStoreId, then, thenDeps) =>
+  useDel(storeOrStoreId, ROW, then, thenDeps, tableId, rowId);
+const useDelCellCallback = (
+  tableId,
+  rowId,
+  cellId,
+  forceDel,
+  storeOrStoreId,
+  then,
+  thenDeps,
+) =>
+  useDel(
+    storeOrStoreId,
+    CELL,
+    then,
+    thenDeps,
+    tableId,
+    rowId,
+    cellId,
+    forceDel,
+  );
+const useDelValuesCallback = (storeOrStoreId, then, thenDeps) =>
+  useDel(storeOrStoreId, VALUES, then, thenDeps);
+const useDelValueCallback = (valueId, storeOrStoreId, then, thenDeps) =>
+  useDel(storeOrStoreId, VALUE, then, thenDeps, valueId);
+const useHasTablesListener = (
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    HAS + TABLES,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [],
+    mutator,
+  );
+const useTablesListener = (listener, listenerDeps, mutator, storeOrStoreId) =>
+  useListener(
+    TABLES,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    EMPTY_ARRAY,
+    mutator,
+  );
+const useTableIdsListener = (listener, listenerDeps, mutator, storeOrStoreId) =>
+  useListener(
+    TABLE_IDS,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    EMPTY_ARRAY,
+    mutator,
+  );
+const useHasTableListener = (
+  tableId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    HAS + TABLE,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId],
+    mutator,
+  );
+const useTableListener = (
+  tableId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    TABLE,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId],
+    mutator,
+  );
+const useTableCellIdsListener = (
+  tableId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    TABLE + CELL_IDS,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId],
+    mutator,
+  );
+const useHasTableCellListener = (
+  tableId,
+  cellId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    HAS + TABLE + CELL,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId, cellId],
+    mutator,
+  );
+const useRowCountListener = (
+  tableId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    ROW_COUNT,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId],
+    mutator,
+  );
+const useRowIdsListener = (
+  tableId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    ROW_IDS,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId],
+    mutator,
+  );
+const useSortedRowIdsListener = (
+  tableId,
+  cellId,
+  descending,
+  offset,
+  limit,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    SORTED_ROW_IDS,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId, cellId, descending, offset, limit],
+    mutator,
+  );
+const useHasRowListener = (
+  tableId,
+  rowId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    HAS + ROW,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId, rowId],
+    mutator,
+  );
+const useRowListener = (
+  tableId,
+  rowId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    ROW,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId, rowId],
+    mutator,
+  );
+const useCellIdsListener = (
+  tableId,
+  rowId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    CELL_IDS,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId, rowId],
+    mutator,
+  );
+const useHasCellListener = (
+  tableId,
+  rowId,
+  cellId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    HAS + CELL,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId, rowId, cellId],
+    mutator,
+  );
+const useCellListener = (
+  tableId,
+  rowId,
+  cellId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    CELL,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [tableId, rowId, cellId],
+    mutator,
+  );
+const useHasValuesListener = (
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    HAS + VALUES,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [],
+    mutator,
+  );
+const useValuesListener = (listener, listenerDeps, mutator, storeOrStoreId) =>
+  useListener(
+    VALUES,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    EMPTY_ARRAY,
+    mutator,
+  );
+const useValueIdsListener = (listener, listenerDeps, mutator, storeOrStoreId) =>
+  useListener(
+    VALUE_IDS,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    EMPTY_ARRAY,
+    mutator,
+  );
+const useHasValueListener = (
+  valueId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    HAS + VALUE,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [valueId],
+    mutator,
+  );
+const useValueListener = (
+  valueId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    VALUE,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+    [valueId],
+    mutator,
+  );
+const useStartTransactionListener = (listener, listenerDeps, storeOrStoreId) =>
+  useListener(
+    'Start' + TRANSACTION,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+  );
+const useWillFinishTransactionListener = (
+  listener,
+  listenerDeps,
+  storeOrStoreId,
+) =>
+  useListener(
+    'WillFinish' + TRANSACTION,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+  );
+const useDidFinishTransactionListener = (
+  listener,
+  listenerDeps,
+  storeOrStoreId,
+) =>
+  useListener(
+    'DidFinish' + TRANSACTION,
+    useStoreOrStoreById(storeOrStoreId),
+    listener,
+    listenerDeps,
+  );
+const useCreateMetrics = (store, create, createDeps) =>
+  useCreate(store, create, createDeps);
+const useMetricsIds = () => useThingIds(3);
+const useMetricIds = (metricsOrMetricsId) =>
+  useListenable('MetricIds', useMetricsOrMetricsById(metricsOrMetricsId), 1);
+const useMetric = (metricId, metricsOrMetricsId) =>
+  useListenable('Metric', useMetricsOrMetricsById(metricsOrMetricsId), 3, [
+    metricId,
+  ]);
+const useMetricListener = (
+  metricId,
+  listener,
+  listenerDeps,
+  metricsOrMetricsId,
+) =>
+  useListener(
+    'Metric',
+    useMetricsOrMetricsById(metricsOrMetricsId),
+    listener,
+    listenerDeps,
+    [metricId],
+  );
+const useCreateIndexes = (store, create, createDeps) =>
+  useCreate(store, create, createDeps);
+const useIndexesIds = () => useThingIds(5);
+const useSliceIds = (indexId, indexesOrIndexesId) =>
+  useListenable('SliceIds', useIndexesOrIndexesById(indexesOrIndexesId), 1, [
+    indexId,
+  ]);
+const useIndexIds = (indexesOrIndexesId) =>
+  useListenable('IndexIds', useIndexesOrIndexesById(indexesOrIndexesId), 1);
+const useSliceRowIds = (indexId, sliceId, indexesOrIndexesId) =>
+  useListenable(
+    'Slice' + ROW_IDS,
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    1,
+    [indexId, sliceId],
+  );
+const useSliceIdsListener = (
+  indexId,
+  listener,
+  listenerDeps,
+  indexesOrIndexesId,
+) =>
+  useListener(
+    'SliceIds',
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    listener,
+    listenerDeps,
+    [indexId],
+  );
+const useSliceRowIdsListener = (
+  indexId,
+  sliceId,
+  listener,
+  listenerDeps,
+  indexesOrIndexesId,
+) =>
+  useListener(
+    'Slice' + ROW_IDS,
+    useIndexesOrIndexesById(indexesOrIndexesId),
+    listener,
+    listenerDeps,
+    [indexId, sliceId],
+  );
+const useCreateRelationships = (store, create, createDeps) =>
+  useCreate(store, create, createDeps);
+const useRelationshipsIds = () => useThingIds(7);
+const useRelationshipIds = (relationshipsOrRelationshipsId) =>
+  useListenable(
+    'RelationshipIds',
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    1,
+  );
+const useRemoteRowId = (
+  relationshipId,
+  localRowId,
+  relationshipsOrRelationshipsId,
+) =>
+  useListenable(
+    'RemoteRowId',
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    3,
+    [relationshipId, localRowId],
+  );
+const useLocalRowIds = (
+  relationshipId,
+  remoteRowId,
+  relationshipsOrRelationshipsId,
+) =>
+  useListenable(
+    'Local' + ROW_IDS,
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    1,
+    [relationshipId, remoteRowId],
+  );
+const useLinkedRowIds = (
+  relationshipId,
+  firstRowId,
+  relationshipsOrRelationshipsId,
+) =>
+  useListenable(
+    'Linked' + ROW_IDS,
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    1,
+    [relationshipId, firstRowId],
+  );
+const useRemoteRowIdListener = (
+  relationshipId,
+  localRowId,
+  listener,
+  listenerDeps,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    'RemoteRowId',
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    listener,
+    listenerDeps,
+    [relationshipId, localRowId],
+  );
+const useLocalRowIdsListener = (
+  relationshipId,
+  remoteRowId,
+  listener,
+  listenerDeps,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    'Local' + ROW_IDS,
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    listener,
+    listenerDeps,
+    [relationshipId, remoteRowId],
+  );
+const useLinkedRowIdsListener = (
+  relationshipId,
+  firstRowId,
+  listener,
+  listenerDeps,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    'Linked' + ROW_IDS,
+    useRelationshipsOrRelationshipsById(relationshipsOrRelationshipsId),
+    listener,
+    listenerDeps,
+    [relationshipId, firstRowId],
+  );
+const useCreateQueries = (store, create, createDeps) =>
+  useCreate(store, create, createDeps);
+const useQueriesIds = () => useThingIds(9);
+const useQueryIds = (queriesOrQueriesId) =>
+  useListenable('QueryIds', useQueriesOrQueriesById(queriesOrQueriesId), 1);
+const useResultTable = (queryId, queriesOrQueriesId) =>
+  useListenable(
+    RESULT + TABLE,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    0,
+    [queryId],
+  );
+const useResultTableCellIds = (queryId, queriesOrQueriesId) =>
+  useListenable(
+    RESULT + TABLE + CELL_IDS,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    1,
+    [queryId],
+  );
+const useResultRowCount = (queryId, queriesOrQueriesId) =>
+  useListenable(
+    RESULT + ROW_COUNT,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    5,
+    [queryId],
+  );
+const useResultRowIds = (queryId, queriesOrQueriesId) =>
+  useListenable(
+    RESULT + ROW_IDS,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    1,
+    [queryId],
+  );
+const useResultSortedRowIds = (
+  queryId,
+  cellId,
+  descending,
+  offset = 0,
+  limit,
+  queriesOrQueriesId,
+) =>
+  useListenable(
+    RESULT + SORTED_ROW_IDS,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    1,
+    [queryId, cellId, descending, offset, limit],
+  );
+const useResultRow = (queryId, rowId, queriesOrQueriesId) =>
+  useListenable(RESULT + ROW, useQueriesOrQueriesById(queriesOrQueriesId), 0, [
+    queryId,
+    rowId,
+  ]);
+const useResultCellIds = (queryId, rowId, queriesOrQueriesId) =>
+  useListenable(
+    RESULT + CELL_IDS,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    1,
+    [queryId, rowId],
+  );
+const useResultCell = (queryId, rowId, cellId, queriesOrQueriesId) =>
+  useListenable(RESULT + CELL, useQueriesOrQueriesById(queriesOrQueriesId), 3, [
+    queryId,
+    rowId,
+    cellId,
+  ]);
+const useResultTableListener = (
+  queryId,
+  listener,
+  listenerDeps,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    RESULT + TABLE,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    listener,
+    listenerDeps,
+    [queryId],
+  );
+const useResultTableCellIdsListener = (
+  queryId,
+  listener,
+  listenerDeps,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    RESULT + TABLE + CELL_IDS,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    listener,
+    listenerDeps,
+    [queryId],
+  );
+const useResultRowCountListener = (
+  queryId,
+  listener,
+  listenerDeps,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    RESULT + ROW_COUNT,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    listener,
+    listenerDeps,
+    [queryId],
+  );
+const useResultRowIdsListener = (
+  queryId,
+  listener,
+  listenerDeps,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    RESULT + ROW_IDS,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    listener,
+    listenerDeps,
+    [queryId],
+  );
+const useResultSortedRowIdsListener = (
+  queryId,
+  cellId,
+  descending,
+  offset,
+  limit,
+  listener,
+  listenerDeps,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    RESULT + SORTED_ROW_IDS,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    listener,
+    listenerDeps,
+    [queryId, cellId, descending, offset, limit],
+  );
+const useResultRowListener = (
+  queryId,
+  rowId,
+  listener,
+  listenerDeps,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    RESULT + ROW,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    listener,
+    listenerDeps,
+    [queryId, rowId],
+  );
+const useResultCellIdsListener = (
+  queryId,
+  rowId,
+  listener,
+  listenerDeps,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    RESULT + CELL_IDS,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    listener,
+    listenerDeps,
+    [queryId, rowId],
+  );
+const useResultCellListener = (
+  queryId,
+  rowId,
+  cellId,
+  listener,
+  listenerDeps,
+  queriesOrQueriesId,
+) =>
+  useListener(
+    RESULT + CELL,
+    useQueriesOrQueriesById(queriesOrQueriesId),
+    listener,
+    listenerDeps,
+    [queryId, rowId, cellId],
+  );
+const useCreateCheckpoints = (store, create, createDeps) =>
+  useCreate(store, create, createDeps);
+const useCheckpointsIds = () => useThingIds(11);
+const useCheckpointIds = (checkpointsOrCheckpointsId) =>
+  useListenable(
+    'CheckpointIds',
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
+    2,
+  );
+const useCheckpoint = (checkpointId, checkpointsOrCheckpointsId) =>
+  useListenable(
+    'Checkpoint',
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
+    3,
+    [checkpointId],
+  );
+const useSetCheckpointCallback = (
+  getCheckpoint = getUndefined,
+  getCheckpointDeps = EMPTY_ARRAY,
+  checkpointsOrCheckpointsId,
+  then = getUndefined,
+  thenDeps = EMPTY_ARRAY,
+) => {
+  const checkpoints = useCheckpointsOrCheckpointsById(
+    checkpointsOrCheckpointsId,
+  );
+  return useCallback$2(
+    (parameter) =>
+      ifNotUndefined(checkpoints, (checkpoints2) => {
+        const label = getCheckpoint(parameter);
+        then(checkpoints2.addCheckpoint(label), checkpoints2, label);
+      }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [checkpoints, ...getCheckpointDeps, ...thenDeps],
+  );
+};
+const useGoBackwardCallback = (checkpointsOrCheckpointsId) =>
+  useCheckpointAction(checkpointsOrCheckpointsId, 'goBackward');
+const useGoForwardCallback = (checkpointsOrCheckpointsId) =>
+  useCheckpointAction(checkpointsOrCheckpointsId, 'goForward');
+const useGoToCallback = (
+  getCheckpointId,
+  getCheckpointIdDeps = EMPTY_ARRAY,
+  checkpointsOrCheckpointsId,
+  then = getUndefined,
+  thenDeps = EMPTY_ARRAY,
+) => {
+  const checkpoints = useCheckpointsOrCheckpointsById(
+    checkpointsOrCheckpointsId,
+  );
+  return useCallback$2(
+    (parameter) =>
+      ifNotUndefined(checkpoints, (checkpoints2) =>
+        ifNotUndefined(getCheckpointId(parameter), (checkpointId) =>
+          then(checkpoints2.goTo(checkpointId), checkpointId),
+        ),
+      ),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [checkpoints, ...getCheckpointIdDeps, ...thenDeps],
+  );
+};
+const useUndoInformation = (checkpointsOrCheckpointsId) => {
+  const checkpoints = useCheckpointsOrCheckpointsById(
+    checkpointsOrCheckpointsId,
+  );
+  const [backwardIds, currentId] = useCheckpointIds(checkpoints);
+  return [
+    !arrayIsEmpty(backwardIds),
+    useGoBackwardCallback(checkpoints),
+    currentId,
+    ifNotUndefined(currentId, (id) => checkpoints?.getCheckpoint(id)) ??
+      EMPTY_STRING,
+  ];
+};
+const useRedoInformation = (checkpointsOrCheckpointsId) => {
+  const checkpoints = useCheckpointsOrCheckpointsById(
+    checkpointsOrCheckpointsId,
+  );
+  const [, , [forwardId]] = useCheckpointIds(checkpoints);
+  return [
+    !isUndefined(forwardId),
+    useGoForwardCallback(checkpoints),
+    forwardId,
+    ifNotUndefined(forwardId, (id) => checkpoints?.getCheckpoint(id)) ??
+      EMPTY_STRING,
+  ];
+};
+const useCheckpointIdsListener = (
+  listener,
+  listenerDeps,
+  checkpointsOrCheckpointsId,
+) =>
+  useListener(
+    'CheckpointIds',
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
+    listener,
+    listenerDeps,
+  );
+const useCheckpointListener = (
+  checkpointId,
+  listener,
+  listenerDeps,
+  checkpointsOrCheckpointsId,
+) =>
+  useListener(
+    'Checkpoint',
+    useCheckpointsOrCheckpointsById(checkpointsOrCheckpointsId),
+    listener,
+    listenerDeps,
+    [checkpointId],
+  );
+const useCreatePersister = (
+  store,
+  create,
+  createDeps = EMPTY_ARRAY,
+  then,
+  thenDeps = EMPTY_ARRAY,
+  destroy,
+  destroyDeps = EMPTY_ARRAY,
+) => {
+  const [, rerender] = useState$2();
+  const [persister, setPersister] = useState$2();
+  useEffect(
+    () => {
+      const persister2 = store ? create(store) : void 0;
+      setPersister(persister2);
+      if (persister2 && then) {
+        (async () => {
+          await then(persister2);
+          rerender([]);
+        })();
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [store, ...createDeps, ...thenDeps],
+  );
+  useEffect(
+    () => () => {
+      if (persister) {
+        persister.destroy();
+        destroy?.(persister);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [persister, ...destroyDeps],
+  );
+  return persister;
+};
+const useCreateSynchronizer = (
+  store,
+  create,
+  createDeps = EMPTY_ARRAY,
+  destroy,
+  destroyDeps = EMPTY_ARRAY,
+) => {
+  const [synchronizer, setSynchronizer] = useState$2();
+  useEffect(
+    () => {
+      (async () => {
+        const synchronizer2 = store ? await create(store) : void 0;
+        setSynchronizer(synchronizer2);
+      })();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [store, ...createDeps],
+  );
+  useEffect(
+    () => () => {
+      if (synchronizer) {
+        synchronizer.destroy();
+        destroy?.(synchronizer);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [synchronizer, ...destroyDeps],
+  );
+  return synchronizer;
+};
+
+const {
+  PureComponent,
+  Fragment,
+  createElement,
+  useCallback: useCallback$1,
+  useLayoutEffect,
+  useRef,
+  useState: useState$1,
+} = React;
+const getProps = (getProps2, ...ids) =>
+  isUndefined(getProps2) ? {} : getProps2(...ids);
+const getRelationshipsStoreTableIds = (relationships, relationshipId) => [
+  relationships,
+  relationships?.getStore(),
+  relationships?.getLocalTableId(relationshipId),
+  relationships?.getRemoteTableId(relationshipId),
+];
+const getIndexStoreTableId = (indexes, indexId) => [
+  indexes,
+  indexes?.getStore(),
+  indexes?.getTableId(indexId),
+];
+
+const {useCallback, useContext, useMemo, useState} = React;
+const tableView = (
+  {
+    tableId,
+    store,
+    rowComponent: Row = RowView,
+    getRowComponentProps,
+    customCellIds,
+    separator,
+    debugIds,
+  },
+  rowIds,
+) =>
+  wrap(
+    arrayMap(rowIds, (rowId) =>
+      /* @__PURE__ */ createElement(Row, {
+        ...getProps(getRowComponentProps, rowId),
+        key: rowId,
+        tableId,
+        rowId,
+        customCellIds,
+        store,
+        debugIds,
+      }),
+    ),
+    separator,
+    debugIds,
+    tableId,
+  );
+const resultTableView = (
+  {
+    queryId,
+    queries,
+    resultRowComponent: ResultRow = ResultRowView,
+    getResultRowComponentProps,
+    separator,
+    debugIds,
+  },
+  rowIds,
+) =>
+  wrap(
+    arrayMap(rowIds, (rowId) =>
+      /* @__PURE__ */ createElement(ResultRow, {
+        ...getProps(getResultRowComponentProps, rowId),
+        key: rowId,
+        queryId,
+        rowId,
+        queries,
+        debugIds,
+      }),
+    ),
+    separator,
+    debugIds,
+    queryId,
+  );
+const useComponentPerRow = (
+  {
+    relationshipId,
+    relationships,
+    rowComponent: Row = RowView,
+    getRowComponentProps,
+    separator,
+    debugIds,
+  },
+  getRowIdsHook,
+  rowId,
+) => {
+  const [resolvedRelationships, store, localTableId] =
+    getRelationshipsStoreTableIds(
+      useRelationshipsOrRelationshipsById(relationships),
+      relationshipId,
+    );
+  const rowIds = getRowIdsHook(relationshipId, rowId, resolvedRelationships);
+  return wrap(
+    arrayMap(rowIds, (rowId2) =>
+      /* @__PURE__ */ createElement(Row, {
+        ...getProps(getRowComponentProps, rowId2),
+        key: rowId2,
+        tableId: localTableId,
+        rowId: rowId2,
+        store,
+        debugIds,
+      }),
+    ),
+    separator,
+    debugIds,
+    rowId,
+  );
+};
+const getUseCheckpointView =
+  (getCheckpoints) =>
+  ({
+    checkpoints,
+    checkpointComponent: Checkpoint = CheckpointView,
+    getCheckpointComponentProps,
+    separator,
+    debugIds,
+  }) => {
+    const resolvedCheckpoints = useCheckpointsOrCheckpointsById(checkpoints);
+    return wrap(
+      arrayMap(
+        getCheckpoints(useCheckpointIds(resolvedCheckpoints)),
+        (checkpointId) =>
+          /* @__PURE__ */ createElement(Checkpoint, {
+            ...getProps(getCheckpointComponentProps, checkpointId),
+            key: checkpointId,
+            checkpoints: resolvedCheckpoints,
+            checkpointId,
+            debugIds,
+          }),
+      ),
+      separator,
+    );
+  };
+const Provider = ({
+  store,
+  storesById,
+  metrics,
+  metricsById,
+  indexes,
+  indexesById,
+  relationships,
+  relationshipsById,
+  queries,
+  queriesById,
+  checkpoints,
+  checkpointsById,
+  children,
+}) => {
+  const parentValue = useContext(Context);
+  const [extraStoresById, setExtraStoresById] = useState({});
+  const addExtraStore = useCallback(
+    (id, store2) =>
+      setExtraStoresById((extraStoresById2) =>
+        objGet(extraStoresById2, id) == store2
+          ? extraStoresById2
+          : {...extraStoresById2, [id]: store2},
+      ),
+    [],
+  );
+  const delExtraStore = useCallback(
+    (id) =>
+      setExtraStoresById((extraStoresById2) => ({
+        ...objDel(extraStoresById2, id),
+      })),
+    [],
+  );
+  return /* @__PURE__ */ createElement(
+    Context.Provider,
+    {
+      value: useMemo(
+        () => [
+          store ?? parentValue[0],
+          {...parentValue[1], ...storesById, ...extraStoresById},
+          metrics ?? parentValue[2],
+          {...parentValue[3], ...metricsById},
+          indexes ?? parentValue[4],
+          {...parentValue[5], ...indexesById},
+          relationships ?? parentValue[6],
+          {...parentValue[7], ...relationshipsById},
+          queries ?? parentValue[8],
+          {...parentValue[9], ...queriesById},
+          checkpoints ?? parentValue[10],
+          {...parentValue[11], ...checkpointsById},
+          addExtraStore,
+          delExtraStore,
+        ],
+        [
+          store,
+          storesById,
+          extraStoresById,
+          metrics,
+          metricsById,
+          indexes,
+          indexesById,
+          relationships,
+          relationshipsById,
+          queries,
+          queriesById,
+          checkpoints,
+          checkpointsById,
+          parentValue,
+          addExtraStore,
+          delExtraStore,
+        ],
+      ),
+    },
+    children,
+  );
+};
+const wrap = (children, separator, encloseWithId, id) => {
+  const separated =
+    isUndefined(separator) || !isArray(children)
+      ? children
+      : arrayMap(children, (child, c) => (c > 0 ? [separator, child] : child));
+  return encloseWithId ? [id, ':{', separated, '}'] : separated;
+};
+const useCustomOrDefaultCellIds = (customCellIds, tableId, rowId, store) => {
+  const defaultCellIds = useCellIds(tableId, rowId, store);
+  return customCellIds ?? defaultCellIds;
+};
+const CellView = ({tableId, rowId, cellId, store, debugIds}) =>
+  wrap(
+    EMPTY_STRING + (useCell(tableId, rowId, cellId, store) ?? EMPTY_STRING),
+    void 0,
+    debugIds,
+    cellId,
+  );
+const RowView = ({
+  tableId,
+  rowId,
+  store,
+  cellComponent: Cell = CellView,
+  getCellComponentProps,
+  customCellIds,
+  separator,
+  debugIds,
+}) =>
+  wrap(
+    arrayMap(
+      useCustomOrDefaultCellIds(customCellIds, tableId, rowId, store),
+      (cellId) =>
+        /* @__PURE__ */ createElement(Cell, {
+          ...getProps(getCellComponentProps, cellId),
+          key: cellId,
+          tableId,
+          rowId,
+          cellId,
+          store,
+          debugIds,
+        }),
+    ),
+    separator,
+    debugIds,
+    rowId,
+  );
+const TableView = (props) =>
+  tableView(props, useRowIds(props.tableId, props.store));
+const SortedTableView = ({cellId, descending, offset, limit, ...props}) =>
+  tableView(
+    props,
+    useSortedRowIds(
+      props.tableId,
+      cellId,
+      descending,
+      offset,
+      limit,
+      props.store,
+    ),
+  );
+const TablesView = ({
+  store,
+  tableComponent: Table = TableView,
+  getTableComponentProps,
+  separator,
+  debugIds,
+}) =>
+  wrap(
+    arrayMap(useTableIds(store), (tableId) =>
+      /* @__PURE__ */ createElement(Table, {
+        ...getProps(getTableComponentProps, tableId),
+        key: tableId,
+        tableId,
+        store,
+        debugIds,
+      }),
+    ),
+    separator,
+  );
+const ValueView = ({valueId, store, debugIds}) =>
+  wrap(
+    EMPTY_STRING + (useValue(valueId, store) ?? EMPTY_STRING),
+    void 0,
+    debugIds,
+    valueId,
+  );
+const ValuesView = ({
+  store,
+  valueComponent: Value = ValueView,
+  getValueComponentProps,
+  separator,
+  debugIds,
+}) =>
+  wrap(
+    arrayMap(useValueIds(store), (valueId) =>
+      /* @__PURE__ */ createElement(Value, {
+        ...getProps(getValueComponentProps, valueId),
+        key: valueId,
+        valueId,
+        store,
+        debugIds,
+      }),
+    ),
+    separator,
+  );
+const MetricView = ({metricId, metrics, debugIds}) =>
+  wrap(
+    useMetric(metricId, metrics) ?? EMPTY_STRING,
+    void 0,
+    debugIds,
+    metricId,
+  );
+const SliceView = ({
+  indexId,
+  sliceId,
+  indexes,
+  rowComponent: Row = RowView,
+  getRowComponentProps,
+  separator,
+  debugIds,
+}) => {
+  const [resolvedIndexes, store, tableId] = getIndexStoreTableId(
+    useIndexesOrIndexesById(indexes),
+    indexId,
+  );
+  const rowIds = useSliceRowIds(indexId, sliceId, resolvedIndexes);
+  return wrap(
+    arrayMap(rowIds, (rowId) =>
+      /* @__PURE__ */ createElement(Row, {
+        ...getProps(getRowComponentProps, rowId),
+        key: rowId,
+        tableId,
+        rowId,
+        store,
+        debugIds,
+      }),
+    ),
+    separator,
+    debugIds,
+    sliceId,
+  );
+};
+const IndexView = ({
+  indexId,
+  indexes,
+  sliceComponent: Slice = SliceView,
+  getSliceComponentProps,
+  separator,
+  debugIds,
+}) =>
+  wrap(
+    arrayMap(useSliceIds(indexId, indexes), (sliceId) =>
+      /* @__PURE__ */ createElement(Slice, {
+        ...getProps(getSliceComponentProps, sliceId),
+        key: sliceId,
+        indexId,
+        sliceId,
+        indexes,
+        debugIds,
+      }),
+    ),
+    separator,
+    debugIds,
+    indexId,
+  );
+const RemoteRowView = ({
+  relationshipId,
+  localRowId,
+  relationships,
+  rowComponent: Row = RowView,
+  getRowComponentProps,
+  debugIds,
+}) => {
+  const [resolvedRelationships, store, , remoteTableId] =
+    getRelationshipsStoreTableIds(
+      useRelationshipsOrRelationshipsById(relationships),
+      relationshipId,
+    );
+  const rowId = useRemoteRowId(
+    relationshipId,
+    localRowId,
+    resolvedRelationships,
+  );
+  return wrap(
+    isUndefined(remoteTableId) || isUndefined(rowId)
+      ? null
+      : /* @__PURE__ */ createElement(Row, {
+          ...getProps(getRowComponentProps, rowId),
+          key: rowId,
+          tableId: remoteTableId,
+          rowId,
+          store,
+          debugIds,
+        }),
+    void 0,
+    debugIds,
+    localRowId,
+  );
+};
+const LocalRowsView = (props) =>
+  useComponentPerRow(props, useLocalRowIds, props.remoteRowId);
+const LinkedRowsView = (props) =>
+  useComponentPerRow(props, useLinkedRowIds, props.firstRowId);
+const ResultCellView = ({queryId, rowId, cellId, queries, debugIds}) =>
+  wrap(
+    EMPTY_STRING +
+      (useResultCell(queryId, rowId, cellId, queries) ?? EMPTY_STRING),
+    void 0,
+    debugIds,
+    cellId,
+  );
+const ResultRowView = ({
+  queryId,
+  rowId,
+  queries,
+  resultCellComponent: ResultCell = ResultCellView,
+  getResultCellComponentProps,
+  separator,
+  debugIds,
+}) =>
+  wrap(
+    arrayMap(useResultCellIds(queryId, rowId, queries), (cellId) =>
+      /* @__PURE__ */ createElement(ResultCell, {
+        ...getProps(getResultCellComponentProps, cellId),
+        key: cellId,
+        queryId,
+        rowId,
+        cellId,
+        queries,
+        debugIds,
+      }),
+    ),
+    separator,
+    debugIds,
+    rowId,
+  );
+const ResultTableView = (props) =>
+  resultTableView(props, useResultRowIds(props.queryId, props.queries));
+const ResultSortedTableView = ({cellId, descending, offset, limit, ...props}) =>
+  resultTableView(
+    props,
+    useResultSortedRowIds(
+      props.queryId,
+      cellId,
+      descending,
+      offset,
+      limit,
+      props.queries,
+    ),
+  );
+const CheckpointView = ({checkpoints, checkpointId, debugIds}) =>
+  wrap(
+    useCheckpoint(checkpointId, checkpoints) ?? EMPTY_STRING,
+    void 0,
+    debugIds,
+    checkpointId,
+  );
+const BackwardCheckpointsView = getUseCheckpointView(
+  (checkpointIds) => checkpointIds[0],
+);
+const CurrentCheckpointView = getUseCheckpointView((checkpointIds) =>
+  isUndefined(checkpointIds[1]) ? [] : [checkpointIds[1]],
+);
+const ForwardCheckpointsView = getUseCheckpointView(
+  (checkpointIds) => checkpointIds[2],
+);
+
+export {
+  BackwardCheckpointsView,
+  CellView,
+  CheckpointView,
+  CurrentCheckpointView,
+  ForwardCheckpointsView,
+  IndexView,
+  LinkedRowsView,
+  LocalRowsView,
+  MetricView,
+  Provider,
+  RemoteRowView,
+  ResultCellView,
+  ResultRowView,
+  ResultSortedTableView,
+  ResultTableView,
+  RowView,
+  SliceView,
+  SortedTableView,
+  TableView,
+  TablesView,
+  ValueView,
+  ValuesView,
+  useAddRowCallback,
+  useCell,
+  useCellIds,
+  useCellIdsListener,
+  useCellListener,
+  useCheckpoint,
+  useCheckpointIds,
+  useCheckpointIdsListener,
+  useCheckpointListener,
+  useCheckpoints,
+  useCheckpointsIds,
+  useCheckpointsOrCheckpointsById,
+  useCreateCheckpoints,
+  useCreateIndexes,
+  useCreateMergeableStore,
+  useCreateMetrics,
+  useCreatePersister,
+  useCreateQueries,
+  useCreateRelationships,
+  useCreateStore,
+  useCreateSynchronizer,
+  useDelCellCallback,
+  useDelRowCallback,
+  useDelTableCallback,
+  useDelTablesCallback,
+  useDelValueCallback,
+  useDelValuesCallback,
+  useDidFinishTransactionListener,
+  useGoBackwardCallback,
+  useGoForwardCallback,
+  useGoToCallback,
+  useHasCell,
+  useHasCellListener,
+  useHasRow,
+  useHasRowListener,
+  useHasTable,
+  useHasTableCell,
+  useHasTableCellListener,
+  useHasTableListener,
+  useHasTables,
+  useHasTablesListener,
+  useHasValue,
+  useHasValueListener,
+  useHasValues,
+  useHasValuesListener,
+  useIndexIds,
+  useIndexes,
+  useIndexesIds,
+  useIndexesOrIndexesById,
+  useLinkedRowIds,
+  useLinkedRowIdsListener,
+  useLocalRowIds,
+  useLocalRowIdsListener,
+  useMetric,
+  useMetricIds,
+  useMetricListener,
+  useMetrics,
+  useMetricsIds,
+  useMetricsOrMetricsById,
+  useProvideStore,
+  useQueries,
+  useQueriesIds,
+  useQueriesOrQueriesById,
+  useQueryIds,
+  useRedoInformation,
+  useRelationshipIds,
+  useRelationships,
+  useRelationshipsIds,
+  useRelationshipsOrRelationshipsById,
+  useRemoteRowId,
+  useRemoteRowIdListener,
+  useResultCell,
+  useResultCellIds,
+  useResultCellIdsListener,
+  useResultCellListener,
+  useResultRow,
+  useResultRowCount,
+  useResultRowCountListener,
+  useResultRowIds,
+  useResultRowIdsListener,
+  useResultRowListener,
+  useResultSortedRowIds,
+  useResultSortedRowIdsListener,
+  useResultTable,
+  useResultTableCellIds,
+  useResultTableCellIdsListener,
+  useResultTableListener,
+  useRow,
+  useRowCount,
+  useRowCountListener,
+  useRowIds,
+  useRowIdsListener,
+  useRowListener,
+  useSetCellCallback,
+  useSetCheckpointCallback,
+  useSetPartialRowCallback,
+  useSetPartialValuesCallback,
+  useSetRowCallback,
+  useSetTableCallback,
+  useSetTablesCallback,
+  useSetValueCallback,
+  useSetValuesCallback,
+  useSliceIds,
+  useSliceIdsListener,
+  useSliceRowIds,
+  useSliceRowIdsListener,
+  useSortedRowIds,
+  useSortedRowIdsListener,
+  useStartTransactionListener,
+  useStore,
+  useStoreIds,
+  useStoreOrStoreById,
+  useTable,
+  useTableCellIds,
+  useTableCellIdsListener,
+  useTableIds,
+  useTableIdsListener,
+  useTableListener,
+  useTables,
+  useTablesListener,
+  useUndoInformation,
+  useValue,
+  useValueIds,
+  useValueIdsListener,
+  useValueListener,
+  useValues,
+  useValuesListener,
+  useWillFinishTransactionListener,
+};