tinybase 2.2.6 → 3.0.0-beta.1

package/lib/debug/tinybase.js

@@ -1,7 +1,6 @@
 import {promises, watch} from 'fs';
 
 const getTypeOf = (thing) => typeof thing;
-const EMPTY_OBJECT = '{}';
 const EMPTY_STRING = '';
 const STRING = getTypeOf(EMPTY_STRING);
 const BOOLEAN = getTypeOf(true);
@@ -26,6 +25,9 @@ const SORTED_ROW_IDS = 'SortedRowIds';
 const ROW = 'Row';
 const CELL_IDS = 'CellIds';
 const CELL = 'Cell';
+const VALUES = 'Values';
+const VALUE_IDS = 'ValueIds';
+const VALUE = 'Value';
 const id = (key) => EMPTY_STRING + key;
 
 const arrayHas = (array, value) => array.includes(value);
@@ -148,6 +150,19 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     },
   );
 
+const getCellOrValueType = (cell) => {
+  const type = getTypeOf(cell);
+  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+    ? type
+    : void 0;
+};
+const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
+  isUndefined(cell)
+    ? store.delCell(tableId, rowId, cellId, true)
+    : store.setCell(tableId, rowId, cellId, cell);
+const setOrDelValue = (store, valueId, value) =>
+  isUndefined(value) ? store.delValue(valueId) : store.setValue(valueId, value);
+
 const setNew = (entryOrEntries) =>
   new Set(
     isArray(entryOrEntries) || isUndefined(entryOrEntries)
@@ -343,10 +358,22 @@ const getListenerFunctions = (getThing) => {
   let thing;
   const [getId, releaseId] = getPoolFunctions();
   const allListeners = mapNew();
-  const addListener = (listener, idSetNode, path) => {
+  const addListener = (
+    listener,
+    idSetNode,
+    path,
+    pathGetters = [],
+    extraArgsGetter = () => [],
+  ) => {
     thing ??= getThing();
     const id = getId();
-    mapSet(allListeners, id, [listener, idSetNode, path]);
+    mapSet(allListeners, id, [
+      listener,
+      idSetNode,
+      path,
+      pathGetters,
+      extraArgsGetter,
+    ]);
     setAdd(visitTree(idSetNode, path ?? [EMPTY_STRING], setNew), id);
     return id;
   };
@@ -366,20 +393,23 @@ const getListenerFunctions = (getThing) => {
       releaseId(id);
       return idOrNulls;
     });
-  const callListener = (id, idNullGetters, extraArgsGetter) =>
-    ifNotUndefined(mapGet(allListeners, id), ([listener, , idOrNulls = []]) => {
-      const callWithIds = (...ids) => {
-        const index = arrayLength(ids);
-        index == arrayLength(idOrNulls)
-          ? listener(thing, ...ids, ...extraArgsGetter(ids))
-          : isUndefined(idOrNulls[index])
-          ? arrayForEach(idNullGetters[index](...ids), (id2) =>
-              callWithIds(...ids, id2),
-            )
-          : callWithIds(...ids, idOrNulls[index]);
-      };
-      callWithIds();
-    });
+  const callListener = (id) =>
+    ifNotUndefined(
+      mapGet(allListeners, id),
+      ([listener, , path = [], pathGetters, extraArgsGetter]) => {
+        const callWithIds = (...ids) => {
+          const index = arrayLength(ids);
+          index == arrayLength(path)
+            ? listener(thing, ...ids, ...extraArgsGetter(ids))
+            : isUndefined(path[index])
+            ? arrayForEach(pathGetters[index]?.(...ids) ?? [], (id2) =>
+                callWithIds(...ids, id2),
+              )
+            : callWithIds(...ids, path[index]);
+        };
+        callWithIds();
+      },
+    );
   return [addListener, callListeners, delListener, callListener];
 };
 
@@ -394,23 +424,13 @@ const objHas = (obj, id) => !isUndefined(objGet(obj, id));
 const objDel = (obj, id) => delete obj[id];
 const objMap = (obj, cb) =>
   arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
-const objIsEmpty = (obj) => arrayIsEmpty(objIds(obj));
-
-const getCellType = (cell) => {
-  const type = getTypeOf(cell);
-  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
-    ? type
-    : void 0;
-};
-const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
-  isUndefined(cell)
-    ? store.delCell(tableId, rowId, cellId, true)
-    : store.setCell(tableId, rowId, cellId, cell);
+const objIsEmpty = (obj) => isObject(obj) && arrayIsEmpty(objIds(obj));
 
 const createCheckpoints = getCreateFunction((store) => {
   let backwardIdsSize = 100;
   let currentId;
-  let delta = mapNew();
+  let cellsDelta = mapNew();
+  let valuesDelta = mapNew();
   let listening = 1;
   let nextCheckpointId;
   let checkpointsChanged;
@@ -425,15 +445,19 @@ const createCheckpoints = getCreateFunction((store) => {
   const forwardIds = [];
   const updateStore = (oldOrNew, checkpointId) => {
     listening = 0;
-    store.transaction(() =>
-      collForEach(mapGet(deltas, checkpointId), (table, tableId) =>
+    store.transaction(() => {
+      const [cellsDelta2, valuesDelta2] = mapGet(deltas, checkpointId);
+      collForEach(cellsDelta2, (table, tableId) =>
         collForEach(table, (row, rowId) =>
           collForEach(row, (oldNew, cellId) =>
             setOrDelCell(store, tableId, rowId, cellId, oldNew[oldOrNew]),
           ),
         ),
-      ),
-    );
+      );
+      collForEach(valuesDelta2, (oldNew, valueId) =>
+        setOrDelValue(store, valueId, oldNew[oldOrNew]),
+      );
+    });
     listening = 1;
   };
   const clearCheckpointId = (checkpointId) => {
@@ -448,32 +472,56 @@ const createCheckpoints = getCreateFunction((store) => {
     );
   const trimBackwardsIds = () =>
     clearCheckpointIds(backwardIds, arrayLength(backwardIds) - backwardIdsSize);
-  const listenerId = store.addCellListener(
+  const storeChanged = () =>
+    ifNotUndefined(currentId, () => {
+      arrayPush(backwardIds, currentId);
+      trimBackwardsIds();
+      clearCheckpointIds(forwardIds);
+      currentId = void 0;
+      checkpointsChanged = 1;
+    });
+  const storeUnchanged = () => {
+    currentId = arrayPop(backwardIds);
+    checkpointsChanged = 1;
+  };
+  const cellListenerId = store.addCellListener(
     null,
     null,
     null,
     (_store, tableId, rowId, cellId, newCell, oldCell) => {
       if (listening) {
-        ifNotUndefined(currentId, () => {
-          arrayPush(backwardIds, currentId);
-          trimBackwardsIds();
-          clearCheckpointIds(forwardIds);
-          currentId = void 0;
-          checkpointsChanged = 1;
-        });
-        const table = mapEnsure(delta, tableId, mapNew);
+        storeChanged();
+        const table = mapEnsure(cellsDelta, tableId, mapNew);
         const row = mapEnsure(table, rowId, mapNew);
         const oldNew = mapEnsure(row, cellId, () => [oldCell, void 0]);
         oldNew[1] = newCell;
-        if (oldNew[0] === newCell) {
-          if (collIsEmpty(mapSet(row, cellId))) {
-            if (collIsEmpty(mapSet(table, rowId))) {
-              if (collIsEmpty(mapSet(delta, tableId))) {
-                currentId = arrayPop(backwardIds);
-                checkpointsChanged = 1;
-              }
-            }
-          }
+        if (
+          oldNew[0] === newCell &&
+          collIsEmpty(mapSet(row, cellId)) &&
+          collIsEmpty(mapSet(table, rowId)) &&
+          collIsEmpty(mapSet(cellsDelta, tableId))
+        ) {
+          storeUnchanged();
+        }
+        callListenersIfChanged();
+      }
+    },
+  );
+  const valueListenerId = store.addValueListener(
+    null,
+    (_store, valueId, newValue, oldValue) => {
+      if (listening) {
+        storeChanged();
+        const oldNew = mapEnsure(valuesDelta, valueId, () => [
+          oldValue,
+          void 0,
+        ]);
+        oldNew[1] = newValue;
+        if (
+          oldNew[0] === newValue &&
+          collIsEmpty(mapSet(valuesDelta, valueId))
+        ) {
+          storeUnchanged();
         }
         callListenersIfChanged();
       }
@@ -482,9 +530,10 @@ const createCheckpoints = getCreateFunction((store) => {
   const addCheckpointImpl = (label = EMPTY_STRING) => {
     if (isUndefined(currentId)) {
       currentId = EMPTY_STRING + nextCheckpointId++;
-      mapSet(deltas, currentId, delta);
+      mapSet(deltas, currentId, [cellsDelta, valuesDelta]);
       setCheckpoint(currentId, label);
-      delta = mapNew();
+      cellsDelta = mapNew();
+      valuesDelta = mapNew();
       checkpointsChanged = 1;
     }
     return currentId;
@@ -560,8 +609,8 @@ const createCheckpoints = getCreateFunction((store) => {
     addListener(listener, checkpointIdsListeners);
   const addCheckpointListener = (checkpointId, listener) =>
     addListener(listener, checkpointListeners, [checkpointId]);
-  const delListener = (listenerId2) => {
-    delListenerImpl(listenerId2);
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
     return checkpoints;
   };
   const clear = () => {
@@ -576,7 +625,8 @@ const createCheckpoints = getCreateFunction((store) => {
     return checkpoints;
   };
   const destroy = () => {
-    store.delListener(listenerId);
+    store.delListener(cellListenerId);
+    store.delListener(valueListenerId);
   };
   const getListenerStats = () => ({
     checkpointIds: collSize2(checkpointIdsListeners),
@@ -969,11 +1019,12 @@ const createCustomPersister = (
   stopListeningToPersisted,
 ) => {
   let tablesListenerId;
+  let valuesListenerId;
   let loadSave = 0;
   let loads = 0;
   let saves = 0;
   const persister = {
-    load: async (initialTables) => {
+    load: async (initialTables, initialValues) => {
       /* istanbul ignore else */
       if (loadSave != 2) {
         loadSave = 1;
@@ -984,15 +1035,17 @@ const createCustomPersister = (
         if (!isUndefined(body) && body != EMPTY_STRING) {
           store.setJson(body);
         } else {
-          store.setTables(initialTables);
+          store.transaction(() =>
+            store.setTables(initialTables).setValues(initialValues),
+          );
         }
         loadSave = 0;
       }
       return persister;
     },
-    startAutoLoad: async (initialTables) => {
+    startAutoLoad: async (initialTables, initialValues) => {
       persister.stopAutoLoad();
-      await persister.load(initialTables);
+      await persister.load(initialTables, initialValues);
       startListeningToPersisted(persister.load);
       return persister;
     },
@@ -1014,11 +1067,13 @@ const createCustomPersister = (
     },
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
-      tablesListenerId = store.addTablesListener(() => persister.save());
+      tablesListenerId = store.addTablesListener(persister.save);
+      valuesListenerId = store.addValuesListener(persister.save);
       return persister;
     },
     stopAutoSave: () => {
       ifNotUndefined(tablesListenerId, store.delListener);
+      ifNotUndefined(valuesListenerId, store.delListener);
       return persister;
     },
     getStore: () => store,
@@ -1326,7 +1381,7 @@ const createQueries = getCreateFunction((store) => {
                         aggregators,
                       );
                       groupRow[groupedCellId] = isUndefined(
-                        getCellType(aggregateValue),
+                        getCellOrValueType(aggregateValue),
                       )
                         ? null
                         : aggregateValue;
@@ -1790,18 +1845,27 @@ const validate = (obj, validateChild, onInvalidObj) => {
 const idsChanged = (changedIds, id2, added) =>
   mapSet(changedIds, id2, mapGet(changedIds, id2) == -added ? void 0 : added);
 const createStore = () => {
-  let hasSchema;
+  let hasTablesSchema;
+  let hasValuesSchema;
   let cellsTouched;
+  let valuesTouched;
   let transactions = 0;
   const changedTableIds = mapNew();
   const changedRowIds = mapNew();
   const changedCellIds = mapNew();
   const changedCells = mapNew();
+  const changedValueIds = mapNew();
+  const changedValues = mapNew();
   const invalidCells = mapNew();
-  const schemaMap = mapNew();
-  const schemaRowCache = mapNew();
+  const invalidValues = mapNew();
+  const tablesSchemaMap = mapNew();
+  const tablesSchemaRowCache = mapNew();
+  const valuesSchemaMap = mapNew();
+  const valuesDefaulted = mapNew();
+  const valuesNonDefaulted = setNew();
   const tablePoolFunctions = mapNew();
   const tablesMap = mapNew();
+  const valuesMap = mapNew();
   const tablesListeners = pairNewMap();
   const tableIdsListeners = pairNewMap();
   const tableListeners = pairNewMap();
@@ -1811,31 +1875,38 @@ const createStore = () => {
   const cellIdsListeners = pairNewMap();
   const cellListeners = pairNewMap();
   const invalidCellListeners = pairNewMap();
+  const invalidValueListeners = pairNewMap();
+  const valuesListeners = pairNewMap();
+  const valueIdsListeners = pairNewMap();
+  const valueListeners = pairNewMap();
   const finishTransactionListeners = pairNewMap();
   const [addListener, callListeners, delListenerImpl, callListenerImpl] =
     getListenerFunctions(() => store);
-  const validateSchema = (schema) =>
-    validate(schema, (tableSchema) =>
-      validate(tableSchema, (cellSchema) => {
-        if (
-          !validate(cellSchema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))
-        ) {
-          return false;
-        }
-        const type = cellSchema[TYPE];
-        if (!isTypeStringOrBoolean(type) && type != NUMBER) {
-          return false;
-        }
-        if (getCellType(cellSchema[DEFAULT]) != type) {
-          objDel(cellSchema, DEFAULT);
-        }
-        return true;
-      }),
+  const validateTablesSchema = (tableSchema) =>
+    validate(tableSchema, (tableSchema2) =>
+      validate(tableSchema2, validateCellOrValueSchema),
     );
+  const validateValuesSchema = (valuesSchema) =>
+    validate(valuesSchema, validateCellOrValueSchema);
+  const validateCellOrValueSchema = (schema) => {
+    if (!validate(schema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))) {
+      return false;
+    }
+    const type = schema[TYPE];
+    if (!isTypeStringOrBoolean(type) && type != NUMBER) {
+      return false;
+    }
+    if (getCellOrValueType(schema[DEFAULT]) != type) {
+      objDel(schema, DEFAULT);
+    }
+    return true;
+  };
   const validateTables = (tables) =>
     validate(tables, validateTable, cellInvalid);
   const validateTable = (table, tableId) =>
-    (!hasSchema || collHas(schemaMap, tableId) || cellInvalid(tableId)) &&
+    (!hasTablesSchema ||
+      collHas(tablesSchemaMap, tableId) ||
+      cellInvalid(tableId)) &&
     validate(
       table,
       (row, rowId) => validateRow(tableId, rowId, row),
@@ -1856,21 +1927,48 @@ const createStore = () => {
       () => cellInvalid(tableId, rowId),
     );
   const getValidatedCell = (tableId, rowId, cellId, cell) =>
-    hasSchema
+    hasTablesSchema
       ? ifNotUndefined(
-          mapGet(mapGet(schemaMap, tableId), cellId),
+          mapGet(mapGet(tablesSchemaMap, tableId), cellId),
           (cellSchema) =>
-            getCellType(cell) != cellSchema[TYPE]
+            getCellOrValueType(cell) != cellSchema[TYPE]
               ? cellInvalid(tableId, rowId, cellId, cell, cellSchema[DEFAULT])
               : cell,
           () => cellInvalid(tableId, rowId, cellId, cell),
         )
-      : isUndefined(getCellType(cell))
+      : isUndefined(getCellOrValueType(cell))
       ? cellInvalid(tableId, rowId, cellId, cell)
       : cell;
+  const validateValues = (values, skipDefaults) =>
+    validate(
+      skipDefaults ? values : addDefaultsToValues(values),
+      (value, valueId) =>
+        ifNotUndefined(
+          getValidatedValue(valueId, value),
+          (validValue) => {
+            values[valueId] = validValue;
+            return true;
+          },
+          () => false,
+        ),
+      () => valueInvalid(),
+    );
+  const getValidatedValue = (valueId, value) =>
+    hasValuesSchema
+      ? ifNotUndefined(
+          mapGet(valuesSchemaMap, valueId),
+          (valueSchema) =>
+            getCellOrValueType(value) != valueSchema[TYPE]
+              ? valueInvalid(valueId, value, valueSchema[DEFAULT])
+              : value,
+          () => valueInvalid(valueId, value),
+        )
+      : isUndefined(getCellOrValueType(value))
+      ? valueInvalid(valueId, value)
+      : value;
   const addDefaultsToRow = (row, tableId, rowId) => {
     ifNotUndefined(
-      mapGet(schemaRowCache, tableId),
+      mapGet(tablesSchemaRowCache, tableId),
       ([rowDefaulted, rowNonDefaulted]) => {
         collForEach(rowDefaulted, (cell, cellId) => {
           if (!objHas(row, cellId)) {
@@ -1886,15 +1984,30 @@ const createStore = () => {
     );
     return row;
   };
-  const setValidSchema = (schema) =>
+  const addDefaultsToValues = (values) => {
+    if (hasValuesSchema) {
+      collForEach(valuesDefaulted, (value, valueId) => {
+        if (!objHas(values, valueId)) {
+          values[valueId] = value;
+        }
+      });
+      collForEach(valuesNonDefaulted, (valueId) => {
+        if (!objHas(values, valueId)) {
+          valueInvalid(valueId);
+        }
+      });
+    }
+    return values;
+  };
+  const setValidTablesSchema = (tablesSchema) =>
     transformMap(
-      schemaMap,
-      schema,
-      (_schema, tableId, tableSchema) => {
+      tablesSchemaMap,
+      tablesSchema,
+      (_tablesSchema, tableId, tableSchema) => {
         const rowDefaulted = mapNew();
         const rowNonDefaulted = setNew();
         transformMap(
-          mapEnsure(schemaMap, tableId, mapNew),
+          mapEnsure(tablesSchemaMap, tableId, mapNew),
           tableSchema,
           (tableSchemaMap, cellId, cellSchema) => {
             mapSet(tableSchemaMap, cellId, cellSchema);
@@ -1905,13 +2018,33 @@ const createStore = () => {
             );
           },
         );
-        mapSet(schemaRowCache, tableId, [rowDefaulted, rowNonDefaulted]);
+        mapSet(tablesSchemaRowCache, tableId, [rowDefaulted, rowNonDefaulted]);
+      },
+      (_tablesSchema, tableId) => {
+        mapSet(tablesSchemaMap, tableId);
+        mapSet(tablesSchemaRowCache, tableId);
+      },
+    );
+  const setValidValuesSchema = (valuesSchema) =>
+    transformMap(
+      valuesSchemaMap,
+      valuesSchema,
+      (_valuesSchema, valueId, valueSchema) => {
+        mapSet(valuesSchemaMap, valueId, valueSchema);
+        ifNotUndefined(
+          valueSchema[DEFAULT],
+          (def) => mapSet(valuesDefaulted, valueId, def),
+          () => setAdd(valuesNonDefaulted, valueId),
+        );
       },
-      (_schema, tableId) => {
-        mapSet(schemaMap, tableId);
-        mapSet(schemaRowCache, tableId);
+      (_valuesSchema, valueId) => {
+        mapSet(valuesSchemaMap, valueId);
+        mapSet(valuesDefaulted, valueId);
+        collDel(valuesNonDefaulted, valueId);
       },
     );
+  const setOrDelTables = (tables) =>
+    objIsEmpty(tables) ? delTables() : setTables(tables);
   const setValidTables = (tables) =>
     transformMap(
       tablesMap,
@@ -1929,26 +2062,26 @@ const createStore = () => {
       (tableMap, rowId, row) => setValidRow(tableId, tableMap, rowId, row),
       (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
     );
-  const setValidRow = (tableId, tableMap, rowId, newRow, forceDel) =>
+  const setValidRow = (tableId, tableMap, rowId, row, forceDel) =>
     transformMap(
       mapEnsure(tableMap, rowId, () => {
         rowIdsChanged(tableId, rowId, 1);
         return mapNew();
       }),
-      newRow,
+      row,
       (rowMap, cellId, cell) =>
         setValidCell(tableId, rowId, rowMap, cellId, cell),
       (rowMap, cellId) =>
         delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
     );
-  const setValidCell = (tableId, rowId, rowMap, cellId, newCell) => {
+  const setValidCell = (tableId, rowId, rowMap, cellId, cell) => {
     if (!collHas(rowMap, cellId)) {
       cellIdsChanged(tableId, rowId, cellId, 1);
     }
     const oldCell = mapGet(rowMap, cellId);
-    if (newCell !== oldCell) {
-      cellChanged(tableId, rowId, cellId, oldCell, newCell);
-      mapSet(rowMap, cellId, newCell);
+    if (cell !== oldCell) {
+      cellChanged(tableId, rowId, cellId, oldCell, cell);
+      mapSet(rowMap, cellId, cell);
     }
   };
   const setCellIntoDefaultRow = (tableId, tableMap, rowId, cellId, validCell) =>
@@ -1963,6 +2096,25 @@ const createStore = () => {
           addDefaultsToRow({[cellId]: validCell}, tableId, rowId),
         ),
     );
+  const setOrDelValues = (values) =>
+    objIsEmpty(values) ? delValues() : setValues(values);
+  const setValidValues = (values) =>
+    transformMap(
+      valuesMap,
+      values,
+      (_valuesMap, valueId, value) => setValidValue(valueId, value),
+      (_valuesMap, valueId) => delValidValue(valueId),
+    );
+  const setValidValue = (valueId, value) => {
+    if (!collHas(valuesMap, valueId)) {
+      valueIdsChanged(valueId, 1);
+    }
+    const oldValue = mapGet(valuesMap, valueId);
+    if (value !== oldValue) {
+      valueChanged(valueId, oldValue, value);
+      mapSet(valuesMap, valueId, value);
+    }
+  };
   const getNewRowId = (tableId) => {
     const [getId] = mapEnsure(tablePoolFunctions, tableId, getPoolFunctions);
     const rowId = getId();
@@ -1984,7 +2136,10 @@ const createStore = () => {
     setValidRow(tableId, tableMap, rowId, {}, true);
   };
   const delValidCell = (tableId, table, rowId, row, cellId, forceDel) => {
-    const defaultCell = mapGet(mapGet(schemaRowCache, tableId)?.[0], cellId);
+    const defaultCell = mapGet(
+      mapGet(tablesSchemaRowCache, tableId)?.[0],
+      cellId,
+    );
     if (!isUndefined(defaultCell) && !forceDel) {
       return setValidCell(tableId, rowId, row, cellId, defaultCell);
     }
@@ -2003,6 +2158,15 @@ const createStore = () => {
       }
     }
   };
+  const delValidValue = (valueId) => {
+    const defaultValue = mapGet(valuesDefaulted, valueId);
+    if (!isUndefined(defaultValue)) {
+      return setValidValue(valueId, defaultValue);
+    }
+    valueChanged(valueId, mapGet(valuesMap, valueId));
+    valueIdsChanged(valueId, -1);
+    mapSet(valuesMap, valueId);
+  };
   const tableIdsChanged = (tableId, added) =>
     idsChanged(changedTableIds, tableId, added);
   const rowIdsChanged = (tableId, rowId, added) =>
@@ -2019,6 +2183,10 @@ const createStore = () => {
       cellId,
       () => [oldCell, 0],
     )[1] = newCell);
+  const valueIdsChanged = (valueId, added) =>
+    idsChanged(changedValueIds, valueId, added);
+  const valueChanged = (valueId, oldValue, newValue) =>
+    (mapEnsure(changedValues, valueId, () => [oldValue, 0])[1] = newValue);
   const cellInvalid = (tableId, rowId, cellId, invalidCell, defaultedCell) => {
     arrayPush(
       mapEnsure(
@@ -2030,12 +2198,25 @@ const createStore = () => {
     );
     return defaultedCell;
   };
+  const valueInvalid = (valueId, invalidValue, defaultedValue) => {
+    arrayPush(
+      mapEnsure(invalidValues, valueId, () => []),
+      invalidValue,
+    );
+    return defaultedValue;
+  };
   const getCellChange = (tableId, rowId, cellId) =>
     ifNotUndefined(
       mapGet(mapGet(mapGet(changedCells, tableId), rowId), cellId),
       ([oldCell, newCell]) => [true, oldCell, newCell],
       () => [false, ...pairNew(getCell(tableId, rowId, cellId))],
     );
+  const getValueChange = (valueId) =>
+    ifNotUndefined(
+      mapGet(changedValues, valueId),
+      ([oldValue, newValue]) => [true, oldValue, newValue],
+      () => [false, ...pairNew(getValue(valueId))],
+    );
   const callInvalidCellListeners = (mutator) =>
     !collIsEmpty(invalidCells) && !collIsEmpty(invalidCellListeners[mutator])
       ? collForEach(
@@ -2052,13 +2233,25 @@ const createStore = () => {
             ),
         )
       : 0;
+  const callInvalidValueListeners = (mutator) =>
+    !collIsEmpty(invalidValues) && !collIsEmpty(invalidValueListeners[mutator])
+      ? collForEach(
+          mutator ? mapClone(invalidValues) : invalidValues,
+          (invalidValue, valueId) =>
+            callListeners(
+              invalidValueListeners[mutator],
+              [valueId],
+              invalidValue,
+            ),
+        )
+      : 0;
   const callIdsListenersIfChanged = (listeners, changedIds, ids) => {
     if (!collIsEmpty(changedIds)) {
       callListeners(listeners, ids);
       return 1;
     }
   };
-  const callListenersForChanges = (mutator) => {
+  const callTabularListenersForChanges = (mutator) => {
     const emptySortedRowIdListeners = collIsEmpty(
       sortedRowIdsListeners[mutator],
     );
@@ -2160,6 +2353,38 @@ const createStore = () => {
       }
     }
   };
+  const callKeyedValuesListenersForChanges = (mutator) => {
+    const emptyIdListeners = collIsEmpty(valueIdsListeners[mutator]);
+    const emptyOtherListeners =
+      collIsEmpty(valueListeners[mutator]) &&
+      collIsEmpty(valuesListeners[mutator]);
+    if (!emptyIdListeners || !emptyOtherListeners) {
+      const changes = mutator
+        ? [mapClone(changedValueIds), mapClone(changedValues)]
+        : [changedValueIds, changedValues];
+      if (!emptyIdListeners) {
+        callIdsListenersIfChanged(valueIdsListeners[mutator], changes[0]);
+      }
+      if (!emptyOtherListeners) {
+        let valuesChanged;
+        collForEach(changes[1], ([oldValue, newValue], valueId) => {
+          if (newValue !== oldValue) {
+            callListeners(
+              valueListeners[mutator],
+              [valueId],
+              newValue,
+              oldValue,
+              getValueChange,
+            );
+            valuesChanged = 1;
+          }
+        });
+        if (valuesChanged) {
+          callListeners(valuesListeners[mutator], void 0, getValueChange);
+        }
+      }
+    }
+  };
   const fluentTransaction = (actions, ...args) => {
     transaction(() => actions(...arrayMap(args, id)));
     return store;
@@ -2192,14 +2417,23 @@ const createStore = () => {
     mapKeys(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)));
   const getCell = (tableId, rowId, cellId) =>
     mapGet(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId));
+  const getValues = () => mapToObj(valuesMap);
+  const getValueIds = () => mapKeys(valuesMap);
+  const getValue = (valueId) => mapGet(valuesMap, id(valueId));
   const hasTables = () => !collIsEmpty(tablesMap);
   const hasTable = (tableId) => collHas(tablesMap, id(tableId));
   const hasRow = (tableId, rowId) =>
     collHas(mapGet(tablesMap, id(tableId)), id(rowId));
   const hasCell = (tableId, rowId, cellId) =>
     collHas(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId));
-  const getJson = () => jsonString(tablesMap);
-  const getSchemaJson = () => jsonString(schemaMap);
+  const hasValues = () => !collIsEmpty(valuesMap);
+  const hasValue = (valueId) => collHas(valuesMap, id(valueId));
+  const getTablesJson = () => jsonString(tablesMap);
+  const getValuesJson = () => jsonString(valuesMap);
+  const getJson = () => jsonString([tablesMap, valuesMap]);
+  const getTablesSchemaJson = () => jsonString(tablesSchemaMap);
+  const getValuesSchemaJson = () => jsonString(valuesSchemaMap);
+  const getSchemaJson = () => jsonString([tablesSchemaMap, valuesSchemaMap]);
   const setTables = (tables) =>
     fluentTransaction(() =>
       validateTables(tables) ? setValidTables(tables) : 0,
@@ -2213,13 +2447,8 @@ const createStore = () => {
   const setRow = (tableId, rowId, row) =>
     fluentTransaction(
       (tableId2, rowId2) =>
-        validateRow(id(tableId2), id(rowId2), row)
-          ? setValidRow(
-              id(tableId2),
-              getOrCreateTable(id(tableId2)),
-              id(rowId2),
-              row,
-            )
+        validateRow(tableId2, rowId2, row)
+          ? setValidRow(tableId2, getOrCreateTable(tableId2), rowId2, row)
           : 0,
       tableId,
       rowId,
@@ -2274,16 +2503,56 @@ const createStore = () => {
       rowId,
       cellId,
     );
-  const setJson = (json) => {
+  const setValues = (values) =>
+    fluentTransaction(() =>
+      validateValues(values) ? setValidValues(values) : 0,
+    );
+  const setPartialValues = (partialValues) =>
+    fluentTransaction(() =>
+      validateValues(partialValues, 1)
+        ? objMap(partialValues, (value, valueId) =>
+            setValidValue(valueId, value),
+          )
+        : 0,
+    );
+  const setValue = (valueId, value) =>
+    fluentTransaction(
+      (valueId2) =>
+        ifNotUndefined(
+          getValidatedValue(
+            valueId2,
+            isFunction(value) ? value(getValue(valueId2)) : value,
+          ),
+          (validValue) => setValidValue(valueId2, validValue),
+        ),
+      valueId,
+    );
+  const setTablesJson = (tablesJson) => {
+    try {
+      setOrDelTables(jsonParse(tablesJson));
+    } catch {}
+    return store;
+  };
+  const setValuesJson = (valuesJson) => {
     try {
-      json === EMPTY_OBJECT ? delTables() : setTables(jsonParse(json));
+      setOrDelValues(jsonParse(valuesJson));
     } catch {}
     return store;
   };
-  const setSchema = (schema) =>
+  const setJson = (tablesAndValuesJson) => {
+    try {
+      const [tables, values] = jsonParse(tablesAndValuesJson);
+      setOrDelTables(tables);
+      setOrDelValues(values);
+    } catch {
+      setTablesJson(tablesAndValuesJson);
+    }
+    return store;
+  };
+  const setTablesSchema = (tablesSchema) =>
     fluentTransaction(() => {
-      if ((hasSchema = validateSchema(schema))) {
-        setValidSchema(schema);
+      if ((hasTablesSchema = validateTablesSchema(tablesSchema))) {
+        setValidTablesSchema(tablesSchema);
         if (!collIsEmpty(tablesMap)) {
           const tables = getTables();
           delTables();
@@ -2291,6 +2560,22 @@ const createStore = () => {
         }
       }
     });
+  const setValuesSchema = (valuesSchema) =>
+    fluentTransaction(() => {
+      if ((hasValuesSchema = validateValuesSchema(valuesSchema))) {
+        const values = getValues();
+        delValuesSchema();
+        delValues();
+        hasValuesSchema = true;
+        setValidValuesSchema(valuesSchema);
+        setValues(values);
+      }
+    });
+  const setSchema = (tablesSchema, valuesSchema) =>
+    fluentTransaction(() => {
+      setTablesSchema(tablesSchema);
+      setValuesSchema(valuesSchema);
+    });
   const delTables = () => fluentTransaction(() => setValidTables({}));
   const delTable = (tableId) =>
     fluentTransaction(
@@ -2330,10 +2615,22 @@ const createStore = () => {
       rowId,
       cellId,
     );
-  const delSchema = () =>
+  const delValues = () => fluentTransaction(() => setValidValues({}));
+  const delValue = (valueId) =>
+    fluentTransaction(
+      (valueId2) =>
+        collHas(valuesMap, valueId2) ? delValidValue(valueId2) : 0,
+      valueId,
+    );
+  const delTablesSchema = () =>
+    fluentTransaction(() => {
+      setValidTablesSchema({});
+      hasTablesSchema = false;
+    });
+  const delValuesSchema = () =>
     fluentTransaction(() => {
-      setValidSchema({});
-      hasSchema = false;
+      setValidValuesSchema({});
+      hasValuesSchema = false;
     });
   const transaction = (actions, doRollback) => {
     if (transactions == -1) {
@@ -2353,10 +2650,15 @@ const createStore = () => {
       transactions--;
       if (transactions == 0) {
         cellsTouched = !collIsEmpty(changedCells);
+        valuesTouched = !collIsEmpty(changedValues);
         transactions = 1;
         callInvalidCellListeners(1);
         if (cellsTouched) {
-          callListenersForChanges(1);
+          callTabularListenersForChanges(1);
+        }
+        callInvalidValueListeners(1);
+        if (valuesTouched) {
+          callKeyedValuesListenersForChanges(1);
         }
         transactions = -1;
         if (
@@ -2377,6 +2679,12 @@ const createStore = () => {
               objIsEmpty,
             ),
             mapToObj(invalidCells, (map) => mapToObj(map, mapToObj)),
+            mapToObj(
+              changedValues,
+              (values) => [...values],
+              ([oldValue, newValue]) => oldValue === newValue,
+            ),
+            mapToObj(invalidValues),
           )
         ) {
           transactions = 1;
@@ -2387,23 +2695,43 @@ const createStore = () => {
               ),
             ),
           );
+          collForEach(changedValues, ([oldValue], valueId) =>
+            setOrDelValue(store, valueId, oldValue),
+          );
           transactions = -1;
-          cellsTouched = false;
+          cellsTouched = valuesTouched = false;
         }
-        callListeners(finishTransactionListeners[0], void 0, cellsTouched);
+        callListeners(
+          finishTransactionListeners[0],
+          void 0,
+          cellsTouched,
+          valuesTouched,
+        );
         callInvalidCellListeners(0);
         if (cellsTouched) {
-          callListenersForChanges(0);
+          callTabularListenersForChanges(0);
+        }
+        callInvalidValueListeners(0);
+        if (valuesTouched) {
+          callKeyedValuesListenersForChanges(0);
         }
-        callListeners(finishTransactionListeners[1], void 0, cellsTouched);
+        callListeners(
+          finishTransactionListeners[1],
+          void 0,
+          cellsTouched,
+          valuesTouched,
+        );
         transactions = 0;
         arrayForEach(
           [
-            changedCells,
-            invalidCells,
             changedTableIds,
             changedRowIds,
             changedCellIds,
+            changedCells,
+            invalidCells,
+            changedValueIds,
+            changedValues,
+            invalidValues,
           ],
           collClear,
         );
@@ -2427,6 +2755,7 @@ const createStore = () => {
     );
   const forEachCell = (tableId, rowId, cellCallback) =>
     mapForEach(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), cellCallback);
+  const forEachValue = (valueCallback) => mapForEach(valuesMap, valueCallback);
   const addSortedRowIdsListener = (
     tableId,
     cellId,
@@ -2467,6 +2796,7 @@ const createStore = () => {
       },
       sortedRowIdsListeners[mutator ? 1 : 0],
       [tableId, cellId],
+      [getTableIds],
     );
   };
   const addWillFinishTransactionListener = (listener) =>
@@ -2474,9 +2804,7 @@ const createStore = () => {
   const addDidFinishTransactionListener = (listener) =>
     addListener(listener, finishTransactionListeners[1]);
   const callListener = (listenerId) => {
-    callListenerImpl(listenerId, [getTableIds, getRowIds, getCellIds], (ids) =>
-      isUndefined(ids[2]) ? [] : pairNew(getCell(...ids)),
-    );
+    callListenerImpl(listenerId);
     return store;
   };
   const delListener = (listenerId) => {
@@ -2493,6 +2821,10 @@ const createStore = () => {
     cellIds: pairCollSize2(cellIdsListeners, collSize3),
     cell: pairCollSize2(cellListeners, collSize4),
     invalidCell: pairCollSize2(invalidCellListeners, collSize4),
+    values: pairCollSize2(valuesListeners),
+    valueIds: pairCollSize2(valueIdsListeners),
+    value: pairCollSize2(valueListeners),
+    invalidValue: pairCollSize2(invalidValueListeners),
     transaction: pairCollSize2(finishTransactionListeners),
   });
   const store = {
@@ -2504,11 +2836,20 @@ const createStore = () => {
     getRow,
     getCellIds,
     getCell,
+    getValues,
+    getValueIds,
+    getValue,
     hasTables,
     hasTable,
     hasRow,
     hasCell,
+    hasValues,
+    hasValue,
+    getTablesJson,
+    getValuesJson,
     getJson,
+    getTablesSchemaJson,
+    getValuesSchemaJson,
     getSchemaJson,
     setTables,
     setTable,
@@ -2516,19 +2857,30 @@ const createStore = () => {
     addRow,
     setPartialRow,
     setCell,
+    setValues,
+    setPartialValues,
+    setValue,
+    setTablesJson,
+    setValuesJson,
     setJson,
+    setTablesSchema,
+    setValuesSchema,
     setSchema,
     delTables,
     delTable,
     delRow,
     delCell,
-    delSchema,
+    delValues,
+    delValue,
+    delTablesSchema,
+    delValuesSchema,
     transaction,
     startTransaction,
     finishTransaction,
     forEachTable,
     forEachRow,
     forEachCell,
+    forEachValue,
     addSortedRowIdsListener,
     addWillFinishTransactionListener,
     addDidFinishTransactionListener,
@@ -2541,19 +2893,35 @@ const createStore = () => {
     {
       [TABLES]: [0, tablesListeners],
       [TABLE_IDS]: [0, tableIdsListeners],
-      [TABLE]: [1, tableListeners],
-      [ROW_IDS]: [1, rowIdsListeners],
-      [ROW]: [2, rowListeners],
-      [CELL_IDS]: [2, cellIdsListeners],
-      [CELL]: [3, cellListeners],
+      [TABLE]: [1, tableListeners, [getTableIds]],
+      [ROW_IDS]: [1, rowIdsListeners, [getTableIds]],
+      [ROW]: [2, rowListeners, [getTableIds, getRowIds]],
+      [CELL_IDS]: [2, cellIdsListeners, [getTableIds, getRowIds]],
+      [CELL]: [
+        3,
+        cellListeners,
+        [getTableIds, getRowIds, getCellIds],
+        (ids) => pairNew(getCell(...ids)),
+      ],
       InvalidCell: [3, invalidCellListeners],
+      [VALUES]: [0, valuesListeners],
+      [VALUE_IDS]: [0, valueIdsListeners],
+      [VALUE]: [
+        1,
+        valueListeners,
+        [getValueIds],
+        (ids) => pairNew(getValue(ids[0])),
+      ],
+      InvalidValue: [1, invalidValueListeners],
     },
-    ([argumentCount, idSetNode], listenable) => {
+    ([argumentCount, idSetNode, pathGetters, extraArgsGetter], listenable) => {
       store[ADD + listenable + LISTENER] = (...args) =>
         addListener(
           args[argumentCount],
           idSetNode[args[argumentCount + 1] ? 1 : 0],
           argumentCount > 0 ? arraySlice(args, 0, argumentCount) : void 0,
+          pathGetters,
+          extraArgsGetter,
         );
     },
   );