@angular/compiler 17.1.0-rc.0 → 17.1.0

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.1.0-rc.0
+ * @license Angular v17.1.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -579,6 +579,10 @@ export declare interface BoundTarget<DirectiveT extends DirectiveMeta> {
      * @param trigger Trigger whose target is being looked up.
      */
     getDeferredTriggerTarget(block: TmplAstDeferredBlock, trigger: TmplAstDeferredTrigger): TmplAstElement | null;
+    /**
+     * Whether a given node is located in a `@defer` block.
+     */
+    isDeferred(node: TmplAstElement): boolean;
 }
 
 export declare class BuiltinType extends Type {
@@ -687,7 +691,7 @@ export declare type CompileClassMetadataFn = (metadata: R3ClassMetadata) => outp
  * Similar to the `setClassMetadata` call, it's wrapped into the `ngDevMode`
  * check to tree-shake away this code in production mode.
  */
-export declare function compileComponentClassMetadata(metadata: R3ClassMetadata, deferrableTypes: Map<string, string>): outputAst.Expression;
+export declare function compileComponentClassMetadata(metadata: R3ClassMetadata, deferrableTypes: Map<string, string> | null): outputAst.Expression;
 
 /**
  * Compile a component for the render3 runtime as defined by the `R3ComponentMetadata`.
@@ -1017,6 +1021,30 @@ export declare class DeclareVarStmt extends Statement {
 
 export declare const DEFAULT_INTERPOLATION_CONFIG: InterpolationConfig;
 
+/**
+ * Defines how dynamic imports for deferred dependencies should be emitted in the
+ * generated output:
+ *  - either in a function on per-component basis (in case of local compilation)
+ *  - or in a function on per-block basis (in full compilation mode)
+ */
+export declare const enum DeferBlockDepsEmitMode {
+    /**
+     * Dynamic imports are grouped on per-block basis.
+     *
+     * This is used in full compilation mode, when compiler has more information
+     * about particular dependencies that belong to this block.
+     */
+    PerBlock = 0,
+    /**
+     * Dynamic imports are grouped on per-component basis.
+     *
+     * In local compilation, compiler doesn't have enough information to determine
+     * which deferred dependencies belong to which block. In this case we group all
+     * dynamic imports into a single file on per-component basis.
+     */
+    PerComponent = 1
+}
+
 export declare function devOnlyGuardedExpression(expr: outputAst.Expression): outputAst.Expression;
 
 /**
@@ -2870,10 +2898,11 @@ export declare class R3BoundTarget<DirectiveT extends DirectiveMeta> implements
     private usedPipes;
     private eagerPipes;
     private deferredBlocks;
+    private rootScope;
     constructor(target: Target, directives: Map<TmplAstElement | TmplAstTemplate, DirectiveT[]>, eagerDirectives: DirectiveT[], bindings: Map<TmplAstBoundAttribute | TmplAstBoundEvent | TmplAstTextAttribute, DirectiveT | TmplAstElement | TmplAstTemplate>, references: Map<TmplAstBoundAttribute | TmplAstBoundEvent | TmplAstReference | TmplAstTextAttribute, {
         directive: DirectiveT;
         node: TmplAstElement | TmplAstTemplate;
-    } | TmplAstElement | TmplAstTemplate>, exprTargets: Map<AST, TmplAstReference | TmplAstVariable>, symbols: Map<TmplAstReference | TmplAstVariable, TmplAstTemplate>, nestingLevel: Map<ScopedNode, number>, scopedNodeEntities: Map<ScopedNode | null, ReadonlySet<TmplAstReference | TmplAstVariable>>, usedPipes: Set<string>, eagerPipes: Set<string>, deferredBlocks: Set<TmplAstDeferredBlock>);
+    } | TmplAstElement | TmplAstTemplate>, exprTargets: Map<AST, TmplAstReference | TmplAstVariable>, symbols: Map<TmplAstReference | TmplAstVariable, TmplAstTemplate>, nestingLevel: Map<ScopedNode, number>, scopedNodeEntities: Map<ScopedNode | null, ReadonlySet<TmplAstReference | TmplAstVariable>>, usedPipes: Set<string>, eagerPipes: Set<string>, deferredBlocks: Set<TmplAstDeferredBlock>, rootScope: Scope);
     getEntitiesInScope(node: ScopedNode | null): ReadonlySet<TmplAstReference | TmplAstVariable>;
     getDirectivesOfNode(node: TmplAstElement | TmplAstTemplate): DirectiveT[] | null;
     getReferenceTarget(ref: TmplAstReference): ReferenceTarget<DirectiveT> | null;
@@ -2887,6 +2916,7 @@ export declare class R3BoundTarget<DirectiveT extends DirectiveMeta> implements
     getEagerlyUsedPipes(): string[];
     getDeferBlocks(): TmplAstDeferredBlock[];
     getDeferredTriggerTarget(block: TmplAstDeferredBlock, trigger: TmplAstDeferredTrigger): TmplAstElement | null;
+    isDeferred(element: TmplAstElement): boolean;
     /**
      * Finds an entity with a specific name in a scope.
      * @param rootNode Root node of the scope.
@@ -2998,6 +3028,16 @@ export declare interface R3ComponentMetadata<DeclarationT extends R3TemplateDepe
      * Map of `@defer` blocks -> their corresponding metadata.
      */
     deferBlocks: Map<t.DeferredBlock, R3DeferBlockMetadata>;
+    /**
+     * Defines how dynamic imports for deferred dependencies should be grouped:
+     *  - either in a function on per-component basis (in case of local compilation)
+     *  - or in a function on per-block basis (in full compilation mode)
+     */
+    deferBlockDepsEmitMode: DeferBlockDepsEmitMode;
+    /**
+     * Map of deferrable symbol names -> corresponding import paths.
+     */
+    deferrableTypes: Map<string, string>;
     /**
      * Specifies how the 'directives' and/or `pipes` array, if generated, need to be emitted.
      */
@@ -4529,6 +4569,80 @@ export declare interface SchemaMetadata {
     name: string;
 }
 
+/**
+ * Represents a binding scope within a template.
+ *
+ * Any variables, references, or other named entities declared within the template will
+ * be captured and available by name in `namedEntities`. Additionally, child templates will
+ * be analyzed and have their child `Scope`s available in `childScopes`.
+ */
+declare class Scope implements Visitor_3 {
+    readonly parentScope: Scope | null;
+    readonly rootNode: ScopedNode | null;
+    /**
+     * Named members of the `Scope`, such as `Reference`s or `Variable`s.
+     */
+    readonly namedEntities: Map<string, TmplAstVariable | TmplAstReference>;
+    /**
+     * Set of elements that belong to this scope.
+     */
+    readonly elementsInScope: Set<TmplAstElement>;
+    /**
+     * Child `Scope`s for immediately nested `ScopedNode`s.
+     */
+    readonly childScopes: Map<ScopedNode, Scope>;
+    /** Whether this scope is deferred or if any of its ancestors are deferred. */
+    readonly isDeferred: boolean;
+    private constructor();
+    static newRootScope(): Scope;
+    /**
+     * Process a template (either as a `Template` sub-template with variables, or a plain array of
+     * template `Node`s) and construct its `Scope`.
+     */
+    static apply(template: TmplAstNode[]): Scope;
+    /**
+     * Internal method to process the scoped node and populate the `Scope`.
+     */
+    private ingest;
+    visitElement(element: TmplAstElement): void;
+    visitTemplate(template: TmplAstTemplate): void;
+    visitVariable(variable: TmplAstVariable): void;
+    visitReference(reference: TmplAstReference): void;
+    visitDeferredBlock(deferred: TmplAstDeferredBlock): void;
+    visitDeferredBlockPlaceholder(block: TmplAstDeferredBlockPlaceholder): void;
+    visitDeferredBlockError(block: TmplAstDeferredBlockError): void;
+    visitDeferredBlockLoading(block: TmplAstDeferredBlockLoading): void;
+    visitSwitchBlock(block: TmplAstSwitchBlock): void;
+    visitSwitchBlockCase(block: TmplAstSwitchBlockCase): void;
+    visitForLoopBlock(block: TmplAstForLoopBlock): void;
+    visitForLoopBlockEmpty(block: TmplAstForLoopBlockEmpty): void;
+    visitIfBlock(block: TmplAstIfBlock): void;
+    visitIfBlockBranch(block: TmplAstIfBlockBranch): void;
+    visitContent(content: TmplAstContent): void;
+    visitBoundAttribute(attr: TmplAstBoundAttribute): void;
+    visitBoundEvent(event: TmplAstBoundEvent): void;
+    visitBoundText(text: TmplAstBoundText): void;
+    visitText(text: TmplAstText): void;
+    visitTextAttribute(attr: TmplAstTextAttribute): void;
+    visitIcu(icu: TmplAstIcu): void;
+    visitDeferredTrigger(trigger: TmplAstDeferredTrigger): void;
+    visitUnknownBlock(block: TmplAstUnknownBlock): void;
+    private maybeDeclare;
+    /**
+     * Look up a variable within this `Scope`.
+     *
+     * This can recurse into a parent `Scope` if it's available.
+     */
+    lookup(name: string): TmplAstReference | TmplAstVariable | null;
+    /**
+     * Get the child scope for a `ScopedNode`.
+     *
+     * This should always be defined.
+     */
+    getChildScope(node: ScopedNode): Scope;
+    private ingestScopedNode;
+}
+
 /** Node that has a `Scope` associated with it. */
 export declare type ScopedNode = TmplAstTemplate | TmplAstSwitchBlockCase | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty | TmplAstDeferredBlock | TmplAstDeferredBlockError | TmplAstDeferredBlockLoading | TmplAstDeferredBlockPlaceholder;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler",
-  "version": "17.1.0-rc.0",
+  "version": "17.1.0",
   "description": "Angular - the compiler library",
   "author": "angular",
   "license": "MIT",
@@ -11,7 +11,7 @@
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/core": "17.1.0-rc.0"
+    "@angular/core": "17.1.0"
   },
   "peerDependenciesMeta": {
     "@angular/core": {