1 | "use strict";
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 | var __extends = (this && this.__extends) || (function () {
|
15 | var extendStatics = function (d, b) {
|
16 | extendStatics = Object.setPrototypeOf ||
|
17 | ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
18 | function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
19 | return extendStatics(d, b);
|
20 | };
|
21 | return function (d, b) {
|
22 | extendStatics(d, b);
|
23 | function __() { this.constructor = d; }
|
24 | d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
25 | };
|
26 | })();
|
27 | Object.defineProperty(exports, "__esModule", { value: true });
|
28 | var Utils_1 = require("./Utils");
|
29 | var StorageCache_1 = require("./StorageCache");
|
30 | var core_1 = require("@aws-amplify/core");
|
31 | var logger = new core_1.ConsoleLogger('Cache');
|
32 |
|
33 |
|
34 |
|
35 | var BrowserStorageCacheClass = (function (_super) {
|
36 | __extends(BrowserStorageCacheClass, _super);
|
37 | |
38 |
|
39 |
|
40 |
|
41 | function BrowserStorageCacheClass(config) {
|
42 | var _this = this;
|
43 | var cacheConfig = config
|
44 | ? Object.assign({}, Utils_1.defaultConfig, config)
|
45 | : Utils_1.defaultConfig;
|
46 | _this = _super.call(this, cacheConfig) || this;
|
47 | _this.config.storage = cacheConfig.storage;
|
48 | _this.getItem = _this.getItem.bind(_this);
|
49 | _this.setItem = _this.setItem.bind(_this);
|
50 | _this.removeItem = _this.removeItem.bind(_this);
|
51 | return _this;
|
52 | }
|
53 | |
54 |
|
55 |
|
56 |
|
57 |
|
58 |
|
59 | BrowserStorageCacheClass.prototype._decreaseCurSizeInBytes = function (amount) {
|
60 | var curSize = this.getCacheCurSize();
|
61 | this.config.storage.setItem(this.cacheCurSizeKey, (curSize - amount).toString());
|
62 | };
|
63 | |
64 |
|
65 |
|
66 |
|
67 |
|
68 |
|
69 | BrowserStorageCacheClass.prototype._increaseCurSizeInBytes = function (amount) {
|
70 | var curSize = this.getCacheCurSize();
|
71 | this.config.storage.setItem(this.cacheCurSizeKey, (curSize + amount).toString());
|
72 | };
|
73 | |
74 |
|
75 |
|
76 |
|
77 |
|
78 |
|
79 |
|
80 |
|
81 |
|
82 | BrowserStorageCacheClass.prototype._refreshItem = function (item, prefixedKey) {
|
83 | item.visitedTime = Utils_1.getCurrTime();
|
84 | this.config.storage.setItem(prefixedKey, JSON.stringify(item));
|
85 | return item;
|
86 | };
|
87 | |
88 |
|
89 |
|
90 |
|
91 |
|
92 |
|
93 |
|
94 |
|
95 | BrowserStorageCacheClass.prototype._isExpired = function (key) {
|
96 | var text = this.config.storage.getItem(key);
|
97 | var item = JSON.parse(text);
|
98 | if (Utils_1.getCurrTime() >= item.expires) {
|
99 | return true;
|
100 | }
|
101 | return false;
|
102 | };
|
103 | |
104 |
|
105 |
|
106 |
|
107 |
|
108 |
|
109 |
|
110 | BrowserStorageCacheClass.prototype._removeItem = function (prefixedKey, size) {
|
111 | var itemSize = size
|
112 | ? size
|
113 | : JSON.parse(this.config.storage.getItem(prefixedKey)).byteSize;
|
114 | this._decreaseCurSizeInBytes(itemSize);
|
115 |
|
116 | this.config.storage.removeItem(prefixedKey);
|
117 | };
|
118 | |
119 |
|
120 |
|
121 |
|
122 |
|
123 |
|
124 |
|
125 |
|
126 | BrowserStorageCacheClass.prototype._setItem = function (prefixedKey, item) {
|
127 |
|
128 | this._increaseCurSizeInBytes(item.byteSize);
|
129 | try {
|
130 | this.config.storage.setItem(prefixedKey, JSON.stringify(item));
|
131 | }
|
132 | catch (setItemErr) {
|
133 |
|
134 | this._decreaseCurSizeInBytes(item.byteSize);
|
135 | logger.error("Failed to set item " + setItemErr);
|
136 | }
|
137 | };
|
138 | |
139 |
|
140 |
|
141 |
|
142 |
|
143 |
|
144 |
|
145 |
|
146 | BrowserStorageCacheClass.prototype._sizeToPop = function (itemSize) {
|
147 | var spaceItemNeed = this.getCacheCurSize() + itemSize - this.config.capacityInBytes;
|
148 | var cacheThresholdSpace = (1 - this.config.warningThreshold) * this.config.capacityInBytes;
|
149 | return spaceItemNeed > cacheThresholdSpace
|
150 | ? spaceItemNeed
|
151 | : cacheThresholdSpace;
|
152 | };
|
153 | |
154 |
|
155 |
|
156 |
|
157 |
|
158 |
|
159 |
|
160 |
|
161 | BrowserStorageCacheClass.prototype._isCacheFull = function (itemSize) {
|
162 | return itemSize + this.getCacheCurSize() > this.config.capacityInBytes;
|
163 | };
|
164 | |
165 |
|
166 |
|
167 |
|
168 |
|
169 |
|
170 |
|
171 |
|
172 | BrowserStorageCacheClass.prototype._findValidKeys = function () {
|
173 | var keys = [];
|
174 | var keyInCache = [];
|
175 |
|
176 | for (var i = 0; i < this.config.storage.length; i += 1) {
|
177 | keyInCache.push(this.config.storage.key(i));
|
178 | }
|
179 |
|
180 | for (var i = 0; i < keyInCache.length; i += 1) {
|
181 | var key = keyInCache[i];
|
182 | if (key.indexOf(this.config.keyPrefix) === 0 &&
|
183 | key !== this.cacheCurSizeKey) {
|
184 | if (this._isExpired(key)) {
|
185 | this._removeItem(key);
|
186 | }
|
187 | else {
|
188 | keys.push(key);
|
189 | }
|
190 | }
|
191 | }
|
192 | return keys;
|
193 | };
|
194 | |
195 |
|
196 |
|
197 |
|
198 |
|
199 |
|
200 |
|
201 |
|
202 |
|
203 | BrowserStorageCacheClass.prototype._popOutItems = function (keys, sizeToPop) {
|
204 | var items = [];
|
205 | var remainedSize = sizeToPop;
|
206 |
|
207 | for (var i = 0; i < keys.length; i += 1) {
|
208 | var val = this.config.storage.getItem(keys[i]);
|
209 | if (val != null) {
|
210 | var item = JSON.parse(val);
|
211 | items.push(item);
|
212 | }
|
213 | }
|
214 |
|
215 |
|
216 | items.sort(function (a, b) {
|
217 | if (a.priority > b.priority) {
|
218 | return -1;
|
219 | }
|
220 | else if (a.priority < b.priority) {
|
221 | return 1;
|
222 | }
|
223 | else {
|
224 | if (a.visitedTime < b.visitedTime) {
|
225 | return -1;
|
226 | }
|
227 | else
|
228 | return 1;
|
229 | }
|
230 | });
|
231 | for (var i = 0; i < items.length; i += 1) {
|
232 |
|
233 | this._removeItem(items[i].key, items[i].byteSize);
|
234 | remainedSize -= items[i].byteSize;
|
235 | if (remainedSize <= 0) {
|
236 | return;
|
237 | }
|
238 | }
|
239 | };
|
240 | |
241 |
|
242 |
|
243 |
|
244 |
|
245 |
|
246 |
|
247 |
|
248 |
|
249 |
|
250 |
|
251 |
|
252 |
|
253 |
|
254 |
|
255 |
|
256 | BrowserStorageCacheClass.prototype.setItem = function (key, value, options) {
|
257 | logger.log("Set item: key is " + key + ", value is " + value + " with options: " + options);
|
258 | var prefixedKey = this.config.keyPrefix + key;
|
259 |
|
260 | if (prefixedKey === this.config.keyPrefix ||
|
261 | prefixedKey === this.cacheCurSizeKey) {
|
262 | logger.warn("Invalid key: should not be empty or 'CurSize'");
|
263 | return;
|
264 | }
|
265 | if (typeof value === 'undefined') {
|
266 | logger.warn("The value of item should not be undefined!");
|
267 | return;
|
268 | }
|
269 | var cacheItemOptions = {
|
270 | priority: options && options.priority !== undefined
|
271 | ? options.priority
|
272 | : this.config.defaultPriority,
|
273 | expires: options && options.expires !== undefined
|
274 | ? options.expires
|
275 | : this.config.defaultTTL + Utils_1.getCurrTime(),
|
276 | };
|
277 | if (cacheItemOptions.priority < 1 || cacheItemOptions.priority > 5) {
|
278 | logger.warn("Invalid parameter: priority due to out or range. It should be within 1 and 5.");
|
279 | return;
|
280 | }
|
281 | var item = this.fillCacheItem(prefixedKey, value, cacheItemOptions);
|
282 |
|
283 | if (item.byteSize > this.config.itemMaxSize) {
|
284 | logger.warn("Item with key: " + key + " you are trying to put into is too big!");
|
285 | return;
|
286 | }
|
287 | try {
|
288 |
|
289 | var val = this.config.storage.getItem(prefixedKey);
|
290 | if (val) {
|
291 | this._removeItem(prefixedKey, JSON.parse(val).byteSize);
|
292 | }
|
293 |
|
294 | if (this._isCacheFull(item.byteSize)) {
|
295 | var validKeys = this._findValidKeys();
|
296 |
|
297 | if (this._isCacheFull(item.byteSize)) {
|
298 | var sizeToPop = this._sizeToPop(item.byteSize);
|
299 | this._popOutItems(validKeys, sizeToPop);
|
300 | }
|
301 | }
|
302 |
|
303 |
|
304 | this._setItem(prefixedKey, item);
|
305 | }
|
306 | catch (e) {
|
307 | logger.warn("setItem failed! " + e);
|
308 | }
|
309 | };
|
310 | |
311 |
|
312 |
|
313 |
|
314 |
|
315 |
|
316 |
|
317 |
|
318 |
|
319 |
|
320 |
|
321 |
|
322 |
|
323 |
|
324 |
|
325 | BrowserStorageCacheClass.prototype.getItem = function (key, options) {
|
326 | logger.log("Get item: key is " + key + " with options " + options);
|
327 | var ret = null;
|
328 | var prefixedKey = this.config.keyPrefix + key;
|
329 | if (prefixedKey === this.config.keyPrefix ||
|
330 | prefixedKey === this.cacheCurSizeKey) {
|
331 | logger.warn("Invalid key: should not be empty or 'CurSize'");
|
332 | return null;
|
333 | }
|
334 | try {
|
335 | ret = this.config.storage.getItem(prefixedKey);
|
336 | if (ret != null) {
|
337 | if (this._isExpired(prefixedKey)) {
|
338 |
|
339 | this._removeItem(prefixedKey, JSON.parse(ret).byteSize);
|
340 | ret = null;
|
341 | }
|
342 | else {
|
343 |
|
344 | var item = JSON.parse(ret);
|
345 | item = this._refreshItem(item, prefixedKey);
|
346 | return item.data;
|
347 | }
|
348 | }
|
349 | if (options && options.callback !== undefined) {
|
350 | var val = options.callback();
|
351 | if (val !== null) {
|
352 | this.setItem(key, val, options);
|
353 | }
|
354 | return val;
|
355 | }
|
356 | return null;
|
357 | }
|
358 | catch (e) {
|
359 | logger.warn("getItem failed! " + e);
|
360 | return null;
|
361 | }
|
362 | };
|
363 | |
364 |
|
365 |
|
366 |
|
367 |
|
368 |
|
369 | BrowserStorageCacheClass.prototype.removeItem = function (key) {
|
370 | logger.log("Remove item: key is " + key);
|
371 | var prefixedKey = this.config.keyPrefix + key;
|
372 | if (prefixedKey === this.config.keyPrefix ||
|
373 | prefixedKey === this.cacheCurSizeKey) {
|
374 | return;
|
375 | }
|
376 | try {
|
377 | var val = this.config.storage.getItem(prefixedKey);
|
378 | if (val) {
|
379 | this._removeItem(prefixedKey, JSON.parse(val).byteSize);
|
380 | }
|
381 | }
|
382 | catch (e) {
|
383 | logger.warn("removeItem failed! " + e);
|
384 | }
|
385 | };
|
386 | |
387 |
|
388 |
|
389 |
|
390 |
|
391 | BrowserStorageCacheClass.prototype.clear = function () {
|
392 | logger.log("Clear Cache");
|
393 | var keysToRemove = [];
|
394 | for (var i = 0; i < this.config.storage.length; i += 1) {
|
395 | var key = this.config.storage.key(i);
|
396 | if (key.indexOf(this.config.keyPrefix) === 0) {
|
397 | keysToRemove.push(key);
|
398 | }
|
399 | }
|
400 | try {
|
401 | for (var i = 0; i < keysToRemove.length; i += 1) {
|
402 | this.config.storage.removeItem(keysToRemove[i]);
|
403 | }
|
404 | }
|
405 | catch (e) {
|
406 | logger.warn("clear failed! " + e);
|
407 | }
|
408 | };
|
409 | |
410 |
|
411 |
|
412 |
|
413 |
|
414 | BrowserStorageCacheClass.prototype.getAllKeys = function () {
|
415 | var keys = [];
|
416 | for (var i = 0; i < this.config.storage.length; i += 1) {
|
417 | var key = this.config.storage.key(i);
|
418 | if (key.indexOf(this.config.keyPrefix) === 0 &&
|
419 | key !== this.cacheCurSizeKey) {
|
420 | keys.push(key.substring(this.config.keyPrefix.length));
|
421 | }
|
422 | }
|
423 | return keys;
|
424 | };
|
425 | |
426 |
|
427 |
|
428 |
|
429 |
|
430 | BrowserStorageCacheClass.prototype.getCacheCurSize = function () {
|
431 | var ret = this.config.storage.getItem(this.cacheCurSizeKey);
|
432 | if (!ret) {
|
433 | this.config.storage.setItem(this.cacheCurSizeKey, '0');
|
434 | ret = '0';
|
435 | }
|
436 | return Number(ret);
|
437 | };
|
438 | |
439 |
|
440 |
|
441 |
|
442 |
|
443 |
|
444 | BrowserStorageCacheClass.prototype.createInstance = function (config) {
|
445 | if (!config.keyPrefix || config.keyPrefix === Utils_1.defaultConfig.keyPrefix) {
|
446 | logger.error('invalid keyPrefix, setting keyPrefix with timeStamp');
|
447 | config.keyPrefix = Utils_1.getCurrTime.toString();
|
448 | }
|
449 | return new BrowserStorageCacheClass(config);
|
450 | };
|
451 | return BrowserStorageCacheClass;
|
452 | }(StorageCache_1.StorageCache));
|
453 | exports.BrowserStorageCacheClass = BrowserStorageCacheClass;
|
454 | exports.BrowserStorageCache = new BrowserStorageCacheClass();
|
455 |
|
456 |
|
457 |
|
458 | exports.default = exports.BrowserStorageCache;
|
459 |
|
\ | No newline at end of file |