@matter/tools 0.16.0-alpha.0-20251207-37e501b18 → 0.16.0-alpha.0-20251209-d6072d23e

package/src/building/error.ts

@@ -11,16 +11,16 @@ export class InternalBuildError extends Error {
 }
 
 export class BuildError extends Error {
-    constructor(readonly diagnostics: string) {
+    constructor(readonly diagnostics?: string) {
         super();
     }
 
     override get stack() {
-        return this.diagnostics;
+        return this.diagnostics ?? super.stack;
     }
 
     override toString() {
-        return this.diagnostics;
+        return this.diagnostics ?? "Build error";
     }
 
     inspect() {

package/src/building/project-builder.ts

@@ -9,7 +9,7 @@ import { Progress } from "../util/progress.js";
 import { BuildError } from "./error.js";
 import { Graph } from "./graph.js";
 import { BuildInformation, Project } from "./project.js";
-import { createTypescriptContext } from "./typescript.js";
+import { createTsgoContext, createTypescriptContext } from "./typescript.js";
 import { TypescriptContext } from "./typescript/context.js";
 
 export enum Target {
@@ -23,6 +23,7 @@ export interface Options {
     targets?: Target[];
     clean?: boolean;
     graph?: Graph;
+    tsgo?: boolean;
 }
 
 /**
@@ -34,11 +35,13 @@ export class ProjectBuilder {
     unconditional: boolean;
     tsContext?: TypescriptContext;
     graph?: Graph;
+    tsgo?: boolean;
 
     constructor(private options: Options = {}) {
         this.graph = options.graph;
         this.unconditional =
             options.clean || (options.targets !== undefined && options.targets?.indexOf(Target.clean) !== -1);
+        this.tsgo = options.tsgo;
     }
 
     get hasClean() {
@@ -112,7 +115,12 @@ export class ProjectBuilder {
                 // Obtain or initialize typescript solution builder
                 let context = this.tsContext;
                 if (context === undefined) {
-                    context = this.tsContext = await createTypescriptContext(project.pkg.workspace, graph);
+                    if (this.tsgo) {
+                        context = createTsgoContext(project.pkg.workspace);
+                    } else {
+                        context = await createTypescriptContext(project.pkg.workspace, graph);
+                    }
+                    this.tsContext = context;
                 }
 
                 const refreshCallback = progress.refresh.bind(progress);
@@ -152,8 +160,10 @@ export class ProjectBuilder {
                 }
             } catch (e) {
                 if (e instanceof BuildError) {
+                    if (e.diagnostics) {
+                        process.stderr.write(`${e.diagnostics}\n`);
+                    }
                     progress.failure("Terminating due to type errors");
-                    process.stderr.write(`${e.diagnostics}\n`);
                     process.exit(1);
                 }
                 throw e;

package/src/building/typescript/solution-builder.ts

@@ -39,7 +39,7 @@ export async function createSolutionBuilderContext(
 
     function currentContext() {
         if (context === undefined) {
-            throw new Error("Build context accessed with no ");
+            throw new Error("Build context accessed with no context");
         }
         return context;
     }

package/src/building/typescript/tsgo.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { spawn } from "node:child_process";
+import { cp } from "node:fs/promises";
+import { join } from "path";
+import { isDirectory } from "../../util/file.js";
+import { Package } from "../../util/package.js";
+import { BuildError } from "../error.js";
+import { TypescriptContext } from "./context.js";
+
+export function createTsgoContext(workspace: Package): TypescriptContext {
+    const bin = join(workspace.resolve("node_modules", ".bin", "tsgo"));
+    return {
+        async build(pkg, path, _refreshCallback, emit) {
+            const args = ["--project", path];
+
+            if (emit === false) {
+                args.push("--noEmit");
+            }
+
+            await new Promise<void>((resolve, reject) => {
+                const tsgo = spawn(bin, args, { stdio: "inherit" });
+
+                tsgo.on("exit", (code, signal) => {
+                    switch (code) {
+                        case 0:
+                            resolve();
+                            break;
+
+                        case 1: // Diagnostics present, outputs generated
+                        case 2: // Diagnostics present, outputs skipped
+                        case 3: // Project invalid
+                        case 4: // Reference cycle
+                        case 5: // Not implemented
+                            // TS will have printed an error already
+                            reject(new BuildError());
+                            break;
+
+                        case null:
+                            reject(new BuildError(`tsgo exited with signal ${signal}`));
+                            break;
+
+                        default:
+                            reject(new BuildError(`tsgo exited with code ${code}`));
+                            break;
+                    }
+                });
+            });
+
+            await cp(pkg.resolve("dist/esm"), pkg.resolve("dist/cjs"), {
+                recursive: true,
+                filter(src) {
+                    if (isDirectory(src)) {
+                        return true;
+                    }
+
+                    return src.endsWith(".d.ts") || src.endsWith(".d.ts.map");
+                },
+            });
+        },
+    };
+}

package/src/building/typescript.ts

@@ -6,6 +6,7 @@
 
 import { type TypescriptContext } from "./typescript/context.js";
 import { createSolutionBuilderContext } from "./typescript/solution-builder.js";
+export { createTsgoContext } from "./typescript/tsgo.js";
 
 /**
  * Create a {@link TypescriptContext} for validating types and optionally emitting .d.ts file.