@aws-amplify/core 6.0.1-api-v6-models.9351bcf.0 → 6.0.1-api-v6-models.891fe0d.0

package/lib-esm/Cache/constants.js

@@ -3,7 +3,7 @@
 /**
  * Default cache config
  */
-export var defaultConfig = {
+export const defaultConfig = {
     keyPrefix: 'aws-amplify-cache',
     capacityInBytes: 1048576,
     itemMaxSize: 210000,
@@ -11,4 +11,4 @@ export var defaultConfig = {
     defaultPriority: 5,
     warningThreshold: 0.8,
 };
-export var currentSizeKey = 'CurSize';
+export const currentSizeKey = 'CurSize';

package/lib-esm/Cache/index.js

@@ -1,4 +1,4 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { StorageCache } from './StorageCache';
-export var Cache = new StorageCache();
+export const Cache = new StorageCache();

package/lib-esm/Cache/utils/CacheList.js

@@ -1,25 +1,13 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 import { assert, CacheErrorCode } from './errorHelpers';
-var DoubleLinkedNode = /** @class */ (function () {
-    function DoubleLinkedNode(keyVal) {
+class DoubleLinkedNode {
+    constructor(keyVal) {
         this.key = keyVal ? keyVal : '';
         this.prevNode = null;
         this.nextNode = null;
     }
-    return DoubleLinkedNode;
-}());
+}
 /**
  * double linked list plus a hash table inside
  * each key in the cache stored as a node in the list
@@ -31,11 +19,11 @@ var DoubleLinkedNode = /** @class */ (function () {
  * @member hashtable - the hashtable which maps cache key to list node
  * @member length - length of the list
  */
-var CacheList = /** @class */ (function () {
+export class CacheList {
     /**
      * initialization
      */
-    function CacheList() {
+    constructor() {
         this.head = new DoubleLinkedNode();
         this.tail = new DoubleLinkedNode();
         this.hashtable = {};
@@ -48,21 +36,21 @@ var CacheList = /** @class */ (function () {
      *
      * @param node
      */
-    CacheList.prototype.insertNodeToHead = function (node) {
-        var tmp = this.head.nextNode;
+    insertNodeToHead(node) {
+        const tmp = this.head.nextNode;
         this.head.nextNode = node;
         node.nextNode = tmp;
         node.prevNode = this.head;
         assert(tmp !== null, CacheErrorCode.NullPreviousNode);
         tmp.prevNode = node;
         this.length = this.length + 1;
-    };
+    }
     /**
      * remove node
      *
      * @param node
      */
-    CacheList.prototype.removeNode = function (node) {
+    removeNode(node) {
         assert(node.prevNode !== null, CacheErrorCode.NullPreviousNode);
         assert(node.nextNode !== null, CacheErrorCode.NullNextNode);
         node.prevNode.nextNode = node.nextNode;
@@ -70,112 +58,99 @@ var CacheList = /** @class */ (function () {
         node.prevNode = null;
         node.nextNode = null;
         this.length = this.length - 1;
-    };
+    }
     /**
      * @return true if list is empty
      */
-    CacheList.prototype.isEmpty = function () {
+    isEmpty() {
         return this.length === 0;
-    };
+    }
     /**
      * refresh node so it is rotated to the head
      *
      * @param key - key of the node
      */
-    CacheList.prototype.refresh = function (key) {
-        var node = this.hashtable[key];
+    refresh(key) {
+        const node = this.hashtable[key];
         this.removeNode(node);
         this.insertNodeToHead(node);
-    };
+    }
     /**
      * insert new node to the head and add it in the hashtable
      *
      * @param key - the key of the node
      */
-    CacheList.prototype.insertItem = function (key) {
-        var node = new DoubleLinkedNode(key);
+    insertItem(key) {
+        const node = new DoubleLinkedNode(key);
         this.hashtable[key] = node;
         this.insertNodeToHead(node);
-    };
+    }
     /**
      * @return the LAST Recently Visited key
      */
-    CacheList.prototype.getLastItem = function () {
+    getLastItem() {
         assert(this.tail.prevNode !== null, CacheErrorCode.NullPreviousNode);
         return this.tail.prevNode.key;
-    };
+    }
     /**
      * remove the cache key from the list and hashtable
      * @param key - the key of the node
      */
-    CacheList.prototype.removeItem = function (key) {
-        var removedItem = this.hashtable[key];
+    removeItem(key) {
+        const removedItem = this.hashtable[key];
         this.removeNode(removedItem);
         delete this.hashtable[key];
-    };
+    }
     /**
      * @return length of the list
      */
-    CacheList.prototype.getSize = function () {
+    getSize() {
         return this.length;
-    };
+    }
     /**
      * @return true if the key is in the hashtable
      * @param key
      */
-    CacheList.prototype.containsKey = function (key) {
+    containsKey(key) {
         return key in this.hashtable;
-    };
+    }
     /**
      * clean up the list and hashtable
      */
-    CacheList.prototype.clearList = function () {
-        var e_1, _a;
-        try {
-            for (var _b = __values(Object.keys(this.hashtable)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var key = _c.value;
-                if (this.hashtable.hasOwnProperty(key)) {
-                    delete this.hashtable[key];
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+    clearList() {
+        for (const key of Object.keys(this.hashtable)) {
+            if (this.hashtable.hasOwnProperty(key)) {
+                delete this.hashtable[key];
             }
-            finally { if (e_1) throw e_1.error; }
         }
         this.head.nextNode = this.tail;
         this.tail.prevNode = this.head;
         this.length = 0;
-    };
+    }
     /**
      * @return all keys in the hashtable
      */
-    CacheList.prototype.getKeys = function () {
+    getKeys() {
         return Object.keys(this.hashtable);
-    };
+    }
     /**
      * mainly for test
      *
      * @param key
      * @return true if key is the head node
      */
-    CacheList.prototype.isHeadNode = function (key) {
-        var node = this.hashtable[key];
+    isHeadNode(key) {
+        const node = this.hashtable[key];
         return node.prevNode === this.head;
-    };
+    }
     /**
      * mainly for test
      *
      * @param key
      * @return true if key is the tail node
      */
-    CacheList.prototype.isTailNode = function (key) {
-        var node = this.hashtable[key];
+    isTailNode(key) {
+        const node = this.hashtable[key];
         return node.nextNode === this.tail;
-    };
-    return CacheList;
-}());
-export { CacheList };
+    }
+}

package/lib-esm/Cache/utils/cacheHelpers.js

@@ -6,10 +6,10 @@ import { currentSizeKey } from '../constants';
  * @param str
  */
 export function getByteLength(str) {
-    var ret = 0;
+    let ret = 0;
     ret = str.length;
-    for (var i = str.length; i >= 0; i -= 1) {
-        var charCode = str.charCodeAt(i);
+    for (let i = str.length; i >= 0; i -= 1) {
+        const charCode = str.charCodeAt(i);
         if (charCode > 0x7f && charCode <= 0x7ff) {
             ret += 1;
         }
@@ -27,7 +27,7 @@ export function getByteLength(str) {
  * get current time
  */
 export function getCurrentTime() {
-    var currentTime = new Date();
+    const currentTime = new Date();
     return currentTime.getTime();
 }
 /**
@@ -39,6 +39,4 @@ export function isInteger(value) {
     }
     return (typeof value === 'number' && isFinite(value) && Math.floor(value) === value);
 }
-export var getCurrentSizeKey = function (keyPrefix) {
-    return "".concat(keyPrefix).concat(currentSizeKey);
-};
+export const getCurrentSizeKey = (keyPrefix) => `${keyPrefix}${currentSizeKey}`;

package/lib-esm/Cache/utils/errorHelpers.js

@@ -1,6 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var _a;
 import { createAssertionFunction } from '../../errors';
 export var CacheErrorCode;
 (function (CacheErrorCode) {
@@ -8,15 +7,15 @@ export var CacheErrorCode;
     CacheErrorCode["NullNextNode"] = "NullNextNode";
     CacheErrorCode["NullPreviousNode"] = "NullPreviousNode";
 })(CacheErrorCode || (CacheErrorCode = {}));
-var cacheErrorMap = (_a = {},
-    _a[CacheErrorCode.NoCacheItem] = {
+const cacheErrorMap = {
+    [CacheErrorCode.NoCacheItem]: {
         message: 'Item not found in the cache storage.',
     },
-    _a[CacheErrorCode.NullNextNode] = {
+    [CacheErrorCode.NullNextNode]: {
         message: 'Next node is null.',
     },
-    _a[CacheErrorCode.NullPreviousNode] = {
+    [CacheErrorCode.NullPreviousNode]: {
         message: 'Previous node is null.',
     },
-    _a);
-export var assert = createAssertionFunction(cacheErrorMap);
+};
+export const assert = createAssertionFunction(cacheErrorMap);

package/lib-esm/Hub/index.js

@@ -1,50 +1,14 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { ConsoleLogger as Logger } from '../Logger';
 import { NO_HUBCALLBACK_PROVIDED_EXCEPTION } from '../constants';
 import { AmplifyError } from '../errors';
-export var AMPLIFY_SYMBOL = (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function'
+export const AMPLIFY_SYMBOL = (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function'
     ? Symbol.for('amplify_default')
     : '@@amplify_default');
-var logger = new Logger('Hub');
-var HubClass = /** @class */ (function () {
-    function HubClass(name) {
+const logger = new Logger('Hub');
+export class HubClass {
+    constructor(name) {
         this.listeners = new Map();
         this.protectedChannels = [
             'core',
@@ -65,29 +29,28 @@ var HubClass = /** @class */ (function () {
      * @remarks
      * This private method is for internal use only. Instead of calling Hub.remove, call the result of Hub.listen.
      */
-    HubClass.prototype._remove = function (channel, listener) {
-        var holder = this.listeners.get(channel);
+    _remove(channel, listener) {
+        const holder = this.listeners.get(channel);
         if (!holder) {
-            logger.warn("No listeners for ".concat(channel));
+            logger.warn(`No listeners for ${channel}`);
             return;
         }
-        this.listeners.set(channel, __spreadArray([], __read(holder.filter(function (_a) {
-            var callback = _a.callback;
-            return callback !== listener;
-        })), false));
-    };
-    HubClass.prototype.dispatch = function (channel, payload, source, ampSymbol) {
+        this.listeners.set(channel, [
+            ...holder.filter(({ callback }) => callback !== listener),
+        ]);
+    }
+    dispatch(channel, payload, source, ampSymbol) {
         if (typeof channel === 'string' &&
             this.protectedChannels.indexOf(channel) > -1) {
-            var hasAccess = ampSymbol === AMPLIFY_SYMBOL;
+            const hasAccess = ampSymbol === AMPLIFY_SYMBOL;
             if (!hasAccess) {
-                logger.warn("WARNING: ".concat(channel, " is protected and dispatching on it can have unintended consequences"));
+                logger.warn(`WARNING: ${channel} is protected and dispatching on it can have unintended consequences`);
             }
         }
-        var capsule = {
-            channel: channel,
-            payload: __assign({}, payload),
-            source: source,
+        const capsule = {
+            channel,
+            payload: { ...payload },
+            source,
             patternInfo: [],
         };
         try {
@@ -96,11 +59,9 @@ var HubClass = /** @class */ (function () {
         catch (e) {
             logger.error(e);
         }
-    };
-    HubClass.prototype.listen = function (channel, callback, listenerName) {
-        var _this = this;
-        if (listenerName === void 0) { listenerName = 'noname'; }
-        var cb;
+    }
+    listen(channel, callback, listenerName = 'noname') {
+        let cb;
         if (typeof callback !== 'function') {
             throw new AmplifyError({
                 name: NO_HUBCALLBACK_PROVIDED_EXCEPTION,
@@ -111,7 +72,7 @@ var HubClass = /** @class */ (function () {
             // Needs to be casted as a more generic type
             cb = callback;
         }
-        var holder = this.listeners.get(channel);
+        let holder = this.listeners.get(channel);
         if (!holder) {
             holder = [];
             this.listeners.set(channel, holder);
@@ -120,16 +81,16 @@ var HubClass = /** @class */ (function () {
             name: listenerName,
             callback: cb,
         });
-        return function () {
-            _this._remove(channel, cb);
+        return () => {
+            this._remove(channel, cb);
         };
-    };
-    HubClass.prototype._toListeners = function (capsule) {
-        var channel = capsule.channel, payload = capsule.payload;
-        var holder = this.listeners.get(channel);
+    }
+    _toListeners(capsule) {
+        const { channel, payload } = capsule;
+        const holder = this.listeners.get(channel);
         if (holder) {
-            holder.forEach(function (listener) {
-                logger.debug("Dispatching to ".concat(channel, " with "), payload);
+            holder.forEach(listener => {
+                logger.debug(`Dispatching to ${channel} with `, payload);
                 try {
                     listener.callback(capsule);
                 }
@@ -138,18 +99,16 @@ var HubClass = /** @class */ (function () {
                 }
             });
         }
-    };
-    return HubClass;
-}());
-export { HubClass };
+    }
+}
 /*We export a __default__ instance of HubClass to use it as a
 pseudo Singleton for the main messaging bus, however you can still create
 your own instance of HubClass() for a separate "private bus" of events.*/
-export var Hub = new HubClass('__default__');
+export const Hub = new HubClass('__default__');
 /**
  * @internal
  *
  * Internal hub used for core Amplify functionality. Not intended for use outside of Amplify.
  *
  */
-export var HubInternal = new HubClass('internal-hub');
+export const HubInternal = new HubClass('internal-hub');

package/lib-esm/I18n/I18n.js

@@ -1,28 +1,17 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import { ConsoleLogger as Logger } from '../Logger';
-var logger = new Logger('I18n');
+const logger = new Logger('I18n');
 /**
  * Language translation utility.
  */
-var I18n = /** @class */ (function () {
+export class I18n {
     /**
      * @constructor
      * Initialize with configurations
      * @param {Object} options
      */
-    function I18n() {
+    constructor() {
         /**
          * @private
          */
@@ -39,7 +28,7 @@ var I18n = /** @class */ (function () {
     /**
      * Sets the default language from the configuration when required.
      */
-    I18n.prototype.setDefaultLanguage = function () {
+    setDefaultLanguage() {
         // Default to window language if not set in instance
         if (!this._lang &&
             typeof window !== 'undefined' &&
@@ -48,28 +37,27 @@ var I18n = /** @class */ (function () {
             this._lang = window.navigator.language;
         }
         logger.debug(this._lang);
-    };
+    }
     /**
      * @method
      * Explicitly setting language
      * @param {String} lang
      */
-    I18n.prototype.setLanguage = function (lang) {
+    setLanguage(lang) {
         this._lang = lang;
-    };
+    }
     /**
      * @method
      * Get value
      * @param {String} key
      * @param {String} defVal - Default value
      */
-    I18n.prototype.get = function (key, defVal) {
-        if (defVal === void 0) { defVal = undefined; }
+    get(key, defVal = undefined) {
         if (!this._lang) {
             return typeof defVal !== 'undefined' ? defVal : key;
         }
-        var lang = this._lang;
-        var val = this.getByLanguage(key, lang);
+        const lang = this._lang;
+        let val = this.getByLanguage(key, lang);
         if (val) {
             return val;
         }
@@ -80,7 +68,7 @@ var I18n = /** @class */ (function () {
             return val;
         }
         return typeof defVal !== 'undefined' ? defVal : key;
-    };
+    }
     /**
      * @method
      * Get value according to specified language
@@ -88,42 +76,38 @@ var I18n = /** @class */ (function () {
      * @param {String} language - Specified langurage to be used
      * @param {String} defVal - Default value
      */
-    I18n.prototype.getByLanguage = function (key, language, defVal) {
-        if (defVal === void 0) { defVal = null; }
+    getByLanguage(key, language, defVal = null) {
         if (!language) {
             return defVal;
         }
-        var lang_dict = this._dict[language];
+        const lang_dict = this._dict[language];
         if (!lang_dict) {
             return defVal;
         }
         return lang_dict[key];
-    };
+    }
     /**
      * @method
      * Add vocabularies for one language
      * @param {String} language - Language of the dictionary
      * @param {Object} vocabularies - Object that has key-value as dictionary entry
      */
-    I18n.prototype.putVocabulariesForLanguage = function (language, vocabularies) {
-        var lang_dict = this._dict[language];
+    putVocabulariesForLanguage(language, vocabularies) {
+        let lang_dict = this._dict[language];
         if (!lang_dict) {
             lang_dict = this._dict[language] = {};
         }
-        this._dict[language] = __assign(__assign({}, lang_dict), vocabularies);
-    };
+        this._dict[language] = { ...lang_dict, ...vocabularies };
+    }
     /**
      * @method
      * Add vocabularies for one language
      * @param {Object} vocabularies - Object that has language as key,
      *                                vocabularies of each language as value
      */
-    I18n.prototype.putVocabularies = function (vocabularies) {
-        var _this = this;
-        Object.keys(vocabularies).map(function (key) {
-            _this.putVocabulariesForLanguage(key, vocabularies[key]);
+    putVocabularies(vocabularies) {
+        Object.keys(vocabularies).map(key => {
+            this.putVocabulariesForLanguage(key, vocabularies[key]);
         });
-    };
-    return I18n;
-}());
-export { I18n };
+    }
+}

package/lib-esm/I18n/errorHelpers.js

@@ -1,14 +1,13 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var _a;
 import { createAssertionFunction } from '../errors';
 export var I18nErrorCode;
 (function (I18nErrorCode) {
     I18nErrorCode["NotConfigured"] = "NotConfigured";
 })(I18nErrorCode || (I18nErrorCode = {}));
-var i18nErrorMap = (_a = {},
-    _a[I18nErrorCode.NotConfigured] = {
+const i18nErrorMap = {
+    [I18nErrorCode.NotConfigured]: {
         message: 'i18n is not configured.',
     },
-    _a);
-export var assert = createAssertionFunction(i18nErrorMap);
+};
+export const assert = createAssertionFunction(i18nErrorMap);