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

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

@@ -1,102 +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 { DepGraph } from 'dependency-graph';
-import { ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { Logger } from '../../../src/ngtsc/logging';
-import { NgccConfiguration } from '../packages/configuration';
-import { EntryPoint, EntryPointFormat } from '../packages/entry_point';
-import { PartiallyOrderedList } from '../utils';
-import { DependencyHost, EntryPointWithDependencies } from './dependency_host';
-/**
- * Holds information about entry points that are removed because
- * they have dependencies that are missing (directly or transitively).
- *
- * This might not be an error, because such an entry point might not actually be used
- * in the application. If it is used then the `ngc` application compilation would
- * fail also, so we don't need ngcc to catch this.
- *
- * For example, consider an application that uses the `@angular/router` package.
- * This package includes an entry-point called `@angular/router/upgrade`, which has a dependency
- * on the `@angular/upgrade` package.
- * If the application never uses code from `@angular/router/upgrade` then there is no need for
- * `@angular/upgrade` to be installed.
- * In this case the ngcc tool should just ignore the `@angular/router/upgrade` end-point.
- */
-export interface InvalidEntryPoint {
-    entryPoint: EntryPoint;
-    missingDependencies: string[];
-}
-/**
- * Holds information about dependencies of an entry-point that do not need to be processed
- * by the ngcc tool.
- *
- * For example, the `rxjs` package does not contain any Angular decorators that need to be
- * compiled and so this can be safely ignored by ngcc.
- */
-export interface IgnoredDependency {
-    entryPoint: EntryPoint;
-    dependencyPath: string;
-}
-export interface DependencyDiagnostics {
-    invalidEntryPoints: InvalidEntryPoint[];
-    ignoredDependencies: IgnoredDependency[];
-}
-/**
- * Represents a partially ordered list of entry-points.
- *
- * The entry-points' order/precedence is such that dependent entry-points always come later than
- * their dependencies in the list.
- *
- * See `DependencyResolver#sortEntryPointsByDependency()`.
- */
-export type PartiallyOrderedEntryPoints = PartiallyOrderedList<EntryPoint>;
-/**
- * A list of entry-points, sorted by their dependencies, and the dependency graph.
- *
- * The `entryPoints` array will be ordered so that no entry point depends upon an entry point that
- * appears later in the array.
- *
- * Some entry points or their dependencies may have been ignored. These are captured for
- * diagnostic purposes in `invalidEntryPoints` and `ignoredDependencies` respectively.
- */
-export interface SortedEntryPointsInfo extends DependencyDiagnostics {
-    entryPoints: PartiallyOrderedEntryPoints;
-    graph: DepGraph<EntryPoint>;
-}
-/**
- * A class that resolves dependencies between entry-points.
- */
-export declare class DependencyResolver {
-    private fs;
-    private logger;
-    private config;
-    private hosts;
-    private typingsHost;
-    constructor(fs: ReadonlyFileSystem, logger: Logger, config: NgccConfiguration, hosts: Partial<Record<EntryPointFormat, DependencyHost>>, typingsHost: DependencyHost);
-    /**
-     * Sort the array of entry points so that the dependant entry points always come later than
-     * their dependencies in the array.
-     * @param entryPoints An array entry points to sort.
-     * @param target If provided, only return entry-points depended on by this entry-point.
-     * @returns the result of sorting the entry points by dependency.
-     */
-    sortEntryPointsByDependency(entryPoints: EntryPointWithDependencies[], target?: EntryPoint): SortedEntryPointsInfo;
-    getEntryPointWithDependencies(entryPoint: EntryPoint): EntryPointWithDependencies;
-    /**
-     * Computes a dependency graph of the given entry-points.
-     *
-     * The graph only holds entry-points that ngcc cares about and whose dependencies
-     * (direct and transitive) all exist.
-     */
-    private computeDependencyGraph;
-    private getEntryPointFormatInfo;
-    /**
-     * Filter out the deepImports that can be ignored, according to this entryPoint's config.
-     */
-    private filterIgnorableDeepImports;
-}

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

@@ -1,20 +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';
-import { EsmDependencyHost } from './esm_dependency_host';
-/**
- * Helper functions for computing dependencies via typings files.
- */
-export declare class DtsDependencyHost extends EsmDependencyHost {
-    constructor(fs: ReadonlyFileSystem, pathMappings?: PathMappings);
-    /**
-     * Attempts to process the `importPath` directly and also inside `@types/...`.
-     */
-    protected processImport(importPath: string, file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): boolean;
-}

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;
-}