@kubb/core 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/build.ts

@@ -1,12 +1,13 @@
-import c from 'tinyrainbow'
-
 import { clean, read } from '@kubb/fs'
-import { type FileManager, processFiles } from './FileManager.ts'
+import type * as KubbFile from '@kubb/fs/types'
+import { FileManager, processFiles } from './FileManager.ts'
 import { PluginManager } from './PluginManager.ts'
 import { isInputPath } from './config.ts'
 import { createLogger } from './logger.ts'
 import { URLPath } from './utils/URLPath.ts'
 
+import { resolve } from 'node:path'
+import { getRelativePath } from '@kubb/fs'
 import type { Logger } from './logger.ts'
 import type { PluginContext } from './types.ts'
 
@@ -36,12 +37,9 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
     }
   } catch (e) {
     if (isInputPath(config)) {
-      throw new Error(
-        `Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${c.dim(config.input.path)}`,
-        {
-          cause: e,
-        },
-      )
+      throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${config.input.path}`, {
+        cause: e,
+      })
     }
   }
 
@@ -53,25 +51,14 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
 }
 
 export async function build(options: BuildOptions): Promise<BuildOutput> {
-  const pluginManager = await setup(options)
-
-  await pluginManager.hookParallel({
-    hookName: 'buildStart',
-    parameters: [options.config],
-  })
+  const { files, pluginManager, error } = await safeBuild(options)
 
-  const files = await processFiles({
-    config: options.config,
-    dryRun: !options.config.output.write,
-    files: pluginManager.fileManager.files,
-    logger: pluginManager.logger,
-  })
-
-  await pluginManager.hookParallel({ hookName: 'buildEnd' })
+  if (error) throw error
 
   return {
     files,
     pluginManager,
+    error,
   }
 }
 
@@ -85,6 +72,54 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
       parameters: [options.config],
     })
 
+    // create root barrel file
+    const root = resolve(options.config.root)
+    const rootPath = resolve(root, options.config.output.path, 'index.ts')
+    const barrelFiles = pluginManager.fileManager.files.filter((file) => {
+      return file.sources.some((source) => source.isIndexable)
+    })
+
+    const rootFile: KubbFile.File = {
+      path: rootPath,
+      baseName: 'index.ts',
+      exports: barrelFiles
+        .flatMap((file) => {
+          return file.sources
+            ?.map((source) => {
+              if (!file.path || !source.isIndexable) {
+                return undefined
+              }
+
+              // validate of the file is coming from plugin x, needs pluginKey on every file TODO update typing
+              const plugin = pluginManager.plugins.find((item) => {
+                const meta = file.meta as any
+                return item.name === meta?.pluginKey?.[0]
+              })
+
+              if (plugin?.output?.exportType === false) {
+                return undefined
+              }
+
+              if (FileManager.getMode(plugin?.output?.path) === 'single') {
+                return undefined
+              }
+              return {
+                name: options.config.output.exportType === 'barrel' ? undefined : [source.name],
+                path: getRelativePath(rootPath, file.path),
+                isTypeOnly: source.isTypeOnly,
+              } as KubbFile.Export
+            })
+            .filter(Boolean)
+        })
+        .filter(Boolean),
+      sources: [],
+      meta: {},
+    }
+
+    if (options.config.output.exportType) {
+      await pluginManager.fileManager.add(rootFile)
+    }
+
     //TODO set extName here instead of the files, extName is private. All exports will have extName, it's up the the process to hide.override the name
     files = await processFiles({
       config: options.config,
@@ -94,6 +129,8 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
     })
 
     await pluginManager.hookParallel({ hookName: 'buildEnd' })
+
+    pluginManager.fileManager.clear()
   } catch (e) {
     return {
       files: [],

package/src/plugin.ts

@@ -46,7 +46,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,
@@ -67,7 +67,7 @@ export const pluginCore = createPlugin<PluginCore>((options) => {
       }
     },
     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/types.ts

@@ -75,6 +75,11 @@ export type Config<TInput = Input> = {
      * @default true
      */
     write?: boolean
+    /**
+     * Define what needs to exported, here you can also disable the export of barrel files
+     * @default `'barrelNamed'`
+     */
+    exportType?: 'barrel' | 'barrelNamed' | false
   }
   /**
    * Array of Kubb plugins to use.
@@ -146,7 +151,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>
   /**
@@ -176,9 +181,24 @@ export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    * @private
    */
   key: TOptions['key']
+  output?: {
+    /**
+     * Output to save the clients.
+     */
+    path: string
+    /**
+     * Add an extension to the generated imports and exports, default it will not use an extension
+     */
+    extName?: KubbFile.Extname
+    /**
+     * Define what needs to exported, here you can also disable the export of barrel files
+     * @default `'barrelNamed'`
+     */
+    exportType?: 'barrel' | 'barrelNamed' | false
+  }
   /**
    * 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>
   /**

package/src/utils/TreeNode.ts

@@ -95,6 +95,48 @@ export class TreeNode {
     return this
   }
 
+  filter(callback: (treeNode: TreeNode) => boolean): Array<TreeNode> {
+    let data: Array<TreeNode> = []
+    if (typeof callback !== 'function') {
+      throw new TypeError('forEach() callback must be a function')
+    }
+
+    // run this node through function
+    if (callback(this)) {
+      data.push(this)
+    }
+
+    // do the same for all children
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        const childData = this.children[i]?.filter(callback).filter(Boolean) || []
+        data = [...new Set([...data, ...childData])]
+      }
+    }
+
+    return data
+  }
+
+  map<T>(callback: (treeNode: TreeNode) => T): Array<T> {
+    let data: Array<T> = []
+    if (typeof callback !== 'function') {
+      throw new TypeError('forEach() callback must be a function')
+    }
+
+    // run this node through function
+    data.push(callback(this))
+
+    // do the same for all children
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        const childData = this.children[i]?.map(callback).filter(Boolean) || []
+        data = [...new Set([...data, ...childData])]
+      }
+    }
+
+    return data
+  }
+
   public static build(files: KubbFile.File[], root?: string): TreeNode | null {
     try {
       const filteredTree = buildDirectoryTree(files, root)
@@ -129,7 +171,7 @@ export class TreeNode {
 
       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 })
     }
   }
 }

package/src/utils/index.ts

@@ -10,5 +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 { getFileParser, createFile, createFileParser } from './parser.ts'
+export { getFileParser, createFileImport, createFileExport, createFile, createFileParser } from './parser.ts'
 export type { ParserModule } from './parser.ts'

package/src/utils/parser.ts

@@ -1,92 +1,153 @@
+import { extname } 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 = 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: file.baseName.split('.').pop() || '',
-    ...file,
+    extName,
+    imports: imports.map((item) => createFileImport(item)),
+    exports: exports.map((item) => createFileExport(item)),
+    sources: sources.map((item) => createFileSource(item)),
   }
 }
 
-export type ParserModule<TImport = unknown, TExport = unknown> = {
-  createImport: (props: {
-    name:
-      | string
-      | Array<
-          | string
-          | {
-              propertyName: string
-              name?: string
-            }
-        >
-    path: string
-    isTypeOnly?: boolean
-    isNameSpace?: boolean
-  }) => TImport | undefined
-  createExport: (props: {
-    path: string
-    asAlias?: boolean
-    isTypeOnly?: boolean
-    name?: string | Array<string>
-  }) => TExport | undefined
-  print: (props: { imports: Array<TImport>; exports: Array<TExport>; source: string }) => string
+/**
+ * Helper to create a fileImport with extName set
+ */
+export 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 {
+  const extName = extname(imp.path) as KubbFile.Extname
+
+  return {
+    ...imp,
+    extName: imp.extName ? imp.extName : extName,
+  }
 }
 
-export function createFileParser<TImport = unknown, TExport = unknown>(parser: ParserModule<TImport, TExport>): ParserModule<TImport, TExport> {
+/**
+ * Helper to create a fileExport with extName set
+ */
+export function createFileExport(exp: KubbFile.Export): KubbFile.ResolvedExport {
+  const extName = extname(exp.path) as KubbFile.Extname
+
+  return {
+    ...exp,
+    extName: exp.extName ? exp.extName : extName,
+  }
+}
+
+export type ParserModule<TMeta extends object = object> = {
+  /**
+   * By default @kubb/react is used
+   */
+  render: (item: any) => any
+  /**
+   * 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
 }
 
-export async function getFileParser(extName: string | undefined): Promise<ParserModule<any, any>> {
-  switch (extName) {
-    case 'ts':
-    case 'js':
-    case 'tsx':
-    case 'jsx': {
-      const module = await import('@kubb/parser-ts')
-
-      return createFileParser({
-        createExport({ name, path, isTypeOnly, asAlias }) {
-          return module.factory.createExportDeclaration({
-            path,
-            asAlias,
-            isTypeOnly,
-            name,
-          })
-        },
-        createImport({ name, path, isTypeOnly }) {
-          return module.factory.createImportDeclaration({
-            name: name as any,
-            path,
-            isTypeOnly,
-          })
-        },
-        print(props) {
-          const source = [module.print([...props.imports, ...props.exports]), props.source].join('\n')
-
-          // do some basic linting with the ts compiler
-          return module.print([], { source, noEmitHelpers: false })
-        },
+type PrintOptions = {
+  logger?: Logger
+}
+
+const typeScriptParser = createFileParser({
+  render() {
+    return undefined
+  },
+  async print(file) {
+    const module = await import('@kubb/parser-ts')
+
+    const importNodes = file.imports
+      .map((item) => {
+        const path = item.root ? getRelativePath(item.root, item.path) : item.path
+
+        return module.factory.createImportDeclaration({
+          name: item.name,
+          path,
+          isTypeOnly: item.isTypeOnly,
+        })
       })
-    }
-    default:
-      return createFileParser<string>({
-        createExport() {
-          return undefined
-        },
-        createImport() {
-          return undefined
-        },
-        print(props) {
-          return props.source
-        },
+      .filter(Boolean)
+
+    const exportNodes = file.exports
+      .map((item) => {
+        return module.factory.createExportDeclaration({
+          name: item.name,
+          path: item.path,
+          isTypeOnly: item.isTypeOnly,
+          asAlias: item.asAlias,
+        })
       })
+      .filter(Boolean)
+
+    const source = [module.print([...importNodes, ...exportNodes]), file.sources.map((item) => item.value).join('\n\n')].join('\n')
+
+    // do some basic linting with the ts compiler
+    return module.print([], { source, noEmitHelpers: false })
+  },
+})
+
+const defaultParser = createFileParser({
+  render() {
+    return undefined
+  },
+  async print(file, { logger }) {
+    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
 }
 
 export function trimExtName(text: string): string {