@kubb/core 1.1.11 → 1.1.13

package/src/build.ts

@@ -1,106 +0,0 @@
-import { getFileSource } from './managers/fileManager/index.ts'
-import { PluginManager } from './managers/pluginManager/index.ts'
-import { clean, isURL, read } from './utils/index.ts'
-import { isPromise } from './utils/isPromise.ts'
-
-import type { Ora } from 'ora'
-import type { File } from './managers/fileManager/index.ts'
-import type { OnExecute } from './managers/pluginManager/index.ts'
-import type { BuildOutput, KubbPlugin, LogLevel, PluginContext, TransformResult } from './types.ts'
-import type { QueueTask } from './utils/index.ts'
-
-export type Logger<TParams = Record<string, any>> = {
-  log: (message: string | null, options: { logLevel: LogLevel; params?: TParams }) => void
-  spinner?: Ora
-}
-type BuildOptions = {
-  config: PluginContext['config']
-  logger?: Logger
-}
-
-async function transformReducer(
-  this: PluginContext,
-  _previousCode: string,
-  result: TransformResult | Promise<TransformResult>,
-
-  _plugin: KubbPlugin
-): Promise<string | null> {
-  return result
-}
-
-export async function build(options: BuildOptions): Promise<BuildOutput> {
-  const { config, logger } = options
-
-  try {
-    if (!isURL(config.input.path)) {
-      await read(config.input.path)
-    }
-  } catch (e: any) {
-    throw new Error('Cannot read file/URL defined in `input.path` or set with --input in the CLI of your Kubb config', { cause: e })
-  }
-
-  if (config.output.clean) {
-    await clean(config.output.path)
-  }
-
-  const queueTask = async (id: string, file: File) => {
-    const { path } = file
-
-    let code: string | null = getFileSource(file)
-
-    const { result: loadedResult } = await pluginManager.hookFirst({
-      hookName: 'load',
-      parameters: [path],
-    })
-    if (loadedResult && isPromise(loadedResult)) {
-      code = await loadedResult
-    }
-    if (loadedResult && !isPromise(loadedResult)) {
-      code = loadedResult
-    }
-
-    if (code) {
-      const transformedCode = await pluginManager.hookReduceArg0({
-        hookName: 'transform',
-        parameters: [code, path],
-        reduce: transformReducer,
-      })
-
-      if (config.output.write || config.output.write === undefined) {
-        await pluginManager.hookParallel({
-          hookName: 'writeFile',
-          parameters: [transformedCode, path],
-        })
-      }
-    }
-  }
-
-  const onExecute: OnExecute = (executer) => {
-    if (!executer) {
-      return
-    }
-
-    const { hookName, plugin } = executer
-
-    if (config.logLevel === 'info' && logger) {
-      logger.log(null, { logLevel: config.logLevel, params: { hookName, pluginName: plugin.name } })
-    }
-  }
-
-  const pluginManager = new PluginManager(config, { task: queueTask as QueueTask<File>, onExecute })
-  const { plugins, fileManager } = pluginManager
-
-  await pluginManager.hookParallel<'validate', true>({
-    hookName: 'validate',
-    parameters: [plugins],
-  })
-
-  await pluginManager.hookParallel({
-    hookName: 'buildStart',
-    parameters: [config],
-  })
-
-  await pluginManager.hookParallel({ hookName: 'buildEnd' })
-
-  return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })), pluginManager }
-}

package/src/config.ts

@@ -1,15 +0,0 @@
-import type { CLIOptions, KubbUserConfig, MaybePromise } from './types.ts'
-
-/**
- * Type helper to make it easier to use kubb.config.js
- * accepts a direct {@link KubbConfig} object, or a function that returns it.
- * The function receives a {@link ConfigEnv} object that exposes two properties:
- */
-export const defineConfig = (
-  options:
-    | MaybePromise<KubbUserConfig>
-    | ((
-        /** The options derived from the CLI flags */
-        cliOptions: CLIOptions
-      ) => MaybePromise<KubbUserConfig>)
-) => options

package/src/generators/Generator.ts

@@ -1,23 +0,0 @@
-/**
- * Abstract class that contains the building blocks for plugins to create their own Generator
- * @link idea based on https://github.com/colinhacks/zod/blob/master/src/types.ts#L137
- */
-export abstract class Generator<TOptions extends object = object> {
-  private _options: TOptions = {} as TOptions
-
-  constructor(options: TOptions = {} as TOptions) {
-    if (options) {
-      this._options = {
-        ...this._options,
-        ...options,
-      }
-    }
-    return this
-  }
-
-  get options() {
-    return this._options
-  }
-
-  abstract build(...params: unknown[]): unknown
-}

package/src/generators/SchemaGenerator.ts

@@ -1,8 +0,0 @@
-import { Generator } from './Generator.ts'
-
-/**
- * Abstract class that contains the building blocks for plugins to create their own SchemaGenerator
- */
-export abstract class SchemaGenerator<TOptions extends object, TInput, TOutput> extends Generator<TOptions> {
-  abstract build(schema: TInput, name: string, description?: string): TOutput
-}

package/src/generators/index.ts

@@ -1,2 +0,0 @@
-export * from './SchemaGenerator.ts'
-export * from './Generator.ts'

package/src/index.ts

@@ -1,12 +0,0 @@
-import { build } from './build.ts'
-
-export * from './config.ts'
-export * from './build.ts'
-export * from './types.ts'
-export { CorePluginOptions, createPlugin, name } from './plugin.ts'
-
-export * from './utils/index.ts'
-export * from './managers/index.ts'
-export * from './generators/index.ts'
-
-export default build

package/src/managers/fileManager/FileManager.ts

@@ -1,127 +0,0 @@
-import crypto from 'node:crypto'
-
-import { read, write } from '../../utils/index.ts'
-
-import type { Queue, QueueTask } from '../../utils/index.ts'
-import type { CacheStore, File, Status, UUID } from './types.ts'
-
-export class FileManager {
-  private cache: Map<CacheStore['id'], CacheStore> = new Map()
-
-  private task?: QueueTask<File>
-
-  private queue?: Queue
-
-  constructor(options?: { queue: Queue; task?: QueueTask<File> }) {
-    if (options) {
-      this.task = options.task
-      this.queue = options.queue
-    }
-  }
-
-  private getCache(id: UUID) {
-    return this.cache.get(id)
-  }
-
-  getCacheByPath(path: string | undefined): CacheStore | undefined {
-    let cache
-
-    this.cache.forEach((item) => {
-      if (item.file.path === path) {
-        cache = item
-      }
-    })
-    return cache as unknown as CacheStore
-  }
-
-  get files() {
-    const files: File[] = []
-    this.cache.forEach((item) => {
-      files.push(item.file)
-    })
-
-    return files
-  }
-
-  get cachedFiles() {
-    const files: CacheStore[] = []
-    this.cache.forEach((item) => {
-      files.push(item)
-    })
-
-    return files
-  }
-
-  async add(file: File) {
-    const cacheItem: CacheStore = { id: crypto.randomUUID(), file, status: 'new' as Status }
-
-    this.cache.set(cacheItem.id, cacheItem)
-
-    if (this.queue) {
-      await this.queue.run(async () => {
-        await this.task?.(cacheItem.id, file)
-      })
-    }
-
-    return file
-  }
-
-  addOrAppend(file: File) {
-    if (!file.path.endsWith(file.fileName)) {
-      // console.warn(`Path ${file.path}(file.path) should end with the fileName ${file.fileName}(file.filename)`)
-    }
-
-    const previousCache = this.getCacheByPath(file.path)
-
-    if (previousCache) {
-      // empty source will also return true when using includes
-      const sourceAlreadyExists = file.source && previousCache.file.source.includes(file.source)
-
-      if (sourceAlreadyExists) {
-        return Promise.resolve(file)
-      }
-
-      this.cache.delete(previousCache.id)
-
-      return this.add({
-        ...file,
-        source: `${previousCache.file.source}\n${file.source}`,
-        imports: [...(previousCache.file.imports || []), ...(file.imports || [])],
-        exports: [...(previousCache.file.exports || []), ...(file.exports || [])],
-      })
-    }
-    return this.add(file)
-  }
-
-  setStatus(id: UUID, status: Status) {
-    const cacheItem = this.getCache(id)
-    if (!cacheItem) {
-      return
-    }
-
-    cacheItem.status = status
-    this.cache.set(id, cacheItem)
-  }
-
-  get(id: UUID) {
-    const cacheItem = this.getCache(id)
-    return cacheItem?.file
-  }
-
-  remove(id: UUID) {
-    const cacheItem = this.getCache(id)
-    if (!cacheItem) {
-      return
-    }
-
-    this.setStatus(id, 'removed')
-  }
-
-  async write(...params: Parameters<typeof write>) {
-    return write(...params)
-  }
-
-  async read(...params: Parameters<typeof read>) {
-    return read(...params)
-  }
-}

package/src/managers/fileManager/index.ts

@@ -1,3 +0,0 @@
-export * from './FileManager.ts'
-export * from './types.ts'
-export * from './utils.ts'

package/src/managers/fileManager/types.ts

@@ -1,40 +0,0 @@
-type Import = {
-  name: string | string[]
-  path: string
-  isTypeOnly?: boolean
-}
-
-type Export = {
-  name?: string | string[]
-  path: string
-  isTypeOnly?: boolean
-  asAlias?: boolean
-}
-
-export type File = {
-  /**
-   * Name to be used to dynamicly create the fileName(based on input.path)
-   */
-  fileName: string
-  /**
-   * Path will be full qualified path to a specified file
-   */
-  path: string
-  source: string
-  imports?: Import[]
-  exports?: Export[]
-  /**
-   * This will call fileManager.add instead of fileManager.addOrAppend, adding the source when the files already exists
-   * @default `false`
-   */
-  override?: boolean
-  meta?: {
-    pluginName?: string
-  }
-}
-
-export type UUID = string
-
-export type CacheStore = { id: UUID; file: File; status: Status }
-
-export type Status = 'new' | 'success' | 'removed'

package/src/managers/fileManager/utils.ts

@@ -1,167 +0,0 @@
-import pathParser from 'node:path'
-
-import { createExportDeclaration, createImportDeclaration, print } from '@kubb/ts-codegen'
-
-import { TreeNode } from '../../utils/index.ts'
-
-import type ts from 'typescript'
-import type { Path } from '../../types.ts'
-import type { PathMode, TreeNodeOptions } from '../../utils/index.ts'
-import type { File } from './types.ts'
-
-type TreeNodeData = { type: PathMode; path: Path; name: string }
-
-export function writeIndexes(root: string, options: TreeNodeOptions = {}): File[] | null {
-  const tree = TreeNode.build<TreeNodeData>(root, { extensions: /\.ts/, ...options })
-
-  if (!tree) {
-    return null
-  }
-
-  const fileReducer = (files: File[], currentTree: typeof tree) => {
-    if (!currentTree.children) {
-      return []
-    }
-
-    if (currentTree.children?.length > 1) {
-      const path = pathParser.resolve(currentTree.data.path, 'index.ts')
-      const exports = currentTree.children
-        .map((file) => {
-          if (!file) {
-            return undefined
-          }
-
-          const importPath: string = file.data.type === 'directory' ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, '')}`
-
-          // TODO weird hacky fix
-          if (importPath.includes('index') && path.includes('index')) {
-            return undefined
-          }
-
-          return { path: importPath }
-        })
-        .filter(Boolean) as File['exports']
-
-      files.push({
-        path,
-        fileName: 'index.ts',
-        source: '',
-        exports,
-      })
-    } else {
-      currentTree.children?.forEach((child) => {
-        const path = pathParser.resolve(currentTree.data.path, 'index.ts')
-        const importPath = child.data.type === 'directory' ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, '')}`
-
-        files.push({
-          path,
-          fileName: 'index.ts',
-          source: '',
-          exports: [{ path: importPath }],
-        })
-      })
-    }
-
-    currentTree.children.forEach((childItem) => {
-      fileReducer(files, childItem)
-    })
-
-    return files
-  }
-
-  const files = fileReducer([], tree)
-
-  return files
-}
-
-export function combineFiles(files: Array<File | null>): File[] {
-  return (files.filter(Boolean) as File[]).reduce((acc, curr: File) => {
-    const prevIndex = acc.findIndex((item) => item.path === curr.path)
-
-    if (prevIndex !== -1) {
-      const prev = acc[prevIndex]
-      acc[prevIndex] = {
-        ...curr,
-        source: prev.source && curr.source ? `${prev.source}\n${curr.source}` : "'",
-        imports: [...(prev.imports || []), ...(curr.imports || [])],
-        exports: [...(prev.exports || []), ...(curr.exports || [])],
-      }
-    } else {
-      acc.push(curr)
-    }
-
-    return acc
-  }, [] as File[])
-}
-
-export function getFileSource(file: File): string {
-  let { source } = file
-
-  // TODO make generic check
-  if (!file.fileName.endsWith('.ts')) {
-    return file.source
-  }
-  const imports: File['imports'] = []
-  const exports: File['exports'] = []
-
-  file.imports?.forEach((curr) => {
-    const existingImport = imports.find((imp) => imp.path === curr.path)
-
-    if (!existingImport) {
-      imports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name,
-      })
-    }
-
-    if (existingImport && !Array.isArray(existingImport.name) && existingImport.name !== curr.name) {
-      imports.push(curr)
-    }
-
-    if (existingImport && Array.isArray(existingImport.name)) {
-      if (Array.isArray(curr.name)) {
-        existingImport.name = [...new Set([...existingImport.name, ...curr.name])]
-      }
-    }
-  })
-
-  file.exports?.forEach((curr) => {
-    const exists = exports.find((imp) => imp.path === curr.path)
-    if (!exists) {
-      exports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name,
-      })
-    }
-
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name && exists.asAlias === curr.asAlias) {
-      exports.push(curr)
-    }
-
-    if (exists && Array.isArray(exists.name)) {
-      if (Array.isArray(curr.name)) {
-        exists.name = [...new Set([...exists.name, ...curr.name])]
-      }
-    }
-  })
-
-  const importNodes = imports.reduce((prev, curr) => {
-    return [...prev, createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })]
-  }, [] as ts.ImportDeclaration[])
-  const importSource = print(importNodes)
-
-  const exportNodes = exports.reduce((prev, curr) => {
-    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly, asAlias: curr.asAlias })]
-  }, [] as ts.ExportDeclaration[])
-  const exportSource = print(exportNodes)
-
-  if (importSource) {
-    source = `${importSource}\n${source}`
-  }
-
-  if (exportSource) {
-    source = `${exportSource}\n${source}`
-  }
-
-  return source
-}

package/src/managers/index.ts

@@ -1,2 +0,0 @@
-export * from './fileManager/index.ts'
-export * from './pluginManager/index.ts'

package/src/managers/pluginManager/ParallelPluginError.ts

@@ -1,15 +0,0 @@
-import type { PluginError } from './PluginError.ts'
-import type { PluginManager } from './PluginManager'
-
-export class ParallelPluginError extends Error {
-  public errors: PluginError[]
-
-  public pluginManager: PluginManager
-
-  constructor(message: string, options: { cause?: Error; errors: PluginError[]; pluginManager: PluginManager }) {
-    super(message, { cause: options.cause })
-
-    this.errors = options.errors
-    this.pluginManager = options.pluginManager
-  }
-}

package/src/managers/pluginManager/PluginError.ts

@@ -1,11 +0,0 @@
-import type { PluginManager } from './PluginManager'
-
-export class PluginError extends Error {
-  public pluginManager: PluginManager
-
-  constructor(message: string, options: { cause?: Error; pluginManager: PluginManager }) {
-    super(message, { cause: options.cause })
-
-    this.pluginManager = options.pluginManager
-  }
-}