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

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

@@ -0,0 +1,10 @@
+/**
+ * @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 { bootstrapEventContract } from './src/register_events';
+window['__jsaction_bootstrap'] = bootstrapEventContract;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJhY3RfYmluYXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9wcmltaXRpdmVzL2V2ZW50LWRpc3BhdGNoL2NvbnRyYWN0X2JpbmFyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsc0JBQXNCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUU1RCxNQUFjLENBQUMsc0JBQXNCLENBQUMsR0FBRyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge2Jvb3RzdHJhcEV2ZW50Q29udHJhY3R9IGZyb20gJy4vc3JjL3JlZ2lzdGVyX2V2ZW50cyc7XG5cbih3aW5kb3cgYXMgYW55KVsnX19qc2FjdGlvbl9ib290c3RyYXAnXSA9IGJvb3RzdHJhcEV2ZW50Q29udHJhY3Q7XG4iXX0=

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

@@ -0,0 +1,13 @@
+/**
+ * @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
+ */
+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 { EventInfoWrapper } from './src/event_info';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFVBQVUsRUFBRSxrQkFBa0IsRUFBQyxNQUFNLGtCQUFrQixDQUFDO0FBQ2hFLE9BQU8sRUFBQyxzQkFBc0IsRUFBQyxNQUFNLGdDQUFnQyxDQUFDO0FBQ3RFLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUNsRCxPQUFPLEVBQUMsc0JBQXNCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUM3RCxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQge0Rpc3BhdGNoZXIsIHJlZ2lzdGVyRGlzcGF0Y2hlcn0gZnJvbSAnLi9zcmMvZGlzcGF0Y2hlcic7XG5leHBvcnQge0V2ZW50Q29udHJhY3RDb250YWluZXJ9IGZyb20gJy4vc3JjL2V2ZW50X2NvbnRyYWN0X2NvbnRhaW5lcic7XG5leHBvcnQge0V2ZW50Q29udHJhY3R9IGZyb20gJy4vc3JjL2V2ZW50Y29udHJhY3QnO1xuZXhwb3J0IHtib290c3RyYXBFdmVudENvbnRyYWN0fSBmcm9tICcuL3NyYy9yZWdpc3Rlcl9ldmVudHMnO1xuZXhwb3J0IHtFdmVudEluZm9XcmFwcGVyfSBmcm9tICcuL3NyYy9ldmVudF9pbmZvJztcbiJdfQ==

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

@@ -0,0 +1,54 @@
+/**
+ * @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 * as eventLib from './event';
+import * as eventInfoLib from './event_info';
+import { EventType } from './event_type';
+/**
+ * Update `EventInfo` to be `eventType = 'click'` and sets `a11yClickKey` if it
+ * is a a11y click.
+ */
+export function updateEventInfoForA11yClick(eventInfo) {
+    if (!eventLib.isActionKeyEvent(eventInfoLib.getEvent(eventInfo))) {
+        return;
+    }
+    eventInfoLib.setA11yClickKey(eventInfo, true);
+    // A 'click' triggered by a DOM keypress should be mapped to the 'click'
+    // jsaction.
+    eventInfoLib.setEventType(eventInfo, EventType.CLICK);
+}
+/**
+ * Call `preventDefault` on an a11y click if it is space key or to prevent the
+ * browser's default action for native HTML controls.
+ */
+export function preventDefaultForA11yClick(eventInfo) {
+    if (!eventInfoLib.getA11yClickKey(eventInfo) ||
+        (!eventLib.isSpaceKeyEvent(eventInfoLib.getEvent(eventInfo)) &&
+            !eventLib.shouldCallPreventDefaultOnNativeHtmlControl(eventInfoLib.getEvent(eventInfo)))) {
+        return;
+    }
+    eventLib.preventDefault(eventInfoLib.getEvent(eventInfo));
+}
+/**
+ * Sets the `action` to `clickonly` for a click event that is not an a11y click
+ * and if there is not already a click action.
+ */
+export function populateClickOnlyAction(actionElement, eventInfo, actionMap) {
+    if (
+    // If there's already an action, don't attempt to set a CLICKONLY
+    eventInfoLib.getAction(eventInfo) ||
+        // Only attempt CLICKONLY if the type is CLICK
+        eventInfoLib.getEventType(eventInfo) !== EventType.CLICK ||
+        // a11y clicks are never CLICKONLY
+        eventInfoLib.getA11yClickKey(eventInfo) ||
+        actionMap[EventType.CLICKONLY] === undefined) {
+        return;
+    }
+    eventInfoLib.setEventType(eventInfo, EventType.CLICKONLY);
+    eventInfoLib.setAction(eventInfo, actionMap[EventType.CLICKONLY], actionElement);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,35 @@
+/**
+ * @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
+ */
+/**
+ * Defines special EventInfo and Event properties used when
+ * A11Y_SUPPORT_IN_DISPATCHER is enabled.
+ */
+export var Attribute;
+(function (Attribute) {
+    /**
+     * An event-type set when the event contract detects a KEYDOWN event but
+     * doesn't know if the key press can be treated like a click. The dispatcher
+     * will use this event-type to parse the keypress and handle it accordingly.
+     */
+    Attribute["MAYBE_CLICK_EVENT_TYPE"] = "maybe_click";
+    /**
+     * A property added to a dispatched event that had the MAYBE_CLICK_EVENTTYPE
+     * event-type but could not be used as a click. The dispatcher sets this
+     * property for non-global dispatches before it retriggers the event and it
+     * signifies that the event contract should not dispatch this event globally.
+     */
+    Attribute["SKIP_GLOBAL_DISPATCH"] = "a11ysgd";
+    /**
+     * A property added to a dispatched event that had the MAYBE_CLICK_EVENTTYPE
+     * event-type but could not be used as a click. The dispatcher sets this
+     * property before it retriggers the event and it signifies that the event
+     * contract should not look at CLICK actions for KEYDOWN events.
+     */
+    Attribute["SKIP_A11Y_CHECK"] = "a11ysc";
+})(Attribute || (Attribute = {}));
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,72 @@
+/**
+ * @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
+ */
+export var Attribute;
+(function (Attribute) {
+    /**
+     * The jsaction attribute defines a mapping of a DOM event to a
+     * generic event (aka jsaction), to which the actual event handlers
+     * that implement the behavior of the application are bound. The
+     * value is a semicolon separated list of colon separated pairs of
+     * an optional DOM event name and a jsaction name. If the optional
+     * DOM event name is omitted, 'click' is assumed. The jsaction names
+     * are dot separated pairs of a namespace and a simple jsaction
+     * name. If the namespace is absent, it is taken from the closest
+     * ancestor element with a jsnamespace attribute, if there is
+     * any. If there is no ancestor with a jsnamespace attribute, the
+     * simple name is assumed to be the jsaction name.
+     *
+     * Used by EventContract.
+     */
+    Attribute["JSACTION"] = "jsaction";
+    /**
+     * The jsnamespace attribute provides the namespace part of the
+     * jaction names occurring in the jsaction attribute where it's
+     * missing.
+     *
+     * Used by EventContract.
+     */
+    Attribute["JSNAMESPACE"] = "jsnamespace";
+    /**
+     * The oi attribute is a log impression tag for impression logging
+     * and action tracking. For an element that carries a jsaction
+     * attribute, the element is identified for the purpose of
+     * impression logging and click tracking by the dot separated path
+     * of all oi attributes in the chain of ancestors of the element.
+     *
+     * Used by ActionFlow.
+     */
+    Attribute["OI"] = "oi";
+    /**
+     * The ved attribute is an encoded ClickTrackingCGI proto to track
+     * visual elements.
+     *
+     * Used by ActionFlow.
+     */
+    Attribute["VED"] = "ved";
+    /**
+     * The vet attribute is the visual element type used to identify tracked
+     * visual elements.
+     */
+    Attribute["VET"] = "vet";
+    /**
+     * Support for iteration on reprocessing.
+     *
+     * Used by ActionFlow.
+     */
+    Attribute["JSINSTANCE"] = "jsinstance";
+    /**
+     * All click jsactions that happen on the element that carries this
+     * attribute or its descendants are automatically logged.
+     * Impressions of jsactions on these elements are tracked too, if
+     * requested by the impression() method of ActionFlow.
+     *
+     * Used by ActionFlow.
+     */
+    Attribute["JSTRACK"] = "jstrack";
+})(Attribute || (Attribute = {}));
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,196 @@
+/**
+ * @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 as AccessibilityAttribute } from './accessibility';
+import * as eventLib from './event';
+import { EventInfoWrapper } from './event_info';
+import { EventType } from './event_type';
+import { replayEvent } from './replay';
+import { Restriction } from './restriction';
+/**
+ * Receives a DOM event, determines the jsaction associated with the source
+ * element of the DOM event, and invokes the handler associated with the
+ * jsaction.
+ */
+export class BaseDispatcher {
+    /**
+     * Options are:
+     *   1. `eventReplayer`: When the event contract dispatches replay events
+     *      to the Dispatcher, the Dispatcher collects them and in the next tick
+     *      dispatches them to the `eventReplayer`.
+     * @param dispatchDelegate A function that should handle dispatching an `EventInfoWrapper` to handlers.
+     */
+    constructor(dispatchDelegate, { eventReplayer = undefined } = {}) {
+        this.dispatchDelegate = dispatchDelegate;
+        /** The queue of events. */
+        this.queuedEventInfoWrappers = [];
+        /** Whether the event replay is scheduled. */
+        this.eventReplayScheduled = false;
+        this.eventReplayer = eventReplayer;
+    }
+    /**
+     * Receives an event or the event queue from the EventContract. The event
+     * queue is copied and it attempts to replay.
+     * If event info is passed in it looks for an action handler that can handle
+     * the given event.  If there is no handler registered queues the event and
+     * checks if a loader is registered for the given namespace. If so, calls it.
+     *
+     * Alternatively, if in global dispatch mode, calls all registered global
+     * handlers for the appropriate event type.
+     *
+     * The three functionalities of this call are deliberately not split into
+     * three methods (and then declared as an abstract interface), because the
+     * interface is used by EventContract, which lives in a different jsbinary.
+     * Therefore the interface between the three is defined entirely in terms that
+     * are invariant under jscompiler processing (Function and Array, as opposed
+     * to a custom type with method names).
+     *
+     * @param eventInfo The info for the event that triggered this call or the
+     *     queue of events from EventContract.
+     * @param isGlobalDispatch If true, dispatches a global event instead of a
+     *     regular jsaction handler.
+     * @return An `EventInfo` for the `EventContract` to handle again if the
+     *    `Dispatcher` tried to resolve an a11y event as a click but failed.
+     */
+    dispatch(eventInfo, isGlobalDispatch) {
+        const eventInfoWrapper = new EventInfoWrapper(eventInfo);
+        if (eventInfoWrapper.getIsReplay()) {
+            if (isGlobalDispatch || !this.eventReplayer) {
+                return;
+            }
+            const resolved = resolveA11yEvent(eventInfoWrapper, isGlobalDispatch);
+            if (!resolved) {
+                // Send the event back through the `EventContract` by dispatching to
+                // the browser.
+                replayEvent(eventInfoWrapper.getEvent(), eventInfoWrapper.getTargetElement(), eventInfoWrapper.getEventType());
+                return;
+            }
+            this.queueEventInfoWrapper(eventInfoWrapper);
+            this.scheduleEventReplay();
+            return;
+        }
+        const resolved = resolveA11yEvent(eventInfoWrapper, isGlobalDispatch);
+        if (!resolved) {
+            // Reset action information.
+            eventInfoWrapper.setAction(undefined);
+            return eventInfoWrapper.eventInfo;
+        }
+        this.dispatchDelegate(eventInfoWrapper, isGlobalDispatch);
+    }
+    /** Queue an `EventInfoWrapper` for replay. */
+    queueEventInfoWrapper(eventInfoWrapper) {
+        this.queuedEventInfoWrappers.push(eventInfoWrapper);
+    }
+    /**
+     * Replays queued events, if any. The replaying will happen in its own
+     * stack once the current flow cedes control. This is done to mimic
+     * browser event handling.
+     */
+    scheduleEventReplay() {
+        if (this.eventReplayScheduled ||
+            !this.eventReplayer ||
+            this.queuedEventInfoWrappers.length === 0) {
+            return;
+        }
+        this.eventReplayScheduled = true;
+        Promise.resolve().then(() => {
+            this.eventReplayScheduled = false;
+            this.eventReplayer(this.queuedEventInfoWrappers);
+        });
+    }
+}
+/**
+ * If a 'MAYBE_CLICK_EVENT_TYPE' event was dispatched, updates the eventType
+ * to either click or keydown based on whether the keydown action can be
+ * treated as a click. For MAYBE_CLICK_EVENT_TYPE events that are just
+ * keydowns, we set flags on the event object so that the event contract
+ * does't try to dispatch it as a MAYBE_CLICK_EVENT_TYPE again.
+ *
+ * @param isGlobalDispatch Whether the eventInfo is meant to be dispatched to
+ *     the global handlers.
+ * @return Returns false if the a11y event could not be resolved and should
+ *    be re-dispatched.
+ */
+function resolveA11yEvent(eventInfoWrapper, isGlobalDispatch = false) {
+    if (eventInfoWrapper.getEventType() !== AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE) {
+        return true;
+    }
+    if (isA11yClickEvent(eventInfoWrapper, isGlobalDispatch)) {
+        if (shouldPreventDefault(eventInfoWrapper)) {
+            eventLib.preventDefault(eventInfoWrapper.getEvent());
+        }
+        // If the keydown event can be treated as a click, we change the eventType
+        // to 'click' so that the dispatcher can retrieve the right handler for
+        // it. Even though EventInfo['action'] corresponds to the click action,
+        // the global handler and any custom 'getHandler' implementations may rely
+        // on the eventType instead.
+        eventInfoWrapper.setEventType(EventType.CLICK);
+    }
+    else {
+        // Otherwise, if the keydown can't be treated as a click, we need to
+        // retrigger it because now we need to look for 'keydown' actions instead.
+        eventInfoWrapper.setEventType(EventType.KEYDOWN);
+        if (!isGlobalDispatch) {
+            // This prevents the event contract from setting the
+            // AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE type for Keydown
+            // events.
+            eventInfoWrapper.getEvent()[AccessibilityAttribute.SKIP_A11Y_CHECK] = true;
+            // Since globally dispatched events will get handled by the dispatcher,
+            // don't have the event contract dispatch it again.
+            eventInfoWrapper.getEvent()[AccessibilityAttribute.SKIP_GLOBAL_DISPATCH] = true;
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Returns true if the default action for this event should be prevented
+ * before the event handler is envoked.
+ */
+function shouldPreventDefault(eventInfoWrapper) {
+    const actionElement = eventInfoWrapper.getAction()?.element;
+    // For parity with no-a11y-support behavior.
+    if (!actionElement) {
+        return false;
+    }
+    // Prevent scrolling if the Space key was pressed
+    if (eventLib.isSpaceKeyEvent(eventInfoWrapper.getEvent())) {
+        return true;
+    }
+    // or prevent the browser's default action for native HTML controls.
+    if (eventLib.shouldCallPreventDefaultOnNativeHtmlControl(eventInfoWrapper.getEvent())) {
+        return true;
+    }
+    // Prevent browser from following <a> node links if a jsaction is present
+    // and we are dispatching the action now. Note that the targetElement may be
+    // a child of an anchor that has a jsaction attached. For that reason, we
+    // need to check the actionElement rather than the targetElement.
+    if (actionElement.tagName === 'A') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Returns true if the given key event can be treated as a 'click'.
+ *
+ * @param isGlobalDispatch Whether the eventInfo is meant to be dispatched to
+ *     the global handlers.
+ */
+function isA11yClickEvent(eventInfoWrapper, isGlobalDispatch) {
+    return ((isGlobalDispatch || eventInfoWrapper.getAction() !== undefined) &&
+        eventLib.isActionKeyEvent(eventInfoWrapper.getEvent()));
+}
+/**
+ * Registers deferred functionality for an EventContract and a Jsaction
+ * Dispatcher.
+ */
+export function registerDispatcher(eventContract, dispatcher) {
+    eventContract.ecrd((eventInfo, globalDispatch) => {
+        return dispatcher.dispatch(eventInfo, globalDispatch);
+    }, 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,EAAC,SAAS,IAAI,sBAAsB,EAAC,MAAM,iBAAiB,CAAC;AACpE,OAAO,KAAK,QAAQ,MAAM,SAAS,CAAC;AACpC,OAAO,EAAY,gBAAgB,EAAC,MAAM,cAAc,CAAC;AACzD,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC;AACrC,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;;;;;;;;;;;;;;;;;;;;;;;OAuBG;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,MAAM,QAAQ,GAAG,gBAAgB,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;YACtE,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,oEAAoE;gBACpE,eAAe;gBACf,WAAW,CACT,gBAAgB,CAAC,QAAQ,EAAE,EAC3B,gBAAgB,CAAC,gBAAgB,EAAE,EACnC,gBAAgB,CAAC,YAAY,EAAE,CAChC,CAAC;gBACF,OAAO;YACT,CAAC;YACD,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,CAAC,CAAC;YAC7C,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,OAAO;QACT,CAAC;QACD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;QACtE,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,4BAA4B;YAC5B,gBAAgB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YACtC,OAAO,gBAAgB,CAAC,SAAS,CAAC;QACpC,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;;;;;;;;;;;GAWG;AACH,SAAS,gBAAgB,CAAC,gBAAkC,EAAE,gBAAgB,GAAG,KAAK;IACpF,IAAI,gBAAgB,CAAC,YAAY,EAAE,KAAK,sBAAsB,CAAC,sBAAsB,EAAE,CAAC;QACtF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,gBAAgB,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,EAAE,CAAC;QACzD,IAAI,oBAAoB,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAC3C,QAAQ,CAAC,cAAc,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,CAAC;QACvD,CAAC;QACD,0EAA0E;QAC1E,uEAAuE;QACvE,uEAAuE;QACvE,0EAA0E;QAC1E,4BAA4B;QAC5B,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;SAAM,CAAC;QACN,oEAAoE;QACpE,0EAA0E;QAC1E,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QACjD,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,oDAAoD;YACpD,iEAAiE;YACjE,UAAU;YACV,gBAAgB,CAAC,QAAQ,EAAE,CAAC,sBAAsB,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;YAC3E,uEAAuE;YACvE,mDAAmD;YACnD,gBAAgB,CAAC,QAAQ,EAAE,CAAC,sBAAsB,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAAC;YAChF,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB,CAAC,gBAAkC;IAC9D,MAAM,aAAa,GAAG,gBAAgB,CAAC,SAAS,EAAE,EAAE,OAAO,CAAC;IAC5D,4CAA4C;IAC5C,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,iDAAiD;IACjD,IAAI,QAAQ,CAAC,eAAe,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC;QAC1D,OAAO,IAAI,CAAC;IACd,CAAC;IACD,oEAAoE;IACpE,IAAI,QAAQ,CAAC,2CAA2C,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC;QACtF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,yEAAyE;IACzE,4EAA4E;IAC5E,yEAAyE;IACzE,iEAAiE;IACjE,IAAI,aAAa,CAAC,OAAO,KAAK,GAAG,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,SAAS,gBAAgB,CAAC,gBAAkC,EAAE,gBAA0B;IACtF,OAAO,CACL,CAAC,gBAAgB,IAAI,gBAAgB,CAAC,SAAS,EAAE,KAAK,SAAS,CAAC;QAChE,QAAQ,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,CACvD,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAChC,aAAqC,EACrC,UAA0B;IAE1B,aAAa,CAAC,IAAI,CAAC,CAAC,SAAoB,EAAE,cAAwB,EAAE,EAAE;QACpE,OAAO,UAAU,CAAC,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;IACxD,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 {Attribute as AccessibilityAttribute} from './accessibility';\nimport * as eventLib from './event';\nimport {EventInfo, EventInfoWrapper} from './event_info';\nimport {EventType} from './event_type';\nimport {UnrenamedEventContract} from './eventcontract';\nimport {replayEvent} from './replay';\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   * @return An `EventInfo` for the `EventContract` to handle again if the\n   *    `Dispatcher` tried to resolve an a11y event as a click but failed.\n   */\n  dispatch(eventInfo: EventInfo, isGlobalDispatch?: boolean): EventInfo | void {\n    const eventInfoWrapper = new EventInfoWrapper(eventInfo);\n    if (eventInfoWrapper.getIsReplay()) {\n      if (isGlobalDispatch || !this.eventReplayer) {\n        return;\n      }\n      const resolved = resolveA11yEvent(eventInfoWrapper, isGlobalDispatch);\n      if (!resolved) {\n        // Send the event back through the `EventContract` by dispatching to\n        // the browser.\n        replayEvent(\n          eventInfoWrapper.getEvent(),\n          eventInfoWrapper.getTargetElement(),\n          eventInfoWrapper.getEventType(),\n        );\n        return;\n      }\n      this.queueEventInfoWrapper(eventInfoWrapper);\n      this.scheduleEventReplay();\n      return;\n    }\n    const resolved = resolveA11yEvent(eventInfoWrapper, isGlobalDispatch);\n    if (!resolved) {\n      // Reset action information.\n      eventInfoWrapper.setAction(undefined);\n      return eventInfoWrapper.eventInfo;\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 * If a 'MAYBE_CLICK_EVENT_TYPE' event was dispatched, updates the eventType\n * to either click or keydown based on whether the keydown action can be\n * treated as a click. For MAYBE_CLICK_EVENT_TYPE events that are just\n * keydowns, we set flags on the event object so that the event contract\n * does't try to dispatch it as a MAYBE_CLICK_EVENT_TYPE again.\n *\n * @param isGlobalDispatch Whether the eventInfo is meant to be dispatched to\n *     the global handlers.\n * @return Returns false if the a11y event could not be resolved and should\n *    be re-dispatched.\n */\nfunction resolveA11yEvent(eventInfoWrapper: EventInfoWrapper, isGlobalDispatch = false): boolean {\n  if (eventInfoWrapper.getEventType() !== AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE) {\n    return true;\n  }\n  if (isA11yClickEvent(eventInfoWrapper, isGlobalDispatch)) {\n    if (shouldPreventDefault(eventInfoWrapper)) {\n      eventLib.preventDefault(eventInfoWrapper.getEvent());\n    }\n    // If the keydown event can be treated as a click, we change the eventType\n    // to 'click' so that the dispatcher can retrieve the right handler for\n    // it. Even though EventInfo['action'] corresponds to the click action,\n    // the global handler and any custom 'getHandler' implementations may rely\n    // on the eventType instead.\n    eventInfoWrapper.setEventType(EventType.CLICK);\n  } else {\n    // Otherwise, if the keydown can't be treated as a click, we need to\n    // retrigger it because now we need to look for 'keydown' actions instead.\n    eventInfoWrapper.setEventType(EventType.KEYDOWN);\n    if (!isGlobalDispatch) {\n      // This prevents the event contract from setting the\n      // AccessibilityAttribute.MAYBE_CLICK_EVENT_TYPE type for Keydown\n      // events.\n      eventInfoWrapper.getEvent()[AccessibilityAttribute.SKIP_A11Y_CHECK] = true;\n      // Since globally dispatched events will get handled by the dispatcher,\n      // don't have the event contract dispatch it again.\n      eventInfoWrapper.getEvent()[AccessibilityAttribute.SKIP_GLOBAL_DISPATCH] = true;\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Returns true if the default action for this event should be prevented\n * before the event handler is envoked.\n */\nfunction shouldPreventDefault(eventInfoWrapper: EventInfoWrapper): boolean {\n  const actionElement = eventInfoWrapper.getAction()?.element;\n  // For parity with no-a11y-support behavior.\n  if (!actionElement) {\n    return false;\n  }\n  // Prevent scrolling if the Space key was pressed\n  if (eventLib.isSpaceKeyEvent(eventInfoWrapper.getEvent())) {\n    return true;\n  }\n  // or prevent the browser's default action for native HTML controls.\n  if (eventLib.shouldCallPreventDefaultOnNativeHtmlControl(eventInfoWrapper.getEvent())) {\n    return true;\n  }\n  // Prevent browser from following <a> node links if a jsaction is present\n  // and we are dispatching the action now. Note that the targetElement may be\n  // a child of an anchor that has a jsaction attached. For that reason, we\n  // need to check the actionElement rather than the targetElement.\n  if (actionElement.tagName === 'A') {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Returns true if the given key event can be treated as a 'click'.\n *\n * @param isGlobalDispatch Whether the eventInfo is meant to be dispatched to\n *     the global handlers.\n */\nfunction isA11yClickEvent(eventInfoWrapper: EventInfoWrapper, isGlobalDispatch?: boolean): boolean {\n  return (\n    (isGlobalDispatch || eventInfoWrapper.getAction() !== undefined) &&\n    eventLib.isActionKeyEvent(eventInfoWrapper.getEvent())\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    return dispatcher.dispatch(eventInfo, globalDispatch);\n  }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);\n}\n"]}

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

@@ -0,0 +1,95 @@
+/**
+ * @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 { Property } from './property';
+/**
+ * Map from jsaction annotation to a parsed map from event name to action name.
+ */
+const parseCache = {};
+/**
+ * Reads the jsaction parser cache from the given DOM Element.
+ *
+ * @param element .
+ * @return Map from event to qualified name of the jsaction bound to it.
+ */
+export function get(element) {
+    // @ts-ignore
+    return element[Property.JSACTION];
+}
+/**
+ * Writes the jsaction parser cache to the given DOM Element.
+ *
+ * @param element .
+ * @param actionMap Map from event to qualified name of the jsaction bound to
+ *     it.
+ */
+export function set(element, actionMap) {
+    // @ts-ignore
+    element[Property.JSACTION] = actionMap;
+}
+/**
+ * Looks up the parsed action map from the source jsaction attribute value.
+ *
+ * @param text Unparsed jsaction attribute value.
+ * @return Parsed jsaction attribute value, if already present in the cache.
+ */
+export function getParsed(text) {
+    return parseCache[text];
+}
+/**
+ * Inserts the parse result for the given source jsaction value into the cache.
+ *
+ * @param text Unparsed jsaction attribute value.
+ * @param parsed Attribute value parsed into the action map.
+ */
+export function setParsed(text, parsed) {
+    parseCache[text] = parsed;
+}
+/**
+ * Clears the jsaction parser cache from the given DOM Element.
+ *
+ * @param element .
+ */
+export function clear(element) {
+    if (Property.JSACTION in element) {
+        delete element[Property.JSACTION];
+    }
+}
+/**
+ * Reads the cached jsaction namespace from the given DOM
+ * Element. Undefined means there is no cached value; null is a cached
+ * jsnamespace attribute that's absent.
+ *
+ * @param element .
+ * @return .
+ */
+export function getNamespace(element) {
+    // @ts-ignore
+    return element[Property.JSNAMESPACE];
+}
+/**
+ * Writes the cached jsaction namespace to the given DOM Element. Null
+ * represents a jsnamespace attribute that's absent.
+ *
+ * @param element .
+ * @param jsnamespace .
+ */
+export function setNamespace(element, jsnamespace) {
+    // @ts-ignore
+    element[Property.JSNAMESPACE] = jsnamespace;
+}
+/**
+ * Clears the cached jsaction namespace from the given DOM Element.
+ *
+ * @param element .
+ */
+export function clearNamespace(element) {
+    if (Property.JSNAMESPACE in element) {
+        delete element[Property.JSNAMESPACE];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,35 @@
+/**
+ * @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
+ */
+export const Char = {
+    /**
+     * The separator between the namespace and the action name in the
+     * jsaction attribute value.
+     */
+    NAMESPACE_ACTION_SEPARATOR: '.',
+    /**
+     * The separator between the event name and action in the jsaction
+     * attribute value.
+     */
+    EVENT_ACTION_SEPARATOR: ':',
+    /**
+     * The separator between the logged oi attribute values in the &oi=
+     * URL parameter value.
+     */
+    OI_SEPARATOR: '.',
+    /**
+     * The separator between the key and the value pairs in the &cad=
+     * URL parameter value.
+     */
+    CAD_KEY_VALUE_SEPARATOR: ':',
+    /**
+     * The separator between the key-value pairs in the &cad= URL
+     * parameter value.
+     */
+    CAD_SEPARATOR: ',',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvcHJpbWl0aXZlcy9ldmVudC1kaXNwYXRjaC9zcmMvY2hhci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxNQUFNLENBQUMsTUFBTSxJQUFJLEdBQUc7SUFDbEI7OztPQUdHO0lBQ0gsMEJBQTBCLEVBQUUsR0FBRztJQUUvQjs7O09BR0c7SUFDSCxzQkFBc0IsRUFBRSxHQUFHO0lBRTNCOzs7T0FHRztJQUNILFlBQVksRUFBRSxHQUFHO0lBRWpCOzs7T0FHRztJQUNILHVCQUF1QixFQUFFLEdBQUc7SUFFNUI7OztPQUdHO0lBQ0gsYUFBYSxFQUFFLEdBQUc7Q0FDbkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgY29uc3QgQ2hhciA9IHtcbiAgLyoqXG4gICAqIFRoZSBzZXBhcmF0b3IgYmV0d2VlbiB0aGUgbmFtZXNwYWNlIGFuZCB0aGUgYWN0aW9uIG5hbWUgaW4gdGhlXG4gICAqIGpzYWN0aW9uIGF0dHJpYnV0ZSB2YWx1ZS5cbiAgICovXG4gIE5BTUVTUEFDRV9BQ1RJT05fU0VQQVJBVE9SOiAnLicsXG5cbiAgLyoqXG4gICAqIFRoZSBzZXBhcmF0b3IgYmV0d2VlbiB0aGUgZXZlbnQgbmFtZSBhbmQgYWN0aW9uIGluIHRoZSBqc2FjdGlvblxuICAgKiBhdHRyaWJ1dGUgdmFsdWUuXG4gICAqL1xuICBFVkVOVF9BQ1RJT05fU0VQQVJBVE9SOiAnOicsXG5cbiAgLyoqXG4gICAqIFRoZSBzZXBhcmF0b3IgYmV0d2VlbiB0aGUgbG9nZ2VkIG9pIGF0dHJpYnV0ZSB2YWx1ZXMgaW4gdGhlICZvaT1cbiAgICogVVJMIHBhcmFtZXRlciB2YWx1ZS5cbiAgICovXG4gIE9JX1NFUEFSQVRPUjogJy4nLFxuXG4gIC8qKlxuICAgKiBUaGUgc2VwYXJhdG9yIGJldHdlZW4gdGhlIGtleSBhbmQgdGhlIHZhbHVlIHBhaXJzIGluIHRoZSAmY2FkPVxuICAgKiBVUkwgcGFyYW1ldGVyIHZhbHVlLlxuICAgKi9cbiAgQ0FEX0tFWV9WQUxVRV9TRVBBUkFUT1I6ICc6JyxcblxuICAvKipcbiAgICogVGhlIHNlcGFyYXRvciBiZXR3ZWVuIHRoZSBrZXktdmFsdWUgcGFpcnMgaW4gdGhlICZjYWQ9IFVSTFxuICAgKiBwYXJhbWV0ZXIgdmFsdWUuXG4gICAqL1xuICBDQURfU0VQQVJBVE9SOiAnLCcsXG59O1xuIl19