@simplysm/sd-cli 14.0.47 → 14.0.48

package/src/typecheck/typecheck-serialization.ts

@@ -2,38 +2,87 @@ import ts from "typescript";
 import { fsx } from "@simplysm/core-node";
 
 /**
- * Worker로 전달할 수 있는 직렬화된 Diagnostic
+ * DiagnosticMessageChain을 worker 경계로 넘기기 위한 직렬화 구조.
+ * (chain 구조를 그대로 보존하여 formatter가 원본 들여쓰기/순서대로 출력하게 함)
+ */
+export interface SerializedMessageChain {
+  messageText: string;
+  category: number;
+  code: number;
+  next?: SerializedMessageChain[];
+}
+
+/**
+ * Worker로 전달할 수 있는 직렬화된 Diagnostic.
+ * ts.Diagnostic의 모든 사용자 가시 필드(detail/relatedInformation/flag)를 보존한다.
  */
 export interface SerializedDiagnostic {
   category: number;
   code: number;
-  messageText: string;
+  /** messageText는 chain(overload 에러 등)이거나 단순 문자열. chain이면 구조 그대로 보존 */
+  messageText: string | SerializedMessageChain;
   file?: {
     fileName: string;
   };
   start?: number;
   length?: number;
+  relatedInformation?: SerializedDiagnosticRelatedInformation[];
+  /** true 또는 ts가 넘기는 (빈) 객체. formatter가 인식. */
+  reportsUnnecessary?: boolean;
+  reportsDeprecated?: boolean;
+  source?: string;
+}
+
+/** ts.DiagnosticRelatedInformation에 대응. file/start/length와 messageText만 가진 축약 구조. */
+export interface SerializedDiagnosticRelatedInformation {
+  category: number;
+  code: number;
+  messageText: string | SerializedMessageChain;
+  file?: { fileName: string };
+  start?: number;
+  length?: number;
+}
+
+function serializeMessageChain(chain: ts.DiagnosticMessageChain): SerializedMessageChain {
+  return {
+    messageText: chain.messageText,
+    category: chain.category,
+    code: chain.code,
+    next: chain.next?.map(serializeMessageChain),
+  };
+}
+
+function serializeMessageText(
+  messageText: string | ts.DiagnosticMessageChain,
+): string | SerializedMessageChain {
+  if (typeof messageText === "string") return messageText;
+  return serializeMessageChain(messageText);
 }
 
 /**
  * Diagnostic을 직렬화 가능한 형태로 변환한다.
  * (Worker 스레드 간 structured clone 통신을 위해 순환 참조/함수를 제거)
+ * messageText chain, relatedInformation, reportsUnnecessary/Deprecated, source 등 모든 detail 보존.
  */
 export function serializeDiagnostic(diagnostic: ts.Diagnostic): SerializedDiagnostic {
-  // DiagnosticMessageChain인 경우 모든 컨텍스트 정보를 보존하기 위해 전체 체인을 평탄화
-  const messageText = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-
   return {
     category: diagnostic.category,
     code: diagnostic.code,
-    messageText,
-    file: diagnostic.file
-      ? {
-          fileName: diagnostic.file.fileName,
-        }
-      : undefined,
+    messageText: serializeMessageText(diagnostic.messageText),
+    file: diagnostic.file != null ? { fileName: diagnostic.file.fileName } : undefined,
     start: diagnostic.start,
     length: diagnostic.length,
+    relatedInformation: diagnostic.relatedInformation?.map((ri) => ({
+      category: ri.category,
+      code: ri.code,
+      messageText: serializeMessageText(ri.messageText),
+      file: ri.file != null ? { fileName: ri.file.fileName } : undefined,
+      start: ri.start,
+      length: ri.length,
+    })),
+    reportsUnnecessary: diagnostic.reportsUnnecessary != null ? true : undefined,
+    reportsDeprecated: diagnostic.reportsDeprecated != null ? true : undefined,
+    source: diagnostic.source,
   };
 }
 
@@ -53,32 +102,57 @@ function getScriptKind(fileName: string): ts.ScriptKind {
  * @param fileCache - 파일 내용 캐시 (같은 파일의 중복 읽기 방지)
  * @returns 복원된 ts.Diagnostic 객체
  */
+function deserializeMessageChain(chain: SerializedMessageChain): ts.DiagnosticMessageChain {
+  return {
+    messageText: chain.messageText,
+    category: chain.category,
+    code: chain.code,
+    next: chain.next?.map(deserializeMessageChain),
+  };
+}
+
+function deserializeMessageText(
+  messageText: string | SerializedMessageChain,
+): string | ts.DiagnosticMessageChain {
+  if (typeof messageText === "string") return messageText;
+  return deserializeMessageChain(messageText);
+}
+
+function loadFile(fileName: string, fileCache: Map<string, string>): ts.SourceFile {
+  if (!fileCache.has(fileName)) {
+    fileCache.set(fileName, fsx.existsSync(fileName) ? fsx.readSync(fileName) : "");
+  }
+  const content = fileCache.get(fileName)!;
+  const scriptKind = getScriptKind(fileName);
+  return ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, false, scriptKind);
+}
+
 export function deserializeDiagnostic(
   serialized: SerializedDiagnostic,
   fileCache: Map<string, string>,
 ): ts.Diagnostic {
-  let file: ts.SourceFile | undefined;
-  if (serialized.file != null) {
-    const fileName = serialized.file.fileName;
+  const file = serialized.file != null ? loadFile(serialized.file.fileName, fileCache) : undefined;
 
-    // 캐시된 파일 내용 가져오기 (없으면 읽어서 캐시)
-    // 파일이 삭제되었거나 접근 불가능하면 빈 내용으로 처리
-    // (소스 코드 컨텍스트는 표시되지 않지만 진단 메시지는 정상 표시됨)
-    if (!fileCache.has(fileName)) {
-      fileCache.set(fileName, fsx.existsSync(fileName) ? fsx.readSync(fileName) : "");
-    }
-    const content = fileCache.get(fileName)!;
-
-    const scriptKind = getScriptKind(fileName);
-    file = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, false, scriptKind);
-  }
+  const relatedInformation: ts.DiagnosticRelatedInformation[] | undefined =
+    serialized.relatedInformation?.map((ri) => ({
+      category: ri.category,
+      code: ri.code,
+      messageText: deserializeMessageText(ri.messageText),
+      file: ri.file != null ? loadFile(ri.file.fileName, fileCache) : undefined,
+      start: ri.start,
+      length: ri.length,
+    }));
 
   return {
     category: serialized.category,
     code: serialized.code,
-    messageText: serialized.messageText,
+    messageText: deserializeMessageText(serialized.messageText),
     file,
     start: serialized.start,
     length: serialized.length,
+    relatedInformation,
+    reportsUnnecessary: serialized.reportsUnnecessary === true ? {} : undefined,
+    reportsDeprecated: serialized.reportsDeprecated === true ? {} : undefined,
+    source: serialized.source,
   };
 }

package/src/utils/output-utils.ts

@@ -1,8 +1,8 @@
 import { formatMessagesSync, type PartialMessage } from "esbuild";
-import { consola } from "consola";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type { BuildResult } from "../runtime/ResultCollector";
 
-const logger = consola.withTag("sd:cli:output");
+const logger = createLazyLogger("sd:cli:output");
 
 /**
  * esbuild Message 배열을 포맷된 문자열 배열로 변환한다.

package/src/utils/package-classify.ts

@@ -1,6 +1,6 @@
 import path from "path";
-import { consola } from "consola";
 import { pathx } from "@simplysm/core-node";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type {
   BuildTarget,
   SdBuildPackageConfig,
@@ -10,7 +10,7 @@ import type {
   SdServerPackageConfig,
 } from "../sd-config.types";
 
-const logger = consola.withTag("sd:cli:package-classify");
+const logger = createLazyLogger("sd:cli:package-classify");
 
 /**
  * 패키지 config를 순회하며 null 필터링 + target 필터링을 수행한다.

package/src/utils/package-utils.ts

@@ -1,14 +1,14 @@
 import path from "path";
 import fs from "fs";
-import { consola } from "consola";
 import { SdError } from "@simplysm/core-common";
 import { pathx } from "@simplysm/core-node";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type {
   SdBuildPackageConfig,
   SdPackageConfig,
 } from "../sd-config.types";
 
-const logger = consola.withTag("sd:cli:package-utils");
+const logger = createLazyLogger("sd:cli:package-utils");
 
 /**
  * import.meta.dirname에서 위로 탐색하여 package.json을 찾고 패키지 루트를 반환한다.

package/src/utils/sd-config.ts

@@ -1,10 +1,10 @@
 import { createJiti } from "jiti";
 import { SdError } from "@simplysm/core-common";
 import { fsx, pathx } from "@simplysm/core-node";
-import { consola } from "consola";
+import { createLazyLogger } from "../runtime/lazy-logger";
 import type { SdConfig, SdConfigParams } from "../sd-config.types";
 
-const logger = consola.withTag("sd:cli:sd-config");
+const logger = createLazyLogger("sd:cli:sd-config");
 
 /**
  * sd.config.ts를 로드한다.

package/src/utils/tsconfig.ts

@@ -2,9 +2,9 @@ import path from "path";
 import fs from "fs";
 import ts from "typescript";
 import { pathx } from "@simplysm/core-node";
-import { consola } from "consola";
+import { createLazyLogger } from "../runtime/lazy-logger";
 
-const logger = consola.withTag("sd:cli:tsconfig");
+const logger = createLazyLogger("sd:cli:tsconfig");
 
 //#region TypecheckEnv
 
@@ -110,10 +110,9 @@ export function getPackageSourceFiles(
   const srcDir = path.join(pkgDir, "src");
   const files = parsedConfig.fileNames.filter((f) => {
     if (pathx.isChildPath(f, srcDir)) return true;
-    if (f.endsWith(".fixture.ts")) return true;
     return false;
   });
-  logger.debug(`소스 파일 필터링: ${parsedConfig.fileNames.length}개 중 ${files.length}개 (src/ + fixtures)`);
+  logger.debug(`소스 파일 필터링: ${parsedConfig.fileNames.length}개 중 ${files.length}개 (src/ only)`);
   return files;
 }
 

package/tests/esbuild/esbuild-worker-plugin.spec.ts

@@ -476,6 +476,14 @@ const x = 1;`,
 
     expect(matches).toHaveLength(0);
   });
+
+  it("래퍼 함수를 통한 Worker 생성은 탐지하지 않는다", () => {
+    const matches = findWorkerPatterns(
+      `const w = createBrowserWorker(new URL("./worker.js", import.meta.url), { type: "module" });`,
+    );
+
+    expect(matches).toHaveLength(0);
+  });
 });
 
 describe("transformWorkerPatterns — TypeScript 파일 처리", () => {

package/tests/utils/replace-deps-watch.acc.spec.ts

@@ -134,4 +134,89 @@ describe("watchReplaceDeps onChanged 콜백", () => {
     // 콜백 호출 대기
     await changedPromise;
   }, 10_000);
+
+  it("동일 source를 참조하는 복수 entry가 있으면 모든 target에 복사된다", async () => {
+    // 추가 target 디렉토리 생성 (@test/pkgB)
+    const targetDirB = path.join(tmpDir, "project", "node_modules", "@test", "pkgB", "src");
+    await fs.promises.mkdir(targetDirB, { recursive: true });
+    await fs.promises.writeFile(path.join(targetDirB, "index.ts"), "export const a = 1;");
+
+    const projectRoot = path.join(tmpDir, "project");
+    const sourcePath = path.join(tmpDir, "source-pkg");
+
+    // 두 패턴이 동일 sourcePath를 참조
+    const replaceDeps = {
+      "@test/pkg": sourcePath,
+      "@test/pkgB": sourcePath,
+    };
+
+    let callCount = 0;
+    watchResult = await watchReplaceDeps(projectRoot, replaceDeps, {
+      onChanged: () => {
+        callCount++;
+      },
+    });
+
+    // 소스 파일 변경
+    await fs.promises.writeFile(
+      path.join(sourcePath, "src", "index.ts"),
+      "export const a = 9;",
+    );
+
+    // 배칭 + 복사 완료 대기
+    await new Promise((r) => setTimeout(r, 1500));
+
+    // 두 target 모두 업데이트
+    const targetAContent = await fs.promises.readFile(
+      path.join(tmpDir, "project", "node_modules", "@test", "pkg", "src", "index.ts"),
+      "utf-8",
+    );
+    const targetBContent = await fs.promises.readFile(
+      path.join(targetDirB, "index.ts"),
+      "utf-8",
+    );
+    expect(targetAContent).toBe("export const a = 9;");
+    expect(targetBContent).toBe("export const a = 9;");
+
+    // 동일 source의 중복 watchPath는 하나로 통합되므로 이벤트가 1회만 배칭됨 → onChanged 1회
+    expect(callCount).toBe(1);
+  }, 10_000);
+
+  it("소스 파일이 삭제되면 대상 파일도 삭제된다", async () => {
+    const projectRoot = path.join(tmpDir, "project");
+    const sourcePath = path.join(tmpDir, "source-pkg");
+    const replaceDeps = { "@test/pkg": sourcePath };
+
+    let resolveChanged: () => void;
+    const changedPromise = new Promise<void>((resolve) => {
+      resolveChanged = resolve;
+    });
+
+    watchResult = await watchReplaceDeps(projectRoot, replaceDeps, {
+      onChanged: () => {
+        resolveChanged();
+      },
+    });
+
+    const destPath = path.join(
+      tmpDir, "project", "node_modules", "@test", "pkg", "src", "index.ts",
+    );
+
+    // 삭제 전 target 파일 존재 확인
+    await expect(fs.promises.access(destPath)).resolves.toBeUndefined();
+
+    // 소스 삭제
+    await fs.promises.unlink(path.join(sourcePath, "src", "index.ts"));
+
+    await changedPromise;
+
+    // 삭제 반영까지 여유 대기
+    await new Promise((r) => setTimeout(r, 500));
+
+    // target도 삭제됨
+    const targetExists = await fs.promises
+      .access(destPath)
+      .then(() => true, () => false);
+    expect(targetExists).toBe(false);
+  }, 10_000);
 });

package/tests/utils/replace-deps-watch.spec.ts

@@ -1,7 +1,8 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import { consola } from "consola";
 import { watchReplaceDeps } from "../../src/deps/replace-deps/replace-deps";
 import type { WatchReplaceDepResult } from "../../src/deps/replace-deps/replace-deps";
 
@@ -12,10 +13,28 @@ import type { WatchReplaceDepResult } from "../../src/deps/replace-deps/replace-
 describe("watchReplaceDeps onChanged", () => {
   let tmpDir: string;
   let watchResult: WatchReplaceDepResult | undefined;
+  let mockLogger: {
+    warn: ReturnType<typeof vi.fn>;
+    error: ReturnType<typeof vi.fn>;
+    info: ReturnType<typeof vi.fn>;
+    start: ReturnType<typeof vi.fn>;
+    success: ReturnType<typeof vi.fn>;
+    debug: ReturnType<typeof vi.fn>;
+  };
 
   beforeEach(async () => {
     tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "sd-replace-deps-unit-"));
 
+    mockLogger = {
+      warn: vi.fn(),
+      error: vi.fn(),
+      info: vi.fn(),
+      start: vi.fn(),
+      success: vi.fn(),
+      debug: vi.fn(),
+    };
+    vi.spyOn(consola, "withTag").mockReturnValue(mockLogger as any);
+
     // 소스 패키지 생성
     const sourcePkg = path.join(tmpDir, "source-pkg");
     await fs.promises.mkdir(sourcePkg, { recursive: true });
@@ -43,6 +62,7 @@ describe("watchReplaceDeps onChanged", () => {
     watchResult?.dispose();
     watchResult = undefined;
     await fs.promises.rm(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
   });
 
   it("복수 파일 변경 시 300ms 배칭 후 onChanged가 한 번 호출된다", async () => {
@@ -131,6 +151,58 @@ describe("watchReplaceDeps onChanged", () => {
     await changedPromise;
   }, 10_000);
 
+  it("nested source 경로는 longest-prefix로 소속이 결정된다", async () => {
+    // sourceOuter: tmpDir/outer-pkg
+    // sourceInner: tmpDir/outer-pkg/inner-pkg (outer의 하위)
+    const outerPkg = path.join(tmpDir, "outer-pkg");
+    await fs.promises.mkdir(path.join(outerPkg, "src"), { recursive: true });
+    await fs.promises.writeFile(
+      path.join(outerPkg, "package.json"),
+      JSON.stringify({ name: "@test/outer", files: ["src"] }),
+    );
+    await fs.promises.writeFile(path.join(outerPkg, "src", "o.ts"), "o");
+
+    const innerPkg = path.join(outerPkg, "inner-pkg");
+    await fs.promises.mkdir(path.join(innerPkg, "src"), { recursive: true });
+    await fs.promises.writeFile(
+      path.join(innerPkg, "package.json"),
+      JSON.stringify({ name: "@test/inner", files: ["src"] }),
+    );
+    await fs.promises.writeFile(path.join(innerPkg, "src", "i.ts"), "i");
+
+    // target들
+    const outerTarget = path.join(
+      tmpDir, "project", "node_modules", "@test", "outer", "src",
+    );
+    const innerTarget = path.join(
+      tmpDir, "project", "node_modules", "@test", "inner", "src",
+    );
+    await fs.promises.mkdir(outerTarget, { recursive: true });
+    await fs.promises.mkdir(innerTarget, { recursive: true });
+    await fs.promises.writeFile(path.join(outerTarget, "o.ts"), "o");
+    await fs.promises.writeFile(path.join(innerTarget, "i.ts"), "i");
+
+    const projectRoot = path.join(tmpDir, "project");
+
+    watchResult = await watchReplaceDeps(
+      projectRoot,
+      { "@test/outer": outerPkg, "@test/inner": innerPkg },
+    );
+
+    // inner 파일 변경 — longest-prefix로 inner source에만 매칭되어야 함
+    await fs.promises.writeFile(path.join(innerPkg, "src", "i.ts"), "i2");
+    await new Promise((r) => setTimeout(r, 1500));
+
+    const innerCopied = await fs.promises.readFile(path.join(innerTarget, "i.ts"), "utf-8");
+    expect(innerCopied).toBe("i2");
+
+    // outer target에는 i.ts가 복사되지 않아야 함 (잘못된 매칭 방지)
+    const outerHasI = await fs.promises
+      .access(path.join(outerTarget, "inner-pkg", "src", "i.ts"))
+      .then(() => true, () => false);
+    expect(outerHasI).toBe(false);
+  }, 10_000);
+
   it("options 파라미터가 undefined일 때 에러가 발생하지 않는다", async () => {
     const projectRoot = path.join(tmpDir, "project");
     const sourcePath = path.join(tmpDir, "source-pkg");
@@ -144,4 +216,129 @@ describe("watchReplaceDeps onChanged", () => {
     await new Promise((r) => setTimeout(r, 1500));
     // 에러 없이 완료됨
   }, 10_000);
+
+  it("source의 files 필드가 없으면 경고를 출력하고 감시에서 제외한다", async () => {
+    const projectRoot = path.join(tmpDir, "project");
+    const sourcePath = path.join(tmpDir, "source-pkg");
+
+    // files 필드 제거
+    await fs.promises.writeFile(
+      path.join(sourcePath, "package.json"),
+      JSON.stringify({ name: "@test/pkg" }),
+    );
+
+    let callCount = 0;
+    watchResult = await watchReplaceDeps(projectRoot, { "@test/pkg": sourcePath }, {
+      onChanged: () => {
+        callCount++;
+      },
+    });
+
+    expect(mockLogger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("package.json에 files 필드가 없어 감시 건너뜀"),
+    );
+
+    // 파일을 변경해도 감지되지 않음
+    await fs.promises.writeFile(
+      path.join(sourcePath, "src", "index.ts"),
+      "export const v = 2;",
+    );
+    await new Promise((r) => setTimeout(r, 1500));
+
+    expect(callCount).toBe(0);
+  }, 10_000);
+
+  it("동일 내용 재저장 시 isFileContentSame 스킵으로 onChanged가 호출되지 않는다", async () => {
+    const projectRoot = path.join(tmpDir, "project");
+    const sourcePath = path.join(tmpDir, "source-pkg");
+
+    // beforeEach에서 source와 target 모두 "export const v = 1;"로 설정된 상태
+    let callCount = 0;
+    watchResult = await watchReplaceDeps(projectRoot, { "@test/pkg": sourcePath }, {
+      onChanged: () => {
+        callCount++;
+      },
+    });
+
+    // 동일 내용으로 재저장 (mtime은 변경되지만 내용은 같음)
+    await fs.promises.writeFile(
+      path.join(sourcePath, "src", "index.ts"),
+      "export const v = 1;",
+    );
+
+    await new Promise((r) => setTimeout(r, 1500));
+
+    // isFileContentSame이 true를 반환하여 복사 스킵 → hasActualCopy=false → onChanged 미호출
+    expect(callCount).toBe(0);
+  }, 10_000);
+
+  it("dispose 이후의 파일 변경은 감지되지 않는다", async () => {
+    const projectRoot = path.join(tmpDir, "project");
+    const sourcePath = path.join(tmpDir, "source-pkg");
+
+    let callCount = 0;
+    const result = await watchReplaceDeps(projectRoot, { "@test/pkg": sourcePath }, {
+      onChanged: () => {
+        callCount++;
+      },
+    });
+
+    result.dispose();
+    // afterEach에서 중복 dispose 방지
+    watchResult = undefined;
+
+    // close 완료 대기
+    await new Promise((r) => setTimeout(r, 500));
+
+    await fs.promises.writeFile(
+      path.join(sourcePath, "src", "index.ts"),
+      "export const v = 99;",
+    );
+
+    await new Promise((r) => setTimeout(r, 1500));
+
+    expect(callCount).toBe(0);
+  }, 10_000);
+
+  it("모든 source의 files 필드가 없으면 감시 대상이 없음 경고를 출력한다", async () => {
+    const projectRoot = path.join(tmpDir, "project");
+    const sourcePath = path.join(tmpDir, "source-pkg");
+
+    // files 필드 제거
+    await fs.promises.writeFile(
+      path.join(sourcePath, "package.json"),
+      JSON.stringify({ name: "@test/pkg" }),
+    );
+
+    watchResult = await watchReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    expect(mockLogger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("감시 대상이 없어 워치가 시작되지 않음"),
+    );
+  }, 10_000);
+
+  it("files 필드가 없으면 해당 source에 대한 readdir이 호출되지 않는다", async () => {
+    const projectRoot = path.join(tmpDir, "project");
+    const sourcePath = path.join(tmpDir, "source-pkg");
+
+    // files 필드 제거
+    await fs.promises.writeFile(
+      path.join(sourcePath, "package.json"),
+      JSON.stringify({ name: "@test/pkg" }),
+    );
+
+    const readdirSpy = vi.spyOn(fs.promises, "readdir");
+
+    watchResult = await watchReplaceDeps(projectRoot, { "@test/pkg": sourcePath });
+
+    // sourcePath에 대한 readdir 호출이 없어야 함 (files null이면 생략되어야 함)
+    const sourcePathPosix = path.resolve(sourcePath).replace(/\\/g, "/");
+    const calledWithSource = readdirSpy.mock.calls.some((args) => {
+      const arg = args[0];
+      if (typeof arg !== "string") return false;
+      return arg.replace(/\\/g, "/") === sourcePathPosix;
+    });
+
+    expect(calledWithSource).toBe(false);
+  }, 10_000);
 });

package/dist/sd-cli/tests/angular/fixtures/packages/basic-app/tests/test.fixture.d.ts

@@ -1,3 +0,0 @@
-export declare class FixtureComponent {
-}
-//# sourceMappingURL=test.fixture.d.ts.map

package/dist/sd-cli/tests/angular/fixtures/packages/basic-app/tests/test.fixture.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.fixture.d.ts","sourceRoot":"","sources":["../../../../../../../../tests/angular/fixtures/packages/basic-app/tests/test.fixture.ts"],"names":[],"mappings":"AAEA,qBAKa,gBAAgB;CAAG"}

package/dist/sd-cli/tests/angular/fixtures/packages/basic-app/tests/test.fixture.js

@@ -1,9 +0,0 @@
-import { Component } from "@angular/core";
-@Component({
-    selector: "app-fixture",
-    standalone: true,
-    template: `<span>fixture</span>`,
-})
-export class FixtureComponent {
-}
-//# sourceMappingURL=test.fixture.js.map

package/dist/sd-cli/tests/angular/fixtures/packages/basic-app/tests/test.fixture.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.fixture.js","sourceRoot":"","sources":["../../../../../../../../tests/angular/fixtures/packages/basic-app/tests/test.fixture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1C,CAAC,SAAS,CAAC;IACT,QAAQ,EAAE,aAAa;IACvB,UAAU,EAAE,IAAI;IAChB,QAAQ,EAAE,sBAAsB;CACjC,CAAC;AACF,MAAM,OAAO,gBAAgB;CAAG"}