type-flash 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,626 @@
+/**
+ * 类型定义
+ */
+/**
+ * 原始类型
+ */
+interface PrimitiveType {
+    kind: 'primitive';
+    type: 'string' | 'number' | 'boolean' | 'any' | 'unknown' | 'never';
+}
+/**
+ * 数组类型
+ */
+interface ArrayType {
+    kind: 'array';
+    elementType: TSTypeNode;
+}
+/**
+ * 对象类型（接口）
+ */
+interface ObjectType {
+    kind: 'object';
+    properties: PropertyDef[];
+    /** 是否为字典类型（索引签名） */
+    isRecord?: boolean;
+    /** 字典值类型 */
+    valueType?: TSTypeNode;
+}
+/**
+ * 属性定义
+ */
+interface PropertyDef {
+    name: string;
+    type: TSTypeNode;
+    /** 是否可选 */
+    optional: boolean;
+    /** JSDoc 注释 */
+    comment?: string;
+}
+/**
+ * 联合类型
+ */
+interface UnionType {
+    kind: 'union';
+    types: TSTypeNode[];
+}
+/**
+ * 字面量类型
+ */
+interface LiteralType {
+    kind: 'literal';
+    value: string | number | boolean;
+}
+/**
+ * 枚举类型
+ */
+interface EnumType {
+    kind: 'enum';
+    name: string;
+    values: (string | number)[];
+}
+/**
+ * null 类型
+ */
+interface NullType {
+    kind: 'null';
+}
+/**
+ * undefined 类型
+ */
+interface UndefinedType {
+    kind: 'undefined';
+}
+/**
+ * 泛型类型
+ */
+interface GenericType {
+    kind: 'generic';
+    name: string;
+    typeArgs: TSTypeNode[];
+}
+/**
+ * TS 类型节点（联合类型，支持 discriminated union 类型收窄）
+ */
+type TSTypeNode = PrimitiveType | ArrayType | ObjectType | UnionType | LiteralType | EnumType | NullType | UndefinedType | GenericType;
+/**
+ * 命名风格
+ */
+type NamingStyle = 'PascalCase' | 'camelCase';
+/**
+ * 输出风格
+ */
+type OutputStyle = 'interface' | 'type';
+/**
+ * 排序方式
+ */
+type SortOrder = 'alpha' | 'definition';
+/**
+ * 生成配置选项
+ */
+interface GenerateOptions {
+    /** 根类型名称，默认 'Root' */
+    rootName?: string;
+    /** 输出风格：interface 或 type，默认 'interface' */
+    outputStyle?: OutputStyle;
+    /** 命名风格：PascalCase 或 camelCase，默认 'PascalCase' */
+    namingStyle?: NamingStyle;
+    /** 属性排序方式，默认 'alpha' */
+    sortProperties?: SortOrder;
+    /** 是否添加 export 语句，默认 true */
+    addExport?: boolean;
+    /** 是否生成 JSDoc 注释，默认 false */
+    addComments?: boolean;
+    /** 是否严格空值（null 单独类型），默认 false */
+    strictNullChecks?: boolean;
+    /** 是否将可选属性标记为 ?，默认 true */
+    markOptional?: boolean;
+    /** 是否提取枚举类型，默认 true */
+    extractEnums?: boolean;
+    /** 枚举提取阈值（字段不同值数量 ≤ 此值时提取为枚举），默认 5 */
+    enumThreshold?: number;
+    /** 是否提取泛型（如 PageResult<T>），默认 true */
+    extractGenerics?: boolean;
+    /** 缩进空格数，默认 2 */
+    indentSize?: number;
+    /** 行尾换行符，默认 '\n' */
+    lineEnding?: string;
+    /** 自定义类型名映射 { 字段路径: 类型名 } */
+    typeNameMap?: Record<string, string>;
+    /** 前缀，所有生成的类型名添加此前缀 */
+    typePrefix?: string;
+    /** 后缀，所有生成的类型名添加此后缀 */
+    typeSuffix?: string;
+}
+/**
+ * 已命名的类型定义
+ */
+interface NamedTypeDef {
+    name: string;
+    type: TSTypeNode;
+    comment?: string;
+}
+/**
+ * 生成结果
+ */
+interface GenerateResult {
+    /** 生成的 TypeScript 代码字符串 */
+    code: string;
+    /** 生成的类型定义列表 */
+    types: NamedTypeDef[];
+}
+
+/**
+ * ts-gen - 命名与去重模块
+ *
+ * 核心功能：
+ * - 根据字段名 + 上下文自动生成有意义的类型名
+ * - 结构等价性判断与类型去重
+ * - 循环引用检测与处理
+ * - 命名风格转换（PascalCase / camelCase）
+ */
+
+/**
+ * 命名上下文
+ */
+interface NamingContext {
+    /** 当前字段名 */
+    fieldName?: string;
+    /** 父级类型名 */
+    parentName?: string;
+    /** 深度 */
+    depth: number;
+}
+/**
+ * 类型命名器
+ */
+declare class TypeNamer {
+    /** 已命名的类型映射（结构 key -> 类型名） */
+    private namedTypes;
+    /** 类型名计数器（用于重名时加序号） */
+    private nameCounter;
+    /** 命名风格 */
+    private namingStyle;
+    /** 类型名前缀 */
+    private prefix;
+    /** 类型名后缀 */
+    private suffix;
+    /** 自定义类型名映射 */
+    private customNameMap;
+    /** 正在处理的对象（用于循环引用检测） */
+    private processing;
+    /** 循环引用类型名映射 */
+    private circularRefs;
+    constructor(options?: {
+        namingStyle?: NamingStyle;
+        prefix?: string;
+        suffix?: string;
+        customNameMap?: Record<string, string>;
+    });
+    /**
+     * 为类型生成名称
+     * @param type 类型节点
+     * @param context 命名上下文
+     * @returns 类型名，如果是内联类型则返回 null
+     */
+    nameType(type: TSTypeNode, context?: NamingContext): string | null;
+    /**
+     * 生成类型名
+     */
+    private generateName;
+    /**
+     * 确保名称唯一
+     */
+    private ensureUniqueName;
+    /**
+     * 应用前后缀
+     */
+    private applyAffixes;
+    /**
+     * 构建路径 key（用于自定义名称映射）
+     */
+    private buildPathKey;
+    /**
+     * 获取类型的结构 key
+     */
+    private getTypeKey;
+    /**
+     * 获取简单类型 key（用于属性比较）
+     */
+    private getSimpleTypeKey;
+    /**
+     * 转换为 PascalCase
+     */
+    toPascalCase(str: string): string;
+    /**
+     * 转换为 camelCase
+     */
+    toCamelCase(str: string): string;
+    /**
+     * 根据命名风格转换
+     */
+    formatName(name: string): string;
+    /**
+     * 检查是否为循环引用
+     */
+    isCircular(obj: object): boolean;
+    /**
+     * 标记对象为正在处理
+     */
+    markProcessing(obj: object): void;
+    /**
+     * 取消标记
+     */
+    unmarkProcessing(obj: object): void;
+    /**
+     * 获取所有已命名的类型
+     */
+    getAllNamedTypes(): Map<string, string>;
+    /**
+     * 重置命名器
+     */
+    reset(): void;
+}
+/**
+ * 类型去重与收集器
+ * 遍历类型树，收集所有需要单独定义的命名类型
+ */
+declare class TypeCollector {
+    private namer;
+    private collected;
+    private seenStructs;
+    constructor(namer: TypeNamer);
+    /**
+     * 收集类型树中的所有命名类型
+     * @param rootType 根类型
+     * @param rootName 根类型名
+     * @returns 类型定义列表（根类型在最前）
+     */
+    collect(rootType: TSTypeNode, rootName: string): NamedTypeDef[];
+    /**
+     * 递归收集
+     */
+    private collectRecursive;
+    /**
+     * 获取结构 key（用于去重）
+     */
+    private getStructKey;
+    /**
+     * 获取属性类型的简化 key
+     */
+    private getPropTypeKey;
+}
+
+/**
+ * ts-gen - 格式化输出模块
+ *
+ * 核心功能：
+ * - 将类型节点转换为 TypeScript 代码字符串
+ * - 支持 interface 和 type alias 两种输出风格
+ * - 自动缩进、排序
+ * - 支持导出语句
+ * - 支持 JSDoc 注释生成
+ */
+
+/**
+ * 代码格式化器
+ */
+declare class CodeFormatter {
+    private options;
+    private namer;
+    constructor(options: Required<GenerateOptions>, namer: TypeNamer);
+    /**
+     * 格式化单个类型定义为代码
+     */
+    formatTypeDef(typeDef: NamedTypeDef): string;
+    /**
+     * 格式化对象类型
+     */
+    private formatObjectType;
+    /**
+     * 格式化枚举类型
+     */
+    private formatEnumType;
+    /**
+     * 格式化类型节点为字符串
+     */
+    formatType(type: TSTypeNode): string;
+    /**
+     * 格式化字面量
+     */
+    private formatLiteral;
+    /**
+     * 格式化数组类型
+     */
+    private formatArrayType;
+    /**
+     * 格式化内联对象类型
+     */
+    private formatInlineObject;
+    /**
+     * 格式化联合类型
+     */
+    private formatUnionType;
+    /**
+     * 格式化属性名
+     * 处理非法标识符的情况（用引号包裹）
+     */
+    private formatPropertyName;
+    /**
+     * 排序属性
+     */
+    private sortProperties;
+    /**
+     * 格式化 JSDoc 注释（多行）
+     */
+    private formatJSDoc;
+    /**
+     * 格式化内联 JSDoc 注释（单行）
+     */
+    private formatInlineJSDoc;
+    /**
+     * 转换为枚举键名
+     */
+    private toEnumKey;
+    /**
+     * 格式化所有类型定义
+     */
+    formatAll(typeDefs: NamedTypeDef[]): string;
+    /**
+     * 生成完整的输出代码
+     */
+    generateOutput(typeDefs: NamedTypeDef[], rootTypeName: string): string;
+}
+
+/**
+ * ts-gen - 类型推断引擎
+ *
+ * 核心功能：
+ * - 基础类型识别（string、number、boolean、null、undefined）
+ * - 数组类型识别与元素类型统一
+ * - 对象类型递归遍历
+ * - 联合类型推断与合并
+ * - 可选属性识别
+ * - 空值处理
+ * - 循环引用检测
+ * - 结构等价性判断
+ */
+
+/**
+ * 创建联合类型节点
+ */
+declare function createUnion(types: TSTypeNode[]): UnionType;
+/**
+ * 合并两个类型为联合类型
+ */
+declare function mergeTypes(a: TSTypeNode, b: TSTypeNode): TSTypeNode;
+/**
+ * 合并两个对象类型
+ * - 相同字段合并类型
+ * - 仅在一个对象中存在的字段标记为可选
+ */
+declare function mergeObjects(a: ObjectType, b: ObjectType): ObjectType;
+/**
+ * 推断单个值的类型
+ */
+declare function inferType(value: unknown): TSTypeNode;
+/**
+ * 推断数组类型
+ * - 统一提取元素类型
+ * - 元素类型不一致时生成联合类型
+ */
+declare function inferArrayType(arr: unknown[]): TSTypeNode;
+/**
+ * 推断对象类型
+ */
+declare function inferObjectType(obj: Record<string, unknown>): ObjectType;
+/**
+ * 判断两个类型是否结构等价
+ * 用于类型去重与复用
+ */
+declare function isStructurallyEqual(a: TSTypeNode, b: TSTypeNode): boolean;
+
+/**
+ * ts-gen - 增强功能模块
+ *
+ * 核心功能：
+ * - 泛型提取（识别列表结构，提取为 PageResult<T>）
+ * - 枚举提取（字符串字段取值有限时自动提取为枚举）
+ * - 空值处理（严格/非严格模式）
+ * - 可选属性处理
+ */
+
+/**
+ * 泛型模式定义
+ */
+interface GenericPattern {
+    /** 模式名称，如 'PageResult' */
+    name: string;
+    /** 匹配的属性列表 */
+    match: {
+        /** 列表字段名（可变的部分） */
+        listField?: string[];
+        /** 总数字段名 */
+        totalField?: string[];
+        /** 页码字段名 */
+        pageField?: string[];
+        /** 每页大小字段名 */
+        pageSizeField?: string[];
+    };
+    /** 泛型参数索引（哪个字段作为 T） */
+    typeParamIndex: number;
+}
+/**
+ * 泛型提取器
+ */
+declare class GenericExtractor {
+    private patterns;
+    constructor(customPatterns?: GenericPattern[]);
+    /**
+     * 尝试提取泛型类型
+     * @param type 对象类型
+     * @returns 如果匹配成功返回泛型类型，否则返回原类型
+     */
+    extract(type: TSTypeNode): TSTypeNode;
+    /**
+     * 尝试匹配泛型模式
+     */
+    private tryMatchPattern;
+    /**
+     * 递归处理子属性
+     */
+    private extractRecursive;
+    /**
+     * 提取属性类型中的泛型
+     */
+    private extractPropertyType;
+}
+/**
+ * 枚举提取器
+ */
+declare class EnumExtractor {
+    private threshold;
+    constructor(threshold?: number);
+    /**
+     * 从 JSON 数据中提取枚举
+     * @param jsonData JSON 数据
+     * @param type 已推断的类型
+     * @returns 处理后的类型（可能包含枚举）
+     */
+    extract(jsonData: unknown, type: TSTypeNode): TSTypeNode;
+    /**
+     * 递归提取
+     */
+    private extractRecursive;
+    /**
+     * 收集数组中某个字段的所有取值
+     */
+    private collectFieldValues;
+    /**
+     * 尝试提取枚举
+     */
+    private tryExtractEnum;
+}
+/**
+ * 空值处理器
+ */
+declare class NullHandler {
+    private strictNullChecks;
+    constructor(strictNullChecks?: boolean);
+    /**
+     * 处理类型中的 null
+     */
+    process(type: TSTypeNode): TSTypeNode;
+    /**
+     * 递归处理（严格模式）
+     */
+    private processRecursive;
+    /**
+     * 递归移除 null
+     */
+    private removeNullRecursive;
+}
+/**
+ * 可选属性处理器
+ * 基于数组中对象的字段出现频率判断是否可选
+ */
+declare class OptionalHandler {
+    private markOptional;
+    constructor(markOptional?: boolean);
+    /**
+     * 处理可选属性
+     * @param jsonData 原始 JSON 数据
+     * @param type 已推断的类型
+     */
+    process(jsonData: unknown, type: TSTypeNode): TSTypeNode;
+    /**
+     * 递归处理
+     */
+    private processRecursive;
+    /**
+     * 在数组对象中标记可选属性
+     */
+    private markOptionalInArrayObjects;
+}
+/**
+ * 应用所有增强功能
+ */
+declare function applyEnhancements(jsonData: unknown, type: TSTypeNode, options: Required<GenerateOptions>): TSTypeNode;
+
+/**
+ * ts-gen - JSON 智能生成 TypeScript 类型定义
+ *
+ * 主入口文件
+ *
+ * @example
+ * ```ts
+ * import { generate } from 'ts-gen';
+ *
+ * const json = { name: 'foo', age: 25 };
+ * const result = generate(json, { rootName: 'User' });
+ * console.log(result.code);
+ * ```
+ */
+
+/**
+ * 从 JSON 数据生成 TypeScript 类型定义
+ *
+ * @param jsonData JSON 数据（对象或数组）
+ * @param options 生成选项
+ * @returns 生成结果，包含代码字符串和类型定义列表
+ *
+ * @example
+ * ```ts
+ * import { generate } from 'ts-gen';
+ *
+ * const data = {
+ *   id: 1,
+ *   name: 'Alice',
+ *   email: 'alice@example.com',
+ *   profile: {
+ *     avatar: 'https://...',
+ *     bio: null
+ *   }
+ * };
+ *
+ * const result = generate(data, {
+ *   rootName: 'User',
+ *   outputStyle: 'interface'
+ * });
+ *
+ * console.log(result.code);
+ * ```
+ */
+declare function generate(jsonData: unknown, options?: GenerateOptions): GenerateResult;
+/**
+ * 从 JSON 字符串生成 TypeScript 类型定义
+ *
+ * @param jsonString JSON 字符串
+ * @param options 生成选项
+ * @returns 生成结果
+ *
+ * @example
+ * ```ts
+ * import { generateFromString } from 'ts-gen';
+ *
+ * const jsonStr = '{"name": "foo", "age": 25}';
+ * const result = generateFromString(jsonStr, { rootName: 'User' });
+ * ```
+ */
+declare function generateFromString(jsonString: string, options?: GenerateOptions): GenerateResult;
+/**
+ * 生成单个类型的字符串表示（不生成完整文件）
+ *
+ * @param jsonData JSON 数据
+ * @param options 生成选项
+ * @returns 类型定义字符串
+ */
+declare function generateType(jsonData: unknown, options?: GenerateOptions): string;
+
+declare const _default: {
+    generate: typeof generate;
+    generateFromString: typeof generateFromString;
+    generateType: typeof generateType;
+};
+
+export { type ArrayType, CodeFormatter, EnumExtractor, type EnumType, type GenerateOptions, type GenerateResult, GenericExtractor, type GenericType, type NamedTypeDef, type NamingStyle, NullHandler, type ObjectType, OptionalHandler, type OutputStyle, type PrimitiveType, type PropertyDef, type SortOrder, type TSTypeNode, TypeCollector, TypeNamer, type UnionType, applyEnhancements, createUnion, _default as default, generate, generateFromString, generateType, inferArrayType, inferObjectType, inferType, isStructurallyEqual, mergeObjects, mergeTypes };

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";var P=Object.defineProperty;var L=Object.getOwnPropertyDescriptor;var V=Object.getOwnPropertyNames;var z=Object.prototype.hasOwnProperty;var _=(i,e)=>{for(var t in e)P(i,t,{get:e[t],enumerable:!0})},q=(i,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of V(e))!z.call(i,n)&&n!==t&&P(i,n,{get:()=>e[n],enumerable:!(r=L(e,n))||r.enumerable});return i};var J=i=>q(P({},"__esModule",{value:!0}),i);var X={};_(X,{CodeFormatter:()=>T,EnumExtractor:()=>S,GenericExtractor:()=>k,NullHandler:()=>v,OptionalHandler:()=>b,TypeCollector:()=>y,TypeNamer:()=>d,applyEnhancements:()=>x,createUnion:()=>h,default:()=>Q,generate:()=>$,generateFromString:()=>M,generateType:()=>F,inferArrayType:()=>A,inferObjectType:()=>E,inferType:()=>f,isStructurallyEqual:()=>U,mergeObjects:()=>R,mergeTypes:()=>N});module.exports=J(X);var D={rootName:"Root",outputStyle:"interface",namingStyle:"PascalCase",sortProperties:"alpha",addExport:!0,addComments:!1,strictNullChecks:!1,markOptional:!0,extractEnums:!0,enumThreshold:5,extractGenerics:!0,indentSize:2,lineEnding:`
+`,typeNameMap:{},typePrefix:"",typeSuffix:""};function m(i){return{kind:"primitive",type:i}}function Z(){return{kind:"null"}}function B(){return{kind:"undefined"}}function w(i){return{kind:"array",elementType:i}}function G(i=[]){return{kind:"object",properties:i}}function h(i){let e=[],t=new Set;for(let r of i)if(r.kind==="union")for(let n of r.types){let o=c(n);t.has(o)||(t.add(o),e.push(n))}else{let n=c(r);t.has(n)||(t.add(n),e.push(r))}return e.length===1?e[0]:{kind:"union",types:e}}function c(i){switch(i.kind){case"primitive":return`primitive:${i.type}`;case"null":return"null";case"undefined":return"undefined";case"literal":return`literal:${typeof i.value}:${String(i.value)}`;case"array":return`array:${c(i.elementType)}`;case"object":return`object:${i.properties.map(e=>`${e.name}:${c(e.type)}:${e.optional}`).join(",")}`;case"union":return`union:${i.types.map(c).sort().join("|")}`;case"enum":return`enum:${i.name}:${i.values.join(",")}`;case"generic":return`generic:${i.name}:${i.typeArgs.map(c).join(",")}`;default:return"unknown"}}function N(i,e){return c(i)===c(e)?i:i.kind==="object"&&e.kind==="object"?R(i,e):i.kind==="array"&&e.kind==="array"?w(N(i.elementType,e.elementType)):h([i,e])}function R(i,e){let t=new Map;for(let r of i.properties)t.set(r.name,{...r});for(let r of e.properties){let n=t.get(r.name);n?(n.type=N(n.type,r.type),n.optional=n.optional||r.optional,r.comment&&!n.comment&&(n.comment=r.comment)):t.set(r.name,{...r,optional:!0})}for(let[r,n]of t)e.properties.some(s=>s.name===r)||(n.optional=!0);return G(Array.from(t.values()))}function f(i){return i===null?Z():i===void 0?B():typeof i=="string"?m("string"):typeof i=="number"?m("number"):typeof i=="boolean"?m("boolean"):Array.isArray(i)?A(i):typeof i=="object"?E(i):m("unknown")}function A(i){if(i.length===0)return w(m("never"));let e=f(i[0]);for(let t=1;t<i.length;t++){let r=f(i[t]);e=N(e,r)}return w(e)}function E(i){let e=[];for(let[t,r]of Object.entries(i)){let n=f(r);e.push({name:t,type:n,optional:!1})}return G(e)}function U(i,e){return c(i)===c(e)}function l(i){switch(i.kind){case"primitive":case"null":case"undefined":return{...i};case"literal":return{...i};case"array":return{...i,elementType:l(i.elementType)};case"object":return{...i,properties:i.properties.map(e=>({...e,type:l(e.type)}))};case"union":return{...i,types:i.types.map(e=>l(e))};case"enum":return{...i,values:[...i.values]};case"generic":return{...i,typeArgs:i.typeArgs.map(e=>l(e))};default:return{...i}}}var d=class{constructor(e={}){this.namedTypes=new Map;this.nameCounter=new Map;this.processing=new WeakSet;this.circularRefs=new Map;this.namingStyle=e.namingStyle||"PascalCase",this.prefix=e.prefix||"",this.suffix=e.suffix||"",this.customNameMap=e.customNameMap||{}}nameType(e,t={depth:0}){if(e.kind!=="object"&&e.kind!=="enum")return null;let r=this.buildPathKey(t);if(this.customNameMap[r])return this.applyAffixes(this.customNameMap[r]);let n=this.getTypeKey(e);if(this.namedTypes.has(n))return this.namedTypes.get(n);let o=this.generateName(e,t);return o=this.ensureUniqueName(o),o=this.applyAffixes(o),this.namedTypes.set(n,o),o}generateName(e,t){if(e.kind==="enum")return t.fieldName?this.toPascalCase(t.fieldName)+"Enum":"AnonymousEnum";if(e.kind==="object"){if(t.fieldName){let r=this.toPascalCase(t.fieldName);return t.parentName?`${t.parentName}${r}`:r}return t.parentName?`${t.parentName}Item`:"AnonymousObject"}return"UnknownType"}ensureUniqueName(e){let t=this.nameCounter.get(e)||0;if(t===0)return this.nameCounter.set(e,1),e;let r=`${e}${t+1}`;return this.nameCounter.set(e,t+1),r}applyAffixes(e){let t=e;return this.prefix&&(t=this.toPascalCase(this.prefix)+t),this.suffix&&(t=t+this.toPascalCase(this.suffix)),t}buildPathKey(e){let t=[];return e.parentName&&t.push(e.parentName),e.fieldName&&t.push(e.fieldName),t.join(".")}getTypeKey(e){return e.kind==="object"?`object:${e.properties.map(t=>`${t.name}:${this.getSimpleTypeKey(t.type)}:${t.optional}`).sort().join(",")}`:e.kind==="enum"?`enum:${e.values.sort().join(",")}`:e.kind}getSimpleTypeKey(e){switch(e.kind){case"primitive":return e.type;case"null":return"null";case"undefined":return"undefined";case"array":return`array<${this.getSimpleTypeKey(e.elementType)}>`;case"object":return"object";case"union":return e.types.map(t=>this.getSimpleTypeKey(t)).sort().join("|");case"enum":return`enum:${e.name}`;case"generic":return`generic:${e.name}`;default:return"unknown"}}toPascalCase(e){return e?e.replace(/[-_\s]+/g," ").replace(/([a-z])([A-Z])/g,"$1 $2").trim().split(" ").filter(Boolean).map(r=>r.charAt(0).toUpperCase()+r.slice(1).toLowerCase()).join(""):""}toCamelCase(e){let t=this.toPascalCase(e);return t.charAt(0).toLowerCase()+t.slice(1)}formatName(e){return this.namingStyle==="camelCase"?this.toCamelCase(e):this.toPascalCase(e)}isCircular(e){return this.processing.has(e)}markProcessing(e){this.processing.add(e)}unmarkProcessing(e){this.processing.delete(e)}getAllNamedTypes(){return new Map(this.namedTypes)}reset(){this.namedTypes.clear(),this.nameCounter.clear(),this.processing=new WeakSet,this.circularRefs.clear()}},y=class{constructor(e){this.collected=[];this.seenStructs=new Set;this.namer=e}collect(e,t){this.collected=[],this.seenStructs.clear(),this.namer.reset();let r=this.getStructKey(e);this.namer.nameType(e,{fieldName:t,depth:0}),this.collectRecursive(e,{fieldName:t,parentName:void 0,depth:0});let n=this.collected.find(s=>s.name===t),o=this.collected.filter(s=>s.name!==t);return n?[n,...o]:this.collected}collectRecursive(e,t){let r=this.getStructKey(e);if(e.kind==="object"){let n=this.namer.nameType(e,t);if(n&&!this.seenStructs.has(r)){this.seenStructs.add(r),this.collected.push({name:n,type:l(e)});for(let o of e.properties)this.collectRecursive(o.type,{fieldName:o.name,parentName:n,depth:t.depth+1})}return}if(e.kind==="array"){this.collectRecursive(e.elementType,{fieldName:t.fieldName?t.fieldName+"Item":void 0,parentName:t.parentName,depth:t.depth+1});return}if(e.kind==="union"){for(let n of e.types)this.collectRecursive(n,t);return}if(e.kind==="enum"){let n=this.namer.nameType(e,t);n&&!this.seenStructs.has(r)&&(this.seenStructs.add(r),this.collected.push({name:n,type:l(e)}));return}if(e.kind==="generic"){for(let n of e.typeArgs)this.collectRecursive(n,{...t,depth:t.depth+1});return}}getStructKey(e){return e.kind==="object"?`object:${e.properties.map(t=>`${t.name}:${this.getPropTypeKey(t.type)}:${t.optional}`).sort().join("|")}`:e.kind==="enum"?`enum:${[...e.values].sort().join(",")}`:e.kind}getPropTypeKey(e){switch(e.kind){case"primitive":return e.type;case"null":return"null";case"undefined":return"undefined";case"array":return`array:${this.getPropTypeKey(e.elementType)}`;case"object":return"object";case"union":return e.types.map(t=>this.getPropTypeKey(t)).sort().join("|");case"enum":return`enum:${e.name}`;case"generic":return`generic:${e.name}`;default:return"unknown"}}};function I(i){let e=i.replace(/[^a-zA-Z0-9_$]/g,"_");return/^\d/.test(e)&&(e="_"+e),e}function C(i){return/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(i)}var T=class{constructor(e,t){this.options=e,this.namer=t}formatTypeDef(e){let{name:t,type:r,comment:n}=e,o="";this.options.addComments&&n&&(o+=this.formatJSDoc(n)+this.options.lineEnding);let s=this.options.addExport?"export ":"";return r.kind==="object"?o+=this.formatObjectType(t,r,s):r.kind==="enum"?o+=this.formatEnumType(t,r,s):o+=`${s}type ${t} = ${this.formatType(r)};`,o}formatObjectType(e,t,r){let n=this.options.outputStyle,o=" ".repeat(this.options.indentSize),s=this.options.lineEnding,u=this.sortProperties(t.properties);if(n==="interface"){let a=`${r}interface ${e} {${s}`;for(let p of u){this.options.addComments&&p.comment&&(a+=o+this.formatInlineJSDoc(p.comment)+s);let g=this.formatPropertyName(p.name),j=p.optional&&this.options.markOptional?"?":"",O=this.formatType(p.type);a+=`${o}${g}${j}: ${O};${s}`}return a+=`}${s}`,a}else{let a=`${r}type ${e} = {${s}`;for(let p of u){this.options.addComments&&p.comment&&(a+=o+this.formatInlineJSDoc(p.comment)+s);let g=this.formatPropertyName(p.name),j=p.optional&&this.options.markOptional?"?":"",O=this.formatType(p.type);a+=`${o}${g}${j}: ${O};${s}`}return a+=`};${s}`,a}}formatEnumType(e,t,r){let n=" ".repeat(this.options.indentSize),o=this.options.lineEnding,s=t.values.every(a=>typeof a=="string"),u=`${r}enum ${e} {${o}`;for(let a of t.values)if(s){let p=this.toEnumKey(String(a));u+=`${n}${p} = '${a}',${o}`}else{let p=`Value${a}`;u+=`${n}${p} = ${a},${o}`}return u+=`}${o}`,u}formatType(e){switch(e.kind){case"primitive":return e.type;case"null":return"null";case"undefined":return"undefined";case"literal":return this.formatLiteral(e.value);case"array":return this.formatArrayType(e.elementType);case"object":return this.formatInlineObject(e);case"union":return this.formatUnionType(e.types);case"enum":return e.name;case"generic":return`${e.name}<${e.typeArgs.map(t=>this.formatType(t)).join(", ")}>`;default:return"unknown"}}formatLiteral(e){return typeof e=="string"?`'${e.replace(/'/g,"\\'")}'`:String(e)}formatArrayType(e){let t=this.formatType(e);return e.kind==="union"?`(${t})[]`:`${t}[]`}formatInlineObject(e){let t=" ".repeat(this.options.indentSize),r=this.options.lineEnding,n=this.sortProperties(e.properties);if(n.length===0)return"{}";let o=`{${r}`;for(let s of n){let u=this.formatPropertyName(s.name),a=s.optional&&this.options.markOptional?"?":"",p=this.formatType(s.type);o+=`${t}${u}${a}: ${p};${r}`}return o+="}",o}formatUnionType(e){return e.map(t=>this.formatType(t)).join(" | ")}formatPropertyName(e){return C(e)?e:`'${e.replace(/'/g,"\\'")}'`}sortProperties(e){return this.options.sortProperties==="alpha"?[...e].sort((r,n)=>r.name.localeCompare(n.name)):[...e]}formatJSDoc(e){let t=e.split(`
+`);return t.length===1?`/** ${e} */`:`/**
+ * ${t.join(`
+ * `)}
+ */`}formatInlineJSDoc(e){return`/** ${e} */`}toEnumKey(e){let r=e.replace(/[-_\s]+/g," ").replace(/([a-z])([A-Z])/g,"$1 $2").trim().split(" ").filter(Boolean).map(n=>n.toUpperCase()).join("_");return/^\d/.test(r)&&(r="VALUE_"+r),C(r)||(r=I(r)),r}formatAll(e){let t=this.options.lineEnding,r=[];for(let n of e)r.push(this.formatTypeDef(n));return r.join(t)}generateOutput(e,t){let r=this.options.lineEnding,n="";return n+=`/**${r}`,n+=` * Generated by ts-gen${r}`,n+=` * Root type: ${t}${r}`,n+=` */${r}`,n+=r,n+=this.formatAll(e),n}};function H(i){let e=i.toLowerCase();return{id:"\u552F\u4E00\u6807\u8BC6\u7B26",name:"\u540D\u79F0",title:"\u6807\u9898",desc:"\u63CF\u8FF0",description:"\u63CF\u8FF0",type:"\u7C7B\u578B",status:"\u72B6\u6001",code:"\u7F16\u7801/\u72B6\u6001\u7801",msg:"\u6D88\u606F",message:"\u6D88\u606F",data:"\u6570\u636E",list:"\u5217\u8868\u6570\u636E",total:"\u603B\u6570",page:"\u9875\u7801",pageSize:"\u6BCF\u9875\u6570\u91CF",pageNum:"\u9875\u7801",pageIndex:"\u9875\u7801",size:"\u6570\u91CF/\u5927\u5C0F",count:"\u6570\u91CF",createTime:"\u521B\u5EFA\u65F6\u95F4",updateTime:"\u66F4\u65B0\u65F6\u95F4",createdAt:"\u521B\u5EFA\u65F6\u95F4",updatedAt:"\u66F4\u65B0\u65F6\u95F4",deleted:"\u662F\u5426\u5DF2\u5220\u9664",enabled:"\u662F\u5426\u542F\u7528",active:"\u662F\u5426\u6FC0\u6D3B",url:"\u94FE\u63A5\u5730\u5740",avatar:"\u5934\u50CF",email:"\u90AE\u7BB1",phone:"\u624B\u673A\u53F7",mobile:"\u624B\u673A\u53F7",username:"\u7528\u6237\u540D",password:"\u5BC6\u7801",token:"\u4EE4\u724C",userId:"\u7528\u6237ID",userName:"\u7528\u6237\u540D"}[e]}function K(i){return{...i,properties:i.properties.map(e=>({...e,comment:e.comment||H(e.name)}))}}var W=[{name:"PageResult",match:{listField:["list","records","rows","items","dataList"],totalField:["total","totalCount","count"]},typeParamIndex:0},{name:"ListResult",match:{listField:["list","records","rows","items"]},typeParamIndex:0},{name:"ApiResponse",match:{listField:["data"],totalField:["code","status"]},typeParamIndex:0}],k=class{constructor(e){this.patterns=e||W}extract(e){if(e.kind!=="object")return e;for(let t of this.patterns){let r=this.tryMatchPattern(e,t);if(r)return r}return this.extractRecursive(e)}tryMatchPattern(e,t){let r=e.properties,n=r.map(a=>a.name),o;if(t.match.listField)for(let a of t.match.listField){let p=r.find(g=>g.name===a);if(p&&p.type.kind==="array"){o=p;break}}if(!o||t.match.totalField&&!t.match.totalField.some(p=>n.includes(p)))return null;let s=o.type.elementType,u=this.extract(s);return{kind:"generic",name:t.name,typeArgs:[u]}}extractRecursive(e){return{...e,properties:e.properties.map(t=>({...t,type:this.extractPropertyType(t.type)}))}}extractPropertyType(e){return e.kind==="object"?this.extract(e):e.kind==="array"?{...e,elementType:this.extractPropertyType(e.elementType)}:e.kind==="union"?{...e,types:e.types.map(t=>this.extractPropertyType(t))}:e}},S=class{constructor(e=5){this.threshold=e}extract(e,t){return this.extractRecursive(e,t,"")}extractRecursive(e,t,r){if(t.kind==="object"&&e&&typeof e=="object"){let n=e;return{...t,properties:t.properties.map(o=>{let s=r?`${r}.${o.name}`:o.name,u=n[o.name];return{...o,type:this.extractRecursive(u,o.type,s)}})}}if(t.kind==="array"&&Array.isArray(e)){let n=t.elementType;if(n.kind==="object"){let o=n.properties.map(s=>{let u=this.collectFieldValues(e,s.name),a=this.tryExtractEnum(u,s.type,s.name);return{...s,type:a}});return{...t,elementType:{...n,properties:o}}}if(n.kind==="primitive"&&n.type==="string"){let o=e.filter(u=>typeof u=="string"),s=[...new Set(o)];if(s.length>0&&s.length<=this.threshold)return{...t,elementType:{kind:"enum",name:"",values:s}}}return t}return t}collectFieldValues(e,t){let r=[];for(let n of e)if(n&&typeof n=="object"){let o=n[t];o!==void 0&&r.push(o)}return r}tryExtractEnum(e,t,r){if(t.kind!=="primitive"||t.type!=="string")return t;let n=e.filter(a=>typeof a=="string"),o=[...new Set(n)];return o.length===0||o.length>this.threshold||!o.every(a=>a.length<=50&&/^[a-zA-Z0-9_\-]+$/.test(a))?t:{kind:"enum",name:"",values:o}}},v=class{constructor(e=!1){this.strictNullChecks=e}process(e){return this.strictNullChecks?this.processRecursive(e):this.removeNullRecursive(e)}processRecursive(e){return e.kind==="object"?{...e,properties:e.properties.map(t=>({...t,type:this.processRecursive(t.type)}))}:e.kind==="array"?{...e,elementType:this.processRecursive(e.elementType)}:e.kind==="union"?{...e,types:e.types.map(t=>this.processRecursive(t))}:e}removeNullRecursive(e){if(e.kind==="object")return{...e,properties:e.properties.map(t=>({...t,type:this.removeNullRecursive(t.type)}))};if(e.kind==="array")return{...e,elementType:this.removeNullRecursive(e.elementType)};if(e.kind==="union"){let t=e.types.map(r=>this.removeNullRecursive(r)).filter(r=>r.kind!=="null");return t.length===0?m("unknown"):t.length===1?t[0]:h(t)}return e}},b=class{constructor(e=!0){this.markOptional=e}process(e,t){return this.markOptional?this.processRecursive(e,t):t}processRecursive(e,t){if(t.kind==="array"&&Array.isArray(e)&&e.length>1){let r=t.elementType;if(r.kind==="object"){let n=e.filter(o=>o!==null&&typeof o=="object"&&!Array.isArray(o));if(n.length>0){let o=this.markOptionalInArrayObjects(n,r);return{...t,elementType:o}}}return{...t,elementType:this.processRecursive(e[0],t.elementType)}}if(t.kind==="object"&&e&&typeof e=="object"){let r=e;return{...t,properties:t.properties.map(n=>{let o=r[n.name];return{...n,type:this.processRecursive(o,n.type)}})}}return t.kind==="union"?{...t,types:t.types.map(r=>this.processRecursive(e,r))}:t}markOptionalInArrayObjects(e,t){let r=e.length;return{...t,properties:t.properties.map(n=>{let o=0;for(let p of e)n.name in p&&o++;let s=o<r,u=e.map(p=>p[n.name]).filter(p=>p!==void 0),a=u.length>0?this.processRecursive(u[0],n.type):n.type;return{...n,optional:n.optional||s,type:a}})}}};function x(i,e,t){let r=l(e);return t.markOptional&&(r=new b(t.markOptional).process(i,r)),t.extractEnums&&(r=new S(t.enumThreshold).extract(i,r)),t.extractGenerics&&(r=new k().extract(r)),r=new v(t.strictNullChecks).process(r),r}function $(i,e={}){let t={...D,...e},r=f(i);r=x(i,r,t),t.addComments&&r.kind==="object"&&(r=K(r));let n=new d({namingStyle:t.namingStyle,prefix:t.typePrefix,suffix:t.typeSuffix,customNameMap:t.typeNameMap}),o=new y(n),s=t.rootName||"Root",u=o.collect(r,s);return{code:new T(t,n).generateOutput(u,s),types:u}}function M(i,e={}){let t=JSON.parse(i);return $(t,e)}function F(i,e={}){return $(i,e).code}var Q={generate:$,generateFromString:M,generateType:F};0&&(module.exports={CodeFormatter,EnumExtractor,GenericExtractor,NullHandler,OptionalHandler,TypeCollector,TypeNamer,applyEnhancements,createUnion,generate,generateFromString,generateType,inferArrayType,inferObjectType,inferType,isStructurallyEqual,mergeObjects,mergeTypes});