type-flash 1.1.3 → 1.1.4

package/bin/type-flash.js

@@ -1,26 +1,20 @@
 #!/usr/bin/env node
+
 /**
- * type-flash CLI - 命令行工具
+ * type-flash - CLI 命令行工具
  * 
  * 用法：
- *   type-flash <input.json> [options]
  *   type-flash -i input.json -o output.ts
- *   cat data.json | type-flash
- * 
- * 示例：
- *   type-flash user.json -n User
- *   type-flash api.json --style type --no-export
- *   curl https://api.example.com/users | type-flash -n UserList
+ *   cat data.json | type-flash -n User
  */
 
-'use strict';
-
 const fs = require('fs');
 const path = require('path');
 
 // 解析命令行参数
-function parseArgs(argv) {
-  const args = {
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
     input: null,
     output: null,
     rootName: 'Root',
@@ -34,182 +28,139 @@ function parseArgs(argv) {
     indentSize: 2,
     typePrefix: '',
     typeSuffix: '',
+    typeNameMap: {},
     help: false,
     version: false,
   };
 
-  let i = 2; // 跳过 node 和脚本路径
-  while (i < argv.length) {
-    const arg = argv[i];
-
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
     switch (arg) {
-      case '-h':
-      case '--help':
-        args.help = true;
-        break;
-
-      case '-v':
-      case '--version':
-        args.version = true;
-        break;
-
       case '-i':
       case '--input':
-        args.input = argv[++i];
+        options.input = args[++i];
         break;
-
       case '-o':
       case '--output':
-        args.output = argv[++i];
+        options.output = args[++i];
         break;
-
       case '-n':
       case '--name':
-      case '--root-name':
-        args.rootName = argv[++i];
+        options.rootName = args[++i];
         break;
-
       case '-s':
       case '--style':
-        args.outputStyle = argv[++i];
+        options.outputStyle = args[++i];
         break;
-
       case '--naming-style':
-        args.namingStyle = argv[++i];
+        options.namingStyle = args[++i];
         break;
-
       case '--sort':
-        args.sortProperties = argv[++i];
+        options.sortProperties = args[++i];
         break;
-
       case '--no-export':
-        args.addExport = false;
+        options.addExport = false;
         break;
-
       case '--strict-null':
-        args.strictNullChecks = true;
+        options.strictNullChecks = true;
         break;
-
       case '--no-optional':
-        args.markOptional = false;
+        options.markOptional = false;
         break;
-
       case '--no-generics':
-        args.extractGenerics = false;
+        options.extractGenerics = false;
         break;
-
       case '--indent':
-        args.indentSize = parseInt(argv[++i], 10);
+        options.indentSize = parseInt(args[++i], 10);
         break;
-
       case '--prefix':
-        args.typePrefix = argv[++i];
+        options.typePrefix = args[++i];
         break;
-
       case '--suffix':
-        args.typeSuffix = argv[++i];
+        options.typeSuffix = args[++i];
+        break;
+      case '-h':
+      case '--help':
+        options.help = true;
+        break;
+      case '-v':
+      case '--version':
+        options.version = true;
         break;
-
       default:
-        // 第一个非选项参数作为输入文件
-        if (!args.input && !arg.startsWith('-')) {
-          args.input = arg;
-        }
+        // 未知参数，忽略
         break;
     }
-
-    i++;
   }
 
-  return args;
+  return options;
 }
 
-// 显示帮助信息
+// 显示帮助
 function showHelp() {
   console.log(`
 type-flash - JSON 智能生成 TypeScript 类型定义
 
 用法:
-  type-flash <input.json> [options]
-  type-flash -i input.json -o output.ts
-  cat data.json | type-flash
+  type-flash -i <file> [选项]
+  cat data.json | type-flash [选项]
 
 选项:
-  -i, --input <file>        输入 JSON 文件路径
-  -o, --output <file>       输出 TypeScript 文件路径（默认输出到 stdout）
-  -n, --name <name>         根类型名称（默认: Root）
-  -s, --style <style>       输出风格: interface | type（默认: interface）
-      --naming-style <s>    命名风格: PascalCase | camelCase（默认: PascalCase）
-      --sort <order>        属性排序: alpha | definition（默认: alpha）
-      --no-export           不添加 export 关键字
-      --strict-null         严格空值模式（保留 null 类型）
-      --no-optional         不标记可选属性
-      --no-generics         不提取泛型类型
-      --indent <n>          缩进空格数（默认: 2）
-      --prefix <prefix>     类型名前缀
-      --suffix <suffix>     类型名后缀
-  -h, --help                显示帮助信息
-  -v, --version             显示版本号
+  -i, --input <file>       输入 JSON 文件路径
+  -o, --output <file>      输出 TS 文件路径
+  -n, --name <name>        根类型名称 (默认: Root)
+  -s, --style <style>      输出风格: interface | type (默认: interface)
+      --naming-style <s>   命名风格: PascalCase | camelCase (默认: PascalCase)
+      --sort <order>       属性排序: alpha | definition (默认: alpha)
+      --no-export          不添加 export 语句
+      --strict-null        严格空值模式
+      --no-optional        不标记可选属性
+      --no-generics        不提取泛型
+      --indent <n>         缩进空格数 (默认: 2)
+      --prefix <prefix>    类型名前缀
+      --suffix <suffix>    类型名后缀
+  -v, --version            显示版本号
+  -h, --help               显示帮助
 
 示例:
-  # 从文件生成
-  type-flash user.json -n User -o user.ts
-
-  # 使用 type 风格输出
-  type-flash data.json --style type
-
-  # 从标准输入读取
-  curl https://api.example.com/data | type-flash -n ApiResponse
-
-  # 带前缀
-  type-flash api.json --prefix Api -o api-types.ts
+  type-flash -i data.json -o types.ts
+  type-flash -i data.json -n User
+  cat data.json | type-flash -s type
 `);
 }
 
-// 显示版本号
+// 显示版本
 function showVersion() {
   try {
     const pkgPath = path.join(__dirname, '..', 'package.json');
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-    console.log(`type-flash v${pkg.version}`);
+    console.log(pkg.version);
   } catch (e) {
-    console.log('type-flash (unknown version)');
+    console.log('unknown');
   }
 }
 
-// 读取输入
-async function readInput(inputPath) {
-  if (inputPath) {
-    // 从文件读取
-    const fullPath = path.resolve(inputPath);
-    if (!fs.existsSync(fullPath)) {
-      console.error(`错误: 文件不存在: ${fullPath}`);
-      process.exit(1);
-    }
-    return fs.readFileSync(fullPath, 'utf-8');
-  }
-
-  // 从标准输入读取
+// 读取标准输入
+function readStdin() {
   return new Promise((resolve, reject) => {
     let data = '';
     process.stdin.setEncoding('utf-8');
-
+    
     process.stdin.on('data', chunk => {
       data += chunk;
     });
-
+    
     process.stdin.on('end', () => {
       resolve(data);
     });
-
+    
     process.stdin.on('error', reject);
-
-    // 检查是否有输入
+    
+    // 如果没有输入，超时返回空
     setTimeout(() => {
       if (!data) {
-        console.error('错误: 未提供输入数据。请指定输入文件或通过管道传入 JSON。');
-        console.error('使用 --help 查看帮助信息。');
-        process.exit(1);
+        resolve('');
       }
     }, 100);
   });
@@ -217,65 +168,98 @@ async function readInput(inputPath) {
 
 // 主函数
 async function main() {
-  const args = parseArgs(process.argv);
+  const options = parseArgs();
 
-  if (args.help) {
+  // 显示帮助
+  if (options.help) {
     showHelp();
     return;
   }
 
-  if (args.version) {
+  // 显示版本
+  if (options.version) {
     showVersion();
     return;
   }
 
   try {
-    // 读取输入
-    const jsonStr = await readInput(args.input);
+    // 1. 获取 JSON 数据
+    let jsonString;
+    
+    if (options.input) {
+      // 从文件读取
+      const inputPath = path.resolve(options.input);
+      if (!fs.existsSync(inputPath)) {
+        console.error(`错误: 文件不存在 - ${options.input}`);
+        process.exit(1);
+      }
+      jsonString = fs.readFileSync(inputPath, 'utf-8');
+    } else {
+      // 从标准输入读取
+      jsonString = await readStdin();
+      if (!jsonString.trim()) {
+        console.error('错误: 未提供输入数据。使用 -i 指定文件或通过管道输入');
+        console.error('使用 type-flash --help 查看帮助');
+        process.exit(1);
+      }
+    }
 
-    // 解析 JSON
+    // 2. 解析 JSON
     let jsonData;
     try {
-      jsonData = JSON.parse(jsonStr);
+      jsonData = JSON.parse(jsonString);
     } catch (e) {
       console.error(`错误: JSON 解析失败 - ${e.message}`);
       process.exit(1);
     }
 
-    // 动态导入生成函数
-    const { generate } = require('../dist/index.js');
+    // 3. 生成类型
+    // 动态导入生成的模块
+    const distPath = path.join(__dirname, '..', 'dist', 'index.js');
+    let generate;
+    
+    try {
+      const mod = require(distPath);
+      generate = mod.generate || mod.default?.generate;
+    } catch (e) {
+      console.error(`错误: 加载模块失败 - ${e.message}`);
+      console.error('请先运行 npm run build 构建项目');
+      process.exit(1);
+    }
+
+    if (!generate) {
+      console.error('错误: 未找到 generate 函数');
+      process.exit(1);
+    }
 
-    // 生成类型
+    // 生成类型（generate 直接返回字符串）
     const result = generate(jsonData, {
-      rootName: args.rootName,
-      outputStyle: args.outputStyle,
-      namingStyle: args.namingStyle,
-      sortProperties: args.sortProperties,
-      addExport: args.addExport,
-      strictNullChecks: args.strictNullChecks,
-      markOptional: args.markOptional,
-      extractGenerics: args.extractGenerics,
-      indentSize: args.indentSize,
-      typePrefix: args.typePrefix,
-      typeSuffix: args.typeSuffix,
+      rootName: options.rootName,
+      outputStyle: options.outputStyle,
+      namingStyle: options.namingStyle,
+      sortProperties: options.sortProperties,
+      addExport: options.addExport,
+      strictNullChecks: options.strictNullChecks,
+      markOptional: options.markOptional,
+      extractGenerics: options.extractGenerics,
+      indentSize: options.indentSize,
+      typePrefix: options.typePrefix,
+      typeSuffix: options.typeSuffix,
     });
 
-    // 输出结果
-    if (args.output) {
-      const outputPath = path.resolve(args.output);
-      fs.writeFileSync(outputPath, result.code, 'utf-8');
-      console.log(`✓ 已生成: ${outputPath}`);
-      console.log(`  共生成 ${result.types.length} 个类型定义`);
+    // 4. 输出结果
+    if (options.output) {
+      const outputPath = path.resolve(options.output);
+      fs.writeFileSync(outputPath, result, 'utf-8');
+      console.log(`✅ 已生成: ${options.output}`);
     } else {
-      console.log(result.code);
+      console.log(result);
     }
+
   } catch (e) {
     console.error(`错误: ${e.message}`);
-    if (process.env.DEBUG) {
-      console.error(e.stack);
-    }
     process.exit(1);
   }
 }
 
-main();
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-flash",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "JSON 智能生成 TypeScript 类型定义 - 一键从 JSON 数据生成 Interface / Type 定义",
   "main": "dist/index.js",
   "module": "dist/index.mjs",