https://fxboss.firstcitizens.com/app/assets/angular-cache/angular-cache.js?v=9.0.2

1/**
2 * angular-cache
3 * @version 4.6.0 - Homepage <https://github.com/jmdobry/angular-cache>
4 * @copyright (c) 2013-2016 angular-cache project authors
5 * @license MIT <https://github.com/jmdobry/angular-cache/blob/master/LICENSE>
6 * @overview angular-cache is a very useful replacement for Angular's $cacheFactory.
7 */
8(function (global, factory) {
9  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(typeof angular === 'undefined' ? require('angular') : angular) :
10  typeof define === 'function' && define.amd ? define('angular-cache', ['angular'], factory) :
11  (global.angularCacheModuleName = factory(global.angular));
12}(this, function (angular) { 'use strict';
13
14  angular = 'default' in angular ? angular['default'] : angular;
15
16  var babelHelpers = {};
17  babelHelpers.typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
18    return typeof obj;
19  } : function (obj) {
20    return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj;
21  };
22  
23  /**
24   * @method bubbleUp
25   * @param {array} heap The heap.
26   * @param {function} weightFunc The weight function.
27   * @param {number} n The index of the element to bubble up.
28   */
29  var bubbleUp = function bubbleUp(heap, weightFunc, n) {
30    var element = heap[n];
31    var weight = weightFunc(element);
32    // When at 0, an element can not go up any further.
33    while (n > 0) {
34      // Compute the parent element's index, and fetch it.
35      var parentN = Math.floor((n + 1) / 2) - 1;
36      var parent = heap[parentN];
37      // If the parent has a lesser weight, things are in order and we
38      // are done.
39      if (weight >= weightFunc(parent)) {
40        break;
41      } else {
42        heap[parentN] = element;
43        heap[n] = parent;
44        n = parentN;
45      }
46    }
47  };
48
49  /**
50   * @method bubbleDown
51   * @param {array} heap The heap.
52   * @param {function} weightFunc The weight function.
53   * @param {number} n The index of the element to sink down.
54   */
55  var bubbleDown = function bubbleDown(heap, weightFunc, n) {
56    var length = heap.length;
57    var node = heap[n];
58    var nodeWeight = weightFunc(node);
59
60    while (true) {
61      var child2N = (n + 1) * 2;
62      var child1N = child2N - 1;
63      var swap = null;
64      if (child1N < length) {
65        var child1 = heap[child1N];
66        var child1Weight = weightFunc(child1);
67        // If the score is less than our node's, we need to swap.
68        if (child1Weight < nodeWeight) {
69          swap = child1N;
70        }
71      }
72      // Do the same checks for the other child.
73      if (child2N < length) {
74        var child2 = heap[child2N];
75        var child2Weight = weightFunc(child2);
76        if (child2Weight < (swap === null ? nodeWeight : weightFunc(heap[child1N]))) {
77          swap = child2N;
78        }
79      }
80
81      if (swap === null) {
82        break;
83      } else {
84        heap[n] = heap[swap];
85        heap[swap] = node;
86        n = swap;
87      }
88    }
89  };
90
91  function BinaryHeap(weightFunc, compareFunc) {
92    if (!weightFunc) {
93      weightFunc = function weightFunc(x) {
94        return x;
95      };
96    }
97    if (!compareFunc) {
98      compareFunc = function compareFunc(x, y) {
99        return x === y;
100      };
101    }
102    if (typeof weightFunc !== 'function') {
103      throw new Error('BinaryHeap([weightFunc][, compareFunc]): "weightFunc" must be a function!');
104    }
105    if (typeof compareFunc !== 'function') {
106      throw new Error('BinaryHeap([weightFunc][, compareFunc]): "compareFunc" must be a function!');
107    }
108    this.weightFunc = weightFunc;
109    this.compareFunc = compareFunc;
110    this.heap = [];
111  }
112
113  var BHProto = BinaryHeap.prototype;
114
115  BHProto.push = function (node) {
116    this.heap.push(node);
117    bubbleUp(this.heap, this.weightFunc, this.heap.length - 1);
118  };
119
120  BHProto.peek = function () {
121    return this.heap[0];
122  };
123
124  BHProto.pop = function () {
125    var front = this.heap[0];
126    var end = this.heap.pop();
127    if (this.heap.length > 0) {
128      this.heap[0] = end;
129      bubbleDown(this.heap, this.weightFunc, 0);
130    }
131    return front;
132  };
133
134  BHProto.remove = function (node) {
135    var length = this.heap.length;
136    for (var i = 0; i < length; i++) {
137      if (this.compareFunc(this.heap[i], node)) {
138        var removed = this.heap[i];
139        var end = this.heap.pop();
140        if (i !== length - 1) {
141          this.heap[i] = end;
142          bubbleUp(this.heap, this.weightFunc, i);
143          bubbleDown(this.heap, this.weightFunc, i);
144        }
145        return removed;
146      }
147    }
148    return null;
149  };
150
151  BHProto.removeAll = function () {
152    this.heap = [];
153  };
154
155  BHProto.size = function () {
156    return this.heap.length;
157  };
158
159  var _Promise = null;
160  try {
161    _Promise = window.Promise;
162  } catch (e) {}
163
164  var utils = {
165    isNumber: function isNumber(value) {
166      return typeof value === 'number';
167    },
168    isString: function isString(value) {
169      return typeof value === 'string';
170    },
171    isObject: function isObject(value) {
172      return value !== null && (typeof value === 'undefined' ? 'undefined' : babelHelpers.typeof(value)) === 'object';
173    },
174    isFunction: function isFunction(value) {
175      return typeof value === 'function';
176    },
177    fromJson: function fromJson(value) {
178      return JSON.parse(value);
179    },
180    equals: function equals(a, b) {
181      return a === b;
182    },
183
184    Promise: _Promise
185  };
186
187  function _keys(collection) {
188    var keys = [];
189    var key = void 0;
190    if (!utils.isObject(collection)) {
191      return keys;
192    }
193    for (key in collection) {
194      if (collection.hasOwnProperty(key)) {
195        keys.push(key);
196      }
197    }
198    return keys;
199  }
200
201  function _isPromiseLike(value) {
202    return value && typeof value.then === 'function';
203  }
204
205  function _stringifyNumber(number) {
206    if (utils.isNumber(number)) {
207      return number.toString();
208    }
209    return number;
210  }
211
212  function _keySet(collection) {
213    var keySet = {};
214    var key = void 0;
215    if (!utils.isObject(collection)) {
216      return keySet;
217    }
218    for (key in collection) {
219      if (collection.hasOwnProperty(key)) {
220        keySet[key] = key;
221      }
222    }
223    return keySet;
224  }
225
226  var defaults = {
227    capacity: Number.MAX_VALUE,
228    maxAge: Number.MAX_VALUE,
229    deleteOnExpire: 'none',
230    onExpire: null,
231    cacheFlushInterval: null,
232    recycleFreq: 1000,
233    storageMode: 'memory',
234    storageImpl: null,
235    disabled: false,
236    storagePrefix: 'cachefactory.caches.',
237    storeOnResolve: false,
238    storeOnReject: false
239  };
240
241  var caches = {};
242
243  function createCache(cacheId, options) {
244    if (cacheId in caches) {
245      throw new Error(cacheId + ' already exists!');
246    } else if (!utils.isString(cacheId)) {
247      throw new Error('cacheId must be a string!');
248    }
249
250    var $$data = {};
251    var $$promises = {};
252    var $$storage = null;
253    var $$expiresHeap = new BinaryHeap(function (x) {
254      return x.expires;
255    }, utils.equals);
256    var $$lruHeap = new BinaryHeap(function (x) {
257      return x.accessed;
258    }, utils.equals);
259
260    var cache = caches[cacheId] = {
261
262      $$id: cacheId,
263
264      destroy: function destroy() {
265        clearInterval(this.$$cacheFlushIntervalId);
266        clearInterval(this.$$recycleFreqId);
267        this.removeAll();
268        if ($$storage) {
269          $$storage().removeItem(this.$$prefix + '.keys');
270          $$storage().removeItem(this.$$prefix);
271        }
272        $$storage = null;
273        $$data = null;
274        $$lruHeap = null;
275        $$expiresHeap = null;
276        this.$$prefix = null;
277        delete caches[this.$$id];
278      },
279      disable: function disable() {
280        this.$$disabled = true;
281      },
282      enable: function enable() {
283        delete this.$$disabled;
284      },
285      get: function get(key, options) {
286        var _this2 = this;
287
288        if (Array.isArray(key)) {
289          var _ret = function () {
290            var keys = key;
291            var values = [];
292
293            keys.forEach(function (key) {
294              var value = _this2.get(key, options);
295              if (value !== null && value !== undefined) {
296                values.push(value);
297              }
298            });
299
300            return {
301              v: values
302            };
303          }();
304
305          if ((typeof _ret === 'undefined' ? 'undefined' : babelHelpers.typeof(_ret)) === "object") return _ret.v;
306        } else {
307          key = _stringifyNumber(key);
308
309          if (this.$$disabled) {
310            return;
311          }
312        }
313
314        options = options || {};
315        if (!utils.isString(key)) {
316          throw new Error('key must be a string!');
317        } else if (options && !utils.isObject(options)) {
318          throw new Error('options must be an object!');
319        } else if (options.onExpire && !utils.isFunction(options.onExpire)) {
320          throw new Error('options.onExpire must be a function!');
321        }
322
323        var item = void 0;
324
325        if ($$storage) {
326          if ($$promises[key]) {
327            return $$promises[key];
328          }
329
330          var itemJson = $$storage().getItem(this.$$prefix + '.data.' + key);
331
332          if (itemJson) {
333            item = utils.fromJson(itemJson);
334          } else {
335            return;
336          }
337        } else if (utils.isObject($$data)) {
338          if (!(key in $$data)) {
339            return;
340          }
341
342          item = $$data[key];
343        }
344
345        var value = item.value;
346        var now = new Date().getTime();
347
348        if ($$storage) {
349          $$lruHeap.remove({
350            key: key,
351            accessed: item.accessed
352          });
353          item.accessed = now;
354          $$lruHeap.push({
355            key: key,
356            accessed: now
357          });
358        } else {
359          $$lruHeap.remove(item);
360          item.accessed = now;
361          $$lruHeap.push(item);
362        }
363
364        if (this.$$deleteOnExpire === 'passive' && 'expires' in item && item.expires < now) {
365          this.remove(key);
366
367          if (this.$$onExpire) {
368            this.$$onExpire(key, item.value, options.onExpire);
369          } else if (options.onExpire) {
370            options.onExpire.call(this, key, item.value);
371          }
372          value = undefined;
373        } else if ($$storage) {
374          $$storage().setItem(this.$$prefix + '.data.' + key, JSON.stringify(item));
375        }
376
377        return value;
378      },
379      info: function info(key) {
380        if (key) {
381          var item = void 0;
382          if ($$storage) {
383            var itemJson = $$storage().getItem(this.$$prefix + '.data.' + key);
384
385            if (itemJson) {
386              item = utils.fromJson(itemJson);
387              return {
388                created: item.created,

389                accessed: item.accessed,
390                expires: item.expires,
391                isExpired: new Date().getTime() - item.created > (item.maxAge || this.$$maxAge)
392              };
393            } else {
394              return undefined;
395            }
396          } else if (utils.isObject($$data) && key in $$data) {
397            item = $$data[key];
398
399            return {
400              created: item.created,
401              accessed: item.accessed,
402              expires: item.expires,
403              isExpired: new Date().getTime() - item.created > (item.maxAge || this.$$maxAge)
404            };
405          } else {
406            return undefined;
407          }
408        } else {
409          return {
410            id: this.$$id,
411            capacity: this.$$capacity,
412            maxAge: this.$$maxAge,
413            deleteOnExpire: this.$$deleteOnExpire,
414            onExpire: this.$$onExpire,
415            cacheFlushInterval: this.$$cacheFlushInterval,
416            recycleFreq: this.$$recycleFreq,
417            storageMode: this.$$storageMode,
418            storageImpl: $$storage ? $$storage() : undefined,
419            disabled: !!this.$$disabled,
420            size: $$lruHeap && $$lruHeap.size() || 0
421          };
422        }
423      },
424      keys: function keys() {
425        if ($$storage) {
426          var keysJson = $$storage().getItem(this.$$prefix + '.keys');
427
428          if (keysJson) {
429            return utils.fromJson(keysJson);
430          } else {
431            return [];
432          }
433        } else {
434          return _keys($$data);
435        }
436      },
437      keySet: function keySet() {
438        if ($$storage) {
439          var keysJson = $$storage().getItem(this.$$prefix + '.keys');
440          var kSet = {};
441
442          if (keysJson) {
443            var keys = utils.fromJson(keysJson);
444
445            for (var i = 0; i < keys.length; i++) {
446              kSet[keys[i]] = keys[i];
447            }
448          }
449          return kSet;
450        } else {
451          return _keySet($$data);
452        }
453      },
454      put: function put(key, value, options) {
455        var _this3 = this;
456
457        options || (options = {});
458
459        var storeOnResolve = 'storeOnResolve' in options ? !!options.storeOnResolve : this.$$storeOnResolve;
460        var storeOnReject = 'storeOnReject' in options ? !!options.storeOnReject : this.$$storeOnReject;
461
462        var getHandler = function getHandler(store, isError) {
463          return function (v) {
464            if (store) {
465              delete $$promises[key];
466              if (utils.isObject(v) && 'status' in v && 'data' in v) {
467                v = [v.status, v.data, v.headers(), v.statusText];
468                _this3.put(key, v);
469              } else {
470                _this3.put(key, v);
471              }
472            }
473            if (isError) {
474              if (utils.Promise) {
475                return utils.Promise.reject(v);
476              } else {
477                throw v;
478              }
479            } else {
480              return v;
481            }
482          };
483        };
484
485        if (this.$$disabled || !utils.isObject($$data) || value === null || value === undefined) {
486          return;
487        }
488        key = _stringifyNumber(key);
489
490        if (!utils.isString(key)) {
491          throw new Error('key must be a string!');
492        }
493
494        var now = new Date().getTime();
495        var item = {
496          key: key,
497          value: _isPromiseLike(value) ? value.then(getHandler(storeOnResolve, false), getHandler(storeOnReject, true)) : value,
498          created: options.created === undefined ? now : options.created,
499          accessed: options.accessed === undefined ? now : options.accessed
500        };
501        if (options.maxAge) {
502          item.maxAge = options.maxAge;
503        }
504
505        if (options.expires === undefined) {
506          item.expires = item.created + (item.maxAge || this.$$maxAge);
507        } else {
508          item.expires = options.expires;
509        }
510
511        if ($$storage) {
512          if (_isPromiseLike(item.value)) {
513            $$promises[key] = item.value;
514            return $$promises[key];
515          }
516          var keysJson = $$storage().getItem(this.$$prefix + '.keys');
517          var keys = keysJson ? utils.fromJson(keysJson) : [];
518          var itemJson = $$storage().getItem(this.$$prefix + '.data.' + key);
519
520          // Remove existing
521          if (itemJson) {
522            this.remove(key);
523          }
524          // Add to expires heap
525          $$expiresHeap.push({
526            key: key,
527            expires: item.expires
528          });
529          // Add to lru heap
530          $$lruHeap.push({
531            key: key,
532            accessed: item.accessed
533          });
534          // Set item
535          $$storage().setItem(this.$$prefix + '.data.' + key, JSON.stringify(item));
536          var exists = false;

537          for (var i = 0; i < keys.length; i++) {
538            if (keys[i] === key) {
539              exists = true;
540              break;
541            }
542          }
543          if (!exists) {
544            keys.push(key);
545          }
546          $$storage().setItem(this.$$prefix + '.keys', JSON.stringify(keys));
547        } else {
548          // Remove existing
549          if ($$data[key]) {
550            this.remove(key);
551          }
552          // Add to expires heap
553          $$expiresHeap.push(item);
554          // Add to lru heap
555          $$lruHeap.push(item);
556          // Set item
557          $$data[key] = item;
558          delete $$promises[key];
559        }
560
561        // Handle exceeded capacity
562        if ($$lruHeap.size() > this.$$capacity) {
563          this.remove($$lruHeap.peek().key);
564        }
565
566        return value;
567      },
568      remove: function remove(key) {
569        key += '';
570        delete $$promises[key];
571        if ($$storage) {
572          var itemJson = $$storage().getItem(this.$$prefix + '.data.' + key);
573
574          if (itemJson) {
575            var item = utils.fromJson(itemJson);
576            $$lruHeap.remove({
577              key: key,
578              accessed: item.accessed
579            });
580            $$expiresHeap.remove({
581              key: key,
582              expires: item.expires
583            });
584            $$storage().removeItem(this.$$prefix + '.data.' + key);
585            var keysJson = $$storage().getItem(this.$$prefix + '.keys');
586            var keys = keysJson ? utils.fromJson(keysJson) : [];
587            var index = keys.indexOf(key);
588
589            if (index >= 0) {
590              keys.splice(index, 1);
591            }
592            $$storage().setItem(this.$$prefix + '.keys', JSON.stringify(keys));
593            return item.value;
594          }
595        } else if (utils.isObject($$data)) {
596          var value = $$data[key] ? $$data[key].value : undefined;
597          $$lruHeap.remove($$data[key]);
598          $$expiresHeap.remove($$data[key]);
599          $$data[key] = null;
600          delete $$data[key];
601          return value;
602        }
603      },
604      removeAll: function removeAll() {
605        if ($$storage) {
606          $$lruHeap.removeAll();
607          $$expiresHeap.removeAll();
608          var keysJson = $$storage().getItem(this.$$prefix + '.keys');
609
610          if (keysJson) {
611            var keys = utils.fromJson(keysJson);
612
613            for (var i = 0; i < keys.length; i++) {
614              this.remove(keys[i]);
615            }
616          }
617          $$storage().setItem(this.$$prefix + '.keys', JSON.stringify([]));
618        } else if (utils.isObject($$data)) {
619          $$lruHeap.removeAll();
620          $$expiresHeap.removeAll();
621          for (var key in $$data) {
622            $$data[key] = null;
623          }
624          $$data = {};
625        } else {
626          $$lruHeap.removeAll();
627          $$expiresHeap.removeAll();
628          $$data = {};
629        }
630        $$promises = {};
631      },
632      removeExpired: function removeExpired() {
633        var now = new Date().getTime();
634        var expired = {};
635        var key = void 0;
636        var expiredItem = void 0;
637
638        while ((expiredItem = $$expiresHeap.peek()) && expiredItem.expires <= now) {
639          expired[expiredItem.key] = expiredItem.value ? expiredItem.value : null;
640          $$expiresHeap.pop();
641        }
642
643        if ($$storage) {
644          for (key in expired) {
645            var itemJson = $$storage().getItem(this.$$prefix + '.data.' + key);
646            if (itemJson) {
647              expired[key] = utils.fromJson(itemJson).value;
648              this.remove(key);
649            }
650          }
651        } else {
652          for (key in expired) {
653            this.remove(key);
654          }
655        }
656
657        if (this.$$onExpire) {
658          for (key in expired) {
659            this.$$onExpire(key, expired[key]);
660          }
661        }
662
663        return expired;
664      },
665      setCacheFlushInterval: function setCacheFlushInterval(cacheFlushInterval) {
666        var _this = this;
667        if (cacheFlushInterval === null) {
668          delete _this.$$cacheFlushInterval;
669        } else if (!utils.isNumber(cacheFlushInterval)) {
670          throw new Error('cacheFlushInterval must be a number!');
671        } else if (cacheFlushInterval < 0) {
672          throw new Error('cacheFlushInterval must be greater than zero!');
673        } else if (cacheFlushInterval !== _this.$$cacheFlushInterval) {
674          _this.$$cacheFlushInterval = cacheFlushInterval;
675
676          clearInterval(_this.$$cacheFlushIntervalId); // eslint-disable-line
677
678          _this.$$cacheFlushIntervalId = setInterval(function () {
679            _this.removeAll();
680          }, _this.$$cacheFlushInterval);
681        }
682      },
683      setCapacity: function setCapacity(capacity) {
684        if (capacity === null) {
685          delete this.$$capacity;
686        } else if (!utils.isNumber(capacity)) {
687          throw new Error('capacity must be a number!');
688        } else if (capacity < 0) {
689          throw new Error('capacity must be greater than zero!');
690        } else {
691          this.$$capacity = capacity;
692        }
693        var removed = {};
694        while ($$lruHeap.size() > this.$$capacity) {
695          removed[$$lruHeap.peek().key] = this.remove($$lruHeap.peek().key);
696        }
697        return removed;
698      },
699      setDeleteOnExpire: function setDeleteOnExpire(deleteOnExpire, setRecycleFreq) {
700        if (deleteOnExpire === null) {
701          delete this.$$deleteOnExpire;
702        } else if (!utils.isString(deleteOnExpire)) {
703          throw new Error('deleteOnExpire must be a string!');
704        } else if (deleteOnExpire !== 'none' && deleteOnExpire !== 'passive' && deleteOnExpire !== 'aggressive') {
705          throw new Error('deleteOnExpire must be "none", "passive" or "aggressive"!');
706        } else {
707          this.$$deleteOnExpire = deleteOnExpire;
708        }
709        if (setRecycleFreq !== false) {
710          this.setRecycleFreq(this.$$recycleFreq);
711        }
712      },

713      setMaxAge: function setMaxAge(maxAge) {
714        if (maxAge === null) {
715          this.$$maxAge = Number.MAX_VALUE;
716        } else if (!utils.isNumber(maxAge)) {
717          throw new Error('maxAge must be a number!');
718        } else if (maxAge < 0) {
719          throw new Error('maxAge must be greater than zero!');
720        } else {
721          this.$$maxAge = maxAge;
722        }
723        var i = void 0,
724            keys = void 0,
725            key = void 0;
726
727        $$expiresHeap.removeAll();
728
729        if ($$storage) {
730          var keysJson = $$storage().getItem(this.$$prefix + '.keys');
731
732          keys = keysJson ? utils.fromJson(keysJson) : [];
733
734          for (i = 0; i < keys.length; i++) {
735            key = keys[i];
736            var itemJson = $$storage().getItem(this.$$prefix + '.data.' + key);
737
738            if (itemJson) {
739              var item = utils.fromJson(itemJson);
740              if (this.$$maxAge === Number.MAX_VALUE) {
741                item.expires = Number.MAX_VALUE;
742              } else {
743                item.expires = item.created + (item.maxAge || this.$$maxAge);
744              }
745              $$expiresHeap.push({
746                key: key,
747                expires: item.expires
748              });
749            }
750          }
751        } else {
752          keys = _keys($$data);
753
754          for (i = 0; i < keys.length; i++) {
755            key = keys[i];
756            if (this.$$maxAge === Number.MAX_VALUE) {
757              $$data[key].expires = Number.MAX_VALUE;
758            } else {
759              $$data[key].expires = $$data[key].created + ($$data[key].maxAge || this.$$maxAge);
760            }
761            $$expiresHeap.push($$data[key]);
762          }
763        }
764        if (this.$$deleteOnExpire === 'aggressive') {
765          return this.removeExpired();
766        } else {
767          return {};
768        }
769      },
770      setOnExpire: function setOnExpire(onExpire) {
771        if (onExpire === null) {
772          delete this.$$onExpire;
773        } else if (!utils.isFunction(onExpire)) {
774          throw new Error('onExpire must be a function!');
775        } else {
776          this.$$onExpire = onExpire;
777        }
778      },
779      setOptions: function setOptions(cacheOptions, strict) {
780        cacheOptions = cacheOptions || {};
781        strict = !!strict;
782        if (!utils.isObject(cacheOptions)) {
783          throw new Error('cacheOptions must be an object!');
784        }
785
786        if ('storagePrefix' in cacheOptions) {
787          this.$$storagePrefix = cacheOptions.storagePrefix;
788        } else if (strict) {
789          this.$$storagePrefix = defaults.storagePrefix;
790        }
791
792        this.$$prefix = this.$$storagePrefix + this.$$id;
793
794        if ('disabled' in cacheOptions) {
795          this.$$disabled = !!cacheOptions.disabled;
796        } else if (strict) {
797          this.$$disabled = defaults.disabled;
798        }
799
800        if ('deleteOnExpire' in cacheOptions) {
801          this.setDeleteOnExpire(cacheOptions.deleteOnExpire, false);
802        } else if (strict) {
803          this.setDeleteOnExpire(defaults.deleteOnExpire, false);
804        }
805
806        if ('recycleFreq' in cacheOptions) {
807          this.setRecycleFreq(cacheOptions.recycleFreq);
808        } else if (strict) {
809          this.setRecycleFreq(defaults.recycleFreq);
810        }
811
812        if ('maxAge' in cacheOptions) {
813          this.setMaxAge(cacheOptions.maxAge);
814        } else if (strict) {
815          this.setMaxAge(defaults.maxAge);
816        }
817
818        if ('storeOnResolve' in cacheOptions) {
819          this.$$storeOnResolve = !!cacheOptions.storeOnResolve;
820        } else if (strict) {
821          this.$$storeOnResolve = defaults.storeOnResolve;
822        }
823
824        if ('storeOnReject' in cacheOptions) {
825          this.$$storeOnReject = !!cacheOptions.storeOnReject;
826        } else if (strict) {
827          this.$$storeOnReject = defaults.storeOnReject;
828        }
829
830        if ('capacity' in cacheOptions) {
831          this.setCapacity(cacheOptions.capacity);
832        } else if (strict) {
833          this.setCapacity(defaults.capacity);
834        }
835
836        if ('cacheFlushInterval' in cacheOptions) {
837          this.setCacheFlushInterval(cacheOptions.cacheFlushInterval);
838        } else if (strict) {
839          this.setCacheFlushInterval(defaults.cacheFlushInterval);
840        }
841
842        if ('onExpire' in cacheOptions) {
843          this.setOnExpire(cacheOptions.onExpire);
844        } else if (strict) {
845          this.setOnExpire(defaults.onExpire);
846        }
847
848        if ('storageMode' in cacheOptions || 'storageImpl' in cacheOptions) {
849          this.setStorageMode(cacheOptions.storageMode || defaults.storageMode, cacheOptions.storageImpl || defaults.storageImpl);
850        } else if (strict) {
851          this.setStorageMode(defaults.storageMode, defaults.storageImpl);
852        }
853      },
854      setRecycleFreq: function setRecycleFreq(recycleFreq) {
855        if (recycleFreq === null) {
856          delete this.$$recycleFreq;
857        } else if (!utils.isNumber(recycleFreq)) {
858          throw new Error('recycleFreq must be a number!');
859        } else if (recycleFreq < 0) {
860          throw new Error('recycleFreq must be greater than zero!');
861        } else {
862          this.$$recycleFreq = recycleFreq;
863        }
864        clearInterval(this.$$recycleFreqId);
865        if (this.$$deleteOnExpire === 'aggressive') {
866          (function (self) {
867            self.$$recycleFreqId = setInterval(function () {
868              self.removeExpired();
869            }, self.$$recycleFreq);
870          })(this);
871        } else {
872          delete this.$$recycleFreqId;
873        }
874      },
875      setStorageMode: function setStorageMode(storageMode, storageImpl) {
876        if (!utils.isString(storageMode)) {
877          throw new Error('storageMode must be a string!');
878        } else if (storageMode !== 'memory' && storageMode !== 'localStorage' && storageMode !== 'sessionStorage') {
879          throw new Error('storageMode must be "memory", "localStorage" or "sessionStorage"!');
880        }
881
882        var prevStorage = $$storage;
883        var prevData = $$data;
884        var shouldReInsert = false;

885        var items = {};
886
887        function load(prevStorage, prevData) {
888          var keys = this.keys();
889          var length = keys.length;
890          if (length) {
891            var _key = void 0;
892            var prevDataIsObject = utils.isObject(prevData);
893            for (var i = 0; i < length; i++) {
894              _key = keys[i];
895              if (prevStorage) {
896                var itemJson = prevStorage().getItem(this.$$prefix + '.data.' + _key);
897                if (itemJson) {
898                  items[_key] = utils.fromJson(itemJson);
899                }
900              } else if (prevDataIsObject) {
901                items[_key] = prevData[_key];
902              }
903              this.remove(_key);
904            }
905            shouldReInsert = true;
906          }
907        }
908
909        if (!this.$$initializing) {
910          load.call(this, prevStorage, prevData);
911        }
912
913        this.$$storageMode = storageMode;
914
915        if (storageImpl) {
916          if (!utils.isObject(storageImpl)) {
917            throw new Error('storageImpl must be an object!');
918          } else if (!('setItem' in storageImpl) || typeof storageImpl.setItem !== 'function') {
919            throw new Error('storageImpl must implement "setItem(key, value)"!');
920          } else if (!('getItem' in storageImpl) || typeof storageImpl.getItem !== 'function') {
921            throw new Error('storageImpl must implement "getItem(key)"!');
922          } else if (!('removeItem' in storageImpl) || typeof storageImpl.removeItem !== 'function') {
923            throw new Error('storageImpl must implement "removeItem(key)"!');
924          }
925          $$storage = function $$storage() {
926            return storageImpl;
927          };
928        } else if (this.$$storageMode === 'localStorage') {
929          try {
930            localStorage.setItem('cachefactory', 'cachefactory');
931            localStorage.removeItem('cachefactory');
932            $$storage = function $$storage() {
933              return localStorage;
934            };
935          } catch (e) {
936            $$storage = null;
937            this.$$storageMode = 'memory';
938          }
939        } else if (this.$$storageMode === 'sessionStorage') {
940          try {
941            sessionStorage.setItem('cachefactory', 'cachefactory');
942            sessionStorage.removeItem('cachefactory');
943            $$storage = function $$storage() {
944              return sessionStorage;
945            };
946          } catch (e) {
947            $$storage = null;
948            this.$$storageMode = 'memory';
949          }
950        } else {
951          $$storage = null;
952          this.$$storageMode = 'memory';
953        }
954
955        if (this.$$initializing) {
956          load.call(this, $$storage, $$data);
957        }
958
959        if (shouldReInsert) {
960          var item = void 0;
961          for (var key in items) {
962            item = items[key];
963            this.put(key, item.value, {
964              created: item.created,
965              accessed: item.accessed,
966              expires: item.expires
967            });
968          }
969        }
970      },
971      touch: function touch(key, options) {
972        var _this4 = this;
973
974        if (key) {
975          var val = this.get(key, {
976            onExpire: function onExpire(k, v) {
977              return _this4.put(k, v);
978            }
979          });
980          if (val) {
981            this.put(key, val, options);
982          }
983        } else {
984          var keys = this.keys();
985          for (var i = 0; i < keys.length; i++) {
986            this.touch(keys[i], options);
987          }
988        }
989      },
990      values: function values() {
991        var keys = this.keys();
992        var items = [];
993        for (var i = 0; i < keys.length; i++) {
994          items.push(this.get(keys[i]));
995        }
996        return items;
997      }
998    };
999
1000    cache.$$initializing = true;
1001    cache.setOptions(options, true);
1002    cache.$$initializing = false;
1003
1004    return cache;
1005  }
1006
1007  function CacheFactory(cacheId, options) {
1008    return createCache(cacheId, options);
1009  }
1010
1011  CacheFactory.createCache = createCache;
1012  CacheFactory.defaults = defaults;
1013
1014  CacheFactory.info = function () {
1015    var keys = _keys(caches);
1016    var info = {
1017      size: keys.length,
1018      caches: {}
1019    };
1020    for (var opt in defaults) {
1021      if (defaults.hasOwnProperty(opt)) {
1022        info[opt] = defaults[opt];
1023      }
1024    }
1025    for (var i = 0; i < keys.length; i++) {
1026      var key = keys[i];
1027      info.caches[key] = caches[key].info();
1028    }
1029    return info;
1030  };
1031
1032  CacheFactory.get = function (cacheId) {
1033    return caches[cacheId];
1034  };
1035  CacheFactory.keySet = function () {
1036    return _keySet(caches);
1037  };
1038  CacheFactory.keys = function () {
1039    return _keys(caches);
1040  };
1041  CacheFactory.destroy = function (cacheId) {
1042    if (caches[cacheId]) {
1043      caches[cacheId].destroy();
1044      delete caches[cacheId];
1045    }
1046  };
1047  CacheFactory.destroyAll = function () {
1048    for (var cacheId in caches) {
1049      caches[cacheId].destroy();
1050    }
1051    caches = {};
1052  };
1053  CacheFactory.clearAll = function () {
1054    for (var cacheId in caches) {
1055      caches[cacheId].removeAll();
1056    }
1057  };
1058  CacheFactory.removeExpiredFromAll = function () {
1059    var expired = {};
1060    for (var cacheId in caches) {
1061      expired[cacheId] = caches[cacheId].removeExpired();
1062    }
1063    return expired;
1064  };
1065  CacheFactory.enableAll = function () {
1066    for (var cacheId in caches) {
1067      caches[cacheId].$$disabled = false;

1068    }
1069  };
1070  CacheFactory.disableAll = function () {
1071    for (var cacheId in caches) {
1072      caches[cacheId].$$disabled = true;
1073    }
1074  };
1075  CacheFactory.touchAll = function () {
1076    for (var cacheId in caches) {
1077      caches[cacheId].touch();
1078    }
1079  };
1080
1081  CacheFactory.utils = utils;
1082  CacheFactory.BinaryHeap = BinaryHeap;
1083
1084  CacheFactory.utils.equals = angular.equals;
1085  CacheFactory.utils.isObject = angular.isObject;
1086  CacheFactory.utils.fromJson = angular.fromJson;
1087
1088  function BinaryHeapProvider() {
1089    this.$get = function () {
1090      return CacheFactory.BinaryHeap;
1091    };
1092  }
1093
1094  function CacheFactoryProvider() {
1095    this.defaults = CacheFactory.defaults;
1096    this.defaults.storagePrefix = 'angular-cache.caches.';
1097
1098    this.$get = ['$q', function ($q) {
1099      CacheFactory.utils.Promise = $q;
1100      return CacheFactory;
1101    }];
1102  }
1103
1104  angular.module('angular-cache', []).provider('BinaryHeap', BinaryHeapProvider).provider('CacheFactory', CacheFactoryProvider);
1105
1106  var index = 'angular-cache';
1107
1108  return index;
1109
1110}));