@angular/compiler-cli 15.2.1 → 16.0.0-next.1

package/ngcc/src/dependencies/esm_dependency_host.d.ts

@@ -1,93 +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';
-import { DependencyHostBase } from './dependency_host';
-import { ModuleResolver } from './module_resolver';
-/**
- * Helper functions for computing dependencies.
- */
-export declare class EsmDependencyHost extends DependencyHostBase {
-    private scanImportExpressions;
-    constructor(fs: ReadonlyFileSystem, moduleResolver: ModuleResolver, scanImportExpressions?: boolean);
-    private scanner;
-    protected canSkipFile(fileContents: string): boolean;
-    /**
-     * Extract any import paths from imports found in the contents of this file.
-     *
-     * This implementation uses the TypeScript scanner, which tokenizes source code,
-     * to process the string. This is halfway between working with the string directly,
-     * which is too difficult due to corner cases, and parsing the string into a full
-     * TypeScript Abstract Syntax Tree (AST), which ends up doing more processing than
-     * is needed.
-     *
-     * The scanning is not trivial because we must hold state between each token since
-     * the context of the token affects how it should be scanned, and the scanner does
-     * not manage this for us.
-     *
-     * Specifically, backticked strings are particularly challenging since it is possible
-     * to recursively nest backticks and TypeScript expressions within each other.
-     */
-    protected extractImports(file: AbsoluteFsPath, fileContents: string): Set<string>;
-    /**
-     * We have found an `import` token so now try to identify the import path.
-     *
-     * This method will use the current state of `this.scanner` to extract a string literal module
-     * specifier. It expects that the current state of the scanner is that an `import` token has just
-     * been scanned.
-     *
-     * The following forms of import are matched:
-     *
-     * * `import "module-specifier";`
-     * * `import("module-specifier")`
-     * * `import defaultBinding from "module-specifier";`
-     * * `import defaultBinding, * as identifier from "module-specifier";`
-     * * `import defaultBinding, {...} from "module-specifier";`
-     * * `import * as identifier from "module-specifier";`
-     * * `import {...} from "module-specifier";`
-     *
-     * @returns the import path or null if there is no import or it is not a string literal.
-     */
-    protected extractImportPath(): string | null;
-    /**
-     * We have found an `export` token so now try to identify a re-export path.
-     *
-     * This method will use the current state of `this.scanner` to extract a string literal module
-     * specifier. It expects that the current state of the scanner is that an `export` token has
-     * just been scanned.
-     *
-     * There are three forms of re-export that are matched:
-     *
-     * * `export * from '...';
-     * * `export * as alias from '...';
-     * * `export {...} from '...';
-     */
-    protected extractReexportPath(): string | null;
-    protected skipNamespacedClause(): ts.SyntaxKind | null;
-    protected skipNamedClause(): ts.SyntaxKind;
-    protected tryStringLiteral(): string | null;
-}
-/**
- * Check whether a source file needs to be parsed for imports.
- * This is a performance short-circuit, which saves us from creating
- * a TypeScript AST unnecessarily.
- *
- * @param source The content of the source file to check.
- *
- * @returns false if there are definitely no import or re-export statements
- * in this file, true otherwise.
- */
-export declare function hasImportOrReexportStatements(source: string): boolean;
-/**
- * Check whether the given statement is an import with a string literal module specifier.
- * @param stmt the statement node to check.
- * @returns true if the statement is an import with a string literal module specifier.
- */
-export declare function isStringImportOrReexport(stmt: ts.Statement): stmt is ts.ImportDeclaration & {
-    moduleSpecifier: ts.StringLiteral;
-};

package/ngcc/src/dependencies/module_resolver.d.ts

@@ -1,134 +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, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { PathMappings } from '../path_mappings';
-/**
- * This is a very cut-down implementation of the TypeScript module resolution strategy.
- *
- * It is specific to the needs of ngcc and is not intended to be a drop-in replacement
- * for the TS module resolver. It is used to compute the dependencies between entry-points
- * that may be compiled by ngcc.
- *
- * The algorithm only finds `.js` files for internal/relative imports and paths to
- * the folder containing the `package.json` of the entry-point for external imports.
- *
- * It can cope with nested `node_modules` folders and also supports `paths`/`baseUrl`
- * configuration properties, as provided in a `ts.CompilerOptions` object.
- */
-export declare class ModuleResolver {
-    private fs;
-    readonly relativeExtensions: string[];
-    private pathMappings;
-    constructor(fs: ReadonlyFileSystem, pathMappings?: PathMappings, relativeExtensions?: string[]);
-    /**
-     * Resolve an absolute path for the `moduleName` imported into a file at `fromPath`.
-     * @param moduleName The name of the import to resolve.
-     * @param fromPath The path to the file containing the import.
-     * @returns A path to the resolved module or null if missing.
-     * Specifically:
-     *  * the absolute path to the package.json of an external module
-     *  * a JavaScript file of an internal module
-     *  * null if none exists.
-     */
-    resolveModuleImport(moduleName: string, fromPath: AbsoluteFsPath): ResolvedModule | null;
-    /**
-     * Convert the `pathMappings` into a collection of `PathMapper` functions.
-     */
-    private processPathMappings;
-    /**
-     * Try to resolve a module name, as a relative path, from the `fromPath`.
-     *
-     * As it is relative, it only looks for files that end in one of the `relativeExtensions`.
-     * For example: `${moduleName}.js` or `${moduleName}/index.js`.
-     * If neither of these files exist then the method returns `null`.
-     */
-    private resolveAsRelativePath;
-    /**
-     * Try to resolve the `moduleName`, by applying the computed `pathMappings` and
-     * then trying to resolve the mapped path as a relative or external import.
-     *
-     * Whether the mapped path is relative is defined as it being "below the `fromPath`" and not
-     * containing `node_modules`.
-     *
-     * If the mapped path is not relative but does not resolve to an external entry-point, then we
-     * check whether it would have resolved to a relative path, in which case it is marked as a
-     * "deep-import".
-     */
-    private resolveByPathMappings;
-    /**
-     * Try to resolve the `moduleName` as an external entry-point by searching the `node_modules`
-     * folders up the tree for a matching `.../node_modules/${moduleName}`.
-     *
-     * If a folder is found but the path is not considered an entry-point (see `isEntryPoint()`) then
-     * it is marked as a "deep-import".
-     */
-    private resolveAsEntryPoint;
-    /**
-     * Can we consider the given path as an entry-point to a package?
-     *
-     * This is achieved by checking for the existence of `${modulePath}/package.json`.
-     * If there is no `package.json`, we check whether this is an APF v14+ secondary entry-point,
-     * which does not have its own `package.json` but has an `exports` entry in the package's primary
-     * `package.json`.
-     */
-    private isEntryPoint;
-    /**
-     * Apply the `pathMappers` to the `moduleName` and return all the possible
-     * paths that match.
-     *
-     * The mapped path is computed for each template in `mapping.templates` by
-     * replacing the `matcher.prefix` and `matcher.postfix` strings in `path with the
-     * `template.prefix` and `template.postfix` strings.
-     */
-    private findMappedPaths;
-    /**
-     * Attempt to find a mapped path for the given `path` and a `mapping`.
-     *
-     * The `path` matches the `mapping` if if it starts with `matcher.prefix` and ends with
-     * `matcher.postfix`.
-     *
-     * @returns the wildcard segment of a matched `path`, or `null` if no match.
-     */
-    private matchMapping;
-    /**
-     * Compute the candidate paths from the given mapping's templates using the matched
-     * string.
-     */
-    private computeMappedTemplates;
-    /**
-     * Search up the folder tree for the first folder that contains `package.json`
-     * or `null` if none is found.
-     */
-    private findPackagePath;
-}
-/** The result of resolving an import to a module. */
-export type ResolvedModule = ResolvedExternalModule | ResolvedRelativeModule | ResolvedDeepImport;
-/**
- * A module that is external to the package doing the importing.
- * In this case we capture the folder containing the entry-point.
- */
-export declare class ResolvedExternalModule {
-    entryPointPath: AbsoluteFsPath;
-    constructor(entryPointPath: AbsoluteFsPath);
-}
-/**
- * A module that is relative to the module doing the importing, and so internal to the
- * source module's package.
- */
-export declare class ResolvedRelativeModule {
-    modulePath: AbsoluteFsPath;
-    constructor(modulePath: AbsoluteFsPath);
-}
-/**
- * A module that is external to the package doing the importing but pointing to a
- * module that is deep inside a package, rather than to an entry-point of the package.
- */
-export declare class ResolvedDeepImport {
-    importPath: AbsoluteFsPath;
-    constructor(importPath: AbsoluteFsPath);
-}

package/ngcc/src/dependencies/umd_dependency_host.d.ts

@@ -1,9 +0,0 @@
-import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
-import { DependencyHostBase } from './dependency_host';
-/**
- * Helper functions for computing dependencies.
- */
-export declare class UmdDependencyHost extends DependencyHostBase {
-    protected canSkipFile(fileContents: string): boolean;
-    protected extractImports(file: AbsoluteFsPath, fileContents: string): Set<string>;
-}

package/ngcc/src/entry_point_finder/directory_walker_entry_point_finder.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 { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { EntryPointWithDependencies } from '../dependencies/dependency_host';
-import { DependencyResolver, SortedEntryPointsInfo } from '../dependencies/dependency_resolver';
-import { EntryPointManifest } from '../packages/entry_point_manifest';
-import { PathMappings } from '../path_mappings';
-import { EntryPointCollector } from './entry_point_collector';
-import { EntryPointFinder } from './interface';
-/**
- * An EntryPointFinder that searches for all entry-points that can be found given a `basePath` and
- * `pathMappings`.
- */
-export declare class DirectoryWalkerEntryPointFinder implements EntryPointFinder {
-    private logger;
-    private resolver;
-    private entryPointCollector;
-    private entryPointManifest;
-    private sourceDirectory;
-    private pathMappings;
-    private basePaths;
-    constructor(logger: Logger, resolver: DependencyResolver, entryPointCollector: EntryPointCollector, entryPointManifest: EntryPointManifest, sourceDirectory: AbsoluteFsPath, pathMappings: PathMappings | undefined);
-    /**
-     * Search the `sourceDirectory`, and sub-directories, using `pathMappings` as necessary, to find
-     * all package entry-points.
-     */
-    findEntryPoints(): SortedEntryPointsInfo;
-    /**
-     * Search the `basePath` for possible Angular packages and entry-points.
-     *
-     * @param basePath The path at which to start the search.
-     * @returns an array of `EntryPoint`s that were found within `basePath`.
-     */
-    walkBasePathForPackages(basePath: AbsoluteFsPath): EntryPointWithDependencies[];
-}

package/ngcc/src/entry_point_finder/entry_point_collector.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 { AbsoluteFsPath, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { EntryPointWithDependencies } from '../dependencies/dependency_host';
-import { DependencyResolver } from '../dependencies/dependency_resolver';
-import { NgccConfiguration } from '../packages/configuration';
-/**
- * A class that traverses a file-tree, starting at a given path, looking for all entry-points,
- * also capturing the dependencies of each entry-point that is found.
- */
-export declare class EntryPointCollector {
-    private fs;
-    private config;
-    private logger;
-    private resolver;
-    constructor(fs: ReadonlyFileSystem, config: NgccConfiguration, logger: Logger, resolver: DependencyResolver);
-    /**
-     * Look for Angular packages that need to be compiled, starting at the source directory.
-     * The function will recurse into directories that start with `@...`, e.g. `@angular/...`.
-     *
-     * @param sourceDirectory An absolute path to the root directory where searching begins.
-     * @returns an array of `EntryPoint`s that were found within `sourceDirectory`.
-     */
-    walkDirectoryForPackages(sourceDirectory: AbsoluteFsPath): EntryPointWithDependencies[];
-    /**
-     * Search the `directory` looking for any secondary entry-points for a package, adding any that
-     * are found to the `entryPoints` array.
-     *
-     * @param entryPoints An array where we will add any entry-points found in this directory.
-     * @param packagePath The absolute path to the package that may contain entry-points.
-     * @param directory The current directory being searched.
-     * @param paths The paths contained in the current `directory`.
-     */
-    private collectSecondaryEntryPoints;
-}

package/ngcc/src/entry_point_finder/interface.d.ts

@@ -1,14 +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 { SortedEntryPointsInfo } from '../dependencies/dependency_resolver';
-export interface EntryPointFinder {
-    /**
-     * Search for Angular package entry-points.
-     */
-    findEntryPoints(): SortedEntryPointsInfo;
-}

package/ngcc/src/entry_point_finder/program_based_entry_point_finder.d.ts

@@ -1,61 +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, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { ParsedConfiguration } from '../../../src/perform_compile';
-import { EntryPointWithDependencies } from '../dependencies/dependency_host';
-import { DependencyResolver } from '../dependencies/dependency_resolver';
-import { NgccConfiguration } from '../packages/configuration';
-import { EntryPointManifest } from '../packages/entry_point_manifest';
-import { EntryPointCollector } from './entry_point_collector';
-import { TracingEntryPointFinder } from './tracing_entry_point_finder';
-/**
- * An EntryPointFinder that starts from the files in the program defined by the given tsconfig.json
- * and only returns entry-points that are dependencies of these files.
- *
- * This is faster than searching the entire file-system for all the entry-points,
- * and is used primarily by the CLI integration.
- */
-export declare class ProgramBasedEntryPointFinder extends TracingEntryPointFinder {
-    private entryPointCollector;
-    private entryPointManifest;
-    private tsConfig;
-    private entryPointsWithDependencies;
-    constructor(fs: ReadonlyFileSystem, config: NgccConfiguration, logger: Logger, resolver: DependencyResolver, entryPointCollector: EntryPointCollector, entryPointManifest: EntryPointManifest, basePath: AbsoluteFsPath, tsConfig: ParsedConfiguration, projectPath: AbsoluteFsPath);
-    /**
-     * Return an array containing the external import paths that were extracted from the source-files
-     * of the program defined by the tsconfig.json.
-     */
-    protected getInitialEntryPointPaths(): AbsoluteFsPath[];
-    /**
-     * For the given `entryPointPath`, compute, or retrieve, the entry-point information, including
-     * paths to other entry-points that this entry-point depends upon.
-     *
-     * In this entry-point finder, we use the `EntryPointManifest` to avoid computing each
-     * entry-point's dependencies in the case that this had been done previously.
-     *
-     * @param entryPointPath the path to the entry-point whose information and dependencies are to be
-     *     retrieved or computed.
-     *
-     * @returns the entry-point and its dependencies or `null` if the entry-point is not compiled by
-     *     Angular or cannot be determined.
-     */
-    protected getEntryPointWithDeps(entryPointPath: AbsoluteFsPath): EntryPointWithDependencies | null;
-    /**
-     * Walk the base paths looking for entry-points or load this information from an entry-point
-     * manifest, if available.
-     */
-    private findOrLoadEntryPoints;
-    /**
-     * Search the `basePath` for possible Angular packages and entry-points.
-     *
-     * @param basePath The path at which to start the search.
-     * @returns an array of `EntryPoint`s that were found within `basePath`.
-     */
-    walkBasePathForPackages(basePath: AbsoluteFsPath): EntryPointWithDependencies[];
-}

package/ngcc/src/entry_point_finder/targeted_entry_point_finder.d.ts

@@ -1,95 +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, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { EntryPointWithDependencies } from '../dependencies/dependency_host';
-import { DependencyResolver, SortedEntryPointsInfo } from '../dependencies/dependency_resolver';
-import { NgccConfiguration } from '../packages/configuration';
-import { EntryPointJsonProperty } from '../packages/entry_point';
-import { PathMappings } from '../path_mappings';
-import { TracingEntryPointFinder } from './tracing_entry_point_finder';
-/**
- * An EntryPointFinder that starts from a target entry-point and only finds
- * entry-points that are dependencies of the target.
- *
- * This is faster than searching the entire file-system for all the entry-points,
- * and is used primarily by the CLI integration.
- */
-export declare class TargetedEntryPointFinder extends TracingEntryPointFinder {
-    private targetPath;
-    constructor(fs: ReadonlyFileSystem, config: NgccConfiguration, logger: Logger, resolver: DependencyResolver, basePath: AbsoluteFsPath, pathMappings: PathMappings | undefined, targetPath: AbsoluteFsPath);
-    /**
-     * Search for Angular entry-points that can be reached from the entry-point specified by the given
-     * `targetPath`.
-     */
-    findEntryPoints(): SortedEntryPointsInfo;
-    /**
-     * Determine whether the entry-point at the given `targetPath` needs to be processed.
-     *
-     * @param propertiesToConsider the package.json properties that should be considered for
-     *     processing.
-     * @param compileAllFormats true if all formats need to be processed, or false if it is enough for
-     *     one of the formats covered by the `propertiesToConsider` is processed.
-     */
-    targetNeedsProcessingOrCleaning(propertiesToConsider: EntryPointJsonProperty[], compileAllFormats: boolean): boolean;
-    /**
-     * Return an array containing the `targetPath` from which to start the trace.
-     */
-    protected getInitialEntryPointPaths(): AbsoluteFsPath[];
-    /**
-     * For the given `entryPointPath`, compute, or retrieve, the entry-point information, including
-     * paths to other entry-points that this entry-point depends upon.
-     *
-     * @param entryPointPath the path to the entry-point whose information and dependencies are to be
-     *     retrieved or computed.
-     *
-     * @returns the entry-point and its dependencies or `null` if the entry-point is not compiled by
-     *     Angular or cannot be determined.
-     */
-    protected getEntryPointWithDeps(entryPointPath: AbsoluteFsPath): EntryPointWithDependencies | null;
-    /**
-     * Compute the path to the package that contains the given entry-point.
-     *
-     * In this entry-point finder it is not trivial to find the containing package, since it is
-     * possible that this entry-point is not directly below the directory containing the package.
-     * Moreover, the import path could be affected by path-mapping.
-     *
-     * @param entryPointPath the path to the entry-point, whose package path we want to compute.
-     */
-    private computePackagePath;
-    /**
-     * Compute whether the `test` path is contained within the `base` path.
-     *
-     * Note that this doesn't use a simple `startsWith()` since that would result in a false positive
-     * for `test` paths such as `a/b/c-x` when the `base` path is `a/b/c`.
-     *
-     * Since `fs.relative()` can be quite expensive we check the fast possibilities first.
-     */
-    private isPathContainedBy;
-    /**
-     * Search down to the `entryPointPath` from the `containingPath` for the first `package.json` that
-     * we come to. This is the path to the entry-point's containing package. For example if
-     * `containingPath` is `/a/b/c` and `entryPointPath` is `/a/b/c/d/e` and there exists
-     * `/a/b/c/d/package.json` and `/a/b/c/d/e/package.json`, then we will return `/a/b/c/d`.
-     *
-     * To account for nested `node_modules` we actually start the search at the last `node_modules` in
-     * the `entryPointPath` that is below the `containingPath`. E.g. if `containingPath` is `/a/b/c`
-     * and `entryPointPath` is `/a/b/c/d/node_modules/x/y/z`, we start the search at
-     * `/a/b/c/d/node_modules`.
-     */
-    private computePackagePathFromContainingPath;
-    /**
-     * Search up the directory tree from the `entryPointPath` looking for a `node_modules` directory
-     * that we can use as a potential starting point for computing the package path.
-     */
-    private computePackagePathFromNearestNodeModules;
-    /**
-     * Split the given `path` into path segments using an FS independent algorithm.
-     */
-    private splitPath;
-}

package/ngcc/src/entry_point_finder/tracing_entry_point_finder.d.ts

@@ -1,67 +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, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { EntryPointWithDependencies } from '../dependencies/dependency_host';
-import { DependencyResolver, SortedEntryPointsInfo } from '../dependencies/dependency_resolver';
-import { NgccConfiguration } from '../packages/configuration';
-import { PathMappings } from '../path_mappings';
-import { EntryPointFinder } from './interface';
-/**
- * An EntryPointFinder that starts from a set of initial files and only returns entry-points that
- * are dependencies of these files.
- *
- * This is faster than processing all entry-points in the entire file-system, and is used primarily
- * by the CLI integration.
- *
- * There are two concrete implementations of this class.
- *
- * * `TargetEntryPointFinder` - is given a single entry-point as the initial entry-point. This can
- *   be used in the synchronous CLI integration where the build tool has identified an external
- *   import to one of the source files being built.
- * * `ProgramBasedEntryPointFinder` - computes the initial entry-points from the source files
- *   computed from a `tsconfig.json` file. This can be used in the asynchronous CLI integration
- *   where the `tsconfig.json` to be used to do the build is known.
- */
-export declare abstract class TracingEntryPointFinder implements EntryPointFinder {
-    protected fs: ReadonlyFileSystem;
-    protected config: NgccConfiguration;
-    protected logger: Logger;
-    protected resolver: DependencyResolver;
-    protected basePath: AbsoluteFsPath;
-    protected pathMappings: PathMappings | undefined;
-    private basePaths;
-    constructor(fs: ReadonlyFileSystem, config: NgccConfiguration, logger: Logger, resolver: DependencyResolver, basePath: AbsoluteFsPath, pathMappings: PathMappings | undefined);
-    /**
-     * Search for Angular package entry-points.
-     */
-    findEntryPoints(): SortedEntryPointsInfo;
-    /**
-     * Return an array of entry-point paths from which to start the trace.
-     */
-    protected abstract getInitialEntryPointPaths(): AbsoluteFsPath[];
-    /**
-     * For the given `entryPointPath`, compute, or retrieve, the entry-point information, including
-     * paths to other entry-points that this entry-point depends upon.
-     *
-     * @param entryPointPath the path to the entry-point whose information and dependencies are to be
-     *     retrieved or computed.
-     *
-     * @returns the entry-point and its dependencies or `null` if the entry-point is not compiled by
-     *     Angular or cannot be determined.
-     */
-    protected abstract getEntryPointWithDeps(entryPointPath: AbsoluteFsPath): EntryPointWithDependencies | null;
-    /**
-     * Parse the path-mappings to compute the base-paths that need to be considered when finding
-     * entry-points.
-     *
-     * This processing can be time-consuming if the path-mappings are complex or extensive.
-     * So the result is cached locally once computed.
-     */
-    protected getBasePaths(): AbsoluteFsPath[];
-}

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

@@ -1,38 +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 { Logger } from '../../../src/ngtsc/logging';
-import { PathMappings } from '../path_mappings';
-/**
- * Extract all the base-paths that we need to search for entry-points.
- *
- * This always contains the standard base-path (`sourceDirectory`).
- * But it also parses the `paths` mappings object to guess additional base-paths.
- *
- * For example:
- *
- * ```
- * getBasePaths('/node_modules', {baseUrl: '/dist', paths: {'*': ['lib/*', 'lib/generated/*']}})
- * > ['/node_modules', '/dist/lib']
- * ```
- *
- * Notice that `'/dist'` is not included as there is no `'*'` path,
- * and `'/dist/lib/generated'` is not included as it is covered by `'/dist/lib'`.
- *
- * @param sourceDirectory The standard base-path (e.g. node_modules).
- * @param pathMappings Path mapping configuration, from which to extract additional base-paths.
- */
-export declare function getBasePaths(logger: Logger, sourceDirectory: AbsoluteFsPath, pathMappings: PathMappings | undefined): AbsoluteFsPath[];
-/**
- * Run a task and track how long it takes.
- *
- * @param task The task whose duration we are tracking.
- * @param log The function to call with the duration of the task.
- * @returns The result of calling `task`.
- */
-export declare function trackDuration<T = void>(task: () => T extends Promise<unknown> ? never : T, log: (duration: number) => void): T;

package/ngcc/src/execution/analyze_entry_points.d.ts

@@ -1,9 +0,0 @@
-import { FileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { EntryPointFinder } from '../entry_point_finder/interface';
-import { EntryPointJsonProperty } from '../packages/entry_point';
-import { AnalyzeEntryPointsFn } from './api';
-/**
- * Create the function for performing the analysis of the entry-points.
- */
-export declare function getAnalyzeEntryPointsFn(logger: Logger, finder: EntryPointFinder, fileSystem: FileSystem, supportedPropertiesToConsider: EntryPointJsonProperty[], typingsOnly: boolean, compileAllFormats: boolean, propertiesToConsider: string[], inParallel: boolean): AnalyzeEntryPointsFn;

package/ngcc/src/execution/api.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
- */
-import { FileToWrite } from '../rendering/utils';
-import { Task, TaskCompletedCallback, TaskQueue } from './tasks/api';
-/**
- * The type of the function that analyzes entry-points and creates the list of tasks.
- *
- * @return A list of tasks that need to be executed in order to process the necessary format
- *         properties for all entry-points.
- */
-export type AnalyzeEntryPointsFn = () => TaskQueue;
-/** The type of the function that can process/compile a task. */
-export type CompileFn<T> = (task: Task) => void | T;
-/** The type of the function that creates the `CompileFn` function used to process tasks. */
-export type CreateCompileFn = <T extends void | Promise<void>>(beforeWritingFiles: (transformedFiles: FileToWrite[]) => T, onTaskCompleted: TaskCompletedCallback) => CompileFn<T>;
-/**
- * A class that orchestrates and executes the required work (i.e. analyzes the entry-points,
- * processes the resulting tasks, does book-keeping and validates the final outcome).
- */
-export interface Executor {
-    execute(analyzeEntryPoints: AnalyzeEntryPointsFn, createCompileFn: CreateCompileFn): void | Promise<void>;
-}