@kubb/core 5.0.0-beta.10 → 5.0.0-beta.100

package/src/devtools.ts

@@ -1,66 +0,0 @@
-import type { InputNode } from '@kubb/ast'
-import { deflateSync, inflateSync } from 'fflate'
-import { x } from 'tinyexec'
-
-export type DevtoolsOptions = {
-  /**
-   * Open the AST inspector in Kubb Studio (`/ast`). Defaults to the main Studio page.
-   * @default false
-   */
-  ast?: boolean
-}
-
-/**
- * Encodes an `InputNode` as a compressed, URL-safe string.
- *
- * The JSON representation is deflate-compressed with {@link deflateSync} before
- * base64url encoding, which typically reduces payload size by 70–80 % and
- * keeps URLs well within browser and server path-length limits.
- *
- * Use {@link decodeAst} to reverse.
- */
-export function encodeAst(input: InputNode): string {
-  const compressed = deflateSync(new TextEncoder().encode(JSON.stringify(input)))
-  return Buffer.from(compressed).toString('base64url')
-}
-
-/**
- * Decodes an `InputNode` from a string produced by {@link encodeAst}.
- *
- * Works in both Node.js and the browser — no streaming APIs required.
- */
-export function decodeAst(encoded: string): InputNode {
-  const bytes = Buffer.from(encoded, 'base64url')
-  return JSON.parse(new TextDecoder().decode(inflateSync(bytes))) as InputNode
-}
-
-/**
- * Constructs the Kubb Studio URL for the given `InputNode`.
- * When `options.ast` is `true`, navigates to the AST inspector (`/ast`).
- * The `input` is encoded and attached as the `?root=` query parameter so Studio
- * can decode and render it without a round-trip to any server.
- */
-export function getStudioUrl(input: InputNode, studioUrl: string, options: DevtoolsOptions = {}): string {
-  const baseUrl = studioUrl.replace(/\/$/, '')
-  const path = options.ast ? '/ast' : ''
-
-  return `${baseUrl}${path}?root=${encodeAst(input)}`
-}
-
-/**
- * Opens the Kubb Studio URL for the given `InputNode` in the default browser —
- *
- * Falls back to printing the URL if the browser cannot be launched.
- */
-export async function openInStudio(input: InputNode, studioUrl: string, options: DevtoolsOptions = {}): Promise<void> {
-  const url = getStudioUrl(input, studioUrl, options)
-
-  const cmd = process.platform === 'win32' ? 'cmd' : process.platform === 'darwin' ? 'open' : 'xdg-open'
-  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url]
-
-  try {
-    await x(cmd, args)
-  } catch {
-    console.log(`\n  ${url}\n`)
-  }
-}

package/src/index.ts

@@ -1,20 +0,0 @@
-export { AsyncEventEmitter, URLPath } from '@internals/utils'
-export * as ast from '@kubb/ast'
-export { logLevel } from './constants.ts'
-export { createAdapter } from './createAdapter.ts'
-export { createKubb } from './createKubb.ts'
-export { createRenderer } from './createRenderer.ts'
-export { createStorage } from './createStorage.ts'
-export { defineGenerator } from './defineGenerator.ts'
-export { defineLogger } from './defineLogger.ts'
-export { defineMiddleware } from './defineMiddleware.ts'
-export { defineParser } from './defineParser.ts'
-export { definePlugin } from './definePlugin.ts'
-export { defineResolver } from './defineResolver.ts'
-export { FileManager } from './FileManager.ts'
-export { FileProcessor } from './FileProcessor.ts'
-export { PluginDriver } from './PluginDriver.ts'
-export { fsStorage } from './storages/fsStorage.ts'
-export { memoryStorage } from './storages/memoryStorage.ts'
-export * from './types.ts'
-export { isInputPath } from './createKubb.ts'

package/src/mocks.ts

@@ -1,177 +0,0 @@
-import { resolve } from 'node:path'
-import type { FileNode, OperationNode, SchemaNode, Visitor } from '@kubb/ast'
-import { transform } from '@kubb/ast'
-import { FileManager } from './FileManager.ts'
-import { applyHookResult, PluginDriver } from './PluginDriver.ts'
-import type { Adapter, AdapterFactoryOptions, Config, Generator, GeneratorContext, NormalizedPlugin, PluginFactoryOptions } from './types.ts'
-
-/**
-
- * Creates a minimal `PluginDriver` mock for unit tests.
- */
-export function createMockedPluginDriver(options: { name?: string; plugin?: NormalizedPlugin; config?: Config } = {}): PluginDriver {
-  return {
-    config: options?.config ?? {
-      root: '.',
-      output: {
-        path: './path',
-      },
-    },
-    getPlugin(_pluginName: string): NormalizedPlugin | undefined {
-      return options?.plugin
-    },
-    getResolver: (_pluginName: string) => options?.plugin?.resolver,
-    fileManager: new FileManager(),
-  } as unknown as PluginDriver
-}
-
-/**
- * Creates a minimal `Adapter` mock for unit tests.
- * `parse` returns an empty `InputNode` by default; override via `options.parse`.
- * `getImports` returns `[]` by default.
- */
-export function createMockedAdapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions>(
-  options: {
-    name?: TOptions['name']
-    resolvedOptions?: TOptions['resolvedOptions']
-    inputNode?: Adapter<TOptions>['inputNode']
-    parse?: Adapter<TOptions>['parse']
-    getImports?: Adapter<TOptions>['getImports']
-  } = {},
-): Adapter<TOptions> {
-  const inputNode = options.inputNode ?? null
-  return {
-    name: (options.name ?? 'oas') as TOptions['name'],
-    options: (options.resolvedOptions ?? {}) as TOptions['resolvedOptions'],
-    inputNode,
-    parse: options.parse ?? (async () => ({ kind: 'Input' as const, schemas: [], operations: [] })),
-    getImports: options.getImports ?? ((_node: SchemaNode, _resolve: (schemaName: string) => { name: string; path: string }) => []),
-  } as Adapter<TOptions>
-}
-
-/**
- * Creates a minimal plugin mock for unit tests.
- *
- * @example
- * `const plugin = createMockedPlugin<PluginTs>({ name: '@kubb/plugin-ts', options })`
- */
-export function createMockedPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(params: {
-  name: TOptions['name']
-  options: TOptions['resolvedOptions']
-  resolver?: TOptions['resolver']
-  transformer?: Visitor
-  dependencies?: Array<string>
-}): NormalizedPlugin<TOptions> {
-  return {
-    name: params.name,
-    options: params.options,
-    resolver: params.resolver,
-    transformer: params.transformer,
-    dependencies: params.dependencies,
-    hooks: {},
-  } as unknown as NormalizedPlugin<TOptions>
-}
-
-type RenderGeneratorOptions<TOptions extends PluginFactoryOptions> = {
-  config: Config
-  adapter: Adapter
-  driver: PluginDriver
-  plugin: NormalizedPlugin<TOptions>
-  options: TOptions['resolvedOptions']
-  resolver: TOptions['resolver']
-}
-
-function createMockedPluginContext<TOptions extends PluginFactoryOptions>(opts: RenderGeneratorOptions<TOptions>): Omit<GeneratorContext<TOptions>, 'options'> {
-  const root = resolve(opts.config.root, opts.config.output.path)
-
-  return {
-    config: opts.config,
-    root,
-    getMode: (output: { path: string }) => PluginDriver.getMode(resolve(root, output.path)),
-    adapter: opts.adapter,
-    resolver: opts.resolver,
-    plugin: opts.plugin,
-    driver: opts.driver,
-    getResolver: (name: string) => opts.driver.getResolver(name),
-    inputNode: { kind: 'Input', schemas: [], operations: [] },
-    addFile: async (...files: Array<FileNode>) => opts.driver.fileManager.add(...files),
-    upsertFile: async (...files: Array<FileNode>) => opts.driver.fileManager.upsert(...files),
-    hooks: opts.driver.hooks ?? ({} as never),
-    warn: (msg: string) => console.warn(msg),
-    error: (msg: string) => console.error(msg),
-    info: (msg: string) => console.info(msg),
-    openInStudio: async () => {},
-  } as unknown as Omit<GeneratorContext<TOptions>, 'options'>
-}
-
-/**
- * Renders a generator's `schema` method in a test context.
- *
- * @example
- * ```ts
- * await renderGeneratorSchema(typeGenerator, node, { config, adapter, driver, plugin, options, resolver })
- * await matchFiles(driver.fileManager.files)
- * ```
- */
-export async function renderGeneratorSchema<TOptions extends PluginFactoryOptions>(
-  generator: Generator<TOptions>,
-  node: SchemaNode,
-  opts: RenderGeneratorOptions<TOptions>,
-): Promise<void> {
-  if (!generator.schema) return
-  const context = createMockedPluginContext(opts)
-  const transformedNode = opts.plugin.transformer ? transform(node, opts.plugin.transformer) : node
-  const result = await generator.schema(transformedNode, {
-    ...context,
-    options: opts.options,
-  })
-  await applyHookResult(result, opts.driver, generator.renderer ?? undefined)
-}
-
-/**
- * Renders a generator's `operation` method in a test context.
- *
- * @example
- * ```ts
- * await renderGeneratorOperation(typeGenerator, node, { config, adapter, driver, plugin, options, resolver })
- * await matchFiles(driver.fileManager.files)
- * ```
- */
-export async function renderGeneratorOperation<TOptions extends PluginFactoryOptions>(
-  generator: Generator<TOptions>,
-  node: OperationNode,
-  opts: RenderGeneratorOptions<TOptions>,
-): Promise<void> {
-  if (!generator.operation) return
-  const context = createMockedPluginContext(opts)
-  const transformedNode = opts.plugin.transformer ? transform(node, opts.plugin.transformer) : node
-  const result = await generator.operation(transformedNode, {
-    ...context,
-    options: opts.options,
-  })
-  await applyHookResult(result, opts.driver, generator.renderer ?? undefined)
-}
-
-/**
- * Renders a generator's `operations` method in a test context.
- *
- * @example
- * ```ts
- * await renderGeneratorOperations(classClientGenerator, nodes, { config, adapter, driver, plugin, options, resolver })
- * await matchFiles(driver.fileManager.files)
- * ```
- */
-export async function renderGeneratorOperations<TOptions extends PluginFactoryOptions>(
-  generator: Generator<TOptions>,
-  nodes: Array<OperationNode>,
-  opts: RenderGeneratorOptions<TOptions>,
-): Promise<void> {
-  if (!generator.operations) return
-  const context = createMockedPluginContext(opts)
-  const transformedNodes = opts.plugin.transformer ? nodes.map((n) => transform(n, opts.plugin.transformer!)) : nodes
-  const result = await generator.operations(transformedNodes, {
-    ...context,
-    options: opts.options,
-  })
-  await applyHookResult(result, opts.driver, generator.renderer ?? undefined)
-}

package/src/storages/fsStorage.ts

@@ -1,89 +0,0 @@
-import type { Dirent } from 'node:fs'
-import { access, readdir, readFile, rm } from 'node:fs/promises'
-import { join, resolve } from 'node:path'
-import { clean, write } from '@internals/utils'
-import { createStorage } from '../createStorage.ts'
-
-/**
- * Built-in filesystem storage driver.
- *
- * This is the default storage when no `storage` option is configured in the root config.
- * Keys are resolved against `process.cwd()`, so root-relative paths such as
- * `src/gen/api/getPets.ts` are written to the correct location without extra configuration.
- *
- * Internally uses the `write` utility from `@internals/utils`, which:
- * - trims leading/trailing whitespace before writing
- * - skips the write when file content is already identical (deduplication)
- * - creates missing parent directories automatically
- * - supports Bun's native file API when running under Bun
- *
- * @example
- * ```ts
- * import { fsStorage } from '@kubb/core'
- * import { defineConfig } from 'kubb'
- *
- * export default defineConfig({
- *   input:  { path: './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   storage: fsStorage(),
- * })
- * ```
- */
-export const fsStorage = createStorage(() => ({
-  name: 'fs',
-  async hasItem(key: string) {
-    try {
-      await access(resolve(key))
-      return true
-    } catch (_error) {
-      return false
-    }
-  },
-  async getItem(key: string) {
-    try {
-      return await readFile(resolve(key), 'utf8')
-    } catch (_error) {
-      return null
-    }
-  },
-  async setItem(key: string, value: string) {
-    await write(resolve(key), value, { sanity: false })
-  },
-  async removeItem(key: string) {
-    await rm(resolve(key), { force: true })
-  },
-  async getKeys(base?: string) {
-    const keys: Array<string> = []
-    const resolvedBase = resolve(base ?? process.cwd())
-
-    async function walk(dir: string, prefix: string): Promise<void> {
-      let entries: Array<Dirent>
-      try {
-        entries = (await readdir(dir, {
-          withFileTypes: true,
-        })) as Array<Dirent>
-      } catch (_error) {
-        return
-      }
-      for (const entry of entries) {
-        const rel = prefix ? `${prefix}/${entry.name}` : entry.name
-        if (entry.isDirectory()) {
-          await walk(join(dir, entry.name), rel)
-        } else {
-          keys.push(rel)
-        }
-      }
-    }
-
-    await walk(resolvedBase, '')
-
-    return keys
-  },
-  async clear(base?: string) {
-    if (!base) {
-      return
-    }
-
-    await clean(resolve(base))
-  },
-}))

package/src/storages/memoryStorage.ts

@@ -1,55 +0,0 @@
-import { createStorage } from '../createStorage.ts'
-
-/**
- * In-memory storage driver. Useful for testing and dry-run scenarios where
- * generated output should be captured without touching the filesystem.
- *
- * All data lives in a `Map` scoped to the storage instance and is discarded
- * when the instance is garbage-collected.
- *
- * @example
- * ```ts
- * import { memoryStorage } from '@kubb/core'
- * import { defineConfig } from 'kubb'
- *
- * export default defineConfig({
- *   input:  { path: './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   storage: memoryStorage(),
- * })
- * ```
- */
-export const memoryStorage = createStorage(() => {
-  const store = new Map<string, string>()
-
-  return {
-    name: 'memory',
-    async hasItem(key: string) {
-      return store.has(key)
-    },
-    async getItem(key: string) {
-      return store.get(key) ?? null
-    },
-    async setItem(key: string, value: string) {
-      store.set(key, value)
-    },
-    async removeItem(key: string) {
-      store.delete(key)
-    },
-    async getKeys(base?: string) {
-      const keys = [...store.keys()]
-      return base ? keys.filter((k) => k.startsWith(base)) : keys
-    },
-    async clear(base?: string) {
-      if (!base) {
-        store.clear()
-        return
-      }
-      for (const key of store.keys()) {
-        if (key.startsWith(base)) {
-          store.delete(key)
-        }
-      }
-    },
-  }
-})

package/src/types.ts

@@ -1,41 +0,0 @@
-export type { DevtoolsOptions } from './devtools.ts'
-export type { Adapter, AdapterFactoryOptions, AdapterSource } from './createAdapter.ts'
-export type {
-  BuildOutput,
-  CLIOptions,
-  Config,
-  InputData,
-  InputPath,
-  Kubb,
-  KubbBuildEndContext,
-  KubbBuildStartContext,
-  KubbConfigEndContext,
-  KubbDebugContext,
-  KubbErrorContext,
-  KubbFileProcessingUpdateContext,
-  KubbFilesProcessingEndContext,
-  KubbFilesProcessingStartContext,
-  KubbGenerationEndContext,
-  KubbGenerationStartContext,
-  KubbGenerationSummaryContext,
-  KubbHookEndContext,
-  KubbHookStartContext,
-  KubbHooks,
-  KubbInfoContext,
-  KubbLifecycleStartContext,
-  KubbPluginsEndContext,
-  KubbSuccessContext,
-  KubbVersionNewContext,
-  KubbWarnContext,
-  PossibleConfig,
-  UserConfig,
-} from './createKubb.ts'
-export type { Renderer, RendererFactory } from './createRenderer.ts'
-export type { Storage } from './createStorage.ts'
-export type { Generator, GeneratorContext } from './defineGenerator.ts'
-export type { Logger, LoggerContext, LoggerOptions, UserLogger } from './defineLogger.ts'
-export type { Middleware } from './defineMiddleware.ts'
-export type { Parser } from './defineParser.ts'
-export type { Exclude, Group, Include, Output, Override } from './definePlugin.ts'
-export type { KubbPluginEndContext, KubbPluginSetupContext, KubbPluginStartContext, NormalizedPlugin, Plugin, PluginFactoryOptions } from './definePlugin.ts'
-export type { ResolveBannerContext, ResolveOptionsContext, Resolver, ResolverContext, ResolverFileParams, ResolverPathParams } from './defineResolver.ts'