@simplysm/sd-cli 13.0.100 → 14.0.1

package/src/utils/ngtsc-build-core.ts

@@ -0,0 +1,379 @@
+import path from "path";
+import fs from "fs";
+import ts from "typescript";
+import { err as errNs } from "@simplysm/core-common";
+import type { BuildOutput } from "../engines/types";
+import type { SerializedDiagnostic } from "./typecheck-serialization";
+import { serializeDiagnostic } from "./typecheck-serialization";
+import {
+  parseTsconfig,
+  getPackageSourceFiles,
+} from "./tsconfig";
+import {
+  NgtscProgram,
+  OptimizeFor,
+  type AngularLibraryHostExtensions,
+} from "./angular-build";
+import { createOutputPathRewriter } from "./output-path-rewriter";
+import { compileScssString, compileScssFile } from "./scss-compiler";
+
+//#region Types
+
+export interface NgtscBuildInfo {
+  name: string;
+  cwd: string;
+  pkgDir: string;
+  output: BuildOutput;
+}
+
+export interface NgtscBuildResult {
+  js: { success: boolean; errors?: string[]; warnings?: string[] };
+  dts: { success: boolean; errors?: string[]; diagnostics: SerializedDiagnostic[] };
+}
+
+export interface NgtscCombinedBuildEvent {
+  js: { success: boolean; errors?: string[]; warnings?: string[] };
+  dts: { success: boolean; errors?: string[] };
+}
+
+//#endregion
+
+//#region CompilerOptions helpers
+
+export function buildCompilerOptions(
+  baseOptions: ts.CompilerOptions,
+  pkgDir: string,
+  output: BuildOutput,
+): ts.CompilerOptions {
+  const options: ts.CompilerOptions = {
+    ...baseOptions,
+    sourceMap: false,
+    outDir: path.join(pkgDir, "dist"),
+  };
+
+  if (output.js && output.dts) {
+    options.noEmit = false;
+    options.declaration = true;
+    options.declarationMap = true;
+    options.emitDeclarationOnly = false;
+    options.declarationDir = path.join(pkgDir, "dist");
+  } else if (output.js && !output.dts) {
+    options.noEmit = false;
+    options.declaration = false;
+    options.declarationMap = false;
+    options.emitDeclarationOnly = false;
+  } else if (!output.js && output.dts) {
+    options.noEmit = false;
+    options.declaration = true;
+    options.declarationMap = true;
+    options.emitDeclarationOnly = true;
+    options.declarationDir = path.join(pkgDir, "dist");
+  } else {
+    // both false — typecheck only
+    options.noEmit = true;
+    options.declaration = false;
+    options.declarationMap = false;
+    options.emitDeclarationOnly = false;
+  }
+
+  return options;
+}
+
+//#endregion
+
+//#region SCSS loadPaths helper
+
+export function buildScssLoadPaths(info: NgtscBuildInfo): string[] {
+  return [
+    path.join(info.pkgDir, "scss"),
+    path.join(info.cwd, "node_modules"),
+  ];
+}
+
+//#endregion
+
+//#region NgtscProgram build core
+
+interface NgtscProgramWithHostResult {
+  program: NgtscProgram;
+  host: ts.CompilerHost;
+  scssErrors: string[];
+  scssDependencies: Map<string, Set<string>>;
+}
+
+function createNgtscProgramWithHost(
+  rootNames: string[],
+  compilerOptions: ts.CompilerOptions,
+  info: NgtscBuildInfo,
+  output: BuildOutput,
+  oldProgram?: NgtscProgram,
+  modifiedResourceFiles?: Set<string>,
+): NgtscProgramWithHostResult {
+  const pkgDir = info.pkgDir;
+  const host = ts.createCompilerHost(compilerOptions);
+  const scssErrors: string[] = [];
+  const scssDependencies = new Map<string, Set<string>>();
+
+  const loadPaths = buildScssLoadPaths(info);
+
+  // AngularLibraryHostExtensions duck-typing
+  const hostExt = host as ts.CompilerHost & AngularLibraryHostExtensions;
+  hostExt.readResource = (fileName: string) => ts.sys.readFile(fileName) ?? "";
+
+  hostExt.transformResource = (data, context) => {
+    if (context.type !== "style") return Promise.resolve(null);
+
+    try {
+      if (context.resourceFile != null && context.resourceFile.endsWith(".scss")) {
+        const result = compileScssFile(context.resourceFile, loadPaths);
+        trackDeps(scssDependencies, context.containingFile, result.dependencies);
+        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);
+      trackDeps(scssDependencies, context.containingFile, result.dependencies);
+      return Promise.resolve({ content: result.css });
+    } catch (err) {
+      scssErrors.push(formatScssError(err, context.containingFile));
+      return Promise.resolve({ content: "/* SCSS compilation error */" });
+    }
+  };
+
+  if (modifiedResourceFiles != null) {
+    hostExt.getModifiedResourceFiles = () => modifiedResourceFiles;
+  }
+
+  // Output path rewriting
+  if (output.js || output.dts) {
+    const rewritePath = createOutputPathRewriter(pkgDir);
+    const originalWriteFile = host.writeFile;
+    host.writeFile = (fileName, content, writeByteOrderMark, onError, sourceFiles, data) => {
+      const result = rewritePath(fileName, content);
+      if (result != null) {
+        originalWriteFile(result[0], result[1], writeByteOrderMark, onError, sourceFiles, data);
+      }
+    };
+  }
+
+  const program = new NgtscProgram(rootNames, compilerOptions, hostExt, oldProgram);
+
+  return { program, host, scssErrors, scssDependencies };
+}
+
+function trackDeps(
+  depsMap: Map<string, Set<string>>,
+  containingFile: string,
+  dependencies: string[],
+): void {
+  let deps = depsMap.get(containingFile);
+  if (deps == null) {
+    deps = new Set<string>();
+    depsMap.set(containingFile, deps);
+  }
+  for (const dep of dependencies) {
+    deps.add(dep);
+  }
+}
+
+function formatScssError(err: unknown, containingFile: string): string {
+  const message = errNs.message(err);
+  return `SCSS error in ${containingFile}: ${message}`;
+}
+
+//#region Global SCSS
+
+export function compileGlobalScss(
+  pkgDir: string,
+  loadPaths: string[],
+): string[] {
+  const stylesPath = path.join(pkgDir, "scss", "styles.scss");
+  if (!fs.existsSync(stylesPath)) return [];
+
+  const errors: string[] = [];
+  try {
+    const result = compileScssFile(stylesPath, loadPaths);
+    const distDir = path.join(pkgDir, "dist");
+    fs.mkdirSync(distDir, { recursive: true });
+    fs.writeFileSync(path.join(distDir, "styles.css"), result.css, "utf-8");
+  } catch (err) {
+    errors.push(`Global SCSS error: ${errNs.message(err)}`);
+  }
+  return errors;
+}
+
+//#endregion
+
+function collectDiagnostics(
+  program: NgtscProgram,
+  tsProgram: ts.Program,
+  pkgSrcDir: string,
+): { serialized: SerializedDiagnostic[]; errorCount: number; errors: string[] } {
+  const allDiagnostics: ts.Diagnostic[] = [
+    ...tsProgram.getSyntacticDiagnostics(),
+    ...tsProgram.getOptionsDiagnostics(),
+    ...tsProgram.getGlobalDiagnostics(),
+    ...tsProgram.getSemanticDiagnostics(),
+  ];
+
+  // Angular-specific diagnostics
+  for (const sf of tsProgram.getSourceFiles()) {
+    const ngDiags = program.compiler.getDiagnosticsForFile(sf, OptimizeFor.WholeProgram);
+    allDiagnostics.push(...ngDiags);
+  }
+
+  // Filter diagnostics to package source files
+  const normalizedSrcDir = pkgSrcDir.replace(/\\/g, "/");
+  const filteredDiagnostics = allDiagnostics.filter(
+    (d) => d.file == null || d.file.fileName.includes(normalizedSrcDir),
+  );
+
+  const serialized = filteredDiagnostics.map(serializeDiagnostic);
+  const errorCount = filteredDiagnostics.filter(
+    (d) => d.category === ts.DiagnosticCategory.Error,
+  ).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 { serialized, errorCount, errors };
+}
+
+function emitFiles(
+  program: NgtscProgram,
+  tsProgram: ts.Program,
+  pkgSrcDir: string,
+  output: BuildOutput,
+): void {
+  const { transformers } = program.compiler.prepareEmit();
+  const normalizedSrcDir = pkgSrcDir.replace(/\\/g, "/");
+
+  for (const sf of tsProgram.getSourceFiles()) {
+    if (program.compiler.ignoreForEmit.has(sf)) continue;
+    // Only emit files from this package's src directory
+    if (!sf.fileName.includes(normalizedSrcDir)) continue;
+
+    tsProgram.emit(sf, undefined, undefined, output.dts && !output.js, transformers);
+  }
+}
+
+/**
+ * Run a full NgtscProgram build (parse, analyze, diagnostics, emit)
+ */
+export async function runNgtscBuild(info: NgtscBuildInfo): Promise<NgtscBuildResult> {
+  try {
+    const parsedConfig = parseTsconfig(info.pkgDir);
+    const sourceFiles = getPackageSourceFiles(info.pkgDir, parsedConfig);
+    const compilerOptions = buildCompilerOptions(parsedConfig.options, info.pkgDir, info.output);
+    const pkgSrcDir = path.join(info.pkgDir, "src");
+
+    const { program, scssErrors } = createNgtscProgramWithHost(
+      sourceFiles,
+      compilerOptions,
+      info,
+      info.output,
+    );
+
+    // AOT analysis
+    await program.compiler.analyzeAsync();
+
+    // Collect diagnostics
+    const tsProgram = program.getTsProgram();
+    const { serialized, errorCount, errors } = collectDiagnostics(program, tsProgram, pkgSrcDir);
+
+    // Emit if needed
+    if (info.output.js || info.output.dts) {
+      emitFiles(program, tsProgram, pkgSrcDir, info.output);
+    }
+
+    // Global SCSS compilation
+    const globalScssErrors = compileGlobalScss(info.pkgDir, buildScssLoadPaths(info));
+
+    const allErrors = [...errors, ...scssErrors, ...globalScssErrors];
+
+    return {
+      js: {
+        success: true,
+        errors: undefined,
+        warnings: undefined,
+      },
+      dts: {
+        success: errorCount === 0 && scssErrors.length === 0 && globalScssErrors.length === 0,
+        errors: allErrors.length > 0 ? allErrors : undefined,
+        diagnostics: serialized,
+      },
+    };
+  } catch (err) {
+    const message = errNs.message(err);
+    return {
+      js: { success: false, errors: [message] },
+      dts: { success: false, errors: [message], diagnostics: [] },
+    };
+  }
+}
+
+/**
+ * Run NgtscProgram incremental rebuild (for watch mode)
+ */
+export async function runNgtscRebuild(
+  info: NgtscBuildInfo,
+  oldProg?: NgtscProgram,
+  modifiedResourceFiles?: Set<string>,
+): Promise<{
+  result: NgtscCombinedBuildEvent;
+  program: NgtscProgram;
+  scssDependencies: Map<string, Set<string>>;
+}> {
+  const parsedConfig = parseTsconfig(info.pkgDir);
+  const sourceFiles = getPackageSourceFiles(info.pkgDir, parsedConfig);
+  const compilerOptions = buildCompilerOptions(parsedConfig.options, info.pkgDir, info.output);
+  const pkgSrcDir = path.join(info.pkgDir, "src");
+
+  const { program, scssErrors, scssDependencies } = createNgtscProgramWithHost(
+    sourceFiles,
+    compilerOptions,
+    info,
+    info.output,
+    oldProg,
+    modifiedResourceFiles,
+  );
+
+  await program.compiler.analyzeAsync();
+
+  const tsProgram = program.getTsProgram();
+  const { errorCount, errors } = collectDiagnostics(program, tsProgram, pkgSrcDir);
+
+  if (info.output.js || info.output.dts) {
+    emitFiles(program, tsProgram, pkgSrcDir, info.output);
+  }
+
+  // Global SCSS compilation
+  const globalScssErrors = compileGlobalScss(info.pkgDir, buildScssLoadPaths(info));
+
+  const allErrors = [...errors, ...scssErrors, ...globalScssErrors];
+
+  return {
+    result: {
+      js: { success: true },
+      dts: {
+        success: errorCount === 0 && scssErrors.length === 0 && globalScssErrors.length === 0,
+        errors: allErrors.length > 0 ? allErrors : undefined,
+      },
+    },
+    program,
+    scssDependencies,
+  };
+}

package/src/utils/output-path-rewriter.ts

@@ -0,0 +1,82 @@
+import path from "path";
+import { pathx } from "@simplysm/core-node";
+
+/**
+ * Add .js extension to extensionless relative import/export paths in ESM output.
+ *
+ * Matches: from "./foo", import("./bar"), from "../baz"
+ * Skips: bare specifiers ("lodash"), paths already ending with known extensions (.js, .json, .css, etc.)
+ */
+export function addJsExtensionToImports(text: string): string {
+  return text.replace(
+    /((?:from|import)\s*(?:\(\s*)?["'])(\.\.?\/[^"']*?)(["'](?:\s*\))?)/g,
+    (_match, prefix: string, importPath: string, suffix: string) => {
+      if (/\.(js|mjs|cjs|json|css|wasm|node)$/i.test(importPath)) return _match;
+      return `${prefix}${importPath}.js${suffix}`;
+    },
+  );
+}
+
+/**
+ * Adjust sources path in .d.ts.map file to new location
+ */
+export function adjustMapSources(content: string, originalDir: string, newDir: string): string {
+  if (originalDir === newDir) return content;
+  try {
+    const map = JSON.parse(content) as { sources?: string[] };
+    if (Array.isArray(map.sources)) {
+      map.sources = map.sources.map((source) => {
+        const absoluteSource = path.resolve(originalDir, source);
+        return path.relative(newDir, absoluteSource);
+      });
+    }
+    return JSON.stringify(map);
+  } catch {
+    return content;
+  }
+}
+
+/**
+ * Create path rewriter function for NgtscProgram output files (.js, .d.ts, .d.ts.map)
+ *
+ * TypeScript/NgtscProgram includes other package sources referenced via path alias (@simplysm/*)
+ * in rootDir calculation, so output is generated as nested structure dist/{pkgName}/src/...
+ * The returned function rewrites only this package's output to flat structure (dist/...)
+ * and ignores output from other packages.
+ *
+ * @returns (fileName, content) => [newPath, newContent] | null (null to skip writing)
+ */
+export function createOutputPathRewriter(
+  pkgDir: string,
+): (fileName: string, content: string) => [string, string] | null {
+  const pkgName = path.basename(pkgDir);
+  const distDir = pathx.norm(path.join(pkgDir, "dist"));
+  const distPrefix = distDir + path.sep;
+  // Nested structure prefix for this package: dist/{pkgName}/src/
+  const ownNestedPrefix = pathx.norm(path.join(distDir, pkgName, "src")) + path.sep;
+
+  return (fileName, content) => {
+    fileName = pathx.norm(fileName);
+
+    if (!fileName.startsWith(distPrefix)) return null;
+
+    if (fileName.startsWith(ownNestedPrefix)) {
+      // Rewrite nested path to flat: dist/{pkgName}/src/... → dist/...
+      const flatPath = path.join(distDir, fileName.slice(ownNestedPrefix.length));
+      if (fileName.endsWith(".d.ts.map") || fileName.endsWith(".js.map")) {
+        content = adjustMapSources(content, path.dirname(fileName), path.dirname(flatPath));
+      }
+      return [flatPath, content];
+    }
+
+    // Nested output from other packages (dist/{otherPkg}/src/...) → ignore
+    const relFromDist = fileName.slice(distPrefix.length);
+    const segments = relFromDist.split(path.sep);
+    if (segments.length >= 3 && segments[1] === "src") {
+      return null;
+    }
+
+    // Already flat structure (package with no dependencies) → output as is
+    return [fileName, content];
+  };
+}

package/src/utils/package-utils.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import fs from "fs";
 import { consola } from "consola";
+import { SdError } from "@simplysm/core-common";
 import type { SdPackageConfig } from "../sd-config.types";
 
 const logger = consola.withTag("sd:cli:package-utils");
@@ -91,6 +92,25 @@ export function collectDeps(
   return { workspaceDeps, replaceDeps };
 }
 
+/**
+ * Validate that all target names exist in the sdConfig packages.
+ * Throws SdError if any unknown targets are found.
+ * Does nothing when targets is empty.
+ * @param targets - package name list to validate
+ * @param packages - sdConfig.packages object
+ */
+export function validateTargets(
+  targets: string[],
+  packages: Record<string, unknown>,
+): void {
+  if (targets.length === 0) return;
+  const packageNames = Object.keys(packages);
+  const unknown = targets.filter((t) => !packageNames.includes(t));
+  if (unknown.length > 0) {
+    throw new SdError(`Unknown target: ${unknown.join(", ")}`);
+  }
+}
+
 /**
  * Filter packages config by targets (excluding scripts target)
  * @param packages Package config map

package/src/utils/scss-compiler.ts

@@ -0,0 +1,58 @@
+import * as sass from "sass";
+import { pathToFileURL } from "url";
+
+//#region Types
+
+export interface ScssCompileResult {
+  css: string;
+  /** 컴파일에 참여한 의존 파일 목록 (loadedUrls -> 절대 경로) */
+  dependencies: string[];
+}
+
+//#endregion
+
+//#region Private helpers
+
+function extractDependencies(loadedUrls: URL[]): string[] {
+  return loadedUrls
+    .filter((url) => url.protocol === "file:")
+    .map((url) => url.pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+}
+
+//#endregion
+
+//#region Public API
+
+/** 인라인 SCSS 문자열을 CSS로 컴파일한다 */
+export function compileScssString(
+  source: string,
+  containingFile: string,
+  loadPaths: string[],
+): ScssCompileResult {
+  const result = sass.compileString(source, {
+    url: pathToFileURL(containingFile),
+    loadPaths,
+    silenceDeprecations: ["color-functions", "global-builtin", "import", "legacy-js-api"],
+  });
+  return {
+    css: result.css,
+    dependencies: extractDependencies(result.loadedUrls),
+  };
+}
+
+/** 외부 SCSS 파일을 CSS로 컴파일한다 */
+export function compileScssFile(
+  filePath: string,
+  loadPaths: string[],
+): ScssCompileResult {
+  const result = sass.compile(filePath, {
+    loadPaths,
+    silenceDeprecations: ["color-functions", "global-builtin", "import", "legacy-js-api"],
+  });
+  return {
+    css: result.css,
+    dependencies: extractDependencies(result.loadedUrls),
+  };
+}
+
+//#endregion