tinybase 4.0.0-beta.0 → 4.0.0-beta.2

package/lib/debug/tinybase.js

@@ -1,5 +1,3 @@
-import {promises, watch} from 'fs';
-
 const getTypeOf = (thing) => typeof thing;
 const EMPTY_STRING = '';
 const STRING = getTypeOf(EMPTY_STRING);
@@ -8,7 +6,6 @@ const NUMBER = getTypeOf(0);
 const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
-const UTF8 = 'utf8';
 const SUM = 'sum';
 const AVG = 'avg';
 const MIN = 'min';
@@ -48,7 +45,6 @@ const arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);
 const arrayLength = (array) => array.length;
 const arrayIsEmpty = (array) => arrayLength(array) == 0;
 const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
-const arrayFilter = (array, cb) => array.filter(cb);
 const arraySlice = (array, start, end) => array.slice(start, end);
 const arrayClear = (array, to) => array.splice(0, to);
 const arrayPush = (array, ...values) => array.push(...values);
@@ -84,6 +80,19 @@ const isArray = (thing) => Array.isArray(thing);
 const test = (regex, subject) => regex.test(subject);
 const getUndefined = () => void 0;
 
+const object = Object;
+const objIds = object.keys;
+const objFrozen = object.isFrozen;
+const objFreeze = object.freeze;
+const isObject = (obj) =>
+  isInstanceOf(obj, object) && obj.constructor == object;
+const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+const objHas = (obj, id) => !isUndefined(objGet(obj, id));
+const objDel = (obj, id) => delete obj[id];
+const objMap = (obj, cb) =>
+  arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
+const objIsEmpty = (obj) => isObject(obj) && arrayIsEmpty(objIds(obj));
+
 const collSizeN = (collSizer) => (coll) =>
   arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
 const collSize = (coll) => coll.size;
@@ -112,23 +121,33 @@ const mapEnsure = (map, key, getDefaultValue) => {
   }
   return mapGet(map, key);
 };
-const mapToObj = (map, childMapper, childExclude) => {
+const mapToObj = (map, mapValue, excludeValue) => {
   const obj = {};
-  const mapper = childMapper ?? ((mapValue) => mapValue);
-  collForEach(map, (value, key) =>
-    ifNotUndefined(mapper(value), (mappedValue) =>
-      childExclude?.(mappedValue) ? 0 : (obj[key] = mappedValue),
-    ),
-  );
+  collForEach(map, (value, id) => {
+    const mappedValue = mapValue ? mapValue(value, id) : value;
+    excludeValue?.(mappedValue, value) ? 0 : (obj[id] = mappedValue);
+  });
   return obj;
 };
-const mapClone = (map, childMapper) => {
+const mapToObj2 = (map, mapValue, excludeValue) =>
+  mapToObj(
+    map,
+    (childMap) => mapToObj(childMap, mapValue, excludeValue),
+    objIsEmpty,
+  );
+const mapToObj3 = (map, mapValue, excludeValue) =>
+  mapToObj(
+    map,
+    (childMap) => mapToObj2(childMap, mapValue, excludeValue),
+    objIsEmpty,
+  );
+const mapClone = (map, mapValue) => {
   const map2 = mapNew();
-  const mapper = childMapper ?? ((mapValue) => mapValue);
-  collForEach(map, (value, key) => map2.set(key, mapper(value)));
+  collForEach(map, (value, key) => map2.set(key, mapValue?.(value) ?? value));
   return map2;
 };
 const mapClone2 = (map) => mapClone(map, mapClone);
+const mapClone3 = (map) => mapClone(map, mapClone2);
 const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
   ifNotUndefined(
     (ensureLeaf ? mapEnsure : mapGet)(
@@ -414,19 +433,6 @@ const getListenerFunctions = (getThing) => {
   return [addListener, callListeners, delListener, callListener];
 };
 
-const object = Object;
-const objIds = object.keys;
-const objFrozen = object.isFrozen;
-const objFreeze = object.freeze;
-const isObject = (obj) =>
-  isInstanceOf(obj, object) && obj.constructor == object;
-const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-const objHas = (obj, id) => !isUndefined(objGet(obj, id));
-const objDel = (obj, id) => delete obj[id];
-const objMap = (obj, cb) =>
-  arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
-const objIsEmpty = (obj) => isObject(obj) && arrayIsEmpty(objIds(obj));
-
 const createCheckpoints = getCreateFunction((store) => {
   let backwardIdsSize = 100;
   let currentId;
@@ -1016,72 +1022,86 @@ const createCustomPersister = (
   store,
   getPersisted,
   setPersisted,
-  startListeningToPersisted,
-  stopListeningToPersisted,
+  addPersisterListener,
+  delPersisterListener,
 ) => {
-  let tablesListenerId;
-  let valuesListenerId;
+  let listenerId;
   let loadSave = 0;
   let loads = 0;
   let saves = 0;
   let listening = false;
   let listeningHandle;
+  const loadLock = async (actions) => {
+    /* istanbul ignore else */
+    if (loadSave != 2) {
+      loadSave = 1;
+      {
+        loads++;
+      }
+      await actions();
+      loadSave = 0;
+    }
+  };
   const persister = {
     load: async (initialTables, initialValues) => {
-      /* istanbul ignore else */
-      if (loadSave != 2) {
-        loadSave = 1;
-        {
-          loads++;
-        }
-        const body = await getPersisted();
-        if (!isUndefined(body) && body != EMPTY_STRING) {
-          store.setJson(body);
-        } else {
-          store.transaction(() =>
-            store.setTables(initialTables).setValues(initialValues),
-          );
-        }
-        loadSave = 0;
-      }
+      await loadLock(async () => {
+        let content;
+        try {
+          content = await getPersisted();
+        } catch {}
+        store.setContent(content ?? [initialTables, initialValues]);
+      });
       return persister;
     },
     startAutoLoad: async (initialTables, initialValues) => {
       persister.stopAutoLoad();
       await persister.load(initialTables, initialValues);
       listening = true;
-      listeningHandle = startListeningToPersisted(persister.load);
+      listeningHandle = addPersisterListener(
+        async (getContent, getTransactionChanges) => {
+          await loadLock(async () => {
+            if (getTransactionChanges) {
+              store.setTransactionChanges(getTransactionChanges());
+            } else {
+              try {
+                store.setContent(getContent?.() ?? (await getPersisted()));
+              } catch {}
+            }
+          });
+        },
+      );
       return persister;
     },
     stopAutoLoad: () => {
       if (listening) {
-        stopListeningToPersisted(listeningHandle);
+        delPersisterListener(listeningHandle);
         listeningHandle = void 0;
         listening = false;
       }
       return persister;
     },
-    save: async () => {
+    save: async (getTransactionChanges) => {
       /* istanbul ignore else */
       if (loadSave != 1) {
         loadSave = 2;
         {
           saves++;
         }
-        await setPersisted(store.getJson());
+        await setPersisted(store.getContent, getTransactionChanges);
         loadSave = 0;
       }
       return persister;
     },
     startAutoSave: async () => {
       await persister.stopAutoSave().save();
-      tablesListenerId = store.addTablesListener(persister.save);
-      valuesListenerId = store.addValuesListener(persister.save);
+      listenerId = store.addDidFinishTransactionListener(
+        (_store, getTransactionChanges) =>
+          persister.save(getTransactionChanges),
+      );
       return persister;
     },
     stopAutoSave: () => {
-      ifNotUndefined(tablesListenerId, store.delListener);
-      ifNotUndefined(valuesListenerId, store.delListener);
+      ifNotUndefined(listenerId, store.delListener);
       return persister;
     },
     getStore: () => store,
@@ -1091,99 +1111,6 @@ const createCustomPersister = (
   return objFreeze(persister);
 };
 
-const STORAGE = 'storage';
-const WINDOW = globalThis.window;
-const getStoragePersister = (store, storageName, storage) => {
-  const getPersisted = async () => storage.getItem(storageName);
-  const setPersisted = async (json) => storage.setItem(storageName, json);
-  const startListeningToPersisted = (didChange) => {
-    const listener = (event) => {
-      if (event.storageArea === storage && event.key === storageName) {
-        didChange();
-      }
-    };
-    WINDOW.addEventListener(STORAGE, listener);
-    return listener;
-  };
-  const stopListeningToPersisted = (listener) =>
-    WINDOW.removeEventListener(STORAGE, listener);
-  return createCustomPersister(
-    store,
-    getPersisted,
-    setPersisted,
-    startListeningToPersisted,
-    stopListeningToPersisted,
-  );
-};
-const createLocalPersister = (store, storageName) =>
-  getStoragePersister(store, storageName, localStorage);
-const createSessionPersister = (store, storageName) =>
-  getStoragePersister(store, storageName, sessionStorage);
-
-const createFilePersister = (store, filePath) => {
-  const getPersisted = async () => {
-    try {
-      return await promises.readFile(filePath, UTF8);
-    } catch {}
-  };
-  const setPersisted = async (json) => {
-    try {
-      await promises.writeFile(filePath, json, UTF8);
-    } catch {}
-  };
-  const startListeningToPersisted = (didChange) => watch(filePath, didChange);
-  const stopListeningToPersisted = (watcher) => watcher?.close();
-  return createCustomPersister(
-    store,
-    getPersisted,
-    setPersisted,
-    startListeningToPersisted,
-    stopListeningToPersisted,
-  );
-};
-
-const getETag = (response) => response.headers.get('ETag');
-const createRemotePersister = (
-  store,
-  loadUrl,
-  saveUrl,
-  autoLoadIntervalSeconds,
-) => {
-  let lastEtag;
-  const getPersisted = async () => {
-    const response = await fetch(loadUrl);
-    lastEtag = getETag(response);
-    return response.text();
-  };
-  const setPersisted = async (json) =>
-    await fetch(saveUrl, {
-      method: 'POST',
-      headers: {'Content-Type': 'application/json'},
-      body: json,
-    });
-  const startListeningToPersisted = (didChange) =>
-    setInterval(async () => {
-      const response = await fetch(loadUrl, {method: 'HEAD'});
-      const currentEtag = getETag(response);
-      if (
-        !isUndefined(lastEtag) &&
-        !isUndefined(currentEtag) &&
-        currentEtag != lastEtag
-      ) {
-        lastEtag = currentEtag;
-        didChange();
-      }
-    }, autoLoadIntervalSeconds * 1e3);
-  const stopListeningToPersisted = (interval) => clearInterval(interval);
-  return createCustomPersister(
-    store,
-    getPersisted,
-    setPersisted,
-    startListeningToPersisted,
-    stopListeningToPersisted,
-  );
-};
-
 const createQueries = getCreateFunction((store) => {
   const createStore = store.createStore;
   const [
@@ -1813,16 +1740,12 @@ const createRelationships = getCreateFunction((store) => {
 const pairNew = (value) => [value, value];
 const pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);
 const pairNewMap = () => [mapNew(), mapNew()];
+const pairClone = (array) => [...array];
+const pairIsEqual = ([entry1, entry2]) => entry1 === entry2;
 
-const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
-  const idsToDelete = arrayFilter(
-    mapKeys(map),
-    (id2) => !objHas(toBeLikeObject, id2),
-  );
-  arrayForEach(objIds(toBeLikeObject), (id2) =>
-    setId(map, id2, toBeLikeObject[id2]),
-  );
-  arrayForEach(idsToDelete, (id2) => delId(map, id2));
+const mapMatch = (map, obj, set, del = mapSet) => {
+  objMap(obj, (value, id2) => set(map, id2, value));
+  mapForEach(map, (id2) => (objHas(obj, id2) ? 0 : del(map, id2)));
   return map;
 };
 const validate = (obj, validateChild, onInvalidObj) => {
@@ -1837,8 +1760,12 @@ const validate = (obj, validateChild, onInvalidObj) => {
   });
   return !objIsEmpty(obj);
 };
-const idsChanged = (changedIds, id2, added) =>
-  mapSet(changedIds, id2, mapGet(changedIds, id2) == -added ? void 0 : added);
+const idsChanged = (changedIds, id2, addedOrRemoved) =>
+  mapSet(
+    changedIds,
+    id2,
+    mapGet(changedIds, id2) == -addedOrRemoved ? void 0 : addedOrRemoved,
+  );
 const createStore = () => {
   let hasTablesSchema;
   let hasValuesSchema;
@@ -1995,13 +1922,13 @@ const createStore = () => {
     return values;
   };
   const setValidTablesSchema = (tablesSchema) =>
-    transformMap(
+    mapMatch(
       tablesSchemaMap,
       tablesSchema,
       (_tablesSchema, tableId, tableSchema) => {
         const rowDefaulted = mapNew();
         const rowNonDefaulted = setNew();
-        transformMap(
+        mapMatch(
           mapEnsure(tablesSchemaMap, tableId, mapNew),
           tableSchema,
           (tableSchemaMap, cellId, cellSchema) => {
@@ -2021,7 +1948,7 @@ const createStore = () => {
       },
     );
   const setValidValuesSchema = (valuesSchema) =>
-    transformMap(
+    mapMatch(
       valuesSchemaMap,
       valuesSchema,
       (_valuesSchema, valueId, valueSchema) => {
@@ -2041,14 +1968,14 @@ const createStore = () => {
   const setOrDelTables = (tables) =>
     objIsEmpty(tables) ? delTables() : setTables(tables);
   const setValidTables = (tables) =>
-    transformMap(
+    mapMatch(
       tablesMap,
       tables,
       (_tables, tableId, table) => setValidTable(tableId, table),
       (_tables, tableId) => delValidTable(tableId),
     );
   const setValidTable = (tableId, table) =>
-    transformMap(
+    mapMatch(
       mapEnsure(tablesMap, tableId, () => {
         tableIdsChanged(tableId, 1);
         return mapNew();
@@ -2058,7 +1985,7 @@ const createStore = () => {
       (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
     );
   const setValidRow = (tableId, tableMap, rowId, row, forceDel) =>
-    transformMap(
+    mapMatch(
       mapEnsure(tableMap, rowId, () => {
         rowIdsChanged(tableId, rowId, 1);
         return mapNew();
@@ -2094,7 +2021,7 @@ const createStore = () => {
   const setOrDelValues = (values) =>
     objIsEmpty(values) ? delValues() : setValues(values);
   const setValidValues = (values) =>
-    transformMap(
+    mapMatch(
       valuesMap,
       values,
       (_valuesMap, valueId, value) => setValidValue(valueId, value),
@@ -2162,15 +2089,19 @@ const createStore = () => {
     valueIdsChanged(valueId, -1);
     mapSet(valuesMap, valueId);
   };
-  const tableIdsChanged = (tableId, added) =>
-    idsChanged(changedTableIds, tableId, added);
-  const rowIdsChanged = (tableId, rowId, added) =>
-    idsChanged(mapEnsure(changedRowIds, tableId, mapNew), rowId, added);
-  const cellIdsChanged = (tableId, rowId, cellId, added) =>
+  const tableIdsChanged = (tableId, addedOrRemoved) =>
+    idsChanged(changedTableIds, tableId, addedOrRemoved);
+  const rowIdsChanged = (tableId, rowId, addedOrRemoved) =>
+    idsChanged(
+      mapEnsure(changedRowIds, tableId, mapNew),
+      rowId,
+      addedOrRemoved,
+    );
+  const cellIdsChanged = (tableId, rowId, cellId, addedOrRemoved) =>
     idsChanged(
       mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, mapNew),
       cellId,
-      added,
+      addedOrRemoved,
     );
   const cellChanged = (tableId, rowId, cellId, oldCell, newCell) =>
     (mapEnsure(
@@ -2178,8 +2109,8 @@ const createStore = () => {
       cellId,
       () => [oldCell, 0],
     )[1] = newCell);
-  const valueIdsChanged = (valueId, added) =>
-    idsChanged(changedValueIds, valueId, added);
+  const valueIdsChanged = (valueId, addedOrRemoved) =>
+    idsChanged(changedValueIds, valueId, addedOrRemoved);
   const valueChanged = (valueId, oldValue, newValue) =>
     (mapEnsure(changedValues, valueId, () => [oldValue, 0])[1] = newValue);
   const cellInvalid = (tableId, rowId, cellId, invalidCell, defaultedCell) => {
@@ -2215,7 +2146,7 @@ const createStore = () => {
   const callInvalidCellListeners = (mutator) =>
     !collIsEmpty(invalidCells) && !collIsEmpty(invalidCellListeners[mutator])
       ? collForEach(
-          mutator ? mapClone(invalidCells, mapClone2) : invalidCells,
+          mutator ? mapClone3(invalidCells) : invalidCells,
           (rows, tableId) =>
             collForEach(rows, (cells, rowId) =>
               collForEach(cells, (invalidCell, cellId) =>
@@ -2265,8 +2196,8 @@ const createStore = () => {
         ? [
             mapClone(changedTableIds),
             mapClone2(changedRowIds),
-            mapClone(changedCellIds, mapClone2),
-            mapClone(changedCells, mapClone2),
+            mapClone3(changedCellIds),
+            mapClone3(changedCells),
           ]
         : [changedTableIds, changedRowIds, changedCellIds, changedCells];
       if (!emptyIdListeners) {
@@ -2384,11 +2315,48 @@ const createStore = () => {
     transaction(() => actions(...arrayMap(args, id)));
     return store;
   };
-  const getTables = () =>
-    mapToObj(tablesMap, (table) => mapToObj(table, mapToObj));
+  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);
-  const getTable = (tableId) =>
-    mapToObj(mapGet(tablesMap, id(tableId)), mapToObj);
+  const getTable = (tableId) => mapToObj2(mapGet(tablesMap, id(tableId)));
   const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, id(tableId)));
   const getSortedRowIds = (tableId, cellId, descending, offset = 0, limit) =>
     arrayMap(
@@ -2429,6 +2397,11 @@ const createStore = () => {
   const getTablesSchemaJson = () => jsonString(tablesSchemaMap);
   const getValuesSchemaJson = () => jsonString(valuesSchemaMap);
   const getSchemaJson = () => jsonString([tablesSchemaMap, valuesSchemaMap]);
+  const setContent = ([tables, values]) =>
+    fluentTransaction(() => {
+      setTables(tables);
+      setValues(values);
+    });
   const setTables = (tables) =>
     fluentTransaction(() =>
       validateTables(tables) ? setValidTables(tables) : 0,
@@ -2522,6 +2495,23 @@ const createStore = () => {
         ),
       valueId,
     );
+  const setTransactionChanges = (transactionChanges) =>
+    fluentTransaction(() => {
+      objMap(transactionChanges[0], (table, tableId) =>
+        isUndefined(table)
+          ? delTable(tableId)
+          : objMap(table, (row, rowId) =>
+              isUndefined(row)
+                ? delRow(tableId, rowId)
+                : objMap(row, (cell, cellId) =>
+                    setOrDelCell(store, tableId, rowId, cellId, cell),
+                  ),
+            ),
+      );
+      objMap(transactionChanges[1], (value, valueId) =>
+        setOrDelValue(store, valueId, value),
+      );
+    });
   const setTablesJson = (tablesJson) => {
     try {
       setOrDelTables(jsonParse(tablesJson));
@@ -2661,32 +2651,7 @@ const createStore = () => {
           callKeyedValuesListenersForChanges(1);
         }
         transactions = -1;
-        if (
-          doRollback?.(
-            mapToObj(
-              changedCells,
-              (table) =>
-                mapToObj(
-                  table,
-                  (row) =>
-                    mapToObj(
-                      row,
-                      (cells) => [...cells],
-                      ([oldCell, newCell]) => oldCell === newCell,
-                    ),
-                  objIsEmpty,
-                ),
-              objIsEmpty,
-            ),
-            mapToObj(invalidCells, (map) => mapToObj(map, mapToObj)),
-            mapToObj(
-              changedValues,
-              (values) => [...values],
-              ([oldValue, newValue]) => oldValue === newValue,
-            ),
-            mapToObj(invalidValues),
-          )
-        ) {
+        if (doRollback?.(getTransactionChanges, getTransactionLog)) {
           transactions = 1;
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
@@ -2704,8 +2669,8 @@ const createStore = () => {
         callListeners(
           finishTransactionListeners[0],
           void 0,
-          cellsTouched,
-          valuesTouched,
+          getTransactionChanges,
+          getTransactionLog,
         );
         callInvalidCellListeners(0);
         if (cellsTouched) {
@@ -2718,8 +2683,8 @@ const createStore = () => {
         callListeners(
           finishTransactionListeners[1],
           void 0,
-          cellsTouched,
-          valuesTouched,
+          getTransactionChanges,
+          getTransactionLog,
         );
         transactions = 0;
         arrayForEach(
@@ -2828,6 +2793,7 @@ const createStore = () => {
     transaction: pairCollSize2(finishTransactionListeners),
   });
   const store = {
+    getContent,
     getTables,
     getTableIds,
     getTable,
@@ -2851,6 +2817,7 @@ const createStore = () => {
     getTablesSchemaJson,
     getValuesSchemaJson,
     getSchemaJson,
+    setContent,
     setTables,
     setTable,
     setRow,
@@ -2860,6 +2827,7 @@ const createStore = () => {
     setValues,
     setPartialValues,
     setValue,
+    setTransactionChanges,
     setTablesJson,
     setValuesJson,
     setJson,
@@ -2932,14 +2900,10 @@ const createStore = () => {
 export {
   createCheckpoints,
   createCustomPersister,
-  createFilePersister,
   createIndexes,
-  createLocalPersister,
   createMetrics,
   createQueries,
   createRelationships,
-  createRemotePersister,
-  createSessionPersister,
   createStore,
   defaultSorter,
 };

package/lib/debug/tools.js

@@ -48,6 +48,15 @@ const getCellOrValueType = (cell) => {
     : void 0;
 };
 
+const object = Object;
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const isObject = (obj) =>
+  isInstanceOf(obj, object) && obj.constructor == object;
+const objMap = (obj, cb) =>
+  arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
+const objIsEmpty = (obj) => isObject(obj) && arrayIsEmpty(objIds(obj));
+
 const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
 const collValues = (coll) => [...(coll?.values() ?? [])];
 const collForEach = (coll, cb) => coll?.forEach(cb);
@@ -349,15 +358,6 @@ const getCodeFunctions = () => {
   ];
 };
 
-const object = Object;
-const objIds = object.keys;
-const objFreeze = object.freeze;
-const isObject = (obj) =>
-  isInstanceOf(obj, object) && obj.constructor == object;
-const objMap = (obj, cb) =>
-  arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
-const objIsEmpty = (obj) => isObject(obj) && arrayIsEmpty(objIds(obj));
-
 const getCreateFunction = (getFunction) => {
   const getFunctionsByStore = /* @__PURE__ */ new WeakMap();
   return (store) => {