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

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 { bootstrapEventContract, bootstrapEarlyEventContract } from './src/register_events';
 export { EventInfoWrapper } from './src/event_info';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFVBQVUsRUFBRSxrQkFBa0IsRUFBQyxNQUFNLGtCQUFrQixDQUFDO0FBQ2hFLE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLGdDQUFnQyxDQUFDO0FBQ3RFLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUMsc0JBQXNCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUM3RCxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge0Rpc3BhdGNoZXIsIHJlZ2lzdGVyRGlzcGF0Y2hlcn0gZnJvbSAnLi9zcmMvZGlzcGF0Y2hlcic7XG5leHBvcnQge0V2ZW50Q29udHJhY3RDb250YWluZXJ9IGZyb20gJy4vc3JjL2V2ZW50X2NvbnRyYWN0X2NvbnRhaW5lcic7XG5leHBvcnQge0V2ZW50Q29udHJhY3R9IGZyb20gJy4vc3JjL2V2ZW50Y29udHJhY3QnO1xuZXhwb3J0IHtib290c3RyYXBFdmVudENvbnRyYWN0fSBmcm9tICcuL3NyYy9yZWdpc3Rlcl9ldmVudHMnO1xuZXhwb3J0IHtFdmVudEluZm9XcmFwcGVyfSBmcm9tICcuL3NyYy9ldmVudF9pbmZvJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFVBQVUsRUFBRSxrQkFBa0IsRUFBQyxNQUFNLGtCQUFrQixDQUFDO0FBQ2hFLE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLGdDQUFnQyxDQUFDO0FBQ3RFLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUMsc0JBQXNCLEVBQUUsMkJBQTJCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUcxRixPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge0Rpc3BhdGNoZXIsIHJlZ2lzdGVyRGlzcGF0Y2hlcn0gZnJvbSAnLi9zcmMvZGlzcGF0Y2hlcic7XG5leHBvcnQge0V2ZW50Q29udHJhY3RDb250YWluZXJ9IGZyb20gJy4vc3JjL2V2ZW50X2NvbnRyYWN0X2NvbnRhaW5lcic7XG5leHBvcnQge0V2ZW50Q29udHJhY3R9IGZyb20gJy4vc3JjL2V2ZW50Y29udHJhY3QnO1xuZXhwb3J0IHtib290c3RyYXBFdmVudENvbnRyYWN0LCBib290c3RyYXBFYXJseUV2ZW50Q29udHJhY3R9IGZyb20gJy4vc3JjL3JlZ2lzdGVyX2V2ZW50cyc7XG5cbmV4cG9ydCB0eXBlIHtFdmVudENvbnRyYWN0VHJhY2tlcn0gZnJvbSAnLi9zcmMvcmVnaXN0ZXJfZXZlbnRzJztcbmV4cG9ydCB7RXZlbnRJbmZvV3JhcHBlcn0gZnJvbSAnLi9zcmMvZXZlbnRfaW5mbyc7XG4iXX0=

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

@@ -0,0 +1,234 @@
+/**
+ * @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 { Property } 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({ customEventSupport = false, 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 (eventInfoLib.getEventType(eventInfo) === EventType.CUSTOM) {
+                const detail = eventInfoLib.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;
+                }
+                eventInfoLib.setEventType(eventInfo, detail['_type']);
+            }
+        }
+        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[Property.OWNER]) {
+                actionElement = actionElement[Property.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":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC;AAEpC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,YAAY,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,QAAQ,MAAM,SAAS,CAAC;AAEpC;;;GAGG;AACH,MAAM,gBAAgB,GAA4B,EAAE,CAAC;AAErD;;GAEG;AACH,MAAM,gBAAgB,GAAG,SAAS,CAAC;AAEnC,wDAAwD;AACxD,MAAM,kBAAkB,GAAW,SAAS,CAAC,KAAK,CAAC;AAEnD,mCAAmC;AACnC,MAAM,OAAO,cAAc;IAezB,YAAY,EACV,kBAAkB,GAAG,KAAK,EAC1B,0BAA0B,GAAG,KAAK,MAIhC,EAAE;QApBE,qBAAgB,GAAY,KAAK,CAAC;QAIlC,gCAA2B,GAAiD,SAAS,CAAC;QAEtF,+BAA0B,GAAiD,SAAS,CAAC;QAErF,4BAAuB,GAInB,SAAS,CAAC;QASpB,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;QAC7C,IAAI,CAAC,0BAA0B,GAAG,0BAA0B,CAAC;IAC/D,CAAC;IAED,OAAO,CAAC,SAAiC;QACvC,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,IAAI,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,SAAS,CAAC,MAAM,EAAE,CAAC;gBAC9D,MAAM,MAAM,GAAI,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAiB,CAAC,MAAM,CAAC;gBACxE,oEAAoE;gBACpE,4BAA4B;gBAC5B,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;oBAChC,4BAA4B;oBAC5B,OAAO;gBACT,CAAC;gBACD,YAAY,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;QAED,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;;;;;OAWG;IACK,cAAc,CAAC,SAAiC;QACtD,mEAAmE;QACnE,mEAAmE;QACnE,gEAAgE;QAChE,+DAA+D;QAC/D,mEAAmE;QACnE,iDAAiD;QACjD,EAAE;QACF,oEAAoE;QACpE,mEAAmE;QACnE,EAAE;QACF,yCAAyC;QACzC,+CAA+C;QAC/C,EAAE;QACF,4DAA4D;QAC5D,4DAA4D;QAC5D,2DAA2D;QAC3D,WAAW;QACX,EAAE;QACF,mEAAmE;QACnE,+BAA+B;QAC/B,EAAE;QACF,kDAAkD;QAClD,EAAE;QACF,2DAA2D;QAC3D,qDAAqD;QACrD,EAAE;QACF,qEAAqE;QACrE,yDAAyD;QACzD,EAAE;QACF,yDAAyD;QACzD,4EAA4E;QAC5E,4EAA4E;QAC5E,+BAA+B;QAC/B,IACE,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,SAAS,CAAC,KAAK;YACxD,QAAQ,CAAC,oBAAoB,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,EAC/D,CAAC;YACD,YAAY,CAAC,YAAY,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC3D,CAAC;aAAM,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACjC,IAAI,CAAC,2BAA4B,CAAC,SAAS,CAAC,CAAC;QAC/C,CAAC;QAED,oEAAoE;QACpE,gEAAgE;QAChE,yBAAyB;QACzB,IAAI,aAAa,GAAmB,YAAY,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;QAC7E,OAAO,aAAa,IAAI,aAAa,KAAK,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC;YAC/E,IAAI,aAAa,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE,CAAC;gBACjD,IAAI,CAAC,uBAAuB,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;YACzD,CAAC;YAED,IAAI,YAAY,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC;gBACtC,mEAAmE;gBACnE,mEAAmE;gBACnE,2CAA2C;gBAC3C,MAAM;YACR,CAAC;YACD,IAAI,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBAClC,aAAa,GAAG,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAY,CAAC;gBACzD,SAAS;YACX,CAAC;YACD,IAAI,aAAa,CAAC,UAAU,EAAE,QAAQ,KAAK,oBAAoB,EAAE,CAAC;gBAChE,aAAa,GAAG,aAAa,CAAC,UAA4B,CAAC;YAC7D,CAAC;iBAAM,CAAC;gBACN,aAAa,GAAI,aAAa,CAAC,UAAgC,EAAE,IAAI,IAAI,IAAI,CAAC;YAChF,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,YAAY,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QACjD,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,mBAAmB;YACnB,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,0BAA2B,CAAC,SAAS,CAAC,CAAC;QAC9C,CAAC;QAED,gEAAgE;QAChE,gEAAgE;QAChE,+BAA+B;QAC/B,IAAI,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACpC,IACE,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,SAAS,CAAC,UAAU;gBAC7D,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,SAAS,CAAC,UAAU;gBAC7D,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,SAAS,CAAC,YAAY;gBAC/D,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,SAAS,CAAC,YAAY,EAC/D,CAAC;gBACD,gEAAgE;gBAChE,gEAAgE;gBAChE,+BAA+B;gBAC/B,IACE,QAAQ,CAAC,mBAAmB,CAC1B,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,EAChC,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,EACpC,YAAY,CAAC,gBAAgB,CAAC,MAAM,CAAC,CACtC,EACD,CAAC;oBACD,kEAAkE;oBAClE,4DAA4D;oBAC5D,6DAA6D;oBAC7D,mEAAmE;oBACnE,gCAAgC;oBAChC,MAAM,WAAW,GAAG,QAAQ,CAAC,uBAAuB,CAClD,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,EAChC,YAAY,CAAC,gBAAgB,CAAC,MAAM,CAAC,CACtC,CAAC;oBACF,YAAY,CAAC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;oBAC9C,mEAAmE;oBACnE,qEAAqE;oBACrE,wBAAwB;oBACxB,YAAY,CAAC,gBAAgB,CAAC,SAAS,EAAE,YAAY,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;gBAClF,CAAC;qBAAM,CAAC;oBACN,YAAY,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;gBACtC,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;;;;OAUG;IACK,uBAAuB,CAAC,aAAsB,EAAE,SAAiC;QACvF,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;QAEnD,MAAM,UAAU,GAAG,SAAS,CAAC,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;QACnE,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,YAAY,CAAC,SAAS,CAAC,SAAS,EAAE,UAAU,EAAE,aAAa,CAAC,CAAC;QAC/D,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,uBAAwB,CAAC,aAAa,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACK,YAAY,CAAC,aAAsB;QACzC,IAAI,SAAS,GAAwC,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAC9E,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,iBAAiB,GAAG,aAAa,CAAC,YAAY,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACzE,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,SAAS,GAAG,gBAAgB,CAAC;gBAC7B,KAAK,CAAC,GAAG,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;YACtC,CAAC;iBAAM,CAAC;gBACN,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;gBAC/C,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,SAAS,GAAG,EAAE,CAAC;oBACf,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;oBACzD,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC;wBAC7C,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;wBAC1B,IAAI,CAAC,KAAK,EAAE,CAAC;4BACX,SAAS;wBACX,CAAC;wBACD,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;wBACzD,MAAM,QAAQ,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC;wBAC9B,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC;wBAC3E,MAAM,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;wBACjE,SAAS,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;oBAC3B,CAAC;oBACD,KAAK,CAAC,SAAS,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAC;gBAChD,CAAC;gBACD,KAAK,CAAC,GAAG,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;YACtC,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,mBAAmB,CACjB,2BAAyE,EACzE,0BAAuE,EACvE,uBAAiE;QAEjE,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,2BAA2B,GAAG,2BAA2B,CAAC;QAC/D,IAAI,CAAC,0BAA0B,GAAG,0BAA0B,CAAC;QAC7D,IAAI,CAAC,uBAAuB,GAAG,uBAAuB,CAAC;IACzD,CAAC;CACF","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 {Property} 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 customEventSupport: boolean;\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    customEventSupport = false,\n    syntheticMouseEventSupport = false,\n  }: {\n    customEventSupport?: boolean;\n    syntheticMouseEventSupport?: boolean;\n  } = {}) {\n    this.customEventSupport = customEventSupport;\n    this.syntheticMouseEventSupport = syntheticMouseEventSupport;\n  }\n\n  resolve(eventInfo: eventInfoLib.EventInfo) {\n    if (this.customEventSupport) {\n      if (eventInfoLib.getEventType(eventInfo) === EventType.CUSTOM) {\n        const detail = (eventInfoLib.getEvent(eventInfo) as CustomEvent).detail;\n        // For custom events, use a secondary dispatch based on the internal\n        // custom type of the event.\n        if (!detail || !detail['_type']) {\n          // This should never happen.\n          return;\n        }\n        eventInfoLib.setEventType(eventInfo, detail['_type']);\n      }\n    }\n\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[Property.OWNER]) {\n        actionElement = actionElement[Property.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/base_dispatcher.mjs

@@ -47,20 +47,18 @@ export class BaseDispatcher {
      *
      * @param eventInfo The info for the event that triggered this call or the
      *     queue of events from EventContract.
-     * @param isGlobalDispatch If true, dispatches a global event instead of a
-     *     regular jsaction handler.
      */
-    dispatch(eventInfo, isGlobalDispatch) {
+    dispatch(eventInfo) {
         const eventInfoWrapper = new EventInfoWrapper(eventInfo);
         if (eventInfoWrapper.getIsReplay()) {
-            if (isGlobalDispatch || !this.eventReplayer) {
+            if (!this.eventReplayer) {
                 return;
             }
             this.queueEventInfoWrapper(eventInfoWrapper);
             this.scheduleEventReplay();
             return;
         }
-        this.dispatchDelegate(eventInfoWrapper, isGlobalDispatch);
+        this.dispatchDelegate(eventInfoWrapper);
     }
     /** Queue an `EventInfoWrapper` for replay. */
     queueEventInfoWrapper(eventInfoWrapper) {
@@ -89,8 +87,8 @@ export class BaseDispatcher {
  * Dispatcher.
  */
 export function registerDispatcher(eventContract, dispatcher) {
-    eventContract.ecrd((eventInfo, globalDispatch) => {
-        dispatcher.dispatch(eventInfo, globalDispatch);
+    eventContract.ecrd((eventInfo) => {
+        dispatcher.dispatch(eventInfo);
     }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base_dispatcher.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/base_dispatcher.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAY,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAEzD,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAU1C;;;;GAIG;AACH,MAAM,OAAO,cAAc;IAQzB;;;;;;OAMG;IACH,YACmB,gBAGR,EACT,EAAC,aAAa,GAAG,SAAS,KAAgC,EAAE;QAJ3C,qBAAgB,GAAhB,gBAAgB,CAGxB;QAlBX,2BAA2B;QACV,4BAAuB,GAAuB,EAAE,CAAC;QAGlE,6CAA6C;QACrC,yBAAoB,GAAG,KAAK,CAAC;QAgBnC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACrC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,SAAoB,EAAE,gBAA0B;QACvD,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,SAAS,CAAC,CAAC;QACzD,IAAI,gBAAgB,CAAC,WAAW,EAAE,EAAE,CAAC;YACnC,IAAI,gBAAgB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;gBAC5C,OAAO;YACT,CAAC;YACD,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,CAAC,CAAC;YAC7C,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,OAAO;QACT,CAAC;QACD,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;IAC5D,CAAC;IAED,8CAA8C;IAC9C,qBAAqB,CAAC,gBAAkC;QACtD,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACtD,CAAC;IAED;;;;OAIG;IACH,mBAAmB;QACjB,IACE,IAAI,CAAC,oBAAoB;YACzB,CAAC,IAAI,CAAC,aAAa;YACnB,IAAI,CAAC,uBAAuB,CAAC,MAAM,KAAK,CAAC,EACzC,CAAC;YACD,OAAO;QACT,CAAC;QACD,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;QACjC,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YAC1B,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC;YAClC,IAAI,CAAC,aAAc,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAChC,aAAqC,EACrC,UAA0B;IAE1B,aAAa,CAAC,IAAI,CAAC,CAAC,SAAoB,EAAE,cAAwB,EAAE,EAAE;QACpE,UAAU,CAAC,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;IACjD,CAAC,EAAE,WAAW,CAAC,2BAA2B,CAAC,CAAC;AAC9C,CAAC","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 {EventInfo, EventInfoWrapper} from './event_info';\nimport {UnrenamedEventContract} from './eventcontract';\nimport {Restriction} from './restriction';\n/**\n * A replayer is a function that is called when there are queued events,\n * either from the `EventContract` or when there are no detected handlers.\n */\nexport type Replayer = (eventInfoWrappers: EventInfoWrapper[]) => void;\n/**\n * A handler is dispatched to during normal handling.\n */\nexport type EventInfoWrapperHandler = (eventInfoWrapper: EventInfoWrapper) => void;\n/**\n * Receives a DOM event, determines the jsaction associated with the source\n * element of the DOM event, and invokes the handler associated with the\n * jsaction.\n */\nexport class BaseDispatcher {\n  /** The queue of events. */\n  private readonly queuedEventInfoWrappers: EventInfoWrapper[] = [];\n  /** The replayer function to be called when there are queued events. */\n  private eventReplayer?: Replayer;\n  /** Whether the event replay is scheduled. */\n  private eventReplayScheduled = false;\n\n  /**\n   * Options are:\n   *   1. `eventReplayer`: When the event contract dispatches replay events\n   *      to the Dispatcher, the Dispatcher collects them and in the next tick\n   *      dispatches them to the `eventReplayer`.\n   * @param dispatchDelegate A function that should handle dispatching an `EventInfoWrapper` to handlers.\n   */\n  constructor(\n    private readonly dispatchDelegate: (\n      eventInfoWrapper: EventInfoWrapper,\n      isGlobalDispatch?: boolean,\n    ) => void,\n    {eventReplayer = undefined}: {eventReplayer?: Replayer} = {},\n  ) {\n    this.eventReplayer = eventReplayer;\n  }\n\n  /**\n   * Receives an event or the event queue from the EventContract. The event\n   * queue is copied and it attempts to replay.\n   * If event info is passed in it looks for an action handler that can handle\n   * the given event.  If there is no handler registered queues the event and\n   * checks if a loader is registered for the given namespace. If so, calls it.\n   *\n   * Alternatively, if in global dispatch mode, calls all registered global\n   * handlers for the appropriate event type.\n   *\n   * The three functionalities of this call are deliberately not split into\n   * three methods (and then declared as an abstract interface), because the\n   * interface is used by EventContract, which lives in a different jsbinary.\n   * Therefore the interface between the three is defined entirely in terms that\n   * are invariant under jscompiler processing (Function and Array, as opposed\n   * to a custom type with method names).\n   *\n   * @param eventInfo The info for the event that triggered this call or the\n   *     queue of events from EventContract.\n   * @param isGlobalDispatch If true, dispatches a global event instead of a\n   *     regular jsaction handler.\n   */\n  dispatch(eventInfo: EventInfo, isGlobalDispatch?: boolean): void {\n    const eventInfoWrapper = new EventInfoWrapper(eventInfo);\n    if (eventInfoWrapper.getIsReplay()) {\n      if (isGlobalDispatch || !this.eventReplayer) {\n        return;\n      }\n      this.queueEventInfoWrapper(eventInfoWrapper);\n      this.scheduleEventReplay();\n      return;\n    }\n    this.dispatchDelegate(eventInfoWrapper, isGlobalDispatch);\n  }\n\n  /** Queue an `EventInfoWrapper` for replay. */\n  queueEventInfoWrapper(eventInfoWrapper: EventInfoWrapper) {\n    this.queuedEventInfoWrappers.push(eventInfoWrapper);\n  }\n\n  /**\n   * Replays queued events, if any. The replaying will happen in its own\n   * stack once the current flow cedes control. This is done to mimic\n   * browser event handling.\n   */\n  scheduleEventReplay() {\n    if (\n      this.eventReplayScheduled ||\n      !this.eventReplayer ||\n      this.queuedEventInfoWrappers.length === 0\n    ) {\n      return;\n    }\n    this.eventReplayScheduled = true;\n    Promise.resolve().then(() => {\n      this.eventReplayScheduled = false;\n      this.eventReplayer!(this.queuedEventInfoWrappers);\n    });\n  }\n}\n\n/**\n * Registers deferred functionality for an EventContract and a Jsaction\n * Dispatcher.\n */\nexport function registerDispatcher(\n  eventContract: UnrenamedEventContract,\n  dispatcher: BaseDispatcher,\n) {\n  eventContract.ecrd((eventInfo: EventInfo, globalDispatch?: boolean) => {\n    dispatcher.dispatch(eventInfo, globalDispatch);\n  }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -50,6 +50,9 @@ export function createCustomEvent(type, data, triggeringEvent) {
  * Fires a custom event with an optional payload. Only intended to be consumed
  * by jsaction itself. Supported in Firefox 6+, IE 9+, and all Chrome versions.
  *
+ * `bootstrapCustomEventSupport` is required to add a listener that handles the
+ * event.
+ *
  * @param target The target element.
  * @param type The type of the action, e.g., 'submit'.
  * @param data An optional data payload.
@@ -60,4 +63,40 @@ export function fireCustomEvent(target, type, data, triggeringEvent) {
     const event = createCustomEvent(type, data, triggeringEvent);
     target.dispatchEvent(event);
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Bootstraps `CustomEvent` support on the container.
+ *
+ * This is required to handle events fired by `fireCustomEvent` in the `container`.
+ *
+ * @param container The JSAction container to add an event listener on.
+ * @param trigger A function that can trigger JSAction Event dispatch. Generally this function
+ *    should delegate to an `EventContract` handler for the event type provided defined by
+ *    `event.detail['_type']`.
+ * @returns A function that removes the event listener.
+ */
+export function bootstrapCustomEventSupport(container, trigger) {
+    const customEventListener = (event) => {
+        let customEvent = event;
+        const detail = customEvent.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;
+        }
+        // Mirrors code from Wiz's internal `trigger()` method.
+        const syntheticCustomEvent = {
+            'type': detail['_type'],
+            'target': event.target,
+            'bubbles': true,
+            detail,
+        };
+        // tslint:disable-next-line:no-any
+        trigger(syntheticCustomEvent);
+    };
+    container.addEventListener('_custom', customEventListener);
+    return () => {
+        container.removeEventListener('_custom', customEventListener);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom_events.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/custom_events.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,SAAS,EAAC,MAAM,eAAe,CAAC;AAexC;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAI,IAAY,EAAE,IAAQ,EAAE,eAAuB;IAClF,IAAI,KAAqE,CAAC;IAC1E,MAAM,eAAe,GAA+B;QAClD,OAAO,EAAE,IAAI;KACd,CAAC;IACF,MAAM,aAAa,GAAyB;QAC1C,IAAI;QACJ,IAAI;QACJ,eAAe;KAChB,CAAC;IACF,MAAM,MAAM,GAAG,EAAC,GAAG,eAAe,EAAE,GAAG,aAAa,EAAC,CAAC;IACtD,IAAI,CAAC;QACH,mEAAmE;QACnE,qEAAqE;QACrE,KAAK,GAAG,QAAQ,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;QAC5C,KAAK,CAAC,eAAe,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAC/D,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,0EAA0E;QAC1E,+CAA+C;QAE/C,4EAA4E;QAC5E,QAAQ;QACR,kCAAkC;QAClC,KAAK,GAAG,QAAQ,CAAC,WAAW,CAAC,YAAY,CAAQ,CAAC;QAClD,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QAC/C,wEAAwE;QACxE,kCAAkC;QACjC,KAAa,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;IACpC,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAe,EACf,IAAY,EACZ,IAAQ,EACR,eAAuB;IAEvB,MAAM,KAAK,GAAG,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,eAAe,CAAC,CAAC;IAC7D,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,2BAA2B,CAAC,SAAkB,EAAE,OAA+B;IAC7F,MAAM,mBAAmB,GAAG,CAAC,KAAY,EAAE,EAAE;QAC3C,IAAI,WAAW,GAAG,KAAoB,CAAC;QACvC,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;QAClC,oEAAoE;QACpE,4BAA4B;QAC5B,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,4BAA4B;YAC5B,OAAO;QACT,CAAC;QACD,uDAAuD;QACvD,MAAM,oBAAoB,GAAG;YAC3B,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC;YACvB,QAAQ,EAAE,KAAK,CAAC,MAAM;YACtB,SAAS,EAAE,IAAI;YACf,MAAM;SACP,CAAC;QACF,kCAAkC;QAClC,OAAO,CAAC,oBAA2B,CAAC,CAAC;IACvC,CAAC,CAAC;IACF,SAAS,CAAC,gBAAgB,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;IAC3D,OAAO,GAAG,EAAE;QACV,SAAS,CAAC,mBAAmB,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;IAChE,CAAC,CAAC;AACJ,CAAC","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 {EventType} from './/event_type';\n\n// We use '_type' for the event contract, which lives in a separate\n// compilation unit.\ndeclare interface UnrenamedCustomEventDetail {\n  _type: string;\n}\n\n/** The detail interface provided for custom events. */\nexport interface CustomEventDetail<T> {\n  type: string;\n  data?: T;\n  triggeringEvent?: Event;\n}\n\n/**\n * Create a custom event with the specified data.\n * @param type The type of the action, e.g., 'submit'.\n * @param data An optional data payload.\n * @param triggeringEvent The event that triggers this custom event. This can be\n *     accessed from the custom event's action flow like so:\n *     actionFlow.event().detail.triggeringEvent.\n * @return The new custom event.\n */\nexport function createCustomEvent<T>(type: string, data?: T, triggeringEvent?: Event): Event {\n  let event: CustomEvent<CustomEventDetail<T> & UnrenamedCustomEventDetail>;\n  const unrenamedDetail: UnrenamedCustomEventDetail = {\n    '_type': type,\n  };\n  const renamedDetail: CustomEventDetail<T> = {\n    type,\n    data,\n    triggeringEvent,\n  };\n  const detail = {...unrenamedDetail, ...renamedDetail};\n  try {\n    // We don't use the CustomEvent constructor directly since it isn't\n    // supported in IE 9 or 10 and initCustomEvent below works just fine.\n    event = document.createEvent('CustomEvent');\n    event.initCustomEvent(EventType.CUSTOM, true, false, detail);\n  } catch (e) {\n    // If custom events aren't supported, fall back to custom-named HTMLEvent.\n    // Fallback used by Android Gingerbread, FF4-5.\n\n    // Hack to emulate `CustomEvent`, `HTMLEvents` doesn't satisfy `CustomEvent`\n    // type.\n    // tslint:disable-next-line:no-any\n    event = document.createEvent('HTMLEvents') as any;\n    event.initEvent(EventType.CUSTOM, true, false);\n    // Hack to emulate `CustomEvent`, `detail` is readonly on `CustomEvent`.\n    // tslint:disable-next-line:no-any\n    (event as any)['detail'] = detail;\n  }\n\n  return event;\n}\n\n/**\n * Fires a custom event with an optional payload. Only intended to be consumed\n * by jsaction itself. Supported in Firefox 6+, IE 9+, and all Chrome versions.\n *\n * `bootstrapCustomEventSupport` is required to add a listener that handles the\n * event.\n *\n * @param target The target element.\n * @param type The type of the action, e.g., 'submit'.\n * @param data An optional data payload.\n * @param triggeringEvent An optional data for the Event triggered this custom\n *     event.\n */\nexport function fireCustomEvent<T>(\n  target: Element,\n  type: string,\n  data?: T,\n  triggeringEvent?: Event,\n) {\n  const event = createCustomEvent(type, data, triggeringEvent);\n  target.dispatchEvent(event);\n}\n\n/**\n * Bootstraps `CustomEvent` support on the container.\n *\n * This is required to handle events fired by `fireCustomEvent` in the `container`.\n *\n * @param container The JSAction container to add an event listener on.\n * @param trigger A function that can trigger JSAction Event dispatch. Generally this function\n *    should delegate to an `EventContract` handler for the event type provided defined by\n *    `event.detail['_type']`.\n * @returns A function that removes the event listener.\n */\nexport function bootstrapCustomEventSupport(container: Element, trigger: (event: Event) => void) {\n  const customEventListener = (event: Event) => {\n    let customEvent = event as CustomEvent;\n    const detail = customEvent.detail;\n    // For custom events, use a secondary dispatch based on the internal\n    // custom type of the event.\n    if (!detail || !detail['_type']) {\n      // This should never happen.\n      return;\n    }\n    // Mirrors code from Wiz's internal `trigger()` method.\n    const syntheticCustomEvent = {\n      'type': detail['_type'],\n      'target': event.target,\n      'bubbles': true,\n      detail,\n    };\n    // tslint:disable-next-line:no-any\n    trigger(syntheticCustomEvent as any);\n  };\n  container.addEventListener('_custom', customEventListener);\n  return () => {\n    container.removeEventListener('_custom', customEventListener);\n  };\n}\n"]}

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

@@ -35,8 +35,8 @@ export class Dispatcher {
         /** A map of global event handlers, where each key is an event type. */
         this.globalHandlers = new Map();
         this.eventReplayer = eventReplayer;
-        this.baseDispatcher = new BaseDispatcher((eventInfoWrapper, isGlobalDispatch) => {
-            this.dispatchToHandler(eventInfoWrapper, isGlobalDispatch);
+        this.baseDispatcher = new BaseDispatcher((eventInfoWrapper) => {
+            this.dispatchToHandler(eventInfoWrapper);
         }, {
             eventReplayer: (eventInfoWrappers) => {
                 this.eventReplayer?.(eventInfoWrappers, this);
@@ -63,38 +63,45 @@ export class Dispatcher {
      *
      * @param eventInfo The info for the event that triggered this call or the
      *     queue of events from EventContract.
-     * @param isGlobalDispatch If true, dispatches a global event instead of a
-     *     regular jsaction handler.
      */
     dispatch(eventInfo, isGlobalDispatch) {
-        this.baseDispatcher.dispatch(eventInfo, isGlobalDispatch);
+        this.baseDispatcher.dispatch(eventInfo);
     }
     /**
      * Dispatches an `EventInfoWrapper`.
      */
-    dispatchToHandler(eventInfoWrapper, isGlobalDispatch) {
-        if (isGlobalDispatch) {
+    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 ev = eventInfoWrapper.getEvent();
-            const eventTypeHandlers = this.globalHandlers.get(eventInfoWrapper.getEventType());
+            const event = globalEventInfoWrapper.getEvent();
+            const eventTypeHandlers = this.globalHandlers.get(globalEventInfoWrapper.getEventType());
             let shouldPreventDefault = false;
             if (eventTypeHandlers) {
                 for (const handler of eventTypeHandlers) {
-                    if (handler(ev) === false) {
+                    if (handler(event) === false) {
                         shouldPreventDefault = true;
                     }
                 }
             }
             if (shouldPreventDefault) {
-                eventLib.preventDefault(ev);
+                eventLib.preventDefault(event);
             }
+        }
+        const action = eventInfoWrapper.getAction();
+        if (!action) {
             return;
         }
         if (this.stopPropagation) {
             stopPropagation(eventInfoWrapper);
         }
-        const action = eventInfoWrapper.getAction();
         let handler = undefined;
         if (this.getHandler) {
             handler = this.getHandler(eventInfoWrapper);
@@ -246,8 +253,8 @@ export function stopPropagation(eventInfoWrapper) {
  * Dispatcher.
  */
 export function registerDispatcher(eventContract, dispatcher) {
-    eventContract.ecrd((eventInfo, globalDispatch) => {
-        dispatcher.dispatch(eventInfo, globalDispatch);
+    eventContract.ecrd((eventInfo) => {
+        dispatcher.dispatch(eventInfo);
     }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dispatcher.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/dispatcher.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 {BaseDispatcher, EventInfoWrapperHandler} from './base_dispatcher';\nimport {Char} from './char';\nimport * as eventLib from './event';\nimport {EventInfo, EventInfoWrapper} from './event_info';\nimport {EventType} from './event_type';\nimport {UnrenamedEventContract} from './eventcontract';\nimport {Restriction} from './restriction';\n\nexport type {EventInfoWrapperHandler as EventInfoHandler} from './base_dispatcher';\n\n/**\n * A global handler is dispatched to before normal handler dispatch. Returning\n * false will `preventDefault` on the event.\n */\nexport type GlobalHandler = (event: Event) => boolean | void;\n\n/**\n * A replayer is a function that is called when there are queued events,\n * either from the `EventContract` or when there are no detected handlers.\n */\nexport type Replayer = (eventInfoWrappers: EventInfoWrapper[], dispatcher: Dispatcher) => void;\n\n/**\n * Receives a DOM event, determines the jsaction associated with the source\n * element of the DOM event, and invokes the handler associated with the\n * jsaction.\n */\nexport class Dispatcher {\n  private readonly baseDispatcher: BaseDispatcher;\n\n  /** Whether to stop propagation for an `EventInfo`. */\n  private readonly stopPropagation: boolean;\n\n  /**\n   * The actions that are registered for this Dispatcher instance.\n   * This should be the primary one used once migration off of registerHandlers\n   * is done.\n   */\n  private readonly actions: {[key: string]: EventInfoWrapperHandler} = {};\n\n  /** A map of global event handlers, where each key is an event type. */\n  private readonly globalHandlers = new Map<string, Set<GlobalHandler>>();\n\n  /** The event replayer. */\n  private eventReplayer?: Replayer;\n\n  /**\n   * Receives a DOM event, determines the jsaction associated with the source\n   * element of the DOM event, and invokes the handler associated with the\n   * jsaction.\n   *\n   * @param getHandler A function that knows how to get the handler for a\n   *     given event info.\n   */\n  constructor(\n    private readonly getHandler?: (\n      eventInfoWrapper: EventInfoWrapper,\n    ) => EventInfoWrapperHandler | void,\n    {\n      stopPropagation = false,\n      eventReplayer = undefined,\n    }: {stopPropagation?: boolean; eventReplayer?: Replayer} = {},\n  ) {\n    this.eventReplayer = eventReplayer;\n    this.baseDispatcher = new BaseDispatcher(\n      (eventInfoWrapper: EventInfoWrapper, isGlobalDispatch?: boolean) => {\n        this.dispatchToHandler(eventInfoWrapper, isGlobalDispatch);\n      },\n      {\n        eventReplayer: (eventInfoWrappers) => {\n          this.eventReplayer?.(eventInfoWrappers, this);\n        },\n      },\n    );\n    this.stopPropagation = stopPropagation;\n  }\n\n  /**\n   * Receives an event or the event queue from the EventContract. The event\n   * queue is copied and it attempts to replay.\n   * If event info is passed in it looks for an action handler that can handle\n   * the given event.  If there is no handler registered queues the event and\n   * checks if a loader is registered for the given namespace. If so, calls it.\n   *\n   * Alternatively, if in global dispatch mode, calls all registered global\n   * handlers for the appropriate event type.\n   *\n   * The three functionalities of this call are deliberately not split into\n   * three methods (and then declared as an abstract interface), because the\n   * interface is used by EventContract, which lives in a different jsbinary.\n   * Therefore the interface between the three is defined entirely in terms that\n   * are invariant under jscompiler processing (Function and Array, as opposed\n   * to a custom type with method names).\n   *\n   * @param eventInfo The info for the event that triggered this call or the\n   *     queue of events from EventContract.\n   * @param isGlobalDispatch If true, dispatches a global event instead of a\n   *     regular jsaction handler.\n   */\n  dispatch(eventInfo: EventInfo, isGlobalDispatch?: boolean): void {\n    this.baseDispatcher.dispatch(eventInfo, isGlobalDispatch);\n  }\n\n  /**\n   * Dispatches an `EventInfoWrapper`.\n   */\n  private dispatchToHandler(eventInfoWrapper: EventInfoWrapper, isGlobalDispatch?: boolean) {\n    if (isGlobalDispatch) {\n      // Skip everything related to jsaction handlers, and execute the global\n      // handlers.\n      const ev = eventInfoWrapper.getEvent();\n      const eventTypeHandlers = this.globalHandlers.get(eventInfoWrapper.getEventType());\n      let shouldPreventDefault = false;\n      if (eventTypeHandlers) {\n        for (const handler of eventTypeHandlers) {\n          if (handler(ev) === false) {\n            shouldPreventDefault = true;\n          }\n        }\n      }\n      if (shouldPreventDefault) {\n        eventLib.preventDefault(ev);\n      }\n      return;\n    }\n\n    if (this.stopPropagation) {\n      stopPropagation(eventInfoWrapper);\n    }\n\n    const action = eventInfoWrapper.getAction()!;\n\n    let handler: EventInfoWrapperHandler | void = undefined;\n    if (this.getHandler) {\n      handler = this.getHandler(eventInfoWrapper);\n    }\n\n    if (!handler) {\n      handler = this.actions[action.name];\n    }\n\n    if (handler) {\n      handler(eventInfoWrapper);\n      return;\n    }\n\n    // No handler was found.\n    this.baseDispatcher.queueEventInfoWrapper(eventInfoWrapper);\n  }\n\n  /**\n   * Registers multiple methods all bound to the same object\n   * instance. This is a common case: an application module binds\n   * multiple of its methods under public names to the event contract of\n   * the application. So we provide a shortcut for it.\n   * Attempts to replay the queued events after registering the handlers.\n   *\n   * @param namespace The namespace of the jsaction name.\n   *\n   * @param instance The object to bind the methods to. If this is null, then\n   *     the functions are not bound, but directly added under the public names.\n   *\n   * @param methods A map from public name to functions that will be bound to\n   *     instance and registered as action under the public name. I.e. the\n   *     property names are the public names. The property values are the\n   *     methods of instance.\n   */\n  registerEventInfoHandlers<T>(\n    namespace: string,\n    instance: T | null,\n    methods: {[key: string]: EventInfoWrapperHandler},\n  ) {\n    for (const [name, method] of Object.entries(methods)) {\n      const handler = instance ? method.bind(instance) : method;\n      if (namespace) {\n        // Include a '.' separator between namespace name and action name.\n        // In the case that no namespace name is provided, the jsaction name\n        // consists of the action name only (no period).\n        const fullName = namespace + Char.NAMESPACE_ACTION_SEPARATOR + name;\n        this.actions[fullName] = handler;\n      } else {\n        this.actions[name] = handler;\n      }\n    }\n\n    this.baseDispatcher.scheduleEventReplay();\n  }\n\n  /**\n   * Unregisters an action.  Provided as an easy way to reverse the effects of\n   * registerHandlers.\n   * @param namespace The namespace of the jsaction name.\n   * @param name The action name to unbind.\n   */\n  unregisterHandler(namespace: string, name: string) {\n    const fullName = namespace ? namespace + Char.NAMESPACE_ACTION_SEPARATOR + name : name;\n    delete this.actions[fullName];\n  }\n\n  /** Registers a global event handler. */\n  registerGlobalHandler(eventType: string, handler: GlobalHandler) {\n    if (!this.globalHandlers.has(eventType)) {\n      this.globalHandlers.set(eventType, new Set<GlobalHandler>([handler]));\n    } else {\n      this.globalHandlers.get(eventType)!.add(handler);\n    }\n  }\n\n  /** Unregisters a global event handler. */\n  unregisterGlobalHandler(eventType: string, handler: GlobalHandler) {\n    if (this.globalHandlers.has(eventType)) {\n      this.globalHandlers.get(eventType)!.delete(handler);\n    }\n  }\n\n  /**\n   * Checks whether there is an action registered under the given\n   * name. This returns true if there is a namespace handler, even\n   * if it can not yet handle the event.\n   *\n   * @param name Action name.\n   * @return Whether the name is registered.\n   * @see #canDispatch\n   */\n  hasAction(name: string): boolean {\n    return this.actions.hasOwnProperty(name);\n  }\n\n  /**\n   * Whether this dispatcher can dispatch the event. This can be used by\n   * event replayer to check whether the dispatcher can replay an event.\n   */\n  canDispatch(eventInfoWrapper: EventInfoWrapper): boolean {\n    const action = eventInfoWrapper.getAction();\n    if (!action) {\n      return false;\n    }\n    return this.hasAction(action.name);\n  }\n\n  /**\n   * Sets the event replayer, enabling queued events to be replayed when actions\n   * are bound. To replay events, you must register the dispatcher to the\n   * contract after setting the `EventReplayer`. The event replayer takes as\n   * parameters the queue of events and the dispatcher (used to check whether\n   * actions have handlers registered and can be replayed). The event replayer\n   * is also responsible for dequeuing events.\n   *\n   * Example: An event replayer that replays only the last event.\n   *\n   *   const dispatcher = new Dispatcher();\n   *   // ...\n   *   dispatcher.setEventReplayer((queue, dispatcher) => {\n   *     const lastEventInfoWrapper = queue[queue.length -1];\n   *     if (dispatcher.canDispatch(lastEventInfoWrapper.getAction())) {\n   *       jsaction.replay.replayEvent(\n   *           lastEventInfoWrapper.getEvent(),\n   *           lastEventInfoWrapper.getTargetElement(),\n   *           lastEventInfoWrapper.getEventType(),\n   *       );\n   *       queue.length = 0;\n   *     }\n   *   });\n   *\n   * @param eventReplayer It allows elements to be replayed and dequeuing.\n   */\n  setEventReplayer(eventReplayer: Replayer) {\n    this.eventReplayer = eventReplayer;\n  }\n}\n\n/** Stop propagation for an `EventInfo`. */\nexport function stopPropagation(eventInfoWrapper: EventInfoWrapper) {\n  if (\n    eventLib.isGecko &&\n    (eventInfoWrapper.getTargetElement().tagName === 'INPUT' ||\n      eventInfoWrapper.getTargetElement().tagName === 'TEXTAREA') &&\n    eventInfoWrapper.getEventType() === EventType.FOCUS\n  ) {\n    /**\n     * Do nothing since stopping propagation on a focus event on an input\n     * element in Firefox makes the text cursor disappear:\n     * https://bugzilla.mozilla.org/show_bug.cgi?id=509684\n     */\n    return;\n  }\n\n  const event = eventInfoWrapper.getEvent();\n  // There are some cases where users of the `Dispatcher` will call dispatch\n  // with a fake event that does not support `stopPropagation`.\n  if (!event.stopPropagation) {\n    return;\n  }\n  event.stopPropagation();\n}\n\n/**\n * Registers deferred functionality for an EventContract and a Jsaction\n * Dispatcher.\n */\nexport function registerDispatcher(eventContract: UnrenamedEventContract, dispatcher: Dispatcher) {\n  eventContract.ecrd((eventInfo: EventInfo, globalDispatch?: boolean) => {\n    dispatcher.dispatch(eventInfo, globalDispatch);\n  }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dispatcher.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/dispatcher.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 {BaseDispatcher, EventInfoWrapperHandler} from './base_dispatcher';\nimport {Char} from './char';\nimport * as eventLib from './event';\nimport {EventInfo, EventInfoWrapper} from './event_info';\nimport {EventType} from './event_type';\nimport {UnrenamedEventContract} from './eventcontract';\nimport {Restriction} from './restriction';\n\nexport type {EventInfoWrapperHandler as EventInfoHandler} from './base_dispatcher';\n\n/**\n * A global handler is dispatched to before normal handler dispatch. Returning\n * false will `preventDefault` on the event.\n */\nexport type GlobalHandler = (event: Event) => boolean | void;\n\n/**\n * A replayer is a function that is called when there are queued events,\n * either from the `EventContract` or when there are no detected handlers.\n */\nexport type Replayer = (eventInfoWrappers: EventInfoWrapper[], dispatcher: Dispatcher) => void;\n\n/**\n * Receives a DOM event, determines the jsaction associated with the source\n * element of the DOM event, and invokes the handler associated with the\n * jsaction.\n */\nexport class Dispatcher {\n  private readonly baseDispatcher: BaseDispatcher;\n\n  /** Whether to stop propagation for an `EventInfo`. */\n  private readonly stopPropagation: boolean;\n\n  /**\n   * The actions that are registered for this Dispatcher instance.\n   * This should be the primary one used once migration off of registerHandlers\n   * is done.\n   */\n  private readonly actions: {[key: string]: EventInfoWrapperHandler} = {};\n\n  /** A map of global event handlers, where each key is an event type. */\n  private readonly globalHandlers = new Map<string, Set<GlobalHandler>>();\n\n  /** The event replayer. */\n  private eventReplayer?: Replayer;\n\n  /**\n   * Receives a DOM event, determines the jsaction associated with the source\n   * element of the DOM event, and invokes the handler associated with the\n   * jsaction.\n   *\n   * @param getHandler A function that knows how to get the handler for a\n   *     given event info.\n   */\n  constructor(\n    private readonly getHandler?: (\n      eventInfoWrapper: EventInfoWrapper,\n    ) => EventInfoWrapperHandler | void,\n    {\n      stopPropagation = false,\n      eventReplayer = undefined,\n    }: {stopPropagation?: boolean; eventReplayer?: Replayer} = {},\n  ) {\n    this.eventReplayer = eventReplayer;\n    this.baseDispatcher = new BaseDispatcher(\n      (eventInfoWrapper: EventInfoWrapper) => {\n        this.dispatchToHandler(eventInfoWrapper);\n      },\n      {\n        eventReplayer: (eventInfoWrappers) => {\n          this.eventReplayer?.(eventInfoWrappers, this);\n        },\n      },\n    );\n    this.stopPropagation = stopPropagation;\n  }\n\n  /**\n   * Receives an event or the event queue from the EventContract. The event\n   * queue is copied and it attempts to replay.\n   * If event info is passed in it looks for an action handler that can handle\n   * the given event.  If there is no handler registered queues the event and\n   * checks if a loader is registered for the given namespace. If so, calls it.\n   *\n   * Alternatively, if in global dispatch mode, calls all registered global\n   * handlers for the appropriate event type.\n   *\n   * The three functionalities of this call are deliberately not split into\n   * three methods (and then declared as an abstract interface), because the\n   * interface is used by EventContract, which lives in a different jsbinary.\n   * Therefore the interface between the three is defined entirely in terms that\n   * are invariant under jscompiler processing (Function and Array, as opposed\n   * to a custom type with method names).\n   *\n   * @param eventInfo The info for the event that triggered this call or the\n   *     queue of events from EventContract.\n   */\n  dispatch(eventInfo: EventInfo, isGlobalDispatch?: boolean): void {\n    this.baseDispatcher.dispatch(eventInfo);\n  }\n\n  /**\n   * Dispatches an `EventInfoWrapper`.\n   */\n  private dispatchToHandler(eventInfoWrapper: EventInfoWrapper) {\n    if (this.globalHandlers.size) {\n      const globalEventInfoWrapper = eventInfoWrapper.clone();\n\n      // In some cases, `populateAction` will rewrite `click` events to\n      // `clickonly`. Revert back to a regular click, otherwise we won't be able\n      // to execute global event handlers registered on click events.\n      if (globalEventInfoWrapper.getEventType() === EventType.CLICKONLY) {\n        globalEventInfoWrapper.setEventType(EventType.CLICK);\n      }\n      // Skip everything related to jsaction handlers, and execute the global\n      // handlers.\n      const event = globalEventInfoWrapper.getEvent();\n      const eventTypeHandlers = this.globalHandlers.get(globalEventInfoWrapper.getEventType());\n      let shouldPreventDefault = false;\n      if (eventTypeHandlers) {\n        for (const handler of eventTypeHandlers) {\n          if (handler(event) === false) {\n            shouldPreventDefault = true;\n          }\n        }\n      }\n      if (shouldPreventDefault) {\n        eventLib.preventDefault(event);\n      }\n    }\n\n    const action = eventInfoWrapper.getAction();\n    if (!action) {\n      return;\n    }\n\n    if (this.stopPropagation) {\n      stopPropagation(eventInfoWrapper);\n    }\n\n    let handler: EventInfoWrapperHandler | void = undefined;\n    if (this.getHandler) {\n      handler = this.getHandler(eventInfoWrapper);\n    }\n\n    if (!handler) {\n      handler = this.actions[action.name];\n    }\n\n    if (handler) {\n      handler(eventInfoWrapper);\n      return;\n    }\n\n    // No handler was found.\n    this.baseDispatcher.queueEventInfoWrapper(eventInfoWrapper);\n  }\n\n  /**\n   * Registers multiple methods all bound to the same object\n   * instance. This is a common case: an application module binds\n   * multiple of its methods under public names to the event contract of\n   * the application. So we provide a shortcut for it.\n   * Attempts to replay the queued events after registering the handlers.\n   *\n   * @param namespace The namespace of the jsaction name.\n   *\n   * @param instance The object to bind the methods to. If this is null, then\n   *     the functions are not bound, but directly added under the public names.\n   *\n   * @param methods A map from public name to functions that will be bound to\n   *     instance and registered as action under the public name. I.e. the\n   *     property names are the public names. The property values are the\n   *     methods of instance.\n   */\n  registerEventInfoHandlers<T>(\n    namespace: string,\n    instance: T | null,\n    methods: {[key: string]: EventInfoWrapperHandler},\n  ) {\n    for (const [name, method] of Object.entries(methods)) {\n      const handler = instance ? method.bind(instance) : method;\n      if (namespace) {\n        // Include a '.' separator between namespace name and action name.\n        // In the case that no namespace name is provided, the jsaction name\n        // consists of the action name only (no period).\n        const fullName = namespace + Char.NAMESPACE_ACTION_SEPARATOR + name;\n        this.actions[fullName] = handler;\n      } else {\n        this.actions[name] = handler;\n      }\n    }\n\n    this.baseDispatcher.scheduleEventReplay();\n  }\n\n  /**\n   * Unregisters an action.  Provided as an easy way to reverse the effects of\n   * registerHandlers.\n   * @param namespace The namespace of the jsaction name.\n   * @param name The action name to unbind.\n   */\n  unregisterHandler(namespace: string, name: string) {\n    const fullName = namespace ? namespace + Char.NAMESPACE_ACTION_SEPARATOR + name : name;\n    delete this.actions[fullName];\n  }\n\n  /** Registers a global event handler. */\n  registerGlobalHandler(eventType: string, handler: GlobalHandler) {\n    if (!this.globalHandlers.has(eventType)) {\n      this.globalHandlers.set(eventType, new Set<GlobalHandler>([handler]));\n    } else {\n      this.globalHandlers.get(eventType)!.add(handler);\n    }\n  }\n\n  /** Unregisters a global event handler. */\n  unregisterGlobalHandler(eventType: string, handler: GlobalHandler) {\n    if (this.globalHandlers.has(eventType)) {\n      this.globalHandlers.get(eventType)!.delete(handler);\n    }\n  }\n\n  /**\n   * Checks whether there is an action registered under the given\n   * name. This returns true if there is a namespace handler, even\n   * if it can not yet handle the event.\n   *\n   * @param name Action name.\n   * @return Whether the name is registered.\n   * @see #canDispatch\n   */\n  hasAction(name: string): boolean {\n    return this.actions.hasOwnProperty(name);\n  }\n\n  /**\n   * Whether this dispatcher can dispatch the event. This can be used by\n   * event replayer to check whether the dispatcher can replay an event.\n   */\n  canDispatch(eventInfoWrapper: EventInfoWrapper): boolean {\n    const action = eventInfoWrapper.getAction();\n    if (!action) {\n      return false;\n    }\n    return this.hasAction(action.name);\n  }\n\n  /**\n   * Sets the event replayer, enabling queued events to be replayed when actions\n   * are bound. To replay events, you must register the dispatcher to the\n   * contract after setting the `EventReplayer`. The event replayer takes as\n   * parameters the queue of events and the dispatcher (used to check whether\n   * actions have handlers registered and can be replayed). The event replayer\n   * is also responsible for dequeuing events.\n   *\n   * Example: An event replayer that replays only the last event.\n   *\n   *   const dispatcher = new Dispatcher();\n   *   // ...\n   *   dispatcher.setEventReplayer((queue, dispatcher) => {\n   *     const lastEventInfoWrapper = queue[queue.length -1];\n   *     if (dispatcher.canDispatch(lastEventInfoWrapper.getAction())) {\n   *       jsaction.replay.replayEvent(\n   *           lastEventInfoWrapper.getEvent(),\n   *           lastEventInfoWrapper.getTargetElement(),\n   *           lastEventInfoWrapper.getEventType(),\n   *       );\n   *       queue.length = 0;\n   *     }\n   *   });\n   *\n   * @param eventReplayer It allows elements to be replayed and dequeuing.\n   */\n  setEventReplayer(eventReplayer: Replayer) {\n    this.eventReplayer = eventReplayer;\n  }\n}\n\n/** Stop propagation for an `EventInfo`. */\nexport function stopPropagation(eventInfoWrapper: EventInfoWrapper) {\n  if (\n    eventLib.isGecko &&\n    (eventInfoWrapper.getTargetElement().tagName === 'INPUT' ||\n      eventInfoWrapper.getTargetElement().tagName === 'TEXTAREA') &&\n    eventInfoWrapper.getEventType() === EventType.FOCUS\n  ) {\n    /**\n     * Do nothing since stopping propagation on a focus event on an input\n     * element in Firefox makes the text cursor disappear:\n     * https://bugzilla.mozilla.org/show_bug.cgi?id=509684\n     */\n    return;\n  }\n\n  const event = eventInfoWrapper.getEvent();\n  // There are some cases where users of the `Dispatcher` will call dispatch\n  // with a fake event that does not support `stopPropagation`.\n  if (!event.stopPropagation) {\n    return;\n  }\n  event.stopPropagation();\n}\n\n/**\n * Registers deferred functionality for an EventContract and a Jsaction\n * Dispatcher.\n */\nexport function registerDispatcher(eventContract: UnrenamedEventContract, dispatcher: Dispatcher) {\n  eventContract.ecrd((eventInfo: EventInfo) => {\n    dispatcher.dispatch(eventInfo);\n  }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);\n}\n"]}