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

package/src/utils/config-editor.ts

@@ -0,0 +1,131 @@
+import { Project, SyntaxKind, type ObjectLiteralExpression } from "ts-morph";
+
+/**
+ * sd.config.ts에서 packages 객체 리터럴을 찾는다.
+ *
+ * 구조: const config: SdConfigFn = () => ({ packages: { ... } });
+ * -> ArrowFunction -> ParenthesizedExpression -> ObjectLiteral -> "packages" property -> ObjectLiteral
+ */
+function findPackagesObject(configPath: string): {
+  project: Project;
+  packagesObj: ObjectLiteralExpression;
+} {
+  const project = new Project();
+  const sourceFile = project.addSourceFileAtPath(configPath);
+
+  // "config" 변수 선언 찾기
+  const configVar = sourceFile.getVariableDeclarationOrThrow("config");
+  const arrowFn = configVar.getInitializerIfKindOrThrow(SyntaxKind.ArrowFunction);
+
+  // 화살표 함수 본문에서 반환 객체 찾기
+  const body = arrowFn.getBody();
+  let returnObj: ObjectLiteralExpression;
+
+  if (body.isKind(SyntaxKind.ParenthesizedExpression)) {
+    returnObj = body.getExpressionIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+  } else if (body.isKind(SyntaxKind.Block)) {
+    const returnStmt = body.getFirstDescendantByKindOrThrow(SyntaxKind.ReturnStatement);
+    returnObj = returnStmt.getExpressionIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+  } else {
+    throw new Error("sd.config.ts의 구조를 인식할 수 없습니다.");
+  }
+
+  // "packages" 프로퍼티 찾기
+  const packagesProp = returnObj.getPropertyOrThrow("packages").asKindOrThrow(SyntaxKind.PropertyAssignment);
+  const packagesObj = packagesProp.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+
+  return { project, packagesObj };
+}
+
+/**
+ * sd.config.ts의 packages 객체에 새 패키지 항목을 추가한다.
+ *
+ * @returns true: 성공, false: 이미 존재
+ */
+export function addPackageToSdConfig(
+  configPath: string,
+  packageName: string,
+  config: Record<string, unknown>,
+): boolean {
+  const { project, packagesObj } = findPackagesObject(configPath);
+
+  // 이미 존재하는지 확인 (따옴표 있는 형태와 없는 형태 모두 체크)
+  const existing = packagesObj.getProperty(`"${packageName}"`) ?? packagesObj.getProperty(packageName);
+  if (existing) {
+    return false;
+  }
+
+  // 새 프로퍼티 추가 -- config 객체를 ts-morph initializer 문자열로 변환
+  const configStr = JSON.stringify(config)
+    .replace(/"([^"]+)":/g, "$1: ")
+    .replace(/"/g, '"');
+
+  packagesObj.addPropertyAssignment({
+    name: `"${packageName}"`,
+    initializer: configStr,
+  });
+
+  project.saveSync();
+  return true;
+}
+
+/**
+ * sd.config.ts에서 특정 클라이언트의 server 필드를 설정한다.
+ */
+export function setClientServerInSdConfig(configPath: string, clientName: string, serverName: string): void {
+  const { project, packagesObj } = findPackagesObject(configPath);
+
+  const clientPropNode = packagesObj.getProperty(`"${clientName}"`) ?? packagesObj.getProperty(clientName);
+  if (clientPropNode == null) {
+    throw new Error(`클라이언트 "${clientName}"을(를) sd.config.ts에서 찾을 수 없습니다.`);
+  }
+
+  const clientProp = clientPropNode.asKindOrThrow(SyntaxKind.PropertyAssignment);
+  const clientObj = clientProp.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+
+  // 기존 server 프로퍼티가 있으면 제거
+  const serverProp = clientObj.getProperty("server");
+  if (serverProp) {
+    serverProp.remove();
+  }
+
+  // server 프로퍼티 추가
+  clientObj.addPropertyAssignment({
+    name: "server",
+    initializer: `"${serverName}"`,
+  });
+
+  project.saveSync();
+}
+
+/**
+ * eslint.config.ts에 tailwindcss 설정 블록을 추가한다.
+ *
+ * @returns true: 추가됨, false: 이미 존재
+ */
+export function addTailwindToEslintConfig(configPath: string, clientName: string): boolean {
+  const project = new Project();
+  const sourceFile = project.addSourceFileAtPath(configPath);
+
+  // default export 배열 찾기
+  const defaultExport = sourceFile.getFirstDescendantByKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+
+  // tailwindcss 설정이 이미 있는지 확인
+  const text = defaultExport.getText();
+  if (text.includes("tailwindcss")) {
+    return false;
+  }
+
+  // 새 설정 객체 추가
+  defaultExport.addElement(`{
+    files: ["**/*.{ts,tsx}"],
+    settings: {
+      tailwindcss: {
+        config: "packages/${clientName}/tailwind.config.ts",
+      },
+    },
+  }`);
+
+  project.saveSync();
+  return true;
+}

package/src/utils/copy-src.ts

@@ -0,0 +1,60 @@
+import path from "path";
+import { fsGlob, fsCopy, fsMkdir, fsRm, FsWatcher } from "@simplysm/core-node";
+
+/**
+ * src/에서 glob 패턴에 매칭되는 파일을 dist/로 복사한다.
+ * 상대 경로가 유지된다: src/a/b.css → dist/a/b.css
+ *
+ * @param pkgDir 패키지 루트 디렉토리
+ * @param patterns glob 패턴 배열 (src/ 기준 상대 경로)
+ */
+export async function copySrcFiles(pkgDir: string, patterns: string[]): Promise<void> {
+  const srcDir = path.join(pkgDir, "src");
+  const distDir = path.join(pkgDir, "dist");
+
+  for (const pattern of patterns) {
+    const files = await fsGlob(pattern, { cwd: srcDir, absolute: true });
+    for (const file of files) {
+      const relativePath = path.relative(srcDir, file);
+      const distPath = path.join(distDir, relativePath);
+      await fsMkdir(path.dirname(distPath));
+      await fsCopy(file, distPath);
+    }
+  }
+}
+
+/**
+ * src/에서 glob 패턴에 매칭되는 파일을 감시하여 dist/로 복사한다.
+ * 초기 복사 후 변경/추가/삭제를 자동 반영한다.
+ *
+ * @param pkgDir 패키지 루트 디렉토리
+ * @param patterns glob 패턴 배열 (src/ 기준 상대 경로)
+ * @returns FsWatcher 인스턴스 (shutdown 시 close() 호출 필요)
+ */
+export async function watchCopySrcFiles(pkgDir: string, patterns: string[]): Promise<FsWatcher> {
+  const srcDir = path.join(pkgDir, "src");
+  const distDir = path.join(pkgDir, "dist");
+
+  // 초기 복사
+  await copySrcFiles(pkgDir, patterns);
+
+  // watch 시작
+  const watchPaths = patterns.map((p) => path.join(srcDir, p));
+  const watcher = await FsWatcher.watch(watchPaths);
+
+  watcher.onChange({ delay: 300 }, async (changes) => {
+    for (const { event, path: filePath } of changes) {
+      const relPath = path.relative(srcDir, filePath);
+      const distPath = path.join(distDir, relPath);
+
+      if (event === "unlink") {
+        await fsRm(distPath);
+      } else if (event === "add" || event === "change") {
+        await fsMkdir(path.dirname(distPath));
+        await fsCopy(filePath, distPath);
+      }
+    }
+  });
+
+  return watcher;
+}

package/src/utils/esbuild-config.ts

@@ -0,0 +1,263 @@
+import path from "path";
+import { readFileSync, existsSync } from "fs";
+import fs from "fs/promises";
+import { createRequire } from "module";
+import { glob } from "glob";
+import type esbuild from "esbuild";
+import { solidPlugin } from "esbuild-plugin-solid";
+import type { TypecheckEnv } from "./tsconfig";
+
+/**
+ * ESM 상대 import 경로에 .js 확장자를 추가하는 esbuild 플러그인.
+ *
+ * bundle: false 모드에서 esbuild는 import 경로를 그대로 유지하므로,
+ * Node.js ESM에서 직접 실행 시 확장자 누락으로 모듈을 찾지 못하는 문제를 해결한다.
+ */
+function esmRelativeImportPlugin(outdir: string): esbuild.Plugin {
+  return {
+    name: "esm-relative-import",
+    setup(build) {
+      build.onEnd(async () => {
+        const files = await glob("**/*.js", { cwd: outdir });
+
+        await Promise.all(
+          files.map(async (file) => {
+            const filePath = path.join(outdir, file);
+            const content = await fs.readFile(filePath, "utf-8");
+
+            const rewritten = content.replace(
+              /((?:from|import)\s*["'])(\.\.?\/[^"']*?)(["'])/g,
+              (_match, prefix: string, importPath: string, suffix: string) => {
+                if (/\.(js|mjs|cjs|json|css|wasm|node)$/i.test(importPath)) return _match;
+                return `${prefix}${importPath}.js${suffix}`;
+              },
+            );
+
+            if (rewritten !== content) {
+              await fs.writeFile(filePath, rewritten);
+            }
+          }),
+        );
+      });
+    },
+  };
+}
+
+/**
+ * Library 빌드용 esbuild 옵션
+ * - bundle: false (개별 파일 트랜스파일)
+ * - platform: target에 따라 node 또는 browser
+ */
+export interface LibraryEsbuildOptions {
+  pkgDir: string;
+  entryPoints: string[];
+  target: "node" | "browser" | "neutral";
+  compilerOptions: Record<string, unknown>;
+}
+
+/**
+ * Server 빌드용 esbuild 옵션
+ * - bundle: true (모든 의존성 포함한 단일 번들)
+ */
+export interface ServerEsbuildOptions {
+  pkgDir: string;
+  entryPoints: string[];
+  compilerOptions: Record<string, unknown>;
+  env?: Record<string, string>;
+  /** 번들에서 제외할 외부 모듈 */
+  external?: string[];
+}
+
+/**
+ * package.json에서 solid-js 의존성 감지
+ */
+function hasSolidDependency(pkgDir: string): boolean {
+  const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
+  const allDeps = { ...pkgJson.dependencies, ...pkgJson.peerDependencies };
+  return "solid-js" in allDeps;
+}
+
+/**
+ * Library용 esbuild 설정 생성
+ *
+ * node/browser/neutral 타겟의 라이브러리 패키지 빌드에 사용합니다.
+ * - bundle: false (개별 파일을 각각 트랜스파일)
+ * - platform: target이 node면 node, 그 외는 browser
+ * - target: node면 node20, 그 외는 chrome84
+ */
+export function createLibraryEsbuildOptions(options: LibraryEsbuildOptions): esbuild.BuildOptions {
+  const plugins: esbuild.Plugin[] = [esmRelativeImportPlugin(path.join(options.pkgDir, "dist"))];
+
+  if (hasSolidDependency(options.pkgDir)) {
+    plugins.unshift(solidPlugin());
+  }
+
+  return {
+    entryPoints: options.entryPoints,
+    outdir: path.join(options.pkgDir, "dist"),
+    format: "esm",
+    sourcemap: true,
+    sourcesContent: false,
+    platform: options.target === "node" ? "node" : "browser",
+    target: options.target === "node" ? "node20" : "chrome84",
+    bundle: false,
+    tsconfigRaw: { compilerOptions: options.compilerOptions as esbuild.TsconfigRaw["compilerOptions"] },
+    plugins,
+  };
+}
+
+/**
+ * Server용 esbuild 설정 생성
+ *
+ * 서버 패키지 빌드에 사용합니다.
+ * - bundle: true (모든 의존성 포함한 단일 번들)
+ * - minify: true (코드 보호를 위한 압축)
+ * - banner: CJS 패키지의 require() 지원을 위한 createRequire shim
+ * - env를 define 옵션으로 치환 (process.env["KEY"] 형태)
+ */
+export function createServerEsbuildOptions(options: ServerEsbuildOptions): esbuild.BuildOptions {
+  const define: Record<string, string> = {};
+  if (options.env != null) {
+    for (const [key, value] of Object.entries(options.env)) {
+      define[`process.env["${key}"]`] = JSON.stringify(value);
+    }
+  }
+
+  return {
+    entryPoints: options.entryPoints,
+    outdir: path.join(options.pkgDir, "dist"),
+    format: "esm",
+    minify: true,
+    platform: "node",
+    target: "node20",
+    bundle: true,
+    banner: {
+      js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);",
+    },
+    external: options.external,
+    define,
+    tsconfigRaw: { compilerOptions: options.compilerOptions as esbuild.TsconfigRaw["compilerOptions"] },
+  };
+}
+
+/**
+ * 빌드 타겟에서 TypecheckEnv 추출
+ *
+ * 빌드용이므로 neutral은 browser로 처리합니다.
+ * (neutral 패키지는 Node/브라우저 공용이지만, 빌드 시에는 browser 환경 기준으로 처리)
+ */
+export function getTypecheckEnvFromTarget(target: "node" | "browser" | "neutral"): TypecheckEnv {
+  return target === "node" ? "node" : "browser";
+}
+
+//#region Optional Peer Deps
+
+interface PkgJson {
+  dependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
+}
+
+/**
+ * 의존성 트리에서 미설치 optional peer dep 수집
+ *
+ * 서버 빌드(bundle: true) 시 설치되지 않은 optional peer dependency를
+ * esbuild external로 지정하여 빌드 실패를 방지한다.
+ */
+export function collectUninstalledOptionalPeerDeps(pkgDir: string): string[] {
+  const external = new Set<string>();
+  const visited = new Set<string>();
+
+  const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
+  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+    scanOptionalPeerDeps(dep, pkgDir, external, visited);
+  }
+
+  return [...external];
+}
+
+function scanOptionalPeerDeps(pkgName: string, resolveDir: string, external: Set<string>, visited: Set<string>): void {
+  if (visited.has(pkgName)) return;
+  visited.add(pkgName);
+
+  const req = createRequire(path.join(resolveDir, "noop.js"));
+
+  let pkgJsonPath: string;
+  try {
+    pkgJsonPath = req.resolve(`${pkgName}/package.json`);
+  } catch {
+    return;
+  }
+
+  const depDir = path.dirname(pkgJsonPath);
+  const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8")) as PkgJson;
+
+  if (pkgJson.peerDependenciesMeta != null) {
+    const peerDeps = pkgJson.peerDependencies ?? {};
+    const depReq = createRequire(path.join(depDir, "noop.js"));
+    for (const [name, meta] of Object.entries(pkgJson.peerDependenciesMeta)) {
+      if (meta.optional === true && name in peerDeps) {
+        try {
+          depReq.resolve(name);
+        } catch {
+          external.add(name);
+        }
+      }
+    }
+  }
+
+  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+    scanOptionalPeerDeps(dep, depDir, external, visited);
+  }
+}
+
+//#endregion
+
+//#region Native Module Externals
+
+/**
+ * 의존성 중 binding.gyp가 있는 네이티브 모듈 수집
+ *
+ * node-gyp로 빌드되는 네이티브 모듈은 esbuild가 번들링할 수 없으므로
+ * external로 지정해야 한다.
+ */
+export function collectNativeModuleExternals(pkgDir: string): string[] {
+  const external = new Set<string>();
+  const visited = new Set<string>();
+
+  const pkgJson = JSON.parse(readFileSync(path.join(pkgDir, "package.json"), "utf-8")) as PkgJson;
+  for (const dep of Object.keys(pkgJson.dependencies ?? {})) {
+    scanNativeModules(dep, pkgDir, external, visited);
+  }
+
+  return [...external];
+}
+
+function scanNativeModules(pkgName: string, resolveDir: string, external: Set<string>, visited: Set<string>): void {
+  if (visited.has(pkgName)) return;
+  visited.add(pkgName);
+
+  const req = createRequire(path.join(resolveDir, "noop.js"));
+
+  let pkgJsonPath: string;
+  try {
+    pkgJsonPath = req.resolve(`${pkgName}/package.json`);
+  } catch {
+    return;
+  }
+
+  const depDir = path.dirname(pkgJsonPath);
+
+  // binding.gyp 존재 여부로 네이티브 모듈 감지
+  if (existsSync(path.join(depDir, "binding.gyp"))) {
+    external.add(pkgName);
+  }
+
+  // 하위 dependencies도 재귀 탐색
+  const depPkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8")) as PkgJson;
+  for (const dep of Object.keys(depPkgJson.dependencies ?? {})) {
+    scanNativeModules(dep, depDir, external, visited);
+  }
+}
+
+//#endregion

package/src/utils/listr-manager.ts

@@ -0,0 +1,89 @@
+import { EventEmitter } from "node:events";
+import { Listr } from "listr2";
+import type { consola } from "consola";
+
+/**
+ * RebuildListrManager 이벤트 타입
+ */
+interface RebuildListrManagerEvents {
+  batchComplete: [];
+}
+
+/**
+ * 리빌드 시 Listr 실행을 관리하는 클래스
+ *
+ * 여러 Worker가 동시에 buildStart를 발생시킬 때, 한 번에 하나의 Listr만 실행되도록 보장합니다.
+ * 실행 중에 들어온 빌드 요청은 pending에 모아두었다가 현재 배치가 완료되면 다음 배치로 실행합니다.
+ *
+ * EventEmitter를 확장하여 배치 완료 시 `batchComplete` 이벤트를 발생시킵니다.
+ */
+export class RebuildListrManager extends EventEmitter<RebuildListrManagerEvents> {
+  private _isRunning = false;
+  private readonly _pendingBuilds = new Map<string, { title: string; promise: Promise<void>; resolver: () => void }>();
+
+  constructor(private readonly _logger: ReturnType<typeof consola.withTag>) {
+    super();
+  }
+
+  /**
+   * 빌드를 등록하고 resolver 함수를 반환합니다.
+   *
+   * @param key - 빌드를 식별하는 고유 키 (예: "core-common:build")
+   * @param title - Listr에 표시할 제목 (예: "core-common (node)")
+   * @returns 워커가 빌드 완료 시 호출할 resolver 함수
+   */
+  registerBuild(key: string, title: string): () => void {
+    let resolver!: () => void;
+    const promise = new Promise<void>((resolve) => {
+      resolver = resolve;
+    });
+
+    this._pendingBuilds.set(key, { title, promise, resolver });
+
+    // Listr가 실행 중이 아니면 다음 tick에 배치 실행
+    if (!this._isRunning) {
+      void Promise.resolve().then(() => void this._runBatch());
+    }
+
+    return resolver;
+  }
+
+  /**
+   * pending에 있는 빌드들을 모아서 하나의 Listr로 실행합니다.
+   * 실행 중에 들어온 새 빌드는 다음 배치로 넘어갑니다.
+   */
+  private async _runBatch(): Promise<void> {
+    if (this._isRunning || this._pendingBuilds.size === 0) {
+      return;
+    }
+
+    this._isRunning = true;
+
+    // 현재 pending을 스냅샷으로 가져옴
+    const batchBuilds = new Map(this._pendingBuilds);
+    this._pendingBuilds.clear();
+
+    // Listr 태스크 생성
+    const tasks = Array.from(batchBuilds.entries()).map(([, { title, promise }]) => ({
+      title,
+      task: () => promise,
+    }));
+
+    const listr = new Listr(tasks, { concurrent: true });
+
+    try {
+      await listr.run();
+      // 배치 완료 이벤트 발생
+      this.emit("batchComplete");
+    } catch (err) {
+      this._logger.error("listr 실행 중 오류 발생", { error: String(err) });
+    }
+
+    this._isRunning = false;
+
+    // 실행 중 새로 들어온 pending이 있으면 다음 배치 실행
+    if (this._pendingBuilds.size > 0) {
+      void this._runBatch();
+    }
+  }
+}

package/src/utils/output-utils.ts

@@ -0,0 +1,61 @@
+import { consola } from "consola";
+import type { BuildResult } from "../infra/ResultCollector";
+import type { PackageResult } from "./package-utils";
+
+/**
+ * printErrors에서 사용되는 결과 타입
+ * PackageResult와 BuildResult 모두 지원
+ */
+type ErrorResult = PackageResult | BuildResult;
+
+/**
+ * 에러만 출력한다.
+ * 성공한 빌드는 listr의 체크마크로 이미 표시되므로 별도 출력하지 않음.
+ * @param results 패키지별 빌드 결과 상태
+ */
+export function printErrors(results: Map<string, ErrorResult>): void {
+  for (const result of results.values()) {
+    if (result.status === "error") {
+      const typeLabel = result.type === "dts" ? "dts" : result.target;
+      const errorLines: string[] = [`${result.name} (${typeLabel})`];
+      if (result.message != null && result.message !== "") {
+        for (const line of result.message.split("\n")) {
+          errorLines.push(`  → ${line}`);
+        }
+      }
+      consola.error(errorLines.join("\n"));
+    }
+  }
+}
+
+/**
+ * 서버 URL만 출력한다.
+ * @param results 패키지별 빌드 결과 상태
+ * @param serverClientsMap 서버별 연결된 클라이언트 목록
+ */
+export function printServers(results: Map<string, PackageResult>, serverClientsMap?: Map<string, string[]>): void {
+  // 서버 정보 수집
+  const servers = [...results.values()].filter((r) => r.status === "server" && r.port != null);
+
+  // 서버 정보 출력 (있으면 앞에 빈 줄 추가)
+  if (servers.length > 0) {
+    process.stdout.write("\n");
+    for (const server of servers) {
+      if (server.target === "server") {
+        // 서버에 연결된 클라이언트가 있으면 클라이언트 URL만 출력
+        const clients = serverClientsMap?.get(server.name) ?? [];
+        if (clients.length > 0) {
+          for (const clientName of clients) {
+            consola.info(`[server] http://localhost:${server.port}/${clientName}/`);
+          }
+        } else {
+          // 연결된 클라이언트가 없으면 서버 루트 URL 출력
+          consola.info(`[server] http://localhost:${server.port}/`);
+        }
+      } else {
+        // standalone client는 이름 포함해서 출력
+        consola.info(`[server] http://localhost:${server.port}/${server.name}/`);
+      }
+    }
+  }
+}

package/src/utils/package-utils.ts

@@ -0,0 +1,63 @@
+import type { SdPackageConfig } from "../sd-config.types";
+
+/**
+ * 패키지명에서 watch scope 목록을 생성한다.
+ * - 패키지명의 scope (예: "@myapp/root" → "@myapp")
+ * - @simplysm (항상 포함)
+ * @param packageName 루트 package.json의 name 필드
+ * @returns scope 배열 (중복 제거)
+ */
+export function getWatchScopes(packageName: string): string[] {
+  const scopes = new Set(["@simplysm"]);
+  const match = packageName.match(/^(@[^/]+)\//);
+  if (match != null) {
+    scopes.add(match[1]);
+  }
+  return [...scopes];
+}
+
+/**
+ * 패키지 결과 상태
+ */
+export interface PackageResult {
+  name: string;
+  target: string;
+  type: "build" | "dts" | "server" | "capacitor";
+  status: "success" | "error" | "server";
+  message?: string;
+  port?: number;
+}
+
+/**
+ * 패키지 설정에서 targets 필터링 (scripts 타겟 제외)
+ * @param packages 패키지 설정 맵
+ * @param targets 필터링할 패키지 이름 목록. 빈 배열이면 scripts를 제외한 모든 패키지 반환
+ * @returns 필터링된 패키지 설정 맵
+ * @internal 테스트용으로 export
+ */
+export function filterPackagesByTargets(
+  packages: Record<string, SdPackageConfig | undefined>,
+  targets: string[],
+): Record<string, SdPackageConfig> {
+  const result: Record<string, SdPackageConfig> = {};
+
+  for (const [name, config] of Object.entries(packages)) {
+    if (config == null) continue;
+
+    // scripts 타겟은 watch/dev 대상에서 제외
+    if (config.target === "scripts") continue;
+
+    // targets가 비어있으면 모든 패키지 포함
+    if (targets.length === 0) {
+      result[name] = config;
+      continue;
+    }
+
+    // targets에 포함된 패키지만 필터링
+    if (targets.includes(name)) {
+      result[name] = config;
+    }
+  }
+
+  return result;
+}