tinybase 1.0.5 → 1.1.0

package/lib/debug/tinybase.js

@@ -29,6 +29,8 @@ const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const arrayFilter = (array, cb) => array.filter(cb);
 const arrayFromSecond = (ids) => ids.slice(1);
 const arrayClear = (array, to) => array.splice(0, to);
+const arrayPush = (array, value) => array.push(value);
+const arrayPop = (array) => array.pop();
 
 const jsonString = (obj) =>
   JSON.stringify(obj, (_key, value) =>
@@ -254,7 +256,7 @@ const getListenerFunctions = (getThing) => {
   const allListeners = mapNew();
   const addListener = (listener, deepSet, idOrNulls = []) => {
     thing ??= getThing();
-    const id = listenerPool.pop() ?? '' + nextId++;
+    const id = arrayPop(listenerPool) ?? '' + nextId++;
     mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
     addDeepSet(deepSet, id, idOrNulls);
     return id;
@@ -275,7 +277,7 @@ const getListenerFunctions = (getThing) => {
         forDeepSet(collDel)(deepSet, id, ...idOrNulls);
         mapSet(allListeners, id);
         if (arrayLength(listenerPool) < 1e3) {
-          listenerPool.push(id);
+          arrayPush(listenerPool, id);
         }
         return idOrNulls;
       },
@@ -361,7 +363,7 @@ const createCheckpoints = getCreateFunction((store) => {
     (_store, tableId, rowId, cellId, newCell, oldCell) => {
       if (listening) {
         ifNotUndefined(currentId, () => {
-          backwardIds.push(currentId);
+          arrayPush(backwardIds, currentId);
           trimBackwardsIds();
           clearCheckpointIds(forwardIds);
           currentId = void 0;
@@ -380,7 +382,7 @@ const createCheckpoints = getCreateFunction((store) => {
           if (collIsEmpty(mapSet(row, cellId))) {
             if (collIsEmpty(mapSet(table, rowId))) {
               if (collIsEmpty(mapSet(delta, tableId))) {
-                currentId = backwardIds.pop();
+                currentId = arrayPop(backwardIds);
                 checkpointsChanged = 1;
               }
             }
@@ -404,13 +406,13 @@ const createCheckpoints = getCreateFunction((store) => {
     if (!arrayIsEmpty(backwardIds)) {
       forwardIds.unshift(addCheckpointImpl());
       updateStore(0, currentId);
-      currentId = backwardIds.pop();
+      currentId = arrayPop(backwardIds);
       checkpointsChanged = 1;
     }
   };
   const goForwardImpl = () => {
     if (!arrayIsEmpty(forwardIds)) {
-      backwardIds.push(currentId);
+      arrayPush(backwardIds, currentId);
       currentId = forwardIds.shift();
       updateStore(1, currentId);
       checkpointsChanged = 1;
@@ -1212,8 +1214,9 @@ const getCellType = (cell) => {
     ? type
     : void 0;
 };
-const validate = (obj, validateChild) => {
-  if (isUndefined(obj) || !isObject(obj) || objFrozen(obj)) {
+const validate = (obj, validateChild, onInvalidObj) => {
+  if (isUndefined(obj) || !isObject(obj) || objIsEmpty(obj) || objFrozen(obj)) {
+    onInvalidObj?.();
     return false;
   }
   objForEach(obj, (child, id) => {
@@ -1233,8 +1236,9 @@ const createStore = () => {
   const changedRowIds = mapNew();
   const changedCellIds = mapNew();
   const changedCells = mapNew();
+  const invalidCells = mapNew();
   const schemaMap = mapNew();
-  const schemaDefaultRows = mapNew();
+  const schemaRowCache = mapNew();
   const tablesMap = mapNew();
   const tablesListeners = mapNewPair(setNew);
   const tableIdsListeners = mapNewPair(setNew);
@@ -1243,6 +1247,7 @@ const createStore = () => {
   const rowListeners = mapNewPair();
   const cellIdsListeners = mapNewPair();
   const cellListeners = mapNewPair();
+  const invalidCellListeners = mapNewPair();
   const [addListener, callListeners, delListenerImpl, callListenerImpl] =
     getListenerFunctions(() => store);
   const validateSchema = (schema) =>
@@ -1263,40 +1268,57 @@ const createStore = () => {
         return true;
       }),
     );
-  const validateTables = (tables) => validate(tables, validateTable);
+  const validateTables = (tables) =>
+    validate(tables, validateTable, cellInvalid);
   const validateTable = (table, tableId) =>
-    (!hasSchema || collHas(schemaMap, tableId)) &&
-    validate(table, (row) => validateRow(tableId, row));
-  const validateRow = (tableId, row, skipDefaults) =>
+    (!hasSchema || collHas(schemaMap, tableId) || cellInvalid(tableId)) &&
     validate(
-      skipDefaults ? row : addDefaultsToRow(row, tableId),
+      table,
+      (row, rowId) => validateRow(tableId, rowId, row),
+      () => cellInvalid(tableId),
+    );
+  const validateRow = (tableId, rowId, row, skipDefaults) =>
+    validate(
+      skipDefaults ? row : addDefaultsToRow(row, tableId, rowId),
       (cell, cellId) =>
         ifNotUndefined(
-          getValidatedCell(tableId, cellId, cell),
+          getValidatedCell(tableId, rowId, cellId, cell),
           (validCell) => {
             row[cellId] = validCell;
             return true;
           },
           () => false,
         ),
+      () => cellInvalid(tableId, rowId),
     );
-  const getValidatedCell = (tableId, cellId, cell) =>
+  const getValidatedCell = (tableId, rowId, cellId, cell) =>
     hasSchema
       ? ifNotUndefined(
           mapGet(mapGet(schemaMap, tableId), cellId),
           (cellSchema) =>
-            getCellType(cell) != cellSchema[TYPE] ? cellSchema[DEFAULT] : cell,
+            getCellType(cell) != cellSchema[TYPE]
+              ? cellInvalid(tableId, rowId, cellId, cell, cellSchema[DEFAULT])
+              : cell,
+          () => cellInvalid(tableId, rowId, cellId, cell),
         )
       : isUndefined(getCellType(cell))
-      ? void 0
+      ? cellInvalid(tableId, rowId, cellId, cell)
       : cell;
-  const addDefaultsToRow = (row, tableId) => {
-    ifNotUndefined(mapGet(schemaDefaultRows, tableId), (defaultRow) =>
-      objForEach(defaultRow, (cell, cellId) => {
-        if (!objHas(row, cellId)) {
-          row[cellId] = cell;
-        }
-      }),
+  const addDefaultsToRow = (row, tableId, rowId) => {
+    ifNotUndefined(
+      mapGet(schemaRowCache, tableId),
+      ([rowDefaulted, rowNonDefaulted]) => {
+        collForEach(rowDefaulted, (cell, cellId) => {
+          if (!objHas(row, cellId)) {
+            row[cellId] = cell;
+          }
+        });
+        collForEach(rowNonDefaulted, (cellId) => {
+          if (!objHas(row, cellId)) {
+            cellInvalid(tableId, rowId, cellId);
+          }
+        });
+      },
     );
     return row;
   };
@@ -1305,7 +1327,8 @@ const createStore = () => {
       schemaMap,
       schema,
       (_schema, tableId, tableSchema) => {
-        const defaultRow = {};
+        const rowDefaulted = mapNew();
+        const rowNonDefaulted = setNew();
         transformMap(
           mapEnsure(schemaMap, tableId, mapNew()),
           tableSchema,
@@ -1313,15 +1336,16 @@ const createStore = () => {
             mapSet(tableSchemaMap, cellId, cellSchema);
             ifNotUndefined(
               cellSchema[DEFAULT],
-              (def) => (defaultRow[cellId] = def),
+              (def) => mapSet(rowDefaulted, cellId, def),
+              () => setAdd(rowNonDefaulted, cellId),
             );
           },
         );
-        mapSet(schemaDefaultRows, tableId, defaultRow);
+        mapSet(schemaRowCache, tableId, [rowDefaulted, rowNonDefaulted]);
       },
       (_schema, tableId) => {
         mapSet(schemaMap, tableId);
-        mapSet(schemaDefaultRows, tableId);
+        mapSet(schemaRowCache, tableId);
       },
     );
   const setValidTables = (tables) =>
@@ -1361,10 +1385,6 @@ const createStore = () => {
       mapSet(rowMap, cellId, newCell);
     }
   };
-  const setValidRowTransaction = (tableId, rowId, row) =>
-    transaction(() =>
-      setValidRow(tableId, getOrCreateTable(tableId), rowId, row),
-    );
   const setCellIntoDefaultRow = (tableId, tableMap, rowId, cellId, validCell) =>
     ifNotUndefined(
       mapGet(tableMap, rowId),
@@ -1374,7 +1394,7 @@ const createStore = () => {
           tableId,
           tableMap,
           rowId,
-          addDefaultsToRow({[cellId]: validCell}, tableId),
+          addDefaultsToRow({[cellId]: validCell}, tableId, rowId),
         ),
     );
   const getNewRowId = (tableMap) => {
@@ -1390,7 +1410,7 @@ const createStore = () => {
   const delValidRow = (tableId, tableMap, rowId) =>
     setValidRow(tableId, tableMap, rowId, {}, true);
   const delValidCell = (tableId, table, rowId, row, cellId, forceDel) => {
-    const defaultCell = mapGet(schemaDefaultRows, tableId)?.[cellId];
+    const defaultCell = mapGet(mapGet(schemaRowCache, tableId)?.[0], cellId);
     if (!isUndefined(defaultCell) && !forceDel) {
       return setValidCell(tableId, rowId, row, cellId, defaultCell);
     }
@@ -1424,6 +1444,17 @@ const createStore = () => {
       cellId,
       oldCell,
     );
+  const cellInvalid = (tableId, rowId, cellId, invalidCell, defaultedCell) => {
+    arrayPush(
+      mapEnsure(
+        mapEnsure(mapEnsure(invalidCells, tableId, mapNew()), rowId, mapNew()),
+        cellId,
+        [],
+      ),
+      invalidCell,
+    );
+    return defaultedCell;
+  };
   const getCellChange = (tableId, rowId, cellId) => {
     const changedRow = mapGet(mapGet(changedCells, tableId), rowId);
     const newCell = getCell(tableId, rowId, cellId);
@@ -1431,80 +1462,103 @@ const createStore = () => {
       ? [true, mapGet(changedRow, cellId), newCell]
       : [false, newCell, newCell];
   };
+  const callInvalidCellListeners = (mutator) =>
+    !collIsEmpty(invalidCells) && !collIsEmpty(invalidCellListeners[mutator])
+      ? collForEach(
+          mutator
+            ? mapClone(invalidCells, (table) => mapClone(table, mapClone))
+            : invalidCells,
+          (rows, tableId) =>
+            collForEach(rows, (cells, rowId) =>
+              collForEach(cells, (invalidCell, cellId) =>
+                callListeners(
+                  invalidCellListeners[mutator],
+                  [tableId, rowId, cellId],
+                  invalidCell,
+                ),
+              ),
+            ),
+        )
+      : 0;
   const callListenersForChanges = (mutator) => {
-    const emptyIdListeners =
-      collIsEmpty(cellIdsListeners[mutator]) &&
-      collIsEmpty(rowIdsListeners[mutator]) &&
-      collIsEmpty(tableIdsListeners[mutator]);
-    const emptyOtherListeners =
-      collIsEmpty(cellListeners[mutator]) &&
-      collIsEmpty(rowListeners[mutator]) &&
-      collIsEmpty(tableListeners[mutator]) &&
-      collIsEmpty(tablesListeners[mutator]);
-    if (emptyIdListeners && emptyOtherListeners) {
-      return;
-    }
-    const changes = mutator
-      ? [
-          mapClone(changedTableIds),
-          mapClone(changedRowIds, mapClone),
-          mapClone(changedCellIds, (table) => mapClone(table, mapClone)),
-          mapClone(changedCells, (table) => mapClone(table, mapClone)),
-        ]
-      : [changedTableIds, changedRowIds, changedCellIds, changedCells];
-    if (!emptyIdListeners) {
-      collForEach(changes[2], (rowCellIds, tableId) =>
-        collForEach(rowCellIds, (changedIds, rowId) => {
-          if (!collIsEmpty(changedIds)) {
-            callListeners(cellIdsListeners[mutator], [tableId, rowId]);
+    if (!collIsEmpty(changedCells)) {
+      const emptyIdListeners =
+        collIsEmpty(cellIdsListeners[mutator]) &&
+        collIsEmpty(rowIdsListeners[mutator]) &&
+        collIsEmpty(tableIdsListeners[mutator]);
+      const emptyOtherListeners =
+        collIsEmpty(cellListeners[mutator]) &&
+        collIsEmpty(rowListeners[mutator]) &&
+        collIsEmpty(tableListeners[mutator]) &&
+        collIsEmpty(tablesListeners[mutator]);
+      if (!(emptyIdListeners && emptyOtherListeners)) {
+        const changes = mutator
+          ? [
+              mapClone(changedTableIds),
+              mapClone(changedRowIds, mapClone),
+              mapClone(changedCellIds, (table) => mapClone(table, mapClone)),
+              mapClone(changedCells, (table) => mapClone(table, mapClone)),
+            ]
+          : [changedTableIds, changedRowIds, changedCellIds, changedCells];
+        if (!emptyIdListeners) {
+          collForEach(changes[2], (rowCellIds, tableId) =>
+            collForEach(rowCellIds, (changedIds, rowId) => {
+              if (!collIsEmpty(changedIds)) {
+                callListeners(cellIdsListeners[mutator], [tableId, rowId]);
+              }
+            }),
+          );
+          collForEach(changes[1], (changedIds, tableId) => {
+            if (!collIsEmpty(changedIds)) {
+              callListeners(rowIdsListeners[mutator], [tableId]);
+            }
+          });
+          if (!collIsEmpty(changes[0])) {
+            callListeners(tableIdsListeners[mutator]);
           }
-        }),
-      );
-      collForEach(changes[1], (changedIds, tableId) => {
-        if (!collIsEmpty(changedIds)) {
-          callListeners(rowIdsListeners[mutator], [tableId]);
         }
-      });
-      if (!collIsEmpty(changes[0])) {
-        callListeners(tableIdsListeners[mutator]);
-      }
-    }
-    if (!emptyOtherListeners) {
-      let tablesChanged;
-      collForEach(changes[3], (rows, tableId) => {
-        let tableChanged;
-        collForEach(rows, (cells, rowId) => {
-          let rowChanged;
-          collForEach(cells, (oldCell, cellId) => {
-            const newCell = getCell(tableId, rowId, cellId);
-            if (newCell !== oldCell) {
-              callListeners(
-                cellListeners[mutator],
-                [tableId, rowId, cellId],
-                newCell,
-                oldCell,
-                getCellChange,
-              );
-              tablesChanged = tableChanged = rowChanged = 1;
+        if (!emptyOtherListeners) {
+          let tablesChanged;
+          collForEach(changes[3], (rows, tableId) => {
+            let tableChanged;
+            collForEach(rows, (cells, rowId) => {
+              let rowChanged;
+              collForEach(cells, (oldCell, cellId) => {
+                const newCell = getCell(tableId, rowId, cellId);
+                if (newCell !== oldCell) {
+                  callListeners(
+                    cellListeners[mutator],
+                    [tableId, rowId, cellId],
+                    newCell,
+                    oldCell,
+                    getCellChange,
+                  );
+                  tablesChanged = tableChanged = rowChanged = 1;
+                }
+              });
+              if (rowChanged) {
+                callListeners(
+                  rowListeners[mutator],
+                  [tableId, rowId],
+                  getCellChange,
+                );
+              }
+            });
+            if (tableChanged) {
+              callListeners(tableListeners[mutator], [tableId], getCellChange);
             }
           });
-          if (rowChanged) {
-            callListeners(
-              rowListeners[mutator],
-              [tableId, rowId],
-              getCellChange,
-            );
+          if (tablesChanged) {
+            callListeners(tablesListeners[mutator], [], getCellChange);
           }
-        });
-        if (tableChanged) {
-          callListeners(tableListeners[mutator], [tableId], getCellChange);
         }
-      });
-      if (tablesChanged) {
-        callListeners(tablesListeners[mutator], [], getCellChange);
       }
     }
   };
+  const fluentTransaction = (actions) => {
+    transaction(actions);
+    return store;
+  };
   const getTables = () =>
     mapToObj(tablesMap, (tableMap) => mapToObj(tableMap, mapToObj));
   const getTableIds = () => mapKeys(tablesMap);
@@ -1523,52 +1577,52 @@ const createStore = () => {
     collHas(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
   const getJson = () => jsonString(tablesMap);
   const getSchemaJson = () => jsonString(schemaMap);
-  const setTables = (tables) => {
-    if (validateTables(tables)) {
-      transaction(() => setValidTables(tables));
-    }
-    return store;
-  };
-  const setTable = (tableId, table) => {
-    if (validateTable(table, tableId)) {
-      transaction(() => setValidTable(tableId, table));
-    }
-    return store;
-  };
-  const setRow = (tableId, rowId, row) => {
-    if (validateRow(tableId, row)) {
-      setValidRowTransaction(tableId, rowId, row);
-    }
-    return store;
-  };
-  const addRow = (tableId, row) => {
-    let rowId = void 0;
-    if (validateRow(tableId, row)) {
-      rowId = getNewRowId(mapGet(tablesMap, tableId));
-      setValidRowTransaction(tableId, rowId, row);
-    }
-    return rowId;
-  };
-  const setPartialRow = (tableId, rowId, partialRow) => {
-    if (validateRow(tableId, partialRow, 1)) {
-      transaction(() => {
+  const setTables = (tables) =>
+    fluentTransaction(() =>
+      validateTables(tables) ? setValidTables(tables) : 0,
+    );
+  const setTable = (tableId, table) =>
+    fluentTransaction(() =>
+      validateTable(table, tableId) ? setValidTable(tableId, table) : 0,
+    );
+  const setRow = (tableId, rowId, row) =>
+    fluentTransaction(() =>
+      validateRow(tableId, rowId, row)
+        ? setValidRow(tableId, getOrCreateTable(tableId), rowId, row)
+        : 0,
+    );
+  const addRow = (tableId, row) =>
+    transaction(() => {
+      let rowId = void 0;
+      if (validateRow(tableId, rowId, row)) {
+        setValidRow(
+          tableId,
+          getOrCreateTable(tableId),
+          (rowId = getNewRowId(mapGet(tablesMap, tableId))),
+          row,
+        );
+      }
+      return rowId;
+    });
+  const setPartialRow = (tableId, rowId, partialRow) =>
+    fluentTransaction(() => {
+      if (validateRow(tableId, rowId, partialRow, 1)) {
         const table = getOrCreateTable(tableId);
         objForEach(partialRow, (cell, cellId) =>
           setCellIntoDefaultRow(tableId, table, rowId, cellId, cell),
         );
-      });
-    }
-    return store;
-  };
-  const setCell = (tableId, rowId, cellId, cell) => {
-    ifNotUndefined(
-      getValidatedCell(
-        tableId,
-        cellId,
-        isFunction(cell) ? cell(getCell(tableId, rowId, cellId)) : cell,
-      ),
-      (validCell) =>
-        transaction(() =>
+      }
+    });
+  const setCell = (tableId, rowId, cellId, cell) =>
+    fluentTransaction(() =>
+      ifNotUndefined(
+        getValidatedCell(
+          tableId,
+          rowId,
+          cellId,
+          isFunction(cell) ? cell(getCell(tableId, rowId, cellId)) : cell,
+        ),
+        (validCell) =>
           setCellIntoDefaultRow(
             tableId,
             getOrCreateTable(tableId),
@@ -1576,77 +1630,74 @@ const createStore = () => {
             cellId,
             validCell,
           ),
-        ),
+      ),
     );
-    return store;
-  };
   const setJson = (json) => {
     try {
       json === EMPTY_OBJECT ? delTables() : setTables(jsonParse(json));
     } catch {}
     return store;
   };
-  const setSchema = (schema) => {
-    if ((hasSchema = validateSchema(schema))) {
-      setValidSchema(schema);
-      if (!collIsEmpty(tablesMap)) {
-        const tables = getTables();
-        delTables();
-        setTables(tables);
-      }
-    }
-    return store;
-  };
-  const delTables = () => {
-    transaction(() => setValidTables({}));
-    return store;
-  };
-  const delTable = (tableId) => {
-    if (collHas(tablesMap, tableId)) {
-      transaction(() => delValidTable(tableId));
-    }
-    return store;
-  };
-  const delRow = (tableId, rowId) => {
-    ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) => {
-      if (collHas(tableMap, rowId)) {
-        transaction(() => delValidRow(tableId, tableMap, rowId));
+  const setSchema = (schema) =>
+    fluentTransaction(() => {
+      if ((hasSchema = validateSchema(schema))) {
+        setValidSchema(schema);
+        if (!collIsEmpty(tablesMap)) {
+          const tables = getTables();
+          delTables();
+          setTables(tables);
+        }
       }
     });
-    return store;
-  };
-  const delCell = (tableId, rowId, cellId, forceDel) => {
-    ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) =>
-      ifNotUndefined(mapGet(tableMap, rowId), (rowMap) => {
-        if (collHas(rowMap, cellId)) {
-          transaction(() =>
-            delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
-          );
-        }
-      }),
+  const delTables = () => fluentTransaction(() => setValidTables({}));
+  const delTable = (tableId) =>
+    fluentTransaction(() =>
+      collHas(tablesMap, tableId) ? delValidTable(tableId) : 0,
     );
-    return store;
-  };
-  const delSchema = () => {
-    setValidSchema({});
-    hasSchema = false;
-    return store;
-  };
+  const delRow = (tableId, rowId) =>
+    fluentTransaction(() =>
+      ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) =>
+        collHas(tableMap, rowId) ? delValidRow(tableId, tableMap, rowId) : 0,
+      ),
+    );
+  const delCell = (tableId, rowId, cellId, forceDel) =>
+    fluentTransaction(() =>
+      ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) =>
+        ifNotUndefined(mapGet(tableMap, rowId), (rowMap) =>
+          collHas(rowMap, cellId)
+            ? delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel)
+            : 0,
+        ),
+      ),
+    );
+  const delSchema = () =>
+    fluentTransaction(() => {
+      setValidSchema({});
+      hasSchema = false;
+    });
   const transaction = (actions) => {
     if (transactions == -1) {
       return;
     }
     transactions++;
-    const result = actions();
+    const result = actions?.();
     transactions--;
     if (transactions == 0) {
       transactions = 1;
+      callInvalidCellListeners(1);
       callListenersForChanges(1);
       transactions = -1;
+      callInvalidCellListeners(0);
       callListenersForChanges(0);
       transactions = 0;
       arrayForEach(
-        [changedCells, changedTableIds, changedRowIds, changedCellIds],
+        [
+          changedCells,
+          invalidCells,
+          changedTableIds,
+          changedRowIds,
+          changedCellIds,
+        ],
         collClear,
       );
     }
@@ -1686,6 +1737,12 @@ const createStore = () => {
       rowId,
       cellId,
     ]);
+  const addInvalidCellListener = (tableId, rowId, cellId, listener, mutator) =>
+    addListener(listener, invalidCellListeners[mutator ? 1 : 0], [
+      tableId,
+      rowId,
+      cellId,
+    ]);
   const callListener = (listenerId) => {
     callListenerImpl(listenerId, [getTableIds, getRowIds, getCellIds], (ids) =>
       isUndefined(ids[2]) ? [] : Array(2).fill(getCell(...ids)),
@@ -1743,6 +1800,7 @@ const createStore = () => {
     addRowListener,
     addCellIdsListener,
     addCellListener,
+    addInvalidCellListener,
     callListener,
     delListener,
     getListenerStats,

package/lib/metrics.d.ts

@@ -37,7 +37,7 @@ export type Metric = number;
 export type MetricCallback = (metricId: Id, metric?: Metric) => void;
 
 /**
- * The Aggregate type describes a custom function that takes an array or numbers
+ * The Aggregate type describes a custom function that takes an array of numbers
  * and returns an aggregate that is used as a Metric.
  *
  * There are a number of common predefined aggregators, such as for counting,