@kubb/adapter-oas 5.0.0-beta.63 → 5.0.0-beta.65

package/src/dedupe.ts

@@ -1,237 +0,0 @@
-import { containsCircularRef, extractRefName } from '@kubb/ast/utils'
-import { ast } from '@kubb/core'
-import { SCHEMA_REF_PREFIX } from './constants.ts'
-
-/**
- * The destination a deduplicated shape points at: the shared schema name and the
- * synthetic `$ref` path stored on the generated `ref` nodes.
- */
-type Target = {
-  name: string
-  ref: string
-}
-
-/**
- * The result of {@link plan}: the shared definitions to prepend to the schema list, plus the
- * rewriting behavior that repoints duplicate shapes at their shared target. The lookup maps stay
- * private to the closure, so callers interact with one object instead of three collections.
- */
-export type Plan = {
-  /**
-   * New top-level schema definitions created for inline shapes that had no existing named
-   * component. Nested duplicates inside each definition are already collapsed.
-   */
-  extracted: Array<ast.SchemaNode>
-  /**
-   * Rewrites an operation or nested schema, replacing every duplicate sub-schema with a `ref` to
-   * its shared target. Replacing a node prunes its subtree, so nested duplicates inside a replaced
-   * shape are not visited again. A `ref` to a duplicate top-level schema is repointed at the first
-   * schema with the same content.
-   */
-  apply<T extends ast.Node>(node: T): T
-  /**
-   * Rewrites a top-level schema. A schema whose content duplicates a different shared one becomes a
-   * `ref` alias to it (keeping its own name and docs). Otherwise its nested duplicates collapse
-   * while its own root is preserved.
-   */
-  applyTopLevel(node: ast.SchemaNode): ast.SchemaNode
-  /**
-   * Whether a top-level name duplicates an earlier schema with the same content. Such a schema is
-   * never emitted, since every reference to it is repointed at the first schema with that content.
-   */
-  isAlias(name: string): boolean
-}
-
-/**
- * Runtime state {@link plan} reads from the current parse: schema names that take part in a
- * circular chain (never extracted, extracting them would break the cycle) and the names already in
- * use (so extracted definitions resolve collisions).
- */
-export type DedupeContext = {
-  circularSchemas: ReadonlySet<string>
-  usedNames: Set<string>
-}
-
-/**
- * Minimum occurrences before a shape is deduplicated.
- */
-const MIN_OCCURRENCES = 2
-
-/**
- * Builds the shared `ref` replacement for a duplicate occurrence, carrying the
- * usage-slot and documentation fields that are not part of the shared type.
- */
-function createRefNode(node: ast.SchemaNode, target: Target): ast.SchemaNode {
-  return ast.factory.createSchema({
-    type: 'ref',
-    name: target.name,
-    ref: target.ref,
-    optional: node.optional,
-    nullish: node.nullish,
-    readOnly: node.readOnly,
-    writeOnly: node.writeOnly,
-    deprecated: node.deprecated,
-    description: node.description,
-    default: node.default,
-    example: node.example,
-  })
-}
-
-/**
- * Strips usage-slot flags from an extracted definition and applies its name.
- * A standalone definition is never optional, so `optional`/`nullish` are cleared.
- */
-function cleanDefinition(node: ast.SchemaNode, name: string): ast.SchemaNode {
-  return { ...node, name, optional: undefined, nullish: undefined }
-}
-
-/**
- * Returns `true` when a node is eligible for deduplication. Only enums and objects qualify, and
- * object shapes that take part in a circular chain are rejected so recursive structures are not
- * extracted (which would break the cycle).
- */
-function isCandidate(node: ast.SchemaNode, circularSchemas: ReadonlySet<string>): boolean {
-  if (node.type === 'enum') return true
-  if (node.type !== 'object') return false
-  if (node.name && circularSchemas.has(node.name)) return false
-  return !containsCircularRef(node, { circularSchemas })
-}
-
-/**
- * Produces the name for an inline shape with no existing named component, resolving
- * collisions against `usedNames`. Returns `null` for an unnamed shape, which stays inline.
- */
-function nameFor(node: ast.SchemaNode, usedNames: Set<string>): string | null {
-  const base = node.name
-  if (!base) return null
-
-  let name = base
-  let counter = 2
-  while (usedNames.has(name)) {
-    name = `${base}${counter++}`
-  }
-  usedNames.add(name)
-  return name
-}
-
-/**
- * Scans a forest of schema and operation nodes and produces a {@link Plan}.
- *
- * A shape that occurs at least {@link MIN_OCCURRENCES} times is deduplicated: if any occurrence is
- * a named top-level schema, the first one becomes the target (so other top-level duplicates and
- * inline copies turn into references to it). Other top-level names with the same content are
- * recorded as aliases. Otherwise a new definition is extracted using {@link nameFor}. The returned
- * plan rewrites nodes against those decisions.
- *
- * @example
- * ```ts
- * const dedupePlan = plan([...schemaNodes, ...operationNodes], { circularSchemas, usedNames })
- * ```
- */
-export function plan(roots: ReadonlyArray<ast.Node>, context: DedupeContext): Plan {
-  const { circularSchemas, usedNames } = context
-
-  const topLevelNodes = new Set<ast.SchemaNode>()
-
-  type Group = {
-    count: number
-    representative: ast.SchemaNode
-    topLevelNames: Array<string>
-  }
-  const groups = new Map<string, Group>()
-
-  for (const root of roots) {
-    if (root.kind === 'Schema') topLevelNodes.add(root)
-    for (const schemaNode of ast.collect<ast.SchemaNode>(root, { schema: (node) => node })) {
-      if (!isCandidate(schemaNode, circularSchemas)) continue
-
-      const signature = ast.signatureOf(schemaNode)
-      const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name
-      const group = groups.get(signature)
-      if (group) {
-        group.count++
-        if (isTopLevel) group.topLevelNames.push(schemaNode.name!)
-      } else {
-        groups.set(signature, { count: 1, representative: schemaNode, topLevelNames: isTopLevel ? [schemaNode.name!] : [] })
-      }
-    }
-  }
-
-  const bySignature = new Map<string, Target>()
-  const byName = new Map<string, Target>()
-  const pendingExtractions: Array<{ name: string; representative: ast.SchemaNode }> = []
-
-  for (const [signature, group] of groups) {
-    if (group.count < MIN_OCCURRENCES) continue
-
-    const [firstName, ...duplicateNames] = group.topLevelNames
-    if (firstName) {
-      const target: Target = { name: firstName, ref: `${SCHEMA_REF_PREFIX}${firstName}` }
-      bySignature.set(signature, target)
-      for (const duplicate of duplicateNames) {
-        byName.set(duplicate, target)
-      }
-      continue
-    }
-
-    const name = nameFor(group.representative, usedNames)
-    if (!name) continue
-
-    bySignature.set(signature, { name, ref: `${SCHEMA_REF_PREFIX}${name}` })
-    pendingExtractions.push({ name, representative: group.representative })
-  }
-
-  // Rewrites a node against the resolved targets. `skipRootMatch` keeps a definition's own root from
-  // turning into a reference to itself. Nested duplicates are still collapsed.
-  function rewrite<T extends ast.Node>(node: T, skipRootMatch: boolean): T {
-    if (bySignature.size === 0 && byName.size === 0) return node
-
-    const root = node
-
-    return ast.transform(node, {
-      schema(schemaNode) {
-        if (schemaNode.type === 'ref') {
-          const refName = schemaNode.ref ? extractRefName(schemaNode.ref) : schemaNode.name
-          const target = refName ? byName.get(refName) : undefined
-
-          return target ? { ...schemaNode, name: target.name, ref: target.ref } : undefined
-        }
-
-        if (skipRootMatch && schemaNode === root) return undefined
-
-        const target = bySignature.get(ast.signatureOf(schemaNode))
-        if (!target) return undefined
-
-        return createRefNode(schemaNode, target)
-      },
-    }) as T
-  }
-
-  // Build extracted definitions only after every target name is known, so nested
-  // duplicates inside a definition also resolve to refs.
-  const extracted = pendingExtractions.map(({ name, representative }) => cleanDefinition(rewrite(representative, true), name))
-
-  return {
-    extracted,
-    apply<T extends ast.Node>(node: T): T {
-      return rewrite(node, false)
-    },
-    applyTopLevel(node: ast.SchemaNode): ast.SchemaNode {
-      const target = bySignature.get(ast.signatureOf(node))
-      if (target && target.name !== node.name) {
-        return ast.factory.createSchema({
-          type: 'ref',
-          name: node.name ?? null,
-          ref: target.ref,
-          description: node.description,
-          deprecated: node.deprecated,
-        })
-      }
-
-      return rewrite(node, true)
-    },
-    isAlias(name: string): boolean {
-      return byName.has(name)
-    },
-  }
-}

package/src/dialect.ts

@@ -1,42 +0,0 @@
-import { ast } from '@kubb/core'
-import { plan } from './dedupe.ts'
-import { isDiscriminator, isNullable, isReference } from './guards.ts'
-import { resolveRef } from './refs.ts'
-import type { SchemaObject } from './types.ts'
-
-/**
- * The OpenAPI / Swagger dialect, the default used by `@kubb/adapter-oas`.
- *
- * Implements the spec-agnostic {@link ast.SchemaDialect} contract: it isolates the
- * decisions that differ between specs (nullability, `$ref`, discriminator, binary,
- * ref resolution) so the converter pipeline and dispatch rules stay shared. A
- * future adapter (e.g. AsyncAPI) ships its own dialect, `type: ['null', …]`
- * nullability, no discriminator object, binary via `contentEncoding` and reuses
- * the rest unchanged.
- *
- * Formats (`uuid`, `email`, dates, …) are intentionally NOT here: they are shared
- * JSON Schema vocabulary, so the converters keep that common case.
- *
- * @example
- * ```ts
- * const parser = createSchemaParser(context)             // uses oasDialect
- * const parser = createSchemaParser(context, oasDialect) // explicit
- * ```
- */
-export const oasDialect = ast.defineDialect({
-  name: 'oas',
-  schema: {
-    isNullable,
-    isReference,
-    isDiscriminator,
-    isBinary: (schema: SchemaObject) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
-    resolveRef,
-  },
-  dedupe: { plan },
-})
-
-/**
- * The concrete dialect type for `@kubb/adapter-oas`. Keeps the OAS guard predicates
- * (`isReference`, `isDiscriminator`) intact so converters narrow schemas after a check.
- */
-export type OasDialect = typeof oasDialect

package/src/discriminator.ts

@@ -1,132 +0,0 @@
-import { ast } from '@kubb/core'
-import type { SchemaNodeByType } from '@kubb/ast'
-
-export type DiscriminatorTarget = {
-  propertyName: string
-  enumValues: Array<string | number | boolean>
-}
-
-/**
- * Maps each child schema name to its discriminator patch data by scanning the given
- * top-level AST schema nodes for union schemas that carry a `discriminatorPropertyName`.
- *
- * The streaming path calls this on a small pre-parsed subset of schemas (only the
- * discriminator parents) rather than on all schemas at once.
- */
-export function buildDiscriminatorChildMap(schemas: Array<ast.SchemaNode>): Map<string, DiscriminatorTarget> {
-  const childMap = new Map<string, DiscriminatorTarget>()
-
-  for (const schema of schemas) {
-    // Case 1: top-level schema is a union (oneOf/anyOf with discriminator)
-    // Case 2: top-level schema is an intersection wrapping a union (oneOf/anyOf + shared properties)
-    let unionNode = ast.narrowSchema(schema, 'union')
-
-    if (!unionNode) {
-      const intersectionMembers = ast.narrowSchema(schema, 'intersection')?.members
-      if (intersectionMembers) {
-        for (const m of intersectionMembers) {
-          const u = ast.narrowSchema(m, 'union')
-          if (u) {
-            unionNode = u
-            break
-          }
-        }
-      }
-    }
-
-    if (!unionNode?.discriminatorPropertyName || !unionNode.members) continue
-
-    const { discriminatorPropertyName, members } = unionNode
-
-    for (const member of members) {
-      // Members with a discriminant value are intersections: [RefSchemaNode, ObjectSchemaNode]
-      const intersectionNode = ast.narrowSchema(member, 'intersection')
-      if (!intersectionNode?.members) continue
-
-      let refNode: SchemaNodeByType['ref'] | null = null
-      let objNode: SchemaNodeByType['object'] | null = null
-
-      for (const m of intersectionNode.members) {
-        refNode ??= ast.narrowSchema(m, 'ref')
-        objNode ??= ast.narrowSchema(m, 'object')
-      }
-
-      if (!refNode?.name || !objNode) continue
-
-      const prop = objNode.properties.find((p) => p.name === discriminatorPropertyName)
-      const enumNode = prop ? ast.narrowSchema(prop.schema, 'enum') : null
-      if (!enumNode?.enumValues?.length) continue
-
-      const enumValues = enumNode.enumValues.filter((v): v is string | number | boolean => v !== null)
-      if (!enumValues.length) continue
-
-      const existing = childMap.get(refNode.name)
-      if (!existing) {
-        childMap.set(refNode.name, { propertyName: discriminatorPropertyName, enumValues: [...enumValues] })
-        continue
-      }
-      existing.enumValues.push(...enumValues)
-    }
-  }
-
-  return childMap
-}
-
-/**
- * Patches a single top-level `SchemaNode` with its discriminator entry (adds or replaces
- * the discriminant property). Used by the streaming path to apply patches inline per yield
- * without buffering all schemas.
- */
-export function patchDiscriminatorNode(node: ast.SchemaNode, entry: { propertyName: string; enumValues: Array<string | number | boolean> }): ast.SchemaNode {
-  const objectNode = ast.narrowSchema(node, 'object')
-  if (!objectNode) return node
-
-  const { propertyName, enumValues } = entry
-  const enumSchema = ast.factory.createSchema({ type: 'enum', enumValues })
-  const newProp = ast.factory.createProperty({ name: propertyName, required: true, schema: enumSchema })
-
-  const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName)
-  const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => (i === existingIdx ? newProp : p)) : [...objectNode.properties, newProp]
-
-  return { ...objectNode, properties: newProperties }
-}
-
-/**
- * Creates a single-property object schema used as a discriminator literal.
- *
- * @example
- * ```ts
- * createDiscriminantNode({ propertyName: 'type', value: 'dog' })
- * // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
- * ```
- */
-export function createDiscriminantNode({ propertyName, value }: { propertyName: string; value: string }): ast.SchemaNode {
-  return ast.factory.createSchema({
-    type: 'object',
-    primitive: 'object',
-    properties: [
-      ast.factory.createProperty({
-        name: propertyName,
-        schema: ast.factory.createSchema({
-          type: 'enum',
-          primitive: 'string',
-          enumValues: [value],
-        }),
-        required: true,
-      }),
-    ],
-  })
-}
-
-/**
- * Returns the discriminator key whose mapping value matches `ref`, or `null` when there is no match.
- *
- * @example
- * ```ts
- * findDiscriminator({ dog: '#/components/schemas/Dog' }, '#/components/schemas/Dog') // 'dog'
- * ```
- */
-export function findDiscriminator(mapping: Record<string, string> | undefined, ref: string | undefined): string | null {
-  if (!mapping || !ref) return null
-  return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null
-}

package/src/factory.ts

@@ -1,180 +0,0 @@
-import path from 'node:path'
-import { exists, mergeDeep, Url } from '@internals/utils'
-import { Diagnostics } from '@kubb/core'
-import type { AdapterSource } from '@kubb/core'
-import { compileErrors, validate } from '@readme/openapi-parser'
-import { parse } from 'yaml'
-import { bundleDocument } from './bundler.ts'
-import { MERGE_DEFAULT_TITLE, MERGE_DEFAULT_VERSION, MERGE_OPENAPI_VERSION } from './constants.ts'
-import { isOpenApiV2Document } from './guards.ts'
-import type { Document } from './types.ts'
-
-export type ParseOptions = {
-  canBundle?: boolean
-}
-
-export type ValidateDocumentOptions = {
-  throwOnError?: boolean
-}
-
-/**
- * Loads and bundles an OpenAPI document, returning the raw `Document`.
- *
- * Accepts a file path string or an already-parsed document object. File paths and URLs are
- * bundled via `api-ref-bundler`, hoisting external file schemas into named `components.schemas`
- * entries so generators can emit named types and imports. Swagger 2.0 documents are
- * automatically up-converted to OpenAPI 3.0 via `swagger2openapi`.
- *
- * @example
- * ```ts
- * const document = await parseDocument('./openapi.yaml')
- * const document = await parse(rawDocumentObject, { canBundle: false })
- * ```
- */
-export async function parseDocument(pathOrApi: string | Document, { canBundle = true }: ParseOptions = {}): Promise<Document> {
-  if (typeof pathOrApi === 'string' && canBundle) {
-    const bundled = await bundleDocument(pathOrApi)
-
-    return parseDocument(bundled, { canBundle: false })
-  }
-
-  // A string here is always inline YAML/JSON content: file paths and URLs are read and parsed by
-  // `bundleDocument` first. `yaml.parse` also parses JSON, since JSON is a subset of YAML.
-  const document = (typeof pathOrApi === 'string' ? parse(pathOrApi) : pathOrApi) as Document
-
-  if (isOpenApiV2Document(document)) {
-    const { default: swagger2openapi } = await import('swagger2openapi')
-    const { openapi } = await swagger2openapi.convertObj(document, {
-      anchors: true,
-    })
-
-    return openapi as Document
-  }
-
-  return document
-}
-
-/**
- * Deep-merges multiple OpenAPI documents into a single `Document`.
- *
- * Each document is parsed independently, then deep-merged into one in array order.
- * Throws when the input array is empty.
- *
- * @example
- * ```ts
- * const document = await mergeDocuments(['./pets.yaml', './orders.yaml'])
- * ```
- */
-export async function mergeDocuments(pathOrApi: Array<string | Document>): Promise<Document> {
-  const documents = await Promise.all(pathOrApi.map((p) => parseDocument(p, { canBundle: false })))
-
-  if (documents.length === 0) {
-    throw new Diagnostics.Error({
-      code: Diagnostics.code.inputRequired,
-      severity: 'error',
-      message: 'No OAS documents were provided for merging.',
-      help: 'Pass at least one path or document to `input.path`.',
-      location: { kind: 'config' },
-    })
-  }
-
-  const seed: Document = {
-    openapi: MERGE_OPENAPI_VERSION,
-    info: { title: MERGE_DEFAULT_TITLE, version: MERGE_DEFAULT_VERSION },
-    paths: {},
-    components: { schemas: {} },
-  } as Document
-
-  const merged = documents.reduce(
-    (acc, current) => mergeDeep(acc as Record<string, unknown>, current as Record<string, unknown>),
-    seed as Record<string, unknown>,
-  )
-
-  return parseDocument(merged as Document)
-}
-
-/**
- * Creates a `Document` from an `AdapterSource`.
- *
- * Handles all three source types:
- * - `{ type: 'path' }` resolves and bundles a local file path or remote URL.
- * - `{ type: 'paths' }` merges multiple file paths into a single document.
- * - `{ type: 'data' }` parses an inline string (YAML/JSON) or raw object.
- *
- * @example
- * ```ts
- * const document = await parseFromConfig({ type: 'path', path: './openapi.yaml' })
- * const document = await parseFromConfig({ type: 'data', data: '{"openapi":"3.0.0",...}' })
- * ```
- */
-export async function parseFromConfig(source: AdapterSource): Promise<Document> {
-  if (source.type === 'data') {
-    if (typeof source.data === 'object') {
-      return parseDocument(structuredClone(source.data) as Document)
-    }
-
-    return parseDocument(source.data as string, { canBundle: false })
-  }
-
-  if (source.type === 'paths') {
-    return mergeDocuments(source.paths)
-  }
-
-  // type === 'path'
-  if (Url.canParse(source.path)) {
-    return parseDocument(source.path)
-  }
-
-  const resolved = path.resolve(path.dirname(source.path), source.path)
-  await assertInputExists(resolved)
-  return parseDocument(resolved)
-}
-
-/**
- * Throws a coded `KUBB_INPUT_NOT_FOUND` diagnostic when a local input path does not exist.
- * URLs are skipped, and a malformed but readable file is left for `parseDocument` to surface
- * its parse error instead.
- */
-export async function assertInputExists(input: string): Promise<void> {
-  if (Url.canParse(input)) {
-    return
-  }
-  if (!(await exists(input))) {
-    throw new Diagnostics.Error({
-      code: Diagnostics.code.inputNotFound,
-      severity: 'error',
-      message: `Cannot read the file set in \`input.path\` (or via \`kubb generate PATH\`): ${input}`,
-      help: 'Check that the path exists and is readable, then set it in `input.path` or pass it as `kubb generate PATH`.',
-      location: { kind: 'config' },
-    })
-  }
-}
-
-/**
- * Validates an OpenAPI document using `@readme/openapi-parser` with colorized error output.
- *
- * @example
- * ```ts
- * await validateDocument(document)
- * ```
- */
-export async function validateDocument(document: Document, { throwOnError = false }: ValidateDocumentOptions = {}): Promise<void> {
-  try {
-    // `validate` dereferences its input in place, so clone to keep the cached document intact.
-    const result = await validate(structuredClone(document), {
-      validate: {
-        errors: { colorize: true },
-      },
-    })
-
-    if (!result.valid) {
-      throw new Error(compileErrors(result))
-    }
-  } catch (error) {
-    if (throwOnError) {
-      throw error
-    }
-
-    // Validation failures are non-fatal, mirror plugin-oas behavior
-  }
-}

package/src/guards.ts

@@ -1,68 +0,0 @@
-import { isPlainObject } from '@internals/utils'
-import type { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'
-import type { DiscriminatorObject, SchemaObject } from './types.ts'
-
-/**
- * Returns `true` when `doc` is a Swagger 2.0 document (no `openapi` key).
- *
- * @example
- * ```ts
- * if (isOpenApiV2Document(doc)) {
- *   // doc is OpenAPIV2.Document
- * }
- * ```
- */
-export function isOpenApiV2Document(doc: unknown): doc is OpenAPIV2.Document {
-  return !!doc && isPlainObject(doc) && !('openapi' in doc)
-}
-
-/**
- * Returns `true` when a schema should be treated as nullable.
- *
- * Recognizes all nullable signals across OAS versions: `nullable: true` (OAS 3.0),
- * `x-nullable: true` (vendor extension), `type: 'null'`, and `type: ['null', ...]` (OAS 3.1).
- *
- * @example
- * ```ts
- * isNullable({ type: 'string', nullable: true }) // true
- * isNullable({ type: ['string', 'null'] })       // true
- * isNullable({ type: 'string' })                 // false
- * ```
- */
-export function isNullable(schema?: SchemaObject & { 'x-nullable'?: boolean }): boolean {
-  const explicitNullable = schema?.nullable ?? schema?.['x-nullable']
-  if (explicitNullable === true) return true
-
-  const schemaType = schema?.type
-  if (schemaType === 'null') return true
-  if (Array.isArray(schemaType)) return schemaType.includes('null')
-
-  return false
-}
-
-/**
- * Returns `true` when `obj` is an OpenAPI `$ref` pointer object.
- *
- * @example
- * ```ts
- * isReference({ $ref: '#/components/schemas/Pet' }) // true
- * isReference({ type: 'string' })                   // false
- * ```
- */
-export function isReference(obj?: unknown): obj is OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject {
-  return !!obj && typeof obj === 'object' && '$ref' in obj
-}
-
-/**
- * Returns `true` when `obj` is a schema with a structured OAS 3.x `discriminator` object.
- *
- * @example
- * ```ts
- * isDiscriminator({ discriminator: { propertyName: 'type', mapping: {} } }) // true
- * isDiscriminator({ discriminator: 'type' })                                 // false (Swagger 2 string form)
- * ```
- */
-export function isDiscriminator(obj?: unknown): obj is SchemaObject & { discriminator: DiscriminatorObject } {
-  const record = obj as Record<string, unknown>
-  return !!obj && !!record['discriminator'] && typeof record['discriminator'] !== 'string'
-}

package/src/index.ts

@@ -1,15 +0,0 @@
-export { adapterOas, adapterOasName } from './adapter.ts'
-export type {
-  AdapterOas,
-  AdapterOasOptions,
-  AdapterOasResolvedOptions,
-  ContentType,
-  DiscriminatorObject,
-  Document,
-  HttpMethod,
-  MediaTypeObject,
-  Operation,
-  ReferenceObject,
-  ResponseObject,
-  SchemaObject,
-} from './types.ts'

package/src/mime.ts

@@ -1,21 +0,0 @@
-/**
- * MIME type fragments that mark a media type as JSON-like.
- *
- * A content type is JSON when it contains any of these substrings. The `+json` entry catches
- * structured-syntax suffixes such as `application/vnd.api+json`.
- */
-const jsonMimeFragments = ['application/json', 'application/x-json', 'text/json', 'text/x-json', '+json'] as const
-
-/**
- * Returns `true` when a media type string is JSON-like.
- *
- * @example
- * ```ts
- * isJsonMimeType('application/json')         // true
- * isJsonMimeType('application/vnd.api+json') // true
- * isJsonMimeType('multipart/form-data')      // false
- * ```
- */
-export function isJsonMimeType(mimeType: string): boolean {
-  return jsonMimeFragments.some((fragment) => mimeType.includes(fragment))
-}