@simplysm/sd-cli 14.0.15 → 14.0.17

package/tests/utils/esbuild-config.spec.ts

@@ -162,7 +162,7 @@ describe("writeChangedOutputFiles", () => {
   it("skips writing when transformed content matches existing file", async () => {
     vi.mocked(mockFs.readFile).mockResolvedValue('import { bar } from "./bar.js";' as any);
 
-    const hasChanges = await writeChangedOutputFiles([
+    await writeChangedOutputFiles([
       {
         path: "/pkg/dist/foo.js",
         text: 'import { bar } from "./bar";',
@@ -170,13 +170,12 @@ describe("writeChangedOutputFiles", () => {
     ] as any);
 
     expect(mockFs.writeFile).not.toHaveBeenCalled();
-    expect(hasChanges).toBe(false);
   });
 
-  it("writes file and returns true when content changed", async () => {
+  it("writes file when content changed", async () => {
     vi.mocked(mockFs.readFile).mockResolvedValue('import { old } from "./old.js";' as any);
 
-    const hasChanges = await writeChangedOutputFiles([
+    await writeChangedOutputFiles([
       {
         path: "/pkg/dist/foo.js",
         text: 'import { bar } from "./bar";',
@@ -184,13 +183,12 @@ describe("writeChangedOutputFiles", () => {
     ] as any);
 
     expect(mockFs.writeFile).toHaveBeenCalled();
-    expect(hasChanges).toBe(true);
   });
 
   it("writes new file when existing file does not exist", async () => {
     vi.mocked(mockFs.readFile).mockRejectedValue(new Error("ENOENT"));
 
-    const hasChanges = await writeChangedOutputFiles([
+    await writeChangedOutputFiles([
       {
         path: "/pkg/dist/foo.js",
         text: 'const x = 1;',
@@ -199,7 +197,6 @@ describe("writeChangedOutputFiles", () => {
 
     expect(mockFs.mkdir).toHaveBeenCalledWith(path.dirname("/pkg/dist/foo.js"), { recursive: true });
     expect(mockFs.writeFile).toHaveBeenCalledWith("/pkg/dist/foo.js", "const x = 1;");
-    expect(hasChanges).toBe(true);
   });
 
   it("does not transform non-.js files", async () => {

package/tests/utils/{ngtsc-build-core-angular-compiler.spec.ts → ngtsc-build-core.spec.ts}

@@ -1,9 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import ts from "typescript";
 
-// --- Unit Tests: runNgtscBuild가 AngularCompiler를 사용하는지 검증 ---
+// --- Mock: AngularCompiler를 사용하는지 검증 ---
 
-// Mock AngularCompiler to verify runNgtscBuild uses it
 const mockInitialize = vi.fn().mockResolvedValue({ affectedFiles: new Set() });
 const mockCollectDiagnostics = vi.fn().mockReturnValue([]);
 const mockEmitAffectedFiles = vi.fn().mockReturnValue([]);
@@ -42,7 +41,6 @@ vi.mock("../../src/utils/angular-compiler", () => {
   };
 });
 
-// Mock tsconfig module to avoid filesystem access
 vi.mock("../../src/utils/tsconfig", () => ({
   parseTsconfig: vi.fn().mockReturnValue({
     options: {
@@ -60,7 +58,6 @@ vi.mock("../../src/utils/tsconfig", () => ({
   getCompilerOptionsForEnv: vi.fn().mockImplementation((opts: ts.CompilerOptions) => opts),
 }));
 
-// Mock NgtscProgram should NOT be used after migration
 const ngtscProgramSpy = vi.fn();
 vi.mock("../../src/utils/angular-build", () => {
   class NgtscProgram {
@@ -90,11 +87,18 @@ vi.mock("../../src/utils/angular-build", () => {
   };
 });
 
-const { runNgtscBuild } = await import("../../src/utils/ngtsc-build-core");
+const {
+  runNgtscBuild,
+  createLibraryTransformStylesheet,
+  buildScssLoadPaths,
+} = await import("../../src/utils/ngtsc-build-core");
+
+import { resolve, join } from "node:path";
 
-// Use real workspace root so ts.readConfigFile can find tsconfig.json
-const { resolve } = await import("node:path");
 const workspaceRoot = resolve(import.meta.dirname, "../../../..");
+const angularPkgDir = resolve(workspaceRoot, "packages/angular");
+
+// ─── runNgtscBuild가 AngularCompiler를 사용한다 ───
 
 describe("runNgtscBuild가 AngularCompiler를 사용한다", () => {
   beforeEach(() => {
@@ -111,14 +115,10 @@ describe("runNgtscBuild가 AngularCompiler를 사용한다", () => {
       output: { js: true, dts: true },
     });
 
-    // AngularCompiler가 생성됨
     expect(angularCompilerConstructorSpy).toHaveBeenCalledTimes(1);
-    // initialize()가 호출됨
     expect(mockInitialize).toHaveBeenCalledTimes(1);
-    // NgtscProgram이 직접 생성되지 않음
     expect(ngtscProgramSpy).not.toHaveBeenCalled();
 
-    // 결과 구조 확인
     expect(result.build).toHaveProperty("success");
     expect(result.build).toHaveProperty("diagnostics");
   });
@@ -170,3 +170,134 @@ describe("runNgtscBuild가 AngularCompiler를 사용한다", () => {
     expect(options.compilerOptions.noEmit).toBe(true);
   });
 });
+
+// ─── createLibraryTransformStylesheet ───
+
+describe("createLibraryTransformStylesheet", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("외부 .scss 파일이면 compileScssFile로 CSS를 반환하고 의존성을 기록한다", async () => {
+    const loadPaths = ["/pkg/scss", "/cwd/node_modules"];
+    const scssErrors: string[] = [];
+    const scssDependencies = new Map<string, Set<string>>();
+
+    const transform = createLibraryTransformStylesheet(loadPaths, scssErrors, scssDependencies);
+
+    const result = await transform(
+      ".host { color: red; }",
+      "/project/src/app.component.ts",
+      "/project/src/app.component.scss",
+    );
+
+    expect(scssErrors.length).toBeGreaterThan(0);
+    expect(result).toBe("/* SCSS compilation error */");
+  });
+
+  it("외부 .css 파일이면 null을 반환한다", async () => {
+    const loadPaths = ["/pkg/scss"];
+    const scssErrors: string[] = [];
+    const scssDependencies = new Map<string, Set<string>>();
+
+    const transform = createLibraryTransformStylesheet(loadPaths, scssErrors, scssDependencies);
+
+    const result = await transform(
+      ".host { color: red; }",
+      "/project/src/app.component.ts",
+      "/project/src/app.component.css",
+    );
+
+    expect(result).toBeNull();
+    expect(scssErrors.length).toBe(0);
+  });
+
+  it("인라인 SCSS(stylesheetFile 미지정)이면 compileScssString으로 CSS를 반환한다", async () => {
+    const loadPaths: string[] = [];
+    const scssErrors: string[] = [];
+    const scssDependencies = new Map<string, Set<string>>();
+
+    const transform = createLibraryTransformStylesheet(loadPaths, scssErrors, scssDependencies);
+
+    const result = await transform(
+      ".host { color: red; }",
+      "/project/src/app.component.ts",
+      undefined,
+    );
+
+    expect(typeof result).toBe("string");
+    expect(result).toContain("color: red");
+    expect(scssErrors.length).toBe(0);
+  });
+
+  it("SCSS 컴파일 에러 시 scssErrors에 에러를 추가하고 에러 주석을 반환한다", async () => {
+    const loadPaths: string[] = [];
+    const scssErrors: string[] = [];
+    const scssDependencies = new Map<string, Set<string>>();
+
+    const transform = createLibraryTransformStylesheet(loadPaths, scssErrors, scssDependencies);
+
+    const result = await transform(
+      "",
+      "/project/src/broken.component.ts",
+      "/nonexistent/path/broken.scss",
+    );
+
+    expect(result).toBe("/* SCSS compilation error */");
+    expect(scssErrors.length).toBeGreaterThan(0);
+    expect(scssErrors[0]).toContain("SCSS error");
+  });
+
+  it("SCSS 의존성이 scssDependencies에 기록된다", async () => {
+    const loadPaths: string[] = [];
+    const scssErrors: string[] = [];
+    const scssDependencies = new Map<string, Set<string>>();
+
+    const transform = createLibraryTransformStylesheet(loadPaths, scssErrors, scssDependencies);
+
+    await transform(
+      ".host { color: red; }",
+      "/project/src/app.component.ts",
+      undefined,
+    );
+
+    expect(scssDependencies.has("/project/src/app.component.ts")).toBe(true);
+  });
+});
+
+// ─── buildScssLoadPaths ───
+
+describe("buildScssLoadPaths", () => {
+  it("returns [pkgDir/scss, cwd/node_modules] for given NgtscBuildInfo", () => {
+    const info = {
+      name: "angular",
+      cwd: workspaceRoot,
+      pkgDir: angularPkgDir,
+      output: { js: true, dts: false },
+    };
+
+    const result = buildScssLoadPaths(info);
+
+    expect(result).toEqual([
+      join(angularPkgDir, "scss"),
+      join(workspaceRoot, "node_modules"),
+    ]);
+  });
+
+  it("uses cwd from info to construct node_modules path", () => {
+    const customCwd = "/custom/workspace";
+    const customPkgDir = "/custom/workspace/packages/my-pkg";
+
+    const result = buildScssLoadPaths({
+      name: "test",
+      cwd: customCwd,
+      pkgDir: customPkgDir,
+      output: { js: true, dts: false },
+    });
+
+    expect(result).toEqual([
+      join(customPkgDir, "scss"),
+      join(customCwd, "node_modules"),
+    ]);
+  });
+});

package/tests/utils/orchestrator-utils.spec.ts

@@ -57,7 +57,7 @@ describe("loadAndValidateConfig", () => {
     expect(mocks.loadSdConfig).toHaveBeenCalledWith({
       cwd: "/test",
       dev: false,
-      options: [],
+      opt: [],
     });
     expect(mocks.validateTargets).toHaveBeenCalledWith(
       ["core-common"],
@@ -83,7 +83,7 @@ describe("loadAndValidateConfig", () => {
     expect(mocks.loadSdConfig).toHaveBeenCalledWith({
       cwd: "/test",
       dev: true,
-      options: ["key=value"],
+      opt: ["key=value"],
     });
     expect(mocks.validateTargets).toHaveBeenCalledWith([], config.packages);
     expect(result).toBe(config);

package/tests/utils/sd-config.spec.ts

@@ -22,7 +22,7 @@ vi.mock("jiti", () => ({
 const { loadSdConfig } = await import("../../src/utils/sd-config");
 
 describe("loadSdConfig", () => {
-  const baseParams = { cwd: "/project", dev: true, options: [] as string[] };
+  const baseParams = { cwd: "/project", dev: true, opt: [] as string[] };
 
   beforeEach(() => {
     vi.clearAllMocks();
@@ -73,7 +73,7 @@ describe("loadSdConfig", () => {
     mockExists.mockResolvedValue(true);
     mockJitiImport.mockResolvedValue({ default: configFn });
 
-    const params = { cwd: "/project", dev: true, options: ["key=val"] };
+    const params = { cwd: "/project", dev: true, opt: ["key=val"] };
     await loadSdConfig(params);
 
     expect(configFn).toHaveBeenCalledWith(params);

package/tests/utils/tsc-build.spec.ts

@@ -176,11 +176,12 @@ describe("runTscPackageBuild", () => {
       output: { js: true, dts: true },
     });
 
-    // createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, options, host)
+    // createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, options, host, oldBuilderProgram)
     expect(vi.mocked(tsModule.default.createEmitAndSemanticDiagnosticsBuilderProgram)).toHaveBeenCalledWith(
       [SRC_INDEX, SRC_UTIL],
       expect.any(Object),
       expect.any(Object),
+      undefined,
     );
   });
 
@@ -198,6 +199,7 @@ describe("runTscPackageBuild", () => {
       [SRC_INDEX, SRC_UTIL],
       expect.any(Object),
       expect.any(Object),
+      undefined,
     );
   });
 
@@ -216,6 +218,7 @@ describe("runTscPackageBuild", () => {
       [SRC_INDEX, SRC_UTIL, TEST_INDEX],
       expect.any(Object),
       expect.any(Object),
+      undefined,
     );
   });