@kubb/core 1.1.10 → 1.1.12

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}\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
-  }
-}

package/src/managers/pluginManager/PluginManager.ts

@@ -1,472 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-types */
-
-import { definePlugin } from '../../plugin.ts'
-import { isPromise } from '../../utils/isPromise.ts'
-import { Queue } from '../../utils/Queue.ts'
-import { FileManager } from '../fileManager/FileManager.ts'
-import { ParallelPluginError } from './ParallelPluginError.ts'
-import { PluginError } from './PluginError.ts'
-
-import type { CorePluginOptions } from '../../plugin.ts'
-import type { KubbConfig, KubbPlugin, MaybePromise, PluginLifecycle, PluginLifecycleHooks, ResolveNameParams, ResolvePathParams } from '../../types.ts'
-import type { QueueTask } from '../../utils/Queue.ts'
-import type { Argument0, Executer, OnExecute, ParseResult, SafeParseResult, Strategy } from './types.ts'
-
-// inspired by: https://github.com/rollup/rollup/blob/master/src/utils/PluginDriver.ts#
-
-// This will make sure no input hook is omitted
-const hookNames: {
-  [P in PluginLifecycleHooks]: 1
-} = {
-  validate: 1,
-  buildStart: 1,
-  resolvePath: 1,
-  resolveName: 1,
-  load: 1,
-  transform: 1,
-  writeFile: 1,
-  buildEnd: 1,
-}
-export const hooks = Object.keys(hookNames) as [PluginLifecycleHooks]
-
-type Options = { task: QueueTask; onExecute?: OnExecute<PluginLifecycleHooks> }
-
-export class PluginManager {
-  public plugins: KubbPlugin[]
-
-  public readonly fileManager: FileManager
-
-  private readonly onExecute?: OnExecute
-
-  private readonly core: KubbPlugin<CorePluginOptions>
-
-  public queue: Queue
-
-  public executer: Executer | undefined
-
-  public executed: Executer[] = []
-
-  constructor(config: KubbConfig, options: Options) {
-    this.onExecute = options.onExecute
-    this.queue = new Queue(10)
-
-    this.fileManager = new FileManager({ task: options.task, queue: this.queue })
-    this.core = definePlugin({
-      config,
-      fileManager: this.fileManager,
-      load: this.load,
-      resolvePath: this.resolvePath,
-      resolveName: this.resolveName,
-      getExecuter: this.getExecuter.bind(this),
-    }) as KubbPlugin<CorePluginOptions> & {
-      api: CorePluginOptions['api']
-    }
-    this.plugins = [this.core, ...(config.plugins || [])]
-  }
-
-  getExecuter() {
-    return this.executer
-  }
-
-  resolvePath = (params: ResolvePathParams) => {
-    if (params.pluginName) {
-      return this.hookForPluginSync({
-        pluginName: params.pluginName,
-        hookName: 'resolvePath',
-        parameters: [params.fileName, params.directory, params.options],
-      })
-    }
-    return this.hookFirstSync({
-      hookName: 'resolvePath',
-      parameters: [params.fileName, params.directory, params.options],
-    }).result
-  }
-
-  resolveName = (params: ResolveNameParams) => {
-    if (params.pluginName) {
-      return this.hookForPluginSync({
-        pluginName: params.pluginName,
-        hookName: 'resolveName',
-        parameters: [params.name],
-      })
-    }
-    return this.hookFirstSync({
-      hookName: 'resolveName',
-      parameters: [params.name],
-    }).result
-  }
-
-  load = async (id: string) => {
-    return this.hookFirst({
-      hookName: 'load',
-      parameters: [id],
-    })
-  }
-
-  /**
-   *
-   * Run only hook for a specific plugin name
-   */
-  hookForPlugin<H extends PluginLifecycleHooks>({
-    pluginName,
-    hookName,
-    parameters,
-  }: {
-    pluginName: string
-    hookName: H
-    parameters: Parameters<PluginLifecycle[H]>
-  }): Promise<ReturnType<ParseResult<H>> | null> | null {
-    const plugin = this.getPlugin(hookName, pluginName)
-
-    return this.execute({
-      strategy: 'hookFirst',
-      hookName,
-      parameters,
-      plugin,
-    })
-  }
-
-  hookForPluginSync<H extends PluginLifecycleHooks>({
-    pluginName,
-    hookName,
-    parameters,
-  }: {
-    pluginName: string
-    hookName: H
-    parameters: Parameters<PluginLifecycle[H]>
-  }): ReturnType<ParseResult<H>> | null {
-    const plugin = this.getPlugin(hookName, pluginName)
-
-    return this.executeSync({
-      strategy: 'hookFirst',
-      hookName,
-      parameters,
-      plugin,
-    })
-  }
-
-  /**
-   *
-   * Chains, first non-null result stops and returns
-   */
-  hookFirst<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    skipped,
-  }: {
-    hookName: H
-    parameters: Parameters<PluginLifecycle[H]>
-    skipped?: ReadonlySet<KubbPlugin> | null
-  }): Promise<SafeParseResult<H>> {
-    let promise: Promise<SafeParseResult<H>> = Promise.resolve(null as unknown as SafeParseResult<H>)
-
-    for (const plugin of this.getSortedPlugins(hookName)) {
-      if (skipped && skipped.has(plugin)) {
-        continue
-      }
-      promise = promise.then(async (parseResult) => {
-        if (parseResult?.result != null) {
-          return parseResult
-        }
-        const value = await this.execute<H>({
-          strategy: 'hookFirst',
-          hookName,
-          parameters,
-          plugin,
-        })
-
-        return Promise.resolve({
-          plugin,
-          result: value,
-        } as typeof parseResult)
-      })
-    }
-
-    return promise
-  }
-
-  /**
-   *
-   * Chains, first non-null result stops and returns
-   */
-  hookFirstSync<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    skipped,
-  }: {
-    hookName: H
-    parameters: Parameters<PluginLifecycle[H]>
-    skipped?: ReadonlySet<KubbPlugin> | null
-  }): SafeParseResult<H> {
-    let parseResult: SafeParseResult<H> = null as unknown as SafeParseResult<H>
-
-    for (const plugin of this.getSortedPlugins(hookName)) {
-      if (skipped && skipped.has(plugin)) {
-        continue
-      }
-
-      parseResult = {
-        result: this.executeSync<H>({
-          strategy: 'hookFirst',
-          hookName,
-          parameters,
-          plugin,
-        }),
-        plugin,
-      } as SafeParseResult<H>
-
-      if (parseResult?.result != null) {
-        break
-      }
-    }
-    return parseResult
-  }
-
-  /**
-   *
-   * Parallel, runs all plugins
-   */
-  async hookParallel<H extends PluginLifecycleHooks, TOuput = void>({
-    hookName,
-    parameters,
-  }: {
-    hookName: H
-    parameters?: Parameters<PluginLifecycle[H]> | undefined
-  }): Promise<Awaited<TOuput>[]> {
-    const parallelPromises: Promise<TOuput>[] = []
-
-    for (const plugin of this.getSortedPlugins(hookName)) {
-      // TODO implement sequential with `buildStart` as an object({ sequential: boolean; handler: PluginContext["buildStart"] })
-      // if ((plugin[hookName] as { sequential?: boolean })?.sequential) {
-      //   await Promise.all(parallelPromises)
-      //   parallelPromises.length = 0
-      //   await this.execute({
-      //     strategy: 'hookParallel',
-      //     hookName,
-      //     parameters,
-      //     plugin,
-      //   })
-      // }
-      const promise: Promise<TOuput> | null = this.execute({ strategy: 'hookParallel', hookName, parameters, plugin })
-
-      if (promise) {
-        parallelPromises.push(promise)
-      }
-    }
-    const results = await Promise.allSettled(parallelPromises)
-    const errors = results.filter((result) => result.status === 'rejected').map((result) => (result as PromiseRejectedResult).reason) as PluginError[]
-
-    if (errors.length) {
-      throw new ParallelPluginError('Error', { errors, pluginManager: this })
-    }
-
-    return results.filter((result) => result.status === 'fulfilled').map((result) => (result as PromiseFulfilledResult<Awaited<TOuput>>).value)
-  }
-
-  /**
-   *
-   * Chains, reduces returned value, handling the reduced value as the first hook argument
-   */
-  hookReduceArg0<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    reduce,
-  }: {
-    hookName: H
-    parameters: Parameters<PluginLifecycle[H]>
-    reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>
-  }): Promise<Argument0<H>> {
-    const [argument0, ...rest] = parameters
-
-    let promise: Promise<Argument0<H>> = Promise.resolve(argument0)
-    for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise
-        .then((arg0) => {
-          const value = this.execute({
-            strategy: 'hookReduceArg0',
-            hookName,
-            parameters: [arg0, ...rest] as Parameters<PluginLifecycle[H]>,
-            plugin,
-          })
-          return value
-        })
-        .then((result) => reduce.call(this.core.api, argument0, result as ReturnType<ParseResult<H>>, plugin)) as Promise<Argument0<H>>
-    }
-    return promise
-  }
-
-  /**
-   * Chains plugins
-   */
-  hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: { hookName: H; parameters?: Parameters<PluginLifecycle[H]> }) {
-    let promise: Promise<void | null> = Promise.resolve()
-    for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then(() =>
-        this.execute({
-          strategy: 'hookSeq',
-          hookName,
-          parameters,
-          plugin,
-        })
-      )
-    }
-    return promise.then(noReturn)
-  }
-
-  private getSortedPlugins(_hookName: keyof PluginLifecycle): KubbPlugin[] {
-    const plugins = [...this.plugins].filter((plugin) => plugin.name !== 'core')
-
-    return plugins
-  }
-
-  public getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin {
-    const plugins = [...this.plugins]
-
-    const pluginByPluginName = plugins.find((item) => item.name === pluginName && item[hookName])
-    if (!pluginByPluginName) {
-      // fallback on the core plugin when there is no match
-
-      return this.core
-    }
-    return pluginByPluginName
-  }
-
-  private addExecuter(executer: Executer | undefined) {
-    this.onExecute?.call(this, executer)
-
-    if (executer) {
-      this.executed.push(executer)
-    }
-  }
-
-  /**
-   * Run an async plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The actual pluginObject to run.
-   */
-  // Implementation signature
-  private execute<H extends PluginLifecycleHooks, TResult = void>({
-    strategy,
-    hookName,
-    parameters,
-    plugin,
-  }: {
-    strategy: Strategy
-    hookName: H
-    parameters: unknown[] | undefined
-    plugin: KubbPlugin
-  }): Promise<TResult> | null {
-    const hook = plugin[hookName]
-
-    if (!hook) {
-      return null
-    }
-
-    return Promise.resolve()
-      .then(() => {
-        // add current execution to the variable `this.executer` so we can track which plugin is getting called
-        this.executer = {
-          strategy,
-          hookName,
-          plugin,
-        }
-
-        if (typeof hook === 'function') {
-          const hookResult = (hook as Function).apply(this.core.api, parameters) as TResult
-
-          if (isPromise(hookResult)) {
-            return Promise.resolve(hookResult).then((result: TResult) => {
-              this.addExecuter({
-                strategy,
-                hookName,
-                plugin,
-              })
-
-              return result
-            })
-          }
-
-          return hookResult
-        }
-
-        this.addExecuter({
-          strategy,
-          hookName,
-          plugin,
-        })
-
-        return hook
-      })
-      .catch((e: Error) => {
-        this.catcher<H>(e, plugin, hookName)
-      }) as Promise<TResult>
-  }
-
-  /**
-   * Run a sync plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The acutal plugin
-   * @param replaceContext When passed, the plugin context can be overridden.
-   */
-  private executeSync<H extends PluginLifecycleHooks>({
-    strategy,
-    hookName,
-    parameters,
-    plugin,
-  }: {
-    strategy: Strategy
-    hookName: H
-    parameters: Parameters<PluginLifecycle[H]>
-    plugin: KubbPlugin
-  }): ReturnType<ParseResult<H>> | null {
-    const hook = plugin[hookName]
-
-    if (!hook) {
-      return null
-    }
-
-    try {
-      // add current execution to the variable `this.executer` so we can track which plugin is getting called
-      this.executer = {
-        strategy,
-        hookName,
-        plugin,
-      }
-
-      if (typeof hook === 'function') {
-        const fn = (hook as Function).apply(this.core.api, parameters) as ReturnType<ParseResult<H>>
-
-        this.addExecuter({
-          strategy,
-          hookName,
-          plugin,
-        })
-
-        return fn
-      }
-
-      this.addExecuter({
-        strategy,
-        hookName,
-        plugin,
-      })
-
-      return hook
-    } catch (e) {
-      this.catcher<H>(e as Error, plugin, hookName)
-
-      return null as ReturnType<ParseResult<H>>
-    }
-  }
-
-  private catcher<H extends PluginLifecycleHooks>(e: Error, plugin: KubbPlugin, hookName: H) {
-    const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})\n`
-
-    throw new PluginError(text, { cause: e, pluginManager: this })
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-function noReturn() {}