@kubb/core 3.0.0-alpha.1 → 3.0.0-alpha.10

package/src/FileManager.ts

@@ -1,101 +1,83 @@
-import crypto from 'node:crypto'
-import { extname, resolve } from 'node:path'
+import { extname, join, relative } from 'node:path'
 
 import { orderBy } from 'natural-orderby'
-import PQueue from 'p-queue'
 import { isDeepEqual } from 'remeda'
 
-import { getRelativePath, read, write } from '@kubb/fs'
+import { read, write } from '@kubb/fs'
 import { BarrelManager } from './BarrelManager.ts'
-import { searchAndReplace } from './transformers/searchAndReplace.ts'
-import { trimExtName } from './transformers/trim.ts'
 
 import type * as KubbFile from '@kubb/fs/types'
 
-import type { BaseName, File, UUID } from '@kubb/fs/src/types.ts'
+import { trimExtName } from '@kubb/fs'
+import type { ResolvedFile } from '@kubb/fs/types'
 import type { GreaterThan } from '@kubb/types'
-import type { BarrelManagerOptions } from './BarrelManager.ts'
+import PQueue from 'p-queue'
 import type { Logger } from './logger.ts'
-import transformers from './transformers/index.ts'
-import type { Plugin } from './types.ts'
-import { getParser } from './utils'
-
-export type ResolvedFile<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = File<TMeta, TBaseName> & {
-  /**
-   * @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
-}
+import type { Config, Plugin } from './types.ts'
+import { createFile, getFileParser } from './utils'
+import { type DirectoryTree, TreeNode, buildDirectoryTree } from './utils/TreeNode.ts'
 
 export type FileMetaBase = {
   pluginKey?: Plugin['key']
 }
 
-type FileWithMeta<TMeta extends FileMetaBase = FileMetaBase> = KubbFile.File<TMeta>
-
-type CacheItem = ResolvedFile & {
-  cancel?: () => void
-}
-
-type AddResult<T extends Array<FileWithMeta>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<ResolvedFile[]> : Promise<ResolvedFile>>>
+type AddResult<T extends Array<KubbFile.File>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<ResolvedFile[]> : Promise<ResolvedFile>>>
 
 type AddIndexesProps = {
   /**
    * Root based on root and output.path specified in the config
    */
   root: string
+  files: KubbFile.File[]
   /**
    * Output for plugin
    */
   output: {
     path: string
-    exportAs?: string
     extName?: KubbFile.Extname
+    exportAs?: string
     exportType?: 'barrel' | 'barrelNamed' | false
   }
-  logger: Logger
-  options?: BarrelManagerOptions
-  meta?: FileWithMeta['meta']
-}
+  group?: {
+    output: string
+    exportAs: string
+  }
+  logger?: Logger
 
-type Options = {
-  queue?: PQueue
-  task?: (file: ResolvedFile) => Promise<ResolvedFile>
+  meta?: FileMetaBase
 }
 
 export class FileManager {
-  #cache: Map<KubbFile.Path, CacheItem[]> = new Map()
-
-  #task: Options['task']
-  #queue: PQueue
-
-  constructor({ task = async (file) => file, queue = new PQueue() }: Options = {}) {
-    this.#task = task
-    this.#queue = queue
-
+  #filesByPath: Map<KubbFile.Path, KubbFile.ResolvedFile> = new Map()
+  #files: Set<KubbFile.ResolvedFile> = new Set()
+  constructor() {
     return this
   }
 
-  get files(): Array<FileWithMeta> {
-    const files: Array<FileWithMeta> = []
-    this.#cache.forEach((item) => {
-      files.push(...item.flat(1))
-    })
+  get files(): Array<KubbFile.ResolvedFile> {
+    return Array.from(this.#files)
+  }
 
-    return files
+  get orderedFiles(): Array<KubbFile.ResolvedFile> {
+    return orderBy(Array.from(this.#files), [
+      (v) => v?.meta && 'pluginKey' in v.meta && !v.meta.pluginKey,
+      (v) => v.path.length,
+      (v) => trimExtName(v.path).endsWith('index'),
+      (v) => trimExtName(v.baseName),
+      (v) => v.path.split('.').pop(),
+    ])
   }
-  get isExecuting(): boolean {
-    return this.#queue.size !== 0 && this.#queue.pending !== 0
+
+  get groupedFiles(): DirectoryTree | null {
+    return buildDirectoryTree(Array.from(this.#files))
+  }
+
+  get treeNode(): TreeNode | null {
+    return TreeNode.build(Array.from(this.#files))
   }
 
-  async add<T extends Array<FileWithMeta> = Array<FileWithMeta>>(...files: T): AddResult<T> {
-    const promises = combineFiles(files).map((file) => {
+  async add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T> {
+    const promises = files.map((file) => {
       if (file.override) {
         return this.#add(file)
       }
@@ -112,270 +94,161 @@ export class FileManager {
     return resolvedFiles[0] as unknown as AddResult<T>
   }
 
-  async #add(file: FileWithMeta): Promise<ResolvedFile> {
-    const controller = new AbortController()
-    const resolvedFile: ResolvedFile = {
-      id: crypto.randomUUID(),
-      name: trimExtName(file.baseName),
-      ...file,
-    }
-
-    if (resolvedFile.exports?.length) {
-      const folder = resolvedFile.path.replace(resolvedFile.baseName, '')
-
-      resolvedFile.exports = resolvedFile.exports.filter((exportItem) => {
-        const exportedFile = this.files.find((file) => file.path.includes(resolve(folder, exportItem.path)))
-
-        if (exportedFile) {
-          return exportedFile.exportable
-        }
+  async #add(file: KubbFile.File): Promise<ResolvedFile> {
+    const resolvedFile = createFile(file)
 
-        return true
-      })
-    }
+    this.#filesByPath.set(resolvedFile.path, resolvedFile)
+    this.#files.add(resolvedFile)
 
-    this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }])
+    return resolvedFile
+  }
 
-    return this.#queue.add(
-      async () => {
-        return this.#task?.(resolvedFile)
-      },
-      { signal: controller.signal },
-    ) as Promise<ResolvedFile>
+  clear() {
+    this.#filesByPath.clear()
+    this.#files.clear()
   }
 
-  async #addOrAppend(file: FileWithMeta): Promise<ResolvedFile> {
-    const previousCaches = this.#cache.get(file.path)
-    const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : undefined
+  async #addOrAppend(file: KubbFile.File): Promise<ResolvedFile> {
+    const previousFile = this.#filesByPath.get(file.path)
 
-    if (previousCache) {
-      this.#cache.delete(previousCache.path)
+    if (previousFile) {
+      this.#filesByPath.delete(previousFile.path)
+      this.#files.delete(previousFile)
 
-      return this.#add({
-        ...file,
-        source: previousCache.source && file.source ? `${previousCache.source}\n${file.source}` : '',
-        imports: [...(previousCache.imports || []), ...(file.imports || [])],
-        exports: [...(previousCache.exports || []), ...(file.exports || [])],
-        env: { ...(previousCache.env || {}), ...(file.env || {}) },
-      })
+      return this.#add(mergeFile(previousFile, file))
     }
     return this.#add(file)
   }
 
-  async addIndexes({ root, output, meta, logger, options = {} }: AddIndexesProps): Promise<void> {
-    const { exportType = 'barrel' } = output
-    //        ^?
-    if (exportType === false) {
-      return undefined
-    }
-
-    const pathToBuildFrom = resolve(root, output.path)
+  getCacheById(id: string): KubbFile.File | undefined {
+    let cache: KubbFile.File | undefined
 
-    if (transformers.trimExtName(pathToBuildFrom).endsWith('index')) {
-      logger.emit('warning', 'Output has the same fileName as the barrelFiles, please disable barrel generation')
-      return
-    }
-
-    const exportPath = output.path.startsWith('./') ? trimExtName(output.path) : `./${trimExtName(output.path)}`
-    const mode = FileManager.getMode(output.path)
-    const barrelManager = new BarrelManager({
-      extName: output.extName,
-      ...options,
+    this.#files.forEach((file) => {
+      if (file.id === id) {
+        cache = file
+      }
     })
-    let files = barrelManager.getIndexes(pathToBuildFrom)
+    return cache
+  }
 
-    if (!files) {
-      return undefined
-    }
+  getByPath(path: KubbFile.Path): KubbFile.ResolvedFile | undefined {
+    return this.#filesByPath.get(path)
+  }
 
-    if (exportType === 'barrelNamed') {
-      files = files.map((file) => {
-        if (file.exports) {
-          return {
-            ...file,
-            exports: barrelManager.getNamedExports(pathToBuildFrom, file.exports),
-          }
-        }
-        return file
-      })
+  deleteByPath(path: KubbFile.Path): void {
+    const cacheItem = this.getByPath(path)
+    if (!cacheItem) {
+      return
     }
 
-    await Promise.all(
-      files.map((file) => {
-        return this.#addOrAppend({
-          ...file,
-          meta: meta ? meta : file.meta,
-        })
-      }),
-    )
-
-    const rootPath = mode === 'split' ? `${exportPath}/index${output.extName || ''}` : `${exportPath}${output.extName || ''}`
-    const rootFile: FileWithMeta = {
-      path: resolve(root, 'index.ts'),
-      baseName: 'index.ts',
-      source: '',
-      exports: [
-        output.exportAs
-          ? {
-              name: output.exportAs,
-              asAlias: true,
-              path: rootPath,
-              isTypeOnly: options.isTypeOnly,
-            }
-          : {
-              path: rootPath,
-              isTypeOnly: options.isTypeOnly,
-            },
-      ],
-      exportable: true,
-    }
+    this.#filesByPath.delete(path)
+    this.#files.delete(cacheItem)
+  }
 
-    if (exportType === 'barrelNamed' && !output.exportAs && rootFile.exports?.[0]) {
-      rootFile.exports = barrelManager.getNamedExport(root, rootFile.exports[0])
+  async getBarrelFiles({ files, meta, root, output, logger }: AddIndexesProps): Promise<KubbFile.File[]> {
+    const { exportType = 'barrelNamed' } = output
+    const barrelManager = new BarrelManager({ logger })
+
+    if (exportType === false) {
+      return []
     }
 
-    await this.#addOrAppend({
-      ...rootFile,
-      meta: meta ? meta : rootFile.meta,
-    })
-  }
+    const pathToBuildFrom = join(root, output.path)
 
-  getCacheByUUID(UUID: KubbFile.UUID): FileWithMeta | undefined {
-    let cache: FileWithMeta | undefined
+    if (trimExtName(pathToBuildFrom).endsWith('index')) {
+      logger?.emit('warning', 'Output has the same fileName as the barrelFiles, please disable barrel generation')
 
-    this.#cache.forEach((files) => {
-      cache = files.find((item) => item.id === UUID)
-    })
-    return cache
-  }
+      return []
+    }
 
-  get(path: KubbFile.Path): Array<FileWithMeta> | undefined {
-    return this.#cache.get(path)
-  }
+    const barrelFiles = barrelManager.getFiles({ files, root: pathToBuildFrom, meta })
 
-  remove(path: KubbFile.Path): void {
-    const cacheItem = this.get(path)
-    if (!cacheItem) {
-      return
+    if (exportType === 'barrel') {
+      return barrelFiles.map((file) => {
+        return {
+          ...file,
+          exports: file.exports?.map((exportItem) => {
+            return {
+              ...exportItem,
+              name: undefined,
+            }
+          }),
+        }
+      })
     }
 
-    this.#cache.delete(path)
+    return barrelFiles.map((indexFile) => {
+      return {
+        ...indexFile,
+        meta,
+      }
+    })
   }
 
-  async write(...params: Parameters<typeof write>): Promise<string | undefined> {
+  async write(...params: Parameters<typeof write>): ReturnType<typeof write> {
     return write(...params)
   }
 
-  async read(...params: Parameters<typeof read>): Promise<string> {
+  async read(...params: Parameters<typeof read>): ReturnType<typeof read> {
     return read(...params)
   }
 
   // statics
-
-  static async getSource<TMeta extends FileMetaBase = FileMetaBase>(file: FileWithMeta<TMeta>): Promise<string> {
-    return getSource<TMeta>(file)
-  }
-
-  static combineFiles<TMeta extends FileMetaBase = FileMetaBase>(files: Array<FileWithMeta<TMeta> | null>): Array<FileWithMeta<TMeta>> {
-    return combineFiles<TMeta>(files)
-  }
   static getMode(path: string | undefined | null): KubbFile.Mode {
     if (!path) {
       return 'split'
     }
     return extname(path) ? 'single' : 'split'
   }
+}
 
-  static get extensions(): Array<KubbFile.Extname> {
-    return ['.js', '.ts', '.tsx']
-  }
+type GetSourceOptions = {
+  logger?: Logger
+}
+
+export async function getSource<TMeta extends FileMetaBase = FileMetaBase>(file: ResolvedFile<TMeta>, { logger }: GetSourceOptions = {}): Promise<string> {
+  const parser = await getFileParser(file.extName)
+
+  return parser.print(file, { logger })
+}
 
-  static isJavascript(baseName: string): boolean {
-    return FileManager.extensions.some((extension) => baseName.endsWith(extension))
+export function mergeFile<TMeta extends FileMetaBase = FileMetaBase>(a: KubbFile.File<TMeta>, b: KubbFile.File<TMeta>): KubbFile.File<TMeta> {
+  return {
+    ...a,
+    sources: [...(a.sources || []), ...(b.sources || [])],
+    imports: [...(a.imports || []), ...(b.imports || [])],
+    exports: [...(a.exports || []), ...(b.exports || [])],
   }
 }
 
-function combineFiles<TMeta extends FileMetaBase = FileMetaBase>(files: Array<FileWithMeta<TMeta> | null>): Array<FileWithMeta<TMeta>> {
-  return files.filter(Boolean).reduce(
-    (acc, file: FileWithMeta<TMeta>) => {
-      const prevIndex = acc.findIndex((item) => item.path === file.path)
+export function combineSources(sources: Array<KubbFile.Source>): Array<KubbFile.Source> {
+  return sources.reduce(
+    (prev, curr) => {
+      const prevByName = prev.findLast((imp) => imp.name === curr.name)
+      const prevByPathAndIsExportable = prev.findLast((imp) => imp.name === curr.name && imp.isExportable)
 
-      if (prevIndex === -1) {
-        return [...acc, file]
+      if (prevByPathAndIsExportable) {
+        // we already have an export that has the same name but uses `isExportable` (export type ...)
+        return [...prev, curr]
       }
 
-      const prev = acc[prevIndex]
+      if (prevByName) {
+        prevByName.value = curr.value
+        prevByName.isExportable = curr.isExportable
+        prevByName.isTypeOnly = curr.isTypeOnly
+        prevByName.isIndexable = curr.isIndexable
 
-      if (prev && file.override) {
-        acc[prevIndex] = {
-          imports: [],
-          exports: [],
-          ...file,
-        }
-        return acc
-      }
-
-      if (prev) {
-        acc[prevIndex] = {
-          ...file,
-          source: prev.source && file.source ? `${prev.source}\n${file.source}` : '',
-          imports: [...(prev.imports || []), ...(file.imports || [])],
-          exports: [...(prev.exports || []), ...(file.exports || [])],
-          env: { ...(prev.env || {}), ...(file.env || {}) },
-        }
+        return prev
       }
 
-      return acc
+      return [...prev, curr]
     },
-    [] as Array<FileWithMeta<TMeta>>,
-  )
-}
-
-export async function getSource<TMeta extends FileMetaBase = FileMetaBase>(file: FileWithMeta<TMeta>): Promise<string> {
-  // only use .js, .ts or .tsx files for ESM imports
-
-  if (file.language ? !['typescript', 'javascript'].includes(file.language) : !FileManager.isJavascript(file.baseName)) {
-    return file.source
-  }
-
-  const parser = await getParser(file.language)
-
-  const exports = file.exports ? combineExports(file.exports) : []
-  // imports should be defined and source should contain code or we have imports without them being used
-  const imports = file.imports && file.source ? combineImports(file.imports, exports, file.source) : []
-
-  const importNodes = imports
-    .filter((item) => {
-      const path = item.root ? getRelativePath(item.root, item.path) : item.path
-      // trim extName
-      return path !== trimExtName(file.path)
-    })
-    .map((item) => {
-      const path = item.root ? getRelativePath(item.root, item.path) : item.path
-
-      return parser.factory.createImportDeclaration({
-        name: item.name,
-        path: item.extName ? `${path}${item.extName}` : path,
-        isTypeOnly: item.isTypeOnly,
-      })
-    })
-  const exportNodes = exports.map((item) =>
-    parser.factory.createExportDeclaration({
-      name: item.name,
-      path: item.extName ? `${item.path}${item.extName}` : item.path,
-      isTypeOnly: item.isTypeOnly,
-      asAlias: item.asAlias,
-    }),
+    [] as Array<KubbFile.Source>,
   )
-
-  const source = [parser.print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join('\n')
-
-  // do some basic linting with the ts compiler
-  return parser.print([], { source, noEmitHelpers: false })
 }
 
 export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export> {
-  const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ['asc']).reduce(
+  const combinedExports = exports.reduce(
     (prev, curr) => {
       const name = curr.name
       const prevByPath = prev.findLast((imp) => imp.path === curr.path)
@@ -390,6 +263,7 @@ export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.
         (imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias,
       )
 
+      // we already have an item that was unique enough or name field is empty or prev asAlias is set but current has no changes
       if (uniquePrev || (Array.isArray(name) && !name.length) || (prevByPath?.asAlias && !curr.asAlias)) {
         return prev
       }
@@ -404,6 +278,7 @@ export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.
         ]
       }
 
+      // merge all names when prev and current both have the same isTypeOnly set
       if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
         prevByPath.name = [...new Set([...prevByPath.name, ...curr.name])]
 
@@ -415,11 +290,17 @@ export function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.
     [] as Array<KubbFile.Export>,
   )
 
-  return orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ['desc', 'desc'])
+  return orderBy(combinedExports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
+  ])
 }
 
 export function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source?: string): Array<KubbFile.Import> {
-  const combinedImports = orderBy(imports, [(v) => !v.isTypeOnly], ['asc']).reduce(
+  const combinedImports = imports.reduce(
     (prev, curr) => {
       let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
 
@@ -438,6 +319,7 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
         return prev
       }
 
+      // merge all names and check if the importName is being used in the generated source and if not filter those imports out
       if (Array.isArray(name)) {
         name = name.filter((item) => (typeof item === 'string' ? hasImportInSource(item) : hasImportInSource(item.propertyName)))
       }
@@ -451,10 +333,12 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
         return prev
       }
 
+      // already unique enough or name is empty
       if (uniquePrev || (Array.isArray(name) && !name.length)) {
         return prev
       }
 
+      // new item, append name
       if (!prevByPath) {
         return [
           ...prev,
@@ -465,12 +349,14 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
         ]
       }
 
+      // merge all names when prev and current both have the same isTypeOnly set
       if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
         prevByPath.name = [...new Set([...prevByPath.name, ...name])]
 
         return prev
       }
 
+      // no import was found in the source, ignore import
       if (!Array.isArray(name) && name && !hasImportInSource(name)) {
         return prev
       }
@@ -480,43 +366,58 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
     [] as Array<KubbFile.Import>,
   )
 
-  return orderBy(combinedImports, [(v) => !v.isTypeOnly], ['desc'])
+  return orderBy(combinedImports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => (Array.isArray(v.name) ? orderBy(v.name) : v.name),
+  ])
+}
+type WriteFilesProps = {
+  config: Config
+  files: Array<KubbFile.ResolvedFile>
+  logger: Logger
+  dryRun?: boolean
 }
+/**
+ * Global queue
+ */
+const queue = new PQueue({ concurrency: 100 })
 
-function getEnvSource(source: string, env: NodeJS.ProcessEnv | undefined): string {
-  if (!env) {
-    return source
-  }
+export async function processFiles({ dryRun, config, logger, files }: WriteFilesProps) {
+  const orderedFiles = orderBy(files, [
+    (v) => v?.meta && 'pluginKey' in v.meta && !v.meta.pluginKey,
+    (v) => v.path.length,
+    (v) => trimExtName(v.path).endsWith('index'),
+  ])
 
-  const keys = Object.keys(env)
+  logger.emit('debug', {
+    date: new Date(),
+    logs: [JSON.stringify({ files: orderedFiles }, null, 2)],
+    fileName: 'kubb-files.log',
+  })
 
-  if (!keys.length) {
-    return source
-  }
+  if (!dryRun) {
+    const size = orderedFiles.length
 
-  return keys.reduce((prev, key: string) => {
-    const environmentValue = env[key]
-    const replaceBy = environmentValue ? `'${environmentValue.replaceAll('"', '')?.replaceAll("'", '')}'` : 'undefined'
+    logger.emit('progress_start', { id: 'files', size, message: 'Writing files ...' })
+    const promises = orderedFiles.map(async (file) => {
+      await queue.add(async () => {
+        const message = file ? `Writing ${relative(config.root, file.path)}` : ''
 
-    if (key.toUpperCase() !== key) {
-      throw new TypeError(`Environment should be in upperCase for ${key}`)
-    }
+        const source = await getSource(file, { logger })
 
-    if (typeof replaceBy === 'string') {
-      prev = searchAndReplace({
-        text: prev.replaceAll(`process.env.${key}`, replaceBy),
-        replaceBy,
-        prefix: 'process.env',
-        key,
-      })
-      // removes `declare const ...`
-      prev = searchAndReplace({
-        text: prev.replaceAll(/(declare const).*\n/gi, ''),
-        replaceBy,
-        key,
+        await write(file.path, source, { sanity: false })
+
+        logger.emit('progressed', { id: 'files', message })
       })
-    }
+    })
+
+    await Promise.all(promises)
+
+    logger.emit('progress_stop', { id: 'files' })
+  }
 
-    return prev
-  }, source)
+  return files
 }

package/src/PackageManager.ts

@@ -68,7 +68,7 @@ export class PackageManager {
 
       return module?.default ?? module
     } catch (e) {
-      console.log(e)
+      console.error(e)
       return undefined
     }
   }