@angular/core 18.1.0-next.1 → 18.1.0-next.2

package/fesm2022/primitives/event-dispatch.mjs

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

package/fesm2022/primitives/signals.mjs

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

package/fesm2022/rxjs-interop.mjs

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

package/fesm2022/testing.mjs

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

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v18.1.0-next.1
+ * @license Angular v18.1.0-next.2
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -83,19 +83,105 @@ export declare interface AfterContentInit {
 }
 
 /**
- * Register a callback to be invoked the next time the application
- * finishes rendering.
+ * Register callbacks to be invoked the next time the application finishes rendering, during the
+ * specified phases. The available phases are:
+ * - `earlyRead`
+ *   Use this phase to **read** from the DOM before a subsequent `write` callback, for example to
+ *   perform custom layout that the browser doesn't natively support. Prefer the `read` phase if
+ *   reading can wait until after the write phase. **Never** write to the DOM in this phase.
+ * - `write`
+ *    Use this phase to **write** to the DOM. **Never** read from the DOM in this phase.
+ * - `mixedReadWrite`
+ *    Use this phase to read from and write to the DOM simultaneously. **Never** use this phase if
+ *    it is possible to divide the work among the other phases instead.
+ * - `read`
+ *    Use this phase to **read** from the DOM. **Never** write to the DOM in this phase.
  *
  * <div class="alert is-critical">
  *
- * You should always explicitly specify a non-default [phase](api/core/AfterRenderPhase), or you
- * risk significant performance degradation.
+ * You should prefer using the `read` and `write` phases over the `earlyRead` and `mixedReadWrite`
+ * phases when possible, to avoid performance degradation.
+ *
+ * </div>
+ *
+ * Note that:
+ * - Callbacks run in the following phase order *once, after the next render*:
+ *   1. `earlyRead`
+ *   2. `write`
+ *   3. `mixedReadWrite`
+ *   4. `read`
+ * - Callbacks in the same phase run in the order they are registered.
+ * - Callbacks run on browser platforms only, they will not run on the server.
+ *
+ * The first phase callback to run as part of this spec will receive no parameters. Each
+ * subsequent phase callback in this spec will receive the return value of the previously run
+ * phase callback as a parameter. This can be used to coordinate work across multiple phases.
+ *
+ * Angular is unable to verify or enforce that phases are used correctly, and instead
+ * relies on each developer to follow the guidelines documented for each value and
+ * carefully choose the appropriate one, refactoring their code if necessary. By doing
+ * so, Angular is better able to minimize the performance degradation associated with
+ * manual DOM access, ensuring the best experience for the end users of your application
+ * or library.
+ *
+ * <div class="alert is-important">
+ *
+ * Components are not guaranteed to be [hydrated](guide/hydration) before the callback runs.
+ * You must use caution when directly reading or writing the DOM and layout.
+ *
+ * </div>
+ *
+ * @param spec The callback functions to register
+ *
+ * @usageNotes
+ *
+ * Use `afterNextRender` to read or write the DOM once,
+ * for example to initialize a non-Angular library.
+ *
+ * ### Example
+ * ```ts
+ * @Component({
+ *   selector: 'my-chart-cmp',
+ *   template: `<div #chart>{{ ... }}</div>`,
+ * })
+ * export class MyChartCmp {
+ *   @ViewChild('chart') chartRef: ElementRef;
+ *   chart: MyChart|null;
+ *
+ *   constructor() {
+ *     afterNextRender({
+ *       write: () => {
+ *         this.chart = new MyChart(this.chartRef.nativeElement);
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare function afterNextRender<E = never, W = never, M = never>(spec: {
+    earlyRead?: () => E;
+    write?: (...args: ɵFirstAvailable<[E]>) => W;
+    mixedReadWrite?: (...args: ɵFirstAvailable<[W, E]>) => M;
+    read?: (...args: ɵFirstAvailable<[M, W, E]>) => void;
+}, opts?: Omit<AfterRenderOptions, 'phase'>): AfterRenderRef;
+
+/**
+ * Register a callback to be invoked the next time the application finishes rendering, during the
+ * `mixedReadWrite` phase.
+ *
+ * <div class="alert is-critical">
+ *
+ * You should prefer specifying an explicit phase for the callback instead, or you risk significant
+ * performance degradation.
  *
  * </div>
  *
  * Note that the callback will run
  * - in the order it was registered
  * - on browser platforms only
+ * - during the `mixedReadWrite` phase
  *
  * <div class="alert is-important">
  *
@@ -122,9 +208,11 @@ export declare interface AfterContentInit {
  *   chart: MyChart|null;
  *
  *   constructor() {
- *     afterNextRender(() => {
- *       this.chart = new MyChart(this.chartRef.nativeElement);
- *     }, {phase: AfterRenderPhase.Write});
+ *     afterNextRender({
+ *       write: () => {
+ *         this.chart = new MyChart(this.chartRef.nativeElement);
+ *       }
+ *     });
  *   }
  * }
  * ```
@@ -134,13 +222,96 @@ export declare interface AfterContentInit {
 export declare function afterNextRender(callback: VoidFunction, options?: AfterRenderOptions): AfterRenderRef;
 
 /**
- * Register a callback to be invoked each time the application
- * finishes rendering.
+ * Register callbacks to be invoked each time the application finishes rendering, during the
+ * specified phases. The available phases are:
+ * - `earlyRead`
+ *   Use this phase to **read** from the DOM before a subsequent `write` callback, for example to
+ *   perform custom layout that the browser doesn't natively support. Prefer the `read` phase if
+ *   reading can wait until after the write phase. **Never** write to the DOM in this phase.
+ * - `write`
+ *    Use this phase to **write** to the DOM. **Never** read from the DOM in this phase.
+ * - `mixedReadWrite`
+ *    Use this phase to read from and write to the DOM simultaneously. **Never** use this phase if
+ *    it is possible to divide the work among the other phases instead.
+ * - `read`
+ *    Use this phase to **read** from the DOM. **Never** write to the DOM in this phase.
  *
  * <div class="alert is-critical">
  *
- * You should always explicitly specify a non-default [phase](api/core/AfterRenderPhase), or you
- * risk significant performance degradation.
+ * You should prefer using the `read` and `write` phases over the `earlyRead` and `mixedReadWrite`
+ * phases when possible, to avoid performance degradation.
+ *
+ * </div>
+ *
+ * Note that:
+ * - Callbacks run in the following phase order *after each render*:
+ *   1. `earlyRead`
+ *   2. `write`
+ *   3. `mixedReadWrite`
+ *   4. `read`
+ * - Callbacks in the same phase run in the order they are registered.
+ * - Callbacks run on browser platforms only, they will not run on the server.
+ *
+ * The first phase callback to run as part of this spec will receive no parameters. Each
+ * subsequent phase callback in this spec will receive the return value of the previously run
+ * phase callback as a parameter. This can be used to coordinate work across multiple phases.
+ *
+ * Angular is unable to verify or enforce that phases are used correctly, and instead
+ * relies on each developer to follow the guidelines documented for each value and
+ * carefully choose the appropriate one, refactoring their code if necessary. By doing
+ * so, Angular is better able to minimize the performance degradation associated with
+ * manual DOM access, ensuring the best experience for the end users of your application
+ * or library.
+ *
+ * <div class="alert is-important">
+ *
+ * Components are not guaranteed to be [hydrated](guide/hydration) before the callback runs.
+ * You must use caution when directly reading or writing the DOM and layout.
+ *
+ * </div>
+ *
+ * @param spec The callback functions to register
+ *
+ * @usageNotes
+ *
+ * Use `afterRender` to read or write the DOM after each render.
+ *
+ * ### Example
+ * ```ts
+ * @Component({
+ *   selector: 'my-cmp',
+ *   template: `<span #content>{{ ... }}</span>`,
+ * })
+ * export class MyComponent {
+ *   @ViewChild('content') contentRef: ElementRef;
+ *
+ *   constructor() {
+ *     afterRender({
+ *       read: () => {
+ *         console.log('content height: ' + this.contentRef.nativeElement.scrollHeight);
+ *       }
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare function afterRender<E = never, W = never, M = never>(spec: {
+    earlyRead?: () => E;
+    write?: (...args: ɵFirstAvailable<[E]>) => W;
+    mixedReadWrite?: (...args: ɵFirstAvailable<[W, E]>) => M;
+    read?: (...args: ɵFirstAvailable<[M, W, E]>) => void;
+}, opts?: Omit<AfterRenderOptions, 'phase'>): AfterRenderRef;
+
+/**
+ * Register a callback to be invoked each time the application finishes rendering, during the
+ * `mixedReadWrite` phase.
+ *
+ * <div class="alert is-critical">
+ *
+ * You should prefer specifying an explicit phase for the callback instead, or you risk significant
+ * performance degradation.
  *
  * </div>
  *
@@ -148,6 +319,7 @@ export declare function afterNextRender(callback: VoidFunction, options?: AfterR
  * - in the order it was registered
  * - once per render
  * - on browser platforms only
+ * - during the `mixedReadWrite` phase
  *
  * <div class="alert is-important">
  *
@@ -172,9 +344,11 @@ export declare function afterNextRender(callback: VoidFunction, options?: AfterR
  *   @ViewChild('content') contentRef: ElementRef;
  *
  *   constructor() {
- *     afterRender(() => {
- *       console.log('content height: ' + this.contentRef.nativeElement.scrollHeight);
- *     }, {phase: AfterRenderPhase.Read});
+ *     afterRender({
+ *       read: () => {
+ *         console.log('content height: ' + this.contentRef.nativeElement.scrollHeight);
+ *       }
+ *     });
  *   }
  * }
  * ```
@@ -204,6 +378,9 @@ export declare interface AfterRenderOptions {
      * phase instead. See `AfterRenderPhase` for more information.
      *
      * </div>
+     *
+     * @deprecated Specify the phase for your callback to run in by passing a spec-object as the first
+     *   parameter to `afterRender` or `afterNextRender` insetad of a function.
      */
     phase?: AfterRenderPhase;
 }
@@ -226,14 +403,16 @@ export declare interface AfterRenderOptions {
  * manual DOM access, ensuring the best experience for the end users of your application
  * or library.
  *
- * @developerPreview
+ * @deprecated Specify the phase for your callback to run in by passing a spec-object as the first
+ *   parameter to `afterRender` or `afterNextRender` insetad of a function.
  */
 export declare enum AfterRenderPhase {
     /**
      * Use `AfterRenderPhase.EarlyRead` for callbacks that only need to **read** from the
      * DOM before a subsequent `AfterRenderPhase.Write` callback, for example to perform
-     * custom layout that the browser doesn't natively support. **Never** use this phase
-     * for callbacks that can write to the DOM or when `AfterRenderPhase.Read` is adequate.
+     * custom layout that the browser doesn't natively support. Prefer the
+     * `AfterRenderPhase.EarlyRead` phase if reading can wait until after the write phase.
+     * **Never** write to the DOM in this phase.
      *
      * <div class="alert is-important">
      *
@@ -245,25 +424,25 @@ export declare enum AfterRenderPhase {
     EarlyRead = 0,
     /**
      * Use `AfterRenderPhase.Write` for callbacks that only **write** to the DOM. **Never**
-     * use this phase for callbacks that can read from the DOM.
+     * read from the DOM in this phase.
      */
     Write = 1,
     /**
      * Use `AfterRenderPhase.MixedReadWrite` for callbacks that read from or write to the
-     * DOM, that haven't been refactored to use a different phase. **Never** use this phase
-     * for callbacks that can use a different phase instead.
+     * DOM, that haven't been refactored to use a different phase. **Never** use this phase if
+     * it is possible to divide the work among the other phases instead.
      *
      * <div class="alert is-critical">
      *
      * Using this value can **significantly** degrade performance.
-     * Instead, prefer refactoring into multiple callbacks using a more specific phase.
+     * Instead, prefer dividing work into the appropriate phase callbacks.
      *
      * </div>
      */
     MixedReadWrite = 2,
     /**
      * Use `AfterRenderPhase.Read` for callbacks that only **read** from the DOM. **Never**
-     * use this phase for callbacks that can write to the DOM.
+     * write to the DOM in this phase.
      */
     Read = 3
 }
@@ -3964,8 +4143,8 @@ export declare class ExperimentalPendingTasks {
      * @returns A cleanup function that removes a task when called.
      */
     add(): () => void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ExperimentalPendingTasks, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ExperimentalPendingTasks>;
+    /** @nocollapse */
+    static ɵprov: unknown;
 }
 
 /**
@@ -8675,7 +8854,6 @@ declare const REACTIVE_TEMPLATE_CONSUMER = 23;
 
 declare interface ReactiveLViewConsumer extends ReactiveNode {
     lView: LView | null;
-    slot: typeof REACTIVE_TEMPLATE_CONSUMER;
 }
 
 /**
@@ -12624,6 +12802,12 @@ export declare const enum ɵExtraLocaleDataIndex {
  */
 export declare function ɵfindLocaleData(locale: string): any;
 
+/**
+ * An argument list containing the first non-never type in the given type array, or an empty
+ * argument list if there are no non-never types in the type array.
+ */
+export declare type ɵFirstAvailable<T extends unknown[]> = T extends [infer H, ...infer R] ? [H] extends [never] ? ɵFirstAvailable<R> : [H] : [];
+
 /**
  * Loops over queued module definitions, if a given module definition has all of its
  * declarations resolved, it dequeues that module definition and sets the scope on
@@ -13184,8 +13368,8 @@ export declare class ɵPendingTasks implements OnDestroy {
     add(): number;
     remove(taskId: number): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ɵPendingTasks, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ɵPendingTasks>;
+    /** @nocollapse */
+    static ɵprov: unknown;
 }
 
 

package/package.json

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

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

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

package/primitives/signals/index.d.ts

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

package/rxjs-interop/index.d.ts

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