@adobe/alloy 2.28.0 → 2.28.1-beta.0

package/libEs6/core/injectExecuteCommand.js

@@ -0,0 +1,113 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { isFunction, isObject } from "../utils/index.js";
+import { CONFIGURE, SET_DEBUG } from "../constants/coreCommands.js";
+import { objectOf, boolean } from "../utils/validation/index.js";
+export default ({
+  logger,
+  configureCommand,
+  setDebugCommand,
+  handleError,
+  validateCommandOptions
+}) => {
+  let configurePromise;
+  const getExecutor = (commandName, options) => {
+    let executor;
+    if (commandName === CONFIGURE) {
+      if (configurePromise) {
+        throw new Error("The library has already been configured and may only be configured once.");
+      }
+      executor = () => {
+        configurePromise = configureCommand(options);
+        return configurePromise.then(() => {
+          // Don't expose internals to the user.
+        });
+      };
+    } else {
+      if (!configurePromise) {
+        throw new Error(`The library must be configured first. Please do so by executing the configure command.`);
+      }
+      if (commandName === SET_DEBUG) {
+        executor = () => {
+          const optionsValidator = objectOf({
+            enabled: boolean().required()
+          }).noUnknownFields();
+          const validatedOptions = validateCommandOptions({
+            command: {
+              commandName: SET_DEBUG,
+              optionsValidator
+            },
+            options
+          });
+          setDebugCommand(validatedOptions);
+        };
+      } else {
+        executor = () => {
+          return configurePromise.then(componentRegistry => {
+            const command = componentRegistry.getCommand(commandName);
+            if (!command || !isFunction(command.run)) {
+              const commandNames = [CONFIGURE, SET_DEBUG].concat(componentRegistry.getCommandNames()).join(", ");
+              throw new Error(`The ${commandName} command does not exist. List of available commands: ${commandNames}.`);
+            }
+            const validatedOptions = validateCommandOptions({
+              command,
+              options
+            });
+            return command.run(validatedOptions);
+          }, () => {
+            logger.warn(`An error during configuration is preventing the ${commandName} command from executing.`);
+            // If configuration failed, we prevent the configuration
+            // error from bubbling here because we don't want the
+            // configuration error to be reported in the console every
+            // time any command is executed. Only having it bubble
+            // once when the configure command runs is sufficient.
+            // Instead, for this command, we'll just return a promise
+            // that never gets resolved.
+            return new Promise(() => {});
+          });
+        };
+      }
+    }
+    return executor;
+  };
+  return (commandName, options = {}) => {
+    return new Promise(resolve => {
+      // We have to wrap the getExecutor() call in the promise so the promise
+      // will be rejected if getExecutor() throws errors.
+      const executor = getExecutor(commandName, options);
+      logger.logOnBeforeCommand({
+        commandName,
+        options
+      });
+      resolve(executor());
+    }).catch(error => {
+      return handleError(error, `${commandName} command`);
+    }).catch(error => {
+      logger.logOnCommandRejected({
+        commandName,
+        options,
+        error
+      });
+      throw error;
+    }).then(rawResult => {
+      // We should always be returning an object from every command.
+      const result = isObject(rawResult) ? rawResult : {};
+      logger.logOnCommandResolved({
+        commandName,
+        options,
+        result
+      });
+      return result;
+    });
+  };
+};

package/libEs6/core/injectHandleError.js

@@ -0,0 +1,33 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { toError, updateErrorMessage } from "../utils/index.js";
+import { DECLINED_CONSENT_ERROR_CODE } from "./consent/createConsentStateMachine.js";
+export default ({
+  errorPrefix,
+  logger
+}) => (error, operation) => {
+  const err = toError(error);
+
+  // In the case of declined consent, we've opted to not reject the promise
+  // returned to the customer, but instead resolve the promise with an
+  // empty result object.
+  if (err.code === DECLINED_CONSENT_ERROR_CODE) {
+    logger.warn(`The ${operation} could not fully complete. ${err.message}`);
+    return {};
+  }
+  updateErrorMessage({
+    error: err,
+    message: `${errorPrefix} ${err.message}`
+  });
+  throw err;
+};

package/libEs6/core/injectShouldTransferCookie.js

@@ -0,0 +1,25 @@
+/*
+Copyright 2022 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { isNamespacedCookieName } from "../utils/index.js";
+import { AT_QA_MODE, MBOX } from "../constants/legacyCookies.js";
+export default ({
+  orgId,
+  targetMigrationEnabled
+}) => name => {
+  // We have a contract with the server that we will pass
+  // all cookies whose names are namespaced according to the
+  // logic in isNamespacedCookieName as well as any legacy
+  // cookie names (so that the server can handle migrating
+  // identities on websites previously using Visitor.js)
+  return isNamespacedCookieName(orgId, name) || name === AT_QA_MODE || targetMigrationEnabled && name === MBOX;
+};

package/libEs6/core/network/getRequestRetryDelay.js

@@ -0,0 +1,72 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { RETRY_AFTER } from "../../constants/httpHeaderNames.js";
+import { isInteger } from "../../utils/index.js";
+
+// The retry gets incrementally (but not exponentially) longer for each retry.
+const FIRST_DELAY_MILLIS = 1000;
+const INCREMENTAL_DELAY_MILLIS = 1000;
+
+// When the target delay is randomized, make it within the range of this percentage above or below the target delay.
+const MAX_RANDOM_VARIANCE_PERCENTAGE = 0.3;
+const calculateRetryDelay = retriesAttempted => {
+  const targetDelay = FIRST_DELAY_MILLIS + retriesAttempted * INCREMENTAL_DELAY_MILLIS;
+  const maxVariance = targetDelay * MAX_RANDOM_VARIANCE_PERCENTAGE;
+  const minDelay = targetDelay - maxVariance;
+  const maxDelay = targetDelay + maxVariance;
+  const randomizedDelayWithinRange = Math.round(minDelay + Math.random() * (maxDelay - minDelay));
+  return randomizedDelayWithinRange;
+};
+const getDelayFromHeader = response => {
+  // According to the HTTP spec, if the header is defined, its value will be a string that
+  // represents either:
+  //  * An integer indicating the number of seconds to delay.
+  //  * A date after which a retry may occur. The date would be in HTTP-date
+  //    format (https://tools.ietf.org/html/rfc7231#section-7.1.1.1). When debugging, it can
+  //    be helpful to know that this is the same format that a JavaScript date's
+  //    toGMTString() returns.
+  const headerValue = response.getHeader(RETRY_AFTER);
+  let delayInMillis;
+  if (headerValue) {
+    const headerValueInt = parseInt(headerValue, 10);
+    if (isInteger(headerValueInt)) {
+      delayInMillis = headerValueInt * 1000;
+    } else {
+      delayInMillis = Math.max(0, new Date(headerValue).getTime() - new Date().getTime());
+    }
+  }
+  return delayInMillis;
+};
+
+// These rules are in accordance with
+// https://git.corp.adobe.com/pages/experience-edge/konductor/#/apis/errors?id=handling-4xx-and-5xx-responses
+// For retry delays that don't come from a Retry-After response header, we try to stick with the following best
+// practices outlined in https://docs.microsoft.com/en-us/azure/architecture/best-practices/transient-faults:
+//  * Incremental retry
+//  * Random interval
+export default ({
+  response,
+  retriesAttempted
+}) => {
+  // Technically, only 429 or 503 responses should have a Retry-After header, but we'll respect the
+  // header if we find it on any response.
+  let delayInMillis = getDelayFromHeader(response);
+
+  // Note that the value of delay may be 0 at this point, which would be a valid delay we want to use
+  // and not override, which is why we don't do:
+  // if (!delay) { ... }
+  if (delayInMillis === undefined) {
+    delayInMillis = calculateRetryDelay(retriesAttempted);
+  }
+  return delayInMillis;
+};

package/libEs6/core/network/injectSendNetworkRequest.js

@@ -0,0 +1,96 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { stackError } from "../../utils/index.js";
+export default ({
+  logger,
+  sendFetchRequest,
+  sendBeaconRequest,
+  isRequestRetryable,
+  getRequestRetryDelay
+}) => {
+  /**
+   * Send a network request and returns details about the response.
+   */
+  return ({
+    requestId,
+    url,
+    payload,
+    useSendBeacon
+  }) => {
+    // We want to log raw payload and event data rather than
+    // our fancy wrapper objects. Calling payload.toJSON() is
+    // insufficient to get all the nested raw data, because it's
+    // not recursive (it doesn't call toJSON() on the event objects).
+    // Parsing the result of JSON.stringify(), however, gives the
+    // fully recursive raw data.
+    const stringifiedPayload = JSON.stringify(payload);
+    const parsedPayload = JSON.parse(stringifiedPayload);
+    logger.logOnBeforeNetworkRequest({
+      url,
+      requestId,
+      payload: parsedPayload
+    });
+    const executeRequest = (retriesAttempted = 0) => {
+      const requestMethod = useSendBeacon ? sendBeaconRequest : sendFetchRequest;
+      return requestMethod(url, stringifiedPayload).then(response => {
+        const requestIsRetryable = isRequestRetryable({
+          response,
+          retriesAttempted
+        });
+        if (requestIsRetryable) {
+          const requestRetryDelay = getRequestRetryDelay({
+            response,
+            retriesAttempted
+          });
+          return new Promise(resolve => {
+            setTimeout(() => {
+              resolve(executeRequest(retriesAttempted + 1));
+            }, requestRetryDelay);
+          });
+        }
+        let parsedBody;
+        try {
+          parsedBody = JSON.parse(response.body);
+        } catch {
+          // Non-JSON. Something went wrong.
+        }
+        logger.logOnNetworkResponse({
+          requestId,
+          url,
+          payload: parsedPayload,
+          ...response,
+          parsedBody,
+          retriesAttempted
+        });
+        return {
+          statusCode: response.statusCode,
+          body: response.body,
+          parsedBody,
+          getHeader: response.getHeader
+        };
+      });
+    };
+    return executeRequest().catch(error => {
+      logger.logOnNetworkError({
+        requestId,
+        url,
+        payload: parsedPayload,
+        error
+      });
+      throw stackError({
+        error,
+        message: "Network request failed."
+      });
+    });
+  };
+};

package/libEs6/core/network/isRequestRetryable.js

@@ -0,0 +1,24 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+import { TOO_MANY_REQUESTS, SERVICE_UNAVAILABLE, BAD_GATEWAY, GATEWAY_TIMEOUT } from "../../constants/httpStatusCode.js";
+const MAX_RETRIES = 3;
+const RETRYABLE_STATUS_CODES = [TOO_MANY_REQUESTS, SERVICE_UNAVAILABLE, BAD_GATEWAY, GATEWAY_TIMEOUT];
+
+// These rules are in accordance with
+// https://git.corp.adobe.com/pages/experience-edge/konductor/#/apis/errors?id=handling-4xx-and-5xx-responses
+export default ({
+  response,
+  retriesAttempted
+}) => {
+  return retriesAttempted < MAX_RETRIES && RETRYABLE_STATUS_CODES.includes(response.statusCode);
+};

package/libEs6/core/network/requestMethods/injectSendBeaconRequest.js

@@ -0,0 +1,38 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export default ({
+  sendBeacon,
+  sendFetchRequest,
+  logger
+}) => {
+  return (url, body) => {
+    const blob = new Blob([body], {
+      type: "text/plain; charset=UTF-8"
+    });
+    if (!sendBeacon(url, blob)) {
+      logger.info("Unable to use `sendBeacon`; falling back to `fetch`.");
+      return sendFetchRequest(url, body);
+    }
+
+    // Using sendBeacon, we technically don't get a response back from
+    // the server, but we'll resolve the promise with an object to maintain
+    // consistency with other network strategies.
+    return Promise.resolve({
+      statusCode: 204,
+      getHeader() {
+        return null;
+      },
+      body: ""
+    });
+  };
+};

package/libEs6/core/network/requestMethods/injectSendFetchRequest.js

@@ -0,0 +1,40 @@
+/*
+Copyright 2019 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export default ({
+  fetch
+}) => {
+  return (url, body) => {
+    return fetch(url, {
+      method: "POST",
+      cache: "no-cache",
+      credentials: "include",
+      // To set the cookie header in the request.
+      headers: {
+        "Content-Type": "text/plain; charset=UTF-8"
+      },
+      referrerPolicy: "no-referrer-when-downgrade",
+      body
+    }).then(response => {
+      return response.text().then(responseBody => ({
+        statusCode: response.status,
+        // We expose headers through a function instead of creating an object
+        // with all the headers up front largely because the native
+        // request.getResponseHeader method is case-insensitive.
+        getHeader(name) {
+          return response.headers.get(name);
+        },
+        body: responseBody
+      }));
+    });
+  };
+};

package/libEs6/core/requiredComponentCreators.js

@@ -0,0 +1,16 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+export { default as context } from "../components/Context/index.js";
+export { default as dataCollector } from "../components/DataCollector/index.js";
+export { default as identity } from "../components/Identity/index.js";
+export { default as libraryInfo } from "../components/LibraryInfo/index.js";

package/libEs6/core/types.js

@@ -0,0 +1,16 @@
+/**
+ * @typedef {object} AlloyMonitor
+ * @property {function(data): void} [onBeforeLog]
+ * @property {function(data): void} [onInstanceCreated]
+ * @property {function(data): void} [onInstanceConfigured]
+ * @property {function(data): void} [onBeforeCommand]
+ * @property {function(data): void} [onCommandResolved]
+ * @property {function(data): void} [onCommandRejected]
+ * @property {function(data): void} [onBeforeNetworkRequest]
+ * @property {function(data): void} [onNetworkResponse]
+ * @property {function(data): void} [onNetworkError]
+ * @property {function(data): void} [onContentHiding]
+ * @property {function(data): void} [onContentRendering]
+ */
+
+export const Types = {};

package/libEs6/core/validateCommandOptions.js

@@ -0,0 +1,33 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const COMMAND_DOC_URI = "https://adobe.ly/3sHgQHb";
+export default ({
+  command,
+  options
+}) => {
+  const {
+    commandName,
+    documentationUri = COMMAND_DOC_URI,
+    optionsValidator
+  } = command;
+  let validatedOptions = options;
+  if (optionsValidator) {
+    try {
+      validatedOptions = optionsValidator(options);
+    } catch (validationError) {
+      const invalidOptionsMessage = `Invalid ${commandName} command options:\n\t - ${validationError} For command documentation see: ${documentationUri}`;
+      throw new Error(invalidOptionsMessage);
+    }
+  }
+  return validatedOptions;
+};

package/libEs6/index.js

@@ -0,0 +1,103 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+// This file is used to rollup the code into an ES module version to be used by other npm projects
+// like the launch extension. Everything that is exported here can be used independently by other
+// npm projects.
+
+/** @import { AlloyMonitor } from './types.js' */
+
+import { createExecuteCommand } from "./core/index.js";
+import createLogger from "./core/createLogger.js";
+import createLogController from "./core/createLogController.js";
+import { injectStorage } from "./utils/index.js";
+import { arrayOf, objectOf, string, callback } from "./utils/validation/index.js";
+import getMonitors from "./core/getMonitors.js";
+import * as optionalComponents from "./core/componentCreators.js";
+const {
+  console
+} = window;
+const createNamespacedStorage = injectStorage(window);
+
+/**
+ * Creates a custom Alloy instance which can reduce the library size and increase performance.
+ *
+ * @type {(options: Object) => Function}
+ * @param {Object} [options] - Configuration options for the instance.
+ * @param {string} [options.name=alloy] - The name of the instance.
+ * @param {Array<AlloyMonitor>} [options.monitors] - Monitors for the instance.
+ * @param {Array<Function>} [options.components] - Components for the instance.
+ * @returns {(commandName: string, options?: Object) => Promise<any>} A callable Alloy instance.
+ *
+ * @see {@link https://experienceleague.adobe.com/en/docs/experience-platform/web-sdk/install/create-custom-build} for more details.
+ */
+export const createCustomInstance = (options = {}) => {
+  const eventOptionsValidator = objectOf({
+    name: string().default("alloy"),
+    monitors: arrayOf(objectOf({})).default([]),
+    components: arrayOf(callback())
+  }).noUnknownFields();
+  const {
+    name,
+    monitors,
+    components
+  } = eventOptionsValidator(options);
+  const logController = createLogController({
+    console,
+    locationSearch: window.location.search,
+    createLogger,
+    instanceName: name,
+    createNamespacedStorage,
+    getMonitors: getMonitors.bind(null, monitors)
+  });
+  const instance = createExecuteCommand({
+    instanceName: name,
+    logController,
+    components
+  });
+  logController.logger.logOnInstanceCreated({
+    instance
+  });
+  return instance;
+};
+
+/**
+ * Creates a new Alloy instance.
+ *
+ * @type {(options?: Object) => Function}
+ * @param {Object} [options] - Configuration options for the instance.
+ * @param {string} [options.name=alloy] - The name of the instance.
+ * @param {Array<AlloyMonitor>} [options.monitors] - (Optional) Monitors for the instance.
+ * @returns {(commandName: string, options?: Object) => Promise<any>} A callable Alloy instance.
+ *
+ * @example
+ * const alloy = createInstance({ name: "myInstance" });
+ * alloy("configure", { datastreamId: "myDatastreamId", orgId: "myOrgId" });
+ *
+ * @see {@link https://experienceleague.adobe.com/en/docs/experience-platform/web-sdk/install/npm} for more details.
+ */
+export const createInstance = (options = {}) => {
+  const eventOptionsValidator = objectOf({
+    name: string().default("alloy"),
+    monitors: arrayOf(objectOf({})).default([])
+  }).noUnknownFields();
+  const {
+    name,
+    monitors
+  } = eventOptionsValidator(options);
+  return createCustomInstance({
+    name,
+    monitors,
+    components: Object.values(optionalComponents)
+  });
+};
+export { optionalComponents as components };

package/libEs6/standalone.js

@@ -0,0 +1,22 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+// This file is used by rollup to create the browser version that is uploaded to cdn
+
+import core from "./core/index.js";
+import * as components from "./core/componentCreators.js";
+
+// If you change this line, check if the custom build script is still working.
+// You might need to change the babel plugin in scripts/helpers/entryPointGeneratorBabelPlugin.js.
+core({
+  components: Object.values(components)
+});

package/libEs6/utils/assignConcatArrayValues.js

@@ -0,0 +1,35 @@
+/*
+Copyright 2023 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import isObject from "./isObject.js";
+export default (...values) => {
+  if (values.length < 2) {
+    // if the number of args is 0 or 1, just use the default behavior from Object.assign
+    return Object.assign(...values);
+  }
+  return values.reduce((accumulator, currentValue) => {
+    if (isObject(currentValue)) {
+      Object.keys(currentValue).forEach(key => {
+        if (Array.isArray(currentValue[key])) {
+          if (Array.isArray(accumulator[key])) {
+            accumulator[key].push(...currentValue[key]);
+          } else {
+            // clone the array so the original isn't modified.
+            accumulator[key] = [...currentValue[key]];
+          }
+        } else {
+          accumulator[key] = currentValue[key];
+        }
+      });
+    }
+    return accumulator;
+  }); // no default value to pass into reduce because we want to skip the first value
+};