@angular/compiler-cli 13.0.3 → 13.1.0-next.3

package/src/metadata/schema.d.ts

@@ -1,182 +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/metadata/schema" />
-export declare const METADATA_VERSION = 4;
-export declare type MetadataEntry = ClassMetadata | InterfaceMetadata | FunctionMetadata | MetadataValue;
-export interface ModuleMetadata {
-    __symbolic: 'module';
-    version: number;
-    exports?: ModuleExportMetadata[];
-    importAs?: string;
-    metadata: {
-        [name: string]: MetadataEntry;
-    };
-    origins?: {
-        [name: string]: string;
-    };
-}
-export declare function isModuleMetadata(value: any): value is ModuleMetadata;
-export interface ModuleExportMetadata {
-    export?: (string | {
-        name: string;
-        as: string;
-    })[];
-    from: string;
-}
-export interface ClassMetadata {
-    __symbolic: 'class';
-    extends?: MetadataSymbolicExpression | MetadataError;
-    arity?: number;
-    decorators?: (MetadataSymbolicExpression | MetadataError)[];
-    members?: MetadataMap;
-    statics?: {
-        [name: string]: MetadataValue | FunctionMetadata;
-    };
-}
-export declare function isClassMetadata(value: any): value is ClassMetadata;
-export interface InterfaceMetadata {
-    __symbolic: 'interface';
-}
-export declare function isInterfaceMetadata(value: any): value is InterfaceMetadata;
-export interface MetadataMap {
-    [name: string]: MemberMetadata[];
-}
-export interface MemberMetadata {
-    __symbolic: 'constructor' | 'method' | 'property';
-    decorators?: (MetadataSymbolicExpression | MetadataError)[];
-    parameters?: (MetadataSymbolicExpression | MetadataError | null | undefined)[];
-}
-export declare function isMemberMetadata(value: any): value is MemberMetadata;
-export interface MethodMetadata extends MemberMetadata {
-    __symbolic: 'constructor' | 'method';
-    parameterDecorators?: ((MetadataSymbolicExpression | MetadataError)[] | undefined)[];
-}
-export declare function isMethodMetadata(value: any): value is MethodMetadata;
-export interface ConstructorMetadata extends MethodMetadata {
-    __symbolic: 'constructor';
-    parameters?: (MetadataSymbolicExpression | MetadataError | null | undefined)[];
-}
-export declare function isConstructorMetadata(value: any): value is ConstructorMetadata;
-export interface FunctionMetadata {
-    __symbolic: 'function';
-    parameters: string[];
-    defaults?: MetadataValue[];
-    value: MetadataValue;
-}
-export declare function isFunctionMetadata(value: any): value is FunctionMetadata;
-export declare type MetadataValue = string | number | boolean | undefined | null | MetadataObject | MetadataArray | MetadataSymbolicExpression | MetadataSymbolicReferenceExpression | MetadataSymbolicBinaryExpression | MetadataSymbolicIndexExpression | MetadataSymbolicCallExpression | MetadataSymbolicPrefixExpression | MetadataSymbolicIfExpression | MetadataSymbolicSpreadExpression | MetadataSymbolicSelectExpression | MetadataError;
-export interface MetadataObject {
-    [name: string]: MetadataValue;
-}
-export interface MetadataArray {
-    [name: number]: MetadataValue;
-}
-export declare type MetadataSymbolicExpression = MetadataSymbolicBinaryExpression | MetadataSymbolicIndexExpression | MetadataSymbolicIndexExpression | MetadataSymbolicCallExpression | MetadataSymbolicCallExpression | MetadataSymbolicPrefixExpression | MetadataSymbolicIfExpression | MetadataGlobalReferenceExpression | MetadataModuleReferenceExpression | MetadataImportedSymbolReferenceExpression | MetadataImportedDefaultReferenceExpression | MetadataSymbolicSelectExpression | MetadataSymbolicSpreadExpression;
-export declare function isMetadataSymbolicExpression(value: any): value is MetadataSymbolicExpression;
-export interface MetadataSymbolicBinaryExpression {
-    __symbolic: 'binary';
-    operator: '&&' | '||' | '|' | '^' | '&' | '==' | '!=' | '===' | '!==' | '<' | '>' | '<=' | '>=' | 'instanceof' | 'in' | 'as' | '<<' | '>>' | '>>>' | '+' | '-' | '*' | '/' | '%' | '**' | '??';
-    left: MetadataValue;
-    right: MetadataValue;
-}
-export declare function isMetadataSymbolicBinaryExpression(value: any): value is MetadataSymbolicBinaryExpression;
-export interface MetadataSymbolicIndexExpression {
-    __symbolic: 'index';
-    expression: MetadataValue;
-    index: MetadataValue;
-}
-export declare function isMetadataSymbolicIndexExpression(value: any): value is MetadataSymbolicIndexExpression;
-export interface MetadataSymbolicCallExpression {
-    __symbolic: 'call' | 'new';
-    expression: MetadataValue;
-    arguments?: MetadataValue[];
-}
-export declare function isMetadataSymbolicCallExpression(value: any): value is MetadataSymbolicCallExpression;
-export interface MetadataSymbolicPrefixExpression {
-    __symbolic: 'pre';
-    operator: '+' | '-' | '~' | '!';
-    operand: MetadataValue;
-}
-export declare function isMetadataSymbolicPrefixExpression(value: any): value is MetadataSymbolicPrefixExpression;
-export interface MetadataSymbolicIfExpression {
-    __symbolic: 'if';
-    condition: MetadataValue;
-    thenExpression: MetadataValue;
-    elseExpression: MetadataValue;
-}
-export declare function isMetadataSymbolicIfExpression(value: any): value is MetadataSymbolicIfExpression;
-export interface MetadataSourceLocationInfo {
-    /**
-     * The line number of the error in the .ts file the metadata was created for.
-     */
-    line?: number;
-    /**
-     * The number of utf8 code-units from the beginning of the file of the error.
-     */
-    character?: number;
-}
-export interface MetadataGlobalReferenceExpression extends MetadataSourceLocationInfo {
-    __symbolic: 'reference';
-    name: string;
-    arguments?: MetadataValue[];
-}
-export declare function isMetadataGlobalReferenceExpression(value: any): value is MetadataGlobalReferenceExpression;
-export interface MetadataModuleReferenceExpression extends MetadataSourceLocationInfo {
-    __symbolic: 'reference';
-    module: string;
-}
-export declare function isMetadataModuleReferenceExpression(value: any): value is MetadataModuleReferenceExpression;
-export interface MetadataImportedSymbolReferenceExpression extends MetadataSourceLocationInfo {
-    __symbolic: 'reference';
-    module: string;
-    name: string;
-    arguments?: MetadataValue[];
-}
-export declare function isMetadataImportedSymbolReferenceExpression(value: any): value is MetadataImportedSymbolReferenceExpression;
-export interface MetadataImportedDefaultReferenceExpression extends MetadataSourceLocationInfo {
-    __symbolic: 'reference';
-    module: string;
-    default: boolean;
-    arguments?: MetadataValue[];
-}
-export declare function isMetadataImportDefaultReference(value: any): value is MetadataImportedDefaultReferenceExpression;
-export declare type MetadataSymbolicReferenceExpression = MetadataGlobalReferenceExpression | MetadataModuleReferenceExpression | MetadataImportedSymbolReferenceExpression | MetadataImportedDefaultReferenceExpression;
-export declare function isMetadataSymbolicReferenceExpression(value: any): value is MetadataSymbolicReferenceExpression;
-export interface MetadataSymbolicSelectExpression {
-    __symbolic: 'select';
-    expression: MetadataValue;
-    member: string;
-}
-export declare function isMetadataSymbolicSelectExpression(value: any): value is MetadataSymbolicSelectExpression;
-export interface MetadataSymbolicSpreadExpression {
-    __symbolic: 'spread';
-    expression: MetadataValue;
-}
-export declare function isMetadataSymbolicSpreadExpression(value: any): value is MetadataSymbolicSpreadExpression;
-export interface MetadataError extends MetadataSourceLocationInfo {
-    __symbolic: 'error';
-    /**
-     * This message should be short and relatively discriptive and should be fixed once it is created.
-     * If the reader doesn't recognize the message, it will display the message unmodified. If the
-     * reader recognizes the error message is it free to use substitute message the is more
-     * descriptive and/or localized.
-     */
-    message: string;
-    /**
-     * The module of the error (only used in bundled metadata)
-     */
-    module?: string;
-    /**
-     * Context information that can be used to generate a more descriptive error message. The content
-     * of the context is dependent on the error message.
-     */
-    context?: {
-        [name: string]: string;
-    };
-}
-export declare function isMetadataError(value: any): value is MetadataError;

package/src/metadata/symbols.d.ts

@@ -1,22 +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/metadata/symbols" />
-import ts from 'typescript';
-import { MetadataSymbolicReferenceExpression, MetadataValue } from './schema';
-export declare class Symbols {
-    private sourceFile;
-    private _symbols;
-    private references;
-    constructor(sourceFile: ts.SourceFile);
-    resolve(name: string, preferReference?: boolean): MetadataValue | undefined;
-    define(name: string, value: MetadataValue): void;
-    defineReference(name: string, value: MetadataSymbolicReferenceExpression): void;
-    has(name: string): boolean;
-    private get symbols();
-    private buildImports;
-}

package/src/transformers/inline_resources.d.ts

@@ -1,26 +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/inline_resources" />
-import ts from 'typescript';
-import { MetadataObject, MetadataValue } from '../metadata/index';
-import { MetadataTransformer, ValueTransform } from './metadata_cache';
-/** A subset of members from AotCompilerHost */
-export declare type ResourcesHost = {
-    resourceNameToFileName(resourceName: string, containingFileName: string): string | null;
-    loadResource(path: string): Promise<string> | string;
-};
-export declare type StaticResourceLoader = {
-    get(url: string | MetadataValue): string;
-};
-export declare class InlineResourcesMetadataTransformer implements MetadataTransformer {
-    private host;
-    constructor(host: ResourcesHost);
-    start(sourceFile: ts.SourceFile): ValueTransform | undefined;
-    updateDecoratorMetadata(loader: StaticResourceLoader, arg: MetadataObject): MetadataObject;
-}
-export declare function getInlineResourcesTransformFactory(program: ts.Program, host: ResourcesHost): ts.TransformerFactory<ts.SourceFile>;

package/src/transformers/lower_expressions.d.ts

@@ -1,30 +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/lower_expressions" />
-import ts from 'typescript';
-import { MetadataCache, MetadataTransformer, ValueTransform } from './metadata_cache';
-export interface LoweringRequest {
-    kind: ts.SyntaxKind;
-    location: number;
-    end: number;
-    name: string;
-}
-export declare type RequestLocationMap = Map<number, LoweringRequest>;
-export declare function getExpressionLoweringTransformFactory(requestsMap: RequestsMap, program: ts.Program): (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile;
-export interface RequestsMap {
-    getRequests(sourceFile: ts.SourceFile): RequestLocationMap;
-}
-export declare class LowerMetadataTransform implements RequestsMap, MetadataTransformer {
-    private cache;
-    private requests;
-    private lowerableFieldNames;
-    constructor(lowerableFieldNames: string[]);
-    getRequests(sourceFile: ts.SourceFile): RequestLocationMap;
-    connect(cache: MetadataCache): void;
-    start(sourceFile: ts.SourceFile): ValueTransform | undefined;
-}

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;