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

package/libEs5/utils/validation/index.js

@@ -23,75 +23,79 @@ var _numberValidator = require("./numberValidator");
 var _regexpValidator = require("./regexpValidator");
 var _requiredValidator = require("./requiredValidator");
 var _stringValidator = require("./stringValidator");
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } /*
-                                                                                                                                                                                                                  Copyright 2020 Adobe. All rights reserved.
-                                                                                                                                                                                                                  This file is licensed to you under the Apache License, Version 2.0 (the "License");
-                                                                                                                                                                                                                  you may not use this file except in compliance with the License. You may obtain a copy
-                                                                                                                                                                                                                  of the License at http://www.apache.org/licenses/LICENSE-2.0
-                                                                                                                                                                                                                  
-                                                                                                                                                                                                                  Unless required by applicable law or agreed to in writing, software distributed under
-                                                                                                                                                                                                                  the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
-                                                                                                                                                                                                                  OF ANY KIND, either express or implied. See the License for the specific language
-                                                                                                                                                                                                                  governing permissions and limitations under the License.
-                                                                                                                                                                                                                  */ /**
-                                                                                                                                                                                                                      * Validators are functions of two parameters (value and path) that return the
-                                                                                                                                                                                                                      * computed value if the input is valid, or throw an exception if the input is
-                                                                                                                                                                                                                      * invalid. In most cases the returned value is the same as the input value;
-                                                                                                                                                                                                                      * however, reference createDefaultValidator.js to see an example where the
-                                                                                                                                                                                                                      * computed value is different from the input. Additionally, if we ever wanted
-                                                                                                                                                                                                                      * to coerce types (i.e. parse string values into integers) as part of the
-                                                                                                                                                                                                                      * validation process we could use the computed value to accomplish that.
-                                                                                                                                                                                                                      *
-                                                                                                                                                                                                                      * The path parameter is used to generate informative error messages. It is
-                                                                                                                                                                                                                      * created by the objectOf, and arrayOf validators so that any error message can
-                                                                                                                                                                                                                      * describe which key within the object or array is invalid.
-                                                                                                                                                                                                                      *
-                                                                                                                                                                                                                      * The validators also have methods to chain additional validation logic. For
-                                                                                                                                                                                                                      * example, when you call `string()` to start a validator chain, it returns a
-                                                                                                                                                                                                                      * validator function but it also has methods like `required` and `nonEmpty`.
-                                                                                                                                                                                                                      * Here you can see that these methods are actually calling `chain`.
-                                                                                                                                                                                                                      * Specifically in this function, the leftValidator is called first and then the
-                                                                                                                                                                                                                      * return value of that is sent to the rightValidator. For example, when calling
-                                                                                                                                                                                                                      * `string().nonEmpty().required()` the following chain is built up:
-                                                                                                                                                                                                                      * ```
-                                                                                                                                                                                                                      *              *
-                                                                                                                                                                                                                      *            /   \
-                                                                                                                                                                                                                      *          *     required
-                                                                                                                                                                                                                      *        /   \
-                                                                                                                                                                                                                      *      *     nonEmpty
-                                                                                                                                                                                                                      *    /   \
-                                                                                                                                                                                                                      * base   string
-                                                                                                                                                                                                                      * ```
-                                                                                                                                                                                                                      * Where every * is a call to chain where the two are combined. The individual
-                                                                                                                                                                                                                      * validators are called from left to right in the above tree. The base
-                                                                                                                                                                                                                      * validator is simply the identity function `value => value`, representing an
-                                                                                                                                                                                                                      * optional value.
-                                                                                                                                                                                                                      *
-                                                                                                                                                                                                                      * After combining the validators, the new validator function is then augmented
-                                                                                                                                                                                                                      * with the methods from the leftValidator and from the additionalMethods
-                                                                                                                                                                                                                      * parameter. For example, when the string() function is called it chains to the
-                                                                                                                                                                                                                      * base validator, but also adds additional methods like (`regexp`, `domain`,
-                                                                                                                                                                                                                      * `nonEmpty`, and `unique`). When `nonEmpty` is called, which calls chain
-                                                                                                                                                                                                                      * again, the additional methods are carried forward because they are already
-                                                                                                                                                                                                                      * defined on the leftValidator.
-                                                                                                                                                                                                                      *
-                                                                                                                                                                                                                      * The base validator also contains the two methods `required` and `default`, so
-                                                                                                                                                                                                                      * these can be used anywhere after any of the exposed validator functions are
-                                                                                                                                                                                                                      * called.
-                                                                                                                                                                                                                      *
-                                                                                                                                                                                                                      * For most validators, we want the validation to be optional (i.e. allow null
-                                                                                                                                                                                                                      * or undefined values). To accomplish this, the validator needs to have a check
-                                                                                                                                                                                                                      * at the begining of the function, short circuiting the validation logic and
-                                                                                                                                                                                                                      * returning value if value is null or undefined. `default` and `required` do
-                                                                                                                                                                                                                      * not want this null check though. Indeed, `default` should return the default
-                                                                                                                                                                                                                      * value if value is null, and `required` should throw an error if value is
-                                                                                                                                                                                                                      * null.
-                                                                                                                                                                                                                      *
-                                                                                                                                                                                                                      * So to keep from having to have a null check in front of most validators,
-                                                                                                                                                                                                                      * nullSafeChain allows you to chain a validator in a null-safe way.
-                                                                                                                                                                                                                      */
+var _matchesRegexpValidator = require("./matchesRegexpValidator");
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/ /**
+ * Validators are functions of two parameters (value and path) that return the
+ * computed value if the input is valid, or throw an exception if the input is
+ * invalid. In most cases the returned value is the same as the input value;
+ * however, reference createDefaultValidator.js to see an example where the
+ * computed value is different from the input. Additionally, if we ever wanted
+ * to coerce types (i.e. parse string values into integers) as part of the
+ * validation process we could use the computed value to accomplish that.
+ *
+ * The path parameter is used to generate informative error messages. It is
+ * created by the objectOf, and arrayOf validators so that any error message can
+ * describe which key within the object or array is invalid.
+ *
+ * The validators also have methods to chain additional validation logic. For
+ * example, when you call `string()` to start a validator chain, it returns a
+ * validator function but it also has methods like `required` and `nonEmpty`.
+ * Here you can see that these methods are actually calling `chain`.
+ * Specifically in this function, the leftValidator is called first and then the
+ * return value of that is sent to the rightValidator. For example, when calling
+ * `string().nonEmpty().required()` the following chain is built up:
+ * ```
+ *              *
+ *            /   \
+ *          *     required
+ *        /   \
+ *      *     nonEmpty
+ *    /   \
+ * base   string
+ * ```
+ * Where every * is a call to chain where the two are combined. The individual
+ * validators are called from left to right in the above tree. The base
+ * validator is simply the identity function `value => value`, representing an
+ * optional value.
+ *
+ * After combining the validators, the new validator function is then augmented
+ * with the methods from the leftValidator and from the additionalMethods
+ * parameter. For example, when the string() function is called it chains to the
+ * base validator, but also adds additional methods like (`regexp`, `domain`,
+ * `nonEmpty`, and `unique`). When `nonEmpty` is called, which calls chain
+ * again, the additional methods are carried forward because they are already
+ * defined on the leftValidator.
+ *
+ * The base validator also contains the two methods `required` and `default`, so
+ * these can be used anywhere after any of the exposed validator functions are
+ * called.
+ *
+ * For most validators, we want the validation to be optional (i.e. allow null
+ * or undefined values). To accomplish this, the validator needs to have a check
+ * at the begining of the function, short circuiting the validation logic and
+ * returning value if value is null or undefined. `default` and `required` do
+ * not want this null check though. Indeed, `default` should return the default
+ * value if value is null, and `required` should throw an error if value is
+ * null.
+ *
+ * So to keep from having to have a null check in front of most validators,
+ * nullSafeChain allows you to chain a validator in a null-safe way.
+ */
 // The base validator does no validation and just returns the value unchanged
 var base = function base(value) {
   return value;
@@ -137,6 +141,9 @@ var nonEmptyObject = function nonEmptyObject() {
 var regexp = function regexp() {
   return (0, _utils.nullSafeChain)(this, _regexpValidator.default);
 };
+var matches = function matches(regexpPattern) {
+  return (0, _utils.nullSafeChain)(this, (0, _matchesRegexpValidator.default)(regexpPattern));
+};
 var unique = function createUnique() {
   return (0, _utils.nullSafeChain)(this, (0, _createUniqueValidator.default)());
 };
@@ -208,35 +215,25 @@ var string = function string() {
     regexp: regexp,
     domain: domain,
     nonEmpty: nonEmptyString,
-    unique: unique
+    unique: unique,
+    matches: matches
   });
 };
-var boundAnyOf = anyOf.bind(base);
-exports.anyOf = boundAnyOf;
-var boundAnything = anything.bind(base);
-exports.anything = boundAnything;
-var boundArrayOf = arrayOf.bind(base);
-exports.arrayOf = boundArrayOf;
-var boundBoolean = boolean.bind(base);
-exports.boolean = boundBoolean;
-var boundCallback = callback.bind(base);
-exports.callback = boundCallback;
-var boundLiteral = literal.bind(base);
-exports.literal = boundLiteral;
-var boundNumber = number.bind(base);
-exports.number = boundNumber;
-var boundMapOfValues = mapOfValues.bind(base);
-exports.mapOfValues = boundMapOfValues;
-var boundObjectOf = objectOf.bind(base);
-exports.objectOf = boundObjectOf;
-var boundString = string.bind(base);
+var boundAnyOf = exports.anyOf = anyOf.bind(base);
+var boundAnything = exports.anything = anything.bind(base);
+var boundArrayOf = exports.arrayOf = arrayOf.bind(base);
+var boundBoolean = exports.boolean = boolean.bind(base);
+var boundCallback = exports.callback = callback.bind(base);
+var boundLiteral = exports.literal = literal.bind(base);
+var boundNumber = exports.number = number.bind(base);
+var boundMapOfValues = exports.mapOfValues = mapOfValues.bind(base);
+var boundObjectOf = exports.objectOf = objectOf.bind(base);
+var boundString = exports.string = string.bind(base);
 
 // compound validators
-exports.string = boundString;
-var boundEnumOf = function boundEnumOf() {
+var boundEnumOf = exports.enumOf = function boundEnumOf() {
   for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
     values[_key] = arguments[_key];
   }
   return boundAnyOf(values.map(boundLiteral), "one of these values: [" + JSON.stringify(values) + "]");
-};
-exports.enumOf = boundEnumOf;
+};

package/libEs5/utils/validation/integerValidator.js

@@ -14,8 +14,7 @@ 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.
 */
-var _default = function _default(value, path) {
+var _default = exports.default = function _default(value, path) {
   (0, _utils.assertValid)((0, _isInteger.default)(value), value, path, "an integer");
   return value;
-};
-exports.default = _default;
+};

package/{libEs6/components/MediaCollection/createMediaRequestPayload.js → libEs5/utils/validation/matchesRegexpValidator.js}

@@ -1,3 +1,7 @@
+"use strict";
+
+exports.default = void 0;
+var _utils = require("./utils");
 /*
 Copyright 2023 Adobe. All rights reserved.
 This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -9,18 +13,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.
 */
-
-import { createAddIdentity, createHasIdentity, createRequestPayload } from "../../utils/request";
-export default (() => {
-  const content = {};
-  const payload = createRequestPayload({
-    content,
-    addIdentity: createAddIdentity(content),
-    hasIdentity: createHasIdentity(content)
-  });
-  payload.addEvent = event => {
-    content.events = content.events || [];
-    content.events.push(event);
+var _default = exports.default = function _default(regexp) {
+  return function (value, path) {
+    (0, _utils.assertValid)(regexp.test(value), value, path, "does not match the " + regexp.toString());
+    return value;
   };
-  return payload;
-});
+};

package/libEs5/utils/validation/numberValidator.js

@@ -14,8 +14,7 @@ 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.
 */
-var _default = function _default(value, path) {
+var _default = exports.default = function _default(value, path) {
   (0, _utils.assertValid)((0, _isNumber.default)(value), value, path, "a number");
   return value;
-};
-exports.default = _default;
+};

package/libEs5/utils/validation/regexpValidator.js

@@ -14,8 +14,7 @@ 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.
 */
-var _default = function _default(value, path) {
+var _default = exports.default = function _default(value, path) {
   (0, _utils.assertValid)((0, _isValidRegExp.default)(value), value, path, "a regular expression");
   return value;
-};
-exports.default = _default;
+};

package/libEs5/utils/validation/requiredValidator.js

@@ -12,10 +12,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.
 */
-var _default = function _default(value, path) {
+var _default = exports.default = function _default(value, path) {
   if (value == null) {
     throw new Error("'" + path + "' is a required option");
   }
   return value;
-};
-exports.default = _default;
+};

package/libEs5/utils/validation/stringValidator.js

@@ -14,8 +14,7 @@ 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.
 */
-var _default = function _default(value, path) {
+var _default = exports.default = function _default(value, path) {
   (0, _utils.assertValid)((0, _isString.default)(value), value, path, "a string");
   return value;
-};
-exports.default = _default;
+};

package/libEs5/utils/validation/utils.js

@@ -82,7 +82,7 @@ var callSequentiallyJoinErrors = function callSequentiallyJoinErrors(firstValida
  * validator.
  * @returns {function}
  */
-var chain = function chain(baseValidator, newValidator, additionalMethods) {
+var chain = exports.chain = function chain(baseValidator, newValidator, additionalMethods) {
   return (0, _assign.default)(callSequentially(baseValidator, newValidator), baseValidator, additionalMethods);
 };
 
@@ -101,8 +101,7 @@ var chain = function chain(baseValidator, newValidator, additionalMethods) {
  * validator.
  * @returns {function}
  */
-exports.chain = chain;
-var nullSafeChain = function nullSafeChain(baseValidator, newValidator, additionalMethods) {
+var nullSafeChain = exports.nullSafeChain = function nullSafeChain(baseValidator, newValidator, additionalMethods) {
   return (0, _assign.default)(callSequentially(baseValidator, skipIfNull(newValidator)), baseValidator, additionalMethods);
 };
 
@@ -117,8 +116,7 @@ var nullSafeChain = function nullSafeChain(baseValidator, newValidator, addition
  * validator.
  * @returns {function}
  */
-exports.nullSafeChain = nullSafeChain;
-var reverseNullSafeChainJoinErrors = function reverseNullSafeChainJoinErrors(baseValidator, newValidator, additionalMethods) {
+var reverseNullSafeChainJoinErrors = exports.reverseNullSafeChainJoinErrors = function reverseNullSafeChainJoinErrors(baseValidator, newValidator, additionalMethods) {
   return (0, _assign.default)(callSequentiallyJoinErrors(skipIfNull(newValidator), baseValidator), baseValidator, additionalMethods);
 };
 
@@ -132,10 +130,8 @@ var reverseNullSafeChainJoinErrors = function reverseNullSafeChainJoinErrors(bas
  * @throws {Error} - Throws an error if the value is not valid.
  * @returns {void}
  */
-exports.reverseNullSafeChainJoinErrors = reverseNullSafeChainJoinErrors;
-var assertValid = function assertValid(isValid, value, path, message) {
+var assertValid = exports.assertValid = function assertValid(isValid, value, path, message) {
   if (!isValid) {
     throw new Error("'" + path + "': Expected " + message + ", but got " + JSON.stringify(value) + ".");
   }
-};
-exports.assertValid = assertValid;
+};

package/libEs5/utils/values.js

@@ -18,9 +18,8 @@ governing permissions and limitations under the License.
  * @param {Object} obj
  * @returns {Array}
  */
-var _default = function _default(obj) {
+var _default = exports.default = function _default(obj) {
   return Object.keys(obj).map(function (key) {
     return obj[key];
   });
-};
-exports.default = _default;
+};

package/libEs6/components/ActivityCollector/index.js

@@ -49,7 +49,6 @@ const createActivityCollector = ({
         });
         // TODO: createScrollActivityCollector ...
       },
-
       onClick({
         event,
         clickedElement

package/libEs6/components/Identity/index.js

@@ -84,7 +84,8 @@ const createIdentity = ({
   });
   const awaitIdentityCookie = injectAwaitIdentityCookie({
     doesIdentityCookieExist,
-    orgId
+    orgId,
+    logger
   });
   const ensureSingleIdentity = injectEnsureSingleIdentity({
     doesIdentityCookieExist,

package/libEs6/components/Identity/injectAddQueryStringIdentityToPayload.js

@@ -28,10 +28,14 @@ export default (({
     return;
   }
   const parsedQueryString = queryString.parse(locationSearch);
-  const queryStringValue = parsedQueryString[queryStringIdentityParam];
+  let queryStringValue = parsedQueryString[queryStringIdentityParam];
   if (queryStringValue === undefined) {
     return;
   }
+  if (Array.isArray(queryStringValue)) {
+    logger.warn("Found multiple adobe_mc query string paramters, only using the last one.");
+    queryStringValue = queryStringValue[queryStringValue.length - 1];
+  }
   const properties = queryStringValue.split("|").reduce((memo, keyValue) => {
     const [key, value] = keyValue.split("=");
     memo[key] = value;

package/libEs6/components/Identity/injectAwaitIdentityCookie.js

@@ -12,7 +12,8 @@ governing permissions and limitations under the License.
 
 export default (({
   doesIdentityCookieExist,
-  orgId
+  orgId,
+  logger
 }) => {
   /**
    * Returns a promise that will be resolved once an identity cookie exists.
@@ -30,16 +31,11 @@ export default (({
         } else {
           // This logic assumes that the code setting the cookie is working as expected and that
           // the cookie was missing from the response.
-          const noIdentityCookieError = new Error(`An identity was not set properly. Please verify that the org ID ${orgId} configured in Alloy matches the org ID specified in the edge configuration.`);
+          logger.warn(`Identity cookie not found. This could be caused by any of the following issues:\n` + `\t* The org ID ${orgId} configured in Alloy doesn't match the org ID specified in the edge configuration.\n` + `\t* Experience edge was not able to set the identity cookie due to domain or cookie restrictions.\n` + `\t* The request was canceled by the browser and not fully processed.`);
 
-          // Rejecting the promise will reject commands that were queued
-          // by the Identity component while waiting on the response to
-          // the initial request.
-          reject(noIdentityCookieError);
-
-          // Throwing an error will reject the event command that initiated
-          // the request.
-          throw noIdentityCookieError;
+          // Rejecting the promise will tell queued events to still go out
+          // one at a time.
+          reject(new Error("Identity cookie not found."));
         }
       });
       onRequestFailure(() => {
@@ -48,7 +44,7 @@ export default (({
         } else {
           // The error from the request failure will be logged separately. Rejecting this here
           // will tell ensureSingleIdentity to send the next request without identity
-          reject(new Error("No identity was set on response."));
+          reject(new Error("Identity cookie not found."));
         }
       });
     });

package/libEs6/components/Identity/injectEnsureSingleIdentity.js

@@ -55,9 +55,8 @@ export default (({
     if (obtainedIdentityPromise) {
       // We don't have an identity cookie, but at least one request has
       // been sent to get it. Konductor may set the identity cookie in the
-      // response. We will hold up this request until the last request
-      // requiring identity returns and awaitIdentityCookie confirms the
-      // identity was set.
+      // response. We will hold up this request until the previous request
+      // returns and awaitIdentityCookie confirms the identity was set.
       logger.info("Delaying request while retrieving ECID from server.");
       const previousObtainedIdentityPromise = obtainedIdentityPromise;
 
@@ -92,6 +91,8 @@ export default (({
       onResponse,
       onRequestFailure
     });
+    // This prevents an un-caught promise in the console when the identity isn't set.
+    obtainedIdentityPromise.catch(() => undefined);
     return allowRequestToGoWithoutIdentity(request);
   };
 });

package/libEs6/components/LegacyMediaAnalytics/{media → constants}/constants.js

@@ -10,11 +10,11 @@ OF ANY KIND, either express or implied. See the License for the specific languag
 governing permissions and limitations under the License.
 */
 
-export const MediaType = {
+export const MEDIA_TYPE = {
   Video: "video",
   Audio: "audio"
 };
-export const StreamType = {
+export const STREAM_TYPE = {
   VOD: "vod",
   Live: "live",
   Linear: "linear",
@@ -22,14 +22,14 @@ export const StreamType = {
   Audiobook: "audiobook",
   AOD: "aod"
 };
-export const PlayerState = {
+export const PLAYER_STATE = {
   FullScreen: "fullScreen",
   ClosedCaption: "closedCaptioning",
   Mute: "mute",
   PictureInPicture: "pictureInPicture",
   InFocus: "inFocus"
 };
-export const Event = {
+export const EVENT = {
   /**
    * Constant defining event type for AdBreak start
    */
@@ -91,19 +91,20 @@ export const Event = {
    */
   StateEnd: "stateEnd"
 };
-export const mediaEvent = {
+export const MEDIA_EVENTS_INTERNAL = {
   SessionStart: "sessionStart",
   SessionEnd: "sessionEnd",
   SessionComplete: "sessionComplete",
   Play: "play",
   Pause: "pauseStart",
-  ...Event
+  Error: "error",
+  StateUpdate: "statesUpdate"
 };
-export const MediaObjectKey = {
+export const MEDIA_OBJECT_KEYS = {
   MediaResumed: "media.resumed",
   GranularAdTracking: "media.granularadtracking"
 };
-export const VideoMetadataKeys = {
+export const VIDEO_METADATA_KEYS = {
   Show: "a.media.show",
   Season: "a.media.season",
   Episode: "a.media.episode",
@@ -122,7 +123,7 @@ export const VideoMetadataKeys = {
   Feed: "a.media.feed",
   StreamFormat: "a.media.format"
 };
-export const AudioMetadataKeys = {
+export const AUDIO_METADATA_KEYS = {
   Artist: "a.media.artist",
   Album: "a.media.album",
   Label: "a.media.label",
@@ -130,7 +131,7 @@ export const AudioMetadataKeys = {
   Station: "a.media.station",
   Publisher: "a.media.publisher"
 };
-export const AdMetadataKeys = {
+export const AD_METADATA_KEYS = {
   Advertiser: "a.media.ad.advertiser",
   CampaignId: "a.media.ad.campaign",
   CreativeId: "a.media.ad.creative",