@angular/core 18.0.0-rc.1 → 18.0.0-rc.3

package/fesm2022/primitives/event-dispatch.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v18.0.0-rc.1
+ * @license Angular v18.0.0-rc.3
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -80,6 +80,14 @@ function getA11yClickKey(eventInfo) {
 function setA11yClickKey(eventInfo, a11yClickKey) {
     eventInfo.eiack = a11yClickKey;
 }
+/** Added for readability when accessing stable property names. */
+function getResolved(eventInfo) {
+    return eventInfo.eir;
+}
+/** Added for readability when accessing stable property names. */
+function setResolved(eventInfo, resolved) {
+    eventInfo.eir = resolved;
+}
 /** Clones an `EventInfo` */
 function cloneEventInfo(eventInfo) {
     return {
@@ -91,6 +99,7 @@ function cloneEventInfo(eventInfo) {
         timeStamp: eventInfo.timeStamp,
         eirp: eventInfo.eirp,
         eiack: eventInfo.eiack,
+        eir: eventInfo.eir,
     };
 }
 /**
@@ -191,171 +200,15 @@ class EventInfoWrapper {
     setIsReplay(replay) {
         setIsReplay(this.eventInfo, replay);
     }
-    clone() {
-        return new EventInfoWrapper(cloneEventInfo(this.eventInfo));
-    }
-}
-
-/**
- * @fileoverview An enum to control who can call certain jsaction APIs.
- */
-var Restriction;
-(function (Restriction) {
-    Restriction[Restriction["I_AM_THE_JSACTION_FRAMEWORK"] = 1] = "I_AM_THE_JSACTION_FRAMEWORK";
-})(Restriction || (Restriction = {}));
-
-/**
- * Receives a DOM event, determines the jsaction associated with the source
- * element of the DOM event, and invokes the handler associated with the
- * jsaction.
- */
-class BaseDispatcher {
-    /**
-     * Options are:
-     *   1. `eventReplayer`: When the event contract dispatches replay events
-     *      to the Dispatcher, the Dispatcher collects them and in the next tick
-     *      dispatches them to the `eventReplayer`.
-     * @param dispatchDelegate A function that should handle dispatching an `EventInfoWrapper` to handlers.
-     */
-    constructor(dispatchDelegate, { eventReplayer = undefined } = {}) {
-        this.dispatchDelegate = dispatchDelegate;
-        /** The queue of events. */
-        this.queuedEventInfoWrappers = [];
-        /** Whether the event replay is scheduled. */
-        this.eventReplayScheduled = false;
-        this.eventReplayer = eventReplayer;
-    }
-    /**
-     * Receives an event or the event queue from the EventContract. The event
-     * queue is copied and it attempts to replay.
-     * If event info is passed in it looks for an action handler that can handle
-     * the given event.  If there is no handler registered queues the event and
-     * checks if a loader is registered for the given namespace. If so, calls it.
-     *
-     * Alternatively, if in global dispatch mode, calls all registered global
-     * handlers for the appropriate event type.
-     *
-     * The three functionalities of this call are deliberately not split into
-     * three methods (and then declared as an abstract interface), because the
-     * interface is used by EventContract, which lives in a different jsbinary.
-     * Therefore the interface between the three is defined entirely in terms that
-     * are invariant under jscompiler processing (Function and Array, as opposed
-     * to a custom type with method names).
-     *
-     * @param eventInfo The info for the event that triggered this call or the
-     *     queue of events from EventContract.
-     */
-    dispatch(eventInfo) {
-        const eventInfoWrapper = new EventInfoWrapper(eventInfo);
-        if (eventInfoWrapper.getIsReplay()) {
-            if (!this.eventReplayer) {
-                return;
-            }
-            this.queueEventInfoWrapper(eventInfoWrapper);
-            this.scheduleEventReplay();
-            return;
-        }
-        this.dispatchDelegate(eventInfoWrapper);
-    }
-    /** Queue an `EventInfoWrapper` for replay. */
-    queueEventInfoWrapper(eventInfoWrapper) {
-        this.queuedEventInfoWrappers.push(eventInfoWrapper);
-    }
-    /**
-     * Replays queued events, if any. The replaying will happen in its own
-     * stack once the current flow cedes control. This is done to mimic
-     * browser event handling.
-     */
-    scheduleEventReplay() {
-        if (this.eventReplayScheduled ||
-            !this.eventReplayer ||
-            this.queuedEventInfoWrappers.length === 0) {
-            return;
-        }
-        this.eventReplayScheduled = true;
-        Promise.resolve().then(() => {
-            this.eventReplayScheduled = false;
-            this.eventReplayer(this.queuedEventInfoWrappers);
-        });
-    }
-}
-/**
- * Registers deferred functionality for an EventContract and a Jsaction
- * Dispatcher.
- */
-function registerDispatcher$1(eventContract, dispatcher) {
-    eventContract.ecrd((eventInfo) => {
-        dispatcher.dispatch(eventInfo);
-    }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
-}
-
-const Char = {
-    /**
-     * The separator between the namespace and the action name in the
-     * jsaction attribute value.
-     */
-    NAMESPACE_ACTION_SEPARATOR: '.',
-    /**
-     * The separator between the event name and action in the jsaction
-     * attribute value.
-     */
-    EVENT_ACTION_SEPARATOR: ':',
-    /**
-     * The separator between the logged oi attribute values in the &oi=
-     * URL parameter value.
-     */
-    OI_SEPARATOR: '.',
-    /**
-     * The separator between the key and the value pairs in the &cad=
-     * URL parameter value.
-     */
-    CAD_KEY_VALUE_SEPARATOR: ':',
-    /**
-     * The separator between the key-value pairs in the &cad= URL
-     * parameter value.
-     */
-    CAD_SEPARATOR: ',',
-};
-
-/**
- * Determines if one node is contained within another. Adapted from
- * {@see goog.dom.contains}.
- * @param node Node that should contain otherNode.
- * @param otherNode Node being contained.
- * @return True if otherNode is contained within node.
- */
-function contains(node, otherNode) {
-    if (otherNode === null) {
-        return false;
-    }
-    // We use browser specific methods for this if available since it is faster
-    // that way.
-    // IE DOM
-    if ('contains' in node && otherNode.nodeType === 1) {
-        return node.contains(otherNode);
-    }
-    // W3C DOM Level 3
-    if ('compareDocumentPosition' in node) {
-        return node === otherNode || Boolean(node.compareDocumentPosition(otherNode) & 16);
+    getResolved() {
+        return getResolved(this.eventInfo);
     }
-    // W3C DOM Level 1
-    while (otherNode && node !== otherNode) {
-        otherNode = otherNode.parentNode;
+    setResolved(resolved) {
+        setResolved(this.eventInfo, resolved);
     }
-    return otherNode === node;
-}
-/**
- * Helper method for broadcastCustomEvent. Returns true if any member of
- * the set is an ancestor of element.
- */
-function hasAncestorInNodeList(element, nodeList) {
-    for (let idx = 0; idx < nodeList.length; ++idx) {
-        const member = nodeList[idx];
-        if (member !== element && contains(member, element)) {
-            return true;
-        }
+    clone() {
+        return new EventInfoWrapper(cloneEventInfo(this.eventInfo));
     }
-    return false;
 }
 
 /*
@@ -595,19 +448,66 @@ const EventType = {
     CUSTOM: '_custom',
 };
 
+/**
+ * @fileoverview An enum to control who can call certain jsaction APIs.
+ */
+var Restriction;
+(function (Restriction) {
+    Restriction[Restriction["I_AM_THE_JSACTION_FRAMEWORK"] = 0] = "I_AM_THE_JSACTION_FRAMEWORK";
+})(Restriction || (Restriction = {}));
+
+/**
+ * Determines if one node is contained within another. Adapted from
+ * {@see goog.dom.contains}.
+ * @param node Node that should contain otherNode.
+ * @param otherNode Node being contained.
+ * @return True if otherNode is contained within node.
+ */
+function contains(node, otherNode) {
+    if (otherNode === null) {
+        return false;
+    }
+    // We use browser specific methods for this if available since it is faster
+    // that way.
+    // IE DOM
+    if ('contains' in node && otherNode.nodeType === 1) {
+        return node.contains(otherNode);
+    }
+    // W3C DOM Level 3
+    if ('compareDocumentPosition' in node) {
+        return node === otherNode || Boolean(node.compareDocumentPosition(otherNode) & 16);
+    }
+    // W3C DOM Level 1
+    while (otherNode && node !== otherNode) {
+        otherNode = otherNode.parentNode;
+    }
+    return otherNode === node;
+}
+/**
+ * Helper method for broadcastCustomEvent. Returns true if any member of
+ * the set is an ancestor of element.
+ */
+function hasAncestorInNodeList(element, nodeList) {
+    for (let idx = 0; idx < nodeList.length; ++idx) {
+        const member = nodeList[idx];
+        if (member !== element && contains(member, element)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * If on a Macintosh with an extended keyboard, the Enter key located in the
+ * numeric pad has a different ASCII code.
+ */
+const MAC_ENTER = 3;
+/** The Enter key. */
+const ENTER = 13;
+/** The Space key. */
+const SPACE = 32;
 /** Special keycodes used by jsaction for the generic click action. */
-var KeyCode;
-(function (KeyCode) {
-    /**
-     * If on a Macintosh with an extended keyboard, the Enter key located in the
-     * numeric pad has a different ASCII code.
-     */
-    KeyCode[KeyCode["MAC_ENTER"] = 3] = "MAC_ENTER";
-    /** The Enter key. */
-    KeyCode[KeyCode["ENTER"] = 13] = "ENTER";
-    /** The Space key. */
-    KeyCode[KeyCode["SPACE"] = 32] = "SPACE";
-})(KeyCode || (KeyCode = {}));
+const KeyCode = { MAC_ENTER, ENTER, SPACE };
 
 /**
  * Gets a browser event type, if it would differ from the JSAction event type.
@@ -691,7 +591,7 @@ function removeEventListener(element, info) {
  * Cancels propagation of an event.
  * @param e The event to cancel propagation for.
  */
-function stopPropagation$1(e) {
+function stopPropagation(e) {
     e.stopPropagation ? e.stopPropagation() : (e.cancelBubble = true);
 }
 /**
@@ -1244,32 +1144,20 @@ const testing = {
  */
 class Dispatcher {
     /**
-     * Receives a DOM event, determines the jsaction associated with the source
-     * element of the DOM event, and invokes the handler associated with the
-     * jsaction.
-     *
-     * @param getHandler A function that knows how to get the handler for a
-     *     given event info.
+     * Options are:
+     *   - `eventReplayer`: When the event contract dispatches replay events
+     *      to the Dispatcher, the Dispatcher collects them and in the next tick
+     *      dispatches them to the `eventReplayer`. Defaults to dispatching to `dispatchDelegate`.
+     * @param dispatchDelegate A function that should handle dispatching an `EventInfoWrapper` to handlers.
      */
-    constructor(getHandler, { stopPropagation = false, eventReplayer = undefined, } = {}) {
-        this.getHandler = getHandler;
-        /**
-         * The actions that are registered for this Dispatcher instance.
-         * This should be the primary one used once migration off of registerHandlers
-         * is done.
-         */
-        this.actions = {};
-        /** A map of global event handlers, where each key is an event type. */
-        this.globalHandlers = new Map();
+    constructor(dispatchDelegate, { actionResolver, eventReplayer = createEventReplayer(dispatchDelegate), } = {}) {
+        this.dispatchDelegate = dispatchDelegate;
+        /** Whether the event replay is scheduled. */
+        this.eventReplayScheduled = false;
+        /** The queue of events. */
+        this.replayEventInfoWrappers = [];
+        this.actionResolver = actionResolver;
         this.eventReplayer = eventReplayer;
-        this.baseDispatcher = new BaseDispatcher((eventInfoWrapper) => {
-            this.dispatchToHandler(eventInfoWrapper);
-        }, {
-            eventReplayer: (eventInfoWrappers) => {
-                this.eventReplayer?.(eventInfoWrappers, this);
-            },
-        });
-        this.stopPropagation = stopPropagation;
     }
     /**
      * Receives an event or the event queue from the EventContract. The event
@@ -1291,189 +1179,58 @@ class Dispatcher {
      * @param eventInfo The info for the event that triggered this call or the
      *     queue of events from EventContract.
      */
-    dispatch(eventInfo, isGlobalDispatch) {
-        this.baseDispatcher.dispatch(eventInfo);
-    }
-    /**
-     * Dispatches an `EventInfoWrapper`.
-     */
-    dispatchToHandler(eventInfoWrapper) {
-        if (this.globalHandlers.size) {
-            const globalEventInfoWrapper = eventInfoWrapper.clone();
-            // In some cases, `populateAction` will rewrite `click` events to
-            // `clickonly`. Revert back to a regular click, otherwise we won't be able
-            // to execute global event handlers registered on click events.
-            if (globalEventInfoWrapper.getEventType() === EventType.CLICKONLY) {
-                globalEventInfoWrapper.setEventType(EventType.CLICK);
-            }
-            // Skip everything related to jsaction handlers, and execute the global
-            // handlers.
-            const event = globalEventInfoWrapper.getEvent();
-            const eventTypeHandlers = this.globalHandlers.get(globalEventInfoWrapper.getEventType());
-            let shouldPreventDefault = false;
-            if (eventTypeHandlers) {
-                for (const handler of eventTypeHandlers) {
-                    if (handler(event) === false) {
-                        shouldPreventDefault = true;
-                    }
-                }
-            }
-            if (shouldPreventDefault) {
-                preventDefault(event);
-            }
-        }
+    dispatch(eventInfo) {
+        const eventInfoWrapper = new EventInfoWrapper(eventInfo);
+        this.actionResolver?.resolve(eventInfo);
         const action = eventInfoWrapper.getAction();
-        if (!action) {
-            return;
-        }
-        if (this.stopPropagation) {
-            stopPropagation(eventInfoWrapper);
-        }
-        let handler = undefined;
-        if (this.getHandler) {
-            handler = this.getHandler(eventInfoWrapper);
+        if (action && shouldPreventDefaultBeforeDispatching(action.element, eventInfoWrapper)) {
+            preventDefault(eventInfoWrapper.getEvent());
         }
-        if (!handler) {
-            handler = this.actions[action.name];
-        }
-        if (handler) {
-            handler(eventInfoWrapper);
+        if (eventInfoWrapper.getIsReplay()) {
+            this.scheduleEventInfoWrapperReplay(eventInfoWrapper);
             return;
         }
-        // No handler was found.
-        this.baseDispatcher.queueEventInfoWrapper(eventInfoWrapper);
-    }
-    /**
-     * Registers multiple methods all bound to the same object
-     * instance. This is a common case: an application module binds
-     * multiple of its methods under public names to the event contract of
-     * the application. So we provide a shortcut for it.
-     * Attempts to replay the queued events after registering the handlers.
-     *
-     * @param namespace The namespace of the jsaction name.
-     *
-     * @param instance The object to bind the methods to. If this is null, then
-     *     the functions are not bound, but directly added under the public names.
-     *
-     * @param methods A map from public name to functions that will be bound to
-     *     instance and registered as action under the public name. I.e. the
-     *     property names are the public names. The property values are the
-     *     methods of instance.
-     */
-    registerEventInfoHandlers(namespace, instance, methods) {
-        for (const [name, method] of Object.entries(methods)) {
-            const handler = instance ? method.bind(instance) : method;
-            if (namespace) {
-                // Include a '.' separator between namespace name and action name.
-                // In the case that no namespace name is provided, the jsaction name
-                // consists of the action name only (no period).
-                const fullName = namespace + Char.NAMESPACE_ACTION_SEPARATOR + name;
-                this.actions[fullName] = handler;
-            }
-            else {
-                this.actions[name] = handler;
-            }
-        }
-        this.baseDispatcher.scheduleEventReplay();
+        this.dispatchDelegate(eventInfoWrapper);
     }
     /**
-     * Unregisters an action.  Provided as an easy way to reverse the effects of
-     * registerHandlers.
-     * @param namespace The namespace of the jsaction name.
-     * @param name The action name to unbind.
+     * Schedules an `EventInfoWrapper` for replay. The replaying will happen in its own
+     * stack once the current flow cedes control. This is done to mimic
+     * browser event handling.
      */
-    unregisterHandler(namespace, name) {
-        const fullName = namespace ? namespace + Char.NAMESPACE_ACTION_SEPARATOR + name : name;
-        delete this.actions[fullName];
-    }
-    /** Registers a global event handler. */
-    registerGlobalHandler(eventType, handler) {
-        if (!this.globalHandlers.has(eventType)) {
-            this.globalHandlers.set(eventType, new Set([handler]));
-        }
-        else {
-            this.globalHandlers.get(eventType).add(handler);
-        }
-    }
-    /** Unregisters a global event handler. */
-    unregisterGlobalHandler(eventType, handler) {
-        if (this.globalHandlers.has(eventType)) {
-            this.globalHandlers.get(eventType).delete(handler);
+    scheduleEventInfoWrapperReplay(eventInfoWrapper) {
+        this.replayEventInfoWrappers.push(eventInfoWrapper);
+        if (this.eventReplayScheduled) {
+            return;
         }
+        this.eventReplayScheduled = true;
+        Promise.resolve().then(() => {
+            this.eventReplayScheduled = false;
+            this.eventReplayer(this.replayEventInfoWrappers);
+        });
     }
-    /**
-     * Checks whether there is an action registered under the given
-     * name. This returns true if there is a namespace handler, even
-     * if it can not yet handle the event.
-     *
-     * @param name Action name.
-     * @return Whether the name is registered.
-     * @see #canDispatch
-     */
-    hasAction(name) {
-        return this.actions.hasOwnProperty(name);
-    }
-    /**
-     * Whether this dispatcher can dispatch the event. This can be used by
-     * event replayer to check whether the dispatcher can replay an event.
-     */
-    canDispatch(eventInfoWrapper) {
-        const action = eventInfoWrapper.getAction();
-        if (!action) {
-            return false;
+}
+/**
+ * Creates an `EventReplayer` that calls the `replay` function for every `eventInfoWrapper` in
+ * the queue.
+ */
+function createEventReplayer(replay) {
+    return (eventInfoWrappers) => {
+        for (const eventInfoWrapper of eventInfoWrappers) {
+            replay(eventInfoWrapper);
         }
-        return this.hasAction(action.name);
-    }
-    /**
-     * Sets the event replayer, enabling queued events to be replayed when actions
-     * are bound. To replay events, you must register the dispatcher to the
-     * contract after setting the `EventReplayer`. The event replayer takes as
-     * parameters the queue of events and the dispatcher (used to check whether
-     * actions have handlers registered and can be replayed). The event replayer
-     * is also responsible for dequeuing events.
-     *
-     * Example: An event replayer that replays only the last event.
-     *
-     *   const dispatcher = new Dispatcher();
-     *   // ...
-     *   dispatcher.setEventReplayer((queue, dispatcher) => {
-     *     const lastEventInfoWrapper = queue[queue.length -1];
-     *     if (dispatcher.canDispatch(lastEventInfoWrapper.getAction())) {
-     *       jsaction.replay.replayEvent(
-     *           lastEventInfoWrapper.getEvent(),
-     *           lastEventInfoWrapper.getTargetElement(),
-     *           lastEventInfoWrapper.getEventType(),
-     *       );
-     *       queue.length = 0;
-     *     }
-     *   });
-     *
-     * @param eventReplayer It allows elements to be replayed and dequeuing.
-     */
-    setEventReplayer(eventReplayer) {
-        this.eventReplayer = eventReplayer;
-    }
+    };
 }
-/** Stop propagation for an `EventInfo`. */
-function stopPropagation(eventInfoWrapper) {
-    if (isGecko &&
-        (eventInfoWrapper.getTargetElement().tagName === 'INPUT' ||
-            eventInfoWrapper.getTargetElement().tagName === 'TEXTAREA') &&
-        eventInfoWrapper.getEventType() === EventType.FOCUS) {
-        /**
-         * Do nothing since stopping propagation on a focus event on an input
-         * element in Firefox makes the text cursor disappear:
-         * https://bugzilla.mozilla.org/show_bug.cgi?id=509684
-         */
-        return;
-    }
-    const event = eventInfoWrapper.getEvent();
-    // There are some cases where users of the `Dispatcher` will call dispatch
-    // with a fake event that does not support `stopPropagation`.
-    if (!event.stopPropagation) {
-        return;
-    }
-    event.stopPropagation();
+/**
+ * Returns true if the default action of this event should be prevented before
+ * this event is dispatched.
+ */
+function shouldPreventDefaultBeforeDispatching(actionElement, eventInfoWrapper) {
+    // Prevent browser from following <a> node links if a jsaction is present
+    // and we are dispatching the action now. Note that the targetElement may be
+    // a child of an anchor that has a jsaction attached. For that reason, we
+    // need to check the actionElement rather than the targetElement.
+    return ((actionElement.tagName === 'A' && eventInfoWrapper.getEventType() === EventType.CLICK) ||
+        eventInfoWrapper.getEventType() === EventType.CLICKMOD);
 }
 /**
  * Registers deferred functionality for an EventContract and a Jsaction
@@ -1584,98 +1341,110 @@ function populateClickOnlyAction(actionElement, eventInfo, actionMap) {
     setAction(eventInfo, actionMap[EventType.CLICKONLY], actionElement);
 }
 
-var Attribute;
-(function (Attribute) {
-    /**
-     * The jsaction attribute defines a mapping of a DOM event to a
-     * generic event (aka jsaction), to which the actual event handlers
-     * that implement the behavior of the application are bound. The
-     * value is a semicolon separated list of colon separated pairs of
-     * an optional DOM event name and a jsaction name. If the optional
-     * DOM event name is omitted, 'click' is assumed. The jsaction names
-     * are dot separated pairs of a namespace and a simple jsaction
-     * name. If the namespace is absent, it is taken from the closest
-     * ancestor element with a jsnamespace attribute, if there is
-     * any. If there is no ancestor with a jsnamespace attribute, the
-     * simple name is assumed to be the jsaction name.
-     *
-     * Used by EventContract.
-     */
-    Attribute["JSACTION"] = "jsaction";
-    /**
-     * The jsnamespace attribute provides the namespace part of the
-     * jaction names occurring in the jsaction attribute where it's
-     * missing.
-     *
-     * Used by EventContract.
-     */
-    Attribute["JSNAMESPACE"] = "jsnamespace";
+/**
+ * The jsaction attribute defines a mapping of a DOM event to a
+ * generic event (aka jsaction), to which the actual event handlers
+ * that implement the behavior of the application are bound. The
+ * value is a semicolon separated list of colon separated pairs of
+ * an optional DOM event name and a jsaction name. If the optional
+ * DOM event name is omitted, 'click' is assumed. The jsaction names
+ * are dot separated pairs of a namespace and a simple jsaction
+ * name.
+ *
+ * See grammar in README.md for expected syntax in the attribute value.
+ */
+const JSACTION$1 = 'jsaction';
+/**
+ * The oi attribute is a log impression tag for impression logging
+ * and action tracking. For an element that carries a jsaction
+ * attribute, the element is identified for the purpose of
+ * impression logging and click tracking by the dot separated path
+ * of all oi attributes in the chain of ancestors of the element.
+ *
+ * Used by ActionFlow.
+ */
+const OI$1 = 'oi';
+/**
+ * The ved attribute is an encoded ClickTrackingCGI proto to track
+ * visual elements.
+ *
+ * Used by ActionFlow.
+ */
+const VED = 'ved';
+/**
+ * The vet attribute is the visual element type used to identify tracked
+ * visual elements.
+ */
+const VET = 'vet';
+/**
+ * Support for iteration on reprocessing.
+ *
+ * Used by ActionFlow.
+ */
+const JSINSTANCE = 'jsinstance';
+/**
+ * All click jsactions that happen on the element that carries this
+ * attribute or its descendants are automatically logged.
+ * Impressions of jsactions on these elements are tracked too, if
+ * requested by the impression() method of ActionFlow.
+ *
+ * Used by ActionFlow.
+ */
+const JSTRACK = 'jstrack';
+const Attribute = { JSACTION: JSACTION$1, OI: OI$1, VED, VET, JSINSTANCE, JSTRACK };
+
+const Char = {
     /**
-     * The oi attribute is a log impression tag for impression logging
-     * and action tracking. For an element that carries a jsaction
-     * attribute, the element is identified for the purpose of
-     * impression logging and click tracking by the dot separated path
-     * of all oi attributes in the chain of ancestors of the element.
-     *
-     * Used by ActionFlow.
+     * The separator between the namespace and the action name in the
+     * jsaction attribute value.
      */
-    Attribute["OI"] = "oi";
+    NAMESPACE_ACTION_SEPARATOR: '.',
     /**
-     * The ved attribute is an encoded ClickTrackingCGI proto to track
-     * visual elements.
-     *
-     * Used by ActionFlow.
+     * The separator between the event name and action in the jsaction
+     * attribute value.
      */
-    Attribute["VED"] = "ved";
+    EVENT_ACTION_SEPARATOR: ':',
     /**
-     * The vet attribute is the visual element type used to identify tracked
-     * visual elements.
+     * The separator between the logged oi attribute values in the &oi=
+     * URL parameter value.
      */
-    Attribute["VET"] = "vet";
+    OI_SEPARATOR: '.',
     /**
-     * Support for iteration on reprocessing.
-     *
-     * Used by ActionFlow.
+     * The separator between the key and the value pairs in the &cad=
+     * URL parameter value.
      */
-    Attribute["JSINSTANCE"] = "jsinstance";
+    CAD_KEY_VALUE_SEPARATOR: ':',
     /**
-     * All click jsactions that happen on the element that carries this
-     * attribute or its descendants are automatically logged.
-     * Impressions of jsactions on these elements are tracked too, if
-     * requested by the impression() method of ActionFlow.
-     *
-     * Used by ActionFlow.
+     * The separator between the key-value pairs in the &cad= URL
+     * parameter value.
      */
-    Attribute["JSTRACK"] = "jstrack";
-})(Attribute || (Attribute = {}));
+    CAD_SEPARATOR: ',',
+};
 
+/**
+ * The parsed value of the jsaction attribute is stored in this
+ * property on the DOM node. The parsed value is an Object. The
+ * property names of the object are the events; the values are the
+ * names of the actions. This property is attached even on nodes
+ * that don't have a jsaction attribute as an optimization, because
+ * property lookup is faster than attribute access.
+ */
+const JSACTION = '__jsaction';
+/** The value of the oi attribute as a property, for faster access. */
+const OI = '__oi';
+/**
+ * The owner property references an a logical owner for a DOM node. JSAction
+ * will follow this reference instead of parentNode when traversing the DOM
+ * to find jsaction attributes. This allows overlaying a logical structure
+ * over a document where the DOM structure can't reflect that structure.
+ */
+const OWNER = '__owner';
 /** All properties that are used by jsaction. */
-var Property;
-(function (Property) {
-    /**
-     * The parsed value of the jsaction attribute is stored in this
-     * property on the DOM node. The parsed value is an Object. The
-     * property names of the object are the events; the values are the
-     * names of the actions. This property is attached even on nodes
-     * that don't have a jsaction attribute as an optimization, because
-     * property lookup is faster than attribute access.
-     */
-    Property["JSACTION"] = "__jsaction";
-    /**
-     * The parsed value of the jsnamespace attribute is stored in this
-     * property on the DOM node.
-     */
-    Property["JSNAMESPACE"] = "__jsnamespace";
-    /** The value of the oi attribute as a property, for faster access. */
-    Property["OI"] = "__oi";
-    /**
-     * The owner property references an a logical owner for a DOM node. JSAction
-     * will follow this reference instead of parentNode when traversing the DOM
-     * to find jsaction attributes. This allows overlaying a logical structure
-     * over a document where the DOM structure can't reflect that structure.
-     */
-    Property["OWNER"] = "__owner";
-})(Property || (Property = {}));
+const Property = {
+    JSACTION,
+    OI,
+    OWNER,
+};
 
 /**
  * Map from jsaction annotation to a parsed map from event name to action name.
@@ -1689,7 +1458,7 @@ const parseCache = {};
  */
 function get(element) {
     // @ts-ignore
-    return element[Property.JSACTION];
+    return element[JSACTION];
 }
 /**
  * Writes the jsaction parser cache to the given DOM Element.
@@ -1700,7 +1469,7 @@ function get(element) {
  */
 function set(element, actionMap) {
     // @ts-ignore
-    element[Property.JSACTION] = actionMap;
+    element[JSACTION] = actionMap;
 }
 /**
  * Looks up the parsed action map from the source jsaction attribute value.
@@ -1726,41 +1495,8 @@ function setParsed(text, parsed) {
  * @param element .
  */
 function clear(element) {
-    if (Property.JSACTION in element) {
-        delete element[Property.JSACTION];
-    }
-}
-/**
- * Reads the cached jsaction namespace from the given DOM
- * Element. Undefined means there is no cached value; null is a cached
- * jsnamespace attribute that's absent.
- *
- * @param element .
- * @return .
- */
-function getNamespace(element) {
-    // @ts-ignore
-    return element[Property.JSNAMESPACE];
-}
-/**
- * Writes the cached jsaction namespace to the given DOM Element. Null
- * represents a jsnamespace attribute that's absent.
- *
- * @param element .
- * @param jsnamespace .
- */
-function setNamespace(element, jsnamespace) {
-    // @ts-ignore
-    element[Property.JSNAMESPACE] = jsnamespace;
-}
-/**
- * Clears the cached jsaction namespace from the given DOM Element.
- *
- * @param element .
- */
-function clearNamespace(element) {
-    if (Property.JSNAMESPACE in element) {
-        delete element[Property.JSNAMESPACE];
+    if (JSACTION in element) {
+        delete element[JSACTION];
     }
 }
 
@@ -1777,28 +1513,19 @@ const REGEXP_SEMICOLON = /\s*;\s*/;
 const DEFAULT_EVENT_TYPE = EventType.CLICK;
 /** Resolves actions for Events. */
 class ActionResolver {
-    constructor({ customEventSupport = false, syntheticMouseEventSupport = false, } = {}) {
+    constructor({ syntheticMouseEventSupport = false, } = {}) {
         this.a11yClickSupport = false;
         this.updateEventInfoForA11yClick = undefined;
         this.preventDefaultForA11yClick = undefined;
         this.populateClickOnlyAction = undefined;
-        this.customEventSupport = customEventSupport;
         this.syntheticMouseEventSupport = syntheticMouseEventSupport;
     }
     resolve(eventInfo) {
-        if (this.customEventSupport) {
-            if (getEventType(eventInfo) === EventType.CUSTOM) {
-                const detail = getEvent(eventInfo).detail;
-                // For custom events, use a secondary dispatch based on the internal
-                // custom type of the event.
-                if (!detail || !detail['_type']) {
-                    // This should never happen.
-                    return;
-                }
-                setEventType(eventInfo, detail['_type']);
-            }
+        if (getResolved(eventInfo)) {
+            return;
         }
         this.populateAction(eventInfo);
+        setResolved(eventInfo, true);
     }
     /**
      * Searches for a jsaction that the DOM event maps to and creates an
@@ -1867,8 +1594,8 @@ class ActionResolver {
                 // ancestor chain of the event target node.
                 break;
             }
-            if (actionElement[Property.OWNER]) {
-                actionElement = actionElement[Property.OWNER];
+            if (actionElement[OWNER]) {
+                actionElement = actionElement[OWNER];
                 continue;
             }
             if (actionElement.parentNode?.nodeName !== '#document-fragment') {
@@ -1994,11 +1721,6 @@ const A11Y_CLICK_SUPPORT = false;
  * flag can be overridden in a build rule.
  */
 const MOUSE_SPECIAL_SUPPORT = false;
-/**
- * @define Support for custom events, which are type EventType.CUSTOM. These are
- * native DOM events with an additional type field and an optional payload.
- */
-const CUSTOM_EVENT_SUPPORT = false;
 
 /**
  * @fileoverview Implements the local event handling contract. This
@@ -2038,14 +1760,10 @@ const CUSTOM_EVENT_SUPPORT = false;
  * be delay loaded in a generic way.
  */
 class EventContract {
-    static { this.CUSTOM_EVENT_SUPPORT = CUSTOM_EVENT_SUPPORT; }
     static { this.A11Y_CLICK_SUPPORT = A11Y_CLICK_SUPPORT; }
     static { this.MOUSE_SPECIAL_SUPPORT = MOUSE_SPECIAL_SUPPORT; }
-    constructor(containerManager) {
-        this.actionResolver = new ActionResolver({
-            customEventSupport: EventContract.CUSTOM_EVENT_SUPPORT,
-            syntheticMouseEventSupport: EventContract.MOUSE_SPECIAL_SUPPORT,
-        });
+    constructor(containerManager, useActionResolver = true) {
+        this.useActionResolver = useActionResolver;
         /**
          * The DOM events which this contract covers. Used to prevent double
          * registration of event types. The value of the map is the
@@ -2071,8 +1789,10 @@ class EventContract {
         /** Whether to add an a11y click listener. */
         this.addA11yClickListener = false;
         this.containerManager = containerManager;
-        if (EventContract.CUSTOM_EVENT_SUPPORT) {
-            this.addEvent(EventType.CUSTOM);
+        if (this.useActionResolver) {
+            this.actionResolver = new ActionResolver({
+                syntheticMouseEventSupport: EventContract.MOUSE_SPECIAL_SUPPORT,
+            });
         }
         if (EventContract.A11Y_CLICK_SUPPORT) {
             // Add a11y click support to the `EventContract`.
@@ -2098,12 +1818,8 @@ class EventContract {
             this.queuedEventInfos?.push(eventInfo);
             return;
         }
-        this.actionResolver.resolve(eventInfo);
-        const action = getAction(eventInfo);
-        if (action) {
-            if (shouldPreventDefaultBeforeDispatching(getActionElement(action), eventInfo)) {
-                preventDefault(getEvent(eventInfo));
-            }
+        if (this.useActionResolver) {
+            this.actionResolver.resolve(eventInfo);
         }
         this.dispatcher(eventInfo);
     }
@@ -2263,7 +1979,9 @@ class EventContract {
      */
     addA11yClickSupportImpl(updateEventInfoForA11yClick, preventDefaultForA11yClick, populateClickOnlyAction) {
         this.addA11yClickListener = true;
-        this.actionResolver.addA11yClickSupport(updateEventInfoForA11yClick, preventDefaultForA11yClick, populateClickOnlyAction);
+        if (this.useActionResolver) {
+            this.actionResolver.addA11yClickSupport(updateEventInfoForA11yClick, preventDefaultForA11yClick, populateClickOnlyAction);
+        }
     }
 }
 function removeEventListeners(container, eventTypes, earlyEventHandler, capture) {
@@ -2280,19 +1998,6 @@ function removeEventListeners(container, eventTypes, earlyEventHandler, capture)
 function addDeferredA11yClickSupport(eventContract) {
     eventContract.ecaacs?.(updateEventInfoForA11yClick, preventDefaultForA11yClick, populateClickOnlyAction);
 }
-/**
- * Returns true if the default action of this event should be prevented before
- * this event is dispatched.
- */
-function shouldPreventDefaultBeforeDispatching(actionElement, eventInfo) {
-    // Prevent browser from following <a> node links if a jsaction is present
-    // and we are dispatching the action now. Note that the targetElement may be
-    // a child of an anchor that has a jsaction attached. For that reason, we
-    // need to check the actionElement rather than the targetElement.
-    return (actionElement.tagName === 'A' &&
-        (getEventType(eventInfo) === EventType.CLICK ||
-            getEventType(eventInfo) === EventType.CLICKMOD));
-}
 
 /**
  * EarlyEventContract intercepts events in the bubbling phase at the
@@ -2303,14 +2008,14 @@ class EarlyEventContract {
     constructor(replaySink = window, container = window.document.documentElement) {
         this.replaySink = replaySink;
         this.container = container;
-        this.replaySink._ejsa = {
+        replaySink._ejsa = {
             c: container,
             q: [],
             et: [],
             etc: [],
             h: (event) => {
-                const eventInfo = createEventInfoFromParameters(event.type, event, event.target, window.document.documentElement, Date.now());
-                this.replaySink._ejsa.q.push(eventInfo);
+                const eventInfo = createEventInfoFromParameters(event.type, event, event.target, container, Date.now());
+                replaySink._ejsa.q.push(eventInfo);
             },
         };
     }
@@ -2328,26 +2033,6 @@ class EarlyEventContract {
     }
 }
 
-/**
- * Provides a factory function for bootstrapping an event contract on a
- * specified object (by default, exposed on the `window`).
- * @param field The property on the object that the event contract will be placed on.
- * @param container The container that listens to events
- * @param appId A given identifier for an application. If there are multiple apps on the page
- *              then this is how contracts can be initialized for each one.
- * @param events An array of event names that should be listened to.
- * @param earlyJsactionTracker The object that should receive the event contract.
- */
-function bootstrapEventContract(field, container, appId, events, earlyJsactionTracker = window) {
-    if (!earlyJsactionTracker[field]) {
-        earlyJsactionTracker[field] = {};
-    }
-    const eventContract = new EventContract(new EventContractContainer(container));
-    earlyJsactionTracker[field][appId] = eventContract;
-    for (const ev of events) {
-        eventContract.addEvent(ev);
-    }
-}
 /**
  * Provides a factory function for bootstrapping an event contract on a
  * specified object (by default, exposed on the `window`).
@@ -2365,9 +2050,11 @@ function bootstrapEarlyEventContract(field, container, appId, eventTypes, captur
     }
     earlyJsactionTracker[field][appId] = {};
     const eventContract = new EarlyEventContract(earlyJsactionTracker[field][appId], container);
-    eventContract.addEvents(eventTypes);
-    eventContract.addEvents(captureEventTypes, true);
+    if (eventTypes)
+        eventContract.addEvents(eventTypes);
+    if (captureEventTypes)
+        eventContract.addEvents(captureEventTypes, true);
 }
 
-export { Dispatcher, EventContract, EventContractContainer, EventInfoWrapper, bootstrapEarlyEventContract, bootstrapEventContract, registerDispatcher };
+export { Dispatcher, EventContract, EventContractContainer, EventInfoWrapper, bootstrapEarlyEventContract, registerDispatcher };
 //# sourceMappingURL=event-dispatch.mjs.map