@angular/core 15.2.1 → 16.0.0-next.1

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v15.2.1
+ * @license Angular v16.0.0-next.1
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1417,6 +1417,13 @@ declare type ComponentTemplate<T> = {
     <U extends T>(rf: ɵRenderFlags, ctx: T | U): void;
 };
 
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ *
+ * @developerPreview
+ */
+export declare function computed<T>(computation: () => T, equal?: ValueEqualityFn<T>): Signal<T>;
+
 /**
  * Configures the `Injector` to return an instance of a token.
  *
@@ -1465,6 +1472,78 @@ export declare interface ConstructorSansProvider {
     deps?: any[];
 }
 
+/**
+ * Represents a reader that can depend on reactive values (`Producer`s) and receive
+ * notifications when those values change.
+ *
+ * `Consumer`s do not wrap the reads they consume themselves, but rather can be set
+ * as the active reader via `setActiveConsumer`.
+ *
+ * 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.
+ *
+ * `Producer`s 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 established.
+ */
+declare interface Consumer {
+    /**
+     * Numeric identifier of this `Producer`.
+     *
+     * May also be used to satisfy the interface for `Producer`.
+     */
+    readonly id: ConsumerId;
+    /**
+     * A `WeakRef` to this `Consumer` instance.
+     *
+     * An implementer provides this as a cached value to avoid the need to instantiate
+     * multiple `WeakRef` instances for the same `Consumer`.
+     *
+     * May also be used to satisfy the interface for `Producer`.
+     */
+    readonly ref: WeakRef<Consumer>;
+    /**
+     * A map of `Edge`s to `Producer` dependencies, keyed by the `ProducerId`.
+     *
+     * Used to poll `Producer`s to determine if the `Consumer` has really updated
+     * or not.
+     */
+    readonly producers: Map<ProducerId, Edge>;
+    /**
+     * Monotonically increasing counter representing a version of this `Consumer`'s
+     * dependencies.
+     */
+    readonly trackingVersion: number;
+    /**
+     * Called when a `Producer` dependency of this `Consumer` indicates it may
+     * have a new value.
+     *
+     * Notification alone does not mean the `Producer` has definitely produced a
+     * semantically different value, only that it _may_ have changed. Before a
+     * `Consumer` re-runs any computations or side effects, it should use the
+     * `consumerPollValueStatus` method to poll the `Producer`s on which it depends
+     * and determine if any of them have actually updated.
+     */
+    notify(): void;
+}
+
+/**
+ * Identifier for a `Consumer`, which is a branded `number`.
+ *
+ * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`
+ * will never be used for both.
+ *
+ * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are
+ * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents
+ * `ConsumerId`s from being inadvertently used to look up `Producer`s or vice versa.
+ */
+declare type ConsumerId = number & {
+    __consumer: true;
+};
+
 /**
  * Type of the ContentChild metadata.
  *
@@ -2125,6 +2204,20 @@ declare type DestroyHookData = (HookEntry | HookData)[];
  */
 export declare function destroyPlatform(): void;
 
+
+/**
+ * `DestroyRef` lets you set callbacks to run for any cleanup or destruction behavior.
+ * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
+ * is injected in a component or directive, the callbacks run when that component or
+ * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
+ */
+export declare abstract class DestroyRef {
+    /**
+     * Registers a destroy callback in a given lifecycle scope.
+     */
+    abstract onDestroy(callback: () => void): void;
+}
+
 /**
  * Directive decorator and metadata.
  *
@@ -2543,6 +2636,61 @@ export declare interface DoCheck {
     ngDoCheck(): void;
 }
 
+/**
+ * A bidirectional edge in the producer-consumer dependency graph.
+ */
+declare interface Edge {
+    /**
+     * Weakly held reference to the `Consumer` side of this edge.
+     */
+    readonly consumerRef: WeakRef<Consumer>;
+    /**
+     * Weakly held reference to the `Producer` side of this edge.
+     */
+    readonly producerRef: WeakRef<Producer>;
+    /**
+     * `trackingVersion` of the `Consumer` at which this dependency edge was last observed.
+     *
+     * If this doesn't match the `Consumer`'s current `trackingVersion`, then this dependency record
+     * is stale, and needs to be cleaned up.
+     */
+    atTrackingVersion: number;
+    /**
+     * `valueVersion` of the `Producer` at the time this dependency was last accessed.
+     *
+     * This is used by `consumerPollValueStatus` to determine whether a `Consumer`'s dependencies have
+     * semantically changed.
+     */
+    seenValueVersion: number;
+}
+
+/**
+ * A global reactive effect, which can be manually scheduled or destroyed.
+ *
+ * @developerPreview
+ */
+export declare interface Effect {
+    /**
+     * Schedule the effect for manual execution, if it's not already.
+     */
+    schedule(): void;
+    /**
+     * Shut down the effect, removing it from any upcoming scheduled executions.
+     */
+    destroy(): void;
+    /**
+     * Direct access to the effect's `Consumer` for advanced use cases.
+     */
+    readonly consumer: Consumer;
+}
+
+/**
+ * Create a global `Effect` for the given reactive function.
+ *
+ * @developerPreview
+ */
+export declare function effect(effectFn: () => void): Effect;
+
 /**
  * Marks that the next string is an element name.
  *
@@ -4246,6 +4394,11 @@ declare interface InternalViewRef extends ViewRef {
  */
 export declare function isDevMode(): boolean;
 
+/**
+ * Checks if the given `value` function is a reactive `Signal`.
+ */
+export declare function isSignal(value: Function): value is Signal<unknown>;
+
 /**
  * Checks whether a given Component, Directive or Pipe is marked as standalone.
  * This will return false if passed anything other than a Component, Directive, or Pipe class
@@ -4939,6 +5092,12 @@ declare interface LView<T = unknown> extends Array<any> {
      * precedence over the element and module injectors.
      */
     readonly [EMBEDDED_VIEW_INJECTOR]: Injector | null;
+    /**
+     * A collection of callbacks functions that are executed when a given LView is destroyed. Those
+     * are user defined, LView-specific destroy callbacks that don't have any corresponding TView
+     * entries.
+     */
+    [ON_DESTROY_HOOKS]: Array<() => void> | null;
 }
 
 /** Flags associated with an LView (saved in LView[FLAGS]) */
@@ -5504,6 +5663,8 @@ export declare class NgZone {
  */
 export declare const NO_ERRORS_SCHEMA: SchemaMetadata;
 
+declare const ON_DESTROY_HOOKS = 22;
+
 /**
  * @description
  * A lifecycle hook that is called when any data-bound property of a directive changes.
@@ -5934,6 +6095,74 @@ declare const enum PreOrderHookFlags {
  */
 declare type ProcessProvidersFunction = (providers: Provider[]) => Provider[];
 
+/**
+ * Represents a value that can be read reactively, and can notify readers (`Consumer`s)
+ * when it changes.
+ *
+ * Producers maintain a weak reference to any `Consumer`s which may depend on the
+ * producer's value.
+ *
+ * Implementers of `Producer` expose a monotonic `valueVersion` counter, and are responsible
+ * for incrementing this version when their value semantically changes. Some Producers may
+ * produce this value 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
+ * `checkForChangedValue` method for Producers, which should perform whatever calculations
+ * are necessary to ensure `valueVersion` is up to date.
+ *
+ * `Producer`s support two operations:
+ *   * `producerNotifyConsumers`
+ *   * `producerAccessed`
+ */
+declare interface Producer {
+    /**
+     * Numeric identifier of this `Producer`.
+     *
+     * May also be used to satisfy the interface for `Consumer`.
+     */
+    readonly id: ProducerId;
+    /**
+     * A `WeakRef` to this `Producer` instance.
+     *
+     * An implementer provides this as a cached value to avoid the need to instantiate
+     * multiple `WeakRef` instances for the same `Producer`.
+     *
+     * May also be used to satisfy the interface for `Consumer`.
+     */
+    readonly ref: WeakRef<Producer>;
+    /**
+     * A map of dependency `Edge`s to `Consumer`s, keyed by the `ConsumerId`.
+     *
+     * Used when the produced value changes to notify interested `Consumer`s.
+     */
+    readonly consumers: Map<ConsumerId, Edge>;
+    /**
+     * Monotonically increasing counter which increases when the value of this `Producer`
+     * semantically changes.
+     */
+    readonly valueVersion: number;
+    /**
+     * Ensure that `valueVersion` is up to date for the `Producer`'s value.
+     *
+     * Some `Producer`s may produce values lazily, and thus require polling before their
+     * `valueVersion` can be compared with the version captured during a previous read.
+     */
+    checkForChangedValue(): void;
+}
+
+/**
+ * Identifier for a `Producer`, which is a branded `number`.
+ *
+ * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`
+ * will never be used for both.
+ *
+ * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are
+ * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents
+ * `ProducerId`s from being inadvertently used to look up `Consumer`s or vice versa.
+ */
+declare type ProducerId = number & {
+    __producer: true;
+};
+
 /**
  * List of slots for a projection. A slot can be either based on a parsed CSS selector
  * which will be used to determine nodes which are projected into that slot.
@@ -6991,7 +7220,7 @@ export declare interface RendererType2 {
     /**
      * Defines CSS styles to be stored on a renderer instance.
      */
-    styles: (string | any[])[];
+    styles: string[];
     /**
      * Defines arbitrary developer-defined data to be stored on a renderer instance.
      * This is useful for renderers that delegate to other renderers.
@@ -7288,12 +7517,62 @@ export declare interface SelfDecorator {
     new (): Self;
 }
 
+/**
+ * A `Signal` with a value that can be mutated via a setter interface.
+ *
+ * @developerPreview
+ */
+export declare interface SettableSignal<T> extends Signal<T> {
+    /**
+     * Directly set the signal to a new value, and notify any dependents.
+     */
+    set(value: T): void;
+    /**
+     * Update the value of the signal based on its current value, and
+     * notify any dependents.
+     */
+    update(updateFn: (value: T) => T): void;
+    /**
+     * Update the current value by mutating it in-place, and
+     * notify any dependents.
+     */
+    mutate(mutatorFn: (value: T) => void): void;
+}
+
 /**
  * Set the {@link GetTestability} implementation used by the Angular testing framework.
  * @publicApi
  */
 export declare function setTestabilityGetter(getter: GetTestability): void;
 
+/**
+ * Symbol used to tell `Signal`s apart from other functions.
+ *
+ * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ */
+declare const SIGNAL: unique symbol;
+
+/**
+ * A reactive value which notifies consumers of any changes.
+ *
+ * Signals are functions which returns their current value. To access the current value of a signal,
+ * call it.
+ *
+ * Ordinary values can be turned into `Signal`s with the `signal` function.
+ *
+ * @developerPreview
+ */
+export declare type Signal<T> = (() => T) & {
+    [SIGNAL]: true;
+};
+
+/**
+ * Create a `Signal` that can be set or updated directly.
+ *
+ * @developerPreview
+ */
+export declare function signal<T>(initialValue: T, equal?: ValueEqualityFn<T>): SettableSignal<T>;
+
 
 /**
  * Represents a basic change from a previous to a new value for a single
@@ -9009,6 +9288,22 @@ declare type TypeOrFactory<T> = T | (() => T);
 export declare interface TypeProvider extends Type<any> {
 }
 
+
+/**
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
+ *
+ * @developerPreview
+ */
+export declare function untracked<T>(nonReactiveReadsFn: () => T): T;
+
+/**
+ * A comparison function which can determine if two values are equal.
+ *
+ * @developerPreview
+ */
+export declare type ValueEqualityFn<T> = (a: T, b: T) => boolean;
+
 /**
  * Configures the `Injector` to return a value for a token.
  * @see ["Dependency Injection Guide"](guide/dependency-injection).
@@ -9483,6 +9778,17 @@ declare interface ViewRefTracker {
     detachView(viewRef: ViewRef): void;
 }
 
+
+declare interface WeakRef<T extends object> {
+    deref(): T | undefined;
+}
+
+declare const WeakRef: WeakRefCtor;
+
+declare interface WeakRefCtor {
+    new <T extends object>(value: T): WeakRef<T>;
+}
+
 /**
  * Sanitizes the given unsafe, untrusted HTML fragment, and returns HTML text that is safe to add to
  * the DOM in a browser environment.
@@ -10105,6 +10411,8 @@ export declare interface ɵDirectiveType<T> extends Type<T> {
     ɵfac: unknown;
 }
 
+export declare function ɵescapeTransferStateContent(text: string): string;
+
 /**
  * Index of each type of locale data from the extra locale data array
  */
@@ -10432,6 +10740,22 @@ export declare function ɵmakeDecorator<T>(name: string, props?: (...args: any[]
     (...args: any[]): (cls: any) => any;
 };
 
+/**
+ * Create a `StateKey<T>` that can be used to store value of type T with `TransferState`.
+ *
+ * Example:
+ *
+ * ```
+ * const COUNTER_KEY = makeStateKey<number>('counter');
+ * let value = 10;
+ *
+ * transferState.set(COUNTER_KEY, value);
+ * ```
+ *
+ * @publicApi
+ */
+export declare function ɵmakeStateKey<T = void>(key: string): ɵStateKey<T>;
+
 
 export declare const ɵNG_COMP_DEF: string;
 
@@ -10943,6 +11267,25 @@ export declare function ɵsetUnknownElementStrictMode(shouldThrow: boolean): voi
  */
 export declare function ɵsetUnknownPropertyStrictMode(shouldThrow: boolean): void;
 
+/**
+ * A type-safe key to use with `TransferState`.
+ *
+ * Example:
+ *
+ * ```
+ * const COUNTER_KEY = makeStateKey<number>('counter');
+ * let value = 10;
+ *
+ * transferState.set(COUNTER_KEY, value);
+ * ```
+ *
+ * @publicApi
+ */
+export declare type ɵStateKey<T> = string & {
+    __not_a_string: never;
+    __value_type?: T;
+};
+
 /** Store a value in the `data` at a given `index`. */
 export declare function ɵstore<T>(tView: TView, lView: LView, index: number, value: T): void;
 
@@ -10965,12 +11308,65 @@ export declare const ɵTESTABILITY: InjectionToken<Testability>;
  */
 export declare const ɵTESTABILITY_GETTER: InjectionToken<GetTestability>;
 
+/**
+ * A key value store that is transferred from the application on the server side to the application
+ * on the client side.
+ *
+ * The `TransferState` is available as an injectable token.
+ * On the client, just inject this token using DI and use it, it will be lazily initialized.
+ * On the server it's already included if `renderApplication` function is used. Otherwise, import
+ * the `ServerTransferStateModule` module to make the `TransferState` available.
+ *
+ * The values in the store are serialized/deserialized using JSON.stringify/JSON.parse. So only
+ * boolean, number, string, null and non-class objects will be serialized and deserialized in a
+ * non-lossy manner.
+ *
+ * @publicApi
+ */
+export declare class ɵTransferState {
+    private store;
+    private onSerializeCallbacks;
+    constructor();
+    /**
+     * Get the value corresponding to a key. Return `defaultValue` if key is not found.
+     */
+    get<T>(key: ɵStateKey<T>, defaultValue: T): T;
+    /**
+     * Set the value corresponding to a key.
+     */
+    set<T>(key: ɵStateKey<T>, value: T): void;
+    /**
+     * Remove a key from the store.
+     */
+    remove<T>(key: ɵStateKey<T>): void;
+    /**
+     * Test whether a key exists in the store.
+     */
+    hasKey<T>(key: ɵStateKey<T>): boolean;
+    /**
+     * Indicates whether the state is empty.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Register a callback to provide the value for a key when `toJson` is called.
+     */
+    onSerialize<T>(key: ɵStateKey<T>, callback: () => T): void;
+    /**
+     * Serialize the current state of the store to JSON.
+     */
+    toJson(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ɵTransferState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ɵTransferState>;
+}
+
 /**
  * Compute the pair of transitive scopes (compilation scope and exported scope) for a given type
  * (either a NgModule or a standalone component / directive / pipe).
  */
 export declare function ɵtransitiveScopesFor<T>(type: Type<T>): ɵNgModuleTransitiveScopes;
 
+export declare function ɵunescapeTransferStateContent(text: string): string;
+
 /**
  * Helper function to remove all the locale data from `LOCALE_DATA`.
  */

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@angular/core",
-  "version": "15.2.1",
+  "version": "16.0.0-next.1",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",
   "engines": {
-    "node": "^14.20.0 || ^16.13.0 || >=18.10.0"
+    "node": "^16.13.0 || >=18.10.0"
   },
   "exports": {
     "./schematics/*": {