tinybase 8.0.0-beta.2 → 8.0.0-beta.4

package/omni/with-schemas/index.js

@@ -15,6 +15,8 @@ const STRING = getTypeOf(EMPTY_STRING);
 const BOOLEAN = getTypeOf(true);
 const NUMBER = getTypeOf(0);
 const FUNCTION$1 = getTypeOf(getTypeOf);
+const OBJECT = 'object';
+const ARRAY = 'array';
 const TRUE = 'true';
 const TYPE = 'type';
 const DEFAULT = 'default';
@@ -68,6 +70,7 @@ const EXTRA = 'extra';
 const T = 't';
 const V = 'v';
 const UNDEFINED = '\uFFFC';
+const JSON_PREFIX = '\uFFFD';
 const id = (key) => EMPTY_STRING + key;
 const strStartsWith = (str, prefix) => str.startsWith(prefix);
 const strEndsWith = (str, suffix) => str.endsWith(suffix);
@@ -118,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();
@@ -619,18 +630,12 @@ const createCheckpoints = getCreateFunction(
         collForEach(cellsDelta2, (table, tableId) =>
           collForEach(table, (row, rowId) =>
             collForEach(row, (oldNew, cellId) =>
-              store.setOrDelCell(
-                tableId,
-                rowId,
-                cellId,
-                oldNew[oldOrNew],
-                true,
-              ),
+              store._[5](tableId, rowId, cellId, oldNew[oldOrNew], true),
             ),
           ),
         );
         collForEach(valuesDelta2, (oldNew, valueId) =>
-          store.setOrDelValue(valueId, oldNew[oldOrNew], true),
+          store._[6](valueId, oldNew[oldOrNew], true),
         );
       });
       listening = 1;
@@ -1233,6 +1238,12 @@ const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
     return NULL;
   }
+  if (isArray(cellOrValue)) {
+    return ARRAY;
+  }
+  if (isObject(cellOrValue)) {
+    return OBJECT;
+  }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||
     (type == NUMBER && isFiniteNumber(cellOrValue))
@@ -1241,17 +1252,33 @@ const getCellOrValueType = (cellOrValue) => {
 };
 const isCellOrValueOrUndefined = (cellOrValue) =>
   isUndefined(cellOrValue) || !isUndefined(getCellOrValueType(cellOrValue));
-const getTypeCase = (type, stringCase, numberCase, booleanCase) =>
+const isJsonType = (type) => type == OBJECT || type == ARRAY;
+const encodeIfJson = (value) =>
+  isObject(value) || isArray(value) ? JSON_PREFIX + jsonString(value) : value;
+const isEncodedJson = (value) => isString(value) && value[0] == JSON_PREFIX;
+const decodeIfJson = (raw, _id, encoded) =>
+  !encoded && isEncodedJson(raw) ? jsonParse(slice(raw, 1)) : raw;
+const getTypeCase = (
+  type,
+  stringCase,
+  numberCase,
+  booleanCase,
+  objectCase,
+  arrayCase,
+) =>
   type == STRING
     ? stringCase
     : type == NUMBER
       ? numberCase
       : type == BOOLEAN
         ? booleanCase
-        : null;
+        : type == OBJECT
+          ? objectCase
+          : type == ARRAY
+            ? arrayCase
+            : null;
 
 const stampClone = ([value, hlc]) => stampNew(value, hlc);
-const stampCloneWithHash = ([value, hlc, hash]) => [value, hlc, hash];
 const stampNew = (value, hlc) => (hlc ? [value, hlc] : [value]);
 const stampNewWithHash = (value, hlc, hash) => [value, hlc, hash];
 const getStampHash = (stamp) => stamp[2];
@@ -1268,10 +1295,11 @@ const stampUpdate = (stamp, hlc, hash) => {
 };
 const stampNewObj = (hlc = EMPTY_STRING) => stampNew(objNew(), hlc);
 const stampNewMap = (hlc = EMPTY_STRING) => [mapNew(), hlc, 0];
-const stampMapToObjWithHash = (
-  [map, hlc, hash],
-  mapper = stampCloneWithHash,
-) => [mapToObj(map, mapper), hlc, hash];
+const stampMapToObjWithHash = ([map, hlc, hash], mapper) => [
+  mapToObj(map, mapper),
+  hlc,
+  hash,
+];
 const stampMapToObjWithoutHash = ([map, hlc], mapper = stampClone) =>
   stampNew(mapToObj(map, mapper), hlc);
 const stampValidate = (stamp, validateThing) =>
@@ -1378,15 +1406,19 @@ const createStore = () => {
       return false;
     }
     const type = schema[TYPE];
-    if (!isTypeStringOrBoolean(type) && type != NUMBER) {
+    if (!isTypeStringOrBoolean(type) && type != NUMBER && !isJsonType(type)) {
       return false;
     }
     const defaultValue = schema[DEFAULT];
     if (isNull(defaultValue) && !schema[ALLOW_NULL]) {
       return false;
     }
-    if (!isNull(defaultValue) && getCellOrValueType(defaultValue) != type) {
-      objDel(schema, DEFAULT);
+    if (!isNull(defaultValue)) {
+      if (getCellOrValueType(defaultValue) != type) {
+        objDel(schema, DEFAULT);
+      } else {
+        schema[DEFAULT] = encodeIfJson(defaultValue);
+      }
     }
     return true;
   };
@@ -1426,20 +1458,22 @@ const createStore = () => {
               ? cellSchema[ALLOW_NULL]
                 ? cell
                 : cellInvalid(tableId, rowId, cellId, cell, cellSchema[DEFAULT])
-              : getCellOrValueType(cell) == cellSchema[TYPE]
-                ? cell
-                : cellInvalid(
-                    tableId,
-                    rowId,
-                    cellId,
-                    cell,
-                    cellSchema[DEFAULT],
-                  ),
+              : getCellOrValueType(cell) === cellSchema[TYPE]
+                ? encodeIfJson(cell)
+                : isJsonType(cellSchema[TYPE]) && isEncodedJson(cell)
+                  ? cell
+                  : cellInvalid(
+                      tableId,
+                      rowId,
+                      cellId,
+                      cell,
+                      cellSchema[DEFAULT],
+                    ),
           () => cellInvalid(tableId, rowId, cellId, cell),
         )
       : isUndefined(getCellOrValueType(cell))
         ? cellInvalid(tableId, rowId, cellId, cell)
-        : cell;
+        : encodeIfJson(cell);
   const validateValues = (values, skipDefaults) =>
     objValidate(
       skipDefaults ? values : addDefaultsToValues(values),
@@ -1463,14 +1497,16 @@ const createStore = () => {
               ? valueSchema[ALLOW_NULL]
                 ? value
                 : valueInvalid(valueId, value, valueSchema[DEFAULT])
-              : getCellOrValueType(value) == valueSchema[TYPE]
-                ? value
-                : valueInvalid(valueId, value, valueSchema[DEFAULT]),
+              : getCellOrValueType(value) === valueSchema[TYPE]
+                ? encodeIfJson(value)
+                : isJsonType(valueSchema[TYPE]) && isEncodedJson(value)
+                  ? value
+                  : valueInvalid(valueId, value, valueSchema[DEFAULT]),
           () => valueInvalid(valueId, value),
         )
       : isUndefined(getCellOrValueType(value))
         ? valueInvalid(valueId, value)
-        : value;
+        : encodeIfJson(value);
   const addDefaultsToRow = (row, tableId, rowId) => {
     ifNotUndefined(
       mapGet(tablesSchemaRowCache, tableId),
@@ -1550,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) =>
@@ -1653,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,
@@ -1893,13 +1967,21 @@ const createStore = () => {
   const getCellChange = (tableId, rowId, cellId) =>
     ifNotUndefined(
       mapGet(mapGet(mapGet(changedCells, tableId), rowId), cellId),
-      ([oldCell, newCell]) => [true, oldCell, newCell],
+      ([oldCell, newCell]) => [
+        true,
+        decodeIfJson(oldCell),
+        decodeIfJson(newCell),
+      ],
       () => [false, ...pairNew(getCell(tableId, rowId, cellId))],
     );
   const getValueChange = (valueId) =>
     ifNotUndefined(
       mapGet(changedValues, valueId),
-      ([oldValue, newValue]) => [true, oldValue, newValue],
+      ([oldValue, newValue]) => [
+        true,
+        decodeIfJson(oldValue),
+        decodeIfJson(newValue),
+      ],
       () => [false, ...pairNew(getValue(valueId))],
     );
   const callInvalidCellListeners = (mutator) =>
@@ -2075,8 +2157,8 @@ const createStore = () => {
                 callListeners(
                   cellListeners[mutator],
                   [tableId, rowId, cellId],
-                  newCell,
-                  oldCell,
+                  decodeIfJson(newCell),
+                  decodeIfJson(oldCell),
                   getCellChange,
                 );
                 tablesChanged = tableChanged = rowChanged = 1;
@@ -2132,8 +2214,8 @@ const createStore = () => {
             callListeners(
               valueListeners[mutator],
               [valueId],
-              newValue,
-              oldValue,
+              decodeIfJson(newValue),
+              decodeIfJson(oldValue),
               getValueChange,
             );
             valuesChanged = 1;
@@ -2170,10 +2252,42 @@ const createStore = () => {
       [getTableIds],
     );
   };
+  const getTransactionChangesImpl = (encoded = false) => [
+    mapToObj(
+      changedCells,
+      (table, tableId) =>
+        mapGet(changedTableIds, tableId) === -1
+          ? void 0
+          : mapToObj(
+              table,
+              (row, rowId) =>
+                mapGet(mapGet(changedRowIds, tableId), rowId) === -1
+                  ? void 0
+                  : mapToObj(
+                      row,
+                      ([, newCell]) =>
+                        decodeIfJson(newCell, EMPTY_STRING, encoded),
+                      (changedCell) => pairIsEqual(changedCell),
+                    ),
+              collIsEmpty,
+              objIsEmpty,
+            ),
+      collIsEmpty,
+      objIsEmpty,
+    ),
+    mapToObj(
+      changedValues,
+      ([, newValue]) => decodeIfJson(newValue, EMPTY_STRING, encoded),
+      (changedValue) => pairIsEqual(changedValue),
+    ),
+    1,
+  ];
   const getContent = () => [getTables(), getValues()];
-  const getTables = () => mapToObj3(tablesMap);
+  const getEncodedContent = () => [mapToObj3(tablesMap), mapToObj(valuesMap)];
+  const getTables = () => mapToObj3(tablesMap, decodeIfJson);
   const getTableIds = () => mapKeys(tablesMap);
-  const getTable = (tableId) => mapToObj2(mapGet(tablesMap, id(tableId)));
+  const getTable = (tableId) =>
+    mapToObj2(mapGet(tablesMap, id(tableId)), decodeIfJson);
   const getTableCellIds = (tableId) =>
     mapKeys(mapGet(tableCellIds, id(tableId)));
   const getRowCount = (tableId) => collSize(mapGet(tablesMap, id(tableId)));
@@ -2209,14 +2323,16 @@ const createStore = () => {
           ([, rowId]) => rowId,
         );
   const getRow = (tableId, rowId) =>
-    mapToObj(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)));
+    mapToObj(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), decodeIfJson);
   const getCellIds = (tableId, rowId) =>
     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);
+    decodeIfJson(
+      mapGet(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId)),
+    );
+  const getValues = () => mapToObj(valuesMap, decodeIfJson);
   const getValueIds = () => mapKeys(valuesMap);
-  const getValue = (valueId) => mapGet(valuesMap, id(valueId));
+  const getValue = (valueId) => decodeIfJson(mapGet(valuesMap, id(valueId)));
   const hasTables = () => !collIsEmpty(tablesMap);
   const hasTable = (tableId) => collHas(tablesMap, id(tableId));
   const hasTableCell = (tableId, cellId) =>
@@ -2287,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(
@@ -2297,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,
@@ -2354,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,
+                        ),
                       ),
                 ),
           );
@@ -2503,35 +2665,8 @@ const createStore = () => {
     }
     return store;
   };
-  const getTransactionChanges = () => [
-    mapToObj(
-      changedCells,
-      (table, tableId) =>
-        mapGet(changedTableIds, tableId) === -1
-          ? void 0
-          : mapToObj(
-              table,
-              (row, rowId) =>
-                mapGet(mapGet(changedRowIds, tableId), rowId) === -1
-                  ? void 0
-                  : mapToObj(
-                      row,
-                      ([, newCell]) => newCell,
-                      (changedCell) => pairIsEqual(changedCell),
-                    ),
-              collIsEmpty,
-              objIsEmpty,
-            ),
-      collIsEmpty,
-      objIsEmpty,
-    ),
-    mapToObj(
-      changedValues,
-      ([, newValue]) => newValue,
-      (changedValue) => pairIsEqual(changedValue),
-    ),
-    1,
-  ];
+  const getTransactionChanges = () => getTransactionChangesImpl();
+  const getEncodedTransactionChanges = () => getTransactionChangesImpl(true);
   const getTransactionLog = () => [
     !collIsEmpty(changedCells),
     !collIsEmpty(changedValues),
@@ -2544,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--;
@@ -2584,7 +2688,6 @@ const createStore = () => {
           callInvalidCellListeners(1);
           if (!collIsEmpty(changedCells)) {
             callTabularListenersForChanges(1);
-            doDidSetRows();
           }
           callInvalidValueListeners(1);
           if (!collIsEmpty(changedValues)) {
@@ -2645,7 +2748,9 @@ const createStore = () => {
       tableCallback(tableId, (rowCallback) =>
         collForEach(tableMap, (rowMap, rowId) =>
           rowCallback(rowId, (cellCallback) =>
-            mapForEach(rowMap, cellCallback),
+            mapForEach(rowMap, (cellId, cell) =>
+              cellCallback(cellId, decodeIfJson(cell)),
+            ),
           ),
         ),
       ),
@@ -2654,11 +2759,21 @@ const createStore = () => {
     mapForEach(mapGet(tableCellIds, id(tableId)), tableCellCallback);
   const forEachRow = (tableId, rowCallback) =>
     collForEach(mapGet(tablesMap, id(tableId)), (rowMap, rowId) =>
-      rowCallback(rowId, (cellCallback) => mapForEach(rowMap, cellCallback)),
+      rowCallback(rowId, (cellCallback) =>
+        mapForEach(rowMap, (cellId, cell) =>
+          cellCallback(cellId, decodeIfJson(cell)),
+        ),
+      ),
     );
   const forEachCell = (tableId, rowId, cellCallback) =>
-    mapForEach(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), cellCallback);
-  const forEachValue = (valueCallback) => mapForEach(valuesMap, valueCallback);
+    mapForEach(
+      mapGet(mapGet(tablesMap, id(tableId)), id(rowId)),
+      (cellId, cell) => cellCallback(cellId, decodeIfJson(cell)),
+    );
+  const forEachValue = (valueCallback) =>
+    mapForEach(valuesMap, (valueId, value) =>
+      valueCallback(valueId, decodeIfJson(value)),
+    );
   const addSortedRowIdsListener = (
     tableIdOrArgs,
     cellIdOrListener,
@@ -2743,7 +2858,7 @@ const createStore = () => {
     willDelValues,
     willDelValue,
     willApplyChanges,
-    didSetRow,
+    hasWillSetRowCallbacks,
   ) =>
     (middleware = [
       willSetContent,
@@ -2760,7 +2875,7 @@ const createStore = () => {
       willDelValues,
       willDelValue,
       willApplyChanges,
-      didSetRow,
+      hasWillSetRowCallbacks,
     ]);
   const setInternalListeners = (
     preStartTransaction,
@@ -2850,14 +2965,17 @@ const createStore = () => {
     delListener,
     getListenerStats,
     isMergeable: () => false,
-    // only used internally by other modules
-    createStore,
-    addListener,
-    callListeners,
-    setInternalListeners,
-    setMiddleware,
-    setOrDelCell,
-    setOrDelValue,
+    _: [
+      createStore,
+      addListener,
+      callListeners,
+      setInternalListeners,
+      setMiddleware,
+      setOrDelCell,
+      setOrDelValue,
+      getEncodedContent,
+      getEncodedTransactionChanges,
+    ],
   };
   objMap(
     {
@@ -3172,14 +3290,78 @@ const createMergeableStore = (uniqueId, getNow) => {
       ]);
     }
   };
-  const getMergeableContent = () => [
+  const getMergeableContentImpl = (encoded = false) => [
     stampMapToObjWithHash(contentStampMap[0], (tableStampMap) =>
       stampMapToObjWithHash(tableStampMap, (rowStampMap) =>
-        stampMapToObjWithHash(rowStampMap),
+        stampMapToObjWithHash(rowStampMap, ([cell, hlc, hash]) => [
+          decodeIfJson(cell, EMPTY_STRING, encoded),
+          hlc,
+          hash,
+        ]),
       ),
     ),
-    stampMapToObjWithHash(contentStampMap[1]),
+    stampMapToObjWithHash(contentStampMap[1], ([value, hlc, hash]) => [
+      decodeIfJson(value, EMPTY_STRING, encoded),
+      hlc,
+      hash,
+    ]),
   ];
+  const getTransactionMergeableChangesImpl = (withHashes, encoded = false) => {
+    const [
+      [tableStampMaps, tablesHlc, tablesHash],
+      [valueStampMaps, valuesHlc, valuesHash],
+    ] = contentStampMap;
+    const newStamp = withHashes ? stampNewWithHash : stampNew;
+    const tablesObj = {};
+    collForEach(touchedCells, (touchedTable, tableId) =>
+      ifNotUndefined(
+        mapGet(tableStampMaps, tableId),
+        ([rowStampMaps, tableHlc, tableHash]) => {
+          const tableObj = {};
+          collForEach(touchedTable, (touchedRow, rowId) =>
+            ifNotUndefined(
+              mapGet(rowStampMaps, rowId),
+              ([cellStampMaps, rowHlc, rowHash]) => {
+                const rowObj = {};
+                collForEach(touchedRow, (cellId) => {
+                  ifNotUndefined(
+                    mapGet(cellStampMaps, cellId),
+                    ([cell, time, hash]) =>
+                      (rowObj[cellId] = newStamp(
+                        encoded ? cell : decodeIfJson(cell),
+                        time,
+                        hash,
+                      )),
+                  );
+                });
+                tableObj[rowId] = newStamp(rowObj, rowHlc, rowHash);
+              },
+            ),
+          );
+          tablesObj[tableId] = newStamp(tableObj, tableHlc, tableHash);
+        },
+      ),
+    );
+    const valuesObj = {};
+    collForEach(touchedValues, (valueId) =>
+      ifNotUndefined(
+        mapGet(valueStampMaps, valueId),
+        ([value, time, hash]) =>
+          (valuesObj[valueId] = newStamp(
+            encoded ? value : decodeIfJson(value),
+            time,
+            hash,
+          )),
+      ),
+    );
+    return [
+      newStamp(tablesObj, tablesHlc, tablesHash),
+      newStamp(valuesObj, valuesHlc, valuesHash),
+      1,
+    ];
+  };
+  const getMergeableContent = () => getMergeableContentImpl();
+  const getEncodedMergeableContent = () => getMergeableContentImpl(true);
   const getMergeableContentHashes = () => [
     contentStampMap[0][2],
     contentStampMap[1][2],
@@ -3319,52 +3501,10 @@ const createMergeableStore = (uniqueId, getNow) => {
     });
     return mergeableStore;
   };
-  const getTransactionMergeableChanges = (withHashes = false) => {
-    const [
-      [tableStampMaps, tablesHlc, tablesHash],
-      [valueStampMaps, valuesHlc, valuesHash],
-    ] = contentStampMap;
-    const newStamp = withHashes ? stampNewWithHash : stampNew;
-    const tablesObj = {};
-    collForEach(touchedCells, (touchedTable, tableId) =>
-      ifNotUndefined(
-        mapGet(tableStampMaps, tableId),
-        ([rowStampMaps, tableHlc, tableHash]) => {
-          const tableObj = {};
-          collForEach(touchedTable, (touchedRow, rowId) =>
-            ifNotUndefined(
-              mapGet(rowStampMaps, rowId),
-              ([cellStampMaps, rowHlc, rowHash]) => {
-                const rowObj = {};
-                collForEach(touchedRow, (cellId) => {
-                  ifNotUndefined(
-                    mapGet(cellStampMaps, cellId),
-                    ([cell, time, hash]) =>
-                      (rowObj[cellId] = newStamp(cell, time, hash)),
-                  );
-                });
-                tableObj[rowId] = newStamp(rowObj, rowHlc, rowHash);
-              },
-            ),
-          );
-          tablesObj[tableId] = newStamp(tableObj, tableHlc, tableHash);
-        },
-      ),
-    );
-    const valuesObj = {};
-    collForEach(touchedValues, (valueId) =>
-      ifNotUndefined(
-        mapGet(valueStampMaps, valueId),
-        ([value, time, hash]) =>
-          (valuesObj[valueId] = newStamp(value, time, hash)),
-      ),
-    );
-    return [
-      newStamp(tablesObj, tablesHlc, tablesHash),
-      newStamp(valuesObj, valuesHlc, valuesHash),
-      1,
-    ];
-  };
+  const getTransactionMergeableChanges = (withHashes = false) =>
+    getTransactionMergeableChangesImpl(withHashes);
+  const getEncodedTransactionMergeableChanges = (withHashes) =>
+    getTransactionMergeableChangesImpl(withHashes, true);
   const applyMergeableChanges = (mergeableChanges) =>
     disableListeningToRawStoreChanges(() =>
       store.applyChanges(mergeContentOrChanges(mergeableChanges)),
@@ -3396,10 +3536,13 @@ const createMergeableStore = (uniqueId, getNow) => {
     getTransactionMergeableChanges,
     applyMergeableChanges,
     merge,
-    // only used internally by other modules
-    hadMutated,
+    __: [
+      hadMutated,
+      getEncodedMergeableContent,
+      getEncodedTransactionMergeableChanges,
+    ],
   };
-  store.setInternalListeners(
+  store._[3](
     preStartTransaction,
     preFinishTransaction,
     postFinishTransaction,
@@ -3638,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) =>
@@ -3665,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);
@@ -3691,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,
@@ -3715,10 +3839,9 @@ const createMiddleware = getCreateFunction((store) => {
     addWillDelValuesCallback,
     addWillDelValueCallback,
     addWillApplyChangesCallback,
-    addDidSetRowCallback,
     destroy,
   });
-  store.setMiddleware(
+  store._[4](
     willSetContent,
     willSetTables,
     willSetTable,
@@ -3733,7 +3856,7 @@ const createMiddleware = getCreateFunction((store) => {
     willDelValues,
     willDelValue,
     willApplyChanges,
-    didSetRow,
+    () => willSetRowCallbacks.length > 0,
   );
   return middleware;
 });
@@ -3758,8 +3881,8 @@ const getStoreFunctions = (
   persist != 1 /* StoreOnly */ && store.isMergeable()
     ? [
         1,
-        store.getMergeableContent,
-        () => store.getTransactionMergeableChanges(!isSynchronizer),
+        store.__[1],
+        () => store.__[2](!isSynchronizer),
         ([[changedTables], [changedValues]]) =>
           !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
         store.setDefaultContent,
@@ -3767,8 +3890,8 @@ const getStoreFunctions = (
     : persist != 2 /* MergeableStoreOnly */
       ? [
           0,
-          store.getContent,
-          store.getTransactionChanges,
+          store._[7],
+          store._[8],
           ([changedTables, changedValues]) =>
             !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
           store.setContent,
@@ -3833,7 +3956,7 @@ const createCustomPersister = (
         : store.setContent)(contentOrChanges);
   };
   const saveAfterMutated = async () => {
-    if (isAutoSaving() && store.hadMutated?.()) {
+    if (isAutoSaving() && store.__?.[0]?.()) {
       await save();
     }
   };
@@ -6246,15 +6369,14 @@ const createYjsPersister = (
 };
 
 const createQueries = getCreateFunction((store) => {
-  const createStore = store.createStore;
+  const createStore = store._[0];
   const preStore = createStore();
   const resultStore = createStore();
   const preStoreListenerIds = mapNew();
   const paramValuesListeners = mapNew();
   const paramValueListeners = mapNew();
   const {
-    addListener,
-    callListeners,
+    _: [, addListener, callListeners],
     delListener: delListenerImpl,
   } = resultStore;
   const [
@@ -6573,7 +6695,7 @@ const createQueries = getCreateFunction((store) => {
       selectJoinWhereStore.transaction(() =>
         arrayEvery(wheres, (where2) => where2(getTableCell))
           ? mapForEach(selects, (asCellId, tableCellGetter) =>
-              selectJoinWhereStore.setOrDelCell(
+              selectJoinWhereStore._[5](
                 queryId,
                 rootRowId,
                 asCellId,
@@ -7894,6 +8016,10 @@ const IS_EQUALS = [
   (paramValues1, paramValues2) =>
     objIsEqual(paramValues1, paramValues2, arrayOrValueEqual),
   arrayOrValueEqual,
+  (thing1, thing2) =>
+    thing1 === thing2 ||
+    ((isObject(thing1) || isArray(thing1)) &&
+      jsonString(thing1) === jsonString(thing2)),
 ];
 const isEqual = (thing1, thing2) => thing1 === thing2;
 const useCreate = (store, create, createDeps = EMPTY_ARRAY) => {
@@ -9635,12 +9761,22 @@ const EditableThing = ({
   const [stringThing, setStringThing] = useState();
   const [numberThing, setNumberThing] = useState();
   const [booleanThing, setBooleanThing] = useState();
+  const [objectThing, setObjectThing] = useState('{}');
+  const [arrayThing, setArrayThing] = useState('[]');
+  const [objectClassName, setObjectClassName] = useState('');
+  const [arrayClassName, setArrayClassName] = useState('');
   if (currentThing !== thing) {
     setThingType(getCellOrValueType(thing));
     setCurrentThing(thing);
-    setStringThing(String(thing));
-    setNumberThing(Number(thing) || 0);
-    setBooleanThing(Boolean(thing));
+    if (isObject(thing)) {
+      setObjectThing(jsonString(thing));
+    } else if (isArray(thing)) {
+      setArrayThing(jsonString(thing));
+    } else {
+      setStringThing(String(thing));
+      setNumberThing(Number(thing) || 0);
+      setBooleanThing(Boolean(thing));
+    }
   }
   const handleThingChange = useCallback(
     (thing2, setTypedThing) => {
@@ -9650,14 +9786,39 @@ 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(thingType, NUMBER, BOOLEAN, STRING);
+      const nextType = getTypeCase(
+        thingType,
+        NUMBER,
+        BOOLEAN,
+        OBJECT,
+        ARRAY,
+        STRING,
+      );
       const thing2 = getTypeCase(
         nextType,
         stringThing,
         numberThing,
         booleanThing,
+        tryReturn(() => jsonParse(objectThing), {}),
+        tryReturn(() => jsonParse(arrayThing), []),
       );
       setThingType(nextType);
       setCurrentThing(thing2);
@@ -9669,6 +9830,8 @@ const EditableThing = ({
     stringThing,
     numberThing,
     booleanThing,
+    objectThing,
+    arrayThing,
     thingType,
   ]);
   const widget = getTypeCase(
@@ -9720,6 +9883,42 @@ const EditableThing = ({
       },
       thingType,
     ),
+    /* @__PURE__ */ jsx(
+      'input',
+      {
+        value: objectThing,
+        className: objectClassName,
+        onChange: useCallback(
+          (event) =>
+            handleJsonThingChange(
+              event[CURRENT_TARGET][_VALUE],
+              setObjectThing,
+              isObject,
+              setObjectClassName,
+            ),
+          [handleJsonThingChange],
+        ),
+      },
+      thingType,
+    ),
+    /* @__PURE__ */ jsx(
+      'input',
+      {
+        value: arrayThing,
+        className: arrayClassName,
+        onChange: useCallback(
+          (event) =>
+            handleJsonThingChange(
+              event[CURRENT_TARGET][_VALUE],
+              setArrayThing,
+              isArray,
+              setArrayClassName,
+            ),
+          [handleJsonThingChange],
+        ),
+      },
+      thingType,
+    ),
   );
   return /* @__PURE__ */ jsxs('div', {
     className,