ttsc 0.4.3-dev.20260426-3 → 0.4.4-dev.20260426

package/cmd/platform/main.go

@@ -76,8 +76,8 @@ which resolve the consuming project's @typescript/native-preview binary and any
 plugin-selected native sidecar.
 
 Usage:
-  ttsc-platform --version
-  ttsc-platform demo --type=string
+  ttsc --version
+  ttsc demo --type=string
 `))
 }
 

package/lib/api.d.ts

@@ -66,6 +66,7 @@ export type CheckOptions = Omit<BuildOptions, "emit">;
 export declare function transform(options: TransformOptions): string;
 /** Result of `build()`. Non-zero `status` means the build failed. */
 export interface BuildResult {
+    emittedFiles?: string[];
     status: number;
     stdout: string;
     stderr: string;

package/lib/api.js

@@ -122,6 +122,9 @@ function transform(options) {
     const sourceFile = realpathIfExists(path.isAbsolute(options.file)
         ? options.file
         : path.resolve(options.cwd ?? process.cwd(), options.file));
+    if (execution.sourcePlugins.length > 0) {
+        return transformWithSourceTransforms(options, execution, sourceFile);
+    }
     if (execution.nativeBinary) {
         return transformWithNativeBinary(options, execution, sourceFile);
     }
@@ -147,8 +150,9 @@ function transform(options) {
         if (!emitted) {
             throw new Error(`ttsc.transform: no output produced for ${sourceFile}`);
         }
-        const transformed = finalizeTransformText(execution.plugins, {
+        const transformed = finalizeTransformText(execution.outputPlugins, {
             command: "transform",
+            compilerOptions: execution.compilerOptions,
             cwd: execution.cwd,
             projectRoot: execution.projectRoot,
             sourceFile,
@@ -185,8 +189,9 @@ function transformWithNativeBinary(options, execution, sourceFile) {
     if (res.status !== 0) {
         throw new Error("ttsc.transform exited " + res.status + "\n" + (res.stderr || ""));
     }
-    const transformed = finalizeTransformText(execution.plugins, {
+    const transformed = finalizeTransformText(execution.outputPlugins, {
         command: "transform",
+        compilerOptions: execution.compilerOptions,
         cwd: execution.cwd,
         projectRoot: execution.projectRoot,
         sourceFile,
@@ -198,6 +203,58 @@ function transformWithNativeBinary(options, execution, sourceFile) {
     }
     return transformed;
 }
+function transformWithSourceTransforms(options, execution, sourceFile) {
+    if (execution.nativeBinary || execution.nativeMode !== "none") {
+        throw new Error("ttsc.transform: transformSource cannot be combined with native rewrite mode yet");
+    }
+    const materialized = materializeSourceTransformedProject(execution, "transform", sourceFile);
+    const tempOutDir = path.join(materialized.root, ".ttsc-transform-out");
+    try {
+        const tempSourceFile = toMaterializedPath(sourceFile, materialized);
+        const result = build({
+            ...options,
+            cwd: materialized.root,
+            emit: true,
+            forceListEmittedFiles: true,
+            outDir: tempOutDir,
+            plugins: false,
+            tsconfig: materialized.tsconfig,
+        });
+        if (result.status !== 0) {
+            throw new Error("ttsc.transform exited " +
+                result.status +
+                "\n" +
+                (result.stderr || result.stdout));
+        }
+        const emitted = findEmittedFile(tempOutDir, materialized.root, tempSourceFile);
+        if (!emitted) {
+            throw new Error(`ttsc.transform: no output produced for ${sourceFile}`);
+        }
+        let transformed = finalizeTransformText(execution.outputPlugins, {
+            command: "transform",
+            compilerOptions: execution.compilerOptions,
+            cwd: execution.cwd,
+            projectRoot: execution.projectRoot,
+            sourceFile,
+            tsconfig: execution.tsconfig,
+        }, fs.readFileSync(emitted, "utf8"));
+        if (options.out) {
+            const mapFile = `${emitted}.map`;
+            if (fs.existsSync(mapFile)) {
+                const outMap = `${options.out}.map`;
+                fs.mkdirSync(path.dirname(outMap), { recursive: true });
+                fs.writeFileSync(outMap, patchSourceMapText(fs.readFileSync(mapFile, "utf8"), materialized, outMap, mapFile), "utf8");
+                transformed = rewriteSourceMapReference(transformed, path.basename(outMap));
+            }
+            fs.mkdirSync(path.dirname(options.out), { recursive: true });
+            fs.writeFileSync(options.out, transformed, "utf8");
+        }
+        return transformed;
+    }
+    finally {
+        fs.rmSync(materialized.root, { recursive: true, force: true });
+    }
+}
 function realpathIfExists(file) {
     try {
         return fs.realpathSync(file);
@@ -213,6 +270,9 @@ function realpathIfExists(file) {
  */
 function build(options = {}) {
     const execution = resolveExecutionContext(options);
+    if (execution.sourcePlugins.length > 0) {
+        return buildWithSourceTransforms(options, execution);
+    }
     if (execution.nativeBinary) {
         return buildWithNativeBinary(options, execution);
     }
@@ -231,7 +291,8 @@ function build(options = {}) {
         }
     }
     const args = createTsgoBuildArgs(execution, options, {
-        listEmittedFiles: options.emit !== false && execution.plugins.length > 0,
+        listEmittedFiles: options.emit !== false &&
+            (execution.outputPlugins.length > 0 || options.forceListEmittedFiles === true),
     });
     const res = spawnBinary(execution.tsgo.binary, args, {
         cwd: execution.projectRoot,
@@ -253,10 +314,10 @@ function build(options = {}) {
     if (emittedFiles.length !== 0) {
         result.stdout = stripEmittedFileLines(result.stdout);
     }
-    if (result.status === 0 && options.emit !== false && execution.plugins.length > 0) {
-        applyBuildPlugins(execution.plugins, execution, emittedFiles);
+    if (result.status === 0 && options.emit !== false && execution.outputPlugins.length > 0) {
+        applyBuildPlugins(execution.outputPlugins, execution, emittedFiles);
     }
-    return normalizeFailedDiagnostics(result);
+    return normalizeFailedDiagnostics({ ...result, emittedFiles });
 }
 function buildWithNativeBinary(options, execution) {
     const args = createNativeBuildArgs(execution, options);
@@ -277,6 +338,38 @@ function buildWithNativeBinary(options, execution) {
         stderr: outputText(res.stderr),
     });
 }
+function buildWithSourceTransforms(options, execution) {
+    if (execution.nativeBinary || execution.nativeMode !== "none") {
+        return {
+            status: 2,
+            stdout: "",
+            stderr: "ttsc.build: transformSource cannot be combined with native rewrite mode yet\n",
+        };
+    }
+    const materialized = materializeSourceTransformedProject(execution, "build");
+    try {
+        const outDir = mapOutDirToMaterializedProject(options.outDir, execution, materialized);
+        const result = build({
+            ...options,
+            cwd: materialized.root,
+            forceListEmittedFiles: true,
+            outDir,
+            plugins: false,
+            tsconfig: materialized.tsconfig,
+        });
+        if (result.status === 0 && options.emit !== false) {
+            const copied = copyMaterializedEmittedFiles(materialized, result.emittedFiles ?? []);
+            result.emittedFiles = copied;
+            if (execution.outputPlugins.length > 0) {
+                applyBuildPlugins(execution.outputPlugins, execution, copied);
+            }
+        }
+        return result;
+    }
+    finally {
+        fs.rmSync(materialized.root, { recursive: true, force: true });
+    }
+}
 /**
  * Run `ttsc check` (build without emit) — CI gate / pre-commit hook use.
  * Resolves with an exit-code record; does not throw.
@@ -374,11 +467,13 @@ function resolveExecutionContext(options) {
         tsconfig,
     });
     return {
+        compilerOptions: loaded.project.compilerOptions,
         cwd,
         nativeBinary: loaded.nativeBinary ?? null,
         nativeMode: options.rewriteMode ?? loaded.nativeMode,
-        plugins: loaded.plugins.filter((plugin) => plugin.transformOutput),
+        outputPlugins: loaded.plugins.filter((plugin) => plugin.transformOutput),
         projectRoot,
+        sourcePlugins: loaded.plugins.filter((plugin) => plugin.transformSource),
         tsgo,
         tsconfig,
     };
@@ -404,6 +499,7 @@ function applyBuildPlugins(plugins, execution, emittedFiles) {
         const next = (0, plugin_1.applyPluginTransforms)(plugins, {
             code: current,
             command: "build",
+            compilerOptions: execution.compilerOptions,
             cwd: execution.cwd,
             outputFile: file,
             projectRoot: execution.projectRoot,
@@ -442,6 +538,7 @@ function normalizeFailedDiagnostics(result) {
         return result;
     }
     return {
+        emittedFiles: result.emittedFiles,
         status: result.status,
         stdout: "",
         stderr: result.stdout,
@@ -514,4 +611,408 @@ function readOwnPackageVersion() {
         return "0.0.0";
     }
 }
+function materializeSourceTransformedProject(execution, command, onlySourceFile) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-source-"));
+    const materialized = {
+        mappers: new Map(),
+        originalRoot: execution.projectRoot,
+        root,
+        tsconfig: path.join(root, path.relative(execution.projectRoot, execution.tsconfig)),
+    };
+    copyProjectForSourceTransforms(execution.projectRoot, root, execution.compilerOptions);
+    const files = onlySourceFile
+        ? [toMaterializedPath(onlySourceFile, materialized)]
+        : listSourceTransformFiles(root);
+    for (const tempFile of files) {
+        if (!fs.existsSync(tempFile) || !fs.statSync(tempFile).isFile()) {
+            continue;
+        }
+        const originalFile = fromMaterializedPath(tempFile, materialized);
+        const current = fs.readFileSync(tempFile, "utf8");
+        const transformed = (0, plugin_1.applyPluginSourceTransformsWithMap)(execution.sourcePlugins, {
+            code: current,
+            command,
+            compilerOptions: execution.compilerOptions,
+            cwd: execution.cwd,
+            projectRoot: execution.projectRoot,
+            sourceFile: originalFile,
+            tsconfig: execution.tsconfig,
+        });
+        const next = transformed.code;
+        if (next !== current) {
+            fs.writeFileSync(tempFile, next, "utf8");
+        }
+        if (transformed.stages.length > 0) {
+            materialized.mappers.set(filepathKey(tempFile), {
+                finalCode: next,
+                originalCode: current,
+                stages: transformed.stages,
+            });
+        }
+    }
+    return materialized;
+}
+function copyProjectForSourceTransforms(source, target, compilerOptions) {
+    const excluded = new Set([".git", "node_modules"]);
+    const outDir = typeof compilerOptions.outDir === "string" ? compilerOptions.outDir : "";
+    const resolvedOutDir = outDir ? path.resolve(outDir) : "";
+    copyDirectoryFiltered(source, target, (entry) => {
+        if (excluded.has(path.basename(entry))) {
+            return false;
+        }
+        if (resolvedOutDir && isPathInside(entry, resolvedOutDir)) {
+            return false;
+        }
+        return true;
+    });
+    const nodeModules = path.join(source, "node_modules");
+    if (fs.existsSync(nodeModules)) {
+        const targetNodeModules = path.join(target, "node_modules");
+        try {
+            fs.symlinkSync(nodeModules, targetNodeModules, "junction");
+        }
+        catch {
+            copyDirectoryFiltered(nodeModules, targetNodeModules, () => true);
+        }
+    }
+}
+function copyDirectoryFiltered(source, target, shouldCopy) {
+    if (!shouldCopy(source)) {
+        return;
+    }
+    const stat = fs.lstatSync(source);
+    if (stat.isSymbolicLink()) {
+        const link = fs.readlinkSync(source);
+        fs.symlinkSync(link, target);
+        return;
+    }
+    if (stat.isDirectory()) {
+        fs.mkdirSync(target, { recursive: true });
+        for (const entry of fs.readdirSync(source)) {
+            copyDirectoryFiltered(path.join(source, entry), path.join(target, entry), shouldCopy);
+        }
+        return;
+    }
+    if (stat.isFile()) {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.copyFileSync(source, target);
+    }
+}
+function listSourceTransformFiles(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length !== 0) {
+        const current = stack.pop();
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            if (entry.name === "node_modules" || entry.name === ".git") {
+                continue;
+            }
+            const next = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(next);
+            }
+            else if (entry.isFile() && isTransformableSource(next)) {
+                out.push(next);
+            }
+        }
+    }
+    return out;
+}
+function isTransformableSource(file) {
+    return /\.(?:[cm]?tsx?)$/i.test(file) && !/\.d\.[cm]?ts$/i.test(file);
+}
+function mapOutDirToMaterializedProject(outDir, execution, materialized) {
+    if (!outDir) {
+        return undefined;
+    }
+    const resolved = path.resolve(execution.cwd, outDir);
+    if (isPathInside(resolved, execution.projectRoot)) {
+        return toMaterializedPath(resolved, materialized);
+    }
+    return path.join(materialized.root, ".ttsc-out");
+}
+function copyMaterializedEmittedFiles(materialized, emittedFiles) {
+    const copied = [];
+    for (const emitted of emittedFiles) {
+        if (!isPathInside(emitted, materialized.root)) {
+            continue;
+        }
+        const target = fromMaterializedPath(emitted, materialized);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        if (/\.map$/i.test(emitted)) {
+            fs.writeFileSync(target, patchSourceMapText(fs.readFileSync(emitted, "utf8"), materialized, target), "utf8");
+        }
+        else {
+            fs.copyFileSync(emitted, target);
+        }
+        copied.push(target);
+    }
+    return copied;
+}
+function toMaterializedPath(file, materialized) {
+    const relative = path.relative(materialized.originalRoot, file);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        return file;
+    }
+    return path.join(materialized.root, relative);
+}
+function fromMaterializedPath(file, materialized) {
+    const relative = path.relative(materialized.root, file);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        return file;
+    }
+    return path.join(materialized.originalRoot, relative);
+}
+function isPathInside(file, parent) {
+    const relative = path.relative(parent, file);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function filepathKey(file) {
+    return path.resolve(file).replace(/\\/g, "/");
+}
+function patchSourceMapText(text, materialized, outputFile, tempOutputFile = toMaterializedPath(outputFile, materialized)) {
+    let map;
+    try {
+        map = JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+    if (!Array.isArray(map.sources)) {
+        return text;
+    }
+    const tempMapDir = path.dirname(tempOutputFile);
+    const originalMapDir = path.dirname(outputFile);
+    const nextSources = [];
+    const nextSourcesContent = Array.isArray(map.sourcesContent)
+        ? [...map.sourcesContent]
+        : undefined;
+    const sourceMappings = new Map();
+    map.sources.forEach((source, index) => {
+        const tempSource = path.isAbsolute(source)
+            ? source
+            : path.resolve(tempMapDir, source);
+        if (isPathInside(tempSource, materialized.root)) {
+            const originalSource = fromMaterializedPath(tempSource, materialized);
+            const mapper = materialized.mappers.get(filepathKey(tempSource));
+            if (mapper) {
+                sourceMappings.set(index, mapper);
+            }
+            nextSources.push(relativeSourceMapPath(originalMapDir, originalSource));
+            if (nextSourcesContent) {
+                try {
+                    nextSourcesContent[index] = fs.readFileSync(originalSource, "utf8");
+                }
+                catch {
+                    /* keep emitted sourcesContent */
+                }
+            }
+        }
+        else {
+            nextSources.push(source);
+        }
+    });
+    if (sourceMappings.size > 0 && typeof map.mappings === "string") {
+        map.mappings = remapSourceMapMappings(map.mappings, sourceMappings);
+    }
+    map.sources = nextSources;
+    if (nextSourcesContent) {
+        map.sourcesContent = nextSourcesContent;
+    }
+    delete map.sourceRoot;
+    return JSON.stringify(map);
+}
+function relativeSourceMapPath(fromDir, file) {
+    const relative = path.relative(fromDir, file).replace(/\\/g, "/");
+    return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function rewriteSourceMapReference(code, mapFileName) {
+    const reference = `//# sourceMappingURL=${mapFileName}`;
+    if (/\/\/# sourceMappingURL=.*(?:\r?\n)?$/m.test(code)) {
+        return code.replace(/\/\/# sourceMappingURL=.*(?:\r?\n)?$/m, `${reference}\n`);
+    }
+    return code.endsWith("\n") ? `${code}${reference}\n` : `${code}\n${reference}\n`;
+}
+function remapSourceMapMappings(mappings, sourceMappings) {
+    const decoded = decodeMappings(mappings);
+    for (const line of decoded) {
+        for (const segment of line) {
+            if (segment.length < 4) {
+                continue;
+            }
+            const mapper = sourceMappings.get(segment[1]);
+            if (!mapper) {
+                continue;
+            }
+            const mapped = mapTransformedPositionToOriginal(mapper, {
+                column: segment[3],
+                line: segment[2],
+            });
+            segment[2] = mapped.line;
+            segment[3] = mapped.column;
+        }
+    }
+    return encodeMappings(decoded);
+}
+function mapTransformedPositionToOriginal(mapper, position) {
+    let offset = lineColumnToOffset(mapper.finalCode, position.line, position.column);
+    for (let index = mapper.stages.length - 1; index >= 0; index -= 1) {
+        offset = mapOffsetToPreviousStage(offset, mapper.stages[index]);
+    }
+    return offsetToLineColumn(mapper.originalCode, offset);
+}
+function mapOffsetToPreviousStage(offset, stage) {
+    let delta = 0;
+    for (const edit of stage.edits) {
+        if (offset < edit.newStart) {
+            return clampOffset(offset - delta, stage.before.length);
+        }
+        if (offset < edit.newEnd) {
+            return edit.start;
+        }
+        delta += edit.code.length - (edit.end - edit.start);
+    }
+    return clampOffset(offset - delta, stage.before.length);
+}
+function lineColumnToOffset(source, line, column) {
+    const starts = lineStarts(source);
+    const start = starts[Math.min(Math.max(line, 0), starts.length - 1)] ?? 0;
+    return clampOffset(start + Math.max(column, 0), source.length);
+}
+function offsetToLineColumn(source, offset) {
+    const starts = lineStarts(source);
+    const clamped = clampOffset(offset, source.length);
+    let low = 0;
+    let high = starts.length - 1;
+    while (low <= high) {
+        const mid = (low + high) >> 1;
+        const start = starts[mid];
+        const next = starts[mid + 1] ?? Number.POSITIVE_INFINITY;
+        if (clamped < start) {
+            high = mid - 1;
+        }
+        else if (clamped >= next) {
+            low = mid + 1;
+        }
+        else {
+            return { column: clamped - start, line: mid };
+        }
+    }
+    const last = starts.length - 1;
+    return { column: clamped - (starts[last] ?? 0), line: last };
+}
+function lineStarts(source) {
+    const starts = [0];
+    for (let index = 0; index < source.length; index += 1) {
+        const ch = source.charCodeAt(index);
+        if (ch === 13 /* \r */) {
+            if (source.charCodeAt(index + 1) === 10 /* \n */) {
+                index += 1;
+            }
+            starts.push(index + 1);
+        }
+        else if (ch === 10 /* \n */) {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+function clampOffset(offset, length) {
+    return Math.min(Math.max(offset, 0), length);
+}
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_VALUES = new Map([...BASE64_CHARS].map((char, index) => [char, index]));
+function decodeMappings(mappings) {
+    const lines = [];
+    let line = [];
+    let segment = [];
+    let index = 0;
+    const state = [0, 0, 0, 0, 0];
+    while (index < mappings.length) {
+        const char = mappings[index];
+        if (char === ";") {
+            if (segment.length > 0) {
+                line.push(segment);
+                segment = [];
+            }
+            lines.push(line);
+            line = [];
+            state[0] = 0;
+            index += 1;
+            continue;
+        }
+        if (char === ",") {
+            if (segment.length > 0) {
+                line.push(segment);
+                segment = [];
+            }
+            index += 1;
+            continue;
+        }
+        const read = readVlq(mappings, index);
+        index = read.next;
+        const field = segment.length;
+        state[field] = (state[field] ?? 0) + read.value;
+        segment.push(state[field]);
+    }
+    if (segment.length > 0) {
+        line.push(segment);
+    }
+    lines.push(line);
+    return lines;
+}
+function encodeMappings(lines) {
+    const state = [0, 0, 0, 0, 0];
+    return lines
+        .map((line) => {
+        state[0] = 0;
+        return line
+            .map((segment) => segment
+            .map((value, index) => {
+            const relative = value - (state[index] ?? 0);
+            state[index] = value;
+            return writeVlq(relative);
+        })
+            .join(""))
+            .join(",");
+    })
+        .join(";");
+}
+function readVlq(input, start) {
+    let index = start;
+    let shift = 0;
+    let value = 0;
+    while (index < input.length) {
+        const digit = BASE64_VALUES.get(input[index]);
+        if (digit === undefined) {
+            throw new Error(`ttsc: invalid source map VLQ digit ${input[index]}`);
+        }
+        index += 1;
+        const continuation = (digit & 32) !== 0;
+        value += (digit & 31) << shift;
+        shift += 5;
+        if (!continuation) {
+            const negative = (value & 1) === 1;
+            const decoded = value >> 1;
+            return { next: index, value: negative ? -decoded : decoded };
+        }
+    }
+    throw new Error("ttsc: unterminated source map VLQ segment");
+}
+function writeVlq(value) {
+    let vlq = Math.abs(value) << 1;
+    if (value < 0) {
+        vlq |= 1;
+    }
+    let out = "";
+    do {
+        let digit = vlq & 31;
+        vlq >>>= 5;
+        if (vlq > 0) {
+            digit |= 32;
+        }
+        out += BASE64_CHARS[digit];
+    } while (vlq > 0);
+    return out;
+}
 //# sourceMappingURL=api.js.map