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

package/index.d.ts

@@ -1,7 +1,6 @@
 /// <amd-module name="@angular/compiler-cli" />
 export { AotCompilerHost, AotCompilerHost as StaticReflectorHost, StaticReflector, StaticSymbol } from '@angular/compiler';
 export { VERSION } from './src/version';
-export * from './src/metadata';
 export * from './src/transformers/api';
 export * from './src/transformers/entry_points';
 export * from './src/perform_compile';

package/ngcc/src/packages/build_marker.d.ts

@@ -9,7 +9,7 @@
 import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
 import { PackageJsonUpdater } from '../writing/package_json_updater';
 import { EntryPointPackageJson, PackageJsonFormatProperties } from './entry_point';
-export declare const NGCC_VERSION = "13.0.3";
+export declare const NGCC_VERSION = "13.1.0-next.3";
 /**
  * Returns true if there is a format in this entry-point that was compiled with an outdated version
  * of ngcc.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "13.0.3",
+  "version": "13.1.0-next.3",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -66,8 +66,8 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "13.0.3",
-    "typescript": ">=4.4.2 <4.5"
+    "@angular/compiler": "13.1.0-next.3",
+    "typescript": ">=4.4.2 <4.6"
   },
   "repository": {
     "type": "git",

package/src/ngtsc/core/src/host.d.ts

@@ -42,12 +42,13 @@ export declare class DelegatingCompilerHost implements Omit<RequiredDelegations<
     readResource: ((fileName: string) => string | Promise<string>) | undefined;
     transformResource: ((data: string, context: import("@angular/compiler-cli/src/ngtsc/core/api/index").ResourceHostContext) => Promise<import("@angular/compiler-cli/src/ngtsc/core/api/index").TransformResourceResult | null>) | undefined;
     realpath: ((path: string) => string) | undefined;
-    resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedModule | undefined)[]) | undefined;
+    resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingSourceFile?: ts.SourceFile | undefined) => (ts.ResolvedModule | undefined)[]) | undefined;
     resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
     resourceNameToFileName: ((resourceName: string, containingFilePath: string, fallbackResolve?: ((url: string, fromFile: string) => string | null) | undefined) => string | null) | undefined;
     trace: ((s: string) => void) | undefined;
     useCaseSensitiveFileNames: () => boolean;
     writeFile: ts.WriteFileCallback;
+    getModuleResolutionCache: any;
 }
 /**
  * A wrapper around `ts.CompilerHost` (plus any extension methods from `ExtendedTsCompilerHost`).

package/src/ngtsc/program_driver/src/ts_create_program_driver.d.ts

@@ -36,10 +36,11 @@ export declare class DelegatingCompilerHost implements Omit<RequiredDelegations<
     readDirectory: ((rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined) => string[]) | undefined;
     readFile: (fileName: string) => string | undefined;
     realpath: ((path: string) => string) | undefined;
-    resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedModule | undefined)[]) | undefined;
+    resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingSourceFile?: ts.SourceFile | undefined) => (ts.ResolvedModule | undefined)[]) | undefined;
     resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
     trace: ((s: string) => void) | undefined;
     useCaseSensitiveFileNames: () => boolean;
+    getModuleResolutionCache: any;
 }
 /**
  * Updates a `ts.Program` instance with a new one that incorporates specific changes, using the

package/src/ngtsc/reflection/src/host.d.ts

@@ -290,7 +290,7 @@ export interface NoValueDeclaration {
 export interface TypeOnlyImport {
     kind: ValueUnavailableKind.TYPE_ONLY_IMPORT;
     typeNode: ts.TypeNode;
-    importClause: ts.ImportClause;
+    node: ts.ImportClause | ts.ImportSpecifier;
 }
 export interface NamespaceImport {
     kind: ValueUnavailableKind.NAMESPACE;

package/src/ngtsc/util/src/typescript.d.ts

@@ -62,3 +62,13 @@ export declare type RequiredDelegations<T> = {
  * Obtains the non-redirected source file for `sf`.
  */
 export declare function toUnredirectedSourceFile(sf: ts.SourceFile): ts.SourceFile;
+/**
+ * Backwards-compatible version of `ts.createExportSpecifier`
+ * to handle a breaking change between 4.4 and 4.5.
+ */
+export declare function createExportSpecifier(propertyName: string | ts.Identifier | undefined, name: string | ts.Identifier, isTypeOnly?: boolean): ts.ExportSpecifier;
+/**
+ * Backwards-compatible version of `ts.createImportSpecifier`
+ * to handle a breaking change between 4.4 and 4.5.
+ */
+export declare function createImportSpecifier(propertyName: string | ts.Identifier | undefined, name: string | ts.Identifier, isTypeOnly?: boolean): ts.ImportSpecifier;

package/src/transformers/compiler_host.d.ts

@@ -6,106 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/transformers/compiler_host" />
-import { AotCompilerHost, GeneratedFile, ParseSourceSpan } from '@angular/compiler';
 import ts from 'typescript';
-import { TypeCheckHost } from '../diagnostics/translate_diagnostics';
-import { ModuleMetadata } from '../metadata/index';
-import { CompilerHost, CompilerOptions, LibrarySummary } from './api';
+import { CompilerHost, CompilerOptions } from './api';
 export declare function setWrapHostForTest(wrapFn: ((host: ts.CompilerHost) => ts.CompilerHost) | null): void;
 export declare function createCompilerHost({ options, tsHost }: {
     options: CompilerOptions;
     tsHost?: ts.CompilerHost;
 }): CompilerHost;
-export interface MetadataProvider {
-    getMetadata(sourceFile: ts.SourceFile): ModuleMetadata | undefined;
-}
-export interface CodeGenerator {
-    generateFile(genFileName: string, baseFileName?: string): GeneratedFile;
-    findGeneratedFileNames(fileName: string): string[];
-}
-/**
- * Implements the following hosts based on an api.CompilerHost:
- * - ts.CompilerHost to be consumed by a ts.Program
- * - AotCompilerHost for @angular/compiler
- * - TypeCheckHost for mapping ts errors to ng errors (via translateDiagnostics)
- */
-export declare class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHost, AotCompilerHost, TypeCheckHost {
-    private rootFiles;
-    private options;
-    private context;
-    private metadataProvider;
-    private codeGenerator;
-    private librarySummaries;
-    private metadataReaderCache;
-    private fileNameToModuleNameCache;
-    private flatModuleIndexCache;
-    private flatModuleIndexNames;
-    private flatModuleIndexRedirectNames;
-    private rootDirs;
-    private moduleResolutionCache;
-    private originalSourceFiles;
-    private originalFileExistsCache;
-    private generatedSourceFiles;
-    private generatedCodeFor;
-    private emitter;
-    private metadataReaderHost;
-    getCancellationToken: () => ts.CancellationToken;
-    getDefaultLibLocation: () => string;
-    trace: (s: string) => void;
-    getDirectories: (path: string) => string[];
-    resolveTypeReferenceDirectives?: (names: string[], containingFile: string) => ts.ResolvedTypeReferenceDirective[];
-    directoryExists?: (directoryName: string) => boolean;
-    constructor(rootFiles: ReadonlyArray<string>, options: CompilerOptions, context: CompilerHost, metadataProvider: MetadataProvider, codeGenerator: CodeGenerator, librarySummaries?: Map<string, LibrarySummary>);
-    private resolveModuleName;
-    resolveModuleNames(moduleNames: string[], containingFile: string): ts.ResolvedModule[];
-    moduleNameToFileName(m: string, containingFile?: string): string | null;
-    /**
-     * We want a moduleId that will appear in import statements in the generated code
-     * which will be written to `containingFile`.
-     *
-     * Note that we also generate files for files in node_modules, as libraries
-     * only ship .metadata.json files but not the generated code.
-     *
-     * Logic:
-     * 1. if the importedFile and the containingFile are from the project sources
-     *    or from the same node_modules package, use a relative path
-     * 2. if the importedFile is in a node_modules package,
-     *    use a path that starts with the package name.
-     * 3. Error if the containingFile is in the node_modules package
-     *    and the importedFile is in the project soures,
-     *    as that is a violation of the principle that node_modules packages cannot
-     *    import project sources.
-     */
-    fileNameToModuleName(importedFile: string, containingFile: string): string;
-    resourceNameToFileName(resourceName: string, containingFile: string): string | null;
-    toSummaryFileName(fileName: string, referringSrcFileName: string): string;
-    fromSummaryFileName(fileName: string, referringLibFileName: string): string;
-    parseSourceSpanOf(fileName: string, line: number, character: number): ParseSourceSpan | null;
-    private getOriginalSourceFile;
-    updateGeneratedFile(genFile: GeneratedFile): ts.SourceFile;
-    private addGeneratedFile;
-    shouldGenerateFile(fileName: string): {
-        generate: boolean;
-        baseFileName?: string;
-    };
-    shouldGenerateFilesFor(fileName: string): string | boolean | null;
-    getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined): ts.SourceFile;
-    private getGeneratedFile;
-    private originalFileExists;
-    fileExists(fileName: string): boolean;
-    loadSummary(filePath: string): string | null;
-    isSourceFile(filePath: string): boolean;
-    readFile(fileName: string): string | undefined;
-    getMetadataFor(filePath: string): ModuleMetadata[] | undefined;
-    loadResource(filePath: string): Promise<string> | string;
-    getOutputName(filePath: string): string;
-    private hasBundleIndex;
-    getDefaultLibFileName: (options: ts.CompilerOptions) => string;
-    getCurrentDirectory: () => string;
-    getCanonicalFileName: (fileName: string) => string;
-    useCaseSensitiveFileNames: () => boolean;
-    getNewLine: () => string;
-    realpath: (p: string) => string;
-    writeFile: ts.WriteFileCallback;
-}
-export declare function getOriginalReferences(sourceFile: ts.SourceFile): ts.FileReference[] | undefined;

package/src/transformers/program.d.ts

@@ -6,29 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/transformers/program" />
-import * as path from 'path';
-import ts from 'typescript';
 import { CompilerHost, CompilerOptions, Program } from './api';
-export declare function setTempProgramHandlerForTest(handler: (program: ts.Program) => void): void;
-export declare function resetTempProgramHandlerForTest(): void;
 export declare function createProgram({ rootNames, options, host, oldProgram }: {
     rootNames: ReadonlyArray<string>;
     options: CompilerOptions;
     host: CompilerHost;
     oldProgram?: Program;
 }): Program;
-/**
- * Returns a function that can adjust a path from source path to out path,
- * based on an existing mapping from source to out path.
- *
- * TODO(tbosch): talk to the TypeScript team to expose their logic for calculating the `rootDir`
- * if none was specified.
- *
- * Note: This function works on normalized paths from typescript but should always return
- * POSIX normalized paths for output paths.
- */
-export declare function createSrcToOutPathMapper(outDir: string | undefined, sampleSrcFileName: string | undefined, sampleOutFileName: string | undefined, host?: {
-    dirname: typeof path.dirname;
-    resolve: typeof path.resolve;
-    relative: typeof path.relative;
-}): (srcFileName: string) => string;

package/src/transformers/util.d.ts

@@ -7,21 +7,10 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/transformers/util" />
 import ts from 'typescript';
-import { CompilerOptions, Diagnostic } from './api';
+import { Diagnostic } from './api';
 export declare const GENERATED_FILES: RegExp;
-export declare const DTS: RegExp;
-export declare const TS: RegExp;
-export declare const enum StructureIsReused {
-    Not = 0,
-    SafeModules = 1,
-    Completely = 2
-}
-export declare function tsStructureIsReused(program: ts.Program): StructureIsReused;
 export declare function error(msg: string): never;
-export declare function userError(msg: string): never;
 export declare function createMessageDiagnostic(messageText: string): ts.Diagnostic & Diagnostic;
-export declare function isInRootDir(fileName: string, options: CompilerOptions): string | true | null;
-export declare function relativeToRootDirs(filePath: string, rootDirs: string[]): string;
 /**
  * Converts a ng.Diagnostic into a ts.Diagnostic.
  * This looses some information, and also uses an incomplete object as `file`.
@@ -29,9 +18,3 @@ export declare function relativeToRootDirs(filePath: string, rootDirs: string[])
  * I.e. only use this where the API allows only a ts.Diagnostic.
  */
 export declare function ngToTsDiagnostic(ng: Diagnostic): ts.Diagnostic;
-/**
- * Strip multiline comment start and end markers from the `commentText` string.
- *
- * This will also strip the JSDOC comment start marker (`/**`).
- */
-export declare function stripComment(commentText: string): string;

package/src/{diagnostics/typescript_version.d.ts → version_helpers.d.ts}

@@ -5,7 +5,7 @@
  * 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/diagnostics/typescript_version" />
+/// <amd-module name="@angular/compiler-cli/src/version_helpers" />
 /**
  * Converts a `string` version into an array of numbers
  * @example

package/src/diagnostics/translate_diagnostics.d.ts

@@ -1,18 +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/diagnostics/translate_diagnostics" />
-import { ParseSourceSpan } from '@angular/compiler';
-import ts from 'typescript';
-import { Diagnostic } from '../transformers/api';
-export interface TypeCheckHost {
-    parseSourceSpanOf(fileName: string, line: number, character: number): ParseSourceSpan | null;
-}
-export declare function translateDiagnostics(host: TypeCheckHost, untranslatedDiagnostics: ReadonlyArray<ts.Diagnostic>): {
-    ts: ts.Diagnostic[];
-    ng: Diagnostic[];
-};

package/src/language_services.d.ts

@@ -1,11 +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/language_services" />
-export { MetadataCollector, ModuleMetadata } from './metadata';
-export { CompilerOptions } from './transformers/api';
-export { createMetadataReaderCache, MetadataReaderCache, MetadataReaderHost, readMetadata } from './transformers/metadata_reader';

package/src/metadata/bundle_index_host.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/metadata/bundle_index_host" />
-import ts from 'typescript';
-import { CompilerOptions } from '../transformers/api';
-import { MetadataCache } from '../transformers/metadata_cache';
-export declare function createBundleIndexHost<H extends ts.CompilerHost>(ngOptions: CompilerOptions, rootFiles: ReadonlyArray<string>, host: H, getMetadataCache: () => MetadataCache): {
-    host: H;
-    indexName?: string;
-    errors?: ts.Diagnostic[];
-};

package/src/metadata/bundler.d.ts

@@ -1,66 +0,0 @@
-/// <amd-module name="@angular/compiler-cli/src/metadata/bundler" />
-import ts from 'typescript';
-import { MetadataCache } from '../transformers/metadata_cache';
-import { MetadataEntry, ModuleMetadata } from './schema';
-export interface BundleEntries {
-    [name: string]: MetadataEntry;
-}
-export interface BundlePrivateEntry {
-    privateName: string;
-    name: string;
-    module: string;
-}
-export interface BundledModule {
-    metadata: ModuleMetadata;
-    privates: BundlePrivateEntry[];
-}
-export interface MetadataBundlerHost {
-    getMetadataFor(moduleName: string, containingFile: string): ModuleMetadata | undefined;
-}
-export declare class MetadataBundler {
-    private root;
-    private importAs;
-    private host;
-    private symbolMap;
-    private metadataCache;
-    private exports;
-    private rootModule;
-    private privateSymbolPrefix;
-    private exported;
-    constructor(root: string, importAs: string | undefined, host: MetadataBundlerHost, privateSymbolPrefix?: string);
-    getMetadataBundle(): BundledModule;
-    static resolveModule(importName: string, from: string): string;
-    private getMetadata;
-    private exportAll;
-    /**
-     * Fill in the canonicalSymbol which is the symbol that should be imported by factories.
-     * The canonical symbol is the one exported by the index file for the bundle or definition
-     * symbol for private symbols that are not exported by bundle index.
-     */
-    private canonicalizeSymbols;
-    private canonicalizeSymbol;
-    private getEntries;
-    private getReExports;
-    private convertSymbol;
-    private convertEntry;
-    private convertClass;
-    private convertMembers;
-    private convertMember;
-    private convertStatics;
-    private convertFunction;
-    private convertValue;
-    private convertExpression;
-    private convertError;
-    private convertReference;
-    private convertExpressionNode;
-    private symbolOf;
-    private canonicalSymbolOf;
-}
-export declare class CompilerHostAdapter implements MetadataBundlerHost {
-    private host;
-    private cache;
-    private options;
-    private collector;
-    constructor(host: ts.CompilerHost, cache: MetadataCache | null, options: ts.CompilerOptions);
-    getMetadataFor(fileName: string, containingFile: string): ModuleMetadata | undefined;
-}

package/src/metadata/collector.d.ts

@@ -1,44 +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/collector" />
-import ts from 'typescript';
-import { MetadataValue, ModuleMetadata } from './schema';
-/**
- * A set of collector options to use when collecting metadata.
- */
-export interface CollectorOptions {
-    /**
-     * Version of the metadata to collect.
-     */
-    version?: number;
-    /**
-     * Collect a hidden field "$quoted$" in objects literals that record when the key was quoted in
-     * the source.
-     */
-    quotedNames?: boolean;
-    /**
-     * Do not simplify invalid expressions.
-     */
-    verboseInvalidExpression?: boolean;
-    /**
-     * An expression substitution callback.
-     */
-    substituteExpression?: (value: MetadataValue, node: ts.Node) => MetadataValue;
-}
-/**
- * Collect decorator metadata from a TypeScript module.
- */
-export declare class MetadataCollector {
-    private options;
-    constructor(options?: CollectorOptions);
-    /**
-     * Returns a JSON.stringify friendly form describing the decorators of the exported classes from
-     * the source file that is expected to correspond to a module.
-     */
-    getMetadata(sourceFile: ts.SourceFile, strict?: boolean, substituteExpression?: (value: MetadataValue, node: ts.Node) => MetadataValue): ModuleMetadata | undefined;
-}

package/src/metadata/evaluator.d.ts

@@ -1,58 +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/evaluator" />
-import ts from 'typescript';
-import { CollectorOptions } from './collector';
-import { MetadataEntry, MetadataError, MetadataValue } from './schema';
-import { Symbols } from './symbols';
-export declare function isPrimitive(value: any): boolean;
-export interface ImportSpecifierMetadata {
-    name: string;
-    propertyName?: string;
-}
-export interface ImportMetadata {
-    defaultName?: string;
-    namespace?: string;
-    namedImports?: ImportSpecifierMetadata[];
-    from: string;
-}
-/**
- * Produce a symbolic representation of an expression folding values into their final value when
- * possible.
- */
-export declare class Evaluator {
-    private symbols;
-    private nodeMap;
-    private options;
-    private recordExport?;
-    constructor(symbols: Symbols, nodeMap: Map<MetadataEntry, ts.Node>, options?: CollectorOptions, recordExport?: ((name: string, value: MetadataValue) => void) | undefined);
-    nameOf(node: ts.Node | undefined): string | MetadataError;
-    /**
-     * Returns true if the expression represented by `node` can be folded into a literal expression.
-     *
-     * For example, a literal is always foldable. This means that literal expressions such as `1.2`
-     * `"Some value"` `true` `false` are foldable.
-     *
-     * - An object literal is foldable if all the properties in the literal are foldable.
-     * - An array literal is foldable if all the elements are foldable.
-     * - A call is foldable if it is a call to a Array.prototype.concat or a call to CONST_EXPR.
-     * - A property access is foldable if the object is foldable.
-     * - A array index is foldable if index expression is foldable and the array is foldable.
-     * - Binary operator expressions are foldable if the left and right expressions are foldable and
-     *   it is one of '+', '-', '*', '/', '%', '||', and '&&'.
-     * - An identifier is foldable if a value can be found for its symbol in the evaluator symbol
-     *   table.
-     */
-    isFoldable(node: ts.Node): boolean;
-    private isFoldableWorker;
-    /**
-     * Produce a JSON serialiable object representing `node`. The foldable values in the expression
-     * tree are folded. For example, a node representing `1 + 2` is folded into `3`.
-     */
-    evaluateNode(node: ts.Node, preferReference?: boolean): MetadataValue;
-}

package/src/metadata/index.d.ts

@@ -1,11 +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/index" />
-export * from './collector';
-export * from './schema';
-export * from './bundle_index_host';

package/src/metadata/index_writer.d.ts

@@ -1,10 +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/index_writer" />
-import { BundlePrivateEntry } from './bundler';
-export declare function privateEntriesToIndex(index: string, privates: BundlePrivateEntry[]): string;