@simplysm/sd-cli 13.0.99 → 14.0.1

package/src/utils/tsc-build.ts

@@ -0,0 +1,175 @@
+import path from "path";
+import ts from "typescript";
+import { pathx } from "@simplysm/core-node";
+import { err as errNs } from "@simplysm/core-common";
+import {
+  parseTsconfig,
+  getPackageSourceFiles,
+  getPackageFiles,
+} from "./tsconfig";
+import { serializeDiagnostic, type SerializedDiagnostic } from "./typecheck-serialization";
+import { createOutputPathRewriter, addJsExtensionToImports } from "./output-path-rewriter";
+
+/**
+ * Options for package-mode tsc build
+ */
+export interface TscPackageBuildOptions {
+  pkgDir: string;
+  cwd: string;
+  /** Output control flags: which files to emit */
+  output: { js: boolean; dts: boolean };
+  /** Pre-parsed tsconfig. If provided, skips parseTsconfig() call. */
+  parsedConfig?: ts.ParsedCommandLine;
+}
+
+/**
+ * Result of package-mode tsc build
+ */
+export interface TscPackageBuildResult {
+  success: boolean;
+  errors?: string[];
+  diagnostics: SerializedDiagnostic[];
+  errorCount: number;
+  warningCount: number;
+}
+
+/**
+ * Run TypeScript incremental build for a package.
+ *
+ * - output.js || output.dts: emit mode (src files only, generates output files)
+ * - neither: typecheck only (src + test files, no output)
+ *
+ * Uses tsBuildInfoFile for incremental compilation across runs.
+ */
+export function runTscPackageBuild(options: TscPackageBuildOptions): TscPackageBuildResult {
+  try {
+    const { pkgDir, output } = options;
+    const needsEmit = output.js || output.dts;
+
+    const parsedConfig = options.parsedConfig ?? parseTsconfig(pkgDir);
+    const baseOptions = parsedConfig.options;
+
+    let rootFiles: string[];
+    let diagnosticFilter: (d: ts.Diagnostic) => boolean;
+
+    if (needsEmit) {
+      rootFiles = getPackageSourceFiles(pkgDir, parsedConfig);
+      const pkgSrcDir = path.join(pkgDir, "src");
+      diagnosticFilter = (d) => d.file == null || pathx.isChildPath(d.file.fileName, pkgSrcDir);
+    } else {
+      rootFiles = getPackageFiles(pkgDir, parsedConfig);
+      diagnosticFilter = (d) => d.file == null || pathx.isChildPath(d.file.fileName, pkgDir);
+    }
+
+    const tsBuildInfoFile = path.join(
+      pkgDir,
+      ".cache",
+      needsEmit ? "build.tsbuildinfo" : "typecheck.tsbuildinfo",
+    );
+
+    const compilerOptions: ts.CompilerOptions = {
+      ...baseOptions,
+      sourceMap: output.js,
+      incremental: true,
+      tsBuildInfoFile,
+    };
+
+    if (output.js && output.dts) {
+      compilerOptions.noEmit = false;
+      compilerOptions.emitDeclarationOnly = false;
+      compilerOptions.declaration = true;
+      compilerOptions.declarationMap = true;
+      compilerOptions.outDir = path.join(pkgDir, "dist");
+      compilerOptions.declarationDir = path.join(pkgDir, "dist");
+    } else if (output.js) {
+      compilerOptions.noEmit = false;
+      compilerOptions.emitDeclarationOnly = false;
+      compilerOptions.declaration = false;
+      compilerOptions.declarationMap = false;
+      compilerOptions.outDir = path.join(pkgDir, "dist");
+    } else if (output.dts) {
+      compilerOptions.noEmit = false;
+      compilerOptions.emitDeclarationOnly = true;
+      compilerOptions.declaration = true;
+      compilerOptions.declarationMap = true;
+      compilerOptions.outDir = path.join(pkgDir, "dist");
+      compilerOptions.declarationDir = path.join(pkgDir, "dist");
+    } else {
+      compilerOptions.noEmit = true;
+      compilerOptions.emitDeclarationOnly = false;
+      compilerOptions.declaration = false;
+      compilerOptions.declarationMap = false;
+    }
+
+    const host = ts.createIncrementalCompilerHost(compilerOptions);
+
+    if (needsEmit) {
+      const rewritePath = createOutputPathRewriter(pkgDir);
+      const originalWriteFile = host.writeFile;
+      host.writeFile = (fileName, content, writeByteOrderMark, onError, sourceFiles, data) => {
+        const result = rewritePath(fileName, content);
+        if (result != null) {
+          let [newPath, newContent] = result;
+          if (newPath.endsWith(".js")) {
+            newContent = addJsExtensionToImports(newContent);
+          }
+          originalWriteFile(newPath, newContent, writeByteOrderMark, onError, sourceFiles, data);
+        }
+      };
+    }
+
+    const program = ts.createIncrementalProgram({
+      rootNames: rootFiles,
+      options: compilerOptions,
+      host,
+    });
+
+    const emitResult = program.emit();
+
+    const allDiagnostics = [
+      ...program.getConfigFileParsingDiagnostics(),
+      ...program.getSyntacticDiagnostics(),
+      ...program.getOptionsDiagnostics(),
+      ...program.getGlobalDiagnostics(),
+      ...program.getSemanticDiagnostics(),
+      ...emitResult.diagnostics,
+    ];
+
+    const filteredDiagnostics = allDiagnostics.filter(diagnosticFilter);
+
+    const serializedDiagnostics = filteredDiagnostics.map(serializeDiagnostic);
+    const errorCount = filteredDiagnostics.filter(
+      (d) => d.category === ts.DiagnosticCategory.Error,
+    ).length;
+    const warningCount = filteredDiagnostics.filter(
+      (d) => d.category === ts.DiagnosticCategory.Warning,
+    ).length;
+
+    const errors = filteredDiagnostics
+      .filter((d) => d.category === ts.DiagnosticCategory.Error)
+      .map((d) => {
+        const message = ts.flattenDiagnosticMessageText(d.messageText, "\n");
+        if (d.file != null && d.start != null) {
+          const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
+          return `${d.file.fileName}:${line + 1}:${character + 1}: TS${d.code}: ${message}`;
+        }
+        return `TS${d.code}: ${message}`;
+      });
+
+    return {
+      success: errorCount === 0,
+      errors: errors.length > 0 ? errors : undefined,
+      diagnostics: serializedDiagnostics,
+      errorCount,
+      warningCount,
+    };
+  } catch (err) {
+    return {
+      success: false,
+      errors: [errNs.message(err)],
+      diagnostics: [],
+      errorCount: 1,
+      warningCount: 0,
+    };
+  }
+}

package/src/utils/tsconfig.ts

@@ -1,123 +1,55 @@
-import ts from "typescript";
 import path from "path";
-import { fsx, pathx } from "@simplysm/core-node";
-import { SdError } from "@simplysm/core-common";
-
-/**
- * DOM-related lib patterns - libs that include browser APIs
- * Used when filtering libs that should be excluded from node environment (lib.dom.d.ts, lib.webworker.d.ts, etc)
- */
-const DOM_LIB_PATTERNS = ["dom", "webworker"] as const;
-
-/**
- * Read @types/* devDependencies from package.json and return types list
- */
-export async function getTypesFromPackageJson(packageDir: string): Promise<string[]> {
-  const packageJsonPath = path.join(packageDir, "package.json");
-  if (!(await fsx.exists(packageJsonPath))) {
-    return [];
-  }
-
-  const packageJson = await fsx.readJson<{ devDependencies?: Record<string, string> }>(
-    packageJsonPath,
-  );
-  const devDeps = packageJson.devDependencies ?? {};
-
-  return Object.keys(devDeps)
-    .filter((dep) => dep.startsWith("@types/"))
-    .map((dep) => dep.replace("@types/", ""));
-}
-
-/**
- * Type check environment
- * - node: remove DOM lib + add node types
- * - browser: remove node types
- */
-export type TypecheckEnv = "node" | "browser";
+import ts from "typescript";
+import { pathx } from "@simplysm/core-node";
 
 /**
- * Create compiler options for package
- *
- * @param baseOptions - Compiler options from root tsconfig
- * @param env - Type check environment (node: remove DOM lib + add node types, browser: remove node types)
- * @param packageDir - Package directory path
- *
- * @remarks
- * The types option ignores baseOptions.types and is newly constructed per package.
- * This is because the global types in root tsconfig may not fit the package environment.
- * (e.g., prevent node types from being included in browser packages)
+ * Check if tsconfig.json in the given directory has angularCompilerOptions.
+ * Uses ts.readConfigFile to read raw JSON (before parsing/extension).
  */
-export async function getCompilerOptionsForPackage(
-  baseOptions: ts.CompilerOptions,
-  env: TypecheckEnv,
-  packageDir: string,
-): Promise<ts.CompilerOptions> {
-  const options = { ...baseOptions };
-  const packageTypes = await getTypesFromPackageJson(packageDir);
-
-  // pnpm environment: search both package-specific node_modules/@types and root node_modules/@types
-  options.typeRoots = [
-    path.join(packageDir, "node_modules", "@types"),
-    path.join(process.cwd(), "node_modules", "@types"),
-  ];
-
-  switch (env) {
-    case "node":
-      options.lib = options.lib?.filter(
-        (lib) => !DOM_LIB_PATTERNS.some((pattern) => lib.toLowerCase().includes(pattern)),
-      );
-      options.types = [...new Set([...packageTypes, "node"])];
-      break;
-    case "browser":
-      options.types = packageTypes.filter((t) => t !== "node");
-      break;
+export function hasAngularCompilerOptions(pkgDir: string): boolean {
+  const tsconfigPath = path.join(pkgDir, "tsconfig.json");
+  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+  if (configFile.error != null) {
+    return false;
   }
-
-  return options;
+  return configFile.config?.angularCompilerOptions != null;
 }
 
 /**
- * Parse root tsconfig
- * @throws If unable to read or parse tsconfig.json
+ * Parse tsconfig.json from the given directory.
  */
-export function parseRootTsconfig(cwd: string): ts.ParsedCommandLine {
-  const tsconfigPath = path.join(cwd, "tsconfig.json");
+export function parseTsconfig(dir: string): ts.ParsedCommandLine {
+  const tsconfigPath = path.join(dir, "tsconfig.json");
   const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-
   if (configFile.error) {
-    const message = ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n");
-    throw new SdError(`Failed to read tsconfig.json: ${message}`);
+    throw new Error(ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"));
   }
-
-  const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
-
+  const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, dir);
   if (parsed.errors.length > 0) {
-    const messages = parsed.errors.map((e) => ts.flattenDiagnosticMessageText(e.messageText, "\n"));
-    throw new SdError(`Failed to parse tsconfig.json: ${messages.join("; ")}`);
+    throw new Error(
+      parsed.errors.map((e) => ts.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n"),
+    );
   }
-
   return parsed;
 }
 
 /**
- * Get list of package source files (based on tsconfig)
+ * Get source files (under src/) from a package, filtered by the parsed tsconfig.
  */
 export function getPackageSourceFiles(
   pkgDir: string,
   parsedConfig: ts.ParsedCommandLine,
 ): string[] {
-  const pkgSrcDir = path.join(pkgDir, "src");
-  return parsedConfig.fileNames.filter((f) => pathx.isChildPath(f, pkgSrcDir));
+  const srcDir = path.join(pkgDir, "src");
+  return parsedConfig.fileNames.filter((f) => pathx.isChildPath(f, srcDir));
 }
 
 /**
- * Get full list of package files (including src + tests)
+ * Get all files (src + tests) from a package, filtered by the parsed tsconfig.
  */
-export function getPackageFiles(pkgDir: string, parsedConfig: ts.ParsedCommandLine): string[] {
-  return parsedConfig.fileNames.filter((f) => {
-    if (!pathx.isChildPath(f, pkgDir)) return false;
-    // Exclude files directly in package root (config files) — treated same as project root files in other tasks
-    const relative = path.relative(pkgDir, f);
-    return path.dirname(relative) !== ".";
-  });
+export function getPackageFiles(
+  pkgDir: string,
+  parsedConfig: ts.ParsedCommandLine,
+): string[] {
+  return parsedConfig.fileNames.filter((f) => pathx.isChildPath(f, pkgDir));
 }

package/src/utils/typecheck-non-package.ts

@@ -0,0 +1,87 @@
+import path from "path";
+import ts from "typescript";
+import { parseTsconfig } from "./tsconfig";
+import { serializeDiagnostic, type SerializedDiagnostic } from "./typecheck-serialization";
+
+export interface NonPackageTypecheckResult {
+  success: boolean;
+  errorCount: number;
+  warningCount: number;
+  diagnostics: SerializedDiagnostic[];
+}
+
+/**
+ * Typecheck non-package files (root-level configs + package root configs).
+ * Extracted from dts.worker.ts non-package mode.
+ *
+ * Non-package files include:
+ * - Root-level files (vitest.config.ts, etc.) — not under packages/
+ * - Package root config files (packages/{pkg}/vitest.config.ts) — depth 2 under packages/
+ * Excludes package source files (packages/{pkg}/src/...)
+ */
+export function typecheckNonPackageFiles(cwd: string): NonPackageTypecheckResult {
+  const parsedConfig = parseTsconfig(cwd);
+  const packagesDir = path.join(cwd, "packages");
+
+  const isNonPackageFile = (fileName: string): boolean => {
+    const normalized = path.resolve(fileName);
+    const normalizedPkgDir = path.resolve(packagesDir);
+
+    // Files outside packages/ directory
+    if (!normalized.startsWith(normalizedPkgDir + path.sep)) return true;
+
+    // Files directly in package root (e.g., packages/{pkg}/file.ts — depth 2)
+    const relative = path.relative(normalizedPkgDir, normalized);
+    return relative.split(path.sep).length === 2;
+  };
+
+  const rootFiles = parsedConfig.fileNames.filter(isNonPackageFile);
+
+  const tsBuildInfoFile = path.join(cwd, ".cache", "typecheck-root.tsbuildinfo");
+  const options: ts.CompilerOptions = {
+    ...parsedConfig.options,
+    sourceMap: false,
+    incremental: true,
+    tsBuildInfoFile,
+    noEmit: true,
+    emitDeclarationOnly: false,
+    declaration: false,
+    declarationMap: false,
+  };
+
+  const host = ts.createIncrementalCompilerHost(options);
+  const program = ts.createIncrementalProgram({
+    rootNames: rootFiles,
+    options,
+    host,
+  });
+
+  program.emit();
+
+  const allDiagnostics = [
+    ...program.getConfigFileParsingDiagnostics(),
+    ...program.getSyntacticDiagnostics(),
+    ...program.getOptionsDiagnostics(),
+    ...program.getGlobalDiagnostics(),
+    ...program.getSemanticDiagnostics(),
+  ];
+
+  const filteredDiagnostics = allDiagnostics.filter(
+    (d) => d.file == null || isNonPackageFile(d.file.fileName),
+  );
+
+  const serializedDiagnostics = filteredDiagnostics.map(serializeDiagnostic);
+  const errorCount = filteredDiagnostics.filter(
+    (d) => d.category === ts.DiagnosticCategory.Error,
+  ).length;
+  const warningCount = filteredDiagnostics.filter(
+    (d) => d.category === ts.DiagnosticCategory.Warning,
+  ).length;
+
+  return {
+    success: errorCount === 0,
+    errorCount,
+    warningCount,
+    diagnostics: serializedDiagnostics,
+  };
+}

package/src/vitest-plugin.ts

@@ -0,0 +1,118 @@
+import type { Plugin } from "vite";
+import path from "path";
+import ts from "typescript";
+import { NgtscProgram, type AngularLibraryHostExtensions } from "./utils/angular-build";
+import { compileScssString, compileScssFile } from "./utils/scss-compiler";
+
+export interface AngularVitestPluginOptions {
+  /** Angular 패키지의 tsconfig.json 절대 경로 */
+  tsconfig: string;
+  /** monorepo 워크스페이스 루트 경로. 미지정 시 tsconfig 기준 상위 2단계를 사용한다 */
+  cwd?: string;
+}
+
+export function angularVitestPlugin(options: AngularVitestPluginOptions): Plugin {
+  const compiledFiles = new Map<string, { js: string; map?: string }>();
+
+  return {
+    name: "angular-vitest",
+    enforce: "pre",
+
+    async buildStart() {
+      const configFile = ts.readConfigFile(options.tsconfig, ts.sys.readFile);
+      const parsedConfig = ts.parseJsonConfigFileContent(
+        configFile.config,
+        ts.sys,
+        ts.sys.resolvePath(options.tsconfig + "/.."),
+      );
+
+      // src/ 파일만 필터 (테스트 제외)
+      const sourceFiles = parsedConfig.fileNames.filter((f) => f.includes("/src/"));
+
+      const compilerOptions: ts.CompilerOptions = {
+        ...parsedConfig.options,
+        noEmit: false,
+        declaration: false,
+        declarationMap: false,
+        sourceMap: false,
+        inlineSourceMap: true,
+        inlineSources: true,
+      };
+
+      const host = ts.createCompilerHost(compilerOptions);
+
+      // AngularLibraryHostExtensions duck-typing
+      const hostExt = host as ts.CompilerHost & AngularLibraryHostExtensions;
+      hostExt.readResource = (fileName: string) => ts.sys.readFile(fileName) ?? "";
+
+      const pkgDir = ts.sys.resolvePath(options.tsconfig + "/..");
+      const cwd = options.cwd ?? ts.sys.resolvePath(pkgDir + "/../..");
+      const loadPaths = [
+        path.join(pkgDir, "scss"),
+        path.join(cwd, "node_modules"),
+      ];
+
+      hostExt.transformResource = (data, context) => {
+        if (context.type !== "style") return Promise.resolve(null);
+
+        if (context.resourceFile != null && context.resourceFile.endsWith(".scss")) {
+          const result = compileScssFile(context.resourceFile, loadPaths);
+          return Promise.resolve({ content: result.css });
+        }
+
+        if (context.resourceFile != null) {
+          // .css 등 비-SCSS 파일 -> null 반환 (readResource가 처리)
+          return Promise.resolve(null);
+        }
+
+        // 인라인 스타일 -- SCSS로 시도, 순수 CSS면 그대로 통과
+        const result = compileScssString(data, context.containingFile, loadPaths);
+        return Promise.resolve({ content: result.css });
+      };
+
+      // writeFile 인터셉트 — 메모리에 수집 (inline sourcemap이므로 .js만 수집)
+      let currentSourcePath = "";
+      host.writeFile = (fileName: string, data: string) => {
+        if (fileName.endsWith(".js")) {
+          compiledFiles.set(currentSourcePath, { js: data });
+        }
+      };
+
+      // NgtscProgram 생성 + AOT 컴파일
+      const program = new NgtscProgram(
+        sourceFiles,
+        compilerOptions,
+        hostExt,
+      );
+      await program.compiler.analyzeAsync();
+      const { transformers } = program.compiler.prepareEmit();
+      const tsProgram = program.getTsProgram();
+
+      // per-file emit
+      for (const filePath of sourceFiles) {
+        const sf = tsProgram.getSourceFile(filePath);
+        if (sf == null) continue;
+
+        currentSourcePath = normalizePath(filePath);
+        tsProgram.emit(sf, host.writeFile, undefined, false, transformers);
+      }
+    },
+
+    transform(_code: string, id: string) {
+      if (!id.endsWith(".ts") || id.includes("node_modules")) {
+        return undefined;
+      }
+
+      const compiled = compiledFiles.get(normalizePath(id));
+      if (compiled == null) {
+        return undefined;
+      }
+
+      return { code: compiled.js, map: compiled.map };
+    },
+  };
+}
+
+function normalizePath(p: string): string {
+  return p.replace(/\\/g, "/");
+}

package/src/workers/library-build.worker.ts

@@ -0,0 +1,153 @@
+import path from "path";
+import { createWorker, FsWatcher } from "@simplysm/core-node";
+import { err as errNs } from "@simplysm/core-common";
+import { consola } from "consola";
+import type { SdBuildPackageConfig } from "../sd-config.types";
+import type { BuildOutput } from "../engines/types";
+import type { SerializedDiagnostic } from "../utils/typecheck-serialization";
+import { runTscPackageBuild } from "../utils/tsc-build";
+import { collectDeps } from "../utils/package-utils";
+import { registerCleanupHandlers, createOnceGuard, applyDebugLevel } from "../utils/worker-utils";
+
+applyDebugLevel();
+
+//#region Types
+
+export interface LibraryBuildInfo {
+  name: string;
+  config: SdBuildPackageConfig;
+  cwd: string;
+  pkgDir: string;
+  output: BuildOutput;
+}
+
+export interface LibraryBuildResult {
+  js: { success: boolean; errors?: string[]; warnings?: string[] };
+  dts: { success: boolean; errors?: string[]; diagnostics: SerializedDiagnostic[] };
+}
+
+export interface CombinedBuildEvent {
+  js: { success: boolean; errors?: string[]; warnings?: string[] };
+  dts: { success: boolean; errors?: string[] };
+}
+
+export interface LibraryBuildWorkerEvents extends Record<string, unknown> {
+  buildStart: Record<string, never>;
+  build: CombinedBuildEvent;
+  error: { message: string };
+}
+
+//#endregion
+
+//#region Resource Management
+
+const logger = consola.withTag("sd:cli:library-build:worker");
+
+let fsWatcher: FsWatcher | undefined;
+
+async function cleanup(): Promise<void> {
+  const watcherToClose = fsWatcher;
+  fsWatcher = undefined;
+  await watcherToClose?.close();
+}
+
+registerCleanupHandlers(cleanup, logger);
+
+//#endregion
+
+//#region build (one-time build)
+
+function build(info: LibraryBuildInfo): LibraryBuildResult {
+  const tscResult = runTscPackageBuild({
+    pkgDir: info.pkgDir,
+    cwd: info.cwd,
+    output: info.output,
+  });
+
+  return {
+    js: {
+      success: tscResult.success,
+      errors: tscResult.errors,
+      warnings: undefined,
+    },
+    dts: {
+      success: tscResult.success,
+      errors: tscResult.errors,
+      diagnostics: tscResult.diagnostics,
+    },
+  };
+}
+
+//#endregion
+
+//#region startWatch (watch mode)
+
+const guardStartWatch = createOnceGuard("startWatch");
+
+// Mutable state for watch mode
+let watchInfo: LibraryBuildInfo | undefined;
+
+function rebuildAll(): CombinedBuildEvent {
+  const info = watchInfo!;
+
+  const tscResult = runTscPackageBuild({
+    pkgDir: info.pkgDir,
+    cwd: info.cwd,
+    output: info.output,
+  });
+
+  return {
+    js: { success: tscResult.success, errors: tscResult.errors },
+    dts: { success: tscResult.success, errors: tscResult.errors },
+  };
+}
+
+async function startWatch(info: LibraryBuildInfo): Promise<void> {
+  guardStartWatch();
+  watchInfo = info;
+
+  try {
+    // Initial build
+    const initialResult = rebuildAll();
+    sender.send("build", initialResult);
+
+    // Collect workspace dependency paths
+    const { workspaceDeps } = collectDeps(info.pkgDir, info.cwd);
+
+    // Start FsWatcher — own src/ + workspace deps' src/
+    const watchPaths = [
+      path.join(info.pkgDir, "src", "**", "*.{ts,tsx}"),
+      ...workspaceDeps.map((d) => path.join(info.cwd, "packages", d, "src", "**", "*.{ts,tsx}")),
+    ];
+    fsWatcher = await FsWatcher.watch(watchPaths);
+
+    fsWatcher.onChange({ delay: 300 }, () => {
+      try {
+        sender.send("buildStart", {});
+        const result = rebuildAll();
+        sender.send("build", result);
+      } catch (err) {
+        sender.send("error", { message: errNs.message(err) });
+      }
+    });
+  } catch (err) {
+    sender.send("error", { message: errNs.message(err) });
+  }
+}
+
+async function stopWatch(): Promise<void> {
+  await cleanup();
+}
+
+//#endregion
+
+const sender = createWorker<
+  { build: typeof build; startWatch: typeof startWatch; stopWatch: typeof stopWatch },
+  LibraryBuildWorkerEvents
+>({
+  build,
+  startWatch,
+  stopWatch,
+});
+
+export default sender;