@kubb/plugin-ts 5.0.0-alpha.1 → 5.0.0-alpha.11

package/dist/components-DeNDKlzf.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"components-DeNDKlzf.cjs","names":["ts","factory.createTypeLiteralNode","factory.createArrayDeclaration","factory.createOptionalTypeNode","factory.createRestTypeNode","factory.createArrayTypeNode","factory.createTupleTypeNode","factory.createTypeReferenceNode","factory.createUnionDeclaration","factory.createLiteralTypeNode","factory.createTrue","factory.createFalse","factory.createNumericLiteral","factory.createStringLiteral","factory.createIdentifier","factory.createIntersectionDeclaration","schemaKeywords","factory.createPropertySignature","factory.appendJSDocToNode","factory.createIndexSignature","schemaKeywords","SchemaGenerator","factory.createTypeReferenceNode","factory.createIdentifier","factory.createArrayTypeNode","factory.createUnionDeclaration","factory.createTypeDeclaration","factory.createOmitDeclaration","factory.createEnumDeclaration","File"],"sources":["../../../internals/utils/src/casing.ts","../../../internals/utils/src/string.ts","../src/factory.ts","../src/parser.ts","../src/components/Type.tsx"],"sourcesContent":["type Options = {\n  /** When `true`, dot-separated segments are split on `.` and joined with `/` after casing. */\n  isFile?: boolean\n  /** Text prepended before casing is applied. */\n  prefix?: string\n  /** Text appended before casing is applied. */\n  suffix?: string\n}\n\n/**\n * Shared implementation for camelCase and PascalCase conversion.\n * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)\n * and capitalizes each word according to `pascal`.\n *\n * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.\n */\nfunction toCamelOrPascal(text: string, pascal: boolean): string {\n  const normalized = text\n    .trim()\n    .replace(/([a-z\\d])([A-Z])/g, '$1 $2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')\n    .replace(/(\\d)([a-z])/g, '$1 $2')\n\n  const words = normalized.split(/[\\s\\-_./\\\\:]+/).filter(Boolean)\n\n  return words\n    .map((word, i) => {\n      const allUpper = word.length > 1 && word === word.toUpperCase()\n      if (allUpper) return word\n      if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1)\n      return word.charAt(0).toUpperCase() + word.slice(1)\n    })\n    .join('')\n    .replace(/[^a-zA-Z0-9]/g, '')\n}\n\n/**\n * Splits `text` on `.` and applies `transformPart` to each segment.\n * The last segment receives `isLast = true`, all earlier segments receive `false`.\n * Segments are joined with `/` to form a file path.\n */\nfunction applyToFileParts(text: string, transformPart: (part: string, isLast: boolean) => string): string {\n  const parts = text.split('.')\n  return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join('/')\n}\n\n/**\n * Converts `text` to camelCase.\n * When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.\n *\n * @example\n * camelCase('hello-world')                   // 'helloWorld'\n * camelCase('pet.petId', { isFile: true })   // 'pet/petId'\n */\nexport function camelCase(text: string, { isFile, prefix = '', suffix = '' }: Options = {}): string {\n  if (isFile) {\n    return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? { prefix, suffix } : {}))\n  }\n\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false)\n}\n\n/**\n * Converts `text` to PascalCase.\n * When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.\n *\n * @example\n * pascalCase('hello-world')                  // 'HelloWorld'\n * pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'\n */\nexport function pascalCase(text: string, { isFile, prefix = '', suffix = '' }: Options = {}): string {\n  if (isFile) {\n    return applyToFileParts(text, (part, isLast) => (isLast ? pascalCase(part, { prefix, suffix }) : camelCase(part)))\n  }\n\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true)\n}\n\n/**\n * Converts `text` to snake_case.\n *\n * @example\n * snakeCase('helloWorld')  // 'hello_world'\n * snakeCase('Hello-World') // 'hello_world'\n */\nexport function snakeCase(text: string, { prefix = '', suffix = '' }: Omit<Options, 'isFile'> = {}): string {\n  const processed = `${prefix} ${text} ${suffix}`.trim()\n  return processed\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    .replace(/[\\s\\-.]+/g, '_')\n    .replace(/[^a-zA-Z0-9_]/g, '')\n    .toLowerCase()\n    .split('_')\n    .filter(Boolean)\n    .join('_')\n}\n\n/**\n * Converts `text` to SCREAMING_SNAKE_CASE.\n *\n * @example\n * screamingSnakeCase('helloWorld') // 'HELLO_WORLD'\n */\nexport function screamingSnakeCase(text: string, { prefix = '', suffix = '' }: Omit<Options, 'isFile'> = {}): string {\n  return snakeCase(text, { prefix, suffix }).toUpperCase()\n}\n","/**\n * Strips a single matching pair of `\"...\"`, `'...'`, or `` `...` `` from both ends of `text`.\n * Returns the string unchanged when no balanced quote pair is found.\n *\n * @example\n * trimQuotes('\"hello\"') // 'hello'\n * trimQuotes('hello')   // 'hello'\n */\nexport function trimQuotes(text: string): string {\n  if (text.length >= 2) {\n    const first = text[0]\n    const last = text[text.length - 1]\n    if ((first === '\"' && last === '\"') || (first === \"'\" && last === \"'\") || (first === '`' && last === '`')) {\n      return text.slice(1, -1)\n    }\n  }\n  return text\n}\n\n/**\n * Escapes characters that are not allowed inside JS string literals.\n * Handles quotes, backslashes, and Unicode line terminators (U+2028 / U+2029).\n *\n * @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4\n */\nexport function jsStringEscape(input: unknown): string {\n  return `${input}`.replace(/[\"'\\\\\\n\\r\\u2028\\u2029]/g, (character) => {\n    switch (character) {\n      case '\"':\n      case \"'\":\n      case '\\\\':\n        return `\\\\${character}`\n      case '\\n':\n        return '\\\\n'\n      case '\\r':\n        return '\\\\r'\n      case '\\u2028':\n        return '\\\\u2028'\n      case '\\u2029':\n        return '\\\\u2029'\n      default:\n        return ''\n    }\n  })\n}\n\n/**\n * Returns a masked version of a string, showing only the first and last few characters.\n * Useful for logging sensitive values (tokens, keys) without exposing the full value.\n *\n * @example\n * maskString('KUBB_STUDIO-abc123-xyz789') // 'KUBB_STUDIO-…789'\n */\nexport function maskString(value: string, start = 8, end = 4): string {\n  if (value.length <= start + end) return value\n  return `${value.slice(0, start)}…${value.slice(-end)}`\n}\n","import { camelCase, pascalCase, screamingSnakeCase, snakeCase } from '@internals/utils'\nimport { isNumber, sortBy } from 'remeda'\nimport ts from 'typescript'\n\nconst { SyntaxKind, factory } = ts\n\n// https://ts-ast-viewer.com/\n\nexport const modifiers = {\n  async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),\n  export: factory.createModifier(ts.SyntaxKind.ExportKeyword),\n  const: factory.createModifier(ts.SyntaxKind.ConstKeyword),\n  static: factory.createModifier(ts.SyntaxKind.StaticKeyword),\n} as const\n\nexport const syntaxKind = {\n  union: SyntaxKind.UnionType as 192,\n  literalType: SyntaxKind.LiteralType,\n  stringLiteral: SyntaxKind.StringLiteral,\n} as const\n\nexport function getUnknownType(unknownType: 'any' | 'unknown' | 'void' | undefined) {\n  if (unknownType === 'any') {\n    return keywordTypeNodes.any\n  }\n  if (unknownType === 'void') {\n    return keywordTypeNodes.void\n  }\n\n  return keywordTypeNodes.unknown\n}\nfunction isValidIdentifier(str: string): boolean {\n  if (!str.length || str.trim() !== str) {\n    return false\n  }\n  const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest)\n\n  return !!node && node.kind === ts.SyntaxKind.Identifier && ts.identifierToKeywordKind(node.kind as unknown as ts.Identifier) === undefined\n}\n\nfunction propertyName(name: string | ts.PropertyName): ts.PropertyName {\n  if (typeof name === 'string') {\n    const isValid = isValidIdentifier(name)\n    return isValid ? factory.createIdentifier(name) : factory.createStringLiteral(name)\n  }\n  return name\n}\n\nconst questionToken = factory.createToken(ts.SyntaxKind.QuestionToken)\n\nexport function createQuestionToken(token?: boolean | ts.QuestionToken) {\n  if (!token) {\n    return undefined\n  }\n  if (token === true) {\n    return questionToken\n  }\n  return token\n}\n\nexport function createIntersectionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return null\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] || null\n  }\n\n  const node = factory.createIntersectionTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\n/**\n * Minimum nodes length of 2\n * @example `string & number`\n */\nexport function createTupleDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return null\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] || null\n  }\n\n  const node = factory.createTupleTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\nexport function createArrayDeclaration({ nodes, arrayType = 'array' }: { nodes: Array<ts.TypeNode>; arrayType?: 'array' | 'generic' }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return factory.createTupleTypeNode([])\n  }\n\n  if (nodes.length === 1) {\n    const node = nodes[0]\n    if (!node) {\n      return null\n    }\n    if (arrayType === 'generic') {\n      return factory.createTypeReferenceNode(factory.createIdentifier('Array'), [node])\n    }\n    return factory.createArrayTypeNode(node)\n  }\n\n  // For union types (multiple nodes), respect arrayType preference\n  const unionType = factory.createUnionTypeNode(nodes)\n  if (arrayType === 'generic') {\n    return factory.createTypeReferenceNode(factory.createIdentifier('Array'), [unionType])\n  }\n  // For array syntax with unions, we need parentheses: (string | number)[]\n  return factory.createArrayTypeNode(factory.createParenthesizedType(unionType))\n}\n\n/**\n * Minimum nodes length of 2\n * @example `string | number`\n */\nexport function createUnionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode {\n  if (!nodes.length) {\n    return keywordTypeNodes.any\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] as ts.TypeNode\n  }\n\n  const node = factory.createUnionTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\nexport function createPropertySignature({\n  readOnly,\n  modifiers = [],\n  name,\n  questionToken,\n  type,\n}: {\n  readOnly?: boolean\n  modifiers?: Array<ts.Modifier>\n  name: ts.PropertyName | string\n  questionToken?: ts.QuestionToken | boolean\n  type?: ts.TypeNode\n}) {\n  return factory.createPropertySignature(\n    [...modifiers, readOnly ? factory.createToken(ts.SyntaxKind.ReadonlyKeyword) : undefined].filter(Boolean),\n    propertyName(name),\n    createQuestionToken(questionToken),\n    type,\n  )\n}\n\nexport function createParameterSignature(\n  name: string | ts.BindingName,\n  {\n    modifiers,\n    dotDotDotToken,\n    questionToken,\n    type,\n    initializer,\n  }: {\n    decorators?: Array<ts.Decorator>\n    modifiers?: Array<ts.Modifier>\n    dotDotDotToken?: ts.DotDotDotToken\n    questionToken?: ts.QuestionToken | boolean\n    type?: ts.TypeNode\n    initializer?: ts.Expression\n  },\n): ts.ParameterDeclaration {\n  return factory.createParameterDeclaration(modifiers, dotDotDotToken, name, createQuestionToken(questionToken), type, initializer)\n}\n\nexport function createJSDoc({ comments }: { comments: string[] }) {\n  if (!comments.length) {\n    return null\n  }\n  return factory.createJSDocComment(\n    factory.createNodeArray(\n      comments.map((comment, i) => {\n        if (i === comments.length - 1) {\n          return factory.createJSDocText(comment)\n        }\n\n        return factory.createJSDocText(`${comment}\\n`)\n      }),\n    ),\n  )\n}\n\n/**\n * @link https://github.com/microsoft/TypeScript/issues/44151\n */\nexport function appendJSDocToNode<TNode extends ts.Node>({ node, comments }: { node: TNode; comments: Array<string | undefined> }) {\n  const filteredComments = comments.filter(Boolean)\n\n  if (!filteredComments.length) {\n    return node\n  }\n\n  const text = filteredComments.reduce((acc = '', comment = '') => {\n    return `${acc}\\n * ${comment.replaceAll('*/', '*\\\\/')}`\n  }, '*')\n\n  // Use the node directly instead of spreading to avoid creating Unknown nodes\n  // TypeScript's addSyntheticLeadingComment accepts the node as-is\n  return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `${text || '*'}\\n`, true)\n}\n\nexport function createIndexSignature(\n  type: ts.TypeNode,\n  {\n    modifiers,\n    indexName = 'key',\n    indexType = factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n  }: {\n    indexName?: string\n    indexType?: ts.TypeNode\n    decorators?: Array<ts.Decorator>\n    modifiers?: Array<ts.Modifier>\n  } = {},\n) {\n  return factory.createIndexSignature(modifiers, [createParameterSignature(indexName, { type: indexType })], type)\n}\n\nexport function createTypeAliasDeclaration({\n  modifiers,\n  name,\n  typeParameters,\n  type,\n}: {\n  modifiers?: Array<ts.Modifier>\n  name: string | ts.Identifier\n  typeParameters?: Array<ts.TypeParameterDeclaration>\n  type: ts.TypeNode\n}) {\n  return factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type)\n}\n\nexport function createInterfaceDeclaration({\n  modifiers,\n  name,\n  typeParameters,\n  members,\n}: {\n  modifiers?: Array<ts.Modifier>\n  name: string | ts.Identifier\n  typeParameters?: Array<ts.TypeParameterDeclaration>\n  members: Array<ts.TypeElement>\n}) {\n  return factory.createInterfaceDeclaration(modifiers, name, typeParameters, undefined, members)\n}\n\nexport function createTypeDeclaration({\n  syntax,\n  isExportable,\n  comments,\n  name,\n  type,\n}: {\n  syntax: 'type' | 'interface'\n  comments: Array<string | undefined>\n  isExportable?: boolean\n  name: string | ts.Identifier\n  type: ts.TypeNode\n}) {\n  if (syntax === 'interface' && 'members' in type) {\n    const node = createInterfaceDeclaration({\n      members: type.members as Array<ts.TypeElement>,\n      modifiers: isExportable ? [modifiers.export] : [],\n      name,\n      typeParameters: undefined,\n    })\n\n    return appendJSDocToNode({\n      node,\n      comments,\n    })\n  }\n\n  const node = createTypeAliasDeclaration({\n    type,\n    modifiers: isExportable ? [modifiers.export] : [],\n    name,\n    typeParameters: undefined,\n  })\n\n  return appendJSDocToNode({\n    node,\n    comments,\n  })\n}\n\nexport function createNamespaceDeclaration({ statements, name }: { name: string; statements: ts.Statement[] }) {\n  return factory.createModuleDeclaration(\n    [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n    factory.createIdentifier(name),\n    factory.createModuleBlock(statements),\n    ts.NodeFlags.Namespace,\n  )\n}\n\n/**\n * In { propertyName: string; name?: string } is `name` being used to make the type more unique when multiple same names are used.\n * @example `import { Pet as Cat } from './Pet'`\n */\nexport function createImportDeclaration({\n  name,\n  path,\n  isTypeOnly = false,\n  isNameSpace = false,\n}: {\n  name: string | Array<string | { propertyName: string; name?: string }>\n  path: string\n  isTypeOnly?: boolean\n  isNameSpace?: boolean\n}) {\n  if (!Array.isArray(name)) {\n    let importPropertyName: ts.Identifier | undefined = factory.createIdentifier(name)\n    let importName: ts.NamedImportBindings | undefined\n\n    if (isNameSpace) {\n      importPropertyName = undefined\n      importName = factory.createNamespaceImport(factory.createIdentifier(name))\n    }\n\n    return factory.createImportDeclaration(\n      undefined,\n      factory.createImportClause(isTypeOnly, importPropertyName, importName),\n      factory.createStringLiteral(path),\n      undefined,\n    )\n  }\n\n  // Sort the imports alphabetically for consistent output across platforms\n  const sortedName = sortBy(name, [(item) => (typeof item === 'object' ? item.propertyName : item), 'asc'])\n\n  return factory.createImportDeclaration(\n    undefined,\n    factory.createImportClause(\n      isTypeOnly,\n      undefined,\n      factory.createNamedImports(\n        sortedName.map((item) => {\n          if (typeof item === 'object') {\n            const obj = item as { propertyName: string; name?: string }\n            if (obj.name) {\n              return factory.createImportSpecifier(false, factory.createIdentifier(obj.propertyName), factory.createIdentifier(obj.name))\n            }\n\n            return factory.createImportSpecifier(false, undefined, factory.createIdentifier(obj.propertyName))\n          }\n\n          return factory.createImportSpecifier(false, undefined, factory.createIdentifier(item))\n        }),\n      ),\n    ),\n    factory.createStringLiteral(path),\n    undefined,\n  )\n}\n\nexport function createExportDeclaration({\n  path,\n  asAlias,\n  isTypeOnly = false,\n  name,\n}: {\n  path: string\n  asAlias?: boolean\n  isTypeOnly?: boolean\n  name?: string | Array<ts.Identifier | string>\n}) {\n  if (name && !Array.isArray(name) && !asAlias) {\n    console.warn(`When using name as string, asAlias should be true ${name}`)\n  }\n\n  if (!Array.isArray(name)) {\n    const parsedName = name?.match(/^\\d/) ? `_${name?.slice(1)}` : name\n\n    return factory.createExportDeclaration(\n      undefined,\n      isTypeOnly,\n      asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : undefined,\n      factory.createStringLiteral(path),\n      undefined,\n    )\n  }\n\n  // Sort the exports alphabetically for consistent output across platforms\n  const sortedName = sortBy(name, [(propertyName) => (typeof propertyName === 'string' ? propertyName : propertyName.text), 'asc'])\n\n  return factory.createExportDeclaration(\n    undefined,\n    isTypeOnly,\n    factory.createNamedExports(\n      sortedName.map((propertyName) => {\n        return factory.createExportSpecifier(false, undefined, typeof propertyName === 'string' ? factory.createIdentifier(propertyName) : propertyName)\n      }),\n    ),\n    factory.createStringLiteral(path),\n    undefined,\n  )\n}\n\n/**\n * Apply casing transformation to enum keys\n */\nfunction applyEnumKeyCasing(key: string, casing: 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none' = 'none'): string {\n  if (casing === 'none') {\n    return key\n  }\n  if (casing === 'screamingSnakeCase') {\n    return screamingSnakeCase(key)\n  }\n  if (casing === 'snakeCase') {\n    return snakeCase(key)\n  }\n  if (casing === 'pascalCase') {\n    return pascalCase(key)\n  }\n  if (casing === 'camelCase') {\n    return camelCase(key)\n  }\n  return key\n}\n\nexport function createEnumDeclaration({\n  type = 'enum',\n  name,\n  typeName,\n  enums,\n  enumKeyCasing = 'none',\n}: {\n  /**\n   * Choose to use `enum`, `asConst`, `asPascalConst`, `constEnum`, or `literal` for enums.\n   * - `enum`: TypeScript enum\n   * - `asConst`: const with camelCase name (e.g., `petType`)\n   * - `asPascalConst`: const with PascalCase name (e.g., `PetType`)\n   * - `constEnum`: const enum\n   * - `literal`: literal union type\n   * @default `'enum'`\n   */\n  type?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral'\n  /**\n   * Enum name in camelCase.\n   */\n  name: string\n  /**\n   * Enum name in PascalCase.\n   */\n  typeName: string\n  enums: [key: string | number, value: string | number | boolean][]\n  /**\n   * Choose the casing for enum key names.\n   * @default 'none'\n   */\n  enumKeyCasing?: 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none'\n}): [name: ts.Node | undefined, type: ts.Node] {\n  if (type === 'literal' || type === 'inlineLiteral') {\n    return [\n      undefined,\n      factory.createTypeAliasDeclaration(\n        [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n        factory.createIdentifier(typeName),\n        undefined,\n        factory.createUnionTypeNode(\n          enums\n            .map(([_key, value]) => {\n              if (isNumber(value)) {\n                if (value < 0) {\n                  return factory.createLiteralTypeNode(\n                    factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value))),\n                  )\n                }\n                return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()))\n              }\n\n              if (typeof value === 'boolean') {\n                return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse())\n              }\n              if (value) {\n                return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()))\n              }\n\n              return undefined\n            })\n            .filter(Boolean),\n        ),\n      ),\n    ]\n  }\n\n  if (type === 'enum' || type === 'constEnum') {\n    return [\n      undefined,\n      factory.createEnumDeclaration(\n        [factory.createToken(ts.SyntaxKind.ExportKeyword), type === 'constEnum' ? factory.createToken(ts.SyntaxKind.ConstKeyword) : undefined].filter(Boolean),\n        factory.createIdentifier(typeName),\n        enums\n          .map(([key, value]) => {\n            let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n            const isExactNumber = Number.parseInt(value.toString(), 10) === value\n\n            if (isExactNumber && isNumber(Number.parseInt(value.toString(), 10))) {\n              if ((value as number) < 0) {\n                initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value as number)))\n              } else {\n                initializer = factory.createNumericLiteral(value as number)\n              }\n            }\n\n            if (typeof value === 'boolean') {\n              initializer = value ? factory.createTrue() : factory.createFalse()\n            }\n\n            if (isNumber(Number.parseInt(key.toString(), 10))) {\n              const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing)\n              return factory.createEnumMember(propertyName(casingKey), initializer)\n            }\n\n            if (key) {\n              const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing)\n              return factory.createEnumMember(propertyName(casingKey), initializer)\n            }\n\n            return undefined\n          })\n          .filter(Boolean),\n      ),\n    ]\n  }\n\n  // used when using `as const` instead of an TypeScript enum.\n  // name is already PascalCase for asPascalConst and camelCase for asConst (set in Type.tsx)\n  // typeName has the Key suffix for type alias, so we use name for the const identifier\n  const identifierName = name\n\n  // When there are no enum items (empty or all-null enum), don't generate a runtime const.\n  // Return undefined for nameNode so the barrel won't try to export a non-existent symbol.\n  // Use `never` as the type alias to keep references valid without creating a broken const.\n  if (enums.length === 0) {\n    return [\n      undefined,\n      factory.createTypeAliasDeclaration(\n        [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n        factory.createIdentifier(typeName),\n        undefined,\n        factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword),\n      ),\n    ]\n  }\n\n  return [\n    factory.createVariableStatement(\n      [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n      factory.createVariableDeclarationList(\n        [\n          factory.createVariableDeclaration(\n            factory.createIdentifier(identifierName),\n            undefined,\n            undefined,\n            factory.createAsExpression(\n              factory.createObjectLiteralExpression(\n                enums\n                  .map(([key, value]) => {\n                    let initializer: ts.Expression = factory.createStringLiteral(value?.toString())\n\n                    if (isNumber(value)) {\n                      // Error: Negative numbers should be created in combination with createPrefixUnaryExpression factory.\n                      // The method createNumericLiteral only accepts positive numbers\n                      // or those combined with createPrefixUnaryExpression.\n                      // Therefore, we need to ensure that the number is not negative.\n                      if (value < 0) {\n                        initializer = factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)))\n                      } else {\n                        initializer = factory.createNumericLiteral(value)\n                      }\n                    }\n\n                    if (typeof value === 'boolean') {\n                      initializer = value ? factory.createTrue() : factory.createFalse()\n                    }\n\n                    if (key) {\n                      const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing)\n                      return factory.createPropertyAssignment(propertyName(casingKey), initializer)\n                    }\n\n                    return undefined\n                  })\n                  .filter(Boolean),\n                true,\n              ),\n              factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),\n            ),\n          ),\n        ],\n        ts.NodeFlags.Const,\n      ),\n    ),\n    factory.createTypeAliasDeclaration(\n      [factory.createToken(ts.SyntaxKind.ExportKeyword)],\n      factory.createIdentifier(typeName),\n      undefined,\n      factory.createIndexedAccessTypeNode(\n        factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n        factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n      ),\n    ),\n  ]\n}\n\nexport function createOmitDeclaration({ keys, type, nonNullable }: { keys: Array<string> | string; type: ts.TypeNode; nonNullable?: boolean }) {\n  const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier('NonNullable'), [type]) : type\n\n  if (Array.isArray(keys)) {\n    return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [\n      node,\n      factory.createUnionTypeNode(\n        keys.map((key) => {\n          return factory.createLiteralTypeNode(factory.createStringLiteral(key))\n        }),\n      ),\n    ])\n  }\n\n  return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))])\n}\n\nexport const keywordTypeNodes = {\n  any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),\n  unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n  void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),\n  number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n  integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n  bigint: factory.createKeywordTypeNode(ts.SyntaxKind.BigIntKeyword),\n  object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),\n  string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n  boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),\n  undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n  null: factory.createLiteralTypeNode(factory.createToken(ts.SyntaxKind.NullKeyword)),\n  never: factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword),\n} as const\n\n/**\n * Converts a path like '/pet/{petId}/uploadImage' to a template literal type\n * like `/pet/${string}/uploadImage`\n */\n/**\n * Converts an OAS-style path (e.g. `/pets/{petId}`) or an Express-style path\n * (e.g. `/pets/:petId`) to a TypeScript template literal type\n * like `` `/pets/${string}` ``.\n */\nexport function createUrlTemplateType(path: string): ts.TypeNode {\n  // normalized Express `:param` → OAS `{param}` so a single regex handles both.\n  const normalized = path.replace(/:([^/]+)/g, '{$1}')\n\n  if (!normalized.includes('{')) {\n    return factory.createLiteralTypeNode(factory.createStringLiteral(normalized))\n  }\n\n  const segments = normalized.split(/(\\{[^}]+\\})/)\n  const parts: string[] = []\n  const parameterIndices: number[] = []\n\n  segments.forEach((segment) => {\n    if (segment.startsWith('{') && segment.endsWith('}')) {\n      parameterIndices.push(parts.length)\n      parts.push(segment)\n    } else if (segment) {\n      parts.push(segment)\n    }\n  })\n\n  const head = ts.factory.createTemplateHead(parts[0] || '')\n  const templateSpans: ts.TemplateLiteralTypeSpan[] = []\n\n  parameterIndices.forEach((paramIndex, i) => {\n    const isLast = i === parameterIndices.length - 1\n    const nextPart = parts[paramIndex + 1] || ''\n    const literal = isLast ? ts.factory.createTemplateTail(nextPart) : ts.factory.createTemplateMiddle(nextPart)\n    templateSpans.push(ts.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal))\n  })\n\n  return ts.factory.createTemplateLiteralType(head, templateSpans)\n}\n\nexport const createTypeLiteralNode = factory.createTypeLiteralNode\n\nexport const createTypeReferenceNode = factory.createTypeReferenceNode\nexport const createNumericLiteral = factory.createNumericLiteral\nexport const createStringLiteral = factory.createStringLiteral\n\nexport const createArrayTypeNode = factory.createArrayTypeNode\nexport const createParenthesizedType = factory.createParenthesizedType\n\nexport const createLiteralTypeNode = factory.createLiteralTypeNode\nexport const createNull = factory.createNull\nexport const createIdentifier = factory.createIdentifier\n\nexport const createOptionalTypeNode = factory.createOptionalTypeNode\nexport const createTupleTypeNode = factory.createTupleTypeNode\nexport const createRestTypeNode = factory.createRestTypeNode\nexport const createTrue = factory.createTrue\nexport const createFalse = factory.createFalse\nexport const createIndexedAccessTypeNode = factory.createIndexedAccessTypeNode\nexport const createTypeOperatorNode = factory.createTypeOperatorNode\nexport const createPrefixUnaryExpression = factory.createPrefixUnaryExpression\n\nexport { SyntaxKind }\n","import { jsStringEscape } from '@internals/utils'\nimport type { SchemaKeywordMapper, SchemaMapper } from '@kubb/plugin-oas'\nimport { createParser, isKeyword, schemaKeywords } from '@kubb/plugin-oas'\nimport type ts from 'typescript'\nimport * as factory from './factory.ts'\n\nexport const typeKeywordMapper = {\n  any: () => factory.keywordTypeNodes.any,\n  unknown: () => factory.keywordTypeNodes.unknown,\n  void: () => factory.keywordTypeNodes.void,\n  number: () => factory.keywordTypeNodes.number,\n  integer: () => factory.keywordTypeNodes.number,\n  bigint: () => factory.keywordTypeNodes.bigint,\n  object: (nodes?: ts.TypeElement[]) => {\n    if (!nodes || !nodes.length) {\n      return factory.keywordTypeNodes.object\n    }\n\n    return factory.createTypeLiteralNode(nodes)\n  },\n  string: () => factory.keywordTypeNodes.string,\n  boolean: () => factory.keywordTypeNodes.boolean,\n  undefined: () => factory.keywordTypeNodes.undefined,\n  nullable: undefined,\n  null: () => factory.keywordTypeNodes.null,\n  nullish: undefined,\n  array: (nodes?: ts.TypeNode[], arrayType?: 'array' | 'generic') => {\n    if (!nodes) {\n      return undefined\n    }\n\n    return factory.createArrayDeclaration({ nodes, arrayType })\n  },\n  tuple: (nodes?: ts.TypeNode[], rest?: ts.TypeNode, min?: number, max?: number) => {\n    if (!nodes) {\n      return undefined\n    }\n\n    if (max) {\n      nodes = nodes.slice(0, max)\n\n      if (nodes.length < max && rest) {\n        nodes = [...nodes, ...Array(max - nodes.length).fill(rest)]\n      }\n    }\n\n    if (min) {\n      nodes = nodes.map((node, index) => (index >= min ? factory.createOptionalTypeNode(node) : node))\n    }\n\n    if (typeof max === 'undefined' && rest) {\n      nodes.push(factory.createRestTypeNode(factory.createArrayTypeNode(rest)))\n    }\n\n    return factory.createTupleTypeNode(nodes)\n  },\n  enum: (name?: string) => {\n    if (!name) {\n      return undefined\n    }\n\n    return factory.createTypeReferenceNode(name, undefined)\n  },\n  union: (nodes?: ts.TypeNode[]) => {\n    if (!nodes) {\n      return undefined\n    }\n\n    return factory.createUnionDeclaration({\n      withParentheses: true,\n      nodes,\n    })\n  },\n  const: (name?: string | number | boolean, format?: 'string' | 'number' | 'boolean') => {\n    if (name === null || name === undefined || name === '') {\n      return undefined\n    }\n\n    if (format === 'boolean') {\n      if (name === true) {\n        return factory.createLiteralTypeNode(factory.createTrue())\n      }\n\n      return factory.createLiteralTypeNode(factory.createFalse())\n    }\n\n    if (format === 'number' && typeof name === 'number') {\n      return factory.createLiteralTypeNode(factory.createNumericLiteral(name))\n    }\n\n    return factory.createLiteralTypeNode(factory.createStringLiteral(name.toString()))\n  },\n  datetime: () => factory.keywordTypeNodes.string,\n  date: (type: 'date' | 'string' = 'string') =>\n    type === 'string' ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier('Date')),\n  time: (type: 'date' | 'string' = 'string') =>\n    type === 'string' ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier('Date')),\n  uuid: () => factory.keywordTypeNodes.string,\n  url: () => factory.keywordTypeNodes.string,\n  default: undefined,\n  and: (nodes?: ts.TypeNode[]) => {\n    if (!nodes) {\n      return undefined\n    }\n\n    return factory.createIntersectionDeclaration({\n      withParentheses: true,\n      nodes,\n    })\n  },\n  describe: undefined,\n  min: undefined,\n  max: undefined,\n  optional: undefined,\n  matches: () => factory.keywordTypeNodes.string,\n  email: () => factory.keywordTypeNodes.string,\n  firstName: undefined,\n  lastName: undefined,\n  password: undefined,\n  phone: undefined,\n  readOnly: undefined,\n  writeOnly: undefined,\n  ref: (propertyName?: string) => {\n    if (!propertyName) {\n      return undefined\n    }\n\n    return factory.createTypeReferenceNode(propertyName, undefined)\n  },\n  blob: () => factory.createTypeReferenceNode('Blob', []),\n  deprecated: undefined,\n  example: undefined,\n  schema: undefined,\n  catchall: undefined,\n  name: undefined,\n  interface: undefined,\n  exclusiveMaximum: undefined,\n  exclusiveMinimum: undefined,\n} satisfies SchemaMapper<ts.TypeNode | null | undefined>\n\ntype ParserOptions = {\n  /**\n   * @default `'questionToken'`\n   */\n  optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined'\n  /**\n   * @default `'array'`\n   */\n  arrayType: 'array' | 'generic'\n  /**\n   * Choose to use `enum`, `asConst`, `asPascalConst`, `constEnum`, `literal`, or `inlineLiteral` for enums.\n   * - `enum`: TypeScript enum\n   * - `asConst`: const with camelCase name (e.g., `petType`)\n   * - `asPascalConst`: const with PascalCase name (e.g., `PetType`)\n   * - `constEnum`: const enum\n   * - `literal`: literal union type\n   * - `inlineLiteral`: inline enum values directly into the type (default in v5)\n   * @default `'asConst'`\n   * @note In Kubb v5, `inlineLiteral` becomes the default.\n   */\n  enumType: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral'\n}\n\n/**\n * Recursively parses a schema tree node into a corresponding TypeScript AST node.\n *\n * Maps OpenAPI schema keywords to TypeScript AST nodes using the `typeKeywordMapper`, handling complex types such as unions, intersections, arrays, tuples (with optional/rest elements and length constraints), enums, constants, references, and objects with property modifiers and documentation annotations.\n *\n * @param current - The schema node to parse.\n * @param siblings - Sibling schema nodes, used for context in certain mappings.\n * @param name - The name of the schema or property being parsed.\n * @param options - Parsing options controlling output style, property handling.\n * @returns The generated TypeScript AST node, or `undefined` if the schema keyword is not mapped.\n */\nexport const parse = createParser<ts.Node | null, ParserOptions>({\n  mapper: typeKeywordMapper,\n  handlers: {\n    union(tree, options) {\n      const { current, schema, name } = tree\n\n      return typeKeywordMapper.union(\n        current.args.map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options)).filter(Boolean) as ts.TypeNode[],\n      )\n    },\n    and(tree, options) {\n      const { current, schema, name } = tree\n\n      return typeKeywordMapper.and(\n        current.args.map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options)).filter(Boolean) as ts.TypeNode[],\n      )\n    },\n    array(tree, options) {\n      const { current, schema, name } = tree\n\n      return typeKeywordMapper.array(\n        current.args.items.map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options)).filter(Boolean) as ts.TypeNode[],\n        options.arrayType,\n      )\n    },\n    enum(tree, options) {\n      const { current } = tree\n\n      // If enumType is 'inlineLiteral', generate the literal union inline instead of a type reference\n      if (options.enumType === 'inlineLiteral') {\n        const enumValues = current.args.items\n          .map((item) => item.value)\n          .filter((value): value is string | number | boolean => value !== undefined && value !== null)\n          .map((value) => {\n            const format = typeof value === 'number' ? 'number' : typeof value === 'boolean' ? 'boolean' : 'string'\n            return typeKeywordMapper.const(value, format)\n          })\n          .filter(Boolean) as ts.TypeNode[]\n\n        return typeKeywordMapper.union(enumValues)\n      }\n\n      // Adding suffix to enum (see https://github.com/kubb-labs/kubb/issues/1873)\n      return typeKeywordMapper.enum(['asConst', 'asPascalConst'].includes(options.enumType) ? `${current.args.typeName}Key` : current.args.typeName)\n    },\n    ref(tree, _options) {\n      const { current } = tree\n\n      return typeKeywordMapper.ref(current.args.name)\n    },\n    blob() {\n      return typeKeywordMapper.blob()\n    },\n    tuple(tree, options) {\n      const { current, schema, name } = tree\n\n      return typeKeywordMapper.tuple(\n        current.args.items.map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options)).filter(Boolean) as ts.TypeNode[],\n        current.args.rest &&\n          ((this.parse({ schema, parent: current, name, current: current.args.rest, siblings: [] }, options) ?? undefined) as ts.TypeNode | undefined),\n        current.args.min,\n        current.args.max,\n      )\n    },\n    const(tree, _options) {\n      const { current } = tree\n\n      return typeKeywordMapper.const(current.args.name, current.args.format)\n    },\n    object(tree, options) {\n      const { current, schema, name } = tree\n\n      const properties = Object.entries(current.args?.properties || {})\n        .filter((item) => {\n          const schemas = item[1]\n          return schemas && typeof schemas.map === 'function'\n        })\n        .map(([name, schemas]) => {\n          const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name) as SchemaKeywordMapper['name']\n          const mappedName = nameSchema?.args || name\n\n          const isNullish = schemas.some((schema) => schema.keyword === schemaKeywords.nullish)\n          const isNullable = schemas.some((schema) => schema.keyword === schemaKeywords.nullable)\n          const isOptional = schemas.some((schema) => schema.keyword === schemaKeywords.optional)\n          const isReadonly = schemas.some((schema) => schema.keyword === schemaKeywords.readOnly)\n          const describeSchema = schemas.find((schema) => schema.keyword === schemaKeywords.describe) as SchemaKeywordMapper['describe'] | undefined\n          const deprecatedSchema = schemas.find((schema) => schema.keyword === schemaKeywords.deprecated) as SchemaKeywordMapper['deprecated'] | undefined\n          const defaultSchema = schemas.find((schema) => schema.keyword === schemaKeywords.default) as SchemaKeywordMapper['default'] | undefined\n          const exampleSchema = schemas.find((schema) => schema.keyword === schemaKeywords.example) as SchemaKeywordMapper['example'] | undefined\n          const schemaSchema = schemas.find((schema) => schema.keyword === schemaKeywords.schema) as SchemaKeywordMapper['schema'] | undefined\n          const minSchema = schemas.find((schema) => schema.keyword === schemaKeywords.min) as SchemaKeywordMapper['min'] | undefined\n          const maxSchema = schemas.find((schema) => schema.keyword === schemaKeywords.max) as SchemaKeywordMapper['max'] | undefined\n          const matchesSchema = schemas.find((schema) => schema.keyword === schemaKeywords.matches) as SchemaKeywordMapper['matches'] | undefined\n\n          let type = schemas\n            .map((it) =>\n              this.parse(\n                {\n                  schema,\n                  parent: current,\n                  name,\n                  current: it,\n                  siblings: schemas,\n                },\n                options,\n              ),\n            )\n            .filter(Boolean)[0] as ts.TypeNode\n\n          if (isNullable) {\n            type = factory.createUnionDeclaration({\n              nodes: [type, factory.keywordTypeNodes.null],\n            }) as ts.TypeNode\n          }\n\n          if (isNullish && ['undefined', 'questionTokenAndUndefined'].includes(options.optionalType as string)) {\n            type = factory.createUnionDeclaration({\n              nodes: [type, factory.keywordTypeNodes.undefined],\n            }) as ts.TypeNode\n          }\n\n          if (isOptional && ['undefined', 'questionTokenAndUndefined'].includes(options.optionalType as string)) {\n            type = factory.createUnionDeclaration({\n              nodes: [type, factory.keywordTypeNodes.undefined],\n            }) as ts.TypeNode\n          }\n\n          const propertyNode = factory.createPropertySignature({\n            questionToken: isOptional || isNullish ? ['questionToken', 'questionTokenAndUndefined'].includes(options.optionalType as string) : false,\n            name: mappedName,\n            type,\n            readOnly: isReadonly,\n          })\n\n          return factory.appendJSDocToNode({\n            node: propertyNode,\n            comments: [\n              describeSchema ? `@description ${jsStringEscape(describeSchema.args)}` : undefined,\n              deprecatedSchema ? '@deprecated' : undefined,\n              minSchema ? `@minLength ${minSchema.args}` : undefined,\n              maxSchema ? `@maxLength ${maxSchema.args}` : undefined,\n              matchesSchema ? `@pattern ${matchesSchema.args}` : undefined,\n              defaultSchema ? `@default ${defaultSchema.args}` : undefined,\n              exampleSchema ? `@example ${exampleSchema.args}` : undefined,\n              schemaSchema?.args?.type || schemaSchema?.args?.format\n                ? [`@type ${schemaSchema?.args?.type || 'unknown'}${!isOptional ? '' : ' | undefined'}`, schemaSchema?.args?.format].filter(Boolean).join(', ')\n                : undefined,\n            ].filter(Boolean),\n          })\n        })\n\n      let additionalProperties: any\n\n      if (current.args?.additionalProperties?.length) {\n        let additionalPropertiesType = current.args.additionalProperties\n          .map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options))\n          .filter(Boolean)\n          .at(0) as ts.TypeNode\n\n        const isNullable = current.args?.additionalProperties.some((schema) => isKeyword(schema, schemaKeywords.nullable))\n        if (isNullable) {\n          additionalPropertiesType = factory.createUnionDeclaration({\n            nodes: [additionalPropertiesType, factory.keywordTypeNodes.null],\n          }) as ts.TypeNode\n        }\n\n        // When there are typed properties alongside additionalProperties, use 'unknown' type\n        // for the index signature to avoid TS2411 errors (index signature type conflicts with property types).\n        // This occurs commonly in QueryParams where some params are typed (enums, objects) and\n        // others are dynamic (additionalProperties with explode=true).\n        const hasTypedProperties = properties.length > 0\n        const indexSignatureType = hasTypedProperties ? factory.keywordTypeNodes.unknown : additionalPropertiesType\n\n        additionalProperties = factory.createIndexSignature(indexSignatureType)\n      }\n\n      let patternProperties: ts.TypeNode | ts.IndexSignatureDeclaration | undefined\n\n      if (current.args?.patternProperties) {\n        const allPatternSchemas = Object.values(current.args.patternProperties).flat()\n\n        if (allPatternSchemas.length > 0) {\n          patternProperties = allPatternSchemas\n            .map((it) => this.parse({ schema, parent: current, name, current: it, siblings: [] }, options))\n            .filter(Boolean)\n            .at(0) as ts.TypeNode\n\n          const isNullable = allPatternSchemas.some((schema) => isKeyword(schema, schemaKeywords.nullable))\n          if (isNullable) {\n            patternProperties = factory.createUnionDeclaration({\n              nodes: [patternProperties, factory.keywordTypeNodes.null],\n            }) as ts.TypeNode\n          }\n\n          patternProperties = factory.createIndexSignature(patternProperties)\n        }\n      }\n\n      return typeKeywordMapper.object([...properties, additionalProperties, patternProperties].filter(Boolean))\n    },\n    datetime() {\n      return typeKeywordMapper.datetime()\n    },\n    date(tree) {\n      const { current } = tree\n\n      return typeKeywordMapper.date(current.args.type)\n    },\n    time(tree) {\n      const { current } = tree\n\n      return typeKeywordMapper.time(current.args.type)\n    },\n  },\n})\n","import { camelCase, jsStringEscape, pascalCase, trimQuotes } from '@internals/utils'\nimport { safePrint } from '@kubb/fabric-core/parsers/typescript'\nimport type { SchemaObject } from '@kubb/oas'\nimport { isKeyword, type Schema, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'\nimport { File } from '@kubb/react-fabric'\nimport type { FabricReactNode } from '@kubb/react-fabric/types'\nimport type ts from 'typescript'\nimport * as factory from '../factory.ts'\nimport { parse, typeKeywordMapper } from '../parser.ts'\nimport type { PluginTs } from '../types.ts'\n\ntype Props = {\n  name: string\n  typedName: string\n  schema: SchemaObject\n  tree: Array<Schema>\n  optionalType: PluginTs['resolvedOptions']['optionalType']\n  arrayType: PluginTs['resolvedOptions']['arrayType']\n  enumType: PluginTs['resolvedOptions']['enumType']\n  enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing']\n  syntaxType: PluginTs['resolvedOptions']['syntaxType']\n  description?: string\n  keysToOmit?: string[]\n}\n\nexport function Type({\n  name,\n  typedName,\n  tree,\n  keysToOmit,\n  schema,\n  optionalType,\n  arrayType,\n  syntaxType,\n  enumType,\n  enumKeyCasing,\n  description,\n}: Props): FabricReactNode {\n  const typeNodes: ts.Node[] = []\n\n  if (!tree.length) {\n    return ''\n  }\n\n  const schemaFromTree = tree.find((item) => item.keyword === schemaKeywords.schema)\n  const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords.enum)\n\n  let type =\n    (tree\n      .map((current, _index, siblings) =>\n        parse(\n          { name, schema, parent: undefined, current, siblings },\n          {\n            optionalType,\n            arrayType,\n            enumType,\n          },\n        ),\n      )\n      .filter(Boolean)\n      .at(0) as ts.TypeNode) || typeKeywordMapper.undefined()\n\n  // Add a \"Key\" suffix to avoid collisions where necessary\n  if (['asConst', 'asPascalConst'].includes(enumType) && enumSchemas.length > 0) {\n    const isDirectEnum = schema.type === 'array' && schema.items !== undefined\n    const isEnumOnly = 'enum' in schema && schema.enum\n\n    if (isDirectEnum || isEnumOnly) {\n      const enumSchema = enumSchemas[0]!\n      const typeNameWithKey = `${enumSchema.args.typeName}Key`\n\n      type = factory.createTypeReferenceNode(typeNameWithKey)\n\n      if (schema.type === 'array') {\n        if (arrayType === 'generic') {\n          type = factory.createTypeReferenceNode(factory.createIdentifier('Array'), [type])\n        } else {\n          type = factory.createArrayTypeNode(type)\n        }\n      }\n    }\n  }\n\n  if (schemaFromTree && isKeyword(schemaFromTree, schemaKeywords.schema)) {\n    const isNullish = tree.some((item) => item.keyword === schemaKeywords.nullish)\n    const isNullable = tree.some((item) => item.keyword === schemaKeywords.nullable)\n    const isOptional = tree.some((item) => item.keyword === schemaKeywords.optional)\n\n    if (isNullable) {\n      type = factory.createUnionDeclaration({\n        nodes: [type, factory.keywordTypeNodes.null],\n      }) as ts.TypeNode\n    }\n\n    if (isNullish && ['undefined', 'questionTokenAndUndefined'].includes(optionalType as string)) {\n      type = factory.createUnionDeclaration({\n        nodes: [type, factory.keywordTypeNodes.undefined],\n      }) as ts.TypeNode\n    }\n\n    if (isOptional && ['undefined', 'questionTokenAndUndefined'].includes(optionalType as string)) {\n      type = factory.createUnionDeclaration({\n        nodes: [type, factory.keywordTypeNodes.undefined],\n      }) as ts.TypeNode\n    }\n  }\n\n  const useTypeGeneration = syntaxType === 'type' || [factory.syntaxKind.union].includes(type.kind as typeof factory.syntaxKind.union) || !!keysToOmit?.length\n\n  typeNodes.push(\n    factory.createTypeDeclaration({\n      name,\n      isExportable: true,\n      type: keysToOmit?.length\n        ? factory.createOmitDeclaration({\n            keys: keysToOmit,\n            type,\n            nonNullable: true,\n          })\n        : type,\n      syntax: useTypeGeneration ? 'type' : 'interface',\n      comments: [\n        schema.title ? `${jsStringEscape(schema.title)}` : undefined,\n        description ? `@description ${jsStringEscape(description)}` : undefined,\n        schema.deprecated ? '@deprecated' : undefined,\n        schema.minLength ? `@minLength ${schema.minLength}` : undefined,\n        schema.maxLength ? `@maxLength ${schema.maxLength}` : undefined,\n        schema.pattern ? `@pattern ${schema.pattern}` : undefined,\n        schema.default ? `@default ${schema.default}` : undefined,\n        schema.example ? `@example ${schema.example}` : undefined,\n      ],\n    }),\n  )\n\n  const enums = [...new Set(enumSchemas)].map((enumSchema) => {\n    const name = enumType === 'asPascalConst' ? pascalCase(enumSchema.args.name) : camelCase(enumSchema.args.name)\n    const typeName = ['asConst', 'asPascalConst'].includes(enumType) ? `${enumSchema.args.typeName}Key` : enumSchema.args.typeName\n\n    const [nameNode, typeNode] = factory.createEnumDeclaration({\n      name,\n      typeName,\n      enums: enumSchema.args.items\n        .map((item) => (item.value === undefined ? undefined : [trimQuotes(item.name?.toString()), item.value]))\n        .filter(Boolean) as unknown as Array<[string, string]>,\n      type: enumType,\n      enumKeyCasing,\n    })\n\n    return {\n      nameNode,\n      typeNode,\n      name,\n      typeName,\n    }\n  })\n\n  // Skip enum exports when using inlineLiteral\n  const shouldExportEnums = enumType !== 'inlineLiteral'\n  const shouldExportType = enumType === 'inlineLiteral' || enums.every((item) => item.typeName !== name)\n\n  return (\n    <>\n      {shouldExportEnums &&\n        enums.map(({ name, nameNode, typeName, typeNode }) => (\n          <>\n            {nameNode && (\n              <File.Source name={name} isExportable isIndexable isTypeOnly={false}>\n                {safePrint(nameNode)}\n              </File.Source>\n            )}\n            {\n              <File.Source\n                name={typeName}\n                isIndexable\n                isExportable={['enum', 'asConst', 'asPascalConst', 'constEnum', 'literal', undefined].includes(enumType)}\n                isTypeOnly={['asConst', 'asPascalConst', 'literal', undefined].includes(enumType)}\n              >\n                {safePrint(typeNode)}\n              </File.Source>\n            }\n          </>\n        ))}\n      {shouldExportType && (\n        <File.Source name={typedName} isTypeOnly isExportable isIndexable>\n          {safePrint(...typeNodes)}\n        </File.Source>\n      )}\n    </>\n  )\n}\n"],"mappings":"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"}

package/dist/components.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_components = require("./components-9wydyqUx.cjs");
+const require_components = require("./components-DeNDKlzf.cjs");
 exports.Type = require_components.Type;

package/dist/components.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as PluginTs } from "./types-BpeKGgCn.js";
+import { n as PluginTs } from "./types-mSXmB8WU.js";
 import { Schema } from "@kubb/plugin-oas";
 import { SchemaObject } from "@kubb/oas";
 import { FabricReactNode } from "@kubb/react-fabric/types";
@@ -14,7 +14,6 @@ type Props = {
   arrayType: PluginTs['resolvedOptions']['arrayType'];
   enumType: PluginTs['resolvedOptions']['enumType'];
   enumKeyCasing: PluginTs['resolvedOptions']['enumKeyCasing'];
-  mapper: PluginTs['resolvedOptions']['mapper'];
   syntaxType: PluginTs['resolvedOptions']['syntaxType'];
   description?: string;
   keysToOmit?: string[];
@@ -30,7 +29,6 @@ declare function Type({
   syntaxType,
   enumType,
   enumKeyCasing,
-  mapper,
   description
 }: Props): FabricReactNode;
 //#endregion

package/dist/components.js

@@ -1,2 +1,2 @@
-import { t as Type } from "./components-LmqJfxMv.js";
+import { t as Type } from "./components-CRu8IKY3.js";
 export { Type };

package/dist/generators.cjs

@@ -1,3 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_plugin = require("./plugin-BHE4J4aP.cjs");
-exports.typeGenerator = require_plugin.typeGenerator;
+const require_plugin = require("./plugin-CJ29AwE2.cjs");
+exports.typeGenerator = require_plugin.typeGenerator$1;
+exports.typeGeneratorV2 = require_plugin.typeGenerator;

package/dist/generators.d.ts

@@ -1,12 +1,40 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as PluginTs } from "./types-BpeKGgCn.js";
-import { AsyncEventEmitter, Config, FileMetaBase, Group, KubbEvents, Output, Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from "@kubb/core";
-import { Fabric } from "@kubb/react-fabric";
+import { n as PluginTs } from "./types-mSXmB8WU.js";
+import * as _kubb_core0 from "@kubb/core";
+import { Config, FileMetaBase, Generator, Group, KubbEvents, Output, Plugin, PluginDriver, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
 import { HttpMethod, Oas, Operation, SchemaObject, contentType } from "@kubb/oas";
 import { FabricReactNode } from "@kubb/react-fabric/types";
-import { OperationNode, SchemaNode } from "@kubb/ast/types";
-import { KubbFile } from "@kubb/fabric-core/types";
+import { Fabric, KubbFile } from "@kubb/fabric-core/types";
 
+//#region ../../internals/utils/src/asyncEventEmitter.d.ts
+/** A function that can be registered as an event listener, synchronous or async. */
+type AsyncListener<TArgs extends unknown[]> = (...args: TArgs) => void | Promise<void>;
+/**
+ * A typed EventEmitter that awaits all async listeners before resolving.
+ * Wraps Node's `EventEmitter` with full TypeScript event-map inference.
+ */
+declare class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: unknown[] }> {
+  #private;
+  /**
+   * `maxListener` controls the maximum number of listeners per event before Node emits a memory-leak warning.
+   * @default 10
+   */
+  constructor(maxListener?: number);
+  /**
+   * Emits an event and awaits all registered listeners in parallel.
+   * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+   */
+  emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArgs: TEvents[TEventName]): Promise<void>;
+  /** Registers a persistent listener for the given event. */
+  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
+  /** Registers a one-shot listener that removes itself after the first invocation. */
+  onOnce<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
+  /** Removes a previously registered listener. */
+  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
+  /** Removes all listeners from every event channel. */
+  removeAll(): void;
+}
+//#endregion
 //#region ../plugin-oas/src/types.d.ts
 type GetOasOptions = {
   validate?: boolean;
@@ -26,14 +54,14 @@ declare global {
  *
  * `originalName` is the original name used(in PascalCase), only used to remove duplicates
  *
- * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
+ * `pluginName` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
  * @example import a type(plugin-ts) for a mock file(swagger-faker)
  */
 type Ref = {
   propertyName: string;
   originalName: string;
   path: KubbFile.Path;
-  pluginKey?: Plugin['key'];
+  pluginName?: string;
 };
 type Refs = Record<string, Ref>;
 type OperationSchema = {
@@ -93,8 +121,8 @@ type ByContentType = {
   type: 'contentType';
   pattern: string | RegExp;
 };
-type Exclude = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
-type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Exclude = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
 type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
   options: Partial<TOptions>;
 };
@@ -107,7 +135,7 @@ type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
   include: Array<Include> | undefined;
   override: Array<Override<TOptions>> | undefined;
   contentType: contentType | undefined;
-  pluginManager: PluginManager;
+  driver: PluginDriver;
   events?: AsyncEventEmitter<KubbEvents>;
   /**
    * Current plugin
@@ -133,7 +161,7 @@ declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = P
     method: HttpMethod;
     operation: Operation;
   }>>;
-  build(...generators: Array<Generator<TPluginOptions, Version>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+  build(...generators: Array<Generator$1<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
 }
 //#endregion
 //#region ../plugin-oas/src/SchemaMapper.d.ts
@@ -361,7 +389,7 @@ type Schema = {
 type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
   fabric: Fabric;
   oas: Oas;
-  pluginManager: PluginManager;
+  driver: PluginDriver;
   events?: AsyncEventEmitter<KubbEvents>;
   /**
    * Current plugin
@@ -423,46 +451,33 @@ declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGe
   static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]>;
   static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
   static combineObjects(tree: Schema[] | undefined): Schema[];
-  build(...generators: Array<Generator<TPluginOptions, Version>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+  build(...generators: Array<Generator$1<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
 }
 //#endregion
 //#region ../plugin-oas/src/generators/createGenerator.d.ts
-type CoreGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
+type CoreGenerator<TOptions extends PluginFactoryOptions> = {
   name: string;
   type: 'core';
-  version: TVersion;
-  operations: (props: OperationsProps<TOptions, TVersion>) => Promise<KubbFile.File[]>;
-  operation: (props: OperationProps<TOptions, TVersion>) => Promise<KubbFile.File[]>;
-  schema: (props: SchemaProps<TOptions, TVersion>) => Promise<KubbFile.File[]>;
+  version: '1';
+  operations: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>;
+  operation: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>;
+  schema: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>;
 };
 //#endregion
 //#region ../plugin-oas/src/generators/types.d.ts
-type Version = '1' | '2';
-type OperationsV1Props<TOptions extends PluginFactoryOptions> = {
+type OperationsProps<TOptions extends PluginFactoryOptions> = {
   config: Config;
   generator: Omit<OperationGenerator<TOptions>, 'build'>;
   plugin: Plugin<TOptions>;
   operations: Array<Operation>;
 };
-type OperationsV2Props<TOptions extends PluginFactoryOptions> = {
-  config: Config;
-  plugin: Plugin<TOptions>;
-  nodes: Array<OperationNode>;
-};
-type OperationV1Props<TOptions extends PluginFactoryOptions> = {
+type OperationProps<TOptions extends PluginFactoryOptions> = {
   config: Config;
   generator: Omit<OperationGenerator<TOptions>, 'build'>;
   plugin: Plugin<TOptions>;
   operation: Operation;
 };
-type OperationV2Props<TOptions extends PluginFactoryOptions> = {
-  config: Config;
-  plugin: Plugin<TOptions>;
-  node: OperationNode;
-};
-type OperationsProps<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'> = TVersion extends '2' ? OperationsV2Props<TOptions> : OperationsV1Props<TOptions>;
-type OperationProps<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'> = TVersion extends '2' ? OperationV2Props<TOptions> : OperationV1Props<TOptions>;
-type SchemaV1Props<TOptions extends PluginFactoryOptions> = {
+type SchemaProps<TOptions extends PluginFactoryOptions> = {
   config: Config;
   generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
   plugin: Plugin<TOptions>;
@@ -472,26 +487,23 @@ type SchemaV1Props<TOptions extends PluginFactoryOptions> = {
     value: SchemaObject;
   };
 };
-type SchemaV2Props<TOptions extends PluginFactoryOptions> = {
-  config: Config;
-  plugin: Plugin<TOptions>;
-  node: SchemaNode;
-};
-type SchemaProps<TOptions extends PluginFactoryOptions, TVersion extends Version = '1'> = TVersion extends '2' ? SchemaV2Props<TOptions> : SchemaV1Props<TOptions>;
-type Generator<TOptions extends PluginFactoryOptions, TVersion extends Version = Version> = CoreGenerator<TOptions, TVersion> | ReactGenerator<TOptions, TVersion>;
+type Generator$1<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions> | Generator<TOptions>;
 //#endregion
 //#region ../plugin-oas/src/generators/createReactGenerator.d.ts
-type ReactGenerator<TOptions extends PluginFactoryOptions, TVersion extends Version> = {
+type ReactGenerator<TOptions extends PluginFactoryOptions> = {
   name: string;
   type: 'react';
-  version: TVersion;
-  Operations: (props: OperationsProps<TOptions, TVersion>) => FabricReactNode;
-  Operation: (props: OperationProps<TOptions, TVersion>) => FabricReactNode;
-  Schema: (props: SchemaProps<TOptions, TVersion>) => FabricReactNode;
+  version: '1';
+  Operations: (props: OperationsProps<TOptions>) => FabricReactNode;
+  Operation: (props: OperationProps<TOptions>) => FabricReactNode;
+  Schema: (props: SchemaProps<TOptions>) => FabricReactNode;
 };
 //#endregion
 //#region src/generators/typeGenerator.d.ts
-declare const typeGenerator: ReactGenerator<PluginTs, "1">;
+declare const typeGenerator: ReactGenerator<PluginTs>;
+//#endregion
+//#region src/generators/v2/typeGenerator.d.ts
+declare const typeGenerator$1: _kubb_core0.ReactGeneratorV2<PluginTs>;
 //#endregion
-export { typeGenerator };
+export { typeGenerator, typeGenerator$1 as typeGeneratorV2 };
 //# sourceMappingURL=generators.d.ts.map

package/dist/generators.js

@@ -1,2 +1,2 @@
-import { r as typeGenerator } from "./plugin-DnKRpgGK.js";
-export { typeGenerator };
+import { a as typeGenerator, r as typeGenerator$1 } from "./plugin-D60XNJSD.js";
+export { typeGenerator, typeGenerator$1 as typeGeneratorV2 };

package/dist/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_plugin = require("./plugin-BHE4J4aP.cjs");
+const require_plugin = require("./plugin-CJ29AwE2.cjs");
 exports.pluginTs = require_plugin.pluginTs;
 exports.pluginTsName = require_plugin.pluginTsName;
+exports.resolverTs = require_plugin.resolverTs;

package/dist/index.d.ts

@@ -1,10 +1,49 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as PluginTs, t as Options } from "./types-BpeKGgCn.js";
+import { n as PluginTs, t as Options } from "./types-mSXmB8WU.js";
 import * as _kubb_core0 from "@kubb/core";
+import * as _kubb_ast_types0 from "@kubb/ast/types";
 
 //#region src/plugin.d.ts
 declare const pluginTsName = "plugin-ts";
 declare const pluginTs: (options?: Options | undefined) => _kubb_core0.UserPluginWithLifeCycle<PluginTs>;
 //#endregion
-export { type PluginTs, pluginTs, pluginTsName };
+//#region src/resolverTs.d.ts
+/**
+ * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
+ * helpers used by the plugin. Import this in other plugins to resolve the exact names and
+ * paths that `plugin-ts` generates without hardcoding the conventions.
+ *
+ * The `default` method is automatically injected by `defineResolver` — it uses `camelCase`
+ * for identifiers/files and `pascalCase` for type names.
+ *
+ * @example
+ * ```ts
+ * import { resolver } from '@kubb/plugin-ts'
+ *
+ * resolver.default('list pets', 'type')              // → 'ListPets'
+ * resolver.resolveName('list pets status 200')        // → 'listPetsStatus200'
+ * resolver.resolveTypedName('list pets status 200')   // → 'ListPetsStatus200'
+ * resolver.resolvePathName('list pets', 'file')       // → 'listPets'
+ * ```
+ */
+declare const resolverTs: _kubb_core0.Resolver & {
+  resolveName(name: string): string;
+  resolveTypedName(name: string): string;
+  resolvePathName(name: string, type?: "file" | "function" | "type" | "const"): string;
+  resolveParamName(node: _kubb_ast_types0.OperationNode, param: _kubb_ast_types0.ParameterNode): string;
+  resolveParamTypedName(node: _kubb_ast_types0.OperationNode, param: _kubb_ast_types0.ParameterNode): string;
+  resolveResponseStatusName(node: _kubb_ast_types0.OperationNode, statusCode: _kubb_ast_types0.StatusCode): string;
+  resolveResponseStatusTypedName(node: _kubb_ast_types0.OperationNode, statusCode: _kubb_ast_types0.StatusCode): string;
+  resolveDataName(node: _kubb_ast_types0.OperationNode): string;
+  resolveDataTypedName(node: _kubb_ast_types0.OperationNode): string;
+  resolveRequestConfigName(node: _kubb_ast_types0.OperationNode): string;
+  resolveRequestConfigTypedName(node: _kubb_ast_types0.OperationNode): string;
+  resolveResponsesName(node: _kubb_ast_types0.OperationNode): string;
+  resolveResponsesTypedName(node: _kubb_ast_types0.OperationNode): string;
+  resolveResponseName(node: _kubb_ast_types0.OperationNode): string;
+  resolveResponseTypedName(node: _kubb_ast_types0.OperationNode): string;
+  resolveEnumKeyTypedName(node: _kubb_ast_types0.SchemaNode): string;
+};
+//#endregion
+export { type PluginTs, pluginTs, pluginTsName, resolverTs };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,2 +1,2 @@
-import { n as pluginTsName, t as pluginTs } from "./plugin-DnKRpgGK.js";
-export { pluginTs, pluginTsName };
+import { i as resolverTs, n as pluginTsName, t as pluginTs } from "./plugin-D60XNJSD.js";
+export { pluginTs, pluginTsName, resolverTs };