tinybase 1.1.0-beta.0 → 1.2.0-beta.0

package/lib/debug/store.js

@@ -8,6 +8,7 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 
+const arrayPair = (value) => [value, value];
 const arrayHas = (array, value) => array.includes(value);
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayLength = (array) => array.length;
@@ -69,10 +70,14 @@ const mapEnsure = (map, key, defaultValue, onWillAdd) => {
   }
   return mapGet(map, key);
 };
-const mapToObj = (map, childMapper) => {
+const mapToObj = (map, childMapper, childExclude) => {
   const obj = {};
   const mapper = childMapper ?? ((mapValue) => mapValue);
-  collForEach(map, (value, key) => (obj[key] = mapper(value)));
+  collForEach(map, (value, key) =>
+    ifNotUndefined(mapper(value), (mappedValue) =>
+      childExclude?.(mappedValue) ? 0 : (obj[key] = mappedValue),
+    ),
+  );
   return obj;
 };
 const mapClone = (map, childMapper) => {
@@ -81,6 +86,7 @@ const mapClone = (map, childMapper) => {
   collForEach(map, (value, key) => map2.set(key, mapper(value)));
   return map2;
 };
+const mapClone2 = (map) => mapClone(map, mapClone);
 
 const object = Object;
 const objIds = object.keys;
@@ -188,8 +194,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) => {
@@ -211,7 +218,7 @@ const createStore = () => {
   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);
@@ -241,13 +248,18 @@ 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, rowId) => validateRow(tableId, rowId, row));
+    (!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),
+      skipDefaults ? row : addDefaultsToRow(row, tableId, rowId),
       (cell, cellId) =>
         ifNotUndefined(
           getValidatedCell(tableId, rowId, cellId, cell),
@@ -257,6 +269,7 @@ const createStore = () => {
           },
           () => false,
         ),
+      () => cellInvalid(tableId, rowId),
     );
   const getValidatedCell = (tableId, rowId, cellId, cell) =>
     hasSchema
@@ -266,17 +279,26 @@ const createStore = () => {
             getCellType(cell) != cellSchema[TYPE]
               ? cellInvalid(tableId, rowId, cellId, cell, cellSchema[DEFAULT])
               : cell,
+          () => cellInvalid(tableId, rowId, cellId, cell),
         )
       : isUndefined(getCellType(cell))
       ? 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;
   };
@@ -285,7 +307,8 @@ const createStore = () => {
       schemaMap,
       schema,
       (_schema, tableId, tableSchema) => {
-        const defaultRow = {};
+        const rowDefaulted = mapNew();
+        const rowNonDefaulted = setNew();
         transformMap(
           mapEnsure(schemaMap, tableId, mapNew()),
           tableSchema,
@@ -293,15 +316,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) =>
@@ -337,14 +361,10 @@ const createStore = () => {
     }
     const oldCell = mapGet(rowMap, cellId);
     if (newCell !== oldCell) {
-      cellChanged(tableId, rowId, cellId, oldCell);
+      cellChanged(tableId, rowId, cellId, oldCell, newCell);
       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),
@@ -354,7 +374,7 @@ const createStore = () => {
           tableId,
           tableMap,
           rowId,
-          addDefaultsToRow({[cellId]: validCell}, tableId),
+          addDefaultsToRow({[cellId]: validCell}, tableId, rowId),
         ),
     );
   const getNewRowId = (tableMap) => {
@@ -370,7 +390,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);
     }
@@ -398,12 +418,12 @@ const createStore = () => {
       cellId,
       added,
     );
-  const cellChanged = (tableId, rowId, cellId, oldCell) =>
-    mapEnsure(
+  const cellChanged = (tableId, rowId, cellId, oldCell, newCell) =>
+    (mapEnsure(
       mapEnsure(mapEnsure(changedCells, tableId, mapNew()), rowId, mapNew()),
       cellId,
-      oldCell,
-    );
+      [oldCell],
+    )[1] = newCell);
   const cellInvalid = (tableId, rowId, cellId, invalidCell, defaultedCell) => {
     arrayPush(
       mapEnsure(
@@ -415,108 +435,108 @@ const createStore = () => {
     );
     return defaultedCell;
   };
-  const getCellChange = (tableId, rowId, cellId) => {
-    const changedRow = mapGet(mapGet(changedCells, tableId), rowId);
-    const newCell = getCell(tableId, rowId, cellId);
-    return collHas(changedRow, cellId)
-      ? [true, mapGet(changedRow, cellId), newCell]
-      : [false, newCell, newCell];
-  };
-  const callInvalidCellListeners = (mutator) => {
-    if (!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,
+  const getCellChange = (tableId, rowId, cellId) =>
+    ifNotUndefined(
+      mapGet(mapGet(mapGet(changedCells, tableId), rowId), cellId),
+      ([oldCell, newCell]) => [true, oldCell, newCell],
+      () => [false, ...arrayPair(getCell(tableId, rowId, cellId))],
+    );
+  const callInvalidCellListeners = (mutator) =>
+    !collIsEmpty(invalidCells) && !collIsEmpty(invalidCellListeners[mutator])
+      ? collForEach(
+          mutator ? mapClone(invalidCells, mapClone2) : 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),
+              mapClone2(changedRowIds),
+              mapClone(changedCellIds, mapClone2),
+              mapClone(changedCells, mapClone2),
+            ]
+          : [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, newCell], 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));
+    mapToObj(tablesMap, (table) => mapToObj(table, mapToObj));
   const getTableIds = () => mapKeys(tablesMap);
   const getTable = (tableId) => mapToObj(mapGet(tablesMap, tableId), mapToObj);
   const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, tableId));
@@ -533,56 +553,52 @@ const createStore = () => {
     collHas(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
   const getJson = () => jsonString(tablesMap);
   const getSchemaJson = () => jsonString(schemaMap);
-  const setTables = (tables) => {
-    validateTables(tables)
-      ? transaction(() => setValidTables(tables))
-      : transaction();
-    return store;
-  };
-  const setTable = (tableId, table) => {
-    validateTable(table, tableId)
-      ? transaction(() => setValidTable(tableId, table))
-      : transaction();
-    return store;
-  };
-  const setRow = (tableId, rowId, row) => {
-    validateRow(tableId, rowId, row)
-      ? setValidRowTransaction(tableId, rowId, row)
-      : transaction();
-    return store;
-  };
-  const addRow = (tableId, row) => {
-    let rowId = void 0;
-    validateRow(tableId, rowId, row)
-      ? setValidRowTransaction(
+  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,
-        )
-      : transaction();
-    return rowId;
-  };
-  const setPartialRow = (tableId, rowId, partialRow) => {
-    validateRow(tableId, rowId, partialRow, 1)
-      ? transaction(() => {
-          const table = getOrCreateTable(tableId);
-          objForEach(partialRow, (cell, cellId) =>
-            setCellIntoDefaultRow(tableId, table, rowId, cellId, cell),
-          );
-        })
-      : transaction();
-    return store;
-  };
-  const setCell = (tableId, rowId, cellId, cell) => {
-    ifNotUndefined(
-      getValidatedCell(
-        tableId,
-        rowId,
-        cellId,
-        isFunction(cell) ? cell(getCell(tableId, rowId, cellId)) : cell,
-      ),
-      (validCell) =>
-        transaction(() =>
+        );
+      }
+      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),
+        );
+      }
+    });
+  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),
@@ -590,64 +606,52 @@ const createStore = () => {
             cellId,
             validCell,
           ),
-        ),
-      transaction,
+      ),
     );
-    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 transaction = (actions) => {
+  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, doRollback) => {
     if (transactions == -1) {
       return;
     }
@@ -659,6 +663,38 @@ const createStore = () => {
       callInvalidCellListeners(1);
       callListenersForChanges(1);
       transactions = -1;
+      if (
+        doRollback?.(
+          mapToObj(
+            changedCells,
+            (table) =>
+              mapToObj(
+                table,
+                (row) =>
+                  mapToObj(
+                    row,
+                    void 0,
+                    ([oldCell, newCell]) => oldCell === newCell,
+                  ),
+                objIsEmpty,
+              ),
+            objIsEmpty,
+          ),
+          mapToObj(invalidCells, (map) => mapToObj(map, mapToObj)),
+        )
+      ) {
+        transactions = 1;
+        collForEach(changedCells, (table, tableId) =>
+          collForEach(table, (row, rowId) =>
+            collForEach(row, ([oldCell], cellId) =>
+              isUndefined(oldCell)
+                ? delCell(tableId, rowId, cellId, true)
+                : setCell(tableId, rowId, cellId, oldCell),
+            ),
+          ),
+        );
+        transactions = -1;
+      }
       callInvalidCellListeners(0);
       callListenersForChanges(0);
       transactions = 0;
@@ -717,7 +753,7 @@ const createStore = () => {
     ]);
   const callListener = (listenerId) => {
     callListenerImpl(listenerId, [getTableIds, getRowIds, getCellIds], (ids) =>
-      isUndefined(ids[2]) ? [] : Array(2).fill(getCell(...ids)),
+      isUndefined(ids[2]) ? [] : arrayPair(getCell(...ids)),
     );
     return store;
   };