tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/output-paths.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Where emit writes the outputs of a source file.
+ */
+import type { CompilerOptions, JsxEmit } from './options.js';
+/** What output paths depend on besides options. */
+export interface OutputPathsHost {
+    /** With a trailing `/`, or `''`. */
+    commonSourceDirectory(): string;
+    readonly currentDirectory: string;
+    readonly useCaseSensitiveFileNames: boolean;
+}
+/** The files emitted for one source file; `''` for those not emitted. */
+export declare class OutputPaths {
+    readonly jsFilePath: string;
+    readonly sourceMapFilePath: string;
+    readonly declarationFilePath: string;
+    readonly declarationMapPath: string;
+    constructor(jsFilePath: string, sourceMapFilePath: string, declarationFilePath: string, declarationMapPath: string);
+}
+export declare function getOutputPathsFor(fileName: string, isJson: boolean, options: CompilerOptions, host: OutputPathsHost, forceDtsEmit: boolean): OutputPaths;
+export declare function getOutputExtension(fileName: string, jsx: JsxEmit | undefined): string;
+/** The extension of declarations emitted for `path`. */
+export declare function getDeclarationEmitExtensionForPath(path: string): string;
+/** The declaration output of `inputFileName`, as a referenced project lays it out. */
+export declare function getOutputDeclarationFileName(inputFileName: string, options: CompilerOptions, host: OutputPathsHost): string;
+export declare function getOutputJSFileName(inputFileName: string, options: CompilerOptions, host: OutputPathsHost): string;
+/** The JavaScript output of `inputFileName`, whatever the file kind and emit options. */
+export declare function getOutputJSFileNameWorker(inputFileName: string, options: CompilerOptions, host: OutputPathsHost): string;
+/** The declaration output of `inputFileName`. */
+export declare function getOutputDeclarationFileNameWorker(inputFileName: string, options: CompilerOptions, host: OutputPathsHost): string;
+/** Like `getSourceFilePathInNewDir`, but with a case-folded prefix check. */
+export declare function getSourceFilePathInNewDirWorker(fileName: string, newDirectory: string, currentDirectory: string, commonSourceDirectory: string, useCaseSensitiveFileNames: boolean): string;
+export declare function getSourceMapFilePath(jsFilePath: string, options: CompilerOptions): string;
+/** The `.tsbuildinfo` file of an incremental build, or `''`. */
+export declare function getBuildInfoFileName(options: CompilerOptions, currentDirectory: string, useCaseSensitiveFileNames: boolean): string;
+/**
+ * The common source directory with a trailing `/`: `rootDir`, else the config file's directory, else the deepest
+ * directory containing `files()`. `checkRoot` reports files outside an explicit or config root.
+ */
+export declare function getCommonSourceDirectory(options: CompilerOptions, files: () => readonly string[], currentDirectory: string, useCaseSensitiveFileNames: boolean, checkRoot: ((files: readonly string[], root: string) => void) | undefined): string;
+/** Like `getCommonSourceDirectory` for emitted files only, ignoring `rootDir` and the config file. */
+export declare function getComputedCommonSourceDirectory(emittedFiles: readonly string[], currentDirectory: string, useCaseSensitiveFileNames: boolean): string;

package/dist/api/compiler/output-paths.js

@@ -0,0 +1,195 @@
+import { changeExtension, combinePaths, comparePaths, containsPath, ensureTrailingDirectorySeparator, fileExtensionIs, fileExtensionIsOneOf, getAnyExtensionFromPath, getBaseFileName, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getPathComponents, getPathComponentsRelativeTo, getPathFromPathComponents, reducePathComponents, removeFileExtension, resolvePath, } from './path.js';
+/** The files emitted for one source file; `''` for those not emitted. */
+export class OutputPaths {
+    jsFilePath;
+    sourceMapFilePath;
+    declarationFilePath;
+    declarationMapPath;
+    constructor(jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath) {
+        this.jsFilePath = jsFilePath;
+        this.sourceMapFilePath = sourceMapFilePath;
+        this.declarationFilePath = declarationFilePath;
+        this.declarationMapPath = declarationMapPath;
+    }
+}
+export function getOutputPathsFor(fileName, isJson, options, host, forceDtsEmit) {
+    const ownOutputFilePath = getOwnEmitOutputFilePath(fileName, options, host, getOutputExtension(fileName, options.jsx));
+    // A JSON file emitted onto itself is skipped.
+    const isJsonEmittedToSameLocation = isJson && comparePaths(fileName, ownOutputFilePath, host.useCaseSensitiveFileNames, host.currentDirectory) === 0;
+    let jsFilePath = '';
+    let sourceMapFilePath = '';
+    if (options.emitDeclarationOnly !== true && !isJsonEmittedToSameLocation) {
+        jsFilePath = ownOutputFilePath;
+        if (!isJson)
+            sourceMapFilePath = getSourceMapFilePath(jsFilePath, options);
+    }
+    let declarationFilePath = '';
+    let declarationMapPath = '';
+    if (forceDtsEmit || (getEmitDeclarations(options) && !isJson)) {
+        declarationFilePath = getDeclarationEmitOutputFilePath(fileName, options, host);
+        if (options.declarationMap === true && getEmitDeclarations(options))
+            declarationMapPath = declarationFilePath + '.map';
+    }
+    return new OutputPaths(jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath);
+}
+function getEmitDeclarations(options) {
+    return options.declaration === true || options.composite === true;
+}
+export function getOutputExtension(fileName, jsx) {
+    if (fileExtensionIs(fileName, '.json'))
+        return '.json';
+    if (jsx === 1 /* JsxEmit.Preserve */ && fileExtensionIsOneOf(fileName, ['.jsx', '.tsx']))
+        return '.jsx';
+    if (fileExtensionIsOneOf(fileName, ['.mts', '.mjs']))
+        return '.mjs';
+    if (fileExtensionIsOneOf(fileName, ['.cts', '.cjs']))
+        return '.cjs';
+    return '.js';
+}
+/** The extension of declarations emitted for `path`. */
+export function getDeclarationEmitExtensionForPath(path) {
+    if (fileExtensionIsOneOf(path, ['.mjs', '.mts']))
+        return '.d.mts';
+    if (fileExtensionIsOneOf(path, ['.cjs', '.cts']))
+        return '.d.cts';
+    if (fileExtensionIsOneOf(path, ['.ts', '.tsx', '.js', '.jsx']))
+        return '.d.ts';
+    const extension = getAnyExtensionFromPath(path);
+    return extension !== '' ? '.d' + extension + '.ts' : '.d.ts';
+}
+/** The declaration output of `inputFileName`, as a referenced project lays it out. */
+export function getOutputDeclarationFileName(inputFileName, options, host) {
+    const directory = options.declarationDir ?? options.outDir ?? '';
+    return changeExtension(getOutputPathWithoutChangingExtension(inputFileName, directory, host), getDeclarationEmitExtensionForPath(inputFileName));
+}
+export function getOutputJSFileName(inputFileName, options, host) {
+    if (options.emitDeclarationOnly === true)
+        return '';
+    const outputFileName = changeExtension(getOutputPathWithoutChangingExtension(inputFileName, options.outDir ?? '', host), getOutputExtension(inputFileName, options.jsx));
+    if (!fileExtensionIs(outputFileName, '.json') ||
+        comparePaths(inputFileName, outputFileName, host.useCaseSensitiveFileNames, host.currentDirectory) !== 0) {
+        return outputFileName;
+    }
+    return '';
+}
+/** The JavaScript output of `inputFileName`, whatever the file kind and emit options. */
+export function getOutputJSFileNameWorker(inputFileName, options, host) {
+    return changeExtension(getOutputPathWithoutChangingExtension(inputFileName, options.outDir ?? '', host), getOutputExtension(inputFileName, options.jsx));
+}
+/** The declaration output of `inputFileName`. */
+export function getOutputDeclarationFileNameWorker(inputFileName, options, host) {
+    const directory = options.declarationDir !== undefined && options.declarationDir !== ''
+        ? options.declarationDir
+        : (options.outDir ?? '');
+    return changeExtension(getOutputPathWithoutChangingExtension(inputFileName, directory, host), getDeclarationEmitExtensionForPath(inputFileName));
+}
+function getOutputPathWithoutChangingExtension(inputFileName, outputDirectory, host) {
+    if (outputDirectory === '')
+        return inputFileName;
+    const relative = getPathFromPathComponents(getPathComponentsRelativeTo(host.commonSourceDirectory(), inputFileName, host.useCaseSensitiveFileNames, host.currentDirectory));
+    return resolvePath(outputDirectory, relative);
+}
+function getDeclarationEmitOutputFilePath(file, options, host) {
+    const outputDirectory = options.declarationDir ?? options.outDir;
+    const path = outputDirectory === undefined
+        ? file
+        : getSourceFilePathInNewDirWorker(file, outputDirectory, host.currentDirectory, host.commonSourceDirectory(), host.useCaseSensitiveFileNames);
+    return removeFileExtension(path) + getDeclarationEmitExtensionForPath(path);
+}
+function getSourceFilePathInNewDir(fileName, newDirectory, currentDirectory, commonSourceDirectory, useCaseSensitiveFileNames) {
+    let sourceFilePath = getNormalizedAbsolutePath(fileName, currentDirectory);
+    const common = ensureTrailingDirectorySeparator(commonSourceDirectory);
+    if (containsPath(common, sourceFilePath, useCaseSensitiveFileNames, currentDirectory)) {
+        sourceFilePath = sourceFilePath.slice(common.length);
+    }
+    return combinePaths(newDirectory, sourceFilePath);
+}
+/** Like `getSourceFilePathInNewDir`, but with a case-folded prefix check. */
+export function getSourceFilePathInNewDirWorker(fileName, newDirectory, currentDirectory, commonSourceDirectory, useCaseSensitiveFileNames) {
+    let sourceFilePath = getNormalizedAbsolutePath(fileName, currentDirectory);
+    const common = getCanonicalFileName(commonSourceDirectory, useCaseSensitiveFileNames);
+    if (getCanonicalFileName(sourceFilePath, useCaseSensitiveFileNames).startsWith(common)) {
+        sourceFilePath = sourceFilePath.slice(commonSourceDirectory.length);
+    }
+    return combinePaths(newDirectory, sourceFilePath);
+}
+function getOwnEmitOutputFilePath(fileName, options, host, extension) {
+    const withoutExtension = options.outDir === undefined
+        ? removeFileExtension(fileName)
+        : removeFileExtension(getSourceFilePathInNewDir(fileName, options.outDir, host.currentDirectory, host.commonSourceDirectory(), host.useCaseSensitiveFileNames));
+    return withoutExtension + extension;
+}
+export function getSourceMapFilePath(jsFilePath, options) {
+    return options.sourceMap === true && options.inlineSourceMap !== true ? jsFilePath + '.map' : '';
+}
+/** The `.tsbuildinfo` file of an incremental build, or `''`. */
+export function getBuildInfoFileName(options, currentDirectory, useCaseSensitiveFileNames) {
+    if (options.incremental !== true && options.composite !== true && options.build !== true)
+        return '';
+    if (options.tsBuildInfoFile !== undefined)
+        return options.tsBuildInfoFile;
+    if (options.configFilePath === undefined)
+        return '';
+    const configWithoutExtension = removeFileExtension(options.configFilePath);
+    let buildInfoWithoutExtension = configWithoutExtension;
+    if (options.outDir !== undefined) {
+        buildInfoWithoutExtension =
+            options.rootDir !== undefined
+                ? resolvePath(options.outDir, getPathFromPathComponents(getPathComponentsRelativeTo(options.rootDir, configWithoutExtension, useCaseSensitiveFileNames, currentDirectory)))
+                : combinePaths(options.outDir, getBaseFileName(configWithoutExtension));
+    }
+    return buildInfoWithoutExtension + '.tsbuildinfo';
+}
+/**
+ * The common source directory with a trailing `/`: `rootDir`, else the config file's directory, else the deepest
+ * directory containing `files()`. `checkRoot` reports files outside an explicit or config root.
+ */
+export function getCommonSourceDirectory(options, files, currentDirectory, useCaseSensitiveFileNames, checkRoot) {
+    let directory;
+    if (options.rootDir !== undefined) {
+        directory = options.rootDir;
+        if (checkRoot !== undefined)
+            checkRoot(files(), directory);
+    }
+    else if (options.configFilePath !== undefined) {
+        directory = getDirectoryPath(options.configFilePath);
+        if (checkRoot !== undefined)
+            checkRoot(files(), directory);
+    }
+    else {
+        directory = computeCommonSourceDirectoryOfFilenames(files(), currentDirectory, useCaseSensitiveFileNames);
+    }
+    return directory === '' ? '' : ensureTrailingDirectorySeparator(directory);
+}
+/** Like `getCommonSourceDirectory` for emitted files only, ignoring `rootDir` and the config file. */
+export function getComputedCommonSourceDirectory(emittedFiles, currentDirectory, useCaseSensitiveFileNames) {
+    const directory = computeCommonSourceDirectoryOfFilenames(emittedFiles, currentDirectory, useCaseSensitiveFileNames);
+    return directory === '' ? '' : ensureTrailingDirectorySeparator(directory);
+}
+/** The deepest directory containing every file; `''` if they share no root, `currentDirectory` if there are none. */
+function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, useCaseSensitiveFileNames) {
+    let common;
+    for (const fileName of fileNames) {
+        const components = reducePathComponents(getPathComponents(fileName, currentDirectory));
+        components.pop();
+        if (common === undefined) {
+            common = components;
+            continue;
+        }
+        const shared = Math.min(common.length, components.length);
+        for (let i = 0; i < shared; i++) {
+            if (getCanonicalFileName(common[i], useCaseSensitiveFileNames) !==
+                getCanonicalFileName(components[i], useCaseSensitiveFileNames)) {
+                if (i === 0)
+                    return '';
+                common.length = i;
+                break;
+            }
+        }
+        if (components.length < common.length)
+            common.length = components.length;
+    }
+    if (common === undefined || common.length === 0)
+        return currentDirectory;
+    return getPathFromPathComponents(common);
+}

package/dist/api/compiler/package-json.d.ts

@@ -0,0 +1,175 @@
+/**
+ * `package.json` as module resolution reads it.
+ *
+ * Fields keep the JSON type they were written with, so resolution can trace
+ * "Expected type of 'main' field in 'package.json' to be 'string', got 'number'".
+ */
+import { type MessageWithArgs } from './diagnostics.js';
+export declare const typeScriptVersion = "7.0.2";
+export declare const typeScriptVersionMajorMinor = "7.0";
+export type JsonType = 'null' | 'boolean' | 'number' | 'string' | 'array' | 'object';
+/** How an object in `exports` or `imports` is interpreted, from the first character of its keys. */
+export declare const enum JsonObjectKind {
+    /** No key starts with `.` or `#` (also used for empty objects). */
+    Conditions = 0,
+    /** Keys start with `.`. */
+    Subpaths = 1,
+    /** Keys start with `#`. */
+    Imports = 2,
+    /** Keys mix `.`/`#` with other keys. */
+    Invalid = 3
+}
+export interface JsonNull {
+    readonly type: 'null';
+}
+export interface JsonBoolean {
+    readonly type: 'boolean';
+    readonly value: boolean;
+}
+export interface JsonNumber {
+    readonly type: 'number';
+    readonly value: number;
+}
+export interface JsonString {
+    readonly type: 'string';
+    readonly value: string;
+}
+export interface JsonArray {
+    readonly type: 'array';
+    readonly items: readonly JsonValue[];
+}
+export interface JsonObject {
+    readonly type: 'object';
+    /** Entries in source order; a repeated key keeps its first position and its last value. */
+    readonly entries: ReadonlyMap<string, JsonValue>;
+    readonly kind: JsonObjectKind;
+}
+export type JsonValue = JsonNull | JsonBoolean | JsonNumber | JsonString | JsonArray | JsonObject;
+/**
+ * JavaScript-style falsiness as tsgo checks it for `exports`.
+ * Numbers are never falsy there, matching tsgo.
+ */
+export declare function isFalsyJson(value: JsonValue | undefined): boolean;
+/** Strict RFC 8259 parser. Any error makes the whole document unparseable. */
+export declare class JsonParser {
+    readonly text: string;
+    pos: number;
+    constructor(text: string);
+    skipWhitespace(): void;
+    /** Consumes `literal` if it is next. */
+    eat(literal: string): boolean;
+    peek(): number;
+    /** Parses the value at `pos` (after whitespace); `undefined` on error. */
+    value(): JsonValue | undefined;
+    literal(text: string, value: JsonValue): JsonValue | undefined;
+    object(): JsonObject | undefined;
+    array(): JsonArray | undefined;
+    /** Reads `"key":`, leaving `pos` after the colon. */
+    key(): string | undefined;
+    /** After a member: consumes `,` (requiring another member) or stops before `close`. */
+    endOfMember(close: number): boolean;
+    /** Validates a value without building it. */
+    skip(): boolean;
+    string(): string | undefined;
+    number(): number | undefined;
+}
+/** Parses a JSON document; `undefined` if it is not valid JSON. */
+export declare function parseJson(text: string): JsonValue | undefined;
+/** A field read with an expected JSON type. */
+export interface Expected<T> {
+    /** JSON type as written, or `undefined` when absent. */
+    readonly actualType: JsonType | undefined;
+    /** The value, if it ever had the expected type. */
+    readonly value: T | undefined;
+    readonly isNull: boolean;
+}
+/** `typesVersions` paths for the entry matching the compiler version. */
+export interface VersionPaths {
+    /** The matching `typesVersions` key. */
+    readonly version: string;
+    /** Values are never `undefined`; the type matches compiler options' `paths`. */
+    readonly paths: ReadonlyMap<string, readonly string[] | undefined>;
+}
+export declare class PackageJson {
+    name: Expected<string>;
+    version: Expected<string>;
+    type: Expected<string>;
+    tsconfig: Expected<string>;
+    main: Expected<string>;
+    types: Expected<string>;
+    typings: Expected<string>;
+    dependencies: Expected<ReadonlyMap<string, string>>;
+    peerDependencies: Expected<ReadonlyMap<string, string>>;
+    optionalDependencies: Expected<ReadonlyMap<string, string>>;
+    typesVersions: JsonValue | undefined;
+    imports: JsonValue | undefined;
+    exports: JsonValue | undefined;
+    /** False when the text was not valid JSON; all fields are then absent. */
+    parseable: boolean;
+    private versionPathsRead;
+    private versionPaths;
+    private readonly versionTraces;
+    /** Names in `dependencies`, `peerDependencies` and `optionalDependencies`. */
+    getRuntimeDependencyNames(): Set<string>;
+    /** The `typesVersions` paths for this compiler version, appending what was checked to `traces`. */
+    getVersionPaths(traces: MessageWithArgs[] | undefined): VersionPaths | undefined;
+    private readVersionPaths;
+}
+/** Parses `package.json` text. Invalid JSON yields a `PackageJson` with every field absent. */
+export declare function parsePackageJson(text: string): PackageJson;
+/** A `package.json` lookup: the directory searched and, if the file exists, its contents. */
+export interface PackageJsonInfo {
+    readonly packageDirectory: string;
+    readonly directoryExists: boolean;
+    readonly contents: PackageJson | undefined;
+}
+/**
+ * A `package.json` lookup as build info records it: the directory searched, whether the file exists,
+ * and whether the directory does.
+ */
+export declare class PackageJsonLookup {
+    readonly packageDirectory: string;
+    readonly exists: boolean;
+    readonly directoryExists: boolean;
+    constructor(packageDirectory: string, exists: boolean, directoryExists: boolean);
+}
+/** `info` with `packageDirectory` spelled as the caller looked it up. */
+export declare function withPackageDirectory(info: PackageJsonInfo, packageDirectory: string): PackageJsonInfo;
+export declare class PackageJsonInfoCache {
+    readonly currentDirectory: string;
+    readonly useCaseSensitiveFileNames: boolean;
+    private readonly cache;
+    private shared;
+    constructor(currentDirectory: string, useCaseSensitiveFileNames: boolean);
+    /**
+     * Called before the cache is shared with other threads, which makes it immutable: from then on,
+     * each thread keeps the lookups it adds in a table of its own.
+     */
+    prepareForSharing(): void;
+    get(packageJsonPath: string): PackageJsonInfo | undefined;
+    set(packageJsonPath: string, info: PackageJsonInfo): PackageJsonInfo;
+    private lookup;
+    /** The lookups made, in order (on this thread, once shared). */
+    infos(): PackageJsonInfo[];
+}
+interface Version {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly prerelease: readonly string[];
+}
+type Operator = '<' | '<=' | '=' | '>=' | '>';
+interface Comparator {
+    readonly operator: Operator;
+    readonly operand: Version;
+}
+/** Alternatives (`||`) of comparator sets that must all hold. */
+export type VersionRange = readonly (readonly Comparator[])[];
+/** Parses an npm-style range such as `>=4.1`, `^3.0.0 || 5.x` or `1 - 2`; `undefined` if invalid. */
+export declare function parseVersionRange(text: string): VersionRange | undefined;
+export declare function versionRangeMatches(range: VersionRange, version: Version): boolean;
+/** Whether a `typesVersions` key or `types@<range>` condition range includes this compiler's version. */
+export declare function versionRangeIncludesTypeScript(text: string): boolean;
+/** Whether `key` is `types@<range>` with a range including this compiler's version. */
+export declare function isApplicableVersionedTypesKey(key: string): boolean;
+export {};