gs-idb-pro 0.1.5 → 1.0.0

package/lib/impl.cjs

@@ -0,0 +1,1247 @@
+"use strict";
+var type$1 = require('./type.cjs'), types = require('gs-base/types'), store = require('gs-idb-basic/store'), type = require('gs-idb-basic/type'), basic = require('gs-base/basic'), json = require('gs-base/json'), tx = require('gs-idb-basic/tx'), db = require('gs-idb-basic/db'), storage = require('gs-idb-basic/storage');
+const toNum = (v) => v instanceof Date ? v.getTime() : v;
+function parseIDbQuery(query) {
+  if (type.isDbQueryOrNull(query) || !types.isObject(query))
+    return query;
+  const range = query;
+  if ("lt" in range && "gt" in range) {
+    if (toNum(range.gt) > toNum(range.lt))
+      throw new Error(`Invalid IDBRange: gt (${range.gt}) cannot be greater than lt (${range.lt})`);
+    return IDBKeyRange.bound(range.gt, range.lt, !0, !0);
+  }
+  if ("lt" in range && "gte" in range) {
+    if (toNum(range.gte) > toNum(range.lt))
+      throw new Error(`Invalid IDBRange: gte (${range.gte}) cannot be greater than lt (${range.lt})`);
+    return IDBKeyRange.bound(range.gte, range.lt, !1, !0);
+  }
+  if ("lte" in range && "gt" in range) {
+    if (toNum(range.gt) > toNum(range.lte))
+      throw new Error(`Invalid IDBRange: gt (${range.gt}) cannot be greater than lte (${range.lte})`);
+    return IDBKeyRange.bound(range.gt, range.lte, !0, !1);
+  }
+  if ("lte" in range && "gte" in range) {
+    if (toNum(range.gte) > toNum(range.lte))
+      throw new Error(`Invalid IDBRange: gte (${range.gte}) cannot be greater than lte (${range.lte})`);
+    return IDBKeyRange.bound(range.gte, range.lte, !1, !1);
+  }
+  if ("lt" in range) return IDBKeyRange.upperBound(range.lt, !0);
+  if ("lte" in range) return IDBKeyRange.upperBound(range.lte, !1);
+  if ("gt" in range) return IDBKeyRange.lowerBound(range.gt, !0);
+  if ("gte" in range) return IDBKeyRange.lowerBound(range.gte, !1);
+}
+function isIDbQuery(query) {
+  return parseIDbQuery(query) != null;
+}
+async function openCursor(target, arg, fn) {
+  const { query, direction = "prev", preSkip, startKey, startPrimaryKey } = arg, request = target.openCursor(parseIDbQuery(query), direction);
+  return preSkip && (await store.requestDbResult(request)).advance(preSkip), startKey && (startPrimaryKey ? (await store.requestDbResult(request)).continuePrimaryKey(startKey, startPrimaryKey) : (await store.requestDbResult(request)).continue(startKey)), request;
+}
+function getMapperFn(mapper, keyPath, useArrayRecord) {
+  return Array.isArray(mapper) ? (v) => basic.copyFields({}, v, mapper) : types.isFunction(mapper) ? mapper : keyPath ? (v) => v : useArrayRecord ? (v, k) => [v, k] : (key, value) => ({ key, value });
+}
+class DataOperationBase {
+  idbPro;
+  target;
+  #storeSchema;
+  constructor(schema, db2) {
+    this.idbPro = db2, this.#storeSchema = schema.storeSchema, this.target = schema.target, type$1.isNativeTarget(schema.target) && (this.tx = this.#nativeOperation);
+  }
+  get storeName() {
+    return this.nativeStore?.name || this.target.store;
+  }
+  get storeSchema() {
+    if (this.#storeSchema) return this.#storeSchema;
+    const storeSchema = this.idbPro.getStoreSchema(this.storeName);
+    return Object.isFrozen(storeSchema) && (this.#storeSchema = storeSchema), storeSchema;
+  }
+  get factory() {
+    return this.idbPro.factory;
+  }
+  get nativeStore() {
+    const { target } = this;
+    if (target instanceof IDBObjectStore) return target;
+    if (target instanceof IDBIndex) return target.objectStore;
+  }
+  get keyPath() {
+    const { target } = this;
+    if (type$1.isNativeTarget(target))
+      return target.keyPath;
+    const { storeSchema } = this, { index } = target;
+    return index ? storeSchema.indexSchemas.find((i) => i.name === index)?.keyPath : storeSchema.keyPath;
+  }
+  async forEach(arg, returns) {
+    return arg = types.isFunction(arg) ? { fn: arg } : arg, returns ? this.cursorResult(arg, !1) : this.cursorVoid(arg, !1);
+  }
+  async tx(writable, fn, rollbackOnError) {
+    let { target } = this;
+    const { store: store2, index } = target, db2 = await this.idbPro.openNativeDb();
+    let tx2, nativeStore;
+    try {
+      tx2 = db2.transaction(store2, writable === !0 ? "readwrite" : "readonly"), target = nativeStore = tx2.objectStore(store2), index && (target = target.index(index));
+    } catch (e) {
+      throw db2.close(), e;
+    }
+    if (!fn)
+      return Object.freeze({ db: db2, tx: tx2, nativeStore, target });
+    try {
+      if (writable === !0) {
+        const result = await fn(target, nativeStore);
+        return tx2.commit(), result;
+      }
+      return fn(target);
+    } catch (e) {
+      throw rollbackOnError !== !1 && tx2.abort(), e;
+    } finally {
+      db2.close();
+    }
+  }
+  openCursor(arg, writable) {
+    return this.tx(writable, (store2) => new Promise(async (resolve, reject) => {
+      const { fn } = arg, request = await openCursor(store2, arg);
+      request.onsuccess = async () => {
+        request.result ? await fn(request.result) === !1 && resolve() : resolve();
+      }, request.onerror = () => reject(request.error);
+    }));
+  }
+  cursorVoid({ query, direction, preSkip, startKey, startPrimaryKey, fn }, writable) {
+    let i = 0;
+    return this.openCursor({
+      query,
+      direction,
+      preSkip,
+      startKey,
+      startPrimaryKey,
+      fn: async (cursor) => {
+        const { value: ov, primaryKey: op } = cursor, result = await fn(ov, op, i++), {
+          control,
+          key,
+          primaryKey,
+          modify,
+          value
+        } = types.isObject(result) ? result : { control: result };
+        switch (writable && (modify === type$1.Save ? cursor.update(value || ov) : modify === type$1.Delete && cursor.delete()), control) {
+          case type$1.Break:
+            return !1;
+          case type$1.ContinueKey:
+            cursor.continue(key);
+            break;
+          case type$1.ContinuePrimaryKey:
+            cursor.continuePrimaryKey(key, primaryKey);
+            break;
+          default:
+            cursor.continue();
+        }
+      }
+    }, !0);
+  }
+  async cursorResult({
+    query,
+    direction,
+    preSkip,
+    startKey,
+    startPrimaryKey,
+    fn,
+    mapper: mpr
+  }, writable) {
+    const { keyPath, defaultGetMapper } = this.storeSchema, mapper = getMapperFn(mpr || defaultGetMapper, keyPath), results = [];
+    let i = 0;
+    return await this.openCursor({
+      query,
+      direction,
+      preSkip,
+      startKey,
+      startPrimaryKey,
+      fn: async (cursor) => {
+        const { value: ov, primaryKey: op } = cursor, {
+          control,
+          value,
+          key,
+          primaryKey,
+          modify
+        } = await fn?.(ov, op, i, results) || {};
+        switch (writable && (modify === type$1.Save ? cursor.update(value || ov) : modify === type$1.Delete && cursor.delete()), (!control || control === type$1.Finished || control === type$1.NextKey || control === type$1.NextPrimaryKey) && results.push(mapper(value || ov, primaryKey || op, i)), control) {
+          case type$1.Break:
+          case type$1.Finished:
+            return !1;
+          case type$1.NextKey:
+          case type$1.ContinueKey:
+            cursor.continue(key);
+            break;
+          case type$1.NextPrimaryKey:
+          case type$1.ContinuePrimaryKey:
+            cursor.continuePrimaryKey(key, primaryKey);
+            break;
+          default:
+            cursor.continue();
+        }
+        i++;
+      }
+    }, writable), results;
+  }
+  // noinspection JSUnusedLocalSymbols
+  #nativeOperation(writable, fn) {
+    const { target } = this, nativeStore = target instanceof IDBObjectStore ? target : target.objectStore;
+    return fn ? fn(target, nativeStore) : Object.freeze({ nativeStore, target });
+  }
+}
+class DataOperators {
+  idbPro;
+  schemas;
+  #_storeNames;
+  constructor(idbPro, schemas) {
+    this.idbPro = idbPro, this.schemas = schemas;
+  }
+  get storeNames() {
+    return this.#_storeNames || (this.#_storeNames = Array.from(new Set(this.schemas.map((s) => s.target.store))));
+  }
+  read(fn) {
+    return this.tx("newReader", fn);
+  }
+  write(fn, rollbackOnError = !0) {
+    return this.tx("newWriter", fn, !0, rollbackOnError);
+  }
+  export() {
+    return this.tx("newReader", async (...stores) => {
+      const result = {};
+      for (const store2 of stores)
+        result[store2.storeName] = await store2.export();
+      return result;
+    });
+  }
+  import(data, returns, use) {
+    return use || (use = "addOrChangeMany"), this.tx("newWriter", async (...stores) => {
+      const result = {};
+      stores = Array.from(new Map(stores.map((s) => [s.storeName, s.asStore(!0)])).values());
+      for (const store2 of stores) {
+        const { storeName } = store2, rows = data[storeName];
+        rows && (result[storeName] = await store2[use](rows, returns));
+      }
+      if (returns) return result;
+    }, !0);
+  }
+  async tx(method, fn, writable, rollbackOnError) {
+    const { idbPro, schemas } = this, { factory } = idbPro.schema, db2 = await idbPro.openNativeDb();
+    try {
+      const tx2 = db2.transaction(this.storeNames, writable ? "readwrite" : "readonly");
+      try {
+        const stores = schemas.map(({ storeSchema, target: info }) => {
+          let target = tx2.objectStore(info.store);
+          return info.index && (target = target.index(info.index)), factory[method]({ storeSchema, target }, idbPro);
+        });
+        return await fn(...stores);
+      } catch (e) {
+        throw rollbackOnError !== !1 && tx2.abort(), e;
+      }
+    } finally {
+      db2.close();
+    }
+  }
+}
+class DbIterator extends DataOperationBase {
+  direction;
+  query;
+  writable;
+  parser;
+  endsWithNull;
+  preSkip;
+  startKey;
+  startPrimaryKey;
+  constructor(schema, db2, option) {
+    if (super(schema, db2), !option) return;
+    const { parser } = option;
+    this.direction = option.direction, this.query = option.query, this.writable = !!option.writable, this.endsWithNull = !!option.endsWithNull, this.preSkip = option.preSkip, this.startKey = option.startKey, this.startPrimaryKey = option.startPrimaryKey, parser && (this.parser = types.isFunction(parser) ? parser : type$1.DbIteratorParsers[parser]);
+  }
+  async *[Symbol.asyncIterator]() {
+    const { parser, writable, endsWithNull } = this, { db: db2, tx: tx2, target } = await this.tx(writable);
+    try {
+      const request = await openCursor(target, this);
+      let cursor;
+      if (parser)
+        for (; cursor = await store.requestDbResult(request); ) {
+          const { control, value } = await parser(cursor);
+          if (control || (yield value), control === type$1.Break) break;
+          cursor.continue();
+        }
+      else {
+        let ended = !1;
+        const end = () => {
+          ended = !0;
+        };
+        for (; !ended && (cursor = await store.requestDbResult(request)); )
+          yield { cursor, end };
+      }
+      writable && tx2?.commit(), endsWithNull && !cursor && (yield null);
+    } finally {
+      db2?.close();
+    }
+  }
+}
+function parseFilterArg(arg1, arg2, arg3, limit) {
+  const args = types.isObject(arg1) ? arg1 : {};
+  return types.isFunction(arg1) ? args.fn = arg1 : isIDbQuery(arg1) && (args.query = arg1), types.isFunction(arg2) ? args.fn = arg2 : arg2 && (args.direction = arg2), arg3 && (args.direction = arg3), limit ? args.limit = limit : args.limit || (args.limit = 1e3), args.maxEmptyChecks || (args.maxEmptyChecks = 2e4), args;
+}
+async function queryPage(anyReader, info, arg) {
+  info.size || (info.size = 100), info.nextSkip || (info.nextSkip = 0);
+  const { query, direction, total, maxEmptyChecks, fn } = info;
+  return await anyReader.batchRead(async (nativeReader) => (total || (info.total = await nativeReader.count({ query, direction, maxEmptyChecks, fn }), info.pages = Math.ceil(info.total / info.size)), info.total < 1 ? { info: basic.deepFreeze(info), rows: [] } : fn ? await queryFnPage(nativeReader, info, arg) : await queryNoneFnPage(nativeReader, info)));
+}
+async function queryNoneFnPage(nativeReader, info) {
+  const { keyPath } = nativeReader.storeSchema, { page, query, direction, size, mapper } = info, preSkip = (page - 1) * size, rows = await nativeReader.filter({
+    query,
+    preSkip,
+    direction,
+    limit: size,
+    mapper: getMapperFn(mapper, keyPath, !0)
+  });
+  return info.nextSkip = preSkip + rows.length, {
+    info: basic.deepFreeze(info),
+    rows
+  };
+}
+async function queryFnPage(reader, info, arg) {
+  info.maxEmptyChecks || (info.maxEmptyChecks = 2e4);
+  const { page, query, direction, nextSkip } = info, { keyPath } = reader.storeSchema;
+  return page === 1 ? await queryFnRow(reader, await openCursor(reader.target, { query, direction }), info, keyPath) : arg && nextSkip && page - arg.page === 1 ? await queryFnRow(reader, await openCursor(reader.target, {
+    query,
+    direction,
+    preSkip: nextSkip
+  }), info, keyPath) : await queryFnRow(reader, await openCursor(reader.target, { query, direction }), info, keyPath, !0);
+}
+async function queryFnRow({ storeSchema: { defaultGetMapper } }, request, info, keyPath, hasSkip) {
+  const { page, size, total, maxEmptyChecks, fn } = info, mapper = getMapperFn(info.mapper || defaultGetMapper, keyPath, !0), rows = [], preSkip = (page - 1) * info.size;
+  if (preSkip >= total) return { info: basic.deepFreeze(info), rows: [] };
+  let i = 0;
+  return await new Promise(async (resolve, reject) => {
+    let ept = 0, skipped = 0;
+    const rowFn = async () => {
+      const { result: cursor } = request;
+      if (!cursor) return resolve();
+      let { value, primaryKey } = cursor;
+      if (await fn(value, primaryKey, i) ? (ept = 0, rows.push(mapper(value, primaryKey, i))) : ept++, rows.length >= size || ept >= maxEmptyChecks) return resolve();
+      i++, cursor.continue();
+    };
+    request.onerror = () => reject(request.error), hasSkip ? request.onsuccess = async () => {
+      const { result: cursor } = request;
+      if (!cursor)
+        return resolve();
+      let { value, primaryKey } = cursor;
+      if (await fn(value, primaryKey, i) ? (ept = 0, skipped++) : ept++, skipped >= preSkip || ept >= maxEmptyChecks) {
+        i = ept = 0, request.onsuccess = rowFn, cursor.continue();
+        return;
+      }
+      cursor.continue(), i++;
+    } : request.onsuccess = rowFn;
+  }), i && (info.nextSkip += i + 1), {
+    info: basic.deepFreeze(info),
+    rows
+  };
+}
+class DataReader extends DataOperationBase {
+  all(query, limit) {
+    const param = isIDbQuery(query) ? { query } : query || {};
+    return types.isNumber(limit) && (param.count = limit), types.isNumber(param.count) || (param.count = 1e3), param.query = parseIDbQuery(param.query), this.tx(!1, (store$1) => store.requestDbResult(store$1.getAll(param)));
+  }
+  async count(arg1, arg2, arg3) {
+    const args = parseFilterArg(arg1, arg2, arg3), { query, direction, fn } = args;
+    if (!fn)
+      return await this.tx(!1, (store$1) => store.requestDbResult(store$1.count(parseIDbQuery(query))));
+    const { maxEmptyChecks } = args, findFn = fn;
+    let count = 0, ept = 0, i = 0;
+    return await this.openCursor({
+      query,
+      direction,
+      fn: (cursor) => {
+        if (findFn(cursor.value, cursor.primaryKey, i++))
+          count++, ept = 0;
+        else if (++ept >= maxEmptyChecks)
+          return !1;
+        cursor.continue();
+      }
+    }), count;
+  }
+  get(key) {
+    return this.tx(!1, (store$1) => store.requestDbResult(store$1.get(parseIDbQuery(key))));
+  }
+  getMany(keys, excludeEmpty) {
+    return this.batchRead(async (reader) => {
+      const rows = await basic.asyncMap(keys, (k) => reader.get(k));
+      return excludeEmpty ? rows.filter((v) => v) : rows;
+    });
+  }
+  getRange(query, direction) {
+    return this.forEach({ query, direction }, !0);
+  }
+  async getRangeMany(keys, direction, excludeEmpty) {
+    return (await this.batchRead((w) => basic.asyncMap(keys, (v) => w.getRange(v, direction)))).flat();
+  }
+  index(name, writable) {
+    let { target } = this;
+    return target instanceof IDBIndex && (target = target.objectStore), target instanceof IDBObjectStore ? (target = target.index(name), this.createOperator(target, writable)) : this.idbPro.store(target.store, name);
+  }
+  asStore(writable) {
+    let { target } = this;
+    if (target instanceof IDBObjectStore)
+      return this;
+    if (target instanceof IDBIndex)
+      target = target.objectStore;
+    else {
+      if (!("index" in target))
+        return this;
+      target = { store: target.store };
+    }
+    return this.createOperator(target, writable);
+  }
+  batchRead(fn) {
+    return type$1.isNativeTarget(this.target) ? fn(this) : this.tx(!1, (store2) => fn(this.idbPro.schema.factory.newReader({
+      storeSchema: this.storeSchema,
+      target: store2
+    }, this.idbPro)));
+  }
+  iterator(query, direction) {
+    const arg = {};
+    return types.isString(direction) && (arg.direction = direction), isIDbQuery(query) ? arg.query = query : types.isObject(query) && Object.assign(arg, query), new DbIterator({ storeSchema: this.storeSchema, target: this.target }, this.idbPro, {
+      ...arg,
+      parser: "value"
+    });
+  }
+  async filter(arg1, arg2, arg3, arg4) {
+    const args = parseFilterArg(arg1, arg2, arg3, arg4), { maxEmptyChecks, limit, fn } = args, { keyPath, defaultGetMapper } = this.storeSchema, mapper = getMapperFn(args.mapper || defaultGetMapper, keyPath, !0);
+    if (!fn)
+      return await this.forEach({
+        ...args,
+        mapper,
+        fn: (value, k, i) => {
+          if (i >= limit - 1)
+            return { control: type$1.Finished };
+        }
+      }, !0);
+    let ept = 0;
+    return this.forEach({
+      ...args,
+      mapper,
+      fn: (value, k, i, results) => {
+        if (fn(value, k, i))
+          ept = 0;
+        else
+          return ++ept >= maxEmptyChecks ? { control: type$1.Break } : { control: type$1.Continue };
+        if (results.length >= limit - 1)
+          return { control: type$1.Finished };
+      }
+    }, !0);
+  }
+  async find(query, fn, direction) {
+    const [value] = await this.filter(query, fn, direction, 1);
+    return value;
+  }
+  async page(arg, page) {
+    const info = { ...arg };
+    return info.page = page || arg?.page || 1, queryPage(this, info, arg);
+  }
+  nextPage(info) {
+    return this.page(info, info.page + 1);
+  }
+  export(arg1, arg2) {
+    const args = parseFilterArg(arg1, arg2), { keyPath, exportMapper, name, defaultGetMapper } = this.storeSchema;
+    if (!keyPath && Array.isArray(exportMapper))
+      throw new Error(`When store [ ${name} ] keyPath does not exist, exportMapper does not support string[].`);
+    return args.direction = "next", args.mapper = getMapperFn(exportMapper || defaultGetMapper, keyPath, !0), args.limit = args.maxEmptyChecks = Number.MAX_SAFE_INTEGER, this.filter(args);
+  }
+  asMap() {
+    let { target } = this;
+    return target instanceof IDBIndex ? target = target.objectStore : target instanceof IDBObjectStore || (target = { store: target.store }), this.factory.newDbMap({ target }, this.idbPro);
+  }
+  createOperator(target, writable) {
+    const { idbPro } = this, tmp = this.storeSchema, schema = { storeSchema: Object.isFrozen(tmp) ? tmp : void 0, target };
+    return writable ? this.factory.newWriter(schema, idbPro) : this.factory.newReader(schema, idbPro);
+  }
+}
+function getKeyValueToObject(keyPath, value) {
+  if (!Array.isArray(keyPath))
+    return { [keyPath]: value };
+  const rv = {}, arrayKeyPath = keyPath;
+  for (let i = 0; i < arrayKeyPath.length; i++)
+    rv[arrayKeyPath[i]] = value[i];
+  return rv;
+}
+function getValidKeyValue(keyPath, value) {
+  if (!Array.isArray(keyPath))
+    return value[keyPath];
+  const rv = [];
+  for (const k of keyPath) {
+    if (!value[k]) return;
+    rv.push(value[k]);
+  }
+  return rv;
+}
+function checkAddValue(storeSchema, value) {
+  if (!value || !(value instanceof Object) || Array.isArray(value)) return value;
+  const {
+    addedTimeField,
+    updatedTimeField,
+    updatedCountField,
+    softDeletedField
+  } = storeSchema;
+  return value = { ...value }, addedTimeField?.name && !types.isNumber(value[addedTimeField.name]) && (value[addedTimeField.name] = Date.now()), updatedTimeField?.name && !types.isNumber(value[updatedTimeField.name]) && (value[updatedTimeField.name] = Date.now()), softDeletedField?.name && !types.isNumber(value[softDeletedField.name]) && (value[softDeletedField.name] = 0), updatedCountField?.name && (value[updatedCountField.name] = 0), value;
+}
+function checkUpdateValue(storeSchema, newValue, oldValue) {
+  if (!newValue || !(newValue instanceof Object) || Array.isArray(newValue)) return newValue;
+  const {
+    updatedTimeField,
+    updatedCountField
+  } = storeSchema;
+  return newValue = { ...oldValue, ...newValue }, updatedTimeField.name && (newValue[updatedTimeField.name] = Date.now()), updatedCountField.name && (newValue[updatedCountField.name] = (newValue[updatedCountField.name] || 0) + 1), newValue;
+}
+class DataWriter extends DataReader {
+  add(record) {
+    return this.changeByPk({
+      record,
+      fn: async (store$1, pk, newValue, oldValue, keyPath) => {
+        const { storeSchema } = this;
+        return newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.add(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.add(newValue, pk))];
+      }
+    });
+  }
+  addMany(records, returns) {
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.add(v)) : basic.asyncForEach(records, (v) => w.add(v)), !0);
+  }
+  addOrSkip(record) {
+    return this.batchWrite(async (w) => {
+      const { keyPath: storeKeyPath, defaultGetMapper } = w.storeSchema, { key: pk, value } = storeKeyPath ? {
+        key: getValidKeyValue(storeKeyPath, record),
+        value: record
+      } : type$1.parseDbNoneKeyPathRecord(record);
+      if (pk) {
+        const item = await store.requestDbResult(w.nativeStore.get(pk));
+        if (item)
+          return getMapperFn(defaultGetMapper, storeKeyPath)?.(item, pk);
+      }
+      if (w.target instanceof IDBIndex) {
+        const { keyPath } = w, keyValue = getValidKeyValue(keyPath, value);
+        if (!keyValue) return w.add(record);
+        let oldValue = await w.find(keyValue);
+        if (oldValue) return oldValue;
+      }
+      return w.add(record);
+    });
+  }
+  addOrSkipMany(records, returns) {
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.addOrSkip(v)) : basic.asyncForEach(records, (v) => w.addOrSkip(v)), !0);
+  }
+  replace(record) {
+    return this.changeByPk({
+      record,
+      getOld: !0,
+      fn: async (store$1, pk, newValue, oldValue, keyPath) => {
+        const { storeSchema } = this, { updatedTimeField, updatedCountField, addedTimeField } = storeSchema;
+        return oldValue ? newValue = checkUpdateValue(storeSchema, newValue, {
+          [updatedTimeField.name]: oldValue[updatedTimeField.name],
+          [updatedCountField.name]: oldValue[updatedCountField.name],
+          [addedTimeField.name]: oldValue[addedTimeField.name]
+        }) : newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.put(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.put(newValue, pk))];
+      }
+    });
+  }
+  replaceMany(records, returns) {
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.replace(v)) : basic.asyncForEach(records, (v) => w.replace(v)), !0);
+  }
+  change(record, throwIfMissing) {
+    return this.changeByPk({
+      record,
+      getOld: !0,
+      requiredOld: throwIfMissing,
+      requiredPk: throwIfMissing,
+      fn: async (store$1, pk, newValue, oldValue, keyPath) => {
+        const { storeSchema } = this;
+        if (oldValue)
+          return newValue = checkUpdateValue(storeSchema, newValue, oldValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.put(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.put(newValue, pk))];
+      }
+    });
+  }
+  changeMany(records, option) {
+    const {
+      returns,
+      throwIfMissing
+    } = types.isBoolean(option) ? { returns: option } : option || {};
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.change(v, throwIfMissing)) : basic.asyncForEach(records, (v) => w.change(v, throwIfMissing)), !0);
+  }
+  addOrChange(record) {
+    return this.changeByPk({
+      record,
+      getOld: !0,
+      fn: async (store$1, pk, newValue, oldValue, keyPath) => {
+        const { storeSchema } = this;
+        return oldValue ? (newValue = checkUpdateValue(storeSchema, newValue, oldValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.put(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.put(newValue, pk))]) : (newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.add(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.add(newValue, pk))]);
+      }
+    });
+  }
+  addOrChangeMany(records, returns) {
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.addOrChange(v)) : basic.asyncForEach(records, (v) => w.addOrChange(v)), !0);
+  }
+  delete(pk, returns) {
+    const {
+      returns: getOld,
+      physical
+    } = types.isBoolean(returns) ? { returns } : returns || {}, { storeSchema } = this, softDeletedField = storeSchema.softDeletedField, requiredOld = !!(!physical && softDeletedField?.name);
+    return this.changeByPk({
+      pk,
+      getOld: requiredOld || getOld,
+      fn: (store2, pk2, newValue, oldValue) => {
+        if (requiredOld ? oldValue && (oldValue = checkUpdateValue(storeSchema, { [softDeletedField.name]: type.Bool.True }, oldValue), store2.put(oldValue)) : store2.delete(pk2), !!getOld)
+          return [oldValue, pk2];
+      }
+    });
+  }
+  deleteMany(keys, returns) {
+    const { returns: hasRtn } = types.isBoolean(returns) ? { returns } : returns || {};
+    return this.batchWrite((w) => hasRtn ? basic.asyncMap(keys, (v) => w.delete(v, !0)) : basic.asyncForEach(keys, (v) => w.delete(v)), !0);
+  }
+  deleteRange(query, returns) {
+    const {
+      returns: hasRtn,
+      physical,
+      direction
+    } = types.isBoolean(returns) ? { returns } : returns || {}, { name } = this.storeSchema.softDeletedField || {};
+    return this.cursor({
+      query,
+      direction,
+      fn: (value) => physical || !name ? { modify: type$1.Delete } : (value[name] = type.Bool.True, { modify: type$1.Save })
+    }, hasRtn);
+  }
+  deleteRangeMany(keys, returns) {
+    const option = types.isBoolean(returns) ? { returns } : returns;
+    return this.batchWrite((w) => option?.returns ? basic.asyncMap(keys, (v) => w.deleteRange(v, option)) : basic.asyncForEach(keys, (v) => w.deleteRange(v, option)), !0);
+  }
+  changeRange(arg, returns) {
+    let {
+      direction = "next",
+      query,
+      newValue
+    } = "newValue" in arg ? arg : { newValue: arg };
+    if (query || (query = getValidKeyValue(this.keyPath, newValue)), !query)
+      throw new Error(`query is required：${JSON.stringify(arg)}`);
+    return this.cursor({
+      query,
+      direction,
+      fn: (value) => value instanceof Object ? { modify: type$1.Save, value: { ...value, ...newValue } } : { modify: type$1.Save, value: newValue }
+    }, returns);
+  }
+  changeRangeMany(args, returns) {
+    return this.batchWrite((w) => returns ? basic.asyncMap(args, (v) => w.changeRange(v, returns)) : basic.asyncForEach(args, (v) => w.changeRange(v, returns)), !0);
+  }
+  cursor(arg, returns) {
+    return arg = types.isFunction(arg) ? { fn: arg } : arg || {}, arg.fn ? returns ? this.cursorResult(arg, !0) : this.cursorVoid(arg, !0) : new DbIterator(this, this.idbPro);
+  }
+  batchWrite(fn, rollbackOnError) {
+    const { target } = this;
+    if (type$1.isNativeTarget(target))
+      try {
+        return fn(this);
+      } catch (e) {
+        throw rollbackOnError !== !1 && (target instanceof IDBIndex ? target.objectStore : target).transaction.abort(), e;
+      }
+    return this.tx(!0, (store2) => fn(this.idbPro.schema.factory.newWriter({
+      storeSchema: this.storeSchema,
+      target: store2
+    }, this.idbPro)), rollbackOnError);
+  }
+  changeByPk({ pk, record, fn, requiredPk, getOld, requiredOld, saveMapper, getMapper }) {
+    const { storeSchema } = this, { keyPath, defaultSaveMapper, defaultGetMapper } = storeSchema;
+    return record && (saveMapper || defaultSaveMapper) && (record = getMapperFn(saveMapper || defaultSaveMapper, keyPath)?.(record)), this.batchWrite(async (w) => {
+      let query, newValue = record;
+      if (pk)
+        query = parseIDbQuery(pk);
+      else if (keyPath)
+        query = getValidKeyValue(keyPath, record);
+      else {
+        const { key, value } = type$1.parseDbNoneKeyPathRecord(record);
+        query = key, newValue = value;
+      }
+      if (requiredPk && !query)
+        throw new Error(`key is required: ${JSON.stringify(record)}`);
+      const oldValue = query && (getOld || requiredOld) ? await store.requestDbResult(w.nativeStore.get(query)) : void 0;
+      if (requiredOld && !oldValue)
+        throw new Error(`record not found: ${JSON.stringify(record)}`);
+      const result = await fn(w.nativeStore, query, newValue, oldValue, keyPath);
+      if (result)
+        return getMapperFn(getMapper || defaultGetMapper, keyPath)?.(result[0], result[1]);
+    });
+  }
+}
+class DbMap extends DataOperationBase {
+  get size() {
+    return this.tx(!1, (store$1) => store.requestDbResult(store$1.count()));
+  }
+  delete(key) {
+    return this.tx(!0, async (t, store2) => {
+      store2.delete(key);
+    });
+  }
+  batch(fn) {
+    const { idbPro, storeSchema, factory } = this;
+    return this.tx(!0, async (t, store2) => await fn(factory.newDbMap({ storeSchema, target: store2 }, idbPro)));
+  }
+  asStore(writable) {
+    const { factory } = this.idbPro.schema;
+    return writable ? factory.newWriter(this, this.idbPro) : factory.newReader({ target: this.target }, this.idbPro);
+  }
+  entries() {
+    return new DbIterator({
+      target: this.target
+    }, this.idbPro, { parser: "keyValue" });
+  }
+  async get(key, defaultValue) {
+    return await this.tx(!1, (store$1) => store.requestDbResult(store$1.get(key))) || defaultValue;
+  }
+  getMany(keys) {
+    return this.tx(!1, async (store$1) => {
+      const result = [];
+      for (const k of keys)
+        result.push(await store.requestDbResult(store$1.get(k)));
+      return result;
+    });
+  }
+  async has(key) {
+    return !!await this.get(key);
+  }
+  keys() {
+    return new DbIterator({ storeSchema: this.storeSchema, target: this.target }, this.idbPro, { parser: "key" });
+  }
+  set(key, value) {
+    return this.tx(!0, async (t, store$1) => {
+      await store.requestDbResult(store$1.put(value, key));
+    });
+  }
+  setMany(values) {
+    return this.tx(!0, async (t, store2) => {
+      for (const [k, v] of values)
+        store2.put(v, k);
+    });
+  }
+  values() {
+    return new DbIterator({ storeSchema: this.storeSchema, target: this.target }, this.idbPro, { parser: "value" });
+  }
+}
+function equalKeyPath(p1, p2) {
+  if (p1 == p2) return !0;
+  if (typeof p1 != typeof p2) return !1;
+  if (Array.isArray(p1) && Array.isArray(p2)) {
+    if (p1.length !== p2.length) return !1;
+    for (let i = 0; i < p1.length; i++)
+      if (p1[i] !== p2[i]) return !1;
+    return !0;
+  }
+  return !1;
+}
+const versionDiffValidate = ({ stores, schema }) => {
+  const storeSchemas = schema.storeSchemas;
+  let info = "";
+  for (const store2 of stores) {
+    const ss = storeSchemas.find((s) => s.name === store2.name);
+    if (ss) {
+      if (!equalKeyPath(store2.keyPath, ss.keyPath)) {
+        info = `store [ ${store2.name} ] keyPath not equal,schema.keyPath:${ss.keyPath},store.keyPath:${store2.keyPath}[]`;
+        break;
+      }
+      if (!store2.autoIncrement != !ss.autoIncrement) {
+        info = `store [ ${store2.name} ] autoIncrement not equal`;
+        break;
+      }
+    }
+  }
+  return info ? `The existing database is inconsistent with the definition and cannot be corrected： ${info}` : !0;
+}, versionSameValidate = async (context) => {
+  let result = versionDiffValidate(context);
+  return types.isString(result) || (result = validateStoreAndIndexes(context)), result;
+}, validateStoreAndIndexes = ({ stores, schema }) => {
+  const storeSchemas = schema.storeSchemas, dbStoreNames = stores.map((s) => s.name);
+  let info = "";
+  const missingStoreNames = storeSchemas.map((s) => s.name).filter((s) => !dbStoreNames.includes(s));
+  if (missingStoreNames.length)
+    info = `store [ ${missingStoreNames.join(",")} ] not exist`;
+  else for (const store2 of stores) {
+    const ss = storeSchemas.find((s) => s.name === store2.name);
+    if (ss && (info = validateIndexes$1(store2, Array.from(store2.indexNames), ss.indexSchemas), info))
+      break;
+  }
+  return info ? `The existing database Store index is inconsistent with the definition and requires a database version upgrade to be fixed： ${info}` : !0;
+};
+function validateIndexes$1(store2, indexNames, schemas) {
+  if (indexNames.length !== schemas.length)
+    return `store [ ${store2.name} ] index count not equal`;
+  for (const name of indexNames) {
+    const schema = schemas.find((s) => s.name === name);
+    if (!schema)
+      return `store [ ${store2.name} ] index [ ${name} ] not exist`;
+    const index = store2.index(name);
+    if (!schema.unique != !index.unique)
+      return `store [ ${store2.name} ] index [ ${name} ] unique not equal`;
+    if (!schema.multiEntry != !index.multiEntry)
+      return `store [ ${store2.name} ] index [ ${name} ] multiEntry not equal`;
+    if (!equalKeyPath(schema.keyPath, index.keyPath))
+      return `store [ ${store2.name} ] index [ ${name} ] keyPath not equal`;
+  }
+  return "";
+}
+class StoreUpgradeable {
+  upgradeContext;
+  storeSchema;
+  nativeStore;
+  #writer;
+  constructor(upgradeContext, storeSchema, nativeStore) {
+    this.upgradeContext = upgradeContext, this.storeSchema = storeSchema, this.nativeStore = nativeStore;
+  }
+  get writer() {
+    return this.#writer || (this.#writer = this.upgradeContext.dbSchema.factory?.newWriter({
+      target: this.nativeStore,
+      storeSchema: this.storeSchema
+    }));
+  }
+  add(versionBounds, values, returns) {
+    return this.upgradeContext.versionIn(versionBounds) ? this.writer.addMany(values, returns) : Promise.resolve();
+  }
+  addOrChange(versionBounds, values, returns) {
+    return this.upgradeContext.versionIn(versionBounds) ? this.writer.addOrChangeMany(values, returns) : Promise.resolve();
+  }
+  async call(versionBounds, fn) {
+    if (this.upgradeContext.versionIn(versionBounds))
+      return await fn(this.writer, this.upgradeContext);
+  }
+  replace(versionBounds, values, returns) {
+    return this.upgradeContext.versionIn(versionBounds) ? this.writer.replaceMany(values, returns) : Promise.resolve();
+  }
+}
+const DataOperatorFactory = Object.freeze({
+  newDataOperators(schemas, db2) {
+    return new DataOperators(db2, schemas);
+  },
+  newDbMap(schema, db2) {
+    return new DbMap(schema, db2);
+  },
+  newReader(schema, db2) {
+    return new DataReader(schema, db2);
+  },
+  newStoreUpgradeable(nativeStore, storeSchema, upgradeContext) {
+    return new StoreUpgradeable(upgradeContext, storeSchema, nativeStore);
+  },
+  newWriter(schema, db2) {
+    return new DataWriter(schema, db2);
+  }
+});
+function validateSpecialFields(schema) {
+  Object.isFrozen(schema) || (schema.addedTimeField = validateSpecialField(schema, schema.addedTimeField, "added_at", !0), schema.updatedTimeField = validateSpecialField(schema, schema.updatedTimeField, "updated_at", !0), schema.updatedCountField = validateSpecialField(schema, schema.updatedCountField, "updated_count", !1), schema.softDeletedField = validateSpecialField(schema, schema.softDeletedField, "deleted", !1));
+}
+function validateSpecialField(schema, field, defaultName, useDefault) {
+  const validField = validateSpecialFieldBase(field, defaultName, useDefault);
+  if (!validField)
+    return validField;
+  const schemaField = validField;
+  if (schemaField.isIndexed !== !1) {
+    schemaField.isIndexed || (schemaField.isIndexed = !0);
+    const { name } = schemaField, indexSchemas = schema.indexSchemas;
+    indexSchemas.some((i) => i === name || i.name === name) || indexSchemas.push(name);
+  }
+  return schemaField;
+}
+function validateSpecialFieldBase(field, defaultName, useDefault) {
+  if (field === !1)
+    return !1;
+  if (types.isString(field))
+    return { name: field };
+  if (types.isObject(field)) {
+    const r = field;
+    return types.isBoolean(r.name) && (r.name = defaultName), field;
+  } else if (field === !0 || useDefault)
+    return { name: defaultName };
+  return !1;
+}
+function validateStoreSchema(schema, storeTemplate) {
+  let validSchema = types.isString(schema) ? { name: schema } : schema;
+  return storeTemplate && (validSchema = { ...storeTemplate, ...validSchema }), validSchema.indexSchemas || (validSchema.indexSchemas = []), validateSpecialFields(validSchema), Object.isFrozen(validSchema) || (validSchema.indexSchemas = validSchema.indexSchemas.map(indexMapper)), validateDefaultData(validSchema), validSchema;
+}
+function indexMapper(index) {
+  const schema = types.isString(index) ? { name: index } : index;
+  return schema.keyPath || (schema.keyPath = schema.name), schema;
+}
+function validateDefaultData(schema) {
+  if (!(schema.keyPath || !schema.defaultData?.length)) {
+    for (const row of schema.defaultData)
+      if (!Array.isArray(row) && !("value" in row))
+        throw new Error(`When \`defaultData\` must contain \`value\` fields or be an array：${JSON.stringify(row)}`);
+  }
+}
+const validateSchemaWithDefaults = (schema) => {
+  const { versionDiffValidate: vdf, versionSameValidate: vsf, factory: dof } = schema;
+  return schema.storeSchemas || (schema.storeSchemas = []), schema.storeTemplate || (schema.storeTemplate = { ...type$1.defaultStoreSchemaTemplate }), !vdf && vdf !== !1 && (schema.versionDiffValidate = versionDiffValidate), !vsf && vsf !== !1 && (schema.versionSameValidate = versionSameValidate), dof ? dof !== DataOperatorFactory && (schema.factory = { ...DataOperatorFactory, ...dof }) : schema.factory = DataOperatorFactory, schema.storeSchemas = schema.storeSchemas.map((s) => validateStoreSchema(s, schema.storeTemplate)), schema;
+};
+async function validateBeforeOpen(schema) {
+  const { name, version } = schema, existDb = await db.findExistDb(name);
+  if (!existDb)
+    return !0;
+  const { versionDiffValidate: versionDiffValidate2, versionSameValidate: versionSameValidate2 } = schema, db$1 = await db.openDb(name);
+  try {
+    if (schema.version < db$1.version)
+      return "The existing database version is greater than the current version";
+    const validate = schema.version === void 0 || db$1.version === schema.version ? versionSameValidate2 : versionDiffValidate2;
+    if (!validate)
+      return !0;
+    const storeNames = Array.from(db$1.objectStoreNames);
+    if (storeNames.length < 1)
+      return `The existing database [ ${name} ] is empty`;
+    const stores = await tx.readTx(db$1, storeNames), diffResult = await validate({ schema, db: db$1, stores });
+    if (types.isString(diffResult) || version !== existDb.version)
+      return diffResult;
+  } finally {
+    db$1?.close();
+  }
+  return !0;
+}
+function validateIndexes(storeSchema, store2) {
+  const { indexSchemas } = storeSchema, existNames = store2.indexNames, schemaNames = indexSchemas.map((option) => option.name);
+  for (const name of Array.from(existNames))
+    schemaNames.includes(name) || store2.deleteIndex(name);
+  for (const indexSchema of indexSchemas)
+    existNames.contains(indexSchema.name) ? validateIndex(store2, indexSchema) : createIndex(store2, indexSchema);
+  return store2;
+}
+function validateIndex(store2, indexOption) {
+  const index = store2.index(indexOption.name);
+  checkIndex(index, indexOption) || (store2.deleteIndex(indexOption.name), createIndex(store2, indexOption));
+}
+function checkIndex(index, indexOption) {
+  return index.unique !== indexOption.unique || index.multiEntry !== indexOption.multiEntry ? !1 : equalKeyPath(indexOption.keyPath, index.keyPath);
+}
+function createIndex(store2, schema) {
+  try {
+    store2.createIndex(schema.name, schema.keyPath, {
+      unique: schema.unique,
+      multiEntry: schema.multiEntry
+    });
+  } catch {
+    throw new Error(`store [ ${store2.name} ] index [ ${schema.name} ] create error: ${JSON.stringify(schema)}`);
+  }
+}
+function validateStoreDefine(context, schema) {
+  return context.database.objectStoreNames.contains(schema.name) ? validateIndexes(schema, context.transaction?.objectStore(schema.name)) : defineStore(schema, context.database);
+}
+function defineStore(schema, db2) {
+  const store2 = db2.createObjectStore(schema.name, {
+    keyPath: schema.keyPath,
+    autoIncrement: schema.autoIncrement
+  });
+  for (const option of schema.indexSchemas)
+    createIndex(store2, option);
+  return store2;
+}
+class UpgradeContext {
+  database;
+  newVersion;
+  oldVersion;
+  dbSchema;
+  transaction;
+  #stores = {};
+  constructor(args) {
+    this.database = args.database, this.newVersion = args.newVersion, this.oldVersion = args.oldVersion, this.dbSchema = args.dbSchema, this.transaction = args.transaction;
+  }
+  deleteStoreIfExists(storeName) {
+    const db2 = this.database;
+    db2.objectStoreNames.contains(storeName) && db2.deleteObjectStore(storeName);
+  }
+  destroy() {
+    try {
+      basic.destroyRecords(this.#stores);
+    } finally {
+      for (const k of Object.keys(this.#stores))
+        delete this.#stores[k];
+    }
+  }
+  store(storeName) {
+    if (storeName in this.#stores)
+      return this.#stores[storeName];
+    const { factory } = this.dbSchema, { storeSchemas } = this.dbSchema, storeSchema = storeSchemas.find((s) => s.name === storeName), nativeStore = validateStoreDefine(this, storeSchema);
+    return this.#stores[storeName] = factory.newStoreUpgradeable(nativeStore, storeSchema, this);
+  }
+  versionIn({ oldMin, oldMax, newMax, newMin }) {
+    if (oldMax === void 0 && newMax === void 0 && oldMin === void 0 && newMin === void 0)
+      throw new Error(`versionIn bounds must not be empty ${JSON.stringify({ oldMax, newMax, oldMin, newMin })}`);
+    if (oldMax < oldMin)
+      throw new Error(`oldMax (${oldMax}) cannot be less than oldMin (${oldMin})`);
+    if (newMax < newMin)
+      throw new Error(`newMax (${newMax}) cannot be less than newMin (${newMin})`);
+    const { oldVersion, newVersion } = this;
+    return oldMin !== void 0 && oldVersion < oldMin || oldMax !== void 0 && oldVersion > oldMax || newMin !== void 0 && newVersion < newMin ? !1 : !(newMax !== void 0 && newVersion > newMax);
+  }
+}
+async function upgradeDb(dbSchema, database, e, request) {
+  const { storeSchemas, beforeUpgrade, afterUpgrade, version } = dbSchema, { newVersion = version, oldVersion } = e, { transaction } = request, context = new UpgradeContext({ database, newVersion, oldVersion, dbSchema, transaction });
+  try {
+    const errors = [];
+    if (types.isFunction(beforeUpgrade)) try {
+      await beforeUpgrade(context);
+    } catch (e2) {
+      errors.push(e2);
+    }
+    for (const storeName of storeSchemas.map((s) => s.name))
+      try {
+        context.store(storeName);
+      } catch (e2) {
+        errors.push(e2);
+      }
+    for (const { name, defaultData } of storeSchemas)
+      if (defaultData) try {
+        await context.store(name).add({ oldMax: 0 }, defaultData);
+      } catch (e2) {
+        errors.push(e2);
+      }
+    for (const { name, versionData } of storeSchemas)
+      if (versionData) for (const { version: version2, data, use = "addOrChange" } of versionData)
+        try {
+          await context.store(name)[use](version2, data);
+        } catch (e2) {
+          errors.push(e2);
+        }
+    for (const { name, storeDefined } of storeSchemas)
+      try {
+        await storeDefined?.(context.store(name));
+      } catch (e2) {
+        errors.push(e2);
+      }
+    if (types.isFunction(afterUpgrade)) try {
+      await afterUpgrade(context);
+    } catch (e2) {
+      errors.push(e2);
+    }
+    if (!errors.length) return;
+    throw errors.length === 1 ? errors[0] : new AggregateError(errors, "Database upgrade error");
+  } finally {
+    basic.destroy(context);
+  }
+}
+function validateDataOperationSchema(schema, dbSchema) {
+  return Object.isFrozen(dbSchema) ? frozenValidate(schema) : initValidate(schema, dbSchema);
+}
+function frozenValidate(schema) {
+  let { store: store2, index } = schema;
+  const target = { store: types.isString(store2) ? store2 : store2.name };
+  return index && (target.index = types.isString(index) ? index : index.name), {
+    target
+  };
+}
+function initValidate(schema, dbSchema) {
+  let { store: store2, index } = schema;
+  const { storeTemplate } = dbSchema, { storeSchemas = [] } = dbSchema, storeName = types.isString(store2) ? store2 : store2.name, storeIndex = storeSchemas.findIndex((s) => s === storeName || s.name === storeName), existStore = storeIndex > -1 && storeSchemas[storeIndex];
+  let tmp;
+  types.isString(store2) ? tmp = existStore || storeName : !existStore || types.isString(existStore) || store2 === existStore ? tmp = store2 : tmp = { ...existStore, ...store2 }, (index || existStore?.indexSchemas?.length || store2?.indexSchemas?.length) && (types.isString(tmp) && (tmp = { name: tmp }), tmp.indexSchemas = mergeIndexes(existStore.indexSchemas || [], store2.indexSchemas || [], index));
+  const validSchema = validateStoreSchema(tmp, storeTemplate);
+  storeIndex > -1 ? storeSchemas[storeIndex] = validSchema : storeSchemas.push(validSchema), dbSchema.storeSchemas = storeSchemas;
+  const target = { store: storeName };
+  return index && (target.index = types.isString(index) ? index : index.name), {
+    target
+  };
+}
+function mergeIndexes(existIndexes, newIndexes, index) {
+  index && newIndexes.push(index);
+  for (const index2 of newIndexes) {
+    const indexName = types.isString(index2) ? index2 : index2.name, existIndex = existIndexes.findIndex((i) => i === indexName || i.name === indexName);
+    if (existIndex > -1) {
+      const old = existIndexes[existIndex];
+      types.isString(old) ? existIndexes[existIndex] = index2 : types.isString(index2) || (existIndexes[existIndex] = Object.assign(old, index2));
+    } else
+      existIndexes.push(index2);
+  }
+  return existIndexes;
+}
+const mapStoreSchema = Object.assign({
+  name: "",
+  addedTimeField: !1,
+  autoIncrement: !1,
+  indexSchemas: [],
+  keyPath: void 0,
+  softDeletedField: !1,
+  updatedCountField: !1,
+  updatedTimeField: !1
+});
+class IDbPro {
+  static #_db;
+  #schema;
+  #beforeUseValid;
+  #storeSchemaRecord = {};
+  constructor(schema, skipPreOpenValidation) {
+    this.#schema = schema = types.isString(schema) ? { name: schema } : schema, Array.isArray(schema.storeSchemas) || (schema.storeSchemas = []), types.isObject(schema.storeTemplate) || (schema.storeTemplate = type$1.defaultStoreSchemaTemplate), skipPreOpenValidation && (this.#beforeUseValid = !0);
+  }
+  /**
+   * 默认实例
+   */
+  static get defaultDb() {
+    return this.#_db || (this.#_db = new IDbPro(storage.DefaultDbName));
+  }
+  get initialized() {
+    return Object.isFrozen(this.#schema);
+  }
+  get schema() {
+    return this.#schema;
+  }
+  get storeNames() {
+    return Array.from(new Set(this.#schema.storeSchemas.map((s) => types.isString(s) ? s : s.name)));
+  }
+  get factory() {
+    return this.#schema.factory || (this.#schema.factory = DataOperatorFactory);
+  }
+  /**
+   * 释放默认数据库实例（如果存在）
+   */
+  static releaseDefaultDB() {
+    this.#_db = void 0;
+  }
+  /**
+   * 从已经存在的`name`数据库中打开
+   * @warning 该方法仅用于不需要修改原有数据库结构的场景
+   * - 如果需要修改，请使用 `generateDbSchema()` 从现有数据库生成配置，且适当修改后重新打开
+   * @param name
+   */
+  static async openExistDb(name) {
+    const { generateDbSchema: generateDbSchema2 } = await Promise.resolve().then(function() {
+      return generateDbSchema$1;
+    });
+    return new IDbPro(await generateDbSchema2(name));
+  }
+  static store(arg1, index) {
+    return IDbPro.defaultDb.store(arg1, index);
+  }
+  static stores(schemas) {
+    return IDbPro.defaultDb.stores(schemas);
+  }
+  static map(storeName, defaultData) {
+    return IDbPro.defaultDb.map(storeName, defaultData);
+  }
+  async openNativeDb() {
+    const schema = this.#schema = basic.deepFreeze(this.initSchema());
+    await this.#isBeforeUseValidate();
+    const { name, version } = schema;
+    return await db.openDb({
+      name,
+      version,
+      onupgradeneeded: (db2, e, request) => upgradeDb(schema, db2, e, request)
+    });
+  }
+  store(arg1, index) {
+    const operation = arg1.store ? arg1 : { store: arg1 };
+    return operation.store || (operation.store = arg1), operation.index || (operation.index = index), this.factory.newWriter(validateDataOperationSchema(operation, this.schema), this);
+  }
+  stores(schemas) {
+    const { schema } = this, results = schemas.map((store2) => validateDataOperationSchema(types.isString(store2) ? { store: store2 } : store2, schema));
+    return this.factory.newDataOperators(results, this);
+  }
+  initSchema() {
+    if (this.initialized) return this.#schema;
+    const { validateSchemaWithDefaults: validate = validateSchemaWithDefaults } = this.#schema;
+    return this.#schema = validate(this.#schema);
+  }
+  async traceSchema(showFn) {
+    await json.logJson(this.schema, showFn);
+  }
+  map(storeName, defaultData) {
+    const name = types.isString(storeName) ? storeName : types.isString(defaultData) ? defaultData : storage.DefaultStorageStoreName;
+    Array.isArray(storeName) && (defaultData = storeName);
+    const { storeSchemas } = this.schema;
+    return storeSchemas.find((s) => s.name === name || s === name) || storeSchemas.push({ ...mapStoreSchema, name, defaultData }), this.factory.newDbMap({ target: { store: name } }, this);
+  }
+  export() {
+    return this.stores(this.storeNames).export();
+  }
+  import(data, returns, use) {
+    return this.stores(this.storeNames).import(data, returns, use);
+  }
+  getStoreSchema(name) {
+    if (name in this.#storeSchemaRecord)
+      return this.#storeSchemaRecord[name];
+    const index = this.schema.storeSchemas.findIndex((s) => s === name || s.name === name);
+    let storeSchema = this.schema.storeSchemas[index];
+    return this.initialized ? this.#storeSchemaRecord[name] = storeSchema : types.isString(storeSchema) && (this.schema.storeSchemas[index] = storeSchema = { name: storeSchema }), storeSchema;
+  }
+  async #isBeforeUseValidate() {
+    let valid = this.#beforeUseValid;
+    if (valid === void 0 && (valid = this.#beforeUseValid = await validateBeforeOpen(this.#schema)), valid === !0)
+      return !0;
+    if (types.isString(valid))
+      throw new Error(valid);
+  }
+}
+function dbStore(arg1, index) {
+  return IDbPro.defaultDb.store(arg1, index);
+}
+function dbMap(storeName, defaultData) {
+  return IDbPro.defaultDb.map(storeName, defaultData);
+}
+function dbStores(schemas) {
+  return IDbPro.defaultDb.stores(schemas);
+}
+function releaseDefaultDB() {
+  IDbPro.releaseDefaultDB();
+}
+function generateStoreSchema(store2, fields) {
+  const { name, keyPath, autoIncrement } = store2;
+  return {
+    name,
+    keyPath,
+    autoIncrement,
+    ...parseIndexes(store2, fields)
+  };
+}
+function parseIndexes(store2, fields) {
+  const indexes = Array.from(store2.indexNames).map((n) => store2.index(n)), indexSchemas = [], paths = [];
+  for (const { name, keyPath, unique, multiEntry } of indexes)
+    Array.isArray(keyPath) ? paths.push(...keyPath) : paths.push(keyPath), indexSchemas.push({ name, keyPath, unique, multiEntry });
+  const keySet = new Set(paths);
+  return {
+    indexSchemas,
+    addedTimeField: convertSpecialField(fields.addedTimeField, keySet),
+    updatedTimeField: convertSpecialField(fields.updatedTimeField, keySet),
+    updatedCountField: convertSpecialField(fields.updatedCountField, keySet),
+    softDeletedField: convertSpecialField(fields.softDeletedField, keySet)
+  };
+}
+function convertSpecialField(field, keySet) {
+  return keySet.has(field) ? { name: field, isIndexed: !1 } : !1;
+}
+async function generateDbSchema(db$1, option) {
+  if (!await db.findExistDb(db$1))
+    throw new Error(`db [ ${db$1} ] not exist`);
+  let { asString, specialFields = type$1.defaultSpecialFields, dataExportTarget } = option || {};
+  asString === !0 && (asString = 160), isNaN(asString) || asString < 1 && (asString = 1);
+  let dbSchema = await generateRoot(db$1, specialFields);
+  return dataExportTarget && await generateData(dbSchema, dataExportTarget), asString ? await json.toJson({
+    rootData$: dbSchema,
+    spaceEffectiveLength: asString
+  }) : dbSchema;
+}
+async function generateData(dbSchema, dataExportTarget) {
+  const data = await new IDbPro(basic.copyObject(dbSchema), !0).export();
+  for (const schema of dbSchema.storeSchemas) {
+    const rows = data[schema.name];
+    rows?.length && (dataExportTarget === "defaultData" ? schema.defaultData = rows : dataExportTarget === "versionData" && (schema.versionData || (schema.versionData = []), schema.versionData.push({
+      version: { oldMax: dbSchema.version },
+      data: rows
+    })));
+  }
+  return dbSchema;
+}
+function generateRoot(db$1, specialFields) {
+  return db.openDb(db$1, async function(existDb) {
+    const names = Array.from(existDb.objectStoreNames), tx2 = existDb.transaction(names, "readonly");
+    try {
+      return {
+        name: existDb.name,
+        version: existDb.version,
+        storeSchemas: names.map((name) => generateStoreSchema(tx2.objectStore(name), specialFields))
+      };
+    } finally {
+      tx2.abort();
+    }
+  });
+}
+var generateDbSchema$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  generateDbSchema
+});
+exports.DataOperationBase = DataOperationBase, exports.DataOperators = DataOperators, exports.DataReader = DataReader, exports.DataWriter = DataWriter, exports.DbIterator = DbIterator, exports.DbMap = DbMap, exports.IDbPro = IDbPro, exports.StoreUpgradeable = StoreUpgradeable, exports.UpgradeContext = UpgradeContext, exports.dbMap = dbMap, exports.dbStore = dbStore, exports.dbStores = dbStores, exports.generateDbSchema = generateDbSchema, exports.isIDbQuery = isIDbQuery, exports.parseIDbQuery = parseIDbQuery, exports.releaseDefaultDB = releaseDefaultDB, exports.validateSchemaWithDefaults = validateSchemaWithDefaults, exports.versionDiffValidate = versionDiffValidate, exports.versionSameValidate = versionSameValidate;