@simplysm/sd-cli 13.0.0-beta.45 → 13.0.0-beta.47

package/src/utils/replace-deps.ts

@@ -0,0 +1,163 @@
+import fs from "fs";
+import path from "path";
+import { glob } from "glob";
+import { consola } from "consola";
+
+/**
+ * replaceDeps 설정의 glob 패턴과 대상 패키지 목록을 매칭하여
+ * { targetName, sourcePath } 쌍을 반환한다.
+ *
+ * @param replaceDeps - sd.config.ts의 replaceDeps 설정 (키: glob 패턴, 값: 소스 경로)
+ * @param targetNames - node_modules에서 찾은 패키지 이름 목록 (예: ["@simplysm/solid", ...])
+ * @returns 매칭된 { targetName, sourcePath } 배열
+ */
+export function resolveReplaceDepEntries(
+  replaceDeps: Record<string, string>,
+  targetNames: string[],
+): Array<{ targetName: string; sourcePath: string }> {
+  const results: Array<{ targetName: string; sourcePath: string }> = [];
+
+  for (const [pattern, sourceTemplate] of Object.entries(replaceDeps)) {
+    // glob 패턴을 정규식으로 변환: * → (.*), . → \., / → [\\/]
+    const regexpText = pattern.replace(/[\\/.+*]/g, (ch) => {
+      if (ch === "*") return "(.*)";
+      if (ch === ".") return "\\.";
+      if (ch === "/" || ch === "\\") return "[\\\\/]";
+      if (ch === "+") return "\\+";
+      return ch;
+    });
+    const regex = new RegExp(`^${regexpText}$`);
+    const hasWildcard = pattern.includes("*");
+
+    for (const targetName of targetNames) {
+      const match = regex.exec(targetName);
+      if (match == null) continue;
+
+      // 캡처 그룹이 있으면 소스 경로의 *에 치환
+      const sourcePath = hasWildcard ? sourceTemplate.replace(/\*/g, match[1]) : sourceTemplate;
+
+      results.push({ targetName, sourcePath });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * pnpm-workspace.yaml 내용을 파싱하여 workspace packages glob 배열을 반환한다.
+ * 별도 YAML 라이브러리 없이 간단한 라인 파싱으로 처리한다.
+ *
+ * @param content - pnpm-workspace.yaml 파일 내용
+ * @returns glob 패턴 배열 (예: ["packages/*", "tools/*"])
+ */
+export function parseWorkspaceGlobs(content: string): string[] {
+  const lines = content.split("\n");
+  const globs: string[] = [];
+  let inPackages = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (trimmed === "packages:") {
+      inPackages = true;
+      continue;
+    }
+
+    // packages 섹션 내의 리스트 항목
+    if (inPackages && trimmed.startsWith("- ")) {
+      const value = trimmed
+        .slice(2)
+        .trim()
+        .replace(/^["']|["']$/g, "");
+      globs.push(value);
+      continue;
+    }
+
+    // 다른 섹션이 시작되면 종료
+    if (inPackages && trimmed !== "" && !trimmed.startsWith("#")) {
+      break;
+    }
+  }
+
+  return globs;
+}
+
+/**
+ * replaceDeps 설정에 따라 node_modules 내 패키지를 소스 디렉토리로 symlink 교체한다.
+ *
+ * 1. pnpm-workspace.yaml 파싱 → workspace 패키지 경로 목록
+ * 2. [루트, ...workspace 패키지]의 node_modules에서 매칭되는 패키지 찾기
+ * 3. 기존 symlink/디렉토리 제거 → 소스 경로로 symlink 생성
+ *
+ * @param projectRoot - 프로젝트 루트 경로
+ * @param replaceDeps - sd.config.ts의 replaceDeps 설정
+ */
+export async function setupReplaceDeps(projectRoot: string, replaceDeps: Record<string, string>): Promise<void> {
+  const logger = consola.withTag("sd:cli:replace-deps");
+
+  // 1. Workspace 패키지 경로 목록 수집
+  const searchRoots = [projectRoot];
+
+  const workspaceYamlPath = path.join(projectRoot, "pnpm-workspace.yaml");
+  try {
+    const yamlContent = await fs.promises.readFile(workspaceYamlPath, "utf-8");
+    const workspaceGlobs = parseWorkspaceGlobs(yamlContent);
+
+    for (const pattern of workspaceGlobs) {
+      const dirs = await glob(pattern, { cwd: projectRoot, absolute: true });
+      searchRoots.push(...dirs);
+    }
+  } catch {
+    // pnpm-workspace.yaml가 없으면 루트만 처리
+  }
+
+  // 2. 각 searchRoot의 node_modules에서 매칭되는 패키지 찾기
+  for (const searchRoot of searchRoots) {
+    const nodeModulesDir = path.join(searchRoot, "node_modules");
+
+    try {
+      await fs.promises.access(nodeModulesDir);
+    } catch {
+      continue; // node_modules 없으면 스킵
+    }
+
+    // replaceDeps의 각 glob 패턴으로 node_modules 내 디렉토리 탐색
+    const targetNames: string[] = [];
+    for (const pattern of Object.keys(replaceDeps)) {
+      const matches = await glob(pattern, { cwd: nodeModulesDir });
+      targetNames.push(...matches);
+    }
+
+    if (targetNames.length === 0) continue;
+
+    // 패턴 매칭 및 경로 해석
+    const entries = resolveReplaceDepEntries(replaceDeps, targetNames);
+
+    // 3. Symlink 교체
+    for (const { targetName, sourcePath } of entries) {
+      const targetPath = path.join(nodeModulesDir, targetName);
+      const resolvedSourcePath = path.resolve(projectRoot, sourcePath);
+
+      // 소스 경로 존재 확인
+      try {
+        await fs.promises.access(resolvedSourcePath);
+      } catch {
+        logger.warn(`소스 경로가 존재하지 않아 스킵합니다: ${resolvedSourcePath}`);
+        continue;
+      }
+
+      try {
+        // 기존 symlink/디렉토리 제거
+        await fs.promises.rm(targetPath, { recursive: true, force: true });
+
+        // 상대 경로로 symlink 생성
+        const relativePath = path.relative(path.dirname(targetPath), resolvedSourcePath);
+        await fs.promises.symlink(relativePath, targetPath, "dir");
+
+        logger.info(`${targetName} → ${sourcePath}`);
+      } catch (err) {
+        logger.error(`symlink 교체 실패 (${targetName}): ${err instanceof Error ? err.message : err}`);
+      }
+    }
+  }
+}

package/src/utils/sd-config.ts

@@ -0,0 +1,44 @@
+import path from "path";
+import { createJiti } from "jiti";
+import { SdError } from "@simplysm/core-common";
+import { fsExists } from "@simplysm/core-node";
+import type { SdConfig } from "../sd-config.types";
+
+/**
+ * sd.config.ts 로드
+ * @returns SdConfig 객체
+ * @throws sd.config.ts가 없거나 형식이 잘못된 경우
+ */
+export async function loadSdConfig(params: { cwd: string; dev: boolean; opt: string[] }): Promise<SdConfig> {
+  const sdConfigPath = path.resolve(params.cwd, "sd.config.ts");
+
+  if (!(await fsExists(sdConfigPath))) {
+    throw new SdError(`sd.config.ts 파일을 찾을 수 없습니다: ${sdConfigPath}`);
+  }
+
+  const jiti = createJiti(import.meta.url);
+  const sdConfigModule = await jiti.import(sdConfigPath);
+
+  if (
+    sdConfigModule == null ||
+    typeof sdConfigModule !== "object" ||
+    !("default" in sdConfigModule) ||
+    typeof sdConfigModule.default !== "function"
+  ) {
+    throw new SdError(`sd.config.ts는 함수를 default export해야 합니다: ${sdConfigPath}`);
+  }
+
+  const config = await sdConfigModule.default(params);
+
+  if (
+    config == null ||
+    typeof config !== "object" ||
+    !("packages" in config) ||
+    config.packages == null ||
+    typeof config.packages !== "object" ||
+    Array.isArray(config.packages)
+  ) {
+    throw new SdError(`sd.config.ts의 반환값이 올바른 형식이 아닙니다: ${sdConfigPath}`);
+  }
+  return config as SdConfig;
+}

package/src/utils/spawn.ts

@@ -0,0 +1,79 @@
+import { spawn as cpSpawn, type SpawnOptions as CpSpawnOptions } from "child_process";
+
+/**
+ * spawn 옵션
+ */
+export interface SpawnOptions {
+  /** 작업 디렉토리 */
+  cwd?: string;
+  /** 환경변수 (process.env와 병합) */
+  env?: Record<string, string | undefined>;
+  /** 색상 출력 강제 여부 (기본값: NO_COLOR 환경변수 존중) */
+  forceColor?: boolean;
+}
+
+/**
+ * child_process.spawn을 Promise로 래핑한 함수.
+ *
+ * - stdout/stderr를 캡처하여 반환
+ * - NO_COLOR 환경변수 존중 (forceColor로 오버라이드 가능)
+ * - 종료 코드가 0이 아니면 에러 throw
+ * - Windows에서도 shell 없이 실행 (보안상 shell: true 사용 안 함)
+ *
+ * @param cmd - 실행할 명령어
+ * @param args - 명령어 인자
+ * @param options - 실행 옵션
+ * @returns stdout 출력 (stderr는 stdout에 병합됨)
+ */
+export async function spawn(cmd: string, args: string[], options?: SpawnOptions): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    // NO_COLOR 환경변수 존중 (https://no-color.org/)
+    const noColor = process.env["NO_COLOR"] != null;
+    const useColor = options?.forceColor ?? !noColor;
+
+    const colorEnv = useColor
+      ? {
+          FORCE_COLOR: "1",
+          CLICOLOR_FORCE: "1",
+          COLORTERM: "truecolor",
+        }
+      : {};
+
+    const spawnOptions: CpSpawnOptions = {
+      cwd: options?.cwd,
+      env: {
+        ...process.env,
+        ...colorEnv,
+        ...options?.env,
+      },
+      // shell: false for security (avoid shell injection)
+      // Windows .bat/.cmd files are handled by calling cmd.exe explicitly in capacitor.ts
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+    };
+
+    const child = cpSpawn(cmd, args, spawnOptions);
+
+    let output = "";
+
+    child.stdout?.on("data", (data: Buffer) => {
+      output += data.toString();
+    });
+
+    child.stderr?.on("data", (data: Buffer) => {
+      output += data.toString();
+    });
+
+    child.on("error", (err) => {
+      reject(new Error(`spawn 실패 (${cmd}): ${err.message}`));
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(output);
+      } else {
+        reject(new Error(`명령어 실패 (${cmd} ${args.join(" ")})\n종료 코드: ${code}\n출력:\n${output}`));
+      }
+    });
+  });
+}

package/src/utils/tailwind-config-deps.ts

@@ -0,0 +1,95 @@
+import fs from "fs";
+import path from "path";
+
+const jsExtensions = [".js", ".cjs", ".mjs"];
+
+const jsResolutionOrder = ["", ".js", ".cjs", ".mjs", ".ts", ".cts", ".mts", ".jsx", ".tsx"];
+const tsResolutionOrder = ["", ".ts", ".cts", ".mts", ".tsx", ".js", ".cjs", ".mjs", ".jsx"];
+
+function resolveWithExtension(file: string, extensions: string[]): string | null {
+  for (const ext of extensions) {
+    const full = `${file}${ext}`;
+    if (fs.existsSync(full) && fs.statSync(full).isFile()) {
+      return full;
+    }
+  }
+  for (const ext of extensions) {
+    const full = `${file}/index${ext}`;
+    if (fs.existsSync(full) && fs.statSync(full).isFile()) {
+      return full;
+    }
+  }
+  return null;
+}
+
+function resolvePackageFile(specifier: string, fromDir: string): string | null {
+  const parts = specifier.split("/");
+  const pkgName = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  const subPath = specifier.startsWith("@") ? parts.slice(2).join("/") : parts.slice(1).join("/");
+
+  let searchDir = fromDir;
+  while (true) {
+    const candidate = path.join(searchDir, "node_modules", pkgName);
+    if (fs.existsSync(candidate)) {
+      const realDir = fs.realpathSync(candidate);
+      if (subPath) {
+        return resolveWithExtension(path.join(realDir, subPath), tsResolutionOrder);
+      }
+      return resolveWithExtension(path.join(realDir, "index"), tsResolutionOrder);
+    }
+    const parent = path.dirname(searchDir);
+    if (parent === searchDir) break;
+    searchDir = parent;
+  }
+  return null;
+}
+
+/**
+ * Tailwind config 파일의 의존성을 재귀적으로 수집한다.
+ *
+ * Tailwind 내장 `getModuleDependencies`는 상대 경로 import만 추적하지만,
+ * 이 함수는 지정된 scope의 패키지 경로도 `node_modules` symlink를 풀어 실제 파일을 추적한다.
+ */
+export function getTailwindConfigDeps(configPath: string, scopes: string[]): string[] {
+  const scopePrefixes = scopes.map((s) => (s.endsWith("/") ? s : s + "/"));
+  const seen = new Set<string>();
+
+  function walk(absoluteFile: string): void {
+    if (seen.has(absoluteFile)) return;
+    if (!fs.existsSync(absoluteFile)) return;
+    seen.add(absoluteFile);
+
+    const base = path.dirname(absoluteFile);
+    const ext = path.extname(absoluteFile);
+    const extensions = jsExtensions.includes(ext) ? jsResolutionOrder : tsResolutionOrder;
+
+    let contents: string;
+    try {
+      contents = fs.readFileSync(absoluteFile, "utf-8");
+    } catch {
+      return;
+    }
+
+    for (const match of [
+      ...contents.matchAll(/import[\s\S]*?['"](.{3,}?)['"]/gi),
+      ...contents.matchAll(/import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi),
+      ...contents.matchAll(/require\(['"`](.+)['"`]\)/gi),
+    ]) {
+      const specifier = match[1];
+      let resolved: string | null = null;
+
+      if (specifier.startsWith(".")) {
+        resolved = resolveWithExtension(path.resolve(base, specifier), extensions);
+      } else if (scopePrefixes.some((p) => specifier.startsWith(p))) {
+        resolved = resolvePackageFile(specifier, base);
+      }
+
+      if (resolved != null) {
+        walk(resolved);
+      }
+    }
+  }
+
+  walk(path.resolve(configPath));
+  return [...seen];
+}

package/src/utils/template.ts

@@ -0,0 +1,51 @@
+import path from "path";
+import Handlebars from "handlebars";
+import { fsCopy, fsMkdir, fsRead, fsReaddir, fsStat, fsWrite } from "@simplysm/core-node";
+
+/**
+ * 템플릿 디렉토리를 재귀적으로 순회하며 Handlebars 렌더링 후 파일을 생성한다.
+ *
+ * - `.hbs` 확장자 파일: Handlebars 컴파일 → `.hbs` 제거한 이름으로 저장
+ * - `.hbs` 결과가 빈 문자열/공백만이면: 파일 생성 스킵
+ * - 나머지 파일: 바이너리로 그대로 복사
+ *
+ * @param srcDir - 템플릿 소스 디렉토리
+ * @param destDir - 출력 대상 디렉토리
+ * @param context - Handlebars 템플릿 변수
+ * @param dirReplacements - 디렉토리 이름 치환 맵 (예: `{ __CLIENT__: "client-admin" }`)
+ */
+export async function renderTemplateDir(
+  srcDir: string,
+  destDir: string,
+  context: Record<string, unknown>,
+  dirReplacements?: Record<string, string>,
+): Promise<void> {
+  await fsMkdir(destDir);
+
+  const entries = await fsReaddir(srcDir);
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry);
+    const stat = await fsStat(srcPath);
+
+    if (stat.isDirectory()) {
+      // 디렉토리 이름 치환 적용
+      const destName = dirReplacements?.[entry] ?? entry;
+      await renderTemplateDir(path.join(srcDir, entry), path.join(destDir, destName), context, dirReplacements);
+    } else if (entry.endsWith(".hbs")) {
+      // Handlebars 템플릿 렌더링
+      const source = await fsRead(srcPath);
+      const template = Handlebars.compile(source, { noEscape: true });
+      const result = template(context);
+
+      // 빈 결과면 파일 생성 스킵
+      if (result.trim().length === 0) continue;
+
+      const destFileName = entry.slice(0, -4); // .hbs 제거
+      await fsWrite(path.join(destDir, destFileName), result);
+    } else {
+      // 바이너리 파일은 그대로 복사
+      await fsCopy(srcPath, path.join(destDir, entry));
+    }
+  }
+}

package/src/utils/tsconfig.ts

@@ -0,0 +1,111 @@
+import ts from "typescript";
+import path from "path";
+import { fsExists, fsReadJson } from "@simplysm/core-node";
+import { SdError } from "@simplysm/core-common";
+
+/**
+ * DOM 관련 lib 패턴 - 브라우저 API를 포함하는 lib들
+ * node 환경에서 제외되어야 하는 lib을 필터링할 때 사용 (lib.dom.d.ts, lib.webworker.d.ts 등)
+ */
+const DOM_LIB_PATTERNS = ["dom", "webworker"] as const;
+
+/**
+ * 패키지의 package.json에서 @types/* devDependencies를 읽어 types 목록을 반환합니다.
+ */
+export async function getTypesFromPackageJson(packageDir: string): Promise<string[]> {
+  const packageJsonPath = path.join(packageDir, "package.json");
+  if (!(await fsExists(packageJsonPath))) {
+    return [];
+  }
+
+  const packageJson = await fsReadJson<{ devDependencies?: Record<string, string> }>(packageJsonPath);
+  const devDeps = packageJson.devDependencies ?? {};
+
+  return Object.keys(devDeps)
+    .filter((dep) => dep.startsWith("@types/"))
+    .map((dep) => dep.replace("@types/", ""));
+}
+
+/**
+ * 타입체크 환경
+ * - node: DOM lib 제거 + node 타입 추가
+ * - browser: node 타입 제거
+ * - neutral: DOM lib 유지 + node 타입 추가 (Node/브라우저 공용 패키지용)
+ */
+export type TypecheckEnv = "node" | "browser" | "neutral";
+
+/**
+ * 패키지용 컴파일러 옵션 생성
+ *
+ * @param baseOptions 루트 tsconfig의 컴파일러 옵션
+ * @param env 타입체크 환경 (node: DOM lib 제거 + node 타입 추가, browser: node 타입 제거)
+ * @param packageDir 패키지 디렉토리 경로
+ *
+ * @remarks
+ * types 옵션은 baseOptions.types를 무시하고 패키지별로 새로 구성한다.
+ * 이는 루트 tsconfig의 전역 타입이 패키지 환경에 맞지 않을 수 있기 때문이다.
+ * (예: browser 패키지에 node 타입이 포함되는 것을 방지)
+ */
+export async function getCompilerOptionsForPackage(
+  baseOptions: ts.CompilerOptions,
+  env: TypecheckEnv,
+  packageDir: string,
+): Promise<ts.CompilerOptions> {
+  const options = { ...baseOptions };
+  const packageTypes = await getTypesFromPackageJson(packageDir);
+
+  // pnpm 환경: 패키지별 node_modules/@types와 루트 node_modules/@types 모두 검색
+  options.typeRoots = [
+    path.join(packageDir, "node_modules", "@types"),
+    path.join(process.cwd(), "node_modules", "@types"),
+  ];
+
+  switch (env) {
+    case "node":
+      options.lib = options.lib?.filter(
+        (lib) => !DOM_LIB_PATTERNS.some((pattern) => lib.toLowerCase().includes(pattern)),
+      );
+      options.types = [...new Set([...packageTypes, "node"])];
+      break;
+    case "browser":
+      options.types = packageTypes.filter((t) => t !== "node");
+      break;
+    case "neutral":
+      options.types = [...new Set([...packageTypes, "node"])];
+      break;
+  }
+
+  return options;
+}
+
+/**
+ * 루트 tsconfig 파싱
+ * @throws tsconfig.json을 읽거나 파싱할 수 없는 경우
+ */
+export function parseRootTsconfig(cwd: string): ts.ParsedCommandLine {
+  const tsconfigPath = path.join(cwd, "tsconfig.json");
+  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+
+  if (configFile.error) {
+    const message = ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n");
+    throw new SdError(`tsconfig.json 읽기 실패: ${message}`);
+  }
+
+  const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
+
+  if (parsed.errors.length > 0) {
+    const messages = parsed.errors.map((e) => ts.flattenDiagnosticMessageText(e.messageText, "\n"));
+    throw new SdError(`tsconfig.json 파싱 실패: ${messages.join("; ")}`);
+  }
+
+  return parsed;
+}
+
+/**
+ * 패키지의 소스 파일 목록 가져오기 (tsconfig 기반)
+ */
+export function getPackageSourceFiles(pkgDir: string, parsedConfig: ts.ParsedCommandLine): string[] {
+  // 경로 구분자까지 포함하여 비교 (packages/core와 packages/core-common 구분)
+  const pkgSrcPrefix = path.join(pkgDir, "src") + path.sep;
+  return parsedConfig.fileNames.filter((f) => f.startsWith(pkgSrcPrefix));
+}

package/src/utils/typecheck-serialization.ts

@@ -0,0 +1,82 @@
+import ts from "typescript";
+import { fsExistsSync, fsReadSync } from "@simplysm/core-node";
+
+/**
+ * Worker로 전달 가능한 직렬화된 Diagnostic
+ */
+export interface SerializedDiagnostic {
+  category: number;
+  code: number;
+  messageText: string;
+  file?: {
+    fileName: string;
+  };
+  start?: number;
+  length?: number;
+}
+
+/**
+ * Diagnostic을 직렬화 가능한 형태로 변환
+ * (Worker thread 간 structured clone 통신을 위해 순환 참조/함수 제거)
+ */
+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,
+    start: diagnostic.start,
+    length: diagnostic.length,
+  };
+}
+
+/**
+ * 파일명에서 TypeScript ScriptKind 결정
+ */
+function getScriptKind(fileName: string): ts.ScriptKind {
+  if (fileName.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (fileName.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  if (fileName.endsWith(".js") || fileName.endsWith(".mjs") || fileName.endsWith(".cjs")) return ts.ScriptKind.JS;
+  return ts.ScriptKind.TS;
+}
+
+/**
+ * SerializedDiagnostic을 ts.Diagnostic으로 복원
+ * 실제 파일 내용을 읽어 formatDiagnosticsWithColorAndContext에서 소스 코드 컨텍스트가 표시되도록 함
+ * @param serialized 직렬화된 진단 정보
+ * @param fileCache 파일 내용 캐시 (동일 파일 중복 읽기 방지)
+ * @returns 복원된 ts.Diagnostic 객체
+ */
+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;
+
+    // 캐시된 파일 내용 가져오기 (없으면 읽어서 캐시)
+    // 파일이 삭제되었거나 접근 불가능한 경우 빈 내용으로 처리
+    // (소스 코드 컨텍스트는 표시되지 않지만 진단 메시지는 정상 출력됨)
+    if (!fileCache.has(fileName)) {
+      fileCache.set(fileName, fsExistsSync(fileName) ? fsReadSync(fileName) : "");
+    }
+    const content = fileCache.get(fileName)!;
+
+    const scriptKind = getScriptKind(fileName);
+    file = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, false, scriptKind);
+  }
+
+  return {
+    category: serialized.category,
+    code: serialized.code,
+    messageText: serialized.messageText,
+    file,
+    start: serialized.start,
+    length: serialized.length,
+  };
+}