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

package/ngcc/index.d.ts

@@ -1,19 +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 { AsyncNgccOptions, SyncNgccOptions } from './src/ngcc_options';
-export { ConsoleLogger, Logger, LogLevel } from '../src/ngtsc/logging';
-export { AsyncNgccOptions, clearTsConfigCache, NgccOptions, SyncNgccOptions } from './src/ngcc_options';
-export { PathMappings } from './src/path_mappings';
-export declare function process<T extends AsyncNgccOptions | SyncNgccOptions>(options: T): T extends AsyncNgccOptions ? Promise<void> : void;
-/**
- * Absolute file path that points to the `ngcc` command line entry-point.
- *
- * This can be used by the Angular CLI to spawn a process running ngcc using
- * command line options.
- */
-export declare const ngccMainFilePath: string;

package/ngcc/main-ngcc.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

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

@@ -1,80 +0,0 @@
-import ts from 'typescript';
-import { ParsedConfiguration } from '../../..';
-import { ReferencesRegistry, ResourceLoader } from '../../../src/ngtsc/annotations';
-import { InjectableClassRegistry } from '../../../src/ngtsc/annotations/common';
-import { CycleAnalyzer, ImportGraph } from '../../../src/ngtsc/cycles';
-import { ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
-import { ModuleResolver, PrivateExportAliasingHost, ReferenceEmitter } from '../../../src/ngtsc/imports';
-import { SemanticSymbol } from '../../../src/ngtsc/incremental/semantic_graph';
-import { CompoundMetadataReader, CompoundMetadataRegistry, DtsMetadataReader, HostDirectivesResolver, LocalMetadataRegistry } from '../../../src/ngtsc/metadata';
-import { PartialEvaluator } from '../../../src/ngtsc/partial_evaluator';
-import { LocalModuleScopeRegistry, MetadataDtsModuleScopeResolver, TypeCheckScopeRegistry } from '../../../src/ngtsc/scope';
-import { DecoratorHandler } from '../../../src/ngtsc/transform';
-import { NgccReflectionHost } from '../host/ngcc_host';
-import { Migration } from '../migrations/migration';
-import { EntryPointBundle } from '../packages/entry_point_bundle';
-import { NgccTraitCompiler } from './ngcc_trait_compiler';
-import { CompiledFile, DecorationAnalyses } from './types';
-/**
- * Simple class that resolves and loads files directly from the filesystem.
- */
-declare class NgccResourceLoader implements ResourceLoader {
-    private fs;
-    constructor(fs: ReadonlyFileSystem);
-    canPreload: boolean;
-    canPreprocess: boolean;
-    preload(): undefined | Promise<void>;
-    preprocessInline(): Promise<string>;
-    load(url: string): string;
-    resolve(url: string, containingFile: string): string;
-}
-/**
- * This Analyzer will analyze the files that have decorated classes that need to be transformed.
- */
-export declare class DecorationAnalyzer {
-    private fs;
-    private bundle;
-    private reflectionHost;
-    private referencesRegistry;
-    private diagnosticHandler;
-    private tsConfig;
-    private program;
-    private options;
-    private host;
-    private typeChecker;
-    private rootDirs;
-    private packagePath;
-    private isCore;
-    private compilerOptions;
-    moduleResolver: ModuleResolver;
-    resourceManager: NgccResourceLoader;
-    metaRegistry: LocalMetadataRegistry;
-    dtsMetaReader: DtsMetadataReader;
-    fullMetaReader: CompoundMetadataReader;
-    refEmitter: ReferenceEmitter;
-    aliasingHost: PrivateExportAliasingHost | null;
-    dtsModuleScopeResolver: MetadataDtsModuleScopeResolver;
-    scopeRegistry: LocalModuleScopeRegistry;
-    fullRegistry: CompoundMetadataRegistry;
-    evaluator: PartialEvaluator;
-    importGraph: ImportGraph;
-    cycleAnalyzer: CycleAnalyzer;
-    injectableRegistry: InjectableClassRegistry;
-    hostDirectivesResolver: HostDirectivesResolver;
-    typeCheckScopeRegistry: TypeCheckScopeRegistry;
-    handlers: DecoratorHandler<unknown, unknown, SemanticSymbol | null, unknown>[];
-    compiler: NgccTraitCompiler;
-    migrations: Migration[];
-    constructor(fs: ReadonlyFileSystem, bundle: EntryPointBundle, reflectionHost: NgccReflectionHost, referencesRegistry: ReferencesRegistry, diagnosticHandler?: (error: ts.Diagnostic) => void, tsConfig?: ParsedConfiguration | null);
-    /**
-     * Analyze a program to find all the decorated files should be transformed.
-     *
-     * @returns a map of the source files to the analysis for those files.
-     */
-    analyzeProgram(): DecorationAnalyses;
-    protected applyMigrations(): void;
-    protected reportDiagnostics(): void;
-    protected compileFile(sourceFile: ts.SourceFile): CompiledFile;
-    private getReexportsForSourceFile;
-}
-export {};

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

@@ -1,22 +0,0 @@
-import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
-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';
-import { MigrationHost } from '../migrations/migration';
-import { NgccTraitCompiler } from './ngcc_trait_compiler';
-/**
- * The standard implementation of `MigrationHost`, which is created by the `DecorationAnalyzer`.
- */
-export declare class DefaultMigrationHost implements MigrationHost {
-    readonly reflectionHost: NgccReflectionHost;
-    readonly metadata: MetadataReader;
-    readonly evaluator: PartialEvaluator;
-    private compiler;
-    private entryPointPath;
-    constructor(reflectionHost: NgccReflectionHost, metadata: MetadataReader, evaluator: PartialEvaluator, compiler: NgccTraitCompiler, entryPointPath: AbsoluteFsPath);
-    injectSyntheticDecorator(clazz: ClassDeclaration, decorator: Decorator, flags?: HandlerFlags): void;
-    getAllDecorators(clazz: ClassDeclaration): Decorator[] | null;
-    isInScope(clazz: ClassDeclaration): boolean;
-}

package/ngcc/src/analysis/module_with_providers_analyzer.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 ts from 'typescript';
-import { ReferencesRegistry } from '../../../src/ngtsc/annotations';
-import { Reference } from '../../../src/ngtsc/imports';
-import { ClassDeclaration, DeclarationNode } from '../../../src/ngtsc/reflection';
-import { NgccReflectionHost } from '../host/ngcc_host';
-/**
- * A structure returned from `getModuleWithProvidersFunctions()` that describes functions
- * that return ModuleWithProviders objects.
- */
-export interface ModuleWithProvidersInfo {
-    /**
-     * The name of the declared function.
-     */
-    name: string;
-    /**
-     * The declaration of the function that returns the `ModuleWithProviders` object.
-     */
-    declaration: ts.SignatureDeclaration;
-    /**
-     * Declaration of the containing class (if this is a method)
-     */
-    container: DeclarationNode | null;
-    /**
-     * The declaration of the class that the `ngModule` property on the `ModuleWithProviders` object
-     * refers to.
-     */
-    ngModule: Reference<ClassDeclaration>;
-}
-export type ModuleWithProvidersAnalyses = Map<ts.SourceFile, ModuleWithProvidersInfo[]>;
-export declare const ModuleWithProvidersAnalyses: MapConstructor;
-export declare class ModuleWithProvidersAnalyzer {
-    private host;
-    private typeChecker;
-    private referencesRegistry;
-    private processDts;
-    private evaluator;
-    constructor(host: NgccReflectionHost, typeChecker: ts.TypeChecker, referencesRegistry: ReferencesRegistry, processDts: boolean);
-    analyzeProgram(program: ts.Program): ModuleWithProvidersAnalyses;
-    private getRootFiles;
-    private getModuleWithProvidersFunctions;
-    /**
-     * Parse a function/method node (or its implementation), to see if it returns a
-     * `ModuleWithProviders` object.
-     * @param name The name of the function.
-     * @param node the node to check - this could be a function, a method or a variable declaration.
-     * @param implementation the actual function expression if `node` is a variable declaration.
-     * @param container the class that contains the function, if it is a method.
-     * @returns info about the function if it does return a `ModuleWithProviders` object; `null`
-     * otherwise.
-     */
-    private parseForModuleWithProviders;
-    private getDtsModuleWithProvidersFunction;
-    private resolveNgModuleReference;
-}

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

@@ -1,34 +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 { ReferencesRegistry } from '../../../src/ngtsc/annotations';
-import { Reference } from '../../../src/ngtsc/imports';
-import { Declaration, DeclarationNode, ReflectionHost } from '../../../src/ngtsc/reflection';
-/**
- * This is a place for DecoratorHandlers to register references that they
- * find in their analysis of the code.
- *
- * This registry is used to ensure that these references are publicly exported
- * from libraries that are compiled by ngcc.
- */
-export declare class NgccReferencesRegistry implements ReferencesRegistry {
-    private host;
-    private map;
-    constructor(host: ReflectionHost);
-    /**
-     * Register one or more references in the registry.
-     * Only `ResolveReference` references are stored. Other types are ignored.
-     * @param references A collection of references to register.
-     */
-    add(source: DeclarationNode, ...references: Reference<DeclarationNode>[]): void;
-    /**
-     * Create and return a mapping for the registered resolved references.
-     * @returns A map of reference identifiers to reference declarations.
-     */
-    getDeclarationMap(): Map<ts.Identifier, Declaration>;
-}

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

@@ -1,42 +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 { SemanticSymbol } from '../../../src/ngtsc/incremental/semantic_graph';
-import { ClassDeclaration, Decorator } from '../../../src/ngtsc/reflection';
-import { DecoratorHandler, HandlerFlags, Trait, TraitCompiler } from '../../../src/ngtsc/transform';
-import { NgccReflectionHost } from '../host/ngcc_host';
-/**
- * Specializes the `TraitCompiler` for ngcc purposes. Mainly, this includes an alternative way of
- * scanning for classes to compile using the reflection host's `findClassSymbols`, together with
- * support to inject synthetic decorators into the compilation for ad-hoc migrations that ngcc
- * performs.
- */
-export declare class NgccTraitCompiler extends TraitCompiler {
-    private ngccReflector;
-    constructor(handlers: DecoratorHandler<unknown, unknown, SemanticSymbol | null, unknown>[], ngccReflector: NgccReflectionHost);
-    get analyzedFiles(): ts.SourceFile[];
-    /**
-     * Analyzes the source file in search for classes to process. For any class that is found in the
-     * file, a `ClassRecord` is created and the source file is included in the `analyzedFiles` array.
-     */
-    analyzeFile(sf: ts.SourceFile): void;
-    /**
-     * 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): Trait<unknown, unknown, SemanticSymbol | null, unknown>[];
-    /**
-     * Returns all decorators that have been recognized for the provided class, including any
-     * synthetically injected decorators.
-     * @param clazz the declaration for which the decorators are returned.
-     */
-    getAllDecorators(clazz: ClassDeclaration): Decorator[] | null;
-}

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