tinybase 1.0.3 → 1.1.0-beta.1

package/lib/debug/store.js

@@ -15,6 +15,8 @@ const arrayIsEmpty = (array) => arrayLength(array) == 0;
 const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const arrayFilter = (array, cb) => array.filter(cb);
 const arrayFromSecond = (ids) => ids.slice(1);
+const arrayPush = (array, value) => array.push(value);
+const arrayPop = (array) => array.pop();
 
 const jsonString = (obj) =>
   JSON.stringify(obj, (_key, value) =>
@@ -125,7 +127,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;
@@ -146,7 +148,7 @@ const getListenerFunctions = (getThing) => {
         forDeepSet(collDel)(deepSet, id, ...idOrNulls);
         mapSet(allListeners, id);
         if (arrayLength(listenerPool) < 1e3) {
-          listenerPool.push(id);
+          arrayPush(listenerPool, id);
         }
         return idOrNulls;
       },
@@ -186,8 +188,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) => {
@@ -207,6 +210,7 @@ const createStore = () => {
   const changedRowIds = mapNew();
   const changedCellIds = mapNew();
   const changedCells = mapNew();
+  const invalidCells = mapNew();
   const schemaMap = mapNew();
   const schemaDefaultRows = mapNew();
   const tablesMap = mapNew();
@@ -217,6 +221,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) =>
@@ -237,32 +242,41 @@ 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(
+      table,
+      (row, rowId) => validateRow(tableId, rowId, row),
+      () => cellInvalid(tableId),
+    );
+  const validateRow = (tableId, rowId, row, skipDefaults) =>
     validate(
       skipDefaults ? row : addDefaultsToRow(row, tableId),
       (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) =>
@@ -335,10 +349,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),
@@ -398,6 +408,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);
@@ -405,80 +426,106 @@ 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) => {
+    let emptyIdListeners, emptyOtherListeners;
+    if (
+      !collIsEmpty(changedCells) &&
+      !(
+        (emptyIdListeners =
+          collIsEmpty(cellIdsListeners[mutator]) &&
+          collIsEmpty(rowIdsListeners[mutator]) &&
+          collIsEmpty(tableIdsListeners[mutator])) &&
+        (emptyOtherListeners =
+          collIsEmpty(cellListeners[mutator]) &&
+          collIsEmpty(rowListeners[mutator]) &&
+          collIsEmpty(tableListeners[mutator]) &&
+          collIsEmpty(tablesListeners[mutator]))
+      )
+    ) {
+      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(cellIdsListeners[mutator], [tableId, rowId]);
+            callListeners(rowIdsListeners[mutator], [tableId]);
           }
-        }),
-      );
-      collForEach(changes[1], (changedIds, tableId) => {
-        if (!collIsEmpty(changedIds)) {
-          callListeners(rowIdsListeners[mutator], [tableId]);
+        });
+        if (!collIsEmpty(changes[0])) {
+          callListeners(tableIdsListeners[mutator]);
         }
-      });
-      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) {
+      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(
-                cellListeners[mutator],
-                [tableId, rowId, cellId],
-                newCell,
-                oldCell,
+                rowListeners[mutator],
+                [tableId, rowId],
                 getCellChange,
               );
-              tablesChanged = tableChanged = rowChanged = 1;
             }
           });
-          if (rowChanged) {
-            callListeners(
-              rowListeners[mutator],
-              [tableId, rowId],
-              getCellChange,
-            );
+          if (tableChanged) {
+            callListeners(tableListeners[mutator], [tableId], getCellChange);
           }
         });
-        if (tableChanged) {
-          callListeners(tableListeners[mutator], [tableId], getCellChange);
+        if (tablesChanged) {
+          callListeners(tablesListeners[mutator], [], 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);
@@ -490,58 +537,59 @@ const createStore = () => {
     mapKeys(mapGet(mapGet(tablesMap, tableId), rowId));
   const getCell = (tableId, rowId, cellId) =>
     mapGet(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
+  const hasTables = () => !collIsEmpty(tablesMap);
   const hasTable = (tableId) => collHas(tablesMap, tableId);
   const hasRow = (tableId, rowId) => collHas(mapGet(tablesMap, tableId), rowId);
   const hasCell = (tableId, rowId, cellId) =>
     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),
@@ -549,77 +597,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,
       );
     }
@@ -659,6 +704,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)),
@@ -686,6 +737,7 @@ const createStore = () => {
     getRow,
     getCellIds,
     getCell,
+    hasTables,
     hasTable,
     hasRow,
     hasCell,
@@ -715,6 +767,7 @@ const createStore = () => {
     addRowListener,
     addCellIdsListener,
     addCellListener,
+    addInvalidCellListener,
     callListener,
     delListener,
     getListenerStats,