@angular/core 18.0.0-rc.1 → 18.0.0-rc.2

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

@@ -5,17 +5,15 @@
  * 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
  */
+/**
+ * If on a Macintosh with an extended keyboard, the Enter key located in the
+ * numeric pad has a different ASCII code.
+ */
+export const MAC_ENTER = 3;
+/** The Enter key. */
+export const ENTER = 13;
+/** The Space key. */
+export const SPACE = 32;
 /** 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=
+export const KeyCode = { MAC_ENTER, ENTER, SPACE };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5X2NvZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvc3JjL2tleV9jb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLENBQUM7QUFFM0IscUJBQXFCO0FBQ3JCLE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUM7QUFFeEIscUJBQXFCO0FBQ3JCLE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUM7QUFFeEIsc0VBQXNFO0FBQ3RFLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxFQUFDLFNBQVMsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBJZiBvbiBhIE1hY2ludG9zaCB3aXRoIGFuIGV4dGVuZGVkIGtleWJvYXJkLCB0aGUgRW50ZXIga2V5IGxvY2F0ZWQgaW4gdGhlXG4gKiBudW1lcmljIHBhZCBoYXMgYSBkaWZmZXJlbnQgQVNDSUkgY29kZS5cbiAqL1xuZXhwb3J0IGNvbnN0IE1BQ19FTlRFUiA9IDM7XG5cbi8qKiBUaGUgRW50ZXIga2V5LiAqL1xuZXhwb3J0IGNvbnN0IEVOVEVSID0gMTM7XG5cbi8qKiBUaGUgU3BhY2Uga2V5LiAqL1xuZXhwb3J0IGNvbnN0IFNQQUNFID0gMzI7XG5cbi8qKiBTcGVjaWFsIGtleWNvZGVzIHVzZWQgYnkganNhY3Rpb24gZm9yIHRoZSBnZW5lcmljIGNsaWNrIGFjdGlvbi4gKi9cbmV4cG9ydCBjb25zdCBLZXlDb2RlID0ge01BQ19FTlRFUiwgRU5URVIsIFNQQUNFfTtcbiJdfQ==

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

@@ -5,5 +5,255 @@
  * 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==
+import { Dispatcher, stopPropagation, } from './dispatcher';
+import { Char } from './char';
+import * as eventLib from './event';
+import { EventType } from './event_type';
+import { Restriction } from './restriction';
+export { stopPropagation } from './dispatcher';
+/**
+ * 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 LegacyDispatcher {
+    /**
+     * Receives a DOM event, determines the jsaction associated with the source
+     * element of the DOM event, and invokes the handler associated with the
+     * jsaction.
+     *
+     * @param getHandler A function that knows how to get the handler for a
+     *     given event info.
+     */
+    constructor(getHandler, { actionResolver, eventReplayer, stopPropagation = false, } = {}) {
+        this.getHandler = getHandler;
+        /**
+         * The actions that are registered for this Dispatcher instance.
+         * This should be the primary one used once migration off of registerHandlers
+         * is done.
+         */
+        this.actions = {};
+        /** A map of global event handlers, where each key is an event type. */
+        this.globalHandlers = new Map();
+        /** Whether event replay is scheduled. */
+        this.eventReplayScheduled = false;
+        this.eventReplayer = eventReplayer;
+        this.dispatcher = new Dispatcher((eventInfoWrapper) => {
+            this.dispatchToHandler(eventInfoWrapper);
+        }, {
+            actionResolver,
+            eventReplayer: (eventInfoWrappers) => {
+                this.eventInfoWrapperQueue = eventInfoWrappers;
+                this.eventReplayer?.(this.eventInfoWrapperQueue, this);
+            },
+        });
+        this.stopPropagation = stopPropagation;
+    }
+    /**
+     * 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.
+     */
+    dispatch(eventInfo, isGlobalDispatch) {
+        this.dispatcher.dispatch(eventInfo);
+    }
+    /**
+     * Dispatches an `EventInfoWrapper`.
+     */
+    dispatchToHandler(eventInfoWrapper) {
+        if (this.globalHandlers.size) {
+            const globalEventInfoWrapper = eventInfoWrapper.clone();
+            // In some cases, `populateAction` will rewrite `click` events to
+            // `clickonly`. Revert back to a regular click, otherwise we won't be able
+            // to execute global event handlers registered on click events.
+            if (globalEventInfoWrapper.getEventType() === EventType.CLICKONLY) {
+                globalEventInfoWrapper.setEventType(EventType.CLICK);
+            }
+            // Skip everything related to jsaction handlers, and execute the global
+            // handlers.
+            const event = globalEventInfoWrapper.getEvent();
+            const eventTypeHandlers = this.globalHandlers.get(globalEventInfoWrapper.getEventType());
+            let shouldPreventDefault = false;
+            if (eventTypeHandlers) {
+                for (const handler of eventTypeHandlers) {
+                    if (handler(event) === false) {
+                        shouldPreventDefault = true;
+                    }
+                }
+            }
+            if (shouldPreventDefault) {
+                eventLib.preventDefault(event);
+            }
+        }
+        const action = eventInfoWrapper.getAction();
+        if (!action) {
+            return;
+        }
+        if (this.stopPropagation) {
+            stopPropagation(eventInfoWrapper);
+        }
+        let handler = undefined;
+        if (this.getHandler) {
+            handler = this.getHandler(eventInfoWrapper);
+        }
+        if (!handler) {
+            handler = this.actions[action.name];
+        }
+        if (handler) {
+            handler(eventInfoWrapper);
+            return;
+        }
+        // No handler was found.
+        this.eventInfoWrapperQueue?.push(eventInfoWrapper);
+    }
+    /**
+     * Registers multiple methods all bound to the same object
+     * instance. This is a common case: an application module binds
+     * multiple of its methods under public names to the event contract of
+     * the application. So we provide a shortcut for it.
+     * Attempts to replay the queued events after registering the handlers.
+     *
+     * @param namespace The namespace of the jsaction name.
+     *
+     * @param instance The object to bind the methods to. If this is null, then
+     *     the functions are not bound, but directly added under the public names.
+     *
+     * @param methods A map from public name to functions that will be bound to
+     *     instance and registered as action under the public name. I.e. the
+     *     property names are the public names. The property values are the
+     *     methods of instance.
+     */
+    registerEventInfoHandlers(namespace, instance, methods) {
+        for (const [name, method] of Object.entries(methods)) {
+            const handler = instance ? method.bind(instance) : method;
+            if (namespace) {
+                // Include a '.' separator between namespace name and action name.
+                // In the case that no namespace name is provided, the jsaction name
+                // consists of the action name only (no period).
+                const fullName = namespace + Char.NAMESPACE_ACTION_SEPARATOR + name;
+                this.actions[fullName] = handler;
+            }
+            else {
+                this.actions[name] = handler;
+            }
+        }
+        this.scheduleEventReplay();
+    }
+    /**
+     * Unregisters an action.  Provided as an easy way to reverse the effects of
+     * registerHandlers.
+     * @param namespace The namespace of the jsaction name.
+     * @param name The action name to unbind.
+     */
+    unregisterHandler(namespace, name) {
+        const fullName = namespace ? namespace + Char.NAMESPACE_ACTION_SEPARATOR + name : name;
+        delete this.actions[fullName];
+    }
+    /** Registers a global event handler. */
+    registerGlobalHandler(eventType, handler) {
+        if (!this.globalHandlers.has(eventType)) {
+            this.globalHandlers.set(eventType, new Set([handler]));
+        }
+        else {
+            this.globalHandlers.get(eventType).add(handler);
+        }
+    }
+    /** Unregisters a global event handler. */
+    unregisterGlobalHandler(eventType, handler) {
+        if (this.globalHandlers.has(eventType)) {
+            this.globalHandlers.get(eventType).delete(handler);
+        }
+    }
+    /**
+     * Checks whether there is an action registered under the given
+     * name. This returns true if there is a namespace handler, even
+     * if it can not yet handle the event.
+     *
+     * @param name Action name.
+     * @return Whether the name is registered.
+     * @see #canDispatch
+     */
+    hasAction(name) {
+        return this.actions.hasOwnProperty(name);
+    }
+    /**
+     * Whether this dispatcher can dispatch the event. This can be used by
+     * event replayer to check whether the dispatcher can replay an event.
+     */
+    canDispatch(eventInfoWrapper) {
+        const action = eventInfoWrapper.getAction();
+        if (!action) {
+            return false;
+        }
+        return this.hasAction(action.name);
+    }
+    /**
+     * Sets the event replayer, enabling queued events to be replayed when actions
+     * are bound. To replay events, you must register the dispatcher to the
+     * contract after setting the `EventReplayer`. The event replayer takes as
+     * parameters the queue of events and the dispatcher (used to check whether
+     * actions have handlers registered and can be replayed). The event replayer
+     * is also responsible for dequeuing events.
+     *
+     * Example: An event replayer that replays only the last event.
+     *
+     *   const dispatcher = new Dispatcher();
+     *   // ...
+     *   dispatcher.setEventReplayer((queue, dispatcher) => {
+     *     const lastEventInfoWrapper = queue[queue.length -1];
+     *     if (dispatcher.canDispatch(lastEventInfoWrapper.getAction())) {
+     *       jsaction.replay.replayEvent(
+     *           lastEventInfoWrapper.getEvent(),
+     *           lastEventInfoWrapper.getTargetElement(),
+     *           lastEventInfoWrapper.getEventType(),
+     *       );
+     *       queue.length = 0;
+     *     }
+     *   });
+     *
+     * @param eventReplayer It allows elements to be replayed and dequeuing.
+     */
+    setEventReplayer(eventReplayer) {
+        this.eventReplayer = eventReplayer;
+    }
+    /**
+     * 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.eventInfoWrapperQueue?.length) {
+            return;
+        }
+        this.eventReplayScheduled = true;
+        Promise.resolve().then(() => {
+            this.eventReplayScheduled = false;
+            this.eventReplayer(this.eventInfoWrapperQueue, this);
+        });
+    }
+}
+/**
+ * Registers deferred functionality for an EventContract and a Jsaction
+ * Dispatcher.
+ */
+export function registerDispatcher(eventContract, dispatcher) {
+    eventContract.ecrd((eventInfo) => {
+        dispatcher.dispatch(eventInfo);
+    }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"legacy_dispatcher.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/event-dispatch/src/legacy_dispatcher.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  Dispatcher,\n  EventInfoHandler as EventInfoWrapperHandler,\n  GlobalHandler,\n  stopPropagation,\n} from './dispatcher';\nimport {Char} from './char';\nimport * as eventLib from './event';\nimport {EventInfo, EventInfoWrapper} from './event_info';\nimport {EventType} from './event_type';\nimport {UnrenamedEventContract} from './eventcontract';\nimport {Restriction} from './restriction';\nimport {ActionResolver} from './action_resolver';\n\n/** Re-exports that should eventually be moved into this file. */\nexport type {\n  EventInfoHandler,\n  EventInfoHandler as EventInfoWrapperHandler,\n  GlobalHandler,\n} from './dispatcher';\nexport {stopPropagation} from './dispatcher';\n\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 = (\n  eventInfoWrappers: EventInfoWrapper[],\n  dispatcher: LegacyDispatcher,\n) => void;\n\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 LegacyDispatcher {\n  private readonly dispatcher: Dispatcher;\n\n  /** Whether to stop propagation for an `EventInfo`. */\n  private readonly stopPropagation: boolean;\n\n  /**\n   * The actions that are registered for this Dispatcher instance.\n   * This should be the primary one used once migration off of registerHandlers\n   * is done.\n   */\n  private readonly actions: {[key: string]: EventInfoWrapperHandler} = {};\n\n  /** A map of global event handlers, where each key is an event type. */\n  private readonly globalHandlers = new Map<string, Set<GlobalHandler>>();\n\n  /** The event replayer. */\n  private eventReplayer?: Replayer;\n\n  /** The event infos that have be replayed. */\n  private eventInfoWrapperQueue?: EventInfoWrapper[];\n\n  /** Whether event replay is scheduled. */\n  private eventReplayScheduled: boolean = false;\n\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   *\n   * @param getHandler A function that knows how to get the handler for a\n   *     given event info.\n   */\n  constructor(\n    private readonly getHandler?: (\n      eventInfoWrapper: EventInfoWrapper,\n    ) => EventInfoWrapperHandler | void,\n    {\n      actionResolver,\n      eventReplayer,\n      stopPropagation = false,\n    }: {actionResolver?: ActionResolver; eventReplayer?: Replayer; stopPropagation?: boolean} = {},\n  ) {\n    this.eventReplayer = eventReplayer;\n    this.dispatcher = new Dispatcher(\n      (eventInfoWrapper: EventInfoWrapper) => {\n        this.dispatchToHandler(eventInfoWrapper);\n      },\n      {\n        actionResolver,\n        eventReplayer: (eventInfoWrappers) => {\n          this.eventInfoWrapperQueue = eventInfoWrappers;\n          this.eventReplayer?.(this.eventInfoWrapperQueue, this);\n        },\n      },\n    );\n    this.stopPropagation = stopPropagation;\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   */\n  dispatch(eventInfo: EventInfo, isGlobalDispatch?: boolean): void {\n    this.dispatcher.dispatch(eventInfo);\n  }\n\n  /**\n   * Dispatches an `EventInfoWrapper`.\n   */\n  private dispatchToHandler(eventInfoWrapper: EventInfoWrapper) {\n    if (this.globalHandlers.size) {\n      const globalEventInfoWrapper = eventInfoWrapper.clone();\n\n      // In some cases, `populateAction` will rewrite `click` events to\n      // `clickonly`. Revert back to a regular click, otherwise we won't be able\n      // to execute global event handlers registered on click events.\n      if (globalEventInfoWrapper.getEventType() === EventType.CLICKONLY) {\n        globalEventInfoWrapper.setEventType(EventType.CLICK);\n      }\n      // Skip everything related to jsaction handlers, and execute the global\n      // handlers.\n      const event = globalEventInfoWrapper.getEvent();\n      const eventTypeHandlers = this.globalHandlers.get(globalEventInfoWrapper.getEventType());\n      let shouldPreventDefault = false;\n      if (eventTypeHandlers) {\n        for (const handler of eventTypeHandlers) {\n          if (handler(event) === false) {\n            shouldPreventDefault = true;\n          }\n        }\n      }\n      if (shouldPreventDefault) {\n        eventLib.preventDefault(event);\n      }\n    }\n\n    const action = eventInfoWrapper.getAction();\n    if (!action) {\n      return;\n    }\n\n    if (this.stopPropagation) {\n      stopPropagation(eventInfoWrapper);\n    }\n\n    let handler: EventInfoWrapperHandler | void = undefined;\n    if (this.getHandler) {\n      handler = this.getHandler(eventInfoWrapper);\n    }\n\n    if (!handler) {\n      handler = this.actions[action.name];\n    }\n\n    if (handler) {\n      handler(eventInfoWrapper);\n      return;\n    }\n\n    // No handler was found.\n    this.eventInfoWrapperQueue?.push(eventInfoWrapper);\n  }\n\n  /**\n   * Registers multiple methods all bound to the same object\n   * instance. This is a common case: an application module binds\n   * multiple of its methods under public names to the event contract of\n   * the application. So we provide a shortcut for it.\n   * Attempts to replay the queued events after registering the handlers.\n   *\n   * @param namespace The namespace of the jsaction name.\n   *\n   * @param instance The object to bind the methods to. If this is null, then\n   *     the functions are not bound, but directly added under the public names.\n   *\n   * @param methods A map from public name to functions that will be bound to\n   *     instance and registered as action under the public name. I.e. the\n   *     property names are the public names. The property values are the\n   *     methods of instance.\n   */\n  registerEventInfoHandlers<T>(\n    namespace: string,\n    instance: T | null,\n    methods: {[key: string]: EventInfoWrapperHandler},\n  ) {\n    for (const [name, method] of Object.entries(methods)) {\n      const handler = instance ? method.bind(instance) : method;\n      if (namespace) {\n        // Include a '.' separator between namespace name and action name.\n        // In the case that no namespace name is provided, the jsaction name\n        // consists of the action name only (no period).\n        const fullName = namespace + Char.NAMESPACE_ACTION_SEPARATOR + name;\n        this.actions[fullName] = handler;\n      } else {\n        this.actions[name] = handler;\n      }\n    }\n\n    this.scheduleEventReplay();\n  }\n\n  /**\n   * Unregisters an action.  Provided as an easy way to reverse the effects of\n   * registerHandlers.\n   * @param namespace The namespace of the jsaction name.\n   * @param name The action name to unbind.\n   */\n  unregisterHandler(namespace: string, name: string) {\n    const fullName = namespace ? namespace + Char.NAMESPACE_ACTION_SEPARATOR + name : name;\n    delete this.actions[fullName];\n  }\n\n  /** Registers a global event handler. */\n  registerGlobalHandler(eventType: string, handler: GlobalHandler) {\n    if (!this.globalHandlers.has(eventType)) {\n      this.globalHandlers.set(eventType, new Set<GlobalHandler>([handler]));\n    } else {\n      this.globalHandlers.get(eventType)!.add(handler);\n    }\n  }\n\n  /** Unregisters a global event handler. */\n  unregisterGlobalHandler(eventType: string, handler: GlobalHandler) {\n    if (this.globalHandlers.has(eventType)) {\n      this.globalHandlers.get(eventType)!.delete(handler);\n    }\n  }\n\n  /**\n   * Checks whether there is an action registered under the given\n   * name. This returns true if there is a namespace handler, even\n   * if it can not yet handle the event.\n   *\n   * @param name Action name.\n   * @return Whether the name is registered.\n   * @see #canDispatch\n   */\n  hasAction(name: string): boolean {\n    return this.actions.hasOwnProperty(name);\n  }\n\n  /**\n   * Whether this dispatcher can dispatch the event. This can be used by\n   * event replayer to check whether the dispatcher can replay an event.\n   */\n  canDispatch(eventInfoWrapper: EventInfoWrapper): boolean {\n    const action = eventInfoWrapper.getAction();\n    if (!action) {\n      return false;\n    }\n    return this.hasAction(action.name);\n  }\n\n  /**\n   * Sets the event replayer, enabling queued events to be replayed when actions\n   * are bound. To replay events, you must register the dispatcher to the\n   * contract after setting the `EventReplayer`. The event replayer takes as\n   * parameters the queue of events and the dispatcher (used to check whether\n   * actions have handlers registered and can be replayed). The event replayer\n   * is also responsible for dequeuing events.\n   *\n   * Example: An event replayer that replays only the last event.\n   *\n   *   const dispatcher = new Dispatcher();\n   *   // ...\n   *   dispatcher.setEventReplayer((queue, dispatcher) => {\n   *     const lastEventInfoWrapper = queue[queue.length -1];\n   *     if (dispatcher.canDispatch(lastEventInfoWrapper.getAction())) {\n   *       jsaction.replay.replayEvent(\n   *           lastEventInfoWrapper.getEvent(),\n   *           lastEventInfoWrapper.getTargetElement(),\n   *           lastEventInfoWrapper.getEventType(),\n   *       );\n   *       queue.length = 0;\n   *     }\n   *   });\n   *\n   * @param eventReplayer It allows elements to be replayed and dequeuing.\n   */\n  setEventReplayer(eventReplayer: Replayer) {\n    this.eventReplayer = eventReplayer;\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  private scheduleEventReplay() {\n    if (this.eventReplayScheduled || !this.eventReplayer || !this.eventInfoWrapperQueue?.length) {\n      return;\n    }\n    this.eventReplayScheduled = true;\n    Promise.resolve().then(() => {\n      this.eventReplayScheduled = false;\n      this.eventReplayer!(this.eventInfoWrapperQueue!, this);\n    });\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: LegacyDispatcher,\n) {\n  eventContract.ecrd((eventInfo: EventInfo) => {\n    dispatcher.dispatch(eventInfo);\n  }, Restriction.I_AM_THE_JSACTION_FRAMEWORK);\n}\n"]}

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

@@ -5,31 +5,34 @@
  * 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
  */
+/**
+ * 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.
+ */
+export const JSACTION = '__jsaction';
+/**
+ * The parsed value of the jsnamespace attribute is stored in this
+ * property on the DOM node.
+ */
+export const JSNAMESPACE = '__jsnamespace';
+/** The value of the oi attribute as a property, for faster access. */
+export const 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.
+ */
+export const OWNER = '__owner';
 /** 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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
+export const Property = {
+    JSACTION,
+    JSNAMESPACE,
+    OI,
+    OWNER,
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -6,28 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { EarlyEventContract } from './earlyeventcontract';
-import { EventContractContainer } from './event_contract_container';
-import { EventContract } from './eventcontract';
-/**
- * Provides a factory function for bootstrapping an event contract on a
- * specified object (by default, exposed on the `window`).
- * @param field The property on the object 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 earlyJsactionTracker The object that should receive the event contract.
- */
-export function bootstrapEventContract(field, container, appId, events, earlyJsactionTracker = window) {
-    if (!earlyJsactionTracker[field]) {
-        earlyJsactionTracker[field] = {};
-    }
-    const eventContract = new EventContract(new EventContractContainer(container));
-    earlyJsactionTracker[field][appId] = eventContract;
-    for (const ev of events) {
-        eventContract.addEvent(ev);
-    }
-}
 /**
  * Provides a factory function for bootstrapping an event contract on a
  * specified object (by default, exposed on the `window`).
@@ -45,7 +23,9 @@ export function bootstrapEarlyEventContract(field, container, appId, eventTypes,
     }
     earlyJsactionTracker[field][appId] = {};
     const eventContract = new EarlyEventContract(earlyJsactionTracker[field][appId], container);
-    eventContract.addEvents(eventTypes);
-    eventContract.addEvents(captureEventTypes, true);
+    if (eventTypes)
+        eventContract.addEvents(eventTypes);
+    if (captureEventTypes)
+        eventContract.addEvents(captureEventTypes, true);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -10,6 +10,6 @@
  */
 export var Restriction;
 (function (Restriction) {
-    Restriction[Restriction["I_AM_THE_JSACTION_FRAMEWORK"] = 1] = "I_AM_THE_JSACTION_FRAMEWORK";
+    Restriction[Restriction["I_AM_THE_JSACTION_FRAMEWORK"] = 0] = "I_AM_THE_JSACTION_FRAMEWORK";
 })(Restriction || (Restriction = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdHJpY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvc3JjL3Jlc3RyaWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOztHQUVHO0FBRUgsTUFBTSxDQUFOLElBQVksV0FFWDtBQUZELFdBQVksV0FBVztJQUNyQiwyRkFBK0IsQ0FBQTtBQUNqQyxDQUFDLEVBRlcsV0FBVyxLQUFYLFdBQVcsUUFFdEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBAZmlsZW92ZXJ2aWV3IEFuIGVudW0gdG8gY29udHJvbCB3aG8gY2FuIGNhbGwgY2VydGFpbiBqc2FjdGlvbiBBUElzLlxuICovXG5cbmV4cG9ydCBlbnVtIFJlc3RyaWN0aW9uIHtcbiAgSV9BTV9USEVfSlNBQ1RJT05fRlJBTUVXT1JLID0gMSxcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdHJpY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3ByaW1pdGl2ZXMvZXZlbnQtZGlzcGF0Y2gvc3JjL3Jlc3RyaWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOztHQUVHO0FBRUgsTUFBTSxDQUFOLElBQVksV0FFWDtBQUZELFdBQVksV0FBVztJQUNyQiwyRkFBMkIsQ0FBQTtBQUM3QixDQUFDLEVBRlcsV0FBVyxLQUFYLFdBQVcsUUFFdEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBAZmlsZW92ZXJ2aWV3IEFuIGVudW0gdG8gY29udHJvbCB3aG8gY2FuIGNhbGwgY2VydGFpbiBqc2FjdGlvbiBBUElzLlxuICovXG5cbmV4cG9ydCBlbnVtIFJlc3RyaWN0aW9uIHtcbiAgSV9BTV9USEVfSlNBQ1RJT05fRlJBTUVXT1JLLFxufVxuIl19

package/esm2022/src/application/create_application.mjs

@@ -5,7 +5,7 @@
  * 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 { internalProvideZoneChangeDetection } from '../change_detection/scheduling/ng_zone_scheduling';
+import { internalProvideZoneChangeDetection, PROVIDED_NG_ZONE, } from '../change_detection/scheduling/ng_zone_scheduling';
 import { ErrorHandler } from '../error_handler';
 import { RuntimeError } from '../errors';
 import { DEFAULT_LOCALE_ID } from '../i18n/localization';
@@ -19,6 +19,7 @@ import { EnvironmentNgModuleRefAdapter } from '../render3/ng_module_ref';
 import { NgZone } from '../zone/ng_zone';
 import { ApplicationInitStatus } from './application_init';
 import { _callAndReportToErrorHandler, ApplicationRef } from './application_ref';
+import { PROVIDED_ZONELESS } from '../change_detection/scheduling/zoneless_scheduling';
 /**
  * Internal create application API that implements the core application creation logic and optional
  * bootstrap logic.
@@ -53,8 +54,14 @@ export function internalCreateApplication(config) {
         return ngZone.run(() => {
             envInjector.resolveInjectorInitializers();
             const exceptionHandler = envInjector.get(ErrorHandler, null);
-            if ((typeof ngDevMode === 'undefined' || ngDevMode) && !exceptionHandler) {
-                throw new RuntimeError(402 /* RuntimeErrorCode.MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP */, 'No `ErrorHandler` found in the Dependency Injection tree.');
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                if (!exceptionHandler) {
+                    throw new RuntimeError(402 /* RuntimeErrorCode.MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP */, 'No `ErrorHandler` found in the Dependency Injection tree.');
+                }
+                if (envInjector.get(PROVIDED_ZONELESS) && envInjector.get(PROVIDED_NG_ZONE)) {
+                    throw new RuntimeError(408 /* RuntimeErrorCode.PROVIDED_BOTH_ZONE_AND_ZONELESS */, 'Invalid change detection configuration: ' +
+                        'provideZoneChangeDetection and provideExperimentalZonelessChangeDetection cannot be used together.');
+                }
             }
             let onErrorSubscription;
             ngZone.runOutsideAngular(() => {
@@ -96,4 +103,4 @@ export function internalCreateApplication(config) {
         return Promise.reject(e);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create_application.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/create_application.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 {Subscription} from 'rxjs';\n\nimport {internalProvideZoneChangeDetection} from '../change_detection/scheduling/ng_zone_scheduling';\nimport {EnvironmentProviders, Provider, StaticProvider} from '../di/interface/provider';\nimport {EnvironmentInjector} from '../di/r3_injector';\nimport {ErrorHandler} from '../error_handler';\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {DEFAULT_LOCALE_ID} from '../i18n/localization';\nimport {LOCALE_ID} from '../i18n/tokens';\nimport {ImagePerformanceWarning} from '../image_performance_warning';\nimport {Type} from '../interface/type';\nimport {createOrReusePlatformInjector} from '../platform/platform';\nimport {PLATFORM_DESTROY_LISTENERS} from '../platform/platform_ref';\nimport {assertStandaloneComponentType} from '../render3/errors';\nimport {setLocaleId} from '../render3/i18n/i18n_locale_id';\nimport {EnvironmentNgModuleRefAdapter} from '../render3/ng_module_ref';\nimport {NgZone} from '../zone/ng_zone';\n\nimport {ApplicationInitStatus} from './application_init';\nimport {_callAndReportToErrorHandler, ApplicationRef} from './application_ref';\n\n/**\n * Internal create application API that implements the core application creation logic and optional\n * bootstrap logic.\n *\n * Platforms (such as `platform-browser`) may require different set of application and platform\n * providers for an application to function correctly. As a result, platforms may use this function\n * internally and supply the necessary providers during the bootstrap, while exposing\n * platform-specific APIs as a part of their public API.\n *\n * @returns A promise that returns an `ApplicationRef` instance once resolved.\n */\n\nexport function internalCreateApplication(config: {\n  rootComponent?: Type<unknown>;\n  appProviders?: Array<Provider | EnvironmentProviders>;\n  platformProviders?: Provider[];\n}): Promise<ApplicationRef> {\n  try {\n    const {rootComponent, appProviders, platformProviders} = config;\n\n    if ((typeof ngDevMode === 'undefined' || ngDevMode) && rootComponent !== undefined) {\n      assertStandaloneComponentType(rootComponent);\n    }\n\n    const platformInjector = createOrReusePlatformInjector(platformProviders as StaticProvider[]);\n\n    // Create root application injector based on a set of providers configured at the platform\n    // bootstrap level as well as providers passed to the bootstrap call by a user.\n    const allAppProviders = [internalProvideZoneChangeDetection({}), ...(appProviders || [])];\n    const adapter = new EnvironmentNgModuleRefAdapter({\n      providers: allAppProviders,\n      parent: platformInjector as EnvironmentInjector,\n      debugName: typeof ngDevMode === 'undefined' || ngDevMode ? 'Environment Injector' : '',\n      // We skip environment initializers because we need to run them inside the NgZone, which\n      // happens after we get the NgZone instance from the Injector.\n      runEnvironmentInitializers: false,\n    });\n    const envInjector = adapter.injector;\n    const ngZone = envInjector.get(NgZone);\n\n    return ngZone.run(() => {\n      envInjector.resolveInjectorInitializers();\n      const exceptionHandler: ErrorHandler | null = envInjector.get(ErrorHandler, null);\n      if ((typeof ngDevMode === 'undefined' || ngDevMode) && !exceptionHandler) {\n        throw new RuntimeError(\n          RuntimeErrorCode.MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP,\n          'No `ErrorHandler` found in the Dependency Injection tree.',\n        );\n      }\n\n      let onErrorSubscription: Subscription;\n      ngZone.runOutsideAngular(() => {\n        onErrorSubscription = ngZone.onError.subscribe({\n          next: (error: any) => {\n            exceptionHandler!.handleError(error);\n          },\n        });\n      });\n\n      // If the whole platform is destroyed, invoke the `destroy` method\n      // for all bootstrapped applications as well.\n      const destroyListener = () => envInjector.destroy();\n      const onPlatformDestroyListeners = platformInjector.get(PLATFORM_DESTROY_LISTENERS);\n      onPlatformDestroyListeners.add(destroyListener);\n\n      envInjector.onDestroy(() => {\n        onErrorSubscription.unsubscribe();\n        onPlatformDestroyListeners.delete(destroyListener);\n      });\n\n      return _callAndReportToErrorHandler(exceptionHandler!, ngZone, () => {\n        const initStatus = envInjector.get(ApplicationInitStatus);\n        initStatus.runInitializers();\n\n        return initStatus.donePromise.then(() => {\n          const localeId = envInjector.get(LOCALE_ID, DEFAULT_LOCALE_ID);\n          setLocaleId(localeId || DEFAULT_LOCALE_ID);\n\n          const appRef = envInjector.get(ApplicationRef);\n          if (rootComponent !== undefined) {\n            appRef.bootstrap(rootComponent);\n          }\n          if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            const imagePerformanceService = envInjector.get(ImagePerformanceWarning);\n            imagePerformanceService.start();\n          }\n          return appRef;\n        });\n      });\n    });\n  } catch (e) {\n    return Promise.reject(e);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create_application.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/create_application.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 {Subscription} from 'rxjs';\n\nimport {\n  internalProvideZoneChangeDetection,\n  PROVIDED_NG_ZONE,\n} from '../change_detection/scheduling/ng_zone_scheduling';\nimport {EnvironmentProviders, Provider, StaticProvider} from '../di/interface/provider';\nimport {EnvironmentInjector} from '../di/r3_injector';\nimport {ErrorHandler} from '../error_handler';\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {DEFAULT_LOCALE_ID} from '../i18n/localization';\nimport {LOCALE_ID} from '../i18n/tokens';\nimport {ImagePerformanceWarning} from '../image_performance_warning';\nimport {Type} from '../interface/type';\nimport {createOrReusePlatformInjector} from '../platform/platform';\nimport {PLATFORM_DESTROY_LISTENERS} from '../platform/platform_ref';\nimport {assertStandaloneComponentType} from '../render3/errors';\nimport {setLocaleId} from '../render3/i18n/i18n_locale_id';\nimport {EnvironmentNgModuleRefAdapter} from '../render3/ng_module_ref';\nimport {NgZone} from '../zone/ng_zone';\n\nimport {ApplicationInitStatus} from './application_init';\nimport {_callAndReportToErrorHandler, ApplicationRef} from './application_ref';\nimport {PROVIDED_ZONELESS} from '../change_detection/scheduling/zoneless_scheduling';\n\n/**\n * Internal create application API that implements the core application creation logic and optional\n * bootstrap logic.\n *\n * Platforms (such as `platform-browser`) may require different set of application and platform\n * providers for an application to function correctly. As a result, platforms may use this function\n * internally and supply the necessary providers during the bootstrap, while exposing\n * platform-specific APIs as a part of their public API.\n *\n * @returns A promise that returns an `ApplicationRef` instance once resolved.\n */\n\nexport function internalCreateApplication(config: {\n  rootComponent?: Type<unknown>;\n  appProviders?: Array<Provider | EnvironmentProviders>;\n  platformProviders?: Provider[];\n}): Promise<ApplicationRef> {\n  try {\n    const {rootComponent, appProviders, platformProviders} = config;\n\n    if ((typeof ngDevMode === 'undefined' || ngDevMode) && rootComponent !== undefined) {\n      assertStandaloneComponentType(rootComponent);\n    }\n\n    const platformInjector = createOrReusePlatformInjector(platformProviders as StaticProvider[]);\n\n    // Create root application injector based on a set of providers configured at the platform\n    // bootstrap level as well as providers passed to the bootstrap call by a user.\n    const allAppProviders = [internalProvideZoneChangeDetection({}), ...(appProviders || [])];\n    const adapter = new EnvironmentNgModuleRefAdapter({\n      providers: allAppProviders,\n      parent: platformInjector as EnvironmentInjector,\n      debugName: typeof ngDevMode === 'undefined' || ngDevMode ? 'Environment Injector' : '',\n      // We skip environment initializers because we need to run them inside the NgZone, which\n      // happens after we get the NgZone instance from the Injector.\n      runEnvironmentInitializers: false,\n    });\n    const envInjector = adapter.injector;\n    const ngZone = envInjector.get(NgZone);\n\n    return ngZone.run(() => {\n      envInjector.resolveInjectorInitializers();\n      const exceptionHandler: ErrorHandler | null = envInjector.get(ErrorHandler, null);\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        if (!exceptionHandler) {\n          throw new RuntimeError(\n            RuntimeErrorCode.MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP,\n            'No `ErrorHandler` found in the Dependency Injection tree.',\n          );\n        }\n        if (envInjector.get(PROVIDED_ZONELESS) && envInjector.get(PROVIDED_NG_ZONE)) {\n          throw new RuntimeError(\n            RuntimeErrorCode.PROVIDED_BOTH_ZONE_AND_ZONELESS,\n            'Invalid change detection configuration: ' +\n              'provideZoneChangeDetection and provideExperimentalZonelessChangeDetection cannot be used together.',\n          );\n        }\n      }\n\n      let onErrorSubscription: Subscription;\n      ngZone.runOutsideAngular(() => {\n        onErrorSubscription = ngZone.onError.subscribe({\n          next: (error: any) => {\n            exceptionHandler!.handleError(error);\n          },\n        });\n      });\n\n      // If the whole platform is destroyed, invoke the `destroy` method\n      // for all bootstrapped applications as well.\n      const destroyListener = () => envInjector.destroy();\n      const onPlatformDestroyListeners = platformInjector.get(PLATFORM_DESTROY_LISTENERS);\n      onPlatformDestroyListeners.add(destroyListener);\n\n      envInjector.onDestroy(() => {\n        onErrorSubscription.unsubscribe();\n        onPlatformDestroyListeners.delete(destroyListener);\n      });\n\n      return _callAndReportToErrorHandler(exceptionHandler!, ngZone, () => {\n        const initStatus = envInjector.get(ApplicationInitStatus);\n        initStatus.runInitializers();\n\n        return initStatus.donePromise.then(() => {\n          const localeId = envInjector.get(LOCALE_ID, DEFAULT_LOCALE_ID);\n          setLocaleId(localeId || DEFAULT_LOCALE_ID);\n\n          const appRef = envInjector.get(ApplicationRef);\n          if (rootComponent !== undefined) {\n            appRef.bootstrap(rootComponent);\n          }\n          if (typeof ngDevMode === 'undefined' || ngDevMode) {\n            const imagePerformanceService = envInjector.get(ImagePerformanceWarning);\n            imagePerformanceService.start();\n          }\n          return appRef;\n        });\n      });\n    });\n  } catch (e) {\n    return Promise.reject(e);\n  }\n}\n"]}