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

package/libEs6/components/Personalization/in-app-message-actions/actions/displayIframeContent.js

@@ -0,0 +1,293 @@
+/*
+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 { getNonce } from "../../dom-actions/dom/index.js";
+import { parseAnchor, removeElementById } from "../utils.js";
+import { TEXT_HTML } from "../../../../constants/contentType.js";
+import { assign, includes, isNonEmptyString, values } from "../../../../utils/index.js";
+import { createNode } from "../../../../utils/dom/index.js";
+import { objectOf } from "../../../../utils/validation/index.js";
+import { PropositionEventType } from "../../../../constants/propositionEventType.js";
+import { EVENT_TYPE_TRUE, INTERACT } from "../../../../constants/eventType.js";
+import createRedirect from "../../dom-actions/createRedirect.js";
+const MESSAGING_CONTAINER_ID = "alloy-messaging-container";
+const OVERLAY_CONTAINER_ID = "alloy-overlay-container";
+const IFRAME_ID = "alloy-content-iframe";
+const dismissMessage = () => [MESSAGING_CONTAINER_ID, OVERLAY_CONTAINER_ID].forEach(removeElementById);
+export const createIframeClickHandler = (interact, navigateToUrl = createRedirect(window)) => {
+  return event => {
+    event.preventDefault();
+    event.stopImmediatePropagation();
+    const {
+      target
+    } = event;
+    const anchor = target.tagName.toLowerCase() === "a" ? target : target.closest("a");
+    if (!anchor) {
+      return;
+    }
+    const {
+      action,
+      interaction,
+      link,
+      label,
+      uuid
+    } = parseAnchor(anchor);
+    interact(action, {
+      label,
+      id: interaction,
+      uuid,
+      link
+    });
+    if (action === "dismiss") {
+      dismissMessage();
+    }
+    if (isNonEmptyString(link) && link.length > 0) {
+      navigateToUrl(link, true);
+    }
+  };
+};
+export const createIframe = (htmlContent, clickHandler) => {
+  const parser = new DOMParser();
+  const htmlDocument = parser.parseFromString(htmlContent, TEXT_HTML);
+  const scriptTag = htmlDocument.querySelector("script");
+  if (scriptTag) {
+    scriptTag.setAttribute("nonce", getNonce());
+  }
+  const element = createNode("iframe", {
+    src: URL.createObjectURL(new Blob([htmlDocument.documentElement.outerHTML], {
+      type: "text/html"
+    })),
+    id: IFRAME_ID
+  });
+  element.addEventListener("load", () => {
+    const {
+      addEventListener
+    } = element.contentDocument || element.contentWindow.document;
+    addEventListener("click", clickHandler);
+  });
+  return element;
+};
+const renderMessage = (iframe, webParameters, container, overlay) => {
+  [{
+    id: OVERLAY_CONTAINER_ID,
+    element: overlay
+  }, {
+    id: MESSAGING_CONTAINER_ID,
+    element: container
+  }, {
+    id: IFRAME_ID,
+    element: iframe
+  }].forEach(({
+    id,
+    element
+  }) => {
+    const {
+      style = {},
+      params = {}
+    } = webParameters[id];
+    assign(element.style, style);
+    const {
+      parentElement = "body",
+      insertionMethod = "appendChild",
+      enabled = true
+    } = params;
+    const parent = document.querySelector(parentElement);
+    if (enabled && parent && typeof parent[insertionMethod] === "function") {
+      parent[insertionMethod](element);
+    }
+  });
+};
+export const buildStyleFromMobileParameters = mobileParameters => {
+  const {
+    verticalAlign,
+    width,
+    horizontalAlign,
+    backdropColor,
+    height,
+    cornerRadius,
+    horizontalInset,
+    verticalInset,
+    uiTakeover = false
+  } = mobileParameters;
+  const style = {
+    width: width ? `${width}%` : "100%",
+    backgroundColor: backdropColor || "rgba(0, 0, 0, 0.5)",
+    borderRadius: cornerRadius ? `${cornerRadius}px` : "0px",
+    border: "none",
+    position: uiTakeover ? "fixed" : "relative",
+    overflow: "hidden"
+  };
+  if (horizontalAlign === "left") {
+    style.left = horizontalInset ? `${horizontalInset}%` : "0";
+  } else if (horizontalAlign === "right") {
+    style.right = horizontalInset ? `${horizontalInset}%` : "0";
+  } else if (horizontalAlign === "center") {
+    style.left = "50%";
+    style.transform = "translateX(-50%)";
+  }
+  if (verticalAlign === "top") {
+    style.top = verticalInset ? `${verticalInset}%` : "0";
+  } else if (verticalAlign === "bottom") {
+    style.position = "fixed";
+    style.bottom = verticalInset ? `${verticalInset}%` : "0";
+  } else if (verticalAlign === "center") {
+    style.top = "50%";
+    style.transform = `${horizontalAlign === "center" ? `${style.transform} ` : ""}translateY(-50%)`;
+    style.display = "flex";
+    style.alignItems = "center";
+    style.justifyContent = "center";
+  }
+  if (height) {
+    style.height = `${height}vh`;
+  } else {
+    style.height = "100%";
+  }
+  return style;
+};
+export const mobileOverlay = mobileParameters => {
+  const {
+    backdropOpacity,
+    backdropColor
+  } = mobileParameters;
+  const opacity = backdropOpacity || 0.5;
+  const color = backdropColor || "#FFFFFF";
+  const style = {
+    position: "fixed",
+    top: "0",
+    left: "0",
+    width: "100%",
+    height: "100%",
+    background: "transparent",
+    opacity,
+    backgroundColor: color
+  };
+  return style;
+};
+const REQUIRED_PARAMS = ["enabled", "parentElement", "insertionMethod"];
+const isValidWebParameters = webParameters => {
+  if (!webParameters) {
+    return false;
+  }
+  const ids = Object.keys(webParameters);
+  if (!includes(ids, MESSAGING_CONTAINER_ID)) {
+    return false;
+  }
+  if (!includes(ids, OVERLAY_CONTAINER_ID)) {
+    return false;
+  }
+  const valuesArray = values(webParameters);
+  for (let i = 0; i < valuesArray.length; i += 1) {
+    if (!objectOf(valuesArray[i], "style")) {
+      return false;
+    }
+    if (!objectOf(valuesArray[i], "params")) {
+      return false;
+    }
+    for (let j = 0; j < REQUIRED_PARAMS.length; j += 1) {
+      if (!objectOf(valuesArray[i].params, REQUIRED_PARAMS[j])) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+const generateWebParameters = mobileParameters => {
+  if (!mobileParameters) {
+    return undefined;
+  }
+  const {
+    uiTakeover = false
+  } = mobileParameters;
+  return {
+    [IFRAME_ID]: {
+      style: {
+        border: "none",
+        width: "100%",
+        height: "100%"
+      },
+      params: {
+        enabled: true,
+        parentElement: "#alloy-messaging-container",
+        insertionMethod: "appendChild"
+      }
+    },
+    [MESSAGING_CONTAINER_ID]: {
+      style: buildStyleFromMobileParameters(mobileParameters),
+      params: {
+        enabled: true,
+        parentElement: "body",
+        insertionMethod: "appendChild"
+      }
+    },
+    [OVERLAY_CONTAINER_ID]: {
+      style: mobileOverlay(mobileParameters),
+      params: {
+        enabled: uiTakeover === true,
+        parentElement: "body",
+        insertionMethod: "appendChild"
+      }
+    }
+  };
+};
+
+// eslint-disable-next-line default-param-last
+export const displayHTMLContentInIframe = (settings = {}, interact) => {
+  dismissMessage();
+  const {
+    content,
+    contentType,
+    mobileParameters
+  } = settings;
+  let {
+    webParameters
+  } = settings;
+  if (contentType !== TEXT_HTML) {
+    return;
+  }
+  const container = createNode("div", {
+    id: MESSAGING_CONTAINER_ID
+  });
+  const iframe = createIframe(content, createIframeClickHandler(interact));
+  const overlay = createNode("div", {
+    id: OVERLAY_CONTAINER_ID
+  });
+  if (!isValidWebParameters(webParameters)) {
+    webParameters = generateWebParameters(mobileParameters);
+  }
+  if (!webParameters) {
+    return;
+  }
+  renderMessage(iframe, webParameters, container, overlay);
+};
+export default ((settings, collect) => {
+  return new Promise(resolve => {
+    const {
+      meta
+    } = settings;
+    displayHTMLContentInIframe(settings, (action, propositionAction) => {
+      const propositionEventTypes = {};
+      propositionEventTypes[PropositionEventType.INTERACT] = EVENT_TYPE_TRUE;
+      if (Object.values(PropositionEventType).indexOf(action) !== -1) {
+        propositionEventTypes[action] = EVENT_TYPE_TRUE;
+      }
+      collect({
+        decisionsMeta: [meta],
+        propositionAction,
+        eventType: INTERACT,
+        propositionEventTypes: Object.keys(propositionEventTypes)
+      });
+    });
+    resolve({
+      meta
+    });
+  });
+});

package/libEs6/components/Personalization/in-app-message-actions/initInAppMessageActionsModules.js

@@ -0,0 +1,17 @@
+/*
+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 displayIframeContent from "./actions/displayIframeContent.js";
+export default (collect => {
+  return {
+    defaultContent: settings => displayIframeContent(settings, collect)
+  };
+});

package/libEs6/components/Personalization/in-app-message-actions/utils.js

@@ -0,0 +1,49 @@
+/*
+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 { isNonEmptyArray, queryString, startsWith } from "../../../utils/index.js";
+import { removeNode, selectNodes } from "../../../utils/dom/index.js";
+export const removeElementById = id => {
+  const element = selectNodes(`#${id}`, document);
+  if (element && element.length > 0) {
+    removeNode(element[0]);
+  }
+};
+export const parseAnchor = anchor => {
+  const nothing = {};
+  if (!anchor || anchor.tagName.toLowerCase() !== "a") {
+    return nothing;
+  }
+  const {
+    href
+  } = anchor;
+  if (!href || !startsWith(href, "adbinapp://")) {
+    return nothing;
+  }
+  const hrefParts = href.split("?");
+  const action = hrefParts[0].split("://")[1];
+  const label = anchor.innerText;
+  const uuid = anchor.getAttribute("data-uuid") || "";
+  let interaction;
+  let link;
+  if (isNonEmptyArray(hrefParts)) {
+    const queryParams = queryString.parse(hrefParts[1]);
+    interaction = queryParams.interaction || "";
+    link = decodeURIComponent(queryParams.link || "");
+  }
+  return {
+    action,
+    interaction,
+    link,
+    label,
+    uuid
+  };
+};

package/libEs6/components/Personalization/index.js

@@ -0,0 +1,167 @@
+/*
+Copyright 2019 Adobe. Ackll 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 { boolean, objectOf, string } from "../../utils/validation/index.js";
+import createComponent from "./createComponent.js";
+import { initDomActionsModules } from "./dom-actions/index.js";
+import createCollect from "./createCollect.js";
+import { hideContainers, showContainers } from "./flicker/index.js";
+import createFetchDataHandler from "./createFetchDataHandler.js";
+import collectClicks from "./dom-actions/clicks/collectClicks.js";
+import isAuthoringModeEnabled from "./utils/isAuthoringModeEnabled.js";
+import { mergeDecisionsMeta, mergeQuery } from "./event.js";
+import createOnClickHandler from "./createOnClickHandler.js";
+import createViewCacheManager from "./createViewCacheManager.js";
+import createViewChangeHandler from "./createViewChangeHandler.js";
+import createClickStorage from "./createClickStorage.js";
+import createApplyPropositions from "./createApplyPropositions.js";
+import createGetPageLocation from "./createGetPageLocation.js";
+import createSetTargetMigration from "./createSetTargetMigration.js";
+import remapCustomCodeOffers from "./dom-actions/remapCustomCodeOffers.js";
+import remapHeadOffers from "./dom-actions/remapHeadOffers.js";
+import createPreprocess from "./dom-actions/createPreprocess.js";
+import injectCreateProposition from "./handlers/injectCreateProposition.js";
+import createAsyncArray from "./utils/createAsyncArray.js";
+import * as schema from "../../constants/schema.js";
+import processDefaultContent from "./handlers/processDefaultContent.js";
+import { isPageWideSurface } from "./utils/surfaceUtils.js";
+import createProcessDomAction from "./handlers/createProcessDomAction.js";
+import createProcessHtmlContent from "./handlers/createProcessHtmlContent.js";
+import createProcessRedirect from "./handlers/createProcessRedirect.js";
+import createProcessPropositions from "./handlers/createProcessPropositions.js";
+import createOnDecisionHandler from "./createOnDecisionHandler.js";
+import createProcessInAppMessage from "./handlers/createProcessInAppMessage.js";
+import initInAppMessageActionsModules from "./in-app-message-actions/initInAppMessageActionsModules.js";
+import createRedirect from "./dom-actions/createRedirect.js";
+import createNotificationHandler from "./createNotificationHandler.js";
+import createHandleConsentFlicker from "./createHandleConsentFlicker.js";
+const createPersonalization = ({
+  config,
+  logger,
+  eventManager,
+  consent
+}) => {
+  const {
+    targetMigrationEnabled,
+    prehidingStyle
+  } = config;
+  const collect = createCollect({
+    eventManager,
+    mergeDecisionsMeta
+  });
+  const {
+    getClickMetasBySelector,
+    getClickSelectors,
+    storeClickMetrics
+  } = createClickStorage();
+  const getPageLocation = createGetPageLocation({
+    window
+  });
+  const domActionsModules = initDomActionsModules();
+  const preprocess = createPreprocess([remapHeadOffers, remapCustomCodeOffers]);
+  const createProposition = injectCreateProposition({
+    preprocess,
+    isPageWideSurface
+  });
+  const viewCache = createViewCacheManager({
+    createProposition
+  });
+  const executeRedirect = createRedirect(window);
+  const schemaProcessors = {
+    [schema.DEFAULT_CONTENT_ITEM]: processDefaultContent,
+    [schema.DOM_ACTION]: createProcessDomAction({
+      modules: domActionsModules,
+      logger,
+      storeClickMetrics
+    }),
+    [schema.HTML_CONTENT_ITEM]: createProcessHtmlContent({
+      modules: domActionsModules,
+      logger
+    }),
+    [schema.REDIRECT_ITEM]: createProcessRedirect({
+      logger,
+      executeRedirect,
+      collect
+    }),
+    [schema.MESSAGE_IN_APP]: createProcessInAppMessage({
+      modules: initInAppMessageActionsModules(collect),
+      logger
+    })
+  };
+  const processPropositions = createProcessPropositions({
+    schemaProcessors,
+    logger
+  });
+  const renderedPropositions = createAsyncArray();
+  const notificationHandler = createNotificationHandler(collect, renderedPropositions);
+  const fetchDataHandler = createFetchDataHandler({
+    prehidingStyle,
+    showContainers,
+    hideContainers,
+    mergeQuery,
+    processPropositions,
+    createProposition,
+    notificationHandler,
+    consent
+  });
+  const onClickHandler = createOnClickHandler({
+    mergeDecisionsMeta,
+    collectClicks,
+    getClickSelectors,
+    getClickMetasBySelector
+  });
+  const viewChangeHandler = createViewChangeHandler({
+    processPropositions,
+    viewCache
+  });
+  const applyPropositions = createApplyPropositions({
+    processPropositions,
+    createProposition,
+    renderedPropositions,
+    viewCache
+  });
+  const setTargetMigration = createSetTargetMigration({
+    targetMigrationEnabled
+  });
+  const onDecisionHandler = createOnDecisionHandler({
+    processPropositions,
+    createProposition,
+    notificationHandler
+  });
+  const handleConsentFlicker = createHandleConsentFlicker({
+    showContainers,
+    consent
+  });
+  return createComponent({
+    getPageLocation,
+    logger,
+    fetchDataHandler,
+    viewChangeHandler,
+    onClickHandler,
+    isAuthoringModeEnabled,
+    mergeQuery,
+    viewCache,
+    showContainers,
+    applyPropositions,
+    setTargetMigration,
+    mergeDecisionsMeta,
+    renderedPropositions,
+    onDecisionHandler,
+    handleConsentFlicker
+  });
+};
+createPersonalization.namespace = "Personalization";
+createPersonalization.configValidators = objectOf({
+  prehidingStyle: string().nonEmpty(),
+  targetMigrationEnabled: boolean().default(false)
+});
+export default createPersonalization;

package/libEs6/components/Personalization/utils/addRenderAttemptedToDecisions.js

@@ -0,0 +1,21 @@
+/*
+Copyright 2021 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 { assign } from "../../../utils/index.js";
+export default (({
+  decisions,
+  renderAttempted
+}) => {
+  return decisions.map(decision => assign({
+    renderAttempted
+  }, decision));
+});

package/libEs6/components/Personalization/utils/createAsyncArray.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.
+*/
+export default (() => {
+  let latest = Promise.resolve([]);
+  return {
+    concat(promise) {
+      latest = latest.then(existingPropositions => {
+        return promise.then(newPropositions => {
+          return existingPropositions.concat(newPropositions);
+        }).catch(() => {
+          return existingPropositions;
+        });
+      });
+    },
+    /**
+     * Clears the saved propositions, waiting until the next propositions are resolved and available.
+     *
+     * @returns {Promise<Array>} A promise that resolves to the latest propositions.
+     */
+    clear() {
+      const oldLatest = latest;
+      latest = Promise.resolve([]);
+      return oldLatest;
+    }
+  };
+});

package/libEs6/components/Personalization/utils/isAuthoringModeEnabled.js

@@ -0,0 +1,15 @@
+/*
+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 ((doc = document) => {
+  return doc.location.href.indexOf("adobe_authoring_enabled") !== -1;
+});

package/libEs6/components/Personalization/utils/surfaceUtils.js

@@ -0,0 +1,76 @@
+/*
+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 { WEB, WEBAPP, SURFACE_TYPE_DELIMITER, FRAGMENT_DELIMITER } from "../constants/surface.js";
+import { startsWith, isNil, isNonEmptyString, includes } from "../../../utils/index.js";
+const SURFACE_REGEX = /^(\w+):\/\/([^/#]+)(\/[^#]*)?(#.*)?$/;
+const AUTHORITY_REGEX = /^(?:.*@)?(?:[a-z\d\u00a1-\uffff.-]+|\[[a-f\d:]+])(?::\d+)?$/;
+const PATH_REGEX = /^\/(?:[/\w\u00a1-\uffff-.~]|%[a-fA-F\d]{2})*$/;
+const FRAGMENT_REGEX = /^#(?:[/\w\u00a1-\uffff-.~]|%[a-fA-F\d]{2})+$/;
+const normalizePath = (path = "/") => {
+  let end = path.length;
+  while (end > 0 && "/".indexOf(path.charAt(end - 1)) !== -1) {
+    end -= 1;
+  }
+  return path.substring(0, end) || "/";
+};
+const getSurfaceType = surfaceTypeMatch => isNonEmptyString(surfaceTypeMatch) ? surfaceTypeMatch.toLowerCase() : "";
+const getAuthority = authorityMatch => isNonEmptyString(authorityMatch) ? authorityMatch.toLowerCase() : "";
+const getPath = pathMatch => isNonEmptyString(pathMatch) ? normalizePath(pathMatch) : "/";
+const parseSurface = surfaceString => {
+  const matched = surfaceString.match(SURFACE_REGEX);
+  return matched ? {
+    surfaceType: getSurfaceType(matched[1]),
+    authority: getAuthority(matched[2]),
+    path: getPath(matched[3]),
+    fragment: matched[4]
+  } : null;
+};
+const stringifySurface = surface => `${surface.surfaceType}${SURFACE_TYPE_DELIMITER}${surface.authority}${surface.path || ""}${surface.fragment || ""}`;
+export const buildPageSurface = getPageLocation => {
+  const location = getPageLocation();
+  const host = location.host.toLowerCase();
+  const path = location.pathname;
+  return WEB + SURFACE_TYPE_DELIMITER + host + normalizePath(path);
+};
+const expandFragmentSurface = (surface, getPageLocation) => startsWith(surface, FRAGMENT_DELIMITER) ? buildPageSurface(getPageLocation) + surface : surface;
+const validateSurface = (surface, getPageLocation, logger) => {
+  const invalidateSurface = validationError => {
+    logger.warn(validationError);
+    return null;
+  };
+  if (!isNonEmptyString(surface)) {
+    return invalidateSurface(`Invalid surface: ${surface}`);
+  }
+  const expanded = expandFragmentSurface(surface, getPageLocation);
+  const parsed = parseSurface(expanded);
+  if (parsed === null) {
+    return invalidateSurface(`Invalid surface: ${surface}`);
+  }
+  if (!includes([WEB, WEBAPP], parsed.surfaceType)) {
+    return invalidateSurface(`Unsupported surface type ${parsed.surfaceType} in surface: ${surface}`);
+  }
+  if (!parsed.authority || !AUTHORITY_REGEX.test(parsed.authority)) {
+    return invalidateSurface(`Invalid authority ${parsed.authority} in surface: ${surface}`);
+  }
+  if (parsed.path && !PATH_REGEX.test(parsed.path)) {
+    return invalidateSurface(`Invalid path ${parsed.path} in surface: ${surface}`);
+  }
+  if (parsed.fragment && !FRAGMENT_REGEX.test(parsed.fragment)) {
+    return invalidateSurface(`Invalid fragment ${parsed.fragment} in surface: ${surface}`);
+  }
+  return parsed;
+};
+export const isPageWideSurface = scope => !!scope && scope.indexOf(WEB + SURFACE_TYPE_DELIMITER) === 0 && scope.indexOf(FRAGMENT_DELIMITER) === -1;
+
+// eslint-disable-next-line default-param-last
+export const normalizeSurfaces = (surfaces = [], getPageLocation, logger) => surfaces.map(surface => validateSurface(surface, getPageLocation, logger)).filter(surface => !isNil(surface)).map(stringifySurface);