@microsoft/applicationinsights-offlinechannel-js 0.1.0-nightly3.2402-06

package/dist-es5/Providers/IndexDbHelper.js

@@ -0,0 +1,626 @@
+/*
+ * Application Insights JavaScript SDK - Offline Channel, 0.1.0-nightly3.2402-06
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+
+import dynamicProto from "@microsoft/dynamicproto-js";
+import { getGlobalInst } from "@microsoft/applicationinsights-core-js";
+import { createAsyncPromise, createAsyncRejectedPromise, createAsyncResolvedPromise, createTaskScheduler, doAwait, doAwaitResponse } from "@nevware21/ts-async";
+import { getGlobal, isFunction, isPromiseLike, isString } from "@nevware21/ts-utils";
+import { _DYN_CONTINUE, _DYN_DB_HDL, _DYN_DB_NAME, _DYN_INDEX_OF, _DYN_IS_AVAILABLE, _DYN_KEY_RANGE, _DYN_LENGTH, _DYN_NAME, _DYN_ONERROR, _DYN_ONSUCCESS, _DYN_OPEN_CURSOR, _DYN_OPEN_STORE, _DYN_PUSH, _DYN_REASON, _DYN_REJECTED, _DYN_REMOVE, _DYN_SPLICE, _DYN_SPLIT, _DYN_SUBSTRING, _DYN_THEN, _DYN_TRANSACTION, _DYN_VALUE } from "../__DynamicConstants";
+//TODO: move all const to one file
+//TODO: handle db names
+var IndexedDBNames = ["indexedDB" /*, 'mozIndexedDB', 'webkitIndexedDB', 'msIndexedDb'*/];
+var DbReadWrite = "readwrite";
+var Result = "result";
+var ErrorMessageUnableToOpenDb = "DBError: Unable to open database";
+var ErrorMessageDbUpgradeRequired = "DBError: Database upgrade required";
+var ErrorMessageDbNotOpen = "Database is not open";
+var ErrorMessageDbDoesNotExist = "DBError: Database does not exist";
+var ErrorMessageFailedToDeleteDatabase = "DBError: Failed to delete the database";
+var ErrorMessageDbNotSupported = "DBError: Feature not supported";
+var ErrorMessageFailedToOpenCursor = "DBError: Failed to Open Cursor";
+//window.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction;
+//window.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;
+// By placing this variable here it becomes a global hidden static
+/**
+ * This is used to enforce sequential access to the IndexedDb, so that all operations don't interfere
+ * with each other, this is REALLY useful to ensure that any previous operation has completed before
+ * subsequent operations are completed -- especially for testing using different IndexedDbHelper instances.
+ */
+var _dbContext = [];
+/**
+ * Constructs the IDbContext instance
+ * @param dbName The current database name
+ * @param diagLog The diagnostics logger to use
+ */
+function _getDbContext(dbName, diagLog) {
+    var _a;
+    var dbCtx = null;
+    for (var lp = 0; lp < _dbContext[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+        dbCtx = _dbContext[lp];
+        if (dbCtx[_DYN_NAME /* @min:%2ename */] === dbName) {
+            return dbCtx;
+        }
+    }
+    // Create the global handle for the database
+    dbCtx = (_a = {},
+        _a[_DYN_NAME /* @min:name */] = dbName,
+        _a.sch = createTaskScheduler(createAsyncPromise, "IndexedDbHelper[" + dbName + "]"),
+        _a.dbHdl = [],
+        _a.add = function (db) {
+            dbCtx.dbHdl[_DYN_PUSH /* @min:%2epush */](db);
+            _debugLog(dbName, "- dbOpened (add) -- hdls [" + dbCtx.dbHdl[_DYN_LENGTH /* @min:%2elength */] + "]");
+        },
+        _a[_DYN_REMOVE /* @min:remove */] = function (db) {
+            var hdls = dbCtx[_DYN_DB_HDL /* @min:%2edbHdl */];
+            for (var lp = 0; lp < hdls[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+                if (hdls[lp] === db) {
+                    hdls[_DYN_SPLICE /* @min:%2esplice */](lp, 1);
+                    break;
+                }
+            }
+            _debugLog(dbName, "- dbClosed (remove) -- hdls [" + dbCtx.dbHdl[_DYN_LENGTH /* @min:%2elength */] + "]");
+        },
+        _a.isOpen = function () {
+            return dbCtx.dbHdl[_DYN_LENGTH /* @min:%2elength */] > 0;
+        },
+        _a.openHdl = function () {
+            if (dbCtx.dbHdl[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                return dbCtx[_DYN_DB_HDL /* @min:%2edbHdl */][0];
+            }
+            return null;
+        },
+        _a);
+    _dbContext[_DYN_PUSH /* @min:%2epush */](dbCtx);
+    return dbCtx;
+}
+/**
+ * Schedule an event that will execute the startEvent after all outstanding events are resolved or if any event rejects the optional
+ * rejectEvent will be executed. This is used to ensure that we don't attempt to execute events out of order such as attempting to removed
+ * an event from the indexedDb before the insertion of the event has completed. Only one of the startEvent or unableToStateEvent callbacks
+ * functions will be called.
+ * @param startEvent The event to execute after all outstanding events are complete, may be called synchronously or asynchronously.
+ * @param actionName The name of the action being performed
+ */
+function _scheduleEvent(dbName, actionName, startEvent, evtTimeOut) {
+    // Create or fetch the current scheduler for this dbName
+    var dbCtx = _getDbContext(dbName);
+    return dbCtx.sch.queue(startEvent, actionName, evtTimeOut);
+}
+// TODO: move to common to be able to used by lds
+export function getDbFactory() {
+    var global = getGlobal() || {};
+    var dbFactory = null;
+    if (global) {
+        try {
+            for (var lp = 0; lp < IndexedDBNames[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+                dbFactory = global[IndexedDBNames[lp]];
+                if (dbFactory && isFunction(dbFactory.open)) {
+                    return dbFactory;
+                }
+            }
+        }
+        catch (e) {
+            dbFactory = null;
+        }
+    }
+    return dbFactory;
+}
+function _debugLog(dbName, message) {
+    // Only log if running within test harness
+    if (getGlobalInst("QUnit")) {
+        // tslint:disable-next-line:no-console
+        console && console.log("IndexedDbHelper [" + dbName + "] " + message);
+    }
+}
+/**
+ * Helper method to map an Event rejection to a reject with a message, this is mainly for terminal errors where the
+ * IndexedDb API returns an event which we are going to ignore
+ * @param rejectMessage
+ * @param rejectFunc
+ */
+function _eventReject(dbName, rejectMessage, rejectFunc, evtName) {
+    return function (evt) {
+        rejectFunc(new Error(rejectMessage));
+        _debugLog(dbName, "[" + evtName + "] event rejected");
+    };
+}
+// This helper is designed to allow multiple database implementation
+// The IndexedDB provider will be using only one database with different stores.
+// for each transaction, will open a new connection
+var IndexedDbHelper = /** @class */ (function () {
+    function IndexedDbHelper(diagLog) {
+        var _dbFactory = getDbFactory() || null;
+        dynamicProto(IndexedDbHelper, this, function (_this) {
+            _this[_DYN_IS_AVAILABLE /* @min:%2eisAvailable */] = function () {
+                return !!_dbFactory;
+            };
+            /**
+             * Schedules the opening of the database if not already open
+             */
+            _this.openDb = function (dbName, dbVersion, processFunc, versionChangeFunc) {
+                // Schedule the database to be opened
+                return _scheduleEvent(dbName, "openDb", function (evtName) {
+                    return createAsyncPromise(function (openResolve, openReject) {
+                        var createdNewDb = false;
+                        function _createDbCtx(dbContext, db, dbOpenRequest, isNew, isUpgrade) {
+                            var _a;
+                            var crDbCtx = (_a = {
+                                    db: db
+                                },
+                                _a[_DYN_DB_NAME /* @min:dbName */] = dbName,
+                                _a.dbVersion = dbVersion,
+                                _a.ctx = null,
+                                _a.isNew = isNew,
+                                _a.txn = dbOpenRequest ? dbOpenRequest[_DYN_TRANSACTION /* @min:%2etransaction */] : null // Special case see the versionChangeFunc usage below
+                            ,
+                                _a);
+                            if (!isUpgrade) {
+                                crDbCtx[_DYN_OPEN_STORE /* @min:%2eopenStore */] = function (eventTable, doAction) {
+                                    return _openStore(crDbCtx, eventTable, doAction);
+                                };
+                                crDbCtx[_DYN_OPEN_CURSOR /* @min:%2eopenCursor */] = function (eventTable, query, cursorFunc) {
+                                    return _openCursor(crDbCtx, eventTable, query, cursorFunc);
+                                };
+                            }
+                            return crDbCtx;
+                        }
+                        // TODO: add function to handle version change
+                        function _databaseUpgrade(db, dbOpenRequest, ev) {
+                            _debugLog(dbName, "db upgrade called");
+                            var upgDbCtx = _createDbCtx(null, db, dbOpenRequest, true, true);
+                            if (!versionChangeFunc) {
+                                try {
+                                    dbOpenRequest[_DYN_TRANSACTION /* @min:%2etransaction */] && dbOpenRequest[_DYN_TRANSACTION /* @min:%2etransaction */].abort();
+                                    dbOpenRequest.result && dbOpenRequest.result.close(); // close database to unblock others
+                                }
+                                finally {
+                                    openReject(new Error(ErrorMessageDbUpgradeRequired));
+                                }
+                                return;
+                            }
+                            createdNewDb = true;
+                            doAwaitResponse(versionChangeFunc(upgDbCtx), function (response) {
+                                if (!response[_DYN_REJECTED /* @min:%2erejected */]) {
+                                    // Special case handling, when a DB is first created calling createObjectStore() will
+                                    // automatically start a version change transaction which will block all other transactions
+                                    // from getting created, so we save the auto opened on here for reuse as part of opening the store
+                                    _debugLog(upgDbCtx[_DYN_DB_NAME /* @min:%2edbName */], "on version change success");
+                                    if (!upgDbCtx.txn) {
+                                        upgDbCtx.txn = dbOpenRequest[_DYN_TRANSACTION /* @min:%2etransaction */];
+                                        _debugLog(upgDbCtx[_DYN_DB_NAME /* @min:%2edbName */], "added open request");
+                                    }
+                                }
+                                else {
+                                    // Abort the upgrade event
+                                    try {
+                                        dbOpenRequest[_DYN_TRANSACTION /* @min:%2etransaction */] && dbOpenRequest[_DYN_TRANSACTION /* @min:%2etransaction */].abort();
+                                    }
+                                    finally {
+                                        openReject(response[_DYN_REASON /* @min:%2ereason */]);
+                                    }
+                                }
+                            });
+                        }
+                        function _databaseOpen(db, dbOpenRequest) {
+                            // Save the IDBDatabase handle to the global reference (so we can make sure we can close/delete the Db)
+                            // Also used to track the number of times the DB has been opened
+                            var opDbCtx = _getDbContext(dbName);
+                            opDbCtx.add(db);
+                            db.onabort = function (evt) {
+                                _debugLog(dbName, "onabort -- closing the Db");
+                                opDbCtx[_DYN_REMOVE /* @min:%2eremove */](db);
+                            };
+                            db[_DYN_ONERROR /* @min:%2eonerror */] = function (evt) {
+                                _debugLog(dbName, "onerror -- closing the Db");
+                                opDbCtx[_DYN_REMOVE /* @min:%2eremove */](db);
+                            };
+                            db.onclose = function (evt) {
+                                _debugLog(dbName, "onclose -- closing the Db");
+                                opDbCtx[_DYN_REMOVE /* @min:%2eremove */](db);
+                            };
+                            db.onversionchange = function (evt) {
+                                _debugLog(dbName, "onversionchange -- force closing the Db");
+                                db.close();
+                                opDbCtx[_DYN_REMOVE /* @min:%2eremove */](db);
+                            };
+                            var openDbCtx = null;
+                            var dbHdl = null;
+                            if (opDbCtx.dbHdl[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                                dbHdl = opDbCtx[_DYN_DB_HDL /* @min:%2edbHdl */][0];
+                            }
+                            openDbCtx = _createDbCtx(opDbCtx, dbHdl, dbOpenRequest, createdNewDb);
+                            try {
+                                // Database has been opened
+                                doAwait(processFunc(openDbCtx), openResolve, openReject);
+                            }
+                            catch (e) {
+                                openReject(e);
+                            }
+                        }
+                        var dbCtx = _getDbContext(dbName);
+                        if (_dbFactory == null) {
+                            openReject(new Error("No available storage factory"));
+                        }
+                        else if (dbCtx.isOpen()) {
+                            // Database is already open
+                            var openDbCtx = _createDbCtx(dbCtx, dbCtx.openHdl(), null, false);
+                            doAwait(processFunc(openDbCtx), openResolve, openReject);
+                        }
+                        else {
+                            var dbOpenRequest_1 = _dbFactory.open(dbName, dbVersion);
+                            if (!dbOpenRequest_1) {
+                                throw new Error("missing API"); // in case, some corners case (such as private mode for certain browsers) does not support open db
+                            }
+                            // We can't open the database, possible issues are
+                            // - We are attempting to open the db as a different version but it's already open
+                            dbOpenRequest_1.onblocked = function (evt) {
+                                _debugLog(dbName, "Db Open Blocked event [" + evtName + "] - " + (dbOpenRequest_1.error || ""));
+                                openReject(new Error(ErrorMessageUnableToOpenDb));
+                            };
+                            dbOpenRequest_1[_DYN_ONERROR /* @min:%2eonerror */] = function (evt) {
+                                _debugLog(dbName, "Db Open Error event [" + evtName + "] - " + (dbOpenRequest_1.error || ""));
+                                openReject(new Error(ErrorMessageUnableToOpenDb));
+                            };
+                            dbOpenRequest_1.onupgradeneeded = function (evt) {
+                                _debugLog(dbName, "Db Open Create/Upgrade needed event [" + evtName + "]");
+                                try {
+                                    var db = evt.target[Result] || dbOpenRequest_1.result;
+                                    if (!db) {
+                                        _debugLog(dbName, "no db");
+                                        openReject(new Error(ErrorMessageUnableToOpenDb));
+                                        return;
+                                    }
+                                    _databaseUpgrade(db, dbOpenRequest_1, evt);
+                                }
+                                catch (e) {
+                                    _eventReject(dbName, ErrorMessageUnableToOpenDb, openReject, evtName)(e);
+                                }
+                            };
+                            dbOpenRequest_1[_DYN_ONSUCCESS /* @min:%2eonsuccess */] = function (evt) {
+                                _debugLog(dbName, "Db Open sucess [" + evtName + "]");
+                                var db = evt.target[Result];
+                                if (!db) {
+                                    openReject(new Error(ErrorMessageUnableToOpenDb));
+                                    return;
+                                }
+                                _databaseOpen(db, dbOpenRequest_1);
+                            };
+                        }
+                    });
+                });
+            };
+            _this.closeDb = function (dbName) {
+                // Schedule the close so we don't interrupt an previous scheduled operations
+                _debugLog(dbName, "close db");
+                _scheduleEvent(dbName, "closeDb", function (evtName) {
+                    var dbCtx = _getDbContext(dbName);
+                    var dbHdls = dbCtx[_DYN_DB_HDL /* @min:%2edbHdl */];
+                    var len = dbHdls[_DYN_LENGTH /* @min:%2elength */];
+                    if (len > 0) {
+                        for (var lp = 0; lp < len; lp++) {
+                            // Just call close the db.onclose() event should take care of decrementing and removing the references
+                            dbHdls[lp].close();
+                        }
+                        dbCtx[_DYN_DB_HDL /* @min:%2edbHdl */] = [];
+                    }
+                    return 1;
+                }).catch(function (reason) {
+                    // Handle promise rejection to avoid an unhandled rejection event
+                });
+            };
+            _this.deleteDb = function (dbName) {
+                if (_dbFactory == null) {
+                    return false;
+                }
+                return _scheduleEvent(dbName, "deleteDb", function (evtName) {
+                    // Implicitly close any open db first as this WILL block the deleting
+                    var dbCtx = _getDbContext(dbName);
+                    var dbHdls = dbCtx[_DYN_DB_HDL /* @min:%2edbHdl */];
+                    var len = dbHdls[_DYN_LENGTH /* @min:%2elength */];
+                    if (len > 0) {
+                        _debugLog(dbName, "Db is open [" + len + "] force closing");
+                        for (var lp = 0; lp < len; lp++) {
+                            // Just call close the db.onclose() event should take care of decrementing and removing the references
+                            dbHdls[lp].close();
+                        }
+                        // Clear all of the existing handles as we have forced closed them and for compatibility we can't
+                        // rely on the db onclose event
+                        dbCtx[_DYN_DB_HDL /* @min:%2edbHdl */] = [];
+                    }
+                    return createAsyncPromise(function (deleteResolve, deleteReject) {
+                        // Attempting to delete the Db, only after we wait so that any outstanding operations can finish
+                        setTimeout(function () {
+                            try {
+                                _debugLog(dbName, "[" + evtName + "] starting");
+                                var dbRequest = _dbFactory.deleteDatabase(dbName);
+                                dbRequest[_DYN_ONERROR /* @min:%2eonerror */] = function (evt) {
+                                    deleteReject(new Error(ErrorMessageFailedToDeleteDatabase));
+                                };
+                                dbRequest.onblocked = function (evt) {
+                                    deleteReject(new Error(ErrorMessageFailedToDeleteDatabase));
+                                };
+                                dbRequest.onupgradeneeded = function (evt) {
+                                    deleteReject(new Error(ErrorMessageFailedToDeleteDatabase));
+                                };
+                                dbRequest[_DYN_ONSUCCESS /* @min:%2eonsuccess */] = function (evt) {
+                                    _debugLog(dbName, "[" + evtName + "] complete");
+                                    deleteResolve(true);
+                                };
+                                _debugLog(dbName, "[" + evtName + "] started");
+                            }
+                            catch (e) {
+                                deleteReject(new Error(ErrorMessageFailedToDeleteDatabase + " - " + e));
+                            }
+                        }, 0);
+                    });
+                });
+            };
+            _this.getDbDetails = function (dbName) {
+                return _scheduleEvent(dbName, "getDbDetails", function (evtName) {
+                    if (_dbFactory == null || !_dbFactory.databases) {
+                        // Either IndexedDb is not supported or databases is not supported
+                        return createAsyncRejectedPromise(new Error(ErrorMessageDbNotSupported));
+                    }
+                    return createAsyncPromise(function (databasesResolve, databasesReject) {
+                        // databases() is still experimental, so it's not fully available
+                        // The promise will reject if there is a JS error
+                        var dbPromise = _dbFactory.databases();
+                        dbPromise[_DYN_THEN /* @min:%2ethen */](function (databases) {
+                            for (var lp = 0; lp < databases[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+                                if (databases[lp][_DYN_NAME /* @min:%2ename */] === dbName) {
+                                    databasesResolve(databases[lp]);
+                                    return;
+                                }
+                            }
+                            databasesReject(new Error(ErrorMessageDbDoesNotExist));
+                        }, databasesReject);
+                    });
+                }, 2000);
+            };
+            function _createStoreContext(openDbCtx, eventTable) {
+                // Save the current handle so we close the correct one during the transaction events
+                var dbHdl = openDbCtx.db || null;
+                // Check if the openDb event created a transaction that we should reuse
+                var tx = dbHdl && dbHdl[_DYN_TRANSACTION /* @min:%2etransaction */](eventTable, DbReadWrite);
+                if (tx) {
+                    // The transaction was aborted and therefore the adding of the event failed
+                    tx.onabort = function () {
+                        // add log
+                    };
+                    tx[_DYN_ONERROR /* @min:%2eonerror */] = function () {
+                        // add log
+                    };
+                    // Note we don't listen for the transaction onComplete event as we don't have any value
+                    // to resolve the promise with, we are relying on the doAction() to resolve and the exception
+                    // handling below to ensure we don't deadlock.
+                    tx.oncomplete = function () {
+                        // We need to capture the transaction close event as not all browsers are triggering the db onclose event
+                        _debugLog(openDbCtx[_DYN_DB_NAME /* @min:%2edbName */], "txn.oncomplete");
+                    };
+                    // Ok, so now we have the transaction handling setup lets try and store the event
+                    return {
+                        db: openDbCtx,
+                        store: tx.objectStore(eventTable),
+                        tx: tx,
+                        tbl: eventTable,
+                        openCursor: function (query, processFunc) {
+                            return _openCursor(openDbCtx, eventTable, query, processFunc);
+                        },
+                        newTransaction: function (doAction) {
+                            return _openStore(openDbCtx, eventTable, doAction);
+                        }
+                    };
+                }
+                return null;
+            }
+            /**
+             * Opens the specific store for the database
+             * @param openDbCtx
+             * @param eventTable
+             * @param doAction
+             */
+            function _openStore(openDbCtx, eventTable, doAction) {
+                // While the open DB promise may have been resolved we still might not have opened the DB (This is to ensure that
+                // non-critical failures don't cause event execution out of order)
+                if (!openDbCtx || !openDbCtx.db) {
+                    // Database is not open so pass the only option is to resolve the event so it's passed onto the next on the event to the next chain
+                    return createAsyncRejectedPromise(new Error(ErrorMessageDbNotOpen));
+                }
+                try {
+                    // Perform the transaction action
+                    var result = doAction(_createStoreContext(openDbCtx, eventTable));
+                    if (isPromiseLike(result)) {
+                        return result;
+                    }
+                    return createAsyncResolvedPromise(result);
+                }
+                catch (e) {
+                    return createAsyncRejectedPromise(e);
+                }
+            }
+            function _openCursor(openDbCtx, eventTable, query, processFunc) {
+                // While the open DB promise may have been resolved we still might not have opened the DB (This is to ensure that
+                // non-critical failures don't cause event execution out of order)
+                if (!openDbCtx || !openDbCtx.db) {
+                    // Database is not open so pass the only option is to resolve the event so it's passed onto the next on the event to the next chain
+                    return createAsyncRejectedPromise(new Error(ErrorMessageDbNotOpen));
+                }
+                var simpleQuery = null;
+                if (query && isString(query)) {
+                    simpleQuery = new SimpleQuery(query);
+                }
+                else if (query && query.isMatch) { // simple check to make sure this is a IIndexedDbSimpleQuery
+                    simpleQuery = query;
+                }
+                return createAsyncPromise(function (openCursorResolve, openCursorReject) {
+                    var values = [];
+                    var cursorRequest = null;
+                    var queryKeyRange = null;
+                    if (simpleQuery && simpleQuery[_DYN_KEY_RANGE /* @min:%2ekeyRange */]) {
+                        queryKeyRange = simpleQuery[_DYN_KEY_RANGE /* @min:%2ekeyRange */]();
+                    }
+                    var storeCtx = _createStoreContext(openDbCtx, eventTable);
+                    if (queryKeyRange) {
+                        cursorRequest = storeCtx.store[_DYN_OPEN_CURSOR /* @min:%2eopenCursor */](queryKeyRange);
+                    }
+                    else {
+                        cursorRequest = storeCtx.store[_DYN_OPEN_CURSOR /* @min:%2eopenCursor */]();
+                    }
+                    cursorRequest[_DYN_ONERROR /* @min:%2eonerror */] = _eventReject(storeCtx.db[_DYN_DB_NAME /* @min:%2edbName */], ErrorMessageFailedToOpenCursor, openCursorReject, "openCursor");
+                    cursorRequest[_DYN_ONSUCCESS /* @min:%2eonsuccess */] = function (evt) {
+                        var _a;
+                        // Cursor was open/next iteration
+                        var cursor = evt.target[Result];
+                        if (!cursor) {
+                            // This occurs when we get to the end of the cursor iteration
+                            openCursorResolve(values);
+                            return;
+                        }
+                        var processCursorState = (_a = {
+                                store: storeCtx,
+                                cursor: cursor
+                            },
+                            _a[_DYN_CONTINUE /* @min:continue */] = function () {
+                                cursor[_DYN_CONTINUE /* @min:%2econtinue */]();
+                            },
+                            _a.done = function () {
+                                openCursorResolve(values);
+                            } // Stops the cursor processing
+                        ,
+                            _a);
+                        var value = cursor[_DYN_VALUE /* @min:%2evalue */];
+                        if (simpleQuery && !simpleQuery.isMatch(value)) {
+                            processCursorState[_DYN_CONTINUE /* @min:%2econtinue */]();
+                            return;
+                        }
+                        if (processFunc) {
+                            try {
+                                switch (processFunc(processCursorState, value, values)) {
+                                    case 2 /* CursorProcessResult.Complete */:
+                                        openCursorResolve(values);
+                                        break;
+                                    case 1 /* CursorProcessResult.Waiting */:
+                                        // The process method now controls whether th
+                                        break;
+                                    case 0 /* CursorProcessResult.Continue */:
+                                    default:
+                                        processCursorState[_DYN_CONTINUE /* @min:%2econtinue */]();
+                                        break;
+                                }
+                            }
+                            catch (ex) {
+                                // Make sure the reject the promise if the processFunc callback throws unexpectable
+                                openCursorReject(ex);
+                            }
+                        }
+                        else {
+                            values[_DYN_PUSH /* @min:%2epush */](value);
+                            processCursorState[_DYN_CONTINUE /* @min:%2econtinue */]();
+                        }
+                    };
+                });
+            }
+        });
+    }
+// Removed Stub for IndexedDbHelper.prototype.isAvailable.
+// Removed Stub for IndexedDbHelper.prototype.openDb.
+// Removed Stub for IndexedDbHelper.prototype.closeDb.
+// Removed Stub for IndexedDbHelper.prototype.deleteDb.
+// Removed Stub for IndexedDbHelper.prototype.getDbDetails.
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    IndexedDbHelper.__ieDyn=1;
+
+    return IndexedDbHelper;
+}());
+export { IndexedDbHelper };
+/**
+ * A simple query interface to provide a simple cursor query (IDBKeyRange) key range and matching.
+ * Used by the openCursor() method.
+ */
+var SimpleQuery = /** @class */ (function () {
+    function SimpleQuery(theQuery) {
+        var _queryCols = [];
+        var _keyRange = null;
+        dynamicProto(SimpleQuery, this, function (_this) {
+            _this[_DYN_KEY_RANGE /* @min:%2ekeyRange */] = function () {
+                return _keyRange;
+            };
+            _this.parseQuery = function (query) {
+                _queryCols = [];
+                if (query) {
+                    var items = query[_DYN_SPLIT /* @min:%2esplit */](";");
+                    for (var lp = 0; lp < items[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+                        var item = items[lp];
+                        var idx = item[_DYN_INDEX_OF /* @min:%2eindexOf */]("=");
+                        if (idx !== -1) {
+                            var key = item[_DYN_SUBSTRING /* @min:%2esubstring */](0, idx);
+                            var value = item[_DYN_SUBSTRING /* @min:%2esubstring */](idx + 1);
+                            if (key[_DYN_INDEX_OF /* @min:%2eindexOf */]("#") === 0) {
+                                key = key[_DYN_SUBSTRING /* @min:%2esubstring */](1);
+                                if (!_keyRange) {
+                                    _keyRange = IDBKeyRange.bound(value, value + "\uffff");
+                                }
+                            }
+                            _this.startsWith(key, value);
+                        }
+                    }
+                }
+            };
+            _this.startsWith = function (columnName, value) {
+                var _a;
+                _queryCols[_DYN_PUSH /* @min:%2epush */]((_a = {},
+                    _a[_DYN_NAME /* @min:name */] = columnName,
+                    _a[_DYN_VALUE /* @min:value */] = value,
+                    _a.type = 0 /* ValueQueryType.StartsWith */,
+                    _a));
+            };
+            _this.contains = function (columnName, value) {
+                var _a;
+                _queryCols[_DYN_PUSH /* @min:%2epush */]((_a = {},
+                    _a[_DYN_NAME /* @min:name */] = columnName,
+                    _a[_DYN_VALUE /* @min:value */] = value,
+                    _a.type = 1 /* ValueQueryType.Contains */,
+                    _a));
+            };
+            _this.isMatch = function (value) {
+                // No query restriction so everything matches
+                if (!_queryCols || _queryCols[_DYN_LENGTH /* @min:%2elength */] === 0) {
+                    return true;
+                }
+                if (!value) {
+                    return false;
+                }
+                for (var lp = 0; lp < _queryCols[_DYN_LENGTH /* @min:%2elength */]; lp++) {
+                    var query = _queryCols[lp];
+                    var chkValue = value[query.name];
+                    if (chkValue) {
+                        if (query.type === 0 /* ValueQueryType.StartsWith */) {
+                            if (chkValue.indexOf(query[_DYN_VALUE /* @min:%2evalue */]) !== 0) {
+                                return false;
+                            }
+                        }
+                        else if (query.type === 1 /* ValueQueryType.Contains */) {
+                            if (chkValue.indexOf(query[_DYN_VALUE /* @min:%2evalue */]) === -1) {
+                                return false;
+                            }
+                        }
+                    }
+                }
+                return true;
+            };
+            if (theQuery) {
+                _this.parseQuery(theQuery);
+            }
+        });
+    }
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    SimpleQuery.__ieDyn=1;
+
+    return SimpleQuery;
+}());
+//# sourceMappingURL=IndexDbHelper.js.map