@angular/compiler-cli 17.3.1 → 17.3.2

package/src/ngtsc/translator/src/import_manager/reuse_generated_imports.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import ts from 'typescript';
+import { ImportRequest } from '../api/import_generator';
+import type { ModuleName } from './import_manager';
+/** Branded string identifying a hashed {@link ImportRequest}. */
+type ImportRequestHash = string & {
+    __importHash: string;
+};
+/** Tracker capturing re-used generated imports. */
+export interface ReuseGeneratedImportsTracker {
+    /**
+     * Map of previously resolved symbol imports. Cache can be re-used to return
+     * the same identifier without checking the source-file again.
+     */
+    directReuseCache: Map<ImportRequestHash, ts.Identifier | [ts.Identifier, ts.Identifier]>;
+    /**
+     * Map of module names and their potential namespace import
+     * identifiers. Allows efficient re-using of namespace imports.
+     */
+    namespaceImportReuseCache: Map<ModuleName, ts.Identifier>;
+}
+/** Attempts to efficiently re-use previous generated import requests. */
+export declare function attemptToReuseGeneratedImports(tracker: ReuseGeneratedImportsTracker, request: ImportRequest<ts.SourceFile>): ts.Identifier | [ts.Identifier, ts.Identifier] | null;
+/** Captures the given import request and its generated reference node/path for future re-use. */
+export declare function captureGeneratedImport(request: ImportRequest<ts.SourceFile>, tracker: ReuseGeneratedImportsTracker, referenceNode: ts.Identifier | [ts.Identifier, ts.Identifier]): void;
+export {};

package/src/ngtsc/translator/src/import_manager/reuse_source_file_imports.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import ts from 'typescript';
+import { AliasImportDeclaration } from '../../../imports';
+import { ImportRequest } from '../api/import_generator';
+/**
+ * Tracker necessary for enabling re-use of original source file imports.
+ *
+ * The tracker holds information about original source file imports that
+ * need to be updated, or import declarations/specifiers that are now
+ * referenced due to the import manager.
+ */
+export interface ReuseExistingSourceFileImportsTracker {
+    /**
+     * Map of import declarations that need to be updated to include the
+     * given symbols.
+     */
+    updatedImports: Map<ts.ImportDeclaration, {
+        propertyName: ts.Identifier;
+        fileUniqueAlias: ts.Identifier | null;
+    }[]>;
+    /**
+     * Set of re-used alias import declarations.
+     *
+     * These are captured so that we can tell TypeScript to not elide these source file
+     * imports as we introduced references to them. More details: {@link AliasImportDeclaration}.
+     */
+    reusedAliasDeclarations: Set<AliasImportDeclaration>;
+    /** Generates a unique identifier for a name in the given file. */
+    generateUniqueIdentifier(file: ts.SourceFile, symbolName: string): ts.Identifier | null;
+}
+/** Attempts to re-use original source file imports for the given request. */
+export declare function attemptToReuseExistingSourceFileImports(tracker: ReuseExistingSourceFileImportsTracker, sourceFile: ts.SourceFile, request: ImportRequest<ts.SourceFile>): ts.Identifier | [ts.Identifier, ts.Identifier] | null;

package/src/ngtsc/translator/src/translator.d.ts

@@ -16,13 +16,14 @@ export interface TranslatorOptions<TExpression> {
     recordWrappedNode?: RecordWrappedNodeFn<TExpression>;
     annotateForClosureCompiler?: boolean;
 }
-export declare class ExpressionTranslatorVisitor<TStatement, TExpression> implements o.ExpressionVisitor, o.StatementVisitor {
+export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression> implements o.ExpressionVisitor, o.StatementVisitor {
     private factory;
     private imports;
+    private contextFile;
     private downlevelTaggedTemplates;
     private downlevelVariableDeclarations;
     private recordWrappedNode;
-    constructor(factory: AstFactory<TStatement, TExpression>, imports: ImportGenerator<TExpression>, options: TranslatorOptions<TExpression>);
+    constructor(factory: AstFactory<TStatement, TExpression>, imports: ImportGenerator<TFile, TExpression>, contextFile: TFile, options: TranslatorOptions<TExpression>);
     visitDeclareVarStmt(stmt: o.DeclareVarStmt, context: Context): TStatement;
     visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, context: Context): TStatement;
     visitExpressionStmt(stmt: o.ExpressionStatement, context: Context): TStatement;

package/src/ngtsc/translator/src/type_translator.d.ts

@@ -9,5 +9,5 @@ import * as o from '@angular/compiler';
 import ts from 'typescript';
 import { ReferenceEmitter } from '../../imports';
 import { ReflectionHost } from '../../reflection';
-import { ImportManager } from './import_manager';
+import { ImportManager } from './import_manager/import_manager';
 export declare function translateType(type: o.Type, contextFile: ts.SourceFile, reflector: ReflectionHost, refEmitter: ReferenceEmitter, imports: ImportManager): ts.TypeNode;

package/src/ngtsc/translator/src/typescript_translator.d.ts

@@ -9,5 +9,5 @@ import * as o from '@angular/compiler';
 import ts from 'typescript';
 import { ImportGenerator } from './api/import_generator';
 import { TranslatorOptions } from './translator';
-export declare function translateExpression(expression: o.Expression, imports: ImportGenerator<ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Expression;
-export declare function translateStatement(statement: o.Statement, imports: ImportGenerator<ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Statement;
+export declare function translateExpression(contextFile: ts.SourceFile, expression: o.Expression, imports: ImportGenerator<ts.SourceFile, ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Expression;
+export declare function translateStatement(contextFile: ts.SourceFile, statement: o.Statement, imports: ImportGenerator<ts.SourceFile, ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Statement;

package/src/ngtsc/typecheck/src/reference_emit_environment.d.ts

@@ -20,7 +20,7 @@ export declare class ReferenceEmitEnvironment {
     readonly importManager: ImportManager;
     protected refEmitter: ReferenceEmitter;
     readonly reflector: ReflectionHost;
-    protected contextFile: ts.SourceFile;
+    contextFile: ts.SourceFile;
     constructor(importManager: ImportManager, refEmitter: ReferenceEmitter, reflector: ReflectionHost, contextFile: ts.SourceFile);
     canReferenceType(ref: Reference, flags?: ImportFlags): boolean;
     /**

package/src/ngtsc/typecheck/src/ts_util.d.ts

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import ts from 'typescript';
-import { Import } from '../../translator';
 export declare function tsCastToAny(expr: ts.Expression): ts.Expression;
 /**
  * Create an expression which instantiates an element by its HTML tagName.
@@ -49,4 +48,3 @@ export declare function isAccessExpression(node: ts.Node): node is ts.ElementAcc
  * Creates a TypeScript node representing a numeric value.
  */
 export declare function tsNumericExpression(value: number): ts.NumericLiteral | ts.PrefixUnaryExpression;
-export declare function getImportString(imp: Import): string;

package/src/transformers/jit_transforms/initializer_api_transforms/transform_api.d.ts

@@ -7,11 +7,11 @@
  */
 import ts from 'typescript';
 import { ImportedSymbolsTracker } from '../../../ngtsc/imports';
-import { Decorator, ReflectionHost } from '../../../ngtsc/reflection';
+import { ClassMember, Decorator, ReflectionHost } from '../../../ngtsc/reflection';
 import { ImportManager } from '../../../ngtsc/translator';
 /** Function that can be used to transform class properties. */
-export type PropertyTransform = (node: ts.PropertyDeclaration & {
-    name: ts.Identifier | ts.StringLiteralLike;
+export type PropertyTransform = (member: Pick<ClassMember, 'name' | 'accessLevel' | 'value'> & {
+    node: ts.PropertyDeclaration;
 }, host: ReflectionHost, factory: ts.NodeFactory, importTracker: ImportedSymbolsTracker, importManager: ImportManager, classDecorator: Decorator, isCore: boolean) => ts.PropertyDeclaration;
 /**
  * Creates an import and access for a given Angular core import while
@@ -19,6 +19,6 @@ export type PropertyTransform = (node: ts.PropertyDeclaration & {
  * import in order to make the synthetic decorator compatible with the JIT
  * decorator downlevel transform.
  */
-export declare function createSyntheticAngularCoreDecoratorAccess(factory: ts.NodeFactory, importManager: ImportManager, ngClassDecorator: Decorator, decoratorName: string): ts.PropertyAccessExpression;
+export declare function createSyntheticAngularCoreDecoratorAccess(factory: ts.NodeFactory, importManager: ImportManager, ngClassDecorator: Decorator, sourceFile: ts.SourceFile, decoratorName: string): ts.PropertyAccessExpression;
 /** Casts the given expression as `any`. */
 export declare function castAsAny(factory: ts.NodeFactory, expr: ts.Expression): ts.Expression;