dexie 4.0.0-alpha.4 → 4.0.1-alpha.11

package/CONTRIBUTING.md

@@ -13,7 +13,9 @@ We appreciate contributions in forms of:
 Contribute while developing your own app
 ========================================
 
-Here is a little cheat-sheet for how to symlink your app's `node_modules/dexie` to a place where you can edit the source, version control your changes and create pull requests back to Dexie. Assuming you've already ran `npm install dexie --save` for the app your are developing.
+Dexie uses pnpm package manager. Refer to [pnpm.io/installation](https://pnpm.io/installation) for how to install pnpm.
+
+Here is a little cheat-sheet for how to symlink your app's `node_modules/dexie` to a place where you can edit the source, version control your changes and create pull requests back to Dexie. Assuming you've already ran `npm install dexie` for the app your are developing.
 
 1. Fork Dexie.js from the web gui on github
 2. Clone your fork locally by launching a shell/command window and cd to a neutral place (like `~repos/`, `c:\repos` or whatever)
@@ -22,39 +24,42 @@ Here is a little cheat-sheet for how to symlink your app's `node_modules/dexie`
     ```
     git clone https://github.com/YOUR-USERNAME/Dexie.js.git dexie
     cd dexie
-    npm install
-    npm run build
-    npm link
+    pnpm install
+    pnpm run build
+    npm link # Or yarn link or pnpm link --global depending on what package manager you are using.
     ```
 3. cd to your app directory and write:
     ```
-    npm link dexie
+    npm link dexie # Or yarn link dexie / pnpm link dexie depending on your package manager.
     ```
 
-Your app's `node_modules/dexie/` is now sym-linked to the Dexie.js clone on your hard drive so any change you do there will propagate to your app. Build dexie.js using `npm run build` or `npm run watch`. The latter will react on any source file change and rebuild the dist files.
+Your app's `node_modules/dexie/` is now sym-linked to the Dexie.js clone on your hard drive so any change you do there will propagate to your app. Build dexie.js using `pnpm run build` or `pnpm run watch`. The latter will react on any source file change and rebuild the dist files.
 
 That's it. Now you're up and running to test and commit changes to files under dexie/src/* or dexie/test/* and the changes will instantly affect the app you are developing.
 
+If you're on yarn or pnpm, do the same procedures using yarn link / pnpm link.
+
 Pull requests are more than welcome. Some advices are:
 
-* Run npm test before making a pull request.
+* Run pnpm test before making a pull request.
 * If you find an issue, a unit test that reproduces it is lovely ;). If you don't know where to put it, put it in `test/tests-misc.js`. We use qunit. Just look at existing tests in `tests-misc.js` to see how they should be written. Tests are transpiled in the build script so you can use ES6 if you like.
 
 Build
 -----
 ```
-npm install
-npm run build
+# To install pnpm, see https://pnpm.io/installation
+pnpm install
+pnpm run build
 ```
 
 Test
 ----
 ```
-npm test
+pnpm test
 ```
 
 Watch
 -----
 ```
-npm run watch
+pnpm run watch
 ```

package/README.md

@@ -229,50 +229,25 @@ https://unpkg.com/dexie@latest/dist/dexie.d.ts
 
 Contributing
 ============
-Here is a little cheat-sheet for how to symlink your app's `node_modules/dexie` to a place where you can edit the source, version control your changes and create pull requests back to Dexie. Assuming you've already ran `npm install dexie --save` for the app your are developing.
-
-1. Fork Dexie.js from the web gui on github
-2. Clone your fork locally by launching a shell/command window and cd to a neutral place (like `~repos/`, `c:\repos` or whatever)
-3. Run the following commands:
-
-    ```
-    git clone https://github.com/YOUR-USERNAME/Dexie.js.git dexie
-    cd dexie
-    npm install
-    npm run build
-    npm link
-    ```
-3. cd to your app directory and write:
-    ```
-    npm link dexie
-    ```
-
-Your app's `node_modules/dexie/` is now sym-linked to the Dexie.js clone on your hard drive so any change you do there will propagate to your app. Build dexie.js using `npm run build` or `npm run watch`. The latter will react on any source file change and rebuild the dist files.
-
-That's it. Now you're up and running to test and commit changes to files under dexie/src/* or dexie/test/* and the changes will instantly affect the app you are developing.
-
-Pull requests are more than welcome. Some advices are:
-
-* Run npm test before making a pull request.
-* If you find an issue, a unit test that reproduces it is lovely ;). If you don't know where to put it, put it in `test/tests-misc.js`. We use qunit. Just look at existing tests in `tests-misc.js` to see how they should be written. Tests are transpiled in the build script so you can use ES6 if you like.
+See [CONTRIBUTING.md](CONTRIBUTING.md)
 
 Build
 -----
 ```
-npm install
-npm run build
+pnpm install
+pnpm run build
 ```
 
 Test
 ----
 ```
-npm test
+pnpm test
 ```
 
 Watch
 -----
 ```
-npm run watch
+pnpm run watch
 ```
 
 

package/dist/dexie.d.ts

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.0-alpha.4, Tue May 31 2022
+ * Version 4.0.1-alpha.11, Wed May 24 2023
  *
  * 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;
@@ -85,7 +86,7 @@ export interface DeletingHookContext<T, Key> {
 	onerror?: (err: any) => void;
 }
 export interface TableHooks<T = any, TKey = IndexableType> extends DexieEventSet {
-	(eventName: "creating", subscriber: (this: CreatingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
+	(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;
 	(eventName: "deleting", subscriber: (this: DeletingHookContext<T, TKey>, primKey: TKey, obj: T, transaction: Transaction) => any): void;
@@ -357,11 +358,11 @@ 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 : 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 Extract<T, P> = P extends keyof T ? T[P] : void;
-export type KeyPathValue<T, PATH> = PATH extends `${infer R}.${infer S}` ? R extends keyof T ? Extract<T[R], S> : void : Extract<T, PATH>;
+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>;
 };
@@ -388,6 +389,7 @@ export interface Collection<T = any, TKey = IndexableType> {
 		key: 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>;
 	first(): PromiseExtended<T | undefined>;
 	first<R>(thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
@@ -416,6 +418,88 @@ export interface Collection<T = any, TKey = IndexableType> {
 	}) => void | boolean): PromiseExtended<number>;
 	modify(changes: UpdateSpec<T>): 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,
 	Range = 2,
@@ -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;
@@ -464,9 +550,12 @@ export interface DBCorePutRequest {
 	changeSpec?: {
 		[keyPath: string]: any;
 	}; // Common changeSpec for each key
-	changeSpecs?: {
-		[keyPath: string]: any;
-	}[]; // changeSpec per key. 
+	updates?: {
+		keys: any[];
+		changeSpecs: {
+			[keyPath: string]: any;
+		}[]; // changeSpec per key.  
+	};
 	/** @deprecated Will always get results since 3.1.0-alpha.5 */
 	wantResults?: boolean;
 }
@@ -474,6 +563,7 @@ export interface DBCoreDeleteRequest {
 	type: "delete";
 	trans: DBCoreTransaction;
 	keys: any[];
+	mutatedParts?: ObservabilitySet;
 	criteria?: {
 		index: string | null;
 		range: DBCoreKeyRange;
@@ -483,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.
@@ -502,6 +595,7 @@ export interface DBCoreQueryRequest {
 	values?: boolean;
 	limit?: number;
 	query: DBCoreQuery;
+	obsSet?: ObservabilitySet;
 }
 export interface DBCoreQueryResponse {
 	result: any[];
@@ -512,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;
@@ -581,76 +677,71 @@ export interface DBCoreTable {
 	openCursor(req: DBCoreOpenCursorRequest): Promise<DBCoreCursor | null>;
 	count(req: DBCoreCountRequest): Promise<number>;
 }
-export type MethodProps<T> = {
-	[P in keyof T]: T[P] extends (...args: any[]) => any ? P : never;
-}[keyof T];
-export type InsertType<T, TOptionalProperties, TKeyPropNameOrKeyType> = string extends MethodProps<T> ? T : Omit<T, TOptionalProperties extends keyof T ? TKeyPropNameOrKeyType extends keyof T ? MethodProps<T> | TOptionalProperties | TKeyPropNameOrKeyType : MethodProps<T> | TOptionalProperties : MethodProps<T>> & (TOptionalProperties extends keyof T ? TKeyPropNameOrKeyType extends keyof T ? {
-	[P in (TOptionalProperties | TKeyPropNameOrKeyType)]?: T[P];
-} : {
-	[P in TOptionalProperties]?: T[P];
-} : {});
-export type IDType<T, TKey> = TKey extends keyof T ? T[TKey] : TKey;
-export interface Table<T = any, TKeyPropNameOrKeyType = IndexableType, TOpt = void> {
+export interface Table<T = any, TKey = any, TInsertType = T> {
 	db: Dexie;
 	name: string;
 	schema: TableSchema;
-	hook: TableHooks<T, IDType<T, TKeyPropNameOrKeyType>>;
+	hook: TableHooks<T, TKey>;
 	core: DBCoreTable;
-	get(key: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<T | undefined>;
-	get<R>(key: IDType<T, TKeyPropNameOrKeyType>, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
+	get(key: TKey): PromiseExtended<T | undefined>;
+	get<R>(key: TKey, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
 	get(equalityCriterias: {
 		[key: string]: any;
 	}): PromiseExtended<T | undefined>;
 	get<R>(equalityCriterias: {
 		[key: string]: any;
 	}, thenShortcut: ThenShortcut<T | undefined, R>): PromiseExtended<R>;
-	where(index: string | string[]): WhereClause<T, IDType<T, TKeyPropNameOrKeyType>>;
+	where(index: string | string[]): WhereClause<T, TKey>;
 	where(equalityCriterias: {
 		[key: string]: any;
-	}): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
-	filter(fn: (obj: T) => boolean): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	}): Collection<T, TKey>;
+	filter(fn: (obj: T) => boolean): Collection<T, TKey>;
 	count(): PromiseExtended<number>;
 	count<R>(thenShortcut: ThenShortcut<number, R>): PromiseExtended<R>;
-	offset(n: number): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
-	limit(n: number): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	offset(n: number): Collection<T, TKey>;
+	limit(n: number): Collection<T, TKey>;
 	each(callback: (obj: T, cursor: {
 		key: any;
-		primaryKey: IDType<T, TKeyPropNameOrKeyType>;
+		primaryKey: TKey;
 	}) => any): PromiseExtended<void>;
 	toArray(): PromiseExtended<Array<T>>;
 	toArray<R>(thenShortcut: ThenShortcut<T[], R>): PromiseExtended<R>;
-	toCollection(): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
-	orderBy(index: string | string[]): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
-	reverse(): Collection<T, IDType<T, TKeyPropNameOrKeyType>>;
+	toCollection(): Collection<T, TKey>;
+	orderBy(index: string | string[]): Collection<T, TKey>;
+	reverse(): Collection<T, TKey>;
 	mapToClass(constructor: Function): Function;
-	add(item: InsertType<T, TOpt, TKeyPropNameOrKeyType>, key?: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
-	update(key: IDType<T, TKeyPropNameOrKeyType> | T, changes: UpdateSpec<T> | ((obj: T, ctx: {
+	add(item: TInsertType, key?: TKey): PromiseExtended<TKey>;
+	update(key: TKey | T, changes: UpdateSpec<T> | ((obj: T, ctx: {
 		value: any;
 		primKey: IndexableType;
 	}) => void | boolean)): PromiseExtended<number>;
-	put(item: InsertType<T, TOpt, TKeyPropNameOrKeyType>, key?: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
-	delete(key: IDType<T, TKeyPropNameOrKeyType>): PromiseExtended<void>;
+	put(item: TInsertType, key?: TKey): PromiseExtended<TKey>;
+	delete(key: TKey): PromiseExtended<void>;
 	clear(): PromiseExtended<void>;
-	bulkGet(keys: IDType<T, TKeyPropNameOrKeyType>[]): PromiseExtended<(T | undefined)[]>;
-	bulkAdd<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys: IndexableTypeArrayReadonly, options: {
+	bulkGet(keys: TKey[]): PromiseExtended<(T | undefined)[]>;
+	bulkAdd<B extends boolean>(items: readonly TInsertType[], keys: IndexableTypeArrayReadonly, options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
-	bulkAdd<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], options: {
+	}): PromiseExtended<B extends true ? TKey[] : TKey>;
+	bulkAdd<B extends boolean>(items: readonly TInsertType[], options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
-	bulkAdd(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys?: IndexableTypeArrayReadonly, options?: {
+	}): PromiseExtended<B extends true ? TKey[] : TKey>;
+	bulkAdd(items: readonly TInsertType[], keys?: IndexableTypeArrayReadonly, options?: {
 		allKeys: boolean;
-	}): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
-	bulkPut<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys: IndexableTypeArrayReadonly, options: {
+	}): PromiseExtended<TKey>;
+	bulkPut<B extends boolean>(items: readonly TInsertType[], keys: IndexableTypeArrayReadonly, options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
-	bulkPut<B extends boolean>(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], options: {
+	}): PromiseExtended<B extends true ? TKey[] : TKey>;
+	bulkPut<B extends boolean>(items: readonly TInsertType[], options: {
 		allKeys: B;
-	}): PromiseExtended<B extends true ? IDType<T, TKeyPropNameOrKeyType>[] : IDType<T, TKeyPropNameOrKeyType>>;
-	bulkPut(items: readonly InsertType<T, TOpt, TKeyPropNameOrKeyType>[], keys?: IndexableTypeArrayReadonly, options?: {
+	}): PromiseExtended<B extends true ? TKey[] : TKey>;
+	bulkPut(items: readonly TInsertType[], keys?: IndexableTypeArrayReadonly, options?: {
 		allKeys: boolean;
-	}): PromiseExtended<IDType<T, TKeyPropNameOrKeyType>>;
-	bulkDelete(keys: IDType<T, TKeyPropNameOrKeyType>[]): PromiseExtended<void>;
+	}): PromiseExtended<TKey>;
+	bulkUpdate(keysAndChanges: ReadonlyArray<{
+		key: TKey;
+		changes: UpdateSpec<T>;
+	}>): PromiseExtended<number>;
+	bulkDelete(keys: TKey[]): PromiseExtended<void>;
 }
 export interface Version {
 	stores(schema: {
@@ -658,88 +749,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;
@@ -969,10 +978,16 @@ 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;
+	[Symbol.observable]: () => Subscribable<T>;
 }
 export interface Subscription {
 	unsubscribe(): void;
@@ -984,6 +999,41 @@ 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;
+	signalTimer?: number;
+}
+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>;
@@ -999,6 +1049,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;
@@ -1027,6 +1078,7 @@ 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;
 	Promise: PromiseExtendedConstructor;
 	//TableSchema: {}; // Deprecate!
 	//IndexSpec: {new():IndexSpec}; //? Deprecate
@@ -1039,6 +1091,27 @@ export class Entity<TDexieSubClass extends Dexie = Dexie> {
 	protected readonly db: TDexieSubClass;
 	table(): TableProp<TDexieSubClass>;
 }
+export type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
+/** Extract the union of literal method names in T
+ */
+export type MethodProps<T> = {
+	[P in keyof T]: IsStrictlyAny<T[P]> extends true ? never // Plain property of type any (not method)
+	 : T[P] extends (...args: any[]) => any ? P // a function (method)
+	 : never;
+}[keyof T];
+/** Default insert type of T is a subset of T where:
+ *    * given optional props (such as an auto-generated primary key) are made optional
+ *    * methods are omitted
+ */
+export type InsertType<T, OptionalProps extends keyof T> = Omit<T, OptionalProps | MethodProps<T>> & {
+	[P in OptionalProps]?: T[P];
+};
+/** IDType extract the actual type of the primary key:
+ *  * If TKey is a literal type that names a property of T, extract the type using T[TKey]
+ *  * Else, use TKey as is.
+ */
+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> {
 }