@easy-editor/easypack 0.0.2

package/dist/bin.js

@@ -0,0 +1,1076 @@
+#!/usr/bin/env node
+import mri from 'mri';
+import pc from 'picocolors';
+import { spawn } from 'node:child_process';
+import { rollup } from 'rollup';
+import { build } from 'esbuild';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import babel from '@rollup/plugin-babel';
+import commonjs from '@rollup/plugin-commonjs';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import json from '@rollup/plugin-json';
+import alias from '@rollup/plugin-alias';
+import cleanup from 'rollup-plugin-cleanup';
+import postcss from 'rollup-plugin-postcss';
+import terser from '@rollup/plugin-terser';
+import { createServer } from 'vite';
+import react from '@vitejs/plugin-react';
+import { WebSocketServer, WebSocket } from 'ws';
+import * as prompts from '@clack/prompts';
+
+const materialPreset = {
+  entry: {
+    main: 'src/index.tsx',
+    meta: 'src/meta.ts',
+    component: 'src/component.tsx'
+  },
+  output: {
+    dir: 'dist',
+    umd: true,
+    minify: true
+  },
+  css: {
+    scopedName: '[name]__[local]___[hash:base64:5]',
+    mode: 'inject'
+  },
+  jsxRuntime: 'automatic',
+  dev: {
+    port: 5001,
+    materialApi: true
+  }
+};
+
+const setterPreset = {
+  entry: {
+    main: 'src/index.ts'
+  },
+  output: {
+    dir: 'dist',
+    umd: true,
+    minify: true
+  },
+  css: {
+    scopedName: '[name]-[local]-[hash:base64:5]',
+    mode: 'extract',
+    extractFilename: 'index.css'
+  },
+  jsxRuntime: 'classic',
+  alias: {
+    '@': './src'
+  },
+  dev: {
+    port: 5002,
+    materialApi: false
+  }
+};
+
+const libraryPreset = {
+  entry: {
+    main: 'src/index.ts'
+  },
+  output: {
+    dir: 'dist',
+    umd: true,
+    minify: true
+  },
+  css: {
+    scopedName: '[name]__[local]___[hash:base64:5]',
+    mode: 'inject'
+  },
+  jsxRuntime: 'automatic',
+  dev: {
+    port: 5000,
+    materialApi: false
+  }
+};
+
+function getPreset(preset) {
+  switch (preset) {
+    case 'material':
+      return materialPreset;
+    case 'setter':
+      return setterPreset;
+    case 'library':
+      return libraryPreset;
+    default:
+      throw new Error(`Unknown preset: ${preset}`);
+  }
+}
+
+const DEFAULT_EXTERNALS$1 = ['react', 'react-dom', 'react/jsx-runtime'];
+const DEFAULT_GLOBALS$1 = {
+  react: 'React',
+  'react-dom': 'ReactDOM',
+  'react/jsx-runtime': 'jsxRuntime'
+};
+const DEFAULT_ENTRY = {
+  main: 'src/index.ts',
+  meta: 'src/meta.ts',
+  component: 'src/component.tsx'
+};
+const DEFAULT_OUTPUT = {
+  dir: 'dist',
+  esm: false,
+  cjs: false,
+  umd: true,
+  minify: true,
+  sourcemap: false,
+  types: false
+};
+const DEFAULT_CSS = {
+  scopedName: '[name]__[local]___[hash:base64:5]',
+  mode: 'inject',
+  extractFilename: 'index.css'
+};
+const DEFAULT_DEV = {
+  port: 5001,
+  materialApi: true
+};
+function deriveGlobalName(pkgName) {
+  const withoutScope = pkgName.replace(/^@[^/]+\//, '');
+  if (withoutScope.startsWith('materials-dashboard-')) {
+    const componentName = withoutScope.replace('materials-dashboard-', '');
+    return `EasyEditorMaterials${toPascalCase(componentName)}`;
+  }
+  return `EasyEditor${toPascalCase(withoutScope)}`;
+}
+function toPascalCase(str) {
+  return str.split('-').map(part => part.charAt(0).toUpperCase() + part.slice(1)).join('');
+}
+function deepMerge(target, source) {
+  const result = {
+    ...target
+  };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue !== undefined && typeof sourceValue === 'object' && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === 'object' && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+    } else if (sourceValue !== undefined) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function resolveConfig(userConfig, pkg) {
+  const presetConfig = getPreset(userConfig.preset);
+  const merged = deepMerge(presetConfig, userConfig);
+  const resolved = {
+    preset: userConfig.preset,
+    globalName: merged.globalName || deriveGlobalName(pkg.name),
+    entry: {
+      main: merged.entry?.main || DEFAULT_ENTRY.main,
+      meta: merged.entry?.meta || DEFAULT_ENTRY.meta,
+      component: merged.entry?.component || DEFAULT_ENTRY.component
+    },
+    output: {
+      dir: merged.output?.dir || DEFAULT_OUTPUT.dir,
+      esm: merged.output?.esm ?? DEFAULT_OUTPUT.esm,
+      cjs: merged.output?.cjs ?? DEFAULT_OUTPUT.cjs,
+      umd: merged.output?.umd ?? DEFAULT_OUTPUT.umd,
+      minify: merged.output?.minify ?? DEFAULT_OUTPUT.minify,
+      sourcemap: merged.output?.sourcemap ?? DEFAULT_OUTPUT.sourcemap,
+      types: merged.output?.types ?? DEFAULT_OUTPUT.types
+    },
+    external: {
+      externals: merged.external?.externals || DEFAULT_EXTERNALS$1,
+      globals: {
+        ...DEFAULT_GLOBALS$1,
+        ...merged.external?.globals
+      }
+    },
+    css: {
+      scopedName: merged.css?.scopedName || DEFAULT_CSS.scopedName,
+      mode: merged.css?.mode || DEFAULT_CSS.mode,
+      extractFilename: merged.css?.extractFilename || DEFAULT_CSS.extractFilename
+    },
+    jsxRuntime: merged.jsxRuntime || 'automatic',
+    alias: merged.alias || {},
+    dev: {
+      port: merged.dev?.port || DEFAULT_DEV.port,
+      materialApi: merged.dev?.materialApi ?? DEFAULT_DEV.materialApi
+    },
+    vitePlugins: merged.vitePlugins || [],
+    pkg
+  };
+  return resolved;
+}
+
+const CONFIG_FILES = ['easypack.config.ts', 'easypack.config.js', 'easypack.config.mjs'];
+function readPackageJson(cwd) {
+  const pkgPath = path.join(cwd, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    throw new Error(`package.json not found in ${cwd}`);
+  }
+  const content = fs.readFileSync(pkgPath, 'utf-8');
+  const pkg = JSON.parse(content);
+  return {
+    name: pkg.name || 'unknown',
+    version: pkg.version || '0.0.0'
+  };
+}
+async function loadConfigFile(configPath) {
+  const ext = path.extname(configPath);
+  if (ext === '.js' || ext === '.mjs') {
+    const module = await import(pathToFileURL(configPath).href);
+    return module.default;
+  }
+  const result = await build({
+    entryPoints: [configPath],
+    bundle: true,
+    format: 'esm',
+    platform: 'node',
+    write: false,
+    external: ['@easy-editor/easypack']
+  });
+  const code = result.outputFiles[0].text;
+  const tempFile = path.join(path.dirname(configPath), '.easypack.config.tmp.mjs');
+  fs.writeFileSync(tempFile, code);
+  try {
+    const module = await import(pathToFileURL(tempFile).href);
+    return module.default;
+  } finally {
+    try {
+      fs.unlinkSync(tempFile);
+    } catch {
+    }
+  }
+}
+function findConfigFile(cwd, customPath) {
+  if (customPath) {
+    const fullPath = path.isAbsolute(customPath) ? customPath : path.join(cwd, customPath);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+    throw new Error(`Config file not found: ${customPath}`);
+  }
+  for (const file of CONFIG_FILES) {
+    const fullPath = path.join(cwd, file);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function loadConfig(customConfigPath, cwd = process.cwd()) {
+  const configPath = findConfigFile(cwd, customConfigPath);
+  if (!configPath) {
+    throw new Error(`No config file found. Run \`easypack init\` to create one.\nSupported config files: ${CONFIG_FILES.join(', ')}`);
+  }
+  const pkg = readPackageJson(cwd);
+  const userConfig = await loadConfigFile(configPath);
+  return resolveConfig(userConfig, pkg);
+}
+
+const DEFAULT_EXTENSIONS = ['.js', '.ts', '.jsx', '.tsx'];
+
+function createPlugins(options) {
+  const {
+    config,
+    minify = false,
+    cwd = process.cwd()
+  } = options;
+  const plugins = [];
+  if (Object.keys(config.alias).length > 0) {
+    const entries = Object.entries(config.alias).map(([find, replacement]) => ({
+      find,
+      replacement: path.resolve(cwd, replacement)
+    }));
+    plugins.push(alias({
+      entries
+    }));
+  }
+  plugins.push(nodeResolve({
+    extensions: DEFAULT_EXTENSIONS
+  }));
+  plugins.push(commonjs());
+  plugins.push(json());
+  plugins.push(postcss({
+    modules: {
+      generateScopedName: config.css.scopedName
+    },
+    autoModules: true,
+    minimize: true,
+    inject: config.css.mode === 'inject',
+    extract: config.css.mode === 'extract' ? config.css.extractFilename : false
+  }));
+  plugins.push(babel({
+    extensions: DEFAULT_EXTENSIONS,
+    exclude: 'node_modules/**',
+    babelrc: false,
+    babelHelpers: 'bundled',
+    presets: [['@babel/preset-react', {
+      runtime: config.jsxRuntime
+    }], ['@babel/preset-typescript', {
+      allowDeclareFields: true
+    }]]
+  }));
+  plugins.push(cleanup({
+    comments: ['some', /PURE/],
+    extensions: ['.js', '.ts']
+  }));
+  if (minify) {
+    plugins.push(terser());
+  }
+  return plugins;
+}
+
+function createBanner(pkgName, version, suffix) {
+  const suffixPart = suffix ? ` (${suffix})` : '';
+  return `/* ${pkgName} v${version}${suffixPart} */`;
+}
+function getExternals(config) {
+  return config.external.externals;
+}
+function getGlobals(config) {
+  return config.external.globals;
+}
+function getUmdName(globalName, type) {
+  switch (type) {
+    case 'meta':
+      return `${globalName}Meta`;
+    case 'component':
+      return `${globalName}Component`;
+    default:
+      return globalName;
+  }
+}
+function getFilePrefix(type) {
+  switch (type) {
+    case 'meta':
+      return 'meta';
+    case 'component':
+      return 'component';
+    default:
+      return 'index';
+  }
+}
+function createOutputConfigs(options) {
+  const {
+    config,
+    input,
+    type,
+    cwd = process.cwd()
+  } = options;
+  const configs = [];
+  const external = getExternals(config);
+  const globals = getGlobals(config);
+  const umdName = getUmdName(config.globalName, type);
+  const filePrefix = getFilePrefix(type);
+  const {
+    pkg,
+    output: outputConfig
+  } = config;
+  const {
+    minify
+  } = outputConfig;
+  const plugins = createPlugins({
+    config,
+    minify,
+    cwd
+  });
+  if (outputConfig.esm) {
+    const filename = minify ? `${filePrefix}.min.esm.js` : `${filePrefix}.esm.js`;
+    configs.push({
+      input,
+      output: {
+        file: `${outputConfig.dir}/${filename}`,
+        format: 'esm',
+        sourcemap: outputConfig.sourcemap,
+        banner: createBanner(pkg.name, pkg.version, minify ? 'minified' : undefined),
+        exports: 'named'
+      },
+      plugins,
+      external
+    });
+  }
+  if (outputConfig.umd) {
+    const filename = minify ? `${filePrefix}.min.js` : `${filePrefix}.js`;
+    configs.push({
+      input,
+      output: {
+        file: `${outputConfig.dir}/${filename}`,
+        format: 'umd',
+        name: umdName,
+        globals,
+        sourcemap: outputConfig.sourcemap,
+        banner: createBanner(pkg.name, pkg.version, minify ? 'minified' : undefined),
+        exports: 'named'
+      },
+      plugins,
+      external
+    });
+  }
+  if (type === 'full' && outputConfig.cjs) {
+    const filename = minify ? `${filePrefix}.min.cjs` : `${filePrefix}.cjs`;
+    configs.push({
+      input,
+      output: {
+        file: `${outputConfig.dir}/${filename}`,
+        format: 'cjs',
+        sourcemap: outputConfig.sourcemap,
+        exports: 'named'
+      },
+      plugins,
+      external
+    });
+  }
+  return configs;
+}
+
+function entryExists(entry, cwd) {
+  const fullPath = path.join(cwd, entry);
+  return fs.existsSync(fullPath);
+}
+function createRollupConfig(options) {
+  const {
+    config,
+    cwd = process.cwd()
+  } = options;
+  const configs = [];
+  if (config.preset === 'material') {
+    if (config.entry.meta && entryExists(config.entry.meta, cwd)) {
+      configs.push(...createOutputConfigs({
+        config,
+        input: config.entry.meta,
+        type: 'meta',
+        cwd
+      }));
+    }
+    if (config.entry.component && entryExists(config.entry.component, cwd)) {
+      configs.push(...createOutputConfigs({
+        config,
+        input: config.entry.component,
+        type: 'component',
+        cwd
+      }));
+    }
+  }
+  if (config.entry.main && entryExists(config.entry.main, cwd)) {
+    configs.push(...createOutputConfigs({
+      config,
+      input: config.entry.main,
+      type: 'full',
+      cwd
+    }));
+  } else {
+    throw new Error(`Main entry file not found: ${config.entry.main}`);
+  }
+  return configs;
+}
+
+async function generateTypes(config) {
+  return new Promise((resolve, reject) => {
+    const args = ['tsc', '--declaration', '--emitDeclarationOnly', '--outDir', config.output.dir];
+    const tsc = spawn('npx', args, {
+      stdio: 'pipe'
+    });
+    let stderr = '';
+    tsc.stderr?.on('data', data => {
+      stderr += data.toString();
+    });
+    tsc.on('close', code => {
+      if (code === 0) {
+        resolve([`${config.output.dir}/index.d.ts`]);
+      } else {
+        reject(new Error(`TypeScript compilation failed:\n${stderr}`));
+      }
+    });
+    tsc.on('error', reject);
+  });
+}
+async function buildCommand(argv) {
+  const startTime = Date.now();
+  console.log(pc.cyan('Building for production...\n'));
+  const config = await loadConfig(argv.config);
+  console.log(pc.gray(`  Package: ${config.pkg.name}@${config.pkg.version}`));
+  console.log(pc.gray(`  Preset:  ${config.preset}`));
+  console.log(pc.gray(`  Output:  ${config.output.dir}/\n`));
+  const rollupConfigs = createRollupConfig({
+    config
+  });
+  let fileCount = 0;
+  for (const rollupConfig of rollupConfigs) {
+    const bundle = await rollup(rollupConfig);
+    const outputs = Array.isArray(rollupConfig.output) ? rollupConfig.output : [rollupConfig.output];
+    for (const output of outputs) {
+      if (output && output.file) {
+        await bundle.write(output);
+        console.log(pc.green(`  ✓ ${output.file}`));
+        fileCount++;
+      }
+    }
+    await bundle.close();
+  }
+  if (config.output.types) {
+    try {
+      const typeFiles = await generateTypes(config);
+      for (const file of typeFiles) {
+        console.log(pc.green(`  ✓ ${file}`));
+        fileCount++;
+      }
+    } catch (error) {
+      console.log(pc.yellow(`  ⚠ Types generation skipped (no tsconfig.json or tsc error)`));
+    }
+  }
+  const duration = Date.now() - startTime;
+  console.log('');
+  console.log(pc.green(`Build completed! `) + pc.gray(`(${fileCount} files in ${duration}ms)`));
+}
+
+const DEFAULT_EXTERNALS = ['react', 'react-dom', 'react/jsx-runtime'];
+const DEFAULT_GLOBALS = {
+  react: 'React',
+  'react-dom': 'ReactDOM',
+  'react/jsx-runtime': 'jsxRuntime'
+};
+const VIRTUAL_PREFIX = '\0virtual:external:';
+function generateReactCode(globalName) {
+  return `
+// External module: react -> window.${globalName}
+const React = window.${globalName};
+if (!React) {
+  throw new Error(
+    'External dependency "react" (window.${globalName}) is not available. ' +
+    'Make sure the parent application has loaded it globally.'
+  );
+}
+
+export default React;
+
+export const {
+  useState, useEffect, useContext, useReducer, useCallback, useMemo,
+  useRef, useImperativeHandle, useLayoutEffect, useDebugValue,
+  useDeferredValue, useTransition, useId, useSyncExternalStore,
+  Fragment, StrictMode, Suspense, createElement, createContext,
+  forwardRef, lazy, memo, startTransition, Component, PureComponent,
+  Children, cloneElement, isValidElement,
+} = React;
+`;
+}
+function generateReactDomCode(globalName) {
+  return `
+// External module: react-dom -> window.${globalName}
+const ReactDOM = window.${globalName};
+if (!ReactDOM) {
+  throw new Error(
+    'External dependency "react-dom" (window.${globalName}) is not available. ' +
+    'Make sure the parent application has loaded it globally.'
+  );
+}
+
+export default ReactDOM;
+
+export const {
+  createRoot, hydrateRoot, render, hydrate,
+  unmountComponentAtNode, findDOMNode, flushSync,
+} = ReactDOM;
+`;
+}
+function generateJsxRuntimeCode(globalName) {
+  return `
+// External module: react/jsx-runtime -> window.${globalName}
+const jsxRuntime = window.${globalName};
+if (!jsxRuntime) {
+  throw new Error(
+    'External dependency "react/jsx-runtime" (window.${globalName}) is not available. ' +
+    'Make sure the parent application has loaded it globally.'
+  );
+}
+
+export const { jsx, jsxs, Fragment } = jsxRuntime;
+export default jsxRuntime;
+`;
+}
+function generateEasyEditorCoreCode(globalName) {
+  return `
+// External module: @easy-editor/core -> window.${globalName}
+const EasyEditorCore = window.${globalName};
+if (!EasyEditorCore) {
+  throw new Error(
+    'External dependency "@easy-editor/core" (window.${globalName}) is not available. ' +
+    'Make sure the parent application has loaded it globally.'
+  );
+}
+
+export default EasyEditorCore;
+
+// 动态导出所有属性
+const keys = Object.keys(EasyEditorCore || {});
+keys.forEach(key => {
+  Object.defineProperty(module.exports, key, {
+    get: () => EasyEditorCore[key],
+    enumerable: true,
+  });
+});
+`;
+}
+function generateGenericCode(moduleName, globalName) {
+  return `
+// External module: ${moduleName} -> window.${globalName}
+const mod = window.${globalName};
+if (!mod) {
+  throw new Error(
+    'External dependency "${moduleName}" (window.${globalName}) is not available. ' +
+    'Make sure the parent application has loaded it globally.'
+  );
+}
+export default mod;
+`;
+}
+function externalDepsPlugin(options = {}) {
+  const externals = options.externals || DEFAULT_EXTERNALS;
+  const globals = {
+    ...DEFAULT_GLOBALS,
+    ...options.globals
+  };
+  return {
+    name: 'vite-plugin-external-deps',
+    enforce: 'pre',
+    resolveId(id) {
+      if (externals.includes(id)) {
+        return VIRTUAL_PREFIX + id;
+      }
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) {
+        return null;
+      }
+      const moduleName = id.slice(VIRTUAL_PREFIX.length);
+      const globalName = globals[moduleName];
+      if (!globalName) {
+        throw new Error(`[vite-plugin-external-deps] No global mapping found for "${moduleName}". ` + 'Please add it to the globals option.');
+      }
+      switch (moduleName) {
+        case 'react':
+          return generateReactCode(globalName);
+        case 'react-dom':
+          return generateReactDomCode(globalName);
+        case 'react/jsx-runtime':
+          return generateJsxRuntimeCode(globalName);
+        case '@easy-editor/core':
+          return generateEasyEditorCoreCode(globalName);
+        default:
+          return generateGenericCode(moduleName, globalName);
+      }
+    },
+    config() {
+      return {
+        build: {
+          rollupOptions: {
+            external: externals,
+            output: {
+              globals
+            }
+          }
+        }
+      };
+    }
+  };
+}
+
+function materialDevPlugin(options = {}) {
+  const {
+    entry = '/src/index.tsx'
+  } = options;
+  let server;
+  let wss = null;
+  const clients = new Set();
+  function broadcast(message) {
+    const data = JSON.stringify(message);
+    for (const client of clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    }
+  }
+  return {
+    name: 'vite-plugin-material-dev',
+    configureServer(_server) {
+      server = _server;
+      wss = new WebSocketServer({
+        noServer: true
+      });
+      server.httpServer?.on('upgrade', (request, socket, head) => {
+        if (request.url === '/ws' || request.url === '/__material_ws__') {
+          wss?.handleUpgrade(request, socket, head, ws => {
+            wss?.emit('connection', ws, request);
+          });
+        }
+      });
+      wss.on('connection', ws => {
+        clients.add(ws);
+        ws.send(JSON.stringify({
+          type: 'connected',
+          message: 'Material dev server connected',
+          timestamp: Date.now()
+        }));
+        ws.on('close', () => {
+          clients.delete(ws);
+        });
+        ws.on('error', () => {
+          clients.delete(ws);
+        });
+      });
+      server.middlewares.use((req, res, next) => {
+        if (req.method === 'OPTIONS') {
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+          res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+          res.statusCode = 204;
+          res.end();
+          return;
+        }
+        next();
+      });
+      server.middlewares.use('/api/health', (_req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.end(JSON.stringify({
+          status: 'ok',
+          timestamp: Date.now(),
+          server: 'vite',
+          wsPath: '/ws'
+        }));
+      });
+      server.middlewares.use('/api/material', async (_req, res) => {
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        try {
+          const module = await server.ssrLoadModule(entry);
+          const meta = module.meta || module.default?.meta;
+          const component = module.component || module.default;
+          if (!meta) {
+            res.statusCode = 400;
+            res.end(JSON.stringify({
+              error: 'Material meta not found. Make sure to export "meta" from the entry file.'
+            }));
+            return;
+          }
+          const materialInfo = {
+            name: meta.componentName,
+            title: meta.title,
+            version: meta.npm?.version || '0.0.0-dev',
+            group: meta.group,
+            category: meta.category,
+            entry,
+            hasComponent: !!component,
+            hasMeta: !!meta,
+            hasConfigure: !!meta.configure,
+            hasSnippets: Array.isArray(meta.snippets) && meta.snippets.length > 0,
+            wsPath: '/ws'
+          };
+          res.end(JSON.stringify(materialInfo));
+        } catch (error) {
+          res.statusCode = 500;
+          res.end(JSON.stringify({
+            error: error instanceof Error ? error.message : String(error)
+          }));
+        }
+      });
+      server.httpServer?.once('listening', () => {
+        const address = server.httpServer?.address();
+        const port = typeof address === 'object' && address ? address.port : 5001;
+        const host = server.config.server.host || 'localhost';
+        setTimeout(() => {
+          console.log('');
+          console.log('\x1b[36m%s\x1b[0m', '  Material Dev Server Ready');
+          console.log('');
+          console.log(`  Health Check:  http://${host}:${port}/api/health`);
+          console.log(`  Material Info: http://${host}:${port}/api/material`);
+          console.log(`  Module Entry:  http://${host}:${port}${entry}`);
+          console.log(`  WebSocket:     ws://${host}:${port}/ws`);
+          console.log('');
+          console.log('\x1b[33m%s\x1b[0m', '  Connect this URL in EasyEditor to start debugging');
+          console.log('');
+        }, 100);
+      });
+    },
+    handleHotUpdate({
+      file,
+      modules
+    }) {
+      broadcast({
+        type: 'update',
+        file,
+        timestamp: Date.now(),
+        modules: modules.map(m => m.id)
+      });
+      return;
+    },
+    closeBundle() {
+      if (wss) {
+        for (const client of clients) {
+          client.close();
+        }
+        clients.clear();
+        wss.close();
+        wss = null;
+      }
+    }
+  };
+}
+
+function createViteConfig(options) {
+  const {
+    config,
+    cwd = process.cwd()
+  } = options;
+  const {
+    externals,
+    globals
+  } = config.external;
+  const plugins = [react()];
+  plugins.push(externalDepsPlugin({
+    externals,
+    globals
+  }));
+  if (config.dev.materialApi) {
+    plugins.push(materialDevPlugin({
+      entry: `/${config.entry.main}`
+    }));
+  }
+  if (config.vitePlugins.length > 0) {
+    plugins.push(...config.vitePlugins);
+  }
+  const aliasConfig = {};
+  for (const [key, value] of Object.entries(config.alias)) {
+    aliasConfig[key] = path.resolve(cwd, value);
+  }
+  return {
+    plugins,
+    server: {
+      port: config.dev.port,
+      host: 'localhost',
+      cors: true,
+      hmr: {
+        port: config.dev.port
+      }
+    },
+    build: {
+      target: 'esnext',
+      rollupOptions: {
+        external: externals,
+        output: {
+          globals
+        }
+      }
+    },
+    resolve: {
+      alias: aliasConfig,
+      dedupe: ['react', 'react-dom']
+    },
+    css: {
+      modules: {
+        generateScopedName: config.css.scopedName
+      }
+    }
+  };
+}
+
+async function devCommand(argv) {
+  console.log(pc.cyan('Starting development server...\n'));
+  const config = await loadConfig(argv.config);
+  console.log(pc.gray(`  Package: ${config.pkg.name}@${config.pkg.version}`));
+  console.log(pc.gray(`  Preset:  ${config.preset}`));
+  console.log(pc.gray(`  Port:    ${config.dev.port}\n`));
+  const viteConfig = createViteConfig({
+    config
+  });
+  const server = await createServer(viteConfig);
+  await server.listen();
+  server.printUrls();
+  const shutdown = async () => {
+    console.log(pc.yellow('\nShutting down...'));
+    await server.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+const MATERIAL_TEMPLATE = `/**
+ * @easy-editor/easypack configuration
+ * @type {import('@easy-editor/easypack').EasypackConfig}
+ */
+export default {
+  preset: 'material',
+  // globalName 自动从 package.json 推导
+  dev: {
+    port: 5001,
+  },
+  // output: {
+  //   umd: true,       // UMD 格式（默认开启）
+  //   esm: false,      // ESM 格式
+  //   cjs: false,      // CJS 格式
+  //   minify: true,    // 压缩输出（默认开启）
+  //   types: false,    // TypeScript 类型声明
+  // },
+}
+`;
+const SETTER_TEMPLATE = `/**
+ * @easy-editor/easypack configuration
+ * @type {import('@easy-editor/easypack').EasypackConfig}
+ */
+export default {
+  preset: 'setter',
+  globalName: 'EasyEditorSetters',
+  // output: {
+  //   umd: true,       // UMD 格式（默认开启）
+  //   esm: false,      // ESM 格式
+  //   cjs: false,      // CJS 格式
+  //   minify: true,    // 压缩输出（默认开启）
+  //   types: false,    // TypeScript 类型声明
+  // },
+}
+`;
+const LIBRARY_TEMPLATE = `/**
+ * @easy-editor/easypack configuration
+ * @type {import('@easy-editor/easypack').EasypackConfig}
+ */
+export default {
+  preset: 'library',
+  // globalName: 'MyLibrary',
+  // output: {
+  //   umd: true,       // UMD 格式（默认开启）
+  //   esm: false,      // ESM 格式
+  //   cjs: false,      // CJS 格式
+  //   minify: true,    // 压缩输出（默认开启）
+  //   types: false,    // TypeScript 类型声明
+  // },
+}
+`;
+async function initCommand(argv) {
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, 'easypack.config.ts');
+  if (fs.existsSync(configPath)) {
+    const overwrite = await prompts.confirm({
+      message: 'easypack.config.ts already exists. Overwrite?'
+    });
+    if (prompts.isCancel(overwrite) || !overwrite) {
+      prompts.cancel('Operation cancelled');
+      return;
+    }
+  }
+  let preset = argv.preset;
+  if (!preset) {
+    const selected = await prompts.select({
+      message: 'Select a preset:',
+      options: [{
+        label: 'material',
+        value: 'material',
+        hint: 'For EasyMaterials components'
+      }, {
+        label: 'setter',
+        value: 'setter',
+        hint: 'For EasySetters package'
+      }, {
+        label: 'library',
+        value: 'library',
+        hint: 'For general React libraries'
+      }]
+    });
+    if (prompts.isCancel(selected)) {
+      prompts.cancel('Operation cancelled');
+      return;
+    }
+    preset = selected;
+  }
+  let template;
+  switch (preset) {
+    case 'material':
+      template = MATERIAL_TEMPLATE;
+      break;
+    case 'setter':
+      template = SETTER_TEMPLATE;
+      break;
+    case 'library':
+    default:
+      template = LIBRARY_TEMPLATE;
+      break;
+  }
+  fs.writeFileSync(configPath, template);
+  console.log('');
+  console.log(pc.green('✓ Created easypack.config.ts'));
+  console.log('');
+  console.log(pc.gray('Next steps:'));
+  console.log(pc.gray('  1. Review and customize the config file'));
+  console.log(pc.gray('  2. Run `easypack build` to build for production'));
+  console.log(pc.gray('  3. Run `easypack dev` to start dev server'));
+  console.log('');
+}
+
+const VERSION = '0.0.1';
+const helpMessage = `
+${pc.bold(pc.cyan('@easy-editor/easypack'))} - Build and dev tools for EasyEditor ecosystem
+
+${pc.bold('Usage:')}
+  easypack <command> [options]
+
+${pc.bold('Commands:')}
+  build       Build for production
+  dev         Start development server
+  init        Generate config file template
+
+${pc.bold('Options:')}
+  -c, --config <file>   Config file path
+  -h, --help            Show help
+  -v, --version         Show version
+
+${pc.bold('Examples:')}
+  ${pc.gray('# Build for production')}
+  easypack build
+
+  ${pc.gray('# Start dev server')}
+  easypack dev
+
+  ${pc.gray('# Generate config template')}
+  easypack init
+`;
+async function cli() {
+  const argv = mri(process.argv.slice(2), {
+    alias: {
+      h: 'help',
+      v: 'version',
+      c: 'config',
+      p: 'preset'
+    },
+    boolean: ['help', 'version'],
+    string: ['config', 'preset']
+  });
+  if (argv.version) {
+    console.log(VERSION);
+    return;
+  }
+  if (argv.help || argv._.length === 0) {
+    console.log(helpMessage);
+    return;
+  }
+  const command = argv._[0];
+  try {
+    switch (command) {
+      case 'build':
+        await buildCommand(argv);
+        break;
+      case 'dev':
+        await devCommand(argv);
+        break;
+      case 'init':
+        await initCommand(argv);
+        break;
+      default:
+        console.log(pc.red(`Unknown command: ${command}`));
+        console.log(helpMessage);
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(pc.red('Error:'), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+cli();
+//# sourceMappingURL=bin.js.map