@kubb/core 2.0.0-beta.6 → 2.0.0-beta.8

package/src/BarrelManager.ts

@@ -1,23 +1,28 @@
 import path from 'path'
 
+import transformers from './transformers/index.ts'
 import { TreeNode } from './utils/TreeNode.ts'
 
 import type { DirectoryTreeOptions } from 'directory-tree'
 import type { KubbFile } from './FileManager.ts'
+import type { KubbPlugin } from './index.ts'
 
-type BarrelData = { type: KubbFile.Mode; path: KubbFile.Path; name: string }
+type FileMeta = {
+  pluginKey?: KubbPlugin['key']
+  treeNode: TreeNode
+}
 
 export type BarrelManagerOptions = {
   treeNode?: DirectoryTreeOptions
   isTypeOnly?: boolean
-  filter?: (file: KubbFile.File) => boolean
-  map?: (file: KubbFile.File) => KubbFile.File
-  includeExt?: boolean
-  output?: string
+  /**
+   * Add .ts or .js
+   */
+  extName?: KubbFile.Extname
 }
 
 export class BarrelManager {
-  #options: BarrelManagerOptions = {}
+  #options: BarrelManagerOptions
 
   constructor(options: BarrelManagerOptions = {}) {
     this.#options = options
@@ -26,45 +31,34 @@ export class BarrelManager {
   }
 
   getIndexes(
-    root: string,
-    extName?: KubbFile.Extname,
-  ): Array<KubbFile.File> | null {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = this.#options
-
-    const extMapper: Record<KubbFile.Extname, DirectoryTreeOptions> = {
-      '.ts': {
-        extensions: /\.ts/,
-        exclude: [/schemas/, /json/],
-      },
-      '.json': {
-        extensions: /\.json/,
-        exclude: [],
-      },
-    }
-    const tree = TreeNode.build<BarrelData>(root, { ...(extMapper[extName as keyof typeof extMapper] || {}), ...treeNode })
+    pathToBuild: string,
+  ): Array<KubbFile.File<FileMeta>> | null {
+    const { treeNode = {}, isTypeOnly, extName } = this.#options
+    const tree = TreeNode.build(pathToBuild, treeNode)
 
     if (!tree) {
       return null
     }
 
-    const fileReducer = (files: Array<KubbFile.File>, currentTree: typeof tree) => {
-      if (!currentTree.children) {
+    const fileReducer = (files: Array<KubbFile.File<FileMeta>>, treeNode: TreeNode) => {
+      if (!treeNode.children) {
         return []
       }
 
-      if (currentTree.children?.length > 1) {
-        const indexPath: KubbFile.Path = path.resolve(currentTree.data.path, 'index.ts')
-        const exports: KubbFile.Export[] = currentTree.children
+      if (treeNode.children.length > 1) {
+        const indexPath: KubbFile.Path = path.resolve(treeNode.data.path, 'index.ts')
+
+        const exports: KubbFile.Export[] = treeNode.children
           .filter(Boolean)
           .map((file) => {
-            const importPath: string = file.data.type === 'directory' ? `./${file.data.name}/index` : `./${file.data.name.replace(/\.[^.]*$/, '')}`
+            const importPath: string = file.data.type === 'directory' ? `./${file.data.name}/index` : `./${transformers.trimExtName(file.data.name)}`
 
-            if (importPath.includes('index') && file.data.type === 'file') {
+            if (importPath.endsWith('index') && file.data.type === 'file') {
               return undefined
             }
 
             return {
-              path: includeExt ? `${importPath}${extName}` : importPath,
+              path: extName ? `${importPath}${extName}` : importPath,
               isTypeOnly,
             } as KubbFile.Export
           })
@@ -74,50 +68,46 @@ export class BarrelManager {
           path: indexPath,
           baseName: 'index.ts',
           source: '',
-          exports: output
-            ? exports?.filter((item) => {
-              return item.path.endsWith(output.replace(/\.[^.]*$/, ''))
-            })
-            : exports,
+          exports,
+          meta: {
+            treeNode,
+          },
         })
-      } else {
-        currentTree.children?.forEach((child) => {
-          const indexPath = path.resolve(currentTree.data.path, 'index.ts')
-          const importPath = child.data.type === 'directory' ? `./${child.data.name}/index` : `./${child.data.name.replace(/\.[^.]*$/, '')}`
-
-          const exports = [
-            {
-              path: includeExt
-                ? `${importPath}${extName}`
-                : importPath,
-              isTypeOnly,
-            },
-          ]
-
-          files.push({
-            path: indexPath,
-            baseName: 'index.ts',
-            source: '',
-            exports: output
-              ? exports?.filter((item) => {
-                return item.path.endsWith(output.replace(/\.[^.]*$/, ''))
-              })
-              : exports,
-          })
+      } else if (treeNode.children.length === 1) {
+        const [treeNodeChild] = treeNode.children as [TreeNode]
+
+        const indexPath = path.resolve(treeNode.data.path, 'index.ts')
+        const importPath = treeNodeChild.data.type === 'directory'
+          ? `./${treeNodeChild.data.name}/index`
+          : `./${transformers.trimExtName(treeNodeChild.data.name)}`
+
+        const exports = [
+          {
+            path: extName
+              ? `${importPath}${extName}`
+              : importPath,
+            isTypeOnly,
+          },
+        ]
+
+        files.push({
+          path: indexPath,
+          baseName: 'index.ts',
+          source: '',
+          exports,
+          meta: {
+            treeNode,
+          },
         })
       }
 
-      currentTree.children.forEach((childItem) => {
+      treeNode.children.forEach((childItem) => {
         fileReducer(files, childItem)
       })
 
       return files
     }
 
-    const files = fileReducer([], tree).reverse()
-
-    const filteredFiles = filter ? files.filter(filter) : files
-
-    return map ? filteredFiles.map(map) : filteredFiles
+    return fileReducer([], tree).reverse()
   }
 }

package/src/FileManager.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 import crypto from 'node:crypto'
-import { extname } from 'node:path'
+import { extname, resolve } from 'node:path'
 
 import { print } from '@kubb/parser'
 import * as factory from '@kubb/parser/factory'
@@ -45,6 +45,10 @@ export namespace KubbFile {
      * Add `type` prefix to the import, this will result in: `import type { Type } from './path'`.
      */
     isTypeOnly?: boolean
+    /**
+     * Add `* as` prefix to the import, this will result in: `import * as path from './path'`.
+     */
+    isNameSpace?: boolean
     /**
      * When root is set it will get the path with relative getRelativePath(root, path).
      */
@@ -115,8 +119,8 @@ export namespace KubbFile {
      */
     id?: string
     /**
-     * Name to be used to dynamicly create the baseName(based on input.path)
-     * Based on UNIX basename
+     * Name to be used to create the path
+     * Based on UNIX basename, `${name}.extName`
      * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
      */
     baseName: TBaseName
@@ -151,6 +155,12 @@ export namespace KubbFile {
      * @default crypto.randomUUID()
      */
     id: UUID
+    /**
+     * Contains the first part of the baseName, generated based on baseName
+     * @link  https://nodejs.org/api/path.html#pathformatpathobject
+     */
+
+    name: string
   }
 }
 
@@ -163,8 +173,18 @@ type AddResult<T extends Array<KubbFile.File>> = Promise<
 >
 
 type AddIndexesProps = {
-  root: KubbFile.Path
-  extName?: KubbFile.Extname
+  /**
+   * Root based on root and output.path specified in the config
+   */
+  root: string
+  /**
+   * Output for plugin
+   */
+  output: {
+    path: string
+    exportAs?: string
+    extName?: KubbFile.Extname
+  }
   options?: BarrelManagerOptions
   meta?: KubbFile.File['meta']
 }
@@ -241,7 +261,7 @@ export class FileManager {
 
   async #add(file: KubbFile.File): Promise<KubbFile.ResolvedFile> {
     const controller = new AbortController()
-    const resolvedFile: KubbFile.ResolvedFile = { id: crypto.randomUUID(), ...file }
+    const resolvedFile: KubbFile.ResolvedFile = { id: crypto.randomUUID(), name: transformers.trimExtName(file.baseName), ...file }
 
     this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }])
 
@@ -275,15 +295,41 @@ export class FileManager {
     return this.#add(file)
   }
 
-  async addIndexes({ root, extName = '.ts', meta, options = {} }: AddIndexesProps): Promise<Array<KubbFile.File> | undefined> {
-    const barrelManager = new BarrelManager(options)
+  async addIndexes({ root, output, meta, options = {} }: AddIndexesProps): Promise<Array<KubbFile.File> | undefined> {
+    const exportPath = output.path.startsWith('./') ? output.path : `./${output.path}`
+
+    const barrelManager = new BarrelManager({ extName: output.extName, ...options })
 
-    const files = barrelManager.getIndexes(root, extName)
+    const files = barrelManager.getIndexes(resolve(root, output.path))
 
     if (!files) {
       return undefined
     }
 
+    const rootFile: KubbFile.File = {
+      path: resolve(root, 'index.ts'),
+      baseName: 'index.ts',
+      source: '',
+      exports: [
+        output.exportAs
+          ? {
+            name: output.exportAs,
+            asAlias: true,
+            path: exportPath,
+            isTypeOnly: options.isTypeOnly,
+          }
+          : {
+            path: exportPath,
+            isTypeOnly: options.isTypeOnly,
+          },
+      ],
+    }
+
+    await this.#addOrAppend({
+      ...rootFile,
+      meta: meta ? meta : rootFile.meta,
+    })
+
     return await Promise.all(
       files.map((file) => {
         return this.#addOrAppend({

package/src/utils/TreeNode.ts

@@ -3,10 +3,13 @@ import dirTree from 'directory-tree'
 import { FileManager } from '../FileManager.ts'
 
 import type { DirectoryTree, DirectoryTreeOptions } from 'directory-tree'
+import type { KubbFile } from '../FileManager.ts'
 
 export type TreeNodeOptions = DirectoryTreeOptions
 
-export class TreeNode<T = unknown> {
+type BarrelData = { type: KubbFile.Mode; path: KubbFile.Path; name: string }
+
+export class TreeNode<T = BarrelData> {
   public data: T
 
   public parent?: TreeNode<T>
@@ -91,7 +94,7 @@ export class TreeNode<T = unknown> {
     return this
   }
 
-  public static build<T = unknown>(path: string, options: TreeNodeOptions = {}): TreeNode<T> | null {
+  public static build(path: string, options: TreeNodeOptions = {}): 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] })
@@ -114,7 +117,7 @@ export class TreeNode<T = unknown> {
 
       filteredTree.children?.forEach((child) => recurse(treeNode, child))
 
-      return treeNode as TreeNode<T>
+      return treeNode
     } catch (e) {
       throw new Error('Something went wrong with creating index files with the TreehNode class', { cause: e })
     }