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

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

@@ -0,0 +1,21 @@
+/**
+ * @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
+ */
+/** Special keycodes used by jsaction for the generic click action. */
+export var KeyCode;
+(function (KeyCode) {
+    /**
+     * If on a Macintosh with an extended keyboard, the Enter key located in the
+     * numeric pad has a different ASCII code.
+     */
+    KeyCode[KeyCode["MAC_ENTER"] = 3] = "MAC_ENTER";
+    /** The Enter key. */
+    KeyCode[KeyCode["ENTER"] = 13] = "ENTER";
+    /** The Space key. */
+    KeyCode[KeyCode["SPACE"] = 32] = "SPACE";
+})(KeyCode || (KeyCode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5X2NvZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvc3JjL2tleV9jb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILHNFQUFzRTtBQUN0RSxNQUFNLENBQU4sSUFBWSxPQVlYO0FBWkQsV0FBWSxPQUFPO0lBQ2pCOzs7T0FHRztJQUNILCtDQUFhLENBQUE7SUFFYixxQkFBcUI7SUFDckIsd0NBQVUsQ0FBQTtJQUVWLHFCQUFxQjtJQUNyQix3Q0FBVSxDQUFBO0FBQ1osQ0FBQyxFQVpXLE9BQU8sS0FBUCxPQUFPLFFBWWxCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8qKiBTcGVjaWFsIGtleWNvZGVzIHVzZWQgYnkganNhY3Rpb24gZm9yIHRoZSBnZW5lcmljIGNsaWNrIGFjdGlvbi4gKi9cbmV4cG9ydCBlbnVtIEtleUNvZGUge1xuICAvKipcbiAgICogSWYgb24gYSBNYWNpbnRvc2ggd2l0aCBhbiBleHRlbmRlZCBrZXlib2FyZCwgdGhlIEVudGVyIGtleSBsb2NhdGVkIGluIHRoZVxuICAgKiBudW1lcmljIHBhZCBoYXMgYSBkaWZmZXJlbnQgQVNDSUkgY29kZS5cbiAgICovXG4gIE1BQ19FTlRFUiA9IDMsXG5cbiAgLyoqIFRoZSBFbnRlciBrZXkuICovXG4gIEVOVEVSID0gMTMsXG5cbiAgLyoqIFRoZSBTcGFjZSBrZXkuICovXG4gIFNQQUNFID0gMzIsXG59XG4iXX0=

package/esm2022/primitives/event-dispatch/src/legacy_dispatcher.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 { Dispatcher as LegacyDispatcher, registerDispatcher } from './dispatcher';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVnYWN5X2Rpc3BhdGNoZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvc3JjL2xlZ2FjeV9kaXNwYXRjaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxVQUFVLElBQUksZ0JBQWdCLEVBQUUsa0JBQWtCLEVBQUMsTUFBTSxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IHtEaXNwYXRjaGVyIGFzIExlZ2FjeURpc3BhdGNoZXIsIHJlZ2lzdGVyRGlzcGF0Y2hlcn0gZnJvbSAnLi9kaXNwYXRjaGVyJztcbiJdfQ==

package/esm2022/primitives/event-dispatch/src/property.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
+ */
+/** All properties that are used by jsaction. */
+export var Property;
+(function (Property) {
+    /**
+     * The parsed value of the jsaction attribute is stored in this
+     * property on the DOM node. The parsed value is an Object. The
+     * property names of the object are the events; the values are the
+     * names of the actions. This property is attached even on nodes
+     * that don't have a jsaction attribute as an optimization, because
+     * property lookup is faster than attribute access.
+     */
+    Property["JSACTION"] = "__jsaction";
+    /**
+     * The parsed value of the jsnamespace attribute is stored in this
+     * property on the DOM node.
+     */
+    Property["JSNAMESPACE"] = "__jsnamespace";
+    /** The value of the oi attribute as a property, for faster access. */
+    Property["OI"] = "__oi";
+    /**
+     * The owner property references an a logical owner for a DOM node. JSAction
+     * will follow this reference instead of parentNode when traversing the DOM
+     * to find jsaction attributes. This allows overlaying a logical structure
+     * over a document where the DOM structure can't reflect that structure.
+     */
+    Property["OWNER"] = "__owner";
+})(Property || (Property = {}));
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,32 @@
+/**
+ * @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';
+import { EventContract } from './eventcontract';
+/**
+ * Provides a factory function for bootstrapping an event contract on a
+ * window object.
+ * @param field The property on the window that the event contract will be placed on.
+ * @param container The container that listens to events
+ * @param appId A given identifier for an application. If there are multiple apps on the page
+ *              then this is how contracts can be initialized for each one.
+ * @param events An array of event names that should be listened to.
+ * @param anyWindow The global window object that should receive the event contract.
+ * @returns The `event` contract. This is both assigned to `anyWindow` and returned for testing.
+ */
+export function bootstrapEventContract(field, container, appId, events, anyWindow = window) {
+    if (!anyWindow[field]) {
+        anyWindow[field] = {};
+    }
+    const eventContract = new EventContract(new EventContractContainer(container));
+    anyWindow[field][appId] = eventContract;
+    for (const ev of events) {
+        eventContract.addEvent(ev);
+    }
+    return eventContract;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,389 @@
+/**
+ * @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
+ */
+/**
+ * @fileoverview Functions for replaying events by the jsaction
+ * Dispatcher.
+ * All ts-ignores in this file are due to APIs that are no longer in the browser.
+ */
+import { createCustomEvent } from './/custom_events';
+import * as jsactionEvent from './/event';
+import { EventType } from './/event_type';
+/**
+ * Replays an event.
+ */
+export function replayEvent(event, targetElement, eventType) {
+    triggerEvent(targetElement, createEvent(event, eventType));
+}
+/**
+ * Checks if a given event was triggered by the keyboard.
+ * @param eventType The event type.
+ * @return Whether it's a keyboard event.
+ */
+function isKeyboardEvent(eventType) {
+    return (eventType === EventType.KEYPRESS ||
+        eventType === EventType.KEYDOWN ||
+        eventType === EventType.KEYUP);
+}
+/**
+ * Checks if a given event was triggered by the mouse.
+ * @param eventType The event type.
+ * @return Whether it's a mouse event.
+ */
+function isMouseEvent(eventType) {
+    // TODO: Verify if Drag events should be bound here.
+    return (eventType === EventType.CLICK ||
+        eventType === EventType.DBLCLICK ||
+        eventType === EventType.MOUSEDOWN ||
+        eventType === EventType.MOUSEOVER ||
+        eventType === EventType.MOUSEOUT ||
+        eventType === EventType.MOUSEMOVE);
+}
+/**
+ * Checks if a given event is a general UI event.
+ * @param eventType The event type.
+ * @return Whether it's a focus event.
+ */
+function isUiEvent(eventType) {
+    // Almost nobody supports the W3C method of creating FocusEvents.
+    // For now, we're going to use the UIEvent as a super-interface.
+    return (eventType === EventType.FOCUS ||
+        eventType === EventType.BLUR ||
+        eventType === EventType.FOCUSIN ||
+        eventType === EventType.FOCUSOUT ||
+        eventType === EventType.SCROLL);
+}
+/**
+ * Create a whitespace-delineated list of modifier keys that should be
+ * considered to be active on the event's key. See details at
+ * https://developer.mozilla.org/en/DOM/KeyboardEvent.
+ * @param alt Alt pressed.
+ * @param ctrl Control pressed.
+ * @param meta Command pressed (OSX only).
+ * @param shift Shift pressed.
+ * @return The constructed modifier keys string.
+ */
+function createKeyboardModifiersList(alt, ctrl, meta, shift) {
+    const keys = [];
+    if (alt) {
+        keys.push('Alt');
+    }
+    if (ctrl) {
+        keys.push('Control');
+    }
+    if (meta) {
+        keys.push('Meta');
+    }
+    if (shift) {
+        keys.push('Shift');
+    }
+    return keys.join(' ');
+}
+/**
+ * Creates a UI event object for replaying through the DOM.
+ * @param original The event to create a new event from.
+ * @param opt_eventType The type this event is being handled as by jsaction.
+ *     e.g. blur events are handled as focusout
+ * @return The event object.
+ */
+export function createUiEvent(original, opt_eventType) {
+    let event;
+    if (document.createEvent) {
+        const originalUiEvent = original;
+        // Event creation as per W3C event model specification.  This codepath
+        // is used by most non-IE browsers and also by IE 9 and later.
+        event = document.createEvent('UIEvent');
+        // On IE and Opera < 12, we must provide non-undefined values to
+        // initEvent, otherwise it will fail.
+        event.initUIEvent(opt_eventType || originalUiEvent.type, originalUiEvent.bubbles !== undefined ? originalUiEvent.bubbles : true, originalUiEvent.cancelable || false, originalUiEvent.view || window, original.detail || 0);
+        // detail
+    }
+    else {
+        // Older versions of IE (up to version 8) do not support the
+        // W3C event model. Use the IE specific function instead.
+        // Suppressing errors for ts-migration.
+        //   TS2339: Property 'createEventObject' does not exist on type 'Document'.
+        // @ts-ignore
+        event = document.createEventObject();
+        event.type = opt_eventType || original.type;
+        event.bubbles = original.bubbles !== undefined ? original.bubbles : true;
+        event.cancelable = original.cancelable || false;
+        event.view = original.view || window;
+        event.detail = original.detail || 0;
+    }
+    // Some focus events also have a nullable relatedTarget value which isn't
+    // directly supported in the initUIEvent() method.
+    event.relatedTarget = original.relatedTarget || null;
+    event.originalTimestamp = original.timeStamp;
+    return event;
+}
+/**
+ * Creates a keyboard event object for replaying through the DOM.
+ * @param original The event to create a new event from.
+ * @param opt_eventType The type this event is being handled as by jsaction.
+ *     E.g. a keypress is handled as click in some cases.
+ * @return The event object.
+ * @suppress {strictMissingProperties} Two definitions of initKeyboardEvent.
+ */
+export function createKeyboardEvent(original, opt_eventType) {
+    let event;
+    const keyboardEvent = original;
+    if (document.createEvent) {
+        // Event creation as per W3C event model specification.  This codepath
+        // is used by most non-IE browsers and also by IE 9 and later.
+        event = document.createEvent('KeyboardEvent');
+        if (event.initKeyboardEvent) {
+            if (jsactionEvent.isIe) {
+                // IE9+
+                // https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/ff975945(v=vs.85)
+                const modifiers = createKeyboardModifiersList(keyboardEvent.altKey, keyboardEvent.ctrlKey, keyboardEvent.metaKey, keyboardEvent.shiftKey);
+                event.initKeyboardEvent(opt_eventType || keyboardEvent.type, true, true, window, keyboardEvent.key, keyboardEvent.location, 
+                // Suppressing errors for ts-migration.
+                //   TS2345: Argument of type 'string' is not assignable to
+                //   parameter of type 'boolean | undefined'.
+                // @ts-ignore
+                modifiers, keyboardEvent.repeat, 
+                // @ts-ignore This doesn't exist
+                keyboardEvent.locale);
+            }
+            else {
+                // W3C DOM Level 3 Events model.
+                // https://www.w3.org/TR/uievents/#idl-interface-KeyboardEvent-initializers
+                event.initKeyboardEvent(opt_eventType || original.type, true, true, window, keyboardEvent.key, keyboardEvent.location, keyboardEvent.ctrlKey, keyboardEvent.altKey, keyboardEvent.shiftKey, keyboardEvent.metaKey);
+                Object.defineProperty(event, 'repeat', {
+                    get: () => original.repeat,
+                    enumerable: true,
+                });
+                // Add missing 'locale' which is not part of the spec.
+                // https://bugs.chromium.org/p/chromium/issues/detail?id=168971
+                Object.defineProperty(event, 'locale', {
+                    // Suppressing errors for ts-migration.
+                    //   TS2339: Property 'locale' does not exist on type 'Event'.
+                    // @ts-ignore
+                    get: () => original.locale,
+                    enumerable: true,
+                });
+                // Apple WebKit has a non-standard altGraphKey that is not implemented
+                // here.
+                // https://developer.apple.com/documentation/webkitjs/keyboardevent/1633753-initkeyboardevent
+            }
+            // Blink and Webkit had a bug that causes the `charCode`, `keyCode`, and
+            // `which` properties to always be unset when synthesizing a keyboard
+            // event. Details at: https://bugs.webkit.org/show_bug.cgi?id=16735. With
+            // these properties being deprecated, the bug has evolved into affecting
+            // the `key` property. We work around it by redefining the `key` and
+            // deprecated properties; a simple assignment here would fail because the
+            // native properties are readonly.
+            if (jsactionEvent.isWebKit) {
+                if (keyboardEvent.key && event.key === '') {
+                    Object.defineProperty(event, 'key', {
+                        get: () => keyboardEvent.key,
+                        enumerable: true,
+                    });
+                }
+            }
+            // Re-implement the deprecated `charCode`, `keyCode` and `which` which
+            // are also an issue on IE9+.
+            if (jsactionEvent.isWebKit || jsactionEvent.isIe || jsactionEvent.isGecko) {
+                Object.defineProperty(event, 'charCode', {
+                    get: () => original.charCode,
+                    enumerable: true,
+                });
+                const keyCodeGetter = () => original.keyCode;
+                Object.defineProperty(event, 'keyCode', {
+                    get: keyCodeGetter,
+                    enumerable: true,
+                });
+                Object.defineProperty(event, 'which', {
+                    get: keyCodeGetter,
+                    enumerable: true,
+                });
+            }
+        }
+        else {
+            // Gecko only supports an older/deprecated version from DOM Level 2. See
+            // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/initKeyEvent
+            // for details.
+            // @ts-ignore ditto
+            event.initKeyEvent(opt_eventType || original.type, true, true, window, 
+            // Suppressing errors for ts-migration.
+            //   TS2339: Property 'ctrlKey' does not exist on type 'Event'.
+            // @ts-ignore
+            original.ctrlKey, 
+            // Suppressing errors for ts-migration.
+            //   TS2339: Property 'altKey' does not exist on type 'Event'.
+            // @ts-ignore
+            original.altKey, 
+            // Suppressing errors for ts-migration.
+            //   TS2339: Property 'shiftKey' does not exist on type 'Event'.
+            // @ts-ignore
+            original.shiftKey, 
+            // Suppressing errors for ts-migration.
+            //   TS2339: Property 'metaKey' does not exist on type 'Event'.
+            // @ts-ignore
+            original.metaKey, 
+            // Suppressing errors for ts-migration.
+            //   TS2339: Property 'keyCode' does not exist on type 'Event'.
+            // @ts-ignore
+            original.keyCode, 
+            // Suppressing errors for ts-migration.
+            //   TS2339: Property 'charCode' does not exist on type 'Event'.
+            // @ts-ignore
+            original.charCode);
+        }
+    }
+    else {
+        // Older versions of IE (up to version 8) do not support the
+        // W3C event model. Use the IE specific function instead.
+        // Suppressing errors for ts-migration.
+        // @ts-ignore
+        event = document.createEventObject();
+        event.type = opt_eventType || original.type;
+        const originalKeyboardEvent = original;
+        event.repeat = originalKeyboardEvent.repeat;
+        event.ctrlKey = originalKeyboardEvent.ctrlKey;
+        event.altKey = originalKeyboardEvent.altKey;
+        event.shiftKey = originalKeyboardEvent.shiftKey;
+        event.metaKey = originalKeyboardEvent.metaKey;
+        event.key = originalKeyboardEvent.key;
+        event.keyCode = originalKeyboardEvent.keyCode;
+        event.charCode = originalKeyboardEvent.charCode;
+    }
+    event.originalTimestamp = original.timeStamp;
+    return event;
+}
+/**
+ * Creates a mouse event object for replaying through the DOM.
+ * @param original The event to create a new event from.
+ * @param opt_eventType The type this event is being handled as by jsaction.
+ *     E.g. a keypress is handled as click in some cases.
+ * @return The event object.
+ */
+export function createMouseEvent(original, opt_eventType) {
+    let event;
+    const originalMouseEvent = original;
+    if (document.createEvent) {
+        // Event creation as per W3C event model specification.  This codepath
+        // is used by most non-IE browsers and also by IE 9 and later.
+        event = document.createEvent('MouseEvent');
+        // On IE and Opera < 12, we must provide non-undefined values to
+        // initMouseEvent, otherwise it will fail.
+        event.initMouseEvent(opt_eventType || original.type, true, // canBubble
+        true, // cancelable
+        window, original.detail || 1, originalMouseEvent.screenX || 0, originalMouseEvent.screenY || 0, originalMouseEvent.clientX || 0, originalMouseEvent.clientY || 0, originalMouseEvent.ctrlKey || false, originalMouseEvent.altKey || false, originalMouseEvent.shiftKey || false, originalMouseEvent.metaKey || false, originalMouseEvent.button || 0, originalMouseEvent.relatedTarget || null);
+    }
+    else {
+        // Older versions of IE (up to version 8) do not support the
+        // W3C event model. Use the IE specific function instead.
+        // @ts-ignore
+        event = document.createEventObject();
+        event.type = opt_eventType || original.type;
+        event.clientX = originalMouseEvent.clientX;
+        event.clientY = originalMouseEvent.clientY;
+        event.button = originalMouseEvent.button;
+        event.detail = original.detail;
+        event.ctrlKey = originalMouseEvent.ctrlKey;
+        event.altKey = originalMouseEvent.altKey;
+        event.shiftKey = originalMouseEvent.shiftKey;
+        event.metaKey = originalMouseEvent.metaKey;
+    }
+    event.originalTimestamp = original.timeStamp;
+    return event;
+}
+/**
+ * Creates a generic event object for replaying through the DOM.
+ * @param original The event to create a new event from.
+ * @param opt_eventType The type this event is being handled as by jsaction.
+ *     E.g. a keypress is handled as click in some cases.
+ * @return The event object.
+ */
+function createGenericEvent(original, opt_eventType) {
+    let event;
+    if (document.createEvent) {
+        // Event creation as per W3C event model specification.  This codepath
+        // is used by most non-IE browsers and also by IE 9 and later.
+        event = document.createEvent('Event');
+        event.initEvent(opt_eventType || original.type, true, true);
+    }
+    else {
+        // Older versions of IE (up to version 8) do not support the
+        // W3C event model. Use the IE specific function instead.
+        // Suppressing errors for ts-migration.
+        //   TS2339: Property 'createEventObject' does not exist on type 'Document'.
+        // @ts-ignore
+        event = document.createEventObject();
+        event.type = opt_eventType || original.type;
+    }
+    event.originalTimestamp = original.timeStamp;
+    return event;
+}
+/**
+ * Creates an event object for replaying through the DOM.
+ * NOTE: This function is visible just for testing.  Please don't use
+ * it outside JsAction internal testing.
+ * TODO: Add support for FocusEvent and WheelEvent.
+ * @param base The event to create a new event from.
+ * @param opt_eventType The type this event is being handled as by jsaction.
+ *     E.g. a keypress is handled as click in some cases.
+ * @return The event object.
+ */
+export function createEvent(base, opt_eventType) {
+    const original = base;
+    let event;
+    let eventType;
+    if (original.type === EventType.CUSTOM) {
+        eventType = EventType.CUSTOM;
+    }
+    else {
+        eventType = opt_eventType || original.type;
+    }
+    if (isKeyboardEvent(eventType)) {
+        event = createKeyboardEvent(original, opt_eventType);
+    }
+    else if (isMouseEvent(eventType)) {
+        event = createMouseEvent(original, opt_eventType);
+    }
+    else if (isUiEvent(eventType)) {
+        event = createUiEvent(original, opt_eventType);
+    }
+    else if (eventType === EventType.CUSTOM) {
+        event = createCustomEvent(opt_eventType, original['detail']['data'], original['detail']['triggeringEvent']);
+        event.originalTimestamp = original.timeStamp;
+    }
+    else {
+        // This ensures we don't send an undefined event object to the replayer.
+        event = createGenericEvent(original, opt_eventType);
+    }
+    return event;
+}
+/**
+ * Sends an event for replay to the DOM.
+ * @param target The target for the event.
+ * @param event The event object.
+ * @return The return value of the event replay, i.e., whether preventDefault()
+ *     was called on it.
+ */
+export function triggerEvent(target, event) {
+    if (target.dispatchEvent) {
+        return target.dispatchEvent(event);
+    }
+    else {
+        // Suppressing errors for ts-migration.
+        //   TS2339: Property 'fireEvent' does not exist on type 'Element'.
+        // @ts-ignore
+        return target.fireEvent('on' + event.type, event);
+    }
+}
+/** Do not use outiside of testing. */
+export const testing = {
+    createKeyboardModifiersList,
+    createGenericEvent,
+    isKeyboardEvent,
+    isMouseEvent,
+    isUiEvent,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"replay.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/replay.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n/**\n * @fileoverview Functions for replaying events by the jsaction\n * Dispatcher.\n * All ts-ignores in this file are due to APIs that are no longer in the browser.\n */\n\nimport {createCustomEvent} from './/custom_events';\nimport * as jsactionEvent from './/event';\nimport {EventType} from './/event_type';\n\ntype Writeable<T> = {\n  -readonly [P in keyof T]: T[P];\n};\n\n/**\n * Replays an event.\n */\nexport function replayEvent(event: Event, targetElement: Element, eventType?: string) {\n  triggerEvent(targetElement, createEvent(event, eventType));\n}\n\n/**\n * Checks if a given event was triggered by the keyboard.\n * @param eventType The event type.\n * @return Whether it's a keyboard event.\n */\nfunction isKeyboardEvent(eventType: string): boolean {\n  return (\n    eventType === EventType.KEYPRESS ||\n    eventType === EventType.KEYDOWN ||\n    eventType === EventType.KEYUP\n  );\n}\n\n/**\n * Checks if a given event was triggered by the mouse.\n * @param eventType The event type.\n * @return Whether it's a mouse event.\n */\nfunction isMouseEvent(eventType: string): boolean {\n  // TODO: Verify if Drag events should be bound here.\n  return (\n    eventType === EventType.CLICK ||\n    eventType === EventType.DBLCLICK ||\n    eventType === EventType.MOUSEDOWN ||\n    eventType === EventType.MOUSEOVER ||\n    eventType === EventType.MOUSEOUT ||\n    eventType === EventType.MOUSEMOVE\n  );\n}\n\n/**\n * Checks if a given event is a general UI event.\n * @param eventType The event type.\n * @return Whether it's a focus event.\n */\nfunction isUiEvent(eventType: string): boolean {\n  // Almost nobody supports the W3C method of creating FocusEvents.\n  // For now, we're going to use the UIEvent as a super-interface.\n  return (\n    eventType === EventType.FOCUS ||\n    eventType === EventType.BLUR ||\n    eventType === EventType.FOCUSIN ||\n    eventType === EventType.FOCUSOUT ||\n    eventType === EventType.SCROLL\n  );\n}\n\n/**\n * Create a whitespace-delineated list of modifier keys that should be\n * considered to be active on the event's key. See details at\n * https://developer.mozilla.org/en/DOM/KeyboardEvent.\n * @param alt Alt pressed.\n * @param ctrl Control pressed.\n * @param meta Command pressed (OSX only).\n * @param shift Shift pressed.\n * @return The constructed modifier keys string.\n */\nfunction createKeyboardModifiersList(\n  alt: boolean,\n  ctrl: boolean,\n  meta: boolean,\n  shift: boolean,\n): string {\n  const keys = [];\n  if (alt) {\n    keys.push('Alt');\n  }\n  if (ctrl) {\n    keys.push('Control');\n  }\n  if (meta) {\n    keys.push('Meta');\n  }\n  if (shift) {\n    keys.push('Shift');\n  }\n  return keys.join(' ');\n}\n\n/**\n * Creates a UI event object for replaying through the DOM.\n * @param original The event to create a new event from.\n * @param opt_eventType The type this event is being handled as by jsaction.\n *     e.g. blur events are handled as focusout\n * @return The event object.\n */\nexport function createUiEvent(original: Event, opt_eventType?: string): Event {\n  let event: Writeable<UIEvent> & {originalTimestamp?: DOMHighResTimeStamp};\n  if (document.createEvent) {\n    const originalUiEvent = original as UIEvent;\n    // Event creation as per W3C event model specification.  This codepath\n    // is used by most non-IE browsers and also by IE 9 and later.\n    event = document.createEvent('UIEvent');\n    // On IE and Opera < 12, we must provide non-undefined values to\n    // initEvent, otherwise it will fail.\n    event.initUIEvent(\n      opt_eventType || originalUiEvent.type,\n      originalUiEvent.bubbles !== undefined ? originalUiEvent.bubbles : true,\n      originalUiEvent.cancelable || false,\n      originalUiEvent.view || window,\n      (original as CustomEvent).detail || 0,\n    );\n    // detail\n  } else {\n    // Older versions of IE (up to version 8) do not support the\n    // W3C event model. Use the IE specific function instead.\n    // Suppressing errors for ts-migration.\n    //   TS2339: Property 'createEventObject' does not exist on type 'Document'.\n    // @ts-ignore\n    event = document.createEventObject();\n    event.type = opt_eventType || original.type;\n    event.bubbles = original.bubbles !== undefined ? original.bubbles : true;\n    event.cancelable = original.cancelable || false;\n    event.view = (original as Writeable<UIEvent>).view || window;\n    event.detail = (original as CustomEvent).detail || 0;\n  }\n  // Some focus events also have a nullable relatedTarget value which isn't\n  // directly supported in the initUIEvent() method.\n  (event as Writeable<FocusEvent>).relatedTarget = (original as FocusEvent).relatedTarget || null;\n  event.originalTimestamp = original.timeStamp;\n  return event;\n}\n\n/**\n * Creates a keyboard event object for replaying through the DOM.\n * @param original The event to create a new event from.\n * @param opt_eventType The type this event is being handled as by jsaction.\n *     E.g. a keypress is handled as click in some cases.\n * @return The event object.\n * @suppress {strictMissingProperties} Two definitions of initKeyboardEvent.\n */\nexport function createKeyboardEvent(original: Event, opt_eventType?: string): Event {\n  let event;\n  const keyboardEvent = original as KeyboardEvent;\n  if (document.createEvent) {\n    // Event creation as per W3C event model specification.  This codepath\n    // is used by most non-IE browsers and also by IE 9 and later.\n    event = document.createEvent('KeyboardEvent');\n    if (event.initKeyboardEvent) {\n      if (jsactionEvent.isIe) {\n        // IE9+\n        // https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/ff975945(v=vs.85)\n        const modifiers = createKeyboardModifiersList(\n          keyboardEvent.altKey,\n          keyboardEvent.ctrlKey,\n          keyboardEvent.metaKey,\n          keyboardEvent.shiftKey,\n        );\n        event.initKeyboardEvent(\n          opt_eventType || keyboardEvent.type,\n          true,\n          true,\n          window,\n          keyboardEvent.key,\n          keyboardEvent.location,\n          // Suppressing errors for ts-migration.\n          //   TS2345: Argument of type 'string' is not assignable to\n          //   parameter of type 'boolean | undefined'.\n          // @ts-ignore\n          modifiers,\n          keyboardEvent.repeat,\n          // @ts-ignore This doesn't exist\n          keyboardEvent.locale,\n        );\n      } else {\n        // W3C DOM Level 3 Events model.\n        // https://www.w3.org/TR/uievents/#idl-interface-KeyboardEvent-initializers\n        event.initKeyboardEvent(\n          opt_eventType || original.type,\n          true,\n          true,\n          window,\n          keyboardEvent.key,\n          keyboardEvent.location,\n          keyboardEvent.ctrlKey,\n          keyboardEvent.altKey,\n          keyboardEvent.shiftKey,\n          keyboardEvent.metaKey,\n        );\n        Object.defineProperty(event, 'repeat', {\n          get: () => (original as KeyboardEvent).repeat,\n          enumerable: true,\n        });\n        // Add missing 'locale' which is not part of the spec.\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=168971\n        Object.defineProperty(event, 'locale', {\n          // Suppressing errors for ts-migration.\n          //   TS2339: Property 'locale' does not exist on type 'Event'.\n          // @ts-ignore\n          get: () => original.locale,\n          enumerable: true,\n        });\n        // Apple WebKit has a non-standard altGraphKey that is not implemented\n        // here.\n        // https://developer.apple.com/documentation/webkitjs/keyboardevent/1633753-initkeyboardevent\n      }\n      // Blink and Webkit had a bug that causes the `charCode`, `keyCode`, and\n      // `which` properties to always be unset when synthesizing a keyboard\n      // event. Details at: https://bugs.webkit.org/show_bug.cgi?id=16735. With\n      // these properties being deprecated, the bug has evolved into affecting\n      // the `key` property. We work around it by redefining the `key` and\n      // deprecated properties; a simple assignment here would fail because the\n      // native properties are readonly.\n      if (jsactionEvent.isWebKit) {\n        if (keyboardEvent.key && event.key === '') {\n          Object.defineProperty(event, 'key', {\n            get: () => keyboardEvent.key,\n            enumerable: true,\n          });\n        }\n      }\n      // Re-implement the deprecated `charCode`, `keyCode` and `which` which\n      // are also an issue on IE9+.\n      if (jsactionEvent.isWebKit || jsactionEvent.isIe || jsactionEvent.isGecko) {\n        Object.defineProperty(event, 'charCode', {\n          get: () => (original as KeyboardEvent).charCode,\n          enumerable: true,\n        });\n        const keyCodeGetter = () => (original as KeyboardEvent).keyCode;\n        Object.defineProperty(event, 'keyCode', {\n          get: keyCodeGetter,\n          enumerable: true,\n        });\n        Object.defineProperty(event, 'which', {\n          get: keyCodeGetter,\n          enumerable: true,\n        });\n      }\n    } else {\n      // Gecko only supports an older/deprecated version from DOM Level 2. See\n      // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/initKeyEvent\n      // for details.\n      // @ts-ignore ditto\n      event.initKeyEvent(\n        opt_eventType || original.type,\n        true,\n        true,\n        window,\n        // Suppressing errors for ts-migration.\n        //   TS2339: Property 'ctrlKey' does not exist on type 'Event'.\n        // @ts-ignore\n        original.ctrlKey,\n        // Suppressing errors for ts-migration.\n        //   TS2339: Property 'altKey' does not exist on type 'Event'.\n        // @ts-ignore\n        original.altKey,\n        // Suppressing errors for ts-migration.\n        //   TS2339: Property 'shiftKey' does not exist on type 'Event'.\n        // @ts-ignore\n        original.shiftKey,\n        // Suppressing errors for ts-migration.\n        //   TS2339: Property 'metaKey' does not exist on type 'Event'.\n        // @ts-ignore\n        original.metaKey,\n        // Suppressing errors for ts-migration.\n        //   TS2339: Property 'keyCode' does not exist on type 'Event'.\n        // @ts-ignore\n        original.keyCode,\n        // Suppressing errors for ts-migration.\n        //   TS2339: Property 'charCode' does not exist on type 'Event'.\n        // @ts-ignore\n        original.charCode,\n      );\n    }\n  } else {\n    // Older versions of IE (up to version 8) do not support the\n    // W3C event model. Use the IE specific function instead.\n    // Suppressing errors for ts-migration.\n    // @ts-ignore\n    event = document.createEventObject();\n    event.type = opt_eventType || original.type;\n    const originalKeyboardEvent = original as KeyboardEvent;\n    event.repeat = originalKeyboardEvent.repeat;\n    event.ctrlKey = originalKeyboardEvent.ctrlKey;\n    event.altKey = originalKeyboardEvent.altKey;\n    event.shiftKey = originalKeyboardEvent.shiftKey;\n    event.metaKey = originalKeyboardEvent.metaKey;\n    event.key = originalKeyboardEvent.key;\n    event.keyCode = originalKeyboardEvent.keyCode;\n    event.charCode = originalKeyboardEvent.charCode;\n  }\n  event.originalTimestamp = original.timeStamp;\n  return event;\n}\n\n/**\n * Creates a mouse event object for replaying through the DOM.\n * @param original The event to create a new event from.\n * @param opt_eventType The type this event is being handled as by jsaction.\n *     E.g. a keypress is handled as click in some cases.\n * @return The event object.\n */\nexport function createMouseEvent(original: Event, opt_eventType?: string): MouseEvent {\n  let event;\n  const originalMouseEvent = original as MouseEvent;\n  if (document.createEvent) {\n    // Event creation as per W3C event model specification.  This codepath\n    // is used by most non-IE browsers and also by IE 9 and later.\n    event = document.createEvent('MouseEvent');\n    // On IE and Opera < 12, we must provide non-undefined values to\n    // initMouseEvent, otherwise it will fail.\n    event.initMouseEvent(\n      opt_eventType || original.type,\n      true, // canBubble\n      true, // cancelable\n      window,\n      (original as CustomEvent).detail || 1,\n      originalMouseEvent.screenX || 0,\n      originalMouseEvent.screenY || 0,\n      originalMouseEvent.clientX || 0,\n      originalMouseEvent.clientY || 0,\n      originalMouseEvent.ctrlKey || false,\n      originalMouseEvent.altKey || false,\n      originalMouseEvent.shiftKey || false,\n      originalMouseEvent.metaKey || false,\n      originalMouseEvent.button || 0,\n      originalMouseEvent.relatedTarget || null,\n    );\n  } else {\n    // Older versions of IE (up to version 8) do not support the\n    // W3C event model. Use the IE specific function instead.\n    // @ts-ignore\n    event = document.createEventObject();\n    event.type = opt_eventType || original.type;\n    event.clientX = originalMouseEvent.clientX;\n    event.clientY = originalMouseEvent.clientY;\n    event.button = originalMouseEvent.button;\n    event.detail = (original as CustomEvent).detail;\n    event.ctrlKey = originalMouseEvent.ctrlKey;\n    event.altKey = originalMouseEvent.altKey;\n    event.shiftKey = originalMouseEvent.shiftKey;\n    event.metaKey = originalMouseEvent.metaKey;\n  }\n  event.originalTimestamp = original.timeStamp;\n  return event;\n}\n\n/**\n * Creates a generic event object for replaying through the DOM.\n * @param original The event to create a new event from.\n * @param opt_eventType The type this event is being handled as by jsaction.\n *     E.g. a keypress is handled as click in some cases.\n * @return The event object.\n */\nfunction createGenericEvent(original: Event, opt_eventType?: string): Event {\n  let event;\n  if (document.createEvent) {\n    // Event creation as per W3C event model specification.  This codepath\n    // is used by most non-IE browsers and also by IE 9 and later.\n    event = document.createEvent('Event');\n    event.initEvent(opt_eventType || original.type, true, true);\n  } else {\n    // Older versions of IE (up to version 8) do not support the\n    // W3C event model. Use the IE specific function instead.\n    // Suppressing errors for ts-migration.\n    //   TS2339: Property 'createEventObject' does not exist on type 'Document'.\n    // @ts-ignore\n    event = document.createEventObject();\n    event.type = opt_eventType || original.type;\n  }\n  event.originalTimestamp = original.timeStamp;\n  return event;\n}\n\n/**\n * Creates an event object for replaying through the DOM.\n * NOTE: This function is visible just for testing.  Please don't use\n * it outside JsAction internal testing.\n * TODO: Add support for FocusEvent and WheelEvent.\n * @param base The event to create a new event from.\n * @param opt_eventType The type this event is being handled as by jsaction.\n *     E.g. a keypress is handled as click in some cases.\n * @return The event object.\n */\nexport function createEvent(base: unknown, opt_eventType?: string): Event {\n  const original = base as Event;\n  let event;\n  let eventType;\n  if (original.type === EventType.CUSTOM) {\n    eventType = EventType.CUSTOM;\n  } else {\n    eventType = opt_eventType || original.type;\n  }\n\n  if (isKeyboardEvent(eventType)) {\n    event = createKeyboardEvent(original, opt_eventType);\n  } else if (isMouseEvent(eventType)) {\n    event = createMouseEvent(original, opt_eventType);\n  } else if (isUiEvent(eventType)) {\n    event = createUiEvent(original, opt_eventType);\n  } else if (eventType === EventType.CUSTOM) {\n    event = createCustomEvent(\n      opt_eventType!,\n      (original as CustomEvent)['detail']['data'],\n      (original as CustomEvent)['detail']['triggeringEvent'],\n    );\n    (event as {originalTimestamp?: number | null} | null)!.originalTimestamp = original.timeStamp;\n  } else {\n    // This ensures we don't send an undefined event object to the replayer.\n    event = createGenericEvent(original, opt_eventType);\n  }\n  return event;\n}\n\n/**\n * Sends an event for replay to the DOM.\n * @param target The target for the event.\n * @param event The event object.\n * @return The return value of the event replay, i.e., whether preventDefault()\n *     was called on it.\n */\nexport function triggerEvent(target: EventTarget, event: Event): boolean {\n  if (target.dispatchEvent) {\n    return target.dispatchEvent(event);\n  } else {\n    // Suppressing errors for ts-migration.\n    //   TS2339: Property 'fireEvent' does not exist on type 'Element'.\n    // @ts-ignore\n    return (target as Element).fireEvent('on' + event.type, event);\n  }\n}\n\n/** Do not use outiside of testing. */\nexport const testing = {\n  createKeyboardModifiersList,\n  createGenericEvent,\n  isKeyboardEvent,\n  isMouseEvent,\n  isUiEvent,\n};\n"]}

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

@@ -0,0 +1,15 @@
+/**
+ * @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
+ */
+/**
+ * @fileoverview An enum to control who can call certain jsaction APIs.
+ */
+export var Restriction;
+(function (Restriction) {
+    Restriction[Restriction["I_AM_THE_JSACTION_FRAMEWORK"] = 1] = "I_AM_THE_JSACTION_FRAMEWORK";
+})(Restriction || (Restriction = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdHJpY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvc3JjL3Jlc3RyaWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOztHQUVHO0FBRUgsTUFBTSxDQUFOLElBQVksV0FFWDtBQUZELFdBQVksV0FBVztJQUNyQiwyRkFBK0IsQ0FBQTtBQUNqQyxDQUFDLEVBRlcsV0FBVyxLQUFYLFdBQVcsUUFFdEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBAZmlsZW92ZXJ2aWV3IEFuIGVudW0gdG8gY29udHJvbCB3aG8gY2FuIGNhbGwgY2VydGFpbiBqc2FjdGlvbiBBUElzLlxuICovXG5cbmV4cG9ydCBlbnVtIFJlc3RyaWN0aW9uIHtcbiAgSV9BTV9USEVfSlNBQ1RJT05fRlJBTUVXT1JLID0gMSxcbn1cbiJdfQ==

package/esm2022/primitives/signals/index.mjs

@@ -8,8 +8,8 @@
 export { createComputed } from './src/computed';
 export { defaultEquals } from './src/equality';
 export { setThrowInvalidWriteToSignalError } from './src/errors';
-export { REACTIVE_NODE, SIGNAL, consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, getActiveConsumer, isInNotificationPhase, isReactive, producerAccessed, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, setActiveConsumer } from './src/graph';
-export { SIGNAL_NODE, createSignal, setPostSignalSetFn, signalSetFn, signalUpdateFn } from './src/signal';
+export { REACTIVE_NODE, SIGNAL, consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, getActiveConsumer, isInNotificationPhase, isReactive, producerAccessed, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, setActiveConsumer, } from './src/graph';
+export { SIGNAL_NODE, createSignal, setPostSignalSetFn, signalSetFn, signalUpdateFn, } from './src/signal';
 export { createWatch } from './src/watch';
 export { setAlternateWeakRefImpl } from './src/weak_ref';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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