tsc-ts 0.0.9 → 0.1.0

package/src/compiler/options.ts

@@ -19,10 +19,11 @@ export enum ScriptTarget {
   ES2023 = 10,
   ES2024 = 11,
   ES2025 = 12,
+  ES2026 = 13,
   ESNext = 99,
   JSON = 100,
   Latest = ESNext,
-  LatestStandard = ES2025,
+  LatestStandard = ES2026,
 }
 
 export enum ModuleKind {
@@ -48,6 +49,16 @@ export enum ModuleKind {
   Preserve = 200,
 }
 
+/** Whether `import defer` and `import.defer()` are allowed under a module kind. */
+export function supportsDeferredImports(moduleKind: ModuleKind): boolean {
+  return moduleKind === ModuleKind.ESNext || moduleKind === ModuleKind.Preserve;
+}
+
+/** Whether `import source` and `import.source()` are allowed under a module kind. */
+export function supportsSourcePhaseImports(moduleKind: ModuleKind): boolean {
+  return moduleKind === ModuleKind.ESNext || moduleKind === ModuleKind.NodeNext || moduleKind === ModuleKind.Preserve;
+}
+
 export enum ModuleResolutionKind {
   /** @deprecated Accepted for parsing and validation only. */
   Classic = 1,
@@ -66,8 +77,8 @@ export enum ModuleDetectionKind {
 
 export enum JsxEmit {
   Preserve = 1,
-  ReactNative = 2,
-  React = 3,
+  React = 2,
+  ReactNative = 3,
   ReactJSX = 4,
   ReactJSXDev = 5,
 }
@@ -77,29 +88,6 @@ export enum NewLineKind {
   LF = 2,
 }
 
-export enum WatchFileKind {
-  FixedPollingInterval = 1,
-  PriorityPollingInterval = 2,
-  DynamicPriorityPolling = 3,
-  FixedChunkSizePolling = 4,
-  UseFsEvents = 5,
-  UseFsEventsOnParentDirectory = 6,
-}
-
-export enum WatchDirectoryKind {
-  UseFsEvents = 1,
-  FixedPollingInterval = 2,
-  DynamicPriorityPolling = 3,
-  FixedChunkSizePolling = 4,
-}
-
-export enum PollingKind {
-  FixedInterval = 1,
-  PriorityInterval = 2,
-  DynamicPriority = 3,
-  FixedChunkSize = 4,
-}
-
 /**
  * Compiler options, in tsgo's field order (which `--showConfig` follows).
  *
@@ -174,6 +162,8 @@ export interface CompilerOptions {
   outDir?: string;
   /** Substitutions are `undefined` where the config gave a non-array. */
   paths?: Map<string, string[] | undefined>;
+  /** Read only for `--showConfig`; plugins are not loaded. */
+  plugins?: PluginImport[];
   preserveConstEnums?: boolean;
   preserveSymlinks?: boolean;
   project?: string;
@@ -239,16 +229,6 @@ export interface CompilerOptions {
   checkers?: number;
 }
 
-export interface WatchOptions {
-  watchInterval?: number;
-  watchFile?: WatchFileKind;
-  watchDirectory?: WatchDirectoryKind;
-  fallbackPolling?: PollingKind;
-  synchronousWatchDirectory?: boolean;
-  excludeDirectories?: string[];
-  excludeFiles?: string[];
-}
-
 export interface BuildOptions {
   dry?: boolean;
   force?: boolean;
@@ -275,6 +255,11 @@ export type OptionValue = boolean | number | string | string[] | null;
 /** A compiler option value as stored in `CompilerOptions`, except `paths`. */
 export type CompilerOptionValue = boolean | number | string | string[];
 
+/** An entry of `plugins`: its `name`, or `''` when it has no string name. */
+export class PluginImport {
+  constructor(readonly name: string) {}
+}
+
 /** Compiler option names in field order. */
 export const compilerOptionNames: readonly string[] = [
   'allowJs',
@@ -344,6 +329,7 @@ export const compilerOptionNames: readonly string[] = [
   'noUncheckedSideEffectImports',
   'outDir',
   'paths',
+  'plugins',
   'preserveConstEnums',
   'preserveSymlinks',
   'project',
@@ -991,6 +977,7 @@ export function mergeCompilerOptions(
   );
   target.outDir = merged(source.outDir, target.outDir, nulls, 'outDir');
   target.paths = merged(source.paths, target.paths, nulls, 'paths');
+  target.plugins = merged(source.plugins, target.plugins, nulls, 'plugins');
   target.preserveConstEnums = merged(source.preserveConstEnums, target.preserveConstEnums, nulls, 'preserveConstEnums');
   target.preserveSymlinks = merged(source.preserveSymlinks, target.preserveSymlinks, nulls, 'preserveSymlinks');
   target.project = merged(source.project, target.project, nulls, 'project');
@@ -1411,32 +1398,6 @@ export function getCompilerOption(options: CompilerOptions, name: string): Compi
   return undefined;
 }
 
-export function setWatchOption(options: WatchOptions, name: string, value: OptionValue): void {
-  switch (name) {
-    case 'watchInterval':
-      options.watchInterval = numberValue(value);
-      break;
-    case 'watchFile':
-      if (value !== null) options.watchFile = numberValue(value);
-      break;
-    case 'watchDirectory':
-      if (value !== null) options.watchDirectory = numberValue(value);
-      break;
-    case 'fallbackPolling':
-      if (value !== null) options.fallbackPolling = numberValue(value);
-      break;
-    case 'synchronousWatchDirectory':
-      options.synchronousWatchDirectory = value === null ? undefined : value === true;
-      break;
-    case 'excludeDirectories':
-      options.excludeDirectories = stringList(value);
-      break;
-    case 'excludeFiles':
-      options.excludeFiles = stringList(value);
-      break;
-  }
-}
-
 export function setBuildOption(options: BuildOptions, name: string, value: OptionValue): void {
   if (value === null) return;
   switch (name) {

package/src/compiler/output-paths.ts

@@ -6,7 +6,6 @@ import {
   changeExtension,
   combinePaths,
   comparePaths,
-  containsPath,
   ensureTrailingDirectorySeparator,
   fileExtensionIs,
   fileExtensionIsOneOf,
@@ -182,22 +181,10 @@ function getDeclarationEmitOutputFilePath(file: string, options: CompilerOptions
   return removeFileExtension(path) + getDeclarationEmitExtensionForPath(path);
 }
 
-function getSourceFilePathInNewDir(
-  fileName: string,
-  newDirectory: string,
-  currentDirectory: string,
-  commonSourceDirectory: string,
-  useCaseSensitiveFileNames: boolean,
-): string {
-  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. */
+/**
+ * `fileName` moved from `commonSourceDirectory` to `newDirectory`. The prefix check is case-folded when file names
+ * are case-insensitive; case folding keeps each code point's length, so the prefix is removed by its own length.
+ */
 export function getSourceFilePathInNewDirWorker(
   fileName: string,
   newDirectory: string,
@@ -223,7 +210,7 @@ function getOwnEmitOutputFilePath(
     options.outDir === undefined
       ? removeFileExtension(fileName)
       : removeFileExtension(
-          getSourceFilePathInNewDir(
+          getSourceFilePathInNewDirWorker(
             fileName,
             options.outDir,
             host.currentDirectory,

package/src/compiler/package-entrypoints.ts

@@ -0,0 +1,345 @@
+// The files a package offers for import and the module specifiers that reach them, as tsgo's
+// GetEntrypointsFromPackageJsonInfo finds them for auto-imports, and the ending a specifier takes in an importing file.
+import type { FileSystem } from './file-system.js';
+import type { Resolver } from './module-resolution.js';
+import {
+  getJSExtensionForDeclarationFileExtension,
+  ModuleSpecifierEnding,
+  tryGetJSExtensionForFile,
+} from './module-specifiers.js';
+import type { CompilerOptions } from './options.js';
+import { isApplicableVersionedTypesKey, type JsonValue, JsonObjectKind, type PackageJsonInfo } from './package-json.js';
+import {
+  changeExtension,
+  comparePaths,
+  fileExtensionIsOneOf,
+  getDeclarationFileExtension,
+  getPathComponents,
+  getRelativePathFromDirectory,
+  normalizePath,
+  removeExtension,
+  removeFileExtension,
+  resolvePath,
+} from './path.js';
+import { readDirectory, unlimitedDepth } from './vfs-match.js';
+
+/** Whether the file name and extension of an entrypoint's module specifier can change. */
+export const enum EntrypointEnding {
+  /** The specifier cannot change without changing what it resolves to. */
+  Fixed,
+  /** The extension came from a file on disk, so an interchangeable one can be used (`.d.ts` as `.js`). */
+  ExtensionChangeable,
+  /**
+   * The file name and extension came from a file on disk outside an `exports` pattern, so they follow the
+   * importing file's resolution rules (an `/index.d.ts` may be dropped).
+   */
+  Changeable,
+}
+
+/** A file a package offers for import, with the module specifier that reaches it. */
+export class ResolvedEntrypoint {
+  constructor(
+    /** The path the entrypoint was found at when that is a symlink, else `''`. */
+    readonly originalFileName: string,
+    /** The real path of the file. */
+    readonly resolvedFileName: string,
+    readonly moduleSpecifier: string,
+    readonly ending: EntrypointEnding,
+    /** The conditions a resolver needs to reach this entrypoint. */
+    readonly includeConditions: ReadonlySet<string> | undefined,
+    /** The conditions a resolver must not have to reach this entrypoint. */
+    readonly excludeConditions: ReadonlySet<string> | undefined,
+  ) {}
+
+  symlinkOrRealpath(): string {
+    return this.originalFileName !== '' ? this.originalFileName : this.resolvedFileName;
+  }
+}
+
+// TypeScript and declaration files.
+const entrypointExtensions = ['.ts', '.tsx', '.mts', '.cts', '.d.ts', '.d.mts', '.d.cts'];
+
+/**
+ * The entrypoints of a package: what its `exports` lead to, or else its main file and, with `enableDirectorySearch`,
+ * every TypeScript and declaration file in it outside `node_modules`. Undefined for none.
+ */
+export function getEntrypointsFromPackageJsonInfo(
+  resolver: Resolver,
+  fs: FileSystem,
+  info: PackageJsonInfo,
+  packageName: string,
+  enableDirectorySearch: boolean,
+): ResolvedEntrypoint[] | undefined {
+  const exports = info.contents?.exports;
+  if (exports !== undefined) return new ExportMapWalker(resolver, fs, info, packageName).walk(exports);
+
+  const result: ResolvedEntrypoint[] = [];
+  const main = resolver.loadPackageMainEntrypoint(info);
+  if (main !== '') {
+    result.push(createEntrypoint(fs, main, packageName, undefined, undefined, EntrypointEnding.Fixed));
+  }
+  if (enableDirectorySearch) {
+    const directory = info.packageDirectory;
+    const files = readDirectory(
+      fs,
+      directory,
+      directory,
+      entrypointExtensions,
+      ['node_modules'],
+      ['**/*'],
+      unlimitedDepth,
+    );
+    for (const file of files) {
+      if (main !== '' && comparePaths(file, main, fs.useCaseSensitiveFileNames) === 0) continue;
+      const relative = getRelativePathFromDirectory(directory, file, fs.useCaseSensitiveFileNames);
+      result.push(
+        createEntrypoint(fs, file, packageName + '/' + relative, undefined, undefined, EntrypointEnding.Changeable),
+      );
+    }
+  }
+  return result.length > 0 ? result : undefined;
+}
+
+function createEntrypoint(
+  fs: FileSystem,
+  fileName: string,
+  moduleSpecifier: string,
+  includeConditions: ReadonlySet<string> | undefined,
+  excludeConditions: ReadonlySet<string> | undefined,
+  ending: EntrypointEnding,
+): ResolvedEntrypoint {
+  const realpath = normalizePath(fs.realpath(fileName));
+  return realpath !== fileName
+    ? new ResolvedEntrypoint(fileName, realpath, moduleSpecifier, ending, includeConditions, excludeConditions)
+    : new ResolvedEntrypoint('', fileName, moduleSpecifier, ending, includeConditions, excludeConditions);
+}
+
+// Walks an `exports` value, collecting the entrypoint of each target and the conditions that reach it.
+class ExportMapWalker {
+  readonly entrypoints: ResolvedEntrypoint[] = [];
+
+  constructor(
+    private readonly resolver: Resolver,
+    private readonly fs: FileSystem,
+    private readonly info: PackageJsonInfo,
+    private readonly packageName: string,
+  ) {}
+
+  walk(exports: JsonValue): ResolvedEntrypoint[] {
+    if (exports.type === 'array') {
+      for (const element of exports.items) this.target('.', undefined, undefined, element);
+    } else if (exports.type === 'object' && exports.kind === JsonObjectKind.Subpaths) {
+      for (const [subpath, target] of exports.entries) this.target(subpath, undefined, undefined, target);
+    } else {
+      this.target('.', undefined, undefined, exports);
+    }
+    return this.entrypoints;
+  }
+
+  private target(
+    subpath: string,
+    includeConditions: Set<string> | undefined,
+    excludeConditionsIn: Set<string> | undefined,
+    exports: JsonValue,
+  ): void {
+    let excludeConditions = excludeConditionsIn;
+    if (exports.type === 'string' && exports.value.startsWith('./')) {
+      const target = exports.value;
+      // A target with `.` or `..` after its leading `./` offers nothing, as in tsc; for a pattern this also keeps the
+      // directory search inside the package. A literal target into `node_modules` offers nothing either.
+      const partsAfterFirst = getPathComponents(target).slice(2);
+      if (partsAfterFirst.includes('..') || partsAfterFirst.includes('.')) return;
+      if (target.includes('*')) this.patternTarget(subpath, includeConditions, excludeConditions, target);
+      else {
+        if (partsAfterFirst.includes('node_modules')) return;
+        const candidate = resolvePath(this.info.packageDirectory, target);
+        const resolved = this.resolver.loadPackageExportTargetEntrypoint(this.info.packageDirectory, candidate, target);
+        if (resolved !== '') {
+          this.entrypoints.push(
+            createEntrypoint(
+              this.fs,
+              resolved,
+              resolvePath(this.packageName, subpath),
+              includeConditions,
+              excludeConditions,
+              target.endsWith('*') ? EntrypointEnding.ExtensionChangeable : EntrypointEnding.Fixed,
+            ),
+          );
+        }
+      }
+    } else if (exports.type === 'array') {
+      for (const element of exports.items) this.target(subpath, includeConditions, excludeConditions, element);
+    } else if (exports.type === 'object') {
+      const previousConditions: string[] = [];
+      for (const [condition, conditionTarget] of exports.entries) {
+        if (excludeConditions?.has(condition) === true) continue;
+        const alwaysMatches =
+          condition === 'default' || condition === 'types' || isApplicableVersionedTypesKey(condition);
+        let newIncludeConditions = includeConditions;
+        if (!alwaysMatches) {
+          // A later condition is reached only without the earlier ones; the exclusions carry over to the
+          // conditions after it, as tsgo keeps them.
+          newIncludeConditions = includeConditions === undefined ? new Set<string>() : new Set(includeConditions);
+          if (excludeConditions !== undefined) excludeConditions = new Set(excludeConditions);
+          newIncludeConditions.add(condition);
+          for (const previous of previousConditions) {
+            excludeConditions ??= new Set();
+            excludeConditions.add(previous);
+          }
+        }
+        previousConditions.push(condition);
+        this.target(subpath, newIncludeConditions, excludeConditions, conditionTarget);
+        if (alwaysMatches) break;
+      }
+    }
+  }
+
+  // A target with a `*`: each file the pattern matches.
+  private patternTarget(
+    subpath: string,
+    includeConditions: Set<string> | undefined,
+    excludeConditions: Set<string> | undefined,
+    target: string,
+  ): void {
+    const star = target.indexOf('*');
+    if (star !== target.lastIndexOf('*')) return;
+    const directory = this.info.packageDirectory;
+    const include = changeFullExtension(target.replace('*', '**/*'), '.*');
+    const patternPath = target.slice('./'.length);
+    const leading = patternPath.slice(0, patternPath.indexOf('*'));
+    const trailing = patternPath.slice(patternPath.indexOf('*') + 1);
+    const caseSensitive = this.fs.useCaseSensitiveFileNames;
+    const files = readDirectory(this.fs, directory, directory, entrypointExtensions, [], [include], unlimitedDepth);
+    for (const file of files) {
+      const relative = getRelativePathFromDirectory(directory, file, caseSensitive);
+      const matchedStar = getMatchedStarForPatternEntrypoint(relative, leading, trailing, caseSensitive);
+      if (matchedStar === undefined) continue;
+      let resolvedSubpath = subpath.replace('*', matchedStar);
+      if (resolvedSubpath.startsWith('./')) resolvedSubpath = resolvedSubpath.slice('./'.length);
+      if (resolvedSubpath === '') continue;
+      this.entrypoints.push(
+        createEntrypoint(
+          this.fs,
+          file,
+          this.packageName + '/' + resolvedSubpath,
+          includeConditions,
+          excludeConditions,
+          target.endsWith('*') ? EntrypointEnding.ExtensionChangeable : EntrypointEnding.Fixed,
+        ),
+      );
+    }
+  }
+}
+
+// The text a pattern's `*` matches in a package file, also with the file's JavaScript extension in place of its own.
+function getMatchedStarForPatternEntrypoint(
+  file: string,
+  leading: string,
+  trailing: string,
+  caseSensitive: boolean,
+): string | undefined {
+  if (hasPrefixAndSuffixWithoutOverlap(file, leading, trailing, caseSensitive)) {
+    return file.slice(leading.length, file.length - trailing.length);
+  }
+  const jsExtension = tryGetJSExtensionForFile(file, {});
+  if (jsExtension !== '') {
+    const swapped = changeFullExtension(file, jsExtension);
+    if (hasPrefixAndSuffixWithoutOverlap(swapped, leading, trailing, caseSensitive)) {
+      return swapped.slice(leading.length, swapped.length - trailing.length);
+    }
+  }
+  return undefined;
+}
+
+function hasPrefixAndSuffixWithoutOverlap(
+  text: string,
+  prefix: string,
+  suffix: string,
+  caseSensitive: boolean,
+): boolean {
+  if (prefix.length + suffix.length > text.length) return false;
+  if (caseSensitive) return text.startsWith(prefix) && text.endsWith(suffix);
+  const lower = text.toLowerCase();
+  return lower.startsWith(prefix.toLowerCase()) && lower.endsWith(suffix.toLowerCase());
+}
+
+/** Replaces the extension, taking a declaration extension from its `.d`. */
+function changeFullExtension(path: string, newExtension: string): string {
+  const declarationExtension = getDeclarationFileExtension(path);
+  if (declarationExtension === '') return changeExtension(path, newExtension);
+  return path.slice(0, path.length - declarationExtension.length) + newExtension;
+}
+
+/**
+ * The module specifier of an entrypoint as `importingFile` writes it: a fixed specifier as it is, others with the
+ * extension or file name the importing file's preferred ending gives them.
+ */
+export function processEntrypointEnding(
+  entrypoint: ResolvedEntrypoint,
+  options: CompilerOptions,
+  allowedEndings: readonly ModuleSpecifierEnding[],
+): string {
+  let specifier = entrypoint.moduleSpecifier;
+  if (entrypoint.ending === EntrypointEnding.Fixed) return specifier;
+  const preferredEnding = allowedEndings[0]!;
+
+  const dtsExtension = getDeclarationFileExtension(specifier);
+  if (dtsExtension !== '') {
+    const withJsExtension = (): string =>
+      removeExtension(specifier, dtsExtension) + getJSExtensionForDeclarationFileExtension(dtsExtension);
+    switch (preferredEnding) {
+      case ModuleSpecifierEnding.TsExtension:
+      case ModuleSpecifierEnding.JsExtension:
+        return withJsExtension();
+      case ModuleSpecifierEnding.Minimal:
+      case ModuleSpecifierEnding.Index:
+        if (entrypoint.ending === EntrypointEnding.Changeable && dtsExtension === '.d.ts') {
+          specifier = removeExtension(specifier, dtsExtension);
+          if (preferredEnding === ModuleSpecifierEnding.Minimal) specifier = trimSuffix(specifier, '/index');
+          return specifier;
+        }
+        // `.d.mts` and `.d.cts` keep an extension; an extension changeable entrypoint keeps one too.
+        return withJsExtension();
+    }
+    return specifier;
+  }
+
+  if (fileExtensionIsOneOf(specifier, ['.ts', '.tsx', '.mts', '.cts'])) {
+    switch (preferredEnding) {
+      case ModuleSpecifierEnding.TsExtension:
+        return specifier;
+      case ModuleSpecifierEnding.JsExtension: {
+        const jsExtension = tryGetJSExtensionForFile(specifier, options);
+        return jsExtension !== '' ? removeFileExtension(specifier) + jsExtension : specifier;
+      }
+      case ModuleSpecifierEnding.Minimal:
+      case ModuleSpecifierEnding.Index: {
+        if (entrypoint.ending === EntrypointEnding.Changeable) {
+          specifier = removeFileExtension(specifier);
+          if (preferredEnding === ModuleSpecifierEnding.Minimal) specifier = trimSuffix(specifier, '/index');
+          return specifier;
+        }
+        const jsExtension = tryGetJSExtensionForFile(specifier, options);
+        return jsExtension !== '' ? removeFileExtension(specifier) + jsExtension : specifier;
+      }
+    }
+    return specifier;
+  }
+
+  if (fileExtensionIsOneOf(specifier, ['.js', '.jsx', '.mjs', '.cjs'])) {
+    switch (preferredEnding) {
+      case ModuleSpecifierEnding.Minimal:
+      case ModuleSpecifierEnding.Index:
+        if (entrypoint.ending === EntrypointEnding.Changeable) {
+          specifier = removeFileExtension(specifier);
+          if (preferredEnding === ModuleSpecifierEnding.Minimal) specifier = trimSuffix(specifier, '/index');
+        }
+        return specifier;
+    }
+  }
+  return specifier;
+}
+
+function trimSuffix(text: string, suffix: string): string {
+  return text.endsWith(suffix) ? text.slice(0, text.length - suffix.length) : text;
+}

package/src/compiler/package-json.ts

@@ -8,8 +8,8 @@
 import { Diagnostics, messageWithArgs, type MessageWithArgs } from './diagnostics.js';
 import { toPath, type Path } from './path.js';
 
-export const typeScriptVersion = '7.0.2';
-export const typeScriptVersionMajorMinor = '7.0';
+export const typeScriptVersion = '7.1.0-beta';
+export const typeScriptVersionMajorMinor = '7.1';
 
 //// JSON values
 
@@ -679,10 +679,10 @@ export class PackageJsonInfoCache {
 
   /**
    * 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.
+   * each thread keeps the lookups it adds in a table of its own. A cache already shared is immutable.
    */
   prepareForSharing(): void {
-    this.shared = true;
+    if (!this.shared) this.shared = true;
   }
 
   get(packageJsonPath: string): PackageJsonInfo | undefined {