@simplysm/sd-cli 14.0.29 → 14.0.32

package/tests/workers/build-change-filter.acc.spec.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { consola } from "consola";
+import { hasFileAddOrRemove, shouldSkipRebuild } from "../../src/workers/build-change-filter";
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("hasFileAddOrRemove + shouldSkipRebuild integration", () => {
+  const logger = consola.withTag("test");
+
+  // Scenario: 관련 없는 파일 변경은 리빌드를 건너뛴다
+  it("skips rebuild when changed files are not in source file paths", () => {
+    const changes = [{ event: "change", path: "c.ts" }];
+    const lastSourceFilePaths = new Set(["a.ts", "b.ts"]);
+
+    const addOrRemove = hasFileAddOrRemove(changes);
+    const skip = shouldSkipRebuild(
+      changes.map((c) => c.path),
+      addOrRemove,
+      lastSourceFilePaths,
+      logger,
+    );
+
+    expect(addOrRemove).toBe(false);
+    expect(skip).toBe(true);
+  });
+
+  // Scenario: 관련 있는 파일 변경은 리빌드를 수행한다
+  it("does not skip rebuild when changed files are in source file paths", () => {
+    const changes = [{ event: "change", path: "a.ts" }];
+    const lastSourceFilePaths = new Set(["a.ts", "b.ts"]);
+
+    const addOrRemove = hasFileAddOrRemove(changes);
+    const skip = shouldSkipRebuild(
+      changes.map((c) => c.path),
+      addOrRemove,
+      lastSourceFilePaths,
+      logger,
+    );
+
+    expect(addOrRemove).toBe(false);
+    expect(skip).toBe(false);
+  });
+
+  // Scenario: 파일 추가/삭제가 있으면 항상 리빌드를 수행한다
+  it("does not skip rebuild when files are added", () => {
+    const changes = [{ event: "add", path: "d.ts" }];
+    const lastSourceFilePaths = new Set(["a.ts", "b.ts"]);
+
+    const addOrRemove = hasFileAddOrRemove(changes);
+    const skip = shouldSkipRebuild(
+      changes.map((c) => c.path),
+      addOrRemove,
+      lastSourceFilePaths,
+      logger,
+    );
+
+    expect(addOrRemove).toBe(true);
+    expect(skip).toBe(false);
+  });
+
+  // Scenario: lastSourceFilePaths가 없으면 항상 리빌드를 수행한다
+  it("does not skip rebuild when lastSourceFilePaths is undefined", () => {
+    const changes = [{ event: "change", path: "c.ts" }];
+
+    const addOrRemove = hasFileAddOrRemove(changes);
+    const skip = shouldSkipRebuild(
+      changes.map((c) => c.path),
+      addOrRemove,
+      undefined,
+      logger,
+    );
+
+    expect(addOrRemove).toBe(false);
+    expect(skip).toBe(false);
+  });
+});

package/tests/workers/build-change-filter.spec.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi } from "vitest";
+import { consola } from "consola";
+import { hasFileAddOrRemove, shouldSkipRebuild } from "../../src/workers/build-change-filter";
+
+describe("hasFileAddOrRemove", () => {
+  it("returns false when only change events", () => {
+    expect(hasFileAddOrRemove([{ event: "change", path: "a.ts" }])).toBe(false);
+  });
+
+  it("returns true when add event exists", () => {
+    expect(hasFileAddOrRemove([{ event: "add", path: "a.ts" }])).toBe(true);
+  });
+
+  it("returns true when unlink event exists", () => {
+    expect(hasFileAddOrRemove([{ event: "unlink", path: "a.ts" }])).toBe(true);
+  });
+
+  it("returns false for empty changes", () => {
+    expect(hasFileAddOrRemove([])).toBe(false);
+  });
+});
+
+describe("shouldSkipRebuild", () => {
+  const logger = consola.withTag("test");
+
+  it("logs debug message when skipping rebuild", () => {
+    const debugSpy = vi.spyOn(logger, "debug");
+    shouldSkipRebuild(["x.ts"], false, new Set(["a.ts", "b.ts"]), logger);
+    expect(debugSpy).toHaveBeenCalledWith(
+      "변경된 파일이 빌드에 포함되지 않아 리빌드 건너뜀",
+    );
+  });
+
+  it("accepts Iterable<string> (Set) as filePaths", () => {
+    const filePaths = new Set(["c.ts"]);
+    const result = shouldSkipRebuild(filePaths, false, new Set(["a.ts"]), logger);
+    expect(result).toBe(true);
+  });
+});

package/tests/workers/build-watch-paths-library.verify.md

@@ -0,0 +1,10 @@
+# library-build watchPaths 동일성 — LLM 검증
+
+## 검증 항목
+
+- [x] buildWatchPaths 호출 인자가 기존 코드와 동등: `srcGlobs: ["*.ts"]`, `replaceDeps: info.replaceDeps` — 기존 `pathx.posixResolve(info.pkgDir, "src", "**", "*.ts")` 패턴과 동일한 경로 생성 확인
+- [x] workspace deps 경로 생성이 동일: 기존 `workspaceDeps.map((d) => pathx.posixResolve(info.cwd, "packages", d, "src", "**", "*.ts"))` → buildWatchPaths 내부에서 동일하게 `pathx.posixResolve(cwd, "packages", d)` + `src/**/*.ts` 생성
+- [x] replaceDeps dist 경로가 cwd와 pkgDir 양쪽에서 생성됨: buildWatchPaths 내부에서 `pathx.posixResolve(cwd, "node_modules", ...pkg.split("/"), "dist", "**", "*.{js,mjs,cjs}")` 및 pkgDir 경로 동일하게 생성
+- [x] collectDeps import 제거됨: library-build.worker.ts에서 collectDeps가 더 이상 직접 import되지 않음 — buildWatchPaths가 내부에서 호출
+- [x] 변경 필터링 동작 동일: 기존 `hasFileAddOrRemove` 인라인 로직 + `lastSourceFilePaths` 교차가 `shouldSkipRebuild(changes.map(c => c.path), hasFileAddOrRemove(changes), lastSourceFilePaths, logger)`로 동일하게 대체됨
+- [x] 기존 테스트(library-build-worker.spec.ts) 16건 모두 통과 확인

package/tests/workers/build-watch-paths-ngtsc-server.verify.md

@@ -0,0 +1,12 @@
+# ngtsc-build, server-build watchPaths 적용 — LLM 검증
+
+## 검증 항목
+
+- [x] ngtsc-build watchPaths 동일성: `srcGlobs: ["*.{ts,scss,css}"]`, `extraDirs: [{ dir: "scss", globs: ["*.{scss,css}"] }]` — 기존 코드의 `src/**/*.{ts,scss,css}` + `scss/**/*.{scss,css}` + deps 동일 패턴과 매칭 확인
+- [x] ngtsc-build SCSS 역방향 탐색 유지: `hasFileAddOrRemove` → `hasFileAddOrRemoveFn`으로 변경 후에도 `modifiedFiles` 구성 로직(pipeline.findAffectedByScss)이 그대로 유지됨
+- [x] ngtsc-build `shouldSkipRebuild(modifiedFiles, addOrRemove, ...)`: SCSS 역방향 탐색 결과가 포함된 `modifiedFiles` Set을 Iterable로 전달하여 정확한 필터링 수행
+- [x] server-build watchPaths 동일성: `srcGlobs: ["*"]` — 기존 `src/**/*` 패턴과 동일
+- [x] server-build metafile 기반 필터링 유지: `hasFileAddOrRemoveFn(changes)` → `addOrRemove` 변수명으로 변경 외에 metafile 기반 로직(L444-470) 무변경
+- [x] server-build esbuild context 재생성 로직 유지: `if (addOrRemove)` 블록 내 context 재생성 로직이 기존과 동일
+- [x] collectDeps import 제거: ngtsc-build, server-build 모두에서 collectDeps 직접 import 제거됨 — buildWatchPaths가 내부에서 호출
+- [x] 기존 테스트 94건 모두 통과 확인

package/tests/workers/build-watch-paths.acc.spec.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// collectDeps는 파일 시스템에 의존하므로 모킹
+vi.mock("../../src/deps/replace-deps/collect-deps", () => ({
+  collectDeps: vi.fn(),
+}));
+
+const { collectDeps } = await import("../../src/deps/replace-deps/collect-deps");
+const { buildWatchPaths } = await import("../../src/workers/build-watch-paths");
+
+const mockCollectDeps = vi.mocked(collectDeps);
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("buildWatchPaths", () => {
+  // Scenario: library-build의 감시 경로가 공통 함수로 생성된다
+  it("generates watchPaths for library-build pattern (srcGlobs=['*.ts'])", () => {
+    mockCollectDeps.mockReturnValue({
+      workspaceDeps: ["core-common"],
+      replaceDeps: ["@external/lib"],
+    });
+
+    const result = buildWatchPaths({
+      pkgDir: "/workspace/packages/my-lib",
+      cwd: "/workspace",
+      srcGlobs: ["*.ts"],
+      replaceDeps: { "@external/*": "../external" },
+    });
+
+    // 자체 src
+    expect(result.watchPaths).toContainEqual(
+      expect.stringContaining("my-lib/src/**/*.ts"),
+    );
+    // workspace dep src
+    expect(result.watchPaths).toContainEqual(
+      expect.stringContaining("core-common/src/**/*.ts"),
+    );
+    // replaceDeps dist (cwd + pkgDir 두 위치)
+    expect(result.watchPaths).toContainEqual(
+      expect.stringContaining("node_modules/@external/lib/dist/**/*.{js,mjs,cjs}"),
+    );
+    // deps 결과 반환
+    expect(result.deps.workspaceDeps).toEqual(["core-common"]);
+    expect(result.deps.replaceDeps).toEqual(["@external/lib"]);
+  });
+
+  // Scenario: ngtsc-build의 감시 경로가 scss 디렉토리를 포함하여 생성된다
+  it("generates watchPaths for ngtsc-build pattern with extraDirs", () => {
+    mockCollectDeps.mockReturnValue({
+      workspaceDeps: ["core-common"],
+      replaceDeps: [],
+    });
+
+    const result = buildWatchPaths({
+      pkgDir: "/workspace/packages/angular-lib",
+      cwd: "/workspace",
+      srcGlobs: ["*.{ts,scss,css}"],
+      extraDirs: [{ dir: "scss", globs: ["*.{scss,css}"] }],
+    });
+
+    // 자체 src + scss
+    expect(result.watchPaths).toContainEqual(
+      expect.stringContaining("angular-lib/src/**/*.{ts,scss,css}"),
+    );
+    expect(result.watchPaths).toContainEqual(
+      expect.stringContaining("angular-lib/scss/**/*.{scss,css}"),
+    );
+    // workspace dep src + scss
+    expect(result.watchPaths).toContainEqual(
+      expect.stringContaining("core-common/src/**/*.{ts,scss,css}"),
+    );
+    expect(result.watchPaths).toContainEqual(
+      expect.stringContaining("core-common/scss/**/*.{scss,css}"),
+    );
+  });
+
+  // Scenario: server-build의 감시 경로가 모든 파일을 대상으로 생성된다
+  it("generates watchPaths for server-build pattern (srcGlobs=['*'])", () => {
+    mockCollectDeps.mockReturnValue({
+      workspaceDeps: ["core-node"],
+      replaceDeps: [],
+    });
+
+    const result = buildWatchPaths({
+      pkgDir: "/workspace/packages/server",
+      cwd: "/workspace",
+      srcGlobs: ["*"],
+    });
+
+    // 자체 src
+    expect(result.watchPaths).toContainEqual(
+      expect.stringContaining("server/src/**/*"),
+    );
+    // workspace dep src
+    expect(result.watchPaths).toContainEqual(
+      expect.stringContaining("core-node/src/**/*"),
+    );
+  });
+});

package/tests/workers/build-watch-paths.spec.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../src/deps/replace-deps/collect-deps", () => ({
+  collectDeps: vi.fn(),
+}));
+
+const { collectDeps } = await import("../../src/deps/replace-deps/collect-deps");
+const { buildWatchPaths } = await import("../../src/workers/build-watch-paths");
+
+const mockCollectDeps = vi.mocked(collectDeps);
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("buildWatchPaths", () => {
+  it("passes replaceDeps config to collectDeps", () => {
+    mockCollectDeps.mockReturnValue({ workspaceDeps: [], replaceDeps: [] });
+
+    const config = { "@ext/*": "../ext" };
+    buildWatchPaths({
+      pkgDir: "/ws/packages/lib",
+      cwd: "/ws",
+      srcGlobs: ["*.ts"],
+      replaceDeps: config,
+    });
+
+    expect(mockCollectDeps).toHaveBeenCalledWith("/ws/packages/lib", "/ws", config);
+  });
+
+  it("includes src globs for pkgDir and each workspace dep", () => {
+    mockCollectDeps.mockReturnValue({
+      workspaceDeps: ["dep-a", "dep-b"],
+      replaceDeps: [],
+    });
+
+    const { watchPaths } = buildWatchPaths({
+      pkgDir: "/ws/packages/lib",
+      cwd: "/ws",
+      srcGlobs: ["*.ts"],
+    });
+
+    // 자체 src
+    expect(watchPaths.some((p) => p.includes("lib/src/**/*.ts"))).toBe(true);
+    // dep-a src
+    expect(watchPaths.some((p) => p.includes("dep-a/src/**/*.ts"))).toBe(true);
+    // dep-b src
+    expect(watchPaths.some((p) => p.includes("dep-b/src/**/*.ts"))).toBe(true);
+  });
+
+  it("includes replaceDeps dist paths from both cwd and pkgDir", () => {
+    mockCollectDeps.mockReturnValue({
+      workspaceDeps: [],
+      replaceDeps: ["@scope/pkg"],
+    });
+
+    const { watchPaths } = buildWatchPaths({
+      pkgDir: "/ws/packages/lib",
+      cwd: "/ws",
+      srcGlobs: ["*.ts"],
+    });
+
+    // cwd node_modules
+    expect(
+      watchPaths.some((p) =>
+        p.includes("/ws/node_modules/@scope/pkg/dist/**/*.{js,mjs,cjs}"),
+      ),
+    ).toBe(true);
+    // pkgDir node_modules
+    expect(
+      watchPaths.some((p) =>
+        p.includes("lib/node_modules/@scope/pkg/dist/**/*.{js,mjs,cjs}"),
+      ),
+    ).toBe(true);
+  });
+
+  it("includes extraDirs globs for each directory", () => {
+    mockCollectDeps.mockReturnValue({
+      workspaceDeps: ["dep-a"],
+      replaceDeps: [],
+    });
+
+    const { watchPaths } = buildWatchPaths({
+      pkgDir: "/ws/packages/lib",
+      cwd: "/ws",
+      srcGlobs: ["*.{ts,scss,css}"],
+      extraDirs: [{ dir: "scss", globs: ["*.{scss,css}"] }],
+    });
+
+    // 자체 scss
+    expect(watchPaths.some((p) => p.includes("lib/scss/**/*.{scss,css}"))).toBe(true);
+    // dep-a scss
+    expect(watchPaths.some((p) => p.includes("dep-a/scss/**/*.{scss,css}"))).toBe(true);
+  });
+
+  it("returns deps result from collectDeps", () => {
+    const depsResult = { workspaceDeps: ["x"], replaceDeps: ["y"] };
+    mockCollectDeps.mockReturnValue(depsResult);
+
+    const { deps } = buildWatchPaths({
+      pkgDir: "/ws/packages/lib",
+      cwd: "/ws",
+      srcGlobs: ["*.ts"],
+    });
+
+    expect(deps).toEqual(depsResult);
+  });
+
+  it("works without extraDirs and replaceDeps", () => {
+    mockCollectDeps.mockReturnValue({ workspaceDeps: [], replaceDeps: [] });
+
+    const { watchPaths } = buildWatchPaths({
+      pkgDir: "/ws/packages/lib",
+      cwd: "/ws",
+      srcGlobs: ["*"],
+    });
+
+    expect(watchPaths).toHaveLength(1);
+    expect(watchPaths[0]).toContain("lib/src/**/*");
+  });
+});

package/tests/workers/client-worker-browser-support.verify.md

@@ -0,0 +1,7 @@
+# browserSupport 전달로 이중 로딩 제거 — LLM 검증
+
+## 검증 항목
+
+- [x] loadSdConfig import 제거: `client.worker.ts` — `import { loadSdConfig }` 라인이 제거됨. `sd-config` 모듈 import 없음
+- [x] resolvePackageInfo가 동기 함수: `client.worker.ts:73` — `function resolvePackageInfo(info: ClientBuildInfo): {` (async 제거, Promise 반환 없음)
+- [x] resolvePackageInfo가 info.browserSupport 사용: `client.worker.ts:83-86` — `info.browserSupport?.legacyModule`, `info.browserSupport?.browserslist`, `info.browserSupport?.postCss?.plugins`

package/tests/workers/client-worker-onend-sync.verify.md

@@ -0,0 +1,7 @@
+# onEnd 비동기 동기화 — LLM 검증
+
+## 검증 항목
+
+- [x] onEnd 타입이 `void | Promise<void>`를 허용: `esbuild-client-config.ts:29` — `onEnd?: (result: esbuild.BuildResult) => void | Promise<void>;`
+- [x] sd-on-end 플러그인이 onEnd 반환값을 return: `esbuild-client-config.ts:220` — `return options.onEnd!(result);`
+- [x] client.worker.ts onEnd가 async 직접 전달 (fire-and-forget 제거): `client.worker.ts:240` — `onEnd: async (result: esbuild.BuildResult) => {` (이전의 `void (async () => { ... })()` 패턴 제거됨)

package/tests/workers/client-worker.acc.spec.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+//#region Mocks
+
+let workerFns: Record<string, (...args: any[]) => any>;
+let mockSend: ReturnType<typeof vi.fn>;
+
+const mockRebuild = vi.fn();
+const mockDispose = vi.fn();
+const mockReadFileSync = vi.fn();
+const mockExistsSync = vi.fn();
+
+vi.mock("@simplysm/core-node", () => ({
+  createWorker: vi.fn((fns: Record<string, Function>) => {
+    workerFns = fns as any;
+    mockSend = vi.fn();
+    return { send: mockSend };
+  }),
+}));
+
+vi.mock("../../src/workers/shared-worker-lifecycle", () => ({
+  setupWorkerLifecycle: vi.fn(() => ({
+    logger: { debug: vi.fn(), error: vi.fn(), warn: vi.fn() },
+    guardStartWatch: vi.fn(),
+  })),
+}));
+
+vi.mock("../../src/esbuild/esbuild-client-config", () => ({
+  createClientEsbuildContext: vi.fn(() =>
+    Promise.resolve({
+      context: { rebuild: mockRebuild, dispose: mockDispose, watch: vi.fn() },
+      sourceFileCache: {},
+    }),
+  ),
+}));
+
+vi.mock("../../src/esbuild/esbuild-index-html", () => ({
+  generateIndexHtml: vi.fn(() =>
+    Promise.resolve({ content: "<html></html>", errors: [], warnings: [] }),
+  ),
+}));
+
+vi.mock("../../src/esbuild/esbuild-pwa", () => ({
+  applyPwa: vi.fn(() => Promise.resolve()),
+  createPwaHtmlTransform: vi.fn(),
+}));
+
+vi.mock("../../src/dev-server/dev-http-server", () => ({
+  createDevHttpServer: vi.fn(),
+}));
+
+vi.mock("../../src/dev-server/hmr-service", () => ({
+  createHmrService: vi.fn(),
+}));
+
+vi.mock("../../src/dev-server/hmr-client-script", () => ({
+  createHmrPostTransform: vi.fn(),
+}));
+
+vi.mock("../../src/utils/copy-public", () => ({
+  copyPublicFiles: vi.fn(() => Promise.resolve()),
+  watchPublicFiles: vi.fn(),
+}));
+
+vi.mock("../../src/utils/sd-config", () => ({
+  loadSdConfig: vi.fn(() =>
+    Promise.resolve({
+      packages: { "my-app": { target: "client", server: "my-server" } },
+    }),
+  ),
+}));
+
+vi.mock("node:fs", () => ({
+  default: {
+    readFileSync: (...args: any[]) => mockReadFileSync(...args),
+    writeFileSync: vi.fn(),
+    existsSync: (...args: any[]) => mockExistsSync(...args),
+    mkdirSync: vi.fn(),
+    rmSync: vi.fn(),
+  },
+}));
+
+//#endregion
+
+// Import triggers createWorker, capturing the functions
+await import("../../src/workers/client.worker");
+
+const baseBuildInfo = {
+  name: "my-app",
+  cwd: "/workspace",
+  pkgDir: "/workspace/packages/my-app",
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockReadFileSync.mockImplementation((filePath: any) => {
+    if (String(filePath).endsWith("package.json")) {
+      return JSON.stringify({ name: "@scope/my-app" });
+    }
+    return "";
+  });
+  mockExistsSync.mockReturnValue(false);
+  mockRebuild.mockResolvedValue({
+    metafile: { outputs: {} },
+    errors: [],
+    warnings: [],
+  });
+});
+
+describe("client.worker build() — Acceptance", () => {
+  // Scenario: esbuild BuildFailure의 상세 에러가 전파된다
+  it("esbuild BuildFailure 발생 시 errors 배열의 text 필드가 반환 errors에 포함된다", async () => {
+    const buildFailure = {
+      message: "Build failed with 2 errors",
+      errors: [
+        { text: "Could not resolve 'missing-module'" },
+        { text: "Syntax error in file.ts" },
+      ],
+    };
+    mockRebuild.mockRejectedValueOnce(buildFailure);
+
+    const result = await workerFns["build"](baseBuildInfo);
+
+    expect(result.success).toBe(false);
+    expect(result.errors).toContain("Could not resolve 'missing-module'");
+    expect(result.errors).toContain("Syntax error in file.ts");
+    // 요약 메시지("Build failed with 2 errors")가 아닌 상세 에러만 포함
+    expect(result.errors).not.toContain("Build failed with 2 errors");
+  });
+
+  // Scenario: 일반 Error 발생 시 기존 폴백이 동작한다
+  it("일반 Error 발생 시 errNs.message()로 추출한 메시지가 errors에 포함된다", async () => {
+    mockRebuild.mockRejectedValueOnce(new Error("Unexpected crash"));
+
+    const result = await workerFns["build"](baseBuildInfo);
+
+    expect(result.success).toBe(false);
+    expect(result.errors).toContain("Unexpected crash");
+  });
+});
+
+describe("client.worker build() — browserSupport 전달", () => {
+  // Scenario: browserSupport가 ClientBuildInfo를 통해 전달된다
+  it("browserSupport 설정이 createClientEsbuildContext에 legacyModule/browserslist/postcssPlugins로 전달된다", async () => {
+    const { createClientEsbuildContext } = await import(
+      "../../src/esbuild/esbuild-client-config"
+    );
+
+    const result = await workerFns["build"]({
+      ...baseBuildInfo,
+      browserSupport: {
+        legacyModule: true,
+        browserslist: "Chrome 61",
+        postCss: { plugins: [["autoprefixer"]] },
+      },
+    });
+
+    expect(result.success).toBe(true);
+    expect(vi.mocked(createClientEsbuildContext)).toHaveBeenCalledWith(
+      expect.objectContaining({
+        legacyModule: true,
+        browserslist: "Chrome 61",
+        postcssPlugins: [["autoprefixer"]],
+      }),
+    );
+  });
+
+  // Scenario: browserSupport 미설정 시 기본값으로 동작한다
+  it("browserSupport 미설정 시 legacyModule=false, browserslist=undefined로 전달된다", async () => {
+    const { createClientEsbuildContext } = await import(
+      "../../src/esbuild/esbuild-client-config"
+    );
+
+    const result = await workerFns["build"](baseBuildInfo);
+
+    expect(result.success).toBe(true);
+    expect(vi.mocked(createClientEsbuildContext)).toHaveBeenCalledWith(
+      expect.objectContaining({
+        legacyModule: false,
+        browserslist: undefined,
+        postcssPlugins: undefined,
+      }),
+    );
+  });
+});