@skmtc/core 0.29.0 → 0.31.0

package/esm/_dnt.polyfills.d.ts

@@ -4,6 +4,17 @@ declare global {
     }
 }
 export {};
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};
 /**
  * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
  * but instead of using npm to install additional dependencies,

package/esm/_dnt.polyfills.js

@@ -1,3 +1,17 @@
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
 /**
  * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
  * but instead of using npm to install additional dependencies,

package/esm/context/ParseContext.js

@@ -29,6 +29,7 @@ import "../_dnt.polyfills.js";
 import { buildSchema } from 'graphql';
 import { toDocumentFieldsV3 } from '../parse/v3-0/document/toDocumentFieldsV3.js';
 import { toDocumentFieldsV3 as toDocumentFieldsV31 } from '../parse/v3-1/document/toDocumentFieldsV3.js';
+import { toDocumentFieldsV3 as toDocumentFieldsV32 } from '../parse/v3-2/document/toDocumentFieldsV3.js';
 import { toOasDialect } from '../parse/toOasDialect.js';
 import { OasDocument } from '../oas/document/Document.js';
 import { GqlRegistry } from '../gql/registry/GqlRegistry.js';
@@ -184,7 +185,7 @@ export class ParseContext {
                 const oasState = this.protocol;
                 // The ONE place the OpenAPI version is examined: pick the dialect's
                 // parser tree. Everything downstream is version-specific code living
-                // in its own tree (v3-0 / v3-1) and never re-checks the version.
+                // in its own tree (v3-0 / v3-1 / v3-2) and never re-checks the version.
                 const dialect = toOasDialect(oasState.documentObject.openapi);
                 switch (dialect) {
                     case '3.0':
@@ -201,6 +202,13 @@ export class ParseContext {
                             context: this
                         });
                         break;
+                    case '3.2':
+                        oasState.oasDocument.fields = toDocumentFieldsV32({
+                            documentObject: oasState.documentObject,
+                            stackTrail,
+                            context: this
+                        });
+                        break;
                     default: {
                         const _exhaustive = dialect;
                         throw new Error(`Unhandled OAS dialect: ${JSON.stringify(_exhaustive)}`);

package/esm/context/generateTypes.d.ts

@@ -154,8 +154,20 @@ export type AnyOasDocument = OpenAPIV2.Document | OpenAPIV3.Document | OpenAPIV3
  * The TS type and the valibot schema below stay in sync via the
  * `v.GenericSchema<OasIssueType>` annotation — adding a variant in one
  * place without the other fails to type-check.
+ *
+ * Media type issues, at most one per response or request body, from the
+ * choice `toJsonContent` makes on its parsed `content`:
+ *
+ * - `WILDCARD_MEDIA_TYPE` (`warning`) — the body has no JSON media type
+ *   (see `isJsonMediaType`) and is read from `*\/*` as JSON, since its schema
+ *   there is an object, array, union or `$ref`. The document does not say the
+ *   format; springdoc writes `*\/*` for every response.
+ * - `NO_JSON_MEDIA_TYPE` (`debug`) — no lookup without a media type reads the
+ *   body, and its keys include a range: `application/*`, or `*\/*` with a
+ *   scalar schema (a text body or a file). A body with only specific
+ *   non-JSON types (`multipart/form-data`, `text/plain`) logs nothing.
  */
-export type OasIssueType = 'UNEXPECTED_PROPERTY' | 'MISSING_OBJECT_TYPE' | 'MISSING_STRING_TYPE' | 'MISSING_ARRAY_TYPE' | 'MISSING_BOOLEAN_TYPE' | 'INVALID_EXAMPLE' | 'INVALID_ENUM' | 'INVALID_DEFAULT' | 'INVALID_NULLABLE' | 'UNEXPECTED_FORMAT' | 'INVALID_RESPONSE' | 'INVALID_FORMAT' | 'INVALID_OPERATION' | 'INVALID_SCHEMA' | 'INVALID_PARAMETER' | 'INVALID_SECURITY_SCHEME' | 'INVALID_DEPENDENCY_REF' | 'EXAMPLE_AND_EXAMPLES_DEFINED';
+export type OasIssueType = 'UNEXPECTED_PROPERTY' | 'MISSING_OBJECT_TYPE' | 'MISSING_STRING_TYPE' | 'MISSING_ARRAY_TYPE' | 'MISSING_BOOLEAN_TYPE' | 'INVALID_EXAMPLE' | 'INVALID_ENUM' | 'INVALID_DEFAULT' | 'INVALID_NULLABLE' | 'UNEXPECTED_FORMAT' | 'INVALID_RESPONSE' | 'INVALID_FORMAT' | 'INVALID_OPERATION' | 'INVALID_SCHEMA' | 'INVALID_PARAMETER' | 'INVALID_SECURITY_SCHEME' | 'INVALID_DEPENDENCY_REF' | 'EXAMPLE_AND_EXAMPLES_DEFINED' | 'INVALID_TAG_PARENT' | 'UNSUPPORTED_OPERATION_METHOD' | 'WILDCARD_MEDIA_TYPE' | 'NO_JSON_MEDIA_TYPE';
 /**
  * Valibot schema for {@link OasIssueType}. Annotation deliberately omitted
  * so the precise literal-union output type flows through to consumers
@@ -163,7 +175,7 @@ export type OasIssueType = 'UNEXPECTED_PROPERTY' | 'MISSING_OBJECT_TYPE' | 'MISS
  * this list and {@link OasIssueType} is caught by `assertSchemaMatchesType`
  * below.
  */
-export declare const oasIssueType: v.UnionSchema<[v.LiteralSchema<"UNEXPECTED_PROPERTY", undefined>, v.LiteralSchema<"MISSING_OBJECT_TYPE", undefined>, v.LiteralSchema<"MISSING_STRING_TYPE", undefined>, v.LiteralSchema<"MISSING_ARRAY_TYPE", undefined>, v.LiteralSchema<"MISSING_BOOLEAN_TYPE", undefined>, v.LiteralSchema<"INVALID_EXAMPLE", undefined>, v.LiteralSchema<"INVALID_ENUM", undefined>, v.LiteralSchema<"INVALID_DEFAULT", undefined>, v.LiteralSchema<"INVALID_NULLABLE", undefined>, v.LiteralSchema<"UNEXPECTED_FORMAT", undefined>, v.LiteralSchema<"INVALID_RESPONSE", undefined>, v.LiteralSchema<"INVALID_FORMAT", undefined>, v.LiteralSchema<"INVALID_OPERATION", undefined>, v.LiteralSchema<"INVALID_SCHEMA", undefined>, v.LiteralSchema<"INVALID_PARAMETER", undefined>, v.LiteralSchema<"INVALID_SECURITY_SCHEME", undefined>, v.LiteralSchema<"INVALID_DEPENDENCY_REF", undefined>, v.LiteralSchema<"EXAMPLE_AND_EXAMPLES_DEFINED", undefined>], undefined>;
+export declare const oasIssueType: v.UnionSchema<[v.LiteralSchema<"UNEXPECTED_PROPERTY", undefined>, v.LiteralSchema<"MISSING_OBJECT_TYPE", undefined>, v.LiteralSchema<"MISSING_STRING_TYPE", undefined>, v.LiteralSchema<"MISSING_ARRAY_TYPE", undefined>, v.LiteralSchema<"MISSING_BOOLEAN_TYPE", undefined>, v.LiteralSchema<"INVALID_EXAMPLE", undefined>, v.LiteralSchema<"INVALID_ENUM", undefined>, v.LiteralSchema<"INVALID_DEFAULT", undefined>, v.LiteralSchema<"INVALID_NULLABLE", undefined>, v.LiteralSchema<"UNEXPECTED_FORMAT", undefined>, v.LiteralSchema<"INVALID_RESPONSE", undefined>, v.LiteralSchema<"INVALID_FORMAT", undefined>, v.LiteralSchema<"INVALID_OPERATION", undefined>, v.LiteralSchema<"INVALID_SCHEMA", undefined>, v.LiteralSchema<"INVALID_PARAMETER", undefined>, v.LiteralSchema<"INVALID_SECURITY_SCHEME", undefined>, v.LiteralSchema<"INVALID_DEPENDENCY_REF", undefined>, v.LiteralSchema<"EXAMPLE_AND_EXAMPLES_DEFINED", undefined>, v.LiteralSchema<"INVALID_TAG_PARENT", undefined>, v.LiteralSchema<"UNSUPPORTED_OPERATION_METHOD", undefined>, v.LiteralSchema<"WILDCARD_MEDIA_TYPE", undefined>, v.LiteralSchema<"NO_JSON_MEDIA_TYPE", undefined>], undefined>;
 export type GenerateResult = {
     files: Map<string, FileBase>;
     previews: Record<string, Preview>;

package/esm/context/generateTypes.js

@@ -24,7 +24,11 @@ export const oasIssueType = v.union([
     v.literal('INVALID_PARAMETER'),
     v.literal('INVALID_SECURITY_SCHEME'),
     v.literal('INVALID_DEPENDENCY_REF'),
-    v.literal('EXAMPLE_AND_EXAMPLES_DEFINED')
+    v.literal('EXAMPLE_AND_EXAMPLES_DEFINED'),
+    v.literal('INVALID_TAG_PARENT'),
+    v.literal('UNSUPPORTED_OPERATION_METHOD'),
+    v.literal('WILDCARD_MEDIA_TYPE'),
+    v.literal('NO_JSON_MEDIA_TYPE')
 ]);
 // Compile-time drift detector: this binding fails to type-check if
 // `OasIssueType` and the literal list above disagree in either

package/esm/dsl/GeneratorKeys.d.ts

@@ -466,8 +466,8 @@ export declare const isGeneratorKey: (arg: unknown) => arg is GeneratorKey;
  * Type guard to check if a value is a valid OasOperationGeneratorKey.
  *
  * Validates that the argument is a string with the correct format:
- * `generatorId|path|method` where each part is non-empty and method
- * is a valid HTTP method.
+ * `generatorId|path|method|variant` where each part is non-empty, path
+ * starts with `/` and method is a valid HTTP method.
  *
  * @param arg - Value to check
  * @returns True if the value is a valid OasOperationGeneratorKey

package/esm/dsl/GeneratorKeys.js

@@ -253,8 +253,8 @@ export const isGeneratorKey = (arg) => {
  * Type guard to check if a value is a valid OasOperationGeneratorKey.
  *
  * Validates that the argument is a string with the correct format:
- * `generatorId|path|method` where each part is non-empty and method
- * is a valid HTTP method.
+ * `generatorId|path|method|variant` where each part is non-empty, path
+ * starts with `/` and method is a valid HTTP method.
  *
  * @param arg - Value to check
  * @returns True if the value is a valid OasOperationGeneratorKey
@@ -285,7 +285,10 @@ export const isOasOperationGeneratorKey = (arg) => {
     if (typeof generatorId !== 'string' || !generatorId.length) {
         return false;
     }
-    if (typeof path !== 'string' || !path.length) {
+    // An OpenAPI path starts with `/`. Checking it keeps a GraphQL key whose
+    // field name is also an HTTP method (`gen|mutation|query|main`) from
+    // parsing as an operation.
+    if (typeof path !== 'string' || !path.startsWith('/')) {
         return false;
     }
     if (!isMethod(method)) {

package/esm/helpers/naming.d.ts

@@ -4,7 +4,7 @@ import type { Method } from '../types/Method.js';
  * Determines the endpoint type based on HTTP method.
  *
  * @param operation - The OpenAPI operation to analyze
- * @returns 'query' for GET operations, 'mutation' for all others
+ * @returns 'query' for GET and QUERY operations, 'mutation' for all others
  *
  * @example
  * ```typescript
@@ -67,6 +67,7 @@ export declare const toArgsName: (operation: OasOperation) => string;
  * console.log(toMethodVerb('put'));  // 'Update'
  * console.log(toMethodVerb('get'));  // 'get'
  * console.log(toMethodVerb('delete')); // 'delete'
+ * console.log(toMethodVerb('query')); // 'Query'
  * ```
  */
 export declare const toMethodVerb: (method: Method) => string;

package/esm/helpers/naming.js

@@ -3,7 +3,7 @@ import { camelCase, capitalize } from './strings.js';
  * Determines the endpoint type based on HTTP method.
  *
  * @param operation - The OpenAPI operation to analyze
- * @returns 'query' for GET operations, 'mutation' for all others
+ * @returns 'query' for GET and QUERY operations, 'mutation' for all others
  *
  * @example
  * ```typescript
@@ -15,7 +15,8 @@ import { camelCase, capitalize } from './strings.js';
  * ```
  */
 export const toEndpointType = (operation) => {
-    return operation.method === 'get' ? 'query' : 'mutation';
+    // QUERY is safe and idempotent, like GET.
+    return operation.method === 'get' || operation.method === 'query' ? 'query' : 'mutation';
 };
 /**
  * Generates endpoint name in the `camelCase{method}Api{path}` format.
@@ -78,6 +79,7 @@ export const toArgsName = (operation) => {
  * console.log(toMethodVerb('put'));  // 'Update'
  * console.log(toMethodVerb('get'));  // 'get'
  * console.log(toMethodVerb('delete')); // 'delete'
+ * console.log(toMethodVerb('query')); // 'Query'
  * ```
  */
 export const toMethodVerb = (method) => {

package/esm/mod.d.ts

@@ -146,6 +146,7 @@ export * from './oas/info/info-types.js';
 export * from './oas/license/License.js';
 export * from './oas/license/license-types.js';
 export * from './oas/mediaType/MediaType.js';
+export * from './oas/mediaType/jsonMediaType.js';
 export * from './oas/integer/Integer.js';
 export * from './oas/integer/integer-types.js';
 export * from './parse/v3-0/integer/toInteger.js';

package/esm/mod.js

@@ -146,6 +146,7 @@ export * from './oas/info/info-types.js';
 export * from './oas/license/License.js';
 export * from './oas/license/license-types.js';
 export * from './oas/mediaType/MediaType.js';
+export * from './oas/mediaType/jsonMediaType.js';
 export * from './oas/integer/Integer.js';
 export * from './oas/integer/integer-types.js';
 export * from './parse/v3-0/integer/toInteger.js';

package/esm/oas/discriminator/Discriminator.d.ts

@@ -2,10 +2,13 @@ import "../../_dnt.polyfills.js";
 export type DiscriminatorFields = {
     propertyName: string;
     mapping?: Record<string, string>;
+    /** Schema to use when the discriminating value has no mapping entry (OpenAPI 3.2) */
+    defaultMapping?: string;
 };
 export declare class OasDiscriminator {
     oasType: 'discriminator';
     propertyName: string;
     mapping?: Record<string, string>;
+    defaultMapping?: string;
     constructor(fields: DiscriminatorFields);
 }

package/esm/oas/discriminator/Discriminator.js

@@ -19,7 +19,14 @@ export class OasDiscriminator {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "defaultMapping", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.propertyName = fields.propertyName;
         this.mapping = fields.mapping;
+        this.defaultMapping = fields.defaultMapping;
     }
 }

package/esm/oas/document/Document.d.ts

@@ -20,6 +20,11 @@ import type { OasExternalDocs } from '../externalDocs/ExternalDocs.js';
 export type DocumentFields = {
     /** OpenAPI specification version (e.g., '3.0.0', '3.1.0') */
     openapi: string;
+    /**
+     * The document's own URI (OpenAPI 3.2 `$self`). Stored only: reference
+     * resolution does not use it.
+     */
+    $self?: string | undefined;
     /** API metadata including title, version, description */
     info: OasInfo;
     /** Array of server objects providing connectivity information */
@@ -215,6 +220,8 @@ export declare class OasDocument {
     set fields(fields: DocumentFields);
     /** OpenAPI specification version */
     get openapi(): string;
+    /** The document's own URI (OpenAPI 3.2 `$self`) */
+    get $self(): string | undefined;
     /** API metadata */
     get info(): OasInfo;
     get servers(): OasServer[] | undefined;

package/esm/oas/document/Document.js

@@ -225,6 +225,13 @@ export class OasDocument {
         }
         return __classPrivateFieldGet(this, _OasDocument_fields, "f").openapi;
     }
+    /** The document's own URI (OpenAPI 3.2 `$self`) */
+    get $self() {
+        if (!__classPrivateFieldGet(this, _OasDocument_fields, "f")) {
+            throw new Error(`Accessing '$self' before fields are set`);
+        }
+        return __classPrivateFieldGet(this, _OasDocument_fields, "f").$self;
+    }
     /** API metadata */
     get info() {
         if (!__classPrivateFieldGet(this, _OasDocument_fields, "f")) {
@@ -311,6 +318,7 @@ export class OasDocument {
     toJSON() {
         return {
             openapi: this.openapi,
+            ...(this.$self !== undefined ? { $self: this.$self } : {}),
             info: this.info,
             servers: this.servers,
             operations: this.operations,

package/esm/oas/example/Example.d.ts

@@ -11,6 +11,10 @@ export type ExampleFields = {
     description?: string;
     /** The example value — absent when the example is given as an `externalValue` */
     value?: unknown;
+    /** The example as data that is valid against its schema (OpenAPI 3.2) */
+    dataValue?: unknown;
+    /** The example in its serialized form (OpenAPI 3.2) */
+    serializedValue?: string;
     /** The external value of the example */
     externalValue?: string;
     /** Custom extension fields (x-* properties) */
@@ -23,6 +27,8 @@ export declare class OasExample {
     summary?: string;
     description?: string;
     value?: unknown;
+    dataValue?: unknown;
+    serializedValue?: string;
     externalValue?: string;
     extensionFields?: Record<string, unknown>;
     constructor(fields: ExampleFields);
@@ -31,5 +37,8 @@ export declare class OasExample {
     /** Returns itself */
     resolve(): OasExample;
     resolveOnce(): OasExample;
-    toJsonSchema(_options: ToJsonSchemaOptions): OpenAPIV3.ExampleObject;
+    toJsonSchema(_options: ToJsonSchemaOptions): OpenAPIV3.ExampleObject & {
+        dataValue?: unknown;
+        serializedValue?: string;
+    };
 }

package/esm/oas/example/Example.js

@@ -26,6 +26,18 @@ export class OasExample {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "dataValue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "serializedValue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "externalValue", {
             enumerable: true,
             configurable: true,
@@ -41,6 +53,8 @@ export class OasExample {
         this.summary = fields.summary;
         this.description = fields.description;
         this.value = fields.value;
+        this.dataValue = fields.dataValue;
+        this.serializedValue = fields.serializedValue;
         this.externalValue = fields.externalValue;
         this.extensionFields = fields.extensionFields;
     }
@@ -60,6 +74,8 @@ export class OasExample {
             summary: this.summary,
             description: this.description,
             value: this.value,
+            ...(this.dataValue !== undefined ? { dataValue: this.dataValue } : {}),
+            ...(this.serializedValue !== undefined ? { serializedValue: this.serializedValue } : {}),
             // Without this an `externalValue`-only example round-trips to an Example
             // Object holding neither an inline value nor a pointer to one.
             externalValue: this.externalValue

package/esm/oas/header/Header.d.ts

@@ -77,9 +77,11 @@ export declare class OasHeader {
     resolve(): OasHeader;
     resolveOnce(): OasHeader;
     /** Returns schema for the header. Either, `schema` property if
-     * definedor value matching `mediaType` from `content` property.
+     * defined or value matching `mediaType` from `content` property. When
+     * `content` has exactly one entry (the spec requires one), its schema is
+     * used whatever the media type, as in `OasParameter.toSchema`.
      *
-     * @param mediaType - Optional media type to get schema for. Defaults to `application/json`
+     * @param mediaType - Optional media type to get schema for, an exact lookup. Omitted: the JSON media type (`application/json`, else the first JSON-like type, else `*\/*`).
      */
     toSchema(mediaType?: string): OasSchema | OasRef<'schema'>;
     toJsonSchema(options: ToJsonSchemaOptions): OpenAPIV3.HeaderObject;

package/esm/oas/header/Header.js

@@ -1,3 +1,4 @@
+import { toContentSchema } from '../mediaType/toContentSchema.js';
 /**
  * Represents a Header Object in the OpenAPI Specification.
  *
@@ -106,17 +107,23 @@ export class OasHeader {
         return this;
     }
     /** Returns schema for the header. Either, `schema` property if
-     * definedor value matching `mediaType` from `content` property.
+     * defined or value matching `mediaType` from `content` property. When
+     * `content` has exactly one entry (the spec requires one), its schema is
+     * used whatever the media type, as in `OasParameter.toSchema`.
      *
-     * @param mediaType - Optional media type to get schema for. Defaults to `application/json`
+     * @param mediaType - Optional media type to get schema for, an exact lookup. Omitted: the JSON media type (`application/json`, else the first JSON-like type, else `*\/*`).
      */
-    toSchema(mediaType = 'application/json') {
+    toSchema(mediaType) {
         if (this.schema) {
             return this.schema;
         }
-        const schema = this.content?.[mediaType]?.schema;
+        const contentEntries = Object.values(this.content ?? {});
+        const onlyEntry = contentEntries.length === 1 ? contentEntries[0] : undefined;
+        const schema = toContentSchema(this.content, mediaType) ?? onlyEntry?.schema;
         if (!schema) {
-            throw new Error(`Schema not found for media type ${mediaType}`);
+            throw new Error(mediaType === undefined
+                ? 'Schema not found for a JSON media type'
+                : `Schema not found for media type "${mediaType}"`);
         }
         return schema;
     }

package/esm/oas/mediaType/MediaType.d.ts

@@ -13,12 +13,18 @@ export type MediaTypeFields = {
     mediaType: string;
     /** The schema defining the structure of the content */
     schema?: OasSchema | OasRef<'schema'> | undefined;
+    /** The schema of each item in a sequential media type (OpenAPI 3.2) */
+    itemSchema?: OasSchema | OasRef<'schema'> | undefined;
     /** Example values for the media type */
     examples?: Record<string, OasExample | OasRef<'example'>> | undefined;
     /** Custom extension fields (x-* properties) */
     extensionFields?: Record<string, unknown>;
     /** Encoding information for multipart or form data */
     encoding?: Record<string, unknown> | undefined;
+    /** Positional Encoding Objects for a multipart array (OpenAPI 3.2) */
+    prefixEncoding?: Record<string, unknown>[] | undefined;
+    /** Encoding Object for each array item (OpenAPI 3.2) */
+    itemEncoding?: Record<string, unknown> | undefined;
 };
 /**
  * Represents a Media Type Object in the OpenAPI Specification.
@@ -104,12 +110,18 @@ export declare class OasMediaType extends OasBase {
     mediaType: string;
     /** The schema defining the structure and validation rules for the content */
     schema: OasSchema | OasRef<'schema'> | undefined;
+    /** The schema of each item in a sequential media type (OpenAPI 3.2) */
+    itemSchema: OasSchema | OasRef<'schema'> | undefined;
     /** Example values demonstrating the media type content */
     examples: Record<string, OasExample | OasRef<'example'>> | undefined;
     /** Custom extension fields (x-* properties) defined for this media type */
     extensionFields: Record<string, unknown> | undefined;
     /** Encoding information for multipart and form data serialization */
     encoding?: Record<string, unknown> | undefined;
+    /** Positional Encoding Objects for a multipart array (OpenAPI 3.2), stored as-is */
+    prefixEncoding?: Record<string, unknown>[] | undefined;
+    /** Encoding Object for each array item (OpenAPI 3.2), stored as-is */
+    itemEncoding?: Record<string, unknown> | undefined;
     /**
      * Creates a new OasMediaType instance.
      *

package/esm/oas/mediaType/MediaType.js

@@ -105,6 +105,13 @@ export class OasMediaType extends OasBase {
             writable: true,
             value: void 0
         });
+        /** The schema of each item in a sequential media type (OpenAPI 3.2) */
+        Object.defineProperty(this, "itemSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /** Example values demonstrating the media type content */
         Object.defineProperty(this, "examples", {
             enumerable: true,
@@ -126,10 +133,27 @@ export class OasMediaType extends OasBase {
             writable: true,
             value: void 0
         });
+        /** Positional Encoding Objects for a multipart array (OpenAPI 3.2), stored as-is */
+        Object.defineProperty(this, "prefixEncoding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Encoding Object for each array item (OpenAPI 3.2), stored as-is */
+        Object.defineProperty(this, "itemEncoding", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.mediaType = fields.mediaType;
         this.schema = fields.schema;
+        this.itemSchema = fields.itemSchema;
         this.examples = fields.examples;
         this.encoding = fields.encoding;
+        this.prefixEncoding = fields.prefixEncoding;
+        this.itemEncoding = fields.itemEncoding;
         this.extensionFields = fields.extensionFields;
     }
     /**

package/esm/oas/mediaType/jsonMediaType.d.ts

@@ -0,0 +1,50 @@
+import type { OasRef } from '../ref/Ref.js';
+import type { OasSchema } from '../schema/Schema.js';
+import type { OasMediaType } from './MediaType.js';
+/**
+ * The media type without its parameters, trimmed and lowercased:
+ * `Application/JSON; charset=utf-8` → `application/json`.
+ */
+export declare const toMediaTypeEssence: (mediaType: string) => string;
+/**
+ * True when a body of this media type is one JSON value: `application/json`,
+ * or any `application/…+json` (the RFC 6839 structured syntax suffix, e.g.
+ * `application/vnd.api+json`, `application/ld+json`,
+ * `application/problem+json`). Parameters and case are ignored, so
+ * `application/json;v=1.0` is JSON.
+ *
+ * False for everything else, including:
+ * - `text/json`: not registered; RFC 8259 registers only `application/json`.
+ * - `application/x-ndjson`, `application/jsonl`: a stream of JSON values, not
+ *   one value.
+ * - ranges such as `*\/*`, `application/*` and `application/*+json`: they do
+ *   not name one type.
+ * - names without the suffix, such as `application/vnd.goa.error`, even when
+ *   the API sends JSON under them.
+ */
+export declare const isJsonMediaType: (mediaType: string) => boolean;
+/** True when the media type is the full range `*\/*`, parameters and case ignored. */
+export declare const isAnyMediaType: (mediaType: string) => boolean;
+/** The media type a body is read from, and its schema. */
+export type JsonContent = {
+    /** The key in `content`: a JSON-like media type, or `*\/*` (with any parameters). */
+    mediaType: string;
+    /**
+     * The media type to send or expect the body as: `mediaType` when it is
+     * JSON-like, `application/json` when the body is read from `*\/*`.
+     */
+    contentType: string;
+    schema: OasSchema | OasRef<'schema'> | undefined;
+};
+/**
+ * Choose the media type a body is read from: `application/json` exactly when
+ * it is a key, else the first JSON-like key in document order (see
+ * {@link isJsonMediaType}), else the `*\/*` key when its schema is an object,
+ * array, union or `$ref`. `*\/*` admits JSON, and documents use it for JSON
+ * bodies (springdoc writes it for every response); the parser logs
+ * `WILDCARD_MEDIA_TYPE` for every body read this way. `undefined` otherwise:
+ * there is no fall back to a specific non-JSON type, to a narrower range such
+ * as `application/*`, or to a scalar schema under `*\/*`, since a consumer
+ * would read that body as JSON.
+ */
+export declare const toJsonContent: (content: Record<string, OasMediaType> | undefined) => JsonContent | undefined;

package/esm/oas/mediaType/jsonMediaType.js

@@ -0,0 +1,64 @@
+/**
+ * The media type without its parameters, trimmed and lowercased:
+ * `Application/JSON; charset=utf-8` → `application/json`.
+ */
+export const toMediaTypeEssence = (mediaType) => (mediaType.split(';')[0] ?? '').trim().toLowerCase();
+/**
+ * True when a body of this media type is one JSON value: `application/json`,
+ * or any `application/…+json` (the RFC 6839 structured syntax suffix, e.g.
+ * `application/vnd.api+json`, `application/ld+json`,
+ * `application/problem+json`). Parameters and case are ignored, so
+ * `application/json;v=1.0` is JSON.
+ *
+ * False for everything else, including:
+ * - `text/json`: not registered; RFC 8259 registers only `application/json`.
+ * - `application/x-ndjson`, `application/jsonl`: a stream of JSON values, not
+ *   one value.
+ * - ranges such as `*\/*`, `application/*` and `application/*+json`: they do
+ *   not name one type.
+ * - names without the suffix, such as `application/vnd.goa.error`, even when
+ *   the API sends JSON under them.
+ */
+export const isJsonMediaType = (mediaType) => {
+    const essence = toMediaTypeEssence(mediaType);
+    return essence === 'application/json' || /^application\/[^/*\s]+\+json$/.test(essence);
+};
+/** True when the media type is the full range `*\/*`, parameters and case ignored. */
+export const isAnyMediaType = (mediaType) => toMediaTypeEssence(mediaType) === '*/*';
+/**
+ * True when a schema under `*\/*` can be read as one JSON value: an object,
+ * array, union or `$ref`. A scalar is not: under `*\/*` a `string` is usually
+ * a text body, and `string` with `format: binary` a file.
+ */
+const isJsonShaped = (schema) => schema !== undefined &&
+    (schema.isRef() || schema.type === 'object' || schema.type === 'array' || schema.type === 'union');
+/**
+ * Choose the media type a body is read from: `application/json` exactly when
+ * it is a key, else the first JSON-like key in document order (see
+ * {@link isJsonMediaType}), else the `*\/*` key when its schema is an object,
+ * array, union or `$ref`. `*\/*` admits JSON, and documents use it for JSON
+ * bodies (springdoc writes it for every response); the parser logs
+ * `WILDCARD_MEDIA_TYPE` for every body read this way. `undefined` otherwise:
+ * there is no fall back to a specific non-JSON type, to a narrower range such
+ * as `application/*`, or to a scalar schema under `*\/*`, since a consumer
+ * would read that body as JSON.
+ */
+export const toJsonContent = (content) => {
+    if (!content) {
+        return undefined;
+    }
+    const mediaTypes = Object.keys(content);
+    const jsonMediaType = 'application/json' in content ? 'application/json' : mediaTypes.find(isJsonMediaType);
+    if (jsonMediaType !== undefined) {
+        return {
+            mediaType: jsonMediaType,
+            contentType: jsonMediaType,
+            schema: content[jsonMediaType]?.schema
+        };
+    }
+    const anyMediaType = mediaTypes.find(isAnyMediaType);
+    const schema = anyMediaType === undefined ? undefined : content[anyMediaType]?.schema;
+    return anyMediaType !== undefined && isJsonShaped(schema)
+        ? { mediaType: anyMediaType, contentType: 'application/json', schema }
+        : undefined;
+};

package/esm/oas/mediaType/toContentSchema.d.ts

@@ -0,0 +1,8 @@
+import type { OasRef } from '../ref/Ref.js';
+import type { OasSchema } from '../schema/Schema.js';
+import type { OasMediaType } from './MediaType.js';
+/**
+ * The schema a `toSchema(mediaType?)` lookup returns: an exact key lookup when
+ * `mediaType` is given, else the schema of `toJsonContent`.
+ */
+export declare const toContentSchema: (content: Record<string, OasMediaType> | undefined, mediaType: string | undefined) => OasSchema | OasRef<"schema"> | undefined;

package/esm/oas/mediaType/toContentSchema.js

@@ -0,0 +1,6 @@
+import { toJsonContent } from './jsonMediaType.js';
+/**
+ * The schema a `toSchema(mediaType?)` lookup returns: an exact key lookup when
+ * `mediaType` is given, else the schema of `toJsonContent`.
+ */
+export const toContentSchema = (content, mediaType) => mediaType === undefined ? toJsonContent(content)?.schema : content?.[mediaType]?.schema;