@kubb/core 5.0.0-alpha.2 → 5.0.0-alpha.21

package/src/PromiseManager.ts

@@ -1,40 +0,0 @@
-import type { Strategy, StrategySwitch } from './utils/executeStrategies.ts'
-import { hookFirst, hookParallel, hookSeq } from './utils/executeStrategies.ts'
-
-type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2
-
-type Options<TState = unknown> = {
-  nullCheck?: (state: TState) => boolean
-}
-
-export class PromiseManager<TState = unknown> {
-  #options: Options<TState> = {}
-
-  constructor(options: Options<TState> = {}) {
-    this.#options = options
-  }
-
-  run<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TStrategy extends Strategy, TOutput = StrategySwitch<TStrategy, TInput, TValue>>(
-    strategy: TStrategy,
-    promises: TInput,
-    { concurrency = Number.POSITIVE_INFINITY }: { concurrency?: number } = {},
-  ): TOutput {
-    if (strategy === 'seq') {
-      return hookSeq<TInput, TValue, TOutput>(promises)
-    }
-
-    if (strategy === 'first') {
-      return hookFirst<TInput, TValue, TOutput>(promises, this.#options.nullCheck as ((state: unknown) => boolean) | undefined)
-    }
-
-    if (strategy === 'parallel') {
-      return hookParallel<TInput, TValue, TOutput>(promises, concurrency)
-    }
-
-    throw new Error(`${strategy} not implemented`)
-  }
-}
-
-export function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & { reason: T } {
-  return result.status === 'rejected'
-}

package/src/defineAdapter.ts

@@ -1,22 +0,0 @@
-import type { Adapter, AdapterFactoryOptions } from './types.ts'
-
-type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>
-
-/**
- * Wraps an adapter builder to make the options parameter optional.
- *
- * @example
- * ```ts
- * export const adapterOas = defineAdapter<OasAdapter>((options) => {
- *   const { validate = true, dateType = 'string' } = options
- *   return {
- *     name: adapterOasName,
- *     options: { validate, dateType, ... },
- *     parse(source) { ... },
- *   }
- * })
- * ```
- */
-export function defineAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T> {
-  return (options) => build(options ?? ({} as T['options']))
-}

package/src/definePlugin.ts

@@ -1,12 +0,0 @@
-import type { PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
-
-type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>
-
-/**
- * Wraps a plugin builder to make the options parameter optional.
- */
-export function definePlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(
-  build: PluginBuilder<T>,
-): (options?: T['options']) => UserPluginWithLifeCycle<T> {
-  return (options) => build(options ?? ({} as T['options']))
-}

package/src/defineStorage.ts

@@ -1,56 +0,0 @@
-/**
- * Storage interface for persisting Kubb output.
- *
- * Keys are root-relative forward-slash paths (e.g. `src/gen/api/getPets.ts`).
- * Implement this interface to route generated files to any backend — filesystem,
- * S3, Redis, in-memory, etc.
- *
- * Use `defineStorage` to create a typed storage driver.
- */
-export interface DefineStorage {
-  /** Identifier used for logging and debugging (e.g. `'fs'`, `'s3'`). */
-  readonly name: string
-  /** Returns `true` when an entry for `key` exists in storage. */
-  hasItem(key: string): Promise<boolean>
-  /** Returns the stored string value, or `null` when `key` does not exist. */
-  getItem(key: string): Promise<string | null>
-  /** Persists `value` under `key`, creating any required structure. */
-  setItem(key: string, value: string): Promise<void>
-  /** Removes the entry for `key`. No-ops when the key does not exist. */
-  removeItem(key: string): Promise<void>
-  /** Returns all keys, optionally filtered to those starting with `base`. */
-  getKeys(base?: string): Promise<Array<string>>
-  /** Removes all entries, optionally scoped to those starting with `base`. */
-  clear(base?: string): Promise<void>
-  /** Optional teardown hook called after the build completes. */
-  dispose?(): Promise<void>
-}
-
-/**
- * Wraps a storage builder so the `options` argument is optional, following the
- * same factory pattern as `definePlugin`, `defineLogger`, and `defineAdapter`.
- *
- * The builder receives the resolved options object and must return a
- * `DefineStorage`-compatible object that includes a `name` string.
- *
- * @example
- * ```ts
- * import { defineStorage } from '@kubb/core'
- *
- * export const memoryStorage = defineStorage((_options) => {
- *   const store = new Map<string, string>()
- *   return {
- *     name: 'memory',
- *     async hasItem(key) { return store.has(key) },
- *     async getItem(key) { return store.get(key) ?? null },
- *     async setItem(key, value) { store.set(key, value) },
- *     async removeItem(key) { store.delete(key) },
- *     async getKeys() { return [...store.keys()] },
- *     async clear() { store.clear() },
- *   }
- * })
- * ```
- */
-export function defineStorage<TOptions = Record<string, never>>(build: (options: TOptions) => DefineStorage): (options?: TOptions) => DefineStorage {
-  return (options) => build(options ?? ({} as TOptions))
-}

package/src/errors.ts

@@ -1 +0,0 @@
-export { BuildError, ValidationPluginError } from '@internals/utils'

package/src/hooks/usePluginManager.ts

@@ -1,8 +0,0 @@
-import { useApp } from '@kubb/react-fabric'
-import type { PluginManager } from '../PluginManager.ts'
-
-export function usePluginManager(): PluginManager {
-  const { meta } = useApp<{ pluginManager: PluginManager }>()
-
-  return meta.pluginManager
-}

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