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

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

@@ -0,0 +1,63 @@
+/**
+ * @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';
+/**
+ * Whether the user agent is running on iOS.
+ */
+const isIos = typeof navigator !== 'undefined' && /iPhone|iPad|iPod/.test(navigator.userAgent);
+/**
+ * A class representing a container node and all the event handlers
+ * installed on it. Used so that handlers can be cleaned up if the
+ * container is removed from the contract.
+ */
+export class EventContractContainer {
+    /**
+     * @param element The container Element.
+     */
+    constructor(element) {
+        this.element = element;
+        /**
+         * Array of event handlers and their corresponding event types that are
+         * installed on this container.
+         *
+         */
+        this.handlerInfos = [];
+    }
+    /**
+     * Installs the provided installer on the element owned by this container,
+     * and maintains a reference to resulting handler in order to remove it
+     * later if desired.
+     */
+    addEventListener(eventType, getHandler) {
+        // In iOS, event bubbling doesn't happen automatically in any DOM element,
+        // unless it has an onclick attribute or DOM event handler attached to it.
+        // This breaks JsAction in some cases. See "Making Elements Clickable"
+        // section at http://goo.gl/2VoGnB.
+        //
+        // A workaround for this issue is to change the CSS cursor style to 'pointer'
+        // for the container element, which magically turns on event bubbling. This
+        // solution is described in the comments section at http://goo.gl/6pEO1z.
+        //
+        // We use a navigator.userAgent check here as this problem is present both
+        // on Mobile Safari and thin WebKit wrappers, such as Chrome for iOS.
+        if (isIos) {
+            this.element.style.cursor = 'pointer';
+        }
+        this.handlerInfos.push(eventLib.addEventListener(this.element, eventType, getHandler(this.element)));
+    }
+    /**
+     * Removes all the handlers installed on this container.
+     */
+    cleanUp() {
+        for (let i = 0; i < this.handlerInfos.length; i++) {
+            eventLib.removeEventListener(this.element, this.handlerInfos[i]);
+        }
+        this.handlerInfos = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,48 @@
+/**
+ * @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
+ */
+/**
+ * @define Support for jsnamespace attribute.  This flag can be overridden in a
+ * build rule to trim down the EventContract's binary size.
+ */
+export const JSNAMESPACE_SUPPORT = true;
+/**
+ * @define Handles a11y click casting in the dispatcher rather than
+ * the event contract. When enabled, it will enable
+ * EventContract.A11Y_CLICK_SUPPORT as well as both are required for this
+ * functionality.
+ */
+export const A11Y_SUPPORT_IN_DISPATCHER = false;
+/**
+ * @define Support for accessible click actions.  This flag can be overridden in
+ * a build rule.
+ */
+const A11Y_CLICK_SUPPORT_FLAG_ENABLED = false;
+/**
+ * Enables a11y click casting when either A11Y_CLICK_SUPPORT_FLAG_ENABLED or
+ * A11Y_SUPPORT_IN_DISPATCHER.
+ */
+export const A11Y_CLICK_SUPPORT = A11Y_CLICK_SUPPORT_FLAG_ENABLED || A11Y_SUPPORT_IN_DISPATCHER;
+/**
+ * @define Support for the non-bubbling mouseenter and mouseleave events.  This
+ * flag can be overridden in a build rule.
+ */
+export const MOUSE_SPECIAL_SUPPORT = false;
+/**
+ * @define Call stopPropagation on handled events. When integrating with
+ * non-jsaction event handler based code, you will likely want to turn this flag
+ * off. While most event handlers will continue to work, jsaction binds focus
+ * and blur events in the capture phase and thus with stopPropagation, none of
+ * your non-jsaction-handlers will ever see it.
+ */
+export const STOP_PROPAGATION = true;
+/**
+ * @define Support for custom events, which are type EventType.CUSTOM. These are
+ * native DOM events with an additional type field and an optional payload.
+ */
+export const CUSTOM_EVENT_SUPPORT = false;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRfY29udHJhY3RfZGVmaW5lcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvcHJpbWl0aXZlcy9ldmVudC1kaXNwYXRjaC9zcmMvZXZlbnRfY29udHJhY3RfZGVmaW5lcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSDs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLENBQUM7QUFFeEM7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBRyxLQUFLLENBQUM7QUFFaEQ7OztHQUdHO0FBQ0gsTUFBTSwrQkFBK0IsR0FBRyxLQUFLLENBQUM7QUFFOUM7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsK0JBQStCLElBQUksMEJBQTBCLENBQUM7QUFFaEc7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsS0FBSyxDQUFDO0FBRTNDOzs7Ozs7R0FNRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLElBQUksQ0FBQztBQUVyQzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxLQUFLLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBAZGVmaW5lIFN1cHBvcnQgZm9yIGpzbmFtZXNwYWNlIGF0dHJpYnV0ZS4gIFRoaXMgZmxhZyBjYW4gYmUgb3ZlcnJpZGRlbiBpbiBhXG4gKiBidWlsZCBydWxlIHRvIHRyaW0gZG93biB0aGUgRXZlbnRDb250cmFjdCdzIGJpbmFyeSBzaXplLlxuICovXG5leHBvcnQgY29uc3QgSlNOQU1FU1BBQ0VfU1VQUE9SVCA9IHRydWU7XG5cbi8qKlxuICogQGRlZmluZSBIYW5kbGVzIGExMXkgY2xpY2sgY2FzdGluZyBpbiB0aGUgZGlzcGF0Y2hlciByYXRoZXIgdGhhblxuICogdGhlIGV2ZW50IGNvbnRyYWN0LiBXaGVuIGVuYWJsZWQsIGl0IHdpbGwgZW5hYmxlXG4gKiBFdmVudENvbnRyYWN0LkExMVlfQ0xJQ0tfU1VQUE9SVCBhcyB3ZWxsIGFzIGJvdGggYXJlIHJlcXVpcmVkIGZvciB0aGlzXG4gKiBmdW5jdGlvbmFsaXR5LlxuICovXG5leHBvcnQgY29uc3QgQTExWV9TVVBQT1JUX0lOX0RJU1BBVENIRVIgPSBmYWxzZTtcblxuLyoqXG4gKiBAZGVmaW5lIFN1cHBvcnQgZm9yIGFjY2Vzc2libGUgY2xpY2sgYWN0aW9ucy4gIFRoaXMgZmxhZyBjYW4gYmUgb3ZlcnJpZGRlbiBpblxuICogYSBidWlsZCBydWxlLlxuICovXG5jb25zdCBBMTFZX0NMSUNLX1NVUFBPUlRfRkxBR19FTkFCTEVEID0gZmFsc2U7XG5cbi8qKlxuICogRW5hYmxlcyBhMTF5IGNsaWNrIGNhc3Rpbmcgd2hlbiBlaXRoZXIgQTExWV9DTElDS19TVVBQT1JUX0ZMQUdfRU5BQkxFRCBvclxuICogQTExWV9TVVBQT1JUX0lOX0RJU1BBVENIRVIuXG4gKi9cbmV4cG9ydCBjb25zdCBBMTFZX0NMSUNLX1NVUFBPUlQgPSBBMTFZX0NMSUNLX1NVUFBPUlRfRkxBR19FTkFCTEVEIHx8IEExMVlfU1VQUE9SVF9JTl9ESVNQQVRDSEVSO1xuXG4vKipcbiAqIEBkZWZpbmUgU3VwcG9ydCBmb3IgdGhlIG5vbi1idWJibGluZyBtb3VzZWVudGVyIGFuZCBtb3VzZWxlYXZlIGV2ZW50cy4gIFRoaXNcbiAqIGZsYWcgY2FuIGJlIG92ZXJyaWRkZW4gaW4gYSBidWlsZCBydWxlLlxuICovXG5leHBvcnQgY29uc3QgTU9VU0VfU1BFQ0lBTF9TVVBQT1JUID0gZmFsc2U7XG5cbi8qKlxuICogQGRlZmluZSBDYWxsIHN0b3BQcm9wYWdhdGlvbiBvbiBoYW5kbGVkIGV2ZW50cy4gV2hlbiBpbnRlZ3JhdGluZyB3aXRoXG4gKiBub24tanNhY3Rpb24gZXZlbnQgaGFuZGxlciBiYXNlZCBjb2RlLCB5b3Ugd2lsbCBsaWtlbHkgd2FudCB0byB0dXJuIHRoaXMgZmxhZ1xuICogb2ZmLiBXaGlsZSBtb3N0IGV2ZW50IGhhbmRsZXJzIHdpbGwgY29udGludWUgdG8gd29yaywganNhY3Rpb24gYmluZHMgZm9jdXNcbiAqIGFuZCBibHVyIGV2ZW50cyBpbiB0aGUgY2FwdHVyZSBwaGFzZSBhbmQgdGh1cyB3aXRoIHN0b3BQcm9wYWdhdGlvbiwgbm9uZSBvZlxuICogeW91ciBub24tanNhY3Rpb24taGFuZGxlcnMgd2lsbCBldmVyIHNlZSBpdC5cbiAqL1xuZXhwb3J0IGNvbnN0IFNUT1BfUFJPUEFHQVRJT04gPSB0cnVlO1xuXG4vKipcbiAqIEBkZWZpbmUgU3VwcG9ydCBmb3IgY3VzdG9tIGV2ZW50cywgd2hpY2ggYXJlIHR5cGUgRXZlbnRUeXBlLkNVU1RPTS4gVGhlc2UgYXJlXG4gKiBuYXRpdmUgRE9NIGV2ZW50cyB3aXRoIGFuIGFkZGl0aW9uYWwgdHlwZSBmaWVsZCBhbmQgYW4gb3B0aW9uYWwgcGF5bG9hZC5cbiAqL1xuZXhwb3J0IGNvbnN0IENVU1RPTV9FVkVOVF9TVVBQT1JUID0gZmFsc2U7XG4iXX0=

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

@@ -0,0 +1,192 @@
+/**
+ * @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 { EventContractContainer } from './event_contract_container';
+/**
+ * An `EventContractContainerManager` that supports multiple containers.
+ */
+export class EventContractMultiContainer {
+    /**
+     * @param stopPropagation Controls whether events can bubble between
+     *    containers or not.
+     */
+    constructor(stopPropagation = false) {
+        this.stopPropagation = stopPropagation;
+        /** The list of containers. */
+        this.containers = [];
+        /** The list of nested containers. */
+        this.nestedContainers = [];
+        /** The list of event handler installers. */
+        this.eventHandlerInstallers = [];
+    }
+    /**
+     * Installs the provided installer on the element owned by this container,
+     * and maintains a reference to resulting handler in order to remove it
+     * later if desired.
+     */
+    addEventListener(eventType, getHandler) {
+        const eventHandlerInstaller = (container) => {
+            container.addEventListener(eventType, getHandler);
+        };
+        for (let i = 0; i < this.containers.length; i++) {
+            eventHandlerInstaller(this.containers[i]);
+        }
+        this.eventHandlerInstallers.push(eventHandlerInstaller);
+    }
+    /**
+     * Removes all the handlers installed on all containers.
+     */
+    cleanUp() {
+        const allContainers = [...this.containers, ...this.nestedContainers];
+        for (let i = 0; i < allContainers.length; i++) {
+            allContainers[i].cleanUp();
+        }
+        this.containers = [];
+        this.nestedContainers = [];
+        this.eventHandlerInstallers = [];
+    }
+    /**
+     * Adds a container to the `MultiEventContractContainer`.
+     * Signs the event contract for a new container. All registered events
+     * are enabled for this container too. Containers have to be kept disjoint,
+     * so if the newly added container is a parent/child of existing containers,
+     * they will be merged. If the container is already tracked by this
+     * `EventContract`, then the previously registered `EventContractContainer`
+     * will be returned.
+     */
+    addContainer(element) {
+        // If the container is already registered, return.
+        for (let i = 0; i < this.containers.length; i++) {
+            if (element === this.containers[i].element) {
+                return this.containers[i];
+            }
+        }
+        const container = new EventContractContainer(element);
+        if (this.stopPropagation) {
+            // Events are not propagated, so containers can be considered independent.
+            this.setUpContainer(container);
+            this.containers.push(container);
+        }
+        else {
+            if (this.isNestedContainer(container)) {
+                // This container has an ancestor that is already a contract container.
+                // Don't install event listeners on it in order to prevent an event from
+                // being handled multiple times.
+                this.nestedContainers.push(container);
+                return container;
+            }
+            this.setUpContainer(container);
+            this.containers.push(container);
+            this.updateNestedContainers();
+        }
+        return container;
+    }
+    /**
+     * Removes an already-added container from the contract.
+     */
+    removeContainer(container) {
+        container.cleanUp();
+        let removed = false;
+        for (let i = 0; i < this.containers.length; ++i) {
+            if (this.containers[i] === container) {
+                this.containers.splice(i, 1);
+                removed = true;
+                break;
+            }
+        }
+        if (!removed) {
+            for (let i = 0; i < this.nestedContainers.length; ++i) {
+                if (this.nestedContainers[i] === container) {
+                    this.nestedContainers.splice(i, 1);
+                    break;
+                }
+            }
+        }
+        if (this.stopPropagation) {
+            return;
+        }
+        this.updateNestedContainers();
+    }
+    /**
+     * Tested whether any current container is a parent of the new container.
+     */
+    isNestedContainer(container) {
+        for (let i = 0; i < this.containers.length; i++) {
+            if (containsNode(this.containers[i].element, container.element)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Installs all existing event handlers on a new container. */
+    setUpContainer(container) {
+        for (let i = 0; i < this.eventHandlerInstallers.length; i++) {
+            this.eventHandlerInstallers[i](container);
+        }
+    }
+    /**
+     * Updates the list of nested containers after an add/remove operation. Only
+     * containers that are not children of other containers are placed in the
+     * containers list (and have event listeners on them). This is done in order
+     * to prevent events from being handled multiple times when `stopPropagation`
+     * is false.
+     */
+    updateNestedContainers() {
+        const allContainers = [...this.nestedContainers, ...this.containers];
+        const newNestedContainers = [];
+        const newContainers = [];
+        for (let i = 0; i < this.containers.length; ++i) {
+            const container = this.containers[i];
+            if (isNested(container, allContainers)) {
+                newNestedContainers.push(container);
+                // Remove the event listeners from the nested container.
+                container.cleanUp();
+            }
+            else {
+                newContainers.push(container);
+            }
+        }
+        for (let i = 0; i < this.nestedContainers.length; ++i) {
+            const container = this.nestedContainers[i];
+            if (isNested(container, allContainers)) {
+                newNestedContainers.push(container);
+            }
+            else {
+                newContainers.push(container);
+                // The container is no longer nested, add event listeners on it.
+                this.setUpContainer(container);
+            }
+        }
+        this.containers = newContainers;
+        this.nestedContainers = newNestedContainers;
+    }
+}
+/**
+ * Checks whether the container is a child of any of the containers.
+ */
+function isNested(container, containers) {
+    for (let i = 0; i < containers.length; ++i) {
+        if (containsNode(containers[i].element, container.element)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Checks whether parent contains child.
+ * IE11 only supports the native `Node.contains` for HTMLElement.
+ */
+function containsNode(parent, child) {
+    if (parent === child) {
+        return false;
+    }
+    while (parent !== child && child.parentNode) {
+        child = child.parentNode;
+    }
+    return parent === child;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event_contract_multi_container.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/event_contract_multi_container.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 {EventContractContainer, EventContractContainerManager} from './event_contract_container';\n\n/**\n * An `EventContractContainerManager` that supports multiple containers.\n */\nexport class EventContractMultiContainer implements EventContractContainerManager {\n  /** The list of containers. */\n  private containers: EventContractContainer[] = [];\n  /** The list of nested containers. */\n  private nestedContainers: EventContractContainer[] = [];\n  /** The list of event handler installers. */\n  private eventHandlerInstallers: Array<(container: EventContractContainer) => void> = [];\n\n  /**\n   * @param stopPropagation Controls whether events can bubble between\n   *    containers or not.\n   */\n  constructor(private readonly stopPropagation = false) {}\n\n  /**\n   * Installs the provided installer on the element owned by this container,\n   * and maintains a reference to resulting handler in order to remove it\n   * later if desired.\n   */\n  addEventListener(eventType: string, getHandler: (element: Element) => (event: Event) => void) {\n    const eventHandlerInstaller = (container: EventContractContainer) => {\n      container.addEventListener(eventType, getHandler);\n    };\n    for (let i = 0; i < this.containers.length; i++) {\n      eventHandlerInstaller(this.containers[i]);\n    }\n    this.eventHandlerInstallers.push(eventHandlerInstaller);\n  }\n\n  /**\n   * Removes all the handlers installed on all containers.\n   */\n  cleanUp() {\n    const allContainers = [...this.containers, ...this.nestedContainers];\n    for (let i = 0; i < allContainers.length; i++) {\n      allContainers[i].cleanUp();\n    }\n    this.containers = [];\n    this.nestedContainers = [];\n    this.eventHandlerInstallers = [];\n  }\n\n  /**\n   * Adds a container to the `MultiEventContractContainer`.\n   * Signs the event contract for a new container. All registered events\n   * are enabled for this container too. Containers have to be kept disjoint,\n   * so if the newly added container is a parent/child of existing containers,\n   * they will be merged. If the container is already tracked by this\n   * `EventContract`, then the previously registered `EventContractContainer`\n   * will be returned.\n   */\n  addContainer(element: Element): EventContractContainer {\n    // If the container is already registered, return.\n    for (let i = 0; i < this.containers.length; i++) {\n      if (element === this.containers[i].element) {\n        return this.containers[i];\n      }\n    }\n    const container = new EventContractContainer(element);\n    if (this.stopPropagation) {\n      // Events are not propagated, so containers can be considered independent.\n      this.setUpContainer(container);\n      this.containers.push(container);\n    } else {\n      if (this.isNestedContainer(container)) {\n        // This container has an ancestor that is already a contract container.\n        // Don't install event listeners on it in order to prevent an event from\n        // being handled multiple times.\n        this.nestedContainers.push(container);\n        return container;\n      }\n      this.setUpContainer(container);\n      this.containers.push(container);\n      this.updateNestedContainers();\n    }\n    return container;\n  }\n\n  /**\n   * Removes an already-added container from the contract.\n   */\n  removeContainer(container: EventContractContainer) {\n    container.cleanUp();\n    let removed = false;\n    for (let i = 0; i < this.containers.length; ++i) {\n      if (this.containers[i] === container) {\n        this.containers.splice(i, 1);\n        removed = true;\n        break;\n      }\n    }\n\n    if (!removed) {\n      for (let i = 0; i < this.nestedContainers.length; ++i) {\n        if (this.nestedContainers[i] === container) {\n          this.nestedContainers.splice(i, 1);\n          break;\n        }\n      }\n    }\n\n    if (this.stopPropagation) {\n      return;\n    }\n    this.updateNestedContainers();\n  }\n\n  /**\n   * Tested whether any current container is a parent of the new container.\n   */\n  private isNestedContainer(container: EventContractContainer): boolean {\n    for (let i = 0; i < this.containers.length; i++) {\n      if (containsNode(this.containers[i].element, container.element)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /** Installs all existing event handlers on a new container. */\n  private setUpContainer(container: EventContractContainer) {\n    for (let i = 0; i < this.eventHandlerInstallers.length; i++) {\n      this.eventHandlerInstallers[i](container);\n    }\n  }\n\n  /**\n   * Updates the list of nested containers after an add/remove operation. Only\n   * containers that are not children of other containers are placed in the\n   * containers list (and have event listeners on them). This is done in order\n   * to prevent events from being handled multiple times when `stopPropagation`\n   * is false.\n   */\n  private updateNestedContainers() {\n    const allContainers = [...this.nestedContainers, ...this.containers];\n    const newNestedContainers = [];\n    const newContainers = [];\n\n    for (let i = 0; i < this.containers.length; ++i) {\n      const container = this.containers[i];\n      if (isNested(container, allContainers)) {\n        newNestedContainers.push(container);\n        // Remove the event listeners from the nested container.\n        container.cleanUp();\n      } else {\n        newContainers.push(container);\n      }\n    }\n\n    for (let i = 0; i < this.nestedContainers.length; ++i) {\n      const container = this.nestedContainers[i];\n      if (isNested(container, allContainers)) {\n        newNestedContainers.push(container);\n      } else {\n        newContainers.push(container);\n        // The container is no longer nested, add event listeners on it.\n        this.setUpContainer(container);\n      }\n    }\n\n    this.containers = newContainers;\n    this.nestedContainers = newNestedContainers;\n  }\n}\n\n/**\n * Checks whether the container is a child of any of the containers.\n */\nfunction isNested(\n  container: EventContractContainer,\n  containers: EventContractContainer[],\n): boolean {\n  for (let i = 0; i < containers.length; ++i) {\n    if (containsNode(containers[i].element, container.element)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Checks whether parent contains child.\n * IE11 only supports the native `Node.contains` for HTMLElement.\n */\nfunction containsNode(parent: Node, child: Node): boolean {\n  if (parent === child) {\n    return false;\n  }\n  while (parent !== child && child.parentNode) {\n    child = child.parentNode;\n  }\n  return parent === child;\n}\n"]}

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

@@ -0,0 +1,9 @@
+/**
+ * @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 {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRfaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvcHJpbWl0aXZlcy9ldmVudC1kaXNwYXRjaC9zcmMvZXZlbnRfaGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKlxuICogSW5mb3JtYXRpb24gYWJvdXQgYSByZWdpc3RlcmVkIGV2ZW50IGhhbmRsZXIsIHdoaWNoIGNhbiBiZSB1c2VkIHRvXG4gKiBkZXJlZ2lzdGVyIHRoZSBldmVudCBoYW5kbGVyLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEV2ZW50SGFuZGxlckluZm8ge1xuICBldmVudFR5cGU6IHN0cmluZztcblxuICBoYW5kbGVyOiAoZXZlbnQ6IEV2ZW50KSA9PiB2b2lkO1xuXG4gIGNhcHR1cmU6IGJvb2xlYW47XG59XG4iXX0=

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

@@ -0,0 +1,199 @@
+/**
+ * @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
+ */
+/** Added for readability when accessing stable property names. */
+export function getEventType(eventInfo) {
+    return eventInfo.eventType;
+}
+/** Added for readability when accessing stable property names. */
+export function setEventType(eventInfo, eventType) {
+    eventInfo.eventType = eventType;
+}
+/** Added for readability when accessing stable property names. */
+export function getEvent(eventInfo) {
+    return eventInfo.event;
+}
+/** Added for readability when accessing stable property names. */
+export function setEvent(eventInfo, event) {
+    eventInfo.event = event;
+}
+/** Added for readability when accessing stable property names. */
+export function getTargetElement(eventInfo) {
+    return eventInfo.targetElement;
+}
+/** Added for readability when accessing stable property names. */
+export function setTargetElement(eventInfo, targetElement) {
+    eventInfo.targetElement = targetElement;
+}
+/** Added for readability when accessing stable property names. */
+export function getContainer(eventInfo) {
+    return eventInfo.eic;
+}
+/** Added for readability when accessing stable property names. */
+export function setContainer(eventInfo, container) {
+    eventInfo.eic = container;
+}
+/** Added for readability when accessing stable property names. */
+export function getTimestamp(eventInfo) {
+    return eventInfo.timeStamp;
+}
+/** Added for readability when accessing stable property names. */
+export function setTimestamp(eventInfo, timestamp) {
+    eventInfo.timeStamp = timestamp;
+}
+/** Added for readability when accessing stable property names. */
+export function getAction(eventInfo) {
+    return eventInfo.eia;
+}
+/** Added for readability when accessing stable property names. */
+export function setAction(eventInfo, actionName, actionElement) {
+    eventInfo.eia = [actionName, actionElement];
+}
+/** Added for readability when accessing stable property names. */
+export function unsetAction(eventInfo) {
+    eventInfo.eia = undefined;
+}
+/** Added for readability when accessing stable property names. */
+export function getActionName(actionInfo) {
+    return actionInfo[0];
+}
+/** Added for readability when accessing stable property names. */
+export function getActionElement(actionInfo) {
+    return actionInfo[1];
+}
+/** Added for readability when accessing stable property names. */
+export function getIsReplay(eventInfo) {
+    return eventInfo.eirp;
+}
+/** Added for readability when accessing stable property names. */
+export function setIsReplay(eventInfo, replay) {
+    eventInfo.eirp = replay;
+}
+/** Added for readability when accessing stable property names. */
+export function getA11yClickKey(eventInfo) {
+    return eventInfo.eiack;
+}
+/** Added for readability when accessing stable property names. */
+export function setA11yClickKey(eventInfo, a11yClickKey) {
+    eventInfo.eiack = a11yClickKey;
+}
+/** Clones an `EventInfo` */
+export function cloneEventInfo(eventInfo) {
+    return {
+        eventType: eventInfo.eventType,
+        event: eventInfo.event,
+        targetElement: eventInfo.targetElement,
+        eic: eventInfo.eic,
+        eia: eventInfo.eia,
+        timeStamp: eventInfo.timeStamp,
+        eirp: eventInfo.eirp,
+        eiack: eventInfo.eiack,
+    };
+}
+/**
+ * Utility function for creating an `EventInfo`.
+ *
+ * This can be used from code-size sensitive compilation units, as taking
+ * parameters vs. an `Object` literal reduces code size.
+ */
+export function createEventInfoFromParameters(eventType, event, targetElement, container, timestamp, action, isReplay, a11yClickKey) {
+    return {
+        eventType,
+        event,
+        targetElement,
+        eic: container,
+        timeStamp: timestamp,
+        eia: action,
+        eirp: isReplay,
+        eiack: a11yClickKey,
+    };
+}
+/**
+ * Utility function for creating an `EventInfo`.
+ *
+ * This should be used in compilation units that are less sensitive to code
+ * size.
+ */
+export function createEventInfo({ eventType, event, targetElement, container, timestamp, action, isReplay, a11yClickKey, }) {
+    return {
+        eventType,
+        event,
+        targetElement,
+        eic: container,
+        timeStamp: timestamp,
+        eia: action ? [action.name, action.element] : undefined,
+        eirp: isReplay,
+        eiack: a11yClickKey,
+    };
+}
+/**
+ * Utility class around an `EventInfo`.
+ *
+ * This should be used in compilation units that are less sensitive to code
+ * size.
+ */
+export class EventInfoWrapper {
+    constructor(eventInfo) {
+        this.eventInfo = eventInfo;
+    }
+    getEventType() {
+        return getEventType(this.eventInfo);
+    }
+    setEventType(eventType) {
+        setEventType(this.eventInfo, eventType);
+    }
+    getEvent() {
+        return getEvent(this.eventInfo);
+    }
+    setEvent(event) {
+        setEvent(this.eventInfo, event);
+    }
+    getTargetElement() {
+        return getTargetElement(this.eventInfo);
+    }
+    setTargetElement(targetElement) {
+        setTargetElement(this.eventInfo, targetElement);
+    }
+    getContainer() {
+        return getContainer(this.eventInfo);
+    }
+    setContainer(container) {
+        setContainer(this.eventInfo, container);
+    }
+    getTimestamp() {
+        return getTimestamp(this.eventInfo);
+    }
+    setTimestamp(timestamp) {
+        setTimestamp(this.eventInfo, timestamp);
+    }
+    getAction() {
+        const action = getAction(this.eventInfo);
+        if (!action)
+            return undefined;
+        return {
+            name: action[0],
+            element: action[1],
+        };
+    }
+    setAction(action) {
+        if (!action) {
+            unsetAction(this.eventInfo);
+            return;
+        }
+        setAction(this.eventInfo, action.name, action.element);
+    }
+    getIsReplay() {
+        return getIsReplay(this.eventInfo);
+    }
+    setIsReplay(replay) {
+        setIsReplay(this.eventInfo, replay);
+    }
+    clone() {
+        return new EventInfoWrapper(cloneEventInfo(this.eventInfo));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event_info.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/event_info.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 * Records information about the action that should handle a given `Event`.\n */\nexport interface ActionInfo {\n  name: string;\n  element: Element;\n}\n\ntype ActionInfoInternal = [name: string, element: Element];\n\n/**\n * Records information for later handling of events. This type is\n * shared, and instances of it are passed, between the eventcontract\n * and the dispatcher jsbinary. Therefore, the fields of this type are\n * referenced by string literals rather than property literals\n * throughout the code.\n *\n * 'targetElement' is the element the action occurred on, 'actionElement'\n * is the element that has the jsaction handler.\n *\n * A null 'actionElement' identifies an EventInfo instance that didn't match a\n * jsaction attribute.  This allows us to execute global event handlers with the\n * appropriate event type (including a11y clicks and custom events).\n * The declare portion of this interface creates a set of externs that make sure\n * renaming doesn't happen for EventInfo. This is important since EventInfo\n * is shared across multiple binaries.\n */\nexport declare interface EventInfo {\n  eventType: string;\n  event: Event;\n  targetElement: Element;\n  /** The element that is the container for this Event. */\n  eic: Element;\n  timeStamp: number;\n  /**\n   * The action parsed from the JSAction element.\n   */\n  eia?: ActionInfoInternal;\n  /**\n   * Whether this `Event` is a replay event, meaning no dispatcher was\n   * installed when this `Event` was originally dispatched.\n   */\n  eirp?: boolean;\n  /**\n   * Whether this `Event` represents a `keydown` event that should be processed\n   * as a `click`. Only used when a11y click events is on.\n   */\n  eiack?: boolean;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getEventType(eventInfo: EventInfo) {\n  return eventInfo.eventType;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function setEventType(eventInfo: EventInfo, eventType: string) {\n  eventInfo.eventType = eventType;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getEvent(eventInfo: EventInfo) {\n  return eventInfo.event;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function setEvent(eventInfo: EventInfo, event: Event) {\n  eventInfo.event = event;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getTargetElement(eventInfo: EventInfo) {\n  return eventInfo.targetElement;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function setTargetElement(eventInfo: EventInfo, targetElement: Element) {\n  eventInfo.targetElement = targetElement;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getContainer(eventInfo: EventInfo) {\n  return eventInfo.eic;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function setContainer(eventInfo: EventInfo, container: Element) {\n  eventInfo.eic = container;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getTimestamp(eventInfo: EventInfo) {\n  return eventInfo.timeStamp;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function setTimestamp(eventInfo: EventInfo, timestamp: number) {\n  eventInfo.timeStamp = timestamp;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getAction(eventInfo: EventInfo) {\n  return eventInfo.eia;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function setAction(eventInfo: EventInfo, actionName: string, actionElement: Element) {\n  eventInfo.eia = [actionName, actionElement];\n}\n\n/** Added for readability when accessing stable property names. */\nexport function unsetAction(eventInfo: EventInfo) {\n  eventInfo.eia = undefined;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getActionName(actionInfo: ActionInfoInternal) {\n  return actionInfo[0];\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getActionElement(actionInfo: ActionInfoInternal) {\n  return actionInfo[1];\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getIsReplay(eventInfo: EventInfo) {\n  return eventInfo.eirp;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function setIsReplay(eventInfo: EventInfo, replay: boolean) {\n  eventInfo.eirp = replay;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function getA11yClickKey(eventInfo: EventInfo) {\n  return eventInfo.eiack;\n}\n\n/** Added for readability when accessing stable property names. */\nexport function setA11yClickKey(eventInfo: EventInfo, a11yClickKey: boolean) {\n  eventInfo.eiack = a11yClickKey;\n}\n\n/** Clones an `EventInfo` */\nexport function cloneEventInfo(eventInfo: EventInfo): EventInfo {\n  return {\n    eventType: eventInfo.eventType,\n    event: eventInfo.event,\n    targetElement: eventInfo.targetElement,\n    eic: eventInfo.eic,\n    eia: eventInfo.eia,\n    timeStamp: eventInfo.timeStamp,\n    eirp: eventInfo.eirp,\n    eiack: eventInfo.eiack,\n  };\n}\n\n/**\n * Utility function for creating an `EventInfo`.\n *\n * This can be used from code-size sensitive compilation units, as taking\n * parameters vs. an `Object` literal reduces code size.\n */\nexport function createEventInfoFromParameters(\n  eventType: string,\n  event: Event,\n  targetElement: Element,\n  container: Element,\n  timestamp: number,\n  action?: ActionInfoInternal,\n  isReplay?: boolean,\n  a11yClickKey?: boolean,\n): EventInfo {\n  return {\n    eventType,\n    event,\n    targetElement,\n    eic: container,\n    timeStamp: timestamp,\n    eia: action,\n    eirp: isReplay,\n    eiack: a11yClickKey,\n  };\n}\n\n/**\n * Utility function for creating an `EventInfo`.\n *\n * This should be used in compilation units that are less sensitive to code\n * size.\n */\nexport function createEventInfo({\n  eventType,\n  event,\n  targetElement,\n  container,\n  timestamp,\n  action,\n  isReplay,\n  a11yClickKey,\n}: {\n  eventType: string;\n  event: Event;\n  targetElement: Element;\n  container: Element;\n  timestamp: number;\n  action?: ActionInfo;\n  isReplay?: boolean;\n  a11yClickKey?: boolean;\n}): EventInfo {\n  return {\n    eventType,\n    event,\n    targetElement,\n    eic: container,\n    timeStamp: timestamp,\n    eia: action ? [action.name, action.element] : undefined,\n    eirp: isReplay,\n    eiack: a11yClickKey,\n  };\n}\n\n/**\n * Utility class around an `EventInfo`.\n *\n * This should be used in compilation units that are less sensitive to code\n * size.\n */\nexport class EventInfoWrapper {\n  constructor(readonly eventInfo: EventInfo) {}\n\n  getEventType() {\n    return getEventType(this.eventInfo);\n  }\n\n  setEventType(eventType: string) {\n    setEventType(this.eventInfo, eventType);\n  }\n\n  getEvent() {\n    return getEvent(this.eventInfo);\n  }\n\n  setEvent(event: Event) {\n    setEvent(this.eventInfo, event);\n  }\n\n  getTargetElement() {\n    return getTargetElement(this.eventInfo);\n  }\n\n  setTargetElement(targetElement: Element) {\n    setTargetElement(this.eventInfo, targetElement);\n  }\n\n  getContainer() {\n    return getContainer(this.eventInfo);\n  }\n\n  setContainer(container: Element) {\n    setContainer(this.eventInfo, container);\n  }\n  getTimestamp() {\n    return getTimestamp(this.eventInfo);\n  }\n\n  setTimestamp(timestamp: number) {\n    setTimestamp(this.eventInfo, timestamp);\n  }\n\n  getAction() {\n    const action = getAction(this.eventInfo);\n    if (!action) return undefined;\n    return {\n      name: action[0],\n      element: action[1],\n    };\n  }\n\n  setAction(action: ActionInfo | undefined) {\n    if (!action) {\n      unsetAction(this.eventInfo);\n      return;\n    }\n    setAction(this.eventInfo, action.name, action.element);\n  }\n\n  getIsReplay() {\n    return getIsReplay(this.eventInfo);\n  }\n\n  setIsReplay(replay: boolean) {\n    setIsReplay(this.eventInfo, replay);\n  }\n\n  clone() {\n    return new EventInfoWrapper(cloneEventInfo(this.eventInfo));\n  }\n}\n"]}