@skmtc/core 0.28.7 → 0.30.1

package/script/parse/v3-2/example/toExamplesV3.d.ts

@@ -0,0 +1,77 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasExample } from '../../../oas/example/Example.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/** A 3.2 Example Object: the 3.0 shape plus `dataValue` and `serializedValue`. */
+export type ExampleObjectV32 = OpenAPIV3.ExampleObject & {
+    dataValue?: unknown;
+    serializedValue?: string;
+};
+export type ToExampleSimpleV3Args = {
+    /**
+     * The example value itself. The singular `example` field of a media type,
+     * parameter or header is a LITERAL value — not an Example Object — so it
+     * carries no `summary`, `description` or `externalValue` to read.
+     */
+    example: unknown;
+    /** The stack trail for tracing */
+    stackTrail: StackTrail;
+    /** Parse context for tracing and error handling */
+    context: ParseContextType;
+};
+/**
+ * Creates a simple OAS example from a value.
+ *
+ * Wraps a literal example value as an {@link OasExample}. Used for the singular
+ * `example` field, where only the value exists.
+ *
+ * @param args - Arguments containing the example value
+ * @returns OasExample object with the provided value
+ */
+export declare const toExampleSimpleV3: ({ example }: ToExampleSimpleV3Args) => OasExample | OasRef<"example">;
+/**
+ * Arguments for processing OpenAPI v3 examples into OAS example objects.
+ *
+ * Handles both single example and examples collection scenarios,
+ * with context for tracing and error handling.
+ */
+export type ToExamplesV3Args = {
+    /** The singular `example` field — a literal value, not an Example Object */
+    example: unknown;
+    /** Collection of named examples (OpenAPI v3 format) */
+    examples: Record<string, ExampleObjectV32 | OpenAPIV3.ReferenceObject> | undefined;
+    /** Key name for the example context */
+    exampleKey: string;
+    /** The stack trail for tracing */
+    stackTrail: StackTrail;
+    /** Parse context for tracing and error handling */
+    context: ParseContextType;
+};
+/**
+ * Processes OpenAPI v3 examples into OAS example objects.
+ *
+ * Handles both single example and examples collection scenarios,
+ * converting them to the internal OAS representation. Provides
+ * warnings when both formats are specified simultaneously.
+ *
+ * @param args - Arguments containing example data and context
+ * @returns Record of processed examples, or undefined if no examples
+ */
+export declare const toExamplesV3: ({ example, examples, exampleKey, stackTrail, context }: ToExamplesV3Args) => Record<string, OasExample | OasRef<"example">> | undefined;
+export type ToExampleV3Args = {
+    example: ExampleObjectV32 | OpenAPIV3.ReferenceObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Processes a single OpenAPI v3 example into an OAS example object.
+ *
+ * Converts OpenAPI v3 example objects or references into the internal
+ * OAS representation, handling both direct examples and $ref references.
+ * Processes specification extensions and maintains all example metadata.
+ *
+ * @param args - Arguments containing the example and parsing context
+ * @returns OasExample object or reference to an example
+ */
+export declare const toExampleV3: ({ example, stackTrail, context }: ToExampleV3Args) => OasExample | OasRef<"example">;

package/script/parse/v3-2/example/toExamplesV3.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toExampleV3 = exports.toExamplesV3 = exports.toExampleSimpleV3 = void 0;
+const refFns_js_1 = require("../../../helpers/refFns.js");
+const toRefV31_js_1 = require("../ref/toRefV31.js");
+const Example_js_1 = require("../../../oas/example/Example.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+/**
+ * Creates a simple OAS example from a value.
+ *
+ * Wraps a literal example value as an {@link OasExample}. Used for the singular
+ * `example` field, where only the value exists.
+ *
+ * @param args - Arguments containing the example value
+ * @returns OasExample object with the provided value
+ */
+const toExampleSimpleV3 = ({ example }) => {
+    const fields = { value: example };
+    return new Example_js_1.OasExample(fields);
+};
+exports.toExampleSimpleV3 = toExampleSimpleV3;
+/**
+ * Processes OpenAPI v3 examples into OAS example objects.
+ *
+ * Handles both single example and examples collection scenarios,
+ * converting them to the internal OAS representation. Provides
+ * warnings when both formats are specified simultaneously.
+ *
+ * @param args - Arguments containing example data and context
+ * @returns Record of processed examples, or undefined if no examples
+ */
+const toExamplesV3 = ({ example, examples, exampleKey, stackTrail, context }) => {
+    // An empty map is declared but carries nothing, so it cannot be the richer
+    // field — letting it win would discard the singular in favour of no examples
+    // at all.
+    const namedExamples = examples && Object.keys(examples).length > 0 ? examples : undefined;
+    // `example` is a literal, so test presence rather than truthiness — `false`,
+    // `0` and `''` are all valid example values.
+    if (example !== undefined && examples !== undefined) {
+        context.logIssue({
+            key: 'example',
+            level: 'warning',
+            message: `Both example and examples are defined for ${exampleKey}; using ${namedExamples ? 'examples' : 'example'}`,
+            parent: examples,
+            stackTrail,
+            type: 'EXAMPLE_AND_EXAMPLES_DEFINED'
+        });
+    }
+    // The spec makes the two mutually exclusive, so reaching here with both is
+    // malformed input. Prefer `examples`: it is the richer field — many entries,
+    // each with a summary and description — and the singular carries nothing it
+    // cannot express, so this discards strictly less.
+    if (namedExamples) {
+        return stackTrail.trace('examples', st => {
+            const output = {};
+            const entries = Object.entries(namedExamples);
+            for (const [key, value] of entries) {
+                output[key] = st.trace(key, st2 => (0, exports.toExampleV3)({ example: value, stackTrail: st2, context }));
+            }
+            return output;
+        });
+    }
+    if (example !== undefined) {
+        return {
+            [exampleKey]: stackTrail.trace('example', st => (0, exports.toExampleSimpleV3)({ example, stackTrail: st, context }))
+        };
+    }
+    return undefined;
+};
+exports.toExamplesV3 = toExamplesV3;
+/**
+ * Processes a single OpenAPI v3 example into an OAS example object.
+ *
+ * Converts OpenAPI v3 example objects or references into the internal
+ * OAS representation, handling both direct examples and $ref references.
+ * Processes specification extensions and maintains all example metadata.
+ *
+ * @param args - Arguments containing the example and parsing context
+ * @returns OasExample object or reference to an example
+ */
+const toExampleV3 = ({ example, stackTrail, context }) => {
+    if ((0, refFns_js_1.isRef)(example)) {
+        return (0, toRefV31_js_1.toRefV31)({ ref: example, refType: 'example', stackTrail, context });
+    }
+    // `externalValue` is the alternative to `value` — an example too large or too
+    // awkward to inline. Leaving it in `skipped` both loses it and reports a
+    // standard field as an unexpected property.
+    const { summary, description, value, dataValue, serializedValue, externalValue, ...skipped } = example;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: example,
+        context,
+        stackTrail,
+        parentType: 'example'
+    });
+    const kept = toKeptValueFields({
+        present: { dataValue, value, serializedValue, externalValue },
+        example,
+        stackTrail,
+        context
+    });
+    return new Example_js_1.OasExample({
+        summary,
+        description,
+        value: kept.has('value') ? value : undefined,
+        dataValue: kept.has('dataValue') ? dataValue : undefined,
+        serializedValue: kept.has('serializedValue') ? serializedValue : undefined,
+        externalValue: kept.has('externalValue') ? externalValue : undefined,
+        extensionFields
+    });
+};
+exports.toExampleV3 = toExampleV3;
+/** The value fields in the order they are kept when two conflict. */
+const valueFieldPrecedence = [
+    'dataValue',
+    'value',
+    'serializedValue',
+    'externalValue'
+];
+/** The fields the 3.2 spec forbids next to each value field. */
+const valueFieldExclusions = {
+    dataValue: ['value'],
+    value: ['dataValue', 'serializedValue', 'externalValue'],
+    serializedValue: ['value', 'externalValue'],
+    externalValue: ['value', 'serializedValue']
+};
+/**
+ * Picks the value fields to keep. A field that conflicts with one already
+ * kept is logged as `INVALID_EXAMPLE` and dropped.
+ */
+const toKeptValueFields = ({ present, example, stackTrail, context }) => {
+    return valueFieldPrecedence
+        .filter(field => present[field] !== undefined)
+        .reduce((kept, field) => {
+        const conflict = valueFieldExclusions[field].find(other => kept.has(other));
+        if (conflict === undefined) {
+            return new Set([...kept, field]);
+        }
+        context.logIssue({
+            key: field,
+            level: 'warning',
+            message: `Example has both '${conflict}' and '${field}', which are mutually exclusive; keeping '${conflict}'`,
+            parent: example,
+            stackTrail,
+            type: 'INVALID_EXAMPLE'
+        });
+        return kept;
+    }, new Set());
+};

package/script/parse/v3-2/externalDocs/toExternalDocs.d.ts

@@ -0,0 +1,10 @@
+import { OasExternalDocs } from '../../../oas/externalDocs/ExternalDocs.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToExternalDocsArgs = {
+    externalDocs: OpenAPIV3.ExternalDocumentationObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toExternalDocs: ({ externalDocs, stackTrail }: ToExternalDocsArgs) => OasExternalDocs | undefined;

package/script/parse/v3-2/externalDocs/toExternalDocs.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toExternalDocs = void 0;
+const ExternalDocs_js_1 = require("../../../oas/externalDocs/ExternalDocs.js");
+const v = __importStar(require("valibot"));
+const externalDocsTypes_js_1 = require("../../../oas/externalDocs/externalDocsTypes.js");
+const toExternalDocs = ({ externalDocs, stackTrail }) => {
+    if (!externalDocs) {
+        return undefined;
+    }
+    if (!v.is(externalDocsTypes_js_1.oasExternalDocsData, externalDocs)) {
+        v.parse(externalDocsTypes_js_1.oasExternalDocsData, externalDocs);
+    }
+    return new ExternalDocs_js_1.OasExternalDocs({
+        url: externalDocs.url,
+        description: externalDocs.description
+    });
+};
+exports.toExternalDocs = toExternalDocs;

package/script/parse/v3-2/header/toHeadersV3.d.ts

@@ -0,0 +1,18 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasHeader } from '../../../oas/header/Header.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToHeadersV3Args = {
+    headers: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.HeaderObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toHeadersV3: ({ headers, stackTrail, context }: ToHeadersV3Args) => Record<string, OasHeader | OasRef<"header">> | undefined;
+export type ToHeaderV3Args = {
+    header: OpenAPIV3.ReferenceObject | OpenAPIV3.HeaderObject;
+    /** The header's name, used to key a singular `example` */
+    name: string;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};

package/script/parse/v3-2/header/toHeadersV3.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHeadersV3 = void 0;
+const toExamplesV3_js_1 = require("../example/toExamplesV3.js");
+const toRefV31_js_1 = require("../ref/toRefV31.js");
+const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
+const refFns_js_1 = require("../../../helpers/refFns.js");
+const toMediaTypeItemV3_js_1 = require("../mediaType/toMediaTypeItemV3.js");
+const Header_js_1 = require("../../../oas/header/Header.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const toHeadersV3 = ({ headers, stackTrail, context }) => {
+    if (!headers) {
+        return undefined;
+    }
+    const output = {};
+    const entries = Object.entries(headers);
+    for (const [key, value] of entries) {
+        output[key] = stackTrail.trace(key, st => toHeaderV3({ header: value, name: key, stackTrail: st, context }));
+    }
+    return output;
+};
+exports.toHeadersV3 = toHeadersV3;
+const toHeaderV3 = ({ header, name, stackTrail, context }) => {
+    if ((0, refFns_js_1.isRef)(header)) {
+        return (0, toRefV31_js_1.toRefV31)({ ref: header, refType: 'header', stackTrail, context });
+    }
+    const { description, required, deprecated, schema, example, examples, content, ...skipped } = header;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: header,
+        context,
+        stackTrail,
+        parentType: 'header'
+    });
+    const fields = {
+        description,
+        required,
+        deprecated,
+        schema: stackTrail.trace('schema', st => (0, toSchemasV3_js_1.toOptionalSchemaV3)({ schema, stackTrail: st, context })),
+        examples: (0, toExamplesV3_js_1.toExamplesV3)({
+            examples,
+            example,
+            exampleKey: name,
+            stackTrail,
+            context
+        }),
+        content: stackTrail.trace('content', st => (0, toMediaTypeItemV3_js_1.toOptionalMediaTypeItemsV3)({ content, stackTrail: st, context })),
+        extensionFields
+    };
+    return new Header_js_1.OasHeader(fields);
+};

package/script/parse/v3-2/info/toInfoV3.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasInfo } from '../../../oas/info/Info.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToInfoV3Args = {
+    info: OpenAPIV3.InfoObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toInfoV3: ({ info, stackTrail, context }: ToInfoV3Args) => OasInfo;

package/script/parse/v3-2/info/toInfoV3.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toInfoV3 = void 0;
+const Info_js_1 = require("../../../oas/info/Info.js");
+const toContactV3_js_1 = require("../contact/toContactV3.js");
+const toLicenseV3_js_1 = require("../license/toLicenseV3.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const toInfoV3 = ({ info, stackTrail, context }) => {
+    const { title, description, termsOfService, contact, license, version, ...skipped } = info;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: info,
+        context,
+        stackTrail,
+        parentType: 'info'
+    });
+    return new Info_js_1.OasInfo({
+        title,
+        description,
+        termsOfService,
+        contact: contact ? (0, toContactV3_js_1.toContactV3)(contact, stackTrail, context) : undefined,
+        license: license ? (0, toLicenseV3_js_1.toLicenseV3)(license, stackTrail, context) : undefined,
+        version,
+        extensionFields
+    });
+};
+exports.toInfoV3 = toInfoV3;

package/script/parse/v3-2/integer/toInteger.d.ts

@@ -0,0 +1,21 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasInteger } from '../../../oas/integer/Integer.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToIntegerArgs = {
+    value: OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toInteger: ({ value, stackTrail, context }: ToIntegerArgs) => OasInteger;
+type ToParsedIntegerArgs<Nullable extends boolean | undefined> = {
+    value: Omit<OpenAPIV3.SchemaObject, 'nullable' | 'example' | 'enums' | 'default'>;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+    nullable: Nullable;
+    example: Nullable extends true ? number | null | undefined : number | undefined;
+    enums: Nullable extends true ? (number | null)[] | undefined : number[] | undefined;
+    defaultValue: Nullable extends true ? number | null | undefined : number | undefined;
+};
+export declare const toParsedInteger: <Nullable extends boolean | undefined>({ context, nullable, example, enums, defaultValue, value: valueWithoutEnums, stackTrail }: ToParsedIntegerArgs<Nullable>) => OasInteger<Nullable>;
+export {};

package/script/parse/v3-2/integer/toInteger.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toParsedInteger = exports.toInteger = void 0;
+const Integer_js_1 = require("../../../oas/integer/Integer.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const integer_types_js_1 = require("../../../oas/integer/integer-types.js");
+const parseNullable_js_1 = require("../_helpers/parseNullable.js");
+const parseEnum_js_1 = require("../_helpers/parseEnum.js");
+const parseExample_js_1 = require("../_helpers/parseExample.js");
+const parseDefault_js_1 = require("../_helpers/parseDefault.js");
+const v = __importStar(require("valibot"));
+const toInteger = ({ value, stackTrail, context }) => {
+    const { nullable, value: valueWithoutNullable } = (0, parseNullable_js_1.parseNullable)({
+        value,
+        context,
+        stackTrail
+    });
+    const { example: unparsedExample, ...valueWithoutExample } = valueWithoutNullable;
+    const example = (0, parseExample_js_1.parseExample)({
+        value: unparsedExample,
+        context,
+        parent: valueWithoutNullable,
+        nullable,
+        check: isInteger,
+        toMessage: item => `Removed invalid example. Expected "integer", got: ${item}`,
+        stackTrail
+    });
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = (0, parseEnum_js_1.parseEnum)({
+        value: unparsedEnums,
+        nullable,
+        parent: valueWithoutExample,
+        context,
+        check: isInteger,
+        toMessage: item => `Removed invalid enum. Expected "integer", got: ${item}`,
+        stackTrail
+    });
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = (0, parseDefault_js_1.parseDefault)({
+        value: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable,
+        check: isInteger,
+        toMessage: item => `Removed invalid default. Expected "integer", got: ${item}`,
+        stackTrail
+    });
+    return (0, exports.toParsedInteger)({
+        context,
+        nullable,
+        example,
+        enums,
+        defaultValue,
+        value: valueWithoutDefault,
+        stackTrail
+    });
+};
+exports.toInteger = toInteger;
+const toParsedInteger = ({ context, nullable, example, enums, defaultValue, value: valueWithoutEnums, stackTrail }) => {
+    const { format: unparsedFormat, ...valueWithoutFormat } = valueWithoutEnums;
+    const format = parseIntegerFormat({
+        format: unparsedFormat,
+        context,
+        parent: valueWithoutEnums,
+        stackTrail
+    });
+    if (!v.is(integer_types_js_1.oasIntegerData, valueWithoutFormat)) {
+        v.parse(integer_types_js_1.oasIntegerData, valueWithoutFormat);
+    }
+    const { type: _type, title, description, multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum, readOnly, writeOnly, deprecated, ...skipped } = valueWithoutFormat;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: valueWithoutEnums,
+        context,
+        stackTrail,
+        parentType: 'schema:integer'
+    });
+    return context.withStackTrail(stackTrail, () => new Integer_js_1.OasInteger({
+        title,
+        description,
+        nullable,
+        format,
+        enums,
+        example,
+        multipleOf,
+        maximum,
+        exclusiveMaximum,
+        minimum,
+        exclusiveMinimum,
+        default: defaultValue,
+        readOnly,
+        writeOnly,
+        extensionFields,
+        deprecated
+    }, context));
+};
+exports.toParsedInteger = toParsedInteger;
+const parseIntegerFormat = ({ format, context, parent, stackTrail }) => {
+    if (format === undefined) {
+        return undefined;
+    }
+    if (!v.is(integer_types_js_1.integerFormat, format)) {
+        // `format` is an open vocabulary; a value the IR's integerFormat can't
+        // hold is dropped. Recorded at `debug` — the dropped hint is
+        // informational, not a correctness issue.
+        context.logIssue({
+            key: 'format',
+            level: 'debug',
+            message: `Invalid format: ${format}`,
+            parent,
+            stackTrail,
+            type: 'INVALID_FORMAT'
+        });
+        return undefined;
+    }
+    return format;
+};
+const isInteger = (value) => {
+    return Number.isInteger(value);
+};

package/script/parse/v3-2/license/toLicenseV3.d.ts

@@ -0,0 +1,5 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasLicense } from '../../../oas/license/License.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export declare const toLicenseV3: (license: OpenAPIV3.LicenseObject, stackTrail: StackTrail, context: ParseContextType) => OasLicense;

package/script/parse/v3-2/license/toLicenseV3.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLicenseV3 = void 0;
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const License_js_1 = require("../../../oas/license/License.js");
+const toLicenseV3 = (license, stackTrail, context) => {
+    const { name, url, ...skipped } = license;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: license,
+        context,
+        stackTrail,
+        parentType: 'license'
+    });
+    return new License_js_1.OasLicense({
+        name,
+        url,
+        extensionFields
+    });
+};
+exports.toLicenseV3 = toLicenseV3;

package/script/parse/v3-2/link/toLinksV3.d.ts

@@ -0,0 +1,16 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasLink } from '../../../oas/link/Link.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToLinksV3Args = {
+    links: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.LinkObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toLinksV3: ({ links, stackTrail, context }: ToLinksV3Args) => Record<string, OasLink | OasRef<"link">> | undefined;
+export type ToLinkV3Args = {
+    link: OpenAPIV3.ReferenceObject | OpenAPIV3.LinkObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};

package/script/parse/v3-2/link/toLinksV3.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLinksV3 = void 0;
+const toRefV31_js_1 = require("../ref/toRefV31.js");
+const toServerV3_js_1 = require("../server/toServerV3.js");
+const refFns_js_1 = require("../../../helpers/refFns.js");
+const Link_js_1 = require("../../../oas/link/Link.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const toLinksV3 = ({ links, stackTrail, context }) => {
+    if (!links) {
+        return undefined;
+    }
+    const output = {};
+    for (const [key, value] of Object.entries(links)) {
+        output[key] = stackTrail.trace(key, st => toLinkV3({ link: value, stackTrail: st, context }));
+    }
+    return output;
+};
+exports.toLinksV3 = toLinksV3;
+const toLinkV3 = ({ link, stackTrail, context }) => {
+    if ((0, refFns_js_1.isRef)(link)) {
+        return (0, toRefV31_js_1.toRefV31)({ ref: link, refType: 'link', stackTrail, context });
+    }
+    const { operationRef, operationId, parameters, requestBody, description, server, ...skipped } = link;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: link,
+        context,
+        stackTrail,
+        parentType: 'link'
+    });
+    const fields = {
+        operationRef,
+        operationId,
+        parameters,
+        requestBody,
+        description,
+        server: server !== undefined
+            ? stackTrail.trace('server', st => (0, toServerV3_js_1.toServerV3)({ server, stackTrail: st, context }))
+            : undefined,
+        extensionFields
+    };
+    return new Link_js_1.OasLink(fields);
+};