@angular/core 17.2.0-next.1 → 17.2.0-rc.0

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.2.0-next.1
+ * @license Angular v17.2.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -756,6 +756,8 @@ export declare class ApplicationRef {
      * detection pass during which all change detection must complete.
      */
     tick(): void;
+    private detectChangesInAttachedViews;
+    private detectChangesInView;
     /**
      * Attaches a view so that it will be dirty checked.
      * The view will be automatically detached when it is destroyed.
@@ -1879,6 +1881,26 @@ export declare type ContentChild = Query;
  */
 export declare const ContentChild: ContentChildDecorator;
 
+/**
+ * Initializes a content child query. Consider using `contentChild.required` for queries that should
+ * always match.
+ *
+ * @usageNotes
+ * Create a child query in your component by declaring a
+ * class field and initializing it with the `contentChild()` function.
+ *
+ * ```ts
+ * @Component({...})
+ * export class TestComponent {
+ *   headerEl = contentChild<ElementRef>('h');                    // Signal<ElementRef|undefined>
+ *   headerElElRequired = contentChild.required<ElementRef>('h'); // Signal<ElementRef>
+ *   header = contentChild(MyHeader);                             // Signal<MyHeader|undefined>
+ *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>
+ * }
+ * ```
+ */
+export declare const contentChild: ContentChildFunction;
+
 /**
  * Type of the ContentChild decorator / constructor function.
  *
@@ -1956,6 +1978,46 @@ export declare interface ContentChildDecorator {
     }): ContentChild;
 }
 
+/**
+ * Type of the `contentChild` function.
+ *
+ * The contentChild function creates a singular content query. It is a special function that also
+ * provides access to required query results via the `.required` property.
+ *
+ * @developerPreview
+ */
+export declare interface ContentChildFunction {
+    /**
+     * Initializes a content child query.
+     *
+     * Consider using `contentChild.required` for queries that should always match.
+     * @developerPreview
+     */
+    <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
+        descendants?: boolean;
+        read?: undefined;
+    }): Signal<LocatorT | undefined>;
+    <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+        descendants?: boolean;
+        read: ProviderToken<ReadT>;
+    }): Signal<ReadT | undefined>;
+    /**
+     * Initializes a content child query that is always expected to match.
+     *
+     * @developerPreview
+     */
+    required: {
+        <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
+            descendants?: boolean;
+            read?: undefined;
+        }): Signal<LocatorT>;
+        <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+            descendants?: boolean;
+            read: ProviderToken<ReadT>;
+        }): Signal<ReadT>;
+    };
+}
+
 /**
  * Type of the ContentChildren metadata.
  *
@@ -1974,6 +2036,16 @@ export declare type ContentChildren = Query;
  */
 export declare const ContentChildren: ContentChildrenDecorator;
 
+export declare function contentChildren<LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
+    descendants?: boolean;
+    read?: undefined;
+}): Signal<ReadonlyArray<LocatorT>>;
+
+export declare function contentChildren<LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+    descendants?: boolean;
+    read: ProviderToken<ReadT>;
+}): Signal<ReadonlyArray<ReadT>>;
+
 /**
  * Type of the ContentChildren decorator / constructor function.
  *
@@ -3327,9 +3399,7 @@ declare type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDef
  *  - Because declared and public name are usually same we only generate the array
  *    `['declared', 'public']` format when they differ, or there is a transform.
  *  - The reason why this API and `outputs` API is not the same is that `NgOnChanges` has
- *    inconsistent behavior in that it uses declared names rather than minified or public. For
- *    this reason `NgOnChanges` will be deprecated and removed in future version and this
- *    API will be simplified to be consistent with `output`.
+ *    inconsistent behavior in that it uses declared names rather than minified or public.
  */
 declare type DirectiveInputs<T> = {
     [P in keyof T]?: string | [
@@ -6133,6 +6203,14 @@ declare interface LQueries {
      * @param tView
      */
     detachView(tView: TView): void;
+    /**
+     * A method called when a view finishes its creation pass. As a result all impacted
+     * `LQuery` objects (and associated `QueryList`) are marked as dirty. This additional dirty
+     * marking gives us a precise point in time where we can collect results for a given view in an
+     * atomic way.
+     * @param tView
+     */
+    finishViewCreation(tView: TView): void;
 }
 
 /**
@@ -6556,6 +6634,118 @@ export declare enum MissingTranslationStrategy {
     Ignore = 2
 }
 
+/**
+ * `model` declares a writeable signal that is exposed as an input/output pair on the containing
+ * directive. The input name is taken either from the class member or from the `alias` option.
+ * The output name is generated by taking the input name and appending `Change`.
+ *
+ * Initializes a model with an initial value. If no explicit value
+ * is specified, Angular will use `undefined`.
+ *
+ * Consider using `model.required` for models that don't need an
+ * initial value.
+ *
+ * @usageNotes
+ * Initialize a model in your directive or component by declaring a
+ * class field and initializing it with the `model()` or `model.required()`
+ * function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   firstName = model<string>();            // string|undefined
+ *   lastName = model.required<string>();    // string
+ *   age = model(0);                         // number
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare const model: ModelFunction;
+
+/**
+ * `model` declares a writeable signal that is exposed as an input/output pair on the containing
+ * directive. The input name is taken either from the class member or from the `alias` option.
+ * The output name is generated by taking the input name and appending `Change`.
+ *
+ * The function exposes an API for also declaring required models via the
+ * `model.required` function.
+ *
+ * @usageNotes
+ * Initialize a model in your directive or component by declaring a
+ * class field and initializing it with the `model()` or `model.required()`
+ * function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   firstName = model<string>();            // string|undefined
+ *   lastName = model.required<string>();    // string
+ *   age = model(0);                         // number
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare interface ModelFunction {
+    /**
+     * Initializes a model with an initial value. If no explicit value
+     * is specified, Angular will use `undefined`.
+     *
+     * Consider using `model.required` for models that don't need an
+     * initial value.
+     *
+     * @developerPreview
+     */
+    <T>(): ModelSignal<T | undefined>;
+    <T>(initialValue: T, opts?: ModelOptions): ModelSignal<T>;
+    /**
+     * Initializes a required model.
+     *
+     * Users of your directive/component need to bind to the input side of the model.
+     * If unset, a compile time error will be reported.
+     *
+     * @developerPreview
+     */
+    required<T>(opts?: ModelOptions): ModelSignal<T>;
+}
+
+/**
+ * @developerPreview
+ *
+ * Options for model signals.
+ */
+export declare interface ModelOptions {
+    /**
+     * Optional public name of the input side of the model. The output side will have the same
+     * name as the input, but suffixed with `Change`. By default, the class field name is used.
+     */
+    alias?: string;
+}
+
+/**
+ * `ModelSignal` represents a special `Signal` for a directive/component model field.
+ *
+ * A model signal is a writeable signal that can be exposed as an output.
+ * Whenever its value is updated, it emits to the output.
+ *
+ * @developerPreview
+ */
+export declare interface ModelSignal<T> extends WritableSignal<T> {
+    [SIGNAL]: ModelSignalNode<T>;
+    [ɵINPUT_SIGNAL_BRAND_READ_TYPE]: T;
+    [ɵINPUT_SIGNAL_BRAND_WRITE_TYPE]: T;
+}
+
+/**
+ * Reactive node type for a model signal. Model signals extend
+ * signals by adding the ability to track subscriptions and to be required.
+ */
+declare interface ModelSignalNode<T> extends SignalNode<T> {
+    /** Used by the runtime to write a value to the signal input. */
+    applyValueToInputSignal: (node: ModelSignalNode<T>, value: T) => void;
+}
+
 /**
  * Combination of NgModuleFactory and ComponentFactories.
  *
@@ -10662,6 +10852,29 @@ export declare type ViewChild = Query;
  */
 export declare const ViewChild: ViewChildDecorator;
 
+/**
+ * Initializes a view child query.
+ *
+ * Consider using `viewChild.required` for queries that should always match.
+ *
+ * @usageNotes
+ * Create a child query in your component by declaring a
+ * class field and initializing it with the `viewChild()` function.
+ *
+ * ```ts
+ * @Component({template: '<div #el></div><my-component #cmp />'})
+ * export class TestComponent {
+ *   divEl = viewChild<ElementRef>('el');                   // Signal<ElementRef|undefined>
+ *   divElRequired = viewChild.required<ElementRef>('el');  // Signal<ElementRef>
+ *   cmp = viewChild(MyComponent);                          // Signal<MyComponent|undefined>
+ *   cmpRequired = viewChild.required(MyComponent);         // Signal<MyComponent>
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare const viewChild: ViewChildFunction;
+
 /**
  * Type of the ViewChild decorator / constructor function.
  *
@@ -10735,6 +10948,38 @@ export declare interface ViewChildDecorator {
     }): ViewChild;
 }
 
+/**
+ * Type of the `viewChild` function. The viewChild function creates a singular view query.
+ *
+ * It is a special function that also provides access to required query results via the `.required`
+ * property.
+ *
+ * @developerPreview
+ */
+export declare interface ViewChildFunction {
+    /**
+     * Initializes a view child query. Consider using `viewChild.required` for queries that should
+     * always match.
+     *
+     * @developerPreview
+     */
+    <LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<LocatorT | undefined>;
+    <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+        read: ProviderToken<ReadT>;
+    }): Signal<ReadT | undefined>;
+    /**
+     * Initializes a view child query that is expected to always match an element.
+     *
+     * @developerPreview
+     */
+    required: {
+        <LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<LocatorT>;
+        <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+            read: ProviderToken<ReadT>;
+        }): Signal<ReadT>;
+    };
+}
+
 /**
  * Type of the ViewChildren metadata.
  *
@@ -10750,6 +10995,12 @@ export declare type ViewChildren = Query;
  */
 export declare const ViewChildren: ViewChildrenDecorator;
 
+export declare function viewChildren<LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<ReadonlyArray<LocatorT>>;
+
+export declare function viewChildren<LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+    read: ProviderToken<ReadT>;
+}): Signal<ReadonlyArray<ReadT>>;
+
 /**
  * Type of the ViewChildren decorator / constructor function.
  *
@@ -11101,10 +11352,14 @@ declare interface ViewRefTracker {
     detachView(viewRef: ViewRef): void;
 }
 
+/** Symbol used distinguish `WritableSignal` from other non-writable signals and functions. */
+declare const WRITABLE_SIGNAL: unique symbol;
+
 /**
  * A `Signal` with a value that can be mutated via a setter interface.
  */
 export declare interface WritableSignal<T> extends Signal<T> {
+    [WRITABLE_SIGNAL]: T;
     /**
      * Directly set the signal to a new value, and notify any dependents.
      */
@@ -11139,7 +11394,7 @@ export declare class ɵAfterRenderEventManager {
     /**
      * Executes callbacks. Returns `true` if any callbacks executed.
      */
-    execute(): boolean;
+    execute(): void;
     ngOnDestroy(): void;
     /** @nocollapse */
     static ɵprov: unknown;
@@ -11183,6 +11438,7 @@ export declare const enum ɵAnimationRendererType {
  */
 export declare function ɵannotateForHydration(appRef: ApplicationRef, doc: Document): void;
 
+
 /**
  * A set of marker values to be used in the attributes arrays. These markers indicate that some
  * items are not regular attributes and the processing should be adapted accordingly.
@@ -12424,6 +12680,56 @@ export declare function ɵnoSideEffects<T>(fn: () => T): T;
 
 export declare const ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR: {};
 
+/**
+ * The `outputs` function allows declaration of outputs in directives and
+ * components.
+ *
+ * Initializes an output that can emit values to consumers of your
+ * directive/component.
+ *
+ * @usageNotes
+ * Initialize an output in your directive by declaring a
+ * class field and initializing it with the `output()` function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   nameChange = output<string>();     // OutputEmitter<string>
+ *   onClick = output();                // OutputEmitter<void>
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare function ɵoutput<T = void>(opts?: ɵOutputOptions): ɵOutputEmitter<T>;
+
+
+/**
+ * An `OutputEmitter` is created by the `output()` function and can be
+ * used to emit values to consumers of your directive or component.
+ *
+ * Consumers of your directive/component can bind to the output and
+ * subscribe to changes via the bound event syntax. For example:
+ *
+ * ```html
+ * <my-comp (valueChange)="processNewValue($event)" />
+ * ```
+ *
+ * @developerPreview
+ */
+export declare interface ɵOutputEmitter<T> {
+    emit(value: T): void;
+}
+
+/**
+ * Options for declaring an output.
+ *
+ * @developerPreview
+ */
+export declare interface ɵOutputOptions {
+    alias?: string;
+}
+
 /**
  * Patch the definition of a component with directives and pipes from the compilation scope of
  * a given module.
@@ -12851,6 +13157,8 @@ export declare const enum ɵRuntimeErrorCode {
     COMPONENT_ID_COLLISION = -912,
     IMAGE_PERFORMANCE_WARNING = -913,
     REQUIRED_INPUT_NO_VALUE = -950,
+    REQUIRED_QUERY_NO_VALUE = -951,
+    REQUIRED_MODEL_NO_VALUE = -952,
     RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000,
     RUNTIME_DEPS_ORPHAN_COMPONENT = 1001
 }
@@ -13031,7 +13339,7 @@ export declare function ɵtriggerResourceLoading(tDetails: TDeferBlockDetails, l
  *
  * @param string
  * @param maxLength of the output string
- * @returns elispsed string with ... in the middle
+ * @returns ellipsed string with ... in the middle
  */
 export declare function ɵtruncateMiddle(str: string, maxLength?: number): string;
 
@@ -13055,6 +13363,14 @@ export declare function ɵunwrapSafeValue(value: ɵSafeValue): string;
 
 export declare function ɵunwrapSafeValue<T>(value: T): T;
 
+/**
+ * Utility function used during template type checking to extract the value from a `WritableSignal`.
+ * @codeGenApi
+ */
+export declare function ɵunwrapWritableSignal<T>(value: T | {
+    [WRITABLE_SIGNAL]: T;
+}): T;
+
 /**
  * Indicates whether to use the runtime dependency tracker for scope calculation in JIT compilation.
  * The value "false" means the old code path based on patching scope info into the types will be
@@ -13072,7 +13388,7 @@ export declare class ɵViewRef<T> implements EmbeddedViewRef<T>, ChangeDetectorR
      * This may be different from `_lView` if the `_cdRefInjectingView` is an embedded view.
      */
     private _cdRefInjectingView?;
-    private readonly notifyErrorHandler;
+    readonly notifyErrorHandler: boolean;
     private _appRef;
     private _attachedToViewContainer;
     get rootNodes(): any[];
@@ -14033,18 +14349,17 @@ export declare function ɵɵconditional<T>(containerIndex: number, matchingTempl
 export declare function ɵɵcontentQuery<T>(directiveIndex: number, predicate: ProviderToken<unknown> | string | string[], flags: QueryFlags, read?: any): void;
 
 /**
- * Registers a QueryList, associated with a content query, for later refresh (part of a view
- * refresh).
+ * Creates a new content query and binds it to a signal created by an authoring function.
  *
  * @param directiveIndex Current directive index
+ * @param target The target signal to which the query should be bound
  * @param predicate The type for which the query will search
  * @param flags Flags associated with the query
  * @param read What to save in the query
- * @returns QueryList<T>
  *
  * @codeGenApi
  */
-export declare function ɵɵcontentQuerySignal<T>(target: Signal<T>, directiveIndex: number, predicate: ProviderToken<unknown> | string[], flags: QueryFlags, read?: any): void;
+export declare function ɵɵcontentQuerySignal<T>(directiveIndex: number, target: Signal<T>, predicate: ProviderToken<unknown> | string[], flags: QueryFlags, read?: any): void;
 
 /**
  * Copies the fields not handled by the `ɵɵInheritDefinitionFeature` from the supertype of a
@@ -14763,6 +15078,7 @@ export declare interface ɵɵInjectorDef<T> {
     imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
 }
 
+
 /** Flags describing an input for a directive. */
 export declare enum ɵɵInputFlags {
     None = 0,
@@ -16951,6 +17267,41 @@ export declare function ɵɵtrustConstantHtml(html: TemplateStringsArray): Trust
  */
 export declare function ɵɵtrustConstantResourceUrl(url: TemplateStringsArray): TrustedScriptURL | string;
 
+/**
+ * Function used inside two-way listeners to conditionally set the value of the bound expression.
+ *
+ * @param target Field on which to set the value.
+ * @param value Value to be set to the field.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵtwoWayBindingSet<T>(target: unknown, value: T): boolean;
+
+/**
+ * Adds an event listener that updates a two-way binding to the current node.
+ *
+ * @param eventName Name of the event.
+ * @param listenerFn The function to be called when event emits.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵtwoWayListener(eventName: string, listenerFn: (e?: any) => any): typeof ɵɵtwoWayListener;
+
+/**
+ * Update a two-way bound property on a selected element.
+ *
+ * Operates on the element selected by index via the {@link select} instruction.
+ *
+ * @param propName Name of property.
+ * @param value New value to write.
+ * @param sanitizer An optional function used to sanitize the value.
+ * @returns This function returns itself so that it may be chained
+ * (e.g. `twoWayProperty('name', ctx.name)('title', ctx.title)`)
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵtwoWayProperty<T>(propName: string, value: T | WritableSignal<T>, sanitizer?: SanitizerFn | null): typeof ɵɵtwoWayProperty;
+
 
 /**
  * Validation function invoked at runtime for each binding that might potentially

package/package.json

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

package/primitives/signals/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.2.0-next.1
+ * @license Angular v17.2.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -14,7 +14,7 @@ declare type ComputedGetter<T> = (() => T) & {
  *
  * `Computed`s are both producers and consumers of reactivity.
  */
-declare interface ComputedNode<T> extends ReactiveNode {
+export declare interface ComputedNode<T> extends ReactiveNode {
     /**
      * Current value of the computation, or one of the sentinel values above (`UNSET`, `COMPUTING`,
      * `ERROR`).

package/rxjs-interop/index.d.ts

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