tinybase 1.0.2 → 1.0.3

package/lib/debug/store.js

@@ -0,0 +1,725 @@
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_OBJECT = '{}';
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const BOOLEAN = getTypeOf(true);
+const NUMBER = getTypeOf(0);
+const FUNCTION = getTypeOf(getTypeOf);
+const TYPE = 'type';
+const DEFAULT = 'default';
+
+const arrayHas = (array, value) => array.includes(value);
+const arrayForEach = (array, cb) => array.forEach(cb);
+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 arrayFromSecond = (ids) => ids.slice(1);
+
+const jsonString = (obj) =>
+  JSON.stringify(obj, (_key, value) =>
+    isInstanceOf(value, Map)
+      ? arrayReduce(
+          [...value],
+          (obj2, [key, value2]) => {
+            obj2[key] = value2;
+            return obj2;
+          },
+          {},
+        )
+      : value,
+  );
+const jsonParse = JSON.parse;
+const isFiniteNumber = isFinite;
+const isInstanceOf = (thing, cls) => thing instanceof cls;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
+const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
+
+const collSizeN = (collSizer) => (coll) =>
+  arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
+const collSize = (coll) => coll.size;
+const collSize2 = collSizeN(collSize);
+const collSize3 = collSizeN(collSize2);
+const collSize4 = collSizeN(collSize3);
+const collPairSize = (pair, func = collSize) => func(pair[0]) + func(pair[1]);
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collClear = (coll) => coll.clear();
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapNewPair = (newFunction = mapNew) => [newFunction(), newFunction()];
+const mapKeys = (map) => [...(map?.keys() ?? [])];
+const mapGet = (map, key) => map?.get(key);
+const mapForEach = (map, cb) =>
+  collForEach(map, (value, key) => cb(key, value));
+const mapSet = (map, key, value) =>
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
+const mapEnsure = (map, key, defaultValue, onWillAdd) => {
+  if (!collHas(map, key)) {
+    onWillAdd?.(defaultValue);
+    map.set(key, defaultValue);
+  }
+  return mapGet(map, key);
+};
+const mapToObj = (map, childMapper) => {
+  const obj = {};
+  const mapper = childMapper ?? ((mapValue) => mapValue);
+  collForEach(map, (value, key) => (obj[key] = mapper(value)));
+  return obj;
+};
+const mapClone = (map, childMapper) => {
+  const map2 = mapNew();
+  const mapper = childMapper ?? ((mapValue) => mapValue);
+  collForEach(map, (value, key) => map2.set(key, mapper(value)));
+  return map2;
+};
+
+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 objForEach = (obj, cb) =>
+  arrayForEach(object.entries(obj), ([id, value]) => cb(value, id));
+const objIsEmpty = (obj) => arrayIsEmpty(objIds(obj));
+
+const setNew = (entries) => new Set(entries);
+const setAdd = (set, value) => set?.add(value);
+
+const addDeepSet = (deepSet, value, ids) =>
+  arrayLength(ids) < 2
+    ? setAdd(
+        arrayIsEmpty(ids) ? deepSet : mapEnsure(deepSet, ids[0], setNew()),
+        value,
+      )
+    : addDeepSet(
+        mapEnsure(deepSet, ids[0], mapNew()),
+        value,
+        arrayFromSecond(ids),
+      );
+const forDeepSet = (valueDo) => {
+  const deep = (deepIdSet, arg, ...ids) =>
+    ifNotUndefined(deepIdSet, (deepIdSet2) =>
+      arrayIsEmpty(ids)
+        ? valueDo(deepIdSet2, arg)
+        : arrayForEach([ids[0], null], (id) =>
+            deep(mapGet(deepIdSet2, id), arg, ...arrayFromSecond(ids)),
+          ),
+    );
+  return deep;
+};
+const getListenerFunctions = (getThing) => {
+  let thing;
+  let nextId = 0;
+  const listenerPool = [];
+  const allListeners = mapNew();
+  const addListener = (listener, deepSet, idOrNulls = []) => {
+    thing ??= getThing();
+    const id = listenerPool.pop() ?? '' + nextId++;
+    mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
+    addDeepSet(deepSet, id, idOrNulls);
+    return id;
+  };
+  const callListeners = (deepSet, ids = [], ...extraArgs) =>
+    forDeepSet(collForEach)(
+      deepSet,
+      (id) =>
+        ifNotUndefined(mapGet(allListeners, id), ([listener]) =>
+          listener(thing, ...ids, ...extraArgs),
+        ),
+      ...ids,
+    );
+  const delListener = (id) =>
+    ifNotUndefined(
+      mapGet(allListeners, id),
+      ([, deepSet, idOrNulls]) => {
+        forDeepSet(collDel)(deepSet, id, ...idOrNulls);
+        mapSet(allListeners, id);
+        if (arrayLength(listenerPool) < 1e3) {
+          listenerPool.push(id);
+        }
+        return idOrNulls;
+      },
+      () => [],
+    );
+  const callListener = (id, idNullGetters, extraArgsGetter) =>
+    ifNotUndefined(mapGet(allListeners, id), ([listener, , idOrNulls]) => {
+      const callWithIds = (...ids) => {
+        const index = arrayLength(ids);
+        index == arrayLength(idOrNulls)
+          ? listener(thing, ...ids, ...extraArgsGetter(ids))
+          : isUndefined(idOrNulls[index])
+          ? arrayForEach(idNullGetters[index](...ids), (id2) =>
+              callWithIds(...ids, id2),
+            )
+          : callWithIds(...ids, idOrNulls[index]);
+      };
+      callWithIds();
+    });
+  return [addListener, callListeners, delListener, callListener];
+};
+
+const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
+  const idsToDelete = arrayFilter(
+    mapKeys(map),
+    (id) => !objHas(toBeLikeObject, id),
+  );
+  arrayForEach(objIds(toBeLikeObject), (id) =>
+    setId(map, id, toBeLikeObject[id]),
+  );
+  arrayForEach(idsToDelete, (id) => delId(map, id));
+  return map;
+};
+const getCellType = (cell) => {
+  const type = getTypeOf(cell);
+  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+    ? type
+    : void 0;
+};
+const validate = (obj, validateChild) => {
+  if (isUndefined(obj) || !isObject(obj) || objFrozen(obj)) {
+    return false;
+  }
+  objForEach(obj, (child, id) => {
+    if (!validateChild(child, id)) {
+      objDel(obj, id);
+    }
+  });
+  return !objIsEmpty(obj);
+};
+const idsChanged = (ids, id, added) =>
+  mapSet(ids, id, mapGet(ids, id) == -added ? void 0 : added);
+const createStore = () => {
+  let hasSchema;
+  let nextRowId = 0;
+  let transactions = 0;
+  const changedTableIds = mapNew();
+  const changedRowIds = mapNew();
+  const changedCellIds = mapNew();
+  const changedCells = mapNew();
+  const schemaMap = mapNew();
+  const schemaDefaultRows = mapNew();
+  const tablesMap = mapNew();
+  const tablesListeners = mapNewPair(setNew);
+  const tableIdsListeners = mapNewPair(setNew);
+  const tableListeners = mapNewPair();
+  const rowIdsListeners = mapNewPair();
+  const rowListeners = mapNewPair();
+  const cellIdsListeners = mapNewPair();
+  const cellListeners = mapNewPair();
+  const [addListener, callListeners, delListenerImpl, callListenerImpl] =
+    getListenerFunctions(() => store);
+  const validateSchema = (schema) =>
+    validate(schema, (tableSchema) =>
+      validate(tableSchema, (cellSchema) => {
+        if (
+          !validate(cellSchema, (_child, id) => arrayHas([TYPE, DEFAULT], id))
+        ) {
+          return false;
+        }
+        const type = cellSchema[TYPE];
+        if (!isTypeStringOrBoolean(type) && type != NUMBER) {
+          return false;
+        }
+        if (getCellType(cellSchema[DEFAULT]) != type) {
+          objDel(cellSchema, DEFAULT);
+        }
+        return true;
+      }),
+    );
+  const validateTables = (tables) => validate(tables, validateTable);
+  const validateTable = (table, tableId) =>
+    (!hasSchema || collHas(schemaMap, tableId)) &&
+    validate(table, (row) => validateRow(tableId, row));
+  const validateRow = (tableId, row, skipDefaults) =>
+    validate(
+      skipDefaults ? row : addDefaultsToRow(row, tableId),
+      (cell, cellId) =>
+        ifNotUndefined(
+          getValidatedCell(tableId, cellId, cell),
+          (validCell) => {
+            row[cellId] = validCell;
+            return true;
+          },
+          () => false,
+        ),
+    );
+  const getValidatedCell = (tableId, cellId, cell) =>
+    hasSchema
+      ? ifNotUndefined(
+          mapGet(mapGet(schemaMap, tableId), cellId),
+          (cellSchema) =>
+            getCellType(cell) != cellSchema[TYPE] ? cellSchema[DEFAULT] : cell,
+        )
+      : isUndefined(getCellType(cell))
+      ? void 0
+      : cell;
+  const addDefaultsToRow = (row, tableId) => {
+    ifNotUndefined(mapGet(schemaDefaultRows, tableId), (defaultRow) =>
+      objForEach(defaultRow, (cell, cellId) => {
+        if (!objHas(row, cellId)) {
+          row[cellId] = cell;
+        }
+      }),
+    );
+    return row;
+  };
+  const setValidSchema = (schema) =>
+    transformMap(
+      schemaMap,
+      schema,
+      (_schema, tableId, tableSchema) => {
+        const defaultRow = {};
+        transformMap(
+          mapEnsure(schemaMap, tableId, mapNew()),
+          tableSchema,
+          (tableSchemaMap, cellId, cellSchema) => {
+            mapSet(tableSchemaMap, cellId, cellSchema);
+            ifNotUndefined(
+              cellSchema[DEFAULT],
+              (def) => (defaultRow[cellId] = def),
+            );
+          },
+        );
+        mapSet(schemaDefaultRows, tableId, defaultRow);
+      },
+      (_schema, tableId) => {
+        mapSet(schemaMap, tableId);
+        mapSet(schemaDefaultRows, tableId);
+      },
+    );
+  const setValidTables = (tables) =>
+    transformMap(
+      tablesMap,
+      tables,
+      (_tables, tableId, table) => setValidTable(tableId, table),
+      (_tables, tableId) => delValidTable(tableId),
+    );
+  const setValidTable = (tableId, table) =>
+    transformMap(
+      mapEnsure(tablesMap, tableId, mapNew(), () =>
+        tableIdsChanged(tableId, 1),
+      ),
+      table,
+      (tableMap, rowId, row) => setValidRow(tableId, tableMap, rowId, row),
+      (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
+    );
+  const setValidRow = (tableId, tableMap, rowId, newRow, forceDel) =>
+    transformMap(
+      mapEnsure(tableMap, rowId, mapNew(), () =>
+        rowIdsChanged(tableId, rowId, 1),
+      ),
+      newRow,
+      (rowMap, cellId, cell) =>
+        setValidCell(tableId, rowId, rowMap, cellId, cell),
+      (rowMap, cellId) =>
+        delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
+    );
+  const setValidCell = (tableId, rowId, rowMap, cellId, newCell) => {
+    if (!collHas(rowMap, cellId)) {
+      cellIdsChanged(tableId, rowId, cellId, 1);
+    }
+    const oldCell = mapGet(rowMap, cellId);
+    if (newCell !== oldCell) {
+      cellChanged(tableId, rowId, cellId, oldCell);
+      mapSet(rowMap, cellId, newCell);
+    }
+  };
+  const setValidRowTransaction = (tableId, rowId, row) =>
+    transaction(() =>
+      setValidRow(tableId, getOrCreateTable(tableId), rowId, row),
+    );
+  const setCellIntoDefaultRow = (tableId, tableMap, rowId, cellId, validCell) =>
+    ifNotUndefined(
+      mapGet(tableMap, rowId),
+      (rowMap) => setValidCell(tableId, rowId, rowMap, cellId, validCell),
+      () =>
+        setValidRow(
+          tableId,
+          tableMap,
+          rowId,
+          addDefaultsToRow({[cellId]: validCell}, tableId),
+        ),
+    );
+  const getNewRowId = (tableMap) => {
+    const rowId = '' + nextRowId++;
+    if (!collHas(tableMap, rowId)) {
+      return rowId;
+    }
+    return getNewRowId(tableMap);
+  };
+  const getOrCreateTable = (tableId) =>
+    mapGet(tablesMap, tableId) ?? setValidTable(tableId, {});
+  const delValidTable = (tableId) => setValidTable(tableId, {});
+  const delValidRow = (tableId, tableMap, rowId) =>
+    setValidRow(tableId, tableMap, rowId, {}, true);
+  const delValidCell = (tableId, table, rowId, row, cellId, forceDel) => {
+    const defaultCell = mapGet(schemaDefaultRows, tableId)?.[cellId];
+    if (!isUndefined(defaultCell) && !forceDel) {
+      return setValidCell(tableId, rowId, row, cellId, defaultCell);
+    }
+    const delCell2 = (cellId2) => {
+      cellChanged(tableId, rowId, cellId2, mapGet(row, cellId2));
+      cellIdsChanged(tableId, rowId, cellId2, -1);
+      mapSet(row, cellId2);
+    };
+    isUndefined(defaultCell) ? delCell2(cellId) : mapForEach(row, delCell2);
+    if (collIsEmpty(row)) {
+      rowIdsChanged(tableId, rowId, -1);
+      if (collIsEmpty(mapSet(table, rowId))) {
+        tableIdsChanged(tableId, -1);
+        mapSet(tablesMap, tableId);
+      }
+    }
+  };
+  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) =>
+    idsChanged(
+      mapEnsure(mapEnsure(changedCellIds, tableId, mapNew()), rowId, mapNew()),
+      cellId,
+      added,
+    );
+  const cellChanged = (tableId, rowId, cellId, oldCell) =>
+    mapEnsure(
+      mapEnsure(mapEnsure(changedCells, tableId, mapNew()), rowId, mapNew()),
+      cellId,
+      oldCell,
+    );
+  const getCellChange = (tableId, rowId, cellId) => {
+    const changedRow = mapGet(mapGet(changedCells, tableId), rowId);
+    const newCell = getCell(tableId, rowId, cellId);
+    return collHas(changedRow, cellId)
+      ? [true, mapGet(changedRow, cellId), newCell]
+      : [false, newCell, newCell];
+  };
+  const callListenersForChanges = (mutator) => {
+    const emptyIdListeners =
+      collIsEmpty(cellIdsListeners[mutator]) &&
+      collIsEmpty(rowIdsListeners[mutator]) &&
+      collIsEmpty(tableIdsListeners[mutator]);
+    const emptyOtherListeners =
+      collIsEmpty(cellListeners[mutator]) &&
+      collIsEmpty(rowListeners[mutator]) &&
+      collIsEmpty(tableListeners[mutator]) &&
+      collIsEmpty(tablesListeners[mutator]);
+    if (emptyIdListeners && emptyOtherListeners) {
+      return;
+    }
+    const changes = mutator
+      ? [
+          mapClone(changedTableIds),
+          mapClone(changedRowIds, mapClone),
+          mapClone(changedCellIds, (table) => mapClone(table, mapClone)),
+          mapClone(changedCells, (table) => mapClone(table, mapClone)),
+        ]
+      : [changedTableIds, changedRowIds, changedCellIds, changedCells];
+    if (!emptyIdListeners) {
+      collForEach(changes[2], (rowCellIds, tableId) =>
+        collForEach(rowCellIds, (changedIds, rowId) => {
+          if (!collIsEmpty(changedIds)) {
+            callListeners(cellIdsListeners[mutator], [tableId, rowId]);
+          }
+        }),
+      );
+      collForEach(changes[1], (changedIds, tableId) => {
+        if (!collIsEmpty(changedIds)) {
+          callListeners(rowIdsListeners[mutator], [tableId]);
+        }
+      });
+      if (!collIsEmpty(changes[0])) {
+        callListeners(tableIdsListeners[mutator]);
+      }
+    }
+    if (!emptyOtherListeners) {
+      let tablesChanged;
+      collForEach(changes[3], (rows, tableId) => {
+        let tableChanged;
+        collForEach(rows, (cells, rowId) => {
+          let rowChanged;
+          collForEach(cells, (oldCell, cellId) => {
+            const newCell = getCell(tableId, rowId, cellId);
+            if (newCell !== oldCell) {
+              callListeners(
+                cellListeners[mutator],
+                [tableId, rowId, cellId],
+                newCell,
+                oldCell,
+                getCellChange,
+              );
+              tablesChanged = tableChanged = rowChanged = 1;
+            }
+          });
+          if (rowChanged) {
+            callListeners(
+              rowListeners[mutator],
+              [tableId, rowId],
+              getCellChange,
+            );
+          }
+        });
+        if (tableChanged) {
+          callListeners(tableListeners[mutator], [tableId], getCellChange);
+        }
+      });
+      if (tablesChanged) {
+        callListeners(tablesListeners[mutator], [], getCellChange);
+      }
+    }
+  };
+  const getTables = () =>
+    mapToObj(tablesMap, (tableMap) => mapToObj(tableMap, mapToObj));
+  const getTableIds = () => mapKeys(tablesMap);
+  const getTable = (tableId) => mapToObj(mapGet(tablesMap, tableId), mapToObj);
+  const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, tableId));
+  const getRow = (tableId, rowId) =>
+    mapToObj(mapGet(mapGet(tablesMap, tableId), rowId));
+  const getCellIds = (tableId, rowId) =>
+    mapKeys(mapGet(mapGet(tablesMap, tableId), rowId));
+  const getCell = (tableId, rowId, cellId) =>
+    mapGet(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
+  const hasTable = (tableId) => collHas(tablesMap, tableId);
+  const hasRow = (tableId, rowId) => collHas(mapGet(tablesMap, tableId), rowId);
+  const hasCell = (tableId, rowId, cellId) =>
+    collHas(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
+  const getJson = () => jsonString(tablesMap);
+  const getSchemaJson = () => jsonString(schemaMap);
+  const setTables = (tables) => {
+    if (validateTables(tables)) {
+      transaction(() => setValidTables(tables));
+    }
+    return store;
+  };
+  const setTable = (tableId, table) => {
+    if (validateTable(table, tableId)) {
+      transaction(() => setValidTable(tableId, table));
+    }
+    return store;
+  };
+  const setRow = (tableId, rowId, row) => {
+    if (validateRow(tableId, row)) {
+      setValidRowTransaction(tableId, rowId, row);
+    }
+    return store;
+  };
+  const addRow = (tableId, row) => {
+    let rowId = void 0;
+    if (validateRow(tableId, row)) {
+      rowId = getNewRowId(mapGet(tablesMap, tableId));
+      setValidRowTransaction(tableId, rowId, row);
+    }
+    return rowId;
+  };
+  const setPartialRow = (tableId, rowId, partialRow) => {
+    if (validateRow(tableId, partialRow, 1)) {
+      transaction(() => {
+        const table = getOrCreateTable(tableId);
+        objForEach(partialRow, (cell, cellId) =>
+          setCellIntoDefaultRow(tableId, table, rowId, cellId, cell),
+        );
+      });
+    }
+    return store;
+  };
+  const setCell = (tableId, rowId, cellId, cell) => {
+    ifNotUndefined(
+      getValidatedCell(
+        tableId,
+        cellId,
+        isFunction(cell) ? cell(getCell(tableId, rowId, cellId)) : cell,
+      ),
+      (validCell) =>
+        transaction(() =>
+          setCellIntoDefaultRow(
+            tableId,
+            getOrCreateTable(tableId),
+            rowId,
+            cellId,
+            validCell,
+          ),
+        ),
+    );
+    return store;
+  };
+  const setJson = (json) => {
+    try {
+      json === EMPTY_OBJECT ? delTables() : setTables(jsonParse(json));
+    } catch {}
+    return store;
+  };
+  const setSchema = (schema) => {
+    if ((hasSchema = validateSchema(schema))) {
+      setValidSchema(schema);
+      if (!collIsEmpty(tablesMap)) {
+        const tables = getTables();
+        delTables();
+        setTables(tables);
+      }
+    }
+    return store;
+  };
+  const delTables = () => {
+    transaction(() => setValidTables({}));
+    return store;
+  };
+  const delTable = (tableId) => {
+    if (collHas(tablesMap, tableId)) {
+      transaction(() => delValidTable(tableId));
+    }
+    return store;
+  };
+  const delRow = (tableId, rowId) => {
+    ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) => {
+      if (collHas(tableMap, rowId)) {
+        transaction(() => delValidRow(tableId, tableMap, rowId));
+      }
+    });
+    return store;
+  };
+  const delCell = (tableId, rowId, cellId, forceDel) => {
+    ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) =>
+      ifNotUndefined(mapGet(tableMap, rowId), (rowMap) => {
+        if (collHas(rowMap, cellId)) {
+          transaction(() =>
+            delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
+          );
+        }
+      }),
+    );
+    return store;
+  };
+  const delSchema = () => {
+    setValidSchema({});
+    hasSchema = false;
+    return store;
+  };
+  const transaction = (actions) => {
+    if (transactions == -1) {
+      return;
+    }
+    transactions++;
+    const result = actions();
+    transactions--;
+    if (transactions == 0) {
+      transactions = 1;
+      callListenersForChanges(1);
+      transactions = -1;
+      callListenersForChanges(0);
+      transactions = 0;
+      arrayForEach(
+        [changedCells, changedTableIds, changedRowIds, changedCellIds],
+        collClear,
+      );
+    }
+    return result;
+  };
+  const forEachTable = (tableCallback) =>
+    collForEach(tablesMap, (tableMap, tableId) =>
+      tableCallback(tableId, (rowCallback) =>
+        collForEach(tableMap, (rowMap, rowId) =>
+          rowCallback(rowId, (cellCallback) =>
+            mapForEach(rowMap, cellCallback),
+          ),
+        ),
+      ),
+    );
+  const forEachRow = (tableId, rowCallback) =>
+    collForEach(mapGet(tablesMap, tableId), (rowMap, rowId) =>
+      rowCallback(rowId, (cellCallback) => mapForEach(rowMap, cellCallback)),
+    );
+  const forEachCell = (tableId, rowId, cellCallback) =>
+    mapForEach(mapGet(mapGet(tablesMap, tableId), rowId), cellCallback);
+  const addTablesListener = (listener, mutator) =>
+    addListener(listener, tablesListeners[mutator ? 1 : 0]);
+  const addTableIdsListener = (listener, mutator) =>
+    addListener(listener, tableIdsListeners[mutator ? 1 : 0]);
+  const addTableListener = (tableId, listener, mutator) =>
+    addListener(listener, tableListeners[mutator ? 1 : 0], [tableId]);
+  const addRowIdsListener = (tableId, listener, mutator) =>
+    addListener(listener, rowIdsListeners[mutator ? 1 : 0], [tableId]);
+  const addRowListener = (tableId, rowId, listener, mutator) =>
+    addListener(listener, rowListeners[mutator ? 1 : 0], [tableId, rowId]);
+  const addCellIdsListener = (tableId, rowId, listener, mutator) =>
+    addListener(listener, cellIdsListeners[mutator ? 1 : 0], [tableId, rowId]);
+  const addCellListener = (tableId, rowId, cellId, listener, mutator) =>
+    addListener(listener, cellListeners[mutator ? 1 : 0], [
+      tableId,
+      rowId,
+      cellId,
+    ]);
+  const callListener = (listenerId) => {
+    callListenerImpl(listenerId, [getTableIds, getRowIds, getCellIds], (ids) =>
+      isUndefined(ids[2]) ? [] : Array(2).fill(getCell(...ids)),
+    );
+    return store;
+  };
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return store;
+  };
+  const getListenerStats = () => ({
+    tables: collPairSize(tablesListeners),
+    tableIds: collPairSize(tableIdsListeners),
+    table: collPairSize(tableListeners, collSize2),
+    rowIds: collPairSize(rowIdsListeners, collSize2),
+    row: collPairSize(rowListeners, collSize3),
+    cellIds: collPairSize(cellIdsListeners, collSize3),
+    cell: collPairSize(cellListeners, collSize4),
+  });
+  const store = {
+    getTables,
+    getTableIds,
+    getTable,
+    getRowIds,
+    getRow,
+    getCellIds,
+    getCell,
+    hasTable,
+    hasRow,
+    hasCell,
+    getJson,
+    getSchemaJson,
+    setTables,
+    setTable,
+    setRow,
+    addRow,
+    setPartialRow,
+    setCell,
+    setJson,
+    setSchema,
+    delTables,
+    delTable,
+    delRow,
+    delCell,
+    delSchema,
+    transaction,
+    forEachTable,
+    forEachRow,
+    forEachCell,
+    addTablesListener,
+    addTableIdsListener,
+    addTableListener,
+    addRowIdsListener,
+    addRowListener,
+    addCellIdsListener,
+    addCellListener,
+    callListener,
+    delListener,
+    getListenerStats,
+  };
+  return objFreeze(store);
+};
+
+export {createStore};