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

package/ngcc/src/analysis/private_declarations_analyzer.d.ts

@@ -1,29 +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 } from '../../../src/ngtsc/file_system';
-import { NgccReflectionHost } from '../host/ngcc_host';
-import { NgccReferencesRegistry } from './ngcc_references_registry';
-export interface ExportInfo {
-    identifier: string;
-    from: AbsoluteFsPath;
-    dtsFrom?: AbsoluteFsPath | null;
-}
-export type PrivateDeclarationsAnalyses = ExportInfo[];
-/**
- * This class will analyze a program to find all the declared classes
- * (i.e. on an NgModule) that are not publicly exported via an entry-point.
- */
-export declare class PrivateDeclarationsAnalyzer {
-    private host;
-    private referencesRegistry;
-    constructor(host: NgccReflectionHost, referencesRegistry: NgccReferencesRegistry);
-    analyzeProgram(program: ts.Program): PrivateDeclarationsAnalyses;
-    private getRootFiles;
-    private getPrivateDeclarations;
-}

package/ngcc/src/analysis/types.d.ts

@@ -1,29 +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 { ConstantPool } from '@angular/compiler';
-import ts from 'typescript';
-import { Reexport } from '../../../src/ngtsc/imports';
-import { ClassDeclaration, Decorator } from '../../../src/ngtsc/reflection';
-import { CompileResult } from '../../../src/ngtsc/transform';
-export interface CompiledClass {
-    name: string;
-    decorators: Decorator[] | null;
-    declaration: ClassDeclaration;
-    compilation: CompileResult[];
-}
-export interface CompiledFile {
-    compiledClasses: CompiledClass[];
-    sourceFile: ts.SourceFile;
-    constantPool: ConstantPool;
-    /**
-     * Any re-exports which should be added next to this class, both in .js and (if possible) .d.ts.
-     */
-    reexports: Reexport[];
-}
-export type DecorationAnalyses = Map<ts.SourceFile, CompiledFile>;
-export declare const DecorationAnalyses: MapConstructor;

package/ngcc/src/analysis/util.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
- */
-import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
-import { DependencyTracker } from '../../../src/ngtsc/incremental/api';
-export declare function isWithinPackage(packagePath: AbsoluteFsPath, filePath: AbsoluteFsPath): boolean;
-export declare const NOOP_DEPENDENCY_TRACKER: DependencyTracker;

package/ngcc/src/command_line_options.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import { NgccOptions } from './ngcc_options';
-export declare function parseCommandLineOptions(args: string[]): NgccOptions;

package/ngcc/src/constants.d.ts

@@ -1,9 +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
- */
-export declare const IMPORT_PREFIX = "\u0275ngcc";
-export declare const NGCC_TIMED_OUT_EXIT_CODE = 177;

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

@@ -1,20 +0,0 @@
-import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
-import { DependencyHostBase } from './dependency_host';
-/**
- * Helper functions for computing dependencies.
- */
-export declare class CommonJsDependencyHost extends DependencyHostBase {
-    protected canSkipFile(fileContents: string): boolean;
-    protected extractImports(file: AbsoluteFsPath, fileContents: string): Set<string>;
-}
-/**
- * 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 require calls
- * in this file, true otherwise.
- */
-export declare function hasRequireCalls(source: string): boolean;

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

@@ -1,77 +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, PathSegment, ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { EntryPoint } from '../packages/entry_point';
-import { ModuleResolver } from './module_resolver';
-export interface DependencyHost {
-    collectDependencies(entryPointPath: AbsoluteFsPath, { dependencies, missing, deepImports }: DependencyInfo): void;
-}
-export interface DependencyInfo {
-    dependencies: Set<AbsoluteFsPath>;
-    missing: Set<AbsoluteFsPath | PathSegment>;
-    deepImports: Set<AbsoluteFsPath>;
-}
-export interface EntryPointWithDependencies {
-    entryPoint: EntryPoint;
-    depInfo: DependencyInfo;
-}
-export declare function createDependencyInfo(): DependencyInfo;
-export declare abstract class DependencyHostBase implements DependencyHost {
-    protected fs: ReadonlyFileSystem;
-    protected moduleResolver: ModuleResolver;
-    constructor(fs: ReadonlyFileSystem, moduleResolver: ModuleResolver);
-    /**
-     * Find all the dependencies for the entry-point at the given path.
-     *
-     * @param entryPointPath The absolute path to the JavaScript file that represents an entry-point.
-     * @param dependencyInfo An object containing information about the dependencies of the
-     * entry-point, including those that were missing or deep imports into other entry-points. The
-     * sets in this object will be updated with new information about the entry-point's dependencies.
-     */
-    collectDependencies(entryPointPath: AbsoluteFsPath, { dependencies, missing, deepImports }: DependencyInfo): void;
-    /**
-     * Find all the dependencies for the provided paths.
-     *
-     * @param files The list of absolute paths of JavaScript files to scan for dependencies.
-     * @param dependencyInfo An object containing information about the dependencies of the
-     * entry-point, including those that were missing or deep imports into other entry-points. The
-     * sets in this object will be updated with new information about the entry-point's dependencies.
-     */
-    collectDependenciesInFiles(files: AbsoluteFsPath[], { dependencies, missing, deepImports }: DependencyInfo): void;
-    /**
-     * Compute the dependencies of the given file.
-     *
-     * @param file An absolute path to the file whose dependencies we want to get.
-     * @param dependencies A set that will have the absolute paths of resolved entry points added to
-     * it.
-     * @param missing A set that will have the dependencies that could not be found added to it.
-     * @param deepImports A set that will have the import paths that exist but cannot be mapped to
-     * entry-points, i.e. deep-imports.
-     * @param alreadySeen A set that is used to track internal dependencies to prevent getting stuck
-     * in a circular dependency loop.
-     */
-    protected recursivelyCollectDependencies(file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): void;
-    protected abstract canSkipFile(fileContents: string): boolean;
-    protected abstract extractImports(file: AbsoluteFsPath, fileContents: string): Set<string>;
-    /**
-     * Resolve the given `importPath` from `file` and add it to the appropriate set.
-     *
-     * If the import is local to this package then follow it by calling
-     * `recursivelyCollectDependencies()`.
-     *
-     * @returns `true` if the import was resolved (to an entry-point, a local import, or a
-     * deep-import), `false` otherwise.
-     */
-    protected processImport(importPath: string, file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): boolean;
-    /**
-     * Processes the file if it has not already been seen. This will also recursively process
-     * all files that are imported from the file, while taking the set of already seen files
-     * into account.
-     */
-    protected processFile(file: AbsoluteFsPath, dependencies: Set<AbsoluteFsPath>, missing: Set<string>, deepImports: Set<string>, alreadySeen: Set<AbsoluteFsPath>): void;
-}

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