1014 lines
37 KiB
JavaScript
1014 lines
37 KiB
JavaScript
(function (global, factory) {
|
|
if (typeof define === "function" && define.amd) {
|
|
define('asyncStorage', ['module', 'exports', '../utils/isIndexedDBValid', '../utils/createBlob', '../utils/idb', '../utils/promise', '../utils/executeCallback', '../utils/executeTwoCallbacks', '../utils/normalizeKey', '../utils/getCallback'], factory);
|
|
} else if (typeof exports !== "undefined") {
|
|
factory(module, exports, require('../utils/isIndexedDBValid'), require('../utils/createBlob'), require('../utils/idb'), require('../utils/promise'), require('../utils/executeCallback'), require('../utils/executeTwoCallbacks'), require('../utils/normalizeKey'), require('../utils/getCallback'));
|
|
} else {
|
|
var mod = {
|
|
exports: {}
|
|
};
|
|
factory(mod, mod.exports, global.isIndexedDBValid, global.createBlob, global.idb, global.promise, global.executeCallback, global.executeTwoCallbacks, global.normalizeKey, global.getCallback);
|
|
global.asyncStorage = mod.exports;
|
|
}
|
|
})(this, function (module, exports, _isIndexedDBValid, _createBlob, _idb, _promise, _executeCallback, _executeTwoCallbacks, _normalizeKey, _getCallback) {
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _isIndexedDBValid2 = _interopRequireDefault(_isIndexedDBValid);
|
|
|
|
var _createBlob2 = _interopRequireDefault(_createBlob);
|
|
|
|
var _idb2 = _interopRequireDefault(_idb);
|
|
|
|
var _promise2 = _interopRequireDefault(_promise);
|
|
|
|
var _executeCallback2 = _interopRequireDefault(_executeCallback);
|
|
|
|
var _executeTwoCallbacks2 = _interopRequireDefault(_executeTwoCallbacks);
|
|
|
|
var _normalizeKey2 = _interopRequireDefault(_normalizeKey);
|
|
|
|
var _getCallback2 = _interopRequireDefault(_getCallback);
|
|
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : {
|
|
default: obj
|
|
};
|
|
}
|
|
|
|
// Some code originally from async_storage.js in
|
|
// [Gaia](https://github.com/mozilla-b2g/gaia).
|
|
|
|
var DETECT_BLOB_SUPPORT_STORE = 'local-forage-detect-blob-support';
|
|
var supportsBlobs = void 0;
|
|
var dbContexts = {};
|
|
var toString = Object.prototype.toString;
|
|
|
|
// Transaction Modes
|
|
var READ_ONLY = 'readonly';
|
|
var READ_WRITE = 'readwrite';
|
|
|
|
// Transform a binary string to an array buffer, because otherwise
|
|
// weird stuff happens when you try to work with the binary string directly.
|
|
// It is known.
|
|
// From http://stackoverflow.com/questions/14967647/ (continues on next line)
|
|
// encode-decode-image-with-base64-breaks-image (2013-04-21)
|
|
function _binStringToArrayBuffer(bin) {
|
|
var length = bin.length;
|
|
var buf = new ArrayBuffer(length);
|
|
var arr = new Uint8Array(buf);
|
|
for (var i = 0; i < length; i++) {
|
|
arr[i] = bin.charCodeAt(i);
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
//
|
|
// Blobs are not supported in all versions of IndexedDB, notably
|
|
// Chrome <37 and Android <5. In those versions, storing a blob will throw.
|
|
//
|
|
// Various other blob bugs exist in Chrome v37-42 (inclusive).
|
|
// Detecting them is expensive and confusing to users, and Chrome 37-42
|
|
// is at very low usage worldwide, so we do a hacky userAgent check instead.
|
|
//
|
|
// content-type bug: https://code.google.com/p/chromium/issues/detail?id=408120
|
|
// 404 bug: https://code.google.com/p/chromium/issues/detail?id=447916
|
|
// FileReader bug: https://code.google.com/p/chromium/issues/detail?id=447836
|
|
//
|
|
// Code borrowed from PouchDB. See:
|
|
// https://github.com/pouchdb/pouchdb/blob/master/packages/node_modules/pouchdb-adapter-idb/src/blobSupport.js
|
|
//
|
|
function _checkBlobSupportWithoutCaching(idb) {
|
|
return new _promise2.default(function (resolve) {
|
|
var txn = idb.transaction(DETECT_BLOB_SUPPORT_STORE, READ_WRITE);
|
|
var blob = (0, _createBlob2.default)(['']);
|
|
txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob, 'key');
|
|
|
|
txn.onabort = function (e) {
|
|
// If the transaction aborts now its due to not being able to
|
|
// write to the database, likely due to the disk being full
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
resolve(false);
|
|
};
|
|
|
|
txn.oncomplete = function () {
|
|
var matchedChrome = navigator.userAgent.match(/Chrome\/(\d+)/);
|
|
var matchedEdge = navigator.userAgent.match(/Edge\//);
|
|
// MS Edge pretends to be Chrome 42:
|
|
// https://msdn.microsoft.com/en-us/library/hh869301%28v=vs.85%29.aspx
|
|
resolve(matchedEdge || !matchedChrome || parseInt(matchedChrome[1], 10) >= 43);
|
|
};
|
|
}).catch(function () {
|
|
return false; // error, so assume unsupported
|
|
});
|
|
}
|
|
|
|
function _checkBlobSupport(idb) {
|
|
if (typeof supportsBlobs === 'boolean') {
|
|
return _promise2.default.resolve(supportsBlobs);
|
|
}
|
|
return _checkBlobSupportWithoutCaching(idb).then(function (value) {
|
|
supportsBlobs = value;
|
|
return supportsBlobs;
|
|
});
|
|
}
|
|
|
|
function _deferReadiness(dbInfo) {
|
|
var dbContext = dbContexts[dbInfo.name];
|
|
|
|
// Create a deferred object representing the current database operation.
|
|
var deferredOperation = {};
|
|
|
|
deferredOperation.promise = new _promise2.default(function (resolve, reject) {
|
|
deferredOperation.resolve = resolve;
|
|
deferredOperation.reject = reject;
|
|
});
|
|
|
|
// Enqueue the deferred operation.
|
|
dbContext.deferredOperations.push(deferredOperation);
|
|
|
|
// Chain its promise to the database readiness.
|
|
if (!dbContext.dbReady) {
|
|
dbContext.dbReady = deferredOperation.promise;
|
|
} else {
|
|
dbContext.dbReady = dbContext.dbReady.then(function () {
|
|
return deferredOperation.promise;
|
|
});
|
|
}
|
|
}
|
|
|
|
function _advanceReadiness(dbInfo) {
|
|
var dbContext = dbContexts[dbInfo.name];
|
|
|
|
// Dequeue a deferred operation.
|
|
var deferredOperation = dbContext.deferredOperations.pop();
|
|
|
|
// Resolve its promise (which is part of the database readiness
|
|
// chain of promises).
|
|
if (deferredOperation) {
|
|
deferredOperation.resolve();
|
|
return deferredOperation.promise;
|
|
}
|
|
}
|
|
|
|
function _rejectReadiness(dbInfo, err) {
|
|
var dbContext = dbContexts[dbInfo.name];
|
|
|
|
// Dequeue a deferred operation.
|
|
var deferredOperation = dbContext.deferredOperations.pop();
|
|
|
|
// Reject its promise (which is part of the database readiness
|
|
// chain of promises).
|
|
if (deferredOperation) {
|
|
deferredOperation.reject(err);
|
|
return deferredOperation.promise;
|
|
}
|
|
}
|
|
|
|
function _getConnection(dbInfo, upgradeNeeded) {
|
|
return new _promise2.default(function (resolve, reject) {
|
|
dbContexts[dbInfo.name] = dbContexts[dbInfo.name] || createDbContext();
|
|
|
|
if (dbInfo.db) {
|
|
if (upgradeNeeded) {
|
|
_deferReadiness(dbInfo);
|
|
dbInfo.db.close();
|
|
} else {
|
|
return resolve(dbInfo.db);
|
|
}
|
|
}
|
|
|
|
var dbArgs = [dbInfo.name];
|
|
|
|
if (upgradeNeeded) {
|
|
dbArgs.push(dbInfo.version);
|
|
}
|
|
|
|
var openreq = _idb2.default.open.apply(_idb2.default, dbArgs);
|
|
|
|
if (upgradeNeeded) {
|
|
openreq.onupgradeneeded = function (e) {
|
|
var db = openreq.result;
|
|
try {
|
|
db.createObjectStore(dbInfo.storeName);
|
|
if (e.oldVersion <= 1) {
|
|
// Added when support for blob shims was added
|
|
db.createObjectStore(DETECT_BLOB_SUPPORT_STORE);
|
|
}
|
|
} catch (ex) {
|
|
if (ex.name === 'ConstraintError') {
|
|
console.warn('The database "' + dbInfo.name + '"' + ' has been upgraded from version ' + e.oldVersion + ' to version ' + e.newVersion + ', but the storage "' + dbInfo.storeName + '" already exists.');
|
|
} else {
|
|
throw ex;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
openreq.onerror = function (e) {
|
|
e.preventDefault();
|
|
reject(openreq.error);
|
|
};
|
|
|
|
openreq.onsuccess = function () {
|
|
var db = openreq.result;
|
|
db.onversionchange = function (e) {
|
|
// Triggered when the database is modified (e.g. adding an objectStore) or
|
|
// deleted (even when initiated by other sessions in different tabs).
|
|
// Closing the connection here prevents those operations from being blocked.
|
|
// If the database is accessed again later by this instance, the connection
|
|
// will be reopened or the database recreated as needed.
|
|
e.target.close();
|
|
};
|
|
resolve(db);
|
|
_advanceReadiness(dbInfo);
|
|
};
|
|
});
|
|
}
|
|
|
|
function _getOriginalConnection(dbInfo) {
|
|
return _getConnection(dbInfo, false);
|
|
}
|
|
|
|
function _getUpgradedConnection(dbInfo) {
|
|
return _getConnection(dbInfo, true);
|
|
}
|
|
|
|
function _isUpgradeNeeded(dbInfo, defaultVersion) {
|
|
if (!dbInfo.db) {
|
|
return true;
|
|
}
|
|
|
|
var isNewStore = !dbInfo.db.objectStoreNames.contains(dbInfo.storeName);
|
|
var isDowngrade = dbInfo.version < dbInfo.db.version;
|
|
var isUpgrade = dbInfo.version > dbInfo.db.version;
|
|
|
|
if (isDowngrade) {
|
|
// If the version is not the default one
|
|
// then warn for impossible downgrade.
|
|
if (dbInfo.version !== defaultVersion) {
|
|
console.warn('The database "' + dbInfo.name + '"' + " can't be downgraded from version " + dbInfo.db.version + ' to version ' + dbInfo.version + '.');
|
|
}
|
|
// Align the versions to prevent errors.
|
|
dbInfo.version = dbInfo.db.version;
|
|
}
|
|
|
|
if (isUpgrade || isNewStore) {
|
|
// If the store is new then increment the version (if needed).
|
|
// This will trigger an "upgradeneeded" event which is required
|
|
// for creating a store.
|
|
if (isNewStore) {
|
|
var incVersion = dbInfo.db.version + 1;
|
|
if (incVersion > dbInfo.version) {
|
|
dbInfo.version = incVersion;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// encode a blob for indexeddb engines that don't support blobs
|
|
function _encodeBlob(blob) {
|
|
return new _promise2.default(function (resolve, reject) {
|
|
var reader = new FileReader();
|
|
reader.onerror = reject;
|
|
reader.onloadend = function (e) {
|
|
var base64 = btoa(e.target.result || '');
|
|
resolve({
|
|
__local_forage_encoded_blob: true,
|
|
data: base64,
|
|
type: blob.type
|
|
});
|
|
};
|
|
reader.readAsBinaryString(blob);
|
|
});
|
|
}
|
|
|
|
// decode an encoded blob
|
|
function _decodeBlob(encodedBlob) {
|
|
var arrayBuff = _binStringToArrayBuffer(atob(encodedBlob.data));
|
|
return (0, _createBlob2.default)([arrayBuff], { type: encodedBlob.type });
|
|
}
|
|
|
|
// is this one of our fancy encoded blobs?
|
|
function _isEncodedBlob(value) {
|
|
return value && value.__local_forage_encoded_blob;
|
|
}
|
|
|
|
// Specialize the default `ready()` function by making it dependent
|
|
// on the current database operations. Thus, the driver will be actually
|
|
// ready when it's been initialized (default) *and* there are no pending
|
|
// operations on the database (initiated by some other instances).
|
|
function _fullyReady(callback) {
|
|
var self = this;
|
|
|
|
var promise = self._initReady().then(function () {
|
|
var dbContext = dbContexts[self._dbInfo.name];
|
|
|
|
if (dbContext && dbContext.dbReady) {
|
|
return dbContext.dbReady;
|
|
}
|
|
});
|
|
|
|
(0, _executeTwoCallbacks2.default)(promise, callback, callback);
|
|
return promise;
|
|
}
|
|
|
|
// Try to establish a new db connection to replace the
|
|
// current one which is broken (i.e. experiencing
|
|
// InvalidStateError while creating a transaction).
|
|
function _tryReconnect(dbInfo) {
|
|
_deferReadiness(dbInfo);
|
|
|
|
var dbContext = dbContexts[dbInfo.name];
|
|
var forages = dbContext.forages;
|
|
|
|
for (var i = 0; i < forages.length; i++) {
|
|
var forage = forages[i];
|
|
if (forage._dbInfo.db) {
|
|
forage._dbInfo.db.close();
|
|
forage._dbInfo.db = null;
|
|
}
|
|
}
|
|
dbInfo.db = null;
|
|
|
|
return _getOriginalConnection(dbInfo).then(function (db) {
|
|
dbInfo.db = db;
|
|
if (_isUpgradeNeeded(dbInfo)) {
|
|
// Reopen the database for upgrading.
|
|
return _getUpgradedConnection(dbInfo);
|
|
}
|
|
return db;
|
|
}).then(function (db) {
|
|
// store the latest db reference
|
|
// in case the db was upgraded
|
|
dbInfo.db = dbContext.db = db;
|
|
for (var i = 0; i < forages.length; i++) {
|
|
forages[i]._dbInfo.db = db;
|
|
}
|
|
}).catch(function (err) {
|
|
_rejectReadiness(dbInfo, err);
|
|
throw err;
|
|
});
|
|
}
|
|
|
|
// FF doesn't like Promises (micro-tasks) and IDDB store operations,
|
|
// so we have to do it with callbacks
|
|
function createTransaction(dbInfo, mode, callback, retries) {
|
|
if (retries === undefined) {
|
|
retries = 1;
|
|
}
|
|
|
|
try {
|
|
var tx = dbInfo.db.transaction(dbInfo.storeName, mode);
|
|
callback(null, tx);
|
|
} catch (err) {
|
|
if (retries > 0 && (!dbInfo.db || err.name === 'InvalidStateError' || err.name === 'NotFoundError')) {
|
|
return _promise2.default.resolve().then(function () {
|
|
if (!dbInfo.db || err.name === 'NotFoundError' && !dbInfo.db.objectStoreNames.contains(dbInfo.storeName) && dbInfo.version <= dbInfo.db.version) {
|
|
// increase the db version, to create the new ObjectStore
|
|
if (dbInfo.db) {
|
|
dbInfo.version = dbInfo.db.version + 1;
|
|
}
|
|
// Reopen the database for upgrading.
|
|
return _getUpgradedConnection(dbInfo);
|
|
}
|
|
}).then(function () {
|
|
return _tryReconnect(dbInfo).then(function () {
|
|
createTransaction(dbInfo, mode, callback, retries - 1);
|
|
});
|
|
}).catch(callback);
|
|
}
|
|
|
|
callback(err);
|
|
}
|
|
}
|
|
|
|
function createDbContext() {
|
|
return {
|
|
// Running localForages sharing a database.
|
|
forages: [],
|
|
// Shared database.
|
|
db: null,
|
|
// Database readiness (promise).
|
|
dbReady: null,
|
|
// Deferred operations on the database.
|
|
deferredOperations: []
|
|
};
|
|
}
|
|
|
|
// Open the IndexedDB database (automatically creates one if one didn't
|
|
// previously exist), using any options set in the config.
|
|
function _initStorage(options) {
|
|
var self = this;
|
|
var dbInfo = {
|
|
db: null
|
|
};
|
|
|
|
if (options) {
|
|
for (var i in options) {
|
|
dbInfo[i] = options[i];
|
|
}
|
|
}
|
|
|
|
// Get the current context of the database;
|
|
var dbContext = dbContexts[dbInfo.name];
|
|
|
|
// ...or create a new context.
|
|
if (!dbContext) {
|
|
dbContext = createDbContext();
|
|
// Register the new context in the global container.
|
|
dbContexts[dbInfo.name] = dbContext;
|
|
}
|
|
|
|
// Register itself as a running localForage in the current context.
|
|
dbContext.forages.push(self);
|
|
|
|
// Replace the default `ready()` function with the specialized one.
|
|
if (!self._initReady) {
|
|
self._initReady = self.ready;
|
|
self.ready = _fullyReady;
|
|
}
|
|
|
|
// Create an array of initialization states of the related localForages.
|
|
var initPromises = [];
|
|
|
|
function ignoreErrors() {
|
|
// Don't handle errors here,
|
|
// just makes sure related localForages aren't pending.
|
|
return _promise2.default.resolve();
|
|
}
|
|
|
|
for (var j = 0; j < dbContext.forages.length; j++) {
|
|
var forage = dbContext.forages[j];
|
|
if (forage !== self) {
|
|
// Don't wait for itself...
|
|
initPromises.push(forage._initReady().catch(ignoreErrors));
|
|
}
|
|
}
|
|
|
|
// Take a snapshot of the related localForages.
|
|
var forages = dbContext.forages.slice(0);
|
|
|
|
// Initialize the connection process only when
|
|
// all the related localForages aren't pending.
|
|
return _promise2.default.all(initPromises).then(function () {
|
|
dbInfo.db = dbContext.db;
|
|
// Get the connection or open a new one without upgrade.
|
|
return _getOriginalConnection(dbInfo);
|
|
}).then(function (db) {
|
|
dbInfo.db = db;
|
|
if (_isUpgradeNeeded(dbInfo, self._defaultConfig.version)) {
|
|
// Reopen the database for upgrading.
|
|
return _getUpgradedConnection(dbInfo);
|
|
}
|
|
return db;
|
|
}).then(function (db) {
|
|
dbInfo.db = dbContext.db = db;
|
|
self._dbInfo = dbInfo;
|
|
// Share the final connection amongst related localForages.
|
|
for (var k = 0; k < forages.length; k++) {
|
|
var forage = forages[k];
|
|
if (forage !== self) {
|
|
// Self is already up-to-date.
|
|
forage._dbInfo.db = dbInfo.db;
|
|
forage._dbInfo.version = dbInfo.version;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
function getItem(key, callback) {
|
|
var self = this;
|
|
|
|
key = (0, _normalizeKey2.default)(key);
|
|
|
|
var promise = new _promise2.default(function (resolve, reject) {
|
|
self.ready().then(function () {
|
|
createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
|
|
if (err) {
|
|
return reject(err);
|
|
}
|
|
|
|
try {
|
|
var store = transaction.objectStore(self._dbInfo.storeName);
|
|
var req = store.get(key);
|
|
|
|
req.onsuccess = function () {
|
|
var value = req.result;
|
|
if (value === undefined) {
|
|
value = null;
|
|
}
|
|
if (_isEncodedBlob(value)) {
|
|
value = _decodeBlob(value);
|
|
}
|
|
resolve(value);
|
|
};
|
|
|
|
req.onerror = function () {
|
|
reject(req.error);
|
|
};
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
}).catch(reject);
|
|
});
|
|
|
|
(0, _executeCallback2.default)(promise, callback);
|
|
return promise;
|
|
}
|
|
|
|
// Iterate over all items stored in database.
|
|
function iterate(iterator, callback) {
|
|
var self = this;
|
|
|
|
var promise = new _promise2.default(function (resolve, reject) {
|
|
self.ready().then(function () {
|
|
createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
|
|
if (err) {
|
|
return reject(err);
|
|
}
|
|
|
|
try {
|
|
var store = transaction.objectStore(self._dbInfo.storeName);
|
|
var req = store.openCursor();
|
|
var iterationNumber = 1;
|
|
|
|
req.onsuccess = function () {
|
|
var cursor = req.result;
|
|
|
|
if (cursor) {
|
|
var value = cursor.value;
|
|
if (_isEncodedBlob(value)) {
|
|
value = _decodeBlob(value);
|
|
}
|
|
var result = iterator(value, cursor.key, iterationNumber++);
|
|
|
|
// when the iterator callback returns any
|
|
// (non-`undefined`) value, then we stop
|
|
// the iteration immediately
|
|
if (result !== void 0) {
|
|
resolve(result);
|
|
} else {
|
|
cursor.continue();
|
|
}
|
|
} else {
|
|
resolve();
|
|
}
|
|
};
|
|
|
|
req.onerror = function () {
|
|
reject(req.error);
|
|
};
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
}).catch(reject);
|
|
});
|
|
|
|
(0, _executeCallback2.default)(promise, callback);
|
|
|
|
return promise;
|
|
}
|
|
|
|
function setItem(key, value, callback) {
|
|
var self = this;
|
|
|
|
key = (0, _normalizeKey2.default)(key);
|
|
|
|
var promise = new _promise2.default(function (resolve, reject) {
|
|
var dbInfo;
|
|
self.ready().then(function () {
|
|
dbInfo = self._dbInfo;
|
|
if (toString.call(value) === '[object Blob]') {
|
|
return _checkBlobSupport(dbInfo.db).then(function (blobSupport) {
|
|
if (blobSupport) {
|
|
return value;
|
|
}
|
|
return _encodeBlob(value);
|
|
});
|
|
}
|
|
return value;
|
|
}).then(function (value) {
|
|
createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {
|
|
if (err) {
|
|
return reject(err);
|
|
}
|
|
|
|
try {
|
|
var store = transaction.objectStore(self._dbInfo.storeName);
|
|
|
|
// The reason we don't _save_ null is because IE 10 does
|
|
// not support saving the `null` type in IndexedDB. How
|
|
// ironic, given the bug below!
|
|
// See: https://github.com/mozilla/localForage/issues/161
|
|
if (value === null) {
|
|
value = undefined;
|
|
}
|
|
|
|
var req = store.put(value, key);
|
|
|
|
transaction.oncomplete = function () {
|
|
// Cast to undefined so the value passed to
|
|
// callback/promise is the same as what one would get out
|
|
// of `getItem()` later. This leads to some weirdness
|
|
// (setItem('foo', undefined) will return `null`), but
|
|
// it's not my fault localStorage is our baseline and that
|
|
// it's weird.
|
|
if (value === undefined) {
|
|
value = null;
|
|
}
|
|
|
|
resolve(value);
|
|
};
|
|
transaction.onabort = transaction.onerror = function () {
|
|
var err = req.error ? req.error : req.transaction.error;
|
|
reject(err);
|
|
};
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
}).catch(reject);
|
|
});
|
|
|
|
(0, _executeCallback2.default)(promise, callback);
|
|
return promise;
|
|
}
|
|
|
|
function removeItem(key, callback) {
|
|
var self = this;
|
|
|
|
key = (0, _normalizeKey2.default)(key);
|
|
|
|
var promise = new _promise2.default(function (resolve, reject) {
|
|
self.ready().then(function () {
|
|
createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {
|
|
if (err) {
|
|
return reject(err);
|
|
}
|
|
|
|
try {
|
|
var store = transaction.objectStore(self._dbInfo.storeName);
|
|
// We use a Grunt task to make this safe for IE and some
|
|
// versions of Android (including those used by Cordova).
|
|
// Normally IE won't like `.delete()` and will insist on
|
|
// using `['delete']()`, but we have a build step that
|
|
// fixes this for us now.
|
|
var req = store.delete(key);
|
|
transaction.oncomplete = function () {
|
|
resolve();
|
|
};
|
|
|
|
transaction.onerror = function () {
|
|
reject(req.error);
|
|
};
|
|
|
|
// The request will be also be aborted if we've exceeded our storage
|
|
// space.
|
|
transaction.onabort = function () {
|
|
var err = req.error ? req.error : req.transaction.error;
|
|
reject(err);
|
|
};
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
}).catch(reject);
|
|
});
|
|
|
|
(0, _executeCallback2.default)(promise, callback);
|
|
return promise;
|
|
}
|
|
|
|
function clear(callback) {
|
|
var self = this;
|
|
|
|
var promise = new _promise2.default(function (resolve, reject) {
|
|
self.ready().then(function () {
|
|
createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {
|
|
if (err) {
|
|
return reject(err);
|
|
}
|
|
|
|
try {
|
|
var store = transaction.objectStore(self._dbInfo.storeName);
|
|
var req = store.clear();
|
|
|
|
transaction.oncomplete = function () {
|
|
resolve();
|
|
};
|
|
|
|
transaction.onabort = transaction.onerror = function () {
|
|
var err = req.error ? req.error : req.transaction.error;
|
|
reject(err);
|
|
};
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
}).catch(reject);
|
|
});
|
|
|
|
(0, _executeCallback2.default)(promise, callback);
|
|
return promise;
|
|
}
|
|
|
|
function length(callback) {
|
|
var self = this;
|
|
|
|
var promise = new _promise2.default(function (resolve, reject) {
|
|
self.ready().then(function () {
|
|
createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
|
|
if (err) {
|
|
return reject(err);
|
|
}
|
|
|
|
try {
|
|
var store = transaction.objectStore(self._dbInfo.storeName);
|
|
var req = store.count();
|
|
|
|
req.onsuccess = function () {
|
|
resolve(req.result);
|
|
};
|
|
|
|
req.onerror = function () {
|
|
reject(req.error);
|
|
};
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
}).catch(reject);
|
|
});
|
|
|
|
(0, _executeCallback2.default)(promise, callback);
|
|
return promise;
|
|
}
|
|
|
|
function key(n, callback) {
|
|
var self = this;
|
|
|
|
var promise = new _promise2.default(function (resolve, reject) {
|
|
if (n < 0) {
|
|
resolve(null);
|
|
|
|
return;
|
|
}
|
|
|
|
self.ready().then(function () {
|
|
createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
|
|
if (err) {
|
|
return reject(err);
|
|
}
|
|
|
|
try {
|
|
var store = transaction.objectStore(self._dbInfo.storeName);
|
|
var advanced = false;
|
|
var req = store.openKeyCursor();
|
|
|
|
req.onsuccess = function () {
|
|
var cursor = req.result;
|
|
if (!cursor) {
|
|
// this means there weren't enough keys
|
|
resolve(null);
|
|
|
|
return;
|
|
}
|
|
|
|
if (n === 0) {
|
|
// We have the first key, return it if that's what they
|
|
// wanted.
|
|
resolve(cursor.key);
|
|
} else {
|
|
if (!advanced) {
|
|
// Otherwise, ask the cursor to skip ahead n
|
|
// records.
|
|
advanced = true;
|
|
cursor.advance(n);
|
|
} else {
|
|
// When we get here, we've got the nth key.
|
|
resolve(cursor.key);
|
|
}
|
|
}
|
|
};
|
|
|
|
req.onerror = function () {
|
|
reject(req.error);
|
|
};
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
}).catch(reject);
|
|
});
|
|
|
|
(0, _executeCallback2.default)(promise, callback);
|
|
return promise;
|
|
}
|
|
|
|
function keys(callback) {
|
|
var self = this;
|
|
|
|
var promise = new _promise2.default(function (resolve, reject) {
|
|
self.ready().then(function () {
|
|
createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
|
|
if (err) {
|
|
return reject(err);
|
|
}
|
|
|
|
try {
|
|
var store = transaction.objectStore(self._dbInfo.storeName);
|
|
var req = store.openKeyCursor();
|
|
var keys = [];
|
|
|
|
req.onsuccess = function () {
|
|
var cursor = req.result;
|
|
|
|
if (!cursor) {
|
|
resolve(keys);
|
|
return;
|
|
}
|
|
|
|
keys.push(cursor.key);
|
|
cursor.continue();
|
|
};
|
|
|
|
req.onerror = function () {
|
|
reject(req.error);
|
|
};
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
});
|
|
}).catch(reject);
|
|
});
|
|
|
|
(0, _executeCallback2.default)(promise, callback);
|
|
return promise;
|
|
}
|
|
|
|
function dropInstance(options, callback) {
|
|
callback = _getCallback2.default.apply(this, arguments);
|
|
|
|
var currentConfig = this.config();
|
|
options = typeof options !== 'function' && options || {};
|
|
if (!options.name) {
|
|
options.name = options.name || currentConfig.name;
|
|
options.storeName = options.storeName || currentConfig.storeName;
|
|
}
|
|
|
|
var self = this;
|
|
var promise;
|
|
if (!options.name) {
|
|
promise = _promise2.default.reject('Invalid arguments');
|
|
} else {
|
|
var isCurrentDb = options.name === currentConfig.name && self._dbInfo.db;
|
|
|
|
var dbPromise = isCurrentDb ? _promise2.default.resolve(self._dbInfo.db) : _getOriginalConnection(options).then(function (db) {
|
|
var dbContext = dbContexts[options.name];
|
|
var forages = dbContext.forages;
|
|
dbContext.db = db;
|
|
for (var i = 0; i < forages.length; i++) {
|
|
forages[i]._dbInfo.db = db;
|
|
}
|
|
return db;
|
|
});
|
|
|
|
if (!options.storeName) {
|
|
promise = dbPromise.then(function (db) {
|
|
_deferReadiness(options);
|
|
|
|
var dbContext = dbContexts[options.name];
|
|
var forages = dbContext.forages;
|
|
|
|
db.close();
|
|
for (var i = 0; i < forages.length; i++) {
|
|
var forage = forages[i];
|
|
forage._dbInfo.db = null;
|
|
}
|
|
|
|
var dropDBPromise = new _promise2.default(function (resolve, reject) {
|
|
var req = _idb2.default.deleteDatabase(options.name);
|
|
|
|
req.onerror = function () {
|
|
var db = req.result;
|
|
if (db) {
|
|
db.close();
|
|
}
|
|
reject(req.error);
|
|
};
|
|
|
|
req.onblocked = function () {
|
|
// Closing all open connections in onversionchange handler should prevent this situation, but if
|
|
// we do get here, it just means the request remains pending - eventually it will succeed or error
|
|
console.warn('dropInstance blocked for database "' + options.name + '" until all open connections are closed');
|
|
};
|
|
|
|
req.onsuccess = function () {
|
|
var db = req.result;
|
|
if (db) {
|
|
db.close();
|
|
}
|
|
resolve(db);
|
|
};
|
|
});
|
|
|
|
return dropDBPromise.then(function (db) {
|
|
dbContext.db = db;
|
|
for (var i = 0; i < forages.length; i++) {
|
|
var _forage = forages[i];
|
|
_advanceReadiness(_forage._dbInfo);
|
|
}
|
|
}).catch(function (err) {
|
|
(_rejectReadiness(options, err) || _promise2.default.resolve()).catch(function () {});
|
|
throw err;
|
|
});
|
|
});
|
|
} else {
|
|
promise = dbPromise.then(function (db) {
|
|
if (!db.objectStoreNames.contains(options.storeName)) {
|
|
return;
|
|
}
|
|
|
|
var newVersion = db.version + 1;
|
|
|
|
_deferReadiness(options);
|
|
|
|
var dbContext = dbContexts[options.name];
|
|
var forages = dbContext.forages;
|
|
|
|
db.close();
|
|
for (var i = 0; i < forages.length; i++) {
|
|
var forage = forages[i];
|
|
forage._dbInfo.db = null;
|
|
forage._dbInfo.version = newVersion;
|
|
}
|
|
|
|
var dropObjectPromise = new _promise2.default(function (resolve, reject) {
|
|
var req = _idb2.default.open(options.name, newVersion);
|
|
|
|
req.onerror = function (err) {
|
|
var db = req.result;
|
|
db.close();
|
|
reject(err);
|
|
};
|
|
|
|
req.onupgradeneeded = function () {
|
|
var db = req.result;
|
|
db.deleteObjectStore(options.storeName);
|
|
};
|
|
|
|
req.onsuccess = function () {
|
|
var db = req.result;
|
|
db.close();
|
|
resolve(db);
|
|
};
|
|
});
|
|
|
|
return dropObjectPromise.then(function (db) {
|
|
dbContext.db = db;
|
|
for (var j = 0; j < forages.length; j++) {
|
|
var _forage2 = forages[j];
|
|
_forage2._dbInfo.db = db;
|
|
_advanceReadiness(_forage2._dbInfo);
|
|
}
|
|
}).catch(function (err) {
|
|
(_rejectReadiness(options, err) || _promise2.default.resolve()).catch(function () {});
|
|
throw err;
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
(0, _executeCallback2.default)(promise, callback);
|
|
return promise;
|
|
}
|
|
|
|
var asyncStorage = {
|
|
_driver: 'asyncStorage',
|
|
_initStorage: _initStorage,
|
|
_support: (0, _isIndexedDBValid2.default)(),
|
|
iterate: iterate,
|
|
getItem: getItem,
|
|
setItem: setItem,
|
|
removeItem: removeItem,
|
|
clear: clear,
|
|
length: length,
|
|
key: key,
|
|
keys: keys,
|
|
dropInstance: dropInstance
|
|
};
|
|
exports.default = asyncStorage;
|
|
module.exports = exports['default'];
|
|
});
|