@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.2

package/src/compile.ts

@@ -1,21 +1,18 @@
-import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
 
-const require = createRequire(import.meta.url);
-
-export type SourceModule = {
+type SourceModule = {
     fileName: string;
     source: string;
 };
 
-export type CompileProjectParams = {
+type CompileProjectParams = {
     projectDir: string;
     fileNames: string[];
     compilerOptions: Record<string, unknown>;
     label: string;
-    paths?: Record<string, string[]>;
 };
 
 const BASE_COMPILER_OPTIONS = {
@@ -38,108 +35,136 @@ const BASE_COMPILER_OPTIONS = {
     types: ["node"],
 };
 
-const codegenModules = (): string => dirname(dirname(dirname(require.resolve("@types/node/package.json"))));
+const CHECK_OPTIONS = {
+    declaration: true,
+    isolatedDeclarations: true,
+    noEmit: true,
+};
+
+const FORMAT_HOST: ts.FormatDiagnosticsHost = {
+    getCanonicalFileName: (fileName) => fileName,
+    getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+    getNewLine: () => "\n",
+};
+
+/** `@gtkx/codegen`'s own `node_modules`, which has `@types/node` plus the `@gtkx/*` deps the store typecheck needs. */
+const codegenModules = (): string => {
+    const sourceDir = dirname(fileURLToPath(import.meta.url));
+
+    return join(dirname(sourceDir), "node_modules");
+};
 
 const linkToolingModules = (projectDir: string): (() => void) => {
     const link = join(projectDir, "node_modules");
-    if (existsSync(link)) return () => {};
+
+    if (existsSync(link)) {
+        return (): void => undefined;
+    }
+
     symlinkSync(codegenModules(), link, "junction");
-    return () => rmSync(link, { force: true });
+
+    return () => {
+        rmSync(link, { force: true });
+    };
 };
 
-const tscBin = (): string => join(dirname(require.resolve("typescript/package.json")), "bin", "tsc");
+const isProjectFile = (rel: string): boolean =>
+    !rel.startsWith("..") && !isAbsolute(rel) && !rel.split(/[/\\]/).includes("node_modules");
 
-const runTsc = (tsconfigPath: string, cwd: string): { code: number; output: string } => {
-    try {
-        execFileSync(process.execPath, [tscBin(), "--pretty", "false", "-p", tsconfigPath], {
-            cwd,
-            encoding: "utf8",
-            stdio: ["ignore", "pipe", "pipe"],
-            maxBuffer: 64 * 1024 * 1024,
-        });
-        return { code: 0, output: "" };
-    } catch (error) {
-        const {
-            status,
-            stdout = "",
-            stderr = "",
-        } = error as { status?: number | null; stdout?: string; stderr?: string };
-        return { code: typeof status === "number" ? status : 1, output: `${stdout}\n${stderr}` };
+const projectDiagnosticLine = (diagnostic: ts.Diagnostic, projectDir: string): string | undefined => {
+    const { file, start } = diagnostic;
+
+    if (file === undefined || start === undefined) {
+        return undefined;
+    }
+
+    const filePath = relative(projectDir, file.fileName);
+
+    if (!isProjectFile(filePath)) {
+        return undefined;
     }
+
+    const { line, character } = file.getLineAndCharacterOfPosition(start);
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+
+    return `${filePath}:${String(line + 1)}:${String(character + 1)} - ${message} (TS${String(diagnostic.code)})`;
 };
 
-const DIAGNOSTIC_LINE = /^(.+?)\((\d+),(\d+)\): error TS(\d+): (.*)$/;
-
-type ProjectDiagnostic = { file: string; line: string; column: string; code: string; message: string };
-
-const parseDiagnostics = (output: string, projectDir: string): ProjectDiagnostic[] => {
-    const diagnostics: ProjectDiagnostic[] = [];
-    for (const raw of output.split(/\r?\n/)) {
-        const match = DIAGNOSTIC_LINE.exec(raw);
-        if (match === null) continue;
-        const [, filePart, line, column, code, message] = match;
-        if (filePart === undefined || line === undefined || column === undefined || code === undefined) continue;
-        const file = resolve(projectDir, filePart);
-        const rel = relative(projectDir, file);
-        if (rel.startsWith("..") || isAbsolute(rel) || rel.split(/[/\\]/).includes("node_modules")) continue;
-        diagnostics.push({ file, line, column, code, message: (message ?? "").trim() });
+const projectDiagnosticLines = (diagnostics: ts.Diagnostic[], projectDir: string): string[] => {
+    const lines: string[] = [];
+
+    for (const diagnostic of diagnostics) {
+        const line = projectDiagnosticLine(diagnostic, projectDir);
+
+        if (line !== undefined) {
+            lines.push(line);
+        }
+    }
+
+    return lines;
+};
+
+const diagnosticError = (label: string, projectDir: string, diagnostics: ts.Diagnostic[]): Error => {
+    const lines = projectDiagnosticLines(diagnostics, projectDir);
+
+    if (lines.length > 0) {
+        return new Error(`Type checking ${label} found ${String(lines.length)} error(s):\n${lines.join("\n")}`);
     }
-    return diagnostics;
+
+    return new Error(`Type checking ${label} failed:\n${ts.formatDiagnostics(diagnostics, FORMAT_HOST).trim()}`);
 };
 
-const formatDiagnostics = (label: string, projectDir: string, diagnostics: ProjectDiagnostic[]): string => {
-    const messages = diagnostics.map(
-        (diagnostic) =>
-            `${relative(projectDir, diagnostic.file)}:${diagnostic.line}:${diagnostic.column} - ${diagnostic.message} (TS${diagnostic.code})`,
+const runProgram = (params: CompileProjectParams): ts.Diagnostic[] => {
+    const parsed = ts.parseJsonConfigFileContent(
+        {
+            compilerOptions: { ...BASE_COMPILER_OPTIONS, ...params.compilerOptions },
+            files: params.fileNames.map((name) => `./${name}`),
+        },
+        ts.sys,
+        params.projectDir,
     );
-    return `Type checking ${label} found ${diagnostics.length} error(s):\n${messages.join("\n")}`;
+
+    const program = ts.createProgram({
+        rootNames: parsed.fileNames,
+        options: parsed.options,
+        configFileParsingDiagnostics: parsed.errors,
+    });
+
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+
+    if (diagnostics.length > 0) {
+        return [...diagnostics];
+    }
+
+    return [...program.emit().diagnostics];
 };
 
-export const compileProject = (params: CompileProjectParams): void => {
-    const tsconfigPath = join(params.projectDir, "tsconfig.json");
+const compileProject = (params: CompileProjectParams): void => {
     const unlinkToolingModules = linkToolingModules(params.projectDir);
+
     try {
-        writeFileSync(
-            tsconfigPath,
-            JSON.stringify({
-                compilerOptions: {
-                    ...BASE_COMPILER_OPTIONS,
-                    ...params.compilerOptions,
-                    ...(params.paths === undefined ? {} : { paths: params.paths }),
-                },
-                files: params.fileNames.map((name) => `./${name}`),
-            }),
-        );
-        const { code, output } = runTsc(tsconfigPath, params.projectDir);
-        const diagnostics = parseDiagnostics(output, params.projectDir);
+        const diagnostics = runProgram(params);
+
         if (diagnostics.length > 0) {
-            throw new Error(formatDiagnostics(params.label, params.projectDir, diagnostics));
-        }
-        if (code !== 0) {
-            throw new Error(`Type checking ${params.label} failed:\n${output.trim()}`);
+            throw diagnosticError(params.label, params.projectDir, diagnostics);
         }
     } finally {
         unlinkToolingModules();
-        rmSync(tsconfigPath, { force: true });
     }
 };
 
-const CHECK_OPTIONS = {
-    declaration: true,
-    isolatedDeclarations: true,
-    noEmit: true,
-};
-
-export const checkModules = (params: { modules: SourceModule[]; resolveFrom: string; label: string }): void => {
+const checkModules = (params: { modules: SourceModule[]; resolveFrom: string; label: string }): void => {
     const checkRoot = join(params.resolveFrom, "node_modules");
     mkdirSync(checkRoot, { recursive: true });
     const projectDir = mkdtempSync(join(checkRoot, ".gtkx-check-"));
+
     try {
         for (const module of params.modules) {
             const filePath = join(projectDir, module.fileName);
             mkdirSync(dirname(filePath), { recursive: true });
             writeFileSync(filePath, module.source);
         }
+
         compileProject({
             projectDir,
             fileNames: params.modules.map((module) => module.fileName),
@@ -150,3 +175,5 @@ export const checkModules = (params: { modules: SourceModule[]; resolveFrom: str
         rmSync(projectDir, { recursive: true, force: true });
     }
 };
+
+export { compileProject, checkModules, type SourceModule, type CompileProjectParams };