@adobe/alloy 2.20.0-beta.2 → 2.20.0-beta.6

package/libEs5/core/injectExecuteCommand.js

@@ -0,0 +1,104 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../utils/index.js");
+var _coreCommands = require("../constants/coreCommands.js");
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var logger = _ref.logger,
+    configureCommand = _ref.configureCommand,
+    setDebugCommand = _ref.setDebugCommand,
+    handleError = _ref.handleError,
+    validateCommandOptions = _ref.validateCommandOptions;
+  var configurePromise;
+  var getExecutor = function getExecutor(commandName, options) {
+    var executor;
+    if (commandName === _coreCommands.CONFIGURE) {
+      if (configurePromise) {
+        throw new Error("The library has already been configured and may only be configured once.");
+      }
+      executor = function executor() {
+        configurePromise = configureCommand(options);
+        return configurePromise.then(function () {
+          // 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 === _coreCommands.SET_DEBUG) {
+        executor = function executor() {
+          return setDebugCommand(options);
+        };
+      } else {
+        executor = function executor() {
+          return configurePromise.then(function (componentRegistry) {
+            var command = componentRegistry.getCommand(commandName);
+            if (!command || !(0, _index.isFunction)(command.run)) {
+              var commandNames = [_coreCommands.CONFIGURE, _coreCommands.SET_DEBUG].concat(componentRegistry.getCommandNames()).join(", ");
+              throw new Error("The " + commandName + " command does not exist. List of available commands: " + commandNames + ".");
+            }
+            var validatedOptions = validateCommandOptions({
+              command: command,
+              options: options
+            });
+            return command.run(validatedOptions);
+          }, function () {
+            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(function () {});
+          });
+        };
+      }
+    }
+    return executor;
+  };
+  return function (commandName) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return new Promise(function (resolve) {
+      // We have to wrap the getExecutor() call in the promise so the promise
+      // will be rejected if getExecutor() throws errors.
+      var executor = getExecutor(commandName, options);
+      logger.logOnBeforeCommand({
+        commandName: commandName,
+        options: options
+      });
+      resolve(executor());
+    }).catch(function (error) {
+      return handleError(error, commandName + " command");
+    }).catch(function (error) {
+      logger.logOnCommandRejected({
+        commandName: commandName,
+        options: options,
+        error: error
+      });
+      throw error;
+    }).then(function (rawResult) {
+      // We should always be returning an object from every command.
+      var result = (0, _index.isObject)(rawResult) ? rawResult : {};
+      logger.logOnCommandResolved({
+        commandName: commandName,
+        options: options,
+        result: result
+      });
+      return result;
+    });
+  };
+};

package/libEs5/core/injectHandleError.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../utils/index.js");
+var _createConsentStateMachine = require("./consent/createConsentStateMachine.js");
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var errorPrefix = _ref.errorPrefix,
+    logger = _ref.logger;
+  return function (error, operation) {
+    var err = (0, _index.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 === _createConsentStateMachine.DECLINED_CONSENT_ERROR_CODE) {
+      logger.warn("The " + operation + " could not fully complete. " + err.message);
+      return {};
+    }
+    (0, _index.updateErrorMessage)({
+      error: err,
+      message: errorPrefix + " " + err.message
+    });
+    throw err;
+  };
+};

package/libEs5/core/injectShouldTransferCookie.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../utils/index.js");
+var _legacyCookies = require("../constants/legacyCookies.js");
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var orgId = _ref.orgId,
+    targetMigrationEnabled = _ref.targetMigrationEnabled;
+  return function (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 (0, _index.isNamespacedCookieName)(orgId, name) || name === _legacyCookies.AT_QA_MODE || targetMigrationEnabled && name === _legacyCookies.MBOX;
+  };
+};

package/libEs5/core/network/getRequestRetryDelay.js

@@ -0,0 +1,73 @@
+"use strict";
+
+exports.default = void 0;
+var _httpHeaderNames = require("../../constants/httpHeaderNames.js");
+var _index = require("../../utils/index.js");
+/*
+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.
+*/
+
+// The retry gets incrementally (but not exponentially) longer for each retry.
+var FIRST_DELAY_MILLIS = 1000;
+var INCREMENTAL_DELAY_MILLIS = 1000;
+
+// When the target delay is randomized, make it within the range of this percentage above or below the target delay.
+var MAX_RANDOM_VARIANCE_PERCENTAGE = 0.3;
+var calculateRetryDelay = function calculateRetryDelay(retriesAttempted) {
+  var targetDelay = FIRST_DELAY_MILLIS + retriesAttempted * INCREMENTAL_DELAY_MILLIS;
+  var maxVariance = targetDelay * MAX_RANDOM_VARIANCE_PERCENTAGE;
+  var minDelay = targetDelay - maxVariance;
+  var maxDelay = targetDelay + maxVariance;
+  var randomizedDelayWithinRange = Math.round(minDelay + Math.random() * (maxDelay - minDelay));
+  return randomizedDelayWithinRange;
+};
+var getDelayFromHeader = function 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.
+  var headerValue = response.getHeader(_httpHeaderNames.RETRY_AFTER);
+  var delayInMillis;
+  if (headerValue) {
+    var headerValueInt = parseInt(headerValue, 10);
+    if ((0, _index.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
+var _default = exports.default = function _default(_ref) {
+  var response = _ref.response,
+    retriesAttempted = _ref.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.
+  var 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/libEs5/core/network/injectSendNetworkRequest.js

@@ -0,0 +1,102 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/index.js");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var logger = _ref.logger,
+    sendFetchRequest = _ref.sendFetchRequest,
+    sendBeaconRequest = _ref.sendBeaconRequest,
+    isRequestRetryable = _ref.isRequestRetryable,
+    getRequestRetryDelay = _ref.getRequestRetryDelay;
+  /**
+   * Send a network request and returns details about the response.
+   */
+  return function (_ref2) {
+    var requestId = _ref2.requestId,
+      url = _ref2.url,
+      payload = _ref2.payload,
+      useSendBeacon = _ref2.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.
+    var stringifiedPayload = JSON.stringify(payload);
+    var parsedPayload = JSON.parse(stringifiedPayload);
+    logger.logOnBeforeNetworkRequest({
+      url: url,
+      requestId: requestId,
+      payload: parsedPayload
+    });
+    var executeRequest = function executeRequest() {
+      var retriesAttempted = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      var requestMethod = useSendBeacon ? sendBeaconRequest : sendFetchRequest;
+      return requestMethod(url, stringifiedPayload).then(function (response) {
+        var requestIsRetryable = isRequestRetryable({
+          response: response,
+          retriesAttempted: retriesAttempted
+        });
+        if (requestIsRetryable) {
+          var requestRetryDelay = getRequestRetryDelay({
+            response: response,
+            retriesAttempted: retriesAttempted
+          });
+          return new Promise(function (resolve) {
+            setTimeout(function () {
+              resolve(executeRequest(retriesAttempted + 1));
+            }, requestRetryDelay);
+          });
+        }
+        var parsedBody;
+        try {
+          parsedBody = JSON.parse(response.body);
+        } catch (e) {
+          // Non-JSON. Something went wrong.
+        }
+        logger.logOnNetworkResponse(_objectSpread(_objectSpread({
+          requestId: requestId,
+          url: url,
+          payload: parsedPayload
+        }, response), {}, {
+          parsedBody: parsedBody,
+          retriesAttempted: retriesAttempted
+        }));
+        return {
+          statusCode: response.statusCode,
+          body: response.body,
+          parsedBody: parsedBody,
+          getHeader: response.getHeader
+        };
+      });
+    };
+    return executeRequest().catch(function (error) {
+      logger.logOnNetworkError({
+        requestId: requestId,
+        url: url,
+        payload: parsedPayload,
+        error: error
+      });
+      throw (0, _index.stackError)({
+        error: error,
+        message: "Network request failed."
+      });
+    });
+  };
+};

package/libEs5/core/network/isRequestRetryable.js

@@ -0,0 +1,27 @@
+"use strict";
+
+exports.default = void 0;
+var _httpStatusCode = require("../../constants/httpStatusCode.js");
+var _index = require("../../utils/index.js");
+/*
+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.
+*/
+
+var MAX_RETRIES = 3;
+var RETRYABLE_STATUS_CODES = [_httpStatusCode.TOO_MANY_REQUESTS, _httpStatusCode.SERVICE_UNAVAILABLE, _httpStatusCode.BAD_GATEWAY, _httpStatusCode.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
+var _default = exports.default = function _default(_ref) {
+  var response = _ref.response,
+    retriesAttempted = _ref.retriesAttempted;
+  return retriesAttempted < MAX_RETRIES && (0, _index.includes)(RETRYABLE_STATUS_CODES, response.statusCode);
+};

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

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var sendBeacon = _ref.sendBeacon,
+    sendFetchRequest = _ref.sendFetchRequest,
+    logger = _ref.logger;
+  return function (url, body) {
+    var 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: function getHeader() {
+        return null;
+      },
+      body: ""
+    });
+  };
+};

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

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var fetch = _ref.fetch;
+  return function (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: body
+    }).then(function (response) {
+      return response.text().then(function (responseBody) {
+        return {
+          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 but also because it prevents
+          // us from having to add header parsing logic when using XHR to make requests.
+          getHeader: function getHeader(name) {
+            return response.headers.get(name);
+          },
+          body: responseBody
+        };
+      });
+    });
+  };
+};

package/libEs5/core/network/requestMethods/injectSendXhrRequest.js

@@ -0,0 +1,50 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var XMLHttpRequest = _ref.XMLHttpRequest;
+  return function (url, body) {
+    return new Promise(function (resolve, reject) {
+      var request = new XMLHttpRequest();
+      request.onreadystatechange = function () {
+        if (request.readyState === 4) {
+          if (request.status === 0) {
+            reject(new Error("Request aborted."));
+          } else {
+            resolve({
+              statusCode: request.status,
+              // We expose headers through a function instead of creating an object
+              // with all the headers up front because:
+              // 1. It avoids having to add header parsing code to get all headers.
+              // 2. The native request.getResponseHeader method is case-insensitive.
+              getHeader: function getHeader(name) {
+                return request.getResponseHeader(name);
+              },
+              body: request.responseText
+            });
+          }
+        }
+      };
+      request.onloadstart = function () {
+        request.responseType = "text";
+      };
+      request.open("POST", url, true);
+      request.setRequestHeader("Content-Type", "text/plain; charset=UTF-8");
+      request.withCredentials = true;
+      request.onerror = reject;
+      request.onabort = reject;
+      request.send(body);
+    });
+  };
+};

package/libEs5/core/validateCommandOptions.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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.
+*/
+
+var COMMAND_DOC_URI = "https://adobe.ly/3sHgQHb";
+var _default = exports.default = function _default(_ref) {
+  var command = _ref.command,
+    options = _ref.options;
+  var commandName = command.commandName,
+    _command$documentatio = command.documentationUri,
+    documentationUri = _command$documentatio === void 0 ? COMMAND_DOC_URI : _command$documentatio,
+    optionsValidator = command.optionsValidator;
+  var validatedOptions = options;
+  if (optionsValidator) {
+    try {
+      validatedOptions = optionsValidator(options);
+    } catch (validationError) {
+      var invalidOptionsMessage = "Invalid " + commandName + " command options:\n\t - " + validationError + " For command documentation see: " + documentationUri;
+      throw new Error(invalidOptionsMessage);
+    }
+  }
+  return validatedOptions;
+};

package/libEs5/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+exports.createInstance = void 0;
+var _index = require("./core/index.js");
+var _createLogger = require("./core/createLogger.js");
+var _createLogController = require("./core/createLogController.js");
+var _index2 = require("./utils/index.js");
+var _index3 = require("./utils/validation/index.js");
+/*
+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.
+
+var _window = window,
+  console = _window.console;
+var createNamespacedStorage = (0, _index2.injectStorage)(window);
+var createInstance = exports.createInstance = function createInstance() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var eventOptionsValidator = (0, _index3.objectOf)({
+    name: (0, _index3.string)().default("alloy"),
+    monitors: (0, _index3.arrayOf)((0, _index3.objectOf)({})).default([])
+  }).noUnknownFields();
+  var _eventOptionsValidato = eventOptionsValidator(options),
+    name = _eventOptionsValidato.name,
+    monitors = _eventOptionsValidato.monitors;
+
+  // this is a function so that window.__alloyMonitors can be set or added to at any time
+  // eslint-disable-next-line no-underscore-dangle
+  var getMonitors = function getMonitors() {
+    return (window.__alloyMonitors || []).concat(monitors);
+  };
+  var logController = (0, _createLogController.default)({
+    console: console,
+    locationSearch: window.location.search,
+    createLogger: _createLogger.default,
+    instanceName: name,
+    createNamespacedStorage: createNamespacedStorage,
+    getMonitors: getMonitors
+  });
+  var instance = (0, _index.createExecuteCommand)({
+    instanceName: name,
+    logController: logController
+  });
+  logController.logger.logOnInstanceCreated({
+    instance: instance
+  });
+  return instance;
+};

package/libEs5/utils/areThirdPartyCookiesSupportedByDefault.js

@@ -0,0 +1,24 @@
+"use strict";
+
+exports.default = void 0;
+var _browser = require("../constants/browser.js");
+var _includes = require("./includes.js");
+/*
+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.
+*/
+
+// Users could have also disabled third-party cookies within these browsers, but
+// we don't know. We also assume "unknown" browsers support third-party cookies,
+// though we don't really know that either. We're making best guesses.
+var browsersSupportingThirdPartyCookie = [_browser.CHROME, _browser.EDGE, _browser.EDGE_CHROMIUM, _browser.IE, _browser.UNKNOWN];
+var _default = exports.default = function _default(browser) {
+  return (0, _includes.default)(browsersSupportingThirdPartyCookie, browser);
+};

package/libEs5/utils/assign.js

@@ -0,0 +1,16 @@
+"use strict";
+
+exports.default = void 0;
+var _reactorObjectAssign = require("@adobe/reactor-object-assign");
+/*
+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.
+*/
+var _default = exports.default = _reactorObjectAssign.default;