tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/file-loader.d.ts

@@ -0,0 +1,261 @@
+/**
+ * Finds every file of a program: root files, libraries, references, imports and type directives, in tsgo's order.
+ */
+import { StringLiteral, type ExternalModuleIndicatorOptions, type Node, type SourceFile } from './ast.js';
+import { type MessageWithArgs } from './diagnostics.js';
+import { FileIncludeReason, IncludeProcessor, ProcessingDiagnostic } from './file-include.js';
+import type { FileSystem } from './file-system.js';
+import { ModuleResolutionHost, Resolver } from './module-resolution.js';
+import { type PackageId, type ResolvedModule, type ResolvedTypeReferenceDirective } from './module-resolution-types.js';
+import { ModuleKind, type CompilerOptions } from './options.js';
+import { LoadKind, type LoadJobs, type PreparedFile } from './parallel-parse.js';
+import type { PackageJsonLookup } from './package-json.js';
+import { SourceFileMetadata } from './program-utilities.js';
+import { type ParsedCommandLine, type SourceOutputAndProjectReference } from './tsconfig.js';
+/** Files and services the compiler reads through. */
+export declare class CompilerHost extends ModuleResolutionHost {
+    readonly fs: FileSystem;
+    readonly currentDirectory: string;
+    /** Where bundled `lib.*.d.ts` files are. */
+    readonly defaultLibraryPath: string;
+    private readonly configParser;
+    constructor(fs: FileSystem, currentDirectory: string, 
+    /** Where bundled `lib.*.d.ts` files are. */
+    defaultLibraryPath: string);
+    useCaseSensitiveFileNames(): boolean;
+    getCurrentDirectory(): string;
+    fileExists(path: string): boolean;
+    directoryExists(path: string): boolean;
+    readFile(path: string): string | undefined;
+    realpath(path: string): string;
+    getDirectories(path: string): readonly string[];
+    /** Parses a file, or returns `undefined` if it can't be read. */
+    getSourceFile(fileName: string, path: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions): SourceFile | undefined;
+    /** The config of a referenced project, or `undefined` if it can't be read. */
+    getResolvedProjectReference(fileName: string): ParsedCommandLine | undefined;
+    /** Called with module resolution traces under `--traceResolution`. */
+    trace(_message: MessageWithArgs): void;
+}
+/** A bundled library file. */
+export declare class LibFile {
+    readonly name: string;
+    readonly path: string;
+    /** Found through `libReplacement` in `node_modules/@typescript/lib-*`. */
+    readonly replaced: boolean;
+    constructor(name: string, path: string, 
+    /** Found through `libReplacement` in `node_modules/@typescript/lib-*`. */
+    replaced: boolean);
+}
+/** The JSX runtime import of a file, synthesized for resolution. */
+export declare class JsxRuntimeImport {
+    readonly moduleReference: string;
+    readonly specifier: StringLiteral;
+    constructor(moduleReference: string, specifier: StringLiteral);
+}
+/** A file found through a package installed at several places, kept only once. */
+export declare class RedirectFile {
+    /** Where in `getSourceFiles()` order it is explained. */
+    index: number;
+    readonly fileName: string;
+    readonly path: string;
+    /** The path of the file it redirects to. */
+    readonly target: string;
+    constructor(
+    /** Where in `getSourceFiles()` order it is explained. */
+    index: number, fileName: string, path: string, 
+    /** The path of the file it redirects to. */
+    target: string);
+}
+/** Module resolution results of a file, by name and mode. */
+export type ModeAwareCache<T> = Map<string, T>;
+export declare function modeAwareKey(name: string, mode: ModuleKind): string;
+/** A file a loaded file adds (`ParseTask.addSubTask`), as a parse thread recorded it (`LoadedFile`). */
+export declare class LoadedReference {
+    readonly normalizedFilePath: string;
+    /** The library file's name, or `''`. */
+    readonly libName: string;
+    readonly reason: FileIncludeReason;
+    readonly increaseDepth: boolean;
+    readonly elideOnDepth: boolean;
+    readonly packageId: PackageId | undefined;
+    constructor(normalizedFilePath: string, 
+    /** The library file's name, or `''`. */
+    libName: string, reason: FileIncludeReason, increaseDepth: boolean, elideOnDepth: boolean, packageId: PackageId | undefined);
+}
+/**
+ * What a parse thread's FileLoader found loading a file it prepared (parallel-parse.ts): the same
+ * as the program's FileLoader finds, since both load with the same options and file system. The
+ * program's FileLoader takes it instead of resolving the file's references, imports and type
+ * directives again. Published with the file, so the reasons are copied when taken.
+ */
+export declare class LoadedFile {
+    readonly file: SourceFile;
+    readonly isLibFile: boolean;
+    readonly metadata: SourceFileMetadata;
+    readonly references: LoadedReference[];
+    readonly resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined;
+    readonly typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined;
+    readonly processingDiagnostics: ProcessingDiagnostic[];
+    readonly importHelpersImportSpecifier: StringLiteral | undefined;
+    readonly jsxRuntimeImport: JsxRuntimeImport | undefined;
+    constructor(file: SourceFile, isLibFile: boolean, metadata: SourceFileMetadata, references: LoadedReference[], resolutionsInFile: ModeAwareCache<ResolvedModule> | undefined, typeResolutionsInFile: ModeAwareCache<ResolvedTypeReferenceDirective> | undefined, processingDiagnostics: ProcessingDiagnostic[], importHelpersImportSpecifier: StringLiteral | undefined, jsxRuntimeImport: JsxRuntimeImport | undefined);
+}
+/** Referenced projects, and how their sources map to declaration outputs. */
+export declare class ProjectReferenceMapper {
+    readonly config: ParsedCommandLine;
+    readonly configToProjectReference: Map<string, ParsedCommandLine | undefined>;
+    readonly referencesInConfigFile: Map<string, readonly string[]>;
+    readonly sourceToProjectReference: Map<string, SourceOutputAndProjectReference>;
+    readonly outputDtsToProjectReference: Map<string, SourceOutputAndProjectReference>;
+    private readonly realpathDtsToSource;
+    /** Set while loading files, for symlink lookups. */
+    loader: FileLoader | undefined;
+    constructor(config: ParsedCommandLine);
+    /** The declaration output to load instead of a source of a referenced project, or `''`. */
+    getParseFileRedirect(path: string): string;
+    /** The referenced project whose options apply to a file. */
+    getRedirectForResolution(path: string, fileName: string): SourceOutputAndProjectReference | undefined;
+    getCompilerOptionsForFile(path: string, fileName: string): CompilerOptions;
+    /** Under `preserveSymlinks`, a symlinked declaration in `node_modules` may be the output of a reference. */
+    private getSourceToDtsIfSymlink;
+    /** The configs of the root config's references, `undefined` for those that couldn't be read. */
+    resolvedProjectReferences(): (ParsedCommandLine | undefined)[];
+}
+/** What loading produced. */
+export declare class ProcessedFiles {
+    readonly resolver: Resolver;
+    /** Libraries first, sorted, then other files in load order. */
+    readonly files: readonly SourceFile[];
+    readonly filesByPath: ReadonlyMap<string, SourceFile>;
+    readonly missingFiles: readonly string[];
+    readonly resolvedModules: ReadonlyMap<string, ModeAwareCache<ResolvedModule> | undefined>;
+    readonly typeResolutionsInFile: ReadonlyMap<string, ModeAwareCache<ResolvedTypeReferenceDirective> | undefined>;
+    readonly sourceFileMetadata: ReadonlyMap<string, SourceFileMetadata>;
+    readonly jsxRuntimeImports: ReadonlyMap<string, JsxRuntimeImport>;
+    readonly importHelpersImportSpecifiers: ReadonlyMap<string, StringLiteral>;
+    readonly libFiles: ReadonlyMap<string, LibFile>;
+    /** Files found while searching `node_modules`. */
+    readonly sourceFilesFoundSearchingNodeModules: ReadonlySet<string>;
+    readonly includeProcessor: IncludeProcessor;
+    /** Declaration outputs of referenced projects loaded for their sources, mapped back to the sources. */
+    readonly outputFileToProjectReferenceSource: ReadonlyMap<string, string>;
+    readonly redirectTargets: ReadonlyMap<string, string[]>;
+    readonly redirectFilesByPath: ReadonlyMap<string, RedirectFile>;
+    readonly projectReferenceMapper: ProjectReferenceMapper;
+    /**
+     * The `package.json` lookups made resolving the files whose resolutions were taken from parse
+     * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
+     */
+    readonly preparedPackageJsons: readonly PackageJsonLookup[] | undefined;
+    constructor(resolver: Resolver, 
+    /** Libraries first, sorted, then other files in load order. */
+    files: readonly SourceFile[], filesByPath: ReadonlyMap<string, SourceFile>, missingFiles: readonly string[], resolvedModules: ReadonlyMap<string, ModeAwareCache<ResolvedModule> | undefined>, typeResolutionsInFile: ReadonlyMap<string, ModeAwareCache<ResolvedTypeReferenceDirective> | undefined>, sourceFileMetadata: ReadonlyMap<string, SourceFileMetadata>, jsxRuntimeImports: ReadonlyMap<string, JsxRuntimeImport>, importHelpersImportSpecifiers: ReadonlyMap<string, StringLiteral>, libFiles: ReadonlyMap<string, LibFile>, 
+    /** Files found while searching `node_modules`. */
+    sourceFilesFoundSearchingNodeModules: ReadonlySet<string>, includeProcessor: IncludeProcessor, 
+    /** Declaration outputs of referenced projects loaded for their sources, mapped back to the sources. */
+    outputFileToProjectReferenceSource: ReadonlyMap<string, string>, redirectTargets: ReadonlyMap<string, string[]>, redirectFilesByPath: ReadonlyMap<string, RedirectFile>, projectReferenceMapper: ProjectReferenceMapper, 
+    /**
+     * The `package.json` lookups made resolving the files whose resolutions were taken from parse
+     * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
+     */
+    preparedPackageJsons: readonly PackageJsonLookup[] | undefined);
+}
+/** The files of `processed` with `file` in place of the file at its path, for `Program.updateFile`. */
+export declare function withReplacedFile(processed: ProcessedFiles, file: SourceFile): ProcessedFiles;
+/** Whether `file` imports the `importHelpers` module (tslib) under `options`. */
+export declare function needsImportHelpersImportSpecifier(file: SourceFile, options: CompilerOptions): boolean;
+/** The module `file` imports the JSX runtime from under `options`, or '' if it imports none. */
+export declare function jsxRuntimeImportOf(file: SourceFile, options: CompilerOptions): string;
+/**
+ * Whether `next`, a new version of `file`, can take its place in a program without loading the program again,
+ * as tsgo's canReplaceFileInProgram checks: it has the same script kind, is a module if `file` is one, and has
+ * the same module specifiers with the same resolution modes (`modeOf`), module augmentation names, ambient
+ * modules, file, type and library references, `// @ts-check` directive and node core module style. A CommonJS
+ * module indicator is set when a file is bound, so `next` has none yet; the new program's binder sets it.
+ */
+export declare function canReplaceFile(file: SourceFile, next: SourceFile, modeOf: (file: SourceFile, specifier: Node) => ModuleKind): boolean;
+/** Loads files depth-first in tsgo's single-threaded order; the result does not depend on that order. */
+export declare class FileLoader {
+    readonly host: CompilerHost;
+    private readonly config;
+    readonly resolver: Resolver;
+    readonly mapper: ProjectReferenceMapper;
+    private readonly options;
+    private readonly defaultLibraryPath;
+    private readonly supportedExtensions;
+    private readonly supportedExtensionsWithJson;
+    private readonly maxNodeModuleJsDepth;
+    private readonly rootTasks;
+    private readonly taskDataByPath;
+    /** Work queued by `start`, run last-in first-out like tsgo's single-threaded work group. */
+    private readonly work;
+    private readonly libFileCache;
+    private readonly libResolutions;
+    private readonly referenceTasks;
+    /** `toPath` of each file name seen: every reference to a file asks again. */
+    private readonly paths;
+    /** The normalized config file name root files are found from, once computed. */
+    private rootContainingFile;
+    /** Root files whose tasks `addRootFiles` added. */
+    private rootFilesAdded;
+    /** The sub-tasks of prepared files, by file name, built ahead by `takeAhead`. */
+    private readonly subTasksAhead;
+    /**
+     * Whether a file that parse threads prepared is loaded from what its thread found (its metadata
+     * and resolutions). If not, only the parsed and bound file is taken, and this loader looks up the
+     * file's metadata and resolves its references and imports itself, as without parse threads.
+     */
+    takesPreparedResolutions: boolean;
+    private tookPreparedResolutions;
+    constructor(host: CompilerHost, config: ParsedCommandLine);
+    toPath(fileName: string): string;
+    /**
+     * Adds the tasks of up to `count` more root files, the first step of `load`: the main thread does
+     * this while parse threads load the files (parallel-parse.ts). Returns whether every root file's
+     * task is added.
+     */
+    addRootFiles(count: number): boolean;
+    /**
+     * Builds ahead what loading takes from each of `files` (`takeLoadedFile`): the main thread does
+     * this while parse threads load more files (parallel-parse.ts).
+     */
+    takeAhead(files: readonly PreparedFile[]): void;
+    load(): ProcessedFiles;
+    /**
+     * Parse threads (parallel-parse.ts): loads one file as `load` would, parsing it through
+     * `host.getSourceFile`, and adds the files it references, imports and type directives add to `out`
+     * (libraries by name). `depth` is the file's `maxNodeModuleJsDepth` depth.
+     */
+    loadAhead(kind: LoadKind, name: string, depth: number, out: LoadJobs): LoadedFile | undefined;
+    private loadProjectReferences;
+    private parseProjectReferences;
+    private mapProjectReferences;
+    private addRootTask;
+    private addRootFileTask;
+    private isSupportedExtension;
+    private supportedExtensionsList;
+    /** The file a root file or `/// <reference path>` names, trying extensions, or why there is none. */
+    private getSourceFileFromReference;
+    /** The normalized file name of the library file `name` (`lib.dom.d.ts`), as `loadAhead` loads it. */
+    libraryFileName(name: string): string;
+    private pathForLibFile;
+    private libFilePriority;
+    private start;
+    private run;
+    private loadTask;
+    /** Loads `task` from what a parse thread found loading the same file (`LoadedFile`). */
+    private takeLoadedFile;
+    /** New tasks of the references a parse thread found loading a file. */
+    private subTasksOf;
+    private loadSourceFileMetadata;
+    private resolveTripleSlashPathReference;
+    private resolveTypeReferenceDirectives;
+    private loadAutomaticTypeDirectives;
+    private resolveImportsAndModuleAugmentations;
+    private collect;
+}
+/**
+ * The metadata of `fileName` in a program with `options`: the `type` and directory of its nearest
+ * package.json (`resolver`), where they apply, and its implied module format.
+ */
+export declare function sourceFileMetadataOf(resolver: Resolver, options: CompilerOptions, fileName: string): SourceFileMetadata;