@adobe/alloy 2.28.0 → 2.28.1-beta.1

package/libEs5/core/consent/createConsentStateMachine.js

@@ -0,0 +1,129 @@
+"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.
+*/
+
+const DECLINED_CONSENT = exports.DECLINED_CONSENT = "The user declined consent.";
+const DECLINED_CONSENT_ERROR_CODE = exports.DECLINED_CONSENT_ERROR_CODE = "declinedConsent";
+const CONSENT_SOURCE_DEFAULT = exports.CONSENT_SOURCE_DEFAULT = "default";
+const CONSENT_SOURCE_INITIAL = exports.CONSENT_SOURCE_INITIAL = "initial";
+const CONSENT_SOURCE_NEW = exports.CONSENT_SOURCE_NEW = "new";
+const createDeclinedConsentError = errorMessage => {
+  const error = new Error(errorMessage);
+  error.code = DECLINED_CONSENT_ERROR_CODE;
+  error.message = errorMessage;
+  return error;
+};
+var _default = ({
+  logger
+}) => {
+  const deferreds = [];
+  const runAll = () => {
+    while (deferreds.length) {
+      deferreds.shift().resolve();
+    }
+  };
+  const discardAll = () => {
+    while (deferreds.length) {
+      deferreds.shift().reject(createDeclinedConsentError("The user declined consent."));
+    }
+  };
+  const awaitInitial = () => Promise.resolve();
+  const awaitInDefault = () => Promise.resolve();
+  const awaitIn = () => Promise.resolve();
+  const awaitOutDefault = () => Promise.reject(createDeclinedConsentError("No consent preferences have been set."));
+  const awaitOut = () => Promise.reject(createDeclinedConsentError("The user declined consent."));
+  const awaitPending = returnImmediately => {
+    if (returnImmediately) {
+      return Promise.reject(new Error("Consent is pending."));
+    }
+    const deferred = (0, _index.defer)();
+    deferreds.push(deferred);
+    return deferred.promise;
+  };
+  return {
+    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(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(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() {
+      return this.awaitConsent(true);
+    },
+    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
+          };
+      }
+    }
+  };
+};
+exports.default = _default;

package/libEs5/core/createComponentRegistry.js

@@ -0,0 +1,87 @@
+"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.
+*/
+
+const wrapForErrorHandling = (fn, stackMessage) => {
+  return (...args) => {
+    let result;
+    try {
+      result = fn(...args);
+    } catch (error) {
+      throw (0, _index.stackError)({
+        error,
+        message: stackMessage
+      });
+    }
+    if (result instanceof Promise) {
+      result = result.catch(error => {
+        throw (0, _index.stackError)({
+          error,
+          message: stackMessage
+        });
+      });
+    }
+    return result;
+  };
+};
+
+// TO-DOCUMENT: All public commands and their signatures.
+var _default = () => {
+  const componentsByNamespace = {};
+  const commandsByName = {};
+  const lifecycleCallbacksByName = {};
+  const registerComponentCommands = (namespace, componentCommandsByName = {}) => {
+    const 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(commandName => {
+      const command = componentCommandsByName[commandName];
+      command.commandName = commandName;
+      command.run = wrapForErrorHandling(command.run, "[" + namespace + "] An error occurred while executing the " + commandName + " command.");
+      commandsByName[commandName] = command;
+    });
+  };
+  const registerLifecycleCallbacks = (namespace, componentLifecycleCallbacksByName = {}) => {
+    Object.keys(componentLifecycleCallbacksByName).forEach(hookName => {
+      lifecycleCallbacksByName[hookName] = lifecycleCallbacksByName[hookName] || [];
+      lifecycleCallbacksByName[hookName].push(wrapForErrorHandling(componentLifecycleCallbacksByName[hookName], "[" + namespace + "] An error occurred while executing the " + hookName + " lifecycle hook."));
+    });
+  };
+  return {
+    register(namespace, component) {
+      const {
+        commands,
+        lifecycle
+      } = component;
+      registerComponentCommands(namespace, commands);
+      registerLifecycleCallbacks(namespace, lifecycle);
+      componentsByNamespace[namespace] = component;
+    },
+    getCommand(commandName) {
+      return commandsByName[commandName];
+    },
+    getCommandNames() {
+      return Object.keys(commandsByName);
+    },
+    getLifecycleCallbacks(hookName) {
+      return lifecycleCallbacksByName[hookName] || [];
+    },
+    getComponentNames() {
+      return Object.keys(componentsByNamespace);
+    }
+  };
+};
+exports.default = _default;

package/libEs5/core/createCookieTransfer.js

@@ -0,0 +1,82 @@
+"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.
+*/
+const STATE_STORE_HANDLE_TYPE = "state:store";
+var _default = ({
+  cookieJar,
+  shouldTransferCookie,
+  apexDomain,
+  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(payload, endpointDomain) {
+      // localhost is a special case where the apexDomain is ""
+      // We want to treat localhost as a third-party domain.
+      const isEndpointFirstParty = apexDomain !== "" && endpointDomain.endsWith(apexDomain);
+      const 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) {
+        const cookies = cookieJar.get();
+        const entries = Object.keys(cookies).filter(shouldTransferCookie).map(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(response) {
+      response.getPayloadsByType(STATE_STORE_HANDLE_TYPE).forEach(stateItem => {
+        const options = {
+          domain: apexDomain
+        };
+        const 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);
+      });
+    }
+  };
+};
+exports.default = _default;

package/libEs5/core/createEvent.js

@@ -0,0 +1,165 @@
+"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.
+*/
+
+const getXdmPropositions = xdm => {
+  return xdm &&
+  // eslint-disable-next-line no-underscore-dangle
+  xdm._experience &&
+  // eslint-disable-next-line no-underscore-dangle
+  xdm._experience.decisioning &&
+  // eslint-disable-next-line no-underscore-dangle
+  (0, _index.isNonEmptyArray)(xdm._experience.decisioning.propositions) ?
+  // eslint-disable-next-line no-underscore-dangle
+  xdm._experience.decisioning.propositions : [];
+};
+var _default = () => {
+  const content = {};
+  let userXdm;
+  let userData;
+  let documentMayUnload = false;
+  let isFinalized = false;
+  let shouldSendEvent = true;
+  const throwIfEventFinalized = methodName => {
+    if (isFinalized) {
+      throw new Error(methodName + " cannot be called after event is finalized.");
+    }
+  };
+  const event = {
+    hasQuery() {
+      return Object.prototype.hasOwnProperty.call(this.getContent(), "query");
+    },
+    getContent() {
+      const currentContent = JSON.parse(JSON.stringify(content));
+      if (userXdm) {
+        (0, _index.deepAssign)(currentContent, {
+          xdm: userXdm
+        });
+      }
+      if (userData) {
+        (0, _index.deepAssign)(currentContent, {
+          data: userData
+        });
+      }
+      return currentContent;
+    },
+    setUserXdm(value) {
+      throwIfEventFinalized("setUserXdm");
+      userXdm = value;
+    },
+    setUserData(value) {
+      throwIfEventFinalized("setUserData");
+      userData = value;
+    },
+    mergeXdm(xdm) {
+      throwIfEventFinalized("mergeXdm");
+      if (xdm) {
+        (0, _index.deepAssign)(content, {
+          xdm
+        });
+      }
+    },
+    mergeData(data) {
+      throwIfEventFinalized("mergeData");
+      if (data) {
+        (0, _index.deepAssign)(content, {
+          data
+        });
+      }
+    },
+    mergeMeta(meta) {
+      throwIfEventFinalized("mergeMeta");
+      if (meta) {
+        (0, _index.deepAssign)(content, {
+          meta
+        });
+      }
+    },
+    mergeQuery(query) {
+      throwIfEventFinalized("mergeQuery");
+      if (query) {
+        (0, _index.deepAssign)(content, {
+          query
+        });
+      }
+    },
+    documentMayUnload() {
+      documentMayUnload = true;
+    },
+    finalize(onBeforeEventSend) {
+      if (isFinalized) {
+        return;
+      }
+      const newPropositions = (0, _index.deduplicateArray)([...getXdmPropositions(userXdm), ...getXdmPropositions(content.xdm)], (a, b) => a === b || a.id && b.id && a.id === b.id && a.scope && b.scope && a.scope === b.scope);
+      if (userXdm) {
+        this.mergeXdm(userXdm);
+      }
+      if (newPropositions.length > 0) {
+        // eslint-disable-next-line no-underscore-dangle
+        content.xdm._experience.decisioning.propositions = newPropositions;
+      }
+      if (userData) {
+        event.mergeData(userData);
+      }
+
+      // the event should already be considered finalized in case onBeforeEventSend throws an error
+      isFinalized = true;
+      if (onBeforeEventSend) {
+        // assume that the onBeforeEventSend callback will fail (in-case of an error)
+        shouldSendEvent = false;
+
+        // this allows the user to replace the xdm and data properties
+        // on the object passed to the callback
+        const tempContent = {
+          xdm: content.xdm || {},
+          data: content.data || {}
+        };
+        const result = onBeforeEventSend(tempContent);
+        shouldSendEvent = result !== false;
+        content.xdm = tempContent.xdm || {};
+        content.data = tempContent.data || {};
+        if ((0, _index.isEmptyObject)(content.xdm)) {
+          delete content.xdm;
+        }
+        if ((0, _index.isEmptyObject)(content.data)) {
+          delete content.data;
+        }
+      }
+    },
+    getDocumentMayUnload() {
+      return documentMayUnload;
+    },
+    isEmpty() {
+      return (0, _index.isEmptyObject)(content) && (!userXdm || (0, _index.isEmptyObject)(userXdm)) && (!userData || (0, _index.isEmptyObject)(userData));
+    },
+    shouldSend() {
+      return shouldSendEvent;
+    },
+    getViewName() {
+      if (!userXdm || !userXdm.web || !userXdm.web.webPageDetails) {
+        return undefined;
+      }
+      return userXdm.web.webPageDetails.viewName;
+    },
+    toJSON() {
+      if (!isFinalized) {
+        throw new Error("toJSON called before finalize");
+      }
+      return content;
+    }
+  };
+  return event;
+};
+exports.default = _default;

package/libEs5/core/createEventManager.js

@@ -0,0 +1,139 @@
+"use strict";
+
+exports.default = void 0;
+var _pageWideScope = require("../constants/pageWideScope.js");
+var _index = require("../utils/index.js");
+var _index2 = require("../utils/request/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.
+*/
+
+const EVENT_CANCELLATION_MESSAGE = "Event was canceled because the onBeforeEventSend callback returned false.";
+var _default = ({
+  config,
+  logger,
+  lifecycle,
+  consent,
+  createEvent,
+  createDataCollectionRequestPayload,
+  createDataCollectionRequest,
+  sendEdgeNetworkRequest,
+  applyResponse
+}) => {
+  const {
+    onBeforeEventSend,
+    edgeConfigOverrides: globalConfigOverrides
+  } = config;
+  return {
+    createEvent,
+    /**
+     * Sends an event. This includes running the event and payload through the
+     * appropriate lifecycle hooks, sending the request to the server, and
+     * handling the response.
+     * @param {Object} event This will be JSON stringified and used inside the
+     * request payload.
+     * @param {Object} [options] Options to pass on to the onBeforeEvent
+     * lifecycle method
+     * @param {Object} [options.edgeConfigOverrides] Settings that take
+     * precedence over the global datastream configuration, including which
+     * datastream to use.
+     * @returns {*}
+     */
+    sendEvent(event, options = {}) {
+      const {
+        edgeConfigOverrides: localConfigOverrides,
+        ...otherOptions
+      } = options;
+      const requestParams = (0, _index2.createRequestParams)({
+        payload: createDataCollectionRequestPayload(),
+        localConfigOverrides,
+        globalConfigOverrides
+      });
+      const request = createDataCollectionRequest(requestParams);
+      const onResponseCallbackAggregator = (0, _index.createCallbackAggregator)();
+      const onRequestFailureCallbackAggregator = (0, _index.createCallbackAggregator)();
+      return lifecycle.onBeforeEvent({
+        ...otherOptions,
+        event,
+        onResponse: onResponseCallbackAggregator.add,
+        onRequestFailure: onRequestFailureCallbackAggregator.add
+      }).then(() => {
+        requestParams.payload.addEvent(event);
+        return consent.awaitConsent();
+      }).then(() => {
+        try {
+          // NOTE: this calls onBeforeEventSend callback (if configured)
+          event.finalize(onBeforeEventSend);
+        } catch (error) {
+          const throwError = () => {
+            throw error;
+          };
+          onRequestFailureCallbackAggregator.add(lifecycle.onRequestFailure);
+          return onRequestFailureCallbackAggregator.call({
+            error
+          }).then(throwError, throwError);
+        }
+
+        // if the callback returns false, the event should not be sent
+        if (!event.shouldSend()) {
+          onRequestFailureCallbackAggregator.add(lifecycle.onRequestFailure);
+          logger.info(EVENT_CANCELLATION_MESSAGE);
+          const error = new Error(EVENT_CANCELLATION_MESSAGE);
+          return onRequestFailureCallbackAggregator.call({
+            error
+          }).then(() => {
+            // Ensure the promise gets resolved with undefined instead
+            // of an array of return values from the callbacks.
+          });
+        }
+        return sendEdgeNetworkRequest({
+          request,
+          runOnResponseCallbacks: onResponseCallbackAggregator.call,
+          runOnRequestFailureCallbacks: onRequestFailureCallbackAggregator.call
+        });
+      });
+    },
+    applyResponse(event, options = {}) {
+      const {
+        renderDecisions = false,
+        decisionContext = {},
+        responseHeaders = {},
+        responseBody = {
+          handle: []
+        },
+        personalization
+      } = options;
+      const payload = createDataCollectionRequestPayload();
+      const request = createDataCollectionRequest({
+        payload
+      });
+      const onResponseCallbackAggregator = (0, _index.createCallbackAggregator)();
+      return lifecycle.onBeforeEvent({
+        event,
+        renderDecisions,
+        decisionContext,
+        decisionScopes: [_pageWideScope.default],
+        personalization,
+        onResponse: onResponseCallbackAggregator.add,
+        onRequestFailure: _index.noop
+      }).then(() => {
+        payload.addEvent(event);
+        return applyResponse({
+          request,
+          responseHeaders,
+          responseBody,
+          runOnResponseCallbacks: onResponseCallbackAggregator.call
+        });
+      });
+    }
+  };
+};
+exports.default = _default;

package/libEs5/core/createInstanceFunction.js

@@ -0,0 +1,20 @@
+"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 = executeCommand => {
+  return ([resolve, reject, [commandName, options]]) => {
+    executeCommand(commandName, options).then(resolve, reject);
+  };
+};
+exports.default = _default;

package/libEs5/core/createLifecycle.js

@@ -0,0 +1,69 @@
+"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.
+*/
+
+// TO-DOCUMENT: Lifecycle hooks and their params.
+const hookNames = [
+// Called after all components have been registered.
+"onComponentsRegistered",
+// Called before an event is sent on a data collection request
+"onBeforeEvent",
+// Called before each request is made to the edge.
+"onBeforeRequest",
+// Called after each response is returned from the edge with a successful
+// status code
+"onResponse",
+// Called after a network request to the edge fails. Either the request
+// didn't make it to the edge, didn't make it to Konductor, or Konductor
+// failed to return a regularly-structured response. (In this case { error }
+// is passed as the parameter)
+// Also called when the respone returns a 400 or 500 error. (In this case
+// { response } is passed as the parameter)
+"onRequestFailure",
+// A user clicked on an element.
+"onClick",
+// Called by RulesEngine when a ruleset is satisfied with a list of
+// propositions
+"onDecision"];
+const createHook = (componentRegistry, hookName) => {
+  return (...args) => {
+    return Promise.all(componentRegistry.getLifecycleCallbacks(hookName).map(callback => {
+      return new Promise(resolve => {
+        resolve(callback(...args));
+      });
+    }));
+  };
+};
+
+/**
+ * This ensures that if a component's lifecycle method X
+ * attempts to execute lifecycle method Y, that all X methods on all components
+ * will have been called before any of their Y methods are called. It does
+ * this by kicking the call to the Y method to the next JavaScript tick.
+ * @returns {function}
+ */
+const guardHook = fn => {
+  return (...args) => {
+    return Promise.resolve().then(() => {
+      return fn(...args);
+    });
+  };
+};
+var _default = componentRegistry => {
+  return hookNames.reduce((memo, hookName) => {
+    memo[hookName] = guardHook(createHook(componentRegistry, hookName));
+    return memo;
+  }, {});
+};
+exports.default = _default;