tinybase 8.0.0-beta.1 → 8.0.0-beta.3

package/omni/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);
@@ -619,18 +622,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 +1230,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 +1244,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 +1287,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 +1398,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 +1450,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 +1489,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),
@@ -1893,13 +1921,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) =>
@@ -1944,6 +1980,10 @@ const createStore = () => {
       return 1;
     }
   };
+  const clonedChangedCells = (changedCells2) =>
+    mapClone(changedCells2, (map) =>
+      mapClone(map, (map2) => mapClone(map2, pairClone)),
+    );
   const callTabularListenersForChanges = (mutator) => {
     const hasHasTablesListeners = !collIsEmpty(hasTablesListeners[mutator]);
     const hasSortedRowIdListeners = !collIsEmpty(
@@ -1975,9 +2015,7 @@ const createStore = () => {
             mapClone(changedRowCount),
             mapClone2(changedRowIds),
             mapClone3(changedCellIds),
-            mapClone(changedCells, (map) =>
-              mapClone(map, (map2) => mapClone(map2, pairClone)),
-            ),
+            clonedChangedCells(changedCells),
           ]
         : [
             changedTableIds,
@@ -2073,8 +2111,8 @@ const createStore = () => {
                 callListeners(
                   cellListeners[mutator],
                   [tableId, rowId, cellId],
-                  newCell,
-                  oldCell,
+                  decodeIfJson(newCell),
+                  decodeIfJson(oldCell),
                   getCellChange,
                 );
                 tablesChanged = tableChanged = rowChanged = 1;
@@ -2130,8 +2168,8 @@ const createStore = () => {
             callListeners(
               valueListeners[mutator],
               [valueId],
-              newValue,
-              oldValue,
+              decodeIfJson(newValue),
+              decodeIfJson(oldValue),
               getValueChange,
             );
             valuesChanged = 1;
@@ -2168,10 +2206,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)));
@@ -2207,14 +2277,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) =>
@@ -2501,35 +2573,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),
@@ -2542,6 +2587,37 @@ 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--;
@@ -2551,6 +2627,7 @@ const createStore = () => {
           callInvalidCellListeners(1);
           if (!collIsEmpty(changedCells)) {
             callTabularListenersForChanges(1);
+            doDidSetRows();
           }
           callInvalidValueListeners(1);
           if (!collIsEmpty(changedValues)) {
@@ -2611,7 +2688,9 @@ const createStore = () => {
       tableCallback(tableId, (rowCallback) =>
         collForEach(tableMap, (rowMap, rowId) =>
           rowCallback(rowId, (cellCallback) =>
-            mapForEach(rowMap, cellCallback),
+            mapForEach(rowMap, (cellId, cell) =>
+              cellCallback(cellId, decodeIfJson(cell)),
+            ),
           ),
         ),
       ),
@@ -2620,11 +2699,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,
@@ -2709,6 +2798,7 @@ const createStore = () => {
     willDelValues,
     willDelValue,
     willApplyChanges,
+    didSetRow,
   ) =>
     (middleware = [
       willSetContent,
@@ -2725,6 +2815,7 @@ const createStore = () => {
       willDelValues,
       willDelValue,
       willApplyChanges,
+      didSetRow,
     ]);
   const setInternalListeners = (
     preStartTransaction,
@@ -2814,14 +2905,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(
     {
@@ -3136,14 +3230,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],
@@ -3283,52 +3441,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)),
@@ -3360,10 +3476,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,
@@ -3602,6 +3721,7 @@ const createMiddleware = getCreateFunction((store) => {
   const willDelValuesCallbacks = [];
   const willDelValueCallbacks = [];
   const willApplyChangesCallbacks = [];
+  const didSetRowCallbacksMap = mapNew();
   const willSetContent = (content) =>
     reduceCallbacks(willSetContentCallbacks, content);
   const willSetTables = (tables) =>
@@ -3628,6 +3748,17 @@ 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);
@@ -3643,6 +3774,13 @@ 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,
@@ -3660,9 +3798,10 @@ const createMiddleware = getCreateFunction((store) => {
     addWillDelValuesCallback,
     addWillDelValueCallback,
     addWillApplyChangesCallback,
+    addDidSetRowCallback,
     destroy,
   });
-  store.setMiddleware(
+  store._[4](
     willSetContent,
     willSetTables,
     willSetTable,
@@ -3677,6 +3816,7 @@ const createMiddleware = getCreateFunction((store) => {
     willDelValues,
     willDelValue,
     willApplyChanges,
+    didSetRow,
   );
   return middleware;
 });
@@ -3701,8 +3841,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,
@@ -3710,8 +3850,8 @@ const getStoreFunctions = (
     : persist != 2 /* MergeableStoreOnly */
       ? [
           0,
-          store.getContent,
-          store.getTransactionChanges,
+          store._[7],
+          store._[8],
           ([changedTables, changedValues]) =>
             !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
           store.setContent,
@@ -3776,7 +3916,7 @@ const createCustomPersister = (
         : store.setContent)(contentOrChanges);
   };
   const saveAfterMutated = async () => {
-    if (isAutoSaving() && store.hadMutated?.()) {
+    if (isAutoSaving() && store.__?.[0]?.()) {
       await save();
     }
   };
@@ -6189,15 +6329,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 [
@@ -6516,7 +6655,7 @@ const createQueries = getCreateFunction((store) => {
       selectJoinWhereStore.transaction(() =>
         arrayEvery(wheres, (where2) => where2(getTableCell))
           ? mapForEach(selects, (asCellId, tableCellGetter) =>
-              selectJoinWhereStore.setOrDelCell(
+              selectJoinWhereStore._[5](
                 queryId,
                 rootRowId,
                 asCellId,
@@ -7837,6 +7976,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) => {
@@ -9578,12 +9721,20 @@ 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);
   if (currentThing !== thing) {
     setThingType(getCellOrValueType(thing));
     setCurrentThing(thing);
-    setStringThing(String(thing));
-    setNumberThing(Number(thing) || 0);
-    setBooleanThing(Boolean(thing));
+    if (isObject(thing)) {
+      setObjectThingJson(jsonString(thing));
+    } else if (isArray(thing)) {
+      setArrayThingJson(jsonString(thing));
+    } else {
+      setStringThing(String(thing));
+      setNumberThing(Number(thing) || 0);
+      setBooleanThing(Boolean(thing));
+    }
   }
   const handleThingChange = useCallback(
     (thing2, setTypedThing) => {
@@ -9595,12 +9746,21 @@ const EditableThing = ({
   );
   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,
+        objectThingJson ? jsonParse(objectThingJson) : {},
+        arrayThingJson ? jsonParse(arrayThingJson) : [],
       );
       setThingType(nextType);
       setCurrentThing(thing2);
@@ -9612,6 +9772,8 @@ const EditableThing = ({
     stringThing,
     numberThing,
     booleanThing,
+    objectThingJson,
+    arrayThingJson,
     thingType,
   ]);
   const widget = getTypeCase(
@@ -9663,6 +9825,46 @@ const EditableThing = ({
       },
       thingType,
     ),
+    /* @__PURE__ */ jsx(
+      'textarea',
+      {
+        value: objectThingJson,
+        onChange: useCallback(
+          (event) => {
+            const str = event[CURRENT_TARGET][_VALUE];
+            setObjectThingJson(str);
+            try {
+              const parsed = jsonParse(str);
+              if (isObject(parsed)) {
+                onThingChange(parsed);
+              }
+            } catch {}
+          },
+          [onThingChange],
+        ),
+      },
+      thingType,
+    ),
+    /* @__PURE__ */ jsx(
+      'textarea',
+      {
+        value: arrayThingJson,
+        onChange: useCallback(
+          (event) => {
+            const str = event[CURRENT_TARGET][_VALUE];
+            setArrayThingJson(str);
+            try {
+              const parsed = jsonParse(str);
+              if (isArray(parsed)) {
+                onThingChange(parsed);
+              }
+            } catch {}
+          },
+          [onThingChange],
+        ),
+      },
+      thingType,
+    ),
   );
   return /* @__PURE__ */ jsxs('div', {
     className,