@angular/core 16.0.0-next.0 → 16.0.0-next.2

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.0.0-next.0
+ * @license Angular v16.0.0-next.2
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -273,20 +273,31 @@ export declare const APP_INITIALIZER: InjectionToken<readonly (() => Observable<
 
 declare function _appIdRandomProviderFactory(): string;
 
+/**
+ * Set of config options available during the application bootstrap operation.
+ *
+ * @publicApi
+ */
+export declare interface ApplicationConfig {
+    /**
+     * List of providers that should be available to the root component and all its children.
+     */
+    providers: Array<Provider | EnvironmentProviders>;
+}
+
 /**
  * A class that reflects the state of running {@link APP_INITIALIZER} functions.
  *
  * @publicApi
  */
 export declare class ApplicationInitStatus {
-    private readonly appInits;
     private resolve;
     private reject;
     private initialized;
-    readonly donePromise: Promise<any>;
     readonly done = false;
-    constructor(appInits: ReadonlyArray<() => Observable<unknown> | Promise<unknown> | void>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationInitStatus, [{ optional: true; }]>;
+    readonly donePromise: Promise<any>;
+    private readonly appInits;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationInitStatus, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationInitStatus>;
 }
 
@@ -401,7 +412,6 @@ export declare class ApplicationRef {
     private _zone;
     private _injector;
     private _exceptionHandler;
-    private _views;
     private _runningTick;
     private _stable;
     private _onMicrotaskEmptySubscription;
@@ -2174,6 +2184,46 @@ export declare class DefaultIterableDiffer<V> implements IterableDiffer<V>, Iter
  */
 export declare const defineInjectable: typeof ɵɵdefineInjectable;
 
+/**
+ * Represents a hydration-related element container structure
+ * at runtime, which includes a reference to a first node in
+ * a DOM segment that corresponds to a given element container.
+ */
+declare interface DehydratedElementContainer {
+    /**
+     * A reference to the first child in a DOM segment associated
+     * with a first child in a given <ng-container>.
+     */
+    firstChild: RNode | null;
+}
+
+/**
+ * An object that contains hydration-related information serialized
+ * on the server, as well as the necessary references to segments of
+ * the DOM, to facilitate the hydration process for a given hydration
+ * boundary on the client.
+ */
+declare interface DehydratedView {
+    /**
+     * The readonly hydration annotation data.
+     */
+    data: Readonly<SerializedView>;
+    /**
+     * A reference to the first child in a DOM segment associated
+     * with a given hydration boundary.
+     */
+    firstChild: RNode | null;
+    /**
+     * Collection of <ng-container>s in a given view,
+     * used as a set of pointers to first children in each
+     * <ng-container>, so that those pointers are reused by
+     * subsequent instructions.
+     */
+    ngContainers?: {
+        [index: number]: DehydratedElementContainer;
+    };
+}
+
 declare type DependencyTypeList = (ɵDirectiveType<any> | ɵComponentType<any> | PipeType<any> | Type<any>)[];
 
 /**
@@ -2204,6 +2254,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.
  *
@@ -2677,6 +2741,8 @@ export declare interface Effect {
  */
 export declare function effect(effectFn: () => void): Effect;
 
+declare const ELEMENT_CONTAINERS = "e";
+
 /**
  * Marks that the next string is an element name.
  *
@@ -3534,6 +3600,8 @@ export declare interface HostListenerDecorator {
     new (eventName: string, args?: string[]): any;
 }
 
+declare const HYDRATION = 23;
+
 declare namespace i0 {
     export {
         ɵɵinject,
@@ -5073,11 +5141,21 @@ declare interface LView<T = unknown> extends Array<any> {
     [TRANSPLANTED_VIEWS_TO_REFRESH]: number;
     /** Unique ID of the view. Used for `__ngContext__` lookups in the `LView` registry. */
     [ID]: number;
+    /**
+     * A container related to hydration annotation information that's associated with this LView.
+     */
+    [HYDRATION]: DehydratedView | null;
     /**
      * Optional injector assigned to embedded views that takes
      * 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]) */
@@ -5133,6 +5211,16 @@ declare const enum LViewFlags {
  */
 export declare function makeEnvironmentProviders(providers: (Provider | EnvironmentProviders)[]): EnvironmentProviders;
 
+/**
+ * Merge multiple application configurations from left to right.
+ *
+ * @param configs Two or more configurations to be merged.
+ * @returns A merged [ApplicationConfig](api/core/ApplicationConfig).
+ *
+ * @publicApi
+ */
+export declare function mergeApplicationConfig(...configs: ApplicationConfig[]): ApplicationConfig;
+
 /**
  * Use this enum at bootstrap as an option of `bootstrapModule` to define the strategy
  * that the compiler should use in case of missing translations:
@@ -5643,6 +5731,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.
@@ -6897,11 +6987,13 @@ export declare class ReflectiveKey {
  * listeners on Element.
  */
 declare interface RElement extends RNode {
+    firstChild: RNode | null;
     style: RCssStyleDeclaration;
     classList: RDomTokenList;
     className: string;
     tagName: string;
     textContent: string | null;
+    getAttribute(name: string): string | null;
     setAttribute(name: string, value: string | TrustedHTML | TrustedScript | TrustedScriptURL): void;
     removeAttribute(name: string): void;
     setAttributeNS(namespaceURI: string, qualifiedName: string, value: string | TrustedHTML | TrustedScript | TrustedScriptURL): void;
@@ -7495,6 +7587,29 @@ export declare interface SelfDecorator {
     new (): Self;
 }
 
+/**
+ * Represents element containers within this view, stored as key-value pairs
+ * where key is an index of a container in an LView (also used in the
+ * `elementContainerStart` instruction), the value is the number of root nodes
+ * in this container. This information is needed to locate an anchor comment
+ * node that goes after all container nodes.
+ */
+declare interface SerializedElementContainers {
+    [key: number]: number;
+}
+
+/**
+ * Serialized data structure that contains relevant hydration
+ * annotation information that describes a given hydration boundary
+ * (e.g. a component).
+ */
+declare interface SerializedView {
+    /**
+     * Serialized information about <ng-container>s.
+     */
+    [ELEMENT_CONTAINERS]?: SerializedElementContainers;
+}
+
 /**
  * A `Signal` with a value that can be mutated via a setter interface.
  *
@@ -7739,7 +7854,7 @@ declare interface TContainerNode extends TNode {
      * - They are dynamically created
      */
     parent: TElementNode | TElementContainerNode | null;
-    tViews: TView | TView[] | null;
+    tView: TView | null;
     projection: null;
     value: null;
 }
@@ -7779,7 +7894,7 @@ declare interface TElementContainerNode extends TNode {
     index: number;
     child: TElementNode | TTextNode | TContainerNode | TElementContainerNode | TProjectionNode | null;
     parent: TElementNode | TElementContainerNode | null;
-    tViews: null;
+    tView: null;
     projection: null;
 }
 
@@ -7794,7 +7909,7 @@ declare interface TElementNode extends TNode {
      * retrieved using viewData[HOST_NODE]).
      */
     parent: TElementNode | TElementContainerNode | null;
-    tViews: null;
+    tView: null;
     /**
      * If this is a component TNode with projection, this will be an array of projected
      * TNodes or native nodes (see TNode.projection for more info). If it's a regular element node
@@ -8232,31 +8347,24 @@ declare interface TNode {
      */
     outputs: PropertyAliases | null;
     /**
-     * The TView or TViews attached to this node.
-     *
-     * If this TNode corresponds to an LContainer with inline views, the container will
-     * need to store separate static data for each of its view blocks (TView[]). Otherwise,
-     * nodes in inline views with the same index as nodes in their parent views will overwrite
-     * each other, as they are in the same template.
-     *
-     * Each index in this array corresponds to the static data for a certain
-     * view. So if you had V(0) and V(1) in a container, you might have:
-     *
-     * [
-     *   [{tagName: 'div', attrs: ...}, null],     // V(0) TView
-     *   [{tagName: 'button', attrs ...}, null]    // V(1) TView
+     * The TView attached to this node.
      *
      * If this TNode corresponds to an LContainer with a template (e.g. structural
      * directive), the template's TView will be stored here.
      *
-     * If this TNode corresponds to an element, tViews will be null .
+     * If this TNode corresponds to an element, tView will be `null`.
      */
-    tViews: TView | TView[] | null;
+    tView: TView | null;
     /**
      * The next sibling node. Necessary so we can propagate through the root nodes of a view
      * to insert them or remove them from the DOM.
      */
     next: TNode | null;
+    /**
+     * The previous sibling node.
+     * This simplifies operations when we need a pointer to the previous node.
+     */
+    prev: TNode | null;
     /**
      * The next projected sibling. Since in Angular content projection works on the node-by-node
      * basis the act of projecting nodes might change nodes relationship at the insertion point
@@ -8547,7 +8655,7 @@ declare interface TProjectionNode extends TNode {
      * retrieved using LView.node).
      */
     parent: TElementNode | TElementContainerNode | null;
-    tViews: null;
+    tView: null;
     /** Index of the projection node. (See TNode.projection for more info.) */
     projection: number;
     value: null;
@@ -8938,7 +9046,7 @@ declare interface TTextNode extends TNode {
      * retrieved using LView.node).
      */
     parent: TElementNode | TElementContainerNode | null;
-    tViews: null;
+    tView: null;
     projection: null;
 }
 
@@ -9789,6 +9897,15 @@ export declare function ɵallowSanitizationBypassAndThrow(value: any, type: ɵBy
 
 export declare function ɵallowSanitizationBypassAndThrow(value: any, type: ɵBypassType): boolean;
 
+/**
+ * Annotates all components bootstrapped in a given ApplicationRef
+ * with info needed for hydration.
+ *
+ * @param appRef An instance of an ApplicationRef.
+ * @param doc A reference to the current Document instance.
+ */
+export declare function ɵannotateForHydration(appRef: ApplicationRef, doc: Document): void;
+
 /**
  * Providers that generate a random `APP_ID_TOKEN`.
  * @publicApi
@@ -9991,43 +10108,6 @@ export declare const enum ɵBypassType {
     Style = "Style"
 }
 
-/**
- * Defines the possible states of the default change detector.
- * @see `ChangeDetectorRef`
- */
-export declare enum ɵChangeDetectorStatus {
-    /**
-     * A state in which, after calling `detectChanges()`, the change detector
-     * state becomes `Checked`, and must be explicitly invoked or reactivated.
-     */
-    CheckOnce = 0,
-    /**
-     * A state in which change detection is skipped until the change detector mode
-     * becomes `CheckOnce`.
-     */
-    Checked = 1,
-    /**
-     * A state in which change detection continues automatically until explicitly
-     * deactivated.
-     */
-    CheckAlways = 2,
-    /**
-     * A state in which a change detector sub tree is not a part of the main tree and
-     * should be skipped.
-     */
-    Detached = 3,
-    /**
-     * Indicates that the change detector encountered an error checking a binding
-     * or calling a directive lifecycle method and is now in an inconsistent state. Change
-     * detectors in this state do not detect changes.
-     */
-    Errored = 4,
-    /**
-     * Indicates that the change detector has been destroyed.
-     */
-    Destroyed = 5
-}
-
 export declare function ɵclearResolutionOfComponentResourcesQueue(): Map<Type<any>, Component>;
 
 
@@ -10384,6 +10464,9 @@ 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
  */
@@ -10415,7 +10498,12 @@ export declare function ɵflushModuleScopingQueueAsMuchAsPossible(): void;
  */
 export declare function ɵformatRuntimeError<T extends number = RuntimeErrorCode>(code: T, message: null | false | string): string;
 
-export declare function ɵgetDebugNodeR2(_nativeNode: any): DebugNode | null;
+/**
+ * The following getter methods retrieve the definition from the type. Currently the retrieval
+ * honors inheritance, but in the future we may change the rule to require that definitions are
+ * explicit. This would require some sort of migration strategy.
+ */
+export declare function ɵgetComponentDef<T>(type: any): ɵComponentDef<T> | null;
 
 /**
  * Retrieves directive instances associated with a given DOM node. Does not include
@@ -10560,33 +10648,20 @@ export declare interface ɵInternalEnvironmentProviders extends EnvironmentProvi
     ɵfromNgModule?: true;
 }
 
-export declare function ɵisBoundToModule<C>(cf: ComponentFactory<C>): boolean;
-
 /**
- * Reports whether a given strategy is currently the default for change detection.
- * @param changeDetectionStrategy The strategy to check.
- * @returns True if the given strategy is the current default, false otherwise.
- * @see `ChangeDetectorStatus`
- * @see `ChangeDetectorRef`
+ * Internal token that specifies whether hydration is enabled.
  */
-export declare function ɵisDefaultChangeDetectionStrategy(changeDetectionStrategy: ChangeDetectionStrategy): boolean;
+export declare const ɵIS_HYDRATION_FEATURE_ENABLED: InjectionToken<boolean>;
+
+export declare function ɵisBoundToModule<C>(cf: ComponentFactory<C>): boolean;
 
 export declare function ɵisEnvironmentProviders(value: Provider | EnvironmentProviders | ɵInternalEnvironmentProviders): value is ɵInternalEnvironmentProviders;
 
 export declare function ɵisInjectable(type: any): boolean;
 
-export declare function ɵisListLikeIterable(obj: any): boolean;
-
-/**
- * Determine if the argument is an Observable
- *
- * Strictly this tests that the `obj` is `Subscribable`, since `Observable`
- * types need additional methods, such as `lift()`. But it is adequate for our
- * needs since within the Angular framework code we only ever need to use the
- * `subscribe()` method, and RxJS has mechanisms to wrap `Subscribable` objects
- * into `Observable` as needed.
- */
-export declare const ɵisObservable: (obj: any | Observable<any>) => obj is Observable<any>;
+export declare function ɵisNgModule<T>(value: Type<T>): value is Type<T> & {
+    ɵmod: ɵNgModuleDef<T>;
+};
 
 /**
  * Determine if the argument is shaped like a Promise
@@ -10596,9 +10671,7 @@ export declare function ɵisPromise<T = any>(obj: any): obj is Promise<T>;
 /**
  * Determine if the argument is a Subscribable
  */
-export declare function ɵisSubscribable(obj: any | Subscribable<any>): obj is Subscribable<any>;
-
-export declare const ɵivyEnabled = true;
+export declare function ɵisSubscribable<T>(obj: any | Subscribable<T>): obj is Subscribable<T>;
 
 /**
  * The internal view context which is specific to a given DOM element, directive or
@@ -10707,6 +10780,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;
 
@@ -10936,6 +11025,50 @@ export declare const enum ɵProfilerEvent {
     OutputEnd = 7
 }
 
+/**
+ * Returns a set of providers required to setup hydration support
+ * for an application that is server side rendered.
+ *
+ * ## NgModule-based bootstrap
+ *
+ * You can add the function call to the root AppModule of an application:
+ * ```
+ * import {provideHydrationSupport} from '@angular/core';
+ *
+ * @NgModule({
+ *   providers: [
+ *     // ... other providers ...
+ *     provideHydrationSupport()
+ *   ],
+ *   declarations: [AppComponent],
+ *   bootstrap: [AppComponent]
+ * })
+ * class AppModule {}
+ * ```
+ *
+ * ## Standalone-based bootstrap
+ *
+ * Add the function to the `bootstrapApplication` call:
+ * ```
+ * import {provideHydrationSupport} from '@angular/core';
+ *
+ * bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     // ... other providers ...
+ *     provideHydrationSupport()
+ *   ]
+ * });
+ * ```
+ *
+ * The function sets up an internal flag that would be recognized during
+ * the server side rendering time as well, so there is no need to
+ * configure or change anything in NgUniversal to enable the feature.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export declare function ɵprovideHydrationSupport(): EnvironmentProviders;
+
 /**
  * Publishes a collection of default debug tools onto`window.ng`.
  *
@@ -11218,6 +11351,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;
 
@@ -11240,12 +11392,63 @@ 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 {
+    /** @nocollapse */
+    static ɵprov: unknown;
+    private onSerializeCallbacks;
+    /**
+     * 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;
+}
+
 /**
  * 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": "16.0.0-next.0",
+  "version": "16.0.0-next.2",
   "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/*": {
@@ -36,7 +36,7 @@
   },
   "peerDependencies": {
     "rxjs": "^6.5.3 || ^7.4.0",
-    "zone.js": "~0.11.4 || ~0.12.0"
+    "zone.js": "~0.13.0"
   },
   "repository": {
     "type": "git",