@aws-amplify/core 6.0.1-preview-testing.be90020.0 → 6.0.1-ssr-api.df60e41.0

package/lib/Cache/utils/CacheList.js

@@ -0,0 +1,160 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheList = void 0;
+const errorHelpers_1 = require("./errorHelpers");
+class DoubleLinkedNode {
+    constructor(keyVal) {
+        this.key = keyVal ? keyVal : '';
+        this.prevNode = null;
+        this.nextNode = null;
+    }
+}
+/**
+ * double linked list plus a hash table inside
+ * each key in the cache stored as a node in the list
+ * recently visited node will be rotated to the head
+ * so the Last Recently Visited node will be at the tail
+ *
+ * @member head - dummy head of the linked list
+ * @member tail - dummy tail of the linked list
+ * @member hashtable - the hashtable which maps cache key to list node
+ * @member length - length of the list
+ */
+class CacheList {
+    /**
+     * initialization
+     */
+    constructor() {
+        this.head = new DoubleLinkedNode();
+        this.tail = new DoubleLinkedNode();
+        this.hashtable = {};
+        this.length = 0;
+        this.head.nextNode = this.tail;
+        this.tail.prevNode = this.head;
+    }
+    /**
+     * insert node to the head of the list
+     *
+     * @param node
+     */
+    insertNodeToHead(node) {
+        const tmp = this.head.nextNode;
+        this.head.nextNode = node;
+        node.nextNode = tmp;
+        node.prevNode = this.head;
+        (0, errorHelpers_1.assert)(tmp !== null, errorHelpers_1.CacheErrorCode.NullPreviousNode);
+        tmp.prevNode = node;
+        this.length = this.length + 1;
+    }
+    /**
+     * remove node
+     *
+     * @param node
+     */
+    removeNode(node) {
+        (0, errorHelpers_1.assert)(node.prevNode !== null, errorHelpers_1.CacheErrorCode.NullPreviousNode);
+        (0, errorHelpers_1.assert)(node.nextNode !== null, errorHelpers_1.CacheErrorCode.NullNextNode);
+        node.prevNode.nextNode = node.nextNode;
+        node.nextNode.prevNode = node.prevNode;
+        node.prevNode = null;
+        node.nextNode = null;
+        this.length = this.length - 1;
+    }
+    /**
+     * @return true if list is empty
+     */
+    isEmpty() {
+        return this.length === 0;
+    }
+    /**
+     * refresh node so it is rotated to the head
+     *
+     * @param key - key of the node
+     */
+    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
+     */
+    insertItem(key) {
+        const node = new DoubleLinkedNode(key);
+        this.hashtable[key] = node;
+        this.insertNodeToHead(node);
+    }
+    /**
+     * @return the LAST Recently Visited key
+     */
+    getLastItem() {
+        (0, errorHelpers_1.assert)(this.tail.prevNode !== null, errorHelpers_1.CacheErrorCode.NullPreviousNode);
+        return this.tail.prevNode.key;
+    }
+    /**
+     * remove the cache key from the list and hashtable
+     * @param key - the key of the node
+     */
+    removeItem(key) {
+        const removedItem = this.hashtable[key];
+        this.removeNode(removedItem);
+        delete this.hashtable[key];
+    }
+    /**
+     * @return length of the list
+     */
+    getSize() {
+        return this.length;
+    }
+    /**
+     * @return true if the key is in the hashtable
+     * @param key
+     */
+    containsKey(key) {
+        return key in this.hashtable;
+    }
+    /**
+     * clean up the list and hashtable
+     */
+    clearList() {
+        for (const key of Object.keys(this.hashtable)) {
+            if (this.hashtable.hasOwnProperty(key)) {
+                delete this.hashtable[key];
+            }
+        }
+        this.head.nextNode = this.tail;
+        this.tail.prevNode = this.head;
+        this.length = 0;
+    }
+    /**
+     * @return all keys in the hashtable
+     */
+    getKeys() {
+        return Object.keys(this.hashtable);
+    }
+    /**
+     * mainly for test
+     *
+     * @param key
+     * @return true if key is the head node
+     */
+    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
+     */
+    isTailNode(key) {
+        const node = this.hashtable[key];
+        return node.nextNode === this.tail;
+    }
+}
+exports.CacheList = CacheList;

package/lib/Cache/utils/cacheHelpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * return the byte size of the string
+ * @param str
+ */
+export declare function getByteLength(str: string): number;
+/**
+ * get current time
+ */
+export declare function getCurrentTime(): number;
+/**
+ * check if passed value is an integer
+ */
+export declare function isInteger(value?: number): boolean;
+export declare const getCurrentSizeKey: (keyPrefix: string) => string;

package/lib/Cache/utils/cacheHelpers.js

@@ -0,0 +1,49 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentSizeKey = exports.isInteger = exports.getCurrentTime = exports.getByteLength = void 0;
+const constants_1 = require("../constants");
+/**
+ * return the byte size of the string
+ * @param str
+ */
+function getByteLength(str) {
+    let ret = 0;
+    ret = str.length;
+    for (let i = str.length; i >= 0; i -= 1) {
+        const charCode = str.charCodeAt(i);
+        if (charCode > 0x7f && charCode <= 0x7ff) {
+            ret += 1;
+        }
+        else if (charCode > 0x7ff && charCode <= 0xffff) {
+            ret += 2;
+        }
+        // trail surrogate
+        if (charCode >= 0xdc00 && charCode <= 0xdfff) {
+            i -= 1;
+        }
+    }
+    return ret;
+}
+exports.getByteLength = getByteLength;
+/**
+ * get current time
+ */
+function getCurrentTime() {
+    const currentTime = new Date();
+    return currentTime.getTime();
+}
+exports.getCurrentTime = getCurrentTime;
+/**
+ * check if passed value is an integer
+ */
+function isInteger(value) {
+    if (Number.isInteger) {
+        return Number.isInteger(value);
+    }
+    return (typeof value === 'number' && isFinite(value) && Math.floor(value) === value);
+}
+exports.isInteger = isInteger;
+const getCurrentSizeKey = (keyPrefix) => `${keyPrefix}${constants_1.currentSizeKey}`;
+exports.getCurrentSizeKey = getCurrentSizeKey;

package/lib/Cache/utils/errorHelpers.d.ts

@@ -0,0 +1,7 @@
+import { AssertionFunction } from '../../types';
+export declare enum CacheErrorCode {
+    NoCacheItem = "NoCacheItem",
+    NullNextNode = "NullNextNode",
+    NullPreviousNode = "NullPreviousNode"
+}
+export declare const assert: AssertionFunction<CacheErrorCode>;

package/lib/Cache/utils/errorHelpers.js

@@ -0,0 +1,24 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = exports.CacheErrorCode = void 0;
+const errors_1 = require("../../errors");
+var CacheErrorCode;
+(function (CacheErrorCode) {
+    CacheErrorCode["NoCacheItem"] = "NoCacheItem";
+    CacheErrorCode["NullNextNode"] = "NullNextNode";
+    CacheErrorCode["NullPreviousNode"] = "NullPreviousNode";
+})(CacheErrorCode = exports.CacheErrorCode || (exports.CacheErrorCode = {}));
+const cacheErrorMap = {
+    [CacheErrorCode.NoCacheItem]: {
+        message: 'Item not found in the cache storage.',
+    },
+    [CacheErrorCode.NullNextNode]: {
+        message: 'Next node is null.',
+    },
+    [CacheErrorCode.NullPreviousNode]: {
+        message: 'Previous node is null.',
+    },
+};
+exports.assert = (0, errors_1.createAssertionFunction)(cacheErrorMap);

package/lib/Cache/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { getByteLength, getCurrentSizeKey, getCurrentTime, isInteger, } from './cacheHelpers';
+export { CacheList } from './CacheList';

package/lib/Cache/utils/index.js

@@ -0,0 +1,12 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheList = exports.isInteger = exports.getCurrentTime = exports.getCurrentSizeKey = exports.getByteLength = void 0;
+var cacheHelpers_1 = require("./cacheHelpers");
+Object.defineProperty(exports, "getByteLength", { enumerable: true, get: function () { return cacheHelpers_1.getByteLength; } });
+Object.defineProperty(exports, "getCurrentSizeKey", { enumerable: true, get: function () { return cacheHelpers_1.getCurrentSizeKey; } });
+Object.defineProperty(exports, "getCurrentTime", { enumerable: true, get: function () { return cacheHelpers_1.getCurrentTime; } });
+Object.defineProperty(exports, "isInteger", { enumerable: true, get: function () { return cacheHelpers_1.isInteger; } });
+var CacheList_1 = require("./CacheList");
+Object.defineProperty(exports, "CacheList", { enumerable: true, get: function () { return CacheList_1.CacheList; } });

package/lib/Hub/index.d.ts

@@ -37,3 +37,10 @@ export declare class HubClass {
     private _toListeners;
 }
 export declare const Hub: HubClass;
+/**
+ * @internal
+ *
+ * Internal hub used for core Amplify functionality. Not intended for use outside of Amplify.
+ *
+ */
+export declare const HubInternal: HubClass;

package/lib/Hub/index.js

@@ -1,53 +1,17 @@
 "use strict";
 // 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));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hub = exports.HubClass = exports.AMPLIFY_SYMBOL = void 0;
-var Logger_1 = require("../Logger");
-var Constants_1 = require("../Util/Constants");
-var Errors_1 = require("../Util/Errors");
+exports.HubInternal = exports.Hub = exports.HubClass = exports.AMPLIFY_SYMBOL = void 0;
+const Logger_1 = require("../Logger");
+const constants_1 = require("../constants");
+const errors_1 = require("../errors");
 exports.AMPLIFY_SYMBOL = (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function'
     ? Symbol.for('amplify_default')
     : '@@amplify_default');
-var logger = new Logger_1.ConsoleLogger('Hub');
-var HubClass = /** @class */ (function () {
-    function HubClass(name) {
+const logger = new Logger_1.ConsoleLogger('Hub');
+class HubClass {
+    constructor(name) {
         this.listeners = new Map();
         this.protectedChannels = [
             'core',
@@ -68,29 +32,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 === exports.AMPLIFY_SYMBOL;
+            const hasAccess = ampSymbol === exports.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 {
@@ -99,14 +62,12 @@ 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 Errors_1.AmplifyError({
-                name: Constants_1.NO_HUBCALLBACK_PROVIDED_EXCEPTION,
+            throw new errors_1.AmplifyError({
+                name: constants_1.NO_HUBCALLBACK_PROVIDED_EXCEPTION,
                 message: 'No callback supplied to Hub',
             });
         }
@@ -114,7 +75,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);
@@ -123,16 +84,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);
                 }
@@ -141,11 +102,17 @@ var HubClass = /** @class */ (function () {
                 }
             });
         }
-    };
-    return HubClass;
-}());
+    }
+}
 exports.HubClass = 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.*/
 exports.Hub = new HubClass('__default__');
+/**
+ * @internal
+ *
+ * Internal hub used for core Amplify functionality. Not intended for use outside of Amplify.
+ *
+ */
+exports.HubInternal = new HubClass('internal-hub');

package/lib/Hub/types/AuthTypes.d.ts

@@ -1,3 +1,7 @@
+type AuthUser = {
+    username: string;
+    userId: string;
+};
 export type AuthHubEventData = 
 /** Dispatched when a user signs in with an oauth provider such as Google.*/
 {
@@ -14,4 +18,19 @@ export type AuthHubEventData =
 /** Dispatched when there is an error in the refresh of tokens.*/
  | {
     event: 'tokenRefresh_failure';
+}
+/** Dispatched when there is a customState passed in the options of the `signInWithRedirect` API.*/
+ | {
+    event: 'customOAuthState';
+    data: string;
+}
+/** Dispatched when the user is signed-in.*/
+ | {
+    event: 'signedIn';
+    data: AuthUser;
+}
+/** Dispatched after the user calls the `signOut` API successfully.*/
+ | {
+    event: 'signedOut';
 };
+export {};

package/lib/I18n/I18n.d.ts

@@ -1,14 +1,12 @@
-import { I18nOptions } from './types';
+import { I18nConfig } from './types';
 /**
  * Language translation utility.
- *
- * @deprecated The I18n utility is on a deprecation path and will be removed in a future version of Amplify.
  */
 export declare class I18n {
     /**
      * @private
      */
-    _options: I18nOptions | null;
+    _options: I18nConfig | null;
     /**
      * @private
      */
@@ -21,22 +19,16 @@ export declare class I18n {
      * @constructor
      * Initialize with configurations
      * @param {Object} options
-     *
-     * @deprecated The I18n utility is on a deprecation path and will be removed in a future version of Amplify.
      */
     constructor();
     /**
      * Sets the default language from the configuration when required.
-     *
-     * @deprecated The I18n utility is on a deprecation path and will be removed in a future version of Amplify.
      */
     setDefaultLanguage(): void;
     /**
      * @method
      * Explicitly setting language
      * @param {String} lang
-     *
-     * @deprecated The I18n utility is on a deprecation path and will be removed in a future version of Amplify.
      */
     setLanguage(lang: string): void;
     /**
@@ -44,8 +36,6 @@ export declare class I18n {
      * Get value
      * @param {String} key
      * @param {String} defVal - Default value
-     *
-     * @deprecated The I18n utility is on a deprecation path and will be removed in a future version of Amplify.
      */
     get(key: string, defVal?: string | undefined): any;
     /**
@@ -54,8 +44,6 @@ export declare class I18n {
      * @param {String} key
      * @param {String} language - Specified langurage to be used
      * @param {String} defVal - Default value
-     *
-     * @deprecated The I18n utility is on a deprecation path and will be removed in a future version of Amplify.
      */
     getByLanguage(key: string, language: string, defVal?: string | null): any;
     /**
@@ -63,8 +51,6 @@ export declare class I18n {
      * Add vocabularies for one language
      * @param {String} language - Language of the dictionary
      * @param {Object} vocabularies - Object that has key-value as dictionary entry
-     *
-     * @deprecated The I18n utility is on a deprecation path and will be removed in a future version of Amplify.
      */
     putVocabulariesForLanguage(language: string, vocabularies: Record<string, any>): void;
     /**
@@ -72,8 +58,6 @@ export declare class I18n {
      * Add vocabularies for one language
      * @param {Object} vocabularies - Object that has language as key,
      *                                vocabularies of each language as value
-     *
-     * @deprecated The I18n utility is on a deprecation path and will be removed in a future version of Amplify.
      */
-    putVocabularies(vocabularies: Record<string, any>): void;
+    putVocabularies(vocabularies: Record<string, Record<string, string>>): void;
 }