@xylabs/indexed-db 4.13.3 → 4.13.5

package/dist/browser/index.d.ts

@@ -1,81 +1,74 @@
-import type { DBSchema } from 'idb';
-import type { EmptyObject } from '@xylabs/object';
-import type { IDBPDatabase } from 'idb';
-import type { IDBPObjectStore } from 'idb';
-import type { KeyValueStore } from '@xylabs/storage';
-import type { Logger } from '@xylabs/logger';
-import type { StoreKey } from 'idb';
-import type { StoreNames } from 'idb';
-import type { StoreValue } from 'idb';
-
-/**
- * Given an index description, this will build the index
- * name in standard form
- * @param index The index description
- * @returns The index name in standard form
- */
-export declare const buildStandardIndexName: (index: IndexDescription) => string;
-
-export declare function checkDbNeedsUpgrade(dbName: string, stores: Record<string, IndexDescription[]>, logger?: Logger): Promise<number>;
-
-export declare function createStoreDuringUpgrade<DBTypes extends DBSchema | unknown = unknown>(db: IDBPDatabase<DBTypes>, storeName: StoreNames<DBTypes>, indexes: IndexDescription[], logger?: Logger): void;
-
-export declare function getExistingIndexes<T extends EmptyObject = EmptyObject>(db: IDBPDatabase<ObjectStore<T>> | string, storeName: StoreNames<ObjectStore<T>>, logger?: Logger): Promise<IndexDescription[] | null>;
-
-/**
- * Description of index(es) to be created on a store
- */
-export declare type IndexDescription = {
-    /**
-     * The key(s) to index
-     */
-    key: Record<string, IndexDirection>;
-    /**
-     * Is the indexed value an array
-     */
-    multiEntry?: boolean;
-    /**
-     * If true, the index must enforce uniqueness on the key
-     */
-    unique?: boolean;
-};
-
-/**
- * The index direction (1 for ascending, -1 for descending)
- */
-export declare type IndexDirection = -1 | 1;
-
-/**
- * An IndexedDB key/value store.
- */
-export declare class IndexedDbKeyValueStore<T extends DBSchema, S extends StoreNames<T>> implements KeyValueStore<StoreValue<T, S>, StoreKey<T, S>> {
-    readonly dbName: string;
-    readonly storeName: S;
-    constructor(dbName: string, storeName: S);
-    clear?(): Promise<void>;
-    delete(key: StoreKey<T, S>): Promise<void>;
-    get(key: StoreKey<T, S>): Promise<StoreValue<T, S> | undefined>;
-    keys?(): Promise<StoreKey<T, S>[]>;
-    set(key: StoreKey<T, S>, value: StoreValue<T, S>): Promise<void>;
-    withDb<R = StoreValue<T, S>>(callback: (db: IDBPDatabase<T>) => Promise<R> | R): Promise<R>;
-}
-
-export declare const IndexSeparator = "-";
-
-export declare interface ObjectStore<T extends EmptyObject = EmptyObject> {
-    [s: string]: T;
-}
-
-export declare function withDb<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
-
-export declare function withDbByVersion<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, version?: number, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
-
-export declare function withReadOnlyStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readonly'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
-
-export declare function withReadWriteStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readwrite'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
-
-export declare function withStore<T extends EmptyObject = EmptyObject, R = T, M extends 'readonly' | 'readwrite' = 'readonly'>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [
-StoreNames<ObjectStore<T>>
-], StoreNames<ObjectStore<T>>, M> | null) => Promise<R> | R, mode: M, logger?: Logger): Promise<R>;
-
-export { }
+import { Logger } from '@xylabs/logger';
+import { DBSchema, IDBPDatabase, StoreNames, StoreValue, StoreKey, IDBPObjectStore } from 'idb';
+import { EmptyObject } from '@xylabs/object';
+import { KeyValueStore } from '@xylabs/storage';
+
+/**
+ * The index direction (1 for ascending, -1 for descending)
+ */
+type IndexDirection = -1 | 1;
+/**
+ * Description of index(es) to be created on a store
+ */
+type IndexDescription = {
+    /**
+     * The key(s) to index
+     */
+    key: Record<string, IndexDirection>;
+    /**
+     * Is the indexed value an array
+     */
+    multiEntry?: boolean;
+    /**
+     * If true, the index must enforce uniqueness on the key
+     */
+    unique?: boolean;
+};
+declare const IndexSeparator = "-";
+/**
+ * Given an index description, this will build the index
+ * name in standard form
+ * @param index The index description
+ * @returns The index name in standard form
+ */
+declare const buildStandardIndexName: (index: IndexDescription) => string;
+
+declare function checkDbNeedsUpgrade(dbName: string, stores: Record<string, IndexDescription[]>, logger?: Logger): Promise<number>;
+
+declare function createStoreDuringUpgrade<DBTypes extends DBSchema | unknown = unknown>(db: IDBPDatabase<DBTypes>, storeName: StoreNames<DBTypes>, indexes: IndexDescription[], logger?: Logger): void;
+
+interface ObjectStore<T extends EmptyObject = EmptyObject> {
+    [s: string]: T;
+}
+
+declare function getExistingIndexes<T extends EmptyObject = EmptyObject>(db: IDBPDatabase<ObjectStore<T>> | string, storeName: StoreNames<ObjectStore<T>>, logger?: Logger): Promise<IndexDescription[] | null>;
+
+/**
+ * An IndexedDB key/value store.
+ */
+declare class IndexedDbKeyValueStore<T extends DBSchema, S extends StoreNames<T>> implements KeyValueStore<StoreValue<T, S>, StoreKey<T, S>> {
+    readonly dbName: string;
+    readonly storeName: S;
+    constructor(dbName: string, storeName: S);
+    clear?(): Promise<void>;
+    delete(key: StoreKey<T, S>): Promise<void>;
+    get(key: StoreKey<T, S>): Promise<StoreValue<T, S> | undefined>;
+    keys?(): Promise<StoreKey<T, S>[]>;
+    set(key: StoreKey<T, S>, value: StoreValue<T, S>): Promise<void>;
+    withDb<R = StoreValue<T, S>>(callback: (db: IDBPDatabase<T>) => Promise<R> | R): Promise<R>;
+}
+
+declare function withDb<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
+
+declare function withDbByVersion<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, version?: number, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
+
+declare function withReadOnlyStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readonly'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
+
+declare function withReadWriteStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readwrite'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
+
+declare function withStore<T extends EmptyObject = EmptyObject, R = T, M extends 'readonly' | 'readwrite' = 'readonly'>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [
+    StoreNames<ObjectStore<T>>
+], StoreNames<ObjectStore<T>>, M> | null) => Promise<R> | R, mode: M, logger?: Logger): Promise<R>;
+
+export { IndexSeparator, IndexedDbKeyValueStore, buildStandardIndexName, checkDbNeedsUpgrade, createStoreDuringUpgrade, getExistingIndexes, withDb, withDbByVersion, withReadOnlyStore, withReadWriteStore, withStore };
+export type { IndexDescription, IndexDirection, ObjectStore };

package/dist/neutral/index.d.ts

@@ -1,81 +1,74 @@
-import type { DBSchema } from 'idb';
-import type { EmptyObject } from '@xylabs/object';
-import type { IDBPDatabase } from 'idb';
-import type { IDBPObjectStore } from 'idb';
-import type { KeyValueStore } from '@xylabs/storage';
-import type { Logger } from '@xylabs/logger';
-import type { StoreKey } from 'idb';
-import type { StoreNames } from 'idb';
-import type { StoreValue } from 'idb';
-
-/**
- * Given an index description, this will build the index
- * name in standard form
- * @param index The index description
- * @returns The index name in standard form
- */
-export declare const buildStandardIndexName: (index: IndexDescription) => string;
-
-export declare function checkDbNeedsUpgrade(dbName: string, stores: Record<string, IndexDescription[]>, logger?: Logger): Promise<number>;
-
-export declare function createStoreDuringUpgrade<DBTypes extends DBSchema | unknown = unknown>(db: IDBPDatabase<DBTypes>, storeName: StoreNames<DBTypes>, indexes: IndexDescription[], logger?: Logger): void;
-
-export declare function getExistingIndexes<T extends EmptyObject = EmptyObject>(db: IDBPDatabase<ObjectStore<T>> | string, storeName: StoreNames<ObjectStore<T>>, logger?: Logger): Promise<IndexDescription[] | null>;
-
-/**
- * Description of index(es) to be created on a store
- */
-export declare type IndexDescription = {
-    /**
-     * The key(s) to index
-     */
-    key: Record<string, IndexDirection>;
-    /**
-     * Is the indexed value an array
-     */
-    multiEntry?: boolean;
-    /**
-     * If true, the index must enforce uniqueness on the key
-     */
-    unique?: boolean;
-};
-
-/**
- * The index direction (1 for ascending, -1 for descending)
- */
-export declare type IndexDirection = -1 | 1;
-
-/**
- * An IndexedDB key/value store.
- */
-export declare class IndexedDbKeyValueStore<T extends DBSchema, S extends StoreNames<T>> implements KeyValueStore<StoreValue<T, S>, StoreKey<T, S>> {
-    readonly dbName: string;
-    readonly storeName: S;
-    constructor(dbName: string, storeName: S);
-    clear?(): Promise<void>;
-    delete(key: StoreKey<T, S>): Promise<void>;
-    get(key: StoreKey<T, S>): Promise<StoreValue<T, S> | undefined>;
-    keys?(): Promise<StoreKey<T, S>[]>;
-    set(key: StoreKey<T, S>, value: StoreValue<T, S>): Promise<void>;
-    withDb<R = StoreValue<T, S>>(callback: (db: IDBPDatabase<T>) => Promise<R> | R): Promise<R>;
-}
-
-export declare const IndexSeparator = "-";
-
-export declare interface ObjectStore<T extends EmptyObject = EmptyObject> {
-    [s: string]: T;
-}
-
-export declare function withDb<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
-
-export declare function withDbByVersion<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, version?: number, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
-
-export declare function withReadOnlyStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readonly'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
-
-export declare function withReadWriteStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readwrite'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
-
-export declare function withStore<T extends EmptyObject = EmptyObject, R = T, M extends 'readonly' | 'readwrite' = 'readonly'>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [
-StoreNames<ObjectStore<T>>
-], StoreNames<ObjectStore<T>>, M> | null) => Promise<R> | R, mode: M, logger?: Logger): Promise<R>;
-
-export { }
+import { Logger } from '@xylabs/logger';
+import { DBSchema, IDBPDatabase, StoreNames, StoreValue, StoreKey, IDBPObjectStore } from 'idb';
+import { EmptyObject } from '@xylabs/object';
+import { KeyValueStore } from '@xylabs/storage';
+
+/**
+ * The index direction (1 for ascending, -1 for descending)
+ */
+type IndexDirection = -1 | 1;
+/**
+ * Description of index(es) to be created on a store
+ */
+type IndexDescription = {
+    /**
+     * The key(s) to index
+     */
+    key: Record<string, IndexDirection>;
+    /**
+     * Is the indexed value an array
+     */
+    multiEntry?: boolean;
+    /**
+     * If true, the index must enforce uniqueness on the key
+     */
+    unique?: boolean;
+};
+declare const IndexSeparator = "-";
+/**
+ * Given an index description, this will build the index
+ * name in standard form
+ * @param index The index description
+ * @returns The index name in standard form
+ */
+declare const buildStandardIndexName: (index: IndexDescription) => string;
+
+declare function checkDbNeedsUpgrade(dbName: string, stores: Record<string, IndexDescription[]>, logger?: Logger): Promise<number>;
+
+declare function createStoreDuringUpgrade<DBTypes extends DBSchema | unknown = unknown>(db: IDBPDatabase<DBTypes>, storeName: StoreNames<DBTypes>, indexes: IndexDescription[], logger?: Logger): void;
+
+interface ObjectStore<T extends EmptyObject = EmptyObject> {
+    [s: string]: T;
+}
+
+declare function getExistingIndexes<T extends EmptyObject = EmptyObject>(db: IDBPDatabase<ObjectStore<T>> | string, storeName: StoreNames<ObjectStore<T>>, logger?: Logger): Promise<IndexDescription[] | null>;
+
+/**
+ * An IndexedDB key/value store.
+ */
+declare class IndexedDbKeyValueStore<T extends DBSchema, S extends StoreNames<T>> implements KeyValueStore<StoreValue<T, S>, StoreKey<T, S>> {
+    readonly dbName: string;
+    readonly storeName: S;
+    constructor(dbName: string, storeName: S);
+    clear?(): Promise<void>;
+    delete(key: StoreKey<T, S>): Promise<void>;
+    get(key: StoreKey<T, S>): Promise<StoreValue<T, S> | undefined>;
+    keys?(): Promise<StoreKey<T, S>[]>;
+    set(key: StoreKey<T, S>, value: StoreValue<T, S>): Promise<void>;
+    withDb<R = StoreValue<T, S>>(callback: (db: IDBPDatabase<T>) => Promise<R> | R): Promise<R>;
+}
+
+declare function withDb<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
+
+declare function withDbByVersion<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, version?: number, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
+
+declare function withReadOnlyStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readonly'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
+
+declare function withReadWriteStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readwrite'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
+
+declare function withStore<T extends EmptyObject = EmptyObject, R = T, M extends 'readonly' | 'readwrite' = 'readonly'>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [
+    StoreNames<ObjectStore<T>>
+], StoreNames<ObjectStore<T>>, M> | null) => Promise<R> | R, mode: M, logger?: Logger): Promise<R>;
+
+export { IndexSeparator, IndexedDbKeyValueStore, buildStandardIndexName, checkDbNeedsUpgrade, createStoreDuringUpgrade, getExistingIndexes, withDb, withDbByVersion, withReadOnlyStore, withReadWriteStore, withStore };
+export type { IndexDescription, IndexDirection, ObjectStore };

package/dist/node/index.d.ts

@@ -1,81 +1,74 @@
-import type { DBSchema } from 'idb';
-import type { EmptyObject } from '@xylabs/object';
-import type { IDBPDatabase } from 'idb';
-import type { IDBPObjectStore } from 'idb';
-import type { KeyValueStore } from '@xylabs/storage';
-import type { Logger } from '@xylabs/logger';
-import type { StoreKey } from 'idb';
-import type { StoreNames } from 'idb';
-import type { StoreValue } from 'idb';
-
-/**
- * Given an index description, this will build the index
- * name in standard form
- * @param index The index description
- * @returns The index name in standard form
- */
-export declare const buildStandardIndexName: (index: IndexDescription) => string;
-
-export declare function checkDbNeedsUpgrade(dbName: string, stores: Record<string, IndexDescription[]>, logger?: Logger): Promise<number>;
-
-export declare function createStoreDuringUpgrade<DBTypes extends DBSchema | unknown = unknown>(db: IDBPDatabase<DBTypes>, storeName: StoreNames<DBTypes>, indexes: IndexDescription[], logger?: Logger): void;
-
-export declare function getExistingIndexes<T extends EmptyObject = EmptyObject>(db: IDBPDatabase<ObjectStore<T>> | string, storeName: StoreNames<ObjectStore<T>>, logger?: Logger): Promise<IndexDescription[] | null>;
-
-/**
- * Description of index(es) to be created on a store
- */
-export declare type IndexDescription = {
-    /**
-     * The key(s) to index
-     */
-    key: Record<string, IndexDirection>;
-    /**
-     * Is the indexed value an array
-     */
-    multiEntry?: boolean;
-    /**
-     * If true, the index must enforce uniqueness on the key
-     */
-    unique?: boolean;
-};
-
-/**
- * The index direction (1 for ascending, -1 for descending)
- */
-export declare type IndexDirection = -1 | 1;
-
-/**
- * An IndexedDB key/value store.
- */
-export declare class IndexedDbKeyValueStore<T extends DBSchema, S extends StoreNames<T>> implements KeyValueStore<StoreValue<T, S>, StoreKey<T, S>> {
-    readonly dbName: string;
-    readonly storeName: S;
-    constructor(dbName: string, storeName: S);
-    clear?(): Promise<void>;
-    delete(key: StoreKey<T, S>): Promise<void>;
-    get(key: StoreKey<T, S>): Promise<StoreValue<T, S> | undefined>;
-    keys?(): Promise<StoreKey<T, S>[]>;
-    set(key: StoreKey<T, S>, value: StoreValue<T, S>): Promise<void>;
-    withDb<R = StoreValue<T, S>>(callback: (db: IDBPDatabase<T>) => Promise<R> | R): Promise<R>;
-}
-
-export declare const IndexSeparator = "-";
-
-export declare interface ObjectStore<T extends EmptyObject = EmptyObject> {
-    [s: string]: T;
-}
-
-export declare function withDb<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
-
-export declare function withDbByVersion<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, version?: number, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
-
-export declare function withReadOnlyStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readonly'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
-
-export declare function withReadWriteStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readwrite'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
-
-export declare function withStore<T extends EmptyObject = EmptyObject, R = T, M extends 'readonly' | 'readwrite' = 'readonly'>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [
-StoreNames<ObjectStore<T>>
-], StoreNames<ObjectStore<T>>, M> | null) => Promise<R> | R, mode: M, logger?: Logger): Promise<R>;
-
-export { }
+import { Logger } from '@xylabs/logger';
+import { DBSchema, IDBPDatabase, StoreNames, StoreValue, StoreKey, IDBPObjectStore } from 'idb';
+import { EmptyObject } from '@xylabs/object';
+import { KeyValueStore } from '@xylabs/storage';
+
+/**
+ * The index direction (1 for ascending, -1 for descending)
+ */
+type IndexDirection = -1 | 1;
+/**
+ * Description of index(es) to be created on a store
+ */
+type IndexDescription = {
+    /**
+     * The key(s) to index
+     */
+    key: Record<string, IndexDirection>;
+    /**
+     * Is the indexed value an array
+     */
+    multiEntry?: boolean;
+    /**
+     * If true, the index must enforce uniqueness on the key
+     */
+    unique?: boolean;
+};
+declare const IndexSeparator = "-";
+/**
+ * Given an index description, this will build the index
+ * name in standard form
+ * @param index The index description
+ * @returns The index name in standard form
+ */
+declare const buildStandardIndexName: (index: IndexDescription) => string;
+
+declare function checkDbNeedsUpgrade(dbName: string, stores: Record<string, IndexDescription[]>, logger?: Logger): Promise<number>;
+
+declare function createStoreDuringUpgrade<DBTypes extends DBSchema | unknown = unknown>(db: IDBPDatabase<DBTypes>, storeName: StoreNames<DBTypes>, indexes: IndexDescription[], logger?: Logger): void;
+
+interface ObjectStore<T extends EmptyObject = EmptyObject> {
+    [s: string]: T;
+}
+
+declare function getExistingIndexes<T extends EmptyObject = EmptyObject>(db: IDBPDatabase<ObjectStore<T>> | string, storeName: StoreNames<ObjectStore<T>>, logger?: Logger): Promise<IndexDescription[] | null>;
+
+/**
+ * An IndexedDB key/value store.
+ */
+declare class IndexedDbKeyValueStore<T extends DBSchema, S extends StoreNames<T>> implements KeyValueStore<StoreValue<T, S>, StoreKey<T, S>> {
+    readonly dbName: string;
+    readonly storeName: S;
+    constructor(dbName: string, storeName: S);
+    clear?(): Promise<void>;
+    delete(key: StoreKey<T, S>): Promise<void>;
+    get(key: StoreKey<T, S>): Promise<StoreValue<T, S> | undefined>;
+    keys?(): Promise<StoreKey<T, S>[]>;
+    set(key: StoreKey<T, S>, value: StoreValue<T, S>): Promise<void>;
+    withDb<R = StoreValue<T, S>>(callback: (db: IDBPDatabase<T>) => Promise<R> | R): Promise<R>;
+}
+
+declare function withDb<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
+
+declare function withDbByVersion<DBTypes extends DBSchema | unknown = unknown, R = EmptyObject>(dbName: string, callback: (db: IDBPDatabase<DBTypes>) => Promise<R> | R, version?: number, expectedIndexes?: Record<string, IndexDescription[]>, logger?: Logger, lock?: boolean): Promise<R>;
+
+declare function withReadOnlyStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readonly'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
+
+declare function withReadWriteStore<T extends EmptyObject = EmptyObject, R = T>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [StoreNames<ObjectStore<T>>], StoreNames<ObjectStore<T>>, 'readwrite'> | null) => Promise<R> | R, logger?: Logger): Promise<R>;
+
+declare function withStore<T extends EmptyObject = EmptyObject, R = T, M extends 'readonly' | 'readwrite' = 'readonly'>(db: IDBPDatabase<ObjectStore<T>>, storeName: StoreNames<ObjectStore<T>>, callback: (store: IDBPObjectStore<ObjectStore<T>, [
+    StoreNames<ObjectStore<T>>
+], StoreNames<ObjectStore<T>>, M> | null) => Promise<R> | R, mode: M, logger?: Logger): Promise<R>;
+
+export { IndexSeparator, IndexedDbKeyValueStore, buildStandardIndexName, checkDbNeedsUpgrade, createStoreDuringUpgrade, getExistingIndexes, withDb, withDbByVersion, withReadOnlyStore, withReadWriteStore, withStore };
+export type { IndexDescription, IndexDirection, ObjectStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/indexed-db",
-  "version": "4.13.3",
+  "version": "4.13.5",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "keywords": [
     "hex",
@@ -49,16 +49,16 @@
     "packages/**/*"
   ],
   "dependencies": {
-    "@xylabs/exists": "^4.13.3",
-    "@xylabs/logger": "^4.13.3",
-    "@xylabs/object": "^4.13.3",
-    "@xylabs/storage": "^4.13.3",
+    "@xylabs/exists": "^4.13.5",
+    "@xylabs/logger": "^4.13.5",
+    "@xylabs/object": "^4.13.5",
+    "@xylabs/storage": "^4.13.5",
     "async-mutex": "^0.5.0",
     "idb": "^8.0.3"
   },
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "^7.0.0-rc.7",
-    "@xylabs/tsconfig-dom": "^7.0.0-rc.7",
+    "@xylabs/ts-scripts-yarn3": "^7.0.0-rc.8",
+    "@xylabs/tsconfig-dom": "^7.0.0-rc.8",
     "fake-indexeddb": "^6.0.1",
     "jsdom": "^26.1.0",
     "typescript": "^5.8.3",