Fix actions/tour
This commit is contained in:
408
node_modules/localforage/build/es5src/localforage.js
generated
vendored
Normal file
408
node_modules/localforage/build/es5src/localforage.js
generated
vendored
Normal file
@@ -0,0 +1,408 @@
|
||||
(function (global, factory) {
|
||||
if (typeof define === "function" && define.amd) {
|
||||
define('localforage', ['module', 'exports', './drivers/indexeddb', './drivers/websql', './drivers/localstorage', './utils/serializer', './utils/promise', './utils/executeCallback', './utils/executeTwoCallbacks', './utils/includes', './utils/isArray'], factory);
|
||||
} else if (typeof exports !== "undefined") {
|
||||
factory(module, exports, require('./drivers/indexeddb'), require('./drivers/websql'), require('./drivers/localstorage'), require('./utils/serializer'), require('./utils/promise'), require('./utils/executeCallback'), require('./utils/executeTwoCallbacks'), require('./utils/includes'), require('./utils/isArray'));
|
||||
} else {
|
||||
var mod = {
|
||||
exports: {}
|
||||
};
|
||||
factory(mod, mod.exports, global.indexeddb, global.websql, global.localstorage, global.serializer, global.promise, global.executeCallback, global.executeTwoCallbacks, global.includes, global.isArray);
|
||||
global.localforage = mod.exports;
|
||||
}
|
||||
})(this, function (module, exports, _indexeddb, _websql, _localstorage, _serializer, _promise, _executeCallback, _executeTwoCallbacks, _includes, _isArray) {
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
|
||||
var _indexeddb2 = _interopRequireDefault(_indexeddb);
|
||||
|
||||
var _websql2 = _interopRequireDefault(_websql);
|
||||
|
||||
var _localstorage2 = _interopRequireDefault(_localstorage);
|
||||
|
||||
var _serializer2 = _interopRequireDefault(_serializer);
|
||||
|
||||
var _promise2 = _interopRequireDefault(_promise);
|
||||
|
||||
var _executeCallback2 = _interopRequireDefault(_executeCallback);
|
||||
|
||||
var _executeTwoCallbacks2 = _interopRequireDefault(_executeTwoCallbacks);
|
||||
|
||||
var _includes2 = _interopRequireDefault(_includes);
|
||||
|
||||
var _isArray2 = _interopRequireDefault(_isArray);
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
|
||||
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
|
||||
return typeof obj;
|
||||
} : function (obj) {
|
||||
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
||||
};
|
||||
|
||||
function _classCallCheck(instance, Constructor) {
|
||||
if (!(instance instanceof Constructor)) {
|
||||
throw new TypeError("Cannot call a class as a function");
|
||||
}
|
||||
}
|
||||
|
||||
// Drivers are stored here when `defineDriver()` is called.
|
||||
// They are shared across all instances of localForage.
|
||||
var DefinedDrivers = {};
|
||||
|
||||
var DriverSupport = {};
|
||||
|
||||
var DefaultDrivers = {
|
||||
INDEXEDDB: _indexeddb2.default,
|
||||
WEBSQL: _websql2.default,
|
||||
LOCALSTORAGE: _localstorage2.default
|
||||
};
|
||||
|
||||
var DefaultDriverOrder = [DefaultDrivers.INDEXEDDB._driver, DefaultDrivers.WEBSQL._driver, DefaultDrivers.LOCALSTORAGE._driver];
|
||||
|
||||
var OptionalDriverMethods = ['dropInstance'];
|
||||
|
||||
var LibraryMethods = ['clear', 'getItem', 'iterate', 'key', 'keys', 'length', 'removeItem', 'setItem'].concat(OptionalDriverMethods);
|
||||
|
||||
var DefaultConfig = {
|
||||
description: '',
|
||||
driver: DefaultDriverOrder.slice(),
|
||||
name: 'localforage',
|
||||
// Default DB size is _JUST UNDER_ 5MB, as it's the highest size
|
||||
// we can use without a prompt.
|
||||
size: 4980736,
|
||||
storeName: 'keyvaluepairs',
|
||||
version: 1.0
|
||||
};
|
||||
|
||||
function callWhenReady(localForageInstance, libraryMethod) {
|
||||
localForageInstance[libraryMethod] = function () {
|
||||
var _args = arguments;
|
||||
return localForageInstance.ready().then(function () {
|
||||
return localForageInstance[libraryMethod].apply(localForageInstance, _args);
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
function extend() {
|
||||
for (var i = 1; i < arguments.length; i++) {
|
||||
var arg = arguments[i];
|
||||
|
||||
if (arg) {
|
||||
for (var key in arg) {
|
||||
if (arg.hasOwnProperty(key)) {
|
||||
if ((0, _isArray2.default)(arg[key])) {
|
||||
arguments[0][key] = arg[key].slice();
|
||||
} else {
|
||||
arguments[0][key] = arg[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return arguments[0];
|
||||
}
|
||||
|
||||
var LocalForage = function () {
|
||||
function LocalForage(options) {
|
||||
_classCallCheck(this, LocalForage);
|
||||
|
||||
for (var driverTypeKey in DefaultDrivers) {
|
||||
if (DefaultDrivers.hasOwnProperty(driverTypeKey)) {
|
||||
var driver = DefaultDrivers[driverTypeKey];
|
||||
var driverName = driver._driver;
|
||||
this[driverTypeKey] = driverName;
|
||||
|
||||
if (!DefinedDrivers[driverName]) {
|
||||
// we don't need to wait for the promise,
|
||||
// since the default drivers can be defined
|
||||
// in a blocking manner
|
||||
this.defineDriver(driver);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this._defaultConfig = extend({}, DefaultConfig);
|
||||
this._config = extend({}, this._defaultConfig, options);
|
||||
this._driverSet = null;
|
||||
this._initDriver = null;
|
||||
this._ready = false;
|
||||
this._dbInfo = null;
|
||||
|
||||
this._wrapLibraryMethodsWithReady();
|
||||
this.setDriver(this._config.driver).catch(function () {});
|
||||
}
|
||||
|
||||
// Set any config values for localForage; can be called anytime before
|
||||
// the first API call (e.g. `getItem`, `setItem`).
|
||||
// We loop through options so we don't overwrite existing config
|
||||
// values.
|
||||
|
||||
|
||||
LocalForage.prototype.config = function config(options) {
|
||||
// If the options argument is an object, we use it to set values.
|
||||
// Otherwise, we return either a specified config value or all
|
||||
// config values.
|
||||
if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) === 'object') {
|
||||
// If localforage is ready and fully initialized, we can't set
|
||||
// any new configuration values. Instead, we return an error.
|
||||
if (this._ready) {
|
||||
return new Error("Can't call config() after localforage " + 'has been used.');
|
||||
}
|
||||
|
||||
for (var i in options) {
|
||||
if (i === 'storeName') {
|
||||
options[i] = options[i].replace(/\W/g, '_');
|
||||
}
|
||||
|
||||
if (i === 'version' && typeof options[i] !== 'number') {
|
||||
return new Error('Database version must be a number.');
|
||||
}
|
||||
|
||||
this._config[i] = options[i];
|
||||
}
|
||||
|
||||
// after all config options are set and
|
||||
// the driver option is used, try setting it
|
||||
if ('driver' in options && options.driver) {
|
||||
return this.setDriver(this._config.driver);
|
||||
}
|
||||
|
||||
return true;
|
||||
} else if (typeof options === 'string') {
|
||||
return this._config[options];
|
||||
} else {
|
||||
return this._config;
|
||||
}
|
||||
};
|
||||
|
||||
LocalForage.prototype.defineDriver = function defineDriver(driverObject, callback, errorCallback) {
|
||||
var promise = new _promise2.default(function (resolve, reject) {
|
||||
try {
|
||||
var driverName = driverObject._driver;
|
||||
var complianceError = new Error('Custom driver not compliant; see ' + 'https://mozilla.github.io/localForage/#definedriver');
|
||||
|
||||
// A driver name should be defined and not overlap with the
|
||||
// library-defined, default drivers.
|
||||
if (!driverObject._driver) {
|
||||
reject(complianceError);
|
||||
return;
|
||||
}
|
||||
|
||||
var driverMethods = LibraryMethods.concat('_initStorage');
|
||||
for (var i = 0, len = driverMethods.length; i < len; i++) {
|
||||
var driverMethodName = driverMethods[i];
|
||||
|
||||
// when the property is there,
|
||||
// it should be a method even when optional
|
||||
var isRequired = !(0, _includes2.default)(OptionalDriverMethods, driverMethodName);
|
||||
if ((isRequired || driverObject[driverMethodName]) && typeof driverObject[driverMethodName] !== 'function') {
|
||||
reject(complianceError);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
var configureMissingMethods = function configureMissingMethods() {
|
||||
var methodNotImplementedFactory = function methodNotImplementedFactory(methodName) {
|
||||
return function () {
|
||||
var error = new Error('Method ' + methodName + ' is not implemented by the current driver');
|
||||
var promise = _promise2.default.reject(error);
|
||||
(0, _executeCallback2.default)(promise, arguments[arguments.length - 1]);
|
||||
return promise;
|
||||
};
|
||||
};
|
||||
|
||||
for (var _i = 0, _len = OptionalDriverMethods.length; _i < _len; _i++) {
|
||||
var optionalDriverMethod = OptionalDriverMethods[_i];
|
||||
if (!driverObject[optionalDriverMethod]) {
|
||||
driverObject[optionalDriverMethod] = methodNotImplementedFactory(optionalDriverMethod);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
configureMissingMethods();
|
||||
|
||||
var setDriverSupport = function setDriverSupport(support) {
|
||||
if (DefinedDrivers[driverName]) {
|
||||
console.info('Redefining LocalForage driver: ' + driverName);
|
||||
}
|
||||
DefinedDrivers[driverName] = driverObject;
|
||||
DriverSupport[driverName] = support;
|
||||
// don't use a then, so that we can define
|
||||
// drivers that have simple _support methods
|
||||
// in a blocking manner
|
||||
resolve();
|
||||
};
|
||||
|
||||
if ('_support' in driverObject) {
|
||||
if (driverObject._support && typeof driverObject._support === 'function') {
|
||||
driverObject._support().then(setDriverSupport, reject);
|
||||
} else {
|
||||
setDriverSupport(!!driverObject._support);
|
||||
}
|
||||
} else {
|
||||
setDriverSupport(true);
|
||||
}
|
||||
} catch (e) {
|
||||
reject(e);
|
||||
}
|
||||
});
|
||||
|
||||
(0, _executeTwoCallbacks2.default)(promise, callback, errorCallback);
|
||||
return promise;
|
||||
};
|
||||
|
||||
LocalForage.prototype.driver = function driver() {
|
||||
return this._driver || null;
|
||||
};
|
||||
|
||||
LocalForage.prototype.getDriver = function getDriver(driverName, callback, errorCallback) {
|
||||
var getDriverPromise = DefinedDrivers[driverName] ? _promise2.default.resolve(DefinedDrivers[driverName]) : _promise2.default.reject(new Error('Driver not found.'));
|
||||
|
||||
(0, _executeTwoCallbacks2.default)(getDriverPromise, callback, errorCallback);
|
||||
return getDriverPromise;
|
||||
};
|
||||
|
||||
LocalForage.prototype.getSerializer = function getSerializer(callback) {
|
||||
var serializerPromise = _promise2.default.resolve(_serializer2.default);
|
||||
(0, _executeTwoCallbacks2.default)(serializerPromise, callback);
|
||||
return serializerPromise;
|
||||
};
|
||||
|
||||
LocalForage.prototype.ready = function ready(callback) {
|
||||
var self = this;
|
||||
|
||||
var promise = self._driverSet.then(function () {
|
||||
if (self._ready === null) {
|
||||
self._ready = self._initDriver();
|
||||
}
|
||||
|
||||
return self._ready;
|
||||
});
|
||||
|
||||
(0, _executeTwoCallbacks2.default)(promise, callback, callback);
|
||||
return promise;
|
||||
};
|
||||
|
||||
LocalForage.prototype.setDriver = function setDriver(drivers, callback, errorCallback) {
|
||||
var self = this;
|
||||
|
||||
if (!(0, _isArray2.default)(drivers)) {
|
||||
drivers = [drivers];
|
||||
}
|
||||
|
||||
var supportedDrivers = this._getSupportedDrivers(drivers);
|
||||
|
||||
function setDriverToConfig() {
|
||||
self._config.driver = self.driver();
|
||||
}
|
||||
|
||||
function extendSelfWithDriver(driver) {
|
||||
self._extend(driver);
|
||||
setDriverToConfig();
|
||||
|
||||
self._ready = self._initStorage(self._config);
|
||||
return self._ready;
|
||||
}
|
||||
|
||||
function initDriver(supportedDrivers) {
|
||||
return function () {
|
||||
var currentDriverIndex = 0;
|
||||
|
||||
function driverPromiseLoop() {
|
||||
while (currentDriverIndex < supportedDrivers.length) {
|
||||
var driverName = supportedDrivers[currentDriverIndex];
|
||||
currentDriverIndex++;
|
||||
|
||||
self._dbInfo = null;
|
||||
self._ready = null;
|
||||
|
||||
return self.getDriver(driverName).then(extendSelfWithDriver).catch(driverPromiseLoop);
|
||||
}
|
||||
|
||||
setDriverToConfig();
|
||||
var error = new Error('No available storage method found.');
|
||||
self._driverSet = _promise2.default.reject(error);
|
||||
return self._driverSet;
|
||||
}
|
||||
|
||||
return driverPromiseLoop();
|
||||
};
|
||||
}
|
||||
|
||||
// There might be a driver initialization in progress
|
||||
// so wait for it to finish in order to avoid a possible
|
||||
// race condition to set _dbInfo
|
||||
var oldDriverSetDone = this._driverSet !== null ? this._driverSet.catch(function () {
|
||||
return _promise2.default.resolve();
|
||||
}) : _promise2.default.resolve();
|
||||
|
||||
this._driverSet = oldDriverSetDone.then(function () {
|
||||
var driverName = supportedDrivers[0];
|
||||
self._dbInfo = null;
|
||||
self._ready = null;
|
||||
|
||||
return self.getDriver(driverName).then(function (driver) {
|
||||
self._driver = driver._driver;
|
||||
setDriverToConfig();
|
||||
self._wrapLibraryMethodsWithReady();
|
||||
self._initDriver = initDriver(supportedDrivers);
|
||||
});
|
||||
}).catch(function () {
|
||||
setDriverToConfig();
|
||||
var error = new Error('No available storage method found.');
|
||||
self._driverSet = _promise2.default.reject(error);
|
||||
return self._driverSet;
|
||||
});
|
||||
|
||||
(0, _executeTwoCallbacks2.default)(this._driverSet, callback, errorCallback);
|
||||
return this._driverSet;
|
||||
};
|
||||
|
||||
LocalForage.prototype.supports = function supports(driverName) {
|
||||
return !!DriverSupport[driverName];
|
||||
};
|
||||
|
||||
LocalForage.prototype._extend = function _extend(libraryMethodsAndProperties) {
|
||||
extend(this, libraryMethodsAndProperties);
|
||||
};
|
||||
|
||||
LocalForage.prototype._getSupportedDrivers = function _getSupportedDrivers(drivers) {
|
||||
var supportedDrivers = [];
|
||||
for (var i = 0, len = drivers.length; i < len; i++) {
|
||||
var driverName = drivers[i];
|
||||
if (this.supports(driverName)) {
|
||||
supportedDrivers.push(driverName);
|
||||
}
|
||||
}
|
||||
return supportedDrivers;
|
||||
};
|
||||
|
||||
LocalForage.prototype._wrapLibraryMethodsWithReady = function _wrapLibraryMethodsWithReady() {
|
||||
// Add a stub for each driver API method that delays the call to the
|
||||
// corresponding driver method until localForage is ready. These stubs
|
||||
// will be replaced by the driver methods as soon as the driver is
|
||||
// loaded, so there is no performance impact.
|
||||
for (var i = 0, len = LibraryMethods.length; i < len; i++) {
|
||||
callWhenReady(this, LibraryMethods[i]);
|
||||
}
|
||||
};
|
||||
|
||||
LocalForage.prototype.createInstance = function createInstance(options) {
|
||||
return new LocalForage(options);
|
||||
};
|
||||
|
||||
return LocalForage;
|
||||
}();
|
||||
|
||||
exports.default = new LocalForage();
|
||||
module.exports = exports['default'];
|
||||
});
|
||||
Reference in New Issue
Block a user