@adobe/alloy 2.28.0 → 2.28.1-beta.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 { isNil, isNonEmptyString } 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) => surface.startsWith(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 (![WEB, 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;
+};
+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);

package/libEs6/components/Personalization/validateApplyPropositionsOptions.js

@@ -0,0 +1,42 @@
+/*
+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 { anything, objectOf, arrayOf, string } from "../../utils/validation/index.js";
+export const EMPTY_PROPOSITIONS = {
+  propositions: []
+};
+export default ({
+  logger,
+  options
+}) => {
+  const applyPropositionsOptionsValidator = objectOf({
+    propositions: arrayOf(objectOf({
+      id: string().required(),
+      scope: string().required(),
+      scopeDetails: objectOf({
+        decisionProvider: string().required()
+      }).required(),
+      items: arrayOf(objectOf({
+        id: string().required(),
+        schema: string().required(),
+        data: objectOf(anything())
+      })).nonEmpty().required()
+    }).required()).nonEmpty().required(),
+    metadata: objectOf(anything()),
+    viewName: string()
+  }).required();
+  try {
+    return applyPropositionsOptionsValidator(options);
+  } catch (e) {
+    logger.warn("Invalid options for applyPropositions. No propositions will be applied.", e);
+    return EMPTY_PROPOSITIONS;
+  }
+};

package/libEs6/components/RulesEngine/consequenceAdapters/inAppMessageConsequenceAdapter.js

@@ -0,0 +1,30 @@
+/*
+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 { MESSAGE_IN_APP } from "../../../constants/schema.js";
+import { TEXT_HTML } from "../../../constants/contentType.js";
+export default (id, type, detail) => {
+  const {
+    html,
+    mobileParameters
+  } = detail;
+  const webParameters = {};
+  return {
+    schema: MESSAGE_IN_APP,
+    data: {
+      mobileParameters,
+      webParameters,
+      content: html,
+      contentType: TEXT_HTML
+    },
+    id
+  };
+};

package/libEs6/components/RulesEngine/consequenceAdapters/schemaTypeConsequenceAdapter.js

@@ -0,0 +1,24 @@
+/*
+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 (id, type, detail) => {
+  const {
+    schema,
+    data,
+    id: detailId
+  } = detail;
+  return {
+    schema,
+    data,
+    id: detailId || id
+  };
+};

package/libEs6/components/RulesEngine/constants/index.js

@@ -0,0 +1,34 @@
+/*
+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 EVENT_HISTORY_MAX_RECORDS = 1000;
+export const EVENT_HISTORY_RETENTION_PERIOD = 30; // 30 days
+export const EVENT_HISTORY_STORAGE_KEY = "events";
+export const EVENT_HISTORY_MAX_LENGTH = 2 * 1024 * 1024; // 2MB
+
+export const CONTEXT_KEY = {
+  TYPE: "~type",
+  SOURCE: "~source"
+};
+export const CONTEXT_EVENT_TYPE = {
+  LIFECYCLE: "com.adobe.eventType.lifecycle",
+  TRACK: "com.adobe.eventType.generic.track",
+  EDGE: "com.adobe.eventType.edge",
+  RULES_ENGINE: "com.adobe.eventType.rulesEngine"
+};
+export const CONTEXT_EVENT_SOURCE = {
+  LAUNCH: "com.adobe.eventSource.applicationLaunch",
+  REQUEST: "com.adobe.eventSource.requestContent"
+};
+export const CJM_IN_APP_MESSAGE_TYPE = "cjmiam";
+export const SCHEMA = "schema";
+export const INSERT_OPERATION = "insert";
+export const INSERT_IF_NOT_EXISTS_OPERATION = "insertIfNotExists";

package/libEs6/components/RulesEngine/createApplyResponse.js

@@ -0,0 +1,40 @@
+/*
+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 extractPayloadsFromEventHistoryOperations from "./utils/extractPayloadsFromEventHistoryOperations.js";
+export default ({
+  lifecycle,
+  eventRegistry
+}) => {
+  return ({
+    renderDecisions = false,
+    propositions = [],
+    event,
+    personalization
+  }) => {
+    if (lifecycle) {
+      // Some propositions may contains event history operations.
+      // We extract them and add the events to the event registry.
+      const eventPayloads = extractPayloadsFromEventHistoryOperations(propositions);
+      eventRegistry.addEventPayloads(eventPayloads);
+      lifecycle.onDecision({
+        renderDecisions,
+        propositions,
+        event,
+        personalization
+      });
+    }
+    return {
+      propositions
+    };
+  };
+};

package/libEs6/components/RulesEngine/createConsequenceAdapter.js

@@ -0,0 +1,28 @@
+/*
+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 inAppMessageConsequenceAdapter from "./consequenceAdapters/inAppMessageConsequenceAdapter.js";
+import schemaTypeConsequenceAdapter from "./consequenceAdapters/schemaTypeConsequenceAdapter.js";
+import { CJM_IN_APP_MESSAGE_TYPE, SCHEMA } from "./constants/index.js";
+const adapters = {
+  [CJM_IN_APP_MESSAGE_TYPE]: inAppMessageConsequenceAdapter,
+  [SCHEMA]: schemaTypeConsequenceAdapter
+};
+export default () => {
+  return consequence => {
+    const {
+      id,
+      type,
+      detail
+    } = consequence;
+    return typeof adapters[type] === "function" ? adapters[type](id, type, detail) : detail;
+  };
+};

package/libEs6/components/RulesEngine/createContextProvider.js

@@ -0,0 +1,95 @@
+/*
+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 parseUrl from "../../utils/parseUrl.js";
+import flattenObject from "../../utils/flattenObject.js";
+import libraryVersion from "../../constants/libraryVersion.js";
+export default ({
+  eventRegistry,
+  window,
+  getBrowser
+}) => {
+  const pageLoadTimestamp = new Date().getTime();
+  const getBrowserContext = () => {
+    return {
+      name: getBrowser()
+    };
+  };
+  const getPageContext = () => {
+    return {
+      title: window.title,
+      url: window.url,
+      ...parseUrl(window.url)
+    };
+  };
+  const getReferrerContext = () => {
+    return {
+      url: window.referrer,
+      ...parseUrl(window.referrer)
+    };
+  };
+  const getTimeContext = () => {
+    const now = new Date();
+    const currentTimestamp = now.getTime();
+    return {
+      pageLoadTimestamp,
+      currentTimestamp,
+      currentDate: now.getDate(),
+      // Day of the week starts on Monday as is practiced in ISO 8601, but we want it to start on Sunday to match the authoring UI rule
+      "~state.com.adobe.module.lifecycle/lifecyclecontextdata.dayofweek": now.getDay() + 1,
+      "~state.com.adobe.module.lifecycle/lifecyclecontextdata.hourofday": now.getHours(),
+      currentMinute: now.getMinutes(),
+      currentMonth: now.getMonth(),
+      currentYear: now.getFullYear(),
+      pageVisitDuration: currentTimestamp - pageLoadTimestamp,
+      "~timestampu": currentTimestamp / 1000,
+      "~timestampz": now.toISOString()
+    };
+  };
+  const getWindowContext = () => {
+    const height = window.height;
+    const width = window.width;
+    const scrollY = window.scrollY;
+    const scrollX = window.scrollX;
+    return {
+      height,
+      width,
+      scrollY,
+      scrollX
+    };
+  };
+  const coreGlobalContext = {
+    browser: getBrowserContext(),
+    page: getPageContext(),
+    referringPage: getReferrerContext()
+  };
+  const getGlobalContext = () => {
+    return {
+      ...coreGlobalContext,
+      ...getTimeContext(),
+      window: getWindowContext(),
+      "~sdkver": libraryVersion
+    };
+  };
+  const getContext = (addedContext = {}) => {
+    const context = {
+      ...getGlobalContext(),
+      ...addedContext
+    };
+    return {
+      ...flattenObject(context),
+      events: eventRegistry.toJSON()
+    };
+  };
+  return {
+    getContext
+  };
+};

package/libEs6/components/RulesEngine/createDecisionProvider.js

@@ -0,0 +1,44 @@
+/*
+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 createEvaluableRulesetPayload from "./createEvaluableRulesetPayload.js";
+import { getActivityId } from "./utils/index.js";
+export default ({
+  eventRegistry
+}) => {
+  const payloadsBasedOnActivityId = {};
+  const addPayload = payload => {
+    const activityId = getActivityId(payload);
+    if (!activityId) {
+      return;
+    }
+    const evaluableRulesetPayload = createEvaluableRulesetPayload(payload, eventRegistry);
+    if (evaluableRulesetPayload.isEvaluable) {
+      payloadsBasedOnActivityId[activityId] = evaluableRulesetPayload;
+    }
+  };
+  const evaluate = (context = {}) => {
+    const sortedPayloadsBasedOnActivityId = Object.values(payloadsBasedOnActivityId).sort(({
+      rank: rankA
+    }, {
+      rank: rankB
+    }) => rankA - rankB);
+    return sortedPayloadsBasedOnActivityId.map(payload => payload.evaluate(context)).filter(payload => payload.items.length > 0);
+  };
+  const addPayloads = personalizationPayloads => {
+    personalizationPayloads.forEach(addPayload);
+  };
+  return {
+    addPayload,
+    addPayloads,
+    evaluate
+  };
+};

package/libEs6/components/RulesEngine/createEvaluableRulesetPayload.js

@@ -0,0 +1,85 @@
+/*
+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 RulesEngine from "@adobe/aep-rules-engine";
+import { JSON_CONTENT_ITEM, RULESET_ITEM } from "../../constants/schema.js";
+import { DISPLAY } from "../../constants/eventType.js";
+import { PropositionEventType } from "../../constants/propositionEventType.js";
+import { generateEventHash, getActivityId } from "./utils/index.js";
+import flattenArray from "../../utils/flattenArray.js";
+import createConsequenceAdapter from "./createConsequenceAdapter.js";
+const isRulesetItem = item => {
+  const {
+    schema,
+    data
+  } = item;
+  if (schema === RULESET_ITEM) {
+    return true;
+  }
+  if (schema !== JSON_CONTENT_ITEM) {
+    return false;
+  }
+  try {
+    const content = typeof data.content === "string" ? JSON.parse(data.content) : data.content;
+    return content && Object.prototype.hasOwnProperty.call(content, "version") && Object.prototype.hasOwnProperty.call(content, "rules");
+  } catch {
+    return false;
+  }
+};
+export default (payload, eventRegistry) => {
+  const consequenceAdapter = createConsequenceAdapter();
+  const activityId = getActivityId(payload);
+  const items = [];
+  const addItem = item => {
+    const {
+      data = {},
+      schema
+    } = item;
+    const content = schema === RULESET_ITEM ? data : data.content;
+    if (!content) {
+      return;
+    }
+    items.push(RulesEngine(typeof content === "string" ? JSON.parse(content) : content, {
+      generateEventHash
+    }));
+  };
+  const evaluate = context => {
+    const displayEvent = eventRegistry.getEvent(DISPLAY, activityId);
+    const displayedDate = displayEvent?.timestamps[0];
+    const qualifyingItems = flattenArray(items.map(item => item.execute(context))).map(consequenceAdapter).map(item => {
+      const event = eventRegistry.addEvent({
+        eventType: PropositionEventType.TRIGGER,
+        eventId: activityId
+      });
+      const qualifiedDate = event.timestamps[0];
+      return {
+        ...item,
+        data: {
+          ...item.data,
+          qualifiedDate,
+          displayedDate
+        }
+      };
+    });
+    return {
+      ...payload,
+      items: qualifyingItems
+    };
+  };
+  if (Array.isArray(payload.items)) {
+    payload.items.filter(isRulesetItem).forEach(addItem);
+  }
+  return {
+    rank: payload?.scopeDetails?.rank || Infinity,
+    evaluate,
+    isEvaluable: items.length > 0
+  };
+};

package/libEs6/components/RulesEngine/createEvaluateRulesetsCommand.js

@@ -0,0 +1,45 @@
+/*
+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 { boolean, objectOf } from "../../utils/validation/index.js";
+const validateOptions = ({
+  options
+}) => {
+  const validator = objectOf({
+    renderDecisions: boolean(),
+    personalization: objectOf({
+      decisionContext: objectOf({})
+    })
+  }).noUnknownFields();
+  return validator(options);
+};
+export default ({
+  contextProvider,
+  decisionProvider
+}) => {
+  const run = ({
+    renderDecisions,
+    decisionContext,
+    applyResponse
+  }) => {
+    return applyResponse({
+      renderDecisions,
+      propositions: decisionProvider.evaluate(contextProvider.getContext(decisionContext))
+    });
+  };
+  const optionsValidator = options => validateOptions({
+    options
+  });
+  return {
+    optionsValidator,
+    run
+  };
+};