@kubb/core 5.0.0-alpha.36 → 5.0.0-alpha.39

package/dist/hooks.d.ts

@@ -1,23 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { N as PluginFactoryOptions, j as Plugin, t as PluginDriver } from "./PluginDriver-C9iBgYbk.js";
-
-//#region src/hooks/useDriver.d.ts
-/**
- * @deprecated use `driver` from the generator component props instead
- */
-declare function useDriver(): PluginDriver;
-//#endregion
-//#region src/hooks/useMode.d.ts
-/**
- * @deprecated use `mode` from the generator component props instead
- */
-declare function useMode(): 'single' | 'split';
-//#endregion
-//#region src/hooks/usePlugin.d.ts
-/**
- * @deprecated use `plugin` from the generator component props instead
- */
-declare function usePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(): Plugin<TOptions>;
-//#endregion
-export { useDriver, useMode, usePlugin };
-//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.js

@@ -1,29 +0,0 @@
-import "./chunk--u3MIqq1.js";
-import { KubbContext, inject } from "@kubb/renderer-jsx";
-//#region src/hooks/useDriver.ts
-/**
-* @deprecated use `driver` from the generator component props instead
-*/
-function useDriver() {
-	return inject(KubbContext).driver;
-}
-//#endregion
-//#region src/hooks/useMode.ts
-/**
-* @deprecated use `mode` from the generator component props instead
-*/
-function useMode() {
-	return inject(KubbContext).mode;
-}
-//#endregion
-//#region src/hooks/usePlugin.ts
-/**
-* @deprecated use `plugin` from the generator component props instead
-*/
-function usePlugin() {
-	return inject(KubbContext).plugin;
-}
-//#endregion
-export { useDriver, useMode, usePlugin };
-
-//# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.js","names":[],"sources":["../src/hooks/useDriver.ts","../src/hooks/useMode.ts","../src/hooks/usePlugin.ts"],"sourcesContent":["import { inject, KubbContext } from '@kubb/renderer-jsx'\nimport type { PluginDriver } from '../PluginDriver.ts'\n\n/**\n * @deprecated use `driver` from the generator component props instead\n */\nexport function useDriver(): PluginDriver {\n  return inject(KubbContext)!.driver as PluginDriver\n}\n","import { inject, KubbContext } from '@kubb/renderer-jsx'\n\n/**\n * @deprecated use `mode` from the generator component props instead\n */\nexport function useMode(): 'single' | 'split' {\n  return inject(KubbContext)!.mode\n}\n","import { inject, KubbContext } from '@kubb/renderer-jsx'\nimport type { Plugin, PluginFactoryOptions } from '../types.ts'\n\n/**\n * @deprecated use `plugin` from the generator component props instead\n */\nexport function usePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(): Plugin<TOptions> {\n  return inject(KubbContext)!.plugin as Plugin<TOptions>\n}\n"],"mappings":";;;;;;AAMA,SAAgB,YAA0B;AACxC,QAAO,OAAO,YAAY,CAAE;;;;;;;ACF9B,SAAgB,UAA8B;AAC5C,QAAO,OAAO,YAAY,CAAE;;;;;;;ACA9B,SAAgB,YAA4F;AAC1G,QAAO,OAAO,YAAY,CAAE"}

package/src/hooks/index.ts

@@ -1,3 +0,0 @@
-export { useDriver } from './useDriver.ts'
-export { useMode } from './useMode.ts'
-export { usePlugin } from './usePlugin.ts'

package/src/hooks/useDriver.ts

@@ -1,9 +0,0 @@
-import { inject, KubbContext } from '@kubb/renderer-jsx'
-import type { PluginDriver } from '../PluginDriver.ts'
-
-/**
- * @deprecated use `driver` from the generator component props instead
- */
-export function useDriver(): PluginDriver {
-  return inject(KubbContext)!.driver as PluginDriver
-}

package/src/hooks/useMode.ts

@@ -1,8 +0,0 @@
-import { inject, KubbContext } from '@kubb/renderer-jsx'
-
-/**
- * @deprecated use `mode` from the generator component props instead
- */
-export function useMode(): 'single' | 'split' {
-  return inject(KubbContext)!.mode
-}

package/src/hooks/usePlugin.ts

@@ -1,9 +0,0 @@
-import { inject, KubbContext } from '@kubb/renderer-jsx'
-import type { Plugin, PluginFactoryOptions } from '../types.ts'
-
-/**
- * @deprecated use `plugin` from the generator component props instead
- */
-export function usePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(): Plugin<TOptions> {
-  return inject(KubbContext)!.plugin as Plugin<TOptions>
-}

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 use ast package instead
- */
-export type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType
-
-/**
- * @deprecated use ast package instead
- */
-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/formatters.ts

@@ -1,45 +0,0 @@
-import { x } from 'tinyexec'
-import type { formatters } from '../constants.ts'
-
-type Formatter = keyof typeof formatters
-
-/**
- * Returns `true` when the given formatter is installed and callable.
- *
- * Availability is detected by running `<formatter> --version` and checking
- * that the process exits without error.
- */
-async function isFormatterAvailable(formatter: Formatter): Promise<boolean> {
-  try {
-    await x(formatter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Detects the first available code formatter on the current system.
- *
- * - Checks in preference order: `biome`, `oxfmt`, `prettier`.
- * - Returns `null` when none are found.
- *
- * @example
- * ```ts
- * const formatter = await detectFormatter()
- * if (formatter) {
- *   console.log(`Using ${formatter} for formatting`)
- * }
- * ```
- */
-export async function detectFormatter(): Promise<Formatter | null> {
-  const formatterNames = new Set(['biome', 'oxfmt', 'prettier'] as const)
-
-  for (const formatter of formatterNames) {
-    if (await isFormatterAvailable(formatter)) {
-      return formatter
-    }
-  }
-
-  return null
-}

package/src/utils/getFunctionParams.ts

@@ -1,254 +0,0 @@
-import { sortBy } from 'remeda'
-
-export type Param = {
-  /**
-   * Controls how path parameters are emitted in the function signature.
-   * - `'object'` groups them as a single destructured parameter.
-   * - `'inline'` spreads them as individual comma-separated parameters.
-   * - `'inlineSpread'` emits a single rest parameter.
-   *
-   * @default 'inline'
-   * @internal
-   */
-  mode?: 'object' | 'inline' | 'inlineSpread'
-  type?: 'string' | 'number' | (string & {})
-  optional?: boolean
-  /**
-   * Default value expression for the parameter.
-   *
-   * @example Assignment syntax
-   * `test = "default"`
-   */
-  default?: string
-  /**
-   * Used for no TypeScript (with mode object).
-   *
-   * @example Value syntax
-   * `test: "default"`
-   */
-  value?: string
-  children?: Params
-}
-
-type ParamItem =
-  | (Pick<Param, 'mode' | 'type' | 'value'> & {
-      optional?: true
-      default?: never
-      children?: Params
-    })
-  | (Pick<Param, 'mode' | 'type' | 'value'> & {
-      optional?: false
-      default?: string
-      children?: Params
-    })
-
-export type Params = Record<string, Param | undefined>
-
-type Options = {
-  type: 'constructor' | 'call' | 'object' | 'objectValue'
-  transformName?: (name: string) => string
-  transformType?: (type: string) => string
-}
-
-function order(items: Array<[key: string, item?: ParamItem]>) {
-  return sortBy(items.filter(Boolean) as Array<[key: string, item?: ParamItem]>, ([_key, item]) => {
-    if (item?.children) {
-      return 0 // Treat items with children as required (they'll get = {} if all children are optional)
-    }
-    // Priority order: required (0) → optional (1) → default-only (2)
-    if (item?.optional) {
-      return 1 // Optional parameters (with or without default)
-    }
-    if (item?.default) {
-      // Parameters with default only (not marked as optional)
-      // Note: While the ParamItem type suggests optional and default are mutually exclusive,
-      // this handles the case where a parameter has a default value but isn't explicitly marked as optional
-      return 2
-    }
-    return 0 // Required parameters
-  })
-}
-
-function parseChild(key: string, item: ParamItem, options: Options): string | null {
-  // @ts-expect-error
-  const entries = order(Object.entries(item.children))
-
-  const types: string[] = []
-  const names: string[] = []
-
-  const optional = entries.every(([_key, item]) => item?.optional || !!item?.default)
-
-  entries.forEach(([key, entryItem]) => {
-    if (entryItem) {
-      const name = parseItem(key, { ...entryItem, type: undefined }, options)
-      if (entryItem.children) {
-        const subTypes = Object.entries(entryItem.children)
-          .map(([key]) => {
-            return key
-          })
-          .join(', ')
-
-        if (subTypes) {
-          names.push(`${name}: { ${subTypes} }`)
-        } else {
-          names.push(name)
-        }
-      } else {
-        if (options.type === 'call' && options.transformName) {
-          names.push(`${key}: ${name}`)
-        } else {
-          names.push(name)
-        }
-      }
-
-      if (entries.some(([_key, item]) => item?.type)) {
-        types.push(parseItem(key, { ...entryItem, default: undefined }, options))
-      }
-    }
-  })
-
-  const name = item.mode === 'inline' ? key : names.length ? `{ ${names.join(', ')} }` : undefined
-  const type = item.type ? item.type : types.length ? `{ ${types.join('; ')} }` : undefined
-
-  if (!name) {
-    return null
-  }
-
-  return parseItem(
-    name,
-    {
-      type,
-      default: item.default,
-      optional: !item.default ? optional : undefined,
-    } as ParamItem,
-    options,
-  )
-}
-
-function parseItem(name: string, item: ParamItem, options: Options): string {
-  const acc: string[] = []
-  const transformedName = options.transformName ? options.transformName(name) : name
-  const transformedType = options.transformType && item.type ? options.transformType(item.type) : item.type
-
-  if (options.type === 'object') {
-    return transformedName
-  }
-
-  if (options.type === 'objectValue') {
-    return item.value ? `${transformedName}: ${item.value}` : transformedName
-  }
-
-  //LEGACY
-  if (item.type && options.type === 'constructor') {
-    if (item.optional) {
-      // Check if this is a destructured parameter (object mode)
-      const isDestructured = transformedName.startsWith('{')
-      if (isDestructured) {
-        // For destructured parameters, use ": type = {}" syntax to make it optional
-        acc.push(`${transformedName}: ${transformedType} = {}`)
-      } else {
-        // For inline parameters, use "?: type" syntax
-        acc.push(`${transformedName}?: ${transformedType}`)
-      }
-    } else {
-      acc.push(`${transformedName}: ${transformedType}${item.default ? ` = ${item.default}` : ''}`)
-    }
-  } else if (item.default && options.type === 'constructor') {
-    acc.push(`${transformedName} = ${item.default}`)
-  } else if (item.value) {
-    acc.push(`${transformedName} : ${item.value}`)
-  } else if (item.mode === 'inlineSpread') {
-    acc.push(`... ${transformedName}`)
-  } else {
-    acc.push(transformedName)
-  }
-
-  return acc[0] as string
-}
-
-export function getFunctionParams(params: Params, options: Options): string {
-  const entries = order(Object.entries(params as Record<string, ParamItem | undefined>))
-
-  return entries
-    .reduce((acc, [key, item]) => {
-      if (!item) {
-        return acc
-      }
-
-      if (item.children) {
-        if (Object.keys(item.children).length === 0) {
-          return acc
-        }
-
-        if (item.mode === 'inlineSpread') {
-          return [...acc, getFunctionParams(item.children, options)]
-        }
-
-        const parsedItem = parseChild(key, item, options)
-        if (!parsedItem) {
-          return acc
-        }
-
-        return [...acc, parsedItem]
-      }
-
-      const parsedItem = parseItem(key, item, options)
-
-      return [...acc, parsedItem]
-    }, [] as string[])
-    .join(', ')
-}
-
-/**
- * @deprecated use @kubb/ast
- */
-export function createFunctionParams(params: Params): Params {
-  return params
-}
-
-/**
- * @deprecated use @kubb/ast
- */
-export class FunctionParams {
-  #params: Params
-
-  static factory(params: Params) {
-    return new FunctionParams(params)
-  }
-  constructor(params: Params) {
-    this.#params = params
-  }
-
-  get params(): Params {
-    return this.#params
-  }
-
-  get flatParams(): Params {
-    const flatter = (acc: Params, [key, item]: [key: string, item?: Param]): Params => {
-      if (item?.children) {
-        return Object.entries(item.children).reduce(flatter, acc)
-      }
-      if (item) {
-        acc[key] = item
-      }
-
-      return acc
-    }
-    return Object.entries(this.#params).reduce(flatter, {} as Params)
-  }
-
-  toCall({ transformName, transformType }: Pick<Options, 'transformName' | 'transformType'> = {}): string {
-    return getFunctionParams(this.#params, { type: 'call', transformName, transformType })
-  }
-
-  toObject(): string {
-    return getFunctionParams(this.#params, { type: 'object' })
-  }
-  toObjectValue(): string {
-    return getFunctionParams(this.#params, { type: 'objectValue' })
-  }
-
-  toConstructor(): string {
-    return getFunctionParams(this.#params, { type: 'constructor' })
-  }
-}

package/src/utils/linters.ts

@@ -1,45 +0,0 @@
-import { x } from 'tinyexec'
-import type { linters } from '../constants.ts'
-
-type Linter = keyof typeof linters
-
-/**
- * Returns `true` when the given linter is installed and callable.
- *
- * Availability is detected by running `<linter> --version` and checking
- * that the process exits without error.
- */
-async function isLinterAvailable(linter: Linter): Promise<boolean> {
-  try {
-    await x(linter, ['--version'], { nodeOptions: { stdio: 'ignore' } })
-    return true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Detects the first available linter on the current system.
- *
- * - Checks in preference order: `biome`, `oxlint`, `eslint`.
- * - Returns `null` when none are found.
- *
- * @example
- * ```ts
- * const linter = await detectLinter()
- * if (linter) {
- *   console.log(`Using ${linter} for linting`)
- * }
- * ```
- */
-export async function detectLinter(): Promise<Linter | null> {
-  const linterNames = new Set(['biome', 'oxlint', 'eslint'] as const)
-
-  for (const linter of linterNames) {
-    if (await isLinterAvailable(linter)) {
-      return linter
-    }
-  }
-
-  return null
-}