@angular/compiler-cli 15.2.0 → 16.0.0-next.0

package/ngcc/src/migrations/migration.d.ts

@@ -1,59 +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
- */
-import ts from 'typescript';
-import { MetadataReader } from '../../../src/ngtsc/metadata';
-import { PartialEvaluator } from '../../../src/ngtsc/partial_evaluator';
-import { ClassDeclaration, Decorator } from '../../../src/ngtsc/reflection';
-import { HandlerFlags } from '../../../src/ngtsc/transform';
-import { NgccReflectionHost } from '../host/ngcc_host';
-/**
- * Implement this interface and add it to the `DecorationAnalyzer.migrations` collection to get ngcc
- * to modify the analysis of the decorators in the program in order to migrate older code to work
- * with Ivy.
- *
- * `Migration.apply()` is called for every class in the program being compiled by ngcc.
- *
- * Note that the underlying program could be in a variety of different formats, e.g. ES2015, ES5,
- * UMD, CommonJS etc. This means that an author of a `Migration` should not attempt to navigate and
- * manipulate the AST nodes directly. Instead, the `MigrationHost` interface, passed to the
- * `Migration`, provides access to a `MetadataReader`, `ReflectionHost` and `PartialEvaluator`
- * interfaces, which should be used.
- */
-export interface Migration {
-    apply(clazz: ClassDeclaration, host: MigrationHost): ts.Diagnostic | null;
-}
-export interface MigrationHost {
-    /** Provides access to the decorator information associated with classes. */
-    readonly metadata: MetadataReader;
-    /** Provides access to navigate the AST in a format-agnostic manner. */
-    readonly reflectionHost: NgccReflectionHost;
-    /** Enables expressions to be statically evaluated in the context of the program. */
-    readonly evaluator: PartialEvaluator;
-    /**
-     * Associate a new synthesized decorator, which did not appear in the original source, with a
-     * given class.
-     * @param clazz the class to receive the new decorator.
-     * @param decorator the decorator to inject.
-     * @param flags optional bitwise flag to influence the compilation of the decorator.
-     */
-    injectSyntheticDecorator(clazz: ClassDeclaration, decorator: Decorator, flags?: HandlerFlags): void;
-    /**
-     * Retrieves all decorators that are associated with the class, including synthetic decorators
-     * that have been injected before.
-     * @param clazz the class for which all decorators are retrieved.
-     * @returns the list of the decorators, or null if the class was not decorated.
-     */
-    getAllDecorators(clazz: ClassDeclaration): Decorator[] | null;
-    /**
-     * Determines whether the provided class in within scope of the entry-point that is currently
-     * being compiled.
-     * @param clazz the class for which to determine whether it is within the current entry-point.
-     * @returns true if the file is part of the compiled entry-point, false otherwise.
-     */
-    isInScope(clazz: ClassDeclaration): boolean;
-}

package/ngcc/src/migrations/missing_injectable_migration.d.ts

@@ -1,35 +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
- */
-import ts from 'typescript';
-import { ClassDeclaration, Decorator } from '../../../src/ngtsc/reflection';
-import { Migration, MigrationHost } from './migration';
-/**
- * Ensures that classes that are provided as an Angular service in either `NgModule.providers` or
- * `Directive.providers`/`Component.viewProviders` are decorated with one of the `@Injectable`,
- * `@Directive`, `@Component` or `@Pipe` decorators, adding an `@Injectable()` decorator when none
- * are present.
- *
- * At least one decorator is now mandatory, as otherwise the compiler would not compile an
- * injectable definition for the service. This is unlike View Engine, where having just an unrelated
- * decorator may have been sufficient for the service to become injectable.
- *
- * In essence, this migration operates on classes that are themselves an NgModule, Directive or
- * Component. Their metadata is statically evaluated so that their "providers"/"viewProviders"
- * properties can be analyzed. For any provider that refers to an undecorated class, the class will
- * be migrated to have an `@Injectable()` decorator.
- *
- * This implementation mirrors the "missing-injectable" schematic.
- */
-export declare class MissingInjectableMigration implements Migration {
-    apply(clazz: ClassDeclaration, host: MigrationHost): ts.Diagnostic | null;
-}
-/**
- * Determines the original name of a decorator if it is from '@angular/core'. For other decorators,
- * null is returned.
- */
-export declare function getAngularCoreDecoratorName(decorator: Decorator): string | null;

package/ngcc/src/migrations/undecorated_child_migration.d.ts

@@ -1,15 +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
- */
-import ts from 'typescript';
-import { Reference } from '../../../src/ngtsc/imports';
-import { ClassDeclaration } from '../../../src/ngtsc/reflection';
-import { Migration, MigrationHost } from './migration';
-export declare class UndecoratedChildMigration implements Migration {
-    apply(clazz: ClassDeclaration, host: MigrationHost): ts.Diagnostic | null;
-    maybeMigrate(ref: Reference<ClassDeclaration>, host: MigrationHost): void;
-}

package/ngcc/src/migrations/undecorated_parent_migration.d.ts

@@ -1,51 +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
- */
-import ts from 'typescript';
-import { ClassDeclaration } from '../../../src/ngtsc/reflection';
-import { Migration, MigrationHost } from './migration';
-/**
- * Ensure that the parents of directives and components that have no constructor are also decorated
- * as a `Directive`.
- *
- * Example:
- *
- * ```
- * export class BasePlain {
- *   constructor(private vcr: ViewContainerRef) {}
- * }
- *
- * @Directive({selector: '[blah]'})
- * export class DerivedDir extends BasePlain {}
- * ```
- *
- * When compiling `DerivedDir` which extends the undecorated `BasePlain` class, the compiler needs
- * to generate a directive def (`ɵdir`) for `DerivedDir`. In particular, it needs to generate a
- * factory function that creates instances of `DerivedDir`.
- *
- * As `DerivedDir` has no constructor, the factory function for `DerivedDir` must delegate to the
- * factory function for `BasePlain`. But for this to work, `BasePlain` must have a factory function,
- * itself.
- *
- * This migration adds a `Directive` decorator to such undecorated parent classes, to ensure that
- * the compiler will create the necessary factory function.
- *
- * The resulting code looks like:
- *
- * ```
- * @Directive()
- * export class BasePlain {
- *   constructor(private vcr: ViewContainerRef) {}
- * }
- *
- * @Directive({selector: '[blah]'})
- * export class DerivedDir extends BasePlain {}
- * ```
- */
-export declare class UndecoratedParentMigration implements Migration {
-    apply(clazz: ClassDeclaration, host: MigrationHost): ts.Diagnostic | null;
-}

package/ngcc/src/migrations/utils.d.ts

@@ -1,41 +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
- */
-import ts from 'typescript';
-import { ClassDeclaration, Decorator } from '../../../src/ngtsc/reflection';
-import { MigrationHost } from './migration';
-export declare function isClassDeclaration(clazz: ts.Node): clazz is ClassDeclaration<ts.Declaration>;
-/**
- * Returns true if the `clazz` is decorated as a `Directive` or `Component`.
- */
-export declare function hasDirectiveDecorator(host: MigrationHost, clazz: ClassDeclaration): boolean;
-/**
- * Returns true if the `clazz` is decorated as a `Pipe`.
- */
-export declare function hasPipeDecorator(host: MigrationHost, clazz: ClassDeclaration): boolean;
-/**
- * Returns true if the `clazz` has its own constructor function.
- */
-export declare function hasConstructor(host: MigrationHost, clazz: ClassDeclaration): boolean;
-/**
- * Create an empty `Directive` decorator that will be associated with the `clazz`.
- */
-export declare function createDirectiveDecorator(clazz: ClassDeclaration, metadata?: {
-    selector: string | null;
-    exportAs: string[] | null;
-}): Decorator;
-/**
- * Create an empty `Component` decorator that will be associated with the `clazz`.
- */
-export declare function createComponentDecorator(clazz: ClassDeclaration, metadata: {
-    selector: string | null;
-    exportAs: string[] | null;
-}): Decorator;
-/**
- * Create an empty `Injectable` decorator that will be associated with the `clazz`.
- */
-export declare function createInjectableDecorator(clazz: ClassDeclaration): Decorator;

package/ngcc/src/ngcc_options.d.ts

@@ -1,155 +0,0 @@
-import { AbsoluteFsPath, FileSystem } from '../../src/ngtsc/file_system';
-import { Logger } from '../../src/ngtsc/logging';
-import { ParsedConfiguration } from '../../src/perform_compile';
-import { PathMappings } from './path_mappings';
-import { FileWriter } from './writing/file_writer';
-import { PackageJsonUpdater } from './writing/package_json_updater';
-/**
- * The options to configure the ngcc compiler for synchronous execution.
- */
-export interface SyncNgccOptions {
-    /** The absolute path to the `node_modules` folder that contains the packages to process. */
-    basePath: string;
-    /**
-     * The path to the primary package to be processed. If not absolute then it must be relative to
-     * `basePath`.
-     *
-     * All its dependencies will need to be processed too.
-     *
-     * If this property is provided then `errorOnFailedEntryPoint` is forced to true.
-     */
-    targetEntryPointPath?: string;
-    /**
-     * Which entry-point properties in the package.json to consider when processing an entry-point.
-     * Each property should hold a path to the particular bundle format for the entry-point.
-     * Defaults to all the properties in the package.json.
-     */
-    propertiesToConsider?: string[];
-    /**
-     * Whether to only process the typings files for this entry-point.
-     *
-     * This is useful when running ngcc only to provide typings files to downstream tooling such as
-     * the Angular Language Service or ng-packagr. Defaults to `false`.
-     *
-     * If this is set to `true` then `compileAllFormats` is forced to `false`.
-     */
-    typingsOnly?: boolean;
-    /**
-     * Whether to process all formats specified by (`propertiesToConsider`)  or to stop processing
-     * this entry-point at the first matching format.
-     *
-     * Defaults to `true`, but is forced to `false` if `typingsOnly` is `true`.
-     */
-    compileAllFormats?: boolean;
-    /**
-     * Whether to create new entry-points bundles rather than overwriting the original files.
-     */
-    createNewEntryPointFormats?: boolean;
-    /**
-     * Provide a logger that will be called with log messages.
-     */
-    logger?: Logger;
-    /**
-     * Paths mapping configuration (`paths` and `baseUrl`), as found in `ts.CompilerOptions`.
-     * These are used to resolve paths to locally built Angular libraries.
-     *
-     * Note that `pathMappings` specified here take precedence over any `pathMappings` loaded from a
-     * TS config file.
-     */
-    pathMappings?: PathMappings;
-    /**
-     * Provide a file-system service that will be used by ngcc for all file interactions.
-     */
-    fileSystem?: FileSystem;
-    /**
-     * Whether the compilation should run and return asynchronously. Allowing asynchronous execution
-     * may speed up the compilation by utilizing multiple CPU cores (if available).
-     *
-     * Default: `false` (i.e. run synchronously)
-     */
-    async?: false;
-    /**
-     * Set to true in order to terminate immediately with an error code if an entry-point fails to be
-     * processed.
-     *
-     * If `targetEntryPointPath` is provided then this property is always true and cannot be
-     * changed. Otherwise the default is false.
-     *
-     * When set to false, ngcc will continue to process entry-points after a failure. In which case it
-     * will log an error and resume processing other entry-points.
-     */
-    errorOnFailedEntryPoint?: boolean;
-    /**
-     * Render `$localize` messages with legacy format ids.
-     *
-     * The default value is `true`. Only set this to `false` if you do not want legacy message ids to
-     * be rendered. For example, if you are not using legacy message ids in your translation files
-     * AND are not doing compile-time inlining of translations, in which case the extra message ids
-     * would add unwanted size to the final source bundle.
-     *
-     * It is safe to leave this set to true if you are doing compile-time inlining because the extra
-     * legacy message ids will all be stripped during translation.
-     */
-    enableI18nLegacyMessageIdFormat?: boolean;
-    /**
-     * Whether to invalidate any entry-point manifest file that is on disk. Instead, walk the
-     * directory tree looking for entry-points, and then write a new entry-point manifest, if
-     * possible.
-     *
-     * Default: `false` (i.e. the manifest will be used if available)
-     */
-    invalidateEntryPointManifest?: boolean;
-    /**
-     * An absolute path to a TS config file (e.g. `tsconfig.json`) or a directory containing one, that
-     * will be used to configure module resolution with things like path mappings, if not specified
-     * explicitly via the `pathMappings` property to `mainNgcc`.
-     *
-     * If `undefined`, ngcc will attempt to load a `tsconfig.json` file from the directory above the
-     * `basePath`.
-     *
-     * If `null`, ngcc will not attempt to load any TS config file at all.
-     */
-    tsConfigPath?: string | null;
-    /**
-     * Use the program defined in the loaded tsconfig.json (if available - see
-     * `tsConfigPath` option) to identify the entry-points that should be processed.
-     * If this is set to `true` then only the entry-points reachable from the given
-     * program (and their dependencies) will be processed.
-     */
-    findEntryPointsFromTsConfigProgram?: boolean;
-}
-/**
- * The options to configure the ngcc compiler for asynchronous execution.
- */
-export type AsyncNgccOptions = Omit<SyncNgccOptions, 'async'> & {
-    async: true;
-};
-/**
- * The options to configure the ngcc compiler.
- */
-export type NgccOptions = AsyncNgccOptions | SyncNgccOptions;
-export type OptionalNgccOptionKeys = 'targetEntryPointPath' | 'tsConfigPath' | 'pathMappings' | 'findEntryPointsFromTsConfigProgram';
-export type RequiredNgccOptions = Required<Omit<NgccOptions, OptionalNgccOptionKeys>>;
-export type OptionalNgccOptions = Pick<NgccOptions, OptionalNgccOptionKeys>;
-export type SharedSetup = {
-    fileSystem: FileSystem;
-    absBasePath: AbsoluteFsPath;
-    projectPath: AbsoluteFsPath;
-    tsConfig: ParsedConfiguration | null;
-    getFileWriter(pkgJsonUpdater: PackageJsonUpdater): FileWriter;
-};
-/**
- * Instantiate common utilities that are always used and fix up options with defaults, as necessary.
- *
- * NOTE: Avoid eagerly instantiating anything that might not be used when running sync/async.
- */
-export declare function getSharedSetup(options: NgccOptions): SharedSetup & RequiredNgccOptions & OptionalNgccOptions;
-export declare function clearTsConfigCache(): void;
-/**
- * Determines the maximum number of workers to use for parallel execution. This can be set using the
- * NGCC_MAX_WORKERS environment variable, or is computed based on the number of available CPUs. One
- * CPU core is always reserved for the master process, so we take the number of CPUs minus one, with
- * a maximum of 4 workers. We don't scale the number of workers beyond 4 by default, as it takes
- * considerably more memory and CPU cycles while not offering a substantial improvement in time.
- */
-export declare function getMaxNumberOfWorkers(): number;

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

@@ -1,16 +0,0 @@
-/**
- * UMD/CJS bundles generated by Rollup may be using an element access expression like
- * `exports["ɵa"]` for declaring and exporting classes, instead of a property access like
- * `exports.ɵa`. The element access syntax introduces a problem for ngcc, where it wouldn't consider
- * such export as class declaration, causing them to be skipped. The ngtsc compiler is implemented
- * with the assumption that all class declarations use a `ts.Identifier` as name, whereas the
- * element access is using a string literal for the declared name. This makes it troublesome for
- * ngcc to support this syntax form in UMD bundles.
- *
- * To work around the problem, this function transforms these access expressions into regular
- * property accesses. The source text is parsed to an AST to allow finding the element accesses in a
- * robust way, after which the affected text ranges are replaced with property accesses in the
- * original source text. These replacement operations are faster than applying an AST transform and
- * going through a `ts.Printer` to print the text back out.
- */
-export declare function adjustElementAccessExports(sourceText: string): string;

package/ngcc/src/packages/build_marker.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
- */
-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 = "15.2.0";
-/**
- * Returns true if there is a format in this entry-point that was compiled with an outdated version
- * of ngcc.
- *
- * @param packageJson The parsed contents of the package.json for the entry-point
- */
-export declare function needsCleaning(packageJson: EntryPointPackageJson): boolean;
-/**
- * Clean any build marker artifacts from the given `packageJson` object.
- * @param packageJson The parsed contents of the package.json to modify
- * @returns true if the package was modified during cleaning
- */
-export declare function cleanPackageJson(packageJson: EntryPointPackageJson): boolean;
-/**
- * Check whether ngcc has already processed a given entry-point format.
- *
- * @param packageJson The parsed contents of the package.json file for the entry-point.
- * @param format The entry-point format property in the package.json to check.
- * @returns true if the `format` in the entry-point has already been processed by this ngcc version,
- * false otherwise.
- */
-export declare function hasBeenProcessed(packageJson: EntryPointPackageJson, format: PackageJsonFormatProperties): boolean;
-/**
- * Write a build marker for the given entry-point and format properties, to indicate that they have
- * been compiled by this version of ngcc.
- *
- * @param pkgJsonUpdater The writer to use for updating `package.json`.
- * @param packageJson The parsed contents of the `package.json` file for the entry-point.
- * @param packageJsonPath The absolute path to the `package.json` file.
- * @param properties The properties in the `package.json` of the formats for which we are writing
- *                   the marker.
- */
-export declare function markAsProcessed(pkgJsonUpdater: PackageJsonUpdater, packageJson: EntryPointPackageJson, packageJsonPath: AbsoluteFsPath, formatProperties: PackageJsonFormatProperties[]): void;

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

@@ -1,35 +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
- */
-import ts from 'typescript';
-import { AbsoluteFsPath, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-/**
- * An entry point bundle contains one or two programs, e.g. `src` and `dts`,
- * that are compiled via TypeScript.
- *
- * To aid with processing the program, this interface exposes the program itself,
- * as well as path and TS file of the entry-point to the program and the r3Symbols
- * file, if appropriate.
- */
-export interface BundleProgram {
-    program: ts.Program;
-    options: ts.CompilerOptions;
-    host: ts.CompilerHost;
-    path: AbsoluteFsPath;
-    file: ts.SourceFile;
-    package: AbsoluteFsPath;
-    r3SymbolsPath: AbsoluteFsPath | null;
-    r3SymbolsFile: ts.SourceFile | null;
-}
-/**
- * Create a bundle program.
- */
-export declare function makeBundleProgram(fs: ReadonlyFileSystem, isCore: boolean, pkg: AbsoluteFsPath, path: AbsoluteFsPath, r3FileName: string, options: ts.CompilerOptions, host: ts.CompilerHost, additionalFiles?: AbsoluteFsPath[]): BundleProgram;
-/**
- * Search the given directory hierarchy to find the path to the `r3_symbols` file.
- */
-export declare function findR3SymbolsPath(fs: ReadonlyFileSystem, directory: AbsoluteFsPath, filename: string): AbsoluteFsPath | null;