tinybase 2.1.0 → 2.2.0-beta.0

package/lib/debug/tools.js

@@ -0,0 +1,955 @@
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const BOOLEAN = getTypeOf(true);
+const NUMBER = getTypeOf(0);
+const TYPE = 'type';
+const DEFAULT = 'default';
+
+const arrayEvery = (array, cb) => array.every(cb);
+const arraySort = (array, sorter) => array.sort(sorter);
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arrayMap = (array, cb) => array.map(cb);
+const arrayLength = (array) => array.length;
+const arrayIsEmpty = (array) => arrayLength(array) == 0;
+const arrayPush = (array, ...values) => array.push(...values);
+const arrayPop = (array) => array.pop();
+const arrayUnshift = (array, ...values) => array.unshift(...values);
+const arrayShift = (array) => array.shift();
+
+const jsonParse = JSON.parse;
+const isFiniteNumber = isFinite;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
+const isString = (thing) => getTypeOf(thing) == STRING;
+const isArray = (thing) => Array.isArray(thing);
+
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapGet = (map, key) => map?.get(key);
+const mapForEach = (map, cb) =>
+  collForEach(map, (value, key) => cb(key, value));
+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) => {
+  if (!collHas(map, key)) {
+    mapSet(map, key, getDefaultValue());
+  }
+  return mapGet(map, key);
+};
+
+const setNew = (entryOrEntries) =>
+  new Set(
+    isArray(entryOrEntries) || isUndefined(entryOrEntries)
+      ? entryOrEntries
+      : [entryOrEntries],
+  );
+const setAdd = (set, value) => set?.add(value);
+
+const pairNew = (value) => [value, value];
+const pairNewMap = () => [mapNew(), mapNew()];
+
+const NON_ALPHANUMERIC = /[^A-Za-z0-9]+/;
+const JSDOC = /^( *)\/\*\* *(.*?) *\*\/$/gm;
+const substr = (str, start, end) => str.substring(start, end);
+const upper = (str) => str.toUpperCase();
+const lower = (str) => str.toLowerCase();
+const mapUnique = (map, id, value, index = 1) => {
+  const uniqueId = `${id}${index == 1 ? '' : index}`;
+  if (collHas(map, uniqueId)) {
+    return mapUnique(map, id, value, index + 1);
+  } else {
+    mapSet(map, uniqueId, value);
+    return uniqueId;
+  }
+};
+const formatJsDoc = (file) =>
+  file.replace(JSDOC, (_, indent, text) => {
+    const lineLength = 77 - length(indent);
+    return `${indent}/**
+${text.replace(
+  new RegExp(`([^\\n]{1,${lineLength}})(\\s|$)`, 'g'),
+  `${indent} * $1
+`,
+)}${indent} */`;
+  });
+const length = (str) => str.length;
+const join = (str, sep = EMPTY_STRING) => str.join(sep);
+const camel = (str, firstCap = 0) =>
+  join(
+    arrayMap(
+      str.split(NON_ALPHANUMERIC),
+      (word, w) =>
+        (w > 0 || firstCap ? upper : lower)(substr(word, 0, 1)) +
+        substr(word, 1),
+    ),
+  );
+const snake = (str) => upper(join(str.split(NON_ALPHANUMERIC), '_'));
+const comment = (doc) => `/** ${doc}. */`;
+const getCodeFunctions = () => {
+  const allImports = pairNewMap();
+  const types = mapNew();
+  const methods = mapNew();
+  const constants = mapNew();
+  const build = (...lines) => {
+    const allLines = [];
+    const handleLine = (line) =>
+      isArray(line)
+        ? arrayForEach(line, handleLine)
+        : arrayPush(allLines, line);
+    arrayForEach(lines, handleLine);
+    return allLines.join('\n');
+  };
+  const addImport = (location, source, ...items) =>
+    arrayForEach(items, (item) =>
+      setAdd(mapEnsure(allImports[location], source, setNew), item),
+    );
+  const addType = (name, body = '', doc = '') =>
+    mapUnique(types, name, [body, doc]);
+  const updateType = (name, body, doc) => mapSet(types, name, [body, doc]);
+  const addMethod = (name, parameters, returnType, body, doc, generic = '') =>
+    mapUnique(methods, name, [parameters, returnType, body, doc, generic]);
+  const addFunction = (name, parameters, body) =>
+    mapUnique(
+      constants,
+      name,
+      isArray(body)
+        ? [`(${parameters}) => {`, body, '}']
+        : [`(${parameters}) => ${body}`],
+    );
+  const addConstant = (name, body) =>
+    mapGet(constants, name) === body ? name : mapUnique(constants, name, body);
+  const getImports = (location) => [
+    ...arraySort(
+      mapMap(
+        allImports[location],
+        (items, source) =>
+          `import {${join(
+            arraySort(collValues(items)),
+            ', ',
+          )}} from '${source}';`,
+      ),
+    ),
+    EMPTY_STRING,
+  ];
+  const getTypes = () =>
+    mapMap(types, ([body, doc], name) => [
+      comment(doc),
+      `export type ${name} = ${body};`,
+      EMPTY_STRING,
+    ]);
+  const getMethods = (location) =>
+    mapMap(methods, ([parameters, returnType, body, doc, generic], name) => {
+      const lines = location
+        ? [`${name}: ${generic}(${parameters}): ${returnType} => ${body},`]
+        : [`${name}${generic}(${parameters}): ${returnType};`];
+      if (!location) {
+        arrayUnshift(lines, comment(doc));
+      }
+      arrayPush(lines, EMPTY_STRING);
+      return lines;
+    });
+  const getConstants = () =>
+    mapMap(constants, (body, name) => {
+      body = isArray(body) ? body : [body];
+      arrayPush(body, `${arrayPop(body)};`);
+      return [`const ${name} = ${arrayShift(body)}`, body, EMPTY_STRING];
+    });
+  return [
+    build,
+    addImport,
+    addType,
+    updateType,
+    addMethod,
+    addFunction,
+    addConstant,
+    getImports,
+    getTypes,
+    getMethods,
+    getConstants,
+  ];
+};
+
+const object = Object;
+const objIds = object.keys;
+const objFreeze = object.freeze;
+const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+const objHas = (obj, id) => !isUndefined(objGet(obj, id));
+const objForEach = (obj, cb) =>
+  arrayForEach(object.entries(obj), ([id, value]) => cb(value, id));
+const objIsEmpty = (obj) => arrayIsEmpty(objIds(obj));
+
+const getCellType = (cell) => {
+  const type = getTypeOf(cell);
+  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+    ? type
+    : void 0;
+};
+
+const getCreateFunction = (getFunction) => {
+  const getFunctionsByStore = /* @__PURE__ */ new WeakMap();
+  return (store) => {
+    if (!getFunctionsByStore.has(store)) {
+      getFunctionsByStore.set(store, getFunction(store));
+    }
+    return getFunctionsByStore.get(store);
+  };
+};
+
+const THE_STORE = 'the Store';
+const REPRESENTS = 'Represents';
+const THE_CONTENT_OF = 'the content of';
+const THE_CONTENT_OF_THE_STORE = `${THE_CONTENT_OF} ${THE_STORE}`;
+const THE_SPECIFIED_ROW = 'the specified Row';
+const REGISTERS_A_LISTENER = 'Registers a listener that will be called';
+const storeMethod = (method, parameters = '', cast = '') =>
+  `store.${method}(${parameters})${cast ? ` as ${cast}` : ''}`;
+const fluentStoreMethod = (method, parameters = '') =>
+  `fluent(() => ${storeMethod(method, parameters)})`;
+const getIdsDoc = (idsNoun, parentNoun, sorted = 0) =>
+  `Gets ${
+    sorted ? 'sorted, paginated' : 'the'
+  } Ids of the ${idsNoun}s in ${parentNoun}`;
+const getForEachDoc = (childNoun, parentNoun) =>
+  `Calls a function for each ${childNoun} in ${parentNoun}`;
+const getHasDoc = (childNoun, parentNoun = THE_STORE) =>
+  `Gets whether ${childNoun} exists in ${parentNoun}`;
+const getCallbackDoc = (takes) => `A function that takes ${takes}`;
+const getListenerDoc = (childNoun, parentNoun, pluralChild = 0) =>
+  `${REGISTERS_A_LISTENER} whenever ${childNoun} in ${parentNoun} change` +
+  (pluralChild ? '' : 's');
+const getVerb = (verb = 0) =>
+  verb == 1
+    ? 'Sets'
+    : verb == 2
+    ? 'Sets part of'
+    : verb == 3
+    ? 'Deletes'
+    : 'Gets';
+const getStoreApi = (schema, module) => {
+  if (objIsEmpty(schema)) {
+    return pairNew('// store has no inferable schema');
+  }
+  const moduleName = camel(module);
+  const storeType = camel(module, 1);
+  const storeInstance = camel(storeType);
+  const returnStore = `return ${storeInstance};`;
+  const tablesTypes = [];
+  const tableIdTypes = [];
+  const tableCallbackArgTypes = [];
+  const getCellChangeArgTypes = [];
+  const cellListenerArgTypes = [];
+  const allCellIdType = [];
+  const schemaLines = [];
+  const storeListener = (method, beforeParameters = '', afterParameters = '') =>
+    `store.${method}(${
+      beforeParameters ? `${beforeParameters}, ` : ''
+    }proxy(listener)${afterParameters ? `, ${afterParameters}` : ''})`;
+  const [
+    build,
+    addImport,
+    addType,
+    updateType,
+    addMethod,
+    addFunction,
+    addConstant,
+    getImports,
+    getTypes,
+    getMethods,
+    getConstants,
+  ] = getCodeFunctions();
+  addImport(
+    0,
+    'tinybase',
+    'CellChange',
+    'ChangedCells',
+    'Id',
+    'IdOrNull',
+    'Ids',
+    'InvalidCells',
+    'Json',
+    'Store',
+  );
+  addImport(
+    1,
+    'tinybase',
+    'ChangedCells',
+    'Id',
+    'IdOrNull',
+    'Ids',
+    'InvalidCells',
+    'Json',
+    'Store',
+    'createStore',
+  );
+  addFunction('fluent', 'actions: () => Store', ['actions();', returnStore]);
+  addFunction(
+    'proxy',
+    `listener: any`,
+    `(_: Store, ...args: any[]) => listener(${storeInstance}, ...args)`,
+  );
+  const TYPE2 = addConstant(snake(TYPE), `'${TYPE}'`);
+  const DEFAULT2 = addConstant(snake(DEFAULT), `'${DEFAULT}'`);
+  const tablesType = addType('Tables');
+  const tableIdType = addType('TableId');
+  const tableCallbackType = addType('TableCallback');
+  const getCellChangeType = addType('GetCellChange');
+  const tablesListenerType = addType(
+    'TablesListener',
+    `(${storeInstance}: ${storeType}, getCellChange: ${getCellChangeType} | undefined) => void`,
+    `A function for listening to changes to ${THE_CONTENT_OF_THE_STORE}`,
+  );
+  const tableIdsListenerType = addType(
+    'TableIdsListener',
+    `(${storeInstance}: ${storeType}) => void`,
+    `A function for listening to changes to Table Ids in ${THE_STORE}`,
+  );
+  const tableListenerType = addType(
+    'TableListener',
+    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType} | undefined) => void`,
+    `A function for listening to changes to a Table in ${THE_STORE}`,
+  );
+  const rowIdsListenerType = addType(
+    'RowIdsListener',
+    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}) => void`,
+    `A function for listening to changes to Row Ids in ${THE_STORE}`,
+  );
+  const rowListenerType = addType(
+    'RowListener',
+    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id, getCellChange: ${getCellChangeType} | undefined) => void`,
+    `A function for listening to changes to a Row in ${THE_STORE}`,
+  );
+  const cellIdsListenerType = addType(
+    'CellIdsListener',
+    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id) => void`,
+    `A function for listening to changes to Cell Ids in ${THE_STORE}`,
+  );
+  const cellListenerType = addType('CellListener');
+  const invalidCellListenerType = addType(
+    'InvalidCellListener',
+    `(${storeInstance}: ${storeType}, tableId: Id, rowId: Id, cellId: Id, invalidCells: any[]) => void;`,
+    `A function for listening to invalid Cell changes`,
+  );
+  const transactionListenerType = addType(
+    'TransactionListener',
+    `(${storeInstance}: ${storeType}, cellsTouched: boolean) => void;`,
+    `A function for listening to the completion of a transaction`,
+  );
+  addImport(
+    1,
+    `./${moduleName}.d`,
+    storeType,
+    `create${storeType} as create${storeType}Decl`,
+    tablesType,
+    tableIdType,
+    tableCallbackType,
+    tablesListenerType,
+    tableIdsListenerType,
+    tableListenerType,
+    rowIdsListenerType,
+    rowListenerType,
+    cellIdsListenerType,
+    cellListenerType,
+    invalidCellListenerType,
+    transactionListenerType,
+  );
+  const getStoreContentDoc = (verb = 0) =>
+    `${getVerb(verb)} ${THE_CONTENT_OF_THE_STORE}`;
+  addMethod(
+    `hasTables`,
+    '',
+    BOOLEAN,
+    storeMethod('hasTables'),
+    getHasDoc('any Table'),
+  );
+  addMethod(
+    `getTables`,
+    '',
+    tablesType,
+    storeMethod('getTables'),
+    getStoreContentDoc(),
+  );
+  addMethod(
+    `setTables`,
+    `tables: ${tablesType}`,
+    storeType,
+    fluentStoreMethod('setTables', 'tables'),
+    getStoreContentDoc(1),
+  );
+  addMethod(
+    `delTables`,
+    '',
+    storeType,
+    fluentStoreMethod('delTables'),
+    getStoreContentDoc(3),
+  );
+  addMethod(
+    `getTableIds`,
+    '',
+    `${tableIdType}[]`,
+    storeMethod('getTableIds', '', `${tableIdType}[]`),
+    getIdsDoc('Table', THE_STORE),
+  );
+  addMethod(
+    'forEachTable',
+    `tableCallback: ${tableCallbackType}`,
+    'void',
+    storeMethod('forEachTable', 'tableCallback as any'),
+    getForEachDoc('Table', THE_STORE),
+  );
+  const mapCellTypes = mapNew();
+  objForEach(schema, (cellSchemas, tableId) => {
+    const table = camel(tableId, 1);
+    const TABLE_ID = addConstant(snake(tableId), `'${tableId}'`);
+    const getCellsTypes = [];
+    const setCellsTypes = [];
+    const cellIdTypes = [];
+    const cellCallbackArgTypes = [];
+    const tableDoc = `the '${tableId}' Table`;
+    const rowDoc = `${THE_SPECIFIED_ROW} in ${tableDoc}`;
+    const tableContentDoc = `${THE_CONTENT_OF} ${tableDoc}`;
+    const getTableContentDoc = (verb = 0) =>
+      `${getVerb(verb)} ${THE_CONTENT_OF} ${tableDoc}`;
+    const getRowContentDoc = (verb = 0) =>
+      `${getVerb(verb)} ${THE_CONTENT_OF} ${rowDoc}`;
+    const getRowTypeDoc = (set = 0) =>
+      `${REPRESENTS} a Row when ${set ? 's' : 'g'}etting ${tableContentDoc}`;
+    const tableType = addType(
+      `${table}Table`,
+      `{[rowId: Id]: ${table}Row}`,
+      `${REPRESENTS} ${tableDoc}`,
+    );
+    const rowType = addType(`${table}Row`);
+    const rowWhenSetType = addType(`${table}RowWhenSet`);
+    const cellIdType = addType(`${table}CellId`);
+    const cellCallbackType = addType(`${table}CellCallback`);
+    const rowCallbackType = addType(`${table}RowCallback`);
+    addImport(
+      1,
+      `./${moduleName}.d`,
+      tableType,
+      rowType,
+      rowWhenSetType,
+      cellIdType,
+      cellCallbackType,
+      rowCallbackType,
+    );
+    addMethod(
+      `has${table}Table`,
+      '',
+      BOOLEAN,
+      storeMethod('hasTable', TABLE_ID),
+      getHasDoc(tableDoc),
+    );
+    addMethod(
+      `get${table}Table`,
+      '',
+      tableType,
+      storeMethod('getTable', TABLE_ID, tableType),
+      getTableContentDoc(),
+    );
+    addMethod(
+      `set${table}Table`,
+      `table: ${tableType}`,
+      storeType,
+      fluentStoreMethod('setTable', `${TABLE_ID}, table`),
+      getTableContentDoc(1),
+    );
+    addMethod(
+      `del${table}Table`,
+      '',
+      storeType,
+      fluentStoreMethod('delTable', TABLE_ID),
+      getTableContentDoc(3),
+    );
+    addMethod(
+      `get${table}RowIds`,
+      '',
+      'Ids',
+      storeMethod('getRowIds', TABLE_ID),
+      getIdsDoc('Row', tableDoc),
+    );
+    addMethod(
+      `get${table}SortedRowIds`,
+      `cellId?: ${cellIdType}, descending?: boolean, offset?: number, limit?: number`,
+      'Ids',
+      storeMethod(
+        'getSortedRowIds',
+        `${TABLE_ID}, cellId, descending, offset, limit`,
+      ),
+      getIdsDoc('Row', tableDoc, 1),
+    );
+    addMethod(
+      `forEach${table}Row`,
+      `rowCallback: ${rowCallbackType}`,
+      'void',
+      storeMethod('forEachRow', `${TABLE_ID}, rowCallback as any`),
+      getForEachDoc('Row', tableDoc),
+    );
+    addMethod(
+      `has${table}Row`,
+      'rowId: Id',
+      BOOLEAN,
+      storeMethod('hasRow', `${TABLE_ID}, rowId`),
+      getHasDoc(THE_SPECIFIED_ROW, tableDoc),
+    );
+    addMethod(
+      `get${table}Row`,
+      'rowId: Id',
+      rowType,
+      storeMethod('getRow', `${TABLE_ID}, rowId`, rowType),
+      getRowContentDoc(),
+    );
+    addMethod(
+      `set${table}Row`,
+      `rowId: Id, row: ${rowWhenSetType}`,
+      storeType,
+      fluentStoreMethod('setRow', `${TABLE_ID}, rowId, row`),
+      getRowContentDoc(1),
+    );
+    addMethod(
+      `add${table}Row`,
+      `row: ${rowWhenSetType}`,
+      'Id | undefined',
+      storeMethod('addRow', `${TABLE_ID}, row`),
+      `Adds a new Row to ${tableDoc}`,
+    );
+    addMethod(
+      `set${table}PartialRow`,
+      `rowId: Id, partialRow: ${rowWhenSetType}`,
+      storeType,
+      fluentStoreMethod('setPartialRow', `${TABLE_ID}, rowId, partialRow`),
+      getRowContentDoc(2),
+    );
+    addMethod(
+      `del${table}Row`,
+      `rowId: Id`,
+      storeType,
+      fluentStoreMethod('delRow', `${TABLE_ID}, rowId`),
+      getRowContentDoc(3),
+    );
+    addMethod(
+      `get${table}CellIds`,
+      'rowId: Id',
+      `${cellIdType}[]`,
+      storeMethod('getCellIds', `${TABLE_ID}, rowId`, `${cellIdType}[]`),
+      getIdsDoc('Cell', rowDoc),
+    );
+    addMethod(
+      `forEach${table}Cell`,
+      `rowId: Id, cellCallback: ${cellCallbackType}`,
+      'void',
+      storeMethod('forEachCell', `${TABLE_ID}, rowId, cellCallback as any`),
+      getForEachDoc('Cell', rowDoc),
+    );
+    arrayPush(schemaLines, `[${TABLE_ID}]: {`);
+    objForEach(cellSchemas, (cellSchema, cellId) => {
+      const cell = camel(cellId, 1);
+      const CELL_ID = addConstant(snake(cellId), `'${cellId}'`);
+      const type = cellSchema[TYPE];
+      const defaulted = objHas(cellSchema, DEFAULT);
+      const defaultValue = cellSchema[DEFAULT];
+      const cellDoc = `the '${cellId}' Cell`;
+      const getCellContentDoc = (verb = 0) =>
+        `${getVerb(verb)} ${cellDoc} for ${rowDoc}`;
+      arrayPush(
+        schemaLines,
+        `[${CELL_ID}]: {[${TYPE2}]: ${addConstant(snake(type), `'${type}'`)}${
+          defaulted
+            ? `, [${DEFAULT2}]: ${
+                isString(defaultValue)
+                  ? addConstant(snake(defaultValue), `'${defaultValue}'`)
+                  : defaultValue
+              }`
+            : ''
+        }},`,
+      );
+      arrayPush(getCellsTypes, `'${cellId}'${defaulted ? '' : '?'}: ${type};`);
+      arrayPush(setCellsTypes, `'${cellId}'?: ${type};`);
+      arrayPush(cellIdTypes, `'${cellId}'`);
+      arrayPush(cellCallbackArgTypes, `[cellId: '${cellId}', cell: ${type}]`);
+      arrayPush(
+        cellListenerArgTypes,
+        `[${storeInstance}: ${storeType}, tableId: '${tableId}', rowId: Id, cellId: '${cellId}', newCell: ${type} | undefined, oldCell: ${type} | undefined, getCellChange: ${getCellChangeType} | undefined]`,
+      );
+      const mapCellType = `Map${camel(type, 1)}`;
+      mapSet(mapCellTypes, type, mapCellType);
+      addMethod(
+        `has${table}${cell}Cell`,
+        'rowId: Id',
+        BOOLEAN,
+        storeMethod('hasCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
+        getHasDoc(cellDoc, rowDoc),
+      );
+      const returnCellType = `${type}${defaulted ? '' : ' | undefined'}`;
+      addMethod(
+        `get${table}${cell}Cell`,
+        'rowId: Id',
+        returnCellType,
+        storeMethod(
+          'getCell',
+          `${TABLE_ID}, rowId, ${CELL_ID}`,
+          returnCellType,
+        ),
+        getCellContentDoc(),
+      );
+      addMethod(
+        `set${table}${cell}Cell`,
+        `rowId: Id, cell: ${type} | ${mapCellType}`,
+        storeType,
+        fluentStoreMethod(
+          'setCell',
+          `${TABLE_ID}, rowId, ${CELL_ID}, cell as any`,
+        ),
+        getCellContentDoc(1),
+      );
+      addMethod(
+        `del${table}${cell}Cell`,
+        `rowId: Id`,
+        storeType,
+        fluentStoreMethod('delCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
+        getCellContentDoc(3),
+      );
+    });
+    arrayPush(schemaLines, `},`);
+    arrayPush(tablesTypes, `'${tableId}'?: ${tableType};`);
+    arrayPush(tableIdTypes, `'${tableId}'`);
+    arrayPush(
+      tableCallbackArgTypes,
+      `[tableId: '${tableId}', forEachRow: (rowCallback: ${rowCallbackType}) => void]`,
+    );
+    arrayPush(
+      getCellChangeArgTypes,
+      `[tableId: '${tableId}', rowId: Id, cellId: ${cellIdType}]`,
+    );
+    arrayPush(allCellIdType, cellIdType);
+    updateType(rowType, `{${join(getCellsTypes, ' ')}}`, getRowTypeDoc());
+    updateType(
+      rowWhenSetType,
+      `{${join(setCellsTypes, ' ')}}`,
+      getRowTypeDoc(1),
+    );
+    updateType(
+      cellIdType,
+      join(cellIdTypes, ' | '),
+      `A Cell Id for ${tableDoc}`,
+    );
+    updateType(
+      cellCallbackType,
+      `(...[cellId, cell]: ${join(cellCallbackArgTypes, ' | ')}) => void`,
+      getCallbackDoc(`a Cell Id and value from a Row in ${tableDoc}`),
+    );
+    updateType(
+      rowCallbackType,
+      `(rowId: Id, forEachCell: (cellCallback: ${cellCallbackType}) => void) => void`,
+      getCallbackDoc(`a Row Id from ${tableDoc}, and a Cell iterator`),
+    );
+  });
+  addMethod(
+    'getJson',
+    '',
+    'Json',
+    storeMethod('getJson'),
+    `Gets a a string serialization ${THE_CONTENT_OF_THE_STORE}`,
+  );
+  addMethod(
+    'setJson',
+    'json: Json',
+    storeType,
+    fluentStoreMethod('setJson', 'json'),
+    `Sets ${THE_CONTENT_OF_THE_STORE} from a serialized string`,
+  );
+  addMethod(
+    'transaction',
+    'actions: () => Return, doRollback?: (changedCells: ChangedCells, invalidCells: InvalidCells) => boolean',
+    'Return',
+    storeMethod('transaction', 'actions, doRollback'),
+    'Execute a transaction to make multiple mutations',
+    '<Return>',
+  );
+  addMethod(
+    'startTransaction',
+    '',
+    storeType,
+    fluentStoreMethod('startTransaction'),
+    'Explicitly starts a transaction',
+  );
+  addMethod(
+    'finishTransaction',
+    'doRollback?: (changedCells: ChangedCells, invalidCells: InvalidCells) => boolean,',
+    storeType,
+    fluentStoreMethod('finishTransaction', 'doRollback'),
+    'Explicitly finishes a transaction',
+  );
+  addMethod(
+    'addTablesListener',
+    `listener: ${tablesListenerType}, mutator?: boolean`,
+    'Id',
+    storeListener('addTablesListener', '', 'mutator'),
+    `${REGISTERS_A_LISTENER} whenever ${THE_CONTENT_OF_THE_STORE} changes`,
+  );
+  addMethod(
+    'addTableIdsListener',
+    `listener: ${tableIdsListenerType}, mutator?: boolean`,
+    'Id',
+    storeListener('addTableIdsListener', '', 'mutator'),
+    getListenerDoc('the Table Ids', THE_STORE, 1),
+  );
+  addMethod(
+    'addTableListener',
+    `tableId: ${tableIdType} | null, listener: ${tableListenerType}, mutator?: boolean`,
+    'Id',
+    storeListener('addTableListener', 'tableId', 'mutator'),
+    getListenerDoc('a Table', THE_STORE),
+  );
+  addMethod(
+    'addRowIdsListener',
+    `tableId: ${tableIdType} | null, listener: ${rowIdsListenerType}, mutator?: boolean`,
+    'Id',
+    storeListener('addRowIdsListener', 'tableId', 'mutator'),
+    getListenerDoc('the Row Ids', 'a Table', 1),
+  );
+  addMethod(
+    'addRowListener',
+    `tableId: ${tableIdType} | null, rowId: IdOrNull, listener: ${rowListenerType}, mutator?: boolean`,
+    'Id',
+    storeListener('addRowListener', 'tableId, rowId', 'mutator'),
+    getListenerDoc('a Row', 'a Table'),
+  );
+  addMethod(
+    'addCellIdsListener',
+    `tableId: ${tableIdType} | null, rowId: IdOrNull, listener: ${cellIdsListenerType}, mutator?: boolean`,
+    'Id',
+    storeListener('addCellIdsListener', 'tableId, rowId', 'mutator'),
+    getListenerDoc('the Cell Ids', 'a Row', 1),
+  );
+  addMethod(
+    'addCellListener',
+    `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${join(
+      allCellIdType,
+      ' | ',
+    )} | null, listener: ${cellListenerType}, mutator?: boolean`,
+    'Id',
+    storeListener('addCellListener', 'tableId, rowId, cellId', 'mutator'),
+    getListenerDoc('a Cell', 'a Row'),
+  );
+  addMethod(
+    'addInvalidCellListener',
+    `tableId: IdOrNull, rowId: IdOrNull, cellId: IdOrNull, listener: ${invalidCellListenerType}, mutator?: boolean`,
+    'Id',
+    storeListener('addCellListener', 'tableId, rowId, cellId', 'mutator'),
+    `${REGISTERS_A_LISTENER} whenever an invalid Cell change was attempted`,
+  );
+  addMethod(
+    'addWillFinishTransactionListener',
+    `listener: ${transactionListenerType}`,
+    'Id',
+    storeListener('addWillFinishTransactionListener'),
+    `${REGISTERS_A_LISTENER} just before the end of the transaction`,
+  );
+  addMethod(
+    'addDidFinishTransactionListener',
+    `listener: ${transactionListenerType}`,
+    'Id',
+    storeListener('addDidFinishTransactionListener'),
+    `${REGISTERS_A_LISTENER} just after the end of the transaction`,
+  );
+  addMethod(
+    'callListener',
+    'listenerId: Id',
+    storeType,
+    fluentStoreMethod('callListener', 'listenerId'),
+    'Manually provoke a listener to be called',
+  );
+  addMethod(
+    'delListener',
+    'listenerId: Id',
+    storeType,
+    fluentStoreMethod('delListener', 'listenerId'),
+    `Remove a listener that was previously added to ${THE_STORE}`,
+  );
+  addMethod(
+    'getStore',
+    '',
+    'Store',
+    'store',
+    'Gets the underlying Store object',
+  );
+  updateType(
+    tablesType,
+    `{${join(tablesTypes, ' ')}}`,
+    `${REPRESENTS} ${THE_CONTENT_OF_THE_STORE}`,
+  );
+  updateType(
+    tableIdType,
+    join(tableIdTypes, ' | '),
+    `A Table Id in ${THE_STORE}`,
+  );
+  updateType(
+    tableCallbackType,
+    `(...[tableId, rowCallback]: ${join(
+      tableCallbackArgTypes,
+      ' | ',
+    )}) => void`,
+    getCallbackDoc('a Table Id, and a Row iterator'),
+  );
+  updateType(
+    getCellChangeType,
+    `(...[tableId, rowId, cellId]: ${join(
+      getCellChangeArgTypes,
+      ' | ',
+    )}) => CellChange`,
+    `A function that returns information about any Cell's changes during a transaction`,
+  );
+  updateType(
+    cellListenerType,
+    `(...[${storeInstance}, tableId, rowId, cellId, newCell, oldCell, getCellChange]: ${join(
+      cellListenerArgTypes,
+      ' | ',
+    )}) => void`,
+    `A function for listening to changes to a Cell in ${THE_STORE}`,
+  );
+  mapForEach(mapCellTypes, (type, mapCellType) =>
+    addType(
+      mapCellType,
+      `(cell: ${type} | undefined) => ${type}`,
+      `Takes a ${type} Cell value and returns another`,
+    ),
+  );
+  addImport(1, `./${moduleName}.d`, ...collValues(mapCellTypes));
+  addConstant('store', ['createStore().setSchema({', ...schemaLines, '})']);
+  addConstant(storeInstance, ['{', ...getMethods(1), '}']);
+  return [
+    build(
+      ...getImports(0),
+      ...getTypes(),
+      `export interface ${storeType} {`,
+      ...getMethods(0),
+      `}`,
+      '',
+      comment(`Creates a ${storeType} object`),
+      `export function create${storeType}(): ${storeType};`,
+    ),
+    build(
+      ...getImports(1),
+      `export const create${storeType}: typeof create${storeType}Decl = () => {`,
+      ...getConstants(),
+      `return Object.freeze(${storeInstance});`,
+      `};`,
+    ),
+  ];
+};
+
+const prettierConfig = {
+  parser: 'typescript',
+  singleQuote: true,
+  trailingComma: 'all',
+  bracketSpacing: false,
+  jsdocSingleLineComment: false,
+};
+const createTools = getCreateFunction((store) => {
+  const getStoreStats = (detail) => {
+    let totalTables = 0;
+    let totalRows = 0;
+    let totalCells = 0;
+    const tables = {};
+    store.forEachTable((tableId, forEachRow) => {
+      totalTables++;
+      let tableRows = 0;
+      let tableCells = 0;
+      const rows = {};
+      forEachRow((rowId, forEachCell) => {
+        tableRows++;
+        let rowCells = 0;
+        forEachCell(() => rowCells++);
+        tableCells += rowCells;
+        if (detail) {
+          rows[rowId] = {rowCells};
+        }
+      });
+      totalRows += tableRows;
+      totalCells += tableCells;
+      if (detail) {
+        tables[tableId] = {tableRows, tableCells, rows};
+      }
+    });
+    return {
+      totalTables,
+      totalRows,
+      totalCells,
+      jsonLength: length(store.getJson()),
+      ...(detail ? {detail: {tables}} : {}),
+    };
+  };
+  const getStoreSchema = () => {
+    const schema = jsonParse(store.getSchemaJson());
+    if (
+      !objIsEmpty(schema) ||
+      arrayEvery(store.getTableIds(), (tableId) => {
+        const rowIds = store.getRowIds(tableId);
+        const cellsMeta = mapNew();
+        if (
+          arrayEvery(rowIds, (rowId) =>
+            arrayEvery(store.getCellIds(tableId, rowId), (cellId) => {
+              const value = store.getCell(tableId, rowId, cellId);
+              const cellMeta = mapEnsure(cellsMeta, cellId, () => [
+                getCellType(value),
+                mapNew(),
+                [0],
+                0,
+              ]);
+              const [type, values, [maxCount]] = cellMeta;
+              const count = mapEnsure(values, value, () => 0) + 1;
+              if (count > maxCount) {
+                cellMeta[2] = [count, value];
+              }
+              mapSet(values, value, count);
+              cellMeta[3]++;
+              return type == getCellType(value);
+            }),
+          )
+        ) {
+          schema[tableId] = {};
+          collForEach(cellsMeta, ([type, , [, maxValue], count], cellId) => {
+            schema[tableId][cellId] = {
+              [TYPE]: type,
+              ...(count == arrayLength(rowIds) ? {[DEFAULT]: maxValue} : {}),
+            };
+          });
+          return 1;
+        }
+      })
+    ) {
+      return schema;
+    }
+    return {};
+  };
+  const getStoreApi$1 = (module) => getStoreApi(getStoreSchema(), module);
+  const getPrettyStoreApi = async (module) => {
+    const files = getStoreApi$1(module);
+    try {
+      const {format} = await import('prettier');
+      return arrayMap(files, (file) =>
+        formatJsDoc(format(file, prettierConfig)),
+      );
+    } catch {}
+    return files;
+  };
+  const tools = {
+    getStoreStats,
+    getStoreSchema,
+    getStoreApi: getStoreApi$1,
+    getPrettyStoreApi,
+  };
+  return objFreeze(tools);
+});
+
+export {createTools};