@defold-typescript/cli 0.5.5 → 0.7.0

package/src/build-session.ts

@@ -8,8 +8,10 @@ import {
 import {
   type BuildConfig,
   collectFailures,
-  computeScriptRel,
+  computeOutputRel,
+  detectSourceOutputKind,
   isTranspilerSource,
+  outputRelsForSource,
   readBuildConfig,
   throwIfFailures,
   toPosix,
@@ -35,7 +37,20 @@ export function createBuildSession(opts: CreateBuildSessionOptions): BuildSessio
   const config: BuildConfig = readBuildConfig(cwd);
   const session: TranspileSession = createTranspileSession();
 
-  function writeOutputs(result: TranspileProjectResult, keys: readonly string[]): BuildResult {
+  function pruneOutputs(rel: string, keepRel?: string): void {
+    for (const outputRel of outputRelsForSource(rel, config)) {
+      if (outputRel !== keepRel && outputRel !== `${keepRel}.map`) {
+        rmSync(path.join(cwd, outputRel), { force: true });
+      }
+    }
+  }
+
+  function writeOutputs(
+    result: TranspileProjectResult,
+    keys: readonly string[],
+    sources: Record<string, string>,
+    pruneAlternatives = false,
+  ): BuildResult {
     const failures = collectFailures(result.diagnostics);
     const written: string[] = [];
     for (const rel of keys) {
@@ -46,12 +61,15 @@ export function createBuildSession(opts: CreateBuildSessionOptions): BuildSessio
       if (lua === undefined) {
         continue;
       }
-      const scriptRel = computeScriptRel(rel, config);
-      writeScriptFile(cwd, scriptRel, lua, result.sourceMaps[rel]);
-      written.push(scriptRel);
+      const outputRel = computeOutputRel(rel, config, detectSourceOutputKind(sources[rel] ?? ""));
+      if (pruneAlternatives) {
+        pruneOutputs(rel, outputRel);
+      }
+      writeScriptFile(cwd, outputRel, lua, result.sourceMaps[rel]);
+      written.push(outputRel);
     }
     throwIfFailures(failures);
-    return { written };
+    return { written: written.sort() };
   }
 
   function buildAll(): BuildResult {
@@ -72,7 +90,7 @@ export function createBuildSession(opts: CreateBuildSessionOptions): BuildSessio
     }
 
     const result = session.update(files);
-    return writeOutputs(result, sources);
+    return writeOutputs(result, sources, files);
   }
 
   function applyEvents(changed: string[], removed: string[]): BuildResult {
@@ -89,12 +107,14 @@ export function createBuildSession(opts: CreateBuildSessionOptions): BuildSessio
     const result = session.update(changes);
 
     for (const rel of sourceRemoved) {
-      const scriptAbs = path.join(cwd, computeScriptRel(rel, config));
-      rmSync(scriptAbs, { force: true });
-      rmSync(`${scriptAbs}.map`, { force: true });
+      pruneOutputs(rel);
     }
 
-    return writeOutputs(result, sourceChanged);
+    const changedSources: Record<string, string> = {};
+    for (const rel of sourceChanged) {
+      changedSources[rel] = changes[rel] ?? "";
+    }
+    return writeOutputs(result, sourceChanged, changedSources, true);
   }
 
   return { buildAll, applyEvents };

package/src/build.ts

@@ -3,7 +3,8 @@ import * as path from "node:path";
 import { transpileProject } from "@defold-typescript/transpiler";
 import {
   collectFailures,
-  computeScriptRel,
+  computeOutputRel,
+  detectSourceOutputKind,
   readBuildConfig,
   throwIfFailures,
   toPosix,
@@ -52,11 +53,11 @@ export function runBuild(opts: RunBuildOptions): RunBuildResult {
     if (!lua) {
       continue;
     }
-    const scriptRel = computeScriptRel(rel, config);
-    writeScriptFile(cwd, scriptRel, lua, result.sourceMaps[rel]);
-    written.push(scriptRel);
+    const outputRel = computeOutputRel(rel, config, detectSourceOutputKind(files[rel] ?? ""));
+    writeScriptFile(cwd, outputRel, lua, result.sourceMaps[rel]);
+    written.push(outputRel);
   }
 
   throwIfFailures(failures);
-  return { written };
+  return { written: written.sort() };
 }

package/src/debug-launcher.ts

@@ -7,28 +7,44 @@ export interface EngineTarget {
 }
 
 // `enginePlatform` keys the d.defold.com download path; `buildFolder` keys the
-// native-extension build output. They diverge on macOS (`x86_64-darwin` vs
-// `x86_64-osx`), which is why they are tracked separately.
+// native-extension build output. Current Defold uses the same `-macos` identifier
+// for both, but they are tracked separately so a future divergence stays local.
+// Keyed by `${process.platform}-${process.arch}` because Apple Silicon and Intel
+// resolve to different engine archives (`arm64-macos` vs `x86_64-macos`).
 const PLATFORM_TARGETS: Record<string, EngineTarget> = {
-  darwin: { enginePlatform: "x86_64-darwin", buildFolder: "x86_64-osx", executable: "dmengine" },
-  linux: { enginePlatform: "x86_64-linux", buildFolder: "x86_64-linux", executable: "dmengine" },
-  win32: {
+  "darwin-arm64": {
+    enginePlatform: "arm64-macos",
+    buildFolder: "arm64-macos",
+    executable: "dmengine",
+  },
+  "darwin-x64": {
+    enginePlatform: "x86_64-macos",
+    buildFolder: "x86_64-macos",
+    executable: "dmengine",
+  },
+  "linux-x64": {
+    enginePlatform: "x86_64-linux",
+    buildFolder: "x86_64-linux",
+    executable: "dmengine",
+  },
+  "win32-x64": {
     enginePlatform: "x86_64-win32",
     buildFolder: "x86_64-win32",
     executable: "dmengine.exe",
   },
 };
 
-const ENGINE_INFO_URL = "https://d.defold.com/stable/info.json";
-const ENGINE_ARCHIVE_BASE = "https://d.defold.com/archive/stable";
+export const ENGINE_INFO_URL = "https://d.defold.com/stable/info.json";
+export const ENGINE_ARCHIVE_BASE = "https://d.defold.com/archive/stable";
 
 export const DEBUG_LAUNCHER_REL = ".vscode/defold-debug.ts";
 
-export function targetPlatform(platform: NodeJS.Platform): EngineTarget {
-  const target = PLATFORM_TARGETS[platform];
+export function targetPlatform(platform: NodeJS.Platform, arch: string): EngineTarget {
+  const key = `${platform}-${arch}`;
+  const target = PLATFORM_TARGETS[key];
   if (!target) {
     throw new Error(
-      `defold-typescript debug: unsupported platform "${platform}"; expected one of ${Object.keys(
+      `defold-typescript debug: unsupported platform "${key}"; expected one of ${Object.keys(
         PLATFORM_TARGETS,
       ).join(", ")}.`,
     );
@@ -69,6 +85,14 @@ export function debugLaunchConfig() {
     internalConsoleOptions: "openOnSessionStart",
     program: { command: "bun" },
     args: [DEBUG_LAUNCHER_REL],
+    // Local Lua Debugger (>=0.3.0) pre-scans `scriptFiles` for the emitted
+    // `--# sourceMappingURL=` trailers so a breakpoint in a `.ts` resolves
+    // ahead of time; without it no source-mapped breakpoint ever binds. Every
+    // build emits `<name>.ts.script` under `src/`. `scriptRoots` lets the
+    // debugger resolve the running Defold chunk path (`/src/...`) and the map's
+    // bare `sources` entry (`player.ts`) back to files on disk.
+    scriptFiles: ["src/**/*.ts.script"],
+    scriptRoots: [".", "src"],
   };
 }
 
@@ -103,9 +127,9 @@ const PLATFORM_TARGETS: Record<string, EngineTarget> = ${targets};
 const ENGINE_INFO_URL = "${ENGINE_INFO_URL}";
 const ENGINE_ARCHIVE_BASE = "${ENGINE_ARCHIVE_BASE}";
 
-const target = PLATFORM_TARGETS[process.platform];
+const target = PLATFORM_TARGETS[\`\${process.platform}-\${process.arch}\`];
 if (!target) {
-  console.error(\`Unsupported platform: \${process.platform}\`);
+  console.error(\`Unsupported platform: \${process.platform}-\${process.arch}\`);
   process.exit(1);
 }
 

package/src/directory-walls.ts

@@ -0,0 +1,214 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
+import { detectSourceOutputKind, isTranspilerSource, readBuildConfig } from "./build-output";
+import { scanFilesSync } from "./scan";
+import {
+  isSkipped,
+  type ScriptKind,
+  selectDirectoryWalls,
+  selectScriptKind,
+  selectScriptKindEntrypoint,
+} from "./script-kind";
+
+export interface DirectoryWall {
+  readonly dir: string;
+  readonly kind: ScriptKind;
+  readonly typesEntrypoint: string;
+}
+
+function describeWall(dir: string, kind: ScriptKind): DirectoryWall {
+  return {
+    dir,
+    kind,
+    typesEntrypoint: selectScriptKindEntrypoint(new Set([kind])),
+  };
+}
+
+export function planDirectoryWalls(cwd: string): DirectoryWall[] {
+  return [...selectDirectoryWalls(cwd)]
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .map(([dir, kind]) => describeWall(dir, kind));
+}
+
+export function groupSourceScriptKindsByDirectory(cwd: string): Map<string, Set<ScriptKind>> {
+  const byDir = new Map<string, Set<ScriptKind>>();
+  const seen = new Set<string>();
+  for (const pattern of readBuildConfig(cwd).include) {
+    for (const match of scanFilesSync(cwd, pattern)) {
+      const rel = match.split(path.sep).join("/");
+      if (seen.has(rel) || !isTranspilerSource(rel) || isSkipped(rel)) {
+        continue;
+      }
+      seen.add(rel);
+      const kind = detectSourceOutputKind(readFileSync(path.join(cwd, match), "utf8"));
+      if (kind === "module") {
+        continue;
+      }
+      const dir = path.posix.dirname(rel);
+      let set = byDir.get(dir);
+      if (set === undefined) {
+        set = new Set<ScriptKind>();
+        byDir.set(dir, set);
+      }
+      set.add(kind);
+    }
+  }
+  return byDir;
+}
+
+export function planSourceDirectoryWalls(cwd: string): DirectoryWall[] {
+  const walls: DirectoryWall[] = [];
+  for (const [dir, kinds] of groupSourceScriptKindsByDirectory(cwd)) {
+    const kind = selectScriptKind(kinds);
+    if (kind !== null) {
+      walls.push(describeWall(dir, kind));
+    }
+  }
+  return walls.sort((a, b) => (a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0));
+}
+
+interface WallTsconfig {
+  readonly extends: string;
+  readonly compilerOptions: {
+    readonly composite: true;
+    readonly typeRoots: null;
+    readonly types: string[];
+  };
+  readonly include: readonly ["**/*.ts"];
+  readonly exclude: readonly [];
+}
+
+export function directoryWallTsconfig(wall: DirectoryWall): WallTsconfig {
+  const depth = wall.dir.split("/").length;
+  return {
+    extends: `${"../".repeat(depth)}tsconfig.json`,
+    compilerOptions: { composite: true, typeRoots: null, types: [wall.typesEntrypoint] },
+    include: ["**/*.ts"],
+    exclude: [],
+  };
+}
+
+function writeJson(filePath: string, value: unknown): void {
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+interface RootTsconfig {
+  exclude?: string[];
+  files?: string[];
+  references?: Array<{ path: string }>;
+  [key: string]: unknown;
+}
+
+function sortedWallDirs(walls: readonly DirectoryWall[]): string[] {
+  return walls
+    .map((w) => w.dir)
+    .filter((dir) => dir !== ".")
+    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+
+function isInsideAnyDir(rel: string, dirs: readonly string[]): boolean {
+  return dirs.some((dir) => rel === dir || rel.startsWith(`${dir}/`));
+}
+
+function hasRootOwnedTranspilerSources(cwd: string, wallDirs: readonly string[]): boolean {
+  const seen = new Set<string>();
+  for (const pattern of readBuildConfig(cwd).include) {
+    for (const match of scanFilesSync(cwd, pattern)) {
+      const rel = match.split(path.sep).join("/");
+      if (seen.has(rel) || !isTranspilerSource(rel) || isSkipped(rel)) {
+        continue;
+      }
+      seen.add(rel);
+      if (!isInsideAnyDir(rel, wallDirs)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export function wireWallReferences(cwd: string, walls: readonly DirectoryWall[]): void {
+  const rootPath = path.join(cwd, "tsconfig.json");
+  const current = JSON.parse(readFileSync(rootPath, "utf8")) as RootTsconfig;
+  const wallDirs = sortedWallDirs(walls);
+  const previousReferences = current.references ?? [];
+  const previousManaged = new Set(previousReferences.map((ref) => ref.path));
+  const nextExclude = [
+    ...new Set([
+      ...(current.exclude ?? []).filter((entry) => !previousManaged.has(entry)),
+      ...wallDirs,
+    ]),
+  ];
+  const next: RootTsconfig = { ...current };
+
+  if (wallDirs.length > 0) {
+    next.references = wallDirs.map((dir) => ({ path: dir }));
+  } else {
+    delete next.references;
+  }
+
+  if (nextExclude.length > 0) {
+    next.exclude = nextExclude;
+  } else {
+    delete next.exclude;
+  }
+
+  if (wallDirs.length > 0 && !hasRootOwnedTranspilerSources(cwd, wallDirs)) {
+    next.files = [];
+  } else if (previousReferences.length > 0 && JSON.stringify(next.files) === JSON.stringify([])) {
+    delete next.files;
+  }
+
+  if (JSON.stringify(next) !== JSON.stringify(current)) {
+    writeJson(rootPath, next);
+  }
+}
+
+export function writeDirectoryWallTsconfigs(cwd: string, walls: DirectoryWall[]): string[] {
+  const written: string[] = [];
+  for (const w of walls) {
+    if (w.dir === ".") {
+      continue;
+    }
+    const rel = `${w.dir}/tsconfig.json`;
+    const target = path.join(cwd, w.dir, "tsconfig.json");
+    const desired = directoryWallTsconfig(w);
+    if (existsSync(target)) {
+      const current = JSON.parse(readFileSync(target, "utf8")) as {
+        extends?: string;
+        compilerOptions?: Record<string, unknown>;
+        [key: string]: unknown;
+      };
+      const options = current.compilerOptions ?? {};
+      // Skip the write when already narrowed so a consumer's formatting is not
+      // churned to JSON.stringify's layout on every build.
+      const alreadyNarrowed =
+        current.extends === desired.extends &&
+        options.composite === desired.compilerOptions.composite &&
+        options.typeRoots === desired.compilerOptions.typeRoots &&
+        JSON.stringify(options.types) === JSON.stringify(desired.compilerOptions.types) &&
+        JSON.stringify(current.include) === JSON.stringify(desired.include) &&
+        JSON.stringify(current.exclude) === JSON.stringify(desired.exclude);
+      if (!alreadyNarrowed) {
+        writeJson(target, {
+          ...current,
+          extends: desired.extends,
+          compilerOptions: {
+            ...options,
+            composite: desired.compilerOptions.composite,
+            typeRoots: desired.compilerOptions.typeRoots,
+            types: desired.compilerOptions.types,
+          },
+          include: desired.include,
+          exclude: desired.exclude,
+        });
+        written.push(rel);
+      }
+    } else {
+      writeJson(target, desired);
+      written.push(rel);
+    }
+  }
+  return written.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}