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

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,30 +0,0 @@
-import type { CLIOptions, ConfigInput } from '../config.ts'
-import type { Config, UserConfig } from '../types.ts'
-import { getPlugins } from './getPlugins.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 resolvedConfig: Promise<UserConfig | Array<UserConfig>> =
-    typeof config === 'function' ? Promise.resolve(config(args as CLIOptions)) : Promise.resolve(config)
-
-  let userConfigs = await resolvedConfig
-
-  if (!Array.isArray(userConfigs)) {
-    userConfigs = [userConfigs]
-  }
-
-  const results: Array<Config> = []
-
-  for (const item of userConfigs) {
-    const plugins = item.plugins ? await getPlugins(item.plugins) : undefined
-
-    results.push({
-      ...item,
-      plugins,
-    } as Config)
-  }
-
-  return results
-}

package/src/utils/getPlugins.ts

@@ -1,23 +0,0 @@
-import type { UnknownUserPlugin, UserConfig } from '../types.ts'
-
-type PluginsArray = Array<Omit<UnknownUserPlugin, 'inject'>>
-
-function isJSONPlugins(plugins: UserConfig['plugins']): boolean {
-  return Array.isArray(plugins) && plugins.some((plugin) => Array.isArray(plugin) && typeof (plugin as unknown[])[0] === 'string')
-}
-
-function isObjectPlugins(plugins: UserConfig['plugins']): boolean {
-  return plugins instanceof Object && !Array.isArray(plugins)
-}
-
-export function getPlugins(plugins: UserConfig['plugins']): Promise<PluginsArray | undefined> {
-  if (isObjectPlugins(plugins)) {
-    throw new Error('Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')
-  }
-
-  if (isJSONPlugins(plugins)) {
-    throw new Error('JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')
-  }
-
-  return Promise.resolve(plugins)
-}

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: Linter[] = ['biome', 'oxlint', 'eslint']
-
-  for (const linter of linterNames) {
-    if (await isLinterAvailable(linter)) {
-      return linter
-    }
-  }
-
-  return undefined
-}

package/src/utils/resolveOptions.ts

@@ -1,93 +0,0 @@
-import { isOperationNode, isSchemaNode } from '@kubb/ast'
-import type { Node, OperationNode, SchemaNode } from '@kubb/ast/types'
-
-type FilterItem = {
-  type: string
-  pattern: string | RegExp
-}
-
-type OverrideItem<TOptions> = FilterItem & {
-  options: Omit<Partial<TOptions>, 'override'>
-}
-
-type ResolveOptionsContext<TOptions> = {
-  options: TOptions
-  exclude?: Array<FilterItem>
-  include?: Array<FilterItem>
-  override?: Array<OverrideItem<TOptions>>
-}
-
-function matchesOperationPattern(node: OperationNode, type: string, pattern: string | RegExp): boolean {
-  switch (type) {
-    case 'tag':
-      return node.tags.some((tag) => !!tag.match(pattern))
-    case 'operationId':
-      return !!node.operationId.match(pattern)
-    case 'path':
-      return !!node.path.match(pattern)
-    case 'method':
-      return !!(node.method.toLowerCase() as string).match(pattern)
-    default:
-      return false
-  }
-}
-
-function matchesSchemaPattern(node: SchemaNode, type: string, pattern: string | RegExp): boolean | null {
-  switch (type) {
-    case 'schemaName':
-      return node.name ? !!node.name.match(pattern) : false
-    default:
-      return null
-  }
-}
-
-/**
- * Resolves the effective plugin options for a given AST node by applying
- * `exclude`, `include`, and `override` rules from the plugin configuration.
- *
- * Returns `null` when the node is excluded or not matched by `include`.
- * Returns the merged options (base options merged with any matching `override`) otherwise.
- *
- * Supported filter types for `OperationNode`: `tag`, `operationId`, `path`, `method`.
- * Supported filter types for `SchemaNode`: `schemaName`.
- *
- * @example
- * const resolved = resolveOptions(operationNode, { options, exclude, include, override })
- * if (!resolved) return // excluded
- */
-export function resolveOptions<TOptions>(node: Node, { options, exclude = [], include, override = [] }: ResolveOptionsContext<TOptions>): TOptions | null {
-  if (isOperationNode(node)) {
-    const isExcluded = exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))
-    if (isExcluded) {
-      return null
-    }
-
-    if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) {
-      return null
-    }
-
-    const overrideOptions = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))?.options
-
-    return { ...options, ...overrideOptions }
-  }
-
-  if (isSchemaNode(node)) {
-    if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) {
-      return null
-    }
-
-    if (include) {
-      const results = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern))
-      const applicable = results.filter((r) => r !== null)
-      if (applicable.length > 0 && !applicable.includes(true)) {
-        return null
-      }
-    }
-
-    const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options
-
-    return { ...options, ...overrideOptions }
-  }
-
-  return options
-}