@angular/core 18.0.0-rc.0 → 18.0.0-rc.2

package/esm2022/primitives/event-dispatch/contract_binary.mjs

@@ -5,6 +5,6 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { bootstrapEventContract } from './src/register_events';
-window['__jsaction_bootstrap'] = bootstrapEventContract;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfYmluYXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9wcmltaXRpdmVzL2V2ZW50LWRpc3BhdGNoL2NvbnRyYWN0X2JpbmFyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsc0JBQXNCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUU1RCxNQUFjLENBQUMsc0JBQXNCLENBQUMsR0FBRyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge2Jvb3RzdHJhcEV2ZW50Q29udHJhY3R9IGZyb20gJy4vc3JjL3JlZ2lzdGVyX2V2ZW50cyc7XG5cbih3aW5kb3cgYXMgYW55KVsnX19qc2FjdGlvbl9ib290c3RyYXAnXSA9IGJvb3RzdHJhcEV2ZW50Q29udHJhY3Q7XG4iXX0=
+import { bootstrapEarlyEventContract } from './src/register_events';
+window['__jsaction_bootstrap'] = bootstrapEarlyEventContract;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfYmluYXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9wcmltaXRpdmVzL2V2ZW50LWRpc3BhdGNoL2NvbnRyYWN0X2JpbmFyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsMkJBQTJCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUVqRSxNQUFjLENBQUMsc0JBQXNCLENBQUMsR0FBRywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge2Jvb3RzdHJhcEVhcmx5RXZlbnRDb250cmFjdH0gZnJvbSAnLi9zcmMvcmVnaXN0ZXJfZXZlbnRzJztcblxuKHdpbmRvdyBhcyBhbnkpWydfX2pzYWN0aW9uX2Jvb3RzdHJhcCddID0gYm9vdHN0cmFwRWFybHlFdmVudENvbnRyYWN0O1xuIl19

package/esm2022/primitives/event-dispatch/index.mjs

@@ -8,6 +8,6 @@
 export { Dispatcher, registerDispatcher } from './src/dispatcher';
 export { EventContractContainer } from './src/event_contract_container';
 export { EventContract } from './src/eventcontract';
-export { bootstrapEventContract } from './src/register_events';
+export { bootstrapEarlyEventContract } from './src/register_events';
 export { EventInfoWrapper } from './src/event_info';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFVBQVUsRUFBRSxrQkFBa0IsRUFBQyxNQUFNLGtCQUFrQixDQUFDO0FBQ2hFLE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLGdDQUFnQyxDQUFDO0FBQ3RFLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUMsc0JBQXNCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUM3RCxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge0Rpc3BhdGNoZXIsIHJlZ2lzdGVyRGlzcGF0Y2hlcn0gZnJvbSAnLi9zcmMvZGlzcGF0Y2hlcic7XG5leHBvcnQge0V2ZW50Q29udHJhY3RDb250YWluZXJ9IGZyb20gJy4vc3JjL2V2ZW50X2NvbnRyYWN0X2NvbnRhaW5lcic7XG5leHBvcnQge0V2ZW50Q29udHJhY3R9IGZyb20gJy4vc3JjL2V2ZW50Y29udHJhY3QnO1xuZXhwb3J0IHtib290c3RyYXBFdmVudENvbnRyYWN0fSBmcm9tICcuL3NyYy9yZWdpc3Rlcl9ldmVudHMnO1xuZXhwb3J0IHtFdmVudEluZm9XcmFwcGVyfSBmcm9tICcuL3NyYy9ldmVudF9pbmZvJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFVBQVUsRUFBRSxrQkFBa0IsRUFBQyxNQUFNLGtCQUFrQixDQUFDO0FBQ2hFLE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLGdDQUFnQyxDQUFDO0FBRXRFLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUMsMkJBQTJCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUdsRSxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge0Rpc3BhdGNoZXIsIHJlZ2lzdGVyRGlzcGF0Y2hlcn0gZnJvbSAnLi9zcmMvZGlzcGF0Y2hlcic7XG5leHBvcnQge0V2ZW50Q29udHJhY3RDb250YWluZXJ9IGZyb20gJy4vc3JjL2V2ZW50X2NvbnRyYWN0X2NvbnRhaW5lcic7XG5leHBvcnQgdHlwZSB7RWFybHlKc2FjdGlvbkRhdGFDb250YWluZXJ9IGZyb20gJy4vc3JjL2Vhcmx5ZXZlbnRjb250cmFjdCc7XG5leHBvcnQge0V2ZW50Q29udHJhY3R9IGZyb20gJy4vc3JjL2V2ZW50Y29udHJhY3QnO1xuZXhwb3J0IHtib290c3RyYXBFYXJseUV2ZW50Q29udHJhY3R9IGZyb20gJy4vc3JjL3JlZ2lzdGVyX2V2ZW50cyc7XG5cbmV4cG9ydCB0eXBlIHtFdmVudENvbnRyYWN0VHJhY2tlcn0gZnJvbSAnLi9zcmMvcmVnaXN0ZXJfZXZlbnRzJztcbmV4cG9ydCB7RXZlbnRJbmZvV3JhcHBlcn0gZnJvbSAnLi9zcmMvZXZlbnRfaW5mbyc7XG4iXX0=

package/esm2022/primitives/event-dispatch/src/action_resolver.mjs

@@ -0,0 +1,221 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Attribute } from './attribute';
+import { Char } from './char';
+import { EventType } from './event_type';
+import { OWNER } from './property';
+import * as cache from './cache';
+import * as eventInfoLib from './event_info';
+import * as eventLib from './event';
+/**
+ * Since maps from event to action are immutable we can use a single map
+ * to represent the empty map.
+ */
+const EMPTY_ACTION_MAP = {};
+/**
+ * This regular expression matches a semicolon.
+ */
+const REGEXP_SEMICOLON = /\s*;\s*/;
+/** If no event type is defined, defaults to `click`. */
+const DEFAULT_EVENT_TYPE = EventType.CLICK;
+/** Resolves actions for Events. */
+export class ActionResolver {
+    constructor({ syntheticMouseEventSupport = false, } = {}) {
+        this.a11yClickSupport = false;
+        this.updateEventInfoForA11yClick = undefined;
+        this.preventDefaultForA11yClick = undefined;
+        this.populateClickOnlyAction = undefined;
+        this.syntheticMouseEventSupport = syntheticMouseEventSupport;
+    }
+    resolve(eventInfo) {
+        this.populateAction(eventInfo);
+    }
+    /**
+     * Searches for a jsaction that the DOM event maps to and creates an
+     * object containing event information used for dispatching by
+     * jsaction.Dispatcher. This method populates the `action` and `actionElement`
+     * fields of the EventInfo object passed in by finding the first
+     * jsaction attribute above the target Node of the event, and below
+     * the container Node, that specifies a jsaction for the event
+     * type. If no such jsaction is found, then action is undefined.
+     *
+     * @param eventInfo `EventInfo` to set `action` and `actionElement` if an
+     *    action is found on any `Element` in the path of the `Event`.
+     */
+    populateAction(eventInfo) {
+        // We distinguish modified and plain clicks in order to support the
+        // default browser behavior of modified clicks on links; usually to
+        // open the URL of the link in new tab or new window on ctrl/cmd
+        // click. A DOM 'click' event is mapped to the jsaction 'click'
+        // event iff there is no modifier present on the event. If there is
+        // a modifier, it's mapped to 'clickmod' instead.
+        //
+        // It's allowed to omit the event in the jsaction attribute. In that
+        // case, 'click' is assumed. Thus the following two are equivalent:
+        //
+        //   <a href="someurl" jsaction="gna.fu">
+        //   <a href="someurl" jsaction="click:gna.fu">
+        //
+        // For unmodified clicks, EventContract invokes the jsaction
+        // 'gna.fu'. For modified clicks, EventContract won't find a
+        // suitable action and leave the event to be handled by the
+        // browser.
+        //
+        // In order to also invoke a jsaction handler for a modifier click,
+        // 'clickmod' needs to be used:
+        //
+        //   <a href="someurl" jsaction="clickmod:gna.fu">
+        //
+        // EventContract invokes the jsaction 'gna.fu' for modified
+        // clicks. Unmodified clicks are left to the browser.
+        //
+        // In order to set up the event contract to handle both clickonly and
+        // clickmod, only addEvent(EventType.CLICK) is necessary.
+        //
+        // In order to set up the event contract to handle click,
+        // addEvent() is necessary for CLICK, KEYDOWN, and KEYPRESS event types.  If
+        // a11y click support is enabled, addEvent() will set up the appropriate key
+        // event handler automatically.
+        if (eventInfoLib.getEventType(eventInfo) === EventType.CLICK &&
+            eventLib.isModifiedClickEvent(eventInfoLib.getEvent(eventInfo))) {
+            eventInfoLib.setEventType(eventInfo, EventType.CLICKMOD);
+        }
+        else if (this.a11yClickSupport) {
+            this.updateEventInfoForA11yClick(eventInfo);
+        }
+        // Walk to the parent node, unless the node has a different owner in
+        // which case we walk to the owner. Attempt to walk to host of a
+        // shadow root if needed.
+        let actionElement = eventInfoLib.getTargetElement(eventInfo);
+        while (actionElement && actionElement !== eventInfoLib.getContainer(eventInfo)) {
+            if (actionElement.nodeType === Node.ELEMENT_NODE) {
+                this.populateActionOnElement(actionElement, eventInfo);
+            }
+            if (eventInfoLib.getAction(eventInfo)) {
+                // An event is handled by at most one jsaction. Thus we stop at the
+                // first matching jsaction specified in a jsaction attribute up the
+                // ancestor chain of the event target node.
+                break;
+            }
+            if (actionElement[OWNER]) {
+                actionElement = actionElement[OWNER];
+                continue;
+            }
+            if (actionElement.parentNode?.nodeName !== '#document-fragment') {
+                actionElement = actionElement.parentNode;
+            }
+            else {
+                actionElement = actionElement.parentNode?.host ?? null;
+            }
+        }
+        const action = eventInfoLib.getAction(eventInfo);
+        if (!action) {
+            // No action found.
+            return;
+        }
+        if (this.a11yClickSupport) {
+            this.preventDefaultForA11yClick(eventInfo);
+        }
+        // We attempt to handle the mouseenter/mouseleave events here by
+        // detecting whether the mouseover/mouseout events correspond to
+        // entering/leaving an element.
+        if (this.syntheticMouseEventSupport) {
+            if (eventInfoLib.getEventType(eventInfo) === EventType.MOUSEENTER ||
+                eventInfoLib.getEventType(eventInfo) === EventType.MOUSELEAVE ||
+                eventInfoLib.getEventType(eventInfo) === EventType.POINTERENTER ||
+                eventInfoLib.getEventType(eventInfo) === EventType.POINTERLEAVE) {
+                // We attempt to handle the mouseenter/mouseleave events here by
+                // detecting whether the mouseover/mouseout events correspond to
+                // entering/leaving an element.
+                if (eventLib.isMouseSpecialEvent(eventInfoLib.getEvent(eventInfo), eventInfoLib.getEventType(eventInfo), eventInfoLib.getActionElement(action))) {
+                    // If both mouseover/mouseout and mouseenter/mouseleave events are
+                    // enabled, two separate handlers for mouseover/mouseout are
+                    // registered. Both handlers will see the same event instance
+                    // so we create a copy to avoid interfering with the dispatching of
+                    // the mouseover/mouseout event.
+                    const copiedEvent = eventLib.createMouseSpecialEvent(eventInfoLib.getEvent(eventInfo), eventInfoLib.getActionElement(action));
+                    eventInfoLib.setEvent(eventInfo, copiedEvent);
+                    // Since the mouseenter/mouseleave events do not bubble, the target
+                    // of the event is technically the `actionElement` (the node with the
+                    // `jsaction` attribute)
+                    eventInfoLib.setTargetElement(eventInfo, eventInfoLib.getActionElement(action));
+                }
+                else {
+                    eventInfoLib.unsetAction(eventInfo);
+                }
+            }
+        }
+    }
+    /**
+     * Accesses the jsaction map on a node and retrieves the name of the
+     * action the given event is mapped to, if any. It parses the
+     * attribute value and stores it in a property on the node for
+     * subsequent retrieval without re-parsing and re-accessing the
+     * attribute.
+     *
+     * @param actionElement The DOM node to retrieve the jsaction map from.
+     * @param eventInfo `EventInfo` to set `action` and `actionElement` if an
+     *    action is found on the `actionElement`.
+     */
+    populateActionOnElement(actionElement, eventInfo) {
+        const actionMap = this.parseActions(actionElement);
+        const actionName = actionMap[eventInfoLib.getEventType(eventInfo)];
+        if (actionName !== undefined) {
+            eventInfoLib.setAction(eventInfo, actionName, actionElement);
+        }
+        if (this.a11yClickSupport) {
+            this.populateClickOnlyAction(actionElement, eventInfo, actionMap);
+        }
+    }
+    /**
+     * Parses and caches an element's jsaction element into a map.
+     *
+     * This is primarily for internal use.
+     *
+     * @param actionElement The DOM node to retrieve the jsaction map from.
+     * @return Map from event to qualified name of the jsaction bound to it.
+     */
+    parseActions(actionElement) {
+        let actionMap = cache.get(actionElement);
+        if (!actionMap) {
+            const jsactionAttribute = actionElement.getAttribute(Attribute.JSACTION);
+            if (!jsactionAttribute) {
+                actionMap = EMPTY_ACTION_MAP;
+                cache.set(actionElement, actionMap);
+            }
+            else {
+                actionMap = cache.getParsed(jsactionAttribute);
+                if (!actionMap) {
+                    actionMap = {};
+                    const values = jsactionAttribute.split(REGEXP_SEMICOLON);
+                    for (let idx = 0; idx < values.length; idx++) {
+                        const value = values[idx];
+                        if (!value) {
+                            continue;
+                        }
+                        const colon = value.indexOf(Char.EVENT_ACTION_SEPARATOR);
+                        const hasColon = colon !== -1;
+                        const type = hasColon ? value.substr(0, colon).trim() : DEFAULT_EVENT_TYPE;
+                        const action = hasColon ? value.substr(colon + 1).trim() : value;
+                        actionMap[type] = action;
+                    }
+                    cache.setParsed(jsactionAttribute, actionMap);
+                }
+                cache.set(actionElement, actionMap);
+            }
+        }
+        return actionMap;
+    }
+    addA11yClickSupport(updateEventInfoForA11yClick, preventDefaultForA11yClick, populateClickOnlyAction) {
+        this.a11yClickSupport = true;
+        this.updateEventInfoForA11yClick = updateEventInfoForA11yClick;
+        this.preventDefaultForA11yClick = preventDefaultForA11yClick;
+        this.populateClickOnlyAction = populateClickOnlyAction;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action_resolver.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/action_resolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Attribute} from './attribute';\nimport {Char} from './char';\nimport {EventType} from './event_type';\nimport {OWNER} from './property';\nimport * as a11yClick from './a11y_click';\nimport * as cache from './cache';\nimport * as eventInfoLib from './event_info';\nimport * as eventLib from './event';\n\n/**\n * Since maps from event to action are immutable we can use a single map\n * to represent the empty map.\n */\nconst EMPTY_ACTION_MAP: {[key: string]: string} = {};\n\n/**\n * This regular expression matches a semicolon.\n */\nconst REGEXP_SEMICOLON = /\\s*;\\s*/;\n\n/** If no event type is defined, defaults to `click`. */\nconst DEFAULT_EVENT_TYPE: string = EventType.CLICK;\n\n/** Resolves actions for Events. */\nexport class ActionResolver {\n  private a11yClickSupport: boolean = false;\n  private readonly syntheticMouseEventSupport: boolean;\n\n  private updateEventInfoForA11yClick?: (eventInfo: eventInfoLib.EventInfo) => void = undefined;\n\n  private preventDefaultForA11yClick?: (eventInfo: eventInfoLib.EventInfo) => void = undefined;\n\n  private populateClickOnlyAction?: (\n    actionElement: Element,\n    eventInfo: eventInfoLib.EventInfo,\n    actionMap: {[key: string]: string},\n  ) => void = undefined;\n\n  constructor({\n    syntheticMouseEventSupport = false,\n  }: {\n    syntheticMouseEventSupport?: boolean;\n  } = {}) {\n    this.syntheticMouseEventSupport = syntheticMouseEventSupport;\n  }\n\n  resolve(eventInfo: eventInfoLib.EventInfo) {\n    this.populateAction(eventInfo);\n  }\n\n  /**\n   * Searches for a jsaction that the DOM event maps to and creates an\n   * object containing event information used for dispatching by\n   * jsaction.Dispatcher. This method populates the `action` and `actionElement`\n   * fields of the EventInfo object passed in by finding the first\n   * jsaction attribute above the target Node of the event, and below\n   * the container Node, that specifies a jsaction for the event\n   * type. If no such jsaction is found, then action is undefined.\n   *\n   * @param eventInfo `EventInfo` to set `action` and `actionElement` if an\n   *    action is found on any `Element` in the path of the `Event`.\n   */\n  private populateAction(eventInfo: eventInfoLib.EventInfo) {\n    // We distinguish modified and plain clicks in order to support the\n    // default browser behavior of modified clicks on links; usually to\n    // open the URL of the link in new tab or new window on ctrl/cmd\n    // click. A DOM 'click' event is mapped to the jsaction 'click'\n    // event iff there is no modifier present on the event. If there is\n    // a modifier, it's mapped to 'clickmod' instead.\n    //\n    // It's allowed to omit the event in the jsaction attribute. In that\n    // case, 'click' is assumed. Thus the following two are equivalent:\n    //\n    //   <a href=\"someurl\" jsaction=\"gna.fu\">\n    //   <a href=\"someurl\" jsaction=\"click:gna.fu\">\n    //\n    // For unmodified clicks, EventContract invokes the jsaction\n    // 'gna.fu'. For modified clicks, EventContract won't find a\n    // suitable action and leave the event to be handled by the\n    // browser.\n    //\n    // In order to also invoke a jsaction handler for a modifier click,\n    // 'clickmod' needs to be used:\n    //\n    //   <a href=\"someurl\" jsaction=\"clickmod:gna.fu\">\n    //\n    // EventContract invokes the jsaction 'gna.fu' for modified\n    // clicks. Unmodified clicks are left to the browser.\n    //\n    // In order to set up the event contract to handle both clickonly and\n    // clickmod, only addEvent(EventType.CLICK) is necessary.\n    //\n    // In order to set up the event contract to handle click,\n    // addEvent() is necessary for CLICK, KEYDOWN, and KEYPRESS event types.  If\n    // a11y click support is enabled, addEvent() will set up the appropriate key\n    // event handler automatically.\n    if (\n      eventInfoLib.getEventType(eventInfo) === EventType.CLICK &&\n      eventLib.isModifiedClickEvent(eventInfoLib.getEvent(eventInfo))\n    ) {\n      eventInfoLib.setEventType(eventInfo, EventType.CLICKMOD);\n    } else if (this.a11yClickSupport) {\n      this.updateEventInfoForA11yClick!(eventInfo);\n    }\n\n    // Walk to the parent node, unless the node has a different owner in\n    // which case we walk to the owner. Attempt to walk to host of a\n    // shadow root if needed.\n    let actionElement: Element | null = eventInfoLib.getTargetElement(eventInfo);\n    while (actionElement && actionElement !== eventInfoLib.getContainer(eventInfo)) {\n      if (actionElement.nodeType === Node.ELEMENT_NODE) {\n        this.populateActionOnElement(actionElement, eventInfo);\n      }\n\n      if (eventInfoLib.getAction(eventInfo)) {\n        // An event is handled by at most one jsaction. Thus we stop at the\n        // first matching jsaction specified in a jsaction attribute up the\n        // ancestor chain of the event target node.\n        break;\n      }\n      if (actionElement[OWNER]) {\n        actionElement = actionElement[OWNER] as Element;\n        continue;\n      }\n      if (actionElement.parentNode?.nodeName !== '#document-fragment') {\n        actionElement = actionElement.parentNode as Element | null;\n      } else {\n        actionElement = (actionElement.parentNode as ShadowRoot | null)?.host ?? null;\n      }\n    }\n\n    const action = eventInfoLib.getAction(eventInfo);\n    if (!action) {\n      // No action found.\n      return;\n    }\n\n    if (this.a11yClickSupport) {\n      this.preventDefaultForA11yClick!(eventInfo);\n    }\n\n    // We attempt to handle the mouseenter/mouseleave events here by\n    // detecting whether the mouseover/mouseout events correspond to\n    // entering/leaving an element.\n    if (this.syntheticMouseEventSupport) {\n      if (\n        eventInfoLib.getEventType(eventInfo) === EventType.MOUSEENTER ||\n        eventInfoLib.getEventType(eventInfo) === EventType.MOUSELEAVE ||\n        eventInfoLib.getEventType(eventInfo) === EventType.POINTERENTER ||\n        eventInfoLib.getEventType(eventInfo) === EventType.POINTERLEAVE\n      ) {\n        // We attempt to handle the mouseenter/mouseleave events here by\n        // detecting whether the mouseover/mouseout events correspond to\n        // entering/leaving an element.\n        if (\n          eventLib.isMouseSpecialEvent(\n            eventInfoLib.getEvent(eventInfo),\n            eventInfoLib.getEventType(eventInfo),\n            eventInfoLib.getActionElement(action),\n          )\n        ) {\n          // If both mouseover/mouseout and mouseenter/mouseleave events are\n          // enabled, two separate handlers for mouseover/mouseout are\n          // registered. Both handlers will see the same event instance\n          // so we create a copy to avoid interfering with the dispatching of\n          // the mouseover/mouseout event.\n          const copiedEvent = eventLib.createMouseSpecialEvent(\n            eventInfoLib.getEvent(eventInfo),\n            eventInfoLib.getActionElement(action),\n          );\n          eventInfoLib.setEvent(eventInfo, copiedEvent);\n          // Since the mouseenter/mouseleave events do not bubble, the target\n          // of the event is technically the `actionElement` (the node with the\n          // `jsaction` attribute)\n          eventInfoLib.setTargetElement(eventInfo, eventInfoLib.getActionElement(action));\n        } else {\n          eventInfoLib.unsetAction(eventInfo);\n        }\n      }\n    }\n  }\n\n  /**\n   * Accesses the jsaction map on a node and retrieves the name of the\n   * action the given event is mapped to, if any. It parses the\n   * attribute value and stores it in a property on the node for\n   * subsequent retrieval without re-parsing and re-accessing the\n   * attribute.\n   *\n   * @param actionElement The DOM node to retrieve the jsaction map from.\n   * @param eventInfo `EventInfo` to set `action` and `actionElement` if an\n   *    action is found on the `actionElement`.\n   */\n  private populateActionOnElement(actionElement: Element, eventInfo: eventInfoLib.EventInfo) {\n    const actionMap = this.parseActions(actionElement);\n\n    const actionName = actionMap[eventInfoLib.getEventType(eventInfo)];\n    if (actionName !== undefined) {\n      eventInfoLib.setAction(eventInfo, actionName, actionElement);\n    }\n\n    if (this.a11yClickSupport) {\n      this.populateClickOnlyAction!(actionElement, eventInfo, actionMap);\n    }\n  }\n\n  /**\n   * Parses and caches an element's jsaction element into a map.\n   *\n   * This is primarily for internal use.\n   *\n   * @param actionElement The DOM node to retrieve the jsaction map from.\n   * @return Map from event to qualified name of the jsaction bound to it.\n   */\n  private parseActions(actionElement: Element): {[key: string]: string} {\n    let actionMap: {[key: string]: string} | undefined = cache.get(actionElement);\n    if (!actionMap) {\n      const jsactionAttribute = actionElement.getAttribute(Attribute.JSACTION);\n      if (!jsactionAttribute) {\n        actionMap = EMPTY_ACTION_MAP;\n        cache.set(actionElement, actionMap);\n      } else {\n        actionMap = cache.getParsed(jsactionAttribute);\n        if (!actionMap) {\n          actionMap = {};\n          const values = jsactionAttribute.split(REGEXP_SEMICOLON);\n          for (let idx = 0; idx < values.length; idx++) {\n            const value = values[idx];\n            if (!value) {\n              continue;\n            }\n            const colon = value.indexOf(Char.EVENT_ACTION_SEPARATOR);\n            const hasColon = colon !== -1;\n            const type = hasColon ? value.substr(0, colon).trim() : DEFAULT_EVENT_TYPE;\n            const action = hasColon ? value.substr(colon + 1).trim() : value;\n            actionMap[type] = action;\n          }\n          cache.setParsed(jsactionAttribute, actionMap);\n        }\n        cache.set(actionElement, actionMap);\n      }\n    }\n    return actionMap;\n  }\n\n  addA11yClickSupport(\n    updateEventInfoForA11yClick: typeof a11yClick.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClick.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClick.populateClickOnlyAction,\n  ) {\n    this.a11yClickSupport = true;\n    this.updateEventInfoForA11yClick = updateEventInfoForA11yClick;\n    this.preventDefaultForA11yClick = preventDefaultForA11yClick;\n    this.populateClickOnlyAction = populateClickOnlyAction;\n  }\n}\n"]}

package/esm2022/primitives/event-dispatch/src/attribute.mjs

@@ -5,68 +5,66 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-export 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 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.
-     */
-    Attribute["OI"] = "oi";
-    /**
-     * The ved attribute is an encoded ClickTrackingCGI proto to track
-     * visual elements.
-     *
-     * Used by ActionFlow.
-     */
-    Attribute["VED"] = "ved";
-    /**
-     * The vet attribute is the visual element type used to identify tracked
-     * visual elements.
-     */
-    Attribute["VET"] = "vet";
-    /**
-     * Support for iteration on reprocessing.
-     *
-     * Used by ActionFlow.
-     */
-    Attribute["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.
-     */
-    Attribute["JSTRACK"] = "jstrack";
-})(Attribute || (Attribute = {}));
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * 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.
+ */
+export const 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.
+ */
+export const JSNAMESPACE = 'jsnamespace';
+/**
+ * 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.
+ */
+export const OI = 'oi';
+/**
+ * The ved attribute is an encoded ClickTrackingCGI proto to track
+ * visual elements.
+ *
+ * Used by ActionFlow.
+ */
+export const VED = 'ved';
+/**
+ * The vet attribute is the visual element type used to identify tracked
+ * visual elements.
+ */
+export const VET = 'vet';
+/**
+ * Support for iteration on reprocessing.
+ *
+ * Used by ActionFlow.
+ */
+export 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.
+ */
+export const JSTRACK = 'jstrack';
+export const Attribute = { JSACTION, JSNAMESPACE, OI, VED, VET, JSINSTANCE, JSTRACK };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/primitives/event-dispatch/src/cache.mjs

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { Property } from './property';
+import { JSACTION, JSNAMESPACE } from './property';
 /**
  * Map from jsaction annotation to a parsed map from event name to action name.
  */
@@ -18,7 +18,7 @@ const parseCache = {};
  */
 export function get(element) {
     // @ts-ignore
-    return element[Property.JSACTION];
+    return element[JSACTION];
 }
 /**
  * Writes the jsaction parser cache to the given DOM Element.
@@ -29,7 +29,7 @@ export function get(element) {
  */
 export 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.
@@ -55,8 +55,8 @@ export function setParsed(text, parsed) {
  * @param element .
  */
 export function clear(element) {
-    if (Property.JSACTION in element) {
-        delete element[Property.JSACTION];
+    if (JSACTION in element) {
+        delete element[JSACTION];
     }
 }
 /**
@@ -69,7 +69,7 @@ export function clear(element) {
  */
 export function getNamespace(element) {
     // @ts-ignore
-    return element[Property.JSNAMESPACE];
+    return element[JSNAMESPACE];
 }
 /**
  * Writes the cached jsaction namespace to the given DOM Element. Null
@@ -80,7 +80,7 @@ export function getNamespace(element) {
  */
 export function setNamespace(element, jsnamespace) {
     // @ts-ignore
-    element[Property.JSNAMESPACE] = jsnamespace;
+    element[JSNAMESPACE] = jsnamespace;
 }
 /**
  * Clears the cached jsaction namespace from the given DOM Element.
@@ -88,8 +88,8 @@ export function setNamespace(element, jsnamespace) {
  * @param element .
  */
 export function clearNamespace(element) {
-    if (Property.JSNAMESPACE in element) {
-        delete element[Property.JSNAMESPACE];
+    if (JSNAMESPACE in element) {
+        delete element[JSNAMESPACE];
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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