tinybase 0.9.1 → 1.0.0

package/lib/debug/tinybase.js

@@ -1,5 +1,4 @@
 import {promises, watch} from 'fs';
-import React from 'react';
 
 const getTypeOf = (thing) => typeof thing;
 const EMPTY_OBJECT = '{}';
@@ -23,7 +22,6 @@ const arrayIsSorted = (array, sorter) =>
   );
 const arraySort = (array, sorter) => array.sort(sorter);
 const arrayForEach = (array, cb) => array.forEach(cb);
-const arrayMap = (array, cb) => array.map(cb);
 const arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);
 const arrayLength = (array) => array.length;
 const arrayIsEmpty = (array) => arrayLength(array) == 0;
@@ -251,7 +249,7 @@ const getListenerFunctions = (getThing) => {
   const listenerPool = [];
   const allListeners = mapNew();
   const addListener = (listener, deepSet, idOrNulls = []) => {
-    thing ?? (thing = getThing());
+    thing ??= getThing();
     const id = listenerPool.pop() ?? '' + nextId++;
     mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
     addDeepSet(deepSet, id, idOrNulls);
@@ -511,6 +509,8 @@ const createCheckpoints = getCreateFunction((store) => {
   return objFreeze(checkpoints.clear());
 });
 
+const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
+
 const createIndexes = getCreateFunction((store) => {
   const sliceIdsListeners = mapNew();
   const sliceRowIdsListeners = mapNew();
@@ -543,7 +543,7 @@ const createIndexes = getCreateFunction((store) => {
     setDefinition(
       indexId,
       tableId,
-      (change, changedSliceIds, changedSortKeys, sliceIds, sortKeys) => {
+      (change, changedSliceIds, changedSortKeys, sliceIds, sortKeys, force) => {
         let sliceIdsChanged = 0;
         const changedSlices = setNew();
         const unsortedSlices = setNew();
@@ -572,12 +572,16 @@ const createIndexes = getCreateFunction((store) => {
           }
         });
         change();
-        mapForEach(changedSortKeys, (rowId) =>
-          ifNotUndefined(mapGet(sliceIds, rowId), (sliceId) =>
-            setAdd(unsortedSlices, sliceId),
-          ),
-        );
         if (!collIsEmpty(sortKeys)) {
+          if (force) {
+            mapForEach(index, (sliceId) => setAdd(unsortedSlices, sliceId));
+          } else {
+            mapForEach(changedSortKeys, (rowId) =>
+              ifNotUndefined(mapGet(sliceIds, rowId), (sliceId) =>
+                setAdd(unsortedSlices, sliceId),
+              ),
+            );
+          }
           collForEach(unsortedSlices, (sliceId) => {
             const rowIdArraySorter = (rowId1, rowId2) =>
               rowIdSorter(
@@ -596,7 +600,7 @@ const createIndexes = getCreateFunction((store) => {
             }
           });
         }
-        if (sliceIdsChanged) {
+        if (sliceIdsChanged || force) {
           if (!isUndefined(sliceIdArraySorter)) {
             const indexArray = [...index];
             if (!arrayIsSorted(indexArray, sliceIdArraySorter)) {
@@ -604,8 +608,11 @@ const createIndexes = getCreateFunction((store) => {
                 indexId,
                 mapNew(arraySort(indexArray, sliceIdArraySorter)),
               );
+              sliceIdsChanged = 1;
             }
           }
+        }
+        if (sliceIdsChanged) {
           callListeners(sliceIdsListeners, [indexId]);
         }
         collForEach(changedSlices, (sliceId) =>
@@ -652,7 +659,6 @@ const createIndexes = getCreateFunction((store) => {
   };
   return objFreeze(indexes);
 });
-const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
 
 const aggregators = mapNew([
   [
@@ -861,7 +867,7 @@ const createCustomPersister = (
 };
 
 const STORAGE = 'storage';
-const WINDOW = window;
+const WINDOW = globalThis.window;
 const getStoragePersister = (store, storageName, storage) => {
   let listener;
   const getPersisted = async () => storage.getItem(storageName);
@@ -966,951 +972,6 @@ const createRemotePersister = (
   );
 };
 
-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],
-);
-
 const createRelationships = getCreateFunction((store) => {
   const remoteTableIds = mapNew();
   const remoteRowIdListeners = mapNew();
@@ -2641,21 +1702,6 @@ const createStore = () => {
 };
 
 export {
-  BackwardCheckpointsView,
-  CellView,
-  CheckpointView,
-  CurrentCheckpointView,
-  ForwardCheckpointsView,
-  IndexView,
-  LinkedRowsView,
-  LocalRowsView,
-  MetricView,
-  Provider,
-  RemoteRowView,
-  RowView,
-  SliceView,
-  TableView,
-  TablesView,
   createCheckpoints,
   createCustomPersister,
   createFilePersister,
@@ -2667,61 +1713,4 @@ export {
   createSessionPersister,
   createStore,
   defaultSorter,
-  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,
 };