import { existsSync, readFileSync, statSync } from "node:fs";
import path from "node:path";
import { resolveTsconfig } from "rolldown/experimental";
import { parseSync, transformSync, TsconfigCache, type TransformOptions } from "rolldown/utils";
import { resolveCacheDirectory, TransformCache } from "./cache.ts";
import type { LoaderOptions } from "./hooks.ts";
import { attachSourceMap, storedSourceMap } from "./source-map.ts";
/** Extensions Oxc transpiles; everything else is JavaScript Node can run. */
export const transformExtensions = new Set([".ts", ".tsx", ".mts", ".cts", ".jsx"]);
export type ModuleFormat = "module" | "commonjs";
/**
* Module format from Node's `load` hook context. Node derives these from the
* extension and the nearest `package.json#type`; `*-typescript` variants are
* its TypeScript-aware spellings and mean the same thing.
*/
const nodeFormat = (format: string | null | undefined): ModuleFormat | undefined => {
switch (format) {
case "module":
case "module-typescript":
return "module";
case "commonjs":
case "commonjs-typescript":
return "commonjs";
default:
return undefined;
}
};
/**
* Format of a module Node gave no format for — resolved by our own
* resolver, so Node never looked at it: the extension, then the nearest
* `package.json#type`, memoized per directory.
*/
const packageTypes = new Map<string, ModuleFormat>();
const packageType = (directory: string): ModuleFormat => {
let format = packageTypes.get(directory);
if (format !== undefined) return format;
const packageJson = path.join(directory, "package.json");
const parent = path.dirname(directory);
if (existsSync(packageJson)) {
try {
format =
JSON.parse(readFileSync(packageJson, "utf8")).type === "module" ? "module" : "commonjs";
} catch {
format = "commonjs";
}
} else {
format = parent === directory ? "commonjs" : packageType(parent);
}
packageTypes.set(directory, format);
return format;
};
const inferFormat = (filePath: string): ModuleFormat => {
const extension = path.extname(filePath);
if (extension === ".mts" || extension === ".mjs") return "module";
if (extension === ".cts" || extension === ".cjs") return "commonjs";
return packageType(path.dirname(filePath));
};
const language = (filePath: string): TransformOptions["lang"] => {
switch (path.extname(filePath)) {
case ".tsx":
return "tsx";
case ".ts":
case ".mts":
case ".cts":
return "ts";
case ".jsx":
return "jsx";
default:
return "js";
}
};
export interface TransformedSource {
readonly format: ModuleFormat;
readonly source: string;
}
export class SourceTransformer {
readonly #options: LoaderOptions;
readonly #tsconfigCache = new TsconfigCache();
readonly #cache: TransformCache | undefined;
/**
* Serialized merged tsconfig per discovered config chain. Discovery runs
* per file (a solution-style tsconfig assigns files of one directory to
* different referenced projects), but thousands of files share a chain
* and the serialization is the expensive part of the key.
*/
readonly #tsconfigKeys = new Map<string, string>();
constructor(options: LoaderOptions) {
this.#options = options;
const directory = resolveCacheDirectory(options.cache);
this.#cache = directory === undefined ? undefined : new TransformCache(directory);
}
/**
* Cache key for one transform, or `undefined` when the result must not be
* cached. Every input Oxc's output depends on is part of it: the file's
* path (source maps name it), its size and mtime standing in for its
* contents — a stat instead of a read plus a hash per module on the warm
* path — the effective transform options, Node's module format, and the
* tsconfig that would be discovered for the file, resolved through the
* same cache `transformSync` uses with the `extends` chain already
* merged, so editing any tsconfig in the chain is a new key.
*/
#cacheKey(filePath: string, options: TransformOptions, format: ModuleFormat): string | undefined {
if (this.#cache === undefined) return undefined;
let stat: { size: bigint; mtimeNs: bigint };
try {
stat = statSync(filePath, { bigint: true });
} catch {
return undefined;
}
let tsconfig = "null";
try {
if (options.tsconfig === true) {
const resolved = resolveTsconfig(filePath, this.#tsconfigCache);
if (resolved != null) {
const chain = resolved.tsconfigFilePaths.join("\0");
let serialized = this.#tsconfigKeys.get(chain);
if (serialized === undefined) {
serialized = JSON.stringify(resolved.tsconfig);
this.#tsconfigKeys.set(chain, serialized);
}
tsconfig = serialized;
}
} else if (typeof options.tsconfig === "string") {
tsconfig = readFileSync(options.tsconfig, "utf8");
}
} catch {
// A broken tsconfig is the transform's error to report; don't cache.
return undefined;
}
return this.#cache.key([
filePath,
`${stat.size}:${stat.mtimeNs}`,
JSON.stringify(options),
tsconfig,
format,
]);
}
/**
* Transpiles `filePath` for Node, or returns `undefined` when the file is
* JavaScript that needs no work. `format` is what Node's `load` hook was
* told; it decides `sourceType` and the format handed back.
*/
transform(filePath: string, format: string | null | undefined): TransformedSource | undefined {
const extension = path.extname(filePath);
if (!transformExtensions.has(extension)) return undefined;
let moduleFormat = nodeFormat(format) ?? inferFormat(filePath);
const lang = language(filePath);
const options: TransformOptions = {
tsconfig: this.#options.tsconfig ?? true,
sourcemap: true,
lang,
};
// The key is taken before the source is read so a hit costs one stat
// and one cache read, never the source itself.
const key = this.#cacheKey(filePath, options, moduleFormat);
const cached = key === undefined ? undefined : this.#cache?.get(key);
if (cached !== undefined) {
const { mapFile } = cached;
return {
format: cached.format,
source:
mapFile === undefined
? cached.code
: attachSourceMap(
cached.code,
{ file: mapFile, text: () => readFileSync(mapFile, "utf8") },
() => readFileSync(filePath, "utf8"),
),
};
}
const source = readFileSync(filePath, "utf8");
// A `.ts` file in a CommonJS package that uses `import`/`export` runs
// as ESM — the same call Node's own module-syntax detection makes for
// `.js`. Explicit `.cts` stays CommonJS regardless.
if (
moduleFormat === "commonjs" &&
extension !== ".cts" &&
parseSync(filePath, source, { lang, sourceType: "unambiguous" }).module.hasModuleSyntax
) {
moduleFormat = "module";
}
const transformed = transformSync(
filePath,
source,
{ ...options, sourceType: moduleFormat },
this.#tsconfigCache,
);
if (transformed.errors.length > 0) {
const [error] = transformed.errors;
throw error instanceof Error
? error
: new SyntaxError(
`${filePath}: ${(error as { message?: string }).message ?? String(error)}`,
);
}
const map =
transformed.map === undefined ? undefined : storedSourceMap(transformed.map, filePath);
// The map is stored next to the cache entry and referenced by path; see
// `attachSourceMap` for when it is inlined instead.
const mapFile =
key === undefined || map === undefined
? undefined
: this.#cache?.set(key, {
format: moduleFormat,
code: transformed.code,
map,
});
return {
format: moduleFormat,
source:
map === undefined
? transformed.code
: attachSourceMap(transformed.code, { file: mapFile, text: () => map }, () => source),
};
}
}