@adobe/alloy 2.20.0-alpha.0 → 2.20.0-beta.0

package/libEs6/components/StreamingMedia/createStreamingMediaComponent.js

@@ -0,0 +1,69 @@
+/*
+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 { noop } from "../../utils";
+import validateSessionOptions from "./validateMediaSessionOptions";
+import validateMediaEventOptions from "./validateMediaEventOptions";
+export default (({
+  config,
+  trackMediaEvent,
+  trackMediaSession,
+  mediaResponseHandler
+}) => {
+  return {
+    lifecycle: {
+      onBeforeEvent({
+        mediaOptions,
+        onResponse = noop
+      }) {
+        if (!mediaOptions) {
+          return;
+        }
+        const {
+          legacy,
+          playerId,
+          getPlayerDetails
+        } = mediaOptions;
+        if (legacy) {
+          return;
+        }
+        onResponse(({
+          response
+        }) => {
+          return mediaResponseHandler({
+            playerId,
+            getPlayerDetails,
+            response
+          });
+        });
+      }
+    },
+    commands: {
+      createMediaSession: {
+        optionsValidator: options => validateSessionOptions({
+          options
+        }),
+        run: trackMediaSession
+      },
+      sendMediaEvent: {
+        optionsValidator: options => validateMediaEventOptions({
+          options
+        }),
+        run: options => {
+          if (!config.streamingMedia) {
+            return Promise.reject(new Error("Streaming media is not configured."));
+          }
+          return trackMediaEvent(options);
+        }
+      }
+    }
+  };
+});

package/libEs6/components/StreamingMedia/createTrackMediaEvent.js

@@ -0,0 +1,88 @@
+/*
+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 MediaEvents from "./constants/eventTypes";
+const getContentState = (eventType, sessionContentState) => {
+  if (eventType === MediaEvents.AD_START || eventType === MediaEvents.Ad_BREAK_START || eventType === MediaEvents.AD_SKIP || eventType === MediaEvents.AD_COMPLETE) {
+    return "ad";
+  }
+  if (eventType === MediaEvents.AD_BREAK_COMPLETE || eventType === MediaEvents.CHAPTER_COMPLETE || eventType === MediaEvents.CHAPTER_START || eventType === MediaEvents.CHAPTER_SKIP || eventType === MediaEvents.SESSION_START) {
+    return "main";
+  }
+  if (eventType === MediaEvents.SESSION_END || eventType === MediaEvents.SESSION_COMPLETE) {
+    return "completed";
+  }
+  return sessionContentState;
+};
+export default (({
+  mediaEventManager,
+  mediaSessionCacheManager,
+  config
+}) => {
+  const sendMediaEvent = options => {
+    const event = mediaEventManager.createMediaEvent({
+      options
+    });
+    const {
+      playerId,
+      xdm
+    } = options;
+    const eventType = xdm.eventType;
+    const action = eventType.split(".")[1];
+    const {
+      getPlayerDetails,
+      sessionPromise,
+      playbackState
+    } = mediaSessionCacheManager.getSession(playerId);
+    return sessionPromise.then(result => {
+      mediaEventManager.augmentMediaEvent({
+        event,
+        eventType,
+        playerId,
+        getPlayerDetails,
+        sessionID: result.sessionId
+      });
+      return mediaEventManager.trackMediaEvent({
+        event,
+        action
+      }).then(() => {
+        if (playerId) {
+          if (eventType === MediaEvents.SESSION_COMPLETE || eventType === MediaEvents.SESSION_END) {
+            mediaSessionCacheManager.stopPing({
+              playerId
+            });
+          } else {
+            const sessionPlaybackState = getContentState(eventType, playbackState);
+            if (sessionPlaybackState === "completed") {
+              return;
+            }
+            const interval = sessionPlaybackState === "ad" ? config.streamingMedia.adPingInterval : config.streamingMedia.mainPingInterval;
+            const pingId = setTimeout(() => {
+              const pingOptions = {
+                playerId,
+                xdm: {
+                  eventType: MediaEvents.PING
+                }
+              };
+              sendMediaEvent(pingOptions);
+            }, interval * 1000);
+            mediaSessionCacheManager.savePing({
+              playerId,
+              pingId,
+              playbackState: sessionPlaybackState
+            });
+          }
+        }
+      });
+    });
+  };
+  return options => sendMediaEvent(options);
+});

package/libEs6/components/StreamingMedia/createTrackMediaSession.js

@@ -0,0 +1,51 @@
+/*
+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 PlaybackState from "./constants/playbackState";
+export default (({
+  config,
+  mediaEventManager,
+  mediaSessionCacheManager,
+  legacy = false
+}) => {
+  return options => {
+    if (!config.streamingMedia) {
+      return Promise.reject(new Error("Streaming media is not configured."));
+    }
+    const {
+      playerId,
+      getPlayerDetails
+    } = options;
+    const event = mediaEventManager.createMediaSession(options);
+    mediaEventManager.augmentMediaEvent({
+      event,
+      playerId,
+      getPlayerDetails
+    });
+    const sessionPromise = mediaEventManager.trackMediaSession({
+      event,
+      mediaOptions: {
+        playerId,
+        getPlayerDetails,
+        legacy
+      }
+    });
+    mediaSessionCacheManager.storeSession({
+      playerId,
+      sessionDetails: {
+        sessionPromise,
+        getPlayerDetails,
+        playbackState: PlaybackState.MAIN
+      }
+    });
+    return sessionPromise;
+  };
+});

package/libEs6/components/StreamingMedia/index.js

@@ -0,0 +1,64 @@
+/*
+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.
+*/
+/* eslint-disable import/no-restricted-paths */
+import createMediaSessionCacheManager from "./createMediaSessionCacheManager";
+import createMediaEventManager from "./createMediaEventManager";
+import createTrackMediaEvent from "./createTrackMediaEvent";
+import configValidators from "./configValidators";
+import createStreamingMediaComponent from "./createStreamingMediaComponent";
+import createTrackMediaSession from "./createTrackMediaSession";
+import createMediaResponseHandler from "./createMediaResponseHandler";
+import injectTimestamp from "../Context/injectTimestamp";
+const createStreamingMedia = ({
+  config,
+  logger,
+  eventManager,
+  sendEdgeNetworkRequest,
+  consent
+}) => {
+  const mediaSessionCacheManager = createMediaSessionCacheManager({
+    config
+  });
+  const mediaEventManager = createMediaEventManager({
+    config,
+    eventManager,
+    logger,
+    consent,
+    sendEdgeNetworkRequest,
+    setTimestamp: injectTimestamp(() => new Date())
+  });
+  const trackMediaEvent = createTrackMediaEvent({
+    mediaSessionCacheManager,
+    mediaEventManager,
+    config
+  });
+  const trackMediaSession = createTrackMediaSession({
+    config,
+    mediaEventManager,
+    mediaSessionCacheManager
+  });
+  const mediaResponseHandler = createMediaResponseHandler({
+    mediaSessionCacheManager,
+    config,
+    trackMediaEvent
+  });
+  return createStreamingMediaComponent({
+    config,
+    trackMediaEvent,
+    mediaEventManager,
+    mediaResponseHandler,
+    trackMediaSession
+  });
+};
+createStreamingMedia.namespace = "Streaming media";
+createStreamingMedia.configValidators = configValidators;
+export default createStreamingMedia;

package/libEs6/components/{MediaCollection → StreamingMedia}/validateMediaEventOptions.js

@@ -9,19 +9,20 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-import { anyOf, anything, number, objectOf, string } from "../../utils/validation";
+import { anyOf, anything, enumOf, number, objectOf, string } from "../../utils/validation";
+import EventTypes from "./constants/eventTypes";
 export default (({
   options
 }) => {
   const validator = anyOf([objectOf({
     playerId: string().required(),
     xdm: objectOf({
-      eventType: string().required(),
+      eventType: enumOf(...Object.values(EventTypes)).required(),
       mediaCollection: objectOf(anything())
     }).required()
   }).required(), objectOf({
     xdm: objectOf({
-      eventType: string().required(),
+      eventType: enumOf(...Object.values(EventTypes)).required(),
       mediaCollection: objectOf({
         playhead: number().integer().required(),
         sessionID: string().required()

package/libEs6/components/{MediaCollection → StreamingMedia}/validateMediaSessionOptions.js

@@ -16,7 +16,7 @@ export default (({
 }) => {
   const sessionValidator = anyOf([objectOf({
     playerId: string().required(),
-    onBeforeMediaEvent: callback().required(),
+    getPlayerDetails: callback().required(),
     xdm: objectOf({
       mediaCollection: objectOf({
         sessionDetails: objectOf(anything()).required()

package/libEs6/constants/libraryVersion.js

@@ -13,4 +13,4 @@ governing permissions and limitations under the License.
 // The __VERSION__ keyword will be replace at alloy build time with the package.json version.
 // see babel-plugin-version
 
-export default "2.20.0-alpha.0";
+export default "2.20.0-beta.0";

package/libEs6/core/componentCreators.js

@@ -1,5 +1,5 @@
 /*
-Copyright 2019 Adobe. All rights reserved.
+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
@@ -9,23 +9,39 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
+
 // This is the only place where core is allowed to import from components.
 // This makes sure that each component could be removed without breaking the library
+
 /* eslint-disable import/no-restricted-paths */
+
 import createDataCollector from "../components/DataCollector";
+
+/* @skipwhen ENV.alloy_activitycollector === false */
 import createActivityCollector from "../components/ActivityCollector";
 import createIdentity from "../components/Identity";
+
+/* @skipwhen ENV.alloy_audiences === false */
 import createAudiences from "../components/Audiences";
+
+/* @skipwhen ENV.alloy_personalization === false */
 import createPersonalization from "../components/Personalization";
 import createContext from "../components/Context";
 import createPrivacy from "../components/Privacy";
+
+/* @skipwhen ENV.alloy_eventmerge === false */
 import createEventMerge from "../components/EventMerge";
 import createLibraryInfo from "../components/LibraryInfo";
+
+/* @skipwhen ENV.alloy_decisioningengine === false */
 import createDecisioningEngine from "../components/DecisioningEngine";
+
+/* @skipwhen ENV.alloy_machinelearning === false */
 import createMachineLearning from "../components/MachineLearning";
-import createMediaCollection from "../components/MediaCollection";
+import createStreamingMedia from "../components/StreamingMedia";
 import createLegacyMediaAnalytics from "../components/LegacyMediaAnalytics";
 
 // TODO: Register the Components here statically for now. They might be registered differently.
 // TODO: Figure out how sub-components will be made available/registered
-export default [createDataCollector, createActivityCollector, createIdentity, createAudiences, createPersonalization, createContext, createPrivacy, createEventMerge, createLibraryInfo, createMachineLearning, createDecisioningEngine, createLegacyMediaAnalytics, createMediaCollection];
+
+export default [createDataCollector, createActivityCollector, createIdentity, createAudiences, createPersonalization, createContext, createPrivacy, createEventMerge, createLibraryInfo, createMachineLearning, createDecisioningEngine, createLegacyMediaAnalytics, createStreamingMedia];

package/libEs6/core/consent/createConsent.js

@@ -52,6 +52,9 @@ export default (({
     },
     withConsent() {
       return generalConsentState.withConsent();
+    },
+    current() {
+      return generalConsentState.current();
     }
   };
 });

package/libEs6/core/consent/createConsentStateMachine.js

@@ -86,6 +86,40 @@ export default (({
     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
+          };
+      }
     }
   };
 });

package/libEs6/core/createComponentRegistry.js

@@ -75,6 +75,9 @@ export default (() => {
     },
     getLifecycleCallbacks(hookName) {
       return lifecycleCallbacksByName[hookName] || [];
+    },
+    getComponentNames() {
+      return Object.keys(componentsByNamespace);
     }
   };
 });

package/libEs6/utils/validation/index.js

@@ -90,6 +90,7 @@ import numberValidator from "./numberValidator";
 import regexpValidator from "./regexpValidator";
 import requiredValidator from "./requiredValidator";
 import stringValidator from "./stringValidator";
+import matchesRegexpValidator from "./matchesRegexpValidator";
 
 // The base validator does no validation and just returns the value unchanged
 const base = value => value;
@@ -134,6 +135,9 @@ const nonEmptyObject = function nonEmptyObject() {
 const regexp = function regexp() {
   return nullSafeChain(this, regexpValidator);
 };
+const matches = function matches(regexpPattern) {
+  return nullSafeChain(this, matchesRegexpValidator(regexpPattern));
+};
 const unique = function createUnique() {
   return nullSafeChain(this, createUniqueValidator());
 };
@@ -206,7 +210,8 @@ const string = function string() {
     regexp,
     domain,
     nonEmpty: nonEmptyString,
-    unique
+    unique,
+    matches
   });
 };
 const boundAnyOf = anyOf.bind(base);

package/libEs6/utils/{debounce.js → validation/matchesRegexpValidator.js}

@@ -9,14 +9,9 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-export default ((fn, delay = 150) => {
-  let timer;
-  return (...args) => {
-    if (timer) {
-      clearTimeout(timer);
-    }
-    timer = setTimeout(() => {
-      fn(...args);
-    }, delay);
-  };
+
+import { assertValid } from "./utils";
+export default (regexp => (value, path) => {
+  assertValid(regexp.test(value), value, path, `does not match the ${regexp.toString()}`);
+  return value;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/alloy",
-  "version": "2.20.0-alpha.0",
+  "version": "2.20.0-beta.0",
   "description": "Adobe Experience Platform Web SDK",
   "main": "libEs5/index.js",
   "module": "libEs6/index.js",
@@ -19,19 +19,23 @@
     "test:unit:saucelabs:local": "karma start karma.saucelabs.conf.js --single-run",
     "test:unit:coverage": "karma start --single-run --reporters spec,coverage",
     "test:functional": "EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" testcafe chrome",
-    "test:functional:saucelabs:dev": "NPM_PACKAGE_VERSION=\"2.17.0\" EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" saucectl run --config ./.sauce/dev.yml",
+    "test:functional:custom": "node scripts/helpers/runFunctionalTests.js",
+    "test:functional:saucelabs:dev": "NPM_PACKAGE_VERSION=$(npm pkg get version | tr -d '\"') EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" saucectl run --config ./.sauce/dev.yml",
     "test:functional:watch": "EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" ./scripts/watchFunctionalTests.js --browsers chrome",
     "test:functional:debug": "EDGE_BASE_PATH=\"ee-pre-prd\" ALLOY_ENV=\"int\" testcafe --inspect-brk chrome",
     "test:functional:build:int": "rollup -c --environment BASE_CODE_MIN,STANDALONE,NPM_PACKAGE_LOCAL",
     "test:functional:build:prod": "rollup -c --environment BASE_CODE_MIN,NPM_PACKAGE_PROD",
     "test:scripts": "jasmine --config=scripts/specs/jasmine.json",
     "sandbox:build": "rollup -c --environment SANDBOX && cd sandbox && npm run build",
+    "sandbox:build:custom": "SANDBOX=true npm run build:custom -- --exclude personalization && cd sandbox && npm run build && npm run start",
     "dev": "concurrently --names build,sandbox \"rollup -c -w --environment SANDBOX\" \"cd sandbox && export REACT_APP_NONCE=321 && npm start\"",
     "build": "npm run format && npm run lint && npm run clean && rollup -c --environment BASE_CODE_MIN,STANDALONE,STANDALONE_MIN && echo \"Base Code:\" && cat distTest/baseCode.min.js",
+    "build:custom": "npm run clean && rollup -c --environment BASE_CODE_MIN,NPM_PACKAGE_LOCAL && node scripts/helpers/customBuild.js",
     "prepare": "husky install && cd sandbox && npm install",
     "prepublishOnly": "rimraf libEs5 libEs6 && babel src -d libEs5 --env-name npmEs5 && babel src -d libEs6 --env-name npmEs6",
     "checkthattestfilesexist": "./scripts/checkThatTestFilesExist.js",
-    "add-license": "./scripts/add-license.js"
+    "add-license": "./scripts/add-license.js",
+    "preinstall": "npx force-resolutions"
   },
   "lint-staged": {
     "./*.js": [
@@ -70,16 +74,21 @@
     "uuid": "^3.3.2"
   },
   "devDependencies": {
-    "@adobe/alloy": "^2.19.1",
+    "@adobe/alloy": "^2.19.2",
     "@babel/cli": "^7.12.8",
     "@babel/core": "^7.2.2",
     "@babel/plugin-proposal-object-rest-spread": "^7.3.2",
     "@babel/plugin-transform-runtime": "^7.16.4",
     "@babel/plugin-transform-template-literals": "^7.4.4",
     "@babel/preset-env": "^7.4.5",
+    "@babel/types": "^7.23.0",
     "@octokit/rest": "^18.3.5",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-node-resolve": "^15.2.3",
     "babel-plugin-version": "^0.2.3",
     "bundlesize": "^0.18.0",
+    "chai": "^5.0.0",
     "chalk": "^2.4.2",
     "concurrently": "^6.5.0",
     "date-fns": "^2.23.0",
@@ -91,6 +100,7 @@
     "eslint-plugin-import": "^2.28.1",
     "eslint-plugin-prettier": "^3.0.1",
     "eslint-plugin-testcafe": "^0.2.1",
+    "force-resolutions": "^1.0.11",
     "glob": "^7.1.3",
     "handlebars": "^4.7.7",
     "husky": "^6.0.0",
@@ -134,5 +144,10 @@
     "url-exists-nodejs": "^0.1.0",
     "url-parse": "^1.4.7",
     "yargs": "^16.2.0"
+  },
+  "overrides": {
+    "karma-sauce-launcher": {
+      "webdriverio": "^8.35.1"
+    }
   }
 }