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

package/lib-esm/Logger/ConsoleLogger.js

@@ -1,43 +1,7 @@
 // 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.");
-};
-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 { AWS_CLOUDWATCH_CATEGORY } from '../Util/Constants';
-var LOG_LEVELS = {
+import { AWS_CLOUDWATCH_CATEGORY } from '../constants';
+const LOG_LEVELS = {
     VERBOSE: 1,
     DEBUG: 2,
     INFO: 3,
@@ -56,32 +20,31 @@ export var LOG_TYPE;
  * Write logs
  * @class Logger
  */
-export var ConsoleLogger = /** @class */ (function () {
+class ConsoleLogger {
     /**
      * @constructor
      * @param {string} name - Name of the logger
      */
-    function ConsoleLogger(name, level) {
-        if (level === void 0) { level = LOG_TYPE.WARN; }
+    constructor(name, level = LOG_TYPE.WARN) {
         this.name = name;
         this.level = level;
         this._pluggables = [];
     }
-    ConsoleLogger.prototype._padding = function (n) {
+    _padding(n) {
         return n < 10 ? '0' + n : '' + n;
-    };
-    ConsoleLogger.prototype._ts = function () {
-        var dt = new Date();
+    }
+    _ts() {
+        const dt = new Date();
         return ([this._padding(dt.getMinutes()), this._padding(dt.getSeconds())].join(':') +
             '.' +
             dt.getMilliseconds());
-    };
-    ConsoleLogger.prototype.configure = function (config) {
+    }
+    configure(config) {
         if (!config)
             return this._config;
         this._config = config;
         return this._config;
-    };
+    }
     /**
      * Write log
      * @method
@@ -89,156 +52,117 @@ export var ConsoleLogger = /** @class */ (function () {
      * @param {LOG_TYPE|string} type - log type, default INFO
      * @param {string|object} msg - Logging message or object
      */
-    ConsoleLogger.prototype._log = function (type) {
-        var e_1, _a;
-        var msg = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            msg[_i - 1] = arguments[_i];
-        }
-        var logger_level_name = this.level;
+    _log(type, ...msg) {
+        let logger_level_name = this.level;
         if (ConsoleLogger.LOG_LEVEL) {
             logger_level_name = ConsoleLogger.LOG_LEVEL;
         }
         if (typeof window !== 'undefined' && window.LOG_LEVEL) {
             logger_level_name = window.LOG_LEVEL;
         }
-        var logger_level = LOG_LEVELS[logger_level_name];
-        var type_level = LOG_LEVELS[type];
+        const logger_level = LOG_LEVELS[logger_level_name];
+        const type_level = LOG_LEVELS[type];
         if (!(type_level >= logger_level)) {
             // Do nothing if type is not greater than or equal to logger level (handle undefined)
             return;
         }
-        var log = console.log.bind(console);
+        let log = console.log.bind(console);
         if (type === LOG_TYPE.ERROR && console.error) {
             log = console.error.bind(console);
         }
         if (type === LOG_TYPE.WARN && console.warn) {
             log = console.warn.bind(console);
         }
-        var prefix = "[".concat(type, "] ").concat(this._ts(), " ").concat(this.name);
-        var message = '';
+        const prefix = `[${type}] ${this._ts()} ${this.name}`;
+        let message = '';
         if (msg.length === 1 && typeof msg[0] === 'string') {
-            message = "".concat(prefix, " - ").concat(msg[0]);
+            message = `${prefix} - ${msg[0]}`;
             log(message);
         }
         else if (msg.length === 1) {
-            message = "".concat(prefix, " ").concat(msg[0]);
+            message = `${prefix} ${msg[0]}`;
             log(prefix, msg[0]);
         }
         else if (typeof msg[0] === 'string') {
-            var obj = msg.slice(1);
+            let obj = msg.slice(1);
             if (obj.length === 1) {
                 obj = obj[0];
             }
-            message = "".concat(prefix, " - ").concat(msg[0], " ").concat(obj);
-            log("".concat(prefix, " - ").concat(msg[0]), obj);
+            message = `${prefix} - ${msg[0]} ${obj}`;
+            log(`${prefix} - ${msg[0]}`, obj);
         }
         else {
-            message = "".concat(prefix, " ").concat(msg);
+            message = `${prefix} ${msg}`;
             log(prefix, msg);
         }
-        try {
-            for (var _b = __values(this._pluggables), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var plugin = _c.value;
-                var logEvent = { message: message, timestamp: Date.now() };
-                plugin.pushLogs([logEvent]);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
+        for (const plugin of this._pluggables) {
+            const logEvent = { message, timestamp: Date.now() };
+            plugin.pushLogs([logEvent]);
         }
-    };
+    }
     /**
      * Write General log. Default to INFO
      * @method
      * @memeberof Logger
      * @param {string|object} msg - Logging message or object
      */
-    ConsoleLogger.prototype.log = function () {
-        var msg = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            msg[_i] = arguments[_i];
-        }
-        this._log.apply(this, __spreadArray([LOG_TYPE.INFO], __read(msg), false));
-    };
+    log(...msg) {
+        this._log(LOG_TYPE.INFO, ...msg);
+    }
     /**
      * Write INFO log
      * @method
      * @memeberof Logger
      * @param {string|object} msg - Logging message or object
      */
-    ConsoleLogger.prototype.info = function () {
-        var msg = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            msg[_i] = arguments[_i];
-        }
-        this._log.apply(this, __spreadArray([LOG_TYPE.INFO], __read(msg), false));
-    };
+    info(...msg) {
+        this._log(LOG_TYPE.INFO, ...msg);
+    }
     /**
      * Write WARN log
      * @method
      * @memeberof Logger
      * @param {string|object} msg - Logging message or object
      */
-    ConsoleLogger.prototype.warn = function () {
-        var msg = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            msg[_i] = arguments[_i];
-        }
-        this._log.apply(this, __spreadArray([LOG_TYPE.WARN], __read(msg), false));
-    };
+    warn(...msg) {
+        this._log(LOG_TYPE.WARN, ...msg);
+    }
     /**
      * Write ERROR log
      * @method
      * @memeberof Logger
      * @param {string|object} msg - Logging message or object
      */
-    ConsoleLogger.prototype.error = function () {
-        var msg = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            msg[_i] = arguments[_i];
-        }
-        this._log.apply(this, __spreadArray([LOG_TYPE.ERROR], __read(msg), false));
-    };
+    error(...msg) {
+        this._log(LOG_TYPE.ERROR, ...msg);
+    }
     /**
      * Write DEBUG log
      * @method
      * @memeberof Logger
      * @param {string|object} msg - Logging message or object
      */
-    ConsoleLogger.prototype.debug = function () {
-        var msg = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            msg[_i] = arguments[_i];
-        }
-        this._log.apply(this, __spreadArray([LOG_TYPE.DEBUG], __read(msg), false));
-    };
+    debug(...msg) {
+        this._log(LOG_TYPE.DEBUG, ...msg);
+    }
     /**
      * Write VERBOSE log
      * @method
      * @memeberof Logger
      * @param {string|object} msg - Logging message or object
      */
-    ConsoleLogger.prototype.verbose = function () {
-        var msg = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            msg[_i] = arguments[_i];
-        }
-        this._log.apply(this, __spreadArray([LOG_TYPE.VERBOSE], __read(msg), false));
-    };
-    ConsoleLogger.prototype.addPluggable = function (pluggable) {
+    verbose(...msg) {
+        this._log(LOG_TYPE.VERBOSE, ...msg);
+    }
+    addPluggable(pluggable) {
         if (pluggable && pluggable.getCategoryName() === AWS_CLOUDWATCH_CATEGORY) {
             this._pluggables.push(pluggable);
             pluggable.configure(this._config);
         }
-    };
-    ConsoleLogger.prototype.listPluggables = function () {
+    }
+    listPluggables() {
         return this._pluggables;
-    };
-    ConsoleLogger.LOG_LEVEL = null;
-    return ConsoleLogger;
-}());
+    }
+}
+ConsoleLogger.LOG_LEVEL = null;
+export { ConsoleLogger };

package/{lib/Util → lib-esm/Mutex}/Mutex.d.ts

@@ -21,20 +21,8 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-interface MutexInterface {
-    acquire(): Promise<MutexInterface.Releaser>;
-    runExclusive<T>(callback: MutexInterface.Worker<T>): Promise<T>;
-    isLocked(): boolean;
-}
-declare namespace MutexInterface {
-    interface Releaser {
-        (): void;
-    }
-    interface Worker<T> {
-        (): Promise<T> | T;
-    }
-}
-declare class Mutex implements MutexInterface {
+import { MutexInterface } from './types';
+export declare class Mutex implements MutexInterface {
     isLocked(): boolean;
     acquire(): Promise<MutexInterface.Releaser>;
     runExclusive<T>(callback: MutexInterface.Worker<T>): Promise<T>;
@@ -42,4 +30,3 @@ declare class Mutex implements MutexInterface {
     private _queue;
     private _pending;
 }
-export default Mutex;

package/lib-esm/{Util → Mutex}/Mutex.js

@@ -23,27 +23,24 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-var Mutex = /** @class */ (function () {
-    function Mutex() {
+export class Mutex {
+    constructor() {
         this._queue = [];
         this._pending = false;
     }
-    Mutex.prototype.isLocked = function () {
+    isLocked() {
         return this._pending;
-    };
-    Mutex.prototype.acquire = function () {
-        var _this = this;
-        var ticket = new Promise(function (resolve) {
-            return _this._queue.push(resolve);
-        });
+    }
+    acquire() {
+        const ticket = new Promise(resolve => this._queue.push(resolve));
         if (!this._pending) {
             this._dispatchNext();
         }
         return ticket;
-    };
-    Mutex.prototype.runExclusive = function (callback) {
-        return this.acquire().then(function (release) {
-            var result;
+    }
+    runExclusive(callback) {
+        return this.acquire().then(release => {
+            let result;
             try {
                 result = callback();
             }
@@ -51,13 +48,13 @@ var Mutex = /** @class */ (function () {
                 release();
                 throw e;
             }
-            return Promise.resolve(result).then(function (x) { return (release(), x); }, function (e) {
+            return Promise.resolve(result).then((x) => (release(), x), e => {
                 release();
                 throw e;
             });
         });
-    };
-    Mutex.prototype._dispatchNext = function () {
+    }
+    _dispatchNext() {
         if (this._queue.length > 0) {
             this._pending = true;
             this._queue.shift()(this._dispatchNext.bind(this));
@@ -65,7 +62,5 @@ var Mutex = /** @class */ (function () {
         else {
             this._pending = false;
         }
-    };
-    return Mutex;
-}());
-export default Mutex;
+    }
+}

package/lib-esm/Mutex/index.d.ts

@@ -0,0 +1 @@
+export { Mutex } from './Mutex';

package/lib-esm/Mutex/index.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { Mutex } from './Mutex';

package/lib-esm/Mutex/types.d.ts

@@ -0,0 +1,13 @@
+export interface MutexInterface {
+    acquire(): Promise<MutexInterface.Releaser>;
+    runExclusive<T>(callback: MutexInterface.Worker<T>): Promise<T>;
+    isLocked(): boolean;
+}
+export declare namespace MutexInterface {
+    interface Releaser {
+        (): void;
+    }
+    interface Worker<T> {
+        (): Promise<T> | T;
+    }
+}

package/lib-esm/Platform/customUserAgent.d.ts

@@ -0,0 +1,16 @@
+import { AdditionalDetails, SetCustomUserAgentInput } from './types';
+/**
+ * Sets custom user agent state which will be appended to applicable requests. Returns a function that can be used to
+ * clean up any custom state set with this API.
+ *
+ * @note
+ * This API operates globally. Calling this API multiple times will result in the most recently set values for a
+ * particular API being used.
+ *
+ * @note
+ * This utility IS NOT compatible with SSR.
+ *
+ * @param input - SetCustomUserAgentInput that defines custom state to apply to the specified APIs.
+ */
+export declare const setCustomUserAgent: (input: SetCustomUserAgentInput) => (() => void);
+export declare const getCustomUserAgent: (category: string, api: string) => AdditionalDetails | undefined;

package/lib-esm/Platform/customUserAgent.js

@@ -0,0 +1,52 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// Maintains custom user-agent state set by external consumers.
+const customUserAgentState = {};
+/**
+ * Sets custom user agent state which will be appended to applicable requests. Returns a function that can be used to
+ * clean up any custom state set with this API.
+ *
+ * @note
+ * This API operates globally. Calling this API multiple times will result in the most recently set values for a
+ * particular API being used.
+ *
+ * @note
+ * This utility IS NOT compatible with SSR.
+ *
+ * @param input - SetCustomUserAgentInput that defines custom state to apply to the specified APIs.
+ */
+export const setCustomUserAgent = (input) => {
+    // Save custom user-agent state & increment reference counter
+    // TODO Remove `any` when we upgrade to TypeScript 5.2, see: https://github.com/microsoft/TypeScript/issues/44373
+    customUserAgentState[input.category] = input.apis.reduce((acc, api) => ({
+        ...acc,
+        [api]: {
+            refCount: acc[api]?.refCount ? acc[api].refCount + 1 : 1,
+            additionalDetails: input.additionalDetails,
+        },
+    }), customUserAgentState[input.category] ?? {});
+    // Callback that cleans up state for APIs recorded by this call
+    let cleanUpCallbackCalled = false;
+    const cleanUpCallback = () => {
+        // Only allow the cleanup callback to be called once
+        if (cleanUpCallbackCalled) {
+            return;
+        }
+        cleanUpCallbackCalled = true;
+        input.apis.forEach(api => {
+            const apiRefCount = customUserAgentState[input.category][api].refCount;
+            if (apiRefCount > 1) {
+                customUserAgentState[input.category][api].refCount = apiRefCount - 1;
+            }
+            else {
+                delete customUserAgentState[input.category][api];
+                // Clean up category if no more APIs set
+                if (!Object.keys(customUserAgentState[input.category]).length) {
+                    delete customUserAgentState[input.category];
+                }
+            }
+        });
+    };
+    return cleanUpCallback;
+};
+export const getCustomUserAgent = (category, api) => customUserAgentState[category]?.[api]?.additionalDetails;

package/lib-esm/Platform/detectFramework.js

@@ -3,15 +3,14 @@
 import { Framework } from './types';
 import { detect } from './detection';
 // We want to cache detection since the framework won't change
-var frameworkCache;
-export var frameworkChangeObservers = [];
+let frameworkCache;
+export const frameworkChangeObservers = [];
 // Setup the detection reset tracking / timeout delays
-var resetTriggered = false;
-var SSR_RESET_TIMEOUT = 10; // ms
-var WEB_RESET_TIMEOUT = 10; // ms
-var PRIME_FRAMEWORK_DELAY = 1000; // ms
-export var detectFramework = function () {
-    var _a;
+let resetTriggered = false;
+const SSR_RESET_TIMEOUT = 10; // ms
+const WEB_RESET_TIMEOUT = 10; // ms
+const PRIME_FRAMEWORK_DELAY = 1000; // ms
+export const detectFramework = () => {
     if (!frameworkCache) {
         frameworkCache = detect();
         if (resetTriggered) {
@@ -20,13 +19,13 @@ export var detectFramework = function () {
             // So we don't need to notify the observers again so the observer
             // can be removed after the final notice.
             while (frameworkChangeObservers.length) {
-                (_a = frameworkChangeObservers.pop()) === null || _a === void 0 ? void 0 : _a();
+                frameworkChangeObservers.pop()?.();
             }
         }
         else {
             // The first run of detectFramework:
             // Every time we update the cache, call each observer function
-            frameworkChangeObservers.forEach(function (fcn) { return fcn(); });
+            frameworkChangeObservers.forEach(fcn => fcn());
         }
         // Retry once for either Unknown type after a delay (explained below)
         resetTimeout(Framework.ServerSideUnknown, SSR_RESET_TIMEOUT);
@@ -37,7 +36,7 @@ export var detectFramework = function () {
 /**
  * @internal Setup observer callback that will be called everytime the framework changes
  */
-export var observeFrameworkChanges = function (fcn) {
+export const observeFrameworkChanges = (fcn) => {
     // When the `frameworkCache` won't be updated again, we ignore all incoming
     // observers.
     if (resetTriggered) {
@@ -56,7 +55,7 @@ export function clearCache() {
 //   non-framework detection result for all requests.
 function resetTimeout(framework, delay) {
     if (frameworkCache === framework && !resetTriggered) {
-        setTimeout(function () {
+        setTimeout(() => {
             clearCache();
             resetTriggered = true;
             setTimeout(detectFramework, PRIME_FRAMEWORK_DELAY);

package/lib-esm/Platform/detection/Angular.js

@@ -3,16 +3,15 @@
 import { documentExists, processExists, windowExists } from './helpers';
 // Tested with @angular/core 16.0.0
 export function angularWebDetect() {
-    var angularVersionSetInDocument = Boolean(documentExists() && document.querySelector('[ng-version]'));
-    var angularContentSetInWindow = Boolean(
+    const angularVersionSetInDocument = Boolean(documentExists() && document.querySelector('[ng-version]'));
+    const angularContentSetInWindow = Boolean(
     // @ts-ignore
     windowExists() && typeof window['ng'] !== 'undefined');
     return angularVersionSetInDocument || angularContentSetInWindow;
 }
 export function angularSSRDetect() {
-    var _a;
     return ((processExists() &&
         typeof process.env === 'object' &&
-        ((_a = process.env['npm_lifecycle_script']) === null || _a === void 0 ? void 0 : _a.startsWith('ng '))) ||
+        process.env['npm_lifecycle_script']?.startsWith('ng ')) ||
         false);
 }

package/lib-esm/Platform/detection/React.js

@@ -3,18 +3,18 @@
 import { documentExists, processExists } from './helpers';
 // Tested with react 18.2 - built using Vite
 export function reactWebDetect() {
-    var elementKeyPrefixedWithReact = function (key) {
+    const elementKeyPrefixedWithReact = (key) => {
         return key.startsWith('_react') || key.startsWith('__react');
     };
-    var elementIsReactEnabled = function (element) {
+    const elementIsReactEnabled = (element) => {
         return Object.keys(element).find(elementKeyPrefixedWithReact);
     };
-    var allElementsWithId = function () { return Array.from(document.querySelectorAll('[id]')); };
+    const allElementsWithId = () => Array.from(document.querySelectorAll('[id]'));
     return documentExists() && allElementsWithId().some(elementIsReactEnabled);
 }
 export function reactSSRDetect() {
     return (processExists() &&
         typeof process.env !== 'undefined' &&
-        !!Object.keys(process.env).find(function (key) { return key.includes('react'); }));
+        !!Object.keys(process.env).find(key => key.includes('react')));
 }
 // use the some

package/lib-esm/Platform/detection/Svelte.js

@@ -8,5 +8,5 @@ export function svelteWebDetect() {
 export function svelteSSRDetect() {
     return (processExists() &&
         typeof process.env !== 'undefined' &&
-        !!Object.keys(process.env).find(function (key) { return key.includes('svelte'); }));
+        !!Object.keys(process.env).find(key => key.includes('svelte')));
 }

package/lib-esm/Platform/detection/helpers.js

@@ -1,20 +1,20 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export var globalExists = function () {
+export const globalExists = () => {
     return typeof global !== 'undefined';
 };
-export var globalThisExists = function () {
+export const globalThisExists = () => {
     return typeof globalThis !== 'undefined';
 };
-export var windowExists = function () {
+export const windowExists = () => {
     return typeof window !== 'undefined';
 };
-export var documentExists = function () {
+export const documentExists = () => {
     return typeof document !== 'undefined';
 };
-export var processExists = function () {
+export const processExists = () => {
     return typeof process !== 'undefined';
 };
-export var keyPrefixMatch = function (object, prefix) {
-    return !!Object.keys(object).find(function (key) { return key.startsWith(prefix); });
+export const keyPrefixMatch = (object, prefix) => {
+    return !!Object.keys(object).find(key => key.startsWith(prefix));
 };

package/lib-esm/Platform/detection/index.js

@@ -11,7 +11,7 @@ import { reactNativeDetect } from './ReactNative';
 import { expoDetect } from './Expo';
 import { webDetect } from './Web';
 // These are in the order of detection where when both are detectable, the early Framework will be reported
-var detectionMap = [
+const detectionMap = [
     // First, detect mobile
     { platform: Framework.Expo, detectionMethod: expoDetect },
     { platform: Framework.ReactNative, detectionMethod: reactNativeDetect },
@@ -32,6 +32,6 @@ var detectionMap = [
     { platform: Framework.SvelteSSR, detectionMethod: svelteSSRDetect },
 ];
 export function detect() {
-    var _a;
-    return (((_a = detectionMap.find(function (detectionEntry) { return detectionEntry.detectionMethod(); })) === null || _a === void 0 ? void 0 : _a.platform) || Framework.ServerSideUnknown);
+    return (detectionMap.find(detectionEntry => detectionEntry.detectionMethod())
+        ?.platform || Framework.ServerSideUnknown);
 }