tinybase 3.1.0-beta.3 → 3.1.0-beta.5

package/lib/debug/tools.js

@@ -72,30 +72,34 @@ const upper = (str) => str.toUpperCase();
 const lower = (str) => str.toLowerCase();
 const A = 'a ';
 const A_FUNCTION_FOR = 'A function for';
+const AND_REGISTERS =
+  ', and registers a listener so that any changes to that result will cause a re-render';
 const CALLBACK = 'Callback';
 const DEL = 'Del';
+const DEPS = 'Deps';
+const DEPS_SUFFIX = DEPS + '?: React.DependencyList';
 const DO_ROLLBACK_PARAM = 'doRollback?: DoRollback';
 const DO_ACTIONS_AND_ROLLBACK_PARAMS =
   'actions: () => Return, ' + DO_ROLLBACK_PARAM;
 const EXPORT = 'export';
 const ID = 'Id';
-const ID_OR_NULL = 'IdOrNull';
 const INVALID = 'Invalid';
 const JSON$1 = 'Json';
 const LISTENER_ = lower(LISTENER);
+const OPTIONAL_COLON = '?: ';
 const OR_UNDEFINED = ' | undefined';
 const NON_NULLABLE = 'NonNullable';
 const PARTIAL = 'Partial';
+const PROPS = 'Props';
+const PROVIDER = 'Provider';
 const REGISTERS_A_LISTENER = `Registers a ${LISTENER_} that will be called`;
 const REPRESENTS = 'Represents';
 const ROW_ID_PARAM = 'rowId: ' + ID;
-const ROW_ID_OR_NULL_PARAM = 'rowId: ' + ID_OR_NULL;
 const SCHEMA = 'Schema';
 const SET = 'Set';
 const SORTED_ARGS = ', descending?: boolean, offset?: number, limit?: number';
 const SQUARE_BRACKETS = '[]';
-const STORE = 'Store';
-const THE_STORE = 'the ' + STORE;
+const THE_STORE = 'the Store';
 const TRANSACTION = 'Transaction';
 const TRANSACTION_ = lower(TRANSACTION);
 const TRANSACTION_DOC =
@@ -150,7 +154,6 @@ const getListenerDoc = (childNoun, parentNoun, pluralChild = 0) =>
   (pluralChild ? EMPTY_STRING : 's');
 const getTableDoc = (tableId) => `the '${tableId}' ` + TABLE;
 const getRowDoc = (tableId) => 'the specified Row in ' + getTableDoc(tableId);
-const getContentDoc = (verb = 0, noun = 0) => VERBS[verb] + SPACE + NOUNS[noun];
 const getTableContentDoc = (tableId, verb = 0) =>
   VERBS[verb] + ` ${getTheContentOfDoc()} ` + getTableDoc(tableId);
 const getRowContentDoc = (tableId, verb = 0) =>
@@ -1550,27 +1553,20 @@ const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
   ];
 };
 
-const DEPS = 'Deps';
 const getGet = (noun) => GET + noun;
 const getGetAndGetDeps = (noun) =>
   getParameterList(getGet(noun), getGet(noun) + DEPS);
 const DEBUG_IDS_PROP_TYPE = 'debugIds?: boolean';
 const DEBUG_IDS_PROP = 'debugIds={debugIds}';
-const DEPS_SUFFIX = DEPS + '?: React.DependencyList';
 const THEN_DEPS = 'then' + DEPS_SUFFIX;
 const PARAMETER = 'Parameter';
 const GETTER_ARGS = ': (parameter: ' + PARAMETER + ', store: Store) => ';
-const PROVIDER = 'Provider';
 const USE_CONTEXT = 'const contextValue = useContext(Context);';
-const AND_REGISTERS =
-  ', and registers a listener so that any changes to that result will cause a re-render';
 const BASED_ON_A_PARAMETER = ', based on a parameter';
 const COLON_SPACE = ': ';
-const OPTIONAL_COLON = '?: ';
 const GENERIC_PARAMETER = '<' + PARAMETER + ',>';
 const PARAMETERIZED_CALLBACK =
   PARAMETER + 'ized' + CALLBACK + '<' + PARAMETER + '>';
-const PROPS = 'Props';
 const ROW_ID = 'rowId';
 const ROW_ID_PROP = 'rowId={rowId}';
 const SEPARATOR_AND_DEBUG_IDS = ', separator, debugIds';
@@ -2643,597 +2639,6 @@ const getStoreApi = (tablesSchema, valuesSchema, module) => {
   ];
 };
 
-const MAY_CONTRADICT_REFINEMENT =
-  '. Note that this may contradict the generated type refinements';
-const getStoreCoreRefinement = (tablesSchema, valuesSchema, _module) => {
-  const [
-    build,
-    addImport,
-    addType,
-    _addInternalFunction,
-    _addConstant,
-    getImports,
-    getTypes,
-    _getConstants,
-  ] = getCodeFunctions();
-  const [mapTablesSchema, mapCellSchema, mapValuesSchema] = getSchemaFunctions(
-    tablesSchema,
-    valuesSchema,
-    () => EMPTY_STRING,
-  );
-  const [getTablesTypes, getValuesTypes, getTransactionListenerType] =
-    getTypeFunctions(addType, mapTablesSchema, mapCellSchema, mapValuesSchema);
-  const methods = mapNew();
-  const getMethods = () =>
-    mapMap(methods, ([parameters, returnType, doc, generic], name) => [
-      comment(doc),
-      name + generic + `(${getParameterList(...parameters)}): ${returnType};`,
-      EMPTY_STRING,
-    ]);
-  const addMethod = (
-    name,
-    parameters,
-    returnType,
-    doc,
-    generic = EMPTY_STRING,
-  ) =>
-    mapUnique(methods, name, [
-      isArray(parameters) ? parameters : [parameters],
-      returnType,
-      doc,
-      generic,
-    ]);
-  addImport(
-    0,
-    'tinybase',
-    ID,
-    IDS,
-    ID_OR_NULL,
-    'StoreListenerStats',
-    JSON$1,
-    TABLES + SCHEMA,
-    VALUES + SCHEMA,
-    'DoRollback',
-  );
-  let tablesTypes;
-  if (objIsEmpty(tablesSchema)) {
-    tablesTypes = [
-      TABLES,
-      TABLES,
-      ID,
-      TABLE,
-      TABLE,
-      ROW,
-      ROW,
-      ID,
-      CELL,
-      CELL + CALLBACK,
-      ROW + CALLBACK,
-      TABLE + CALLBACK,
-      TABLES + LISTENER,
-      TABLE_IDS + LISTENER,
-      TABLE + LISTENER,
-      ROW_IDS + LISTENER,
-      SORTED_ROW_IDS + LISTENER,
-      ROW + LISTENER,
-      CELL_IDS + LISTENER,
-      CELL + LISTENER,
-      INVALID + CELL + LISTENER,
-    ];
-    addImport(0, 'tinybase', ...tablesTypes);
-    arrayPush(tablesTypes, ID, ID_OR_NULL, ID, EMPTY_STRING, ID, EMPTY_STRING);
-  } else {
-    addImport(0, 'tinybase', 'CellChange');
-    tablesTypes = getTablesTypes('store', STORE);
-    arrayForEach([3, 4, 5, 6, 7, 9, 10], (i) => (tablesTypes[i] += '<TId>'));
-    tablesTypes[8] += '<TId, CId>';
-    arrayPush(
-      tablesTypes,
-      'TId',
-      'TId | null',
-      join(
-        mapTablesSchema((tableId2) => `CellId<'${tableId2}'>`),
-        ' | ',
-      ),
-      `<TId extends ${tablesTypes[2]}>`,
-      'CId',
-      `<TId extends ${tablesTypes[2]}, CId extends ${tablesTypes[7]}>`,
-    );
-  }
-  const [
-    tablesType,
-    tablesWhenSetType,
-    tableIdType,
-    tableType,
-    tableWhenSetType,
-    rowType,
-    rowWhenSetType,
-    cellIdType,
-    cellType,
-    cellCallbackType,
-    rowCallbackType,
-    tableCallbackType,
-    tablesListenerType,
-    tableIdsListenerType,
-    tableListenerType,
-    rowIdsListenerType,
-    sortedRowIdsListenerType,
-    rowListenerType,
-    cellIdsListenerType,
-    cellListenerType,
-    invalidCellListenerType,
-    tableId,
-    tableIdOrNull,
-    allCellIdsType,
-    tIdGeneric,
-    cId,
-    cIdGeneric,
-  ] = tablesTypes;
-  const tableIdParam = 'tableId: ' + tableId;
-  const rowIdParams = getParameterList(tableIdParam, ROW_ID_PARAM);
-  const cellIdParams = getParameterList(rowIdParams, 'cellId: ' + cId);
-  const tableIdOrNullParam = 'tableId: ' + tableIdOrNull;
-  const rowIdOrNullParams = getParameterList(
-    tableIdOrNullParam,
-    ROW_ID_OR_NULL_PARAM,
-  );
-  const cellIdOrNullParams = getParameterList(
-    rowIdOrNullParams,
-    'cellId: ' + allCellIdsType,
-  );
-  arrayForEach(
-    [[tablesType], [BOOLEAN], [STORE, 'tables: ' + tablesWhenSetType], [STORE]],
-    ([returnType, params], verb) =>
-      addMethod(
-        METHOD_PREFIX_VERBS[verb] + TABLES,
-        params ?? EMPTY_STRING,
-        returnType,
-        getTheContentOfTheStoreDoc(1, verb),
-      ),
-  );
-  addMethod(
-    GET + TABLE_IDS,
-    EMPTY_STRING,
-    tableIdType + SQUARE_BRACKETS,
-    getIdsDoc(TABLE, THE_STORE),
-  );
-  addMethod(
-    METHOD_PREFIX_VERBS[5] + TABLE,
-    'tableCallback: ' + tableCallbackType,
-    VOID,
-    getForEachDoc(TABLE, THE_STORE),
-  );
-  arrayForEach(
-    [
-      [tableType, tableIdParam],
-      [BOOLEAN, tableIdParam],
-      [STORE, [tableIdParam, 'table: ' + tableWhenSetType]],
-      [STORE, tableIdParam],
-    ],
-    ([returnType, params], verb) =>
-      addMethod(
-        METHOD_PREFIX_VERBS[verb] + TABLE,
-        params ?? EMPTY_STRING,
-        returnType,
-        getContentDoc(verb, 3),
-        tIdGeneric,
-      ),
-  );
-  addMethod(
-    GET + ROW_IDS,
-    tableIdParam,
-    IDS,
-    getIdsDoc(ROW, A + TABLE),
-    tIdGeneric,
-  );
-  addMethod(
-    GET + SORTED_ROW_IDS,
-    [tableIdParam, 'cellId?: ' + cellIdType + SORTED_ARGS],
-    IDS,
-    getIdsDoc(ROW, A + TABLE),
-    tIdGeneric,
-  );
-  addMethod(
-    METHOD_PREFIX_VERBS[5] + ROW,
-    [tableIdParam, 'rowCallback: ' + rowCallbackType],
-    VOID,
-    getForEachDoc(ROW, A + TABLE),
-    tIdGeneric,
-  );
-  arrayForEach(
-    [
-      [rowType, rowIdParams],
-      [BOOLEAN, rowIdParams],
-      [STORE, [rowIdParams, 'row: ' + rowWhenSetType]],
-      [STORE, rowIdParams],
-    ],
-    ([returnType, params], verb) =>
-      addMethod(
-        METHOD_PREFIX_VERBS[verb] + ROW,
-        params ?? EMPTY_STRING,
-        returnType,
-        getContentDoc(verb, 5),
-        tIdGeneric,
-      ),
-  );
-  addMethod(
-    'set' + PARTIAL + ROW,
-    [tableIdParam, ROW_ID_PARAM, 'partialRow: ' + rowWhenSetType],
-    STORE,
-    getContentDoc(4, 5),
-    tIdGeneric,
-  );
-  addMethod(
-    ADD + ROW,
-    [tableIdParam, 'row: ' + rowWhenSetType],
-    ID + OR_UNDEFINED,
-    'Add a new ' + ROW,
-    tIdGeneric,
-  );
-  addMethod(
-    GET + CELL_IDS,
-    [tableIdParam, ROW_ID_PARAM],
-    cellIdType + SQUARE_BRACKETS,
-    getIdsDoc(CELL, A + ROW),
-    tIdGeneric,
-  );
-  addMethod(
-    METHOD_PREFIX_VERBS[5] + CELL,
-    [tableIdParam, ROW_ID_PARAM, 'cellCallback: ' + cellCallbackType],
-    VOID,
-    getForEachDoc(CELL, A + ROW),
-    tIdGeneric,
-  );
-  arrayForEach(
-    [
-      [cellType, cellIdParams],
-      [BOOLEAN, cellIdParams],
-      [STORE, [cellIdParams, 'cell: ' + cellType]],
-      [STORE, cellIdParams],
-    ],
-    ([returnType, params], verb) =>
-      addMethod(
-        METHOD_PREFIX_VERBS[verb] + CELL,
-        params ?? EMPTY_STRING,
-        returnType,
-        getContentDoc(verb, 7),
-        cIdGeneric,
-      ),
-  );
-  addMethod(
-    ADD + TABLES + LISTENER,
-    [LISTENER_ + ': ' + tablesListenerType, 'mutator?: boolean'],
-    ID,
-    getTheContentOfTheStoreDoc(1, 8) + ' changes',
-  );
-  addMethod(
-    ADD + TABLE_IDS + LISTENER,
-    [LISTENER_ + ': ' + tableIdsListenerType, 'mutator?: boolean'],
-    ID,
-    getListenerDoc(2, 0, 1),
-  );
-  addMethod(
-    ADD + TABLE + LISTENER,
-    [
-      tableIdOrNullParam,
-      LISTENER_ + ': ' + tableListenerType,
-      'mutator?: boolean',
-    ],
-    ID,
-    getListenerDoc(3, 0),
-    tIdGeneric,
-  );
-  addMethod(
-    ADD + ROW_IDS + LISTENER,
-    [
-      tableIdOrNullParam,
-      LISTENER_ + ': ' + rowIdsListenerType,
-      'mutator?: boolean',
-    ],
-    ID,
-    getListenerDoc(4, 3, 1),
-    tIdGeneric,
-  );
-  addMethod(
-    ADD + SORTED_ROW_IDS + LISTENER,
-    [
-      tableIdParam,
-      'cellId: ' + cellIdType + OR_UNDEFINED,
-      'descending: boolean',
-      'offset: number',
-      'limit: number' + OR_UNDEFINED,
-      LISTENER_ + ': ' + sortedRowIdsListenerType,
-      'mutator?: boolean',
-    ],
-    ID,
-    getListenerDoc(13, 3, 1),
-    tIdGeneric,
-  );
-  addMethod(
-    ADD + ROW + LISTENER,
-    [
-      rowIdOrNullParams,
-      LISTENER_ + ': ' + rowListenerType,
-      'mutator?: boolean',
-    ],
-    ID,
-    getListenerDoc(5, 3),
-    tIdGeneric,
-  );
-  addMethod(
-    ADD + CELL_IDS + LISTENER,
-    [
-      rowIdOrNullParams,
-      LISTENER_ + ': ' + cellIdsListenerType,
-      'mutator?: boolean',
-    ],
-    ID,
-    getListenerDoc(6, 5, 1),
-    tIdGeneric,
-  );
-  addMethod(
-    ADD + CELL + LISTENER,
-    [
-      cellIdOrNullParams,
-      LISTENER_ + ': ' + cellListenerType,
-      'mutator?: boolean',
-    ],
-    ID,
-    getListenerDoc(7, 5),
-    tIdGeneric,
-  );
-  addMethod(
-    ADD + INVALID + CELL + LISTENER,
-    [
-      'tableId: ' + ID_OR_NULL,
-      'rowId: ' + ID_OR_NULL,
-      'cellId: ' + ID_OR_NULL,
-      LISTENER_ + ': ' + invalidCellListenerType,
-      'mutator?: boolean',
-    ],
-    ID,
-    REGISTERS_A_LISTENER + ' whenever an invalid Cell change was attempted',
-  );
-  let valuesTypes;
-  if (objIsEmpty(valuesSchema)) {
-    valuesTypes = [
-      VALUES,
-      VALUES,
-      ID,
-      VALUE,
-      VALUE + CALLBACK,
-      VALUES + LISTENER,
-      VALUE_IDS + LISTENER,
-      VALUE + LISTENER,
-      INVALID + VALUE + LISTENER,
-    ];
-    addImport(0, 'tinybase', ...valuesTypes);
-    arrayPush(valuesTypes, ID, ID_OR_NULL, EMPTY_STRING);
-  } else {
-    addImport(0, 'tinybase', 'ValueChange');
-    valuesTypes = getValuesTypes('store', STORE);
-    valuesTypes[3] += '<VId>';
-    arrayPush(
-      valuesTypes,
-      'VId',
-      'VId | null',
-      `<VId extends ${valuesTypes[2]}>`,
-    );
-  }
-  const [
-    valuesType,
-    valuesWhenSetType,
-    valueIdType,
-    valueType,
-    valueCallbackType,
-    valuesListenerType,
-    valueIdsListenerType,
-    valueListenerType,
-    invalidValueListenerType,
-    valueId,
-    valueIdOrNull,
-    vIdGeneric,
-  ] = valuesTypes;
-  const valueIdParam = 'valueId: ' + valueId;
-  arrayForEach(
-    [[valuesType], [BOOLEAN], [STORE, 'values: ' + valuesWhenSetType], [STORE]],
-    ([returnType, params], verb) =>
-      addMethod(
-        METHOD_PREFIX_VERBS[verb] + VALUES,
-        params ?? EMPTY_STRING,
-        returnType,
-        getTheContentOfTheStoreDoc(2, verb),
-      ),
-  );
-  addMethod(
-    'set' + PARTIAL + VALUES,
-    'partialValues: ' + valuesWhenSetType,
-    STORE,
-    getTheContentOfTheStoreDoc(2, 4),
-  );
-  addMethod(
-    GET + VALUE_IDS,
-    EMPTY_STRING,
-    valueIdType + SQUARE_BRACKETS,
-    getIdsDoc(VALUE, THE_STORE),
-  );
-  addMethod(
-    METHOD_PREFIX_VERBS[5] + VALUE,
-    'valueCallback: ' + valueCallbackType,
-    VOID,
-    getForEachDoc(VALUE, THE_STORE),
-  );
-  arrayForEach(
-    [
-      [valueType, valueIdParam],
-      [BOOLEAN, valueIdParam],
-      [STORE, [valueIdParam, 'value: ' + valueType]],
-      [STORE, valueIdParam],
-    ],
-    ([returnType, params], verb) =>
-      addMethod(
-        METHOD_PREFIX_VERBS[verb] + VALUE,
-        params ?? EMPTY_STRING,
-        returnType,
-        getContentDoc(verb, 11),
-        vIdGeneric,
-      ),
-  );
-  addMethod(
-    ADD + VALUES + LISTENER,
-    [LISTENER_ + ': ' + valuesListenerType, 'mutator?: boolean'],
-    ID,
-    getTheContentOfTheStoreDoc(2, 8) + ' changes',
-  );
-  addMethod(
-    ADD + VALUE_IDS + LISTENER,
-    [LISTENER_ + ': ' + valueIdsListenerType, 'mutator?: boolean'],
-    ID,
-    getListenerDoc(10, 0, 1),
-  );
-  addMethod(
-    ADD + VALUE + LISTENER,
-    [
-      'valueId: ' + valueIdOrNull,
-      LISTENER_ + ': ' + valueListenerType,
-      'mutator?: boolean',
-    ],
-    ID,
-    getListenerDoc(11, 0),
-    vIdGeneric,
-  );
-  addMethod(
-    ADD + INVALID + VALUE + LISTENER,
-    [
-      'valueId: ' + ID_OR_NULL,
-      LISTENER_ + ': ' + invalidValueListenerType,
-      'mutator?: boolean',
-    ],
-    ID,
-    REGISTERS_A_LISTENER + ' whenever an invalid Value change was attempted',
-  );
-  arrayForEach(
-    [
-      [EMPTY_STRING, 'tablesAndValues'],
-      [TABLES, 'tables'],
-      [VALUES, 'values'],
-    ],
-    ([noun, param], content) => {
-      addMethod(
-        GET + noun + JSON$1,
-        EMPTY_STRING,
-        JSON$1,
-        getTheContentOfTheStoreDoc(content, 6),
-      );
-      addMethod(
-        'set' + noun + JSON$1,
-        param + JSON$1 + ': ' + JSON$1,
-        STORE,
-        getTheContentOfTheStoreDoc(content, 7),
-      );
-      addMethod(
-        GET + noun + SCHEMA + JSON$1,
-        EMPTY_STRING,
-        JSON$1,
-        getTheContentOfTheStoreDoc(content, 14),
-      );
-      if (noun) {
-        addMethod(
-          'set' + noun + SCHEMA,
-          param + SCHEMA + ': ' + noun + SCHEMA,
-          STORE,
-          getTheContentOfTheStoreDoc(content, 15) + MAY_CONTRADICT_REFINEMENT,
-        );
-      }
-      addMethod(
-        'del' + noun + SCHEMA,
-        EMPTY_STRING,
-        STORE,
-        getTheContentOfTheStoreDoc(content, 16),
-      );
-    },
-  );
-  addMethod(
-    'set' + SCHEMA,
-    [
-      `tables${SCHEMA}: ` + TABLES + SCHEMA,
-      `values${SCHEMA}?: ` + VALUES + SCHEMA,
-    ],
-    STORE,
-    getTheContentOfTheStoreDoc(0, 15) + MAY_CONTRADICT_REFINEMENT,
-  );
-  addMethod(
-    TRANSACTION_,
-    DO_ACTIONS_AND_ROLLBACK_PARAMS,
-    'Return',
-    TRANSACTION_DOC,
-    '<Return>',
-  );
-  addMethod('start' + TRANSACTION, EMPTY_STRING, STORE, START_TRANSACTION_DOC);
-  addMethod(
-    'finish' + TRANSACTION,
-    DO_ROLLBACK_PARAM,
-    STORE,
-    FINISH_TRANSACTION_DOC,
-  );
-  const transactionListenerType = getTransactionListenerType('store', STORE);
-  addMethod(
-    ADD + 'WillFinish' + TRANSACTION + LISTENER,
-    LISTENER_ + ': ' + transactionListenerType,
-    ID,
-    REGISTERS_A_LISTENER + ' just before ' + THE_END_OF_THE_TRANSACTION,
-  );
-  addMethod(
-    ADD + 'DidFinish' + TRANSACTION + LISTENER,
-    LISTENER_ + ': ' + transactionListenerType,
-    ID,
-    REGISTERS_A_LISTENER + ' just after ' + THE_END_OF_THE_TRANSACTION,
-  );
-  addMethod(
-    'call' + LISTENER,
-    'listenerId: Id',
-    STORE,
-    'Manually provoke a listener to be called',
-  );
-  addMethod(
-    'del' + LISTENER,
-    'listenerId: Id',
-    STORE,
-    'Remove a listener that was previously added to ' + THE_STORE,
-  );
-  addMethod(
-    GET + LISTENER + 'Stats',
-    EMPTY_STRING,
-    'StoreListenerStats',
-    'Get listener statistics',
-  );
-  return [
-    build(
-      `export * from 'tinybase';`,
-      ...getImports(0),
-      ...getTypes(),
-      'export interface Store {',
-      ...getMethods(),
-      '}',
-      EMPTY_STRING,
-      comment(`Creates a Store object`),
-      'export function createStore(): Store',
-    ),
-  ];
-};
-
-const getStoreUiReactRefinement = (_tablesSchema, _valuesSchema, _module) => {
-  return [`export * from 'tinybase/ui-react';`];
-};
-
-const getStoreRefinement = (tablesSchema, valuesSchema, module) => {
-  if (objIsEmpty(tablesSchema) && objIsEmpty(valuesSchema)) {
-    return [EMPTY_STRING, EMPTY_STRING];
-  }
-  const [dTsCore] = getStoreCoreRefinement(tablesSchema, valuesSchema);
-  return [dTsCore, ...getStoreUiReactRefinement()];
-};
-
 const prettierConfig = {
   parser: 'typescript',
   singleQuote: true,
@@ -3241,13 +2646,6 @@ const prettierConfig = {
   bracketSpacing: false,
   jsdocSingleLineComment: false,
 };
-const getFormat = async () => {
-  try {
-    return (await import('prettier')).format;
-  } catch (e) {
-    return (str) => str;
-  }
-};
 const createTools = getCreateFunction((store) => {
   const getStoreStats = (detail) => {
     let totalTables = 0;
@@ -3341,21 +2739,18 @@ const createTools = getCreateFunction((store) => {
     getStoreApi(getStoreTablesSchema(), getStoreValuesSchema(), module);
   const getPrettyStoreApi = async (module) => {
     const extensions = ['d.ts', 'ts', 'd.ts', 'tsx'];
-    const format = await getFormat();
+    let format;
+    try {
+      format = (await import('prettier')).format;
+    } catch (e) {
+      format = (str) => str;
+    }
     return arrayMap(getStoreApi$1(module), (file, f) =>
       formatJsDoc(
         format(file, {...prettierConfig, filepath: `_.${extensions[f]}`}),
       ),
     );
   };
-  const getStoreRefinement$1 = (module) =>
-    getStoreRefinement(getStoreTablesSchema(), getStoreValuesSchema());
-  const getPrettyStoreRefinement = async (module) => {
-    const format = await getFormat();
-    return arrayMap(getStoreRefinement$1(), (file) =>
-      formatJsDoc(format(file, {...prettierConfig, filepath: `_.d.ts`})),
-    );
-  };
   const getStore = () => store;
   const tools = {
     getStoreStats,
@@ -3363,8 +2758,6 @@ const createTools = getCreateFunction((store) => {
     getStoreValuesSchema,
     getStoreApi: getStoreApi$1,
     getPrettyStoreApi,
-    getStoreRefinement: getStoreRefinement$1,
-    getPrettyStoreRefinement,
     getStore,
   };
   return objFreeze(tools);