@adobe/alloy 2.30.1-beta.12 → 2.30.1-beta.13

package/libEs5/utils/dom/createGetPageLocation.js

@@ -0,0 +1,20 @@
+"use strict";
+
+exports.default = void 0;
+/*
+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 = ({
+  window
+}) => () => {
+  return window.location;
+};
+exports.default = _default;

package/libEs5/utils/index.js

@@ -36,6 +36,12 @@ Object.defineProperty(exports, "createCallbackAggregator", {
     return _createCallbackAggregator.default;
   }
 });
+Object.defineProperty(exports, "createGetPageLocation", {
+  enumerable: true,
+  get: function () {
+    return _createGetPageLocation.default;
+  }
+});
 Object.defineProperty(exports, "createLoggingCookieJar", {
   enumerable: true,
   get: function () {
@@ -362,4 +368,5 @@ var _toISOStringLocal = require("./toISOStringLocal.js");
 var _uuid = require("./uuid.js");
 var _updateErrorMessage = require("./updateErrorMessage.js");
 var _validateIdentityMap = require("./validateIdentityMap.js");
-var _validateConfigOverride = require("./validateConfigOverride.js");
+var _validateConfigOverride = require("./validateConfigOverride.js");
+var _createGetPageLocation = require("./dom/createGetPageLocation.js");

package/libEs5/utils/request/createRequest.js

@@ -47,7 +47,8 @@ var _default = options => {
     getAction,
     getUseSendBeacon,
     datastreamIdOverride,
-    edgeSubPath
+    edgeSubPath,
+    requestParams = {}
   } = options;
   const id = (0, _index.uuid)();
   let shouldUseThirdPartyDomain = false;
@@ -86,6 +87,9 @@ var _default = options => {
     },
     setIsIdentityEstablished() {
       isIdentityEstablished = true;
+    },
+    getRequestParams() {
+      return requestParams;
     }
   };
 };

package/libEs5/utils/surfaceUtils.js

@@ -0,0 +1,82 @@
+"use strict";
+
+exports.normalizeSurfaces = exports.isPageWideSurface = exports.buildPageSurface = void 0;
+var _surface = require("../constants/surface.js");
+var _index = require("./index.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.
+*/
+
+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 => (0, _index.isNonEmptyString)(surfaceTypeMatch) ? surfaceTypeMatch.toLowerCase() : "";
+const getAuthority = authorityMatch => (0, _index.isNonEmptyString)(authorityMatch) ? authorityMatch.toLowerCase() : "";
+const getPath = pathMatch => (0, _index.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.SURFACE_TYPE_DELIMITER + surface.authority + (surface.path || "") + (surface.fragment || "");
+const buildPageSurface = getPageLocation => {
+  const location = getPageLocation();
+  const host = location.host.toLowerCase();
+  const path = location.pathname;
+  return _surface.WEB + _surface.SURFACE_TYPE_DELIMITER + host + normalizePath(path);
+};
+exports.buildPageSurface = buildPageSurface;
+const expandFragmentSurface = (surface, getPageLocation) => surface.startsWith(_surface.FRAGMENT_DELIMITER) ? buildPageSurface(getPageLocation) + surface : surface;
+const validateSurface = (surface, getPageLocation, logger) => {
+  const invalidateSurface = validationError => {
+    logger.warn(validationError);
+    return null;
+  };
+  if (!(0, _index.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 (![_surface.WEB, _surface.WEBAPP].includes(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;
+};
+const isPageWideSurface = scope => !!scope && scope.indexOf(_surface.WEB + _surface.SURFACE_TYPE_DELIMITER) === 0 && scope.indexOf(_surface.FRAGMENT_DELIMITER) === -1;
+
+// eslint-disable-next-line default-param-last
+exports.isPageWideSurface = isPageWideSurface;
+const normalizeSurfaces = (surfaces = [], getPageLocation, logger) => surfaces.map(surface => validateSurface(surface, getPageLocation, logger)).filter(surface => !(0, _index.isNil)(surface)).map(stringifySurface);
+exports.normalizeSurfaces = normalizeSurfaces;

package/libEs6/components/BrandConcierge/constants.js

@@ -0,0 +1,12 @@
+/*
+Copyright 2025 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 const BC_SESSION_COOKIE_NAME = "bc_session_id";

package/libEs6/components/BrandConcierge/createBuildEndpointUrl.js

@@ -0,0 +1,30 @@
+/*
+Copyright 2025 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 ({
+  queryString
+}) => {
+  return ({
+    edgeDomain,
+    request,
+    datastreamId
+  }) => {
+    const params = request.getRequestParams();
+    const configId = request.getDatastreamIdOverride() || datastreamId;
+    params.requestId = request.getId();
+    params.configId = configId;
+    const stringifiedRequestParams = queryString.stringify({
+      ...params
+    });
+    return `https://${edgeDomain}${request.getEdgeSubPath()}/${request.getAction()}?${stringifiedRequestParams}`;
+  };
+};

package/libEs6/components/BrandConcierge/createConversationServiceRequest.js

@@ -0,0 +1,31 @@
+/*
+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 { createRequest } from "../../utils/request/index.js";
+export default ({
+  payload,
+  action = "conversations",
+  sessionId
+}) => {
+  return createRequest({
+    payload: payload,
+    edgeSubPath: "/brand-concierge",
+    requestParams: {
+      sessionId
+    },
+    getAction() {
+      return action;
+    },
+    getUseSendBeacon() {
+      return false;
+    }
+  });
+};

package/libEs6/components/BrandConcierge/createSendConversationEvent.js

@@ -0,0 +1,128 @@
+/*
+Copyright 2025 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 { createDataCollectionRequestPayload } from "../../utils/request/index.js";
+import createConversationServiceRequest from "./createConversationServiceRequest.js";
+import { getConciergeSessionCookie, getPageSurface } from "./utils.js";
+import uuid from "../../utils/uuid.js";
+import createStreamParser from "./createStreamParser.js";
+export default ({
+  eventManager,
+  loggingCookieJar,
+  config,
+  logger,
+  sendConversationServiceRequest,
+  buildEndpointUrl,
+  cookieTransfer,
+  createResponse,
+  decodeKndctrCookie,
+  lifecycle
+}) => {
+  const {
+    edgeDomain,
+    edgeBasePath,
+    datastreamId,
+    onBeforeEventSend
+  } = config;
+  return options => {
+    let streamingEnabled = false;
+    const {
+      message,
+      onStreamResponse,
+      xdm,
+      data
+    } = options;
+    const sessionId = getConciergeSessionCookie({
+      loggingCookieJar,
+      config
+    }) || uuid();
+    const payload = createDataCollectionRequestPayload();
+    const request = createConversationServiceRequest({
+      payload,
+      sessionId: sessionId
+    });
+    const event = eventManager.createEvent();
+    if (message || data) {
+      const pageSurface = getPageSurface();
+      event.mergeQuery({
+        conversation: {
+          surfaces: [pageSurface],
+          message,
+          data
+        }
+      });
+    }
+    const ecid = decodeKndctrCookie();
+    event.mergeXdm({
+      identityMap: {
+        ECID: [{
+          id: ecid
+        }]
+      }
+    });
+    event.mergeXdm({
+      ...xdm
+    });
+    if (message || data) {
+      streamingEnabled = true;
+    }
+    const url = buildEndpointUrl({
+      edgeDomain,
+      edgeBasePath,
+      datastreamId,
+      request
+    });
+    return lifecycle.onBeforeEvent({
+      event
+    }).then(() => {
+      try {
+        // NOTE: this calls onBeforeEventSend callback (if configured)
+        event.finalize(onBeforeEventSend);
+      } catch (error) {
+        onStreamResponse({
+          error
+        });
+        throw error;
+      }
+      payload.addEvent(event);
+      cookieTransfer.cookiesToPayload(payload, edgeDomain);
+      return sendConversationServiceRequest({
+        requestId: uuid(),
+        url,
+        request,
+        onStreamResponse,
+        streamingEnabled
+      }).then(response => {
+        if (response.status === 204) {
+          return;
+        }
+        const onStreamResponseCallback = event => {
+          if (event.error) {
+            onStreamResponse({
+              error: event.error
+            });
+            return;
+          }
+          const substr = event.data.replace("data: ", "");
+          const responseJson = JSON.parse(substr);
+          const response = createResponse({
+            content: responseJson
+          });
+          cookieTransfer.responseToCookies(response);
+          logger.info("onStreamResponse callback called with", response.getPayloadsByType("brand-concierge:conversation"));
+          onStreamResponse(response.getPayloadsByType("brand-concierge:conversation"));
+        };
+        const streamParser = createStreamParser();
+        streamParser(response.body, onStreamResponseCallback);
+      });
+    });
+  };
+};

package/libEs6/components/BrandConcierge/createSendConversationServiceRequest.js

@@ -0,0 +1,81 @@
+/*
+Copyright 2025 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+import { stackError } from "../../utils/index.js";
+export default ({
+  logger,
+  fetch
+}) => {
+  return async ({
+    requestId,
+    url,
+    request,
+    streamingEnabled = true
+  }) => {
+    const payload = request.getPayload();
+    const stringifiedPayload = JSON.stringify(payload);
+    const parsedPayload = JSON.parse(stringifiedPayload);
+    const headers = {
+      "Content-Type": "text/plain"
+    };
+    if (streamingEnabled) {
+      headers.Accept = "text/event-stream";
+    } else {
+      headers.Accept = "text/plain";
+    }
+    logger.logOnBeforeNetworkRequest({
+      url,
+      requestId,
+      payload: parsedPayload
+    });
+    const fetchWithRetries = async (attemptNumber = 1) => {
+      const maxAttempts = 4;
+      const retryDelays = [2000, 3000, 5000];
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: headers,
+          body: stringifiedPayload
+        });
+        if (!response.ok) {
+          throw new Error(`Request failed with status ${response.status}`);
+        }
+        return response;
+      } catch (error) {
+        if (attemptNumber < maxAttempts) {
+          const delay = retryDelays[attemptNumber - 1];
+          logger.logOnNetworkError({
+            requestId,
+            url,
+            payload: parsedPayload,
+            error: new Error(`Attempt ${attemptNumber} failed, retrying in ${delay}ms: ${error.message}`)
+          });
+          await new Promise(resolve => setTimeout(resolve, delay));
+          return fetchWithRetries(attemptNumber + 1);
+        }
+        logger.logOnNetworkError({
+          requestId,
+          url,
+          payload: parsedPayload,
+          error
+        });
+        throw stackError({
+          error,
+          message: "Network request failed after all retries."
+        });
+      }
+    };
+    const executeRequest = async () => {
+      return fetchWithRetries();
+    };
+    return executeRequest();
+  };
+};

package/libEs6/components/BrandConcierge/createStreamParser.js

@@ -0,0 +1,92 @@
+/*
+Copyright 2024 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 () => {
+  // SSE streams are always UTF-8 encoded per specification
+  const ENCODING = "utf-8";
+  // SSE spec allows three line ending styles: CRLF (\r\n), LF (\n), or CR (\r)
+  const LINE_ENDING_REGEX = /\r\n|\r|\n/;
+  // Events are separated by blank lines (double line endings)
+  const EVENT_SEPARATOR_REGEX = /\r\n\r\n|\n\n|\r\r/;
+
+  /**
+   * Parse a single SSE event from raw event data.
+   * Follows the Server-Sent Events specification (https://html.spec.whatwg.org/multipage/server-sent-events.html)
+   *
+   * @param {string} eventData - Raw event data (multi-line string containing SSE fields)
+   * @returns {Object|null} - Parsed SSE event with structure { type, data, id } or null if invalid
+   */
+  const parseEventFromBuffer = eventData => {
+    const lines = eventData.split(LINE_ENDING_REGEX);
+    const parsedEvent = {};
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine) {
+        continue;
+      }
+      const colonIndex = trimmedLine.indexOf(":");
+      if (colonIndex === -1) {
+        continue;
+      }
+      const field = trimmedLine.substring(0, colonIndex).trim();
+      const value = trimmedLine.substring(colonIndex + 1).trim();
+      if (field === "data") {
+        parsedEvent.data = (parsedEvent.data || "") + value;
+      } else if (field === "event") {
+        parsedEvent.type = value;
+      } else if (field === "id") {
+        parsedEvent.id = value;
+      }
+    }
+    return parsedEvent.data ? parsedEvent : null;
+  };
+
+  /**
+   * Parse SSE stream using callbacks.
+   * Uses modern async iteration (for await...of) for clean, performant stream processing.
+   *
+   * @param {ReadableStream} stream - The readable stream from fetch response
+   * @param {Function} onEvent - Callback function called for each parsed event
+   */
+  return async (stream, onEvent) => {
+    const decoder = new TextDecoder(ENCODING);
+    let buffer = "";
+    try {
+      for await (const chunk of stream) {
+        buffer += decoder.decode(chunk, {
+          stream: true
+        });
+        const events = buffer.split(EVENT_SEPARATOR_REGEX);
+        buffer = events.pop() || "";
+        for (const eventData of events) {
+          const trimmedEvent = eventData.trim();
+          if (trimmedEvent) {
+            const event = parseEventFromBuffer(trimmedEvent);
+            if (event !== null) {
+              onEvent(event);
+            }
+          }
+        }
+      }
+      const trimmedBuffer = buffer.trim();
+      if (trimmedBuffer) {
+        const event = parseEventFromBuffer(trimmedBuffer);
+        if (event !== null) {
+          onEvent(event);
+        }
+      }
+    } catch (error) {
+      onEvent({
+        error
+      });
+    }
+  };
+};

package/libEs6/components/BrandConcierge/index.js

@@ -0,0 +1,100 @@
+/*
+Copyright 2024 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 validateMessage from "./validateMessage.js";
+import createSendConversationEvent from "./createSendConversationEvent.js";
+import createBuildEndpointUrl from "./createBuildEndpointUrl.js";
+import queryString from "@adobe/reactor-query-string";
+import { getNamespacedCookieName } from "../../utils/index.js";
+import { BC_SESSION_COOKIE_NAME } from "./constants.js";
+import { boolean, objectOf } from "../../utils/validation/index.js";
+import createGetEcidFromCookie from "../../utils/createDecodeKndctrCookie.js";
+import createSendConversationServiceRequest from "./createSendConversationServiceRequest.js";
+const createConciergeComponent = ({
+  loggingCookieJar,
+  logger,
+  eventManager,
+  consent,
+  instanceName,
+  sendEdgeNetworkRequest,
+  config,
+  lifecycle,
+  cookieTransfer,
+  createResponse,
+  apexDomain
+}) => {
+  const {
+    fetch
+  } = window;
+  if (!config.stickyConversationSession) {
+    loggingCookieJar.remove(getNamespacedCookieName(config.orgId, BC_SESSION_COOKIE_NAME), {
+      domain: apexDomain
+    });
+  }
+  const buildEndpointUrl = createBuildEndpointUrl({
+    queryString
+  });
+  const sendConversationServiceRequest = createSendConversationServiceRequest({
+    logger,
+    fetch,
+    config
+  });
+  const decodeKndctrCookie = createGetEcidFromCookie({
+    orgId: config.orgId,
+    cookieJar: loggingCookieJar,
+    logger
+  });
+  const sendConversationEvent = createSendConversationEvent({
+    loggingCookieJar,
+    logger,
+    eventManager,
+    consent,
+    instanceName,
+    sendEdgeNetworkRequest,
+    config,
+    buildEndpointUrl,
+    lifecycle,
+    cookieTransfer,
+    createResponse,
+    sendConversationServiceRequest,
+    decodeKndctrCookie
+  });
+  return {
+    lifecycle: {
+      onBeforeEvent({
+        event
+      }) {
+        const parsedParams = queryString.parse(window.location.search);
+        if (parsedParams.source) {
+          const source = parsedParams.source;
+          event.mergeXdm({
+            channel: {
+              referringSource: source
+            }
+          });
+        }
+      }
+    },
+    commands: {
+      sendConversationEvent: {
+        optionsValidator: options => validateMessage({
+          options
+        }),
+        run: sendConversationEvent
+      }
+    }
+  };
+};
+createConciergeComponent.namespace = "BrandConcierge";
+createConciergeComponent.configValidators = objectOf({
+  stickyConversationSession: boolean().default(false)
+});
+export default createConciergeComponent;

package/libEs6/components/BrandConcierge/utils.js

@@ -0,0 +1,27 @@
+/*
+Copyright 2025 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 { getNamespacedCookieName, createGetPageLocation } from "../../utils/index.js";
+import { buildPageSurface } from "../../utils/surfaceUtils.js";
+import { BC_SESSION_COOKIE_NAME } from "./constants.js";
+export const getPageSurface = () => {
+  const pageLocation = createGetPageLocation({
+    window: window
+  });
+  return buildPageSurface(pageLocation);
+};
+export const getConciergeSessionCookie = ({
+  loggingCookieJar,
+  config
+}) => {
+  const cookieName = getNamespacedCookieName(config.orgId, BC_SESSION_COOKIE_NAME);
+  return loggingCookieJar.get(cookieName);
+};