tinybase 2.2.6 → 3.0.0-beta.1

package/lib/debug/store.js

@@ -1,5 +1,4 @@
 const getTypeOf = (thing) => typeof thing;
-const EMPTY_OBJECT = '{}';
 const EMPTY_STRING = '';
 const STRING = getTypeOf(EMPTY_STRING);
 const BOOLEAN = getTypeOf(true);
@@ -16,6 +15,9 @@ const ROW_IDS = 'RowIds';
 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);
@@ -125,19 +127,6 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
     },
   );
 
-const object = Object;
-const objIds = object.keys;
-const objFrozen = object.isFrozen;
-const objFreeze = object.freeze;
-const isObject = (obj) =>
-  isInstanceOf(obj, object) && obj.constructor == object;
-const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-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 setNew = (entryOrEntries) =>
   new Set(
     isArray(entryOrEntries) || isUndefined(entryOrEntries)
@@ -175,10 +164,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;
   };
@@ -198,28 +199,44 @@ 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];
 };
 
+const object = Object;
+const objIds = object.keys;
+const objFrozen = object.isFrozen;
+const objFreeze = object.freeze;
+const isObject = (obj) =>
+  isInstanceOf(obj, object) && obj.constructor == object;
+const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+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) => isObject(obj) && arrayIsEmpty(objIds(obj));
+
 const pairNew = (value) => [value, value];
 const pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);
 const pairNewMap = () => [mapNew(), mapNew()];
 
-const getCellType = (cell) => {
+const getCellOrValueType = (cell) => {
   const type = getTypeOf(cell);
   return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
     ? type
@@ -229,6 +246,8 @@ 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 defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
 
@@ -258,18 +277,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();
@@ -279,31 +307,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),
@@ -324,21 +359,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)) {
@@ -354,15 +416,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);
@@ -373,13 +450,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,
@@ -397,26 +494,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) =>
@@ -431,6 +528,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();
@@ -452,7 +568,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);
     }
@@ -471,6 +590,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) =>
@@ -487,6 +615,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(
@@ -498,12 +630,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(
@@ -520,13 +665,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],
     );
@@ -628,6 +785,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;
@@ -660,14 +849,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,
@@ -681,13 +879,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,
@@ -742,16 +935,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();
@@ -759,6 +992,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(
@@ -798,10 +1047,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) {
@@ -821,10 +1082,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 (
@@ -845,6 +1111,12 @@ const createStore = () => {
               objIsEmpty,
             ),
             mapToObj(invalidCells, (map) => mapToObj(map, mapToObj)),
+            mapToObj(
+              changedValues,
+              (values) => [...values],
+              ([oldValue, newValue]) => oldValue === newValue,
+            ),
+            mapToObj(invalidValues),
           )
         ) {
           transactions = 1;
@@ -855,23 +1127,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,
         );
@@ -895,6 +1187,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,
@@ -935,6 +1228,7 @@ const createStore = () => {
       },
       sortedRowIdsListeners[mutator ? 1 : 0],
       [tableId, cellId],
+      [getTableIds],
     );
   };
   const addWillFinishTransactionListener = (listener) =>
@@ -942,9 +1236,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) => {
@@ -961,6 +1253,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 = {
@@ -972,11 +1268,20 @@ const createStore = () => {
     getRow,
     getCellIds,
     getCell,
+    getValues,
+    getValueIds,
+    getValue,
     hasTables,
     hasTable,
     hasRow,
     hasCell,
+    hasValues,
+    hasValue,
+    getTablesJson,
+    getValuesJson,
     getJson,
+    getTablesSchemaJson,
+    getValuesSchemaJson,
     getSchemaJson,
     setTables,
     setTable,
@@ -984,19 +1289,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,
@@ -1009,19 +1325,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,
         );
     },
   );