1this.BX = this.BX || {}; 2(function (exports) { 3 'use strict'; 4 5 /* 6 * Dexie.js - a minimalistic wrapper for IndexedDB 7 * =============================================== 8 * 9 * By David Fahlander, [email protected] 10 * 11 * Version 3.2.2, Wed Apr 27 2022 12 * 13 * https://dexie.org 14 * 15 * Apache License Version 2.0, January 2004, http://www.apache.org/licenses/ 16 */ 17 18 /** 19 * Modify list for integration with Bitrix Framework: 20 * - removed integration with third-party package builders; 21 * - add check variables before using them, see tags: 28122018; 22 * - add alternative Promise check for Bitrix Cli, see tags: 02032020; 23 * - add export for work in Bitrix CoreJS extensions; 24 * - add export BX.Dexie for backward compatibility; 25 */ 26 27 /*! ***************************************************************************** 28 Copyright (c) Microsoft Corporation. 29 Permission to use, copy, modify, and/or distribute this software for any 30 purpose with or without fee is hereby granted. 31 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 32 REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 33 AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 34 INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 35 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 36 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 37 PERFORMANCE OF THIS SOFTWARE. 38 ***************************************************************************** */ 39 var _assign = function __assign() { 40 _assign = Object.assign || function __assign(t) { 41 for (var s, i = 1, n = arguments.length; i < n; i++) { 42 s = arguments[i]; 43 44 for (var p in s) { 45 if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; 46 } 47 } 48 49 return t; 50 }; 51 52 return _assign.apply(this, arguments); 53 }; 54 55 function __spreadArray(to, from, pack) { 56 if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { 57 if (ar || !(i in from)) { 58 if (!ar) ar = Array.prototype.slice.call(from, 0, i); 59 ar[i] = from[i]; 60 } 61 } 62 return to.concat(ar || Array.prototype.slice.call(from)); 63 } 64 65 var _global = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : global; 66 67 var keys = Object.keys; 68 var isArray = Array.isArray; 69 70 if (typeof Promise !== 'undefined' && !_global.Promise) { 71 _global.Promise = Promise; 72 } 73 74 function extend(obj, extension) { 75 if (babelHelpers["typeof"](extension) !== 'object') return obj; 76 keys(extension).forEach(function (key) { 77 obj[key] = extension[key]; 78 }); 79 return obj; 80 } 81 82 var getProto = Object.getPrototypeOf; 83 var _hasOwn = {}.hasOwnProperty; 84 85 function hasOwn(obj, prop) { 86 return _hasOwn.call(obj, prop); 87 } 88 89 function props(proto, extension) { 90 if (typeof extension === 'function') extension = extension(getProto(proto)); // tag start 28122018 91 92 if (babelHelpers["typeof"](extension) !== 'object') return; // tag end 28122018 93 94 (typeof Reflect === "undefined" ? keys : Reflect.ownKeys)(extension).forEach(function (key) { 95 setProp(proto, key, extension[key]); 96 }); 97 } 98 99 var defineProperty = Object.defineProperty; 100 101 function setProp(obj, prop, functionOrGetSet, options) { 102 defineProperty(obj, prop, extend(functionOrGetSet && hasOwn(functionOrGetSet, "get") && typeof functionOrGetSet.get === 'function' ? { 103 get: functionOrGetSet.get, 104 set: functionOrGetSet.set, 105 configurable: true 106 } : { 107 value: functionOrGetSet, 108 configurable: true, 109 writable: true 110 }, options)); 111 } 112 113 function derive(Child) { 114 return { 115 from: function from(Parent) { 116 Child.prototype = Object.create(Parent.prototype); 117 setProp(Child.prototype, "constructor", Child); 118 return { 119 extend: props.bind(null, Child.prototype) 120 }; 121 } 122 }; 123 } 124 125 var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 126 127 function getPropertyDescriptor(obj, prop) { 128 var pd = getOwnPropertyDescriptor(obj, prop); 129 var proto; 130 return pd || (proto = getProto(obj)) && getPropertyDescriptor(proto, prop
130); 131 } 132 133 var _slice = [].slice; 134 135 function slice(args, start, end) { 136 return _slice.call(args, start, end); 137 } 138 139 function override(origFunc, overridedFactory) { 140 return overridedFactory(origFunc); 141 } 142 143 function assert(b) { 144 if (!b) throw new Error("Assertion Failed"); 145 } 146 147 function asap$1(fn) { 148 if (_global.setImmediate) setImmediate(fn);else setTimeout(fn, 0); 149 } 150 151 function arrayToObject(array, extractor) { 152 return array.reduce(function (result, item, i) { 153 var nameAndValue = extractor(item, i); 154 if (nameAndValue) result[nameAndValue[0]] = nameAndValue[1]; 155 return result; 156 }, {}); 157 } 158 159 function tryCatch(fn, onerror, args) { 160 try { 161 fn.apply(null, args); 162 } catch (ex) { 163 onerror && onerror(ex); 164 } 165 } 166 167 function getByKeyPath(obj, keyPath) { 168 if (hasOwn(obj, keyPath)) return obj[keyPath]; 169 if (!keyPath) return obj; 170 171 if (typeof keyPath !== 'string') { 172 var rv = []; 173 174 for (var i = 0, l = keyPath.length; i < l; ++i) { 175 var val = getByKeyPath(obj, keyPath[i]); 176 rv.push(val); 177 } 178 179 return rv; 180 } 181 182 var period = keyPath.indexOf('.'); 183 184 if (period !== -1) { 185 var innerObj = obj[keyPath.substr(0, period)]; 186 return innerObj === undefined ? undefined : getByKeyPath(innerObj, keyPath.substr(period + 1)); 187 } 188 189 return undefined; 190 } 191 192 function setByKeyPath(obj, keyPath, value) { 193 if (!obj || keyPath === undefined) return; 194 if ('isFrozen' in Object && Object.isFrozen(obj)) return; 195 196 if (typeof keyPath !== 'string' && 'length' in keyPath) { 197 assert(typeof value !== 'string' && 'length' in value); 198 199 for (var i = 0, l = keyPath.length; i < l; ++i) { 200 setByKeyPath(obj, keyPath[i], value[i]); 201 } 202 } else { 203 var period = keyPath.indexOf('.'); 204 205 if (period !== -1) { 206 var currentKeyPath = keyPath.substr(0, period); 207 var remainingKeyPath = keyPath.substr(period + 1); 208 if (remainingKeyPath === "") { 209 if (value === undefined) { 210 if (isArray(obj) && !isNaN(parseInt(currentKeyPath))) obj.splice(currentKeyPath, 1);else delete obj[currentKeyPath]; 211 } else obj[currentKeyPath] = value; 212 } else { 213 var innerObj = obj[currentKeyPath]; 214 if (!innerObj || !hasOwn(obj, currentKeyPath)) innerObj = obj[currentKeyPath] = {}; 215 setByKeyPath(innerObj, remainingKeyPath, value); 216 } 217 } else { 218 if (value === undefined) { 219 if (isArray(obj) && !isNaN(parseInt(keyPath))) obj.splice(keyPath, 1);else delete obj[keyPath]; 220 } else obj[keyPath] = value; 221 } 222 } 223 } 224 225 function delByKeyPath(obj, keyPath) { 226 if (typeof keyPath === 'string') setByKeyPath(obj, keyPath, undefined);else if ('length' in keyPath) [].map.call(keyPath, function (kp) { 227 setByKeyPath(obj, kp, undefined); 228 }); 229 } 230 231 function shallowClone(obj) { 232 var rv = {}; 233 234 for (var m in obj) { 235 if (hasOwn(obj, m)) rv[m] = obj[m]; 236 } 237 238 return rv; 239 } 240 241 var concat = [].concat; 242 243 function flatten(a) { 244 return concat.apply([], a); 245 } 246 247 var intrinsicTypeNames = "Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey".split(',').concat(flatten([8, 16, 32, 64].map(function (num) { 248 return ["Int", "Uint", "Float"].map(function (t) { 249 return t + num + "Array"; 250 }); 251 }))).filter(function (t) { 252 return _global[t]; 253 }); 254 var intrinsicTypes = intrinsicTypeNames.map(function (t) { 255 return _global[t]; 256 }); 257 arrayToObject(intrinsicTypeNames, function (x) { 258 return [x, true]; 259 }); 260 var circularRefs = null; 261 262 function deepClone(any) { 263 circularRefs = typeof WeakMap !== 'undefined' && new WeakMap(); 264 var rv = innerDeepClone(any); 265 circularRefs = null; 266 return rv; 267 } 268 269 function innerDeepClone(any) { 270 if (!any || babelHelpers["typeof"](any) !== 'object') return any; 271 var rv = circularRefs && circularRefs.get(any); 272 if (rv) return rv; 273 274 if (isArray(any)) { 275 rv = []; 276 circularRefs && circularRefs.set(any, rv); 277 278 for (var i = 0, l = any.length; i < l; ++i) { 279 rv.push(innerDeepClone(any[i])); 280 } 281 } else if (intrinsicTypes.indexOf(any.constructor) >= 0) { 282 rv = any; 283 } else { 284 var proto = getProto(any); 285 rv = proto === Object.prototype ? {} : Object.create(proto); 286 circularRefs && circularRefs.set(any, rv); 287 288 for (var prop in any) { 289 if (hasOwn(any, prop)) { 290 rv[prop] = innerDeepClone(any[prop]); 291 } 292 } 293 } 294 295 return rv; 296 } 297 298 var toString = {}.toString; 299 300 function toStringTag(o) { 301 return toString.call(o).slice(8, -1); 302 } 303 304 var iteratorSymbol = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator'; 305 var getIteratorOf = babelHelpers["typeof"](iteratorSymbol) === "symbol" ? function (x) { 306 var i; 307 return x != null && (i = x[iteratorSymbol]) && i.apply(x); 308 } : function () { 309 return null; 310 }; 311 var NO_CHAR_ARRAY = {}; 312 313 function getArrayOf(arrayLike) { 314 var i, a, x, it; 315 316 if (arguments.length === 1) { 317 if (isArray(arrayLike)) return arrayLike.slice(); 318 if (this === NO_CHAR_ARRAY && typeof arrayLike === 'string') return [arrayLike]; 319 320 if (it = getIteratorOf(arrayLike)) { 321 a = []; 322 323 while (x = it.next(), !x.done) { 324 a.push(x.value); 325 } 326 327 return a; 328 } 329 330 if (arrayLike == null) return [arrayLike]; 331 i = arrayLike.length; 332 333 if (typeof i === 'number') { 334 a = new Array(i); 335 336 while (i--) { 337 a[i] = arrayLike[i]; 338 } 339 340 return a; 341 } 342 343 return [arrayLike]; 344 } 345 346 i = arguments.length; 347 a = new Array(i); 348 349 while (i--) { 350 a[i] = arguments[i]; 351 } 352 353 return a; 354 } 355 356 var isAsyncFunction = typeof Symbol !== 'undefined' ? function (fn) { 357 return fn[Symbol.toStringTag] === 'AsyncFunction'; 358 } : function () { 359 return false;
360 }; 361 var debug = typeof location !== 'undefined' && /^(http|https):\/\/(localhost|127\.0\.0\.1)/.test(location.href); 362 363 function setDebug(value, filter) { 364 debug = value; 365 libraryFilter = filter; 366 } 367 368 var libraryFilter = function libraryFilter() { 369 return true; 370 }; 371 372 var NEEDS_THROW_FOR_STACK = !new Error("").stack; 373 374 function getErrorWithStack() { 375 if (NEEDS_THROW_FOR_STACK) try { 376 throw new Error(); 377 } catch (e) { 378 return e; 379 } 380 return new Error(); 381 } 382 383 function prettyStack(exception, numIgnoredFrames) { 384 var stack = exception.stack; 385 if (!stack) return ""; 386 numIgnoredFrames = numIgnoredFrames || 0; 387 if (stack.indexOf(exception.name) === 0) numIgnoredFrames += (exception.name + exception.message).split('\n').length; 388 return stack.split('\n').slice(numIgnoredFrames).filter(libraryFilter).map(function (frame) { 389 return "\n" + frame; 390 }).join(''); 391 } 392 393 var dexieErrorNames = ['Modify', 'Bulk', 'OpenFailed', 'VersionChange', 'Schema', 'Upgrade', 'InvalidTable', 'MissingAPI', 'NoSuchDatabase', 'InvalidArgument', 'SubTransaction', 'Unsupported', 'Internal', 'DatabaseClosed', 'PrematureCommit', 'ForeignAwait']; 394 var idbDomErrorNames = ['Unknown', 'Constraint', 'Data', 'TransactionInactive', 'ReadOnly', 'Version', 'NotFound', 'InvalidState', 'InvalidAccess', 'Abort', 'Timeout', 'QuotaExceeded', 'Syntax', 'DataClone']; 395 var errorList = dexieErrorNames.concat(idbDomErrorNames); 396 var defaultTexts = { 397 VersionChanged: "Database version changed by other database connection", 398 DatabaseClosed: "Database has been closed", 399 Abort: "Transaction aborted", 400 TransactionInactive: "Transaction has already completed or failed", 401 MissingAPI: "IndexedDB API missing. Please visit https://tinyurl.com/y2uuvskb" 402 }; 403 404 function DexieError(name, msg) { 405 this._e = getErrorWithStack(); 406 this.name = name; 407 this.message = msg; 408 } 409 410 derive(DexieError).from(Error).extend({ 411 stack: { 412 get: function get() { 413 return this._stack || (this._stack = this.name + ": " + this.message + prettyStack(this._e, 2)); 414 } 415 }, 416 toString: function toString() { 417 return this.name + ": " + this.message; 418 } 419 }); 420 421 function getMultiErrorMessage(msg, failures) { 422 return msg + ". Errors: " + Object.keys(failures).map(function (key) { 423 return failures[key].toString(); 424 }).filter(function (v, i, s) { 425 return s.indexOf(v) === i; 426 }).join('\n'); 427 } 428 429 function ModifyError(msg, failures, successCount, failedKeys) { 430 this._e = getErrorWithStack(); 431 this.failures = failures; 432 this.failedKeys = failedKeys; 433 this.successCount = successCount; 434 this.message = getMultiErrorMessage(msg, failures); 435 } 436 437 derive(ModifyError).from(DexieError); 438 439 function BulkError(msg, failures) { 440 this._e = getErrorWithStack(); 441 this.name = "BulkError"; 442 this.failures = Object.keys(failures).map(function (pos) { 443 return failures[pos]; 444 }); 445 this.failuresByPos = failures; 446 this.message = getMultiErrorMessage(msg, failures); 447 } 448 449 derive(BulkError).from(DexieError); 450 var errnames = errorList.reduce(function (obj, name) { 451 return obj[name] = name + "Error", obj; 452 }, {}); 453 var BaseException = DexieError; 454 var exceptions = errorList.reduce(function (obj, name) { 455 var fullName = name + "Error"; 456 457 function DexieError(msgOrInner, inner) { 458 this._e = getErrorWithStack(); 459 this.name = fullName; 460 461 if (!msgOrInner) { 462 this.message = defaultTexts[name] || fullName; 463 this.inner = null; 464 } else if (typeof msgOrInner === 'string') { 465 this.message = "" + msgOrInner + (!inner ? '' : '\n ' + inner); 466 this.inner = inner || null; 467 } else if (babelHelpers["typeof"](msgOrInner) === 'object') { 468 this.message = msgOrInner.name + " " + msgOrInner.message; 469 this.inner = msgOrInner; 470 } 471 } 472 473 derive(DexieError).from(BaseException); 474 obj[name] = DexieError; 475 return obj; 476 }, {}); 477 exceptions.Syntax = SyntaxError; 478 exceptions.Type = TypeError; 479 exceptions.Range = RangeError; 480 var exceptionMap = idbDomErrorNames.reduce(function (obj, name) { 481 obj[name + "Error"] = exceptions[name]; 482 return obj; 483 }, {}); 484 485 function mapError(domError, message) { 486 if (!domError || domError instanceof DexieError || domError instanceof TypeError || domError instanceof SyntaxError || !domError.name || !exceptionMap[domError.name]) return domError; 487 var rv = new exceptionMap[domError.name](message || domError.message, domError); 488 489 if ("stack" in domError) { 490 setProp(rv, "stack", { 491 get: function get() { 492 return this.inner.stack; 493 } 494 }); 495 } 496 497 return rv; 498 } 499 500 var fullNameExceptions = errorList.reduce(function (obj, name) { 501 if (["Syntax", "Type", "Range"].indexOf(name) === -1) obj[name + "Error"] = exceptions[name]; 502 return obj; 503 }, {}); 504 fullNameExceptions.ModifyError = ModifyError; 505 fullNameExceptions.DexieError = DexieError; 506 fullNameExceptions.BulkError = BulkError; 507 508 function nop() {} 509 510 function mirror(val) { 511 return val; 512 } 513 514 function pureFunctionChain(f1, f2) { 515 if (f1 == null || f1 === mirror) return f2; 516 return function (val) { 517 return f2(f1(val)); 518 }; 519 } 520 521 function callBoth(on1, on2) { 522 return function () { 523 on1.apply(this, arguments); 524 on2.apply(this, arguments); 525 }; 526 } 527 528 function hookCreatingChain(f1, f2) { 529 if (f1 === nop) return f2; 530 return function () { 531 var res = f1.apply(this, arguments); 532 if (res !== undefined) arguments[0] = res; 533 var onsuccess = this.onsuccess, 534 onerror = this.onerror; 535 this.onsuccess = null; 536 this.onerror = null; 537 var res2 = f2.apply(this, arguments); 538 if (onsuccess) this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess;
539 if (onerror) this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror; 540 return res2 !== undefined ? res2 : res; 541 }; 542 } 543 544 function hookDeletingChain(f1, f2) { 545 if (f1 === nop) return f2; 546 return function () { 547 f1.apply(this, arguments); 548 var onsuccess = this.onsuccess, 549 onerror = this.onerror; 550 this.onsuccess = this.onerror = null; 551 f2.apply(this, arguments); 552 if (onsuccess) this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess; 553 if (onerror) this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror; 554 }; 555 } 556 557 function hookUpdatingChain(f1, f2) { 558 if (f1 === nop) return f2; 559 return function (modifications) { 560 var res = f1.apply(this, arguments); 561 extend(modifications, res); 562 var onsuccess = this.onsuccess, 563 onerror = this.onerror; 564 this.onsuccess = null; 565 this.onerror = null; 566 var res2 = f2.apply(this, arguments); 567 if (onsuccess) this.onsuccess = this.onsuccess ? callBoth(onsuccess, this.onsuccess) : onsuccess; 568 if (onerror) this.onerror = this.onerror ? callBoth(onerror, this.onerror) : onerror; 569 return res === undefined ? res2 === undefined ? undefined : res2 : extend(res, res2); 570 }; 571 } 572 573 function reverseStoppableEventChain(f1, f2) { 574 if (f1 === nop) return f2; 575 return function () { 576 if (f2.apply(this, arguments) === false) return false; 577 return f1.apply(this, arguments); 578 }; 579 } 580 581 function promisableChain(f1, f2) { 582 if (f1 === nop) return f2; 583 return function () { 584 var res = f1.apply(this, arguments); 585 586 if (res && typeof res.then === 'function') { 587 var thiz = this, 588 i = arguments.length, 589 args = new Array(i); 590 591 while (i--) { 592 args[i] = arguments[i]; 593 } 594 595 return res.then(function () { 596 return f2.apply(thiz, args); 597 }); 598 } 599 600 return f2.apply(this, arguments); 601 }; 602 } 603 604 var INTERNAL = {}; 605 606 var LONG_STACKS_CLIP_LIMIT = 100, 607 MAX_LONG_STACKS = 20, 608 ZONE_ECHO_LIMIT = 100, 609 _a$1 = typeof Promise === 'undefined' ? [] : function () { 610 var globalP = Promise.resolve(); 611 if (typeof crypto === 'undefined' || !crypto.subtle) return [globalP, getProto(globalP), globalP]; 612 var nativeP = crypto.subtle.digest("SHA-512", new Uint8Array([0])); 613 return [nativeP, getProto(nativeP), globalP]; 614 }(), 615 resolvedNativePromise = _a$1[0], 616 nativePromiseProto = _a$1[1], 617 resolvedGlobalPromise = _a$1[2], 618 nativePromiseThen = nativePromiseProto && nativePromiseProto.then; 619 620 var NativePromise = resolvedNativePromise && resolvedNativePromise.constructor; 621 var patchGlobalPromise = !!resolvedGlobalPromise; 622 var stack_being_generated = false; 623 var schedulePhysicalTick = resolvedGlobalPromise ? function () { 624 resolvedGlobalPromise.then(physicalTick); 625 } : _global.setImmediate ? setImmediate.bind(null, physicalTick) : _global.MutationObserver ? function () { 626 var hiddenDiv = document.createElement("div"); 627 new MutationObserver(function () { 628 physicalTick(); 629 hiddenDiv = null; 630 }).observe(hiddenDiv, { 631 attributes: true 632 }); 633 hiddenDiv.setAttribute('i', '1'); 634 } : function () { 635 setTimeout(physicalTick, 0); 636 }; 637 638 var asap = function asap(callback, args) { 639 microtickQueue.push([callback, args]); 640 641 if (needsNewPhysicalTick) { 642 schedulePhysicalTick(); 643 needsNewPhysicalTick = false; 644 } 645 }; 646 647 var isOutsideMicroTick = true, 648 needsNewPhysicalTick = true, 649 unhandledErrors = [], 650 rejectingErrors = [], 651 currentFulfiller = null, 652 rejectionMapper = mirror; 653 var globalPSD = { 654 id: 'global', 655 global: true, 656 ref: 0, 657 unhandleds: [], 658 onunhandled: globalError,
659 pgp: false, 660 env: {}, 661 finalize: function finalize() { 662 this.unhandleds.forEach(function (uh) { 663 try { 664 globalError(uh[0], uh[1]); 665 } catch (e) {} 666 }); 667 } 668 }; 669 var PSD = globalPSD; 670 var microtickQueue = []; 671 var numScheduledCalls = 0; 672 var tickFinalizers = []; 673 674 function DexiePromise(fn) { 675 if (babelHelpers["typeof"](this) !== 'object') throw new TypeError('Promises must be constructed via new'); 676 this._listeners = []; 677 this.onuncatched = nop; 678 this._lib = false; 679 var psd = this._PSD = PSD; 680 681 if (debug) { 682 this._stackHolder = getErrorWithStack(); 683 this._prev = null; 684 this._numPrev = 0; 685 } 686 687 if (typeof fn !== 'function') { 688 if (fn !== INTERNAL) throw new TypeError('Not a function'); 689 this._state = arguments[1]; 690 this._value = arguments[2]; 691 if (this._state === false) handleRejection(this, this._value); 692 return; 693 } 694 695 this._state = null; 696 this._value = null; 697 ++psd.ref; 698 executePromiseTask(this, fn); 699 } 700 701 var thenProp = { 702 get: function get() { 703 var psd = PSD, 704 microTaskId = totalEchoes; 705 706 function then(onFulfilled, onRejected) { 707 var _this = this; 708 709 var possibleAwait = !psd.global && (psd !== PSD || microTaskId !== totalEchoes); 710 var cleanup = possibleAwait && !decrementExpectedAwaits(); 711 var rv = new DexiePromise(function (resolve, reject) { 712 propagateToListener(_this, new Listener(nativeAwaitCompatibleWrap(onFulfilled, psd, possibleAwait, cleanup), nativeAwaitCompatibleWrap(onRejected, psd, possibleAwait, cleanup), resolve, reject, psd)); 713 }); 714 debug && linkToPreviousPromise(rv, this); 715 return rv; 716 } 717 718 then.prototype = INTERNAL; 719 return then; 720 }, 721 set: function set(value) { 722 setProp(this, 'then', value && value.prototype === INTERNAL ? thenProp : { 723 get: function get() { 724 return value; 725 }, 726 set: thenProp.set 727 }); 728 } 729 }; 730 props(DexiePromise.prototype, { 731 then: thenProp, 732 _then: function _then(onFulfilled, onRejected) { 733 propagateToListener(this, new Listener(null, null, onFulfilled, onRejected, PSD)); 734 }, 735 "catch": function _catch(onRejected) { 736 if (arguments.length === 1) return this.then(null, onRejected); 737 var type = arguments[0], 738 handler = arguments[1]; 739 return typeof type === 'function' ? this.then(null, function (err) { 740 return err instanceof type ? handler(err) : PromiseReject(err); 741 }) : this.then(null, function (err) { 742 return err && err.name === type ? handler(err) : PromiseReject(err); 743 }); 744 }, 745 "finally": function _finally(onFinally) { 746 return this.then(function (value) { 747 onFinally(); 748 return value; 749 }, function (err) { 750 onFinally(); 751 return PromiseReject(err); 752 }); 753 }, 754 stack: { 755 get: function get() { 756 if (this._stack) return this._stack; 757 758 try { 759 stack_being_generated = true; 760 var stacks = getStack(this, [], MAX_LONG_STACKS); 761 var stack = stacks.join("\nFrom previous: "); 762 if (this._state !== null) this._stack = stack; 763 return stack; 764 } finally { 765 stack_being_generated = false; 766 } 767 } 768 }, 769 timeout: function timeout(ms, msg) { 770 var _this = this; 771 772 return ms < Infinity ? new DexiePromise(function (resolve, reject) { 773 var handle = setTimeout(function () { 774 return reject(new exceptions.Timeout(msg)); 775 }, ms); 776 777 _this.then(resolve, reject)["finally"](clearTimeout.bind(null, handle)); 778 }) : this; 779 } 780 }); 781 if (typeof Symbol !== 'undefined' && Symbol.toStringTag) setProp(DexiePromise.prototype, Symbol.toStringTag, 'Dexie.Promise'); 782 globalPSD.env = snapShot(); 783 784 function Listener(onFulfilled, onRejected, resolve, reject, zone) { 785 this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null; 786 this.onRejected = typeof onRejected === 'function' ? onRejected : null; 787 this.resolve = resolve; 788 this.reject = reject; 789 this.psd = zone; 790 } 791 792 props(DexiePromise, { 793 all: function all() { 794 var values = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync); 795 return new DexiePromise(function (resolve, reject) { 796 if (values.length === 0) resolve([]); 797 var remaining = values.length;
798 values.forEach(function (a, i) { 799 return DexiePromise.resolve(a).then(function (x) { 800 values[i] = x; 801 if (! --remaining) resolve(values); 802 }, reject); 803 }); 804 }); 805 }, 806 resolve: function resolve(value) { 807 if (value instanceof DexiePromise) return value; 808 if (value && typeof value.then === 'function') return new DexiePromise(function (resolve, reject) { 809 value.then(resolve, reject); 810 }); 811 var rv = new DexiePromise(INTERNAL, true, value); 812 linkToPreviousPromise(rv, currentFulfiller); 813 return rv; 814 }, 815 reject: PromiseReject, 816 race: function race() { 817 var values = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync); 818 return new DexiePromise(function (resolve, reject) { 819 values.map(function (value) { 820 return DexiePromise.resolve(value).then(resolve, reject); 821 }); 822 }); 823 }, 824 PSD: { 825 get: function get() { 826 return PSD; 827 }, 828 set: function set(value) { 829 return PSD = value; 830 } 831 }, 832 totalEchoes: { 833 get: function get() { 834 return totalEchoes; 835 } 836 }, 837 newPSD: newScope, 838 usePSD: usePSD, 839 scheduler: { 840 get: function get() { 841 return asap; 842 }, 843 set: function set(value) { 844 asap = value; 845 } 846 }, 847 rejectionMapper: { 848 get: function get() { 849 return rejectionMapper; 850 }, 851 set: function set(value) { 852 rejectionMapper = value; 853 } 854 }, 855 follow: function follow(fn, zoneProps) { 856 return new DexiePromise(function (resolve, reject) { 857 return newScope(function (resolve, reject) { 858 var psd = PSD; 859 psd.unhandleds = []; 860 psd.onunhandled = reject; 861 psd.finalize = callBoth(function () { 862 var _this = this; 863 864 run_at_end_of_this_or_next_physical_tick(function () { 865 _this.unhandleds.length === 0 ? resolve() : reject(_this.unhandleds[0]); 866 }); 867 }, psd.finalize); 868 fn(); 869 }, zoneProps, resolve, reject); 870 }); 871 } 872 }); 873 874 if (NativePromise) { 875 if (NativePromise.allSettled) setProp(DexiePromise, "allSettled", function () { 876 var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync); 877 return new DexiePromise(function (resolve) { 878 if (possiblePromises.length === 0) resolve([]); 879 var remaining = possiblePromises.length; 880 var results = new Array(remaining); 881 possiblePromises.forEach(function (p, i) { 882 return DexiePromise.resolve(p).then(function (value) { 883 return results[i] = { 884 status: "fulfilled", 885 value: value 886 }; 887 }, function (reason) { 888 return results[i] = { 889 status: "rejected", 890 reason: reason 891 }; 892 }).then(function () { 893 return --remaining || resolve(results); 894 }); 895 }); 896 }); 897 }); 898 if (NativePromise.any && typeof AggregateError !== 'undefined') setProp(DexiePromise, "any", function () { 899 var possiblePromises = getArrayOf.apply(null, arguments).map(onPossibleParallellAsync); 900 return new DexiePromise(function (resolve, reject) { 901 if (possiblePromises.length === 0) reject(new AggregateError([])); 902 var remaining = possiblePromises.length; 903 var failures = new Array(remaining); 904 possiblePromises.forEach(function (p, i) { 905 return DexiePromise.resolve(p).then(function (value) { 906 return resolve(value); 907 }, function (failure) { 908 failures[i] = failure; 909 if (! --remaining) reject(new AggregateError(failures)); 910 }); 911 }); 912 }); 913 }); 914 } 915 916 function executePromiseTask(promise, fn) { 917 try { 918 fn(function (value) { 919 if (promise._state !== null) return; 920 if (value === promise) throw new TypeError('A promise cannot be resolved with itself.'); 921 var shouldExecuteTick = promise._lib && beginMicroTickScope(); 922 923 if (value && typeof value.then === 'function') { 924 executePromiseTask(promise, function (resolve, reject) { 925 value instanceof DexiePromise ? value._then(resolve, reject) : value.then(resolve, reject); 926 }); 927 } else { 928 promise._state = true; 929 promise._value = value; 930 propagateAllListeners(promise); 931 } 932 933 if (shouldExecuteTick) endMicroTickScope(); 934 }, handleRejection.bind(null, promise)); 935 } catch (ex) { 936 handleRejection(promise, ex); 937 } 938 } 939 940 function handleRejection(promise, reason) { 941 rejectingErrors.push(reason); 942 if (promise._state !== null) return; 943 var shouldExecuteTick = promise._lib && beginMicroTickScope(); 944 reason = rejectionMapper(reason); 945 promise._state = false;
946 promise._value = reason; 947 debug && reason !== null && babelHelpers["typeof"](reason) === 'object' && !reason._promise && tryCatch(function () { 948 var origProp = getPropertyDescriptor(reason, "stack"); 949 reason._promise = promise; 950 setProp(reason, "stack", { 951 get: function get() { 952 return stack_being_generated ? origProp && (origProp.get ? origProp.get.apply(reason) : origProp.value) : promise.stack; 953 } 954 }); 955 }); 956 addPossiblyUnhandledError(promise); 957 propagateAllListeners(promise); 958 if (shouldExecuteTick) endMicroTickScope(); 959 } 960 961 function propagateAllListeners(promise) { 962 var listeners = promise._listeners; 963 promise._listeners = []; 964 965 for (var i = 0, len = listeners.length; i < len; ++i) { 966 propagateToListener(promise, listeners[i]); 967 } 968 969 var psd = promise._PSD; 970 --psd.ref || psd.finalize(); 971 972 if (numScheduledCalls === 0) { 973 ++numScheduledCalls; 974 asap(function () { 975 if (--numScheduledCalls === 0) finalizePhysicalTick(); 976 }, []); 977 } 978 } 979 980 function propagateToListener(promise, listener) { 981 if (promise._state === null) { 982 promise._listeners.push(listener); 983 984 return; 985 } 986 987 var cb = promise._state ? listener.onFulfilled : listener.onRejected; 988 989 if (cb === null) { 990 return (promise._state ? listener.resolve : listener.reject)(promise._value); 991 } 992 993 ++listener.psd.ref; 994 ++numScheduledCalls; 995 asap(callListener, [cb, promise, listener]); 996 } 997 998 function callListener(cb, promise, listener) { 999 try { 1000 currentFulfiller = promise; 1001 var ret, 1002 value = promise._value; 1003 1004 if (promise._state) { 1005 ret = cb(value); 1006 } else { 1007 if (rejectingErrors.length) rejectingErrors = []; 1008 ret = cb(value); 1009 if (rejectingErrors.indexOf(value) === -1) markErrorAsHandled(promise); 1010 } 1011 1012 listener.resolve(ret); 1013 } catch (e) { 1014 listener.reject(e); 1015 } finally { 1016 currentFulfiller = null; 1017 if (--numScheduledCalls === 0) finalizePhysicalTick(); 1018 --listener.psd.ref || listener.psd.finalize(); 1019 } 1020 } 1021 1022 function getStack(promise, stacks, limit) { 1023 if (stacks.length === limit) return stacks; 1024 var stack = ""; 1025 1026 if (promise._state === false) { 1027 var failure = promise._value, 1028 errorName, 1029 message; 1030 1031 if (failure != null) { 1032 errorName = failure.name || "Error"; 1033 message = failure.message || failure; 1034 stack = prettyStack(failure, 0); 1035 } else { 1036 errorName = failure; 1037 message = ""; 1038 } 1039 1040 stacks.push(errorName + (message ? ": " + message : "") + stack); 1041 } 1042 1043 if (debug) { 1044 stack = prettyStack(promise._stackHolder, 2); 1045 if (stack && stacks.indexOf(stack) === -1) stacks.push(stack); 1046 if (promise._prev) getStack(promise._prev, stacks, limit); 1047 } 1048 1049 return stacks; 1050 } 1051 1052 function linkToPreviousPromise(promise, prev) { 1053 var numPrev = prev ? prev._numPrev + 1 : 0; 1054 1055 if (numPrev < LONG_STACKS_CLIP_LIMIT) { 1056 promise._prev = prev; 1057 promise._numPrev = numPrev; 1058 } 1059 } 1060 1061 function physicalTick() { 1062 beginMicroTickScope() && endMicroTickScope(); 1063 } 1064 1065 function beginMicroTickScope() { 1066 var wasRootExec = isOutsideMicroTick; 1067 isOutsideMicroTick = false; 1068 needsNewPhysicalTick = false; 1069 return wasRootExec; 1070 } 1071 1072 function endMicroTickScope() { 1073 var callbacks, i, l; 1074 1075 do { 1076 while (microtickQueue.length > 0) { 1077 callbacks = microtickQueue; 1078 microtickQueue = []; 1079 l = callbacks.length; 1080 1081 for (i = 0; i < l; ++i) { 1082 var item = callbacks[i]; 1083 item[0].apply(null, item[1]); 1084 } 1085 } 1086 } while (microtickQueue.length > 0); 1087 1088 isOutsideMicroTick = true; 1089 needsNewPhysicalTick = true; 1090 } 1091 1092 function finalizePhysicalTick() { 1093 var unhandledErrs = unhandledErrors; 1094 unhandledErrors = []; 1095 unhandledErrs.forEach(function (p) { 1096 p._PSD.onunhandled.call(null, p._value, p); 1097 }); 1098 var finalizers = tickFinalizers.slice(0); 1099 var i = finalizers.length; 1100 1101 while (i) { 1102 finalizers[--i](); 1103 } 1104 } 1105 1106 function run_at_end_of_this_or_next_physical_tick(fn) { 1107 function finalizer() { 1108 fn(); 1109 tickFinalizers.splice(tickFinalizers.indexOf(finalizer), 1); 1110 } 1111 1112 tickFinalizers.push(finalizer); 1113 ++numScheduledCalls; 1114 asap(function () { 1115 if (--numScheduledCalls === 0) finalizePhysicalTick(); 1116 }, []); 1117 } 1118 1119 function addPossiblyUnhandledError(promise) { 1120 if (!unhandledErrors.some(function (p) { 1121 return p._value === promise._value; 1122 })) unhandledErrors.push(promise); 1123 } 1124 1125 function markErrorAsHandled(promise) { 1126 var i = unhandledErrors.length; 1127 1128 while (i) {
1129 if (unhandledErrors[--i]._value === promise._value) { 1130 unhandledErrors.splice(i, 1); 1131 return; 1132 } 1133 } 1134 } 1135 1136 function PromiseReject(reason) { 1137 return new DexiePromise(INTERNAL, false, reason); 1138 } 1139 1140 function wrap(fn, errorCatcher) { 1141 var psd = PSD; 1142 return function () { 1143 var wasRootExec = beginMicroTickScope(), 1144 outerScope = PSD; 1145 1146 try { 1147 switchToZone(psd, true); 1148 return fn.apply(this, arguments); 1149 } catch (e) { 1150 errorCatcher && errorCatcher(e); 1151 } finally { 1152 switchToZone(outerScope, false); 1153 if (wasRootExec) endMicroTickScope(); 1154 } 1155 }; 1156 } 1157 1158 var task = { 1159 awaits: 0, 1160 echoes: 0, 1161 id: 0 1162 }; 1163 var taskCounter = 0; 1164 var zoneStack = []; 1165 var zoneEchoes = 0; 1166 var totalEchoes = 0; 1167 var zone_id_counter = 0; 1168 1169 function newScope(fn, props, a1, a2) { 1170 var parent = PSD, 1171 psd = Object.create(parent); 1172 psd.parent = parent; 1173 psd.ref = 0; 1174 psd.global = false; 1175 psd.id = ++zone_id_counter; 1176 var globalEnv = globalPSD.env; 1177 psd.env = patchGlobalPromise ? { 1178 Promise: DexiePromise, 1179 PromiseProp: { 1180 value: DexiePromise, 1181 configurable: true, 1182 writable: true 1183 }, 1184 all: DexiePromise.all, 1185 race: DexiePromise.race, 1186 allSettled: DexiePromise.allSettled, 1187 any: DexiePromise.any, 1188 resolve: DexiePromise.resolve, 1189 reject: DexiePromise.reject, 1190 nthen: getPatchedPromiseThen(globalEnv.nthen, psd), 1191 gthen: getPatchedPromiseThen(globalEnv.gthen, psd) 1192 } : {}; 1193 if (props) extend(psd, props); 1194 ++parent.ref; 1195 1196 psd.finalize = function () { 1197 --this.parent.ref || this.parent.finalize(); 1198 }; 1199 1200 var rv = usePSD(psd, fn, a1, a2); 1201 if (psd.ref === 0) psd.finalize(); 1202 return rv; 1203 } 1204 1205 function incrementExpectedAwaits() { 1206 if (!task.id) task.id = ++taskCounter; 1207 ++task.awaits; 1208 task.echoes += ZONE_ECHO_LIMIT; 1209 return task.id; 1210 } 1211 1212 function decrementExpectedAwaits() { 1213 if (!task.awaits) return false; 1214 if (--task.awaits === 0) task.id = 0; 1215 task.echoes = task.awaits * ZONE_ECHO_LIMIT; 1216 return true; 1217 } 1218 1219 if (('' + nativePromiseThen).indexOf('[native code]') === -1) { 1220 incrementExpectedAwaits = decrementExpectedAwaits = nop; 1221 } 1222 1223 function onPossibleParallellAsync(possiblePromise) { 1224 if (task.echoes && possiblePromise && possiblePromise.constructor === NativePromise) { 1225 incrementExpectedAwaits(); 1226 return possiblePromise.then(function (x) { 1227 decrementExpectedAwaits(); 1228 return x; 1229 }, function (e) { 1230 decrementExpectedAwaits(); 1231 return rejection(e); 1232 }); 1233 } 1234 1235 return possiblePromise; 1236 } 1237 1238 function zoneEnterEcho(targetZone) { 1239 ++totalEchoes; 1240 1241 if (!task.echoes || --task.echoes === 0) { 1242 task.echoes = task.id = 0; 1243 } 1244 1245 zoneStack.push(PSD); 1246 switchToZone(targetZone, true); 1247 } 1248 1249 function zoneLeaveEcho() { 1250 var zone = zoneStack[zoneStack.length - 1]; 1251 zoneStack.pop(); 1252 switchToZone(zone, false); 1253 } 1254 1255 function switchToZone(targetZone, bEnteringZone) { 1256 var currentZone = PSD; 1257 1258 if (bEnteringZone ? task.echoes && (!zoneEchoes++ || targetZone !== PSD) : zoneEchoes && (! --zoneEchoes || targetZone !== PSD)) { 1259 enqueueNativeMicroTask(bEnteringZone ? zoneEnterEcho.bind(null, targetZone) : zoneLeaveEcho); 1260 } 1261 1262 if (targetZone === PSD) return; 1263 PSD = targetZone; 1264 if (currentZone === globalPSD) globalPSD.env = snapShot(); 1265 1266 if (patchGlobalPromise) { 1267 var GlobalPromise_1 = globalPSD.env.Promise; 1268 var targetEnv = targetZone.env; 1269 nativePromiseProto.then = targetEnv.nthen; 1270 GlobalPromise_1.prototype.then = targetEnv.gthen; 1271 1272 if (currentZone.global || targetZone.global) { 1273 Object.defineProperty(_global, 'Promise', targetEnv.PromiseProp); 1274 GlobalPromise_1.all = targetEnv.all; 1275 GlobalPromise_1.race = targetEnv.race; 1276 GlobalPromise_1.resolve = targetEnv.resolve; 1277 GlobalPromise_1.reject = targetEnv.reject; 1278 if (targetEnv.allSettled) GlobalPromise_1.allSettled = targetEnv.allSettled; 1279 if (targetEnv.any) GlobalPromise_1.any = targetEnv.any; 1280 } 1281 } 1282 } 1283 1284 function snapShot() { 1285 var GlobalPromise = _global.Promise || Promise; // tag 02032020 1286 1287 return patchGlobalPromise ? { 1288 Promise: GlobalPromise, 1289 PromiseProp: Object.getOwnPropertyDescriptor(_global, "Promise"), 1290 all: GlobalPromise.all, 1291 race: GlobalPromise.race, 1292 allSettled: GlobalPromise.allSettled, 1293 any: GlobalPromise.any, 1294 resolve: GlobalPromise.resolve, 1295 reject: GlobalPromise.reject, 1296 nthen: nativePromiseProto.then, 1297 gthen: GlobalPromise.prototype.then 1298 } : {}; 1299 } 1300 1301 function usePSD(psd, fn, a1, a2, a3) { 1302 var outerScope = PSD; 1303 1304 try { 1305 switchToZone(psd, true); 1306 return fn(a1, a2, a3); 1307 } finally { 1308 switchToZone(outerScope, false); 1309 } 1310 } 1311 1312 function enqueueNativeMicroTask(job) { 1313 nativePromiseThen.call(resolvedNativePromise, job); 1314 } 1315 1316 function nativeAwaitCompatibleWrap(fn, zone, possibleAwait, cleanup) { 1317 return typeof fn !== 'function' ? fn : function () { 1318 var outerZone = PSD; 1319 if (possibleAwait) incrementExpectedAwaits(); 1320 switchToZone(zone, true); 1321 1322 try { 1323 return fn.apply(this, arguments); 1324 } finally { 1325 switchToZone(outerZone, false); 1326 if (cleanup) enqueueNativeMicroTask(decrementExpectedAwaits); 1327 } 1328 }; 1329 } 1330 1331 function getPatchedPromiseThen(origThen, zone) { 1332 return function (onResolved, onRejected) { 1333 return origThen.call(this, nativeAwaitCompatibleWrap(onResolved, zone), nativeAwaitCompatibleWrap(onRejected, zone)); 1334 }; 1335 } 1336 1337 var UNHANDLEDREJECTION = "unhandledrejection"; 1338 1339 function globalError(err, promise) { 1340 var rv; 1341 1342 try { 1343 rv = promise.onuncatched(err); 1344 } catch (e) {} 1345 1346 if (rv !== false) try { 1347 var event, 1348 eventData = { 1349 promise: promise, 1350 reason: err 1351 }; 1352 1353 if (_global.document && document.createEvent) { 1354 event = document.createEvent('Event'); 1355 event.initEvent(UNHANDLEDREJECTION, true, true); 1356 extend(event, eventData); 1357 } else if (_global.CustomEvent) { 1358 event = new CustomEvent(UNHANDLEDREJECTION, { 1359 detail: eventData 1360 }); 1361 extend(event, eventData); 1362 } 1363 1364 if (event && _global.dispatchEvent) { 1365 dispatchEvent(event); 1366 if (!_global.PromiseRejectionEvent && _global.onunhandledrejection) try { 1367 _global.onunhandledrejection(event); 1368 } catch (_) {} 1369 } 1370 1371 if (debug && event && !event.defaultPrevented) { 1372 console.warn("Unhandled rejection: " + (err.stack || err)); 1373 } 1374 } catch (e) {} 1375 } 1376 1377 var rejection = DexiePromise.reject; 1378 1379 function tempTransaction(db, mode, storeNames, fn) { 1380 if (!db.idbdb || !db._state.openComplete && !PSD.letThrough && !db._vip) { 1381 if (db._state.openComplete) { 1382 return rejection(new exceptions.DatabaseClosed(db._state.dbOpenError)); 1383 } 1384 1385 if (!db._state.isBeingOpened) { 1386 if (!db._options.autoOpen) return rejection(new exceptions.DatabaseClosed()); 1387 db.open()["catch"](nop); 1388 } 1389 1390 return db._state.dbReadyPromise.then(function () { 1391 return tempTransaction(db, mode, storeNames, fn); 1392 }); 1393 } else { 1394 var trans = db._createTransaction(mode, storeNames, db._dbSchema); 1395 1396 try { 1397 trans.create(); 1398 db._state.PR1398_maxLoop = 3; 1399 } catch (ex) { 1400 if (ex.name === errnames.InvalidState && db.isOpen() && --db._state.PR1398_maxLoop > 0) { 1401 console.warn('Dexie: Need to reopen db'); 1402 1403 db._close(); 1404 1405 return db.open().then(function () { 1406 return tempTransaction(db, mode, storeNames, fn); 1407 }); 1408 } 1409 1410 return rejection(ex); 1411 } 1412 1413 return trans._promise(mode, function (resolve, reject) { 1414 return newScope(function () { 1415 PSD.trans = trans; 1416 return fn(resolve, reject, trans); 1417 }); 1418 }).then(function (result) { 1419 return trans._completion.then(function () { 1420 return result; 1421 }); 1422 }); 1423 } 1424 } 1425 1426 var DEXIE_VERSION = '3.2.2'; 1427 var maxString = String.fromCharCode(65535); 1428 var minKey = -Infinity; 1429 var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>."; 1430 var STRING_EXPECTED = "String expected."; 1431 var connections = []; 1432 var isIEOrEdge = typeof navigator !== 'undefined' && /(MSIE|Trident|Edge)/.test(navigator.userAgent); 1433 var hasIEDeleteObjectStoreBug = isIEOrEdge; 1434 var hangsOnDeleteLargeKeyRange = isIEOrEdge; 1435 1436 var dexieStackFrameFilter = function dexieStackFrameFilter(frame) { 1437 return !/(dexie\.js|dexie\.min\.js)/.test(frame); 1438 }; 1439 1440 var DBNAMES_DB = '__dbnames'; 1441 var READONLY = 'readonly'; 1442 var READWRITE = 'readwrite'; 1443 1444 function combine(filter1, filter2) { 1445 return filter1 ? filter2 ? function () { 1446 return filter1.apply(this, arguments) && filter2.apply(this, arguments); 1447 } : filter1 : filter2; 1448 } 1449 1450 var AnyRange = { 1451 type: 3, 1452 lower: -Infinity, 1453 lowerOpen: false, 1454 upper: [[]], 1455 upperOpen: false 1456 }; 1457
1458 function workaroundForUndefinedPrimKey(keyPath) { 1459 return typeof keyPath === "string" && !/\./.test(keyPath) ? function (obj) { 1460 if (obj[keyPath] === undefined && keyPath in obj) { 1461 obj = deepClone(obj); 1462 delete obj[keyPath]; 1463 } 1464 1465 return obj; 1466 } : function (obj) { 1467 return obj; 1468 }; 1469 } 1470 1471 var Table = function () { 1472 function Table() {} 1473 1474 Table.prototype._trans = function (mode, fn, writeLocked) { 1475 var trans = this._tx || PSD.trans; 1476 var tableName = this.name; 1477 1478 function checkTableInTransaction(resolve, reject, trans) { 1479 if (!trans.schema[tableName]) throw new exceptions.NotFound("Table " + tableName + " not part of transaction"); 1480 return fn(trans.idbtrans, trans); 1481 } 1482 1483 var wasRootExec = beginMicroTickScope(); 1484 1485 try { 1486 return trans && trans.db === this.db ? trans === PSD.trans ? trans._promise(mode, checkTableInTransaction, writeLocked) : newScope(function () { 1487 return trans._promise(mode, checkTableInTransaction, writeLocked); 1488 }, { 1489 trans: trans, 1490 transless: PSD.transless || PSD 1491 }) : tempTransaction(this.db, mode, [this.name], checkTableInTransaction); 1492 } finally { 1493 if (wasRootExec) endMicroTickScope(); 1494 } 1495 }; 1496 1497 Table.prototype.get = function (keyOrCrit, cb) { 1498 var _this = this; 1499 1500 if (keyOrCrit && keyOrCrit.constructor === Object) return this.where(keyOrCrit).first(cb); 1501 return this._trans('readonly', function (trans) { 1502 return _this.core.get({ 1503 trans: trans, 1504 key: keyOrCrit 1505 }).then(function (res) { 1506 return _this.hook.reading.fire(res); 1507 }); 1508 }).then(cb); 1509 }; 1510 1511 Table.prototype.where = function (indexOrCrit) { 1512 if (typeof indexOrCrit === 'string') return new this.db.WhereClause(this, indexOrCrit); 1513 if (isArray(indexOrCrit)) return new this.db.WhereClause(this, "[" + indexOrCrit.join('+') + "]"); 1514 var keyPaths = keys(indexOrCrit); 1515 if (keyPaths.length === 1) return this.where(keyPaths[0]).equals(indexOrCrit[keyPaths[0]]); 1516 var compoundIndex = this.schema.indexes.concat(this.schema.primKey).filter(function (ix) { 1517 return ix.compound && keyPaths.every(function (keyPath) { 1518 return ix.keyPath.indexOf(keyPath) >= 0; 1519 }) && ix.keyPath.every(function (keyPath) { 1520 return keyPaths.indexOf(keyPath) >= 0; 1521 }); 1522 })[0]; 1523 if (compoundIndex && this.db._maxKey !== maxString) return this.where(compoundIndex.name).equals(compoundIndex.keyPath.map(function (kp) { 1524 return indexOrCrit[kp]; 1525 })); 1526 if (!compoundIndex && debug) console.warn("The query " + JSON.stringify(indexOrCrit) + " on " + this.name + " would benefit of a " + ("compound index [" + keyPaths.join('+') + "]")); 1527 var idxByName = this.schema.idxByName; 1528 var idb = this.db._deps.indexedDB; 1529 1530 function equals(a, b) { 1531 try { 1532 return idb.cmp(a, b) === 0; 1533 } catch (e) { 1534 return false; 1535 } 1536 } 1537 1538 var _a = keyPaths.reduce(function (_a, keyPath) { 1539 var prevIndex = _a[0], 1540 prevFilterFn = _a[1]; 1541 var index = idxByName[keyPath]; 1542 var value = indexOrCrit[keyPath]; 1543 return [prevIndex || index, prevIndex || !index ? combine(prevFilterFn, index && index.multi ? function (x) { 1544 var prop = getByKeyPath(x, keyPath); 1545 return isArray(prop) && prop.some(function (item) { 1546 return equals(value, item); 1547 }); 1548 } : function (x) { 1549 return equals(value, getByKeyPath(x, keyPath)); 1550 }) : prevFilterFn]; 1551 }, [null, null]), 1552 idx = _a[0], 1553 filterFunction = _a[1]; 1554 1555 return idx ? this.where(idx.name).equals(indexOrCrit[idx.keyPath]).filter(filterFunction) : compoundIndex ? this.filter(filterFunction) : this.where(keyPaths).equals(''); 1556 }; 1557 1558 Table.prototype.filter = function (filterFunction) { 1559 return this.toCollection().and(filterFunction); 1560 }; 1561 1562 Table.prototype.count = function (thenShortcut) { 1563 return this.toCollection().count(thenShortcut); 1564 }; 1565 1566 Table.prototype.offset = function (offset) { 1567 return this.toCollection().offset(offset); 1568 }; 1569 1570 Table.prototype.limit = function (numRows) { 1571 return this.toCollection().limit(numRows); 1572 }; 1573 1574 Table.prototype.each = function (callback) { 1575 return this.toCollection().each(callback); 1576 }; 1577 1578 Table.prototype.toArray = function (thenShortcut) { 1579 return this.toCollection().toArray(thenShortcut); 1580 }; 1581 1582 Table.prototype.toCollection = function () { 1583 return new this.db.Collection(new this.db.WhereClause(this)); 1584 }; 1585 1586 Table.prototype.orderBy = function (index) { 1587 return new this.db.Collection(new this.db.WhereClause(this, isArray(index) ? "[" + index.join('+') + "]" : index)); 1588 }; 1589 1590 Table.prototype.reverse = function () { 1591 return this.toCollection().reverse(); 1592 }; 1593 1594 Table.prototype.mapToClass = function (constructor) { 1595 this.schema.mappedClass = constructor; 1596 1597 var readHook = function readHook(obj) { 1598 if (!obj) return obj; 1599 var res = Object.create(constructor.prototype); 1600 1601 for (var m in obj) { 1602 if (hasOwn(obj, m)) try { 1603 res[m] = obj[m]; 1604 } catch (_) {} 1605 } 1606 1607 return res; 1608 }; 1609 1610 if (this.schema.readHook) { 1611 this.hook.reading.unsubscribe(this.schema.readHook); 1612 } 1613 1614 this.schema.readHook = readHook; 1615 this.hook("reading", readHook); 1616 return constructor; 1617 }; 1618 1619 Table.prototype.defineClass = function () { 1620 function Class(content) { 1621 extend(this, content); 1622 } 1623 1624 return this.mapToClass(Class); 1625 }; 1626 1627 Table.prototype.add = function (obj, key) { 1628 var _this = this; 1629 1630 var _a = this.schema.primKey, 1631 auto = _a.auto, 1632 keyPath = _a.keyPath; 1633 var objToAdd = obj; 1634 1635 if (keyPath && auto) {
1636 objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj); 1637 } 1638 1639 return this._trans('readwrite', function (trans) { 1640 return _this.core.mutate({ 1641 trans: trans, 1642 type: 'add', 1643 keys: key != null ? [key] : null, 1644 values: [objToAdd] 1645 }); 1646 }).then(function (res) { 1647 return res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult; 1648 }).then(function (lastResult) { 1649 if (keyPath) { 1650 try { 1651 setByKeyPath(obj, keyPath, lastResult); 1652 } catch (_) {} 1653 } 1654 1655 return lastResult; 1656 }); 1657 }; 1658 1659 Table.prototype.update = function (keyOrObject, modifications) { 1660 if (babelHelpers["typeof"](keyOrObject) === 'object' && !isArray(keyOrObject)) { 1661 var key = getByKeyPath(keyOrObject, this.schema.primKey.keyPath); 1662 if (key === undefined) return rejection(new exceptions.InvalidArgument("Given object does not contain its primary key")); 1663 1664 try { 1665 if (typeof modifications !== "function") { 1666 keys(modifications).forEach(function (keyPath) { 1667 setByKeyPath(keyOrObject, keyPath, modifications[keyPath]); 1668 }); 1669 } else { 1670 modifications(keyOrObject, { 1671 value: keyOrObject, 1672 primKey: key 1673 }); 1674 } 1675 } catch (_a) {} 1676 1677 return this.where(":id").equals(key).modify(modifications); 1678 } else { 1679 return this.where(":id").equals(keyOrObject).modify(modifications); 1680 } 1681 }; 1682 1683 Table.prototype.put = function (obj, key) { 1684 var _this = this; 1685 1686 var _a = this.schema.primKey, 1687 auto = _a.auto, 1688 keyPath = _a.keyPath; 1689 var objToAdd = obj; 1690 1691 if (keyPath && auto) {
vendor: 2,558 bytes, lines 1692-1771
1692 objToAdd = workaroundForUndefinedPrimKey(keyPath)(obj); 1693 } 1694 1695 return this._trans('readwrite', function (trans) { 1696 return _this.core.mutate({ 1697 trans: trans, 1698 type: 'put', 1699 values: [objToAdd], 1700 keys: key != null ? [key] : null 1701 }); 1702 }).then(function (res) { 1703 return res.numFailures ? DexiePromise.reject(res.failures[0]) : res.lastResult; 1704 }).then(function (lastResult) { 1705 if (keyPath) { 1706 try { 1707 setByKeyPath(obj, keyPath, lastResult); 1708 } catch (_) {} 1709 } 1710 1711 return lastResult; 1712 }); 1713 }; 1714 1715 Table.prototype["delete"] = function (key) { 1716 var _this = this; 1717 1718 return this._trans('readwrite', function (trans) { 1719 return _this.core.mutate({ 1720 trans: trans, 1721 type: 'delete', 1722 keys: [key] 1723 }); 1724 }).then(function (res) { 1725 return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined; 1726 }); 1727 }; 1728 1729 Table.prototype.clear = function () { 1730 var _this = this; 1731 1732 return this._trans('readwrite', function (trans) { 1733 return _this.core.mutate({ 1734 trans: trans, 1735 type: 'deleteRange', 1736 range: AnyRange 1737 }); 1738 }).then(function (res) { 1739 return res.numFailures ? DexiePromise.reject(res.failures[0]) : undefined; 1740 }); 1741 }; 1742 1743 Table.prototype.bulkGet = function (keys) { 1744 var _this = this; 1745 1746 return this._trans('readonly', function (trans) { 1747 return _this.core.getMany({ 1748 keys: keys, 1749 trans: trans 1750 }).then(function (result) { 1751 return result.map(function (res) { 1752 return _this.hook.reading.fire(res); 1753 }); 1754 }); 1755 }); 1756 }; 1757 1758 Table.prototype.bulkAdd = function (objects, keysOrOptions, options) { 1759 var _this = this; 1760 1761 var keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined; 1762 options = options || (keys ? undefined : keysOrOptions); 1763 var wantResults = options ? options.allKeys : undefined; 1764 return this._trans('readwrite', function (trans) { 1765 var _a = _this.schema.primKey, 1766 auto = _a.auto, 1767 keyPath = _a.keyPath; 1768 if (keyPath && keys) throw new exceptions.InvalidArgument("bulkAdd(): keys argument invalid on tables with inbound keys"); 1769 if (keys && keys.length !== objects.length) throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length"); 1770 var numObjects = objects.length; 1771 var objectsToAdd = keyPath && auto ? objects.map(workaroundForUndef
1771inedPrimKey(keyPath)) : objects; 1772 return _this.core.mutate({ 1773 trans: trans, 1774 type: 'add', 1775 keys: keys, 1776 values: objectsToAdd, 1777 wantResults: wantResults 1778 }).then(function (_a) { 1779 var numFailures = _a.numFailures, 1780 results = _a.results, 1781 lastResult = _a.lastResult, 1782 failures = _a.failures; 1783 var result = wantResults ? results : lastResult; 1784 if (numFailures === 0) return result; 1785 throw new BulkError(_this.name + ".bulkAdd(): " + numFailures + " of " + numObjects + " operations failed", failures); 1786 }); 1787 }); 1788 }; 1789 1790 Table.prototype.bulkPut = function (objects, keysOrOptions, options) { 1791 var _this = this; 1792 1793 var keys = Array.isArray(keysOrOptions) ? keysOrOptions : undefined; 1794 options = options || (keys ? undefined : keysOrOptions); 1795 var wantResults = options ? options.allKeys : undefined; 1796 return this._trans('readwrite', function (trans) { 1797 var _a = _this.schema.primKey, 1798 auto = _a.auto, 1799 keyPath = _a.keyPath; 1800 if (keyPath && keys) throw new exceptions.InvalidArgument("bulkPut(): keys argument invalid on tables with inbound keys"); 1801 if (keys && keys.length !== objects.length) throw new exceptions.InvalidArgument("Arguments objects and keys must have the same length"); 1802 var numObjects = objects.length; 1803 var objectsToPut = keyPath && auto ? objects.map(workaroundForUndef
1803inedPrimKey(keyPath)) : objects; 1804 return _this.core.mutate({ 1805 trans: trans, 1806 type: 'put', 1807 keys: keys, 1808 values: objectsToPut, 1809 wantResults: wantResults 1810 }).then(function (_a) { 1811 var numFailures = _a.numFailures, 1812 results = _a.results, 1813 lastResult = _a.lastResult, 1814 failures = _a.failures; 1815 var result = wantResults ? results : lastResult; 1816 if (numFailures === 0) return result; 1817 throw new BulkError(_this.name + ".bulkPut(): " + numFailures + " of " + numObjects + " operations failed", failures); 1818 }); 1819 }); 1820 }; 1821 1822 Table.prototype.bulkDelete = function (keys) { 1823 var _this = this; 1824 1825 var numKeys = keys.length; 1826 return this._trans('readwrite', function (trans) { 1827 return _this.core.mutate({ 1828 trans: trans, 1829 type: 'delete', 1830 keys: keys 1831 }); 1832 }).then(function (_a) { 1833 var numFailures = _a.numFailures, 1834 lastResult = _a.lastResult, 1835 failures = _a.failures; 1836 if (numFailures === 0) return lastResult; 1837 throw new BulkError(_this.name + ".bulkDelete(): " + numFailures + " of " + numKeys + " operations failed", failures); 1838 }); 1839 }; 1840 1841 return Table; 1842 }(); 1843 1844 function Events(ctx) { 1845 var evs = {}; 1846 1847 var rv = function rv(eventName, subscriber) { 1848 if (subscriber) { 1849 var i = arguments.length, 1850 args = new Array(i - 1); 1851 1852 while (--i) { 1853 args[i - 1] = arguments[i]; 1854 } 1855 1856 evs[eventName].subscribe.apply(null, args); 1857 return ctx; 1858 } else if (typeof eventName === 'string') { 1859 return evs[eventName]; 1860 } 1861 }; 1862 1863 rv.addEventType = add; 1864 1865 for (var i = 1, l = arguments.length; i < l; ++i) { 1866 add(arguments[i]); 1867 } 1868 1869 return rv; 1870 1871 function add(eventName, chainFunction, defaultFunction) { 1872 if (babelHelpers["typeof"](eventName) === 'object') return addConfiguredEvents(eventName); 1873 if (!chainFunction) chainFunction = reverseStoppableEventChain; 1874 if (!defaultFunction) defaultFunction = nop; 1875 var context = { 1876 subscribers: [], 1877 fire: defaultFunction, 1878 subscribe: function subscribe(cb) { 1879 if (context.subscribers.indexOf(cb) === -1) { 1880 context.subscribers.push(cb); 1881 context.fire = chainFunction(context.fire, cb); 1882 } 1883 }, 1884 unsubscribe: function unsubscribe(cb) { 1885 context.subscribers = context.subscribers.filter(function (fn) { 1886 return fn !== cb; 1887 }); 1888 context.fire = context.subscribers.reduce(chainFunction, defaultFunction); 1889 } 1890 }; 1891 evs[eventName] = rv[eventName] = context; 1892 return context; 1893 } 1894 1895 function addConfiguredEvents(cfg) { 1896 keys(cfg).forEach(function (eventName) { 1897 var args = cfg[eventName]; 1898 1899 if (isArray(args)) { 1900 add(eventName, cfg[eventName][0], cfg[eventName][1]); 1901 } else if (args === 'asap') { 1902 var context = add(eventName, mirror, function fire() { 1903 var i = arguments.length, 1904 args = new Array(i); 1905 1906 while (i--) { 1907 args[i] = arguments[i]; 1908 } 1909 1910 context.subscribers.forEach(function (fn) { 1911 asap$1(function fireEvent() { 1912 fn.apply(null, args); 1913 }); 1914 }); 1915 }); 1916 } else throw new exceptions.InvalidArgument("Invalid event config"); 1917 }); 1918 } 1919 } 1920 1921 function makeClassConstructor(prototype, constructor) { 1922 derive(constructor).from({ 1923 prototype: prototype 1924 }); 1925 return constructor; 1926 } 1927 1928 function createTableConstructor(db) { 1929 return makeClassConstructor(Table.prototype, function Table(name, tableSchema, trans) { 1930 this.db = db; 1931 this._tx = trans; 1932 this.name = name; 1933 this.schema = tableSchema; 1934 this.hook = db._allTables[name] ? db._allTables[name].hook : Events(null, { 1935 "creating": [hookCreatingChain, nop], 1936 "reading": [pureFunctionChain, mirror], 1937 "updating": [hookUpdatingChain, nop], 1938 "deleting": [hookDeletingChain, nop] 1939 }); 1940 }); 1941 } 1942 1943 function isPlainKeyRange(ctx, ignoreLimitFilter) { 1944 return !(ctx.filter || ctx.algorithm || ctx.or) && (ignoreLimitFilter ? ctx.justLimit : !ctx.replayFilter); 1945 } 1946 1947 function addFilter(ctx, fn) {
vendor: 8,516 bytes, lines 1948-2256
1948 ctx.filter = combine(ctx.filter, fn); 1949 } 1950 1951 function addReplayFilter(ctx, factory, isLimitFilter) { 1952 var curr = ctx.replayFilter; 1953 ctx.replayFilter = curr ? function () { 1954 return combine(curr(), factory()); 1955 } : factory; 1956 ctx.justLimit = isLimitFilter && !curr; 1957 } 1958 1959 function addMatchFilter(ctx, fn) { 1960 ctx.isMatch = combine(ctx.isMatch, fn); 1961 } 1962 1963 function getIndexOrStore(ctx, coreSchema) { 1964 if (ctx.isPrimKey) return coreSchema.primaryKey; 1965 var index = coreSchema.getIndexByKeyPath(ctx.index); 1966 if (!index) throw new exceptions.Schema("KeyPath " + ctx.index + " on object store " + coreSchema.name + " is not indexed"); 1967 return index; 1968 } 1969 1970 function openCursor(ctx, coreTable, trans) { 1971 var index = getIndexOrStore(ctx, coreTable.schema); 1972 return coreTable.openCursor({ 1973 trans: trans, 1974 values: !ctx.keysOnly, 1975 reverse: ctx.dir === 'prev', 1976 unique: !!ctx.unique, 1977 query: { 1978 index: index, 1979 range: ctx.range 1980 } 1981 }); 1982 } 1983 1984 function iter(ctx, fn, coreTrans, coreTable) { 1985 var filter = ctx.replayFilter ? combine(ctx.filter, ctx.replayFilter()) : ctx.filter; 1986 1987 if (!ctx.or) { 1988 return iterate(openCursor(ctx, coreTable, coreTrans), combine(ctx.algorithm, filter), fn, !ctx.keysOnly && ctx.valueMapper); 1989 } else { 1990 var set_1 = {}; 1991 1992 var union = function union(item, cursor, advance) { 1993 if (!filter || filter(cursor, advance, function (result) { 1994 return cursor.stop(result); 1995 }, function (err) { 1996 return cursor.fail(err); 1997 })) { 1998 var primaryKey = cursor.primaryKey; 1999 var key = '' + primaryKey; 2000 if (key === '[object ArrayBuffer]') key = '' + new Uint8Array(primaryKey); 2001 2002 if (!hasOwn(set_1, key)) { 2003 set_1[key] = true; 2004 fn(item, cursor, advance); 2005 } 2006 } 2007 }; 2008 2009 return Promise.all([ctx.or._iterate(union, coreTrans), iterate(openCursor(ctx, coreTable, coreTrans), ctx.algorithm, union, !ctx.keysOnly && ctx.valueMapper)]); 2010 } 2011 } 2012 2013 function iterate(cursorPromise, filter, fn, valueMapper) { 2014 var mappedFn = valueMapper ? function (x, c, a) { 2015 return fn(valueMapper(x), c, a); 2016 } : fn; 2017 var wrappedFn = wrap(mappedFn); 2018 return cursorPromise.then(function (cursor) { 2019 if (cursor) { 2020 return cursor.start(function () { 2021 var c = function c() { 2022 return cursor["continue"](); 2023 }; 2024 2025 if (!filter || filter(cursor, function (advancer) { 2026 return c = advancer; 2027 }, function (val) { 2028 cursor.stop(val); 2029 c = nop; 2030 }, function (e) { 2031 cursor.fail(e); 2032 c = nop; 2033 })) wrappedFn(cursor.value, cursor, function (advancer) { 2034 return c = advancer; 2035 }); 2036 c(); 2037 }); 2038 } 2039 }); 2040 } 2041 2042 function cmp(a, b) { 2043 try { 2044 var ta = type(a); 2045 var tb = type(b); 2046 2047 if (ta !== tb) { 2048 if (ta === 'Array') return 1; 2049 if (tb === 'Array') return -1; 2050 if (ta === 'binary') return 1; 2051 if (tb === 'binary') return -1; 2052 if (ta === 'string') return 1; 2053 if (tb === 'string') return -1; 2054 if (ta === 'Date') return 1; 2055 if (tb !== 'Date') return NaN; 2056 return -1; 2057 } 2058 2059 switch (ta) { 2060 case 'number': 2061 case 'Date': 2062 case 'string': 2063 return a > b ? 1 : a < b ? -1 : 0; 2064 2065 case 'binary': 2066 { 2067 return compareUint8Arrays(getUint8Array(a), getUint8Array(b)); 2068 } 2069 2070 case 'Array': 2071 return compareArrays(a, b); 2072 } 2073 } catch (_a) {} 2074 2075 return NaN; 2076 } 2077 2078 function compareArrays(a, b) { 2079 var al = a.length; 2080 var bl = b.length; 2081 var l = al < bl ? al : bl; 2082 2083 for (var i = 0; i < l; ++i) { 2084 var res = cmp(a[i], b[i]); 2085 if (res !== 0) return res; 2086 } 2087 2088 return al === bl ? 0 : al < bl ? -1 : 1; 2089 } 2090 2091 function compareUint8Arrays(a, b) { 2092 var al = a.length; 2093 var bl = b.length; 2094 var l = al < bl ? al : bl; 2095 2096 for (var i = 0; i < l; ++i) { 2097 if (a[i] !== b[i]) return a[i] < b[i] ? -1 : 1; 2098 } 2099 2100 return al === bl ? 0 : al < bl ? -1 : 1; 2101 } 2102 2103 function type(x) { 2104 var t = babelHelpers["typeof"](x); 2105 if (t !== 'object') return t; 2106 if (ArrayBuffer.isView(x)) return 'binary'; 2107 var tsTag = toStringTag(x); 2108 return tsTag === 'ArrayBuffer' ? 'binary' : tsTag; 2109 } 2110 2111 function getUint8Array(a) { 2112 if (a instanceof Uint8Array) return a; 2113 if (ArrayBuffer.isView(a)) return new Uint8Array(a.buffer, a.byteOffset, a.byteLength); 2114 return new Uint8Array(a); 2115 } 2116 2117 var Collection = function () { 2118 function Collection() {} 2119 2120 Collection.prototype._read = function (fn, cb) { 2121 var ctx = this._ctx; 2122 return ctx.error ? ctx.table._trans(null, rejection.bind(null, ctx.error)) : ctx.table._trans('readonly', fn).then(cb); 2123 }; 2124 2125 Collection.prototype._write = function (fn) { 2126 var ctx = this._ctx; 2127 return ctx.error ? ctx.table._trans(null, rejection.bind(null, ctx.error)) : ctx.table._trans('readwrite', fn, "locked"); 2128 }; 2129 2130 Collection.prototype._addAlgorithm = function (fn) { 2131 var ctx = this._ctx; 2132 ctx.algorithm = combine(ctx.algorithm, fn); 2133 }; 2134 2135 Collection.prototype._iterate = function (fn, coreTrans) { 2136 return iter(this._ctx, fn, coreTrans, this._ctx.table.core); 2137 }; 2138 2139 Collection.prototype.clone = function (props) { 2140 var rv = Object.create(this.constructor.prototype), 2141 ctx = Object.create(this._ctx); 2142 if (props) extend(ctx, props); 2143 rv._ctx = ctx; 2144 return rv; 2145 }; 2146 2147 Collection.prototype.raw = function () { 2148 this._ctx.valueMapper = null; 2149 return this; 2150 }; 2151 2152 Collection.prototype.each = function (fn) { 2153 var ctx = this._ctx; 2154 return this._read(function (trans) { 2155 return iter(ctx, fn, trans, ctx.table.core); 2156 }); 2157 }; 2158 2159 Collection.prototype.count = function (cb) { 2160 var _this = this; 2161 2162 return this._read(function (trans) { 2163 var ctx = _this._ctx; 2164 var coreTable = ctx.table.core; 2165 2166 if (isPlainKeyRange(ctx, true)) { 2167 return coreTable.count({ 2168 trans: trans, 2169 query: { 2170 index: getIndexOrStore(ctx, coreTable.schema), 2171 range: ctx.range 2172 } 2173 }).then(function (count) { 2174 return Math.min(count, ctx.limit); 2175 }); 2176 } else { 2177 var count = 0; 2178 return iter(ctx, function () { 2179 ++count; 2180 return false; 2181 }, trans, coreTable).then(function () { 2182 return count; 2183 }); 2184 } 2185 }).then(cb); 2186 }; 2187 2188 Collection.prototype.sortBy = function (keyPath, cb) { 2189 var parts = keyPath.split('.').reverse(), 2190 lastPart = parts[0], 2191 lastIndex = parts.length - 1; 2192 2193 function getval(obj, i) { 2194 if (i) return getval(obj[parts[i]], i - 1); 2195 return obj[lastPart]; 2196 } 2197 2198 var order = this._ctx.dir === "next" ? 1 : -1; 2199 2200 function sorter(a, b) { 2201 var aVal = getval(a, lastIndex), 2202 bVal = getval(b, lastIndex); 2203 return aVal < bVal ? -order : aVal > bVal ? order : 0; 2204 } 2205 2206 return this.toArray(function (a) { 2207 return a.sort(sorter); 2208 }).then(cb); 2209 }; 2210 2211 Collection.prototype.toArray = function (cb) { 2212 var _this = this; 2213 2214 return this._read(function (trans) { 2215 var ctx = _this._ctx; 2216 2217 if (ctx.dir === 'next' && isPlainKeyRange(ctx, true) && ctx.limit > 0) { 2218 var valueMapper_1 = ctx.valueMapper; 2219 var index = getIndexOrStore(ctx, ctx.table.core.schema); 2220 return ctx.table.core.query({ 2221 trans: trans, 2222 limit: ctx.limit, 2223 values: true, 2224 query: { 2225 index: index, 2226 range: ctx.range 2227 } 2228 }).then(function (_a) { 2229 var result = _a.result; 2230 return valueMapper_1 ? result.map(valueMapper_1) : result; 2231 }); 2232 } else { 2233 var a_1 = []; 2234 return iter(ctx, function (item) { 2235 return a_1.push(item); 2236 }, trans, ctx.table.core).then(function () { 2237 return a_1; 2238 }); 2239 } 2240 }, cb); 2241 }; 2242 2243 Collection.prototype.offset = function (offset) { 2244 var ctx = this._ctx; 2245 if (offset <= 0) return this; 2246 ctx.offset += offset; 2247 2248 if (isPlainKeyRange(ctx)) { 2249 addReplayFilter(ctx, function () { 2250 var offsetLeft = offset; 2251 return function (cursor, advance) { 2252 if (offsetLeft === 0) return true; 2253 2254 if (offsetLeft === 1) { 2255 --offsetLeft; 2256 return false;
vendor: 4,904 bytes, lines 2257-2443
2257 } 2258 2259 advance(function () { 2260 cursor.advance(offsetLeft); 2261 offsetLeft = 0; 2262 }); 2263 return false; 2264 }; 2265 }); 2266 } else { 2267 addReplayFilter(ctx, function () { 2268 var offsetLeft = offset; 2269 return function () { 2270 return --offsetLeft < 0; 2271 }; 2272 }); 2273 } 2274 2275 return this; 2276 }; 2277 2278 Collection.prototype.limit = function (numRows) { 2279 this._ctx.limit = Math.min(this._ctx.limit, numRows); 2280 addReplayFilter(this._ctx, function () { 2281 var rowsLeft = numRows; 2282 return function (cursor, advance, resolve) { 2283 if (--rowsLeft <= 0) advance(resolve); 2284 return rowsLeft >= 0; 2285 }; 2286 }, true); 2287 return this; 2288 }; 2289 2290 Collection.prototype.until = function (filterFunction, bIncludeStopEntry) { 2291 addFilter(this._ctx, function (cursor, advance, resolve) { 2292 if (filterFunction(cursor.value)) { 2293 advance(resolve); 2294 return bIncludeStopEntry; 2295 } else { 2296 return true; 2297 } 2298 }); 2299 return this; 2300 }; 2301 2302 Collection.prototype.first = function (cb) { 2303 return this.limit(1).toArray(function (a) { 2304 return a[0]; 2305 }).then(cb); 2306 }; 2307 2308 Collection.prototype.last = function (cb) { 2309 return this.reverse().first(cb); 2310 }; 2311 2312 Collection.prototype.filter = function (filterFunction) { 2313 addFilter(this._ctx, function (cursor) { 2314 return filterFunction(cursor.value); 2315 }); 2316 addMatchFilter(this._ctx, filterFunction); 2317 return this; 2318 }; 2319 2320 Collection.prototype.and = function (filter) { 2321 return this.filter(filter); 2322 }; 2323 2324 Collection.prototype.or = function (indexName) { 2325 return new this.db.WhereClause(this._ctx.table, indexName, this); 2326 }; 2327 2328 Collection.prototype.reverse = function () { 2329 this._ctx.dir = this._ctx.dir === "prev" ? "next" : "prev"; 2330 if (this._ondirectionchange) this._ondirectionchange(this._ctx.dir); 2331 return this; 2332 }; 2333 2334 Collection.prototype.desc = function () { 2335 return this.reverse(); 2336 }; 2337 2338 Collection.prototype.eachKey = function (cb) { 2339 var ctx = this._ctx; 2340 ctx.keysOnly = !ctx.isMatch; 2341 return this.each(function (val, cursor) { 2342 cb(cursor.key, cursor); 2343 }); 2344 }; 2345 2346 Collection.prototype.eachUniqueKey = function (cb) { 2347 this._ctx.unique = "unique"; 2348 return this.eachKey(cb); 2349 }; 2350 2351 Collection.prototype.eachPrimaryKey = function (cb) { 2352 var ctx = this._ctx; 2353 ctx.keysOnly = !ctx.isMatch; 2354 return this.each(function (val, cursor) { 2355 cb(cursor.primaryKey, cursor); 2356 }); 2357 }; 2358 2359 Collection.prototype.keys = function (cb) { 2360 var ctx = this._ctx; 2361 ctx.keysOnly = !ctx.isMatch; 2362 var a = []; 2363 return this.each(function (item, cursor) { 2364 a.push(cursor.key); 2365 }).then(function () { 2366 return a; 2367 }).then(cb); 2368 }; 2369 2370 Collection.prototype.primaryKeys = function (cb) { 2371 var ctx = this._ctx; 2372 2373 if (ctx.dir === 'next' && isPlainKeyRange(ctx, true) && ctx.limit > 0) { 2374 return this._read(function (trans) { 2375 var index = getIndexOrStore(ctx, ctx.table.core.schema); 2376 return ctx.table.core.query({ 2377 trans: trans, 2378 values: false, 2379 limit: ctx.limit, 2380 query: { 2381 index: index, 2382 range: ctx.range 2383 } 2384 }); 2385 }).then(function (_a) { 2386 var result = _a.result; 2387 return result; 2388 }).then(cb); 2389 } 2390 2391 ctx.keysOnly = !ctx.isMatch; 2392 var a = []; 2393 return this.each(function (item, cursor) { 2394 a.push(cursor.primaryKey); 2395 }).then(function () { 2396 return a; 2397 }).then(cb); 2398 }; 2399 2400 Collection.prototype.uniqueKeys = function (cb) { 2401 this._ctx.unique = "unique"; 2402 return this.keys(cb); 2403 }; 2404 2405 Collection.prototype.firstKey = function (cb) { 2406 return this.limit(1).keys(function (a) { 2407 return a[0]; 2408 }).then(cb); 2409 }; 2410 2411 Collection.prototype.lastKey = function (cb) { 2412 return this.reverse().firstKey(cb); 2413 }; 2414 2415 Collection.prototype.distinct = function () { 2416 var ctx = this._ctx, 2417 idx = ctx.index && ctx.table.schema.idxByName[ctx.index]; 2418 if (!idx || !idx.multi) return this; 2419 var set = {}; 2420 addFilter(this._ctx, function (cursor) { 2421 var strKey = cursor.primaryKey.toString(); 2422 var found = hasOwn(set, strKey); 2423 set[strKey] = true; 2424 return !found; 2425 }); 2426 return this; 2427 }; 2428 2429 Collection.prototype.modify = function (changes) { 2430 var _this = this; 2431 2432 var ctx = this._ctx; 2433 return this._write(function (trans) { 2434 var modifyer; 2435 2436 if (typeof changes === 'function') { 2437 modifyer = changes; 2438 } else { 2439 var keyPaths = keys(changes); 2440 var numKeys = keyPaths.length; 2441 2442 modifyer = function modifyer(item) { 2443 var anythingModified = false;
2444 2445 for (var i = 0; i < numKeys; ++i) { 2446 var keyPath = keyPaths[i], 2447 val = changes[keyPath]; 2448 2449 if (getByKeyPath(item, keyPath) !== val) { 2450 setByKeyPath(item, keyPath, val); 2451 anythingModified = true; 2452 } 2453 } 2454 2455 return anythingModified; 2456 }; 2457 } 2458 2459 var coreTable = ctx.table.core; 2460 var _a = coreTable.schema.primaryKey, 2461 outbound = _a.outbound, 2462 extractKey = _a.extractKey; 2463 var limit = _this.db._options.modifyChunkSize || 200; 2464 var totalFailures = []; 2465 var successCount = 0; 2466 var failedKeys = []; 2467 2468 var applyMutateResult = function applyMutateResult(expectedCount, res) { 2469 var failures = res.failures, 2470 numFailures = res.numFailures; 2471 successCount += expectedCount - numFailures; 2472 2473 for (var _i = 0, _a = keys(failures); _i < _a.length; _i++) { 2474 var pos = _a[_i]; 2475 totalFailures.push(failures[pos]); 2476 } 2477 }; 2478 2479 return _this.clone().primaryKeys().then(function (keys) { 2480 var nextChunk = function nextChunk(offset) { 2481 var count = Math.min(limit, keys.length - offset); 2482 return coreTable.getMany({ 2483 trans: trans, 2484 keys: keys.slice(offset, offset + count), 2485 cache: "immutable" 2486 }).then(function (values) { 2487 var addValues = []; 2488 var putValues = []; 2489 var putKeys = outbound ? [] : null; 2490 var deleteKeys = []; 2491 2492 for (var i = 0; i < count; ++i) { 2493 var origValue = values[i]; 2494 var ctx_1 = { 2495 value: deepClone(origValue), 2496 primKey: keys[offset + i] 2497 }; 2498 2499 if (modifyer.call(ctx_1, ctx_1.value, ctx_1) !== false) { 2500 if (ctx_1.value == null) { 2501 deleteKeys.push(keys[offset + i]); 2502 } else if (!outbound && cmp(extractKey(origValue), extractKey(ctx_1.value)) !== 0) { 2503 deleteKeys.push(keys[offset + i]); 2504 addValues.push(ctx_1.value); 2505 } else { 2506 putValues.push(ctx_1.value); 2507 if (outbound) putKeys.push(keys[offset + i]); 2508 } 2509 } 2510 } 2511 2512 var criteria = isPlainKeyRange(ctx) && ctx.limit === Infinity && (typeof changes !== 'function' || changes === deleteCallback) && { 2513 index: ctx.index, 2514 range: ctx.range 2515 }; 2516 return Promise.resolve(addValues.length > 0 && coreTable.mutate({ 2517 trans: trans, 2518 type: 'add', 2519 values: addValues 2520 }).then(function (res) { 2521 for (var pos in res.failures) { 2522 deleteKeys.splice(parseInt(pos), 1); 2523 } 2524 2525 applyMutateResult(addValues.length, res); 2526 })).then(function () { 2527 return (putValues.length > 0 || criteria && babelHelpers["typeof"](changes) === 'object') && coreTable.mutate({ 2528 trans: trans, 2529 type: 'put', 2530 keys: putKeys, 2531 values: putValues, 2532 criteria: criteria, 2533 changeSpec: typeof changes !== 'function' && changes 2534 }).then(function (res) { 2535 return applyMutateResult(putValues.length, res); 2536 }); 2537 }).then(function () { 2538 return (deleteKeys.length > 0 || criteria && changes === deleteCallback) && coreTable.mutate({ 2539 trans: trans, 2540 type: 'delete', 2541 keys: deleteKeys, 2542 criteria: criteria 2543 }).then(function (res) { 2544 return applyMutateResult(deleteKeys.length, res); 2545 }); 2546 }).then(function () { 2547 return keys.length > offset + count && nextChunk(offset + limit); 2548 }); 2549 }); 2550 }; 2551 2552 return nextChunk(0).then(function () { 2553 if (totalFailures.length > 0) throw new ModifyError("Error modifying one or more objects", totalFailures, successCount, failedKeys); 2554 return keys.length; 2555 }); 2556 }); 2557 }); 2558 }; 2559 2560 Collection.prototype["delete"] = function () { 2561 var ctx = this._ctx, 2562 range = ctx.range; 2563 2564 if (isPlainKeyRange(ctx) && (ctx.isPrimKey && !hangsOnDeleteLargeKeyRange || range.type === 3)) { 2565 return this._write(function (trans) { 2566 var primaryKey = ctx.table.core.schema.primaryKey; 2567 var coreRange = range; 2568 return ctx.table.core.count({ 2569 trans: trans, 2570 query: { 2571 index: primaryKey, 2572 range: coreRange 2573 } 2574 }).then(function (count) { 2575 return ctx.table.core.mutate({ 2576 trans: trans, 2577 type: 'deleteRange', 2578 range: coreRange 2579 }).then(function (_a) { 2580 var failures = _a.failures; 2581 _a.lastResult; 2582 _a.results; 2583 var numFailures = _a.numFailures; 2584 if (numFailures) throw new ModifyError("Could not delete some values", Object.keys(failures).map(function (pos) { 2585 return failures[pos]; 2586 }), count - numFailures); 2587 return count - numFailures; 2588 }); 2589 }); 2590 }); 2591 } 2592 2593 return this.modify(deleteCallback); 2594 }; 2595 2596 return Collection; 2597 }(); 2598
vendor: 13,358 bytes, lines 2599-3048
2599 var deleteCallback = function deleteCallback(value, ctx) { 2600 return ctx.value = null; 2601 }; 2602 2603 function createCollectionConstructor(db) { 2604 return makeClassConstructor(Collection.prototype, function Collection(whereClause, keyRangeGenerator) { 2605 this.db = db; 2606 var keyRange = AnyRange, 2607 error = null; 2608 if (keyRangeGenerator) try { 2609 keyRange = keyRangeGenerator(); 2610 } catch (ex) { 2611 error = ex; 2612 } 2613 var whereCtx = whereClause._ctx; 2614 var table = whereCtx.table; 2615 var readingHook = table.hook.reading.fire; 2616 this._ctx = { 2617 table: table, 2618 index: whereCtx.index, 2619 isPrimKey: !whereCtx.index || table.schema.primKey.keyPath && whereCtx.index === table.schema.primKey.name, 2620 range: keyRange, 2621 keysOnly: false, 2622 dir: "next", 2623 unique: "", 2624 algorithm: null, 2625 filter: null, 2626 replayFilter: null, 2627 justLimit: true, 2628 isMatch: null, 2629 offset: 0, 2630 limit: Infinity, 2631 error: error, 2632 or: whereCtx.or, 2633 valueMapper: readingHook !== mirror ? readingHook : null 2634 }; 2635 }); 2636 } 2637 2638 function simpleCompare(a, b) { 2639 return a < b ? -1 : a === b ? 0 : 1; 2640 } 2641 2642 function simpleCompareReverse(a, b) { 2643 return a > b ? -1 : a === b ? 0 : 1; 2644 } 2645 2646 function fail(collectionOrWhereClause, err, T) { 2647 var collection = collectionOrWhereClause instanceof WhereClause ? new collectionOrWhereClause.Collection(collectionOrWhereClause) : collectionOrWhereClause; 2648 collection._ctx.error = T ? new T(err) : new TypeError(err); 2649 return collection; 2650 } 2651 2652 function emptyCollection(whereClause) { 2653 return new whereClause.Collection(whereClause, function () { 2654 return rangeEqual(""); 2655 }).limit(0); 2656 } 2657 2658 function upperFactory(dir) { 2659 return dir === "next" ? function (s) { 2660 return s.toUpperCase(); 2661 } : function (s) { 2662 return s.toLowerCase(); 2663 }; 2664 } 2665 2666 function lowerFactory(dir) { 2667 return dir === "next" ? function (s) { 2668 return s.toLowerCase(); 2669 } : function (s) { 2670 return s.toUpperCase(); 2671 }; 2672 } 2673 2674 function nextCasing(key, lowerKey, upperNeedle, lowerNeedle, cmp, dir) { 2675 var length = Math.min(key.length, lowerNeedle.length); 2676 var llp = -1; 2677 2678 for (var i = 0; i < length; ++i) { 2679 var lwrKeyChar = lowerKey[i]; 2680 2681 if (lwrKeyChar !== lowerNeedle[i]) { 2682 if (cmp(key[i], upperNeedle[i]) < 0) return key.substr(0, i) + upperNeedle[i] + upperNeedle.substr(i + 1); 2683 if (cmp(key[i], lowerNeedle[i]) < 0) return key.substr(0, i) + lowerNeedle[i] + upperNeedle.substr(i + 1); 2684 if (llp >= 0) return key.substr(0, llp) + lowerKey[llp] + upperNeedle.substr(llp + 1); 2685 return null; 2686 } 2687 2688 if (cmp(key[i], lwrKeyChar) < 0) llp = i; 2689 } 2690 2691 if (length < lowerNeedle.length && dir === "next") return key + upperNeedle.substr(key.length); 2692 if (length < key.length && dir === "prev") return key.substr(0, upperNeedle.length); 2693 return llp < 0 ? null : key.substr(0, llp) + lowerNeedle[llp] + upperNeedle.substr(llp + 1); 2694 } 2695 2696 function addIgnoreCaseAlgorithm(whereClause, match, needles, suffix) { 2697 var upper, 2698 lower, 2699 compare, 2700 upperNeedles, 2701 lowerNeedles, 2702 direction, 2703 nextKeySuffix, 2704 needlesLen = needles.length; 2705 2706 if (!needles.every(function (s) { 2707 return typeof s === 'string'; 2708 })) { 2709 return fail(whereClause, STRING_EXPECTED); 2710 } 2711 2712 function initDirection(dir) { 2713 upper = upperFactory(dir); 2714 lower = lowerFactory(dir); 2715 compare = dir === "next" ? simpleCompare : simpleCompareReverse; 2716 var needleBounds = needles.map(function (needle) { 2717 return { 2718 lower: lower(needle), 2719 upper: upper(needle) 2720 }; 2721 }).sort(function (a, b) { 2722 return compare(a.lower, b.lower); 2723 }); 2724 upperNeedles = needleBounds.map(function (nb) { 2725 return nb.upper; 2726 }); 2727 lowerNeedles = needleBounds.map(function (nb) { 2728 return nb.lower; 2729 }); 2730 direction = dir; 2731 nextKeySuffix = dir === "next" ? "" : suffix; 2732 } 2733 2734 initDirection("next"); 2735 var c = new whereClause.Collection(whereClause, function () { 2736 return createRange(upperNeedles[0], lowerNeedles[needlesLen - 1] + suffix); 2737 }); 2738 2739 c._ondirectionchange = function (direction) { 2740 initDirection(direction); 2741 }; 2742 2743 var firstPossibleNeedle = 0; 2744 2745 c._addAlgorithm(function (cursor, advance, resolve) { 2746 var key = cursor.key; 2747 if (typeof key !== 'string') return false; 2748 var lowerKey = lower(key); 2749 2750 if (match(lowerKey, lowerNeedles, firstPossibleNeedle)) { 2751 return true; 2752 } else { 2753 var lowestPossibleCasing = null; 2754 2755 for (var i = firstPossibleNeedle; i < needlesLen; ++i) { 2756 var casing = nextCasing(key, lowerKey, upperNeedles[i], lowerNeedles[i], compare, direction); 2757 if (casing === null && lowestPossibleCasing === null) firstPossibleNeedle = i + 1;else if (lowestPossibleCasing === null || compare(lowestPossibleCasing, casing) > 0) { 2758 lowestPossibleCasing = casing; 2759 } 2760 } 2761 2762 if (lowestPossibleCasing !== null) { 2763 advance(function () { 2764 cursor["continue"](lowestPossibleCasing + nextKeySuffix); 2765 }); 2766 } else { 2767 advance(resolve); 2768 } 2769 2770 return false; 2771 } 2772 }); 2773 2774 return c; 2775 } 2776 2777 function createRange(lower, upper, lowerOpen, upperOpen) { 2778 return { 2779 type: 2, 2780 lower: lower, 2781 upper: upper, 2782 lowerOpen: lowerOpen, 2783 upperOpen: upperOpen 2784 }; 2785 } 2786 2787 function rangeEqual(value) { 2788 return { 2789 type: 1, 2790 lower: value, 2791 upper: value 2792 }; 2793 } 2794 2795 var WhereClause = function () { 2796 function WhereClause() {} 2797 2798 Object.defineProperty(WhereClause.prototype, "Collection", { 2799 get: function get() { 2800 return this._ctx.table.db.Collection; 2801 }, 2802 enumerable: false, 2803 configurable: true 2804 }); 2805 2806 WhereClause.prototype.between = function (lower, upper, includeLower, includeUpper) { 2807 includeLower = includeLower !== false; 2808 includeUpper = includeUpper === true; 2809 2810 try { 2811 if (this._cmp(lower, upper) > 0 || this._cmp(lower, upper) === 0 && (includeLower || includeUpper) && !(includeLower && includeUpper)) return emptyCollection(this); 2812 return new this.Collection(this, function () { 2813 return createRange(lower, upper, !includeLower, !includeUpper); 2814 }); 2815 } catch (e) { 2816 return fail(this, INVALID_KEY_ARGUMENT); 2817 } 2818 }; 2819 2820 WhereClause.prototype.equals = function (value) { 2821 if (value == null) return fail(this, INVALID_KEY_ARGUMENT); 2822 return new this.Collection(this, function () { 2823 return rangeEqual(value); 2824 }); 2825 }; 2826 2827 WhereClause.prototype.above = function (value) { 2828 if (value == null) return fail(this, INVALID_KEY_ARGUMENT); 2829 return new this.Collection(this, function () { 2830 return createRange(value, undefined, true); 2831 }); 2832 }; 2833 2834 WhereClause.prototype.aboveOrEqual = function (value) { 2835 if (value == null) return fail(this, INVALID_KEY_ARGUMENT); 2836 return new this.Collection(this, function () { 2837 return createRange(value, undefined, false); 2838 }); 2839 }; 2840 2841 WhereClause.prototype.below = function (value) { 2842 if (value == null) return fail(this, INVALID_KEY_ARGUMENT); 2843 return new this.Collection(this, function () { 2844 return createRange(undefined, value, false, true); 2845 }); 2846 }; 2847 2848 WhereClause.prototype.belowOrEqual = function (value) { 2849 if (value == null) return fail(this, INVALID_KEY_ARGUMENT); 2850 return new this.Collection(this, function () { 2851 return createRange(undefined, value); 2852 }); 2853 }; 2854 2855 WhereClause.prototype.startsWith = function (str) { 2856 if (typeof str !== 'string') return fail(this, STRING_EXPECTED); 2857 return this.between(str, str + maxString, true, true); 2858 }; 2859 2860 WhereClause.prototype.startsWithIgnoreCase = function (str) { 2861 if (str === "") return this.startsWith(str); 2862 return addIgnoreCaseAlgorithm(this, function (x, a) { 2863 return x.indexOf(a[0]) === 0; 2864 }, [str], maxString); 2865 }; 2866 2867 WhereClause.prototype.equalsIgnoreCase = function (str) { 2868 return addIgnoreCaseAlgorithm(this, function (x, a) { 2869 return x === a[0]; 2870 }, [str], ""); 2871 }; 2872 2873 WhereClause.prototype.anyOfIgnoreCase = function () { 2874 var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments); 2875 if (set.length === 0) return emptyCollection(this); 2876 return addIgnoreCaseAlgorithm(this, function (x, a) { 2877 return a.indexOf(x) !== -1; 2878 }, set, ""); 2879 }; 2880 2881 WhereClause.prototype.startsWithAnyOfIgnoreCase = function () { 2882 var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments); 2883 if (set.length === 0) return emptyCollection(this); 2884 return addIgnoreCaseAlgorithm(this, function (x, a) { 2885 return a.some(function (n) { 2886 return x.indexOf(n) === 0; 2887 }); 2888 }, set, maxString); 2889 }; 2890 2891 WhereClause.prototype.anyOf = function () { 2892 var _this = this; 2893 2894 var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments); 2895 var compare = this._cmp; 2896 2897 try { 2898 set.sort(compare); 2899 } catch (e) { 2900 return fail(this, INVALID_KEY_ARGUMENT); 2901 } 2902 2903 if (set.length === 0) return emptyCollection(this); 2904 var c = new this.Collection(this, function () { 2905 return createRange(set[0], set[set.length - 1]); 2906 }); 2907 2908 c._ondirectionchange = function (direction) { 2909 compare = direction === "next" ? _this._ascending : _this._descending; 2910 set.sort(compare); 2911 }; 2912 2913 var i = 0; 2914 2915 c._addAlgorithm(function (cursor, advance, resolve) { 2916 var key = cursor.key; 2917 2918 while (compare(key, set[i]) > 0) { 2919 ++i; 2920 2921 if (i === set.length) { 2922 advance(resolve); 2923 return false; 2924 } 2925 } 2926 2927 if (compare(key, set[i]) === 0) { 2928 return true; 2929 } else { 2930 advance(function () { 2931 cursor["continue"](set[i]); 2932 }); 2933 return false; 2934 } 2935 }); 2936 2937 return c; 2938 }; 2939 2940 WhereClause.prototype.notEqual = function (value) { 2941 return this.inAnyRange([[minKey, value], [value, this.db._maxKey]], { 2942 includeLowers: false, 2943 includeUppers: false 2944 }); 2945 }; 2946 2947 WhereClause.prototype.noneOf = function () { 2948 var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments); 2949 if (set.length === 0) return new this.Collection(this); 2950 2951 try { 2952 set.sort(this._ascending); 2953 } catch (e) { 2954 return fail(this, INVALID_KEY_ARGUMENT); 2955 } 2956 2957 var ranges = set.reduce(function (res, val) { 2958 return res ? res.concat([[res[res.length - 1][1], val]]) : [[minKey, val]]; 2959 }, null); 2960 ranges.push([set[set.length - 1], this.db._maxKey]); 2961 return this.inAnyRange(ranges, { 2962 includeLowers: false, 2963 includeUppers: false 2964 }); 2965 }; 2966 2967 WhereClause.prototype.inAnyRange = function (ranges, options) { 2968 var _this = this; 2969 2970 var cmp = this._cmp, 2971 ascending = this._ascending, 2972 descending = this._descending, 2973 min = this._min, 2974 max = this._max; 2975 if (ranges.length === 0) return emptyCollection(this); 2976 2977 if (!ranges.every(function (range) { 2978 return range[0] !== undefined && range[1] !== undefined && ascending(range[0], range[1]) <= 0; 2979 })) { 2980 return fail(this, "First argument to inAnyRange() must be an Array of two-value Arrays [lower,upper] where upper must not be lower than lower", exceptions.InvalidArgument); 2981 } 2982 2983 var includeLowers = !options || options.includeLowers !== false; 2984 var includeUppers = options && options.includeUppers === true; 2985 2986 function addRange(ranges, newRange) { 2987 var i = 0, 2988 l = ranges.length; 2989 2990 for (; i < l; ++i) { 2991 var range = ranges[i]; 2992 2993 if (cmp(newRange[0], range[1]) < 0 && cmp(newRange[1], range[0]) > 0) { 2994 range[0] = min(range[0], newRange[0]); 2995 range[1] = max(range[1], newRange[1]); 2996 break; 2997 } 2998 } 2999 3000 if (i === l) ranges.push(newRange); 3001 return ranges; 3002 } 3003 3004 var sortDirection = ascending; 3005 3006 function rangeSorter(a, b) { 3007 return sortDirection(a[0], b[0]); 3008 } 3009 3010 var set; 3011 3012 try { 3013 set = ranges.reduce(addRange, []); 3014 set.sort(rangeSorter); 3015 } catch (ex) { 3016 return fail(this, INVALID_KEY_ARGUMENT); 3017 } 3018 3019 var rangePos = 0; 3020 var keyIsBeyondCurrentEntry = includeUppers ? function (key) { 3021 return ascending(key, set[rangePos][1]) > 0; 3022 } : function (key) { 3023 return ascending(key, set[rangePos][1]) >= 0; 3024 }; 3025 var keyIsBeforeCurrentEntry = includeLowers ? function (key) { 3026 return descending(key, set[rangePos][0]) > 0; 3027 } : function (key) { 3028 return descending(key, set[rangePos][0]) >= 0; 3029 }; 3030 3031 function keyWithinCurrentRange(key) { 3032 return !keyIsBeyondCurrentEntry(key) && !keyIsBeforeCurrentEntry(key); 3033 } 3034 3035 var checkKey = keyIsBeyondCurrentEntry; 3036 var c = new this.Collection(this, function () { 3037 return createRange(set[0][0], set[set.length - 1][1], !includeLowers, !includeUppers); 3038 }); 3039 3040 c._ondirectionchange = function (direction) { 3041 if (direction === "next") { 3042 checkKey = keyIsBeyondCurrentEntry; 3043 sortDirection = ascending; 3044 } else { 3045 checkKey = keyIsBeforeCurrentEntry; 3046 sortDirection = descending; 3047 } 3048
3049 set.sort(rangeSorter); 3050 }; 3051 3052 c._addAlgorithm(function (cursor, advance, resolve) { 3053 var key = cursor.key; 3054 3055 while (checkKey(key)) { 3056 ++rangePos; 3057 3058 if (rangePos === set.length) { 3059 advance(resolve); 3060 return false; 3061 } 3062 } 3063 3064 if (keyWithinCurrentRange(key)) { 3065 return true; 3066 } else if (_this._cmp(key, set[rangePos][1]) === 0 || _this._cmp(key, set[rangePos][0]) === 0) { 3067 return false; 3068 } else { 3069 advance(function () { 3070 if (sortDirection === ascending) cursor["continue"](set[rangePos][0]);else cursor["continue"](set[rangePos][1]); 3071 }); 3072 return false; 3073 } 3074 }); 3075 3076 return c; 3077 }; 3078 3079 WhereClause.prototype.startsWithAnyOf = function () { 3080 var set = getArrayOf.apply(NO_CHAR_ARRAY, arguments); 3081 3082 if (!set.every(function (s) { 3083 return typeof s === 'string'; 3084 })) { 3085 return fail(this, "startsWithAnyOf() only works with strings"); 3086 } 3087 3088 if (set.length === 0) return emptyCollection(this); 3089 return this.inAnyRange(set.map(function (str) { 3090 return [str, str + maxString]; 3091 })); 3092 }; 3093 3094 return WhereClause; 3095 }(); 3096 3097 function createWhereClauseConstructor(db) { 3098 return makeClassConstructor(WhereClause.prototype, function WhereClause(table, index, orCollection) { 3099 this.db = db; 3100 this._ctx = { 3101 table: table, 3102 index: index === ":id" ? null : index, 3103 or: orCollection 3104 }; 3105 var indexedDB = db._deps.indexedDB; 3106 if (!indexedDB) throw new exceptions.MissingAPI(); 3107 this._cmp = this._ascending = indexedDB.cmp.bind(indexedDB); 3108 3109 this._descending = function (a, b) { 3110 return indexedDB.cmp(b, a); 3111 }; 3112 3113 this._max = function (a, b) { 3114 return indexedDB.cmp(a, b) > 0 ? a : b; 3115 }; 3116 3117 this._min = function (a, b) { 3118 return indexedDB.cmp(a, b) < 0 ? a : b; 3119 }; 3120 3121 this._IDBKeyRange = db._deps.IDBKeyRange; 3122 }); 3123 } 3124 3125 function eventRejectHandler(reject) { 3126 return wrap(function (event) { 3127 preventDefault(event); 3128 reject(event.target.error); 3129 return false; 3130 }); 3131 } 3132 3133 function preventDefault(event) { 3134 if (event.stopPropagation) event.stopPropagation(); 3135 if (event.preventDefault) event.preventDefault(); 3136 } 3137 3138 var DEXIE_STORAGE_MUTATED_EVENT_NAME = 'storagemutated'; 3139 var STORAGE_MUTATED_DOM_EVENT_NAME = 'x-storagemutated-1'; 3140 var globalEvents = Events(null, DEXIE_STORAGE_MUTATED_EVENT_NAME); 3141 3142 var Transaction = function () { 3143 function Transaction() {} 3144 3145 Transaction.prototype._lock = function () { 3146 assert(!PSD.global); 3147 ++this._reculock; 3148 if (this._reculock === 1 && !PSD.global) PSD.lockOwnerFor = this; 3149 return this; 3150 }; 3151 3152 Transaction.prototype._unlock = function () { 3153 assert(!PSD.global); 3154 3155 if (--this._reculock === 0) { 3156 if (!PSD.global) PSD.lockOwnerFor = null; 3157 3158 while (this._blockedFuncs.length > 0 && !this._locked()) { 3159 var fnAndPSD = this._blockedFuncs.shift(); 3160 3161 try { 3162 usePSD(fnAndPSD[1], fnAndPSD[0]); 3163 } catch (e) {} 3164 } 3165 } 3166 3167 return this; 3168 }; 3169 3170 Transaction.prototype._locked = function () { 3171 return this._reculock && PSD.lockOwnerFor !== this; 3172 }; 3173 3174 Transaction.prototype.create = function (idbtrans) { 3175 var _this = this; 3176 3177 if (!this.mode) return this; 3178 var idbdb = this.db.idbdb; 3179 var dbOpenError = this.db._state.dbOpenError; 3180 assert(!this.idbtrans); 3181 3182 if (!idbtrans && !idbdb) { 3183 switch (dbOpenError && dbOpenError.name) { 3184 case "DatabaseClosedError": 3185 throw new exceptions.DatabaseClosed(dbOpenError); 3186 3187 case "MissingAPIError": 3188 throw new exceptions.MissingAPI(dbOpenError.message, dbOpenError); 3189 3190 default: 3191 throw new exceptions.OpenFailed(dbOpenError); 3192 } 3193 } 3194 3195 if (!this.active) throw new exceptions.TransactionInactive(); 3196 assert(this._completion._state === null); 3197 idbtrans = this.idbtrans = idbtrans || (this.db.core ? this.db.core.transaction(this.storeNames, this.mode, { 3198 durability: this.chromeTransactionDurability 3199 }) : idbdb.transaction(this.storeNames, this.mode, { 3200 durability: this.chromeTransactionDurability 3201 })); 3202 idbtrans.onerror = wrap(function (ev) { 3203 preventDefault(ev); 3204 3205 _this._reject(idbtrans.error); 3206 }); 3207 idbtrans.onabort = wrap(function (ev) { 3208 preventDefault(ev); 3209 _this.active && _this._reject(new exceptions.Abort(idbtrans.error)); 3210 _this.active = false;
3211 3212 _this.on("abort").fire(ev); 3213 }); 3214 idbtrans.oncomplete = wrap(function () { 3215 _this.active = false; 3216 3217 _this._resolve(); 3218 3219 if ('mutatedParts' in idbtrans) { 3220 globalEvents.storagemutated.fire(idbtrans["mutatedParts"]); 3221 } 3222 }); 3223 return this; 3224 }; 3225 3226 Transaction.prototype._promise = function (mode, fn, bWriteLock) { 3227 var _this = this; 3228 3229 if (mode === 'readwrite' && this.mode !== 'readwrite') return rejection(new exceptions.ReadOnly("Transaction is readonly")); 3230 if (!this.active) return rejection(new exceptions.TransactionInactive()); 3231 3232 if (this._locked()) { 3233 return new DexiePromise(function (resolve, reject) { 3234 _this._blockedFuncs.push([function () { 3235 _this._promise(mode, fn, bWriteLock).then(resolve, reject); 3236 }, PSD]); 3237 }); 3238 } else if (bWriteLock) { 3239 return newScope(function () { 3240 var p = new DexiePromise(function (resolve, reject) { 3241 _this._lock(); 3242 3243 var rv = fn(resolve, reject, _this); 3244 if (rv && rv.then) rv.then(resolve, reject); 3245 }); 3246 p["finally"](function () { 3247 return _this._unlock(); 3248 }); 3249 p._lib = true; 3250 return p; 3251 }); 3252 } else { 3253 var p = new DexiePromise(function (resolve, reject) { 3254 var rv = fn(resolve, reject, _this); 3255 if (rv && rv.then) rv.then(resolve, reject); 3256 }); 3257 p._lib = true; 3258 return p; 3259 } 3260 }; 3261 3262 Transaction.prototype._root = function () { 3263 return this.parent ? this.parent._root() : this; 3264 }; 3265 3266 Transaction.prototype.waitFor = function (promiseLike) { 3267 var root = this._root(); 3268 3269 var promise = DexiePromise.resolve(promiseLike); 3270 3271 if (root._waitingFor) { 3272 root._waitingFor = root._waitingFor.then(function () { 3273 return promise; 3274 }); 3275 } else { 3276 root._waitingFor = promise; 3277 root._waitingQueue = []; 3278 var store = root.idbtrans.objectStore(root.storeNames[0]); 3279 3280 (function spin() { 3281 ++root._spinCount; 3282 3283 while (root._waitingQueue.length) { 3284 root._waitingQueue.shift()(); 3285 } 3286 3287 if (root._waitingFor) store.get(-Infinity).onsuccess = spin; 3288 })(); 3289 } 3290 3291 var currentWaitPromise = root._waitingFor; 3292 return new DexiePromise(function (resolve, reject) { 3293 promise.then(function (res) { 3294 return root._waitingQueue.push(wrap(resolve.bind(null, res))); 3295 }, function (err) { 3296 return root._waitingQueue.push(wrap(reject.bind(null, err))); 3297 })["finally"](function () { 3298 if (root._waitingFor === currentWaitPromise) { 3299 root._waitingFor = null; 3300 } 3301 }); 3302 }); 3303 }; 3304 3305 Transaction.prototype.abort = function () { 3306 if (this.active) { 3307 this.active = false; 3308 if (this.idbtrans) this.idbtrans.abort(); 3309 3310 this._reject(new exceptions.Abort()); 3311 } 3312 }; 3313 3314 Transaction.prototype.table = function (tableName) { 3315 var memoizedTables = this._memoizedTables || (this._memoizedTables = {}); 3316 if (hasOwn(memoizedTables, tableName)) return memoizedTables[tableName]; 3317 var tableSchema = this.schema[tableName]; 3318 3319 if (!tableSchema) { 3320 throw new exceptions.NotFound("Table " + tableName + " not part of transaction"); 3321 } 3322 3323 var transactionBoundTable = new this.db.Table(tableName, tableSchema, this); 3324 transactionBoundTable.core = this.db.core.table(tableName); 3325 memoizedTables[tableName] = transactionBoundTable; 3326 return transactionBoundTable; 3327 }; 3328 3329 return Transaction; 3330 }(); 3331 3332 function createTransactionConstructor(db) { 3333 return makeClassConstructor(Transaction.prototype, function Transaction(mode, storeNames, dbschema, chromeTransactionDurability, parent) { 3334 var _this = this; 3335 3336 this.db = db; 3337 this.mode = mode; 3338 this.storeNames = storeNames; 3339 this.schema = dbschema; 3340 this.chromeTransactionDurability = chromeTransactionDurability; 3341 this.idbtrans = null; 3342 this.on = Events(this, "complete", "error", "abort"); 3343 this.parent = parent || null; 3344 this.active = true; 3345 this._reculock = 0; 3346 this._blockedFuncs = []; 3347 this._resolve = null; 3348 this._reject = null; 3349 this._waitingFor = null; 3350 this._waitingQueue = null; 3351 this._spinCount = 0; 3352 this._completion = new DexiePromise(function (resolve, reject) { 3353 _this._resolve = resolve; 3354 _this._reject = reject; 3355 }); 3356 3357 this._completion.then(function () { 3358 _this.active = false;
3359 3360 _this.on.complete.fire(); 3361 }, function (e) { 3362 var wasActive = _this.active; 3363 _this.active = false; 3364 3365 _this.on.error.fire(e); 3366 3367 _this.parent ? _this.parent._reject(e) : wasActive && _this.idbtrans && _this.idbtrans.abort(); 3368 return rejection(e); 3369 }); 3370 }); 3371 } 3372 3373 function createIndexSpec(name, keyPath, unique, multi, auto, compound, isPrimKey) { 3374 return { 3375 name: name, 3376 keyPath: keyPath, 3377 unique: unique, 3378 multi: multi, 3379 auto: auto, 3380 compound: compound, 3381 src: (unique && !isPrimKey ? '&' : '') + (multi ? '*' : '') + (auto ? "++" : "") + nameFromKeyPath(keyPath) 3382 }; 3383 } 3384 3385 function nameFromKeyPath(keyPath) { 3386 return typeof keyPath === 'string' ? keyPath : keyPath ? '[' + [].join.call(keyPath, '+') + ']' : ""; 3387 } 3388 3389 function createTableSchema(name, primKey, indexes) { 3390 return { 3391 name: name, 3392 primKey: primKey, 3393 indexes: indexes, 3394 mappedClass: null, 3395 idxByName: arrayToObject(indexes, function (index) { 3396 return [index.name, index]; 3397 }) 3398 }; 3399 } 3400 3401 function safariMultiStoreFix(storeNames) { 3402 return storeNames.length === 1 ? storeNames[0] : storeNames; 3403 } 3404 3405 var _getMaxKey = function getMaxKey(IdbKeyRange) { 3406 try { 3407 IdbKeyRange.only([[]]); 3408 3409 _getMaxKey = function getMaxKey() { 3410 return [[]]; 3411 }; 3412 3413 return [[]]; 3414 } catch (e) { 3415 _getMaxKey = function getMaxKey() { 3416 return maxString; 3417 }; 3418 3419 return maxString; 3420 } 3421 }; 3422 3423 function getKeyExtractor(keyPath) { 3424 if (keyPath == null) { 3425 return function () { 3426 return undefined; 3427 }; 3428 } else if (typeof keyPath === 'string') { 3429 return getSinglePathKeyExtractor(keyPath); 3430 } else { 3431 return function (obj) { 3432 return getByKeyPath(obj, keyPath); 3433 }; 3434 } 3435 } 3436 3437 function getSinglePathKeyExtractor(keyPath) { 3438 var split = keyPath.split('.'); 3439 3440 if (split.length === 1) { 3441 return function (obj) { 3442 return obj[keyPath]; 3443 }; 3444 } else { 3445 return function (obj) { 3446 return getByKeyPath(obj, keyPath); 3447 }; 3448 } 3449 } 3450 3451 function arrayify(arrayLike) { 3452 return [].slice.call(arrayLike); 3453 } 3454 3455 var _id_counter = 0; 3456 3457 function getKeyPathAlias(keyPath) { 3458 return keyPath == null ? ":id" : typeof keyPath === 'string' ? keyPath : "[" + keyPath.join('+') + "]"; 3459 } 3460 3461 function createDBCore(db, IdbKeyRange, tmpTrans) { 3462 function extractSchema(db, trans) { 3463 var tables = arrayify(db.objectStoreNames); 3464 return { 3465 schema: { 3466 name: db.name, 3467 tables: tables.map(function (table) { 3468 return trans.objectStore(table); 3469 }).map(function (store) { 3470 var keyPath = store.keyPath, 3471 autoIncrement = store.autoIncrement; 3472 var compound = isArray(keyPath); 3473 var outbound = keyPath == null; 3474 var indexByKeyPath = {}; 3475 var result = { 3476 name: store.name, 3477 primaryKey: { 3478 name: null, 3479 isPrimaryKey: true, 3480 outbound: outbound, 3481 compound: compound, 3482 keyPath: keyPath, 3483 autoIncrement: autoIncrement, 3484 unique: true, 3485 extractKey: getKeyExtractor(keyPath) 3486 }, 3487 indexes: arrayify(store.indexNames).map(function (indexName) { 3488 return store.index(indexName); 3489 }).map(function (index) { 3490 var name = index.name, 3491 unique = index.unique, 3492 multiEntry = index.multiEntry, 3493 keyPath = index.keyPath; 3494 var compound = isArray(keyPath); 3495 var result = { 3496 name: name, 3497 compound: compound, 3498 keyPath: keyPath, 3499 unique: unique, 3500 multiEntry: multiEntry, 3501 extractKey: getKeyExtractor(keyPath) 3502 }; 3503 indexByKeyPath[getKeyPathAlias(keyPath)] = result; 3504 return result; 3505 }), 3506 getIndexByKeyPath: function getIndexByKeyPath(keyPath) { 3507 return indexByKeyPath[getKeyPathAlias(keyPath)]; 3508 } 3509 }; 3510 indexByKeyPath[":id"] = result.primaryKey; 3511 3512 if (keyPath != null) { 3513 indexByKeyPath[getKeyPathAlias(keyPath)] = result.primaryKey; 3514 } 3515 3516 return result; 3517 }) 3518 }, 3519 hasGetAll: tables.length > 0 && 'getAll' in trans.objectStore(tables[0]) && !(typeof navigator !== 'undefined' && /Safari/.test(navigator.userAgent) && !/(Chrome\/|Edge\/)/.test(navigator.userAgent) && [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604) 3520 }; 3521 } 3522 3523 function makeIDBKeyRange(range) { 3524 if (range.type === 3) return null; 3525 if (range.type === 4) throw new Error("Cannot convert never type to IDBKeyRange"); 3526 var lower = range.lower, 3527 upper = range.upper, 3528 lowerOpen = range.lowerOpen, 3529 upperOpen = range.upperOpen; 3530 var idbRange = lower === undefined ? upper === undefined ? null : IdbKeyRange.upperBound(upper, !!upperOpen) : upper === undefined ? IdbKeyRange.lowerBound(lower, !!lowerOpen) : IdbKeyRange.bound(lower, upper, !!lowerOpen, !!upperOpen); 3531 return idbRange; 3532 } 3533 3534 function createDbCoreTable(tableSchema) { 3535 var tableName = tableSchema.name; 3536 3537 function mutate(_a) { 3538 var trans = _a.trans, 3539 type = _a.type, 3540 keys = _a.keys, 3541 values = _a.values, 3542 range = _a.range; 3543 return new Promise(function (resolve, reject) { 3544 resolve = wrap(resolve); 3545 var store = trans.objectStore(tableName); 3546 var outbound = store.keyPath == null; 3547 var isAddOrPut = type === "put" || type === "add"; 3548 if (!isAddOrPut && type !== 'delete' && type !== 'deleteRange') throw new Error("Invalid operation type: " + type); 3549 var length = (keys || values || { 3550 length: 1 3551 }).length; 3552 3553 if (keys && values && keys.length !== values.length) { 3554 throw new Error("Given keys array must have same length as given values array."); 3555 } 3556 3557 if (length === 0) return resolve({ 3558 numFailures: 0, 3559 failures: {}, 3560 results: [], 3561 lastResult: undefined 3562 }); 3563 var req; 3564 var reqs = []; 3565 var failures = []; 3566 var numFailures = 0; 3567 3568 var errorHandler = function errorHandler(event) { 3569 ++numFailures; 3570 preventDefault(event); 3571 }; 3572 3573 if (type === 'deleteRange') { 3574 if (range.type === 4) return resolve({ 3575 numFailures: numFailures, 3576 failures: failures, 3577 results: [], 3578 lastResult: undefined 3579 }); 3580 if (range.type === 3) reqs.push(req = store.clear());else reqs.push(req = store["delete"](makeIDBKeyRange(range))); 3581 } else { 3582 var _a = isAddOrPut ? outbound ? [values, keys] : [values, null] : [keys, null], 3583 args1 = _a[0], 3584 args2 = _a[1]; 3585 3586 if (isAddOrPut) { 3587 for (var i = 0; i < length; ++i) { 3588 reqs.push(req = args2 && args2[i] !== undefined ? store[type](args1[i], args2[i]) : store[type](args1[i])); 3589 req.onerror = errorHandler; 3590 } 3591 } else { 3592 for (var i = 0; i < length; ++i) { 3593 reqs.push(req = store[type](args1[i])); 3594 req.onerror = errorHandler; 3595 } 3596 } 3597 } 3598 3599 var done = function done(event) { 3600 var lastResult = event.target.result;
3601 reqs.forEach(function (req, i) { 3602 return req.error != null && (failures[i] = req.error); 3603 }); 3604 resolve({ 3605 numFailures: numFailures, 3606 failures: failures, 3607 results: type === "delete" ? keys : reqs.map(function (req) { 3608 return req.result; 3609 }), 3610 lastResult: lastResult 3611 }); 3612 }; 3613 3614 req.onerror = function (event) { 3615 errorHandler(event); 3616 done(event); 3617 }; 3618 3619 req.onsuccess = done; 3620 }); 3621 } 3622 3623 function openCursor(_a) { 3624 var trans = _a.trans, 3625 values = _a.values, 3626 query = _a.query, 3627 reverse = _a.reverse, 3628 unique = _a.unique; 3629 return new Promise(function (resolve, reject) { 3630 resolve = wrap(resolve); 3631 var index = query.index, 3632 range = query.range; 3633 var store = trans.objectStore(tableName); 3634 var source = index.isPrimaryKey ? store : store.index(index.name); 3635 var direction = reverse ? unique ? "prevunique" : "prev" : unique ? "nextunique" : "next"; 3636 var req = values || !('openKeyCursor' in source) ? source.openCursor(makeIDBKeyRange(range), direction) : source.openKeyCursor(makeIDBKeyRange(range), direction); 3637 req.onerror = eventRejectHandler(reject); 3638 req.onsuccess = wrap(function (ev) { 3639 var cursor = req.result; 3640 3641 if (!cursor) { 3642 resolve(null); 3643 return; 3644 } 3645 3646 cursor.___id = ++_id_counter; 3647 cursor.done = false; 3648 3649 var _cursorContinue = cursor["continue"].bind(cursor); 3650 3651 var _cursorContinuePrimaryKey = cursor.continuePrimaryKey; 3652 if (_cursorContinuePrimaryKey) _cursorContinuePrimaryKey = _cursorContinuePrimaryKey.bind(cursor); 3653 3654 var _cursorAdvance = cursor.advance.bind(cursor); 3655 3656 var doThrowCursorIsNotStarted = function doThrowCursorIsNotStarted() { 3657 throw new Error("Cursor not started"); 3658 }; 3659 3660 var doThrowCursorIsStopped = function doThrowCursorIsStopped() { 3661 throw new Error("Cursor not stopped"); 3662 }; 3663 3664 cursor.trans = trans; 3665 cursor.stop = cursor["continue"] = cursor.continuePrimaryKey = cursor.advance = doThrowCursorIsNotStarted; 3666 cursor.fail = wrap(reject); 3667 3668 cursor.next = function () { 3669 var _this = this; 3670 3671 var gotOne = 1; 3672 return this.start(function () { 3673 return gotOne-- ? _this["continue"]() : _this.stop(); 3674 }).then(function () { 3675 return _this; 3676 }); 3677 }; 3678 3679 cursor.start = function (callback) { 3680 var iterationPromise = new Promise(function (resolveIteration, rejectIteration) { 3681 resolveIteration = wrap(resolveIteration); 3682 req.onerror = eventRejectHandler(rejectIteration); 3683 cursor.fail = rejectIteration; 3684 3685 cursor.stop = function (value) { 3686 cursor.stop = cursor["continue"] = cursor.continuePrimaryKey = cursor.advance = doThrowCursorIsStopped; 3687 resolveIteration(value); 3688 }; 3689 }); 3690 3691 var guardedCallback = function guardedCallback() { 3692 if (req.result) { 3693 try { 3694 callback(); 3695 } catch (err) { 3696 cursor.fail(err); 3697 } 3698 } else { 3699 cursor.done = true; 3700 3701 cursor.start = function () { 3702 throw new Error("Cursor behind last entry"); 3703 }; 3704 3705 cursor.stop(); 3706 } 3707 }; 3708 3709 req.onsuccess = wrap(function (ev) { 3710 req.onsuccess = guardedCallback; 3711 guardedCallback(); 3712 }); 3713 cursor["continue"] = _cursorContinue; 3714 cursor.continuePrimaryKey = _cursorContinuePrimaryKey; 3715 cursor.advance = _cursorAdvance; 3716 guardedCallback(); 3717 return iterationPromise; 3718 }; 3719 3720 resolve(cursor); 3721 }, reject); 3722 }); 3723 } 3724 3725 function query(hasGetAll) { 3726 return function (request) { 3727 return new Promise(function (resolve, reject) { 3728 resolve = wrap(resolve); 3729 var trans = request.trans, 3730 values = request.values, 3731 limit = request.limit, 3732 query = request.query; 3733 var nonInfinitLimit = limit === Infinity ? undefined : limit; 3734 var index = query.index, 3735 range = query.range; 3736 var store = trans.objectStore(tableName); 3737 var source = index.isPrimaryKey ? store : store.index(index.name); 3738 var idbKeyRange = makeIDBKeyRange(range); 3739 if (limit === 0) return resolve({ 3740 result: [] 3741 }); 3742 3743 if (hasGetAll) { 3744 var req = values ? source.getAll(idbKeyRange, nonInfinitLimit) : source.getAllKeys(idbKeyRange, nonInfinitLimit); 3745 3746 req.onsuccess = function (event) { 3747 return resolve({ 3748 result: event.target.result 3749 }); 3750 }; 3751 3752 req.onerror = eventRejectHandler(reject); 3753 } else { 3754 var count_1 = 0; 3755 var req_1 = values || !('openKeyCursor' in source) ? source.openCursor(idbKeyRange) : source.openKeyCursor(idbKeyRange); 3756 var result_1 = []; 3757 3758 req_1.onsuccess = function (event) { 3759 var cursor = req_1.result; 3760 if (!cursor) return resolve({ 3761 result: result_1 3762 });
3763 result_1.push(values ? cursor.value : cursor.primaryKey); 3764 if (++count_1 === limit) return resolve({ 3765 result: result_1 3766 }); 3767 cursor["continue"](); 3768 }; 3769 3770 req_1.onerror = eventRejectHandler(reject); 3771 } 3772 }); 3773 }; 3774 } 3775 3776 return { 3777 name: tableName, 3778 schema: tableSchema, 3779 mutate: mutate, 3780 getMany: function getMany(_a) { 3781 var trans = _a.trans, 3782 keys = _a.keys; 3783 return new Promise(function (resolve, reject) { 3784 resolve = wrap(resolve); 3785 var store = trans.objectStore(tableName); 3786 var length = keys.length; 3787 var result = new Array(length); 3788 var keyCount = 0; 3789 var callbackCount = 0; 3790 var req; 3791 3792 var successHandler = function successHandler(event) { 3793 var req = event.target; 3794 if ((result[req._pos] = req.result) != null) ; 3795 if (++callbackCount === keyCount) resolve(result); 3796 }; 3797 3798 var errorHandler = eventRejectHandler(reject); 3799 3800 for (var i = 0; i < length; ++i) { 3801 var key = keys[i]; 3802 3803 if (key != null) { 3804 req = store.get(keys[i]); 3805 req._pos = i; 3806 req.onsuccess = successHandler; 3807 req.onerror = errorHandler; 3808 ++keyCount; 3809 } 3810 } 3811 3812 if (keyCount === 0) resolve(result); 3813 }); 3814 }, 3815 get: function get(_a) { 3816 var trans = _a.trans, 3817 key = _a.key; 3818 return new Promise(function (resolve, reject) { 3819 resolve = wrap(resolve); 3820 var store = trans.objectStore(tableName); 3821 var req = store.get(key); 3822 3823 req.onsuccess = function (event) { 3824 return resolve(event.target.result); 3825 }; 3826 3827 req.onerror = eventRejectHandler(reject); 3828 }); 3829 }, 3830 query: query(hasGetAll), 3831 openCursor: openCursor, 3832 count: function count(_a) { 3833 var query = _a.query, 3834 trans = _a.trans; 3835 var index = query.index, 3836 range = query.range; 3837 return new Promise(function (resolve, reject) { 3838 var store = trans.objectStore(tableName); 3839 var source = index.isPrimaryKey ? store : store.index(index.name); 3840 var idbKeyRange = makeIDBKeyRange(range); 3841 var req = idbKeyRange ? source.count(idbKeyRange) : source.count(); 3842 req.onsuccess = wrap(function (ev) { 3843 return resolve(ev.target.result); 3844 }); 3845 req.onerror = eventRejectHandler(reject); 3846 }); 3847 } 3848 }; 3849 } 3850 3851 var _a = extractSchema(db, tmpTrans), 3852 schema = _a.schema, 3853 hasGetAll = _a.hasGetAll; 3854 3855 var tables = schema.tables.map(function (tableSchema) { 3856 return createDbCoreTable(tableSchema); 3857 }); 3858 var tableMap = {}; 3859 tables.forEach(function (table) { 3860 return tableMap[table.name] = table; 3861 }); 3862 return { 3863 stack: "dbcore", 3864 transaction: db.transaction.bind(db), 3865 table: function table(name) { 3866 var result = tableMap[name]; 3867 if (!result) throw new Error("Table '" + name + "' not found"); 3868 return tableMap[name]; 3869 }, 3870 MIN_KEY: -Infinity, 3871 MAX_KEY: _getMaxKey(IdbKeyRange), 3872 schema: schema 3873 }; 3874 } 3875 3876 function createMiddlewareStack(stackImpl, middlewares) { 3877 return middlewares.reduce(function (down, _a) { 3878 var create = _a.create; 3879 return _assign(_assign({}, down), create(down)); 3880 }, stackImpl); 3881 } 3882 3883 function createMiddlewareStacks(middlewares, idbdb, _a, tmpTrans) { 3884 var IDBKeyRange = _a.IDBKeyRange; 3885 _a.indexedDB; 3886 var dbcore = createMiddlewareStack(createDBCore(idbdb, IDBKeyRange, tmpTrans), middlewares.dbcore); 3887 return { 3888 dbcore: dbcore 3889 }; 3890 } 3891 3892 function generateMiddlewareStacks(_a, tmpTrans) { 3893 var db = _a._novip; 3894 var idbdb = tmpTrans.db; 3895 var stacks = createMiddlewareStacks(db._middlewares, idbdb, db._deps, tmpTrans); 3896 db.core = stacks.dbcore;
3897 db.tables.forEach(function (table) { 3898 var tableName = table.name; 3899 3900 if (db.core.schema.tables.some(function (tbl) { 3901 return tbl.name === tableName; 3902 })) { 3903 table.core = db.core.table(tableName); 3904 3905 if (db[tableName] instanceof db.Table) { 3906 db[tableName].core = table.core; 3907 } 3908 } 3909 }); 3910 } 3911 3912 function setApiOnPlace(_a, objs, tableNames, dbschema) { 3913 var db = _a._novip; 3914 tableNames.forEach(function (tableName) { 3915 var schema = dbschema[tableName]; 3916 objs.forEach(function (obj) { 3917 var propDesc = getPropertyDescriptor(obj, tableName); 3918 3919 if (!propDesc || "value" in propDesc && propDesc.value === undefined) { 3920 if (obj === db.Transaction.prototype || obj instanceof db.Transaction) { 3921 setProp(obj, tableName, { 3922 get: function get() { 3923 return this.table(tableName); 3924 }, 3925 set: function set(value) { 3926 defineProperty(this, tableName, { 3927 value: value, 3928 writable: true, 3929 configurable: true, 3930 enumerable: true 3931 }); 3932 } 3933 }); 3934 } else { 3935 obj[tableName] = new db.Table(tableName, schema); 3936 } 3937 } 3938 }); 3939 }); 3940 } 3941 3942 function removeTablesApi(_a, objs) { 3943 var db = _a._novip; 3944 objs.forEach(function (obj) { 3945 for (var key in obj) { 3946 if (obj[key] instanceof db.Table) delete obj[key]; 3947 } 3948 }); 3949 } 3950 3951 function lowerVersionFirst(a, b) { 3952 return a._cfg.version - b._cfg.version; 3953 } 3954 3955 function runUpgraders(db, oldVersion, idbUpgradeTrans, reject) { 3956 var globalSchema = db._dbSchema; 3957 3958 var trans = db._createTransaction('readwrite', db._storeNames, globalSchema); 3959 3960 trans.create(idbUpgradeTrans); 3961 3962 trans._completion["catch"](reject); 3963 3964 var rejectTransaction = trans._reject.bind(trans); 3965 3966 var transless = PSD.transless || PSD; 3967 newScope(function () { 3968 PSD.trans = trans; 3969 PSD.transless = transless; 3970 3971 if (oldVersion === 0) { 3972 keys(globalSchema).forEach(function (tableName) { 3973 createTable(idbUpgradeTrans, tableName, globalSchema[tableName].primKey, globalSchema[tableName].indexes); 3974 }); 3975 generateMiddlewareStacks(db, idbUpgradeTrans); 3976 DexiePromise.follow(function () { 3977 return db.on.populate.fire(trans); 3978 })["catch"](rejectTransaction); 3979 } else updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans)["catch"](rejectTransaction); 3980 }); 3981 } 3982 3983 function updateTablesAndIndexes(_a, oldVersion, trans, idbUpgradeTrans) { 3984 var db = _a._novip; 3985 var queue = []; 3986 var versions = db._versions; 3987 var globalSchema = db._dbSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans); 3988 var anyContentUpgraderHasRun = false; 3989 var versToRun = versions.filter(function (v) { 3990 return v._cfg.version >= oldVersion; 3991 }); 3992 versToRun.forEach(function (version) { 3993 queue.push(function () { 3994 var oldSchema = globalSchema; 3995 var newSchema = version._cfg.dbschema; 3996 adjustToExistingIndexNames(db, oldSchema, idbUpgradeTrans); 3997 adjustToExistingIndexNames(db, newSchema, idbUpgradeTrans); 3998 globalSchema = db._dbSchema = newSchema; 3999 var diff = getSchemaDiff(oldSchema, newSchema); 4000 diff.add.forEach(function (tuple) { 4001 createTable(idbUpgradeTrans, tuple[0], tuple[1].primKey, tuple[1].indexes); 4002 }); 4003 diff.change.forEach(function (change) { 4004 if (change.recreate) { 4005 throw new exceptions.Upgrade("Not yet support for changing primary key"); 4006 } else { 4007 var store_1 = idbUpgradeTrans.objectStore(change.name); 4008 change.add.forEach(function (idx) { 4009 return addIndex(store_1, idx); 4010 }); 4011 change.change.forEach(function (idx) { 4012 store_1.deleteIndex(idx.name); 4013 addIndex(store_1, idx); 4014 }); 4015 change.del.forEach(function (idxName) { 4016 return store_1.deleteIndex(idxName); 4017 }); 4018 } 4019 }); 4020 var contentUpgrade = version._cfg.contentUpgrade; 4021 4022 if (contentUpgrade && version._cfg.version > oldVersion) { 4023 generateMiddlewareStacks(db, idbUpgradeTrans); 4024 trans._memoizedTables = {}; 4025 anyContentUpgraderHasRun = true; 4026 var upgradeSchema_1 = shallowClone(newSchema); 4027 diff.del.forEach(function (table) { 4028 upgradeSchema_1[table] = oldSchema[table]; 4029 }); 4030 removeTablesApi(db, [db.Transaction.prototype]); 4031 setApiOnPlace(db, [db.Transaction.prototype], keys(upgradeSchema_1), upgradeSchema_1); 4032 trans.schema = upgradeSchema_1; 4033 var contentUpgradeIsAsync_1 = isAsyncFunction(contentUpgrade); 4034 4035 if (contentUpgradeIsAsync_1) { 4036 incrementExpectedAwaits(); 4037 } 4038 4039 var returnValue_1; 4040 var promiseFollowed = DexiePromise.follow(function () { 4041 returnValue_1 = contentUpgrade(trans); 4042 4043 if (returnValue_1) { 4044 if (contentUpgradeIsAsync_1) { 4045 var decrementor = decrementExpectedAwaits.bind(null, null); 4046 returnValue_1.then(decrementor, decrementor); 4047 } 4048 } 4049 }); 4050 return returnValue_1 && typeof returnValue_1.then === 'function' ? DexiePromise.resolve(returnValue_1) : promiseFollowed.then(function () { 4051 return returnValue_1; 4052 }); 4053 } 4054 }); 4055 queue.push(function (idbtrans) { 4056 if (!anyContentUpgraderHasRun || !hasIEDeleteObjectStoreBug) { 4057 var newSchema = version._cfg.dbschema; 4058 deleteRemovedTables(newSchema, idbtrans); 4059 } 4060 4061 removeTablesApi(db, [db.Transaction.prototype]); 4062 setApiOnPlace(db, [db.Transaction.prototype], db._storeNames, db._dbSchema); 4063 trans.schema = db._dbSchema; 4064 }); 4065 }); 4066 4067 function runQueue() { 4068 return queue.length ? DexiePromise.resolve(queue.shift()(trans.idbtrans)).then(runQueue) : DexiePromise.resolve(); 4069 } 4070 4071 return runQueue().then(function () { 4072 createMissingTables(globalSchema, idbUpgradeTrans); 4073 }); 4074 } 4075 4076 function getSchemaDiff(oldSchema, newSchema) { 4077 var diff = { 4078 del: [], 4079 add: [], 4080 change: [] 4081 }; 4082 var table; 4083 4084 for (table in oldSchema) { 4085 if (!newSchema[table]) diff.del.push(table); 4086 } 4087 4088 for (table in newSchema) { 4089 var oldDef = oldSchema[table], 4090 newDef = newSchema[table]; 4091 4092 if (!oldDef) { 4093 diff.add.push([table, newDef]); 4094 } else { 4095 var change = { 4096 name: table, 4097 def: newDef, 4098 recreate: false, 4099 del: [], 4100 add: [], 4101 change: [] 4102 }; 4103
vendor: 4,610 bytes, lines 4104-4230
4104 if ('' + (oldDef.primKey.keyPath || '') !== '' + (newDef.primKey.keyPath || '') || oldDef.primKey.auto !== newDef.primKey.auto && !isIEOrEdge) { 4105 change.recreate = true; 4106 diff.change.push(change); 4107 } else { 4108 var oldIndexes = oldDef.idxByName; 4109 var newIndexes = newDef.idxByName; 4110 var idxName = void 0; 4111 4112 for (idxName in oldIndexes) { 4113 if (!newIndexes[idxName]) change.del.push(idxName); 4114 } 4115 4116 for (idxName in newIndexes) { 4117 var oldIdx = oldIndexes[idxName], 4118 newIdx = newIndexes[idxName]; 4119 if (!oldIdx) change.add.push(newIdx);else if (oldIdx.src !== newIdx.src) change.change.push(newIdx); 4120 } 4121 4122 if (change.del.length > 0 || change.add.length > 0 || change.change.length > 0) { 4123 diff.change.push(change); 4124 } 4125 } 4126 } 4127 } 4128 4129 return diff; 4130 } 4131 4132 function createTable(idbtrans, tableName, primKey, indexes) { 4133 var store = idbtrans.db.createObjectStore(tableName, primKey.keyPath ? { 4134 keyPath: primKey.keyPath, 4135 autoIncrement: primKey.auto 4136 } : { 4137 autoIncrement: primKey.auto 4138 }); 4139 indexes.forEach(function (idx) { 4140 return addIndex(store, idx); 4141 }); 4142 return store; 4143 } 4144 4145 function createMissingTables(newSchema, idbtrans) { 4146 keys(newSchema).forEach(function (tableName) { 4147 if (!idbtrans.db.objectStoreNames.contains(tableName)) { 4148 createTable(idbtrans, tableName, newSchema[tableName].primKey, newSchema[tableName].indexes); 4149 } 4150 }); 4151 } 4152 4153 function deleteRemovedTables(newSchema, idbtrans) { 4154 [].slice.call(idbtrans.db.objectStoreNames).forEach(function (storeName) { 4155 return newSchema[storeName] == null && idbtrans.db.deleteObjectStore(storeName); 4156 }); 4157 } 4158 4159 function addIndex(store, idx) { 4160 store.createIndex(idx.name, idx.keyPath, { 4161 unique: idx.unique, 4162 multiEntry: idx.multi 4163 }); 4164 } 4165 4166 function buildGlobalSchema(db, idbdb, tmpTrans) { 4167 var globalSchema = {}; 4168 var dbStoreNames = slice(idbdb.objectStoreNames, 0); 4169 dbStoreNames.forEach(function (storeName) { 4170 var store = tmpTrans.objectStore(storeName); 4171 var keyPath = store.keyPath; 4172 var primKey = createIndexSpec(nameFromKeyPath(keyPath), keyPath || "", false, false, !!store.autoIncrement, keyPath && typeof keyPath !== "string", true); 4173 var indexes = []; 4174 4175 for (var j = 0; j < store.indexNames.length; ++j) { 4176 var idbindex = store.index(store.indexNames[j]); 4177 keyPath = idbindex.keyPath; 4178 var index = createIndexSpec(idbindex.name, keyPath, !!idbindex.unique, !!idbindex.multiEntry, false, keyPath && typeof keyPath !== "string", false); 4179 indexes.push(index); 4180 } 4181 4182 globalSchema[storeName] = createTableSchema(storeName, primKey, indexes); 4183 }); 4184 return globalSchema; 4185 } 4186 4187 function readGlobalSchema(_a, idbdb, tmpTrans) { 4188 var db = _a._novip; 4189 db.verno = idbdb.version / 10; 4190 var globalSchema = db._dbSchema = buildGlobalSchema(db, idbdb, tmpTrans); 4191 db._storeNames = slice(idbdb.objectStoreNames, 0); 4192 setApiOnPlace(db, [db._allTables], keys(globalSchema), globalSchema); 4193 } 4194 4195 function verifyInstalledSchema(db, tmpTrans) { 4196 var installedSchema = buildGlobalSchema(db, db.idbdb, tmpTrans); 4197 var diff = getSchemaDiff(installedSchema, db._dbSchema); 4198 return !(diff.add.length || diff.change.some(function (ch) { 4199 return ch.add.length || ch.change.length; 4200 })); 4201 } 4202 4203 function adjustToExistingIndexNames(_a, schema, idbtrans) { 4204 var db = _a._novip; 4205 var storeNames = idbtrans.db.objectStoreNames; 4206 4207 for (var i = 0; i < storeNames.length; ++i) { 4208 var storeName = storeNames[i]; 4209 var store = idbtrans.objectStore(storeName); 4210 db._hasGetAll = 'getAll' in store; 4211 4212 for (var j = 0; j < store.indexNames.length; ++j) { 4213 var indexName = store.indexNames[j]; 4214 var keyPath = store.index(indexName).keyPath; 4215 var dexieName = typeof keyPath === 'string' ? keyPath : "[" + slice(keyPath).join('+') + "]"; 4216 4217 if (schema[storeName]) { 4218 var indexSpec = schema[storeName].idxByName[dexieName]; 4219 4220 if (indexSpec) { 4221 indexSpec.name = indexName; 4222 delete schema[storeName].idxByName[dexieName]; 4223 schema[storeName].idxByName[indexName] = indexSpec; 4224 } 4225 } 4226 } 4227 } 4228 4229 if (typeof navigator !== 'undefined' && /Safari/.test(navigator.userAgent) && !/(Chrome\/|Edge\/)/.test(navigator.userAgent) && _global.WorkerGlobalScope && _global instanceof _global.WorkerGlobalScope && [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604) { 4230 db._hasGetAll = false;
4231 } 4232 } 4233 4234 function parseIndexSyntax(primKeyAndIndexes) { 4235 return primKeyAndIndexes.split(',').map(function (index, indexNum) { 4236 index = index.trim(); 4237 var name = index.replace(/([&*]|\+\+)/g, ""); 4238 var keyPath = /^\[/.test(name) ? name.match(/^\[(.*)\]$/)[1].split('+') : name; 4239 return createIndexSpec(name, keyPath || null, /\&/.test(index), /\*/.test(index), /\+\+/.test(index), isArray(keyPath), indexNum === 0); 4240 }); 4241 } 4242 4243 var Version = function () { 4244 function Version() {} 4245 4246 Version.prototype._parseStoresSpec = function (stores, outSchema) { 4247 keys(stores).forEach(function (tableName) { 4248 if (stores[tableName] !== null) { 4249 var indexes = parseIndexSyntax(stores[tableName]); 4250 var primKey = indexes.shift(); 4251 if (primKey.multi) throw new exceptions.Schema("Primary key cannot be multi-valued"); 4252 indexes.forEach(function (idx) { 4253 if (idx.auto) throw new exceptions.Schema("Only primary key can be marked as autoIncrement (++)"); 4254 if (!idx.keyPath) throw new exceptions.Schema("Index must have a name and cannot be an empty string"); 4255 }); 4256 outSchema[tableName] = createTableSchema(tableName, primKey, indexes); 4257 } 4258 }); 4259 }; 4260 4261 Version.prototype.stores = function (stores) { 4262 var db = this.db; 4263 this._cfg.storesSource = this._cfg.storesSource ? extend(this._cfg.storesSource, stores) : stores; 4264 var versions = db._versions; 4265 var storesSpec = {}; 4266 var dbschema = {}; 4267 versions.forEach(function (version) { 4268 extend(storesSpec, version._cfg.storesSource); 4269 dbschema = version._cfg.dbschema = {}; 4270 4271 version._parseStoresSpec(storesSpec, dbschema); 4272 }); 4273 db._dbSchema = dbschema; 4274 removeTablesApi(db, [db._allTables, db, db.Transaction.prototype]); 4275 setApiOnPlace(db, [db._allTables, db, db.Transaction.prototype, this._cfg.tables], keys(dbschema), dbschema); 4276 db._storeNames = keys(dbschema); 4277 return this; 4278 }; 4279 4280 Version.prototype.upgrade = function (upgradeFunction) { 4281 this._cfg.contentUpgrade = promisableChain(this._cfg.contentUpgrade || nop, upgradeFunction); 4282 return this; 4283 }; 4284 4285 return Version; 4286 }(); 4287 4288 function createVersionConstructor(db) { 4289 return makeClassConstructor(Version.prototype, function Version(versionNumber) { 4290 this.db = db; 4291 this._cfg = { 4292 version: versionNumber, 4293 storesSource: null, 4294 dbschema: {}, 4295 tables: {}, 4296 contentUpgrade: null 4297 }; 4298 }); 4299 } 4300 4301 function getDbNamesTable(indexedDB, IDBKeyRange) { 4302 var dbNamesDB = indexedDB["_dbNamesDB"]; 4303 4304 if (!dbNamesDB) { 4305 dbNamesDB = indexedDB["_dbNamesDB"] = new Dexie$1(DBNAMES_DB, { 4306 addons: [], 4307 indexedDB: indexedDB, 4308 IDBKeyRange: IDBKeyRange 4309 }); 4310 dbNamesDB.version(1).stores({ 4311 dbnames: "name" 4312 }); 4313 } 4314 4315 return dbNamesDB.table("dbnames"); 4316 } 4317 4318 function hasDatabasesNative(indexedDB) { 4319 return indexedDB && typeof indexedDB.databases === "function"; 4320 } 4321 4322 function _getDatabaseNames(_a) { 4323 var indexedDB = _a.indexedDB, 4324 IDBKeyRange = _a.IDBKeyRange; 4325 return hasDatabasesNative(indexedDB) ? Promise.resolve(indexedDB.databases()).then(function (infos) { 4326 return infos.map(function (info) { 4327 return info.name; 4328 }).filter(function (name) { 4329 return name !== DBNAMES_DB; 4330 }); 4331 }) : getDbNamesTable(indexedDB, IDBKeyRange).toCollection().primaryKeys(); 4332 } 4333 4334 function _onDatabaseCreated(_a, name) { 4335 var indexedDB = _a.indexedDB, 4336 IDBKeyRange = _a.IDBKeyRange; 4337 !hasDatabasesNative(indexedDB) && name !== DBNAMES_DB && getDbNamesTable(indexedDB, IDBKeyRange).put({ 4338 name: name 4339 })["catch"](nop); 4340 } 4341 4342 function _onDatabaseDeleted(_a, name) { 4343 var indexedDB = _a.indexedDB, 4344 IDBKeyRange = _a.IDBKeyRange; 4345 !hasDatabasesNative(indexedDB) && name !== DBNAMES_DB && getDbNamesTable(indexedDB, IDBKeyRange)["delete"](name)["catch"](nop); 4346 } 4347 4348 function vip(fn) { 4349 return newScope(function () { 4350 PSD.letThrough = true; 4351 return fn(); 4352 }); 4353 } 4354 4355 function idbReady() { 4356 var isSafari = !navigator.userAgentData && /Safari\//.test(navigator.userAgent) && !/Chrom(e|ium)\//.test(navigator.userAgent); 4357 if (!isSafari || !indexedDB.databases) return Promise.resolve(); 4358 var intervalId; 4359 return new Promise(function (resolve) { 4360 var tryIdb = function tryIdb() { 4361 return indexedDB.databases()["finally"](resolve); 4362 }; 4363 4364 intervalId = setInterval(tryIdb, 100); 4365 tryIdb(); 4366 })["finally"](function () { 4367 return clearInterval(intervalId); 4368 }); 4369 } 4370 4371 function dexieOpen(db) { 4372 var state = db._state; 4373 var indexedDB = db._deps.indexedDB; 4374 if (state.isBeingOpened || db.idbdb) return state.dbReadyPromise.then(function () { 4375 return state.dbOpenError ? rejection(state.dbOpenError) : db; 4376 }); 4377 debug && (state.openCanceller._stackHolder = getErrorWithStack()); 4378 state.isBeingOpened = true; 4379 state.dbOpenError = null; 4380 state.openComplete = false;
4381 var openCanceller = state.openCanceller; 4382 4383 function throwIfCancelled() { 4384 if (state.openCanceller !== openCanceller) throw new exceptions.DatabaseClosed('db.open() was cancelled'); 4385 } 4386 4387 var resolveDbReady = state.dbReadyResolve, 4388 upgradeTransaction = null, 4389 wasCreated = false; 4390 return DexiePromise.race([openCanceller, (typeof navigator === 'undefined' ? DexiePromise.resolve() : idbReady()).then(function () { 4391 return new DexiePromise(function (resolve, reject) { 4392 throwIfCancelled(); 4393 if (!indexedDB) throw new exceptions.MissingAPI(); 4394 var dbName = db.name; 4395 var req = state.autoSchema ? indexedDB.open(dbName) : indexedDB.open(dbName, Math.round(db.verno * 10)); 4396 if (!req) throw new exceptions.MissingAPI(); 4397 req.onerror = eventRejectHandler(reject); 4398 req.onblocked = wrap(db._fireOnBlocked); 4399 req.onupgradeneeded = wrap(function (e) { 4400 upgradeTransaction = req.transaction; 4401 4402 if (state.autoSchema && !db._options.allowEmptyDB) { 4403 req.onerror = preventDefault; 4404 upgradeTransaction.abort(); 4405 req.result.close(); 4406 var delreq = indexedDB.deleteDatabase(dbName); 4407 delreq.onsuccess = delreq.onerror = wrap(function () { 4408 reject(new exceptions.NoSuchDatabase("Database " + dbName + " doesnt exist")); 4409 }); 4410 } else { 4411 upgradeTransaction.onerror = eventRejectHandler(reject); 4412 var oldVer = e.oldVersion > Math.pow(2, 62) ? 0 : e.oldVersion; 4413 wasCreated = oldVer < 1; 4414 db._novip.idbdb = req.result; 4415 runUpgraders(db, oldVer / 10, upgradeTransaction, reject); 4416 } 4417 }, reject); 4418 req.onsuccess = wrap(function () { 4419 upgradeTransaction = null; 4420 var idbdb = db._novip.idbdb = req.result; 4421 var objectStoreNames = slice(idbdb.objectStoreNames); 4422 if (objectStoreNames.length > 0) try { 4423 var tmpTrans = idbdb.transaction(safariMultiStoreFix(objectStoreNames), 'readonly'); 4424 if (state.autoSchema) readGlobalSchema(db, idbdb, tmpTrans);else { 4425 adjustToExistingIndexNames(db, db._dbSchema, tmpTrans); 4426 4427 if (!verifyInstalledSchema(db, tmpTrans)) { 4428 console.warn("Dexie SchemaDiff: Schema was extended without increasing the number passed to db.version(). Some queries may fail."); 4429 } 4430 } 4431 generateMiddlewareStacks(db, tmpTrans); 4432 } catch (e) {} 4433 connections.push(db); 4434 idbdb.onversionchange = wrap(function (ev) { 4435 state.vcFired = true; 4436 db.on("versionchange").fire(ev); 4437 }); 4438 idbdb.onclose = wrap(function (ev) { 4439 db.on("close").fire(ev); 4440 }); 4441 if (wasCreated) _onDatabaseCreated(db._deps, dbName); 4442 resolve(); 4443 }, reject); 4444 }); 4445 })]).then(function () { 4446 throwIfCancelled(); 4447 state.onReadyBeingFired = []; 4448 return DexiePromise.resolve(vip(function () { 4449 return db.on.ready.fire(db.vip); 4450 })).then(function fireRemainders() { 4451 if (state.onReadyBeingFired.length > 0) { 4452 var remainders_1 = state.onReadyBeingFired.reduce(promisableChain, nop); 4453 state.onReadyBeingFired = []; 4454 return DexiePromise.resolve(vip(function () { 4455 return remainders_1(db.vip); 4456 })).then(fireRemainders); 4457 } 4458 }); 4459 })["finally"](function () { 4460 state.onReadyBeingFired = null; 4461 state.isBeingOpened = false; 4462 }).then(function () { 4463 return db; 4464 })["catch"](function (err) { 4465 state.dbOpenError = err; 4466 4467 try { 4468 upgradeTransaction && upgradeTransaction.abort(); 4469 } catch (_a) {} 4470 4471 if (openCanceller === state.openCanceller) { 4472 db._close(); 4473 } 4474 4475 return rejection(err); 4476 })["finally"](function () { 4477 state.openComplete = true; 4478 resolveDbReady(); 4479 }); 4480 } 4481 4482 function awaitIterator(iterator) { 4483 var callNext = function callNext(result) { 4484 return iterator.next(result); 4485 }, 4486 doThrow = function doThrow(error) { 4487 return iterator["throw"](error); 4488 }, 4489 onSuccess = step(callNext), 4490 onError = step(doThrow); 4491 4492 function step(getNext) { 4493 return function (val) { 4494 var next = getNext(val), 4495 value = next.value; 4496 return next.done ? value : !value || typeof value.then !== 'function' ? isArray(value) ? Promise.all(value).then(onSuccess, onError) : onSuccess(value) : value.then(onSuccess, onError); 4497 }; 4498 } 4499 4500 return step(callNext)(); 4501 } 4502 4503 function extractTransactionArgs(mode, _tableArgs_, scopeFunc) { 4504 var i = arguments.length; 4505 if (i < 2) throw new exceptions.InvalidArgument("Too few arguments"); 4506 var args = new Array(i - 1); 4507 4508 while (--i) { 4509 args[i - 1] = arguments[i]; 4510 } 4511 4512 scopeFunc = args.pop(); 4513 var tables = flatten(args); 4514 return [mode, tables, scopeFunc]; 4515 } 4516 4517 function enterTransactionScope(db, mode, storeNames, parentTransaction, scopeFunc) { 4518 return DexiePromise.resolve().then(function () { 4519 var transless = PSD.transless || PSD; 4520 4521 var trans = db._createTransaction(mode, storeNames, db._dbSchema, parentTransaction); 4522 4523 var zoneProps = { 4524 trans: trans, 4525 transless: transless 4526 }; 4527 4528 if (parentTransaction) { 4529 trans.idbtrans = parentTransaction.idbtrans; 4530 } else { 4531 try { 4532 trans.create(); 4533 db._state.PR1398_maxLoop = 3; 4534 } catch (ex) { 4535 if (ex.name === errnames.InvalidState && db.isOpen() && --db._state.PR1398_maxLoop > 0) { 4536 console.warn('Dexie: Need to reopen db'); 4537 4538 db._close(); 4539 4540 return db.open().then(function () { 4541 return enterTransactionScope(db, mode, storeNames, null, scopeFunc); 4542 }); 4543 } 4544 4545 return rejection(ex); 4546 } 4547 } 4548 4549 var scopeFuncIsAsync = isAsyncFunction(scopeFunc); 4550 4551 if (scopeFuncIsAsync) { 4552 incrementExpectedAwaits(); 4553 } 4554 4555 var returnValue; 4556 var promiseFollowed = DexiePromise.follow(function () { 4557 returnValue = scopeFunc.call(trans, trans); 4558 4559 if (returnValue) { 4560 if (scopeFuncIsAsync) { 4561 var decrementor = decrementExpectedAwaits.bind(null, null); 4562 returnValue.then(decrementor, decrementor); 4563 } else if (typeof returnValue.next === 'function' && typeof returnValue["throw"] === 'function') { 4564 returnValue = awaitIterator(returnValue); 4565 } 4566 } 4567 }, zoneProps); 4568 return (returnValue && typeof returnValue.then === 'function' ? DexiePromise.resolve(returnValue).then(function (x) { 4569 return trans.active ? x : rejection(new exceptions.PrematureCommit("Transaction committed too early. See http://bit.ly/2kdckMn")); 4570 }) : promiseFollowed.then(function () { 4571 return returnValue; 4572 })).then(function (x) { 4573 if (parentTransaction) trans._resolve(); 4574 return trans._completion.then(function () { 4575 return x; 4576 }); 4577 })["catch"](function (e) { 4578 trans._reject(e); 4579 4580 return rejection(e); 4581 }); 4582 }); 4583 } 4584 4585 function pad(a, value, count) { 4586 var result = isArray(a) ? a.slice() : [a]; 4587 4588 for (var i = 0; i < count; ++i) { 4589 result.push(value); 4590 } 4591 4592 return result; 4593 } 4594 4595 function createVirtualIndexMiddleware(down) { 4596 return _assign(_assign({}, down), { 4597 table: function table(tableName) { 4598 var table = down.table(tableName); 4599 var schema = table.schema; 4600 var indexLookup = {};
4601 var allVirtualIndexes = []; 4602 4603 function addVirtualIndexes(keyPath, keyTail, lowLevelIndex) { 4604 var keyPathAlias = getKeyPathAlias(keyPath); 4605 var indexList = indexLookup[keyPathAlias] = indexLookup[keyPathAlias] || []; 4606 var keyLength = keyPath == null ? 0 : typeof keyPath === 'string' ? 1 : keyPath.length; 4607 var isVirtual = keyTail > 0; 4608 4609 var virtualIndex = _assign(_assign({}, lowLevelIndex), { 4610 isVirtual: isVirtual, 4611 keyTail: keyTail, 4612 keyLength: keyLength, 4613 extractKey: getKeyExtractor(keyPath), 4614 unique: !isVirtual && lowLevelIndex.unique 4615 }); 4616 4617 indexList.push(virtualIndex); 4618 4619 if (!virtualIndex.isPrimaryKey) { 4620 allVirtualIndexes.push(virtualIndex); 4621 } 4622 4623 if (keyLength > 1) { 4624 var virtualKeyPath = keyLength === 2 ? keyPath[0] : keyPath.slice(0, keyLength - 1); 4625 addVirtualIndexes(virtualKeyPath, keyTail + 1, lowLevelIndex); 4626 } 4627 4628 indexList.sort(function (a, b) { 4629 return a.keyTail - b.keyTail; 4630 }); 4631 return virtualIndex; 4632 } 4633
4634 var primaryKey = addVirtualIndexes(schema.primaryKey.keyPath, 0, schema.primaryKey); 4635 indexLookup[":id"] = [primaryKey]; 4636 4637 for (var _i = 0, _a = schema.indexes; _i < _a.length; _i++) { 4638 var index = _a[_i]; 4639 addVirtualIndexes(index.keyPath, 0, index); 4640 } 4641 4642 function findBestIndex(keyPath) { 4643 var result = indexLookup[getKeyPathAlias(keyPath)]; 4644 return result && result[0]; 4645 } 4646 4647 function translateRange(range, keyTail) { 4648 return { 4649 type: range.type === 1 ? 2 : range.type, 4650 lower: pad(range.lower, range.lowerOpen ? down.MAX_KEY : down.MIN_KEY, keyTail), 4651 lowerOpen: true, 4652 upper: pad(range.upper, range.upperOpen ? down.MIN_KEY : down.MAX_KEY, keyTail), 4653 upperOpen: true 4654 }; 4655 } 4656 4657 function translateRequest(req) { 4658 var index = req.query.index; 4659 return index.isVirtual ? _assign(_assign({}, req), { 4660 query: { 4661 index: index, 4662 range: translateRange(req.query.range, index.keyTail) 4663 } 4664 }) : req; 4665 } 4666 4667 var result = _assign(_assign({}, table), { 4668 schema: _assign(_assign({}, schema), { 4669 primaryKey: primaryKey,
4670 indexes: allVirtualIndexes, 4671 getIndexByKeyPath: findBestIndex 4672 }), 4673 count: function count(req) { 4674 return table.count(translateRequest(req)); 4675 }, 4676 query: function query(req) { 4677 return table.query(translateRequest(req)); 4678 }, 4679 openCursor: function openCursor(req) { 4680 var _a = req.query.index, 4681 keyTail = _a.keyTail, 4682 isVirtual = _a.isVirtual, 4683 keyLength = _a.keyLength; 4684 if (!isVirtual) return table.openCursor(req); 4685 4686 function createVirtualCursor(cursor) { 4687 function _continue(key) { 4688 key != null ? cursor["continue"](pad(key, req.reverse ? down.MAX_KEY : down.MIN_KEY, keyTail)) : req.unique ? cursor["continue"](cursor.key.slice(0, keyLength).concat(req.reverse ? down.MIN_KEY : down.MAX_KEY, keyTail)) : cursor["continue"](); 4689 } 4690 4691 var virtualCursor = Object.create(cursor, { 4692 "continue": { 4693 value: _continue 4694 }, 4695 continuePrimaryKey: { 4696 value: function value(key, primaryKey) { 4697 cursor.continuePrimaryKey(pad(key, down.MAX_KEY, keyTail), primaryKey); 4698 } 4699 }, 4700 primaryKey: { 4701 get: function get() { 4702 return cursor.primaryKey; 4703 } 4704 }, 4705 key: { 4706 get: function get() { 4707 var key = cursor.key; 4708 return keyLength === 1 ? key[0] : key.slice(0, keyLength); 4709 } 4710 }, 4711 value: { 4712 get: function get() { 4713 return cursor.value; 4714 } 4715 } 4716 }); 4717 return virtualCursor; 4718 } 4719 4720 return table.openCursor(translateRequest(req)).then(function (cursor) {
4721 return cursor && createVirtualCursor(cursor); 4722 }); 4723 } 4724 }); 4725 4726 return result; 4727 } 4728 }); 4729 } 4730 4731 var virtualIndexMiddleware = { 4732 stack: "dbcore", 4733 name: "VirtualIndexMiddleware", 4734 level: 1, 4735 create: createVirtualIndexMiddleware 4736 }; 4737 4738 function getObjectDiff(a, b, rv, prfx) { 4739 rv = rv || {}; 4740 prfx = prfx || ''; 4741 keys(a).forEach(function (prop) { 4742 if (!hasOwn(b, prop)) { 4743 rv[prfx + prop] = undefined; 4744 } else { 4745 var ap = a[prop], 4746 bp = b[prop]; 4747 4748 if (babelHelpers["typeof"](ap) === 'object' && babelHelpers["typeof"](bp) === 'object' && ap && bp) { 4749 var apTypeName = toStringTag(ap); 4750 var bpTypeName = toStringTag(bp); 4751 4752 if (apTypeName !== bpTypeName) { 4753 rv[prfx + prop] = b[prop]; 4754 } else if (apTypeName === 'Object') { 4755 getObjectDiff(ap, bp, rv, prfx + prop + '.'); 4756 } else if (ap !== bp) { 4757 rv[prfx + prop] = b[prop]; 4758 } 4759 } else if (ap !== bp) rv[prfx + prop] = b[prop]; 4760 } 4761 }); 4762 keys(b).forEach(function (prop) { 4763 if (!hasOwn(a, prop)) { 4764 rv[prfx + prop] = b[prop]; 4765 } 4766 }); 4767 return rv; 4768 } 4769 4770 function getEffectiveKeys(primaryKey, req) { 4771 if (req.type === 'delete') return req.keys; 4772 return req.keys || req.values.map(primaryKey.extractKey); 4773 } 4774 4775 var hooksMiddleware = { 4776 stack: "dbcore", 4777 name: "HooksMiddleware", 4778 level: 2, 4779 create: function create(downCore) { 4780 return _assign(_assign({}, downCore), { 4781 table: function table(tableName) { 4782 var downTable = downCore.table(tableName); 4783 var primaryKey = downTable.schema.primaryKey; 4784 4785 var tableMiddleware = _assign(_assign({}, downTable), { 4786 mutate: function mutate(req) { 4787 var dxTrans = PSD.trans; 4788 var _a = dxTrans.table(tableName).hook, 4789 deleting = _a.deleting, 4790 creating = _a.creating, 4791 updating = _a.updating; 4792 4793 switch (req.type) { 4794 case 'add': 4795 if (creating.fire === nop) break; 4796 return dxTrans._promise('readwrite', function () { 4797 return addPutOrDelete(req); 4798 }, true); 4799 4800 case 'put': 4801 if (creating.fire === nop && updating.fire === nop) break; 4802 return dxTrans._promise('readwrite', function () { 4803 return addPutOrDelete(req); 4804 }, true); 4805 4806 case 'delete': 4807 if (deleting.fire === nop) break; 4808 return dxTrans._promise('readwrite', function () { 4809 return addPutOrDelete(req); 4810 }, true); 4811 4812 case 'deleteRange': 4813 if (deleting.fire === nop) break; 4814 return dxTrans._promise('readwrite', function () { 4815 return deleteRange(req); 4816 }, true); 4817 } 4818 4819 return downTable.mutate(req); 4820 4821 function addPutOrDelete(req) { 4822 var dxTrans = PSD.trans; 4823 var keys = req.keys || getEffectiveKeys(primaryKey, req); 4824 if (!keys) throw new Error("Keys missing"); 4825 req = req.type === 'add' || req.type === 'put' ? _assign(_assign({}, req), { 4826 keys: keys 4827 }) : _assign({}, req); 4828 if (req.type !== 'delete') req.values = __spreadArray([], req.values, true); 4829 if (req.keys) req.keys = __spreadArray([], req.keys, true); 4830 return getExistingValues(downTable, req, keys).then(function (existingValues) { 4831 var contexts = keys.map(function (key, i) {
vendor: 2,697 bytes, lines 4832-4892
4832 var existingValue = existingValues[i]; 4833 var ctx = { 4834 onerror: null, 4835 onsuccess: null 4836 }; 4837 4838 if (req.type === 'delete') { 4839 deleting.fire.call(ctx, key, existingValue, dxTrans); 4840 } else if (req.type === 'add' || existingValue === undefined) { 4841 var generatedPrimaryKey = creating.fire.call(ctx, key, req.values[i], dxTrans); 4842 4843 if (key == null && generatedPrimaryKey != null) { 4844 key = generatedPrimaryKey; 4845 req.keys[i] = key; 4846 4847 if (!primaryKey.outbound) { 4848 setByKeyPath(req.values[i], primaryKey.keyPath, key); 4849 } 4850 } 4851 } else { 4852 var objectDiff = getObjectDiff(existingValue, req.values[i]); 4853 var additionalChanges_1 = updating.fire.call(ctx, objectDiff, key, existingValue, dxTrans); 4854 4855 if (additionalChanges_1) { 4856 var requestedValue_1 = req.values[i]; 4857 Object.keys(additionalChanges_1).forEach(function (keyPath) { 4858 if (hasOwn(requestedValue_1, keyPath)) { 4859 requestedValue_1[keyPath] = additionalChanges_1[keyPath]; 4860 } else { 4861 setByKeyPath(requestedValue_1, keyPath, additionalChanges_1[keyPath]); 4862 } 4863 }); 4864 } 4865 } 4866 4867 return ctx; 4868 }); 4869 return downTable.mutate(req).then(function (_a) { 4870 var failures = _a.failures, 4871 results = _a.results, 4872 numFailures = _a.numFailures, 4873 lastResult = _a.lastResult; 4874 4875 for (var i = 0; i < keys.length; ++i) { 4876 var primKey = results ? results[i] : keys[i]; 4877 var ctx = contexts[i]; 4878 4879 if (primKey == null) { 4880 ctx.onerror && ctx.onerror(failures[i]); 4881 } else { 4882 ctx.onsuccess && ctx.onsuccess(req.type === 'put' && existingValues[i] ? req.values[i] : primKey); 4883 } 4884 } 4885 4886 return { 4887 failures: failures, 4888 results: results, 4889 numFailures: numFailures, 4890 lastResult: lastResult 4891 }; 4892 })["catch"](function (error) {
4893 contexts.forEach(function (ctx) { 4894 return ctx.onerror && ctx.onerror(error); 4895 }); 4896 return Promise.reject(error); 4897 }); 4898 }); 4899 } 4900 4901 function deleteRange(req) { 4902 return deleteNextChunk(req.trans, req.range, 10000); 4903 } 4904 4905 function deleteNextChunk(trans, range, limit) { 4906 return downTable.query({ 4907 trans: trans, 4908 values: false, 4909 query: { 4910 index: primaryKey, 4911 range: range 4912 }, 4913 limit: limit 4914 }).then(function (_a) { 4915 var result = _a.result; 4916 return addPutOrDelete({ 4917 type: 'delete', 4918 keys: result, 4919 trans: trans 4920 }).then(function (res) { 4921 if (res.numFailures > 0) return Promise.reject(res.failures[0]); 4922 4923 if (result.length < limit) { 4924 return { 4925 failures: [], 4926 numFailures: 0, 4927 lastResult: undefined 4928 }; 4929 } else { 4930 return deleteNextChunk(trans, _assign(_assign({}, range), { 4931 lower: result[result.length - 1], 4932 lowerOpen: true 4933 }), limit); 4934 } 4935 }); 4936 }); 4937 } 4938 } 4939 }); 4940 4941 return tableMiddleware; 4942 } 4943 }); 4944 } 4945 }; 4946 4947 function getExistingValues(table, req, effectiveKeys) { 4948 return req.type === "add" ? Promise.resolve([]) : table.getMany({ 4949 trans: req.trans, 4950 keys: effectiveKeys, 4951 cache: "immutable" 4952 }); 4953 } 4954 4955 function getFromTransactionCache(keys, cache, clone) { 4956 try { 4957 if (!cache) return null; 4958 if (cache.keys.length < keys.length) return null; 4959 var result = []; 4960 4961 for (var i = 0, j = 0; i < cache.keys.length && j < keys.length; ++i) { 4962 if (cmp(cache.keys[i], keys[j]) !== 0) continue; 4963 result.push(clone ? deepClone(cache.values[i]) : cache.values[i]); 4964 ++j; 4965 } 4966 4967 return result.length === keys.length ? result : null; 4968 } catch (_a) { 4969 return null; 4970 } 4971 } 4972 4973 var cacheExistingValuesMiddleware = { 4974 stack: "dbcore", 4975 level: -1, 4976 create: function create(core) { 4977 return { 4978 table: function table(tableName) { 4979 var table = core.table(tableName); 4980 return _assign(_assign({}, table), { 4981 getMany: function getMany(req) { 4982 if (!req.cache) { 4983 return table.getMany(req); 4984 } 4985 4986 var cachedResult = getFromTransactionCache(req.keys, req.trans["_cache"], req.cache === "clone"); 4987 4988 if (cachedResult) { 4989 return DexiePromise.resolve(cachedResult); 4990 } 4991 4992 return table.getMany(req).then(function (res) { 4993 req.trans["_cache"] = { 4994 keys: req.keys, 4995 values: req.cache === "clone" ? deepClone(res) : res 4996 }; 4997 return res; 4998 }); 4999 }, 5000 mutate: function mutate(req) { 5001 if (req.type !== "add") req.trans["_cache"] = null; 5002 return table.mutate(req); 5003 } 5004 }); 5005 } 5006 }; 5007 } 5008 }; 5009 5010 var _a; 5011 5012 function isEmptyRange(node) { 5013 return !("from" in node); 5014 } 5015 5016 var RangeSet = function RangeSet(fromOrTree, to) { 5017 if (this) { 5018 extend(this, arguments.length ? { 5019 d: 1, 5020 from: fromOrTree, 5021 to: arguments.length > 1 ? to : fromOrTree 5022 } : { 5023 d: 0 5024 }); 5025 } else { 5026 var rv = new RangeSet(); 5027 5028 if (fromOrTree && "d" in fromOrTree) { 5029 extend(rv, fromOrTree); 5030 } 5031 5032 return rv; 5033 } 5034 }; 5035 5036 props(RangeSet.prototype, (_a = { 5037 add: function add(rangeSet) { 5038 mergeRanges(this, rangeSet); 5039 return this; 5040 }, 5041 addKey: function addKey(key) { 5042 addRange(this, key, key); 5043 return this; 5044 }, 5045 addKeys: function addKeys(keys) { 5046 var _this = this; 5047 5048 keys.forEach(function (key) {
5049 return addRange(_this, key, key); 5050 }); 5051 return this; 5052 } 5053 }, _a[iteratorSymbol] = function () { 5054 return getRangeSetIterator(this); 5055 }, _a)); 5056 5057 function addRange(target, from, to) { 5058 var diff = cmp(from, to); 5059 if (isNaN(diff)) return; 5060 if (diff > 0) throw RangeError(); 5061 if (isEmptyRange(target)) return extend(target, { 5062 from: from, 5063 to: to, 5064 d: 1 5065 }); 5066 var left = target.l; 5067 var right = target.r; 5068 5069 if (cmp(to, target.from) < 0) { 5070 left ? addRange(left, from, to) : target.l = { 5071 from: from, 5072 to: to, 5073 d: 1, 5074 l: null, 5075 r: null 5076 }; 5077 return rebalance(target); 5078 } 5079 5080 if (cmp(from, target.to) > 0) { 5081 right ? addRange(right, from, to) : target.r = { 5082 from: from, 5083 to: to, 5084 d: 1, 5085 l: null, 5086 r: null 5087 }; 5088 return rebalance(target); 5089 } 5090 5091 if (cmp(from, target.from) < 0) { 5092 target.from = from; 5093 target.l = null; 5094 target.d = right ? right.d + 1 : 1; 5095 } 5096 5097 if (cmp(to, target.to) > 0) { 5098 target.to = to; 5099 target.r = null; 5100 target.d = target.l ? target.l.d + 1 : 1; 5101 } 5102 5103 var rightWasCutOff = !target.r; 5104 5105 if (left && !target.l) { 5106 mergeRanges(target, left); 5107 } 5108 5109 if (right && rightWasCutOff) { 5110 mergeRanges(target, right); 5111 } 5112 } 5113 5114 function mergeRanges(target, newSet) { 5115 function _addRangeSet(target, _a) { 5116 var from = _a.from, 5117 to = _a.to, 5118 l = _a.l, 5119 r = _a.r; 5120 addRange(target, from, to); 5121 if (l) _addRangeSet(target, l); 5122 if (r) _addRangeSet(target, r); 5123 } 5124 5125 if (!isEmptyRange(newSet)) _addRangeSet(target, newSet); 5126 } 5127 5128 function rangesOverlap(rangeSet1, rangeSet2) { 5129 var i1 = getRangeSetIterator(rangeSet2); 5130 var nextResult1 = i1.next(); 5131 if (nextResult1.done) return false; 5132 var a = nextResult1.value; 5133 var i2 = getRangeSetIterator(rangeSet1); 5134 var nextResult2 = i2.next(a.from); 5135 var b = nextResult2.value; 5136 5137 while (!nextResult1.done && !nextResult2.done) { 5138 if (cmp(b.from, a.to) <= 0 && cmp(b.to, a.from) >= 0) return true; 5139 cmp(a.from, b.from) < 0 ? a = (nextResult1 = i1.next(b.from)).value : b = (nextResult2 = i2.next(a.from)).value; 5140 } 5141 5142 return false; 5143 } 5144 5145 function getRangeSetIterator(node) { 5146 var state = isEmptyRange(node) ? null : { 5147 s: 0, 5148 n: node 5149 }; 5150 return { 5151 next: function next(key) { 5152 var keyProvided = arguments.length > 0; 5153 5154 while (state) { 5155 switch (state.s) { 5156 case 0: 5157 state.s = 1; 5158 5159 if (keyProvided) { 5160 while (state.n.l && cmp(key, state.n.from) < 0) { 5161 state = { 5162 up: state, 5163 n: state.n.l, 5164 s: 1 5165 }; 5166 } 5167 } else { 5168 while (state.n.l) { 5169 state = { 5170 up: state, 5171 n: state.n.l, 5172 s: 1 5173 }; 5174 } 5175 } 5176 5177 case 1: 5178 state.s = 2; 5179 if (!keyProvided || cmp(key, state.n.to) <= 0) return { 5180 value: state.n, 5181 done: false 5182 }; 5183 5184 case 2: 5185 if (state.n.r) { 5186 state.s = 3; 5187 state = { 5188 up: state, 5189 n: state.n.r, 5190 s: 0 5191 }; 5192 continue; 5193 } 5194 5195 case 3: 5196 state = state.up; 5197 } 5198 } 5199 5200 return { 5201 done: true 5202 }; 5203 } 5204 }; 5205 } 5206 5207 function rebalance(target) { 5208 var _a, _b; 5209 5210 var diff = (((_a = target.r) === null || _a === void 0 ? void 0 : _a.d) || 0) - (((_b = target.l) === null || _b === void 0 ? void 0 : _b.d) || 0); 5211 var r = diff > 1 ? "r" : diff < -1 ? "l" : ""; 5212 5213 if (r) { 5214 var l = r === "r" ? "l" : "r"; 5215 5216 var rootClone = _assign({}, target); 5217 5218 var oldRootRight = target[r]; 5219 target.from = oldRootRight.from; 5220 target.to = oldRootRight.to; 5221 target[r] = oldRootRight[r]; 5222 rootClone[r] = oldRootRight[l]; 5223 target[l] = rootClone; 5224 rootClone.d = computeDepth(rootClone); 5225 } 5226 5227 target.d = computeDepth(target); 5228 } 5229 5230 function computeDepth(_a) { 5231 var r = _a.r, 5232 l = _a.l; 5233 return (r ? l ? Math.max(r.d, l.d) : r.d : l ? l.d : 0) + 1; 5234 } 5235 5236 var observabilityMiddleware = { 5237 stack: "dbcore", 5238 level: 0, 5239 create: function create(core) { 5240 var dbName = core.schema.name; 5241 var FULL_RANGE = new RangeSet(core.MIN_KEY, core.MAX_KEY); 5242 return _assign(_assign({}, core), { 5243 table: function table(tableName) { 5244 var table = core.table(tableName); 5245 var schema = table.schema; 5246 var primaryKey = schema.primaryKey; 5247 var extractKey = primaryKey.extractKey, 5248 outbound = primaryKey.outbound; 5249 5250 var tableClone = _assign(_assign({}, table), { 5251 mutate: function mutate(req) { 5252 var trans = req.trans; 5253 var mutatedParts = trans.mutatedParts || (trans.mutatedParts = {}); 5254 5255 var getRangeSet = function getRangeSet(indexName) { 5256 var part = "idb://" + dbName + "/" + tableName + "/" + indexName; 5257 return mutatedParts[part] || (mutatedParts[part] = new RangeSet()); 5258 }; 5259 5260 var pkRangeSet = getRangeSet(""); 5261 var delsRangeSet = getRangeSet(":dels"); 5262 var type = req.type; 5263 5264 var _a = req.type === "deleteRange" ? [req.range] : req.type === "delete" ? [req.keys] : req.values.length < 50 ? [[], req.values] : [], 5265 keys = _a[0], 5266 newObjs = _a[1]; 5267 5268 var oldCache = req.trans["_cache"]; 5269 return table.mutate(req).then(function (res) { 5270 if (isArray(keys)) { 5271 if (type !== "delete") keys = res.results; 5272 pkRangeSet.addKeys(keys); 5273 var oldObjs = getFromTransactionCache(keys, oldCache); 5274 5275 if (!oldObjs && type !== "add") {
5276 delsRangeSet.addKeys(keys); 5277 } 5278 5279 if (oldObjs || newObjs) { 5280 trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs); 5281 } 5282 } else if (keys) { 5283 var range = { 5284 from: keys.lower, 5285 to: keys.upper 5286 }; 5287 delsRangeSet.add(range); 5288 pkRangeSet.add(range); 5289 } else { 5290 pkRangeSet.add(FULL_RANGE); 5291 delsRangeSet.add(FULL_RANGE); 5292 schema.indexes.forEach(function (idx) { 5293 return getRangeSet(idx.name).add(FULL_RANGE); 5294 }); 5295 } 5296 5297 return res; 5298 }); 5299 } 5300 }); 5301 5302 var getRange = function getRange(_a) { 5303 var _b, _c; 5304 5305 var _d = _a.query, 5306 index = _d.index, 5307 range = _d.range; 5308 return [index, new RangeSet((_b = range.lower) !== null && _b !== void 0 ? _b : core.MIN_KEY, (_c = range.upper) !== null && _c !== void 0 ? _c : core.MAX_KEY)]; 5309 }; 5310 5311 var readSubscribers = { 5312 get: function get(req) { 5313 return [primaryKey, new RangeSet(req.key)]; 5314 }, 5315 getMany: function getMany(req) { 5316 return [primaryKey, new RangeSet().addKeys(req.keys)]; 5317 }, 5318 count: getRange, 5319 query: getRange, 5320 openCursor: getRange 5321 }; 5322 keys(readSubscribers).forEach(function (method) { 5323 tableClone[method] = function (req) { 5324 var subscr = PSD.subscr; 5325 5326 if (subscr) { 5327 var getRangeSet = function getRangeSet(indexName) { 5328 var part = "idb://" + dbName + "/" + tableName + "/" + indexName; 5329 return subscr[part] || (subscr[part] = new RangeSet()); 5330 }; 5331 5332 var pkRangeSet_1 = getRangeSet(""); 5333 var delsRangeSet_1 = getRangeSet(":dels"); 5334 5335 var _a = readSubscribers[method](req), 5336 queriedIndex = _a[0], 5337 queriedRanges = _a[1]; 5338 5339 getRangeSet(queriedIndex.name || "").add(queriedRanges); 5340 5341 if (!queriedIndex.isPrimaryKey) { 5342 if (method === "count") { 5343 delsRangeSet_1.add(FULL_RANGE); 5344 } else { 5345 var keysPromise_1 = method === "query" && outbound && req.values && table.query(_assign(_assign({}, req), { 5346 values: false 5347 })); 5348 return table[method].apply(this, arguments).then(function (res) { 5349 if (method === "query") { 5350 if (outbound && req.values) { 5351 return keysPromise_1.then(function (_a) { 5352 var resultingKeys = _a.result; 5353 pkRangeSet_1.addKeys(resultingKeys); 5354 return res; 5355 }); 5356 } 5357 5358 var pKeys = req.values ? res.result.map(extractKey) : res.result; 5359 5360 if (req.values) { 5361 pkRangeSet_1.addKeys(pKeys); 5362 } else { 5363 delsRangeSet_1.addKeys(pKeys); 5364 } 5365 } else if (method === "openCursor") { 5366 var cursor_1 = res; 5367 var wantValues_1 = req.values; 5368 return cursor_1 && Object.create(cursor_1, { 5369 key: { 5370 get: function get() { 5371 delsRangeSet_1.addKey(cursor_1.primaryKey); 5372 return cursor_1.key; 5373 } 5374 }, 5375 primaryKey: { 5376 get: function get() { 5377 var pkey = cursor_1.primaryKey; 5378 delsRangeSet_1.addKey(pkey); 5379 return pkey; 5380 } 5381 }, 5382 value: { 5383 get: function get() { 5384 wantValues_1 && pkRangeSet_1.addKey(cursor_1.primaryKey); 5385 return cursor_1.value; 5386 } 5387 } 5388 }); 5389 } 5390 5391 return res; 5392 }); 5393 } 5394 } 5395 } 5396 5397 return table[method].apply(this, arguments); 5398 }; 5399 }); 5400 return tableClone; 5401 } 5402 }); 5403 } 5404 }; 5405 5406 function trackAffectedIndexes(getRangeSet, schema, oldObjs, newObjs) { 5407 function addAffectedIndex(ix) { 5408 var rangeSet = getRangeSet(ix.name || ""); 5409 5410 function extractKey(obj) { 5411 return obj != null ? ix.extractKey(obj) : null; 5412 } 5413 5414 var addKeyOrKeys = function addKeyOrKeys(key) {
5415 return ix.multiEntry && isArray(key) ? key.forEach(function (key) { 5416 return rangeSet.addKey(key); 5417 }) : rangeSet.addKey(key); 5418 }; 5419 5420 (oldObjs || newObjs).forEach(function (_, i) { 5421 var oldKey = oldObjs && extractKey(oldObjs[i]); 5422 var newKey = newObjs && extractKey(newObjs[i]); 5423 5424 if (cmp(oldKey, newKey) !== 0) { 5425 if (oldKey != null) addKeyOrKeys(oldKey); 5426 if (newKey != null) addKeyOrKeys(newKey); 5427 } 5428 }); 5429 } 5430 5431 schema.indexes.forEach(addAffectedIndex); 5432 } 5433 5434 var Dexie$1 = function () { 5435 function Dexie(name, options) { 5436 var _this = this; 5437 5438 this._middlewares = {}; 5439 this.verno = 0; 5440 var deps = Dexie.dependencies; 5441 this._options = options = _assign({ 5442 addons: Dexie.addons, 5443 autoOpen: true, 5444 indexedDB: deps.indexedDB, 5445 IDBKeyRange: deps.IDBKeyRange 5446 }, options); 5447 this._deps = { 5448 indexedDB: options.indexedDB, 5449 IDBKeyRange: options.IDBKeyRange 5450 }; 5451 var addons = options.addons; 5452 this._dbSchema = {}; 5453 this._versions = []; 5454 this._storeNames = []; 5455 this._allTables = {}; 5456 this.idbdb = null; 5457 this._novip = this; 5458 var state = { 5459 dbOpenError: null, 5460 isBeingOpened: false, 5461 onReadyBeingFired: null, 5462 openComplete: false, 5463 dbReadyResolve: nop, 5464 dbReadyPromise: null, 5465 cancelOpen: nop, 5466 openCanceller: null, 5467 autoSchema: true, 5468 PR1398_maxLoop: 3 5469 }; 5470 state.dbReadyPromise = new DexiePromise(function (resolve) { 5471 state.dbReadyResolve = resolve; 5472 }); 5473 state.openCanceller = new DexiePromise(function (_, reject) { 5474 state.cancelOpen = reject; 5475 }); 5476 this._state = state; 5477 this.name = name; 5478 this.on = Events(this, "populate", "blocked", "versionchange", "close", { 5479 ready: [promisableChain, nop] 5480 }); 5481 this.on.ready.subscribe = override(this.on.ready.subscribe, function (subscribe) { 5482 return function (subscriber, bSticky) { 5483 Dexie.vip(function () { 5484 var state = _this._state; 5485 5486 if (state.openComplete) { 5487 if (!state.dbOpenError) DexiePromise.resolve().then(subscriber); 5488 if (bSticky) subscribe(subscriber); 5489 } else if (state.onReadyBeingFired) { 5490 state.onReadyBeingFired.push(subscriber); 5491 if (bSticky) subscribe(subscriber); 5492 } else { 5493 subscribe(subscriber); 5494 var db_1 = _this; 5495 if (!bSticky) subscribe(function unsubscribe() { 5496 db_1.on.ready.unsubscribe(subscriber); 5497 db_1.on.ready.unsubscribe(unsubscribe); 5498 }); 5499 } 5500 }); 5501 }; 5502 }); 5503 this.Collection = createCollectionConstructor(this); 5504 this.Table = createTableConstructor(this); 5505 this.Transaction = createTransactionConstructor(this); 5506 this.Version = createVersionConstructor(this); 5507 this.WhereClause = createWhereClauseConstructor(this); 5508 this.on("versionchange", function (ev) { 5509 if (ev.newVersion > 0) console.warn("Another connection wants to upgrade database '" + _this.name + "'. Closing db now to resume the upgrade.");else console.warn("Another connection wants to delete database '" + _this.name + "'. Closing db now to resume the delete request."); 5510 5511 _this.close(); 5512 }); 5513 this.on("blocked", function (ev) { 5514 if (!ev.newVersion || ev.newVersion < ev.oldVersion) console.warn("Dexie.delete('" + _this.name + "') was blocked");else console.warn("Upgrade '" + _this.name + "' blocked by other connection holding version " + ev.oldVersion / 10); 5515 }); 5516 this._maxKey = _getMaxKey(options.IDBKeyRange); 5517 5518 this._createTransaction = function (mode, storeNames, dbschema, parentTransaction) { 5519 return new _this.Transaction(mode, storeNames, dbschema, _this._options.chromeTransactionDurability, parentTransaction); 5520 }; 5521 5522 this._fireOnBlocked = function (ev) { 5523 _this.on("blocked").fire(ev); 5524 5525 connections.filter(function (c) { 5526 return c.name === _this.name && c !== _this && !c._state.vcFired; 5527 }).map(function (c) { 5528 return c.on("versionchange").fire(ev); 5529 }); 5530 }; 5531 5532 this.use(virtualIndexMiddleware); 5533 this.use(hooksMiddleware); 5534 this.use(observabilityMiddleware); 5535 this.use(cacheExistingValuesMiddleware); 5536 this.vip = Object.create(this, { 5537 _vip: { 5538 value: true 5539 } 5540 }); 5541 addons.forEach(function (addon) { 5542 return addon(_this); 5543 }); 5544 } 5545 5546 Dexie.prototype.version = function (versionNumber) { 5547 if (isNaN(versionNumber) || versionNumber < 0.1) throw new exceptions.Type("Given version is not a positive number"); 5548 versionNumber = Math.round(versionNumber * 10) / 10; 5549 if (this.idbdb || this._state.isBeingOpened) throw new exceptions.Schema("Cannot add version when database is open"); 5550 this.verno = Math.max(this.verno, versionNumber); 5551 var versions = this._versions; 5552 var versionInstance = versions.filter(function (v) { 5553 return v._cfg.version === versionNumber; 5554 })[0]; 5555 if (versionInstance) return versionInstance; 5556 versionInstance = new this.Version(versionNumber); 5557 versions.push(versionInstance); 5558 versions.sort(lowerVersionFirst); 5559 versionInstance.stores({}); 5560 this._state.autoSchema = false;
5561 return versionInstance; 5562 }; 5563 5564 Dexie.prototype._whenReady = function (fn) { 5565 var _this = this; 5566 5567 return this.idbdb && (this._state.openComplete || PSD.letThrough || this._vip) ? fn() : new DexiePromise(function (resolve, reject) { 5568 if (_this._state.openComplete) { 5569 return reject(new exceptions.DatabaseClosed(_this._state.dbOpenError)); 5570 } 5571 5572 if (!_this._state.isBeingOpened) { 5573 if (!_this._options.autoOpen) { 5574 reject(new exceptions.DatabaseClosed()); 5575 return; 5576 } 5577 5578 _this.open()["catch"](nop); 5579 } 5580 5581 _this._state.dbReadyPromise.then(resolve, reject); 5582 }).then(fn); 5583 }; 5584 5585 Dexie.prototype.use = function (_a) { 5586 var stack = _a.stack, 5587 create = _a.create, 5588 level = _a.level, 5589 name = _a.name; 5590 if (name) this.unuse({ 5591 stack: stack, 5592 name: name 5593 }); 5594 var middlewares = this._middlewares[stack] || (this._middlewares[stack] = []); 5595 middlewares.push({ 5596 stack: stack, 5597 create: create, 5598 level: level == null ? 10 : level, 5599 name: name 5600 }); 5601 middlewares.sort(function (a, b) { 5602 return a.level - b.level; 5603 }); 5604 return this; 5605 }; 5606 5607 Dexie.prototype.unuse = function (_a) { 5608 var stack = _a.stack, 5609 name = _a.name, 5610 create = _a.create; 5611 5612 if (stack && this._middlewares[stack]) { 5613 this._middlewares[stack] = this._middlewares[stack].filter(function (mw) { 5614 return create ? mw.create !== create : name ? mw.name !== name : false; 5615 }); 5616 } 5617 5618 return this; 5619 }; 5620 5621 Dexie.prototype.open = function () { 5622 return dexieOpen(this); 5623 }; 5624 5625 Dexie.prototype._close = function () { 5626 var state = this._state; 5627 var idx = connections.indexOf(this); 5628 if (idx >= 0) connections.splice(idx, 1); 5629 5630 if (this.idbdb) { 5631 try { 5632 this.idbdb.close(); 5633 } catch (e) {} 5634 5635 this._novip.idbdb = null; 5636 } 5637 5638 state.dbReadyPromise = new DexiePromise(function (resolve) { 5639 state.dbReadyResolve = resolve; 5640 }); 5641 state.openCanceller = new DexiePromise(function (_, reject) { 5642 state.cancelOpen = reject; 5643 }); 5644 }; 5645 5646 Dexie.prototype.close = function () { 5647 this._close(); 5648 5649 var state = this._state; 5650 this._options.autoOpen = false; 5651 state.dbOpenError = new exceptions.DatabaseClosed(); 5652 if (state.isBeingOpened) state.cancelOpen(state.dbOpenError); 5653 }; 5654 5655 Dexie.prototype["delete"] = function () { 5656 var _this = this; 5657 5658 var hasArguments = arguments.length > 0; 5659 var state = this._state; 5660 return new DexiePromise(function (resolve, reject) { 5661 var doDelete = function doDelete() { 5662 _this.close(); 5663 5664 var req = _this._deps.indexedDB.deleteDatabase(_this.name); 5665 5666 req.onsuccess = wrap(function () { 5667 _onDatabaseDeleted(_this._deps, _this.name); 5668 5669 resolve(); 5670 }); 5671 req.onerror = eventRejectHandler(reject); 5672 req.onblocked = _this._fireOnBlocked; 5673 }; 5674 5675 if (hasArguments) throw new exceptions.InvalidArgument("Arguments not allowed in db.delete()"); 5676 5677 if (state.isBeingOpened) { 5678 state.dbReadyPromise.then(doDelete); 5679 } else { 5680 doDelete(); 5681 } 5682 }); 5683 }; 5684 5685 Dexie.prototype.backendDB = function () { 5686 return this.idbdb; 5687 }; 5688 5689 Dexie.prototype.isOpen = function () { 5690 return this.idbdb !== null; 5691 }; 5692 5693 Dexie.prototype.hasBeenClosed = function () { 5694 var dbOpenError = this._state.dbOpenError; 5695 return dbOpenError && dbOpenError.name === 'DatabaseClosed'; 5696 }; 5697 5698 Dexie.prototype.hasFailed = function () { 5699 return this._state.dbOpenError !== null; 5700 }; 5701 5702 Dexie.prototype.dynamicallyOpened = function () { 5703 return this._state.autoSchema; 5704 }; 5705 5706 Object.defineProperty(Dexie.prototype, "tables", { 5707 get: function get() { 5708 var _this = this; 5709 5710 return keys(this._allTables).map(function (name) { 5711 return _this._allTables[name]; 5712 }); 5713 }, 5714 enumerable: false, 5715 configurable: true 5716 }); 5717 5718 Dexie.prototype.transaction = function () { 5719 var args = extractTransactionArgs.apply(this, arguments); 5720 return this._transaction.apply(this, args); 5721 }; 5722 5723 Dexie.prototype._transaction = function (mode, tables, scopeFunc) { 5724 var _this = this; 5725 5726 var parentTransaction = PSD.trans; 5727 if (!parentTransaction || parentTransaction.db !== this || mode.indexOf('!') !== -1) parentTransaction = null; 5728 var onlyIfCompatible = mode.indexOf('?') !== -1; 5729 mode = mode.replace('!', '').replace('?', ''); 5730 var idbMode, storeNames; 5731 5732 try { 5733 storeNames = tables.map(function (table) { 5734 var storeName = table instanceof _this.Table ? table.name : table; 5735 if (typeof storeName !== 'string') throw new TypeError("Invalid table argument to Dexie.transaction(). Only Table or String are allowed"); 5736 return storeName; 5737 }); 5738 if (mode == "r" || mode === READONLY) idbMode = READONLY;else if (mode == "rw" || mode == READWRITE) idbMode = READWRITE;else throw new exceptions.InvalidArgument("Invalid transaction mode: " + mode); 5739 5740 if (parentTransaction) { 5741 if (parentTransaction.mode === READONLY && idbMode === READWRITE) { 5742 if (onlyIfCompatible) { 5743 parentTransaction = null; 5744 } else throw new exceptions.SubTransaction("Cannot enter a sub-transaction with READWRITE mode when parent transaction is READONLY"); 5745 } 5746 5747 if (parentTransaction) {
5748 storeNames.forEach(function (storeName) { 5749 if (parentTransaction && parentTransaction.storeNames.indexOf(storeName) === -1) { 5750 if (onlyIfCompatible) { 5751 parentTransaction = null; 5752 } else throw new exceptions.SubTransaction("Table " + storeName + " not included in parent transaction."); 5753 } 5754 }); 5755 } 5756 5757 if (onlyIfCompatible && parentTransaction && !parentTransaction.active) { 5758 parentTransaction = null; 5759 } 5760 } 5761 } catch (e) { 5762 return parentTransaction ? parentTransaction._promise(null, function (_, reject) { 5763 reject(e); 5764 }) : rejection(e); 5765 } 5766 5767 var enterTransaction = enterTransactionScope.bind(null, this, idbMode, storeNames, parentTransaction, scopeFunc); 5768 return parentTransaction ? parentTransaction._promise(idbMode, enterTransaction, "lock") : PSD.trans ? usePSD(PSD.transless, function () { 5769 return _this._whenReady(enterTransaction); 5770 }) : this._whenReady(enterTransaction); 5771 }; 5772 5773 Dexie.prototype.table = function (tableName) { 5774 if (!hasOwn(this._allTables, tableName)) { 5775 throw new exceptions.InvalidTable("Table " + tableName + " does not exist"); 5776 } 5777 5778 return this._allTables[tableName]; 5779 }; 5780 5781 return Dexie; 5782 }(); 5783 5784 var symbolObservable = typeof Symbol !== "undefined" && "observable" in Symbol ? Symbol.observable : "@@observable"; 5785 5786 var Observable = function () { 5787 function Observable(subscribe) { 5788 this._subscribe = subscribe; 5789 } 5790 5791 Observable.prototype.subscribe = function (x, error, complete) { 5792 return this._subscribe(!x || typeof x === "function" ? { 5793 next: x, 5794 error: error, 5795 complete: complete 5796 } : x); 5797 }; 5798 5799 Observable.prototype[symbolObservable] = function () { 5800 return this; 5801 }; 5802 5803 return Observable; 5804 }(); 5805 5806 function extendObservabilitySet(target, newSet) { 5807 keys(newSet).forEach(function (part) { 5808 var rangeSet = target[part] || (target[part] = new RangeSet()); 5809 mergeRanges(rangeSet, newSet[part]); 5810 }); 5811 return target; 5812 } 5813 5814 function liveQuery(querier) { 5815 return new Observable(function (observer) { 5816 var scopeFuncIsAsync = isAsyncFunction(querier); 5817 5818 function execute(subscr) { 5819 if (scopeFuncIsAsync) { 5820 incrementExpectedAwaits(); 5821 } 5822 5823 var exec = function exec() { 5824 return newScope(querier, { 5825 subscr: subscr, 5826 trans: null 5827 }); 5828 }; 5829 5830 var rv = PSD.trans ? usePSD(PSD.transless, exec) : exec(); 5831 5832 if (scopeFuncIsAsync) { 5833 rv.then(decrementExpectedAwaits, decrementExpectedAwaits); 5834 } 5835 5836 return rv; 5837 } 5838 5839 var closed = false; 5840 var accumMuts = {}; 5841 var currentObs = {}; 5842 var subscription = { 5843 get closed() { 5844 return closed; 5845 }, 5846 5847 unsubscribe: function unsubscribe() { 5848 closed = true; 5849 globalEvents.storagemutated.unsubscribe(mutationListener); 5850 } 5851 }; 5852 observer.start && observer.start(subscription); 5853 var querying = false, 5854 startedListening = false; 5855 5856 function shouldNotify() { 5857 return keys(currentObs).some(function (key) { 5858 return accumMuts[key] && rangesOverlap(accumMuts[key], currentObs[key]); 5859 }); 5860 } 5861 5862 var mutationListener = function mutationListener(parts) { 5863 extendObservabilitySet(accumMuts, parts); 5864 5865 if (shouldNotify()) { 5866 doQuery(); 5867 } 5868 }; 5869 5870 var doQuery = function doQuery() { 5871 if (querying || closed) return; 5872 accumMuts = {}; 5873 var subscr = {}; 5874 var ret = execute(subscr); 5875 5876 if (!startedListening) { 5877 globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, mutationListener); 5878 startedListening = true; 5879 } 5880 5881 querying = true; 5882 Promise.resolve(ret).then(function (result) { 5883 querying = false; 5884 if (closed) return; 5885 5886 if (shouldNotify()) { 5887 doQuery(); 5888 } else { 5889 accumMuts = {}; 5890 currentObs = subscr; 5891 observer.next && observer.next(result); 5892 } 5893 }, function (err) { 5894 querying = false;
5895 observer.error && observer.error(err); 5896 subscription.unsubscribe(); 5897 }); 5898 }; 5899 5900 doQuery(); 5901 return subscription; 5902 }); 5903 } 5904 5905 var domDeps; 5906 5907 try { 5908 domDeps = { 5909 indexedDB: _global.indexedDB || _global.mozIndexedDB || _global.webkitIndexedDB || _global.msIndexedDB, 5910 IDBKeyRange: _global.IDBKeyRange || _global.webkitIDBKeyRange 5911 }; 5912 } catch (e) { 5913 domDeps = { 5914 indexedDB: null, 5915 IDBKeyRange: null 5916 }; 5917 } 5918 5919 var Dexie = Dexie$1; 5920 props(Dexie, _assign(_assign({}, fullNameExceptions), { 5921 "delete": function _delete(databaseName) { 5922 var db = new Dexie(databaseName, { 5923 addons: [] 5924 }); 5925 return db["delete"](); 5926 }, 5927 exists: function exists(name) { 5928 return new Dexie(name, { 5929 addons: [] 5930 }).open().then(function (db) { 5931 db.close(); 5932 return true; 5933 })["catch"]('NoSuchDatabaseError', function () { 5934 return false; 5935 }); 5936 }, 5937 getDatabaseNames: function getDatabaseNames(cb) { 5938 try { 5939 return _getDatabaseNames(Dexie.dependencies).then(cb); 5940 } catch (_a) { 5941 return rejection(new exceptions.MissingAPI()); 5942 } 5943 }, 5944 defineClass: function defineClass() { 5945 function Class(content) { 5946 extend(this, content); 5947 } 5948 5949 return Class; 5950 }, 5951 ignoreTransaction: function ignoreTransaction(scopeFunc) { 5952 return PSD.trans ? usePSD(PSD.transless, scopeFunc) : scopeFunc(); 5953 }, 5954 vip: vip, 5955 async: function async(generatorFn) { 5956 return function () { 5957 try { 5958 var rv = awaitIterator(generatorFn.apply(this, arguments)); 5959 if (!rv || typeof rv.then !== 'function') return DexiePromise.resolve(rv); 5960 return rv; 5961 } catch (e) { 5962 return rejection(e); 5963 } 5964 }; 5965 }, 5966 spawn: function spawn(generatorFn, args, thiz) { 5967 try { 5968 var rv = awaitIterator(generatorFn.apply(thiz, args || [])); 5969 if (!rv || typeof rv.then !== 'function') return DexiePromise.resolve(rv); 5970 return rv; 5971 } catch (e) { 5972 return rejection(e); 5973 } 5974 }, 5975 currentTransaction: { 5976 get: function get() { 5977 return PSD.trans || null; 5978 } 5979 }, 5980 waitFor: function waitFor(promiseOrFunction, optionalTimeout) { 5981 var promise = DexiePromise.resolve(typeof promiseOrFunction === 'function' ? Dexie.ignoreTransaction(promiseOrFunction) : promiseOrFunction).timeout(optionalTimeout || 60000); 5982 return PSD.trans ? PSD.trans.waitFor(promise) : promise; 5983 }, 5984 Promise: DexiePromise, 5985 debug: { 5986 get: function get() { 5987 return debug; 5988 }, 5989 set: function set(value) { 5990 setDebug(value, value === 'dexie' ? function () { 5991 return true; 5992 } : dexieStackFrameFilter); 5993 } 5994 }, 5995 derive: derive, 5996 extend: extend, 5997 props: props, 5998 override: override, 5999 Events: Events, 6000 on: globalEvents, 6001 liveQuery: liveQuery, 6002 extendObservabilitySet: extendObservabilitySet, 6003 getByKeyPath: getByKeyPath, 6004 setByKeyPath: setByKeyPath, 6005 delByKeyPath: delByKeyPath, 6006 shallowClone: shallowClone, 6007 deepClone: deepClone, 6008 getObjectDiff: getObjectDiff, 6009 cmp: cmp, 6010 asap: asap$1, 6011 minKey: minKey, 6012 addons: [], 6013 connections: connections, 6014 errnames: errnames, 6015 dependencies: domDeps, 6016 semVer: DEXIE_VERSION, 6017 version: DEXIE_VERSION.split('.').map(function (n) { 6018 return parseInt(n); 6019 }).reduce(function (p, c, i) { 6020 return p + c / Math.pow(10, i * 2); 6021 }) 6022 })); 6023 Dexie.maxKey = _getMaxKey(Dexie.dependencies.IDBKeyRange); 6024 6025 if (typeof dispatchEvent !== 'undefined' && typeof addEventListener !== 'undefined') { 6026 globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, function (updatedParts) { 6027 if (!propagatingLocally) { 6028 var event_1; 6029 6030 if (isIEOrEdge) { 6031 event_1 = document.createEvent('CustomEvent'); 6032 event_1.initCustomEvent(STORAGE_MUTATED_DOM_EVENT_NAME, true, true, updatedParts); 6033 } else { 6034 event_1 = new CustomEvent(STORAGE_MUTATED_DOM_EVENT_NAME, { 6035 detail: updatedParts 6036 }); 6037 } 6038 6039 propagatingLocally = true; 6040 dispatchEvent(event_1); 6041 propagatingLocally = false;
6042 } 6043 }); 6044 addEventListener(STORAGE_MUTATED_DOM_EVENT_NAME, function (_a) { 6045 var detail = _a.detail; 6046 6047 if (!propagatingLocally) { 6048 propagateLocally(detail); 6049 } 6050 }); 6051 } 6052 6053 function propagateLocally(updateParts) { 6054 var wasMe = propagatingLocally; 6055 6056 try { 6057 propagatingLocally = true; 6058 globalEvents.storagemutated.fire(updateParts); 6059 } finally { 6060 propagatingLocally = wasMe; 6061 } 6062 } 6063 6064 var propagatingLocally = false; 6065 6066 if (typeof BroadcastChannel !== 'undefined') { 6067 var bc_1 = new BroadcastChannel(STORAGE_MUTATED_DOM_EVENT_NAME); 6068 globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, function (changedParts) { 6069 if (!propagatingLocally) { 6070 bc_1.postMessage(changedParts); 6071 } 6072 }); 6073 6074 bc_1.onmessage = function (ev) { 6075 if (ev.data) propagateLocally(ev.data); 6076 }; 6077 } else if (typeof self !== 'undefined' && typeof navigator !== 'undefined') { 6078 globalEvents(DEXIE_STORAGE_MUTATED_EVENT_NAME, function (changedParts) { 6079 try { 6080 if (!propagatingLocally) { 6081 if (typeof localStorage !== 'undefined') { 6082 localStorage.setItem(STORAGE_MUTATED_DOM_EVENT_NAME, JSON.stringify({ 6083 trig: Math.random(), 6084 changedParts: changedParts 6085 })); 6086 } 6087 6088 if (babelHelpers["typeof"](self['clients']) === 'object') { 6089 __spreadArray([], self['clients'].matchAll({ 6090 includeUncontrolled: true 6091 }), true).forEach(function (client) { 6092 return client.postMessage({ 6093 type: STORAGE_MUTATED_DOM_EVENT_NAME, 6094 changedParts: changedParts 6095 }); 6096 }); 6097 } 6098 } 6099 } catch (_a) {} 6100 }); 6101 6102 if (typeof addEventListener !== 'undefined') { 6103 addEventListener('storage', function (ev) { 6104 if (ev.key === STORAGE_MUTATED_DOM_EVENT_NAME) { 6105 var data = JSON.parse(ev.newValue); 6106 if (data) propagateLocally(data.changedParts); 6107 } 6108 }); 6109 } 6110 6111 var swContainer = self.document && navigator.serviceWorker; 6112 6113 if (swContainer) { 6114 swContainer.addEventListener('message', propagateMessageLocally); 6115 } 6116 } 6117 6118 function propagateMessageLocally(_a) { 6119 var data = _a.data; 6120 6121 if (data && data.type === STORAGE_MUTATED_DOM_EVENT_NAME) { 6122 propagateLocally(data.changedParts); 6123 } 6124 } 6125 6126 DexiePromise.rejectionMapper = mapError; 6127 setDebug(debug, dexieStackFrameFilter); // backward compatibility with Dexie 2 usages 6128 6129 window.BX.Dexie = Dexie$1; 6130 6131 exports.Dexie = Dexie$1; 6132 exports.liveQuery = liveQuery; 6133 exports.RangeSet = RangeSet; 6134 exports.mergeRanges = mergeRanges; 6135 exports.rangesOverlap = rangesOverlap; 6136 6137}((this.BX.Dexie3 = this.BX.Dexie3 || {}))); 6138//# sourceMappingURL=dexie3.bundle.js.map
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.