@kubb/core 3.0.0-alpha.3 → 3.0.0-alpha.30

package/src/plugin.ts

@@ -1,7 +1,5 @@
 import path from 'node:path'
 
-import { createPluginCache } from './utils/cache.ts'
-
 import type { FileManager } from './FileManager.ts'
 import type { PluginManager } from './PluginManager.ts'
 import type { Plugin, PluginContext, PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
@@ -46,7 +44,7 @@ export const pluginCore = createPlugin<PluginCore>((options) => {
           return options.getPlugins()
         },
         get plugin() {
-          // see pluginManger.#execute where we override with `.call` the this with the correct plugin
+          // see pluginManger.#execute where we override with `.call` the context with the correct plugin
           return options.plugin as NonNullable<Options['plugin']>
         },
         logger,
@@ -63,11 +61,10 @@ export const pluginCore = createPlugin<PluginCore>((options) => {
         },
         resolvePath,
         resolveName,
-        cache: createPluginCache(),
       }
     },
     resolvePath(baseName) {
-      const root = path.resolve(this.config.root, this.config.output.path)
+      const root = path.resolve(options.config.root, options.config.output.path)
 
       return path.resolve(root, baseName)
     },

package/src/transformers/escape.ts

@@ -29,13 +29,3 @@ export function jsStringEscape(input: any): string {
     }
   })
 }
-
-export function escapeStringRegexp(string: string) {
-  if (typeof string !== 'string') {
-    throw new TypeError('Expected a string')
-  }
-
-  // Escape characters with special meaning either inside or outside character sets.
-  // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
-  return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d')
-}

package/src/transformers/index.ts

@@ -11,7 +11,7 @@ import { searchAndReplace } from './searchAndReplace.ts'
 import { stringify, stringifyObject } from './stringify.ts'
 import { toRegExp, toRegExpString } from './toRegExp.ts'
 import { transformReservedWord } from './transformReservedWord.ts'
-import { trim, trimExtName, trimQuotes } from './trim.ts'
+import { trim, trimQuotes } from './trim.ts'
 
 export { camelCase, pascalCase, pathCase } from './casing.ts'
 export { combineCodes } from './combineCodes.ts'
@@ -23,7 +23,7 @@ export { searchAndReplace } from './searchAndReplace.ts'
 export { stringify, stringifyObject } from './stringify.ts'
 export { toRegExp, toRegExpString } from './toRegExp.ts'
 export { transformReservedWord } from './transformReservedWord.ts'
-export { trim, trimExtName, trimQuotes } from './trim.ts'
+export { trim, trimQuotes } from './trim.ts'
 export { merge } from 'remeda'
 export { orderBy } from 'natural-orderby'
 
@@ -41,7 +41,6 @@ export default {
   toRegExpString,
   trim,
   trimQuotes,
-  trimExtName,
   JSDoc: {
     createJSDocBlockText,
   },

package/src/transformers/stringify.ts

@@ -1,6 +1,6 @@
 import { trimQuotes } from './trim'
 
-export function stringify(value: string | number | undefined): string {
+export function stringify(value: string | number | boolean | undefined): string {
   if (value === undefined || value === null) {
     return '""'
   }

package/src/transformers/trim.ts

@@ -16,7 +16,3 @@ export function trimQuotes(text: string): string {
 
   return text
 }
-
-export function trimExtName(text: string): string {
-  return text.replace(/\.[^/.]+$/, '')
-}

package/src/types.ts

@@ -3,7 +3,6 @@ import type { PossiblePromise } from '@kubb/types'
 import type { FileManager } from './FileManager.ts'
 import type { PluginManager } from './PluginManager.ts'
 import type { Logger } from './logger.ts'
-import type { Cache } from './utils/cache.ts'
 
 // config
 
@@ -30,20 +29,25 @@ export type UserConfig = Omit<Config, 'root' | 'plugins'> & {
 
 export type InputPath = {
   /**
-   * Path to be used as the input. This can be an absolute path or a path relative to the `root`.
+   * Define your Swagger/OpenAPI file. This can be an absolute path or a path relative to the `root`.
    */
   path: string
 }
 
 export type InputData = {
   /**
-   * `string` or `object` containing the data.
+   * `string` or `object` containing your Swagger/OpenAPI data.
    */
   data: string | unknown
 }
 
 type Input = InputPath | InputData
 
+type OutContext = {}
+type OutExtension = (context: OutContext) => Record<KubbFile.Extname, KubbFile.Extname>
+
+export type BarrelType = 'all' | 'named'
+
 /**
  * @private
  */
@@ -53,33 +57,44 @@ export type Config<TInput = Input> = {
    */
   name?: string
   /**
-   * Project root directory. Can be an absolute path, or a path relative from
-   * the location of the config file itself.
+   * Project root directory. This can be an absolute path or a path relative to the location of your `kubb.config.ts` file.
    * @default process.cwd()
    */
   root: string
+  /**
+   * You can use `input.path` or `input.data` depending on the needs you have.
+   */
   input: TInput
   output: {
     /**
-     * Path to be used to export all generated files.
-     * This can be an absolute path, or a path relative based of the defined `root` option.
+     * The path where all generated files will be exported. This can be an absolute path or a path relative to the specified root option.
      */
     path: string
     /**
-     * Clean output directory before each build.
+     * Clean the output directory before each build.
      */
     clean?: boolean
     /**
-     * Write files to the fileSystem
-     * This is being used for the playground.
+     * Save files to the file system.
      * @default true
      */
     write?: boolean
+
+    /**
+     * Override the extension to the generated imports and exports, default the plugin will add an extension
+     * @default `() => ({ '.ts': '.ts'})`
+     */
+    extension?: OutExtension
+    /**
+     * Define what needs to exported, here you can also disable the export of barrel files.
+     * @default `'named'`
+     */
+    barrelType?: BarrelType | false
   }
   /**
-   * Array of Kubb plugins to use.
-   * The plugin/package can forsee some options that you need to pass through.
-   * Sometimes a plugin is depended on another plugin, if that's the case you will get an error back from the plugin you installed.
+   * An array of Kubb plugins that will be used in the generation.
+   * Each plugin may include additional configurable options(defined in the plugin itself).
+   * If a plugin depends on another plugin, an error will be returned if the required dependency is missing. See pre for more details.
    */
   plugins?: Array<Plugin>
   /**
@@ -146,7 +161,7 @@ export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
   options: TOptions['resolvedOptions']
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
-   * Can be used to validate depended plugins.
+   * Can be used to validate dependent plugins.
    */
   pre?: Array<string>
   /**
@@ -178,7 +193,7 @@ export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   key: TOptions['key']
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
-   * Can be used to validate depended plugins.
+   * Can be used to validate dependent plugins.
    */
   pre?: Array<string>
   /**
@@ -233,8 +248,6 @@ export type PluginLifecycleHooks = keyof PluginLifecycle
 
 export type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>
 
-export type PluginCache = Record<string, [number, unknown]>
-
 export type ResolvePathParams<TOptions = object> = {
   pluginKey?: Plugin['key']
   baseName: string
@@ -253,15 +266,14 @@ export type ResolveNameParams = {
    * `function` can be used used to customize the exported functions(use of camelCase)
    * `type` is a special type for TypeScript(use of PascalCase)
    */
-  type?: 'file' | 'function' | 'type'
+  type?: 'file' | 'function' | 'type' | 'const'
 }
 
 export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config
-  cache: Cache<PluginCache>
   fileManager: FileManager
   pluginManager: PluginManager
-  addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.File>>
+  addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>
   resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => KubbFile.OptionalPath
   resolveName: (params: ResolveNameParams) => string
   logger: Logger
@@ -274,3 +286,23 @@ export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryO
    */
   plugin: Plugin<TOptions>
 }
+
+export type Output = {
+  /**
+   * Output to save the generated files.
+   */
+  path: string
+  /**
+   * Define what needs to exported, here you can also disable the export of barrel files.
+   * @default `'named'`
+   */
+  barrelType?: BarrelType | false
+  /**
+   * Add a banner text in the beginning of every file
+   */
+  banner?: string
+  /**
+   * Add a footer text in the beginning of every file
+   */
+  footer?: string
+}

package/src/utils/TreeNode.ts

@@ -1,28 +1,29 @@
-import dirTree from 'directory-tree'
-
-import { FileManager } from '../FileManager.ts'
-
 import type * as KubbFile from '@kubb/fs/types'
-import type { DirectoryTree, DirectoryTreeOptions } from 'directory-tree'
-
-export type TreeNodeOptions = DirectoryTreeOptions
-
-type BarrelData = { type: KubbFile.Mode; path: KubbFile.Path; name: string }
-
-export class TreeNode<T = BarrelData> {
-  public data: T
+import { FileManager } from '../FileManager.ts'
 
-  public parent?: TreeNode<T>
+type BarrelData = {
+  file?: KubbFile.File
+  /**
+   * @deprecated use file instead
+   */
+  type: KubbFile.Mode
+  path: string
+  name: string
+}
 
-  public children: Array<TreeNode<T>> = []
+export class TreeNode {
+  data: BarrelData
+  parent?: TreeNode
+  children: Array<TreeNode> = []
+  #cachedLeaves?: Array<TreeNode> = undefined
 
-  constructor(data: T, parent?: TreeNode<T>) {
+  constructor(data: BarrelData, parent?: TreeNode) {
     this.data = data
     this.parent = parent
     return this
   }
 
-  addChild(data: T): TreeNode<T> {
+  addChild(data: BarrelData): TreeNode {
     const child = new TreeNode(data, this)
     if (!this.children) {
       this.children = []
@@ -31,51 +32,37 @@ export class TreeNode<T = BarrelData> {
     return child
   }
 
-  find(data?: T): TreeNode<T> | null {
-    if (!data) {
-      return null
-    }
-
-    if (data === this.data) {
+  get root(): TreeNode {
+    if (!this.parent) {
       return this
     }
-
-    if (this.children?.length) {
-      for (let i = 0, { length } = this.children, target: TreeNode<T> | null = null; i < length; i++) {
-        target = this.children[i]!.find(data)
-        if (target) {
-          return target
-        }
-      }
-    }
-
-    return null
+    return this.parent.root
   }
 
-  get leaves(): TreeNode<T>[] {
+  get leaves(): Array<TreeNode> {
     if (!this.children || this.children.length === 0) {
       // this is a leaf
       return [this]
     }
 
+    if (this.#cachedLeaves) {
+      return this.#cachedLeaves
+    }
+
     // if not a leaf, return all children's leaves recursively
-    const leaves: TreeNode<T>[] = []
+    const leaves: TreeNode[] = []
     if (this.children) {
       for (let i = 0, { length } = this.children; i < length; i++) {
         leaves.push.apply(leaves, this.children[i]!.leaves)
       }
     }
-    return leaves
-  }
 
-  get root(): TreeNode<T> {
-    if (!this.parent) {
-      return this
-    }
-    return this.parent.root
+    this.#cachedLeaves = leaves
+
+    return leaves
   }
 
-  forEach(callback: (treeNode: TreeNode<T>) => void): this {
+  forEach(callback: (treeNode: TreeNode) => void): this {
     if (typeof callback !== 'function') {
       throw new TypeError('forEach() callback must be a function')
     }
@@ -93,13 +80,41 @@ export class TreeNode<T = BarrelData> {
     return this
   }
 
-  public static build(path: string, options: TreeNodeOptions = {}): TreeNode | null {
+  findDeep(predicate?: (value: TreeNode, index: number, obj: TreeNode[]) => boolean): TreeNode | undefined {
+    if (typeof predicate !== 'function') {
+      throw new TypeError('find() predicate must be a function')
+    }
+
+    return this.leaves.find(predicate)
+  }
+
+  forEachDeep(callback: (treeNode: TreeNode) => void): void {
+    if (typeof callback !== 'function') {
+      throw new TypeError('forEach() callback must be a function')
+    }
+
+    this.leaves.forEach(callback)
+  }
+
+  filterDeep(callback: (treeNode: TreeNode) => boolean): Array<TreeNode> {
+    if (typeof callback !== 'function') {
+      throw new TypeError('filter() callback must be a function')
+    }
+
+    return this.leaves.filter(callback)
+  }
+
+  mapDeep<T>(callback: (treeNode: TreeNode) => T): Array<T> {
+    if (typeof callback !== 'function') {
+      throw new TypeError('map() callback must be a function')
+    }
+
+    return this.leaves.map(callback)
+  }
+
+  public static build(files: KubbFile.File[], root?: string): TreeNode | null {
     try {
-      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean)
-      const filteredTree = dirTree(path, {
-        extensions: options.extensions,
-        exclude: [/node_modules/, ...exclude],
-      })
+      const filteredTree = buildDirectoryTree(files, root)
 
       if (!filteredTree) {
         return null
@@ -108,6 +123,7 @@ export class TreeNode<T = BarrelData> {
       const treeNode = new TreeNode({
         name: filteredTree.name,
         path: filteredTree.path,
+        file: filteredTree.file,
         type: FileManager.getMode(filteredTree.path),
       })
 
@@ -115,6 +131,7 @@ export class TreeNode<T = BarrelData> {
         const subNode = node.addChild({
           name: item.name,
           path: item.path,
+          file: item.file,
           type: FileManager.getMode(item.path),
         })
 
@@ -129,7 +146,72 @@ export class TreeNode<T = BarrelData> {
 
       return treeNode
     } catch (e) {
-      throw new Error('Something went wrong with creating index files with the TreehNode class', { cause: e })
+      throw new Error('Something went wrong with creating barrel files with the TreeNode class', { cause: e })
     }
   }
 }
+
+export type DirectoryTree = {
+  name: string
+  path: string
+  file?: KubbFile.File
+  children: Array<DirectoryTree>
+}
+
+export function buildDirectoryTree(files: Array<KubbFile.File>, rootFolder = ''): DirectoryTree | null {
+  const rootPrefix = rootFolder.endsWith('/') ? rootFolder : `${rootFolder}/`
+  const filteredFiles = files.filter((file) => (rootFolder ? file.path.startsWith(rootPrefix) && !file.path.endsWith('.json') : !file.path.endsWith('.json')))
+
+  if (filteredFiles.length === 0) {
+    return null // No files match the root folder
+  }
+
+  const root: DirectoryTree = {
+    name: rootFolder || '',
+    path: rootFolder || '',
+    children: [],
+  }
+
+  filteredFiles.forEach((file) => {
+    const path = file.path.slice(rootFolder.length)
+    const parts = path.split('/')
+    let currentLevel: DirectoryTree[] = root.children
+    let currentPath = rootFolder
+
+    parts.forEach((part, index) => {
+      if (index !== 0) {
+        currentPath += `/${part}`
+      } else {
+        currentPath += `${part}`
+      }
+
+      let existingNode = currentLevel.find((node) => node.name === part)
+
+      if (!existingNode) {
+        if (index === parts.length - 1) {
+          // If it's the last part, it's a file
+          existingNode = {
+            name: part,
+            file,
+            path: currentPath,
+          } as DirectoryTree
+        } else {
+          // Otherwise, it's a folder
+          existingNode = {
+            name: part,
+            path: currentPath,
+            children: [],
+          } as DirectoryTree
+        }
+        currentLevel.push(existingNode)
+      }
+
+      // Move to the next level if it's a folder
+      if (!existingNode.file) {
+        currentLevel = existingNode.children
+      }
+    })
+  })
+
+  return root
+}

package/src/utils/executeStrategies.ts

@@ -1,10 +1,10 @@
 type PromiseFunc<T = unknown, T2 = never> = (state?: T) => T2 extends never ? Promise<T> : Promise<T> | T2
 
-export type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc<infer X, infer Y>> ? X | Y : never
+type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc<infer X, infer Y>> ? X | Y : never
 
-export function noReturn(): void {}
+function noReturn(): void {}
 
-type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Array<Awaited<ValueOfPromiseFuncArray<TInput>>>
+type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput>>>>
 
 /**
  * Chains promises

package/src/utils/index.ts

@@ -10,4 +10,5 @@ export { timeout } from './timeout.ts'
 export { getUniqueName, setUniqueName } from './uniqueName.ts'
 export type { URLObject } from './URLPath.ts'
 export { URLPath } from './URLPath.ts'
-export { getParser } from './getParser.ts'
+export { getFileParser, createFileImport, createFileExport, createFile, createFileParser } from './parser.ts'
+export type { ParserModule } from './parser.ts'

package/src/utils/parser.ts

@@ -0,0 +1,156 @@
+import path from 'node:path'
+import type * as KubbFile from '@kubb/fs/types'
+
+import { getRelativePath } from '@kubb/fs'
+import hash from 'object-hash'
+import { combineExports, combineImports, combineSources } from '../FileManager.ts'
+import type { Logger } from '../logger.ts'
+
+/**
+ * Helper to create a file with name and id set
+ */
+export function createFile<TMeta extends object = object>(file: KubbFile.File<TMeta>): KubbFile.ResolvedFile<TMeta> {
+  const extname = path.extname(file.baseName) as KubbFile.Extname
+
+  if (!extname) {
+    throw new Error(`No extname found for ${file.baseName}`)
+  }
+
+  const source = file.sources.map((item) => item.value).join('\n\n')
+  const exports = file.exports ? combineExports(file.exports) : []
+  const imports = file.imports && source ? combineImports(file.imports, exports, source) : []
+  const sources = file.sources ? combineSources(file.sources) : []
+
+  return {
+    ...file,
+    id: hash({ path: file.path }),
+    name: trimExtName(file.baseName),
+    extname,
+    imports: imports.map((item) => createFileImport(item)),
+    exports: exports.map((item) => createFileExport(item)),
+    sources: sources.map((item) => createFileSource(item)),
+    meta: file.meta || ({} as TMeta),
+  }
+}
+
+/**
+ * Helper to create a fileImport with extname set
+ */
+function createFileSource(source: KubbFile.Source): KubbFile.Source {
+  return source
+}
+
+/**
+ * Helper to create a fileImport with extname set
+ */
+export function createFileImport(imp: KubbFile.Import): KubbFile.ResolvedImport {
+  return {
+    ...imp,
+  }
+}
+
+/**
+ * Helper to create a fileExport with extname set
+ */
+export function createFileExport(exp: KubbFile.Export): KubbFile.ResolvedExport {
+  return {
+    ...exp,
+  }
+}
+
+export type ParserModule<TMeta extends object = object> = {
+  format: (source: string) => Promise<string>
+  /**
+   * Convert a file to string
+   */
+  print: (file: KubbFile.ResolvedFile<TMeta>, options: PrintOptions) => Promise<string>
+}
+
+export function createFileParser<TMeta extends object = object>(parser: ParserModule<TMeta>): ParserModule<TMeta> {
+  return parser
+}
+
+type PrintOptions = {
+  extname?: KubbFile.Extname
+  logger?: Logger
+}
+
+const typeScriptParser = createFileParser({
+  async format(source) {
+    const module = await import('@kubb/parser-ts')
+
+    return module.format(source)
+  },
+  async print(file, options = { extname: '.ts' }) {
+    const module = await import('@kubb/parser-ts')
+
+    const source = file.sources.map((item) => item.value).join('\n\n')
+
+    const importNodes = file.imports
+      .map((item) => {
+        const importPath = item.root ? getRelativePath(item.root, item.path) : item.path
+        const hasExtname = !!path.extname(importPath)
+
+        return module.factory.createImportDeclaration({
+          name: item.name,
+          path: options.extname && hasExtname ? `${trimExtName(importPath)}${options.extname}` : trimExtName(importPath),
+          isTypeOnly: item.isTypeOnly,
+        })
+      })
+      .filter(Boolean)
+
+    const exportNodes = file.exports
+      .map((item) => {
+        const exportPath = item.path
+
+        const hasExtname = !!path.extname(exportPath)
+
+        return module.factory.createExportDeclaration({
+          name: item.name,
+          path: options.extname && hasExtname ? `${trimExtName(item.path)}${options.extname}` : trimExtName(item.path),
+          isTypeOnly: item.isTypeOnly,
+          asAlias: item.asAlias,
+        })
+      })
+      .filter(Boolean)
+
+    return [file.banner, module.print([...importNodes, ...exportNodes]), source, file.footer].join('\n')
+  },
+})
+
+const defaultParser = createFileParser({
+  async format(source) {
+    return source
+  },
+  async print(file) {
+    return file.sources.map((item) => item.value).join('\n\n')
+  },
+})
+
+const parsers: Record<KubbFile.Extname, ParserModule<any>> = {
+  '.ts': typeScriptParser,
+  '.js': typeScriptParser,
+  '.jsx': typeScriptParser,
+  '.tsx': typeScriptParser,
+  '.json': defaultParser,
+}
+
+export async function getFileParser<TMeta extends object = object>(extname: KubbFile.Extname | undefined): Promise<ParserModule<TMeta>> {
+  if (!extname) {
+    return defaultParser
+  }
+
+  const parser = parsers[extname]
+
+  if (!parser) {
+    console.warn(`[parser] No parser found for ${extname}, default parser will be used`)
+  }
+
+  return parser || defaultParser
+}
+
+function trimExtName(text: string): string {
+  const extname = text.split('.').pop()
+
+  return text.replace(`.${extname}`, '')
+}