dexie 3.0.0-rc.5 → 3.0.1

package/dist/dexie.d.ts

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 3.0.0-rc.5, Mon Feb 24 2020
+ * Version 3.0.1, Thu May 07 2020
  *
  * http://dexie.org
  *
@@ -215,18 +215,17 @@ export interface TableHooks<T=any,TKey=IndexableType> extends DexieEventSet {
   updating: DexieEvent;
   deleting: DexieEvent;
 }
-export type Key = any;
-export const enum RangeType {
+export const enum DBCoreRangeType {
   Equal = 1,
   Range = 2,
   Any = 3,
   Never = 4
 }
-export interface KeyRange {
-  readonly type: RangeType;
-  readonly lower: Key | undefined;
+export interface DBCoreKeyRange {
+  readonly type: DBCoreRangeType;
+  readonly lower: any;
   readonly lowerOpen?: boolean;
-  readonly upper: Key | undefined;
+  readonly upper: any;
   readonly upperOpen?: boolean;
   //includes (key: Key) : boolean; Despite IDBKeyRange api - it's no good to have this as a method. Benefit from using a more functional approach.
 }
@@ -235,83 +234,82 @@ export interface DBCoreTransaction {
 }
 export interface DBCoreTransactionRequest {
   tables: string[];
-  mode: DBCoreTransactionMode;
+  mode: 'readonly' | 'readwrite';
 }
-export type DBCoreTransactionMode = 'readonly' | 'readwrite';
-export type MutateRequest = AddRequest | PutRequest | DeleteRequest | DeleteRangeRequest;
-export interface MutateResponse {
+export type DBCoreMutateRequest = DBCoreAddRequest | DBCorePutRequest | DBCoreDeleteRequest | DBCoreDeleteRangeRequest;
+export interface DBCoreMutateResponse {
   numFailures: number,
   failures: {[operationNumber: number]: Error};
-  lastResult: Key;
-  results?: Key[]; // Present on AddRequest and PutRequest if request.wantResults is truthy.
+  lastResult: any;
+  results?: any[]; // Present on AddRequest and PutRequest if request.wantResults is truthy.
 }
-export interface AddRequest {
+export interface DBCoreAddRequest {
   type: 'add';
   trans: DBCoreTransaction;
   values: any[];
-  keys?: Key[];
+  keys?: any[];
   wantResults?: boolean;
 }
-export interface PutRequest {
+export interface DBCorePutRequest {
   type: 'put';
   trans: DBCoreTransaction;
   values: any[];
-  keys?: Key[];
+  keys?: any[];
   wantResults?: boolean;
 }
-export interface DeleteRequest {
+export interface DBCoreDeleteRequest {
   type: 'delete';
   trans: DBCoreTransaction;
-  keys: Key[];
+  keys: any[];
 }
-export interface DeleteRangeRequest {
+export interface DBCoreDeleteRangeRequest {
   type: 'deleteRange';
   trans: DBCoreTransaction;
-  range: KeyRange;
+  range: DBCoreKeyRange;
 }
 export interface DBCoreGetManyRequest {
   trans: DBCoreTransaction;
-  keys: Key[];
+  keys: any[];
 }
 export interface DBCoreGetRequest {
   trans: DBCoreTransaction;
-  key: Key;  
+  key: any;  
 }
 export interface DBCoreQuery {
   index: DBCoreIndex;//keyPath: null | string | string[]; // null represents primary key. string a property, string[] several properties.
-  range: KeyRange;
+  range: DBCoreKeyRange;
 }
-export interface DBCoreQueryRequest<TQuery=DBCoreQuery> {
+export interface DBCoreQueryRequest {
   trans: DBCoreTransaction;
   values?: boolean;
   limit?: number;
-  query: TQuery;
+  query: DBCoreQuery;
 }
 export interface DBCoreQueryResponse {
   result: any[];
 }
-export interface DBCoreOpenCursorRequest<TQuery=DBCoreQuery> {
+export interface DBCoreOpenCursorRequest {
   trans: DBCoreTransaction;
   values?: boolean;
   unique?: boolean;
   reverse?: boolean;
-  query: TQuery;
+  query: DBCoreQuery;
 }
-export interface DBCoreCountRequest<TQuery=DBCoreQuery> {
+export interface DBCoreCountRequest {
   trans: DBCoreTransaction;
-  query: TQuery;
+  query: DBCoreQuery;
 }
-export interface DBCoreCursor<TResult=any> {
+export interface DBCoreCursor {
   readonly trans: DBCoreTransaction;
-  readonly key: Key;
-  readonly primaryKey: Key;
+  readonly key: any;
+  readonly primaryKey: any;
   readonly value?: any;
   readonly done?: boolean;
   continue(key?: any): void;
-  continuePrimaryKey(key: Key, primaryKey: Key): void;
+  continuePrimaryKey(key: any, primaryKey: any): void;
   advance(count: number): void;
-  start(onNext: ()=>void): Promise<TResult>
-  stop(value?: TResult | Promise<TResult>): void;
+  start(onNext: ()=>void): Promise<any>
+  stop(value?: any | Promise<any>): void;
   next(): Promise<DBCoreCursor>;
   fail(error: Error): void;
 }
@@ -343,33 +341,30 @@ export interface DBCoreIndex {
   /** Whether index is multiEntry. */
   readonly multiEntry?: boolean;
   /** Extract (using keyPath) a key from given value (object) */
-  readonly extractKey: (value: any) => Key;
+  readonly extractKey: (value: any) => any;
 }
-export interface DBCore<TQuery=DBCoreQuery> {
+export interface DBCore {
   stack: "dbcore";
   // Transaction and Object Store
   transaction(req: DBCoreTransactionRequest): DBCoreTransaction;
 
   // Utility methods
   cmp(a: any, b: any) : number;
-  //rangeIncludes(range: KeyRange): (key: Key) => boolean;
-  //comparer(table: string, index: string | null): (a: any, b: any) => number;
-  //readonly schema: DBCoreSchema;
-  readonly MIN_KEY: Key;
-  readonly MAX_KEY: Key;
+  readonly MIN_KEY: any;
+  readonly MAX_KEY: any;
   readonly schema: DBCoreSchema;
-  table(name: string): DBCoreTable<TQuery>;
+  table(name: string): DBCoreTable;
 }
-export interface DBCoreTable<TQuery=DBCoreQuery> {
+export interface DBCoreTable {
   readonly name: string;
   readonly schema: DBCoreTableSchema;
 
-  mutate(req: MutateRequest): Promise<MutateResponse>;
+  mutate(req: DBCoreMutateRequest): Promise<DBCoreMutateResponse>;
   get(req: DBCoreGetRequest): Promise<any>;
   getMany(req: DBCoreGetManyRequest): Promise<any[]>;
-  query(req: DBCoreQueryRequest<TQuery>): Promise<DBCoreQueryResponse>;
-  openCursor(req: DBCoreOpenCursorRequest<TQuery>): Promise<DBCoreCursor | null>;
-  count(req: DBCoreCountRequest<TQuery>): Promise<number>;
+  query(req: DBCoreQueryRequest): Promise<DBCoreQueryResponse>;
+  openCursor(req: DBCoreOpenCursorRequest): Promise<DBCoreCursor | null>;
+  count(req: DBCoreCountRequest): Promise<number>;
 }
 export interface Table<T=any, TKey=IndexableType> {
   db: Database;

package/dist/dexie.js

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 3.0.0-rc.5, Mon Feb 24 2020
+ * Version 3.0.1, Thu May 07 2020
  *
  * http://dexie.org
  *
@@ -805,31 +805,6 @@ props(DexiePromise, {
             values.map(function (value) { return DexiePromise.resolve(value).then(resolve, reject); });
         });
     },
-    allSettled: function () {
-        var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
-        return new DexiePromise(function (resolve) {
-            if (possiblePromises.length === 0)
-                resolve([]);
-            var remaining = possiblePromises.length;
-            var results = new Array(remaining);
-            possiblePromises.forEach(function (p, i) { return DexiePromise.resolve(p).then(function (value) { return results[i] = { status: "fulfilled", value: value }; }, function (reason) { return results[i] = { status: "rejected", reason: reason }; })
-                .then(function () { return --remaining || resolve(results); }); });
-        });
-    },
-    any: function () {
-        var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
-        return new DexiePromise(function (resolve, reject) {
-            if (possiblePromises.length === 0)
-                reject(new AggregateError([]));
-            var remaining = possiblePromises.length;
-            var failures = new Array(remaining);
-            possiblePromises.forEach(function (p, i) { return DexiePromise.resolve(p).then(function (value) { return resolve(value); }, function (failure) {
-                failures[i] = failure;
-                if (!--remaining)
-                    reject(new AggregateError(failures));
-            }); });
-        });
-    },
     PSD: {
         get: function () { return PSD; },
         set: function (value) { return PSD = value; }
@@ -861,6 +836,35 @@ props(DexiePromise, {
         });
     }
 });
+if (NativePromise) {
+    if (NativePromise.allSettled)
+        setProp(DexiePromise, "allSettled", function () {
+            var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
+            return new DexiePromise(function (resolve) {
+                if (possiblePromises.length === 0)
+                    resolve([]);
+                var remaining = possiblePromises.length;
+                var results = new Array(remaining);
+                possiblePromises.forEach(function (p, i) { return DexiePromise.resolve(p).then(function (value) { return results[i] = { status: "fulfilled", value: value }; }, function (reason) { return results[i] = { status: "rejected", reason: reason }; })
+                    .then(function () { return --remaining || resolve(results); }); });
+            });
+        });
+    if (NativePromise.any && typeof AggregateError !== 'undefined')
+        setProp(DexiePromise, "any", function () {
+            var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync);
+            return new DexiePromise(function (resolve, reject) {
+                if (possiblePromises.length === 0)
+                    reject(new AggregateError([]));
+                var remaining = possiblePromises.length;
+                var failures = new Array(remaining);
+                possiblePromises.forEach(function (p, i) { return DexiePromise.resolve(p).then(function (value) { return resolve(value); }, function (failure) {
+                    failures[i] = failure;
+                    if (!--remaining)
+                        reject(new AggregateError(failures));
+                }); });
+            });
+        });
+}
 function executePromiseTask(promise, fn) {
     try {
         fn(function (value) {
@@ -1184,8 +1188,10 @@ function switchToZone(targetZone, bEnteringZone) {
             GlobalPromise_1.race = targetEnv.race;
             GlobalPromise_1.resolve = targetEnv.resolve;
             GlobalPromise_1.reject = targetEnv.reject;
-            GlobalPromise_1.allSettled = targetEnv.allSettled;
-            GlobalPromise_1.any = targetEnv.any;
+            if (targetEnv.allSettled)
+                GlobalPromise_1.allSettled = targetEnv.allSettled;
+            if (targetEnv.any)
+                GlobalPromise_1.any = targetEnv.any;
         }
     }
 }
@@ -1299,7 +1305,7 @@ function tempTransaction(db, mode, storeNames, fn) {
     }
 }
 
-var DEXIE_VERSION = '3.0.0-rc.5';
+var DEXIE_VERSION = '3.0.1';
 var maxString = String.fromCharCode(65535);
 var minKey = -Infinity;
 var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
@@ -2757,7 +2763,7 @@ function createTransactionConstructor(db) {
     });
 }
 
-function createIndexSpec(name, keyPath, unique, multi, auto, compound) {
+function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey) {
     return {
         name: name,
         keyPath: keyPath,
@@ -2765,7 +2771,7 @@ function createIndexSpec(name, keyPath, unique, multi, auto, compound) {
         multi: multi,
         auto: auto,
         compound: compound,
-        src: (unique ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath)
+        src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath)
     };
 }
 function nameFromKeyPath(keyPath) {
@@ -3220,7 +3226,12 @@ function setApiOnPlace(db, objs, tableNames, dbschema) {
         objs.forEach(function (obj) {
             if (!(tableName in obj)) {
                 if (obj === db.Transaction.prototype || obj instanceof db.Transaction) {
-                    setProp(obj, tableName, { get: function () { return this.table(tableName); } });
+                    setProp(obj, tableName, {
+                        get: function () { return this.table(tableName); },
+                        set: function (value) {
+                            defineProperty(this, tableName, { value: value, writable: true, configurable: true, enumerable: true });
+                        }
+                    });
                 }
                 else {
                     obj[tableName] = new db.Table(tableName, schema);
@@ -3421,17 +3432,15 @@ function addIndex(store, idx) {
 function buildGlobalSchema(db, idbdb, tmpTrans) {
     var globalSchema = {};
     var dbStoreNames = slice(idbdb.objectStoreNames, 0);
-    if (dbStoreNames.length === 0)
-        return;
     dbStoreNames.forEach(function (storeName) {
         var store = tmpTrans.objectStore(storeName);
         var keyPath = store.keyPath;
-        var primKey = createIndexSpec(nameFromKeyPath(keyPath), keyPath || "", false, false, !!store.autoIncrement, keyPath && typeof keyPath !== "string");
+        var primKey = createIndexSpec(nameFromKeyPath(keyPath), keyPath || "", false, false, !!store.autoIncrement, keyPath && typeof keyPath !== "string", true);
         var indexes = [];
         for (var j = 0; j < store.indexNames.length; ++j) {
             var idbindex = store.index(store.indexNames[j]);
             keyPath = idbindex.keyPath;
-            var index = createIndexSpec(idbindex.name, keyPath, !!idbindex.unique, !!idbindex.multiEntry, false, keyPath && typeof keyPath !== "string");
+            var index = createIndexSpec(idbindex.name, keyPath, !!idbindex.unique, !!idbindex.multiEntry, false, keyPath && typeof keyPath !== "string", false);
             indexes.push(index);
         }
         globalSchema[storeName] = createTableSchema(storeName, primKey, indexes);
@@ -3471,15 +3480,13 @@ function adjustToExistingIndexNames(db, schema, idbtrans) {
         db._hasGetAll = false;
     }
 }
-function parseIndexSyntax(indexes) {
-    var rv = [];
-    indexes.split(',').forEach(function (index) {
+function parseIndexSyntax(primKeyAndIndexes) {
+    return primKeyAndIndexes.split(',').map(function (index, indexNum) {
         index = index.trim();
         var name = index.replace(/([&*]|\+\+)/g, "");
         var keyPath = /^\[/.test(name) ? name.match(/^\[(.*)\]$/)[1].split('+') : name;
-        rv.push(createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath)));
+        return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0);
     });
-    return rv;
 }
 
 var Version =               (function () {
@@ -3543,26 +3550,28 @@ function createVersionConstructor(db) {
 
 var databaseEnumerator;
 function DatabaseEnumerator(indexedDB) {
-    var getDatabaseNamesNative = indexedDB && (indexedDB.getDatabaseNames || indexedDB.webkitGetDatabaseNames);
+    var hasDatabasesNative = indexedDB && typeof indexedDB.databases === 'function';
     var dbNamesTable;
-    if (!getDatabaseNamesNative) {
+    if (!hasDatabasesNative) {
         var db = new Dexie(DBNAMES_DB, { addons: [] });
         db.version(1).stores({ dbnames: 'name' });
         dbNamesTable = db.table('dbnames');
     }
     return {
         getDatabaseNames: function () {
-            return getDatabaseNamesNative ? new DexiePromise(function (resolve, reject) {
-                var req = getDatabaseNamesNative.call(indexedDB);
-                req.onsuccess = function (event) { return resolve(slice(event.target.result, 0)); };
-                req.onerror = eventRejectHandler(reject);
-            }) : dbNamesTable.toCollection().primaryKeys();
+            return hasDatabasesNative
+                ?
+                    DexiePromise.resolve(indexedDB.databases()).then(function (infos) { return infos
+                        .map(function (info) { return info.name; })
+                        .filter(function (name) { return name !== DBNAMES_DB; }); })
+                :
+                    dbNamesTable.toCollection().primaryKeys();
         },
         add: function (name) {
-            return !getDatabaseNamesNative && name !== DBNAMES_DB && dbNamesTable.put({ name: name }).catch(nop);
+            return !hasDatabasesNative && name !== DBNAMES_DB && dbNamesTable.put({ name: name }).catch(nop);
         },
         remove: function (name) {
-            return !getDatabaseNamesNative && name !== DBNAMES_DB && dbNamesTable.delete(name).catch(nop);
+            return !hasDatabasesNative && name !== DBNAMES_DB && dbNamesTable.delete(name).catch(nop);
         }
     };
 }