tinybase 0.0.0 → 0.9.0

package/lib/debug/react.js

@@ -0,0 +1,1037 @@
+import React from 'react';
+
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+
+const arrayMap = (array, cb) => array.map(cb);
+const arrayLength = (array) => array.length;
+const arrayIsEmpty = (array) => arrayLength(array) == 0;
+
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isString = (thing) => getTypeOf(thing) == STRING;
+const getUndefined = () => void 0;
+
+const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+
+const {createContext, useContext} = React;
+const Context = createContext([]);
+const useThing = (id, offset) => {
+  const thingsAndThingsById = useContext(Context);
+  return isUndefined(id)
+    ? thingsAndThingsById[offset]
+    : objGet(thingsAndThingsById[offset + 1], id);
+};
+const useThingOrThingId = (thingOrThingId, offset) => {
+  const thing = useThing(thingOrThingId, offset);
+  if (isUndefined(thingOrThingId) || isString(thingOrThingId)) {
+    return thing;
+  }
+  return thingOrThingId;
+};
+const useStore = (id) => useThing(id, 0);
+const useMetrics = (id) => useThing(id, 2);
+const useIndexes = (id) => useThing(id, 4);
+const useRelationships = (id) => useThing(id, 6);
+const useCheckpoints = (id) => useThing(id, 8);
+const useStoreOrStoreId = (storeOrStoreId) =>
+  useThingOrThingId(storeOrStoreId, 0);
+const useMetricsOrMetricsId = (metricsOrMetricsId) =>
+  useThingOrThingId(metricsOrMetricsId, 2);
+const useIndexesOrIndexesId = (indexesOrIndexesId) =>
+  useThingOrThingId(indexesOrIndexesId, 4);
+const useRelationshipsOrRelationshipsId = (relationshipsOrRelationshipsId) =>
+  useThingOrThingId(relationshipsOrRelationshipsId, 6);
+const useCheckpointsOrCheckpointsId = (checkpointsOrCheckpointsId) =>
+  useThingOrThingId(checkpointsOrCheckpointsId, 8);
+
+const {useCallback, useEffect, useMemo: useMemo$1, useState} = React;
+const useCreate = (store, create, createDeps = []) =>
+  useMemo$1(() => create(store), [store, ...createDeps]);
+const useListenable = (listenable, thing, defaulted, ...args) => {
+  const getListenable = thing?.['get' + listenable] ?? (() => defaulted);
+  const immediateListenable = getListenable(...args);
+  const [, setListenable] = useState(immediateListenable);
+  useEffect(() => {
+    const listenerId = thing?.[`add${listenable}Listener`]?.(
+      ...args,
+      () => setListenable(getListenable(...args)),
+      false,
+    );
+    return () => thing?.delListener(listenerId);
+  }, [thing, listenable, setListenable, getListenable, ...args]);
+  return immediateListenable;
+};
+const useListener = (
+  listenable,
+  thing,
+  listener,
+  listenerDeps = [],
+  mutator,
+  ...args
+) => {
+  useEffect(() => {
+    const listenerId = thing?.[`add${listenable}Listener`]?.(
+      ...args,
+      listener,
+      mutator,
+    );
+    return () => thing?.delListener(listenerId);
+  }, [thing, listenable, ...listenerDeps, mutator, ...args]);
+};
+const useSetCallback = (
+  storeOrStoreId,
+  settable,
+  get,
+  getDeps = [],
+  then = getUndefined,
+  thenDeps = [],
+  ...args
+) => {
+  const store = useStoreOrStoreId(storeOrStoreId);
+  return useCallback(
+    (parameter) =>
+      ifNotUndefined(store, (store2) =>
+        ifNotUndefined(get(parameter, store2), (value) =>
+          then(store2['set' + settable](...args, value), value),
+        ),
+      ),
+    [store, settable, ...getDeps, ...thenDeps, ...args],
+  );
+};
+const useDel = (
+  storeOrStoreId,
+  deletable,
+  then = getUndefined,
+  thenDeps = [],
+  ...args
+) => {
+  const store = useStoreOrStoreId(storeOrStoreId);
+  return useCallback(
+    () => then(store?.['del' + deletable](...args)),
+    [store, deletable, ...thenDeps, ...args],
+  );
+};
+const useCheckpointAction = (checkpointsOrCheckpointsId, action, arg) => {
+  const checkpoints = useCheckpointsOrCheckpointsId(checkpointsOrCheckpointsId);
+  return useCallback(
+    () => checkpoints?.[action](arg),
+    [checkpoints, action, arg],
+  );
+};
+const useCreateStore = (create, createDeps = []) =>
+  useMemo$1(create, createDeps);
+const useTables = (storeOrStoreId) =>
+  useListenable('Tables', useStoreOrStoreId(storeOrStoreId), {});
+const useTableIds = (storeOrStoreId) =>
+  useListenable('TableIds', useStoreOrStoreId(storeOrStoreId), []);
+const useTable = (tableId, storeOrStoreId) =>
+  useListenable('Table', useStoreOrStoreId(storeOrStoreId), {}, tableId);
+const useRowIds = (tableId, storeOrStoreId) =>
+  useListenable('RowIds', useStoreOrStoreId(storeOrStoreId), [], tableId);
+const useRow = (tableId, rowId, storeOrStoreId) =>
+  useListenable('Row', useStoreOrStoreId(storeOrStoreId), {}, tableId, rowId);
+const useCellIds = (tableId, rowId, storeOrStoreId) =>
+  useListenable(
+    'CellIds',
+    useStoreOrStoreId(storeOrStoreId),
+    [],
+    tableId,
+    rowId,
+  );
+const useCell = (tableId, rowId, cellId, storeOrStoreId) =>
+  useListenable(
+    'Cell',
+    useStoreOrStoreId(storeOrStoreId),
+    void 0,
+    tableId,
+    rowId,
+    cellId,
+  );
+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 = [],
+  storeOrStoreId,
+  then = getUndefined,
+  thenDeps = [],
+) => {
+  const store = useStoreOrStoreId(storeOrStoreId);
+  return useCallback(
+    (parameter) =>
+      ifNotUndefined(store, (store2) =>
+        ifNotUndefined(getRow(parameter, store2), (row) =>
+          then(store2.addRow(tableId, row), store2, row),
+        ),
+      ),
+    [store, tableId, ...getRowDeps, ...thenDeps],
+  );
+};
+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 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 useTablesListener = (listener, listenerDeps, mutator, storeOrStoreId) =>
+  useListener(
+    'Tables',
+    useStoreOrStoreId(storeOrStoreId),
+    listener,
+    listenerDeps,
+    mutator,
+  );
+const useTableIdsListener = (listener, listenerDeps, mutator, storeOrStoreId) =>
+  useListener(
+    'TableIds',
+    useStoreOrStoreId(storeOrStoreId),
+    listener,
+    listenerDeps,
+    mutator,
+  );
+const useTableListener = (
+  tableId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    'Table',
+    useStoreOrStoreId(storeOrStoreId),
+    listener,
+    listenerDeps,
+    mutator,
+    tableId,
+  );
+const useRowIdsListener = (
+  tableId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    'RowIds',
+    useStoreOrStoreId(storeOrStoreId),
+    listener,
+    listenerDeps,
+    mutator,
+    tableId,
+  );
+const useRowListener = (
+  tableId,
+  rowId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    'Row',
+    useStoreOrStoreId(storeOrStoreId),
+    listener,
+    listenerDeps,
+    mutator,
+    tableId,
+    rowId,
+  );
+const useCellIdsListener = (
+  tableId,
+  rowId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    'CellIds',
+    useStoreOrStoreId(storeOrStoreId),
+    listener,
+    listenerDeps,
+    mutator,
+    tableId,
+    rowId,
+  );
+const useCellListener = (
+  tableId,
+  rowId,
+  cellId,
+  listener,
+  listenerDeps,
+  mutator,
+  storeOrStoreId,
+) =>
+  useListener(
+    'Cell',
+    useStoreOrStoreId(storeOrStoreId),
+    listener,
+    listenerDeps,
+    mutator,
+    tableId,
+    rowId,
+    cellId,
+  );
+const useCreateMetrics = (store, create, createDeps) =>
+  useCreate(store, create, createDeps);
+const useMetric = (metricId, metricsOrMetricsId) =>
+  useListenable(
+    'Metric',
+    useMetricsOrMetricsId(metricsOrMetricsId),
+    void 0,
+    metricId,
+  );
+const useMetricListener = (
+  metricId,
+  listener,
+  listenerDeps,
+  metricsOrMetricsId,
+) =>
+  useListener(
+    'Metric',
+    useMetricsOrMetricsId(metricsOrMetricsId),
+    listener,
+    listenerDeps,
+    void 0,
+    metricId,
+  );
+const useCreateIndexes = (store, create, createDeps) =>
+  useCreate(store, create, createDeps);
+const useSliceIds = (indexId, indexesOrIndexesId) =>
+  useListenable(
+    'SliceIds',
+    useIndexesOrIndexesId(indexesOrIndexesId),
+    [],
+    indexId,
+  );
+const useSliceRowIds = (indexId, sliceId, indexesOrIndexesId) =>
+  useListenable(
+    'SliceRowIds',
+    useIndexesOrIndexesId(indexesOrIndexesId),
+    [],
+    indexId,
+    sliceId,
+  );
+const useSliceIdsListener = (
+  indexId,
+  listener,
+  listenerDeps,
+  indexesOrIndexesId,
+) =>
+  useListener(
+    'SliceIds',
+    useIndexesOrIndexesId(indexesOrIndexesId),
+    listener,
+    listenerDeps,
+    void 0,
+    indexId,
+  );
+const useSliceRowIdsListener = (
+  indexId,
+  sliceId,
+  listener,
+  listenerDeps,
+  indexesOrIndexesId,
+) =>
+  useListener(
+    'SliceRowIds',
+    useIndexesOrIndexesId(indexesOrIndexesId),
+    listener,
+    listenerDeps,
+    void 0,
+    indexId,
+    sliceId,
+  );
+const useCreateRelationships = (store, create, createDeps) =>
+  useCreate(store, create, createDeps);
+const useRemoteRowId = (
+  relationshipId,
+  localRowId,
+  relationshipsOrRelationshipsId,
+) =>
+  useListenable(
+    'RemoteRowId',
+    useRelationshipsOrRelationshipsId(relationshipsOrRelationshipsId),
+    void 0,
+    relationshipId,
+    localRowId,
+  );
+const useLocalRowIds = (
+  relationshipId,
+  remoteRowId,
+  relationshipsOrRelationshipsId,
+) =>
+  useListenable(
+    'LocalRowIds',
+    useRelationshipsOrRelationshipsId(relationshipsOrRelationshipsId),
+    [],
+    relationshipId,
+    remoteRowId,
+  );
+const useLinkedRowIds = (
+  relationshipId,
+  firstRowId,
+  relationshipsOrRelationshipsId,
+) =>
+  useListenable(
+    'LinkedRowIds',
+    useRelationshipsOrRelationshipsId(relationshipsOrRelationshipsId),
+    [],
+    relationshipId,
+    firstRowId,
+  );
+const useRemoteRowIdListener = (
+  relationshipId,
+  localRowId,
+  listener,
+  listenerDeps,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    'RemoteRowId',
+    useRelationshipsOrRelationshipsId(relationshipsOrRelationshipsId),
+    listener,
+    listenerDeps,
+    void 0,
+    relationshipId,
+    localRowId,
+  );
+const useLocalRowIdsListener = (
+  relationshipId,
+  remoteRowId,
+  listener,
+  listenerDeps,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    'LocalRowIds',
+    useRelationshipsOrRelationshipsId(relationshipsOrRelationshipsId),
+    listener,
+    listenerDeps,
+    void 0,
+    relationshipId,
+    remoteRowId,
+  );
+const useLinkedRowIdsListener = (
+  relationshipId,
+  firstRowId,
+  listener,
+  listenerDeps,
+  relationshipsOrRelationshipsId,
+) =>
+  useListener(
+    'LinkedRowIds',
+    useRelationshipsOrRelationshipsId(relationshipsOrRelationshipsId),
+    listener,
+    listenerDeps,
+    void 0,
+    relationshipId,
+    firstRowId,
+  );
+const useCreateCheckpoints = (store, create, createDeps) =>
+  useCreate(store, create, createDeps);
+const useCheckpointIds = (checkpointsOrCheckpointsId) =>
+  useListenable(
+    'CheckpointIds',
+    useCheckpointsOrCheckpointsId(checkpointsOrCheckpointsId),
+    [[], void 0, []],
+  );
+const useCheckpoint = (checkpointId, checkpointsOrCheckpointsId) =>
+  useListenable(
+    'Checkpoint',
+    useCheckpointsOrCheckpointsId(checkpointsOrCheckpointsId),
+    void 0,
+    checkpointId,
+  );
+const useSetCheckpointCallback = (
+  getCheckpoint = getUndefined,
+  getCheckpointDeps = [],
+  checkpointsOrCheckpointsId,
+  then = getUndefined,
+  thenDeps = [],
+) => {
+  const checkpoints = useCheckpointsOrCheckpointsId(checkpointsOrCheckpointsId);
+  return useCallback(
+    (parameter) =>
+      ifNotUndefined(checkpoints, (checkpoints2) => {
+        const label = getCheckpoint(parameter);
+        then(checkpoints2.addCheckpoint(label), checkpoints2, label);
+      }),
+    [checkpoints, ...getCheckpointDeps, ...thenDeps],
+  );
+};
+const useGoBackwardCallback = (checkpointsOrCheckpointsId) =>
+  useCheckpointAction(checkpointsOrCheckpointsId, 'goBackward');
+const useGoForwardCallback = (checkpointsOrCheckpointsId) =>
+  useCheckpointAction(checkpointsOrCheckpointsId, 'goForward');
+const useGoToCallback = (
+  getCheckpointId,
+  getCheckpointIdDeps = [],
+  checkpointsOrCheckpointsId,
+  then = getUndefined,
+  thenDeps = [],
+) => {
+  const checkpoints = useCheckpointsOrCheckpointsId(checkpointsOrCheckpointsId);
+  return useCallback(
+    (parameter) =>
+      ifNotUndefined(checkpoints, (checkpoints2) =>
+        ifNotUndefined(getCheckpointId(parameter), (checkpointId) =>
+          then(checkpoints2.goTo(checkpointId), checkpointId),
+        ),
+      ),
+    [checkpoints, ...getCheckpointIdDeps, ...thenDeps],
+  );
+};
+const useUndoInformation = (checkpointsOrCheckpointsId) => {
+  const checkpoints = useCheckpointsOrCheckpointsId(checkpointsOrCheckpointsId);
+  const [backwardIds, currentId] = useCheckpointIds(checkpoints);
+  return [
+    !arrayIsEmpty(backwardIds),
+    useGoBackwardCallback(checkpoints),
+    currentId,
+    ifNotUndefined(currentId, (id) => checkpoints?.getCheckpoint(id)) ?? '',
+  ];
+};
+const useRedoInformation = (checkpointsOrCheckpointsId) => {
+  const checkpoints = useCheckpointsOrCheckpointsId(checkpointsOrCheckpointsId);
+  const [, , [forwardId]] = useCheckpointIds(checkpoints);
+  return [
+    !isUndefined(forwardId),
+    useGoForwardCallback(checkpoints),
+    forwardId,
+    ifNotUndefined(forwardId, (id) => checkpoints?.getCheckpoint(id)) ?? '',
+  ];
+};
+const useCheckpointIdsListener = (
+  listener,
+  listenerDeps,
+  checkpointsOrCheckpointsId,
+) =>
+  useListener(
+    'CheckpointIds',
+    useCheckpointsOrCheckpointsId(checkpointsOrCheckpointsId),
+    listener,
+    listenerDeps,
+  );
+const useCheckpointListener = (
+  checkpointId,
+  listener,
+  listenerDeps,
+  checkpointsOrCheckpointsId,
+) =>
+  useListener(
+    'Checkpoint',
+    useCheckpointsOrCheckpointsId(checkpointsOrCheckpointsId),
+    listener,
+    listenerDeps,
+    void 0,
+    checkpointId,
+  );
+const useCreatePersister = (
+  store,
+  create,
+  createDeps = [],
+  then,
+  thenDeps = [],
+) => {
+  const [, setDone] = useState();
+  const persister = useMemo$1(() => create(store), [store, ...createDeps]);
+  useEffect(() => {
+    (async () => {
+      await then?.(persister);
+      setDone(1);
+      return;
+    })();
+  }, [persister, ...thenDeps]);
+  return persister;
+};
+
+const {createElement, useMemo} = React;
+const useRelationshipsStoreTableId = (relationships) => {
+  const resolvedRelationships =
+    useRelationshipsOrRelationshipsId(relationships);
+  return [resolvedRelationships, resolvedRelationships?.getStore()];
+};
+const useComponentPerRow = (
+  {
+    relationshipId,
+    relationships,
+    rowComponent: Row = RowView,
+    getRowComponentProps,
+    separator,
+    debugIds,
+  },
+  getRowIdsHook,
+  rowId,
+) => {
+  const [resolvedRelationships, store] =
+    useRelationshipsStoreTableId(relationships);
+  const tableId = resolvedRelationships?.getLocalTableId(relationshipId);
+  const rowIds = getRowIdsHook(relationshipId, rowId, resolvedRelationships);
+  return wrap(
+    arrayMap(rowIds, (rowId2) =>
+      /* @__PURE__ */ createElement(Row, {
+        ...getProps(getRowComponentProps, rowId2),
+        key: rowId2,
+        tableId,
+        rowId: rowId2,
+        store,
+        debugIds,
+      }),
+    ),
+    separator,
+    debugIds,
+    rowId,
+  );
+};
+const getUseCheckpointView =
+  (getCheckpoints) =>
+  ({
+    checkpoints,
+    checkpointComponent: Checkpoint = CheckpointView,
+    getCheckpointComponentProps,
+    separator,
+    debugIds,
+  }) => {
+    const resolvedCheckpoints = useCheckpointsOrCheckpointsId(checkpoints);
+    return wrap(
+      arrayMap(
+        getCheckpoints(useCheckpointIds(resolvedCheckpoints)),
+        (checkpointId) =>
+          /* @__PURE__ */ createElement(Checkpoint, {
+            ...getProps(getCheckpointComponentProps, checkpointId),
+            key: checkpointId,
+            checkpoints: resolvedCheckpoints,
+            checkpointId,
+            debugIds,
+          }),
+      ),
+      separator,
+    );
+  };
+const getProps = (getProps2, id) =>
+  isUndefined(getProps2) ? {} : getProps2(id);
+const Provider = ({
+  store,
+  storesById,
+  metrics,
+  metricsById,
+  indexes,
+  indexesById,
+  relationships,
+  relationshipsById,
+  checkpoints,
+  checkpointsById,
+  children,
+}) =>
+  /* @__PURE__ */ createElement(
+    Context.Provider,
+    {
+      value: useMemo(
+        () => [
+          store,
+          storesById,
+          metrics,
+          metricsById,
+          indexes,
+          indexesById,
+          relationships,
+          relationshipsById,
+          checkpoints,
+          checkpointsById,
+        ],
+        [
+          store,
+          storesById,
+          metrics,
+          metricsById,
+          indexes,
+          indexesById,
+          relationships,
+          relationshipsById,
+          checkpoints,
+          checkpointsById,
+        ],
+      ),
+    },
+    children,
+  );
+const wrap = (children, separator, encloseWithId, id) => {
+  const separatedChildren =
+    isUndefined(separator) || !Array.isArray(children)
+      ? children
+      : arrayMap(children, (child, c) => (c > 0 ? [separator, child] : child));
+  return encloseWithId ? [id, ':{', separatedChildren, '}'] : separatedChildren;
+};
+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,
+  separator,
+  debugIds,
+}) =>
+  wrap(
+    arrayMap(useCellIds(tableId, rowId, store), (cellId) =>
+      /* @__PURE__ */ createElement(Cell, {
+        ...getProps(getCellComponentProps, cellId),
+        key: cellId,
+        tableId,
+        rowId,
+        cellId,
+        store,
+        debugIds,
+      }),
+    ),
+    separator,
+    debugIds,
+    rowId,
+  );
+const TableView = ({
+  tableId,
+  store,
+  rowComponent: Row = RowView,
+  getRowComponentProps,
+  separator,
+  debugIds,
+}) =>
+  wrap(
+    arrayMap(useRowIds(tableId, store), (rowId) =>
+      /* @__PURE__ */ createElement(Row, {
+        ...getProps(getRowComponentProps, rowId),
+        key: rowId,
+        tableId,
+        rowId,
+        store,
+        debugIds,
+      }),
+    ),
+    separator,
+    debugIds,
+    tableId,
+  );
+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 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 = useIndexesOrIndexesId(indexes);
+  const store = resolvedIndexes?.getStore();
+  const tableId = resolvedIndexes?.getTableId(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] =
+    useRelationshipsStoreTableId(relationships);
+  const tableId = resolvedRelationships?.getRemoteTableId(relationshipId);
+  const rowId = useRemoteRowId(
+    relationshipId,
+    localRowId,
+    resolvedRelationships,
+  );
+  return wrap(
+    isUndefined(tableId) || isUndefined(rowId)
+      ? null
+      : /* @__PURE__ */ createElement(Row, {
+          ...getProps(getRowComponentProps, rowId),
+          key: rowId,
+          tableId,
+          rowId,
+          store,
+          debugIds,
+        }),
+    void 0,
+    debugIds,
+    localRowId,
+  );
+};
+const LocalRowsView = (props) =>
+  useComponentPerRow(props, useLocalRowIds, props.remoteRowId);
+const LinkedRowsView = (props) =>
+  useComponentPerRow(props, useLinkedRowIds, props.firstRowId);
+const CheckpointView = ({checkpoints, checkpointId, debugIds}) =>
+  wrap(
+    useCheckpoint(checkpointId, checkpoints) ?? '',
+    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,
+  RowView,
+  SliceView,
+  TableView,
+  TablesView,
+  useAddRowCallback,
+  useCell,
+  useCellIds,
+  useCellIdsListener,
+  useCellListener,
+  useCheckpoint,
+  useCheckpointIds,
+  useCheckpointIdsListener,
+  useCheckpointListener,
+  useCheckpoints,
+  useCreateCheckpoints,
+  useCreateIndexes,
+  useCreateMetrics,
+  useCreatePersister,
+  useCreateRelationships,
+  useCreateStore,
+  useDelCellCallback,
+  useDelRowCallback,
+  useDelTableCallback,
+  useDelTablesCallback,
+  useGoBackwardCallback,
+  useGoForwardCallback,
+  useGoToCallback,
+  useIndexes,
+  useLinkedRowIds,
+  useLinkedRowIdsListener,
+  useLocalRowIds,
+  useLocalRowIdsListener,
+  useMetric,
+  useMetricListener,
+  useMetrics,
+  useRedoInformation,
+  useRelationships,
+  useRemoteRowId,
+  useRemoteRowIdListener,
+  useRow,
+  useRowIds,
+  useRowIdsListener,
+  useRowListener,
+  useSetCellCallback,
+  useSetCheckpointCallback,
+  useSetPartialRowCallback,
+  useSetRowCallback,
+  useSetTableCallback,
+  useSetTablesCallback,
+  useSliceIds,
+  useSliceIdsListener,
+  useSliceRowIds,
+  useSliceRowIdsListener,
+  useStore,
+  useTable,
+  useTableIds,
+  useTableIdsListener,
+  useTableListener,
+  useTables,
+  useTablesListener,
+  useUndoInformation,
+};