@angular/core 18.0.0-next.4 → 18.0.0-next.6

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

@@ -0,0 +1,244 @@
+/**
+ * @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
+ */
+/*
+ * Names of events that are special to jsaction. These are not all
+ * event types that are legal to use in either HTML or the addEvent()
+ * API, but these are the ones that are treated specially. All other
+ * DOM events can be used in either addEvent() or in the value of the
+ * jsaction attribute. Beware of browser specific events or events
+ * that don't bubble though: If they are not mentioned here, then
+ * event contract doesn't work around their peculiarities.
+ */
+export const EventType = {
+    /**
+     * Mouse middle click, introduced in Chrome 55 and not yet supported on
+     * other browsers.
+     */
+    AUXCLICK: 'auxclick',
+    /**
+     * The change event fired by browsers when the `value` attribute of input,
+     * select, and textarea elements are changed.
+     */
+    CHANGE: 'change',
+    /**
+     * The click event. In addEvent() refers to all click events, in the
+     * jsaction attribute it refers to the unmodified click and Enter/Space
+     * keypress events.  In the latter case, a jsaction click will be triggered,
+     * for accessibility reasons.  See clickmod and clickonly, below.
+     */
+    CLICK: 'click',
+    /**
+     * Specifies the jsaction for a modified click event (i.e. a mouse
+     * click with the modifier key Cmd/Ctrl pressed). This event isn't
+     * separately enabled in addEvent(), because in the DOM, it's just a
+     * click event.
+     */
+    CLICKMOD: 'clickmod',
+    /**
+     * Specifies the jsaction for a click-only event.  Click-only doesn't take
+     * into account the case where an element with focus receives an Enter/Space
+     * keypress.  This event isn't separately enabled in addEvent().
+     */
+    CLICKONLY: 'clickonly',
+    /**
+     * The dblclick event.
+     */
+    DBLCLICK: 'dblclick',
+    /**
+     * Focus doesn't bubble, but you can use it in addEvent() and
+     * jsaction anyway. EventContract does the right thing under the
+     * hood.
+     */
+    FOCUS: 'focus',
+    /**
+     * This event only exists in IE. For addEvent() and jsaction, use
+     * focus instead; EventContract does the right thing even though
+     * focus doesn't bubble.
+     */
+    FOCUSIN: 'focusin',
+    /**
+     * Analog to focus.
+     */
+    BLUR: 'blur',
+    /**
+     * Analog to focusin.
+     */
+    FOCUSOUT: 'focusout',
+    /**
+     * Submit doesn't bubble, so it cannot be used with event
+     * contract. However, the browser helpfully fires a click event on
+     * the submit button of a form (even if the form is not submitted by
+     * a click on the submit button). So you should handle click on the
+     * submit button instead.
+     */
+    SUBMIT: 'submit',
+    /**
+     * The keydown event. In addEvent() and non-click jsaction it represents the
+     * regular DOM keydown event. It represents click actions in non-Gecko
+     * browsers.
+     */
+    KEYDOWN: 'keydown',
+    /**
+     * The keypress event. In addEvent() and non-click jsaction it represents the
+     * regular DOM keypress event. It represents click actions in Gecko browsers.
+     */
+    KEYPRESS: 'keypress',
+    /**
+     * The keyup event. In addEvent() and non-click jsaction it represents the
+     * regular DOM keyup event. It represents click actions in non-Gecko
+     * browsers.
+     */
+    KEYUP: 'keyup',
+    /**
+     * The mouseup event. Can either be used directly or used implicitly to
+     * capture mouseup events. In addEvent(), it represents a regular DOM
+     * mouseup event.
+     */
+    MOUSEUP: 'mouseup',
+    /**
+     * The mousedown event. Can either be used directly or used implicitly to
+     * capture mouseenter events. In addEvent(), it represents a regular DOM
+     * mouseover event.
+     */
+    MOUSEDOWN: 'mousedown',
+    /**
+     * The mouseover event. Can either be used directly or used implicitly to
+     * capture mouseenter events. In addEvent(), it represents a regular DOM
+     * mouseover event.
+     */
+    MOUSEOVER: 'mouseover',
+    /**
+     * The mouseout event. Can either be used directly or used implicitly to
+     * capture mouseover events. In addEvent(), it represents a regular DOM
+     * mouseout event.
+     */
+    MOUSEOUT: 'mouseout',
+    /**
+     * The mouseenter event. Does not bubble and fires individually on each
+     * element being entered within a DOM tree.
+     */
+    MOUSEENTER: 'mouseenter',
+    /**
+     * The mouseleave event. Does not bubble and fires individually on each
+     * element being entered within a DOM tree.
+     */
+    MOUSELEAVE: 'mouseleave',
+    /**
+     * The mousemove event.
+     */
+    MOUSEMOVE: 'mousemove',
+    /**
+     * The pointerup event. Can either be used directly or used implicitly to
+     * capture pointerup events. In addEvent(), it represents a regular DOM
+     * pointerup event.
+     */
+    POINTERUP: 'pointerup',
+    /**
+     * The pointerdown event. Can either be used directly or used implicitly to
+     * capture pointerenter events. In addEvent(), it represents a regular DOM
+     * mouseover event.
+     */
+    POINTERDOWN: 'pointerdown',
+    /**
+     * The pointerover event. Can either be used directly or used implicitly to
+     * capture pointerenter events. In addEvent(), it represents a regular DOM
+     * pointerover event.
+     */
+    POINTEROVER: 'pointerover',
+    /**
+     * The pointerout event. Can either be used directly or used implicitly to
+     * capture pointerover events. In addEvent(), it represents a regular DOM
+     * pointerout event.
+     */
+    POINTEROUT: 'pointerout',
+    /**
+     * The pointerenter event. Does not bubble and fires individually on each
+     * element being entered within a DOM tree.
+     */
+    POINTERENTER: 'pointerenter',
+    /**
+     * The pointerleave event. Does not bubble and fires individually on each
+     * element being entered within a DOM tree.
+     */
+    POINTERLEAVE: 'pointerleave',
+    /**
+     * The pointermove event.
+     */
+    POINTERMOVE: 'pointermove',
+    /**
+     * The pointercancel event.
+     */
+    POINTERCANCEL: 'pointercancel',
+    /**
+     * The gotpointercapture event is fired when
+     * Element.setPointerCapture(pointerId) is called on a mouse input, or
+     * implicitly when a touch input begins.
+     */
+    GOTPOINTERCAPTURE: 'gotpointercapture',
+    /**
+     * The lostpointercapture event is fired when
+     * Element.releasePointerCapture(pointerId) is called, or implicitly after a
+     * touch input ends.
+     */
+    LOSTPOINTERCAPTURE: 'lostpointercapture',
+    /**
+     * The error event. The error event doesn't bubble, but you can use it in
+     * addEvent() and jsaction anyway. EventContract does the right thing under
+     * the hood (except in IE8 which does not use error events).
+     */
+    ERROR: 'error',
+    /**
+     * The load event. The load event doesn't bubble, but you can use it in
+     * addEvent() and jsaction anyway. EventContract does the right thing
+     * under the hood.
+     */
+    LOAD: 'load',
+    /**
+     * The unload event.
+     */
+    UNLOAD: 'unload',
+    /**
+     * The touchstart event. Bubbles, will only ever fire in browsers with
+     * touch support.
+     */
+    TOUCHSTART: 'touchstart',
+    /**
+     * The touchend event. Bubbles, will only ever fire in browsers with
+     * touch support.
+     */
+    TOUCHEND: 'touchend',
+    /**
+     * The touchmove event. Bubbles, will only ever fire in browsers with
+     * touch support.
+     */
+    TOUCHMOVE: 'touchmove',
+    /**
+     * The input event.
+     */
+    INPUT: 'input',
+    /**
+     * The scroll event.
+     */
+    SCROLL: 'scroll',
+    /**
+     * The toggle event. The toggle event doesn't bubble, but you can use it in
+     * addEvent() and jsaction anyway. EventContract does the right thing
+     * under the hood.
+     */
+    TOGGLE: 'toggle',
+    /**
+     * A custom event. The actual custom event type is declared as the 'type'
+     * field in the event details. Supported in Firefox 6+, IE 9+, and all Chrome
+     * versions.
+     *
+     * This is an internal name. Users should use jsaction's fireCustomEvent to
+     * fire custom events instead of relying on this type to create them.
+     */
+    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"]}