tinybase 5.0.0-beta.22 → 5.0.0-beta.23

package/cjs/persisters/persister-expo-sqlite-next/with-schemas/index.cjs

@@ -1,926 +0,0 @@
-'use strict';
-
-var next_js = require('expo-sqlite/next.js');
-
-const getTypeOf = (thing) => typeof thing;
-const TINYBASE = 'tinybase';
-const EMPTY_STRING = '';
-const COMMA = ',';
-const STRING = getTypeOf(EMPTY_STRING);
-const UNDEFINED = '\uFFFC';
-const strRepeat = (str, count) => str.repeat(count);
-
-const promise = Promise;
-const startInterval = (callback, sec, immediate) => {
-  callback();
-  return setInterval(callback, sec * 1e3);
-};
-const stopInterval = clearInterval;
-const isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? otherwise?.() : then(value);
-const isString = (thing) => getTypeOf(thing) == STRING;
-const isArray = (thing) => Array.isArray(thing);
-const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
-const size = (arrayOrString) => arrayOrString.length;
-const promiseAll = async (promises) => promise.all(promises);
-const errorNew = (message) => {
-  throw new Error(message);
-};
-
-const arrayJoin = (array, sep = EMPTY_STRING) => array.join(sep);
-const arrayMap = (array, cb) => array.map(cb);
-const arrayIsEmpty = (array) => size(array) == 0;
-const arrayFilter = (array, cb) => array.filter(cb);
-const arrayPush = (array, ...values) => array.push(...values);
-const arrayShift = (array) => array.shift();
-
-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 object = Object;
-const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
-const objEntries = object.entries;
-const isObject = (obj) =>
-  !isUndefined(obj) &&
-  ifNotUndefined(
-    getPrototypeOf(obj),
-    (objPrototype) =>
-      objPrototype == object.prototype ||
-      isUndefined(getPrototypeOf(objPrototype)),
-
-    /* istanbul ignore next */
-    () => true,
-  );
-const objIds = object.keys;
-const objFreeze = object.freeze;
-const objNew = (entries = []) => object.fromEntries(entries);
-const objMerge = (...objs) => object.assign({}, ...objs);
-const objHas = (obj, id) => id in obj;
-const objDel = (obj, id) => {
-  delete obj[id];
-  return obj;
-};
-const objToArray = (obj, cb) =>
-  arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
-const objValues = (obj) => object.values(obj);
-const objSize = (obj) => size(objIds(obj));
-const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
-
-const mapNew = (entries) => new Map(entries);
-const mapKeys = (map) => [...(map?.keys() ?? [])];
-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, hadExistingValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
-  }
-  return mapGet(map, key);
-};
-const mapMatch = (map, obj, set, del = mapSet) => {
-  objToArray(obj, (value, id) => set(map, id, value));
-  mapForEach(map, (id) => (objHas(obj, id) ? 0 : del(map, id)));
-  return map;
-};
-
-const SINGLE_ROW_ID = '_';
-const DEFAULT_ROW_ID_COLUMN_NAME = '_id';
-const escapeId = (str) => `"${str.replace(/"/g, '""')}"`;
-const SELECT = 'SELECT';
-
-const setNew = (entryOrEntries) =>
-  new Set(
-    isArray(entryOrEntries) || isUndefined(entryOrEntries)
-      ? entryOrEntries
-      : [entryOrEntries],
-  );
-const setAdd = (set, value) => set?.add(value);
-
-const TABLE = 'TABLE';
-const ALTER_TABLE = 'ALTER ' + TABLE;
-const DELETE_FROM = 'DELETE FROM';
-const SELECT_STAR_FROM = SELECT + '*FROM';
-const FROM_PRAGMA_TABLE = 'FROM pragma_table_';
-const WHERE = 'WHERE';
-const getCommandFunctions = (
-  cmd,
-  managedTableNames,
-  onIgnoredError,
-  useOnConflict,
-) => {
-  const schemaMap = mapNew();
-  const canSelect = (tableName, rowIdColumnName) =>
-    !isUndefined(mapGet(mapGet(schemaMap, tableName), rowIdColumnName));
-  const refreshSchema = async () =>
-    mapMatch(
-      schemaMap,
-      objNew(
-        await promiseAll(
-          arrayMap(
-            await cmd(
-              'SELECT name ' +
-                FROM_PRAGMA_TABLE +
-                `list WHERE schema='main'AND(type='table'OR type='view')AND name IN(` +
-                getPlaceholders(managedTableNames) +
-                `)ORDER BY name`,
-              managedTableNames,
-            ),
-            async ({name: tableName}) => [
-              tableName,
-              objNew(
-                arrayMap(
-                  await cmd(
-                    SELECT + ' name,type ' + FROM_PRAGMA_TABLE + 'info(?)',
-                    [tableName],
-                  ),
-                  ({name: columnName, type}) => [columnName, type],
-                ),
-              ),
-            ],
-          ),
-        ),
-      ),
-      (_, tableName, tableSchema) =>
-        mapSet(
-          schemaMap,
-          tableName,
-          mapMatch(
-            mapEnsure(schemaMap, tableName, mapNew),
-            tableSchema,
-            (tableSchemaMap, columnName, value) => {
-              if (value != mapGet(tableSchemaMap, columnName)) {
-                mapSet(tableSchemaMap, columnName, value);
-              }
-            },
-            (tableSchema2, columnName) => mapSet(tableSchema2, columnName),
-          ),
-        ),
-      (_, name) => mapSet(schemaMap, name),
-    );
-  const loadTable = async (tableName, rowIdColumnName) =>
-    canSelect(tableName, rowIdColumnName)
-      ? objNew(
-          arrayFilter(
-            arrayMap(
-              await cmd(SELECT_STAR_FROM + escapeId(tableName)),
-              (row) => [
-                row[rowIdColumnName],
-                objDel({...row}, rowIdColumnName),
-              ],
-            ),
-            ([rowId, row]) => !isUndefined(rowId) && !objIsEmpty(row),
-          ),
-        )
-      : {};
-  const saveTable = async (
-    tableName,
-    rowIdColumnName,
-    content,
-    deleteEmptyColumns,
-    deleteEmptyTable,
-    partial = false,
-  ) => {
-    const tableCellOrValueIds = setNew();
-    objToArray(content ?? {}, (contentRow) =>
-      arrayMap(objIds(contentRow ?? {}), (cellOrValueId) =>
-        setAdd(tableCellOrValueIds, cellOrValueId),
-      ),
-    );
-    const tableColumnNames = collValues(tableCellOrValueIds);
-    if (
-      !partial &&
-      deleteEmptyTable &&
-      arrayIsEmpty(tableColumnNames) &&
-      collHas(schemaMap, tableName)
-    ) {
-      await cmd('DROP ' + TABLE + escapeId(tableName));
-      mapSet(schemaMap, tableName);
-      return;
-    }
-    if (!arrayIsEmpty(tableColumnNames) && !collHas(schemaMap, tableName)) {
-      await cmd(
-        `CREATE ` +
-          TABLE +
-          escapeId(tableName) +
-          '(' +
-          escapeId(rowIdColumnName) +
-          ` PRIMARY KEY ON CONFLICT REPLACE${arrayJoin(
-            arrayMap(tableColumnNames, (cellId) => COMMA + escapeId(cellId)),
-          )});`,
-      );
-      mapSet(
-        schemaMap,
-        tableName,
-        mapNew([
-          [rowIdColumnName, EMPTY_STRING],
-          ...arrayMap(tableColumnNames, (columnName) => [
-            columnName,
-            EMPTY_STRING,
-          ]),
-        ]),
-      );
-    } else {
-      const tableSchemaMap = mapGet(schemaMap, tableName);
-      const columnNamesAccountedFor = setNew(mapKeys(tableSchemaMap));
-      await promiseAll([
-        ...arrayMap(tableColumnNames, async (columnName) => {
-          if (!collDel(columnNamesAccountedFor, columnName)) {
-            await cmd(
-              ALTER_TABLE + escapeId(tableName) + 'ADD' + escapeId(columnName),
-            );
-            mapSet(tableSchemaMap, columnName, EMPTY_STRING);
-          }
-        }),
-        ...(!partial && deleteEmptyColumns
-          ? arrayMap(
-              collValues(columnNamesAccountedFor),
-              async (columnName) => {
-                if (columnName != rowIdColumnName) {
-                  await cmd(
-                    ALTER_TABLE +
-                      escapeId(tableName) +
-                      'DROP' +
-                      escapeId(columnName),
-                  );
-                  mapSet(tableSchemaMap, columnName);
-                }
-              },
-            )
-          : []),
-      ]);
-    }
-    if (partial) {
-      if (isUndefined(content)) {
-        await cmd(DELETE_FROM + escapeId(tableName) + WHERE + ' 1');
-      } else {
-        await promiseAll(
-          objToArray(content, async (row, rowId) => {
-            if (isUndefined(row)) {
-              await cmd(
-                DELETE_FROM +
-                  escapeId(tableName) +
-                  WHERE +
-                  escapeId(rowIdColumnName) +
-                  '=?',
-                [rowId],
-              );
-            } else if (!arrayIsEmpty(tableColumnNames)) {
-              await upsert(
-                cmd,
-                tableName,
-                rowIdColumnName,
-                objIds(row),
-                [rowId, ...objValues(row)],
-                useOnConflict,
-              );
-            }
-          }),
-        );
-      }
-    } else {
-      if (!arrayIsEmpty(tableColumnNames)) {
-        const changingColumnNames = arrayFilter(
-          mapKeys(mapGet(schemaMap, tableName)),
-          (columnName) => columnName != rowIdColumnName,
-        );
-        const args = [];
-        const deleteRowIds = [];
-        objToArray(content ?? {}, (row, rowId) => {
-          arrayPush(
-            args,
-            rowId,
-            ...arrayMap(changingColumnNames, (cellId) => row?.[cellId]),
-          );
-          arrayPush(deleteRowIds, rowId);
-        });
-        await upsert(
-          cmd,
-          tableName,
-          rowIdColumnName,
-          changingColumnNames,
-          args,
-          useOnConflict,
-        );
-        await cmd(
-          DELETE_FROM +
-            escapeId(tableName) +
-            WHERE +
-            escapeId(rowIdColumnName) +
-            'NOT IN(' +
-            getPlaceholders(deleteRowIds) +
-            ')',
-          deleteRowIds,
-        );
-      } else if (collHas(schemaMap, tableName)) {
-        await cmd(DELETE_FROM + escapeId(tableName) + WHERE + ' 1');
-      }
-    }
-  };
-  const transaction = async (actions) => {
-    let result;
-    await cmd('BEGIN');
-    try {
-      result = await actions();
-    } catch (error) {
-      onIgnoredError?.(error);
-    }
-    await cmd('END');
-    return result;
-  };
-  return [refreshSchema, loadTable, saveTable, transaction];
-};
-const upsert = async (
-  cmd,
-  tableName,
-  rowIdColumnName,
-  changingColumnNames,
-  args,
-  useOnConflict = true,
-) =>
-  await cmd(
-    'INSERT ' +
-      (useOnConflict ? EMPTY_STRING : 'OR REPLACE ') +
-      'INTO' +
-      escapeId(tableName) +
-      '(' +
-      escapeId(rowIdColumnName) +
-      arrayJoin(
-        arrayMap(
-          changingColumnNames,
-          (columnName) => COMMA + escapeId(columnName),
-        ),
-      ) +
-      ')VALUES' +
-      slice(
-        strRepeat(
-          `,(?${strRepeat(',?', size(changingColumnNames))})`,
-          size(args) / (size(changingColumnNames) + 1),
-        ),
-        1,
-      ) +
-      (useOnConflict
-        ? 'ON CONFLICT(' +
-          escapeId(rowIdColumnName) +
-          ')DO UPDATE SET' +
-          arrayJoin(
-            arrayMap(
-              changingColumnNames,
-              (columnName) =>
-                escapeId(columnName) + '=excluded.' + escapeId(columnName),
-            ),
-            COMMA,
-          )
-        : EMPTY_STRING),
-    arrayMap(args, (arg) => arg ?? null),
-  );
-const getPlaceholders = (array) =>
-  arrayJoin(
-    arrayMap(array, () => '?'),
-    COMMA,
-  );
-
-const jsonStringWithUndefined = (obj) =>
-  JSON.stringify(obj, (_key, value) => (value === void 0 ? UNDEFINED : value));
-const jsonParseWithUndefined = (str) =>
-  JSON.parse(str, (_key, value) => (value === UNDEFINED ? void 0 : value));
-
-const scheduleRunning = mapNew();
-const scheduleActions = mapNew();
-const getStoreFunctions = (supportedStoreType = 1, store) =>
-  supportedStoreType > 1 && store.isMergeable()
-    ? [
-        1,
-        store.getMergeableContent,
-        store.getTransactionMergeableChanges,
-        ([[changedTables], [changedValues]]) =>
-          !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
-        store.setDefaultContent,
-      ]
-    : supportedStoreType != 2
-      ? [
-          0,
-          store.getContent,
-          store.getTransactionChanges,
-          ([changedTables, changedValues]) =>
-            !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
-          store.setContent,
-        ]
-      : errorNew('Store type not supported by this Persister');
-const createCustomPersister = (
-  store,
-  getPersisted,
-  setPersisted,
-  addPersisterListener,
-  delPersisterListener,
-  onIgnoredError,
-  supportedStoreType,
-  extra = {},
-  scheduleId = [],
-) => {
-  let loadSave = 0;
-  let loads = 0;
-  let saves = 0;
-  let action;
-  let autoLoadHandle;
-  let autoSaveListenerId;
-  mapEnsure(scheduleRunning, scheduleId, () => 0);
-  mapEnsure(scheduleActions, scheduleId, () => []);
-  const [
-    isMergeableStore,
-    getContent,
-    getChanges,
-    hasChanges,
-    setDefaultContent,
-  ] = getStoreFunctions(supportedStoreType, store);
-  const run = async () => {
-    /* istanbul ignore else */
-    if (!mapGet(scheduleRunning, scheduleId)) {
-      mapSet(scheduleRunning, scheduleId, 1);
-      while (
-        !isUndefined((action = arrayShift(mapGet(scheduleActions, scheduleId))))
-      ) {
-        try {
-          await action();
-        } catch (error) {
-          /* istanbul ignore next */
-          onIgnoredError?.(error);
-        }
-      }
-      mapSet(scheduleRunning, scheduleId, 0);
-    }
-  };
-  const setContentOrChanges = (contentOrChanges) => {
-    (isMergeableStore && isArray(contentOrChanges?.[0])
-      ? contentOrChanges?.[2] === 1
-        ? store.applyMergeableChanges
-        : store.setMergeableContent
-      : contentOrChanges?.[2] === 1
-        ? store.applyChanges
-        : store.setContent)(contentOrChanges);
-  };
-  const load = async (initialContent) => {
-    /* istanbul ignore else */
-    if (loadSave != 2) {
-      loadSave = 1;
-      loads++;
-      await schedule(async () => {
-        try {
-          setContentOrChanges(await getPersisted());
-        } catch (error) {
-          onIgnoredError?.(error);
-          if (initialContent) {
-            setDefaultContent(initialContent);
-          }
-        }
-        loadSave = 0;
-      });
-    }
-    return persister;
-  };
-  const startAutoLoad = async (initialContent) => {
-    await stopAutoLoad().load(initialContent);
-    autoLoadHandle = addPersisterListener(async (content, changes) => {
-      if (changes || content) {
-        /* istanbul ignore else */
-        if (loadSave != 2) {
-          loadSave = 1;
-          loads++;
-          setContentOrChanges(changes ?? content);
-          loadSave = 0;
-        }
-      } else {
-        await load();
-      }
-    });
-    return persister;
-  };
-  const stopAutoLoad = () => {
-    if (autoLoadHandle) {
-      delPersisterListener(autoLoadHandle);
-      autoLoadHandle = void 0;
-    }
-    return persister;
-  };
-  const isAutoLoading = () => !isUndefined(autoLoadHandle);
-  const save = async (changes) => {
-    /* istanbul ignore else */
-    if (loadSave != 1) {
-      loadSave = 2;
-      saves++;
-      await schedule(async () => {
-        try {
-          await setPersisted(getContent, changes);
-        } catch (error) {
-          /* istanbul ignore next */
-          onIgnoredError?.(error);
-        }
-        loadSave = 0;
-      });
-    }
-    return persister;
-  };
-  const startAutoSave = async () => {
-    await stopAutoSave().save();
-    autoSaveListenerId = store.addDidFinishTransactionListener(() => {
-      const changes = getChanges();
-      if (hasChanges(changes)) {
-        save(changes);
-      }
-    });
-    return persister;
-  };
-  const stopAutoSave = () => {
-    ifNotUndefined(autoSaveListenerId, store.delListener);
-    autoSaveListenerId = void 0;
-    return persister;
-  };
-  const isAutoSaving = () => !isUndefined(autoSaveListenerId);
-  const schedule = async (...actions) => {
-    arrayPush(mapGet(scheduleActions, scheduleId), ...actions);
-    await run();
-    return persister;
-  };
-  const getStore = () => store;
-  const destroy = () => stopAutoLoad().stopAutoSave();
-  const getStats = () => ({loads, saves});
-  const persister = {
-    load,
-    startAutoLoad,
-    stopAutoLoad,
-    isAutoLoading,
-    save,
-    startAutoSave,
-    stopAutoSave,
-    isAutoSaving,
-    schedule,
-    getStore,
-    destroy,
-    getStats,
-    ...extra,
-  };
-  return objFreeze(persister);
-};
-
-const createJsonSqlitePersister = (
-  store,
-  cmd,
-  addPersisterListener,
-  delPersisterListener,
-  onIgnoredError,
-  supportedStoreType,
-  [storeTableName, storeIdColumnName, storeColumnName],
-  managedTableNames,
-  db,
-  getThing,
-  useOnConflict,
-) => {
-  const [refreshSchema, loadTable, saveTable, transaction] =
-    getCommandFunctions(cmd, managedTableNames, onIgnoredError, useOnConflict);
-  const getPersisted = async () =>
-    await transaction(async () => {
-      await refreshSchema();
-      return jsonParseWithUndefined(
-        (await loadTable(storeTableName, storeIdColumnName))[SINGLE_ROW_ID]?.[
-          storeColumnName
-        ] ?? 'null',
-      );
-    });
-  const setPersisted = async (getContent) =>
-    await transaction(async () => {
-      await refreshSchema();
-      await saveTable(
-        storeTableName,
-        storeIdColumnName,
-        {
-          [SINGLE_ROW_ID]: {
-            [storeColumnName]: jsonStringWithUndefined(getContent() ?? null),
-          },
-        },
-        true,
-        true,
-      );
-    });
-  const persister = createCustomPersister(
-    store,
-    getPersisted,
-    setPersisted,
-    addPersisterListener,
-    delPersisterListener,
-    onIgnoredError,
-    supportedStoreType,
-    {[getThing]: () => db},
-    db,
-  );
-  return persister;
-};
-
-const createTabularSqlitePersister = (
-  store,
-  cmd,
-  addPersisterListener,
-  delPersisterListener,
-  onIgnoredError,
-  supportedStoreType,
-  [
-    tablesLoadConfig,
-    tablesSaveConfig,
-    [valuesLoad, valuesSave, valuesTableName],
-  ],
-  managedTableNames,
-  db,
-  getThing,
-  useOnConflict,
-) => {
-  const [refreshSchema, loadTable, saveTable, transaction] =
-    getCommandFunctions(cmd, managedTableNames, onIgnoredError, useOnConflict);
-  const saveTables = async (tables, partial) =>
-    await promiseAll(
-      mapMap(
-        tablesSaveConfig,
-        async (
-          [tableName, rowIdColumnName, deleteEmptyColumns, deleteEmptyTable],
-          tableId,
-        ) => {
-          if (!partial || objHas(tables, tableId)) {
-            await saveTable(
-              tableName,
-              rowIdColumnName,
-              tables[tableId],
-              deleteEmptyColumns,
-              deleteEmptyTable,
-              partial,
-            );
-          }
-        },
-      ),
-    );
-  const saveValues = async (values, partial) =>
-    valuesSave
-      ? await saveTable(
-          valuesTableName,
-          DEFAULT_ROW_ID_COLUMN_NAME,
-          {[SINGLE_ROW_ID]: values},
-          true,
-          true,
-          partial,
-        )
-      : null;
-  const loadTables = async () =>
-    objNew(
-      arrayFilter(
-        await promiseAll(
-          mapMap(
-            tablesLoadConfig,
-            async ([tableId, rowIdColumnName], tableName) => [
-              tableId,
-              await loadTable(tableName, rowIdColumnName),
-            ],
-          ),
-        ),
-        (pair) => !objIsEmpty(pair[1]),
-      ),
-    );
-  const loadValues = async () =>
-    valuesLoad
-      ? (await loadTable(valuesTableName, DEFAULT_ROW_ID_COLUMN_NAME))[
-          SINGLE_ROW_ID
-        ]
-      : {};
-  const getPersisted = async () =>
-    await transaction(async () => {
-      await refreshSchema();
-      const tables = await loadTables();
-      const values = await loadValues();
-      return !objIsEmpty(tables) || !isUndefined(values)
-        ? [tables, values]
-        : void 0;
-    });
-  const setPersisted = async (getContent, changes) =>
-    await transaction(async () => {
-      await refreshSchema();
-      if (!isUndefined(changes)) {
-        await saveTables(changes[0], true);
-        await saveValues(changes[1], true);
-      } else {
-        const [tables, values] = getContent();
-        await saveTables(tables);
-        await saveValues(values);
-      }
-    });
-  const persister = createCustomPersister(
-    store,
-    getPersisted,
-    setPersisted,
-    addPersisterListener,
-    delPersisterListener,
-    onIgnoredError,
-    supportedStoreType,
-    {[getThing]: () => db},
-    db,
-  );
-  return persister;
-};
-
-const COLUMN_NAME = 'ColumnName';
-const STORE = 'store';
-const JSON$1 = 'json';
-const STORE_TABLE_NAME = STORE + 'TableName';
-const STORE_ID_COLUMN_NAME = STORE + 'Id' + COLUMN_NAME;
-const STORE_COLUMN_NAME = STORE + COLUMN_NAME;
-const AUTO_LOAD_INTERVAL_SECONDS = 'autoLoadIntervalSeconds';
-const ROW_ID_COLUMN_NAME = 'rowId' + COLUMN_NAME;
-const TABLE_ID = 'tableId';
-const TABLE_NAME = 'tableName';
-const DELETE_EMPTY_COLUMNS = 'deleteEmptyColumns';
-const DELETE_EMPTY_TABLE = 'deleteEmptyTable';
-const DEFAULT_CONFIG = {
-  mode: JSON$1,
-  [AUTO_LOAD_INTERVAL_SECONDS]: 1,
-};
-const DEFAULT_TABULAR_VALUES_CONFIG = {
-  load: 0,
-  save: 0,
-  [TABLE_NAME]: TINYBASE + '_values',
-};
-const getDefaultedConfig = (configOrStoreTableName) =>
-  objMerge(
-    DEFAULT_CONFIG,
-    isString(configOrStoreTableName)
-      ? {[STORE_TABLE_NAME]: configOrStoreTableName}
-      : configOrStoreTableName ?? {},
-  );
-const getDefaultedTabularConfigMap = (
-  configsObj,
-  defaultObj,
-  tableField,
-  exclude,
-  then,
-) => {
-  const configMap = mapNew();
-  objToArray(configsObj, (configObj, id) => {
-    const defaultedConfig = slice(
-      objValues(
-        objMerge(
-          defaultObj,
-          isString(configObj) ? {[tableField]: configObj} : configObj,
-        ),
-      ),
-      0,
-      objSize(defaultObj),
-    );
-    if (!isUndefined(defaultedConfig[0]) && !exclude(id, defaultedConfig[0])) {
-      then(id, defaultedConfig[0]);
-      mapSet(configMap, id, defaultedConfig);
-    }
-  });
-  return configMap;
-};
-const getConfigStructures = (configOrStoreTableName) => {
-  const config = getDefaultedConfig(configOrStoreTableName);
-  const autoLoadIntervalSeconds = config[AUTO_LOAD_INTERVAL_SECONDS];
-  if (config.mode == JSON$1) {
-    const storeTableName = config[STORE_TABLE_NAME] ?? TINYBASE;
-    return [
-      1,
-      autoLoadIntervalSeconds,
-      [
-        storeTableName,
-        config[STORE_ID_COLUMN_NAME] ?? DEFAULT_ROW_ID_COLUMN_NAME,
-        config[STORE_COLUMN_NAME] ?? STORE,
-      ],
-      setNew(storeTableName),
-    ];
-  }
-  const {tables: {load = {}, save = {}} = {}, values = {}} = config;
-  const valuesConfig = slice(
-    objValues(objMerge(DEFAULT_TABULAR_VALUES_CONFIG, values)),
-    0,
-    objSize(DEFAULT_TABULAR_VALUES_CONFIG),
-  );
-  const valuesTable = valuesConfig[2];
-  const managedTableNames = setNew(valuesTable);
-  const excludedTableNames = setNew(valuesTable);
-  const tabularConfig = [
-    getDefaultedTabularConfigMap(
-      load,
-      {[TABLE_ID]: null, [ROW_ID_COLUMN_NAME]: DEFAULT_ROW_ID_COLUMN_NAME},
-      TABLE_ID,
-      (tableName) => collHas(excludedTableNames, tableName),
-      (tableName) => setAdd(managedTableNames, tableName),
-    ),
-    getDefaultedTabularConfigMap(
-      save,
-      {
-        [TABLE_NAME]: null,
-        [ROW_ID_COLUMN_NAME]: DEFAULT_ROW_ID_COLUMN_NAME,
-        [DELETE_EMPTY_COLUMNS]: 0,
-        [DELETE_EMPTY_TABLE]: 0,
-      },
-      TABLE_NAME,
-      (_, tableName) => collHas(excludedTableNames, tableName),
-      (_, tableName) => setAdd(managedTableNames, tableName),
-    ),
-    valuesConfig,
-  ];
-  return [0, autoLoadIntervalSeconds, tabularConfig, managedTableNames];
-};
-
-const PRAGMA = 'pragma_';
-const DATA_VERSION = 'data_version';
-const SCHEMA_VERSION = 'schema_version';
-const createSqlitePersister = (
-  store,
-  configOrStoreTableName,
-  cmd,
-  addUpdateListener,
-  delUpdateListener,
-  onSqlCommand,
-  onIgnoredError,
-  supportedStoreType,
-  db,
-  getThing = 'getDb',
-  useOnConflict,
-) => {
-  let dataVersion;
-  let schemaVersion;
-  let totalChanges;
-  const [
-    isJson,
-    autoLoadIntervalSeconds,
-    defaultedConfig,
-    managedTableNamesSet,
-  ] = getConfigStructures(configOrStoreTableName);
-  const addPersisterListener = (listener) => [
-    startInterval(async () => {
-      try {
-        const [{d, s, c}] = await cmd(
-          `SELECT ${DATA_VERSION} d,${SCHEMA_VERSION} s,TOTAL_CHANGES() c FROM ${PRAGMA}${DATA_VERSION} JOIN ${PRAGMA}${SCHEMA_VERSION}`,
-        );
-        if (
-          d != (dataVersion ??= d) ||
-          s != (schemaVersion ??= s) ||
-          c != (totalChanges ??= c)
-        ) {
-          listener();
-          dataVersion = d;
-          schemaVersion = s;
-        }
-      } catch {}
-    }, autoLoadIntervalSeconds),
-    addUpdateListener((tableName) =>
-      managedTableNamesSet.has(tableName) ? listener() : 0,
-    ),
-  ];
-  const delPersisterListener = ([interval, listeningHandle]) => {
-    stopInterval(interval);
-    dataVersion = schemaVersion = totalChanges = null;
-    delUpdateListener(listeningHandle);
-  };
-  return (isJson ? createJsonSqlitePersister : createTabularSqlitePersister)(
-    store,
-    onSqlCommand
-      ? async (sql, args) => {
-          onSqlCommand(sql, args);
-          return await cmd(sql, args);
-        }
-      : cmd,
-    addPersisterListener,
-    delPersisterListener,
-    onIgnoredError,
-    supportedStoreType,
-    defaultedConfig,
-    collValues(managedTableNamesSet),
-    db,
-    getThing,
-    useOnConflict,
-  );
-};
-
-const createExpoSqliteNextPersister = (
-  store,
-  db,
-  configOrStoreTableName,
-  onSqlCommand,
-  onIgnoredError,
-) =>
-  createSqlitePersister(
-    store,
-    configOrStoreTableName,
-    async (sql, args = []) => await db.getAllAsync(sql, args),
-    (listener) =>
-      next_js.addDatabaseChangeListener(({tableName}) => listener(tableName)),
-    (subscription) => subscription.remove(),
-    onSqlCommand,
-    onIgnoredError,
-    3,
-    db,
-  );
-
-exports.createExpoSqliteNextPersister = createExpoSqliteNextPersister;