@simplysm/sd-cli 14.0.42 → 14.0.44

package/tests/angular/ngtsc-build-core.acc.spec.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import path from "path";
+import type { SideEffectScssEntry, SideEffectScssOptions } from "../../src/angular/ngtsc-build-core";
+
+// Mock fs — filesystem I/O (OS 의존)
+vi.mock("fs", () => ({
+  default: {
+    mkdirSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    existsSync: vi.fn(() => false),
+  },
+}));
+
+// Mock scss-compiler — dart-sass 외부 의존성
+const mockCompileScssFile = vi.fn<(filePath: string, loadPaths: string[]) => { css: string; dependencies: string[] }>()
+  .mockReturnValue({ css: "/* compiled */", dependencies: [] });
+
+vi.mock("../../src/angular/scss-compiler", () => ({
+  compileScssFile: (filePath: string, loadPaths: string[]) => mockCompileScssFile(filePath, loadPaths),
+  compileScssString: vi.fn(() => ({ css: "", dependencies: [] })),
+}));
+
+const { writeEmitResults, compileSideEffectScss } = await import("../../src/angular/ngtsc-build-core");
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockCompileScssFile.mockReturnValue({ css: "/* compiled */", dependencies: [] as string[] });
+});
+
+describe("writeEmitResults — registryReverseIndex", () => {
+  // 테스트용 경로 헬퍼
+  const pkgDir = path.resolve("/test-pkg");
+  const srcFile = path.resolve(pkgDir, "src", "comp.ts");
+  const distDir = path.resolve(pkgDir, "dist");
+
+  function makeEmitResult(jsContent: string, sourceFileName?: string) {
+    // createOutputPathRewriter는 dist/ 하위 파일만 처리하므로 dist/ 경로로 생성
+    return {
+      filename: path.resolve(distDir, "comp.js"),
+      contents: jsContent,
+      sourceFileName,
+    };
+  }
+
+  // Acceptance: registryReverseIndex가 제공되면 O(1) 삭제를 수행한다
+  it("deletes registry entries using reverseIndex and cleans up reverseIndex", () => {
+    const oldScssPath = path.resolve(pkgDir, "src", "old.scss");
+    const registry = new Map<string, SideEffectScssEntry>([
+      [oldScssPath, { scssAbsPath: oldScssPath, cssAbsPath: "/out/old.css", sourceFileName: srcFile }],
+    ]);
+    const registryReverseIndex = new Map<string, Set<string>>([
+      [srcFile, new Set([oldScssPath])],
+    ]);
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      registry,
+      registryReverseIndex,
+    };
+
+    // SCSS import 없는 JS → 삭제만 발생, 등록 없음
+    writeEmitResults([makeEmitResult("export class Comp {}", srcFile)], pkgDir, scss);
+
+    expect(registry.has(oldScssPath)).toBe(false);
+    expect(registryReverseIndex.has(srcFile)).toBe(false);
+  });
+
+  // Acceptance: 삭제 후 새 SCSS import가 있으면 등록하고 reverseIndex도 갱신
+  it("registers new entries and updates reverseIndex after deletion", () => {
+    const oldScssPath = path.resolve(pkgDir, "src", "old.scss");
+    const registry = new Map<string, SideEffectScssEntry>([
+      [oldScssPath, { scssAbsPath: oldScssPath, cssAbsPath: "/out/old.css", sourceFileName: srcFile }],
+    ]);
+    const registryReverseIndex = new Map<string, Set<string>>([
+      [srcFile, new Set([oldScssPath])],
+    ]);
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      registry,
+      registryReverseIndex,
+    };
+
+    // JS with SCSS import → 삭제 + 등록
+    const jsContent = 'import "./button.scss";\nexport class Comp {}';
+    writeEmitResults([makeEmitResult(jsContent, srcFile)], pkgDir, scss);
+
+    // old.scss 삭제됨
+    expect(registry.has(oldScssPath)).toBe(false);
+    // button.scss가 등록됨 (scssAbsPath = path.resolve(srcDir, "./button.scss"))
+    const expectedScssPath = path.resolve(pkgDir, "src", "button.scss");
+    expect(registry.has(expectedScssPath)).toBe(true);
+    // reverseIndex에 새 항목 반영
+    expect(registryReverseIndex.get(srcFile)).toEqual(new Set([expectedScssPath]));
+  });
+
+  // Acceptance: reverseIndex에 없는 sourceFileName이면 삭제 없음
+  it("does not delete when sourceFileName is not in reverseIndex", () => {
+    const otherScssPath = path.resolve(pkgDir, "src", "other.scss");
+    const otherSrcFile = path.resolve(pkgDir, "src", "other.ts");
+    const registry = new Map<string, SideEffectScssEntry>([
+      [otherScssPath, { scssAbsPath: otherScssPath, cssAbsPath: "/out/other.css", sourceFileName: otherSrcFile }],
+    ]);
+    const registryReverseIndex = new Map<string, Set<string>>([
+      [otherSrcFile, new Set([otherScssPath])],
+    ]);
+    const scss: SideEffectScssOptions = {
+      loadPaths: [],
+      scssErrors: [],
+      scssDependencies: new Map(),
+      registry,
+      registryReverseIndex,
+    };
+
+    // srcFile (comp.ts)에 대한 emit → other.ts의 항목은 건드리지 않음
+    writeEmitResults([makeEmitResult("export class Comp {}", srcFile)], pkgDir, scss);
+
+    expect(registry.has(otherScssPath)).toBe(true);
+    expect(registryReverseIndex.has(otherSrcFile)).toBe(true);
+  });
+});
+
+describe("compileSideEffectScss — incremental compilation", () => {
+  function makeEntry(scssAbsPath: string, sourceFileName: string): SideEffectScssEntry {
+    return {
+      scssAbsPath,
+      cssAbsPath: scssAbsPath.replace(/\.scss$/, ".css"),
+      sourceFileName,
+    };
+  }
+
+  // Acceptance: changedScssFiles 미제공 시 전체 재컴파일
+  it("compiles all entries when changedScssFiles is not provided", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+      ["/src/dialog.scss", makeEntry("/src/dialog.scss", "/src/comp.ts")],
+      ["/src/card.scss", makeEntry("/src/card.scss", "/src/other.ts")],
+    ]);
+
+    compileSideEffectScss(registry, [], [], new Map());
+
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(3);
+  });
+
+  // Acceptance: 변경된 SCSS 파일만 재컴파일 (직접 히트)
+  it("only compiles entries whose scssAbsPath is in changedScssFiles", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+      ["/src/dialog.scss", makeEntry("/src/dialog.scss", "/src/other.ts")],
+    ]);
+    const changedScssFiles = new Set(["/src/button.scss"]);
+    const sideEffectScssDeps = new Map<string, Set<string>>();
+
+    compileSideEffectScss(registry, [], [], new Map(), changedScssFiles, sideEffectScssDeps);
+
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(1);
+    expect(mockCompileScssFile).toHaveBeenCalledWith("/src/button.scss", []);
+  });
+
+  // Acceptance: 의존성이 변경된 SCSS도 재컴파일
+  it("recompiles entries whose dependency is in changedScssFiles", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+    ]);
+    const changedScssFiles = new Set(["/src/shared.scss"]);
+    // button.scss의 이전 컴파일에서 shared.scss가 의존성이었음
+    const sideEffectScssDeps = new Map<string, Set<string>>([
+      ["/src/button.scss", new Set(["/src/shared.scss"])],
+    ]);
+
+    compileSideEffectScss(registry, [], [], new Map(), changedScssFiles, sideEffectScssDeps);
+
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(1);
+    expect(mockCompileScssFile).toHaveBeenCalledWith("/src/button.scss", []);
+  });
+
+  // Acceptance: 영향받지 않는 항목은 건너뜀
+  it("skips entries not affected by changedScssFiles", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+      ["/src/dialog.scss", makeEntry("/src/dialog.scss", "/src/other.ts")],
+    ]);
+    const changedScssFiles = new Set(["/src/shared.scss"]);
+    const sideEffectScssDeps = new Map<string, Set<string>>([
+      ["/src/button.scss", new Set(["/src/shared.scss"])],
+      ["/src/dialog.scss", new Set(["/src/theme.scss"])],
+    ]);
+
+    compileSideEffectScss(registry, [], [], new Map(), changedScssFiles, sideEffectScssDeps);
+
+    // button.scss만 재컴파일 (shared.scss가 의존성), dialog.scss는 건너뜀
+    expect(mockCompileScssFile).toHaveBeenCalledTimes(1);
+    expect(mockCompileScssFile).toHaveBeenCalledWith("/src/button.scss", []);
+  });
+
+  // Unit: 컴파일 후 sideEffectScssDeps가 갱신됨
+  it("updates sideEffectScssDeps after compilation", () => {
+    const registry = new Map<string, SideEffectScssEntry>([
+      ["/src/button.scss", makeEntry("/src/button.scss", "/src/comp.ts")],
+    ]);
+    mockCompileScssFile.mockReturnValue({ css: "/* ok */", dependencies: ["/src/new-dep.scss"] });
+    const sideEffectScssDeps = new Map<string, Set<string>>();
+
+    compileSideEffectScss(registry, [], [], new Map(), undefined, sideEffectScssDeps);
+
+    expect(sideEffectScssDeps.get("/src/button.scss")).toEqual(new Set(["/src/new-dep.scss"]));
+  });
+});

package/tests/angular/ngtsc-build-core.spec.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { buildReverseDeps } from "../../src/angular/ngtsc-build-core";
+
+describe("buildReverseDeps", () => {
+  // Acceptance: 정방향 맵에서 역방향 인덱스를 구축한다
+  it("builds reverse index from forward deps with multiple owners sharing a dep", () => {
+    const forward = new Map<string, ReadonlySet<string>>([
+      ["comp.ts", new Set(["shared.scss", "theme.scss"])],
+      ["dialog.ts", new Set(["shared.scss"])],
+    ]);
+
+    const reverse = buildReverseDeps(forward);
+
+    expect(reverse.get("shared.scss")).toEqual(new Set(["comp.ts", "dialog.ts"]));
+    expect(reverse.get("theme.scss")).toEqual(new Set(["comp.ts"]));
+    expect(reverse.size).toBe(2);
+  });
+
+  // Acceptance: 빈 맵이면 역방향 맵도 비어있다
+  it("returns empty map for empty input", () => {
+    const reverse = buildReverseDeps(new Map());
+
+    expect(reverse.size).toBe(0);
+  });
+
+  // Unit: 하나의 소유자가 여러 의존성을 가진 경우
+  it("maps each dep to its single owner", () => {
+    const forward = new Map<string, ReadonlySet<string>>([
+      ["comp.ts", new Set(["a.scss", "b.scss", "c.scss"])],
+    ]);
+
+    const reverse = buildReverseDeps(forward);
+
+    expect(reverse.size).toBe(3);
+    expect(reverse.get("a.scss")).toEqual(new Set(["comp.ts"]));
+    expect(reverse.get("b.scss")).toEqual(new Set(["comp.ts"]));
+    expect(reverse.get("c.scss")).toEqual(new Set(["comp.ts"]));
+  });
+
+  // Unit: 의존성이 빈 Set인 소유자는 역방향 맵에 영향 없음
+  it("ignores owners with empty dep sets", () => {
+    const forward = new Map<string, ReadonlySet<string>>([
+      ["comp.ts", new Set<string>()],
+      ["dialog.ts", new Set(["shared.scss"])],
+    ]);
+
+    const reverse = buildReverseDeps(forward);
+
+    expect(reverse.size).toBe(1);
+    expect(reverse.get("shared.scss")).toEqual(new Set(["dialog.ts"]));
+  });
+});

package/tests/angular/vite-angular-plugin-sdtscompiler.verify.md

@@ -0,0 +1,13 @@
+# vite-angular-plugin SdTsCompiler 전환 — LLM 검증
+
+## 검증 항목
+
+- [x] AngularBuildPipeline import 제거: `vite-angular-plugin.ts:6` — `SdTsCompiler` import으로 교체, `AngularBuildPipeline` 미사용
+- [x] SdTsCompiler 인스턴스 생성: `:69-81` — `new SdTsCompiler({ pkgDir, cwd, output: { js: true, dts: false }, sourceFileCache, compilerOptionsTransformer })` 올바르게 구성
+- [x] compileAsync 호출: `:90` — `sdTsCompiler.compileAsync(modifiedFiles)` 호출, modifiedFiles는 pendingWatchChanges에서 수집
+- [x] emitResults → emittedFilesBySource 매핑: `:93-95` — `pathx.posix(sourceFileName)` 키로 저장
+- [x] transform 훅: `:107-124` — `emittedFilesBySource.get(normalizedId)` 조회, 인라인 소스맵 분리 유지
+- [x] buildEnd에서 sdTsCompiler 참조 해제: `:127` — `sdTsCompiler = undefined`
+- [x] watch 모드 증분 빌드: `:61-66` — pendingWatchChanges를 modifiedFiles로 전달, compileAsync에서 증분 처리
+- [x] 이미 초기화됐고 변경 없으면 건너뜀: `:84-87` — `emittedFilesBySource.size > 0 && modifiedFiles == null` 조건
+- [x] 기존 테스트 회귀: vite-angular-plugin.spec.ts 6개, vite-angular-plugin-vitest.spec.ts + legacy-watch.spec.ts 5개 모두 통과

package/tests/angular/web-worker-transformer.spec.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi } from "vitest";
+import ts from "typescript";
+
+const { createWorkerTransformer } = await import(
+  "../../src/angular/web-worker-transformer.js"
+);
+
+//#region 헬퍼
+
+/**
+ * TypeScript 소스 코드에 transformer를 적용하고 결과 코드를 반환한다.
+ */
+function transformCode(
+  code: string,
+  fileProcessor: (workerFile: string, containingFile: string) => string,
+  fileName = "test.ts",
+): string {
+  const sourceFile = ts.createSourceFile(fileName, code, ts.ScriptTarget.ES2022, true);
+  const transformer = createWorkerTransformer(fileProcessor);
+  const result = ts.transform(sourceFile, [transformer]);
+  const printer = ts.createPrinter();
+  const output = printer.printFile(result.transformed[0]);
+  result.dispose();
+  return output;
+}
+
+//#endregion
+
+describe("createWorkerTransformer", () => {
+  // Acceptance: Worker 표준 패턴을 감지하여 번들된 경로로 치환한다
+  it("Worker 표준 패턴 — URL 치환 + { type: 'module' } 자동 추가", () => {
+    const fileProcessor = vi.fn().mockReturnValue("worker-ABCD1234.js");
+    const code = `const w = new Worker(new URL('./my-worker.ts', import.meta.url));`;
+
+    const output = transformCode(code, fileProcessor);
+
+    expect(fileProcessor).toHaveBeenCalledWith("./my-worker.ts", "test.ts");
+    expect(output).toContain('"worker-ABCD1234.js"');
+    expect(output).toContain('type');
+    expect(output).toContain('"module"');
+    expect(output).not.toContain("./my-worker.ts");
+  });
+
+  // Acceptance: SharedWorker도 동일하게 처리한다
+  it("SharedWorker도 동일하게 변환한다", () => {
+    const fileProcessor = vi.fn().mockReturnValue("worker-SHARED01.js");
+    const code = `const sw = new SharedWorker(new URL('./shared.ts', import.meta.url));`;
+
+    const output = transformCode(code, fileProcessor);
+
+    expect(fileProcessor).toHaveBeenCalledWith("./shared.ts", "test.ts");
+    expect(output).toContain('"worker-SHARED01.js"');
+  });
+
+  // Acceptance: Worker의 기존 options 인자가 있으면 유지한다
+  it("기존 options 인자가 있으면 유지한다", () => {
+    const fileProcessor = vi.fn().mockReturnValue("worker-OPT00001.js");
+    const code = `const w = new Worker(new URL('./w.ts', import.meta.url), { name: 'test' });`;
+
+    const output = transformCode(code, fileProcessor);
+
+    expect(output).toContain('"worker-OPT00001.js"');
+    expect(output).toContain("name");
+    // { type: 'module' } 자동 추가 없이 기존 options가 유지됨
+    expect(output).not.toMatch(/type.*module.*name/);
+  });
+});
+
+describe("createWorkerTransformer — 변환하지 않는 케이스", () => {
+  const noopProcessor = vi.fn().mockReturnValue("should-not-appear.js");
+
+  // URL 패턴이 아닌 Worker 생성
+  it("URL 패턴 없이 문자열 인자만 있으면 변환하지 않는다", () => {
+    const code = `const w = new Worker('./my-worker.ts');`;
+    const output = transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+    expect(output).toContain("./my-worker.ts");
+  });
+
+  // import.meta.url이 아닌 URL
+  it("import.meta.url이 아닌 URL은 변환하지 않는다", () => {
+    const code = `const w = new Worker(new URL('./w.ts', 'http://example.com'));`;
+    const output = transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+    expect(output).toContain("./w.ts");
+  });
+
+  // Worker 인자 없음
+  it("Worker 인자가 없으면 변환하지 않는다", () => {
+    const code = `const w = new Worker();`;
+    transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+  });
+
+  // Worker 인자 3개 이상
+  it("Worker 인자가 3개 이상이면 변환하지 않는다", () => {
+    const code = `const w = new Worker(new URL('./w.ts', import.meta.url), {}, 'extra');`;
+    transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+  });
+
+  // URL 인자가 1개
+  it("URL 인자가 1개면 변환하지 않는다", () => {
+    const code = `const w = new Worker(new URL('./w.ts'));`;
+    transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+  });
+
+  // URL 인자가 3개
+  it("URL 인자가 3개면 변환하지 않는다", () => {
+    const code = `const w = new Worker(new URL('./w.ts', import.meta.url, 'extra'));`;
+    transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+  });
+
+  // 'Worker' 문자열 없으면 skip
+  it("소스에 'Worker' 문자열이 없으면 변환을 건너뛴다", () => {
+    const code = `const x = 1 + 2;`;
+    const output = transformCode(code, noopProcessor);
+
+    expect(noopProcessor).not.toHaveBeenCalled();
+    expect(output).toContain("1 + 2");
+  });
+});
+
+describe("createWorkerTransformer — 추가 경계 케이스", () => {
+  // fileProcessor가 원본과 동일한 경로를 반환하면 변환하지 않는다
+  it("fileProcessor가 원본 경로를 그대로 반환하면 AST를 변경하지 않는다", () => {
+    const fileProcessor = vi.fn().mockReturnValue("./my-worker.ts");
+    const code = `const w = new Worker(new URL('./my-worker.ts', import.meta.url));`;
+
+    const output = transformCode(code, fileProcessor);
+
+    expect(fileProcessor).toHaveBeenCalledWith("./my-worker.ts", "test.ts");
+    // 원본 경로가 그대로 유지 (변환 없음)
+    expect(output).toContain("./my-worker.ts");
+  });
+
+  // 소스에 Worker 문자열은 있지만 new 표현이 아닌 경우
+  it("Worker 문자열이 있지만 new 표현이 아니면 변환하지 않는다", () => {
+    const fileProcessor = vi.fn();
+    const code = `const WorkerName = "test";`;
+
+    transformCode(code, fileProcessor);
+
+    expect(fileProcessor).not.toHaveBeenCalled();
+  });
+});

package/tests/capacitor/capacitor-build.spec.ts

@@ -66,7 +66,7 @@ vi.mock("sharp", () => ({
 
 // consola mock (logger assertion 필요)
 const mockLoggerWarn = vi.fn();
-vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn() } as any);
+vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn(), start: vi.fn() } as any);
 
 //#endregion
 

package/tests/capacitor/capacitor-icon.spec.ts

@@ -66,7 +66,7 @@ vi.mock("sharp", () => ({ default: mockSharp }));
 
 // consola mock (logger assertion 필요)
 const mockLoggerWarn = vi.fn();
-vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn() } as any);
+vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn(), start: vi.fn() } as any);
 
 //#endregion
 

package/tests/capacitor/capacitor-init.spec.ts

@@ -62,7 +62,7 @@ vi.mock("sharp", () => ({
 }));
 
 const mockLoggerWarn = vi.fn();
-vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn() } as any);
+vi.spyOn(consola, "withTag").mockReturnValue({ debug: vi.fn(), warn: mockLoggerWarn, error: vi.fn(), info: vi.fn(), success: vi.fn(), start: vi.fn() } as any);
 
 //#endregion