Configuration Management

/**
 * Reads TypeScript configuration from tsconfig.json with caching and defaults
 * @param tsConfigPath - Path to tsconfig.json file (optional, uses environment variables or cwd)
 * @returns Parsed TypeScript compiler options with fallback function
 */
function readDefaultTsConfig(
  tsConfigPath?: string
): Partial<ts.CompilerOptions & { fallbackToTs: (path: string) => boolean }>;

import { readDefaultTsConfig } from "@swc-node/register/read-default-tsconfig";

// Read from default location (./tsconfig.json)
const config = readDefaultTsConfig();
console.log(config.target); // ts.ScriptTarget.ES2018 (default)

// Read from specific path
const devConfig = readDefaultTsConfig("./tsconfig.dev.json");

// Read using environment variable
process.env.SWC_NODE_PROJECT = "./tsconfig.test.json";
const testConfig = readDefaultTsConfig();

// The configuration includes file lists from tsconfig.json
console.log(config.files); // Array of file paths from include/exclude

/**
 * Converts TypeScript compiler options to SWC configuration
 * @param options - TypeScript compiler options
 * @param filename - Target filename (used for JSX detection)
 * @returns SWC configuration object
 */
function tsCompilerOptionsToSwcConfig(
  options: ts.CompilerOptions,
  filename: string
): Options;

import { tsCompilerOptionsToSwcConfig } from "@swc-node/register/read-default-tsconfig";
import * as ts from "typescript";

const tsOptions = {
  target: ts.ScriptTarget.ES2020,
  module: ts.ModuleKind.CommonJS,
  jsx: ts.JsxEmit.ReactJSX,
  experimentalDecorators: true,
  emitDecoratorMetadata: true,
  baseUrl: "./src",
  paths: {
    "@/*": ["./src/*"],
    "@utils/*": ["./src/utils/*"]
  }
};

const swcConfig = tsCompilerOptionsToSwcConfig(tsOptions, "component.tsx");
console.log(swcConfig);
// {
//   target: "es2020",
//   module: "commonjs",
//   jsx: true,
//   experimentalDecorators: true,
//   emitDecoratorMetadata: true,
//   baseUrl: "/absolute/path/to/src",
//   paths: { "@/*": ["/absolute/path/to/src/*"] },
//   react: { runtime: "automatic", importSource: "react" }
// }

// Resolution priority:
const tsConfigPath = 
  process.env.SWC_NODE_PROJECT ?? 
  process.env.TS_NODE_PROJECT ?? 
  path.join(process.cwd(), 'tsconfig.json');

const defaultCompilerOptions = {
  target: ts.ScriptTarget.ES2018,
  module: ts.ModuleKind.CommonJS,
  moduleResolution: ts.ModuleResolutionKind.NodeJs,
  sourceMap: true,
  esModuleInterop: true
};

// Supported compiler options
interface SupportedCompilerOptions {
  target: ts.ScriptTarget; // ES3, ES5, ES2015-ES2022, ESNext, Latest
  module: ts.ModuleKind; // CommonJS, UMD, AMD, ES2015, ES2020, ES2022, ESNext, Node16, NodeNext
  jsx: ts.JsxEmit; // None, Preserve, React, ReactJSX, ReactJSXDev, ReactNative
  experimentalDecorators: boolean;
  emitDecoratorMetadata: boolean;
  esModuleInterop: boolean;
  sourceMap: boolean;
  inlineSourceMap: boolean;
  baseUrl: string;
  paths: Record<string, string[]>;
  sourceRoot: string;
  useDefineForClassFields: boolean;
  importHelpers: boolean;
  jsxFactory: string;
  jsxFragmentFactory: string;
  jsxImportSource: string;
}

// JSX is enabled when:
// 1. Filename ends with .jsx or .tsx
// 2. tsconfig.json has jsx option set
const isJsx = filename.endsWith('.tsx') || filename.endsWith('.jsx') || Boolean(options.jsx);

// tsconfig.json paths are converted to absolute paths
const paths = Object.fromEntries(
  Object.entries(options.paths ?? {}).map(([aliasKey, aliasPaths]) => [
    aliasKey,
    aliasPaths.map(path => resolve(options.baseUrl ?? './', path))
  ])
);

// Internal cache prevents repeated file reads
const configCache: Record<string, Partial<ts.CompilerOptions & { 
  fallbackToTs: (path: string) => boolean 
}>>;

// File not found - uses defaults with warning
if (!existsSync(tsConfigPath)) {
  return defaultCompilerOptions;
}

// JSON parsing errors - uses defaults with warning
try {
  const { config } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
  // ... parse config
} catch (error) {
  console.info(yellow(`Read ${tsConfigPath} failed: ${error.message}`));
  return defaultCompilerOptions;
}

// TypeScript compilation errors - uses defaults with detailed error messages  
if (errors.length > 0) {
  console.info(yellow(`Convert compiler options from json failed, ${errors.map(d => d.messageText).join('\n')}`));
  return defaultCompilerOptions;
}