@angular/core 16.2.3 → 16.2.5

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.2.3
+ * @license Angular v16.2.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -164,16 +164,6 @@ export declare function afterNextRender(callback: VoidFunction, options?: AfterR
  */
 export declare function afterRender(callback: VoidFunction, options?: AfterRenderOptions): AfterRenderRef;
 
-/**
- * A wrapper around a function to be used as an after render callback.
- * @private
- */
-declare class AfterRenderCallback {
-    private callback;
-    constructor(callback: VoidFunction);
-    invoke(): void;
-}
-
 /**
  * Options passed to `afterRender` and `afterNextRender`.
  *
@@ -1928,17 +1918,18 @@ declare const CONTEXT = 8;
  * const applicationRef = await bootstrapApplication(RootComponent);
  *
  * // Locate a DOM node that would be used as a host.
- * const host = document.getElementById('hello-component-host');
+ * const hostElement = document.getElementById('hello-component-host');
  *
  * // Get an `EnvironmentInjector` instance from the `ApplicationRef`.
  * const environmentInjector = applicationRef.injector;
  *
  * // We can now create a `ComponentRef` instance.
- * const componentRef = createComponent(HelloComponent, {host, environmentInjector});
+ * const componentRef = createComponent(HelloComponent, {hostElement, environmentInjector});
  *
  * // Last step is to register the newly created ref using the `ApplicationRef` instance
  * // to include the component view into change detection cycles.
  * applicationRef.attachView(componentRef.hostView);
+ * componentRef.changeDetectorRef.detectChanges();
  * ```
  *
  * @param component Component class reference.
@@ -7225,116 +7216,94 @@ declare const REACTIVE_HOST_BINDING_CONSUMER = 24;
 
 declare const REACTIVE_TEMPLATE_CONSUMER = 23;
 
-declare class ReactiveLViewConsumer extends ReactiveNode {
-    protected consumerAllowSignalWrites: boolean;
-    private _lView;
-    set lView(lView: LView);
-    protected onConsumerDependencyMayHaveChanged(): void;
-    protected onProducerUpdateValueVersion(): void;
-    get hasReadASignal(): boolean;
-    runInContext(fn: HostBindingsFunction<unknown> | ComponentTemplate<unknown>, rf: ɵRenderFlags, ctx: unknown): void;
-    destroy(): void;
+declare interface ReactiveLViewConsumer extends ReactiveNode {
+    lView: LView | null;
 }
 
 /**
- * A node in the reactive graph.
- *
- * Nodes can be producers of reactive values, consumers of other reactive values, or both.
- *
- * Producers are nodes that produce values, and can be depended upon by consumer nodes.
- *
- * Producers expose a monotonic `valueVersion` counter, and are responsible for incrementing this
- * version when their value semantically changes. Some producers may produce their values lazily and
- * thus at times need to be polled for potential updates to their value (and by extension their
- * `valueVersion`). This is accomplished via the `onProducerUpdateValueVersion` method for
- * implemented by producers, which should perform whatever calculations are necessary to ensure
- * `valueVersion` is up to date.
- *
- * Consumers are nodes that depend on the values of producers and are notified when those values
- * might have changed.
+ * A producer and/or consumer which participates in the reactive graph.
  *
- * Consumers do not wrap the reads they consume themselves, but rather can be set as the active
- * reader via `setActiveConsumer`. Reads of producers that happen while a consumer is active will
- * result in those producers being added as dependencies of that consumer node.
+ * Producer `ReactiveNode`s which are accessed when a consumer `ReactiveNode` is the
+ * `activeConsumer` are tracked as dependencies of that consumer.
  *
- * The set of dependencies of a consumer is dynamic. Implementers expose a monotonically increasing
- * `trackingVersion` counter, which increments whenever the consumer is about to re-run any reactive
- * reads it needs and establish a new set of dependencies as a result.
+ * Certain consumers are also tracked as "live" consumers and create edges in the other direction,
+ * from producer to consumer. These edges are used to propagate change notifications when a
+ * producer's value is updated.
  *
- * Producers store the last `trackingVersion` they've seen from `Consumer`s which have read them.
- * This allows a producer to identify whether its record of the dependency is current or stale, by
- * comparing the consumer's `trackingVersion` to the version at which the dependency was
- * last observed.
+ * A `ReactiveNode` may be both a producer and consumer.
  */
-declare abstract class ReactiveNode {
-    private readonly id;
-    /**
-     * A cached weak reference to this node, which will be used in `ReactiveEdge`s.
-     */
-    private readonly ref;
-    /**
-     * Edges to producers on which this node depends (in its consumer capacity).
-     */
-    private readonly producers;
-    /**
-     * Edges to consumers on which this node depends (in its producer capacity).
-     */
-    private readonly consumers;
-    /**
-     * Monotonically increasing counter representing a version of this `Consumer`'s
-     * dependencies.
-     */
-    protected trackingVersion: number;
+declare interface ReactiveNode {
     /**
-     * Monotonically increasing counter which increases when the value of this `Producer`
-     * semantically changes.
+     * Version of the value that this node produces.
+     *
+     * This is incremented whenever a new value is produced by this node which is not equal to the
+     * previous value (by whatever definition of equality is in use).
      */
-    protected valueVersion: number;
+    version: Version_2;
     /**
-     * Whether signal writes should be allowed while this `ReactiveNode` is the current consumer.
+     * Whether this node (in its consumer capacity) is dirty.
+     *
+     * Only live consumers become dirty, when receiving a change notification from a dependency
+     * producer.
      */
-    protected abstract readonly consumerAllowSignalWrites: boolean;
+    dirty: boolean;
     /**
-     * Called for consumers whenever one of their dependencies notifies that it might have a new
-     * value.
+     * Producers which are dependencies of this consumer.
+     *
+     * Uses the same indices as the `producerLastReadVersion` and `producerIndexOfThis` arrays.
      */
-    protected abstract onConsumerDependencyMayHaveChanged(): void;
+    producerNode: ReactiveNode[] | undefined;
     /**
-     * Called for producers when a dependent consumer is checking if the producer's value has actually
-     * changed.
+     * `Version` of the value last read by a given producer.
+     *
+     * Uses the same indices as the `producerNode` and `producerIndexOfThis` arrays.
      */
-    protected abstract onProducerUpdateValueVersion(): void;
+    producerLastReadVersion: Version_2[] | undefined;
     /**
-     * Polls dependencies of a consumer to determine if they have actually changed.
+     * Index of `this` (consumer) in each producer's `liveConsumers` array.
      *
-     * If this returns `false`, then even though the consumer may have previously been notified of a
-     * change, the values of its dependencies have not actually changed and the consumer should not
-     * rerun any reactions.
+     * This value is only meaningful if this node is live (`liveConsumers.length > 0`). Otherwise
+     * these indices are stale.
+     *
+     * Uses the same indices as the `producerNode` and `producerLastReadVersion` arrays.
      */
-    protected consumerPollProducersForChange(): boolean;
+    producerIndexOfThis: number[] | undefined;
     /**
-     * Notify all consumers of this producer that its value may have changed.
+     * Index into the producer arrays that the next dependency of this node as a consumer will use.
+     *
+     * This index is zeroed before this node as a consumer begins executing. When a producer is read,
+     * it gets inserted into the producers arrays at this index. There may be an existing dependency
+     * in this location which may or may not match the incoming producer, depending on whether the
+     * same producers were read in the same order as the last computation.
      */
-    protected producerMayHaveChanged(): void;
+    nextProducerIndex: number;
     /**
-     * Mark that this producer node has been accessed in the current reactive context.
+     * Array of consumers of this producer that are "live" (they require push notifications).
+     *
+     * `liveConsumerNode.length` is effectively our reference count for this node.
      */
-    protected producerAccessed(): void;
+    liveConsumerNode: ReactiveNode[] | undefined;
     /**
-     * Whether this consumer currently has any producers registered.
+     * Index of `this` (producer) in each consumer's `producerNode` array.
+     *
+     * Uses the same indices as the `liveConsumerNode` array.
      */
-    protected get hasProducers(): boolean;
+    liveConsumerIndexOfThis: number[] | undefined;
     /**
-     * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
-     * based on the current consumer context.
+     * Whether writes to signals are allowed when this consumer is the `activeConsumer`.
+     *
+     * This is used to enforce guardrails such as preventing writes to writable signals in the
+     * computation function of computed signals, which is supposed to be pure.
      */
-    protected get producerUpdatesAllowed(): boolean;
+    consumerAllowSignalWrites: boolean;
+    readonly consumerIsAlwaysLive: boolean;
     /**
-     * Checks if a `Producer` has a current value which is different than the value
-     * last seen at a specific version by a `Consumer` which recorded a dependency on
-     * this `Producer`.
+     * Tracks whether producers need to recompute their value independently of the reactive graph (for
+     * example, if no initial value has been computed).
      */
-    private producerPollStatus;
+    producerMustRecompute(node: unknown): boolean;
+    producerRecomputeValue(node: unknown): void;
+    consumerMarkedDirty(node: unknown): void;
 }
 
 /**
@@ -9395,17 +9364,17 @@ export declare const TRANSLATIONS_FORMAT: InjectionToken<string>;
  * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/trusted-types/index.d.ts
  * but restricted to the API surface used within Angular.
  */
-declare interface TrustedHTML {
+declare type TrustedHTML = string & {
     __brand__: 'TrustedHTML';
-}
+};
 
-declare interface TrustedScript {
+declare type TrustedScript = string & {
     __brand__: 'TrustedScript';
-}
+};
 
-declare interface TrustedScriptURL {
+declare type TrustedScriptURL = string & {
     __brand__: 'TrustedScriptURL';
-}
+};
 
 /**
  * Value stored in the `TData` which is needed to re-concatenate the styling.
@@ -9454,9 +9423,9 @@ declare type TStylingKeyPrimitive = string | null | false;
  *
  * NOTE: `0` has special significance and represents `null` as in no additional pointer.
  */
-declare interface TStylingRange {
+declare type TStylingRange = number & {
     __brand__: 'TStylingRange';
-}
+};
 
 /**
  * Store the static values for the styling binding.
@@ -9939,6 +9908,10 @@ export declare class Version {
     constructor(full: string);
 }
 
+declare type Version_2 = number & {
+    __brand: 'Version';
+};
+
 declare const VIEW_REFS = 8;
 
 /**
@@ -10112,6 +10085,40 @@ export declare interface ViewChildrenDecorator {
  * A view container instance can contain other view containers,
  * creating a [view hierarchy](guide/glossary#view-hierarchy).
  *
+ * @usageNotes
+ *
+ * The example below demonstrates how the `createComponent` function can be used
+ * to create an instance of a ComponentRef dynamically and attach it to an ApplicationRef,
+ * so that it gets included into change detection cycles.
+ *
+ * Note: the example uses standalone components, but the function can also be used for
+ * non-standalone components (declared in an NgModule) as well.
+ *
+ * ```typescript
+ * @Component({
+ *   standalone: true,
+ *   selector: 'dynamic',
+ *   template: `<span>This is a content of a dynamic component.</span>`,
+ * })
+ * class DynamicComponent {
+ *   vcr = inject(ViewContainerRef);
+ * }
+ *
+ * @Component({
+ *   standalone: true,
+ *   selector: 'app',
+ *   template: `<main>Hi! This is the main content.</main>`,
+ * })
+ * class AppComponent {
+ *   vcr = inject(ViewContainerRef);
+ *
+ *   ngAfterViewInit() {
+ *     const compRef = this.vcr.createComponent(DynamicComponent);
+ *     compRef.changeDetectorRef.detectChanges();
+ *   }
+ * }
+ * ```
+ *
  * @see {@link ComponentRef}
  * @see {@link EmbeddedViewRef}
  *
@@ -10350,14 +10357,6 @@ declare interface ViewRefTracker {
     detachView(viewRef: ViewRef): void;
 }
 
-declare interface WeakRef<T extends object> {
-    deref(): T | undefined;
-}
-
-declare interface WeakRefCtor {
-    new <T extends object>(value: T): WeakRef<T>;
-}
-
 /**
  * A `Signal` with a value that can be mutated via a setter interface.
  *
@@ -10396,25 +10395,21 @@ export declare function ɵ_sanitizeHtml(defaultDoc: any, unsafeHtmlInput: string
 export declare function ɵ_sanitizeUrl(url: string): string;
 
 /**
- * Implements `afterRender` and `afterNextRender` callback manager logic.
+ * Implements core timing for `afterRender` and `afterNextRender` events.
+ * Delegates to an optional `AfterRenderCallbackHandler` for implementation.
  */
 export declare class ɵAfterRenderEventManager {
-    private callbacks;
-    private deferredCallbacks;
     private renderDepth;
-    private runningCallbacks;
     /**
      * Mark the beginning of a render operation (i.e. CD cycle).
-     * Throws if called from an `afterRender` callback.
+     * Throws if called while executing callbacks.
      */
     begin(): void;
     /**
-     * Mark the end of a render operation. Registered callbacks
-     * are invoked if there are no more pending operations.
+     * Mark the end of a render operation. Callbacks will be
+     * executed if there are no more pending operations.
      */
     end(): void;
-    register(callback: AfterRenderCallback): void;
-    unregister(callback: AfterRenderCallback): void;
     ngOnDestroy(): void;
     /** @nocollapse */
     static ɵprov: unknown;
@@ -11818,7 +11813,8 @@ export declare interface ɵSafeValue {
  */
 export declare function ɵsetAllowDuplicateNgModuleIdsForTest(allowDuplicates: boolean): void;
 
-export declare function ɵsetAlternateWeakRefImpl(impl: WeakRefCtor): void;
+
+export declare function ɵsetAlternateWeakRefImpl(impl: unknown): void;
 
 /**
  * Adds decorator, constructor, and property metadata to a given type via static metadata fields

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "16.2.3",
+  "version": "16.2.5",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",

package/rxjs-interop/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.2.3
+ * @license Angular v16.2.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */

package/schematics/ng-generate/standalone-migration/bundle.js

@@ -21920,7 +21920,7 @@ function publishFacade(global) {
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("16.2.3");
+var VERSION2 = new Version("16.2.5");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _I18N_ATTR = "i18n";
@@ -23362,7 +23362,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION = "12.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("16.2.3"));
+  definitionMap.set("version", literal("16.2.5"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -23433,7 +23433,7 @@ function createDirectiveDefinitionMap(meta) {
   const hasTransformFunctions = Object.values(meta.inputs).some((input) => input.transformFunction !== null);
   const minVersion = hasTransformFunctions ? MINIMUM_PARTIAL_LINKER_VERSION2 : "14.0.0";
   definitionMap.set("minVersion", literal(minVersion));
-  definitionMap.set("version", literal("16.2.3"));
+  definitionMap.set("version", literal("16.2.5"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -23618,7 +23618,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION3 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION3));
-  definitionMap.set("version", literal("16.2.3"));
+  definitionMap.set("version", literal("16.2.5"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -23641,7 +23641,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION4));
-  definitionMap.set("version", literal("16.2.3"));
+  definitionMap.set("version", literal("16.2.5"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -23679,7 +23679,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION5));
-  definitionMap.set("version", literal("16.2.3"));
+  definitionMap.set("version", literal("16.2.5"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -23703,7 +23703,7 @@ function createNgModuleDefinitionMap(meta) {
     throw new Error("Invalid path! Local compilation mode should not get into the partial compilation path");
   }
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION6));
-  definitionMap.set("version", literal("16.2.3"));
+  definitionMap.set("version", literal("16.2.5"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -23738,7 +23738,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION7));
-  definitionMap.set("version", literal("16.2.3"));
+  definitionMap.set("version", literal("16.2.5"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
@@ -23755,7 +23755,7 @@ function createPipeDefinitionMap(meta) {
 publishFacade(_global);
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/version.mjs
-var VERSION3 = new Version("16.2.3");
+var VERSION3 = new Version("16.2.5");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/transformers/api.mjs
 var EmitFlags;