@adobe/alloy 2.34.2-beta.2 → 2.35.0-beta.4

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),
@@ -6667,7 +6859,9 @@
           // so that sendBeacon requests don't override the edge info from before.
           edge = { ...edge, ...response.getEdge() };
 
-          identity.setIdentityAcquired();
+          if (identity.getEcidFromCookie()) {
+            identity.setIdentityAcquired();
+          }
 
           return handleResponseForIdSyncs(response);
         },
@@ -7552,10 +7746,10 @@
   governing permissions and limitations under the License.
   */
 
-  // The 2.34.2-beta.2 keyword will be replace at alloy build time with the package.json version.
+  // The 2.35.0-beta.4 keyword will be replace at alloy build time with the package.json version.
   // see babel-plugin-version
 
-  var libraryVersion = "2.34.2-beta.2";
+  var libraryVersion = "2.35.0-beta.4";
 
   /*
   Copyright 2019 Adobe. All rights reserved.
@@ -20500,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.",
@@ -20546,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) {
@@ -20772,10 +20968,10 @@
 
 
   /**
-   * @param {Object} data
+   * @param {Partial<PushServiceWorkerConfig>} data
    * @param {Logger} logger
    *
-   * @returns {Promise<void>}
+   * @returns {Promise<boolean>} Whether the data was successfully saved.
    */
   async function saveToIndexedDB(data, logger) {
     try {
@@ -20809,8 +21005,12 @@
         "Successfully saved web SDK config to IndexedDB",
         updatedConfigData,
       );
+
+      return true;
     } catch (error) {
       logger.error("Failed to save config to IndexedDB", { error });
+
+      return false;
     }
   }
 
@@ -20847,6 +21047,7 @@
    * @param {EdgeRequestExecutor} options.sendEdgeNetworkRequest
    * @param {ConsentManager} options.consent
    * @param {Window} options.window
+   * @param {typeof getPushSubscriptionDetailsDefault} [options.getPushSubscriptionDetails]
    *
    * @returns {Promise<void>}
    */
@@ -20864,6 +21065,14 @@
     await identity.awaitIdentity();
     const ecid = identity.getEcidFromCookie();
 
+    if (!ecid) {
+      logger.info(
+        "No ECID is available. Not sending push subscription details to the server.",
+      );
+
+      return;
+    }
+
     const pushSubscriptionDetails = await getPushSubscriptionDetails$1({
       vapidPublicKey,
       window,
@@ -20876,7 +21085,7 @@
     const cacheValue = `${ecid}${serializedPushSubscriptionDetails}`;
     const storedValue = await storage.getItem(SUBSCRIPTION_DETAILS);
 
-    if (cacheValue === storedValue) {
+    if (storedValue && cacheValue === storedValue) {
       logger.info(
         "Subscription details have not changed. Not sending to the server.",
       );
@@ -20884,8 +21093,6 @@
       return;
     }
 
-    storage.setItem(SUBSCRIPTION_DETAILS, cacheValue);
-
     const payload = await createSendPushSubscriptionPayload({
       eventManager,
       ecid,
@@ -20900,7 +21107,15 @@
     await consent.awaitConsent();
     await sendEdgeNetworkRequest({ request });
 
-    await saveToIndexedDB({ ecid }, logger);
+    const savedToIndexedDb = await saveToIndexedDB({ ecid }, logger);
+
+    // Only cache the subscription details once the ECID has been persisted, so
+    // that a failed send or a failed IndexedDB write does not short-circuit the
+    // dedupe check on the next call. This lets a subsequent sendPushSubscription
+    // self-heal instead of getting stuck with a cached subscription but no ECID.
+    if (savedToIndexedDb) {
+      storage.setItem(SUBSCRIPTION_DETAILS, cacheValue);
+    }
   };
 
   /*
@@ -20916,6 +21131,10 @@
   */
 
 
+  /**
+   * @param {{ orgId?: string, pushNotifications?: { vapidPublicKey?: string, appId?: string, trackingDatasetId?: string } }} config
+   * @returns {boolean}
+   */
   const isComponentConfigured = ({
     orgId,
     pushNotifications: { vapidPublicKey, appId, trackingDatasetId } = {
@@ -20923,7 +21142,7 @@
       appId: undefined,
       trackingDatasetId: undefined,
     },
-  }) => orgId && vapidPublicKey && appId && trackingDatasetId;
+  }) => Boolean(orgId && vapidPublicKey && appId && trackingDatasetId);
 
   /**
    * @function
@@ -20981,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.`,