@kubb/core 5.0.0-alpha.9 → 5.0.0-beta.1

package/src/utils/FunctionParams.ts

@@ -1,155 +0,0 @@
-import { camelCase } from '@internals/utils'
-// TODO replace with @internals/utils
-import { sortBy } from 'remeda'
-
-type FunctionParamsASTWithoutType = {
-  name?: string
-  type?: string
-  /**
-   * @default true
-   */
-  required?: boolean
-  /**
-   * @default true
-   */
-  enabled?: boolean
-  default?: string
-}
-
-type FunctionParamsASTWithType = {
-  name?: never
-  type: string
-  /**
-   * @default true
-   */
-  required?: boolean
-  /**
-   * @default true
-   */
-  enabled?: boolean
-  default?: string
-}
-/**
- * @deprecated
- */
-export type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType
-
-/**
- * @deprecated
- */
-export class FunctionParams {
-  #items: Array<FunctionParamsAST | FunctionParamsAST[]> = []
-
-  get items(): FunctionParamsAST[] {
-    return this.#items.flat()
-  }
-
-  add(item: FunctionParamsAST | Array<FunctionParamsAST | FunctionParamsAST[] | undefined> | undefined): FunctionParams {
-    if (!item) {
-      return this
-    }
-
-    if (Array.isArray(item)) {
-      item
-        .filter((x): x is FunctionParamsAST | FunctionParamsAST[] => x !== undefined)
-        .forEach((it) => {
-          this.#items.push(it)
-        })
-      return this
-    }
-    this.#items.push(item)
-
-    return this
-  }
-  static #orderItems(items: Array<FunctionParamsAST | FunctionParamsAST[]>) {
-    return sortBy(
-      items.filter(Boolean),
-      [(item) => Array.isArray(item), 'desc'], // arrays (rest params) first
-      [(item) => !Array.isArray(item) && (item as FunctionParamsAST).default !== undefined, 'asc'], // no-default before has-default
-      [(item) => Array.isArray(item) || ((item as FunctionParamsAST).required ?? true), 'desc'], // required before optional
-    )
-  }
-
-  static #addParams(acc: string[], item: FunctionParamsAST) {
-    const { enabled = true, name, type, required = true, ...rest } = item
-
-    if (!enabled) {
-      return acc
-    }
-
-    if (!name) {
-      // when name is not se we uses TypeScript generics
-      acc.push(`${type}${rest.default ? ` = ${rest.default}` : ''}`)
-
-      return acc
-    }
-    // TODO check why we still need the camelcase here
-    const parameterName = name.startsWith('{') ? name : camelCase(name)
-
-    if (type) {
-      if (required) {
-        acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ''}`)
-      } else {
-        acc.push(`${parameterName}?: ${type}`)
-      }
-    } else {
-      acc.push(`${parameterName}`)
-    }
-
-    return acc
-  }
-
-  static toObject(items: FunctionParamsAST[]): FunctionParamsAST {
-    let type: string[] = []
-    let name: string[] = []
-
-    const enabled = items.every((item) => item.enabled) ? items.at(0)?.enabled : true
-    const required = items.every((item) => item.required) ?? true
-
-    items.forEach((item) => {
-      name = FunctionParams.#addParams(name, { ...item, type: undefined })
-      if (items.some((item) => item.type)) {
-        type = FunctionParams.#addParams(type, item)
-      }
-    })
-
-    return {
-      name: `{ ${name.join(', ')} }`,
-      type: type.length ? `{ ${type.join('; ')} }` : undefined,
-      enabled,
-      required,
-    }
-  }
-
-  toObject(): FunctionParamsAST {
-    const items = FunctionParams.#orderItems(this.#items).flat()
-
-    return FunctionParams.toObject(items)
-  }
-
-  static toString(items: (FunctionParamsAST | FunctionParamsAST[])[]): string {
-    const sortedData = FunctionParams.#orderItems(items)
-
-    return sortedData
-      .reduce((acc, item) => {
-        if (Array.isArray(item)) {
-          if (item.length <= 0) {
-            return acc
-          }
-          const subItems = FunctionParams.#orderItems(item) as FunctionParamsAST[]
-          const objectItem = FunctionParams.toObject(subItems)
-
-          return FunctionParams.#addParams(acc, objectItem)
-        }
-
-        return FunctionParams.#addParams(acc, item)
-      }, [] as string[])
-      .join(', ')
-  }
-
-  toString(): string {
-    const items = FunctionParams.#orderItems(this.#items)
-
-    return FunctionParams.toString(items)
-  }
-}

package/src/utils/TreeNode.ts

@@ -1,215 +0,0 @@
-import path from 'node:path'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import { getMode } from '../PluginDriver.ts'
-
-type BarrelData = {
-  file?: KubbFile.File
-  /**
-   * @deprecated use file instead
-   */
-  type: KubbFile.Mode
-  path: string
-  name: string
-}
-
-export class TreeNode {
-  data: BarrelData
-  parent?: TreeNode
-  children: Array<TreeNode> = []
-  #cachedLeaves?: Array<TreeNode> = undefined
-
-  constructor(data: BarrelData, parent?: TreeNode) {
-    this.data = data
-    this.parent = parent
-  }
-
-  addChild(data: BarrelData): TreeNode {
-    const child = new TreeNode(data, this)
-    if (!this.children) {
-      this.children = []
-    }
-    this.children.push(child)
-    return child
-  }
-
-  get root(): TreeNode {
-    if (!this.parent) {
-      return this
-    }
-    return this.parent.root
-  }
-
-  get leaves(): Array<TreeNode> {
-    if (!this.children || this.children.length === 0) {
-      // this is a leaf
-      return [this]
-    }
-
-    if (this.#cachedLeaves) {
-      return this.#cachedLeaves
-    }
-
-    const leaves: TreeNode[] = []
-    for (const child of this.children) {
-      leaves.push(...child.leaves)
-    }
-
-    this.#cachedLeaves = leaves
-
-    return leaves
-  }
-
-  forEach(callback: (treeNode: TreeNode) => void): this {
-    if (typeof callback !== 'function') {
-      throw new TypeError('forEach() callback must be a function')
-    }
-
-    callback(this)
-
-    for (const child of this.children) {
-      child.forEach(callback)
-    }
-
-    return this
-  }
-
-  findDeep(predicate?: (value: TreeNode, index: number, obj: TreeNode[]) => boolean): TreeNode | undefined {
-    if (typeof predicate !== 'function') {
-      throw new TypeError('find() predicate must be a function')
-    }
-
-    return this.leaves.find(predicate)
-  }
-
-  forEachDeep(callback: (treeNode: TreeNode) => void): void {
-    if (typeof callback !== 'function') {
-      throw new TypeError('forEach() callback must be a function')
-    }
-
-    this.leaves.forEach(callback)
-  }
-
-  filterDeep(callback: (treeNode: TreeNode) => boolean): Array<TreeNode> {
-    if (typeof callback !== 'function') {
-      throw new TypeError('filter() callback must be a function')
-    }
-
-    return this.leaves.filter(callback)
-  }
-
-  mapDeep<T>(callback: (treeNode: TreeNode) => T): Array<T> {
-    if (typeof callback !== 'function') {
-      throw new TypeError('map() callback must be a function')
-    }
-
-    return this.leaves.map(callback)
-  }
-
-  public static build(files: KubbFile.File[], root?: string): TreeNode | null {
-    try {
-      const filteredTree = buildDirectoryTree(files, root)
-
-      if (!filteredTree) {
-        return null
-      }
-
-      const treeNode = new TreeNode({
-        name: filteredTree.name,
-        path: filteredTree.path,
-        file: filteredTree.file,
-        type: getMode(filteredTree.path),
-      })
-
-      const recurse = (node: typeof treeNode, item: DirectoryTree) => {
-        const subNode = node.addChild({
-          name: item.name,
-          path: item.path,
-          file: item.file,
-          type: getMode(item.path),
-        })
-
-        if (item.children?.length) {
-          item.children?.forEach((child) => {
-            recurse(subNode, child)
-          })
-        }
-      }
-
-      filteredTree.children?.forEach((child) => {
-        recurse(treeNode, child)
-      })
-
-      return treeNode
-    } catch (error) {
-      throw new Error('Something went wrong with creating barrel files with the TreeNode class', { cause: error })
-    }
-  }
-}
-
-type DirectoryTree = {
-  name: string
-  path: string
-  file?: KubbFile.File
-  children: Array<DirectoryTree>
-}
-
-const normalizePath = (p: string): string => p.replaceAll('\\', '/')
-
-function buildDirectoryTree(files: Array<KubbFile.File>, rootFolder = ''): DirectoryTree | null {
-  const normalizedRootFolder = normalizePath(rootFolder)
-  const rootPrefix = normalizedRootFolder.endsWith('/') ? normalizedRootFolder : `${normalizedRootFolder}/`
-
-  const filteredFiles = files.filter((file) => {
-    const normalizedFilePath = normalizePath(file.path)
-    return rootFolder ? normalizedFilePath.startsWith(rootPrefix) && !normalizedFilePath.endsWith('.json') : !normalizedFilePath.endsWith('.json')
-  })
-
-  if (filteredFiles.length === 0) {
-    return null // No files match the root folder
-  }
-
-  const root: DirectoryTree = {
-    name: rootFolder || '',
-    path: rootFolder || '',
-    children: [],
-  }
-
-  filteredFiles.forEach((file) => {
-    const relativePath = file.path.slice(rootFolder.length)
-    const parts = relativePath.split('/').filter(Boolean)
-    let currentLevel: DirectoryTree[] = root.children
-    let currentPath = normalizePath(rootFolder)
-
-    parts.forEach((part, index) => {
-      currentPath = path.posix.join(currentPath, part)
-
-      let existingNode = currentLevel.find((node) => node.name === part)
-
-      if (!existingNode) {
-        if (index === parts.length - 1) {
-          // If its the last part, its a file
-          existingNode = {
-            name: part,
-            file,
-            path: currentPath,
-          } as DirectoryTree
-        } else {
-          // Otherwise, its a folder
-          existingNode = {
-            name: part,
-            path: currentPath,
-            children: [],
-          } as DirectoryTree
-        }
-        currentLevel.push(existingNode)
-      }
-
-      // Move to the next level if its a folder
-      if (!existingNode.file) {
-        currentLevel = existingNode.children
-      }
-    })
-  })
-
-  return root
-}

package/src/utils/executeStrategies.ts

@@ -1,81 +0,0 @@
-import pLimit from 'p-limit'
-
-type PromiseFunc<T = unknown, T2 = never> = (state?: T) => T2 extends never ? Promise<T> : Promise<T> | T2
-
-type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc<infer X, infer Y>> ? X | Y : never
-
-type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput>>>>
-
-/**
- * Chains promises
- */
-export function hookSeq<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TOutput = SeqOutput<TInput, TValue>>(promises: TInput): TOutput {
-  return promises.filter(Boolean).reduce(
-    (promise, func) => {
-      if (typeof func !== 'function') {
-        throw new Error('HookSeq needs a function that returns a promise `() => Promise<unknown>`')
-      }
-
-      return promise.then((state) => {
-        const calledFunc = func(state as TValue)
-
-        if (calledFunc) {
-          return calledFunc.then(Array.prototype.concat.bind(state) as (result: TValue) => TValue[])
-        }
-
-        return state
-      })
-    },
-    Promise.resolve([] as Array<TValue>),
-  ) as TOutput
-}
-
-type HookFirstOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown> = ValueOfPromiseFuncArray<TInput>
-
-/**
- * Chains promises, first non-null result stops and returns
- */
-export function hookFirst<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookFirstOutput<TInput, TValue>>(
-  promises: TInput,
-  nullCheck: (state: unknown) => boolean = (state) => state !== null,
-): TOutput {
-  let promise: Promise<unknown> = Promise.resolve(null) as Promise<unknown>
-
-  for (const func of promises.filter(Boolean)) {
-    promise = promise.then((state) => {
-      if (nullCheck(state)) {
-        return state
-      }
-
-      return func(state as TValue)
-    })
-  }
-
-  return promise as TOutput
-}
-
-type HookParallelOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>
-
-/**
- * Runs an array of promise functions with optional concurrency limit.
- */
-export function hookParallel<TInput extends Array<PromiseFunc<TValue, null>>, TValue = unknown, TOutput = HookParallelOutput<TInput, TValue>>(
-  promises: TInput,
-  concurrency: number = Number.POSITIVE_INFINITY,
-): TOutput {
-  const limit = pLimit(concurrency)
-
-  const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()))
-
-  return Promise.allSettled(tasks) as TOutput
-}
-
-export type Strategy = 'seq' | 'first' | 'parallel'
-
-export type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc<TValue, null>>, TValue> = TStrategy extends 'first'
-  ? HookFirstOutput<TInput, TValue>
-  : TStrategy extends 'seq'
-    ? SeqOutput<TInput, TValue>
-    : TStrategy extends 'parallel'
-      ? HookParallelOutput<TInput, TValue>
-      : never

package/src/utils/formatters.ts

@@ -1,56 +0,0 @@
-import { x } from 'tinyexec'
-import type { formatters } from '../constants.ts'
-
-type Formatter = keyof typeof formatters
-
-/**
- * Check if a formatter command is available in the system.
- *
- * @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
- * @returns Promise that resolves to true if the formatter is available, false otherwise
- *
- * @remarks
- * This function checks availability by running `<formatter> --version` command.
- * All supported formatters (biome, prettier, oxfmt) implement the --version flag.
- */
-async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
-  try {
-    // Try to get the version of the formatter to check if it's installed
-    await x(formatter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Detect which formatter is available in the system.
- *
- * @returns Promise that resolves to the first available formatter or undefined if none are found
- *
- * @remarks
- * Checks in order of preference: biome, oxfmt, prettier.
- * Uses the `--version` flag to detect if each formatter command is available.
- * This is a reliable method as all supported formatters implement this flag.
- *
- * @example
- * ```typescript
- * const formatter = await detectFormatter()
- * if (formatter) {
- *   console.log(`Using ${formatter} for formatting`)
- * } else {
- *   console.log('No formatter found')
- * }
- * ```
- */
-export async function detectFormatter(): Promise<Formatter | undefined> {
-  const formatterNames = new Set(['biome', 'oxfmt', 'prettier'] as const)
-
-  for (const formatter of formatterNames) {
-    if (await isFormatterAvailable(formatter)) {
-      return formatter
-    }
-  }
-
-  return undefined
-}

package/src/utils/getBarrelFiles.ts

@@ -1,141 +0,0 @@
-/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
-import { join } from 'node:path'
-import { getRelativePath } from '@internals/utils'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import type { BarrelType } from '../types.ts'
-import { TreeNode } from './TreeNode.ts'
-
-export type FileMetaBase = {
-  pluginName?: string
-}
-
-type AddIndexesProps = {
-  type: BarrelType | false | undefined
-  /**
-   * Root based on root and output.path specified in the config
-   */
-  root: string
-  /**
-   * Output for plugin
-   */
-  output: {
-    path: string
-  }
-  group?: {
-    output: string
-    exportAs: string
-  }
-
-  meta?: FileMetaBase
-}
-
-function getBarrelFilesByRoot(root: string | undefined, files: Array<KubbFile.ResolvedFile>): Array<KubbFile.File> {
-  const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
-
-  TreeNode.build(files, root)?.forEach((treeNode) => {
-    if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) {
-      return
-    }
-
-    const barrelFilePath = join(treeNode.parent?.data.path, 'index.ts') as KubbFile.Path
-    const barrelFile: KubbFile.File = {
-      path: barrelFilePath,
-      baseName: 'index.ts',
-      exports: [],
-      imports: [],
-      sources: [],
-    }
-    const previousBarrelFile = cachedFiles.get(barrelFile.path)
-    const leaves = treeNode.leaves
-
-    leaves.forEach((item) => {
-      if (!item.data.name) {
-        return
-      }
-
-      const sources = item.data.file?.sources || []
-
-      sources.forEach((source) => {
-        if (!item.data.file?.path || !source.isIndexable || !source.name) {
-          return
-        }
-        const alreadyContainInPreviousBarrelFile = previousBarrelFile?.sources.some(
-          (item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly,
-        )
-
-        if (alreadyContainInPreviousBarrelFile) {
-          return
-        }
-
-        barrelFile.exports!.push({
-          name: [source.name],
-          path: getRelativePath(treeNode.parent?.data.path, item.data.path),
-          isTypeOnly: source.isTypeOnly,
-        })
-
-        barrelFile.sources.push({
-          name: source.name,
-          isTypeOnly: source.isTypeOnly,
-          //TODO use parser to generate import
-          value: '',
-          isExportable: false,
-          isIndexable: false,
-        })
-      })
-    })
-
-    if (previousBarrelFile) {
-      previousBarrelFile.sources.push(...barrelFile.sources)
-      previousBarrelFile.exports?.push(...(barrelFile.exports || []))
-    } else {
-      cachedFiles.set(barrelFile.path, barrelFile)
-    }
-  })
-
-  return [...cachedFiles.values()]
-}
-
-function trimExtName(text: string): string {
-  const dotIndex = text.lastIndexOf('.')
-  // Only strip when the dot is found and no path separator follows it
-  // (guards against stripping dots that are part of a directory name like /project.v2/gen)
-  if (dotIndex > 0 && !text.includes('/', dotIndex)) {
-    return text.slice(0, dotIndex)
-  }
-  return text
-}
-
-export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type, meta = {}, root, output }: AddIndexesProps): Promise<Array<KubbFile.File>> {
-  if (!type || type === 'propagate') {
-    return []
-  }
-
-  const pathToBuildFrom = join(root, output.path)
-
-  if (trimExtName(pathToBuildFrom).endsWith('index')) {
-    return []
-  }
-
-  const barrelFiles = getBarrelFilesByRoot(pathToBuildFrom, files)
-
-  if (type === 'all') {
-    return barrelFiles.map((file) => {
-      return {
-        ...file,
-        exports: file.exports?.map((exportItem) => {
-          return {
-            ...exportItem,
-            name: undefined,
-          }
-        }),
-      }
-    })
-  }
-
-  return barrelFiles.map((indexFile) => {
-    return {
-      ...indexFile,
-      meta,
-    }
-  })
-}

package/src/utils/getConfigs.ts

@@ -1,12 +0,0 @@
-import type { CLIOptions, ConfigInput } from '../config.ts'
-import type { Config, UserConfig } from '../types.ts'
-
-/**
- * Converting UserConfig to Config Array without a change in the object beside the JSON convert.
- */
-export async function getConfigs(config: ConfigInput | UserConfig, args: CLIOptions): Promise<Array<Config>> {
-  const resolved = await (typeof config === 'function' ? config(args as CLIOptions) : config)
-  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
-
-  return userConfigs.map((item) => ({ ...item }) as Config)
-}

package/src/utils/linters.ts

@@ -1,25 +0,0 @@
-import { x } from 'tinyexec'
-import type { linters } from '../constants.ts'
-
-type Linter = keyof typeof linters
-
-async function isLinterAvailable(linter: Linter): Promise<boolean> {
-  try {
-    await x(linter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function detectLinter(): Promise<Linter | undefined> {
-  const linterNames = new Set(['biome', 'oxlint', 'eslint'] as const)
-
-  for (const linter of linterNames) {
-    if (await isLinterAvailable(linter)) {
-      return linter
-    }
-  }
-
-  return undefined
-}