@angular/compiler-cli 13.1.0-next.1 → 13.1.1

package/src/transformers/metadata_cache.d.ts

@@ -1,27 +0,0 @@
-/**
- * @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
- */
-/// <amd-module name="@angular/compiler-cli/src/transformers/metadata_cache" />
-import ts from 'typescript';
-import { MetadataCollector, MetadataValue, ModuleMetadata } from '../metadata/index';
-import { MetadataProvider } from './compiler_host';
-export declare type ValueTransform = (value: MetadataValue, node: ts.Node) => MetadataValue;
-export interface MetadataTransformer {
-    connect?(cache: MetadataCache): void;
-    start(sourceFile: ts.SourceFile): ValueTransform | undefined;
-}
-/**
- * Cache, and potentially transform, metadata as it is being collected.
- */
-export declare class MetadataCache implements MetadataProvider {
-    private collector;
-    private readonly strict;
-    private transformers;
-    private metadataCache;
-    constructor(collector: MetadataCollector, strict: boolean, transformers: MetadataTransformer[]);
-    getMetadata(sourceFile: ts.SourceFile): ModuleMetadata | undefined;
-}

package/src/transformers/metadata_reader.d.ts

@@ -1,19 +0,0 @@
-/**
- * @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
- */
-/// <amd-module name="@angular/compiler-cli/src/transformers/metadata_reader" />
-import { ModuleMetadata } from '../metadata';
-export interface MetadataReaderHost {
-    getSourceFileMetadata(filePath: string): ModuleMetadata | undefined;
-    cacheMetadata?(fileName: string): boolean;
-    fileExists(filePath: string): boolean;
-    readFile(filePath: string): string;
-}
-export interface MetadataReaderCache {
-}
-export declare function createMetadataReaderCache(): MetadataReaderCache;
-export declare function readMetadata(filePath: string, host: MetadataReaderHost, cache?: MetadataReaderCache): ModuleMetadata[] | undefined;

package/src/transformers/node_emitter.d.ts

@@ -1,105 +0,0 @@
-/**
- * @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
- */
-/// <amd-module name="@angular/compiler-cli/src/transformers/node_emitter" />
-import { AssertNotNull, BinaryOperatorExpr, CastExpr, ClassStmt, CommaExpr, ConditionalExpr, DeclareFunctionStmt, DeclareVarStmt, ExpressionStatement, ExpressionVisitor, ExternalExpr, FunctionExpr, IfStmt, InstantiateExpr, InvokeFunctionExpr, LiteralArrayExpr, LiteralExpr, LiteralMapExpr, LocalizedString, NotExpr, ParseSourceSpan, PartialModule, ReadKeyExpr, ReadPropExpr, ReadVarExpr, ReturnStatement, Statement, StatementVisitor, TaggedTemplateExpr, ThrowStmt, TryCatchStmt, TypeofExpr, UnaryOperatorExpr, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr } from '@angular/compiler';
-import ts from 'typescript';
-export interface Node {
-    sourceSpan: ParseSourceSpan | null;
-}
-export declare class TypeScriptNodeEmitter {
-    private annotateForClosureCompiler;
-    constructor(annotateForClosureCompiler: boolean);
-    updateSourceFile(sourceFile: ts.SourceFile, stmts: Statement[], preamble?: string): [
-        ts.SourceFile,
-        Map<ts.Node, Node>
-    ];
-}
-/**
- * Update the given source file to include the changes specified in module.
- *
- * The module parameter is treated as a partial module meaning that the statements are added to
- * the module instead of replacing the module. Also, any classes are treated as partial classes
- * and the included members are added to the class with the same name instead of a new class
- * being created.
- */
-export declare function updateSourceFile(sourceFile: ts.SourceFile, module: PartialModule, annotateForClosureCompiler: boolean): [ts.SourceFile, Map<ts.Node, Node>];
-export declare type RecordedNode<T extends ts.Node = ts.Node> = (T & {
-    __recorded: any;
-}) | null;
-/**
- * Visits an output ast and produces the corresponding TypeScript synthetic nodes.
- */
-export declare class NodeEmitterVisitor implements StatementVisitor, ExpressionVisitor {
-    private annotateForClosureCompiler;
-    private _nodeMap;
-    private _importsWithPrefixes;
-    private _reexports;
-    private _templateSources;
-    private _exportedVariableIdentifiers;
-    constructor(annotateForClosureCompiler: boolean);
-    /**
-     * Process the source file and collect exported identifiers that refer to variables.
-     *
-     * Only variables are collected because exported classes still exist in the module scope in
-     * CommonJS, whereas variables have their declarations moved onto the `exports` object, and all
-     * references are updated accordingly.
-     */
-    loadExportedVariableIdentifiers(sourceFile: ts.SourceFile): void;
-    getReexports(): ts.Statement[];
-    getImports(): ts.Statement[];
-    getNodeMap(): Map<ts.Node, Node>;
-    updateSourceMap(statements: ts.Statement[]): void;
-    private postProcess;
-    private sourceRangeOf;
-    private getModifiers;
-    visitDeclareVarStmt(stmt: DeclareVarStmt): (ts.VariableStatement & {
-        __recorded: any;
-    }) | ((ts.VariableStatement & {
-        __recorded: any;
-    }) | (ts.ExportDeclaration & {
-        __recorded: any;
-    }) | null)[] | null;
-    visitDeclareFunctionStmt(stmt: DeclareFunctionStmt): RecordedNode<ts.FunctionDeclaration>;
-    visitExpressionStmt(stmt: ExpressionStatement): RecordedNode<ts.ExpressionStatement>;
-    visitReturnStmt(stmt: ReturnStatement): RecordedNode<ts.ReturnStatement>;
-    visitDeclareClassStmt(stmt: ClassStmt): RecordedNode<ts.ClassDeclaration>;
-    visitIfStmt(stmt: IfStmt): RecordedNode<ts.IfStatement>;
-    visitTryCatchStmt(stmt: TryCatchStmt): RecordedNode<ts.TryStatement>;
-    visitThrowStmt(stmt: ThrowStmt): RecordedNode<ts.ThrowStatement>;
-    visitWrappedNodeExpr(expr: WrappedNodeExpr<any>): any;
-    visitTypeofExpr(expr: TypeofExpr): RecordedNode<ts.TypeOfExpression>;
-    visitReadVarExpr(expr: ReadVarExpr): (ts.Identifier & {
-        __recorded: any;
-    }) | (ts.SuperExpression & {
-        __recorded: any;
-    }) | null;
-    visitWriteVarExpr(expr: WriteVarExpr): RecordedNode<ts.BinaryExpression>;
-    visitWriteKeyExpr(expr: WriteKeyExpr): RecordedNode<ts.BinaryExpression>;
-    visitWritePropExpr(expr: WritePropExpr): RecordedNode<ts.BinaryExpression>;
-    visitInvokeFunctionExpr(expr: InvokeFunctionExpr): RecordedNode<ts.CallExpression>;
-    visitTaggedTemplateExpr(expr: TaggedTemplateExpr): RecordedNode<ts.TaggedTemplateExpression>;
-    visitInstantiateExpr(expr: InstantiateExpr): RecordedNode<ts.NewExpression>;
-    visitLiteralExpr(expr: LiteralExpr): RecordedNode<ts.Identifier | ts.NullLiteral | ts.StringLiteral>;
-    visitLocalizedString(expr: LocalizedString, context: any): void;
-    visitExternalExpr(expr: ExternalExpr): RecordedNode<ts.Expression>;
-    visitConditionalExpr(expr: ConditionalExpr): RecordedNode<ts.ParenthesizedExpression>;
-    visitNotExpr(expr: NotExpr): RecordedNode<ts.PrefixUnaryExpression>;
-    visitAssertNotNullExpr(expr: AssertNotNull): RecordedNode<ts.Expression>;
-    visitCastExpr(expr: CastExpr): RecordedNode<ts.Expression>;
-    visitFunctionExpr(expr: FunctionExpr): RecordedNode<ts.FunctionExpression>;
-    visitUnaryOperatorExpr(expr: UnaryOperatorExpr): RecordedNode<ts.UnaryExpression | ts.ParenthesizedExpression>;
-    visitBinaryOperatorExpr(expr: BinaryOperatorExpr): RecordedNode<ts.BinaryExpression | ts.ParenthesizedExpression>;
-    visitReadPropExpr(expr: ReadPropExpr): RecordedNode<ts.PropertyAccessExpression>;
-    visitReadKeyExpr(expr: ReadKeyExpr): RecordedNode<ts.ElementAccessExpression>;
-    visitLiteralArrayExpr(expr: LiteralArrayExpr): RecordedNode<ts.ArrayLiteralExpression>;
-    visitLiteralMapExpr(expr: LiteralMapExpr): RecordedNode<ts.ObjectLiteralExpression>;
-    visitCommaExpr(expr: CommaExpr): RecordedNode<ts.Expression>;
-    private _visitStatements;
-    private _visitStatementsPrefix;
-    private _visitIdentifier;
-}

package/src/transformers/node_emitter_transform.d.ts

@@ -1,19 +0,0 @@
-/**
- * @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
- */
-/// <amd-module name="@angular/compiler-cli/src/transformers/node_emitter_transform" />
-import { GeneratedFile } from '@angular/compiler';
-import ts from 'typescript';
-/**
- * Returns a transformer that does two things for generated files (ngfactory etc):
- * - adds a fileoverview JSDoc comment containing Closure Compiler specific "suppress"ions in JSDoc.
- *   The new comment will contain any fileoverview comment text from the original source file this
- *   file was generated from.
- * - updates generated files that are not in the given map of generatedFiles to have an empty
- *   list of statements as their body.
- */
-export declare function getAngularEmitterTransformFactory(generatedFiles: Map<string, GeneratedFile>, program: ts.Program, annotateForClosureCompiler: boolean): () => (sourceFile: ts.SourceFile) => ts.SourceFile;

package/src/transformers/r3_metadata_transform.d.ts

@@ -1,16 +0,0 @@
-/**
- * @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
- */
-/// <amd-module name="@angular/compiler-cli/src/transformers/r3_metadata_transform" />
-import { PartialModule } from '@angular/compiler';
-import ts from 'typescript';
-import { MetadataTransformer, ValueTransform } from './metadata_cache';
-export declare class PartialModuleMetadataTransformer implements MetadataTransformer {
-    private moduleMap;
-    constructor(modules: PartialModule[]);
-    start(sourceFile: ts.SourceFile): ValueTransform | undefined;
-}

package/src/transformers/r3_transform.d.ts

@@ -1,16 +0,0 @@
-/**
- * @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
- */
-/// <amd-module name="@angular/compiler-cli/src/transformers/r3_transform" />
-import { PartialModule } from '@angular/compiler';
-import ts from 'typescript';
-export declare type Transformer = (sourceFile: ts.SourceFile) => ts.SourceFile;
-export declare type TransformerFactory = (context: ts.TransformationContext) => Transformer;
-/**
- * Returns a transformer that adds the requested static methods specified by modules.
- */
-export declare function getAngularClassTransformerFactory(modules: PartialModule[], annotateForClosureCompiler: boolean): TransformerFactory;