@angular/core 18.0.0 → 18.0.2

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

@@ -0,0 +1,128 @@
+/**
+ * @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 { ActionResolver } from './action_resolver';
+import { Dispatcher } from './dispatcher';
+import { Restriction } from './restriction';
+/** An internal symbol used to indicate whether propagation should be stopped or not. */
+export const PROPAGATION_STOPPED_SYMBOL = Symbol.for('propagationStopped');
+/** Extra event phases beyond what the browser provides. */
+export const EventPhase = {
+    REPLAY: 101,
+};
+const PREVENT_DEFAULT_ERROR_MESSAGE_DETAILS = ' Because event replay occurs after browser dispatch, `preventDefault` would have no ' +
+    'effect. You can check whether an event is being replayed by accessing the event phase: ' +
+    '`event.eventPhase === EventPhase.REPLAY`.';
+const PREVENT_DEFAULT_ERROR_MESSAGE = `\`preventDefault\` called during event replay.`;
+const COMPOSED_PATH_ERROR_MESSAGE_DETAILS = ' Because event replay occurs after browser ' +
+    'dispatch, `composedPath()` will be empty. Iterate parent nodes from `event.target` or ' +
+    '`event.currentTarget` if you need to check elements in the event path.';
+const COMPOSED_PATH_ERROR_MESSAGE = `\`composedPath\` called during event replay.`;
+/**
+ * A dispatcher that uses browser-based `Event` semantics, for example bubbling, `stopPropagation`,
+ * `currentTarget`, etc.
+ */
+export class EventDispatcher {
+    constructor(dispatchDelegate) {
+        this.dispatchDelegate = dispatchDelegate;
+        this.actionResolver = new ActionResolver();
+        this.dispatcher = new Dispatcher((eventInfoWrapper) => {
+            this.dispatchToDelegate(eventInfoWrapper);
+        }, {
+            actionResolver: this.actionResolver,
+        });
+    }
+    /**
+     * The entrypoint for the `EventContract` dispatch.
+     */
+    dispatch(eventInfo) {
+        this.dispatcher.dispatch(eventInfo);
+    }
+    /** Internal method that does basic disaptching. */
+    dispatchToDelegate(eventInfoWrapper) {
+        if (eventInfoWrapper.getIsReplay()) {
+            prepareEventForReplay(eventInfoWrapper);
+        }
+        prepareEventForBubbling(eventInfoWrapper);
+        while (eventInfoWrapper.getAction()) {
+            prepareEventForDispatch(eventInfoWrapper);
+            this.dispatchDelegate(eventInfoWrapper.getEvent(), eventInfoWrapper.getAction().name);
+            if (propagationStopped(eventInfoWrapper)) {
+                return;
+            }
+            this.actionResolver.resolveParentAction(eventInfoWrapper.eventInfo);
+        }
+    }
+}
+function prepareEventForBubbling(eventInfoWrapper) {
+    const event = eventInfoWrapper.getEvent();
+    const stopPropagation = () => {
+        event[PROPAGATION_STOPPED_SYMBOL] = true;
+    };
+    patchEventInstance(event, 'stopPropagation', stopPropagation);
+    patchEventInstance(event, 'stopImmediatePropagation', stopPropagation);
+}
+function propagationStopped(eventInfoWrapper) {
+    const event = eventInfoWrapper.getEvent();
+    return !!event[PROPAGATION_STOPPED_SYMBOL];
+}
+function prepareEventForReplay(eventInfoWrapper) {
+    const event = eventInfoWrapper.getEvent();
+    const target = eventInfoWrapper.getTargetElement();
+    patchEventInstance(event, 'target', target);
+    patchEventInstance(event, 'eventPhase', EventPhase.REPLAY);
+    patchEventInstance(event, 'preventDefault', () => {
+        throw new Error(PREVENT_DEFAULT_ERROR_MESSAGE + (ngDevMode ? PREVENT_DEFAULT_ERROR_MESSAGE_DETAILS : ''));
+    });
+    patchEventInstance(event, 'composedPath', () => {
+        throw new Error(COMPOSED_PATH_ERROR_MESSAGE + (ngDevMode ? COMPOSED_PATH_ERROR_MESSAGE_DETAILS : ''));
+    });
+}
+function prepareEventForDispatch(eventInfoWrapper) {
+    const event = eventInfoWrapper.getEvent();
+    const currentTarget = eventInfoWrapper.getAction()?.element;
+    if (currentTarget) {
+        patchEventInstance(event, 'currentTarget', currentTarget, {
+            // `currentTarget` is going to get reassigned every dispatch.
+            configurable: true,
+        });
+    }
+}
+/**
+ * Patch `Event` instance during non-standard `Event` dispatch. This patches just the `Event`
+ * instance that the browser created, it does not patch global properties or methods.
+ *
+ * This is necessary because dispatching an `Event` outside of browser dispatch results in
+ * incorrect properties and methods that need to be polyfilled or do not work.
+ *
+ * JSAction dispatch adds two extra "phases" to event dispatch:
+ * 1. Event delegation - the event is being dispatched by a delegating event handler on a container
+ *    (typically `window.document.documentElement`), to a delegated event handler on some child
+ *    element. Certain `Event` properties will be unintuitive, such as `currentTarget`, which would
+ *    be the container rather than the child element. Bubbling would also not work. In order to
+ *    emulate the browser, these properties and methods on the `Event` are patched.
+ * 2. Event replay - the event is being dispatched by the framework once the handlers have been
+ *    loaded (during hydration, or late-loaded). Certain `Event` properties can be unset by the
+ *    browser because the `Event` is no longer actively being dispatched, such as `target`. Other
+ *    methods have no effect because the `Event` has already been dispatched, such as
+ *    `preventDefault`. Bubbling would also not work. These properties and methods are patched,
+ *    either to fill in information that the browser may have removed, or to throw errors in methods
+ *    that no longer behave as expected.
+ */
+function patchEventInstance(event, property, value, { configurable = false } = {}) {
+    Object.defineProperty(event, property, { value, configurable });
+}
+/**
+ * Registers deferred functionality for an EventContract and a Jsaction
+ * Dispatcher.
+ */
+export function registerDispatcher(eventContract, dispatcher) {
+    eventContract.ecrd((eventInfo) => {
+        dispatcher.dispatch(eventInfo);
+    }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event_dispatcher.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/event_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 {ActionResolver} from './action_resolver';\nimport {Dispatcher} from './dispatcher';\nimport {EventInfo, EventInfoWrapper} from './event_info';\nimport {UnrenamedEventContract} from './eventcontract';\nimport {Restriction} from './restriction';\n\n/**\n * A replayer is a function that is called when there are queued events, from the `EventContract`.\n */\nexport type Replayer = (eventInfoWrappers: Event[]) => void;\n\n/** An internal symbol used to indicate whether propagation should be stopped or not. */\nexport const PROPAGATION_STOPPED_SYMBOL = Symbol.for('propagationStopped');\n\n/** Extra event phases beyond what the browser provides. */\nexport const EventPhase = {\n  REPLAY: 101,\n};\n\nconst PREVENT_DEFAULT_ERROR_MESSAGE_DETAILS =\n  ' Because event replay occurs after browser dispatch, `preventDefault` would have no ' +\n  'effect. You can check whether an event is being replayed by accessing the event phase: ' +\n  '`event.eventPhase === EventPhase.REPLAY`.';\nconst PREVENT_DEFAULT_ERROR_MESSAGE = `\\`preventDefault\\` called during event replay.`;\nconst COMPOSED_PATH_ERROR_MESSAGE_DETAILS =\n  ' Because event replay occurs after browser ' +\n  'dispatch, `composedPath()` will be empty. Iterate parent nodes from `event.target` or ' +\n  '`event.currentTarget` if you need to check elements in the event path.';\nconst COMPOSED_PATH_ERROR_MESSAGE = `\\`composedPath\\` called during event replay.`;\n\ndeclare global {\n  interface Event {\n    [PROPAGATION_STOPPED_SYMBOL]?: boolean;\n  }\n}\n\n/**\n * A dispatcher that uses browser-based `Event` semantics, for example bubbling, `stopPropagation`,\n * `currentTarget`, etc.\n */\nexport class EventDispatcher {\n  private readonly actionResolver: ActionResolver;\n\n  private readonly dispatcher: Dispatcher;\n\n  constructor(private readonly dispatchDelegate: (event: Event, actionName: string) => void) {\n    this.actionResolver = new ActionResolver();\n    this.dispatcher = new Dispatcher(\n      (eventInfoWrapper: EventInfoWrapper) => {\n        this.dispatchToDelegate(eventInfoWrapper);\n      },\n      {\n        actionResolver: this.actionResolver,\n      },\n    );\n  }\n\n  /**\n   * The entrypoint for the `EventContract` dispatch.\n   */\n  dispatch(eventInfo: EventInfo): void {\n    this.dispatcher.dispatch(eventInfo);\n  }\n\n  /** Internal method that does basic disaptching. */\n  private dispatchToDelegate(eventInfoWrapper: EventInfoWrapper) {\n    if (eventInfoWrapper.getIsReplay()) {\n      prepareEventForReplay(eventInfoWrapper);\n    }\n    prepareEventForBubbling(eventInfoWrapper);\n    while (eventInfoWrapper.getAction()) {\n      prepareEventForDispatch(eventInfoWrapper);\n      this.dispatchDelegate(eventInfoWrapper.getEvent(), eventInfoWrapper.getAction()!.name);\n      if (propagationStopped(eventInfoWrapper)) {\n        return;\n      }\n      this.actionResolver.resolveParentAction(eventInfoWrapper.eventInfo);\n    }\n  }\n}\n\nfunction prepareEventForBubbling(eventInfoWrapper: EventInfoWrapper) {\n  const event = eventInfoWrapper.getEvent();\n  const stopPropagation = () => {\n    event[PROPAGATION_STOPPED_SYMBOL] = true;\n  };\n  patchEventInstance(event, 'stopPropagation', stopPropagation);\n  patchEventInstance(event, 'stopImmediatePropagation', stopPropagation);\n}\n\nfunction propagationStopped(eventInfoWrapper: EventInfoWrapper) {\n  const event = eventInfoWrapper.getEvent();\n  return !!event[PROPAGATION_STOPPED_SYMBOL];\n}\n\nfunction prepareEventForReplay(eventInfoWrapper: EventInfoWrapper) {\n  const event = eventInfoWrapper.getEvent();\n  const target = eventInfoWrapper.getTargetElement();\n  patchEventInstance(event, 'target', target);\n  patchEventInstance(event, 'eventPhase', EventPhase.REPLAY);\n  patchEventInstance(event, 'preventDefault', () => {\n    throw new Error(\n      PREVENT_DEFAULT_ERROR_MESSAGE + (ngDevMode ? PREVENT_DEFAULT_ERROR_MESSAGE_DETAILS : ''),\n    );\n  });\n  patchEventInstance(event, 'composedPath', () => {\n    throw new Error(\n      COMPOSED_PATH_ERROR_MESSAGE + (ngDevMode ? COMPOSED_PATH_ERROR_MESSAGE_DETAILS : ''),\n    );\n  });\n}\n\nfunction prepareEventForDispatch(eventInfoWrapper: EventInfoWrapper) {\n  const event = eventInfoWrapper.getEvent();\n  const currentTarget = eventInfoWrapper.getAction()?.element;\n  if (currentTarget) {\n    patchEventInstance(event, 'currentTarget', currentTarget, {\n      // `currentTarget` is going to get reassigned every dispatch.\n      configurable: true,\n    });\n  }\n}\n\n/**\n * Patch `Event` instance during non-standard `Event` dispatch. This patches just the `Event`\n * instance that the browser created, it does not patch global properties or methods.\n *\n * This is necessary because dispatching an `Event` outside of browser dispatch results in\n * incorrect properties and methods that need to be polyfilled or do not work.\n *\n * JSAction dispatch adds two extra \"phases\" to event dispatch:\n * 1. Event delegation - the event is being dispatched by a delegating event handler on a container\n *    (typically `window.document.documentElement`), to a delegated event handler on some child\n *    element. Certain `Event` properties will be unintuitive, such as `currentTarget`, which would\n *    be the container rather than the child element. Bubbling would also not work. In order to\n *    emulate the browser, these properties and methods on the `Event` are patched.\n * 2. Event replay - the event is being dispatched by the framework once the handlers have been\n *    loaded (during hydration, or late-loaded). Certain `Event` properties can be unset by the\n *    browser because the `Event` is no longer actively being dispatched, such as `target`. Other\n *    methods have no effect because the `Event` has already been dispatched, such as\n *    `preventDefault`. Bubbling would also not work. These properties and methods are patched,\n *    either to fill in information that the browser may have removed, or to throw errors in methods\n *    that no longer behave as expected.\n */\nfunction patchEventInstance<T>(\n  event: Event,\n  property: string,\n  value: T,\n  {configurable = false}: {configurable?: boolean} = {},\n) {\n  Object.defineProperty(event, property, {value, configurable});\n}\n\n/**\n * Registers deferred functionality for an EventContract and a Jsaction\n * Dispatcher.\n */\nexport function registerDispatcher(\n  eventContract: UnrenamedEventContract,\n  dispatcher: EventDispatcher,\n) {\n  eventContract.ecrd((eventInfo: EventInfo) => {\n    dispatcher.dispatch(eventInfo);\n  }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);\n}\n"]}

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

@@ -241,4 +241,88 @@ export const EventType = {
      */
     CUSTOM: '_custom',
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event_type.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/event_type.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB;;;OAGG;IACH,QAAQ,EAAE,UAAU;IAEpB;;;OAGG;IACH,MAAM,EAAE,QAAQ;IAEhB;;;;;OAKG;IACH,KAAK,EAAE,OAAO;IAEd;;;;;OAKG;IACH,QAAQ,EAAE,UAAU;IAEpB;;;;OAIG;IACH,SAAS,EAAE,WAAW;IAEtB;;OAEG;IACH,QAAQ,EAAE,UAAU;IAEpB;;;;OAIG;IACH,KAAK,EAAE,OAAO;IAEd;;;;OAIG;IACH,OAAO,EAAE,SAAS;IAElB;;OAEG;IACH,IAAI,EAAE,MAAM;IAEZ;;OAEG;IACH,QAAQ,EAAE,UAAU;IAEpB;;;;;;OAMG;IACH,MAAM,EAAE,QAAQ;IAEhB;;;;OAIG;IACH,OAAO,EAAE,SAAS;IAElB;;;OAGG;IACH,QAAQ,EAAE,UAAU;IAEpB;;;;OAIG;IACH,KAAK,EAAE,OAAO;IAEd;;;;OAIG;IACH,OAAO,EAAE,SAAS;IAElB;;;;OAIG;IACH,SAAS,EAAE,WAAW;IAEtB;;;;OAIG;IACH,SAAS,EAAE,WAAW;IAEtB;;;;OAIG;IACH,QAAQ,EAAE,UAAU;IAEpB;;;OAGG;IACH,UAAU,EAAE,YAAY;IAExB;;;OAGG;IACH,UAAU,EAAE,YAAY;IAExB;;OAEG;IACH,SAAS,EAAE,WAAW;IAEtB;;;;OAIG;IACH,SAAS,EAAE,WAAW;IAEtB;;;;OAIG;IACH,WAAW,EAAE,aAAa;IAE1B;;;;OAIG;IACH,WAAW,EAAE,aAAa;IAE1B;;;;OAIG;IACH,UAAU,EAAE,YAAY;IAExB;;;OAGG;IACH,YAAY,EAAE,cAAc;IAE5B;;;OAGG;IACH,YAAY,EAAE,cAAc;IAE5B;;OAEG;IACH,WAAW,EAAE,aAAa;IAE1B;;OAEG;IACH,aAAa,EAAE,eAAe;IAE9B;;;;OAIG;IACH,iBAAiB,EAAE,mBAAmB;IAEtC;;;;OAIG;IACH,kBAAkB,EAAE,oBAAoB;IAExC;;;;OAIG;IACH,KAAK,EAAE,OAAO;IAEd;;;;OAIG;IACH,IAAI,EAAE,MAAM;IAEZ;;OAEG;IACH,MAAM,EAAE,QAAQ;IAEhB;;;OAGG;IACH,UAAU,EAAE,YAAY;IAExB;;;OAGG;IACH,QAAQ,EAAE,UAAU;IAEpB;;;OAGG;IACH,SAAS,EAAE,WAAW;IAEtB;;OAEG;IACH,KAAK,EAAE,OAAO;IAEd;;OAEG;IACH,MAAM,EAAE,QAAQ;IAEhB;;;;OAIG;IACH,MAAM,EAAE,QAAQ;IAEhB;;;;;;;OAOG;IACH,MAAM,EAAE,SAAS;CAClB,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\n/*\n * Names of events that are special to jsaction. These are not all\n * event types that are legal to use in either HTML or the addEvent()\n * API, but these are the ones that are treated specially. All other\n * DOM events can be used in either addEvent() or in the value of the\n * jsaction attribute. Beware of browser specific events or events\n * that don't bubble though: If they are not mentioned here, then\n * event contract doesn't work around their peculiarities.\n */\nexport const EventType = {\n  /**\n   * Mouse middle click, introduced in Chrome 55 and not yet supported on\n   * other browsers.\n   */\n  AUXCLICK: 'auxclick',\n\n  /**\n   * The change event fired by browsers when the `value` attribute of input,\n   * select, and textarea elements are changed.\n   */\n  CHANGE: 'change',\n\n  /**\n   * The click event. In addEvent() refers to all click events, in the\n   * jsaction attribute it refers to the unmodified click and Enter/Space\n   * keypress events.  In the latter case, a jsaction click will be triggered,\n   * for accessibility reasons.  See clickmod and clickonly, below.\n   */\n  CLICK: 'click',\n\n  /**\n   * Specifies the jsaction for a modified click event (i.e. a mouse\n   * click with the modifier key Cmd/Ctrl pressed). This event isn't\n   * separately enabled in addEvent(), because in the DOM, it's just a\n   * click event.\n   */\n  CLICKMOD: 'clickmod',\n\n  /**\n   * Specifies the jsaction for a click-only event.  Click-only doesn't take\n   * into account the case where an element with focus receives an Enter/Space\n   * keypress.  This event isn't separately enabled in addEvent().\n   */\n  CLICKONLY: 'clickonly',\n\n  /**\n   * The dblclick event.\n   */\n  DBLCLICK: 'dblclick',\n\n  /**\n   * Focus doesn't bubble, but you can use it in addEvent() and\n   * jsaction anyway. EventContract does the right thing under the\n   * hood.\n   */\n  FOCUS: 'focus',\n\n  /**\n   * This event only exists in IE. For addEvent() and jsaction, use\n   * focus instead; EventContract does the right thing even though\n   * focus doesn't bubble.\n   */\n  FOCUSIN: 'focusin',\n\n  /**\n   * Analog to focus.\n   */\n  BLUR: 'blur',\n\n  /**\n   * Analog to focusin.\n   */\n  FOCUSOUT: 'focusout',\n\n  /**\n   * Submit doesn't bubble, so it cannot be used with event\n   * contract. However, the browser helpfully fires a click event on\n   * the submit button of a form (even if the form is not submitted by\n   * a click on the submit button). So you should handle click on the\n   * submit button instead.\n   */\n  SUBMIT: 'submit',\n\n  /**\n   * The keydown event. In addEvent() and non-click jsaction it represents the\n   * regular DOM keydown event. It represents click actions in non-Gecko\n   * browsers.\n   */\n  KEYDOWN: 'keydown',\n\n  /**\n   * The keypress event. In addEvent() and non-click jsaction it represents the\n   * regular DOM keypress event. It represents click actions in Gecko browsers.\n   */\n  KEYPRESS: 'keypress',\n\n  /**\n   * The keyup event. In addEvent() and non-click jsaction it represents the\n   * regular DOM keyup event. It represents click actions in non-Gecko\n   * browsers.\n   */\n  KEYUP: 'keyup',\n\n  /**\n   * The mouseup event. Can either be used directly or used implicitly to\n   * capture mouseup events. In addEvent(), it represents a regular DOM\n   * mouseup event.\n   */\n  MOUSEUP: 'mouseup',\n\n  /**\n   * The mousedown event. Can either be used directly or used implicitly to\n   * capture mouseenter events. In addEvent(), it represents a regular DOM\n   * mouseover event.\n   */\n  MOUSEDOWN: 'mousedown',\n\n  /**\n   * The mouseover event. Can either be used directly or used implicitly to\n   * capture mouseenter events. In addEvent(), it represents a regular DOM\n   * mouseover event.\n   */\n  MOUSEOVER: 'mouseover',\n\n  /**\n   * The mouseout event. Can either be used directly or used implicitly to\n   * capture mouseover events. In addEvent(), it represents a regular DOM\n   * mouseout event.\n   */\n  MOUSEOUT: 'mouseout',\n\n  /**\n   * The mouseenter event. Does not bubble and fires individually on each\n   * element being entered within a DOM tree.\n   */\n  MOUSEENTER: 'mouseenter',\n\n  /**\n   * The mouseleave event. Does not bubble and fires individually on each\n   * element being entered within a DOM tree.\n   */\n  MOUSELEAVE: 'mouseleave',\n\n  /**\n   * The mousemove event.\n   */\n  MOUSEMOVE: 'mousemove',\n\n  /**\n   * The pointerup event. Can either be used directly or used implicitly to\n   * capture pointerup events. In addEvent(), it represents a regular DOM\n   * pointerup event.\n   */\n  POINTERUP: 'pointerup',\n\n  /**\n   * The pointerdown event. Can either be used directly or used implicitly to\n   * capture pointerenter events. In addEvent(), it represents a regular DOM\n   * mouseover event.\n   */\n  POINTERDOWN: 'pointerdown',\n\n  /**\n   * The pointerover event. Can either be used directly or used implicitly to\n   * capture pointerenter events. In addEvent(), it represents a regular DOM\n   * pointerover event.\n   */\n  POINTEROVER: 'pointerover',\n\n  /**\n   * The pointerout event. Can either be used directly or used implicitly to\n   * capture pointerover events. In addEvent(), it represents a regular DOM\n   * pointerout event.\n   */\n  POINTEROUT: 'pointerout',\n\n  /**\n   * The pointerenter event. Does not bubble and fires individually on each\n   * element being entered within a DOM tree.\n   */\n  POINTERENTER: 'pointerenter',\n\n  /**\n   * The pointerleave event. Does not bubble and fires individually on each\n   * element being entered within a DOM tree.\n   */\n  POINTERLEAVE: 'pointerleave',\n\n  /**\n   * The pointermove event.\n   */\n  POINTERMOVE: 'pointermove',\n\n  /**\n   * The pointercancel event.\n   */\n  POINTERCANCEL: 'pointercancel',\n\n  /**\n   * The gotpointercapture event is fired when\n   * Element.setPointerCapture(pointerId) is called on a mouse input, or\n   * implicitly when a touch input begins.\n   */\n  GOTPOINTERCAPTURE: 'gotpointercapture',\n\n  /**\n   * The lostpointercapture event is fired when\n   * Element.releasePointerCapture(pointerId) is called, or implicitly after a\n   * touch input ends.\n   */\n  LOSTPOINTERCAPTURE: 'lostpointercapture',\n\n  /**\n   * The error event. The error event doesn't bubble, but you can use it in\n   * addEvent() and jsaction anyway. EventContract does the right thing under\n   * the hood (except in IE8 which does not use error events).\n   */\n  ERROR: 'error',\n\n  /**\n   * The load event. The load event doesn't bubble, but you can use it in\n   * addEvent() and jsaction anyway. EventContract does the right thing\n   * under the hood.\n   */\n  LOAD: 'load',\n\n  /**\n   * The unload event.\n   */\n  UNLOAD: 'unload',\n\n  /**\n   * The touchstart event. Bubbles, will only ever fire in browsers with\n   * touch support.\n   */\n  TOUCHSTART: 'touchstart',\n\n  /**\n   * The touchend event. Bubbles, will only ever fire in browsers with\n   * touch support.\n   */\n  TOUCHEND: 'touchend',\n\n  /**\n   * The touchmove event. Bubbles, will only ever fire in browsers with\n   * touch support.\n   */\n  TOUCHMOVE: 'touchmove',\n\n  /**\n   * The input event.\n   */\n  INPUT: 'input',\n\n  /**\n   * The scroll event.\n   */\n  SCROLL: 'scroll',\n\n  /**\n   * The toggle event. The toggle event doesn't bubble, but you can use it in\n   * addEvent() and jsaction anyway. EventContract does the right thing\n   * under the hood.\n   */\n  TOGGLE: 'toggle',\n\n  /**\n   * A custom event. The actual custom event type is declared as the 'type'\n   * field in the event details. Supported in Firefox 6+, IE 9+, and all Chrome\n   * versions.\n   *\n   * This is an internal name. Users should use jsaction's fireCustomEvent to\n   * fire custom events instead of relying on this type to create them.\n   */\n  CUSTOM: '_custom',\n};\n"]}
+export const NON_BUBBLING_MOUSE_EVENTS = [
+    EventType.MOUSEENTER,
+    EventType.MOUSELEAVE,
+    'pointerenter',
+    'pointerleave',
+];
+/**
+ * Detects whether a given event type is supported by JSAction.
+ */
+export const isSupportedEvent = (eventType) => SUPPORTED_EVENTS.indexOf(eventType) >= 0;
+const SUPPORTED_EVENTS = [
+    EventType.CLICK,
+    EventType.DBLCLICK,
+    EventType.FOCUS,
+    EventType.FOCUSIN,
+    EventType.BLUR,
+    EventType.ERROR,
+    EventType.FOCUSOUT,
+    EventType.KEYDOWN,
+    EventType.KEYUP,
+    EventType.KEYPRESS,
+    EventType.LOAD,
+    EventType.MOUSEOVER,
+    EventType.MOUSEOUT,
+    EventType.SUBMIT,
+    EventType.TOGGLE,
+    EventType.TOUCHSTART,
+    EventType.TOUCHEND,
+    EventType.TOUCHMOVE,
+    'touchcancel',
+    'auxclick',
+    'change',
+    'compositionstart',
+    'compositionupdate',
+    'compositionend',
+    'beforeinput',
+    'input',
+    'select',
+    'copy',
+    'cut',
+    'paste',
+    'mousedown',
+    'mouseup',
+    'wheel',
+    'contextmenu',
+    'dragover',
+    'dragenter',
+    'dragleave',
+    'drop',
+    'dragstart',
+    'dragend',
+    'pointerdown',
+    'pointermove',
+    'pointerup',
+    'pointercancel',
+    'pointerover',
+    'pointerout',
+    'gotpointercapture',
+    'lostpointercapture',
+    // Video events.
+    'ended',
+    'loadedmetadata',
+    // Page visibility events.
+    'pagehide',
+    'pageshow',
+    'visibilitychange',
+    // Content visibility events.
+    'beforematch',
+];
+/**
+ *
+ * Decides whether or not an event type is an event that only has a capture phase.
+ *
+ * @param eventType
+ * @returns bool
+ */
+export const isCaptureEvent = (eventType) => CAPTURE_EVENTS.indexOf(eventType) >= 0;
+const CAPTURE_EVENTS = [
+    EventType.FOCUS,
+    EventType.BLUR,
+    EventType.ERROR,
+    EventType.LOAD,
+    EventType.TOGGLE,
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event_type.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/event_type.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\n/*\n * Names of events that are special to jsaction. These are not all\n * event types that are legal to use in either HTML or the addEvent()\n * API, but these are the ones that are treated specially. All other\n * DOM events can be used in either addEvent() or in the value of the\n * jsaction attribute. Beware of browser specific events or events\n * that don't bubble though: If they are not mentioned here, then\n * event contract doesn't work around their peculiarities.\n */\nexport const EventType = {\n  /**\n   * Mouse middle click, introduced in Chrome 55 and not yet supported on\n   * other browsers.\n   */\n  AUXCLICK: 'auxclick',\n\n  /**\n   * The change event fired by browsers when the `value` attribute of input,\n   * select, and textarea elements are changed.\n   */\n  CHANGE: 'change',\n\n  /**\n   * The click event. In addEvent() refers to all click events, in the\n   * jsaction attribute it refers to the unmodified click and Enter/Space\n   * keypress events.  In the latter case, a jsaction click will be triggered,\n   * for accessibility reasons.  See clickmod and clickonly, below.\n   */\n  CLICK: 'click',\n\n  /**\n   * Specifies the jsaction for a modified click event (i.e. a mouse\n   * click with the modifier key Cmd/Ctrl pressed). This event isn't\n   * separately enabled in addEvent(), because in the DOM, it's just a\n   * click event.\n   */\n  CLICKMOD: 'clickmod',\n\n  /**\n   * Specifies the jsaction for a click-only event.  Click-only doesn't take\n   * into account the case where an element with focus receives an Enter/Space\n   * keypress.  This event isn't separately enabled in addEvent().\n   */\n  CLICKONLY: 'clickonly',\n\n  /**\n   * The dblclick event.\n   */\n  DBLCLICK: 'dblclick',\n\n  /**\n   * Focus doesn't bubble, but you can use it in addEvent() and\n   * jsaction anyway. EventContract does the right thing under the\n   * hood.\n   */\n  FOCUS: 'focus',\n\n  /**\n   * This event only exists in IE. For addEvent() and jsaction, use\n   * focus instead; EventContract does the right thing even though\n   * focus doesn't bubble.\n   */\n  FOCUSIN: 'focusin',\n\n  /**\n   * Analog to focus.\n   */\n  BLUR: 'blur',\n\n  /**\n   * Analog to focusin.\n   */\n  FOCUSOUT: 'focusout',\n\n  /**\n   * Submit doesn't bubble, so it cannot be used with event\n   * contract. However, the browser helpfully fires a click event on\n   * the submit button of a form (even if the form is not submitted by\n   * a click on the submit button). So you should handle click on the\n   * submit button instead.\n   */\n  SUBMIT: 'submit',\n\n  /**\n   * The keydown event. In addEvent() and non-click jsaction it represents the\n   * regular DOM keydown event. It represents click actions in non-Gecko\n   * browsers.\n   */\n  KEYDOWN: 'keydown',\n\n  /**\n   * The keypress event. In addEvent() and non-click jsaction it represents the\n   * regular DOM keypress event. It represents click actions in Gecko browsers.\n   */\n  KEYPRESS: 'keypress',\n\n  /**\n   * The keyup event. In addEvent() and non-click jsaction it represents the\n   * regular DOM keyup event. It represents click actions in non-Gecko\n   * browsers.\n   */\n  KEYUP: 'keyup',\n\n  /**\n   * The mouseup event. Can either be used directly or used implicitly to\n   * capture mouseup events. In addEvent(), it represents a regular DOM\n   * mouseup event.\n   */\n  MOUSEUP: 'mouseup',\n\n  /**\n   * The mousedown event. Can either be used directly or used implicitly to\n   * capture mouseenter events. In addEvent(), it represents a regular DOM\n   * mouseover event.\n   */\n  MOUSEDOWN: 'mousedown',\n\n  /**\n   * The mouseover event. Can either be used directly or used implicitly to\n   * capture mouseenter events. In addEvent(), it represents a regular DOM\n   * mouseover event.\n   */\n  MOUSEOVER: 'mouseover',\n\n  /**\n   * The mouseout event. Can either be used directly or used implicitly to\n   * capture mouseover events. In addEvent(), it represents a regular DOM\n   * mouseout event.\n   */\n  MOUSEOUT: 'mouseout',\n\n  /**\n   * The mouseenter event. Does not bubble and fires individually on each\n   * element being entered within a DOM tree.\n   */\n  MOUSEENTER: 'mouseenter',\n\n  /**\n   * The mouseleave event. Does not bubble and fires individually on each\n   * element being entered within a DOM tree.\n   */\n  MOUSELEAVE: 'mouseleave',\n\n  /**\n   * The mousemove event.\n   */\n  MOUSEMOVE: 'mousemove',\n\n  /**\n   * The pointerup event. Can either be used directly or used implicitly to\n   * capture pointerup events. In addEvent(), it represents a regular DOM\n   * pointerup event.\n   */\n  POINTERUP: 'pointerup',\n\n  /**\n   * The pointerdown event. Can either be used directly or used implicitly to\n   * capture pointerenter events. In addEvent(), it represents a regular DOM\n   * mouseover event.\n   */\n  POINTERDOWN: 'pointerdown',\n\n  /**\n   * The pointerover event. Can either be used directly or used implicitly to\n   * capture pointerenter events. In addEvent(), it represents a regular DOM\n   * pointerover event.\n   */\n  POINTEROVER: 'pointerover',\n\n  /**\n   * The pointerout event. Can either be used directly or used implicitly to\n   * capture pointerover events. In addEvent(), it represents a regular DOM\n   * pointerout event.\n   */\n  POINTEROUT: 'pointerout',\n\n  /**\n   * The pointerenter event. Does not bubble and fires individually on each\n   * element being entered within a DOM tree.\n   */\n  POINTERENTER: 'pointerenter',\n\n  /**\n   * The pointerleave event. Does not bubble and fires individually on each\n   * element being entered within a DOM tree.\n   */\n  POINTERLEAVE: 'pointerleave',\n\n  /**\n   * The pointermove event.\n   */\n  POINTERMOVE: 'pointermove',\n\n  /**\n   * The pointercancel event.\n   */\n  POINTERCANCEL: 'pointercancel',\n\n  /**\n   * The gotpointercapture event is fired when\n   * Element.setPointerCapture(pointerId) is called on a mouse input, or\n   * implicitly when a touch input begins.\n   */\n  GOTPOINTERCAPTURE: 'gotpointercapture',\n\n  /**\n   * The lostpointercapture event is fired when\n   * Element.releasePointerCapture(pointerId) is called, or implicitly after a\n   * touch input ends.\n   */\n  LOSTPOINTERCAPTURE: 'lostpointercapture',\n\n  /**\n   * The error event. The error event doesn't bubble, but you can use it in\n   * addEvent() and jsaction anyway. EventContract does the right thing under\n   * the hood (except in IE8 which does not use error events).\n   */\n  ERROR: 'error',\n\n  /**\n   * The load event. The load event doesn't bubble, but you can use it in\n   * addEvent() and jsaction anyway. EventContract does the right thing\n   * under the hood.\n   */\n  LOAD: 'load',\n\n  /**\n   * The unload event.\n   */\n  UNLOAD: 'unload',\n\n  /**\n   * The touchstart event. Bubbles, will only ever fire in browsers with\n   * touch support.\n   */\n  TOUCHSTART: 'touchstart',\n\n  /**\n   * The touchend event. Bubbles, will only ever fire in browsers with\n   * touch support.\n   */\n  TOUCHEND: 'touchend',\n\n  /**\n   * The touchmove event. Bubbles, will only ever fire in browsers with\n   * touch support.\n   */\n  TOUCHMOVE: 'touchmove',\n\n  /**\n   * The input event.\n   */\n  INPUT: 'input',\n\n  /**\n   * The scroll event.\n   */\n  SCROLL: 'scroll',\n\n  /**\n   * The toggle event. The toggle event doesn't bubble, but you can use it in\n   * addEvent() and jsaction anyway. EventContract does the right thing\n   * under the hood.\n   */\n  TOGGLE: 'toggle',\n\n  /**\n   * A custom event. The actual custom event type is declared as the 'type'\n   * field in the event details. Supported in Firefox 6+, IE 9+, and all Chrome\n   * versions.\n   *\n   * This is an internal name. Users should use jsaction's fireCustomEvent to\n   * fire custom events instead of relying on this type to create them.\n   */\n  CUSTOM: '_custom',\n};\n\nexport const NON_BUBBLING_MOUSE_EVENTS = [\n  EventType.MOUSEENTER,\n  EventType.MOUSELEAVE,\n  'pointerenter',\n  'pointerleave',\n];\n\n/**\n * Detects whether a given event type is supported by JSAction.\n */\nexport const isSupportedEvent = (eventType: string) => SUPPORTED_EVENTS.indexOf(eventType) >= 0;\n\nconst SUPPORTED_EVENTS = [\n  EventType.CLICK,\n  EventType.DBLCLICK,\n  EventType.FOCUS,\n  EventType.FOCUSIN,\n  EventType.BLUR,\n  EventType.ERROR,\n  EventType.FOCUSOUT,\n  EventType.KEYDOWN,\n  EventType.KEYUP,\n  EventType.KEYPRESS,\n  EventType.LOAD,\n  EventType.MOUSEOVER,\n  EventType.MOUSEOUT,\n  EventType.SUBMIT,\n  EventType.TOGGLE,\n  EventType.TOUCHSTART,\n  EventType.TOUCHEND,\n  EventType.TOUCHMOVE,\n  'touchcancel',\n\n  'auxclick',\n  'change',\n  'compositionstart',\n  'compositionupdate',\n  'compositionend',\n  'beforeinput',\n  'input',\n  'select',\n\n  'copy',\n  'cut',\n  'paste',\n  'mousedown',\n  'mouseup',\n  'wheel',\n  'contextmenu',\n\n  'dragover',\n  'dragenter',\n  'dragleave',\n  'drop',\n  'dragstart',\n  'dragend',\n\n  'pointerdown',\n  'pointermove',\n  'pointerup',\n  'pointercancel',\n  'pointerover',\n  'pointerout',\n  'gotpointercapture',\n  'lostpointercapture',\n\n  // Video events.\n  'ended',\n  'loadedmetadata',\n\n  // Page visibility events.\n  'pagehide',\n  'pageshow',\n  'visibilitychange',\n\n  // Content visibility events.\n  'beforematch',\n];\n\n/**\n *\n * Decides whether or not an event type is an event that only has a capture phase.\n *\n * @param eventType\n * @returns bool\n */\nexport const isCaptureEvent = (eventType: string) => CAPTURE_EVENTS.indexOf(eventType) >= 0;\n\nconst CAPTURE_EVENTS = [\n  EventType.FOCUS,\n  EventType.BLUR,\n  EventType.ERROR,\n  EventType.LOAD,\n  EventType.TOGGLE,\n];\n"]}

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

@@ -33,7 +33,7 @@ import { ActionResolver } from './action_resolver';
 import * as eventLib from './event';
 import { A11Y_CLICK_SUPPORT, MOUSE_SPECIAL_SUPPORT } from './event_contract_defines';
 import * as eventInfoLib from './event_info';
-import { EventType } from './event_type';
+import { EventType, NON_BUBBLING_MOUSE_EVENTS } from './event_type';
 /**
  * EventContract intercepts events in the bubbling phase at the
  * boundary of a container element, and maps them to generic actions
@@ -108,7 +108,8 @@ export class EventContract {
             return;
         }
         if (this.useActionResolver) {
-            this.actionResolver.resolve(eventInfo);
+            this.actionResolver.resolveEventType(eventInfo);
+            this.actionResolver.resolveAction(eventInfo);
         }
         this.dispatcher(eventInfo);
     }
@@ -129,11 +130,7 @@ export class EventContract {
         if (eventType in this.eventHandlers || !this.containerManager) {
             return;
         }
-        if (!EventContract.MOUSE_SPECIAL_SUPPORT &&
-            (eventType === EventType.MOUSEENTER ||
-                eventType === EventType.MOUSELEAVE ||
-                eventType === EventType.POINTERENTER ||
-                eventType === EventType.POINTERLEAVE)) {
+        if (!EventContract.MOUSE_SPECIAL_SUPPORT && NON_BUBBLING_MOUSE_EVENTS.indexOf(eventType) >= 0) {
             return;
         }
         const eventHandler = (eventType, event, container) => {
@@ -287,4 +284,4 @@ function removeEventListeners(container, eventTypes, earlyEventHandler, capture)
 export function addDeferredA11yClickSupport(eventContract) {
     eventContract.ecaacs?.(a11yClickLib.updateEventInfoForA11yClick, a11yClickLib.preventDefaultForA11yClick, a11yClickLib.populateClickOnlyAction);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eventcontract.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/eventcontract.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\n/**\n * @fileoverview Implements the local event handling contract. This\n * allows DOM objects in a container that enters into this contract to\n * define event handlers which are executed in a local context.\n *\n * One EventContract instance can manage the contract for multiple\n * containers, which are added using the addContainer() method.\n *\n * Events can be registered using the addEvent() method.\n *\n * A Dispatcher is added using the registerDispatcher() method. Until there is\n * a dispatcher, events are queued. The idea is that the EventContract\n * class is inlined in the HTML of the top level page and instantiated\n * right after the start of <body>. The Dispatcher class is contained\n * in the external deferred js, and instantiated and registered with\n * EventContract when the external javascript in the page loads. The\n * external javascript will also register the jsaction handlers, which\n * then pick up the queued events at the time of registration.\n *\n * Since this class is meant to be inlined in the main page HTML, the\n * size of the binary compiled from this file MUST be kept as small as\n * possible and thus its dependencies to a minimum.\n */\n\nimport * as a11yClickLib from './a11y_click';\nimport {ActionResolver} from './action_resolver';\nimport {EarlyJsactionData, EarlyJsactionDataContainer} from './earlyeventcontract';\nimport * as eventLib from './event';\nimport {EventContractContainerManager} from './event_contract_container';\nimport {A11Y_CLICK_SUPPORT, MOUSE_SPECIAL_SUPPORT} from './event_contract_defines';\nimport * as eventInfoLib from './event_info';\nimport {EventType} from './event_type';\nimport {Restriction} from './restriction';\n\n/**\n * The API of an EventContract that is safe to call from any compilation unit.\n */\nexport declare interface UnrenamedEventContract {\n  // Alias for Jsction EventContract registerDispatcher.\n  ecrd(dispatcher: Dispatcher, restriction: Restriction): void;\n  // Unrenamed function. Abbreviation for `eventContract.addA11yClickSupport`.\n  ecaacs?: (\n    updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction,\n  ) => void;\n}\n\n/** A function that is called to handle events captured by the EventContract. */\nexport type Dispatcher = (eventInfo: eventInfoLib.EventInfo, globalDispatch?: boolean) => void;\n\n/**\n * A function that handles an event dispatched from the browser.\n *\n * eventType: May differ from `event.type` if JSAction uses a\n * short-hand name or is patching over an non-bubbling event with a bubbling\n * variant.\n * event: The native browser event.\n * container: The container for this dispatch.\n */\ntype EventHandler = (eventType: string, event: Event, container: Element) => void;\n\n/**\n * EventContract intercepts events in the bubbling phase at the\n * boundary of a container element, and maps them to generic actions\n * which are specified using the custom jsaction attribute in\n * HTML. Behavior of the application is then specified in terms of\n * handler for such actions, cf. jsaction.Dispatcher in dispatcher.js.\n *\n * This has several benefits: (1) No DOM event handlers need to be\n * registered on the specific elements in the UI. (2) The set of\n * events that the application has to handle can be specified in terms\n * of the semantics of the application, rather than in terms of DOM\n * events. (3) Invocation of handlers can be delayed and handlers can\n * be delay loaded in a generic way.\n */\nexport class EventContract implements UnrenamedEventContract {\n  static A11Y_CLICK_SUPPORT = A11Y_CLICK_SUPPORT;\n  static MOUSE_SPECIAL_SUPPORT = MOUSE_SPECIAL_SUPPORT;\n\n  private containerManager: EventContractContainerManager | null;\n\n  private readonly actionResolver?: ActionResolver;\n\n  /**\n   * The DOM events which this contract covers. Used to prevent double\n   * registration of event types. The value of the map is the\n   * internally created DOM event handler function that handles the\n   * DOM events. See addEvent().\n   *\n   */\n  private eventHandlers: {[key: string]: EventHandler} = {};\n\n  private browserEventTypeToExtraEventTypes: {[key: string]: string[]} = {};\n\n  /**\n   * The dispatcher function. Events are passed to this function for\n   * handling once it was set using the registerDispatcher() method. This is\n   * done because the function is passed from another jsbinary, so passing the\n   * instance and invoking the method here would require to leave the method\n   * unobfuscated.\n   */\n  private dispatcher: Dispatcher | null = null;\n\n  /**\n   * The list of suspended `EventInfo` that will be dispatched\n   * as soon as the `Dispatcher` is registered.\n   */\n  private queuedEventInfos: eventInfoLib.EventInfo[] | null = [];\n\n  /** Whether to add an a11y click listener. */\n  private addA11yClickListener = false;\n\n  ecaacs?: (\n    updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction,\n  ) => void;\n\n  constructor(\n    containerManager: EventContractContainerManager,\n    private readonly useActionResolver = true,\n  ) {\n    this.containerManager = containerManager;\n    if (this.useActionResolver) {\n      this.actionResolver = new ActionResolver({\n        syntheticMouseEventSupport: EventContract.MOUSE_SPECIAL_SUPPORT,\n      });\n    }\n    if (EventContract.A11Y_CLICK_SUPPORT) {\n      // Add a11y click support to the `EventContract`.\n      this.addA11yClickSupport();\n    }\n  }\n\n  private handleEvent(eventType: string, event: Event, container: Element) {\n    const eventInfo = eventInfoLib.createEventInfoFromParameters(\n      /* eventType= */ eventType,\n      /* event= */ event,\n      /* targetElement= */ event.target as Element,\n      /* container= */ container,\n      /* timestamp= */ Date.now(),\n    );\n    this.handleEventInfo(eventInfo);\n  }\n\n  /**\n   * Handle an `EventInfo`.\n   */\n  private handleEventInfo(eventInfo: eventInfoLib.EventInfo) {\n    if (!this.dispatcher) {\n      // All events are queued when the dispatcher isn't yet loaded.\n      eventInfoLib.setIsReplay(eventInfo, true);\n      this.queuedEventInfos?.push(eventInfo);\n      return;\n    }\n    if (this.useActionResolver) {\n      this.actionResolver!.resolve(eventInfo);\n    }\n    this.dispatcher(eventInfo);\n  }\n\n  /**\n   * Enables jsaction handlers to be called for the event type given by\n   * name.\n   *\n   * If the event is already registered, this does nothing.\n   *\n   * @param prefixedEventType If supplied, this event is used in\n   *     the actual browser event registration instead of the name that is\n   *     exposed to jsaction. Use this if you e.g. want users to be able\n   *     to subscribe to jsaction=\"transitionEnd:foo\" while the underlying\n   *     event is webkitTransitionEnd in one browser and mozTransitionEnd\n   *     in another.\n   */\n  addEvent(eventType: string, prefixedEventType?: string) {\n    if (eventType in this.eventHandlers || !this.containerManager) {\n      return;\n    }\n\n    if (\n      !EventContract.MOUSE_SPECIAL_SUPPORT &&\n      (eventType === EventType.MOUSEENTER ||\n        eventType === EventType.MOUSELEAVE ||\n        eventType === EventType.POINTERENTER ||\n        eventType === EventType.POINTERLEAVE)\n    ) {\n      return;\n    }\n\n    const eventHandler = (eventType: string, event: Event, container: Element) => {\n      this.handleEvent(eventType, event, container);\n    };\n\n    // Store the callback to allow us to replay events.\n    this.eventHandlers[eventType] = eventHandler;\n\n    const browserEventType = eventLib.getBrowserEventType(prefixedEventType || eventType);\n\n    if (browserEventType !== eventType) {\n      const eventTypes = this.browserEventTypeToExtraEventTypes[browserEventType] || [];\n      eventTypes.push(eventType);\n      this.browserEventTypeToExtraEventTypes[browserEventType] = eventTypes;\n    }\n\n    this.containerManager.addEventListener(browserEventType, (element: Element) => {\n      return (event: Event) => {\n        eventHandler(eventType, event, element);\n      };\n    });\n\n    // Automatically install a keypress/keydown event handler if support for\n    // accessible clicks is turned on.\n    if (this.addA11yClickListener && eventType === EventType.CLICK) {\n      this.addEvent(EventType.KEYDOWN);\n    }\n  }\n\n  /**\n   * Gets the queued early events and replay them using the appropriate handler\n   * in the provided event contract. Once all the events are replayed, it cleans\n   * up the early contract.\n   */\n  replayEarlyEvents(\n    earlyJsactionContainer: EarlyJsactionDataContainer = window as EarlyJsactionDataContainer,\n  ) {\n    // Check if the early contract is present and prevent calling this function\n    // more than once.\n    const earlyJsactionData: EarlyJsactionData | undefined = earlyJsactionContainer._ejsa;\n    if (!earlyJsactionData) {\n      return;\n    }\n\n    // Replay the early contract events.\n    const earlyEventInfos: eventInfoLib.EventInfo[] = earlyJsactionData.q;\n    for (let idx = 0; idx < earlyEventInfos.length; idx++) {\n      const earlyEventInfo: eventInfoLib.EventInfo = earlyEventInfos[idx];\n      const eventTypes = this.getEventTypesForBrowserEventType(earlyEventInfo.eventType);\n      for (let i = 0; i < eventTypes.length; i++) {\n        const eventInfo = eventInfoLib.cloneEventInfo(earlyEventInfo);\n        // EventInfo eventType maps to JSAction's internal event type,\n        // rather than the browser event type.\n        eventInfoLib.setEventType(eventInfo, eventTypes[i]);\n        this.handleEventInfo(eventInfo);\n      }\n    }\n\n    // Clean up the early contract.\n    const earlyEventHandler: (event: Event) => void = earlyJsactionData.h;\n    removeEventListeners(earlyJsactionData.c, earlyJsactionData.et, earlyEventHandler);\n    removeEventListeners(earlyJsactionData.c, earlyJsactionData.etc, earlyEventHandler, true);\n    delete earlyJsactionContainer._ejsa;\n  }\n\n  /**\n   * Returns all JSAction event types that have been registered for a given\n   * browser event type.\n   */\n  private getEventTypesForBrowserEventType(browserEventType: string) {\n    const eventTypes = [];\n    if (this.eventHandlers[browserEventType]) {\n      eventTypes.push(browserEventType);\n    }\n    if (this.browserEventTypeToExtraEventTypes[browserEventType]) {\n      eventTypes.push(...this.browserEventTypeToExtraEventTypes[browserEventType]);\n    }\n    return eventTypes;\n  }\n\n  /**\n   * Returns the event handler function for a given event type.\n   */\n  handler(eventType: string): EventHandler | undefined {\n    return this.eventHandlers[eventType];\n  }\n\n  /**\n   * Cleans up the event contract. This resets all of the `EventContract`'s\n   * internal state. Users are responsible for not using this `EventContract`\n   * after it has been cleaned up.\n   */\n  cleanUp() {\n    this.containerManager!.cleanUp();\n    this.containerManager = null;\n    this.eventHandlers = {};\n    this.browserEventTypeToExtraEventTypes = {};\n    this.dispatcher = null;\n    this.queuedEventInfos = [];\n  }\n\n  /**\n   * Register a dispatcher function. Event info of each event mapped to\n   * a jsaction is passed for handling to this callback. The queued\n   * events are passed as well to the dispatcher for later replaying\n   * once the dispatcher is registered. Clears the event queue to null.\n   *\n   * @param dispatcher The dispatcher function.\n   * @param restriction\n   */\n  registerDispatcher(dispatcher: Dispatcher, restriction: Restriction) {\n    this.ecrd(dispatcher, restriction);\n  }\n\n  /**\n   * Unrenamed alias for registerDispatcher. Necessary for any codebases that\n   * split the `EventContract` and `Dispatcher` code into different compilation\n   * units.\n   */\n  ecrd(dispatcher: Dispatcher, restriction: Restriction) {\n    this.dispatcher = dispatcher;\n\n    if (this.queuedEventInfos?.length) {\n      for (let i = 0; i < this.queuedEventInfos.length; i++) {\n        this.handleEventInfo(this.queuedEventInfos[i]);\n      }\n      this.queuedEventInfos = null;\n    }\n  }\n\n  /**\n   * Adds a11y click support to the given `EventContract`. Meant to be called in\n   * the same compilation unit as the `EventContract`.\n   */\n  addA11yClickSupport() {\n    this.addA11yClickSupportImpl(\n      a11yClickLib.updateEventInfoForA11yClick,\n      a11yClickLib.preventDefaultForA11yClick,\n      a11yClickLib.populateClickOnlyAction,\n    );\n  }\n\n  /**\n   * Enables a11y click support to be deferred. Meant to be called in the same\n   * compilation unit as the `EventContract`.\n   */\n  exportAddA11yClickSupport() {\n    this.addA11yClickListener = true;\n    this.ecaacs = this.addA11yClickSupportImpl.bind(this);\n  }\n\n  /**\n   * Unrenamed function that loads a11yClickSupport.\n   */\n  private addA11yClickSupportImpl(\n    updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction,\n  ) {\n    this.addA11yClickListener = true;\n    if (this.useActionResolver) {\n      this.actionResolver!.addA11yClickSupport(\n        updateEventInfoForA11yClick,\n        preventDefaultForA11yClick,\n        populateClickOnlyAction,\n      );\n    }\n  }\n}\n\nfunction removeEventListeners(\n  container: HTMLElement,\n  eventTypes: string[],\n  earlyEventHandler: (e: Event) => void,\n  capture?: boolean,\n) {\n  for (let idx = 0; idx < eventTypes.length; idx++) {\n    container.removeEventListener(eventTypes[idx], earlyEventHandler, /* useCapture */ capture);\n  }\n}\n\n/**\n * Adds a11y click support to the given `EventContract`. Meant to be called\n * in a different compilation unit from the `EventContract`. The `EventContract`\n * must have called `exportAddA11yClickSupport` in its compilation unit for this\n * to have any effect.\n */\nexport function addDeferredA11yClickSupport(eventContract: EventContract) {\n  eventContract.ecaacs?.(\n    a11yClickLib.updateEventInfoForA11yClick,\n    a11yClickLib.preventDefaultForA11yClick,\n    a11yClickLib.populateClickOnlyAction,\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eventcontract.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/eventcontract.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\n/**\n * @fileoverview Implements the local event handling contract. This\n * allows DOM objects in a container that enters into this contract to\n * define event handlers which are executed in a local context.\n *\n * One EventContract instance can manage the contract for multiple\n * containers, which are added using the addContainer() method.\n *\n * Events can be registered using the addEvent() method.\n *\n * A Dispatcher is added using the registerDispatcher() method. Until there is\n * a dispatcher, events are queued. The idea is that the EventContract\n * class is inlined in the HTML of the top level page and instantiated\n * right after the start of <body>. The Dispatcher class is contained\n * in the external deferred js, and instantiated and registered with\n * EventContract when the external javascript in the page loads. The\n * external javascript will also register the jsaction handlers, which\n * then pick up the queued events at the time of registration.\n *\n * Since this class is meant to be inlined in the main page HTML, the\n * size of the binary compiled from this file MUST be kept as small as\n * possible and thus its dependencies to a minimum.\n */\n\nimport * as a11yClickLib from './a11y_click';\nimport {ActionResolver} from './action_resolver';\nimport {EarlyJsactionData, EarlyJsactionDataContainer} from './earlyeventcontract';\nimport * as eventLib from './event';\nimport {EventContractContainerManager} from './event_contract_container';\nimport {A11Y_CLICK_SUPPORT, MOUSE_SPECIAL_SUPPORT} from './event_contract_defines';\nimport * as eventInfoLib from './event_info';\nimport {EventType, NON_BUBBLING_MOUSE_EVENTS} from './event_type';\nimport {Restriction} from './restriction';\n\n/**\n * The API of an EventContract that is safe to call from any compilation unit.\n */\nexport declare interface UnrenamedEventContract {\n  // Alias for Jsction EventContract registerDispatcher.\n  ecrd(dispatcher: Dispatcher, restriction: Restriction): void;\n  // Unrenamed function. Abbreviation for `eventContract.addA11yClickSupport`.\n  ecaacs?: (\n    updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction,\n  ) => void;\n}\n\n/** A function that is called to handle events captured by the EventContract. */\nexport type Dispatcher = (eventInfo: eventInfoLib.EventInfo, globalDispatch?: boolean) => void;\n\n/**\n * A function that handles an event dispatched from the browser.\n *\n * eventType: May differ from `event.type` if JSAction uses a\n * short-hand name or is patching over an non-bubbling event with a bubbling\n * variant.\n * event: The native browser event.\n * container: The container for this dispatch.\n */\ntype EventHandler = (eventType: string, event: Event, container: Element) => void;\n\n/**\n * EventContract intercepts events in the bubbling phase at the\n * boundary of a container element, and maps them to generic actions\n * which are specified using the custom jsaction attribute in\n * HTML. Behavior of the application is then specified in terms of\n * handler for such actions, cf. jsaction.Dispatcher in dispatcher.js.\n *\n * This has several benefits: (1) No DOM event handlers need to be\n * registered on the specific elements in the UI. (2) The set of\n * events that the application has to handle can be specified in terms\n * of the semantics of the application, rather than in terms of DOM\n * events. (3) Invocation of handlers can be delayed and handlers can\n * be delay loaded in a generic way.\n */\nexport class EventContract implements UnrenamedEventContract {\n  static A11Y_CLICK_SUPPORT = A11Y_CLICK_SUPPORT;\n  static MOUSE_SPECIAL_SUPPORT = MOUSE_SPECIAL_SUPPORT;\n\n  private containerManager: EventContractContainerManager | null;\n\n  private readonly actionResolver?: ActionResolver;\n\n  /**\n   * The DOM events which this contract covers. Used to prevent double\n   * registration of event types. The value of the map is the\n   * internally created DOM event handler function that handles the\n   * DOM events. See addEvent().\n   *\n   */\n  private eventHandlers: {[key: string]: EventHandler} = {};\n\n  private browserEventTypeToExtraEventTypes: {[key: string]: string[]} = {};\n\n  /**\n   * The dispatcher function. Events are passed to this function for\n   * handling once it was set using the registerDispatcher() method. This is\n   * done because the function is passed from another jsbinary, so passing the\n   * instance and invoking the method here would require to leave the method\n   * unobfuscated.\n   */\n  private dispatcher: Dispatcher | null = null;\n\n  /**\n   * The list of suspended `EventInfo` that will be dispatched\n   * as soon as the `Dispatcher` is registered.\n   */\n  private queuedEventInfos: eventInfoLib.EventInfo[] | null = [];\n\n  /** Whether to add an a11y click listener. */\n  private addA11yClickListener = false;\n\n  ecaacs?: (\n    updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction,\n  ) => void;\n\n  constructor(\n    containerManager: EventContractContainerManager,\n    private readonly useActionResolver = true,\n  ) {\n    this.containerManager = containerManager;\n    if (this.useActionResolver) {\n      this.actionResolver = new ActionResolver({\n        syntheticMouseEventSupport: EventContract.MOUSE_SPECIAL_SUPPORT,\n      });\n    }\n    if (EventContract.A11Y_CLICK_SUPPORT) {\n      // Add a11y click support to the `EventContract`.\n      this.addA11yClickSupport();\n    }\n  }\n\n  private handleEvent(eventType: string, event: Event, container: Element) {\n    const eventInfo = eventInfoLib.createEventInfoFromParameters(\n      /* eventType= */ eventType,\n      /* event= */ event,\n      /* targetElement= */ event.target as Element,\n      /* container= */ container,\n      /* timestamp= */ Date.now(),\n    );\n    this.handleEventInfo(eventInfo);\n  }\n\n  /**\n   * Handle an `EventInfo`.\n   */\n  private handleEventInfo(eventInfo: eventInfoLib.EventInfo) {\n    if (!this.dispatcher) {\n      // All events are queued when the dispatcher isn't yet loaded.\n      eventInfoLib.setIsReplay(eventInfo, true);\n      this.queuedEventInfos?.push(eventInfo);\n      return;\n    }\n    if (this.useActionResolver) {\n      this.actionResolver!.resolveEventType(eventInfo);\n      this.actionResolver!.resolveAction(eventInfo);\n    }\n    this.dispatcher(eventInfo);\n  }\n\n  /**\n   * Enables jsaction handlers to be called for the event type given by\n   * name.\n   *\n   * If the event is already registered, this does nothing.\n   *\n   * @param prefixedEventType If supplied, this event is used in\n   *     the actual browser event registration instead of the name that is\n   *     exposed to jsaction. Use this if you e.g. want users to be able\n   *     to subscribe to jsaction=\"transitionEnd:foo\" while the underlying\n   *     event is webkitTransitionEnd in one browser and mozTransitionEnd\n   *     in another.\n   */\n  addEvent(eventType: string, prefixedEventType?: string) {\n    if (eventType in this.eventHandlers || !this.containerManager) {\n      return;\n    }\n\n    if (!EventContract.MOUSE_SPECIAL_SUPPORT && NON_BUBBLING_MOUSE_EVENTS.indexOf(eventType) >= 0) {\n      return;\n    }\n\n    const eventHandler = (eventType: string, event: Event, container: Element) => {\n      this.handleEvent(eventType, event, container);\n    };\n\n    // Store the callback to allow us to replay events.\n    this.eventHandlers[eventType] = eventHandler;\n\n    const browserEventType = eventLib.getBrowserEventType(prefixedEventType || eventType);\n\n    if (browserEventType !== eventType) {\n      const eventTypes = this.browserEventTypeToExtraEventTypes[browserEventType] || [];\n      eventTypes.push(eventType);\n      this.browserEventTypeToExtraEventTypes[browserEventType] = eventTypes;\n    }\n\n    this.containerManager.addEventListener(browserEventType, (element: Element) => {\n      return (event: Event) => {\n        eventHandler(eventType, event, element);\n      };\n    });\n\n    // Automatically install a keypress/keydown event handler if support for\n    // accessible clicks is turned on.\n    if (this.addA11yClickListener && eventType === EventType.CLICK) {\n      this.addEvent(EventType.KEYDOWN);\n    }\n  }\n\n  /**\n   * Gets the queued early events and replay them using the appropriate handler\n   * in the provided event contract. Once all the events are replayed, it cleans\n   * up the early contract.\n   */\n  replayEarlyEvents(\n    earlyJsactionContainer: EarlyJsactionDataContainer = window as EarlyJsactionDataContainer,\n  ) {\n    // Check if the early contract is present and prevent calling this function\n    // more than once.\n    const earlyJsactionData: EarlyJsactionData | undefined = earlyJsactionContainer._ejsa;\n    if (!earlyJsactionData) {\n      return;\n    }\n\n    // Replay the early contract events.\n    const earlyEventInfos: eventInfoLib.EventInfo[] = earlyJsactionData.q;\n    for (let idx = 0; idx < earlyEventInfos.length; idx++) {\n      const earlyEventInfo: eventInfoLib.EventInfo = earlyEventInfos[idx];\n      const eventTypes = this.getEventTypesForBrowserEventType(earlyEventInfo.eventType);\n      for (let i = 0; i < eventTypes.length; i++) {\n        const eventInfo = eventInfoLib.cloneEventInfo(earlyEventInfo);\n        // EventInfo eventType maps to JSAction's internal event type,\n        // rather than the browser event type.\n        eventInfoLib.setEventType(eventInfo, eventTypes[i]);\n        this.handleEventInfo(eventInfo);\n      }\n    }\n\n    // Clean up the early contract.\n    const earlyEventHandler: (event: Event) => void = earlyJsactionData.h;\n    removeEventListeners(earlyJsactionData.c, earlyJsactionData.et, earlyEventHandler);\n    removeEventListeners(earlyJsactionData.c, earlyJsactionData.etc, earlyEventHandler, true);\n    delete earlyJsactionContainer._ejsa;\n  }\n\n  /**\n   * Returns all JSAction event types that have been registered for a given\n   * browser event type.\n   */\n  private getEventTypesForBrowserEventType(browserEventType: string) {\n    const eventTypes = [];\n    if (this.eventHandlers[browserEventType]) {\n      eventTypes.push(browserEventType);\n    }\n    if (this.browserEventTypeToExtraEventTypes[browserEventType]) {\n      eventTypes.push(...this.browserEventTypeToExtraEventTypes[browserEventType]);\n    }\n    return eventTypes;\n  }\n\n  /**\n   * Returns the event handler function for a given event type.\n   */\n  handler(eventType: string): EventHandler | undefined {\n    return this.eventHandlers[eventType];\n  }\n\n  /**\n   * Cleans up the event contract. This resets all of the `EventContract`'s\n   * internal state. Users are responsible for not using this `EventContract`\n   * after it has been cleaned up.\n   */\n  cleanUp() {\n    this.containerManager!.cleanUp();\n    this.containerManager = null;\n    this.eventHandlers = {};\n    this.browserEventTypeToExtraEventTypes = {};\n    this.dispatcher = null;\n    this.queuedEventInfos = [];\n  }\n\n  /**\n   * Register a dispatcher function. Event info of each event mapped to\n   * a jsaction is passed for handling to this callback. The queued\n   * events are passed as well to the dispatcher for later replaying\n   * once the dispatcher is registered. Clears the event queue to null.\n   *\n   * @param dispatcher The dispatcher function.\n   * @param restriction\n   */\n  registerDispatcher(dispatcher: Dispatcher, restriction: Restriction) {\n    this.ecrd(dispatcher, restriction);\n  }\n\n  /**\n   * Unrenamed alias for registerDispatcher. Necessary for any codebases that\n   * split the `EventContract` and `Dispatcher` code into different compilation\n   * units.\n   */\n  ecrd(dispatcher: Dispatcher, restriction: Restriction) {\n    this.dispatcher = dispatcher;\n\n    if (this.queuedEventInfos?.length) {\n      for (let i = 0; i < this.queuedEventInfos.length; i++) {\n        this.handleEventInfo(this.queuedEventInfos[i]);\n      }\n      this.queuedEventInfos = null;\n    }\n  }\n\n  /**\n   * Adds a11y click support to the given `EventContract`. Meant to be called in\n   * the same compilation unit as the `EventContract`.\n   */\n  addA11yClickSupport() {\n    this.addA11yClickSupportImpl(\n      a11yClickLib.updateEventInfoForA11yClick,\n      a11yClickLib.preventDefaultForA11yClick,\n      a11yClickLib.populateClickOnlyAction,\n    );\n  }\n\n  /**\n   * Enables a11y click support to be deferred. Meant to be called in the same\n   * compilation unit as the `EventContract`.\n   */\n  exportAddA11yClickSupport() {\n    this.addA11yClickListener = true;\n    this.ecaacs = this.addA11yClickSupportImpl.bind(this);\n  }\n\n  /**\n   * Unrenamed function that loads a11yClickSupport.\n   */\n  private addA11yClickSupportImpl(\n    updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick,\n    preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick,\n    populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction,\n  ) {\n    this.addA11yClickListener = true;\n    if (this.useActionResolver) {\n      this.actionResolver!.addA11yClickSupport(\n        updateEventInfoForA11yClick,\n        preventDefaultForA11yClick,\n        populateClickOnlyAction,\n      );\n    }\n  }\n}\n\nfunction removeEventListeners(\n  container: HTMLElement,\n  eventTypes: string[],\n  earlyEventHandler: (e: Event) => void,\n  capture?: boolean,\n) {\n  for (let idx = 0; idx < eventTypes.length; idx++) {\n    container.removeEventListener(eventTypes[idx], earlyEventHandler, /* useCapture */ capture);\n  }\n}\n\n/**\n * Adds a11y click support to the given `EventContract`. Meant to be called\n * in a different compilation unit from the `EventContract`. The `EventContract`\n * must have called `exportAddA11yClickSupport` in its compilation unit for this\n * to have any effect.\n */\nexport function addDeferredA11yClickSupport(eventContract: EventContract) {\n  eventContract.ecaacs?.(\n    a11yClickLib.updateEventInfoForA11yClick,\n    a11yClickLib.preventDefaultForA11yClick,\n    a11yClickLib.populateClickOnlyAction,\n  );\n}\n"]}