@kubb/core 5.0.0-beta.4 → 5.0.0-beta.40

package/src/PluginDriver.ts

@@ -1,424 +0,0 @@
-import { extname, resolve } from 'node:path'
-import type { AsyncEventEmitter } from '@internals/utils'
-import type { FileNode, InputNode, OperationNode, SchemaNode } from '@kubb/ast'
-import { createFile } from '@kubb/ast'
-import { DEFAULT_STUDIO_URL } from './constants.ts'
-import type { Generator } from './defineGenerator.ts'
-import type { Plugin } from './definePlugin.ts'
-import { defineResolver } from './defineResolver.ts'
-import { openInStudio as openInStudioFn } from './devtools.ts'
-import { FileManager } from './FileManager.ts'
-import { applyHookResult } from './renderNode.ts'
-
-import type {
-  Adapter,
-  Config,
-  DevtoolsOptions,
-  GeneratorContext,
-  KubbHooks,
-  KubbPluginSetupContext,
-  NormalizedPlugin,
-  PluginFactoryOptions,
-  Resolver,
-} from './types.ts'
-
-// inspired by: https://github.com/rollup/rollup/blob/master/src/utils/PluginDriver.ts#
-
-type Options = {
-  hooks: AsyncEventEmitter<KubbHooks>
-}
-
-function enforceOrder(enforce: 'pre' | 'post' | undefined): number {
-  return enforce === 'pre' ? -1 : enforce === 'post' ? 1 : 0
-}
-
-export class PluginDriver {
-  readonly config: Config
-  readonly options: Options
-
-  /**
-   * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
-   *
-   * @example
-   * ```ts
-   * PluginDriver.getMode('src/gen/types.ts')  // 'single'
-   * PluginDriver.getMode('src/gen/types')     // 'split'
-   * ```
-   */
-  static getMode(fileOrFolder: string | undefined | null): 'single' | 'split' {
-    if (!fileOrFolder) {
-      return 'split'
-    }
-    return extname(fileOrFolder) ? 'single' : 'split'
-  }
-
-  /**
-   * The universal `@kubb/ast` `InputNode` produced by the adapter, set by
-   * the build pipeline after the adapter's `parse()` resolves.
-   */
-  inputNode: InputNode | undefined = undefined
-  adapter: Adapter | undefined = undefined
-  #studioIsOpen = false
-
-  /**
-   * Central file store for all generated files.
-   * Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
-   * add files; this property gives direct read/write access when needed.
-   */
-  readonly fileManager = new FileManager()
-
-  readonly plugins = new Map<string, NormalizedPlugin>()
-
-  /**
-   * Tracks which plugins have generators registered via `addGenerator()` (event-based path).
-   * Used by the build loop to decide whether to emit generator events for a given plugin.
-   */
-  readonly #pluginsWithEventGenerators = new Set<string>()
-  readonly #resolvers = new Map<string, Resolver>()
-  readonly #defaultResolvers = new Map<string, Resolver>()
-  readonly #hookListeners = new Map<keyof KubbHooks, Set<(...args: never[]) => void | Promise<void>>>()
-
-  constructor(config: Config, options: Options) {
-    this.config = config
-    this.options = options
-    config.plugins
-      .map((rawPlugin) => this.#normalizePlugin(rawPlugin as Plugin))
-      .filter((plugin) => {
-        if (typeof plugin.apply === 'function') {
-          return plugin.apply(config)
-        }
-        return true
-      })
-      .sort((a, b) => {
-        if (b.dependencies?.includes(a.name)) return -1
-        if (a.dependencies?.includes(b.name)) return 1
-        // enforce: 'pre' plugins run first, 'post' plugins run last
-        return enforceOrder(a.enforce) - enforceOrder(b.enforce)
-      })
-      .forEach((plugin) => {
-        this.plugins.set(plugin.name, plugin)
-      })
-  }
-
-  get hooks() {
-    return this.options.hooks
-  }
-
-  /**
-   * Creates an `NormalizedPlugin` from a hook-style plugin and registers
-   * its lifecycle handlers on the `AsyncEventEmitter`.
-   */
-  #normalizePlugin(hookPlugin: Plugin): NormalizedPlugin {
-    const normalizedPlugin = {
-      name: hookPlugin.name,
-      dependencies: hookPlugin.dependencies,
-      enforce: hookPlugin.enforce,
-      options: { output: { path: '.' }, exclude: [], override: [] },
-    } as unknown as NormalizedPlugin
-
-    this.registerPluginHooks(hookPlugin, normalizedPlugin)
-    return normalizedPlugin
-  }
-
-  /**
-   * Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
-   *
-   * For `kubb:plugin:setup`, the registered listener wraps the globally emitted context with a
-   * plugin-specific one so that `addGenerator`, `setResolver`, `setTransformer`, and
-   * `setRenderer` all target the correct `normalizedPlugin` entry in the plugins map.
-   *
-   * All other hooks are iterated and registered directly as pass-through listeners.
-   * Any event key present in the global `KubbHooks` interface can be subscribed to.
-   *
-   * External tooling can subscribe to any of these events via `hooks.on(...)` to observe
-   * the plugin lifecycle without modifying plugin behavior.
-   *
-   * @internal
-   */
-  registerPluginHooks(hookPlugin: Plugin, normalizedPlugin: NormalizedPlugin): void {
-    const { hooks } = hookPlugin
-
-    // kubb:plugin:setup gets special treatment: the globally emitted context is wrapped with
-    // plugin-specific implementations so that addGenerator / setResolver / etc. target
-    // this plugin's normalizedPlugin entry rather than being no-ops.
-    if (hooks['kubb:plugin:setup']) {
-      const setupHandler = (globalCtx: KubbPluginSetupContext) => {
-        const pluginCtx: KubbPluginSetupContext = {
-          ...globalCtx,
-          options: hookPlugin.options ?? {},
-          addGenerator: (gen) => {
-            this.registerGenerator(normalizedPlugin.name, gen)
-          },
-          setResolver: (resolver) => {
-            this.setPluginResolver(normalizedPlugin.name, resolver)
-          },
-          setTransformer: (visitor) => {
-            normalizedPlugin.transformer = visitor
-          },
-          setRenderer: (renderer) => {
-            normalizedPlugin.renderer = renderer
-          },
-          setOptions: (opts) => {
-            normalizedPlugin.options = { ...normalizedPlugin.options, ...opts }
-          },
-          injectFile: (userFileNode) => {
-            this.fileManager.add(createFile(userFileNode))
-          },
-        }
-        return hooks['kubb:plugin:setup']!(pluginCtx)
-      }
-
-      this.hooks.on('kubb:plugin:setup', setupHandler)
-      this.#trackHookListener('kubb:plugin:setup', setupHandler as (...args: never[]) => void | Promise<void>)
-    }
-
-    // All other hooks are registered as direct pass-through listeners on the shared emitter.
-    for (const [event, handler] of Object.entries(hooks) as Array<[keyof KubbHooks, ((...args: never[]) => void | Promise<void>) | undefined]>) {
-      if (event === 'kubb:plugin:setup' || !handler) continue
-
-      this.hooks.on(event, handler as never)
-      this.#trackHookListener(event, handler as (...args: never[]) => void | Promise<void>)
-    }
-  }
-
-  /**
-   * Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
-   * can configure generators, resolvers, transformers and renderers before `buildStart` runs.
-   *
-   * Call this once from `safeBuild` before the plugin execution loop begins.
-   */
-  async emitSetupHooks(): Promise<void> {
-    const noop = () => {}
-    await this.hooks.emit('kubb:plugin:setup', {
-      config: this.config,
-      options: {},
-      addGenerator: noop,
-      setResolver: noop,
-      setTransformer: noop,
-      setRenderer: noop,
-      setOptions: noop,
-      injectFile: noop,
-      updateConfig: noop,
-    })
-  }
-
-  /**
-   * Registers a generator for the given plugin on the shared event emitter.
-   *
-   * The generator's `schema`, `operation`, and `operations` methods are registered as
-   * listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
-   * respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
-   * so that generators from different plugins do not cross-fire.
-   *
-   * The renderer resolution chain is: `generator.renderer → plugin.renderer → config.renderer`.
-   * Set `generator.renderer = null` to explicitly opt out of rendering even when the plugin
-   * declares a renderer.
-   *
-   * Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
-   */
-  registerGenerator(pluginName: string, gen: Generator): void {
-    const resolveRenderer = () => {
-      const plugin = this.plugins.get(pluginName)
-      return gen.renderer === null ? undefined : (gen.renderer ?? plugin?.renderer ?? this.config.renderer)
-    }
-
-    if (gen.schema) {
-      const schemaHandler = async (node: SchemaNode, ctx: GeneratorContext) => {
-        if (ctx.plugin.name !== pluginName) return
-        const result = await gen.schema!(node, ctx)
-        await applyHookResult(result, this, resolveRenderer())
-      }
-
-      this.hooks.on('kubb:generate:schema', schemaHandler)
-      this.#trackHookListener('kubb:generate:schema', schemaHandler as (...args: never[]) => void | Promise<void>)
-    }
-
-    if (gen.operation) {
-      const operationHandler = async (node: OperationNode, ctx: GeneratorContext) => {
-        if (ctx.plugin.name !== pluginName) return
-        const result = await gen.operation!(node, ctx)
-        await applyHookResult(result, this, resolveRenderer())
-      }
-
-      this.hooks.on('kubb:generate:operation', operationHandler)
-      this.#trackHookListener('kubb:generate:operation', operationHandler as (...args: never[]) => void | Promise<void>)
-    }
-
-    if (gen.operations) {
-      const operationsHandler = async (nodes: Array<OperationNode>, ctx: GeneratorContext) => {
-        if (ctx.plugin.name !== pluginName) return
-        const result = await gen.operations!(nodes, ctx)
-        await applyHookResult(result, this, resolveRenderer())
-      }
-
-      this.hooks.on('kubb:generate:operations', operationsHandler)
-      this.#trackHookListener('kubb:generate:operations', operationsHandler as (...args: never[]) => void | Promise<void>)
-    }
-
-    this.#pluginsWithEventGenerators.add(pluginName)
-  }
-
-  /**
-   * Returns `true` when at least one generator was registered for the given plugin
-   * via `addGenerator()` in `kubb:plugin:setup` (event-based path).
-   *
-   * Used by the build loop to decide whether to walk the AST and emit generator events
-   * for a plugin that has no static `plugin.generators`.
-   */
-  hasRegisteredGenerators(pluginName: string): boolean {
-    return this.#pluginsWithEventGenerators.has(pluginName)
-  }
-
-  /**
-   * Unregisters all plugin lifecycle listeners from the shared event emitter.
-   * Called at the end of a build to prevent listener leaks across repeated builds.
-   *
-   * @internal
-   */
-  dispose(): void {
-    for (const [event, handlers] of this.#hookListeners) {
-      for (const handler of handlers) {
-        this.hooks.off(event, handler as never)
-      }
-    }
-    this.#hookListeners.clear()
-    this.#pluginsWithEventGenerators.clear()
-  }
-
-  #trackHookListener(event: keyof KubbHooks, handler: (...args: never[]) => void | Promise<void>): void {
-    let handlers = this.#hookListeners.get(event)
-    if (!handlers) {
-      handlers = new Set()
-      this.#hookListeners.set(event, handlers)
-    }
-    handlers.add(handler)
-  }
-
-  #createDefaultResolver(pluginName: string): Resolver {
-    const existingResolver = this.#defaultResolvers.get(pluginName)
-    if (existingResolver) {
-      return existingResolver
-    }
-
-    const resolver = defineResolver<PluginFactoryOptions>((_ctx) => ({
-      name: 'default',
-      pluginName,
-    }))
-    this.#defaultResolvers.set(pluginName, resolver)
-    return resolver
-  }
-
-  /**
-   * Merges `partial` with the plugin's default resolver and stores the result.
-   * Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
-   * get the up-to-date resolver without going through `getResolver()`.
-   */
-  setPluginResolver(pluginName: string, partial: Partial<Resolver>): void {
-    const defaultResolver = this.#createDefaultResolver(pluginName)
-    const merged = { ...defaultResolver, ...partial }
-    this.#resolvers.set(pluginName, merged)
-    const plugin = this.plugins.get(pluginName)
-    if (plugin) {
-      plugin.resolver = merged
-    }
-  }
-
-  /**
-   * Returns the resolver for the given plugin.
-   *
-   * Resolution order: dynamic resolver set via `setPluginResolver` → static resolver on the
-   * plugin → lazily created default resolver (identity name, no path transforms).
-   */
-  getResolver<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Kubb.PluginRegistry[TName]['resolver']
-  getResolver<TResolver extends Resolver = Resolver>(pluginName: string): TResolver
-  getResolver(pluginName: string): Resolver {
-    return this.#resolvers.get(pluginName) ?? this.plugins.get(pluginName)?.resolver ?? this.#createDefaultResolver(pluginName)
-  }
-
-  getContext<TOptions extends PluginFactoryOptions>(plugin: NormalizedPlugin<TOptions>): GeneratorContext<TOptions> & Record<string, unknown> {
-    const driver = this
-
-    const baseContext = {
-      config: driver.config,
-      get root(): string {
-        return resolve(driver.config.root, driver.config.output.path)
-      },
-      getMode(output: { path: string }): 'single' | 'split' {
-        return PluginDriver.getMode(resolve(driver.config.root, driver.config.output.path, output.path))
-      },
-      hooks: driver.hooks,
-      plugin,
-      getPlugin: driver.getPlugin.bind(driver),
-      requirePlugin: driver.requirePlugin.bind(driver),
-      getResolver: driver.getResolver.bind(driver),
-      driver,
-      addFile: async (...files: Array<FileNode>) => {
-        driver.fileManager.add(...files)
-      },
-      upsertFile: async (...files: Array<FileNode>) => {
-        driver.fileManager.upsert(...files)
-      },
-      get inputNode(): InputNode | undefined {
-        return driver.inputNode
-      },
-      get adapter(): Adapter | undefined {
-        return driver.adapter
-      },
-      get resolver() {
-        return driver.getResolver(plugin.name)
-      },
-      get transformer() {
-        return plugin.transformer
-      },
-      warn(message: string) {
-        driver.hooks.emit('kubb:warn', { message })
-      },
-      error(error: string | Error) {
-        driver.hooks.emit('kubb:error', { error: typeof error === 'string' ? new Error(error) : error })
-      },
-      info(message: string) {
-        driver.hooks.emit('kubb:info', { message })
-      },
-      openInStudio(options?: DevtoolsOptions) {
-        if (!driver.config.devtools || driver.#studioIsOpen) {
-          return
-        }
-
-        if (typeof driver.config.devtools !== 'object') {
-          throw new Error('Devtools must be an object')
-        }
-
-        if (!driver.inputNode || !driver.adapter) {
-          throw new Error('adapter is not defined, make sure you have set the parser in kubb.config.ts')
-        }
-
-        driver.#studioIsOpen = true
-
-        const studioUrl = driver.config.devtools?.studioUrl ?? DEFAULT_STUDIO_URL
-
-        return openInStudioFn(driver.inputNode, studioUrl, options)
-      },
-    } as unknown as GeneratorContext<TOptions>
-
-    return baseContext
-  }
-
-  getPlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]> | undefined
-  getPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions> | undefined
-  getPlugin(pluginName: string): Plugin | undefined {
-    return this.plugins.get(pluginName)
-  }
-
-  /**
-   * Like `getPlugin` but throws a descriptive error when the plugin is not found.
-   */
-  requirePlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]>
-  requirePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions>
-  requirePlugin(pluginName: string): Plugin {
-    const plugin = this.plugins.get(pluginName)
-    if (!plugin) {
-      throw new Error(`[kubb] Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`)
-    }
-    return plugin
-  }
-}

package/src/devtools.ts

@@ -1,59 +0,0 @@
-import type { InputNode } from '@kubb/ast'
-import { deflateSync, inflateSync } from 'fflate'
-import { x } from 'tinyexec'
-import type { DevtoolsOptions } from './types.ts'
-
-/**
- * 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/renderNode.ts

@@ -1,35 +0,0 @@
-import type { FileNode } from '@kubb/ast'
-import type { RendererFactory } from './createRenderer.ts'
-import type { PluginDriver } from './PluginDriver.ts'
-
-/**
- * Handles the return value of a plugin AST hook or generator method.
- *
- * - Renderer output → rendered via the provided `rendererFactory` (e.g. JSX), files stored in `driver.fileManager`
- * - `Array<FileNode>` → added directly into `driver.fileManager`
- * - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
- *
- * Pass a `rendererFactory` (e.g. `jsxRenderer` from `@kubb/renderer-jsx`) when the result
- * may be a renderer element. Generators that only return `Array<FileNode>` do not need one.
- */
-export async function applyHookResult<TElement = unknown>(
-  result: TElement | Array<FileNode> | void,
-  driver: PluginDriver,
-  rendererFactory?: RendererFactory<TElement>,
-): Promise<void> {
-  if (!result) return
-
-  if (Array.isArray(result)) {
-    driver.fileManager.upsert(...(result as Array<FileNode>))
-    return
-  }
-
-  if (!rendererFactory) {
-    return
-  }
-
-  const renderer = rendererFactory()
-  await renderer.render(result)
-  driver.fileManager.upsert(...renderer.files)
-  renderer.unmount()
-}

package/src/utils/diagnostics.ts

@@ -1,18 +0,0 @@
-import { version as nodeVersion } from 'node:process'
-import { version as KubbVersion } from '../../package.json'
-
-/**
- * Returns a snapshot of the current runtime environment.
- *
- * Useful for attaching context to debug logs and error reports so that
- * issues can be reproduced without manual information gathering.
- */
-export function getDiagnosticInfo() {
-  return {
-    nodeVersion,
-    KubbVersion,
-    platform: process.platform,
-    arch: process.arch,
-    cwd: process.cwd(),
-  } as const
-}

package/src/utils/isInputPath.ts

@@ -1,10 +0,0 @@
-import type { Config, InputPath, UserConfig } from '../types'
-
-/**
- * Type guard to check if a given config has an `input.path`.
- */
-export function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath> & { input: InputPath }
-export function isInputPath(config: Config | undefined): config is Config<InputPath> & { input: InputPath }
-export function isInputPath(config: Config | UserConfig | undefined): config is (Config<InputPath> | UserConfig<InputPath>) & { input: InputPath } {
-  return typeof config?.input === 'object' && config.input !== null && 'path' in config.input
-}

package/src/utils/packageJSON.ts

@@ -1,99 +0,0 @@
-import { findPackageJSON, readSync } from '@internals/utils'
-
-type PackageJSON = {
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-}
-
-type DependencyName = string
-type DependencyVersion = string
-
-function getPackageJSONSync(cwd?: string): PackageJSON | null {
-  const pkgPath = findPackageJSON(cwd)
-  if (!pkgPath) {
-    return null
-  }
-
-  return JSON.parse(readSync(pkgPath)) as PackageJSON
-}
-
-function match(packageJSON: PackageJSON, dependency: DependencyName | RegExp): string | null {
-  const dependencies = {
-    ...(packageJSON.dependencies || {}),
-    ...(packageJSON.devDependencies || {}),
-  }
-
-  if (typeof dependency === 'string' && dependencies[dependency]) {
-    return dependencies[dependency]
-  }
-
-  const matched = Object.keys(dependencies).find((dep) => dep.match(dependency))
-
-  return matched ? (dependencies[matched] ?? null) : null
-}
-
-function getVersionSync(dependency: DependencyName | RegExp, cwd?: string): DependencyVersion | null {
-  const packageJSON = getPackageJSONSync(cwd)
-
-  return packageJSON ? match(packageJSON, dependency) : null
-}
-
-/**
- * Returns `true` when the nearest `package.json` declares a dependency that
- * satisfies the given semver range.
- *
- * - Searches both `dependencies` and `devDependencies`.
- * - Accepts a string package name or a `RegExp` to match scoped/pattern packages.
- * - Uses `semver.satisfies` for range comparison; returns `false` when the
- *   version string cannot be coerced into a valid semver.
- *
- * @example
- * ```ts
- * satisfiesDependency('react', '>=18')          // true when react@18.x is installed
- * satisfiesDependency(/^@tanstack\//, '>=5')    // true when any @tanstack/* >=5 is found
- * ```
- */
-function coerceSemver(version: string): [number, number, number] | null {
-  const m = version.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/)
-  return m ? [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)] : null
-}
-
-function satisfiesSemver(v: [number, number, number], range: string): boolean {
-  return range
-    .trim()
-    .split(/\s+/)
-    .every((cond) => {
-      const m = cond.match(/^(>=|<=|>|<|=|\^|~)?(\d+)(?:\.(\d+))?(?:\.(\d+))?$/)
-      if (!m) return false
-      const op = m[1] ?? '='
-      const r: [number, number, number] = [Number(m[2]), Number(m[3] ?? 0), Number(m[4] ?? 0)]
-      const cmp = v[0] !== r[0] ? v[0] - r[0] : v[1] !== r[1] ? v[1] - r[1] : v[2] - r[2]
-      if (op === '>=') return cmp >= 0
-      if (op === '<=') return cmp <= 0
-      if (op === '>') return cmp > 0
-      if (op === '<') return cmp < 0
-      if (op === '^') return v[0] === r[0] && cmp >= 0
-      if (op === '~') return v[0] === r[0] && v[1] === r[1] && cmp >= 0
-      return cmp === 0
-    })
-}
-
-export function satisfiesDependency(dependency: DependencyName | RegExp, version: DependencyVersion, cwd?: string): boolean {
-  const packageVersion = getVersionSync(dependency, cwd)
-
-  if (!packageVersion) {
-    return false
-  }
-
-  if (packageVersion === version) {
-    return true
-  }
-
-  const semVer = coerceSemver(packageVersion)
-
-  if (!semVer) {
-    return false
-  }
-
-  return satisfiesSemver(semVer, version)
-}