tinybase 5.0.0-beta.1 → 5.0.0-beta.11

package/lib/debug/ui-react-dom.js

@@ -124,9 +124,7 @@ const arrayShift = (array) => array.shift();
 const object = Object;
 const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
 const objEntries = object.entries;
-const objIds = object.keys;
 const objFrozen = object.isFrozen;
-const objFreeze = object.freeze;
 const isObject = (obj) =>
   !isUndefined(obj) &&
   ifNotUndefined(
@@ -137,23 +135,52 @@ const isObject = (obj) =>
     /* istanbul ignore next */
     () => true,
   );
+const objIds = object.keys;
+const objFreeze = object.freeze;
 const objNew = (entries = []) => object.fromEntries(entries);
-const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-const objHas = (obj, id) => !isUndefined(objGet(obj, id));
+const objHas = (obj, id) => id in obj;
 const objDel = (obj, id) => {
   delete obj[id];
   return obj;
 };
-const objMap = (obj, cb) =>
+const objToArray = (obj, cb) =>
   arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
+const objMap = (obj, cb) =>
+  objNew(objToArray(obj, (value, id) => [id, cb(value, id)]));
 const objSize = (obj) => size(objIds(obj));
 const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
+const objValidate = (obj, validateChild, onInvalidObj, emptyIsValid = 0) => {
+  if (
+    isUndefined(obj) ||
+    !isObject(obj) ||
+    (!emptyIsValid && objIsEmpty(obj)) ||
+    objFrozen(obj)
+  ) {
+    onInvalidObj?.();
+    return false;
+  }
+  objToArray(obj, (child, id) => {
+    if (!validateChild(child, id)) {
+      objDel(obj, id);
+    }
+  });
+  return emptyIsValid ? true : !objIsEmpty(obj);
+};
 
-const jsonString = (obj) =>
+const UNDEFINED_MARKER = '\uFFFC';
+const jsonStringWithMap = (obj) =>
   JSON.stringify(obj, (_key, value) =>
     isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,
   );
 const jsonParse = JSON.parse;
+const jsonStringWithUndefined = (obj) =>
+  JSON.stringify(obj, (_key, value) =>
+    value === void 0 ? UNDEFINED_MARKER : value,
+  );
+const jsonParseWithUndefined = (str) =>
+  JSON.parse(str, (_key, value) =>
+    value === UNDEFINED_MARKER ? void 0 : value,
+  );
 
 const UNIQUE_ID = 'tinybaseStoreInspector';
 const TITLE = 'TinyBase Store Inspector';
@@ -164,7 +191,7 @@ const OPEN_CELL = 'open';
 const POSITION_VALUE = 'position';
 const OPEN_VALUE = OPEN_CELL;
 const EDITABLE_CELL = 'editable';
-const getUniqueId = (...args) => jsonString(args);
+const getUniqueId = (...args) => jsonStringWithMap(args);
 const sortedIdsMap = (ids, callback) => arrayMap(arraySort(ids), callback);
 const useEditable = (uniqueId, s) => [
   !!useCell(STATE_TABLE, uniqueId, EDITABLE_CELL, s),
@@ -207,7 +234,7 @@ const DONE_SVG = PRE + `<path d='${PENCIL}M20 20l60 60' />` + POST;
 
 const SCROLLBAR = '*::-webkit-scrollbar';
 const APP_STYLESHEET = arrayJoin(
-  objMap(
+  objToArray(
     {
       '': 'all:initial;font-family:sans-serif;font-size:0.75rem;position:fixed;z-index:999999',
       '*': 'all:revert',
@@ -333,9 +360,10 @@ const Details = ({
   );
 };
 
-const getCellOrValueType = (cell) => {
-  const type = getTypeOf(cell);
-  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+const getCellOrValueType = (cellOrValue) => {
+  const type = getTypeOf(cellOrValue);
+  return isTypeStringOrBoolean(type) ||
+    (type == NUMBER && isFiniteNumber(cellOrValue))
     ? type
     : void 0;
 };
@@ -433,21 +461,16 @@ const useSortingAndPagination = (
 const useCells = (defaultCellIds, customCells, defaultCellComponent) =>
   useMemo(() => {
     const cellIds = customCells ?? defaultCellIds;
-    return objNew(
-      objMap(
-        isArray(cellIds)
-          ? objNew(arrayMap(cellIds, (cellId) => [cellId, cellId]))
-          : cellIds,
-        (labelOrCustomCell, cellId) => [
-          cellId,
-          {
-            ...{label: cellId, component: defaultCellComponent},
-            ...(isString(labelOrCustomCell)
-              ? {label: labelOrCustomCell}
-              : labelOrCustomCell),
-          },
-        ],
-      ),
+    return objMap(
+      isArray(cellIds)
+        ? objNew(arrayMap(cellIds, (cellId) => [cellId, cellId]))
+        : cellIds,
+      (labelOrCustomCell, cellId) => ({
+        ...{label: cellId, component: defaultCellComponent},
+        ...(isString(labelOrCustomCell)
+          ? {label: labelOrCustomCell}
+          : labelOrCustomCell),
+      }),
     );
   }, [customCells, defaultCellComponent, defaultCellIds]);
 const HtmlTable = ({
@@ -484,7 +507,7 @@ const HtmlTable = ({
                   label: 'Id',
                   onClick: handleSort,
                 }),
-            objMap(cells, ({label}, cellId) =>
+            objToArray(cells, ({label}, cellId) =>
               /* @__PURE__ */ createElement(HtmlHeaderCell, {
                 key: cellId,
                 cellId,
@@ -505,17 +528,19 @@ const HtmlTable = ({
           idColumn === false
             ? null
             : /* @__PURE__ */ createElement('th', null, rowId),
-          objMap(cells, ({component: CellView2, getComponentProps}, cellId) =>
-            /* @__PURE__ */ createElement(
-              'td',
-              {key: cellId},
-              /* @__PURE__ */ createElement(CellView2, {
-                ...getProps(getComponentProps, rowId, cellId),
-                ...cellComponentProps,
-                rowId,
-                cellId,
-              }),
-            ),
+          objToArray(
+            cells,
+            ({component: CellView2, getComponentProps}, cellId) =>
+              /* @__PURE__ */ createElement(
+                'td',
+                {key: cellId},
+                /* @__PURE__ */ createElement(CellView2, {
+                  ...getProps(getComponentProps, rowId, cellId),
+                  ...cellComponentProps,
+                  rowId,
+                  cellId,
+                }),
+              ),
           ),
         ),
       ),
@@ -569,7 +594,7 @@ const RelationshipInHtmlRow = ({
           /* @__PURE__ */ createElement('th', null, localRowId),
           /* @__PURE__ */ createElement('th', null, remoteRowId),
         ),
-    objMap(
+    objToArray(
       cells,
       ({component: CellView2, getComponentProps}, compoundCellId) => {
         const [tableId, cellId] = compoundCellId.split(DOT, 2);
@@ -885,7 +910,7 @@ const RelationshipInHtmlTable = ({
                     '.Id',
                   ),
                 ),
-            objMap(cells, ({label}, cellId) =>
+            objToArray(cells, ({label}, cellId) =>
               /* @__PURE__ */ createElement('th', {key: cellId}, label),
             ),
           ),
@@ -1165,7 +1190,7 @@ const QueryView = ({queries, queriesId, queryId, s}) => {
     STATE_TABLE,
     uniqueId,
     SORT_CELL,
-    jsonString,
+    jsonStringWithMap,
     [],
     s,
   );
@@ -1270,7 +1295,7 @@ const TableView = ({tableId, store, storeId, s}) => {
     STATE_TABLE,
     uniqueId,
     SORT_CELL,
-    jsonString,
+    jsonStringWithMap,
     [],
     s,
   );
@@ -1531,35 +1556,41 @@ const mapMap = (coll, cb) =>
   arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
+const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
   if (!collHas(map, key)) {
     mapSet(map, key, getDefaultValue());
+  } else {
+    hadExistingValue?.(mapGet(map, key));
   }
   return mapGet(map, key);
 };
 const mapMatch = (map, obj, set, del = mapSet) => {
-  objMap(obj, (value, id) => set(map, id, value));
+  objToArray(obj, (value, id) => set(map, id, value));
   mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
   return map;
 };
-const mapToObj = (map, mapValue, excludeValue) => {
+const mapToObj = (map, valueMapper, excludeMapValue, excludeObjValue) => {
   const obj = {};
-  collForEach(map, (value, id) => {
-    const mappedValue = mapValue ? mapValue(value, id) : value;
-    excludeValue?.(mappedValue, value) ? 0 : (obj[id] = mappedValue);
+  collForEach(map, (mapValue, id) => {
+    if (!excludeMapValue?.(mapValue, id)) {
+      const objValue = valueMapper ? valueMapper(mapValue, id) : mapValue;
+      excludeObjValue?.(objValue) ? 0 : (obj[id] = objValue);
+    }
   });
   return obj;
 };
-const mapToObj2 = (map, mapValue, excludeValue) =>
+const mapToObj2 = (map, valueMapper, excludeMapValue) =>
   mapToObj(
     map,
-    (childMap) => mapToObj(childMap, mapValue, excludeValue),
+    (childMap) => mapToObj(childMap, valueMapper, excludeMapValue),
+    collIsEmpty,
     objIsEmpty,
   );
-const mapToObj3 = (map, mapValue, excludeValue) =>
+const mapToObj3 = (map, valueMapper, excludeMapValue) =>
   mapToObj(
     map,
-    (childMap) => mapToObj2(childMap, mapValue, excludeValue),
+    (childMap) => mapToObj2(childMap, valueMapper, excludeMapValue),
+    collIsEmpty,
     objIsEmpty,
   );
 const mapClone = (map, mapValue) => {
@@ -1593,6 +1624,27 @@ const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
 
 const scheduleRunning = mapNew();
 const scheduleActions = mapNew();
+const getStoreFunctions = (supportedStoreType = 1, store) =>
+  supportedStoreType > 1 && 'getMergeableContent' in store
+    ? [
+        1,
+        store.getMergeableContent,
+        store.getTransactionMergeableChanges,
+        ([[changedTables], [changedValues]]) =>
+          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+        store.setDefaultContent,
+      ]
+    : supportedStoreType != 2
+      ? [
+          0,
+          store.getContent,
+          store.getTransactionChanges,
+          ([changedTables, changedValues]) =>
+            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
+          store.setContent,
+        ]
+      : /* istanbul ignore next */
+        0;
 const createCustomPersister = (
   store,
   getPersisted,
@@ -1600,18 +1652,25 @@ const createCustomPersister = (
   addPersisterListener,
   delPersisterListener,
   onIgnoredError,
-  [getThing, thing] = [],
+  supportedStoreType,
+  extra = {},
   scheduleId = [],
 ) => {
-  let listenerId;
   let loadSave = 0;
   let loads = 0;
   let saves = 0;
-  let listening = 0;
   let action;
-  let listeningHandle;
+  let autoLoadHandle;
+  let autoSaveListenerId;
   mapEnsure(scheduleRunning, scheduleId, () => 0);
   mapEnsure(scheduleActions, scheduleId, () => []);
+  const [
+    isMergeableStore,
+    getContent,
+    getChanges,
+    hasChanges,
+    setDefaultContent,
+  ] = getStoreFunctions(supportedStoreType, store);
   const run = async () => {
     /* istanbul ignore else */
     if (!mapGet(scheduleRunning, scheduleId)) {
@@ -1629,109 +1688,121 @@ const createCustomPersister = (
       mapSet(scheduleRunning, scheduleId, 0);
     }
   };
-  const loadLock = async (actions) => {
+  const setContentOrChanges = (contentOrChanges) => {
+    (isMergeableStore && isArray(contentOrChanges?.[0])
+      ? contentOrChanges?.[2] === 1
+        ? store.applyMergeableChanges
+        : store.setMergeableContent
+      : contentOrChanges?.[2] === 1
+        ? store.applyChanges
+        : store.setContent)(contentOrChanges);
+  };
+  const load = async (initialContent) => {
     /* istanbul ignore else */
     if (loadSave != 2) {
       loadSave = 1;
       {
         loads++;
       }
-      await persister.schedule(async () => {
-        await actions();
+      await schedule(async () => {
+        try {
+          setContentOrChanges(await getPersisted());
+        } catch (error) {
+          onIgnoredError?.(error);
+          if (initialContent) {
+            setDefaultContent(initialContent);
+          }
+        }
         loadSave = 0;
       });
     }
     return persister;
   };
-  const persister = {
-    load: async (initialTables, initialValues) =>
-      await loadLock(async () => {
-        try {
-          store.setContent(await getPersisted());
-        } catch {
-          store.setContent([initialTables, initialValues]);
-        }
-      }),
-    startAutoLoad: async (initialTables = {}, initialValues = {}) => {
-      persister.stopAutoLoad();
-      await persister.load(initialTables, initialValues);
-      listening = 1;
-      listeningHandle = addPersisterListener(
-        async (getContent, getTransactionChanges) => {
-          if (getTransactionChanges) {
-            const transactionChanges = getTransactionChanges();
-            await loadLock(async () =>
-              store.setTransactionChanges(transactionChanges),
-            );
-          } else {
-            await loadLock(async () => {
-              try {
-                store.setContent(getContent?.() ?? (await getPersisted()));
-              } catch (error) {
-                onIgnoredError?.(error);
-              }
-            });
+  const startAutoLoad = async (initialContent) => {
+    await stopAutoLoad().load(initialContent);
+    autoLoadHandle = addPersisterListener(async (content, changes) => {
+      if (changes || content) {
+        /* istanbul ignore else */
+        if (loadSave != 2) {
+          loadSave = 1;
+          {
+            loads++;
           }
-        },
-      );
-      return persister;
-    },
-    stopAutoLoad: () => {
-      if (listening) {
-        delPersisterListener(listeningHandle);
-        listeningHandle = void 0;
-        listening = 0;
+          setContentOrChanges(changes ?? content);
+          loadSave = 0;
+        }
+      } else {
+        await load();
       }
-      return persister;
-    },
-    save: async (getTransactionChanges) => {
-      /* istanbul ignore else */
-      if (loadSave != 1) {
-        loadSave = 2;
-        {
-          saves++;
+    });
+    return persister;
+  };
+  const stopAutoLoad = () => {
+    if (autoLoadHandle) {
+      delPersisterListener(autoLoadHandle);
+      autoLoadHandle = void 0;
+    }
+    return persister;
+  };
+  const isAutoLoading = () => !isUndefined(autoLoadHandle);
+  const save = async (changes) => {
+    /* istanbul ignore else */
+    if (loadSave != 1) {
+      loadSave = 2;
+      {
+        saves++;
+      }
+      await schedule(async () => {
+        try {
+          await setPersisted(getContent, changes);
+        } catch (error) {
+          /* istanbul ignore next */
+          onIgnoredError?.(error);
         }
-        await persister.schedule(async () => {
-          try {
-            await setPersisted(store.getContent, getTransactionChanges);
-          } catch (error) {
-            /* istanbul ignore next */
-            onIgnoredError?.(error);
-          }
-          loadSave = 0;
-        });
+        loadSave = 0;
+      });
+    }
+    return persister;
+  };
+  const startAutoSave = async () => {
+    await stopAutoSave().save();
+    autoSaveListenerId = store.addDidFinishTransactionListener(() => {
+      const changes = getChanges();
+      if (hasChanges(changes)) {
+        save(changes);
       }
-      return persister;
-    },
-    startAutoSave: async () => {
-      await persister.stopAutoSave().save();
-      listenerId = store.addDidFinishTransactionListener(
-        (_store, getTransactionChanges) => {
-          const [tableChanges, valueChanges] = getTransactionChanges();
-          if (!objIsEmpty(tableChanges) || !objIsEmpty(valueChanges)) {
-            persister.save(() => [tableChanges, valueChanges]);
-          }
-        },
-      );
-      return persister;
-    },
-    stopAutoSave: () => {
-      ifNotUndefined(listenerId, store.delListener);
-      listenerId = void 0;
-      return persister;
-    },
-    schedule: async (...actions) => {
-      arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
-      await run();
-      return persister;
-    },
-    getStore: () => store,
-    destroy: () => persister.stopAutoLoad().stopAutoSave(),
-    getStats: () => ({loads, saves}),
+    });
+    return persister;
+  };
+  const stopAutoSave = () => {
+    ifNotUndefined(autoSaveListenerId, store.delListener);
+    autoSaveListenerId = void 0;
+    return persister;
+  };
+  const isAutoSaving = () => !isUndefined(autoSaveListenerId);
+  const schedule = async (...actions) => {
+    arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
+    await run();
+    return persister;
+  };
+  const getStore = () => store;
+  const destroy = () => stopAutoLoad().stopAutoSave();
+  const getStats = () => ({loads, saves});
+  const persister = {
+    load,
+    startAutoLoad,
+    stopAutoLoad,
+    isAutoLoading,
+    save,
+    startAutoSave,
+    stopAutoSave,
+    isAutoSaving,
+    schedule,
+    getStore,
+    destroy,
+    getStats,
+    ...extra,
   };
-  if (getThing) {
-    persister[getThing] = () => thing;
-  }
   return objFreeze(persister);
 };
 
@@ -1743,13 +1814,18 @@ const createStoragePersister = (
   storage,
   onIgnoredError,
 ) => {
-  const getPersisted = async () => jsonParse(storage.getItem(storageName));
+  const getPersisted = async () =>
+    jsonParseWithUndefined(storage.getItem(storageName));
   const setPersisted = async (getContent) =>
-    storage.setItem(storageName, jsonString(getContent()));
+    storage.setItem(storageName, jsonStringWithUndefined(getContent()));
   const addPersisterListener = (listener) => {
     const storageListener = (event) => {
       if (event.storageArea === storage && event.key === storageName) {
-        listener(() => jsonParse(event.newValue));
+        try {
+          listener(jsonParse(event.newValue));
+        } catch {
+          listener();
+        }
       }
     };
     WINDOW.addEventListener(STORAGE, storageListener);
@@ -1764,7 +1840,8 @@ const createStoragePersister = (
     addPersisterListener,
     delPersisterListener,
     onIgnoredError,
-    ['getStorageName', storageName],
+    3,
+    {getStorageName: () => storageName},
   );
 };
 const createSessionPersister = (store, storageName, onIgnoredError) =>
@@ -1871,18 +1948,6 @@ const pairIsEqual = ([entry1, entry2]) => entry1 === entry2;
 const defaultSorter = (sortKey1, sortKey2) =>
   (sortKey1 ?? 0) < (sortKey2 ?? 0) ? -1 : 1;
 
-const validate = (obj, validateChild, onInvalidObj) => {
-  if (isUndefined(obj) || !isObject(obj) || objIsEmpty(obj) || objFrozen(obj)) {
-    onInvalidObj?.();
-    return false;
-  }
-  objMap(obj, (child, id2) => {
-    if (!validateChild(child, id2)) {
-      objDel(obj, id2);
-    }
-  });
-  return !objIsEmpty(obj);
-};
 const idsChanged = (changedIds, id2, addedOrRemoved) =>
   mapSet(
     changedIds,
@@ -1892,11 +1957,10 @@ const idsChanged = (changedIds, id2, addedOrRemoved) =>
 const createStore = () => {
   let hasTablesSchema;
   let hasValuesSchema;
-  let cellsTouched = false;
-  let valuesTouched = false;
   let hadTables = false;
   let hadValues = false;
   let transactions = 0;
+  let internalListeners = [];
   const changedTableIds = mapNew();
   const changedTableCellIds = mapNew();
   const changedRowCount = mapNew();
@@ -1943,13 +2007,13 @@ const createStore = () => {
   const [addListener, callListeners, delListenerImpl, callListenerImpl] =
     getListenerFunctions(() => store);
   const validateTablesSchema = (tableSchema) =>
-    validate(tableSchema, (tableSchema2) =>
-      validate(tableSchema2, validateCellOrValueSchema),
+    objValidate(tableSchema, (tableSchema2) =>
+      objValidate(tableSchema2, validateCellOrValueSchema),
     );
   const validateValuesSchema = (valuesSchema) =>
-    validate(valuesSchema, validateCellOrValueSchema);
+    objValidate(valuesSchema, validateCellOrValueSchema);
   const validateCellOrValueSchema = (schema) => {
-    if (!validate(schema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))) {
+    if (!objValidate(schema, (_child, id2) => arrayHas([TYPE, DEFAULT], id2))) {
       return false;
     }
     const type = schema[TYPE];
@@ -1962,18 +2026,18 @@ const createStore = () => {
     return true;
   };
   const validateTables = (tables) =>
-    validate(tables, validateTable, cellInvalid);
+    objValidate(tables, validateTable, cellInvalid);
   const validateTable = (table, tableId) =>
     (!hasTablesSchema ||
       collHas(tablesSchemaMap, tableId) ||
       cellInvalid(tableId)) &&
-    validate(
+    objValidate(
       table,
       (row, rowId) => validateRow(tableId, rowId, row),
       () => cellInvalid(tableId),
     );
   const validateRow = (tableId, rowId, row, skipDefaults) =>
-    validate(
+    objValidate(
       skipDefaults ? row : addDefaultsToRow(row, tableId, rowId),
       (cell, cellId) =>
         ifNotUndefined(
@@ -2000,7 +2064,7 @@ const createStore = () => {
         ? cellInvalid(tableId, rowId, cellId, cell)
         : cell;
   const validateValues = (values, skipDefaults) =>
-    validate(
+    objValidate(
       skipDefaults ? values : addDefaultsToValues(values),
       (value, valueId) =>
         ifNotUndefined(
@@ -2263,16 +2327,20 @@ const createStore = () => {
       addedOrRemoved,
     );
   };
-  const cellChanged = (tableId, rowId, cellId, oldCell, newCell) =>
-    (mapEnsure(
+  const cellChanged = (tableId, rowId, cellId, oldCell, newCell) => {
+    mapEnsure(
       mapEnsure(mapEnsure(changedCells, tableId, mapNew), rowId, mapNew),
       cellId,
       () => [oldCell, 0],
-    )[1] = newCell);
+    )[1] = newCell;
+    internalListeners[3]?.(tableId, rowId, cellId, newCell);
+  };
   const valueIdsChanged = (valueId, addedOrRemoved) =>
     idsChanged(changedValueIds, valueId, addedOrRemoved);
-  const valueChanged = (valueId, oldValue, newValue) =>
-    (mapEnsure(changedValues, valueId, () => [oldValue, 0])[1] = newValue);
+  const valueChanged = (valueId, oldValue, newValue) => {
+    mapEnsure(changedValues, valueId, () => [oldValue, 0])[1] = newValue;
+    internalListeners[4]?.(valueId, newValue);
+  };
   const cellInvalid = (tableId, rowId, cellId, invalidCell, defaultedCell) => {
     arrayPush(
       mapEnsure(
@@ -2538,44 +2606,6 @@ const createStore = () => {
     transaction(() => actions(...arrayMap(args, id)));
     return store;
   };
-  const getTransactionChanges = () => [
-    mapToObj(
-      changedCells,
-      (table, tableId) =>
-        mapGet(changedTableIds, tableId) === -1
-          ? null
-          : mapToObj(
-              table,
-              (row, rowId) =>
-                mapGet(mapGet(changedRowIds, tableId), rowId) === -1
-                  ? null
-                  : mapToObj(
-                      row,
-                      ([, newCell]) => newCell ?? null,
-                      (_, changedCell) => pairIsEqual(changedCell),
-                    ),
-              objIsEmpty,
-            ),
-      objIsEmpty,
-    ),
-    mapToObj(
-      changedValues,
-      ([, newValue]) => newValue ?? null,
-      (_, changedValue) => pairIsEqual(changedValue),
-    ),
-  ];
-  const getTransactionLog = () => ({
-    cellsTouched,
-    valuesTouched,
-    changedCells: mapToObj3(changedCells, pairClone, pairIsEqual),
-    invalidCells: mapToObj3(invalidCells),
-    changedValues: mapToObj(changedValues, pairClone, pairIsEqual),
-    invalidValues: mapToObj(invalidValues),
-    changedTableIds: mapToObj(changedTableIds),
-    changedRowIds: mapToObj2(changedRowIds),
-    changedCellIds: mapToObj3(changedCellIds),
-    changedValueIds: mapToObj(changedValueIds),
-  });
   const getContent = () => [getTables(), getValues()];
   const getTables = () => mapToObj3(tablesMap);
   const getTableIds = () => mapKeys(tablesMap);
@@ -2619,12 +2649,13 @@ const createStore = () => {
     collHas(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId));
   const hasValues = () => !collIsEmpty(valuesMap);
   const hasValue = (valueId) => collHas(valuesMap, id(valueId));
-  const getTablesJson = () => jsonString(tablesMap);
-  const getValuesJson = () => jsonString(valuesMap);
-  const getJson = () => jsonString([tablesMap, valuesMap]);
-  const getTablesSchemaJson = () => jsonString(tablesSchemaMap);
-  const getValuesSchemaJson = () => jsonString(valuesSchemaMap);
-  const getSchemaJson = () => jsonString([tablesSchemaMap, valuesSchemaMap]);
+  const getTablesJson = () => jsonStringWithMap(tablesMap);
+  const getValuesJson = () => jsonStringWithMap(valuesMap);
+  const getJson = () => jsonStringWithMap([tablesMap, valuesMap]);
+  const getTablesSchemaJson = () => jsonStringWithMap(tablesSchemaMap);
+  const getValuesSchemaJson = () => jsonStringWithMap(valuesSchemaMap);
+  const getSchemaJson = () =>
+    jsonStringWithMap([tablesSchemaMap, valuesSchemaMap]);
   const setContent = ([tables, values]) =>
     fluentTransaction(() => {
       (objIsEmpty(tables) ? delTables : setTables)(tables);
@@ -2668,7 +2699,7 @@ const createStore = () => {
       (tableId2, rowId2) => {
         if (validateRow(tableId2, rowId2, partialRow, 1)) {
           const table = getOrCreateTable(tableId2);
-          objMap(partialRow, (cell, cellId) =>
+          objToArray(partialRow, (cell, cellId) =>
             setCellIntoDefaultRow(tableId2, table, rowId2, cellId, cell),
           );
         }
@@ -2706,7 +2737,7 @@ const createStore = () => {
   const setPartialValues = (partialValues) =>
     fluentTransaction(() =>
       validateValues(partialValues, 1)
-        ? objMap(partialValues, (value, valueId) =>
+        ? objToArray(partialValues, (value, valueId) =>
             setValidValue(valueId, value),
           )
         : 0,
@@ -2723,20 +2754,20 @@ const createStore = () => {
         ),
       valueId,
     );
-  const setTransactionChanges = (transactionChanges) =>
+  const applyChanges = (changes) =>
     fluentTransaction(() => {
-      objMap(transactionChanges[0], (table, tableId) =>
+      objToArray(changes[0], (table, tableId) =>
         isUndefined(table)
           ? delTable(tableId)
-          : objMap(table, (row, rowId) =>
+          : objToArray(table, (row, rowId) =>
               isUndefined(row)
                 ? delRow(tableId, rowId)
-                : objMap(row, (cell, cellId) =>
+                : objToArray(row, (cell, cellId) =>
                     setOrDelCell(store, tableId, rowId, cellId, cell),
                   ),
             ),
       );
-      objMap(transactionChanges[1], (value, valueId) =>
+      objToArray(changes[1], (value, valueId) =>
         setOrDelValue(store, valueId, value),
       );
     });
@@ -2863,31 +2894,66 @@ const createStore = () => {
       transactions++;
     }
     if (transactions == 1) {
-      callListeners(
-        startTransactionListeners,
-        void 0,
-        getTransactionChanges,
-        getTransactionLog,
-      );
+      internalListeners[0]?.();
+      callListeners(startTransactionListeners);
     }
     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 getTransactionLog = () => [
+    !collIsEmpty(changedCells),
+    !collIsEmpty(changedValues),
+    mapToObj3(changedCells, pairClone, pairIsEqual),
+    mapToObj3(invalidCells),
+    mapToObj(changedValues, pairClone, pairIsEqual),
+    mapToObj(invalidValues),
+    mapToObj(changedTableIds),
+    mapToObj2(changedRowIds),
+    mapToObj3(changedCellIds),
+    mapToObj(changedValueIds),
+  ];
   const finishTransaction = (doRollback) => {
     if (transactions > 0) {
       transactions--;
       if (transactions == 0) {
-        cellsTouched = !collIsEmpty(changedCells);
-        valuesTouched = !collIsEmpty(changedValues);
         transactions = 1;
         callInvalidCellListeners(1);
-        if (cellsTouched) {
+        if (!collIsEmpty(changedCells)) {
           callTabularListenersForChanges(1);
         }
         callInvalidValueListeners(1);
-        if (valuesTouched) {
+        if (!collIsEmpty(changedValues)) {
           callValuesListenersForChanges(1);
         }
-        if (doRollback?.(getTransactionChanges, getTransactionLog)) {
+        if (doRollback?.(store)) {
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
               collForEach(row, ([oldCell], cellId) =>
@@ -2895,34 +2961,26 @@ const createStore = () => {
               ),
             ),
           );
+          collClear(changedCells);
           collForEach(changedValues, ([oldValue], valueId) =>
             setOrDelValue(store, valueId, oldValue),
           );
-          cellsTouched = valuesTouched = false;
+          collClear(changedValues);
         }
-        callListeners(
-          finishTransactionListeners[0],
-          void 0,
-          getTransactionChanges,
-          getTransactionLog,
-        );
+        callListeners(finishTransactionListeners[0], void 0);
         transactions = -1;
         callInvalidCellListeners(0);
-        if (cellsTouched) {
+        if (!collIsEmpty(changedCells)) {
           callTabularListenersForChanges(0);
         }
         callInvalidValueListeners(0);
-        if (valuesTouched) {
+        if (!collIsEmpty(changedValues)) {
           callValuesListenersForChanges(0);
         }
-        callListeners(
-          finishTransactionListeners[1],
-          void 0,
-          getTransactionChanges,
-          getTransactionLog,
-        );
+        internalListeners[1]?.();
+        callListeners(finishTransactionListeners[1], void 0);
+        internalListeners[2]?.();
         transactions = 0;
-        cellsTouched = valuesTouched = false;
         hadTables = hasTables();
         hadValues = hasValues();
         arrayForEach(
@@ -3047,6 +3105,20 @@ const createStore = () => {
       collSize2(startTransactionListeners) +
       pairCollSize2(finishTransactionListeners),
   });
+  const setInternalListeners = (
+    preStartTransaction,
+    preFinishTransaction,
+    postFinishTransaction,
+    cellChanged2,
+    valueChanged2,
+  ) =>
+    (internalListeners = [
+      preStartTransaction,
+      preFinishTransaction,
+      postFinishTransaction,
+      cellChanged2,
+      valueChanged2,
+    ]);
   const store = {
     getContent,
     getTables,
@@ -3087,7 +3159,7 @@ const createStore = () => {
     setValues,
     setPartialValues,
     setValue,
-    setTransactionChanges,
+    applyChanges,
     setTablesJson,
     setValuesJson,
     setJson,
@@ -3105,6 +3177,8 @@ const createStore = () => {
     delSchema,
     transaction,
     startTransaction,
+    getTransactionChanges,
+    getTransactionLog,
     finishTransaction,
     forEachTable,
     forEachTableCell,
@@ -3122,8 +3196,9 @@ const createStore = () => {
     createStore,
     addListener,
     callListeners,
+    setInternalListeners,
   };
-  objMap(
+  objToArray(
     {
       [HAS + TABLES]: [0, hasTablesListeners, [], () => [hasTables()]],
       [TABLES]: [0, tablesListeners],
@@ -3204,10 +3279,13 @@ const App = ({position = 'right', open = false}) => {
     (s2) => createSessionPersister(s2, UNIQUE_ID),
     void 0,
     async (persister) => {
-      await persister.load(void 0, {
-        position: index == -1 ? 1 : index,
-        open: !!open,
-      });
+      await persister.load([
+        {},
+        {
+          position: index == -1 ? 1 : index,
+          open: !!open,
+        },
+      ]);
       await persister.startAutoSave();
     },
   );