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

package/index.d.ts

@@ -1,11 +1,12 @@
 /**
- * @license Angular v18.0.0-rc.0
+ * @license Angular v18.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 
 
 import { BehaviorSubject } from 'rxjs';
+import { EnvironmentProviders as EnvironmentProviders_2 } from '@angular/core';
 import { Observable } from 'rxjs';
 import { ReactiveNode } from '@angular/core/primitives/signals';
 import { SIGNAL } from '@angular/core/primitives/signals';
@@ -646,7 +647,6 @@ export declare class ApplicationRef {
     private readonly zonelessEnabled;
     private externalTestViews;
     private beforeRender;
-    private get allViews();
     /**
      * Indicates whether this instance was destroyed.
      */
@@ -1325,6 +1325,8 @@ export declare interface Component extends Directive {
     encapsulation?: ViewEncapsulation;
     /**
      * Overrides the default interpolation start and end delimiters (`{{` and `}}`).
+     *
+     * @deprecated use Angular's default interpolation delimiters instead.
      */
     interpolation?: [string, string];
     /**
@@ -8169,6 +8171,32 @@ declare type ProcessProvidersFunction = (providers: Provider[]) => Provider[];
  */
 declare type ProjectionSlots = (ɵCssSelectorList | '*')[];
 
+/**
+ * Used to periodically verify no expressions have changed after they were checked.
+ *
+ * @param options Used to configure when the check will execute.
+ *   - `interval` will periodically run exhaustive `checkNoChanges` on application views
+ *   - `useNgZoneOnStable` will us ZoneJS to determine when change detection might have run
+ *      in an application using ZoneJS to drive change detection. When the `NgZone.onStable` would
+ *      have emit, all views attached to the `ApplicationRef` are checked for changes.
+ *   - 'exhaustive' means that all views attached to `ApplicationRef` and all the descendants of those views will be
+ *     checked for changes (excluding those subtrees which are detached via `ChangeDetectorRef.detach()`).
+ *     This is useful because the check that runs after regular change detection does not work for components using `ChangeDetectionStrategy.OnPush`.
+ *     This check is will surface any existing errors hidden by `OnPush` components. By default, this check is exhaustive
+ *     and will always check all views, regardless of their "dirty" state and `ChangeDetectionStrategy`.
+ *
+ * When the `useNgZoneOnStable` option is `true`, this function will provide its own `NgZone` implementation and needs
+ * to come after any other `NgZone` provider, including `provideZoneChangeDetection()` and `provideExperimentalZonelessChangeDetection()`.
+ *
+ * @experimental
+ * @publicApi
+ */
+export declare function provideExperimentalCheckNoChangesForDebug(options: {
+    interval?: number;
+    useNgZoneOnStable?: boolean;
+    exhaustive?: boolean;
+}): EnvironmentProviders_2;
+
 /**
  * Provides change detection without ZoneJS for the application bootstrapped using
  * `bootstrapApplication`.
@@ -12288,7 +12316,6 @@ export declare const ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR: InjectionToken<ɵDefe
 /**
  * Options for configuring defer blocks behavior.
  * @publicApi
- * @developerPreview
  */
 export declare enum ɵDeferBlockBehavior {
     /**
@@ -12343,7 +12370,6 @@ export declare interface ɵDeferBlockDetails {
  * Describes the current state of this defer block instance.
  *
  * @publicApi
- * @developerPreview
  */
 export declare enum ɵDeferBlockState {
     /** The placeholder block content is rendered */
@@ -12828,6 +12854,11 @@ export declare interface ɵInternalEnvironmentProviders extends EnvironmentProvi
     ɵfromNgModule?: true;
 }
 
+export declare function ɵinternalProvideZoneChangeDetection({ ngZoneFactory, ignoreChangesOutsideZone, }: {
+    ngZoneFactory?: () => NgZone;
+    ignoreChangesOutsideZone?: boolean;
+}): StaticProvider[];
+
 /**
  * Internal token that specifies whether DOM reuse logic
  * during hydration is enabled.
@@ -13504,6 +13535,7 @@ export declare const enum ɵRuntimeErrorCode {
     ASYNC_INITIALIZERS_STILL_RUNNING = 405,
     APPLICATION_REF_ALREADY_DESTROYED = 406,
     RENDERER_NOT_FOUND = 407,
+    PROVIDED_BOTH_ZONE_AND_ZONELESS = 408,
     HYDRATION_NODE_MISMATCH = -500,
     HYDRATION_MISSING_SIBLINGS = -501,
     HYDRATION_MISSING_NODE = -502,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "18.0.0-rc.0",
+  "version": "18.0.0-rc.2",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",

package/primitives/event-dispatch/index.d.ts

@@ -1,11 +1,11 @@
 /**
- * @license Angular v18.0.0-rc.0
+ * @license Angular v18.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 
 
-declare namespace a11yClickLib {
+declare namespace a11yClick {
     export {
         updateEventInfoForA11yClick,
         preventDefaultForA11yClick,
@@ -24,18 +24,66 @@ declare interface ActionInfo {
 
 declare type ActionInfoInternal = [name: string, element: Element];
 
+/** Resolves actions for Events. */
+declare class ActionResolver {
+    private a11yClickSupport;
+    private readonly syntheticMouseEventSupport;
+    private updateEventInfoForA11yClick?;
+    private preventDefaultForA11yClick?;
+    private populateClickOnlyAction?;
+    constructor({ syntheticMouseEventSupport, }?: {
+        syntheticMouseEventSupport?: boolean;
+    });
+    resolve(eventInfo: eventInfoLib.EventInfo): void;
+    /**
+     * Searches for a jsaction that the DOM event maps to and creates an
+     * object containing event information used for dispatching by
+     * jsaction.Dispatcher. This method populates the `action` and `actionElement`
+     * fields of the EventInfo object passed in by finding the first
+     * jsaction attribute above the target Node of the event, and below
+     * the container Node, that specifies a jsaction for the event
+     * type. If no such jsaction is found, then action is undefined.
+     *
+     * @param eventInfo `EventInfo` to set `action` and `actionElement` if an
+     *    action is found on any `Element` in the path of the `Event`.
+     */
+    private populateAction;
+    /**
+     * Accesses the jsaction map on a node and retrieves the name of the
+     * action the given event is mapped to, if any. It parses the
+     * attribute value and stores it in a property on the node for
+     * subsequent retrieval without re-parsing and re-accessing the
+     * attribute.
+     *
+     * @param actionElement The DOM node to retrieve the jsaction map from.
+     * @param eventInfo `EventInfo` to set `action` and `actionElement` if an
+     *    action is found on the `actionElement`.
+     */
+    private populateActionOnElement;
+    /**
+     * Parses and caches an element's jsaction element into a map.
+     *
+     * This is primarily for internal use.
+     *
+     * @param actionElement The DOM node to retrieve the jsaction map from.
+     * @return Map from event to qualified name of the jsaction bound to it.
+     */
+    private parseActions;
+    addA11yClickSupport(updateEventInfoForA11yClick: typeof a11yClick.updateEventInfoForA11yClick, preventDefaultForA11yClick: typeof a11yClick.preventDefaultForA11yClick, populateClickOnlyAction: typeof a11yClick.populateClickOnlyAction): void;
+}
+
 /**
  * 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.
+ * 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 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.
+ * @param eventTypes An array of event names that should be listened to.
+ * @param captureEventTypes An array of event names that should be listened to with capture.
+ * @param earlyJsactionTracker The object that should receive the event contract.
  */
-export declare function bootstrapEventContract(field: string, container: Element, appId: string, events: string[], anyWindow?: any): EventContract;
+export declare function bootstrapEarlyEventContract(field: string, container: HTMLElement, appId: string, eventTypes?: string[], captureEventTypes?: string[], earlyJsactionTracker?: EventContractTracker<EarlyJsactionDataContainer>): void;
 
 /** Clones an `EventInfo` */
 declare function cloneEventInfo(eventInfo: EventInfo): EventInfo;
@@ -71,30 +119,23 @@ declare function createEventInfoFromParameters(eventType: string, event: Event,
  * jsaction.
  */
 export declare class Dispatcher {
-    private readonly getHandler?;
-    private readonly baseDispatcher;
-    /** Whether to stop propagation for an `EventInfo`. */
-    private readonly stopPropagation;
-    /**
-     * The actions that are registered for this Dispatcher instance.
-     * This should be the primary one used once migration off of registerHandlers
-     * is done.
-     */
-    private readonly actions;
-    /** A map of global event handlers, where each key is an event type. */
-    private readonly globalHandlers;
-    /** The event replayer. */
+    private readonly dispatchDelegate;
+    private actionResolver?;
+    /** The replayer function to be called when there are queued events. */
     private eventReplayer?;
-    /**
-     * 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?: ((eventInfoWrapper: EventInfoWrapper) => EventInfoWrapperHandler | void) | undefined, { stopPropagation, eventReplayer, }?: {
-        stopPropagation?: boolean;
+    /** Whether the event replay is scheduled. */
+    private eventReplayScheduled;
+    /** The queue of events. */
+    private readonly replayEventInfoWrappers;
+    /**
+     * Options are:
+     *   1. `eventReplayer`: When the event contract dispatches replay events
+     *      to the Dispatcher, the Dispatcher collects them and in the next tick
+     *      dispatches them to the `eventReplayer`.
+     * @param dispatchDelegate A function that should handle dispatching an `EventInfoWrapper` to handlers.
+     */
+    constructor(dispatchDelegate: (eventInfoWrapper: EventInfoWrapper) => void, { actionResolver, eventReplayer, }?: {
+        actionResolver?: ActionResolver;
         eventReplayer?: Replayer;
     });
     /**
@@ -116,92 +157,39 @@ export declare class Dispatcher {
      *
      * @param eventInfo The info for the event that triggered this call or the
      *     queue of events from EventContract.
-     * @param isGlobalDispatch If true, dispatches a global event instead of a
-     *     regular jsaction handler.
-     */
-    dispatch(eventInfo: EventInfo, isGlobalDispatch?: boolean): void;
-    /**
-     * Dispatches an `EventInfoWrapper`.
-     */
-    private dispatchToHandler;
-    /**
-     * 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<T>(namespace: string, instance: T | null, methods: {
-        [key: string]: EventInfoWrapperHandler;
-    }): void;
+    dispatch(eventInfo: EventInfo): void;
     /**
-     * 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.
+     * Schedules an `EventInfoWrapper` for replay. The replaying will happen in its own
+     * stack once the current flow cedes control. This is done to mimic
+     * browser event handling.
      */
-    unregisterHandler(namespace: string, name: string): void;
-    /** Registers a global event handler. */
-    registerGlobalHandler(eventType: string, handler: GlobalHandler): void;
-    /** Unregisters a global event handler. */
-    unregisterGlobalHandler(eventType: string, handler: GlobalHandler): void;
-    /**
-     * 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: string): boolean;
-    /**
-     * 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: EventInfoWrapper): boolean;
-    /**
-     * 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: Replayer): void;
+    private scheduleEventInfoWrapperReplay;
 }
 
 /** A function that is called to handle events captured by the EventContract. */
 declare type Dispatcher_2 = (eventInfo: eventInfoLib.EventInfo, globalDispatch?: boolean) => void;
 
+/**
+ * Defines the early jsaction data types.
+ */
+declare interface EarlyJsactionData {
+    /** List used to keep track of the early JSAction event types. */
+    et: string[];
+    /** List used to keep track of capture event types. */
+    etc: string[];
+    /** List used to keep track of the JSAction events if using earlyeventcontract. */
+    q: EventInfo[];
+    /** Early Jsaction handler. */
+    h: (event: Event) => void;
+    /** Container for listening to events. */
+    c: HTMLElement;
+}
+
+export declare interface EarlyJsactionDataContainer {
+    _ejsa?: EarlyJsactionData;
+}
+
 /**
  * EventContract intercepts events in the bubbling phase at the
  * boundary of a container element, and maps them to generic actions
@@ -217,12 +205,11 @@ declare type Dispatcher_2 = (eventInfo: eventInfoLib.EventInfo, globalDispatch?:
  * be delay loaded in a generic way.
  */
 export declare class EventContract implements UnrenamedEventContract {
-    static CUSTOM_EVENT_SUPPORT: boolean;
-    static STOP_PROPAGATION: boolean;
+    private readonly useActionResolver;
     static A11Y_CLICK_SUPPORT: boolean;
     static MOUSE_SPECIAL_SUPPORT: boolean;
-    static JSNAMESPACE_SUPPORT: boolean;
     private containerManager;
+    private readonly actionResolver?;
     /**
      * The DOM events which this contract covers. Used to prevent double
      * registration of event types. The value of the map is the
@@ -245,48 +232,15 @@ export declare class EventContract implements UnrenamedEventContract {
      * as soon as the `Dispatcher` is registered.
      */
     private queuedEventInfos;
-    /** Whether a11y click support has been loaded or not. */
-    private hasA11yClickSupport;
     /** Whether to add an a11y click listener. */
     private addA11yClickListener;
-    private updateEventInfoForA11yClick?;
-    private preventDefaultForA11yClick?;
-    private populateClickOnlyAction?;
-    ecaacs?: (updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick, preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick, populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction) => void;
-    constructor(containerManager: EventContractContainerManager);
+    ecaacs?: (updateEventInfoForA11yClick: typeof a11yClick.updateEventInfoForA11yClick, preventDefaultForA11yClick: typeof a11yClick.preventDefaultForA11yClick, populateClickOnlyAction: typeof a11yClick.populateClickOnlyAction) => void;
+    constructor(containerManager: EventContractContainerManager, useActionResolver?: boolean);
     private handleEvent;
     /**
      * Handle an `EventInfo`.
      */
     private handleEventInfo;
-    /**
-     * Searches for a jsaction that the DOM event maps to and creates an
-     * object containing event information used for dispatching by
-     * jsaction.Dispatcher. This method populates the `action` and `actionElement`
-     * fields of the EventInfo object passed in by finding the first
-     * jsaction attribute above the target Node of the event, and below
-     * the container Node, that specifies a jsaction for the event
-     * type. If no such jsaction is found, then action is undefined.
-     *
-     * @param eventInfo `EventInfo` to set `action` and `actionElement` if an
-     *    action is found on any `Element` in the path of the `Event`.
-     */
-    private populateAction;
-    /**
-     * Accesses the jsaction map on a node and retrieves the name of the
-     * action the given event is mapped to, if any. It parses the
-     * attribute value and stores it in a property on the node for
-     * subsequent retrieval without re-parsing and re-accessing the
-     * attribute. In order to fully qualify jsaction names using a
-     * namespace, the DOM is searched starting at the current node and
-     * going through ancestor nodes until a jsnamespace attribute is
-     * found.
-     *
-     * @param actionElement The DOM node to retrieve the jsaction map from.
-     * @param eventInfo `EventInfo` to set `action` and `actionElement` if an
-     *    action is found on the `actionElement`.
-     */
-    private populateActionOnElement;
     /**
      * Enables jsaction handlers to be called for the event type given by
      * name.
@@ -306,7 +260,7 @@ export declare class EventContract implements UnrenamedEventContract {
      * in the provided event contract. Once all the events are replayed, it cleans
      * up the early contract.
      */
-    replayEarlyEvents(): void;
+    replayEarlyEvents(earlyJsactionContainer?: EarlyJsactionDataContainer): void;
     /**
      * Returns all JSAction event types that have been registered for a given
      * browser event type.
@@ -393,6 +347,12 @@ declare interface EventContractContainerManager {
     cleanUp(): void;
 }
 
+export declare type EventContractTracker<T> = {
+    [key: string]: {
+        [appId: string]: T;
+    };
+};
+
 /**
  * A function that handles an event dispatched from the browser.
  *
@@ -503,11 +463,6 @@ export declare class EventInfoWrapper {
     clone(): EventInfoWrapper;
 }
 
-/**
- * A handler is dispatched to during normal handling.
- */
-declare type EventInfoWrapperHandler = (eventInfoWrapper: EventInfoWrapper) => void;
-
 /** Added for readability when accessing stable property names. */
 declare function getA11yClickKey(eventInfo: EventInfo): boolean | undefined;
 
@@ -538,12 +493,6 @@ declare function getTargetElement(eventInfo: EventInfo): Element;
 /** Added for readability when accessing stable property names. */
 declare function getTimestamp(eventInfo: EventInfo): number;
 
-/**
- * A global handler is dispatched to before normal handler dispatch. Returning
- * false will `preventDefault` on the event.
- */
-declare type GlobalHandler = (event: Event) => boolean | void;
-
 /**
  * Sets the `action` to `clickonly` for a click event that is not an a11y click
  * and if there is not already a click action.
@@ -568,14 +517,14 @@ export declare function registerDispatcher(eventContract: UnrenamedEventContract
  * A replayer is a function that is called when there are queued events,
  * either from the `EventContract` or when there are no detected handlers.
  */
-declare type Replayer = (eventInfoWrappers: EventInfoWrapper[], dispatcher: Dispatcher) => void;
+declare type Replayer = (eventInfoWrappers: EventInfoWrapper[]) => void;
 
 
 /**
  * @fileoverview An enum to control who can call certain jsaction APIs.
  */
 declare enum Restriction {
-    I_AM_THE_JSACTION_FRAMEWORK = 1
+    I_AM_THE_JSACTION_FRAMEWORK = 0
 }
 
 /** Added for readability when accessing stable property names. */
@@ -607,7 +556,7 @@ declare function setTimestamp(eventInfo: EventInfo, timestamp: number): void;
  */
 declare interface UnrenamedEventContract {
     ecrd(dispatcher: Dispatcher_2, restriction: Restriction): void;
-    ecaacs?: (updateEventInfoForA11yClick: typeof a11yClickLib.updateEventInfoForA11yClick, preventDefaultForA11yClick: typeof a11yClickLib.preventDefaultForA11yClick, populateClickOnlyAction: typeof a11yClickLib.populateClickOnlyAction) => void;
+    ecaacs?: (updateEventInfoForA11yClick: typeof a11yClick.updateEventInfoForA11yClick, preventDefaultForA11yClick: typeof a11yClick.preventDefaultForA11yClick, populateClickOnlyAction: typeof a11yClick.populateClickOnlyAction) => void;
 }
 
 /** Added for readability when accessing stable property names. */

package/primitives/signals/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v18.0.0-rc.0
+ * @license Angular v18.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */

package/rxjs-interop/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v18.0.0-rc.0
+ * @license Angular v18.0.0-rc.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */