@angular/core 17.0.0-next.2 → 17.0.0-next.4

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.2
+ * @license Angular v17.0.0-next.4
  * (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`.
  *
@@ -1123,15 +1113,19 @@ export declare interface Component extends Directive {
      */
     template?: string;
     /**
-     * One or more relative paths or absolute URLs for files containing CSS stylesheets to use
+     * One relative paths or an absolute URL for files containing CSS stylesheet to use
      * in this component.
      */
+    styleUrl?: string;
+    /**
+     * Relative paths or absolute URLs for files containing CSS stylesheets to use in this component.
+     */
     styleUrls?: string[];
     /**
      * One or more inline CSS stylesheets to use
      * in this component.
      */
-    styles?: string[];
+    styles?: string | string[];
     /**
      * One or more animation `trigger()` calls, containing
      * [`state()`](api/animations/state) and `transition()` definitions.
@@ -1942,17 +1936,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.
@@ -2412,12 +2407,14 @@ export declare class DefaultIterableDiffer<V> implements IterableDiffer<V>, Iter
 declare const enum DeferDependenciesLoadingState {
     /** Initial state, dependency loading is not yet triggered */
     NOT_STARTED = 0,
+    /** Dependency loading was scheduled (e.g. `on idle`), but has not started yet */
+    SCHEDULED = 1,
     /** Dependency loading is in progress */
-    IN_PROGRESS = 1,
+    IN_PROGRESS = 2,
     /** Dependency loading has completed successfully */
-    COMPLETE = 2,
+    COMPLETE = 3,
     /** Dependency loading has failed */
-    FAILED = 3
+    FAILED = 4
 }
 
 /** Configuration object for a `{:loading}` block as it is stored in the component constants. */
@@ -3244,19 +3241,6 @@ export declare type EffectCleanupFn = () => void;
  */
 declare type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
 
-/**
- * Tracks all effects registered within a given application and runs them via `flush`.
- */
-declare class EffectManager {
-    private all;
-    private queue;
-    create(effectFn: (onCleanup: (cleanupFn: EffectCleanupFn) => void) => void, destroyRef: DestroyRef | null, allowSignalWrites: boolean): EffectRef;
-    flush(): void;
-    get isQueueEmpty(): boolean;
-    /** @nocollapse */
-    static ɵprov: unknown;
-}
-
 /**
  * A global reactive effect, which can be manually destroyed.
  *
@@ -3403,7 +3387,7 @@ declare const ENVIRONMENT = 10;
  *
  * @publicApi
  */
-export declare const ENVIRONMENT_INITIALIZER: InjectionToken<() => void>;
+export declare const ENVIRONMENT_INITIALIZER: InjectionToken<readonly (() => void)[]>;
 
 /**
  * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
@@ -5780,7 +5764,7 @@ declare interface LViewEnvironment {
     /** An optional custom sanitizer. */
     sanitizer: Sanitizer | null;
     /** Container for reactivity system `effect`s. */
-    effectManager: EffectManager | null;
+    inlineEffectRunner: ɵFlushableEffectRunner | null;
     /** Container for after render hooks */
     afterRenderEventManager: ɵAfterRenderEventManager | null;
 }
@@ -7375,116 +7359,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.
+ * A producer and/or consumer which participates in the reactive graph.
  *
- * Consumers are nodes that depend on the values of producers and are notified when those values
- * might have changed.
+ * Producer `ReactiveNode`s which are accessed when a consumer `ReactiveNode` is the
+ * `activeConsumer` are tracked as dependencies of that consumer.
  *
- * 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.
+ * 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.
  *
- * 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.
- *
- * 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;
+declare interface ReactiveNode {
     /**
-     * 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;
-    /**
-     * 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;
 }
 
 /**
@@ -7935,6 +7897,11 @@ export declare abstract class Sanitizer {
  */
 declare type SanitizerFn = (value: any, tagName?: string, propName?: string) => string | TrustedHTML | TrustedScript | TrustedScriptURL;
 
+declare interface SchedulableEffect {
+    run(): void;
+    creationZone: unknown;
+}
+
 
 /**
  * A schema definition associated with an NgModule.
@@ -9536,17 +9503,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.
@@ -9595,9 +9562,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.
@@ -10080,6 +10047,10 @@ export declare class Version {
     constructor(full: string);
 }
 
+declare type Version_2 = number & {
+    __brand: 'Version';
+};
+
 declare const VIEW_REFS = 8;
 
 /**
@@ -10262,6 +10233,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}
  *
@@ -10500,14 +10505,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.
  *
@@ -10546,25 +10543,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;
@@ -10896,6 +10889,7 @@ export declare interface ɵComponentDef<T> extends ɵDirectiveDef<T> {
      */
     readonly data: {
         [kind: string]: any;
+        animation?: any[];
     };
     /** Whether or not this component's ChangeDetectionStrategy is OnPush */
     readonly onPush: boolean;
@@ -11189,6 +11183,20 @@ export declare interface ɵDirectiveType<T> extends Type<T> {
     ɵfac: unknown;
 }
 
+/**
+ * A scheduler which manages the execution of effects.
+ */
+export declare abstract class ɵEffectScheduler {
+    /**
+     * Schedule the given effect to be executed at a later time.
+     *
+     * It is an error to attempt to execute any effects synchronously during a scheduling operation.
+     */
+    abstract scheduleEffect(e: SchedulableEffect): void;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+
 /**
  * Internal token to collect all SSR-related features enabled for this application.
  *
@@ -11215,6 +11223,16 @@ export declare const enum ɵExtraLocaleDataIndex {
  */
 export declare function ɵfindLocaleData(locale: string): any;
 
+/**
+ * Interface to an `EffectScheduler` capable of running scheduled effects synchronously.
+ */
+export declare interface ɵFlushableEffectRunner {
+    /**
+     * Run any scheduled effects.
+     */
+    flush(): void;
+}
+
 /**
  * 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
@@ -12094,7 +12112,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
@@ -12438,6 +12457,26 @@ export declare function ɵwithDomHydration(): EnvironmentProviders;
  */
 export declare const ɵXSS_SECURITY_URL = "https://g.co/ng/security#xss";
 
+/**
+ * An `EffectScheduler` which is capable of queueing scheduled effects per-zone, and flushing them
+ * as an explicit operation.
+ */
+export declare class ɵZoneAwareQueueingScheduler implements ɵEffectScheduler, ɵFlushableEffectRunner {
+    private queuedEffectCount;
+    private queues;
+    scheduleEffect(handle: SchedulableEffect): void;
+    /**
+     * Run all scheduled effects.
+     *
+     * Execution order of effects within the same zone is guaranteed to be FIFO, but there is no
+     * ordering guarantee between effects scheduled in different zones.
+     */
+    flush(): void;
+    private flushQueue;
+    /** @nocollapse */
+    static ɵprov: unknown;
+}
+
 /**
  * Advances to an element for later binding instructions.
  *
@@ -13099,6 +13138,15 @@ export declare type ɵɵComponentDeclaration<T, Selector extends String, ExportA
     [key: string]: string;
 }, QueryFields extends string[], NgContentSelectors extends string[], IsStandalone extends boolean = false, HostDirectives = never, IsSignal extends boolean = false> = unknown;
 
+/**
+ * Instruction that returns the component instance in which the current instruction is executing.
+ * This is a constant-time version of `nextContent` for the case where we know that we need the
+ * component instance specifically, rather than the context of a particular template.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵcomponentInstance(): unknown;
+
 /**
  * The conditional instruction represents the basic building block on the runtime side to support
  * built-in "if" and "switch". On the high level this instruction is responsible for adding and
@@ -14808,9 +14856,20 @@ export declare function ɵɵrepeater(metadataSlotIdx: number, collection: Iterab
  * - LView[HEADER_OFFSET + index + 2] - optional reference to a template function rendering an empty
  * block
  *
+ * @param index Index at which to store the metadata of the repeater.
+ * @param templateFn Reference to the template of the main repeater block.
+ * @param decls The number of nodes, local refs, and pipes for the main block.
+ * @param vars The number of bindings for the main block.
+ * @param trackByFn Reference to the tracking function.
+ * @param trackByUsesComponentInstance Whether the tracking function has any references to the
+ *  component instance. If it doesn't, we can avoid rebinding it.
+ * @param emptyTemplateFn Reference to the template function of the empty block.
+ * @param emptyDecls The number of nodes, local refs, and pipes for the empty block.
+ * @param emptyVars The number of bindings for the empty block.
+ *
  * @codeGenApi
  */
-export declare function ɵɵrepeaterCreate(index: number, templateFn: ComponentTemplate<unknown>, decls: number, vars: number, trackByFn: TrackByFunction<unknown>, emptyTemplateFn?: ComponentTemplate<unknown>, emptyDecls?: number, emptyVars?: number): void;
+export declare function ɵɵrepeaterCreate(index: number, templateFn: ComponentTemplate<unknown>, decls: number, vars: number, trackByFn: TrackByFunction<unknown>, trackByUsesComponentInstance?: boolean, emptyTemplateFn?: ComponentTemplate<unknown>, emptyDecls?: number, emptyVars?: number): void;
 
 /**
  * A built-in trackBy function used for situations where users specified collection item reference

package/package.json

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

package/rxjs-interop/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.2
+ * @license Angular v17.0.0-next.4
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */