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

package/ui-react-inspector/index.js

@@ -41,6 +41,8 @@ const STRING = getTypeOf(EMPTY_STRING);
 const BOOLEAN = getTypeOf(true);
 const NUMBER = getTypeOf(0);
 const FUNCTION = getTypeOf(getTypeOf);
+const OBJECT = 'object';
+const ARRAY = 'array';
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
@@ -72,6 +74,7 @@ const CURRENT_TARGET = 'currentTarget';
 const _VALUE = 'value';
 const EXTRA = 'extra';
 const UNDEFINED = '\uFFFC';
+const JSON_PREFIX = '\uFFFD';
 const id = (key) => EMPTY_STRING + key;
 const strSplit = (str, separator = EMPTY_STRING, limit) =>
   str.split(separator, limit);
@@ -152,6 +155,7 @@ const isObject = (obj) =>
 const objIds = object.keys;
 const objFreeze = object.freeze;
 const objNew = (entries = []) => object.fromEntries(entries);
+const objMerge = (...objs) => object.assign({}, ...objs);
 const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
 const objHas = (obj, id) => id in obj;
 const objDel = (obj, id) => {
@@ -419,8 +423,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,
@@ -428,8 +432,8 @@ const getStoreFunctions = (
     : persist != 2 /* MergeableStoreOnly */
       ? [
           0,
-          store.getContent,
-          store.getTransactionChanges,
+          store._[7],
+          store._[8],
           ([changedTables, changedValues]) =>
             !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
           store.setContent,
@@ -494,7 +498,7 @@ const createCustomPersister = (
         : store.setContent)(contentOrChanges);
   };
   const saveAfterMutated = async () => {
-    if (isAutoSaving() && store.hadMutated?.()) {
+    if (isAutoSaving() && store.__?.[0]?.()) {
       await save();
     }
   };
@@ -698,20 +702,43 @@ 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))
     ? type
     : void 0;
 };
-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 defaultSorter = (sortKey1, sortKey2) =>
   (sortKey1 ?? 0) < (sortKey2 ?? 0) ? -1 : 1;
@@ -812,15 +839,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;
   };
@@ -860,20 +891,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),
@@ -897,14 +930,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),
@@ -1327,13 +1362,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) =>
@@ -1378,6 +1421,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(
@@ -1409,9 +1456,7 @@ const createStore = () => {
             mapClone(changedRowCount),
             mapClone2(changedRowIds),
             mapClone3(changedCellIds),
-            mapClone(changedCells, (map) =>
-              mapClone(map, (map2) => mapClone(map2, pairClone)),
-            ),
+            clonedChangedCells(changedCells),
           ]
         : [
             changedTableIds,
@@ -1507,8 +1552,8 @@ const createStore = () => {
                 callListeners(
                   cellListeners[mutator],
                   [tableId, rowId, cellId],
-                  newCell,
-                  oldCell,
+                  decodeIfJson(newCell),
+                  decodeIfJson(oldCell),
                   getCellChange,
                 );
                 tablesChanged = tableChanged = rowChanged = 1;
@@ -1564,8 +1609,8 @@ const createStore = () => {
             callListeners(
               valueListeners[mutator],
               [valueId],
-              newValue,
-              oldValue,
+              decodeIfJson(newValue),
+              decodeIfJson(oldValue),
               getValueChange,
             );
             valuesChanged = 1;
@@ -1602,10 +1647,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)));
@@ -1641,14 +1718,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) =>
@@ -1935,35 +2014,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),
@@ -1976,6 +2028,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--;
@@ -1985,6 +2068,7 @@ const createStore = () => {
           callInvalidCellListeners(1);
           if (!collIsEmpty(changedCells)) {
             callTabularListenersForChanges(1);
+            doDidSetRows();
           }
           callInvalidValueListeners(1);
           if (!collIsEmpty(changedValues)) {
@@ -2045,7 +2129,9 @@ const createStore = () => {
       tableCallback(tableId, (rowCallback) =>
         collForEach(tableMap, (rowMap, rowId) =>
           rowCallback(rowId, (cellCallback) =>
-            mapForEach(rowMap, cellCallback),
+            mapForEach(rowMap, (cellId, cell) =>
+              cellCallback(cellId, decodeIfJson(cell)),
+            ),
           ),
         ),
       ),
@@ -2054,11 +2140,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,
@@ -2143,6 +2239,7 @@ const createStore = () => {
     willDelValues,
     willDelValue,
     willApplyChanges,
+    didSetRow,
   ) =>
     (middleware = [
       willSetContent,
@@ -2159,6 +2256,7 @@ const createStore = () => {
       willDelValues,
       willDelValue,
       willApplyChanges,
+      didSetRow,
     ]);
   const setInternalListeners = (
     preStartTransaction,
@@ -2248,14 +2346,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(
     {
@@ -2439,6 +2540,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 addAndDelListener = (thing, listenable, ...args) => {
@@ -2973,12 +3078,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) => {
@@ -2990,12 +3103,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);
@@ -3007,6 +3129,8 @@ const EditableThing = ({
     stringThing,
     numberThing,
     booleanThing,
+    objectThingJson,
+    arrayThingJson,
     thingType,
   ]);
   const widget = getTypeCase(
@@ -3058,6 +3182,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,