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