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

package/libEs5/constants/tagName.js

@@ -0,0 +1,22 @@
+"use strict";
+
+exports.STYLE = exports.SCRIPT = exports.IMG = exports.IFRAME = exports.HEAD = exports.DIV = exports.BODY = 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 BODY = exports.BODY = "BODY";
+var IFRAME = exports.IFRAME = "IFRAME";
+var IMG = exports.IMG = "IMG";
+var DIV = exports.DIV = "DIV";
+var STYLE = exports.STYLE = "STYLE";
+var SCRIPT = exports.SCRIPT = "SCRIPT";
+var HEAD = exports.HEAD = "HEAD";

package/libEs5/core/buildAndValidateConfig.js

@@ -0,0 +1,115 @@
+"use strict";
+
+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); }
+exports.default = void 0;
+var _index = require("../utils/index.js");
+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); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /*
+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 CONFIG_DOC_URI = "https://adobe.ly/3sHh553";
+var transformOptions = function transformOptions(_ref) {
+  var combinedConfigValidator = _ref.combinedConfigValidator,
+    options = _ref.options,
+    logger = _ref.logger;
+  try {
+    var validator = combinedConfigValidator.noUnknownFields().required();
+    return validator.call({
+      logger: logger
+    }, options);
+  } catch (e) {
+    throw new Error("Resolve these configuration problems:\n\t - " + e.message.split("\n").join("\n\t - ") + "\nFor configuration documentation see: " + CONFIG_DOC_URI);
+  }
+};
+var buildAllOnInstanceConfiguredExtraParams = function buildAllOnInstanceConfiguredExtraParams(config, logger, componentCreators) {
+  return componentCreators.reduce(function (memo, _ref2) {
+    var buildOnInstanceConfiguredExtraParams = _ref2.buildOnInstanceConfiguredExtraParams;
+    if (buildOnInstanceConfiguredExtraParams) {
+      (0, _index.assign)(memo, buildOnInstanceConfiguredExtraParams({
+        config: config,
+        logger: logger
+      }));
+    }
+    return memo;
+  }, {});
+};
+var wrapLoggerInQueue = function wrapLoggerInQueue(logger) {
+  var queue = [];
+  var queuedLogger = {
+    get enabled() {
+      return logger.enabled;
+    },
+    flush: function flush() {
+      queue.forEach(function (_ref3) {
+        var method = _ref3.method,
+          args = _ref3.args;
+        return logger[method].apply(logger, _toConsumableArray(args));
+      });
+    }
+  };
+  Object.keys(logger).filter(function (key) {
+    return typeof logger[key] === "function";
+  }).forEach(function (method) {
+    queuedLogger[method] = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      queue.push({
+        method: method,
+        args: args
+      });
+    };
+  });
+  return queuedLogger;
+};
+var _default = exports.default = function _default(_ref4) {
+  var options = _ref4.options,
+    componentCreators = _ref4.componentCreators,
+    coreConfigValidators = _ref4.coreConfigValidators,
+    createConfig = _ref4.createConfig,
+    logger = _ref4.logger,
+    setDebugEnabled = _ref4.setDebugEnabled;
+  // We wrap the logger in a queue in case debugEnabled is set in the config
+  // but we need to log something before the config is created.
+  var queuedLogger = wrapLoggerInQueue(logger);
+  var combinedConfigValidator = componentCreators.map(function (_ref5) {
+    var configValidators = _ref5.configValidators;
+    return configValidators;
+  }).filter(function (configValidators) {
+    return configValidators;
+  }).reduce(function (validator, configValidators) {
+    return validator.concat(configValidators);
+  }, coreConfigValidators);
+  var config = createConfig(transformOptions({
+    combinedConfigValidator: combinedConfigValidator,
+    options: options,
+    logger: queuedLogger
+  }));
+  setDebugEnabled(config.debugEnabled, {
+    fromConfig: true
+  });
+  queuedLogger.flush();
+  // eslint-disable-next-line no-underscore-dangle
+  var extraParams = buildAllOnInstanceConfiguredExtraParams(config, logger, componentCreators);
+  logger.logOnInstanceConfigured(_objectSpread(_objectSpread({}, extraParams), {}, {
+    config: config
+  }));
+  return config;
+};

package/libEs5/core/componentCreators.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../components/DataCollector/index.js");
+var _index2 = require("../components/ActivityCollector/index.js");
+var _index3 = require("../components/Identity/index.js");
+var _index4 = require("../components/Audiences/index.js");
+var _index5 = require("../components/Personalization/index.js");
+var _index6 = require("../components/Context/index.js");
+var _index7 = require("../components/Privacy/index.js");
+var _index8 = require("../components/EventMerge/index.js");
+var _index9 = require("../components/LibraryInfo/index.js");
+var _index10 = require("../components/DecisioningEngine/index.js");
+var _index11 = require("../components/MachineLearning/index.js");
+var _index12 = require("../components/StreamingMedia/index.js");
+var _index13 = require("../components/LegacyMediaAnalytics/index.js");
+/*
+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.
+*/
+// This is the only place where core is allowed to import from components.
+// This makes sure that each component could be removed without breaking the library
+/* eslint-disable import/no-restricted-paths */
+/* @skipwhen ENV.alloy_activitycollector === false */
+/* @skipwhen ENV.alloy_audiences === false */
+/* @skipwhen ENV.alloy_personalization === false */
+/* @skipwhen ENV.alloy_eventmerge === false */
+/* @skipwhen ENV.alloy_decisioningengine === false */
+/* @skipwhen ENV.alloy_machinelearning === false */
+// TODO: Register the Components here statically for now. They might be registered differently.
+// TODO: Figure out how sub-components will be made available/registered
+var _default = exports.default = [_index.default, _index2.default, _index3.default, _index4.default, _index5.default, _index6.default, _index7.default, _index8.default, _index9.default, _index11.default, _index10.default, _index13.default, _index12.default];

package/libEs5/core/config/createConfig.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.default = void 0;
+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 createConfig = function createConfig(options) {
+  return (0, _index.assign)({}, options);
+};
+var _default = exports.default = createConfig;

package/libEs5/core/config/createCoreConfigs.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.default = void 0;
+var _index = require("../../utils/validation/index.js");
+var _index2 = require("../../utils/index.js");
+var _domain = require("../../constants/domain.js");
+var _edgeBasePath = require("../../constants/edgeBasePath.js");
+var _consentStatus = require("../../constants/consentStatus.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() {
+  return (0, _index.objectOf)({
+    debugEnabled: (0, _index.boolean)().default(false),
+    defaultConsent: (0, _index.enumOf)(_consentStatus.IN, _consentStatus.OUT, _consentStatus.PENDING).default(_consentStatus.IN),
+    datastreamId: (0, _index.string)().unique().required(),
+    edgeDomain: (0, _index.string)().domain().default(_domain.EDGE),
+    edgeBasePath: (0, _index.string)().nonEmpty().default(_edgeBasePath.default),
+    orgId: (0, _index.string)().unique().required(),
+    onBeforeEventSend: (0, _index.callback)().default(_index2.noop),
+    edgeConfigOverrides: _index2.validateConfigOverride
+  }).deprecated("edgeConfigId", (0, _index.string)().unique(), "datastreamId");
+};

package/libEs5/core/consent/createConsent.js

@@ -0,0 +1,61 @@
+"use strict";
+
+exports.default = void 0;
+var _consentStatus = require("../../constants/consentStatus.js");
+var _consentPurpose = require("../../constants/consentPurpose.js");
+var _createConsentStateMachine = require("./createConsentStateMachine.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.
+*/
+var _default = exports.default = function _default(_ref) {
+  var generalConsentState = _ref.generalConsentState,
+    logger = _ref.logger;
+  var _setConsent = function setConsent(consentByPurpose, source) {
+    switch (consentByPurpose[_consentPurpose.GENERAL]) {
+      case _consentStatus.IN:
+        generalConsentState.in(source);
+        break;
+      case _consentStatus.OUT:
+        generalConsentState.out(source);
+        break;
+      case _consentStatus.PENDING:
+        generalConsentState.pending(source);
+        break;
+      default:
+        logger.warn("Unknown consent value: " + consentByPurpose[_consentPurpose.GENERAL]);
+        break;
+    }
+  };
+  return {
+    initializeConsent: function initializeConsent(defaultConsentByPurpose, storedConsentByPurpose) {
+      if (storedConsentByPurpose[_consentPurpose.GENERAL]) {
+        _setConsent(storedConsentByPurpose, _createConsentStateMachine.CONSENT_SOURCE_INITIAL);
+      } else {
+        _setConsent(defaultConsentByPurpose, _createConsentStateMachine.CONSENT_SOURCE_DEFAULT);
+      }
+    },
+    setConsent: function setConsent(consentByPurpose) {
+      _setConsent(consentByPurpose, _createConsentStateMachine.CONSENT_SOURCE_NEW);
+    },
+    suspend: function suspend() {
+      generalConsentState.pending();
+    },
+    awaitConsent: function awaitConsent() {
+      return generalConsentState.awaitConsent();
+    },
+    withConsent: function withConsent() {
+      return generalConsentState.withConsent();
+    },
+    current: function current() {
+      return generalConsentState.current();
+    }
+  };
+};

package/libEs5/core/consent/createConsentStateMachine.js

@@ -0,0 +1,137 @@
+"use strict";
+
+exports.default = exports.DECLINED_CONSENT_ERROR_CODE = exports.DECLINED_CONSENT = exports.CONSENT_SOURCE_NEW = exports.CONSENT_SOURCE_INITIAL = exports.CONSENT_SOURCE_DEFAULT = void 0;
+var _index = require("../../utils/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.
+*/
+
+var DECLINED_CONSENT = exports.DECLINED_CONSENT = "The user declined consent.";
+var DECLINED_CONSENT_ERROR_CODE = exports.DECLINED_CONSENT_ERROR_CODE = "declinedConsent";
+var CONSENT_SOURCE_DEFAULT = exports.CONSENT_SOURCE_DEFAULT = "default";
+var CONSENT_SOURCE_INITIAL = exports.CONSENT_SOURCE_INITIAL = "initial";
+var CONSENT_SOURCE_NEW = exports.CONSENT_SOURCE_NEW = "new";
+var createDeclinedConsentError = function createDeclinedConsentError(errorMessage) {
+  var error = new Error(errorMessage);
+  error.code = DECLINED_CONSENT_ERROR_CODE;
+  error.message = errorMessage;
+  return error;
+};
+var _default = exports.default = function _default(_ref) {
+  var logger = _ref.logger;
+  var deferreds = [];
+  var runAll = function runAll() {
+    while (deferreds.length) {
+      deferreds.shift().resolve();
+    }
+  };
+  var discardAll = function discardAll() {
+    while (deferreds.length) {
+      deferreds.shift().reject(createDeclinedConsentError("The user declined consent."));
+    }
+  };
+  var awaitInitial = function awaitInitial() {
+    return Promise.reject(new Error("Consent has not been initialized."));
+  };
+  var awaitInDefault = function awaitInDefault() {
+    return Promise.resolve();
+  };
+  var awaitIn = function awaitIn() {
+    return Promise.resolve();
+  };
+  var awaitOutDefault = function awaitOutDefault() {
+    return Promise.reject(createDeclinedConsentError("No consent preferences have been set."));
+  };
+  var awaitOut = function awaitOut() {
+    return Promise.reject(createDeclinedConsentError("The user declined consent."));
+  };
+  var awaitPending = function awaitPending(returnImmediately) {
+    if (returnImmediately) {
+      return Promise.reject(new Error("Consent is pending."));
+    }
+    var deferred = (0, _index.defer)();
+    deferreds.push(deferred);
+    return deferred.promise;
+  };
+  return {
+    in: function _in(source) {
+      if (source === CONSENT_SOURCE_DEFAULT) {
+        this.awaitConsent = awaitInDefault;
+      } else {
+        if (source === CONSENT_SOURCE_INITIAL) {
+          logger.info("Loaded user consent preferences. The user previously consented.");
+        } else if (source === CONSENT_SOURCE_NEW && this.awaitConsent !== awaitIn) {
+          logger.info("User consented.");
+        }
+        runAll();
+        this.awaitConsent = awaitIn;
+      }
+    },
+    out: function out(source) {
+      if (source === CONSENT_SOURCE_DEFAULT) {
+        logger.warn("User consent preferences not found. Default consent of out will be used.");
+        this.awaitConsent = awaitOutDefault;
+      } else {
+        if (source === CONSENT_SOURCE_INITIAL) {
+          logger.warn("Loaded user consent preferences. The user previously declined consent.");
+        } else if (source === CONSENT_SOURCE_NEW && this.awaitConsent !== awaitOut) {
+          logger.warn("User declined consent.");
+        }
+        discardAll();
+        this.awaitConsent = awaitOut;
+      }
+    },
+    pending: function pending(source) {
+      if (source === CONSENT_SOURCE_DEFAULT) {
+        logger.info("User consent preferences not found. Default consent of pending will be used. Some commands may be delayed.");
+      }
+      this.awaitConsent = awaitPending;
+    },
+    awaitConsent: awaitInitial,
+    withConsent: function withConsent() {
+      return this.awaitConsent(true);
+    },
+    current: function current() {
+      switch (this.awaitConsent) {
+        case awaitInDefault:
+          return {
+            state: "in",
+            wasSet: false
+          };
+        case awaitIn:
+          return {
+            state: "in",
+            wasSet: true
+          };
+        case awaitOutDefault:
+          return {
+            state: "out",
+            wasSet: false
+          };
+        case awaitOut:
+          return {
+            state: "out",
+            wasSet: true
+          };
+        case awaitPending:
+          return {
+            state: "pending",
+            wasSet: false
+          };
+        default:
+          return {
+            state: "in",
+            wasSet: false
+          };
+      }
+    }
+  };
+};

package/libEs5/core/createComponentRegistry.js

@@ -0,0 +1,86 @@
+"use strict";
+
+exports.default = void 0;
+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 wrapForErrorHandling = function wrapForErrorHandling(fn, stackMessage) {
+  return function () {
+    var result;
+    try {
+      result = fn.apply(void 0, arguments);
+    } catch (error) {
+      throw (0, _index.stackError)({
+        error: error,
+        message: stackMessage
+      });
+    }
+    if (result instanceof Promise) {
+      result = result.catch(function (error) {
+        throw (0, _index.stackError)({
+          error: error,
+          message: stackMessage
+        });
+      });
+    }
+    return result;
+  };
+};
+
+// TO-DOCUMENT: All public commands and their signatures.
+var _default = exports.default = function _default() {
+  var componentsByNamespace = {};
+  var commandsByName = {};
+  var lifecycleCallbacksByName = {};
+  var registerComponentCommands = function registerComponentCommands(namespace) {
+    var componentCommandsByName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var conflictingCommandNames = (0, _index.intersection)(Object.keys(commandsByName), Object.keys(componentCommandsByName));
+    if (conflictingCommandNames.length) {
+      throw new Error("[ComponentRegistry] Could not register " + namespace + " " + ("because it has existing command(s): " + conflictingCommandNames.join(",")));
+    }
+    Object.keys(componentCommandsByName).forEach(function (commandName) {
+      var command = componentCommandsByName[commandName];
+      command.commandName = commandName;
+      command.run = wrapForErrorHandling(command.run, "[" + namespace + "] An error occurred while executing the " + commandName + " command.");
+      commandsByName[commandName] = command;
+    });
+  };
+  var registerLifecycleCallbacks = function registerLifecycleCallbacks(namespace) {
+    var componentLifecycleCallbacksByName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    Object.keys(componentLifecycleCallbacksByName).forEach(function (hookName) {
+      lifecycleCallbacksByName[hookName] = lifecycleCallbacksByName[hookName] || [];
+      lifecycleCallbacksByName[hookName].push(wrapForErrorHandling(componentLifecycleCallbacksByName[hookName], "[" + namespace + "] An error occurred while executing the " + hookName + " lifecycle hook."));
+    });
+  };
+  return {
+    register: function register(namespace, component) {
+      var commands = component.commands,
+        lifecycle = component.lifecycle;
+      registerComponentCommands(namespace, commands);
+      registerLifecycleCallbacks(namespace, lifecycle);
+      componentsByNamespace[namespace] = component;
+    },
+    getCommand: function getCommand(commandName) {
+      return commandsByName[commandName];
+    },
+    getCommandNames: function getCommandNames() {
+      return Object.keys(commandsByName);
+    },
+    getLifecycleCallbacks: function getLifecycleCallbacks(hookName) {
+      return lifecycleCallbacksByName[hookName] || [];
+    },
+    getComponentNames: function getComponentNames() {
+      return Object.keys(componentsByNamespace);
+    }
+  };
+};

package/libEs5/core/createCookieTransfer.js

@@ -0,0 +1,80 @@
+"use strict";
+
+exports.default = void 0;
+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 STATE_STORE_HANDLE_TYPE = "state:store";
+var _default = exports.default = function _default(_ref) {
+  var cookieJar = _ref.cookieJar,
+    shouldTransferCookie = _ref.shouldTransferCookie,
+    apexDomain = _ref.apexDomain,
+    dateProvider = _ref.dateProvider;
+  return {
+    /**
+     * When sending to a third-party endpoint, the endpoint won't be able to
+     * access first-party cookies, therefore we transfer cookies into
+     * the request body so they can be read by the server.
+     */
+    cookiesToPayload: function cookiesToPayload(payload, endpointDomain) {
+      var isEndpointFirstParty = (0, _index.endsWith)(endpointDomain, apexDomain);
+      var state = {
+        domain: apexDomain,
+        cookiesEnabled: true
+      };
+
+      // If the endpoint is first-party, there's no need to transfer cookies
+      // to the payload since they'll be automatically passed through cookie
+      // headers.
+      if (!isEndpointFirstParty) {
+        var cookies = cookieJar.get();
+        var entries = Object.keys(cookies).filter(shouldTransferCookie).map(function (qualifyingCookieName) {
+          return {
+            key: qualifyingCookieName,
+            value: cookies[qualifyingCookieName]
+          };
+        });
+        if (entries.length) {
+          state.entries = entries;
+        }
+      }
+      payload.mergeState(state);
+    },
+    /**
+     * When receiving from a third-party endpoint, the endpoint won't be able to
+     * write first-party cookies, therefore we write first-party cookies
+     * as directed in the response body.
+     */
+    responseToCookies: function responseToCookies(response) {
+      response.getPayloadsByType(STATE_STORE_HANDLE_TYPE).forEach(function (stateItem) {
+        var options = {
+          domain: apexDomain
+        };
+        var sameSite = stateItem.attrs && stateItem.attrs.SameSite && stateItem.attrs.SameSite.toLowerCase();
+        if (stateItem.maxAge !== undefined) {
+          // cookieJar expects "expires" as a date object
+          options.expires = new Date(dateProvider().getTime() + stateItem.maxAge * 1000);
+        }
+        if (sameSite !== undefined) {
+          options.sameSite = sameSite;
+        }
+        // When sameSite is set to none, the secure flag must be set.
+        // Experience edge will not set the secure flag in these cases.
+        if (sameSite === "none") {
+          options.secure = true;
+        }
+        cookieJar.set(stateItem.key, stateItem.value, options);
+      });
+    }
+  };
+};