tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/parallel-parse.d.ts

@@ -0,0 +1,219 @@
+import type { Worker } from 'node:worker_threads';
+import { type SourceFile, type ExternalModuleIndicatorOptions } from './ast.js';
+import type { LoadedFile } from './file-loader.js';
+import type { CompilerOptions } from './options.js';
+import { PackageJsonLookup } from './package-json.js';
+/** What a queued file is. */
+export declare const enum LoadKind {
+    /** A root file of the config, as the config names it. */
+    Root = 0,
+    /** A file another file adds, by normalized file name. */
+    File = 1,
+    /** A library file, by its name (`lib.es2020.d.ts`). */
+    Library = 2,
+    /** The automatic type directives (`types`, or every package in `node_modules/@types`). */
+    AutomaticTypes = 3
+}
+/**
+ * Files to load: kind, name and `maxNodeModuleJsDepth` depth of each, and the size in bytes of the
+ * files a parse thread adds (0 where unknown).
+ */
+export declare class LoadJobs {
+    readonly kinds: number[];
+    readonly names: string[];
+    readonly depths: number[];
+    readonly sizes: number[];
+    push(kind: LoadKind, name: string, depth: number, size?: number): void;
+}
+/**
+ * A parsed and bound source file, with the inputs it was parsed from and what the parse thread's
+ * FileLoader found loading it (its references and their resolutions), which the program's
+ * FileLoader takes instead of resolving them again.
+ */
+export declare class PreparedFile {
+    readonly fileName: string;
+    readonly path: string;
+    readonly jsx: boolean;
+    readonly force: boolean;
+    readonly file: SourceFile;
+    /** The build info version of `file` (`computeHash` of its text) for an incremental program, or `''`. */
+    readonly version: string;
+    loaded: LoadedFile | undefined;
+    constructor(fileName: string, path: string, jsx: boolean, force: boolean, file: SourceFile, 
+    /** The build info version of `file` (`computeHash` of its text) for an incremental program, or `''`. */
+    version: string);
+}
+/** The version a parse thread computed for `file` (`PreparedFile.version`), or `''`. */
+export declare function preparedVersion(file: SourceFile): string;
+/** What a parse thread's FileLoader found loading `fileName`, if the thread prepared it. */
+export declare function preparedLoad(fileName: string): LoadedFile | undefined;
+/** What a parse thread sends back for a chunk: its bound files and the files they add. */
+export declare class PreparedBatch {
+    readonly files: PreparedFile[];
+    readonly added: LoadJobs;
+    readonly parseMs: number;
+    /** The `package.json` lookups the thread's module resolution made loading the chunk. */
+    readonly packageJsons: PackageJsonLookups;
+    constructor(files: PreparedFile[], added: LoadJobs, parseMs: number, 
+    /** The `package.json` lookups the thread's module resolution made loading the chunk. */
+    packageJsons: PackageJsonLookups);
+}
+/**
+ * `package.json` lookups: per lookup, the directory searched and whether the file exists
+ * (`PackageJsonLookup`).
+ */
+export declare class PackageJsonLookups {
+    readonly directories: string[];
+    readonly exists: boolean[];
+    readonly directoryExists: boolean[];
+}
+/**
+ * What the main thread posts a parse thread: a chunk of files to load, or `stop`. A plain object:
+ * posting copies it.
+ */
+export type LoadMessage = {
+    readonly stop: boolean;
+    readonly kinds: number[];
+    readonly names: string[];
+    readonly depths: number[];
+};
+/**
+ * Starts a parse thread (main.ts owns the worker entry point). It reads the config `configFileName`
+ * (`''` for none) with the command line of this run, takes ids from `counter`, and loads the chunks
+ * posted to it (`LoadMessage`) until it is told to stop.
+ */
+export type ParserSpawn = (configFileName: string, counter: SharedArrayBuffer, index: number) => Worker;
+export declare class ParallelParse {
+    /** Set where parse threads can be started and share what they parse (scriptc builds). */
+    spawn: ParserSpawn | undefined;
+    /** Prepared files by file name, taken by the FileLoader. */
+    readonly files: Map<string, PreparedFile>;
+    /** Files the FileLoader took, found with other parse inputs, and did not find. */
+    used: number;
+    missed: number;
+    unprepared: number;
+    /** The names of the prepared files the FileLoader took. */
+    readonly taken: Set<string>;
+    /** The `package.json` lookups of the parse threads' module resolution, of all prepared files. */
+    packageJsons: PackageJsonLookup[];
+}
+export declare const parallelParse: ParallelParse;
+/**
+ * Drops the prepared files once a program took what it needed. In a build, the next project's
+ * program must not take another project's files, which were loaded with that project's options.
+ */
+export declare function clearPreparedFiles(): void;
+/**
+ * The parse threads' `package.json` lookups, where they are the lookups the program's own module
+ * resolution would make: the program's FileLoader took every prepared file and the resolutions found
+ * loading it, also of files it then makes redirects to another copy of the same package version,
+ * whose imports its own load resolves all the same. A thread's resolution caches lookups, so the
+ * lookups of a file another file's resolution made first are among that file's: without every
+ * prepared file, some may be missing.
+ */
+export declare function preparedPackageJsonLookups(): PackageJsonLookup[] | undefined;
+/**
+ * The FileLoader's lookup: the prepared file for these parse inputs, or `undefined`. With `text`, the text the
+ * program reads for the file, a prepared file of other text is not taken (a host that serves the file itself).
+ */
+export declare function takePreparedFile(fileName: string, path: string, options: ExternalModuleIndicatorOptions, text?: string): SourceFile | undefined;
+/** The size of the file `fileName` in bytes, or 0. */
+export declare function fileSize(fileName: string): number;
+/**
+ * The files to hand out to parse threads, each queued once. Library files go out first, one per
+ * chunk, also those found later through `/// <reference lib>`: a large one (`lib.dom.d.ts`) takes a
+ * thread 100–150 ms, and queued behind other files it would be the last file the program waits for.
+ * Then, for the same reason, large files, one per chunk: root files (TypeScript's 3 MB `checker.ts`,
+ * which in a chunk of root files kept one thread busy after the others were done) and the files the
+ * parse threads found (`csstype`'s 0.9 MB of declarations, found through React's). The other files go
+ * out in program order, in chunks of up to `maxChunk`.
+ */
+export declare class ParseQueue {
+    private readonly libraries;
+    private readonly large;
+    private readonly others;
+    private libraryHead;
+    private largeHead;
+    private head;
+    private readonly seen;
+    /** Files not to load ahead: the program has them already (`ParseSession`'s `skip`). */
+    skip: ((kind: LoadKind, name: string) => boolean) | undefined;
+    /** Queues a file; the size of a root file, which the threads haven't seen, is read here. */
+    push(kind: LoadKind, name: string, depth: number, size?: number): void;
+    /** Files queued so far. */
+    queued(): number;
+    /** Files not handed out yet. */
+    left(): number;
+    /**
+     * The next chunk for one of `threads` parse threads, or `undefined` when nothing is left. With
+     * `full`, other files only go out `maxChunk` at a time, and stay queued until there are as many.
+     */
+    next(threads: number, full?: boolean): LoadMessage | undefined;
+}
+/** Libraries that take a parse thread 50 ms or more: nothing is queued behind them. */
+export declare const largeLibraries: Set<string>;
+/**
+ * Main thread: loads the program's files ahead of it on parse threads. Started with the compiler
+ * options, before the config's root files are known (`ParseSession.start` takes them), so that the
+ * threads load the libraries, the automatic type directives and the root files the `include`
+ * patterns match (`hint`) while the main thread is still matching them.
+ */
+export declare class ParseSession {
+    private readonly count;
+    private readonly currentDirectory;
+    private readonly startTime;
+    private readonly trace;
+    private readonly verbose;
+    private readonly queue;
+    private readonly workers;
+    /** Chunks posted to each thread and not yet returned. */
+    private readonly outstanding;
+    /** Whether a thread has a large library to load (`largeLibraries`). */
+    private readonly blocked;
+    private readonly alive;
+    /** Parse threads with no chunk; `busy` counts the chunks out on threads. */
+    private readonly idle;
+    private busy;
+    private chunks;
+    private finished;
+    /** Until `start`: root files are still being matched, and more may come. */
+    private matching;
+    private done;
+    /**
+     * Main-thread work done a little at a time while the threads load files: called with each batch
+     * a thread returns, once its files are available and the next chunk is out.
+     */
+    onIdle: ((batch: PreparedBatch) => void) | undefined;
+    /**
+     * Starts `count` parse threads for a program with `options`, with or without root files
+     * (`hasRootFiles`; `true` when not known yet). They read the config `configFileName` (`''` for none).
+     * They don't load the files `skip` names (a library's name, or another file's normalized name),
+     * which the program gets elsewhere; nor the files only those add.
+     */
+    constructor(count: number, options: CompilerOptions, currentDirectory: string, configFileName: string, hasRootFiles: boolean, skip?: (kind: LoadKind, name: string) => boolean);
+    /** A root file the config's `include` patterns matched, while they are still being matched. */
+    hint(fileName: string): void;
+    /** Queues the program's root files, and calls `done` once every prepared file is available. */
+    start(rootNames: readonly string[], done: () => void): void;
+    private received;
+    private post;
+    private dispatch;
+    /**
+     * Queues the full chunks left on the threads, up to `max` chunks each, the least loaded first. A thread
+     * with chunks queued doesn't wait for the main thread to hand it the next one.
+     */
+    private queueOnThreads;
+    /**
+     * Queues chunks on the threads before the main thread reads an incremental program's build info:
+     * it hands out no chunks while it reads, and the threads would wait once they finish the one each has.
+     */
+    queueAhead(): void;
+    private finish;
+}
+/**
+ * Main thread: loads the program's files ahead of it on `count` parse threads, and calls `done` once
+ * every prepared file is available to the FileLoader.
+ */
+export declare function startParallelParse(count: number, rootNames: readonly string[], options: CompilerOptions, currentDirectory: string, configFileName: string, done: () => void): void;
+/** With TSC_TS_CHECKERS_TRACE: how many prepared files the program took, and how many it parsed. */
+export declare function reportPreparedFiles(fileNames: readonly string[]): void;