tinybase 8.0.0-beta.3 → 8.0.0

package/omni/index.js

@@ -121,6 +121,14 @@ const structuredClone = GLOBAL.structuredClone;
 const errorNew = (message) => {
   throw new Error(message);
 };
+const tryReturn = (tryF, catchReturn) => {
+  try {
+    return tryF();
+  } catch {
+    /* istanbul ignore next */
+    return catchReturn;
+  }
+};
 const tryCatch = async (action, then1, then2) => {
   try {
     return await action();
@@ -1578,10 +1586,24 @@ const createStore = () => {
     );
   const setOrDelTables = (tables) =>
     objIsEmpty(tables) ? delTables() : setTables(tables);
-  const setOrDelCell = (tableId, rowId, cellId, cell, skipMiddleware) =>
+  const setOrDelCell = (
+    tableId,
+    rowId,
+    cellId,
+    cell,
+    skipMiddleware,
+    skipRowMiddleware,
+  ) =>
     isUndefined(cell)
       ? delCell(tableId, rowId, cellId, true, skipMiddleware)
-      : setCell(tableId, rowId, cellId, cell, skipMiddleware);
+      : setCell(
+          tableId,
+          rowId,
+          cellId,
+          cell,
+          skipMiddleware,
+          skipRowMiddleware,
+        );
   const setOrDelValues = (values) =>
     objIsEmpty(values) ? delValues() : setValues(values);
   const setOrDelValue = (valueId, value, skipMiddleware) =>
@@ -1681,6 +1703,30 @@ const createStore = () => {
         ),
       objIsEqual,
     );
+  const applyRowDirectly = (tableId, tableMap, rowId, row, skipMiddleware) => {
+    mapMatch(
+      mapEnsure(tableMap, rowId, () => {
+        rowIdsChanged(tableId, rowId, 1);
+        return mapNew();
+      }),
+      row,
+      (rowMap, cellId, cell) =>
+        ifNotUndefined(
+          getValidatedCell(tableId, rowId, cellId, cell),
+          (validCell) =>
+            setValidCell(
+              tableId,
+              rowId,
+              rowMap,
+              cellId,
+              validCell,
+              skipMiddleware,
+            ),
+        ),
+      (rowMap, cellId) =>
+        delValidCell(tableId, tableMap, rowId, rowMap, cellId, true),
+    );
+  };
   const setValidCell = (tableId, rowId, rowMap, cellId, cell, skipMiddleware) =>
     ifTransformed(
       cell,
@@ -2357,7 +2403,14 @@ const createStore = () => {
       tableId,
       rowId,
     );
-  const setCell = (tableId, rowId, cellId, cell, skipMiddleware) =>
+  const setCell = (
+    tableId,
+    rowId,
+    cellId,
+    cell,
+    skipMiddleware,
+    skipRowMiddleware,
+  ) =>
     fluentTransaction(
       (tableId2, rowId2, cellId2) =>
         ifNotUndefined(
@@ -2367,15 +2420,47 @@ const createStore = () => {
             cellId2,
             isFunction(cell) ? cell(getCell(tableId2, rowId2, cellId2)) : cell,
           ),
-          (validCell) =>
-            setCellIntoNewRow(
-              tableId2,
-              getOrCreateTable(tableId2),
-              rowId2,
-              cellId2,
-              validCell,
-              skipMiddleware,
-            ),
+          (validCell) => {
+            const tableMap = getOrCreateTable(tableId2);
+            ifNotUndefined(
+              skipMiddleware || skipRowMiddleware || !middleware[14]?.()
+                ? void 0
+                : middleware[3],
+              (willSetRow) => {
+                const existingRowMap = mapGet(tableMap, rowId2);
+                const prospectiveRow = {
+                  ...(existingRowMap ? mapToObj(existingRowMap) : {}),
+                  [cellId2]: validCell,
+                };
+                ifNotUndefined(
+                  whileMutating(() =>
+                    willSetRow(
+                      tableId2,
+                      rowId2,
+                      structuredClone(prospectiveRow),
+                    ),
+                  ),
+                  (row) =>
+                    applyRowDirectly(
+                      tableId2,
+                      tableMap,
+                      rowId2,
+                      row,
+                      skipMiddleware,
+                    ),
+                );
+              },
+              () =>
+                setCellIntoNewRow(
+                  tableId2,
+                  tableMap,
+                  rowId2,
+                  cellId2,
+                  validCell,
+                  skipMiddleware,
+                ),
+            );
+          },
         ),
       tableId,
       rowId,
@@ -2424,7 +2509,14 @@ const createStore = () => {
                   isUndefined(row)
                     ? delRow(tableId, rowId)
                     : objMap(row, (cell, cellId) =>
-                        setOrDelCell(tableId, rowId, cellId, cell),
+                        setOrDelCell(
+                          tableId,
+                          rowId,
+                          cellId,
+                          cell,
+                          void 0,
+                          true,
+                        ),
                       ),
                 ),
           );
@@ -2587,37 +2679,6 @@ const createStore = () => {
     mapToObj3(changedCellIds),
     mapToObj(changedValueIds),
   ];
-  const doDidSetRows = () => {
-    if (middleware[14]) {
-      const changedCells2 = clonedChangedCells(changedCells);
-      collForEach(changedCells2, (rows, tableId) =>
-        collForEach(rows, (cells, rowId) => {
-          if (
-            !arrayEvery(
-              collValues(cells),
-              ([oldCell, newCell]) => oldCell === newCell,
-            )
-          ) {
-            const newRow = getRow(tableId, rowId);
-            const oldRow = objMerge(newRow);
-            collForEach(cells, ([oldCell], cellId) =>
-              isUndefined(oldCell)
-                ? objDel(oldRow, cellId)
-                : (oldRow[cellId] = oldCell),
-            );
-            const didSetRow = middleware[14](tableId, rowId, oldRow, newRow);
-            if (!objIsEqual(didSetRow, newRow)) {
-              const setOrDelRow = objMap(newRow, () => void 0);
-              objMap(didSetRow, (cell, cellId) => (setOrDelRow[cellId] = cell));
-              objMap(setOrDelRow, (cell, cellId) =>
-                setOrDelCell(tableId, rowId, cellId, cell, true),
-              );
-            }
-          }
-        }),
-      );
-    }
-  };
   const finishTransaction = (doRollback) => {
     if (transactions > 0) {
       transactions--;
@@ -2627,7 +2688,6 @@ const createStore = () => {
           callInvalidCellListeners(1);
           if (!collIsEmpty(changedCells)) {
             callTabularListenersForChanges(1);
-            doDidSetRows();
           }
           callInvalidValueListeners(1);
           if (!collIsEmpty(changedValues)) {
@@ -2798,7 +2858,7 @@ const createStore = () => {
     willDelValues,
     willDelValue,
     willApplyChanges,
-    didSetRow,
+    hasWillSetRowCallbacks,
   ) =>
     (middleware = [
       willSetContent,
@@ -2815,7 +2875,7 @@ const createStore = () => {
       willDelValues,
       willDelValue,
       willApplyChanges,
-      didSetRow,
+      hasWillSetRowCallbacks,
     ]);
   const setInternalListeners = (
     preStartTransaction,
@@ -3721,7 +3781,6 @@ const createMiddleware = getCreateFunction((store) => {
   const willDelValuesCallbacks = [];
   const willDelValueCallbacks = [];
   const willApplyChangesCallbacks = [];
-  const didSetRowCallbacksMap = mapNew();
   const willSetContent = (content) =>
     reduceCallbacks(willSetContentCallbacks, content);
   const willSetTables = (tables) =>
@@ -3748,17 +3807,6 @@ const createMiddleware = getCreateFunction((store) => {
     everyCallback(willDelValueCallbacks, valueId);
   const willApplyChanges = (changes) =>
     reduceCallbacks(willApplyChangesCallbacks, changes);
-  const didSetRow = (tableId, rowId, oldRow, newRow) =>
-    ifNotUndefined(
-      mapGet(didSetRowCallbacksMap, tableId),
-      (callbacks) =>
-        arrayReduce(
-          callbacks,
-          (current, callback) => callback(tableId, rowId, oldRow, current),
-          newRow,
-        ),
-      () => newRow,
-    );
   const getStore = () => store;
   const addWillSetContentCallback = addCallback(willSetContentCallbacks);
   const addWillSetTablesCallback = addCallback(willSetTablesCallbacks);
@@ -3774,13 +3822,6 @@ const createMiddleware = getCreateFunction((store) => {
   const addWillDelValuesCallback = addCallback(willDelValuesCallbacks);
   const addWillDelValueCallback = addCallback(willDelValueCallbacks);
   const addWillApplyChangesCallback = addCallback(willApplyChangesCallbacks);
-  const addDidSetRowCallback = (tableId, callback) =>
-    fluent(() =>
-      arrayPush(
-        mapEnsure(didSetRowCallbacksMap, tableId, () => []),
-        callback,
-      ),
-    );
   const destroy = () => {};
   const middleware = objFreeze({
     getStore,
@@ -3798,7 +3839,6 @@ const createMiddleware = getCreateFunction((store) => {
     addWillDelValuesCallback,
     addWillDelValueCallback,
     addWillApplyChangesCallback,
-    addDidSetRowCallback,
     destroy,
   });
   store._[4](
@@ -3816,7 +3856,7 @@ const createMiddleware = getCreateFunction((store) => {
     willDelValues,
     willDelValue,
     willApplyChanges,
-    didSetRow,
+    () => willSetRowCallbacks.length > 0,
   );
   return middleware;
 });
@@ -9721,15 +9761,17 @@ const EditableThing = ({
   const [stringThing, setStringThing] = useState();
   const [numberThing, setNumberThing] = useState();
   const [booleanThing, setBooleanThing] = useState();
-  const [objectThingJson, setObjectThingJson] = useState(EMPTY_STRING);
-  const [arrayThingJson, setArrayThingJson] = useState(EMPTY_STRING);
+  const [objectThing, setObjectThing] = useState('{}');
+  const [arrayThing, setArrayThing] = useState('[]');
+  const [objectClassName, setObjectClassName] = useState('');
+  const [arrayClassName, setArrayClassName] = useState('');
   if (currentThing !== thing) {
     setThingType(getCellOrValueType(thing));
     setCurrentThing(thing);
     if (isObject(thing)) {
-      setObjectThingJson(jsonString(thing));
+      setObjectThing(jsonString(thing));
     } else if (isArray(thing)) {
-      setArrayThingJson(jsonString(thing));
+      setArrayThing(jsonString(thing));
     } else {
       setStringThing(String(thing));
       setNumberThing(Number(thing) || 0);
@@ -9744,6 +9786,22 @@ const EditableThing = ({
     },
     [onThingChange],
   );
+  const handleJsonThingChange = useCallback(
+    (value, setTypedThing, isThing, setTypedClassName) => {
+      setTypedThing(value);
+      try {
+        const object = jsonParse(value);
+        if (isThing(object)) {
+          setCurrentThing(object);
+          onThingChange(object);
+          setTypedClassName('');
+        }
+      } catch {
+        setTypedClassName('invalid');
+      }
+    },
+    [onThingChange],
+  );
   const handleTypeChange = useCallback(() => {
     if (!hasSchema?.()) {
       const nextType = getTypeCase(
@@ -9759,8 +9817,8 @@ const EditableThing = ({
         stringThing,
         numberThing,
         booleanThing,
-        objectThingJson ? jsonParse(objectThingJson) : {},
-        arrayThingJson ? jsonParse(arrayThingJson) : [],
+        tryReturn(() => jsonParse(objectThing), {}),
+        tryReturn(() => jsonParse(arrayThing), []),
       );
       setThingType(nextType);
       setCurrentThing(thing2);
@@ -9772,8 +9830,8 @@ const EditableThing = ({
     stringThing,
     numberThing,
     booleanThing,
-    objectThingJson,
-    arrayThingJson,
+    objectThing,
+    arrayThing,
     thingType,
   ]);
   const widget = getTypeCase(
@@ -9826,41 +9884,37 @@ const EditableThing = ({
       thingType,
     ),
     /* @__PURE__ */ jsx(
-      'textarea',
+      'input',
       {
-        value: objectThingJson,
+        value: objectThing,
+        className: objectClassName,
         onChange: useCallback(
-          (event) => {
-            const str = event[CURRENT_TARGET][_VALUE];
-            setObjectThingJson(str);
-            try {
-              const parsed = jsonParse(str);
-              if (isObject(parsed)) {
-                onThingChange(parsed);
-              }
-            } catch {}
-          },
-          [onThingChange],
+          (event) =>
+            handleJsonThingChange(
+              event[CURRENT_TARGET][_VALUE],
+              setObjectThing,
+              isObject,
+              setObjectClassName,
+            ),
+          [handleJsonThingChange],
         ),
       },
       thingType,
     ),
     /* @__PURE__ */ jsx(
-      'textarea',
+      'input',
       {
-        value: arrayThingJson,
+        value: arrayThing,
+        className: arrayClassName,
         onChange: useCallback(
-          (event) => {
-            const str = event[CURRENT_TARGET][_VALUE];
-            setArrayThingJson(str);
-            try {
-              const parsed = jsonParse(str);
-              if (isArray(parsed)) {
-                onThingChange(parsed);
-              }
-            } catch {}
-          },
-          [onThingChange],
+          (event) =>
+            handleJsonThingChange(
+              event[CURRENT_TARGET][_VALUE],
+              setArrayThing,
+              isArray,
+              setArrayClassName,
+            ),
+          [handleJsonThingChange],
         ),
       },
       thingType,