dexie 4.0.1-alpha.8 → 4.0.1-beta.10

package/README.md

@@ -1,7 +1,7 @@
 Dexie.js
 ========
 
-[![NPM Version][npm-image]][npm-url] [![Build Status](https://travis-ci.com/dexie/Dexie.js.svg?branch=master)](https://travis-ci.com/dexie/Dexie.js)[![Tested with Browserstack](https://dexie.org/assets/images/tested-with-browserstack2.png)](https://www.browserstack.com)
+[![NPM Version][npm-image]][npm-url] ![Build Status](https://github.com/dexie/Dexie.js/actions/workflows/main.yml/badge.svg)
 
 Dexie.js is a wrapper library for indexedDB - the standard database in the browser. https://dexie.org
 
@@ -250,6 +250,9 @@ Watch
 pnpm run watch
 ```
 
+<br/>
+
+[![Browser testing via LAMDBATEST](https://dexie.org/assets/images/lambdatest2.png)](https://www.lambdatest.com/)
 
 [npm-image]: https://img.shields.io/npm/v/dexie.svg?style=flat
 [npm-url]: https://npmjs.org/package/dexie

package/SECURITY.md

@@ -6,7 +6,7 @@
 | ------- | ------------------ | --------
 | 4.x     | :white_check_mark: | master
 | 3.x     | :white_check_mark: | master-3
-| 2.0.x   | :thinking: | master-2
+| 2.0.x   | :x: | master-2
 | 1.5.x   | :x: | master-1
 | < 1.5.1 | :x:                |
 

package/dist/dexie.d.ts

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.1-alpha.8, Fri Feb 17 2023
+ * Version 4.0.1-beta.10, Mon Feb 12 2024
  *
  * https://dexie.org
  *
@@ -65,6 +65,7 @@ export interface Transaction {
 	mode: IDBTransactionMode;
 	//tables: { [type: string]: Table<any, any> }; Deprecated since 2.0. Obsolete from v3.0.
 	storeNames: Array<string>;
+	explicit?: boolean;
 	parent?: Transaction;
 	on: TransactionEvents;
 	abort(): void;
@@ -84,7 +85,7 @@ export interface DeletingHookContext<T, Key> {
 	onsuccess?: () => void;
 	onerror?: (err: any) => void;
 }
-export interface TableHooks<T = any, TKey = IndexableType> extends DexieEventSet {
+export interface TableHooks<T = any, TKey = IndexableType, TInsertType = T> extends DexieEventSet {
 	(eventName: "creating", subscriber: (this: CreatingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => void | undefined | TKey): void;
 	(eventName: "reading", subscriber: (obj: T) => T | any): void;
 	(eventName: "updating", subscriber: (this: UpdatingHookContext<T, TKey>, modifications: Object, primKey: TKey, obj: T, transaction: Transaction) => any): void;
@@ -95,33 +96,33 @@ export interface TableHooks<T = any, TKey = IndexableType> extends DexieEventSet
 	deleting: DexieEvent;
 }
 export type ThenShortcut<T, TResult> = (value: T) => TResult | PromiseLike<TResult>;
-export interface WhereClause<T = any, TKey = IndexableType> {
-	above(key: any): Collection<T, TKey>;
-	aboveOrEqual(key: any): Collection<T, TKey>;
-	anyOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
-	anyOf(...keys: Array<IndexableType>): Collection<T, TKey>;
-	anyOfIgnoreCase(keys: string[]): Collection<T, TKey>;
-	anyOfIgnoreCase(...keys: string[]): Collection<T, TKey>;
-	below(key: any): Collection<T, TKey>;
-	belowOrEqual(key: any): Collection<T, TKey>;
-	between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): Collection<T, TKey>;
-	equals(key: IndexableType): Collection<T, TKey>;
-	equalsIgnoreCase(key: string): Collection<T, TKey>;
+export interface WhereClause<T = any, TKey = IndexableType, TInsertType = T> {
+	above(key: any): Collection<T, TKey, TInsertType>;
+	aboveOrEqual(key: any): Collection<T, TKey, TInsertType>;
+	anyOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey, TInsertType>;
+	anyOf(...keys: Array<IndexableType>): Collection<T, TKey, TInsertType>;
+	anyOfIgnoreCase(keys: string[]): Collection<T, TKey, TInsertType>;
+	anyOfIgnoreCase(...keys: string[]): Collection<T, TKey, TInsertType>;
+	below(key: any): Collection<T, TKey, TInsertType>;
+	belowOrEqual(key: any): Collection<T, TKey, TInsertType>;
+	between(lower: any, upper: any, includeLower?: boolean, includeUpper?: boolean): Collection<T, TKey, TInsertType>;
+	equals(key: IndexableType): Collection<T, TKey, TInsertType>;
+	equalsIgnoreCase(key: string): Collection<T, TKey, TInsertType>;
 	inAnyRange(ranges: ReadonlyArray<{
 		0: any;
 		1: any;
 	}>, options?: {
 		includeLowers?: boolean;
 		includeUppers?: boolean;
-	}): Collection<T, TKey>;
-	startsWith(key: string): Collection<T, TKey>;
-	startsWithAnyOf(prefixes: string[]): Collection<T, TKey>;
-	startsWithAnyOf(...prefixes: string[]): Collection<T, TKey>;
-	startsWithIgnoreCase(key: string): Collection<T, TKey>;
-	startsWithAnyOfIgnoreCase(prefixes: string[]): Collection<T, TKey>;
-	startsWithAnyOfIgnoreCase(...prefixes: string[]): Collection<T, TKey>;
-	noneOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey>;
-	notEqual(key: IndexableType): Collection<T, TKey>;
+	}): Collection<T, TKey, TInsertType>;
+	startsWith(key: string): Collection<T, TKey, TInsertType>;
+	startsWithAnyOf(prefixes: string[]): Collection<T, TKey, TInsertType>;
+	startsWithAnyOf(...prefixes: string[]): Collection<T, TKey, TInsertType>;
+	startsWithIgnoreCase(key: string): Collection<T, TKey, TInsertType>;
+	startsWithAnyOfIgnoreCase(prefixes: string[]): Collection<T, TKey, TInsertType>;
+	startsWithAnyOfIgnoreCase(...prefixes: string[]): Collection<T, TKey, TInsertType>;
+	noneOf(keys: ReadonlyArray<IndexableType>): Collection<T, TKey, TInsertType>;
+	notEqual(key: IndexableType): Collection<T, TKey, TInsertType>;
 }
 export interface PromiseExtendedConstructor extends PromiseConstructor {
 	readonly prototype: PromiseExtended;
@@ -357,20 +358,21 @@ export interface PromiseExtended<T = any> extends Promise<T> {
 	timeout(ms: number, msg?: string): PromiseExtended<T>;
 }
 export type KeyPaths<T> = {
-	[P in keyof T]: P extends string ? T[P] extends any[] ? P | `${P}.${number}` | `${P}.${number}.${KeyPaths<T[P][number]>}` : T[P] extends (...args: any[]) => any // Method
+	[P in keyof T]: P extends string ? T[P] extends Array<infer K> ? K extends object // only drill into the array element if it's an object
+	 ? P | `${P}.${number}` | `${P}.${number}.${KeyPaths<K>}` : P | `${P}.${number}` : T[P] extends (...args: any[]) => any // Method
 	 ? never : T[P] extends object ? P | `${P}.${KeyPaths<T[P]>}` : P : never;
 }[keyof T];
 export type KeyPathValue<T, PATH> = PATH extends `${infer R}.${infer S}` ? R extends keyof T ? KeyPathValue<T[R], S> : T extends any[] ? PATH extends `${number}.${infer S}` ? KeyPathValue<T[number], S> : void : void : PATH extends `${number}` ? T extends any[] ? T[number] : void : PATH extends keyof T ? T[PATH] : void;
 export type UpdateSpec<T> = {
 	[KP in KeyPaths<T>]?: KeyPathValue<T, KP>;
 };
-export interface Collection<T = any, TKey = IndexableType> {
+export interface Collection<T = any, TKey = IndexableType, TInsertType = T> {
 	db: Dexie;
-	and(filter: (x: T) => boolean): Collection<T, TKey>;
-	clone(props?: Object): Collection<T, TKey>;
+	and(filter: (x: T) => boolean): Collection<T, TKey, TInsertType>;
+	clone(props?: Object): Collection<T, TKey, TInsertType>;
 	count(): PromiseExtended<number>;
 	count<R>(thenShortcut: ThenShortcut<number, R>): PromiseExtended<R>;
-	distinct(): Collection<T, TKey>;
+	distinct(): Collection<T, TKey, TInsertType>;
 	each(callback: (obj: T, cursor: {
 		key: IndexableType;
 		primaryKey: TKey;
@@ -388,7 +390,7 @@ export interface Collection<T = any, TKey = IndexableType> {
 		primaryKey: TKey;
 	}) => any): PromiseExtended<void>;
 	filter<S extends T>(filter: (x: T) => x is S): Collection<S, TKey>;
-	filter(filter: (x: T) => boolean): Collection<T, TKey>;
+	filter(filter: (x: T) => boolean): Collection<T, TKey, TInsertType>;
 	first(): PromiseExtended<T | undefined>;
 	first<R>(thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
 	keys(): PromiseExtended<IndexableTypeArray>;
@@ -397,24 +399,106 @@ export interface Collection<T = any, TKey = IndexableType> {
 	primaryKeys<R>(thenShortcut: ThenShortcut<TKey[], R>): PromiseExtended<R>;
 	last(): PromiseExtended<T | undefined>;
 	last<R>(thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
-	limit(n: number): Collection<T, TKey>;
-	offset(n: number): Collection<T, TKey>;
-	or(indexOrPrimayKey: string): WhereClause<T, TKey>;
-	raw(): Collection<T, TKey>;
-	reverse(): Collection<T, TKey>;
+	limit(n: number): Collection<T, TKey, TInsertType>;
+	offset(n: number): Collection<T, TKey, TInsertType>;
+	or(indexOrPrimayKey: string): WhereClause<T, TKey, TInsertType>;
+	raw(): Collection<T, TKey, TInsertType>;
+	reverse(): Collection<T, TKey, TInsertType>;
 	sortBy(keyPath: string): PromiseExtended<T[]>;
 	sortBy<R>(keyPath: string, thenShortcut: ThenShortcut<T[], R>): PromiseExtended<R>;
 	toArray(): PromiseExtended<Array<T>>;
 	toArray<R>(thenShortcut: ThenShortcut<T[], R>): PromiseExtended<R>;
 	uniqueKeys(): PromiseExtended<IndexableTypeArray>;
 	uniqueKeys<R>(thenShortcut: ThenShortcut<IndexableTypeArray, R>): PromiseExtended<R>;
-	until(filter: (value: T) => boolean, includeStopEntry?: boolean): Collection<T, TKey>;
+	until(filter: (value: T) => boolean, includeStopEntry?: boolean): Collection<T, TKey, TInsertType>;
 	// Mutating methods
 	delete(): PromiseExtended<number>;
 	modify(changeCallback: (obj: T, ctx: {
-		value: T;
+		value: TInsertType;
 	}) => void | boolean): PromiseExtended<number>;
-	modify(changes: UpdateSpec<T>): PromiseExtended<number>;
+	modify(changes: UpdateSpec<TInsertType>): PromiseExtended<number>;
+}
+export type IntervalTree = IntervalTreeNode | EmptyRange;
+export interface IntervalTreeNode {
+	from: IndexableType; // lower bound
+	to: IndexableType; // upper bound
+	l: IntervalTreeNode | null; // left
+	r: IntervalTreeNode | null; // right
+	d: number; // depth
+}
+export interface EmptyRange {
+	d: 0;
+}
+export interface DexieOnReadyEvent {
+	subscribe(fn: (vipDb: Dexie) => any, bSticky: boolean): void;
+	unsubscribe(fn: (vipDb: Dexie) => any): void;
+	fire(vipDb: Dexie): any;
+}
+export interface DexieVersionChangeEvent {
+	subscribe(fn: (event: IDBVersionChangeEvent) => any): void;
+	unsubscribe(fn: (event: IDBVersionChangeEvent) => any): void;
+	fire(event: IDBVersionChangeEvent): any;
+}
+export interface DexiePopulateEvent {
+	subscribe(fn: (trans: Transaction) => any): void;
+	unsubscribe(fn: (trans: Transaction) => any): void;
+	fire(trans: Transaction): any;
+}
+export interface DexieCloseEvent {
+	subscribe(fn: (event: Event) => any): void;
+	unsubscribe(fn: (event: Event) => any): void;
+	fire(event: Event): any;
+}
+export interface DbEvents extends DexieEventSet {
+	(eventName: "ready", subscriber: (vipDb: Dexie) => any, bSticky?: boolean): void;
+	(eventName: "populate", subscriber: (trans: Transaction) => any): void;
+	(eventName: "blocked", subscriber: (event: IDBVersionChangeEvent) => any): void;
+	(eventName: "versionchange", subscriber: (event: IDBVersionChangeEvent) => any): void;
+	(eventName: "close", subscriber: (event: Event) => any): void;
+	ready: DexieOnReadyEvent;
+	populate: DexiePopulateEvent;
+	blocked: DexieEvent;
+	versionchange: DexieVersionChangeEvent;
+	close: DexieCloseEvent;
+}
+/** Set of mutated parts of the database
+ */
+export type ObservabilitySet = {
+	/** Database part having been mutated.
+	 *
+	 * This structure is produced in observability-middleware.ts
+	 * and consumed in live-query.ts.
+	 *
+	 * Format of 'part':
+	 *
+	 *   `idb://${dbName}/${tableName}/${indexName}`
+	 *
+	 * * dbName is the database name
+	 * * tableName is the table name
+	 * * indexName is any of:
+	 *    1. An empty string - represents the primary keys of the affected objs
+	 *    2. ":dels" - represents primary keys of deleted objects in the table
+	 *    3. The keyPath of an index, such as "name", "age" or "address.city" -
+	 *       represents indexes that, if used in a query, might affect the
+	 *       result of that query.
+	 *
+	 * IntervalTree
+	 *    * See definition of IntervalTree type in rangeset.d.ts
+	 *    * See rangesOverlap() in rangeset.ts that can be used to compare two
+	 *      IntervalTrees and detect collissions.
+	 *    * See RangeSet class that can be used to create an IntervalTree and add
+	 *      ranges to it.
+	 */
+	[part: string]: IntervalTree;
+};
+export interface DexieOnStorageMutatedEvent {
+	subscribe(fn: (parts: ObservabilitySet) => any): void;
+	unsubscribe(fn: (parts: ObservabilitySet) => any): void;
+	fire(parts: ObservabilitySet): any;
+}
+export interface GlobalDexieEvents extends DexieEventSet {
+	(eventName: "storagemutated", subscriber: (parts: ObservabilitySet) => any): void;
+	storagemutated: DexieOnStorageMutatedEvent;
 }
 export const enum DBCoreRangeType {
 	Equal = 1,
@@ -449,6 +533,7 @@ export interface DBCoreAddRequest {
 	trans: DBCoreTransaction;
 	values: readonly any[];
 	keys?: any[];
+	mutatedParts?: ObservabilitySet;
 	/** @deprecated Will always get results since 3.1.0-alpha.5 */
 	wantResults?: boolean;
 }
@@ -457,6 +542,7 @@ export interface DBCorePutRequest {
 	trans: DBCoreTransaction;
 	values: readonly any[];
 	keys?: any[];
+	mutatedParts?: ObservabilitySet;
 	criteria?: {
 		index: string | null;
 		range: DBCoreKeyRange;
@@ -477,6 +563,7 @@ export interface DBCoreDeleteRequest {
 	type: "delete";
 	trans: DBCoreTransaction;
 	keys: any[];
+	mutatedParts?: ObservabilitySet;
 	criteria?: {
 		index: string | null;
 		range: DBCoreKeyRange;
@@ -486,15 +573,18 @@ export interface DBCoreDeleteRangeRequest {
 	type: "deleteRange";
 	trans: DBCoreTransaction;
 	range: DBCoreKeyRange;
+	mutatedParts?: ObservabilitySet;
 }
 export interface DBCoreGetManyRequest {
 	trans: DBCoreTransaction;
 	keys: any[];
 	cache?: "immutable" | "clone";
+	obsSet?: ObservabilitySet;
 }
 export interface DBCoreGetRequest {
 	trans: DBCoreTransaction;
 	key: any;
+	obsSet?: ObservabilitySet;
 }
 export interface DBCoreQuery {
 	index: DBCoreIndex; //keyPath: null | string | string[]; // null represents primary key. string a property, string[] several properties.
@@ -505,6 +595,7 @@ export interface DBCoreQueryRequest {
 	values?: boolean;
 	limit?: number;
 	query: DBCoreQuery;
+	obsSet?: ObservabilitySet;
 }
 export interface DBCoreQueryResponse {
 	result: any[];
@@ -515,10 +606,12 @@ export interface DBCoreOpenCursorRequest {
 	unique?: boolean;
 	reverse?: boolean;
 	query: DBCoreQuery;
+	obsSet?: ObservabilitySet;
 }
 export interface DBCoreCountRequest {
 	trans: DBCoreTransaction;
 	query: DBCoreQuery;
+	obsSet?: ObservabilitySet;
 }
 export interface DBCoreCursor {
 	readonly trans: DBCoreTransaction;
@@ -563,6 +656,8 @@ export interface DBCoreIndex {
 	readonly multiEntry?: boolean;
 	/** Extract (using keyPath) a key from given value (object). Null for outbound primary keys */
 	readonly extractKey: ((value: any) => any) | null;
+	/** If this index is a virtual index, lowLevelIndex represents the actual IndexedDB index behind it */
+	readonly lowLevelIndex?: DBCoreIndex;
 }
 export interface DBCore {
 	stack: "dbcore";
@@ -584,11 +679,11 @@ export interface DBCoreTable {
 	openCursor(req: DBCoreOpenCursorRequest): Promise<DBCoreCursor | null>;
 	count(req: DBCoreCountRequest): Promise<number>;
 }
-export interface Table<T = any, TKey = IndexableType, TInsertType = T> {
+export interface Table<T = any, TKey = any, TInsertType = T> {
 	db: Dexie;
 	name: string;
 	schema: TableSchema;
-	hook: TableHooks<T, TKey>;
+	hook: TableHooks<T, TKey, TInsertType>;
 	core: DBCoreTable;
 	get(key: TKey): PromiseExtended<T | undefined>;
 	get<R>(key: TKey, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
@@ -598,27 +693,27 @@ export interface Table<T = any, TKey = IndexableType, TInsertType = T> {
 	get<R>(equalityCriterias: {
 		[key: string]: any;
 	}, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
-	where(index: string | string[]): WhereClause<T, TKey>;
+	where(index: string | string[]): WhereClause<T, TKey, TInsertType>;
 	where(equalityCriterias: {
 		[key: string]: any;
-	}): Collection<T, TKey>;
-	filter(fn: (obj: T) => boolean): Collection<T, TKey>;
+	}): Collection<T, TKey, TInsertType>;
+	filter(fn: (obj: T) => boolean): Collection<T, TKey, TInsertType>;
 	count(): PromiseExtended<number>;
 	count<R>(thenShortcut: ThenShortcut<number, R>): PromiseExtended<R>;
-	offset(n: number): Collection<T, TKey>;
-	limit(n: number): Collection<T, TKey>;
+	offset(n: number): Collection<T, TKey, TInsertType>;
+	limit(n: number): Collection<T, TKey, TInsertType>;
 	each(callback: (obj: T, cursor: {
 		key: any;
 		primaryKey: TKey;
 	}) => any): PromiseExtended<void>;
 	toArray(): PromiseExtended<Array<T>>;
 	toArray<R>(thenShortcut: ThenShortcut<T[], R>): PromiseExtended<R>;
-	toCollection(): Collection<T, TKey>;
-	orderBy(index: string | string[]): Collection<T, TKey>;
-	reverse(): Collection<T, TKey>;
+	toCollection(): Collection<T, TKey, TInsertType>;
+	orderBy(index: string | string[]): Collection<T, TKey, TInsertType>;
+	reverse(): Collection<T, TKey, TInsertType>;
 	mapToClass(constructor: Function): Function;
 	add(item: TInsertType, key?: TKey): PromiseExtended<TKey>;
-	update(key: TKey | T, changes: UpdateSpec<T> | ((obj: T, ctx: {
+	update(key: TKey | T, changes: UpdateSpec<TInsertType> | ((obj: T, ctx: {
 		value: any;
 		primKey: IndexableType;
 	}) => void | boolean)): PromiseExtended<number>;
@@ -656,88 +751,6 @@ export interface Version {
 	}): Version;
 	upgrade(fn: (trans: Transaction) => PromiseLike<any> | void): Version;
 }
-export type IntervalTree = IntervalTreeNode | EmptyRange;
-export interface IntervalTreeNode {
-	from: IndexableType; // lower bound
-	to: IndexableType; // upper bound
-	l: IntervalTreeNode | null; // left
-	r: IntervalTreeNode | null; // right
-	d: number; // depth
-}
-export interface EmptyRange {
-	d: 0;
-}
-export interface DexieOnReadyEvent {
-	subscribe(fn: (vipDb: Dexie) => any, bSticky: boolean): void;
-	unsubscribe(fn: (vipDb: Dexie) => any): void;
-	fire(vipDb: Dexie): any;
-}
-export interface DexieVersionChangeEvent {
-	subscribe(fn: (event: IDBVersionChangeEvent) => any): void;
-	unsubscribe(fn: (event: IDBVersionChangeEvent) => any): void;
-	fire(event: IDBVersionChangeEvent): any;
-}
-export interface DexiePopulateEvent {
-	subscribe(fn: (trans: Transaction) => any): void;
-	unsubscribe(fn: (trans: Transaction) => any): void;
-	fire(trans: Transaction): any;
-}
-export interface DexieCloseEvent {
-	subscribe(fn: (event: Event) => any): void;
-	unsubscribe(fn: (event: Event) => any): void;
-	fire(event: Event): any;
-}
-export interface DbEvents extends DexieEventSet {
-	(eventName: "ready", subscriber: (vipDb: Dexie) => any, bSticky?: boolean): void;
-	(eventName: "populate", subscriber: (trans: Transaction) => any): void;
-	(eventName: "blocked", subscriber: (event: IDBVersionChangeEvent) => any): void;
-	(eventName: "versionchange", subscriber: (event: IDBVersionChangeEvent) => any): void;
-	(eventName: "close", subscriber: (event: Event) => any): void;
-	ready: DexieOnReadyEvent;
-	populate: DexiePopulateEvent;
-	blocked: DexieEvent;
-	versionchange: DexieVersionChangeEvent;
-	close: DexieCloseEvent;
-}
-/** Set of mutated parts of the database
- */
-export type ObservabilitySet = {
-	/** Database part having been mutated.
-	 *
-	 * This structure is produced in observability-middleware.ts
-	 * and consumed in live-query.ts.
-	 *
-	 * Format of 'part':
-	 *
-	 *   `idb://${dbName}/${tableName}/${indexName}`
-	 *
-	 * * dbName is the database name
-	 * * tableName is the table name
-	 * * indexName is any of:
-	 *    1. An empty string - represents the primary keys of the affected objs
-	 *    2. ":dels" - represents primary keys of deleted objects in the table
-	 *    3. The keyPath of an index, such as "name", "age" or "address.city" -
-	 *       represents indexes that, if used in a query, might affect the
-	 *       result of that query.
-	 *
-	 * IntervalTree
-	 *    * See definition of IntervalTree type in rangeset.d.ts
-	 *    * See rangesOverlap() in rangeset.ts that can be used to compare two
-	 *      IntervalTrees and detect collissions.
-	 *    * See RangeSet class that can be used to create an IntervalTree and add
-	 *      ranges to it.
-	 */
-	[part: string]: IntervalTree;
-};
-export interface DexieOnStorageMutatedEvent {
-	subscribe(fn: (parts: ObservabilitySet) => any): void;
-	unsubscribe(fn: (parts: ObservabilitySet) => any): void;
-	fire(parts: ObservabilitySet): any;
-}
-export interface GlobalDexieEvents extends DexieEventSet {
-	(eventName: "storagemutated", subscriber: (parts: ObservabilitySet) => any): void;
-	storagemutated: DexieOnStorageMutatedEvent;
-}
 export type TransactionMode = "readonly" | "readwrite" | "r" | "r!" | "r?" | "rw" | "rw!" | "rw?";
 export type DbSchema = {
 	[tableName: string]: TableSchema;
@@ -788,8 +801,12 @@ export interface Dexie {
 	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, table3: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
 	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, table3: string | Table, table4: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
 	transaction<U>(mode: TransactionMode, table: string | Table, table2: string | Table, table3: string | Table, table5: string | Table, scope: (trans: TXWithTables<this>) => PromiseLike<U> | U): PromiseExtended<U>;
-	close(): void;
-	delete(): PromiseExtended<void>;
+	close(closeOptions?: {
+		disableAutoOpen: boolean;
+	}): void;
+	delete(closeOptions?: {
+		disableAutoOpen: boolean;
+	}): PromiseExtended<void>;
 	isOpen(): boolean;
 	hasBeenClosed(): boolean;
 	hasFailed(): boolean;
@@ -967,10 +984,18 @@ declare global {
 		readonly observable: symbol;
 	}
 }
+export interface Subscribable<T> {
+	subscribe(observer: Partial<Observer<T>>): Unsubscribable;
+}
+export interface Unsubscribable {
+	unsubscribe(): void;
+}
 export interface Observable<T = any> {
-	subscribe(onNext?: ((value: T) => void) | null, onError?: ((error: any) => void) | null, onComplete?: (() => void) | null): Subscription;
-	subscribe(observer?: Observer<T> | null): Subscription;
-	[Symbol.observable]: () => Observable<T>;
+	subscribe(observerOrNext?: Observer<T> | ((value: T) => void)): Subscription;
+	subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
+	getValue?(): T;
+	hasValue?(): boolean;
+	[Symbol.observable]: () => Subscribable<T>;
 }
 export interface Subscription {
 	unsubscribe(): void;
@@ -982,6 +1007,40 @@ export interface Observer<T = any> {
 	error?: (error: any) => void;
 	complete?: () => void;
 }
+export type GlobalQueryCache = {
+	// TODO: Change to parts: {[part: string]: TblQueryCache}
+	//       och unsignaledParts: ObservabilitySet;
+	[part: string]: TblQueryCache; // part is `idb://${dbName}/${tableName}`
+};
+export interface TblQueryCache {
+	queries: {
+		query: {
+			[indexName: string]: CacheEntry[];
+		};
+		count: {
+			[indexName: string]: CacheEntry[];
+		};
+	};
+	objs: Map<string | number, object>;
+	optimisticOps: DBCoreMutateRequest[];
+	unsignaledParts: ObservabilitySet;
+}
+export interface CacheEntryCommon {
+	subscribers: Set<() => void>;
+	obsSet: ObservabilitySet;
+	//txObsSet: ObservabilitySet;
+	promise: Promise<any>;
+	dirty: boolean;
+}
+export type CacheEntry = CacheEntryCommon & ({
+	type: "query";
+	req: DBCoreQueryRequest;
+	res?: readonly any[];
+} | {
+	type: "count";
+	req: DBCoreCountRequest;
+	res?: number;
+});
 export type ChromeTransactionDurability = "default" | "strict" | "relaxed";
 export interface DexieOptions {
 	addons?: Array<(db: Dexie) => void>;
@@ -997,6 +1056,7 @@ export interface DexieOptions {
 	allowEmptyDB?: boolean;
 	modifyChunkSize?: number;
 	chromeTransactionDurability?: ChromeTransactionDurability;
+	cache?: "immutable" | "cloned" | "disabled";
 }
 export interface DexieConstructor extends DexieExceptionClasses {
 	new (databaseName: string, options?: DexieOptions): Dexie;
@@ -1010,6 +1070,7 @@ export interface DexieConstructor extends DexieExceptionClasses {
 	getDatabaseNames<R>(thenShortcut: ThenShortcut<string[], R>): Promise<R>;
 	vip<U>(scopeFunction: () => U): U;
 	ignoreTransaction<U>(fn: () => U): U;
+	disableBfCache?: boolean;
 	liveQuery<T>(fn: () => T | Promise<T>): Observable<T>;
 	extendObservabilitySet(target: ObservabilitySet, newSet: ObservabilitySet): ObservabilitySet;
 	override<F>(origFunc: F, overridedFactory: (fn: any) => any): F; // ?
@@ -1025,6 +1086,8 @@ export interface DexieConstructor extends DexieExceptionClasses {
 	delete(dbName: string): Promise<void>;
 	dependencies: DexieDOMDependencies;
 	default: Dexie; // Work-around for different build tools handling default imports differently.
+	cache: GlobalQueryCache;
+	debug: false | true | "dexie";
 	Promise: PromiseExtendedConstructor;
 	//TableSchema: {}; // Deprecate!
 	//IndexSpec: {new():IndexSpec}; //? Deprecate
@@ -1059,7 +1122,7 @@ export type InsertType<T, OptionalProps extends keyof T> = Omit<T, OptionalProps
 export type IDType<T, TKeyPropNameOrKeyType> = IsStrictlyAny<T> extends true ? TKeyPropNameOrKeyType : TKeyPropNameOrKeyType extends string ? TKeyPropNameOrKeyType extends keyof T ? T[TKeyPropNameOrKeyType] : TKeyPropNameOrKeyType : TKeyPropNameOrKeyType;
 export type EntityTable<T, TKeyPropName extends keyof T = never, TInsertType = InsertType<T, TKeyPropName>> = Table<T, IDType<T, TKeyPropName>, TInsertType>;
 export declare var Dexie: DexieConstructor;
-export interface _Table<T, TKey> extends Table<T, TKey> {
+export interface _Table<T, TKey, TInsertType> extends Table<T, TKey, TInsertType> {
 }
 export interface _Collection<T, TKey> extends Collection<T, TKey> {
 }
@@ -1067,7 +1130,7 @@ export declare module Dexie {
 	// The "Dexie.Promise" type.
 	type Promise<T = any> = PromiseExtended<T>; // Because many samples have been Dexie.Promise.
 	// The "Dexie.Table" interface. Same as named exported interface Table.
-	interface Table<T = any, Key = any> extends _Table<T, Key> {
+	interface Table<T = any, Key = any, TInsertType = T> extends _Table<T, Key, TInsertType> {
 	} // Because all samples have been Dexie.Table<...>
 	// The "Dexie.Collection" interface. Same as named exported interface Collection.
 	interface Collection<T = any, Key = any> extends _Collection<T, Key> {