create-mendix-widget-gleam 1.0.0

package/bin/create-mendix-widget-gleam.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { main } from "../src/index.mjs";
+
+main(process.argv.slice(2));

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "create-mendix-widget-gleam",
+  "version": "1.0.0",
+  "description": "Scaffold a Mendix Pluggable Widget powered by Gleam",
+  "type": "module",
+  "license": "Apache-2.0",
+  "bin": "bin/create-mendix-widget-gleam.mjs",
+  "files": [
+    "bin/",
+    "src/",
+    "template/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mendix",
+    "gleam",
+    "widget",
+    "pluggable-widget",
+    "scaffold",
+    "create"
+  ]
+}

package/src/index.mjs

@@ -0,0 +1,291 @@
+/**
+ * create-mendix-widget-gleam 메인 오케스트레이션
+ */
+
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdir } from "node:fs/promises";
+import { execSync } from "node:child_process";
+import { collectOptions } from "./prompts.mjs";
+import { generateNames } from "./naming.mjs";
+import { getPmConfig } from "./pm.mjs";
+import { scaffold } from "./scaffold.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_DIR = resolve(__dirname, "..", "template");
+
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+const DIM = "\x1b[2m";
+const YELLOW = "\x1b[33m";
+
+const VERSION = "1.0.0";
+
+const HELP = `
+${BOLD}create-mendix-widget-gleam${RESET} — Gleam + Mendix Pluggable Widget 프로젝트 생성
+
+${BOLD}사용법:${RESET}
+  npx create-mendix-widget-gleam [project-name]
+
+${BOLD}옵션:${RESET}
+  --help, -h       도움말 표시
+  --version, -v    버전 표시
+
+${BOLD}예시:${RESET}
+  npx create-mendix-widget-gleam my-cool-widget
+  npx create-mendix-widget-gleam MyCoolWidget
+`;
+
+export async function main(args) {
+  // 플래그 처리
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(HELP);
+    return;
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(VERSION);
+    return;
+  }
+
+  console.log(
+    `\n${BOLD}${CYAN}create-mendix-widget-gleam${RESET} ${DIM}v${VERSION}${RESET}\n`,
+  );
+
+  // CLI 인자에서 프로젝트명 추출 (플래그 제외)
+  const positional = args.filter((a) => !a.startsWith("-"));
+  const cliProjectName = positional[0] || null;
+
+  // 프롬프트로 설정 수집
+  const { projectName, pm } = await collectOptions(cliProjectName);
+
+  // 이름 변환
+  const names = generateNames(projectName);
+  if (!names) {
+    console.error(`${YELLOW}오류: 유효하지 않은 프로젝트 이름입니다.${RESET}`);
+    process.exit(1);
+  }
+
+  const pmConfig = getPmConfig(pm);
+  const targetDir = resolve(process.cwd(), names.kebabCase);
+
+  // 요약 표시
+  console.log(`\n${BOLD}프로젝트 설정:${RESET}`);
+  console.log(`  디렉토리:       ${CYAN}${names.kebabCase}/${RESET}`);
+  console.log(`  위젯 이름:      ${names.pascalCase}`);
+  console.log(`  Gleam 모듈:     ${names.snakeCase}`);
+  console.log(`  패키지 매니저:  ${pm}`);
+  console.log();
+
+  // 디렉토리 생성
+  await mkdir(targetDir, { recursive: true });
+
+  // 템플릿 스케폴딩
+  console.log(`${DIM}파일 생성 중...${RESET}`);
+  const created = await scaffold(TEMPLATE_DIR, targetDir, names, pmConfig);
+  console.log(`${GREEN}✓${RESET} ${created.length}개 파일 생성 완료`);
+
+  // CLAUDE.md 생성
+  await generateClaudeMd(targetDir, names, pm, pmConfig);
+  console.log(`${GREEN}✓${RESET} CLAUDE.md 생성 완료`);
+
+  // README.md 생성
+  await generateReadme(targetDir, names, pm, pmConfig);
+  console.log(`${GREEN}✓${RESET} README.md 생성 완료`);
+
+  // git init
+  try {
+    execSync("git init", { cwd: targetDir, stdio: "ignore" });
+    console.log(`${GREEN}✓${RESET} git 저장소 초기화 완료`);
+  } catch {
+    // git이 없어도 계속 진행
+  }
+
+  // 완료 메시지
+  console.log(`
+${GREEN}${BOLD}프로젝트가 생성되었습니다!${RESET}
+
+${BOLD}다음 단계:${RESET}
+
+  ${CYAN}cd ${names.kebabCase}${RESET}
+  ${CYAN}gleam run -m scripts/install${RESET}   ${DIM}# 의존성 설치${RESET}
+  ${CYAN}gleam run -m scripts/dev${RESET}       ${DIM}# 개발 서버 시작${RESET}
+  ${CYAN}gleam run -m scripts/build${RESET}     ${DIM}# 프로덕션 빌드${RESET}
+`);
+}
+
+/** CLAUDE.md 생성 */
+async function generateClaudeMd(targetDir, names, pm, pmConfig) {
+  const { writeFile } = await import("node:fs/promises");
+
+  const content = `# ${names.pascalCase}
+
+Gleam 언어로 Mendix Pluggable Widget을 개발하여 "Hello World"를 화면에 렌더링하는 프로젝트.
+
+## Goal
+
+**JSX를 사용하지 않고, 오직 Gleam으로만** 위젯을 작성한다. Gleam 코드를 JavaScript로 컴파일하고, 컴파일된 JS가 곧 Mendix Pluggable Widget의 진입점이 된다.
+
+## Tech Stack
+
+- **Gleam** → JavaScript 컴파일 (target: javascript)
+- **Gleam FFI** (\`@external\` 어노테이션 + \`.ffi.mjs\` 파일) — React API를 Gleam에서 직접 호출
+- **Mendix Pluggable Widget** (React 19)
+- **Package Manager**: ${pm} (npm 의존성은 \`gleam run -m scripts/install\`로 설치)
+- **Build**: \`@mendix/pluggable-widgets-tools\` (Rollup 기반)
+
+## Architecture
+
+\`\`\`
+src/
+  widget/                             # 핵심 Gleam 코드 (개발자가 작업하는 곳)
+    ${names.snakeCase}.gleam           #   위젯 메인 모듈
+    ${names.snakeCase}_ffi.mjs         #   React FFI 어댑터
+    editor_config.gleam               #   Studio Pro 속성 패널 설정
+  scripts/                            # 빌드/개발 스크립트 (gleam run -m으로 실행)
+    cmd.gleam                         #   셸 명령어 실행 유틸리티
+    cmd_ffi.mjs                       #   Node.js child_process FFI
+    install.gleam                     #   npm 의존성 설치
+    build.gleam                       #   프로덕션 빌드
+    dev.gleam                         #   개발 서버
+    start.gleam                       #   Mendix 테스트 프로젝트 연동
+    release.gleam                     #   릴리즈 빌드
+    lint.gleam                        #   ESLint 실행
+    lint_fix.gleam                    #   ESLint 자동 수정
+  ${names.pascalCase}.js                # 브릿지 진입점
+  ${names.pascalCase}.editorConfig.js   # 브릿지 (editorConfig)
+  ${names.pascalCase}.xml               # 위젯 속성 정의
+  package.xml                         # Mendix 패키지 매니페스트
+  ui/
+    ${names.pascalCase}.css             # 위젯 스타일시트
+gleam.toml                            # Gleam 프로젝트 설정
+docs/
+  gleam_language_tour.md              # Gleam 언어 레퍼런스
+\`\`\`
+
+## Build Pipeline
+
+\`\`\`
+[src/widget/${names.snakeCase}.gleam] + [src/widget/${names.snakeCase}_ffi.mjs]
+    ↓  gleam run -m scripts/build
+[build/dev/javascript/${names.snakeCase}/widget/${names.snakeCase}.mjs]
+    ↓  src/${names.pascalCase}.js (브릿지)가 import
+    ↓  Rollup (pluggable-widgets-tools build:web)
+[dist/1.0.0/mendix.${names.lowerCase}.${names.pascalCase}.mpk]
+\`\`\`
+
+## Commands
+
+\`\`\`bash
+gleam run -m scripts/install   # 의존성 설치
+gleam run -m scripts/build     # 위젯 프로덕션 빌드 (.mpk 생성)
+gleam run -m scripts/dev       # 개발 서버 (HMR, port 3000)
+gleam run -m scripts/start     # Mendix 테스트 프로젝트와 연동 개발
+gleam run -m scripts/lint      # ESLint 실행
+gleam run -m scripts/lint_fix  # ESLint 자동 수정
+gleam run -m scripts/release   # 릴리즈 빌드
+gleam build --target javascript  # Gleam → JS 컴파일만
+gleam test                       # Gleam 테스트 실행
+gleam format                     # Gleam 코드 포맷팅
+\`\`\`
+
+## Gleam FFI Convention
+
+- FFI 파일명: \`<module_name>_ffi.mjs\`
+- \`@external(javascript, "./<module>_ffi.mjs", "<function>")\` 형식으로 바인딩
+- FFI 파일에는 React API 래핑만 작성. 위젯 로직은 반드시 Gleam으로 작성
+
+## Mendix Widget Conventions
+
+- 위젯 ID: \`mendix.${names.lowerCase}.${names.pascalCase}\`
+- JSX 파일을 작성하지 않는다. 모든 React 로직은 Gleam + FFI로 구현
+- Redraw 등 외부 Gleam React 라이브러리는 사용하지 않는다
+
+## Code Style
+
+- Gleam 파일: \`gleam format\` 사용
+- FFI 파일(\`.ffi.mjs\`): React API 노출만 담당, 최소한으로 유지
+- 한국어 주석 사용
+`;
+
+  await writeFile(join(targetDir, "CLAUDE.md"), content, "utf-8");
+}
+
+/** README.md 생성 */
+async function generateReadme(targetDir, names, pm, pmConfig) {
+  const { writeFile } = await import("node:fs/promises");
+
+  const runCmd = pm === "npm" ? "npm run" : pm;
+
+  const content = `# ${names.pascalCase}
+
+Gleam 언어로 작성된 Mendix Pluggable Widget.
+
+## 시작하기
+
+### 사전 요구사항
+
+- [Gleam](https://gleam.run/getting-started/installing/) (최신 버전)
+- [Node.js](https://nodejs.org/) (v18+)
+- ${pm}
+
+### 설치
+
+\`\`\`bash
+gleam run -m scripts/install
+\`\`\`
+
+### 개발
+
+\`\`\`bash
+gleam run -m scripts/dev
+\`\`\`
+
+### 빌드
+
+\`\`\`bash
+gleam run -m scripts/build
+\`\`\`
+
+빌드 결과물(\`.mpk\`)은 \`dist/\` 디렉토리에 생성됩니다.
+
+### 기타 명령어
+
+\`\`\`bash
+gleam run -m scripts/start      # Mendix 테스트 프로젝트 연동
+gleam run -m scripts/lint       # ESLint 실행
+gleam run -m scripts/lint_fix   # ESLint 자동 수정
+gleam run -m scripts/release    # 릴리즈 빌드
+gleam build --target javascript # Gleam → JS 컴파일만
+gleam test                      # 테스트 실행
+gleam format                    # 코드 포맷팅
+\`\`\`
+
+## 프로젝트 구조
+
+\`\`\`
+src/
+  widget/                          # Gleam 위젯 코드
+    ${names.snakeCase}.gleam        #   메인 위젯 모듈
+    ${names.snakeCase}_ffi.mjs      #   React FFI 어댑터
+    editor_config.gleam            #   Studio Pro 속성 패널
+  scripts/                         # 빌드/개발 스크립트
+  ${names.pascalCase}.js             # Mendix 브릿지 진입점
+  ${names.pascalCase}.xml            # 위젯 속성 정의
+\`\`\`
+
+## 기술 스택
+
+- **Gleam** → JavaScript 컴파일
+- **Gleam FFI** — React API 직접 바인딩
+- **Mendix Pluggable Widget** (React 19)
+- **${pm}** — 패키지 매니저
+
+## 라이센스
+
+Apache-2.0
+`;
+
+  await writeFile(join(targetDir, "README.md"), content, "utf-8");
+}

package/src/naming.mjs

@@ -0,0 +1,56 @@
+/**
+ * 이름 변환 유틸리티
+ * 사용자 입력을 다양한 형식으로 변환한다.
+ */
+
+/** 입력 문자열을 단어 배열로 분리 */
+export function splitWords(input) {
+  // PascalCase / camelCase 경계에서 분리
+  let result = input.replace(/([a-z])([A-Z])/g, "$1 $2");
+  // 숫자-문자 경계
+  result = result.replace(/([0-9])([a-zA-Z])/g, "$1 $2");
+  result = result.replace(/([a-zA-Z])([0-9])/g, "$1 $2");
+  // 구분자(-, _, 공백)로 분리
+  return result
+    .split(/[-_\s]+/)
+    .map((w) => w.trim().toLowerCase())
+    .filter((w) => w.length > 0);
+}
+
+/** PascalCase: MyCoolWidget */
+export function toPascalCase(words) {
+  return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+
+/** snake_case: my_cool_widget */
+export function toSnakeCase(words) {
+  return words.join("_");
+}
+
+/** lowercase: mycoolwidget */
+export function toLowerCase(words) {
+  return words.join("");
+}
+
+/** Display Name: My Cool Widget */
+export function toDisplayName(words) {
+  return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+
+/** kebab-case: my-cool-widget */
+export function toKebabCase(words) {
+  return words.join("-");
+}
+
+/** 모든 형식을 한 번에 생성 */
+export function generateNames(input) {
+  const words = splitWords(input);
+  if (words.length === 0) return null;
+  return {
+    pascalCase: toPascalCase(words),
+    snakeCase: toSnakeCase(words),
+    lowerCase: toLowerCase(words),
+    displayName: toDisplayName(words),
+    kebabCase: toKebabCase(words),
+  };
+}

package/src/pm.mjs

@@ -0,0 +1,26 @@
+/**
+ * 패키지 매니저 설정
+ */
+
+const PM_CONFIG = {
+  npm: { install: "npm install", runner: "npx" },
+  yarn: { install: "yarn install", runner: "npx" },
+  pnpm: { install: "pnpm install", runner: "pnpm exec" },
+  bun: { install: "bun install", runner: "bunx" },
+};
+
+export const PM_CHOICES = Object.keys(PM_CONFIG);
+
+/** 패키지 매니저별 명령어 반환 */
+export function getPmConfig(pm) {
+  return PM_CONFIG[pm] || PM_CONFIG.npm;
+}
+
+/** 실행 환경에서 패키지 매니저 자동 감지 */
+export function detectPm() {
+  const ua = process.env.npm_config_user_agent || "";
+  if (ua.startsWith("pnpm/")) return "pnpm";
+  if (ua.startsWith("yarn/")) return "yarn";
+  if (ua.startsWith("bun/")) return "bun";
+  return "npm";
+}

package/src/prompts.mjs

@@ -0,0 +1,116 @@
+/**
+ * 인터랙티브 프롬프트 (node:readline 기반)
+ */
+
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { splitWords } from "./naming.mjs";
+import { PM_CHOICES, detectPm } from "./pm.mjs";
+
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const CYAN = "\x1b[36m";
+const YELLOW = "\x1b[33m";
+
+/** 프로젝트 이름 검증 */
+function validateName(name) {
+  if (!name || name.trim().length === 0) {
+    return "프로젝트 이름을 입력해주세요.";
+  }
+  const words = splitWords(name.trim());
+  if (words.length === 0) {
+    return "유효한 영문자를 포함해야 합니다.";
+  }
+  // 영문자, 숫자, -, _ 만 허용
+  if (!/^[a-zA-Z][a-zA-Z0-9\-_]*$/.test(name.trim())) {
+    return "영문자로 시작해야 하며, 영문자/숫자/-/_ 만 사용 가능합니다.";
+  }
+  return null;
+}
+
+/** 인터랙티브 프롬프트로 설정 수집 */
+export async function collectOptions(cliProjectName) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  let done = false;
+
+  // Ctrl+C 처리 (프롬프트 완료 전에만)
+  rl.on("close", () => {
+    if (!done) {
+      console.log("\n취소되었습니다.");
+      process.exit(0);
+    }
+  });
+
+  let projectName = cliProjectName;
+
+  try {
+    // 1. 프로젝트 이름
+    if (!projectName) {
+      projectName = await rl.question(
+        `${BOLD}프로젝트 이름:${RESET} `,
+      );
+    }
+
+    const nameError = validateName(projectName);
+    if (nameError) {
+      done = true;
+      rl.close();
+      console.error(`\n${YELLOW}오류: ${nameError}${RESET}`);
+      process.exit(1);
+    }
+
+    projectName = projectName.trim();
+
+    // 디렉토리 충돌 확인
+    const targetDir = resolve(process.cwd(), projectName);
+    if (existsSync(targetDir)) {
+      done = true;
+      rl.close();
+      console.error(
+        `\n${YELLOW}오류: '${projectName}' 디렉토리가 이미 존재합니다.${RESET}`,
+      );
+      process.exit(1);
+    }
+
+    // 2. 패키지 매니저 선택
+    const detected = detectPm();
+    console.log(
+      `\n${BOLD}패키지 매니저 선택:${RESET} ${DIM}(감지: ${detected})${RESET}`,
+    );
+    PM_CHOICES.forEach((pm, i) => {
+      const marker = pm === detected ? ` ${CYAN}← 감지됨${RESET}` : "";
+      console.log(`  ${i + 1}) ${pm}${marker}`);
+    });
+
+    let pmAnswer = "";
+    try {
+      pmAnswer = await rl.question(
+        `선택 ${DIM}(1-${PM_CHOICES.length}, 기본: ${detected})${RESET}: `,
+      );
+    } catch {
+      // stdin이 닫혀도 기본값 사용
+    }
+
+    let pm = detected;
+    const pmIndex = parseInt(pmAnswer, 10);
+    if (pmIndex >= 1 && pmIndex <= PM_CHOICES.length) {
+      pm = PM_CHOICES[pmIndex - 1];
+    } else if (pmAnswer.trim() && PM_CHOICES.includes(pmAnswer.trim())) {
+      pm = pmAnswer.trim();
+    }
+
+    done = true;
+    rl.close();
+    return { projectName, pm };
+  } catch (err) {
+    done = true;
+    rl.close();
+    if (err.code === "ERR_USE_AFTER_CLOSE") {
+      process.exit(0);
+    }
+    throw err;
+  }
+}

package/src/scaffold.mjs

@@ -0,0 +1,90 @@
+/**
+ * 파일 복사 + 템플릿 치환
+ */
+
+import { readdir, readFile, writeFile, mkdir, copyFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+
+/** 바이너리 판별용 확장자 */
+const BINARY_EXTS = new Set([".png", ".jpg", ".gif", ".ico", ".woff", ".woff2", ".ttf", ".eot"]);
+
+/** 재귀적으로 디렉토리 내 모든 파일 경로를 수집 */
+async function walkDir(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await walkDir(fullPath)));
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+// npm publish 시 제외되는 dotfile을 언더스코어 접두사로 보관하고 복원
+const DOTFILE_MAP = { _gitignore: ".gitignore" };
+
+/** 파일명에서 플레이스홀더 치환 + dotfile 복원 */
+function replaceFileName(name, names) {
+  if (DOTFILE_MAP[name]) return DOTFILE_MAP[name];
+  return name
+    .replace(/__WidgetName__/g, names.pascalCase)
+    .replace(/__widget_name__/g, names.snakeCase);
+}
+
+/** 파일 내용에서 플레이스홀더 치환 */
+function replaceContent(content, names, pmConfig) {
+  return content
+    .replace(/\{\{PASCAL_CASE\}\}/g, names.pascalCase)
+    .replace(/\{\{SNAKE_CASE\}\}/g, names.snakeCase)
+    .replace(/\{\{LOWERCASE\}\}/g, names.lowerCase)
+    .replace(/\{\{DISPLAY_NAME\}\}/g, names.displayName)
+    .replace(/\{\{KEBAB_CASE\}\}/g, names.kebabCase)
+    .replace(/\{\{INSTALL_COMMAND\}\}/g, pmConfig.install)
+    .replace(/\{\{RUNNER\}\}/g, pmConfig.runner);
+}
+
+/**
+ * 템플릿을 대상 디렉토리에 스케폴딩
+ * @param {string} templateDir - 템플릿 디렉토리 경로
+ * @param {string} targetDir - 생성할 프로젝트 디렉토리 경로
+ * @param {object} names - 이름 변환 결과
+ * @param {object} pmConfig - 패키지 매니저 설정
+ */
+export async function scaffold(templateDir, targetDir, names, pmConfig) {
+  const files = await walkDir(templateDir);
+  const created = [];
+
+  for (const srcPath of files) {
+    // 템플릿 기준 상대 경로
+    const relPath = relative(templateDir, srcPath);
+
+    // 경로의 각 부분에서 파일명 치환
+    const destRelPath = relPath
+      .split(/[\\/]/)
+      .map((part) => replaceFileName(part, names))
+      .join("/");
+
+    const destPath = join(targetDir, destRelPath);
+    const ext = srcPath.substring(srcPath.lastIndexOf(".")).toLowerCase();
+
+    // 디렉토리 생성
+    await mkdir(join(destPath, ".."), { recursive: true });
+
+    if (BINARY_EXTS.has(ext)) {
+      // 바이너리 파일은 그대로 복사
+      await copyFile(srcPath, destPath);
+    } else {
+      // 텍스트 파일은 내용 치환
+      const content = await readFile(srcPath, "utf-8");
+      const replaced = replaceContent(content, names, pmConfig);
+      await writeFile(destPath, replaced, "utf-8");
+    }
+
+    created.push(destRelPath);
+  }
+
+  return created;
+}

package/template/.gitattributes

@@ -0,0 +1,21 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+*.ts text eol=lf
+*.tsx text eol=lf
+*.js text eol=lf
+*.jsx text eol=lf
+*.css text eol=lf
+*.scss text eol=lf
+*.json text eol=lf
+*.xml text eol=lf
+*.md text eol=lf
+*.gitattributes eol=lf
+*.gitignore eol=lf
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.jpg binary
+*.gif binary

package/template/.prettierignore

@@ -0,0 +1 @@
+tests/testProject/

package/template/LICENSE

@@ -0,0 +1,15 @@
+The Apache License v2.0
+
+Copyright © Mendix Technology BV 2026. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/template/_gitignore

@@ -0,0 +1,48 @@
+# 의존성
+node_modules/
+.yarn/
+.pnp.*
+
+# 패키지 매니저 lock 파일
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+bun.lockb
+bun.lock
+
+# 패키지 매니저 캐시/설정
+.npmrc
+.yarnrc
+.yarnrc.yml
+.pnpmfile.cjs
+.npmignore
+
+# Gleam 컴파일 출력
+build/
+
+# Mendix 위젯 빌드 출력
+dist/
+
+# 환경 변수
+.env
+
+# 로그
+*.log
+
+# OS
+.DS_Store
+
+# IDE
+.idea/
+.vscode/
+*.launch
+
+# Mendix 테스트 프로젝트
+tests/testProject/
+
+# 테스트 산출물
+coverage/
+**/e2e/diffs/
+**/screenshot/
+**/screenshot-results/
+**/artifacts/