@adobe/alloy 2.34.2-beta.3 → 2.35.0

package/dist/alloy.js

@@ -104,7 +104,7 @@
   /**
    * Takes a base64 string of bytes and returns a Uint8Array.
    * @param {string} base64String
-   * @returns {Uint8Array}
+   * @returns {Uint8Array<ArrayBuffer>}
    */
   const base64ToBytes = (base64String) => {
     // Add padding if needed
@@ -114,7 +114,7 @@
     const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");
 
     const binString = atob(base64);
-    return Uint8Array.from(binString, (m) => m.codePointAt(0));
+    return Uint8Array.from(binString, (m) => m.codePointAt(0) ?? 0);
   };
 
   /**
@@ -2284,13 +2284,19 @@
   governing permissions and limitations under the License.
   */
 
+  /** @import { ValidatorFn } from './types.js' */
+
   /**
    * Wraps a validator returning the value if it is null or undefined, otherwise
    * it will call the original validator and return the result.
    *
-   * @param {function} validator - the validator to call if the value is not null
+   * @param {ValidatorFn} validator - the validator to call if the value is not null
+   * @returns {ValidatorFn}
    */
   const skipIfNull = (validator) =>
+    /**
+     * @this {any}
+     */
     function skipIfNullValidator(value, path) {
       return value == null ? value : validator.call(this, value, path);
     };
@@ -2300,11 +2306,14 @@
    * validator with the result of the first validator. The result of the second validator
    * is returned.
    *
-   * @param {function} firstValidator - validator to call first
-   * @param {function} secondValidator - validator to call second
-   * @returns {function} - a new validator that calls the first and second validators
+   * @param {ValidatorFn} firstValidator - validator to call first
+   * @param {ValidatorFn} secondValidator - validator to call second
+   * @returns {ValidatorFn} - a new validator that calls the first and second validators
    */
   const callSequentially = (firstValidator, secondValidator) =>
+    /**
+     * @this {any}
+     */
     function callSequentiallyValidator(value, path) {
       return secondValidator.call(
         this,
@@ -2317,12 +2326,16 @@
    * Just like callSequentially, but if either validator throws an error, the errors
    * are collected and thrown at the end.
    *
-   * @param {function} firstValidator
-   * @param {function} secondValidator
-   * @returns {function}
+   * @param {ValidatorFn} firstValidator
+   * @param {ValidatorFn} secondValidator
+   * @returns {ValidatorFn}
    */
   const callSequentiallyJoinErrors = (firstValidator, secondValidator) =>
+    /**
+     * @this {any}
+     */
     function callSequentiallyJoinErrorsValidator(value, path) {
+      /** @type {unknown[]} */
       const errors = [];
       const newValue = [firstValidator, secondValidator].reduce(
         (memo, validator) => {
@@ -2346,12 +2359,12 @@
    * sequence, this will also copy over methods from the base validator to the
    * resulting validator and include any additional methods.
    *
-   * @param {function} baseValidator - This validator will be called first, and its
+   * @param {ValidatorFn} baseValidator - This validator will be called first, and its
    * methods will be copied over to the returned validator.
-   * @param {function} newValidator - This validator will be called second.
-   * @param {object} additionalMethods - Additional methods to include on the returned
+   * @param {ValidatorFn} newValidator - This validator will be called second.
+   * @param {object} [additionalMethods] - Additional methods to include on the returned
    * validator.
-   * @returns {function}
+   * @returns {ValidatorFn}
    */
   const chain = (baseValidator, newValidator, additionalMethods) => {
     return Object.assign(
@@ -2367,14 +2380,14 @@
    * copy over methods from the base validator to the resulting validator and
    * include any additional methods.
    *
-   * @param {function} baseValidator - This validator will be called first, and its
+   * @param {ValidatorFn} baseValidator - This validator will be called first, and its
    * methods will be copied over to the returned validator.
-   * @param {function} newValidator - This validator will be called second. If the value
+   * @param {ValidatorFn} newValidator - This validator will be called second. If the value
    * is null after the first validator is called, this validator will not be
    * called.
-   * @param {object} additionalMethods - Additional methods to include on the returned
+   * @param {object} [additionalMethods] - Additional methods to include on the returned
    * validator.
-   * @returns {function}
+   * @returns {ValidatorFn}
    */
   const nullSafeChain = (
     baseValidator,
@@ -2391,13 +2404,13 @@
   /**
    * Same as nullSafeChain, but calls the new validator first.
    *
-   * @param {function} baseValidator - This validator will be called second, and its
+   * @param {ValidatorFn} baseValidator - This validator will be called second, and its
    * methods will be copied over to the returned validator.
-   * @param {function} newValidator - This validator will be called first. If the value
+   * @param {ValidatorFn} newValidator - This validator will be called first. If the value
    * is null, this validator will not be called.
-   * @param {function} additionalMethods - Additional methods to include on the returned
+   * @param {object} [additionalMethods] - Additional methods to include on the returned
    * validator.
-   * @returns {function}
+   * @returns {ValidatorFn}
    */
   const reverseNullSafeChainJoinErrors = (
     baseValidator,
@@ -3047,135 +3060,310 @@
 
 
   // The base validator does no validation and just returns the value unchanged
-  const base = (value) => value;
+  const base = /** @type {AnyValidator} */ ((value) => value);
 
   // The 'default', 'required', and 'deprecated' methods are available after any
   // data-type method. Don't use the nullSafeChain on 'default' or 'required'
   // because they need to handle the null or undefined case
+  /**
+   * @this {AnyValidator}
+   * @param {any} defaultValue
+   * @returns {AnyValidator}
+   */
   base.default = function _default(defaultValue) {
-    return chain(this, createDefaultValidator(defaultValue));
+    return /** @type {AnyValidator} */ (
+      chain(this, createDefaultValidator(defaultValue))
+    );
   };
+  /**
+   * @this {AnyValidator}
+   * @returns {AnyValidator}
+   */
   base.required = function required() {
-    return chain(this, requiredValidator);
+    return /** @type {AnyValidator} */ (chain(this, requiredValidator));
   };
+  /**
+   * @this {AnyValidator}
+   * @param {string} message
+   * @returns {AnyValidator}
+   */
   base.deprecated = function deprecated(message) {
-    return chain(this, createDeprecatedValidator(message));
+    return /** @type {AnyValidator} */ (
+      chain(this, createDeprecatedValidator(message))
+    );
   };
 
   // helper validators
+  /**
+   * @this {StringValidator}
+   * @returns {StringValidator}
+   */
   const domain = function domain() {
-    return nullSafeChain(this, domainValidator);
+    return /** @type {StringValidator} */ (nullSafeChain(this, domainValidator));
   };
+  /**
+   * @this {NumberValidator}
+   * @param {number} minValue
+   * @returns {NumberValidator}
+   */
   const minimumInteger = function minimumInteger(minValue) {
-    return nullSafeChain(this, createMinimumValidator("an integer", minValue));
+    return /** @type {NumberValidator} */ (
+      nullSafeChain(this, createMinimumValidator("an integer", minValue))
+    );
   };
+  /**
+   * @this {NumberValidator}
+   * @param {number} minValue
+   * @returns {NumberValidator}
+   */
   const minimumNumber = function minimumNumber(minValue) {
-    return nullSafeChain(this, createMinimumValidator("a number", minValue));
+    return /** @type {NumberValidator} */ (
+      nullSafeChain(this, createMinimumValidator("a number", minValue))
+    );
   };
+  /**
+   * @this {NumberValidator}
+   * @param {number} maxValue
+   * @returns {NumberValidator}
+   */
   const maximumNumber = function maximumNumber(maxValue) {
-    return nullSafeChain(this, createMaximumValidator("a number", maxValue));
+    return /** @type {NumberValidator} */ (
+      nullSafeChain(this, createMaximumValidator("a number", maxValue))
+    );
   };
+  /**
+   * @this {NumberValidator}
+   * @returns {NumberValidator}
+   */
   const integer = function integer() {
-    return nullSafeChain(this, integerValidator, { minimum: minimumInteger });
+    return /** @type {NumberValidator} */ (
+      nullSafeChain(this, integerValidator, { minimum: minimumInteger })
+    );
   };
+  /**
+   * @this {StringValidator}
+   * @returns {StringValidator}
+   */
   const nonEmptyString = function nonEmptyString() {
-    return nullSafeChain(this, createNonEmptyValidator("a non-empty string"));
+    return /** @type {StringValidator} */ (
+      nullSafeChain(this, createNonEmptyValidator("a non-empty string"))
+    );
   };
+  /**
+   * @this {ArrayValidator}
+   * @returns {ArrayValidator}
+   */
   const nonEmptyArray = function nonEmptyArray() {
-    return nullSafeChain(this, createNonEmptyValidator("a non-empty array"));
+    return /** @type {ArrayValidator} */ (
+      nullSafeChain(this, createNonEmptyValidator("a non-empty array"))
+    );
   };
+  /**
+   * @this {MapOfValuesValidator | ObjectValidator}
+   * @returns {MapOfValuesValidator & ObjectValidator}
+   */
   const nonEmptyObject = function nonEmptyObject() {
-    return nullSafeChain(this, createNonEmptyValidator("a non-empty object"));
+    return /** @type {MapOfValuesValidator & ObjectValidator} */ (
+      nullSafeChain(this, createNonEmptyValidator("a non-empty object"))
+    );
   };
+  /**
+   * @this {StringValidator}
+   * @returns {StringValidator}
+   */
   const regexp = function regexp() {
-    return nullSafeChain(this, regexpValidator);
+    return /** @type {StringValidator} */ (nullSafeChain(this, regexpValidator));
   };
+  /**
+   * @this {StringValidator}
+   * @param {RegExp} regexpPattern
+   * @returns {StringValidator}
+   */
   const matches = function matches(regexpPattern) {
-    return nullSafeChain(this, matchesRegexpValidator(regexpPattern));
+    return /** @type {StringValidator} */ (
+      nullSafeChain(this, matchesRegexpValidator(regexpPattern))
+    );
   };
+  /**
+   * @this {NumberValidator | StringValidator}
+   * @returns {NumberValidator & StringValidator}
+   */
   const unique = function createUnique() {
-    return nullSafeChain(this, createUniqueValidator());
+    return /** @type {NumberValidator & StringValidator} */ (
+      nullSafeChain(this, createUniqueValidator())
+    );
   };
+  /**
+   * @this {ArrayValidator}
+   * @returns {ArrayValidator}
+   */
   const uniqueItems = function createUniqueItems() {
-    return nullSafeChain(this, createUniqueItemsValidator());
+    return /** @type {ArrayValidator} */ (
+      nullSafeChain(this, createUniqueItemsValidator())
+    );
   };
 
   // top-level validators.  These are the first functions that are called to create a validator.
+  /**
+   * @this {AnyValidator}
+   * @param {ValidatorFn[]} validators
+   * @param {string} [message]
+   * @returns {AnyValidator}
+   */
   const anyOf = function anyOf(validators, message) {
     // use chain here because we don't want to accept null or undefined unless at least
     // one of the validators accept null or undefined.
-    return chain(this, createAnyOfValidator(validators, message));
+    return /** @type {AnyValidator} */ (
+      chain(this, createAnyOfValidator(validators, message))
+    );
   };
+  /**
+   * @this {AnyValidator}
+   * @returns {AnyValidator}
+   */
   const anything = function anything() {
     return this;
   };
+  /**
+   * @this {AnyValidator}
+   * @param {ValidatorFn} elementValidator
+   * @returns {ArrayValidator}
+   */
   const arrayOf = function arrayOf(elementValidator) {
-    return nullSafeChain(this, createArrayOfValidator(elementValidator), {
-      nonEmpty: nonEmptyArray,
-      uniqueItems,
-    });
+    return /** @type {ArrayValidator} */ (
+      nullSafeChain(this, createArrayOfValidator(elementValidator), {
+        nonEmpty: nonEmptyArray,
+        uniqueItems,
+      })
+    );
   };
+  /**
+   * @this {AnyValidator}
+   * @returns {AnyValidator}
+   */
   const boolean = function boolean() {
-    return nullSafeChain(this, booleanValidator);
+    return /** @type {AnyValidator} */ (nullSafeChain(this, booleanValidator));
   };
+  /**
+   * @this {AnyValidator}
+   * @returns {AnyValidator}
+   */
   const callback = function callback() {
-    return nullSafeChain(this, callbackValidator);
+    return /** @type {AnyValidator} */ (nullSafeChain(this, callbackValidator));
   };
+  /**
+   * @this {AnyValidator}
+   * @param {any} literalValue
+   * @returns {AnyValidator}
+   */
   const literal = function literal(literalValue) {
-    return nullSafeChain(this, createLiteralValidator(literalValue));
+    return /** @type {AnyValidator} */ (
+      nullSafeChain(this, createLiteralValidator(literalValue))
+    );
   };
+  /**
+   * @this {AnyValidator}
+   * @returns {NumberValidator}
+   */
   const number = function number() {
-    return nullSafeChain(this, numberValidator, {
-      minimum: minimumNumber,
-      maximum: maximumNumber,
-      integer,
-      unique,
-    });
+    return /** @type {NumberValidator} */ (
+      nullSafeChain(this, numberValidator, {
+        minimum: minimumNumber,
+        maximum: maximumNumber,
+        integer,
+        unique,
+      })
+    );
   };
+  /**
+   * @this {AnyValidator}
+   * @param {ValidatorFn} valuesValidator
+   * @returns {MapOfValuesValidator}
+   */
   const mapOfValues = function mapOfValues(valuesValidator) {
-    return nullSafeChain(this, createMapOfValuesValidator(valuesValidator), {
-      nonEmpty: nonEmptyObject,
-    });
+    return /** @type {MapOfValuesValidator} */ (
+      nullSafeChain(this, createMapOfValuesValidator(valuesValidator), {
+        nonEmpty: nonEmptyObject,
+      })
+    );
   };
+  /**
+   * @param {ObjectValidatorSchema} schema
+   */
   const createObjectOfAdditionalProperties = (schema) => ({
+    /**
+     * @this {ObjectValidator}
+     * @returns {ObjectValidator}
+     */
     noUnknownFields: function noUnknownFields() {
-      return nullSafeChain(this, createNoUnknownFieldsValidator(schema));
+      return /** @type {ObjectValidator} */ (
+        nullSafeChain(this, createNoUnknownFieldsValidator(schema))
+      );
     },
     nonEmpty: nonEmptyObject,
+    /**
+     * @this {ObjectValidator}
+     * @param {ObjectValidator} otherObjectOfValidator
+     * @returns {ObjectValidator}
+     */
     concat: function concat(otherObjectOfValidator) {
       // combine the schema so that noUnknownFields, and concat have the combined schema
       const newSchema = { ...schema, ...otherObjectOfValidator.schema };
-      return nullSafeChain(
-        this,
-        otherObjectOfValidator,
-        createObjectOfAdditionalProperties(newSchema),
+      return /** @type {ObjectValidator} */ (
+        nullSafeChain(
+          this,
+          otherObjectOfValidator,
+          createObjectOfAdditionalProperties(newSchema),
+        )
       );
     },
+    /**
+     * @this {ObjectValidator}
+     * @param {string} oldField
+     * @param {ValidatorFn} oldSchema
+     * @param {string} newField
+     * @returns {ObjectValidator}
+     */
     renamed: function renamed(oldField, oldSchema, newField) {
       // Run the deprecated validator first so that the deprecated field is removed
       // before the objectOf validator runs.
-      return reverseNullSafeChainJoinErrors(
-        this,
-        createRenamedValidator(oldField, oldSchema, newField),
+      return /** @type {ObjectValidator} */ (
+        reverseNullSafeChainJoinErrors(
+          this,
+          createRenamedValidator(oldField, oldSchema, newField),
+        )
       );
     },
     schema,
   });
+  /**
+   * @this {AnyValidator}
+   * @param {ObjectValidatorSchema} schema
+   * @returns {ObjectValidator}
+   */
   const objectOf = function objectOf(schema) {
-    return nullSafeChain(
-      this,
-      createObjectOfValidator(schema),
-      createObjectOfAdditionalProperties(schema),
+    return /** @type {ObjectValidator} */ (
+      nullSafeChain(
+        this,
+        createObjectOfValidator(schema),
+        createObjectOfAdditionalProperties(schema),
+      )
     );
   };
+  /**
+   * @this {AnyValidator}
+   * @returns {StringValidator}
+   */
   const string = function string() {
-    return nullSafeChain(this, stringValidator, {
-      regexp,
-      domain,
-      nonEmpty: nonEmptyString,
-      unique,
-      matches,
-    });
+    return /** @type {StringValidator} */ (
+      nullSafeChain(this, stringValidator, {
+        regexp,
+        domain,
+        nonEmpty: nonEmptyString,
+        unique,
+        matches,
+      })
+    );
   };
 
   const boundAnyOf = anyOf.bind(base);
@@ -3190,6 +3378,10 @@
   const boundString = string.bind(base);
 
   // compound validators
+  /**
+   * @param {...any} values
+   * @returns {AnyValidator}
+   */
   const boundEnumOf = function boundEnumOf(...values) {
     return boundAnyOf(
       values.map(boundLiteral),
@@ -7554,10 +7746,10 @@
   governing permissions and limitations under the License.
   */
 
-  // The 2.34.2-beta.3 keyword will be replace at alloy build time with the package.json version.
+  // The 2.35.0 keyword will be replace at alloy build time with the package.json version.
   // see babel-plugin-version
 
-  var libraryVersion = "2.34.2-beta.3";
+  var libraryVersion = "2.35.0";
 
   /*
   Copyright 2019 Adobe. All rights reserved.
@@ -20502,8 +20694,7 @@
       throw new Error("Push notifications are not supported in this browser.");
     }
 
-    /** @type {object} */
-    const notification = window.Notification;
+    const notification = /** @type {typeof Notification} */ (window.Notification);
     if (notification.permission !== "granted") {
       throw new Error(
         "The user has not given permission to send push notifications.",
@@ -20548,15 +20739,18 @@
           subscriptionOptions,
         );
 
+      const p256dhKey = subscription.getKey("p256dh");
+      const authKey = subscription.getKey("auth");
+
       return {
         endpoint: subscription.endpoint,
         keys: {
-          p256dh: bytesToBase64(new Uint8Array(subscription.getKey("p256dh")), {
-            urlSafe: true,
-          }),
-          auth: bytesToBase64(new Uint8Array(subscription.getKey("auth")), {
-            urlSafe: true,
-          }),
+          p256dh: p256dhKey
+            ? bytesToBase64(new Uint8Array(p256dhKey), { urlSafe: true })
+            : null,
+          auth: authKey
+            ? bytesToBase64(new Uint8Array(authKey), { urlSafe: true })
+            : null,
         },
       };
     } catch (e) {
@@ -20774,7 +20968,7 @@
 
 
   /**
-   * @param {Object} data
+   * @param {Partial<PushServiceWorkerConfig>} data
    * @param {Logger} logger
    *
    * @returns {Promise<boolean>} Whether the data was successfully saved.
@@ -20853,6 +21047,7 @@
    * @param {EdgeRequestExecutor} options.sendEdgeNetworkRequest
    * @param {ConsentManager} options.consent
    * @param {Window} options.window
+   * @param {typeof getPushSubscriptionDetailsDefault} [options.getPushSubscriptionDetails]
    *
    * @returns {Promise<void>}
    */
@@ -20936,6 +21131,10 @@
   */
 
 
+  /**
+   * @param {{ orgId?: string, pushNotifications?: { vapidPublicKey?: string, appId?: string, trackingDatasetId?: string } }} config
+   * @returns {boolean}
+   */
   const isComponentConfigured = ({
     orgId,
     pushNotifications: { vapidPublicKey, appId, trackingDatasetId } = {
@@ -20943,7 +21142,7 @@
       appId: undefined,
       trackingDatasetId: undefined,
     },
-  }) => orgId && vapidPublicKey && appId && trackingDatasetId;
+  }) => Boolean(orgId && vapidPublicKey && appId && trackingDatasetId);
 
   /**
    * @function
@@ -21001,11 +21200,8 @@
 
             const {
               orgId,
-              pushNotifications: { vapidPublicKey, appId } = {
-                vapidPublicKey: undefined,
-                appId: undefined,
-              },
-            } = config || {};
+              pushNotifications: { vapidPublicKey, appId },
+            } = config;
 
             const storage = platformServices.storage.createNamespacedStorage(
               `${sanitizeOrgIdForCookieName(orgId)}.pushNotifications.`,
@@ -21425,7 +21621,7 @@
 
       // Allow customers to explicitly set the referrer (for SPA view changes)
       // Otherwise, use document.referrer
-      // eslint-disable-next-line no-underscore-dangle
+
       const explicitReferrer = content.data?.__adobe?.analytics?.referrer;
       const currentReferrer =
         explicitReferrer !== undefined