@skmtc/core 0.28.7 → 0.30.1

package/script/parse/v3-2/array/toArray.js

@@ -0,0 +1,203 @@
+"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.toParsedArray = exports.toArray = void 0;
+const Array_js_1 = require("../../../oas/array/Array.js");
+const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.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 array_types_js_1 = require("../../../oas/array/array-types.js");
+/**
+ * Transforms an OpenAPI v3 array schema object into an internal OAS array representation.
+ *
+ * This function processes OpenAPI array schemas by extracting and parsing nullable values,
+ * examples, enumerations, and default values. It handles the complete transformation from
+ * raw OpenAPI JSON to the SKMTC internal array representation with proper type safety.
+ *
+ * The transformation follows a pipeline approach:
+ * 1. Parse nullable flag and extract base value
+ * 2. Parse example values with nullable support
+ * 3. Parse enumeration constraints
+ * 4. Parse default values
+ * 5. Create final OasArray instance
+ *
+ * @param args - Transformation arguments
+ * @param args.value - The OpenAPI v3 array schema object to transform
+ * @param args.context - Parse context providing utilities and tracing
+ * @returns Transformed OAS array object with parsed properties
+ *
+ * @example Basic array transformation
+ * ```typescript
+ * import { toArray } from '@skmtc/core';
+ *
+ * const openApiArray = {
+ *   type: 'array',
+ *   items: { type: 'string' },
+ *   maxItems: 10,
+ *   uniqueItems: true
+ * };
+ *
+ * const oasArray = toArray({
+ *   value: openApiArray,
+ *   context: parseContext
+ * });
+ *
+ * console.log(oasArray.maxItems); // 10
+ * console.log(oasArray.uniqueItems); // true
+ * ```
+ *
+ * @example Array with nullable and examples
+ * ```typescript
+ * const complexArray = {
+ *   type: 'array',
+ *   items: { type: 'number' },
+ *   nullable: true,
+ *   example: [1, 2, 3],
+ *   default: [],
+ *   enum: [[1, 2], [3, 4], null]
+ * };
+ *
+ * const oasArray = toArray({
+ *   value: complexArray,
+ *   context: parseContext
+ * });
+ *
+ * console.log(oasArray.nullable); // true
+ * console.log(oasArray.example); // [1, 2, 3]
+ * ```
+ */
+const toArray = ({ value, context, stackTrail }) => {
+    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: isArray,
+        toMessage: item => `Removed invalid example. Expected "array", got: ${item}`,
+        stackTrail
+    });
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = (0, parseEnum_js_1.parseEnum)({
+        value: unparsedEnums,
+        nullable,
+        stackTrail,
+        parent: valueWithoutExample,
+        context,
+        check: Array.isArray,
+        toMessage: item => `Removed invalid enum. Expected "array", got: ${item}`
+    });
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = (0, parseDefault_js_1.parseDefault)({
+        value: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable,
+        check: isArray,
+        toMessage: item => `Removed invalid default. Expected "array", got: ${item}`,
+        stackTrail
+    });
+    return (0, exports.toParsedArray)({
+        context,
+        nullable,
+        example,
+        enums,
+        defaultValue,
+        stackTrail,
+        value: valueWithoutDefault
+    });
+};
+exports.toArray = toArray;
+const toParsedArray = ({ context, stackTrail, nullable, example, enums, defaultValue, value }) => {
+    // We only want parse non-items fields here since items is handled below
+    const { items, ...rest } = value;
+    // Parse the object without items field
+    if (!v.is(array_types_js_1.oasArrayDataWithoutItems, rest)) {
+        v.parse(array_types_js_1.oasArrayDataWithoutItems, rest);
+    }
+    const { type: _type, title, description, uniqueItems, maxItems, minItems, readOnly, writeOnly, deprecated, ...skipped } = rest;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:array'
+    });
+    return context.withStackTrail(stackTrail, () => new Array_js_1.OasArray({
+        title,
+        description,
+        nullable,
+        defaultValue,
+        items: stackTrail.trace('items', st => {
+            // An array schema with no `items` is invalid OAS but must not
+            // kill the run (fail open): log the issue and treat the items
+            // as unknown — `{}` falls through toSchemaV3 to OasUnknown.
+            if (items === undefined) {
+                context.logIssue({
+                    key: 'items',
+                    level: 'warning',
+                    message: 'Array schema has no "items" — treating as an array of unknown values',
+                    parent: value,
+                    stackTrail: st,
+                    type: 'INVALID_SCHEMA'
+                });
+                return (0, toSchemasV3_js_1.toSchemaV3)({ schema: {}, stackTrail: st, context });
+            }
+            return (0, toSchemasV3_js_1.toSchemaV3)({ schema: items, stackTrail: st, context });
+        }),
+        extensionFields,
+        example,
+        uniqueItems,
+        maxItems,
+        minItems,
+        enums,
+        readOnly,
+        writeOnly,
+        deprecated
+    }, context));
+};
+exports.toParsedArray = toParsedArray;
+const isArray = (value) => {
+    return Array.isArray(value);
+};

package/script/parse/v3-2/boolean/toBoolean.d.ts

@@ -0,0 +1,78 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasBoolean } from '../../../oas/boolean/Boolean.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToBooleanArgs = {
+    value: OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Transforms an OpenAPI v3 boolean schema object into an internal OAS boolean representation.
+ *
+ * This function processes OpenAPI boolean schemas by extracting and parsing nullable values,
+ * examples, enumerations, and default values. It handles the complete transformation from
+ * raw OpenAPI JSON to the SKMTC internal boolean representation with proper validation.
+ *
+ * The transformation follows a pipeline approach:
+ * 1. Parse nullable flag and extract base value
+ * 2. Parse example values with nullable support
+ * 3. Parse enumeration constraints (typically [true], [false], or [true, false])
+ * 4. Parse default values
+ * 5. Create final OasBoolean instance
+ *
+ * @param args - Transformation arguments
+ * @param args.value - The OpenAPI v3 boolean schema object to transform
+ * @param args.context - Parse context providing utilities and tracing
+ * @returns Transformed OAS boolean object with parsed properties
+ *
+ * @example Basic boolean transformation
+ * ```typescript
+ * import { toBoolean } from '@skmtc/core';
+ *
+ * const openApiBoolean = {
+ *   type: 'boolean',
+ *   default: false
+ * };
+ *
+ * const oasBoolean = toBoolean({
+ *   value: openApiBoolean,
+ *   context: parseContext
+ * });
+ *
+ * console.log(oasBoolean.default); // false
+ * ```
+ *
+ * @example Boolean with nullable and enum
+ * ```typescript
+ * const flagBoolean = {
+ *   type: 'boolean',
+ *   nullable: true,
+ *   enum: [true, null],
+ *   default: null,
+ *   example: true,
+ *   title: 'Feature Flag',
+ *   description: 'Whether the feature is enabled'
+ * };
+ *
+ * const oasBoolean = toBoolean({
+ *   value: flagBoolean,
+ *   context: parseContext
+ * });
+ *
+ * console.log(oasBoolean.nullable); // true
+ * console.log(oasBoolean.enums); // [true, null]
+ * ```
+ */
+export declare const toBoolean: ({ value, stackTrail, context }: ToBooleanArgs) => OasBoolean;
+type ToParsedBooleanArgs<Nullable extends boolean | undefined> = {
+    value: Omit<OpenAPIV3.SchemaObject, 'nullable' | 'example' | 'enums'>;
+    context: ParseContextType;
+    nullable: Nullable;
+    example: Nullable extends true ? boolean | null | undefined : boolean | undefined;
+    enums: Nullable extends true ? (boolean | null)[] | undefined : boolean[] | undefined;
+    defaultValue: Nullable extends true ? boolean | null | undefined : boolean | undefined;
+    stackTrail: StackTrail;
+};
+export declare const toParsedBoolean: <Nullable extends boolean | undefined>({ context, nullable, example, enums, defaultValue, value, stackTrail }: ToParsedBooleanArgs<Nullable>) => OasBoolean<Nullable>;
+export {};

package/script/parse/v3-2/boolean/toBoolean.js

@@ -0,0 +1,177 @@
+"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.toParsedBoolean = exports.toBoolean = void 0;
+const Boolean_js_1 = require("../../../oas/boolean/Boolean.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const boolean_types_js_1 = require("../../../oas/boolean/boolean-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"));
+/**
+ * Transforms an OpenAPI v3 boolean schema object into an internal OAS boolean representation.
+ *
+ * This function processes OpenAPI boolean schemas by extracting and parsing nullable values,
+ * examples, enumerations, and default values. It handles the complete transformation from
+ * raw OpenAPI JSON to the SKMTC internal boolean representation with proper validation.
+ *
+ * The transformation follows a pipeline approach:
+ * 1. Parse nullable flag and extract base value
+ * 2. Parse example values with nullable support
+ * 3. Parse enumeration constraints (typically [true], [false], or [true, false])
+ * 4. Parse default values
+ * 5. Create final OasBoolean instance
+ *
+ * @param args - Transformation arguments
+ * @param args.value - The OpenAPI v3 boolean schema object to transform
+ * @param args.context - Parse context providing utilities and tracing
+ * @returns Transformed OAS boolean object with parsed properties
+ *
+ * @example Basic boolean transformation
+ * ```typescript
+ * import { toBoolean } from '@skmtc/core';
+ *
+ * const openApiBoolean = {
+ *   type: 'boolean',
+ *   default: false
+ * };
+ *
+ * const oasBoolean = toBoolean({
+ *   value: openApiBoolean,
+ *   context: parseContext
+ * });
+ *
+ * console.log(oasBoolean.default); // false
+ * ```
+ *
+ * @example Boolean with nullable and enum
+ * ```typescript
+ * const flagBoolean = {
+ *   type: 'boolean',
+ *   nullable: true,
+ *   enum: [true, null],
+ *   default: null,
+ *   example: true,
+ *   title: 'Feature Flag',
+ *   description: 'Whether the feature is enabled'
+ * };
+ *
+ * const oasBoolean = toBoolean({
+ *   value: flagBoolean,
+ *   context: parseContext
+ * });
+ *
+ * console.log(oasBoolean.nullable); // true
+ * console.log(oasBoolean.enums); // [true, null]
+ * ```
+ */
+const toBoolean = ({ 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: isBoolean,
+        toMessage: item => `Removed invalid example. Expected "boolean", got: ${item}`,
+        stackTrail
+    });
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = (0, parseEnum_js_1.parseEnum)({
+        value: unparsedEnums,
+        nullable,
+        parent: valueWithoutExample,
+        stackTrail,
+        context,
+        check: isBoolean,
+        toMessage: item => `Removed invalid enum. Expected "boolean", got: ${item}`
+    });
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = (0, parseDefault_js_1.parseDefault)({
+        value: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable,
+        check: isBoolean,
+        toMessage: item => `Removed invalid default. Expected "boolean", got: ${item}`,
+        stackTrail
+    });
+    return (0, exports.toParsedBoolean)({
+        context,
+        nullable,
+        example,
+        enums,
+        defaultValue,
+        value: valueWithoutDefault,
+        stackTrail
+    });
+};
+exports.toBoolean = toBoolean;
+const toParsedBoolean = ({ context, nullable, example, enums, defaultValue, value, stackTrail }) => {
+    if (!v.is(boolean_types_js_1.oasBooleanData, value)) {
+        v.parse(boolean_types_js_1.oasBooleanData, value);
+    }
+    const { type: _type, title, description, readOnly, writeOnly, deprecated, ...skipped } = value;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:boolean'
+    });
+    return context.withStackTrail(stackTrail, () => new Boolean_js_1.OasBoolean({
+        nullable,
+        title,
+        description,
+        example,
+        enums: enums,
+        default: defaultValue,
+        extensionFields,
+        readOnly,
+        writeOnly,
+        deprecated
+    }, context));
+};
+exports.toParsedBoolean = toParsedBoolean;
+const isBoolean = (value) => {
+    return typeof value === 'boolean';
+};

package/script/parse/v3-2/components/toComponentsV3.d.ts

@@ -0,0 +1,14 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasComponents } from '../../../oas/components/Components.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/** An OpenAPI 3.2 Components Object: the 3.0/3.1 maps plus `mediaTypes`. */
+export type ComponentsObjectV32 = OpenAPIV3.ComponentsObject & {
+    mediaTypes?: Record<string, unknown>;
+};
+export type ToComponentsV3Args = {
+    components: ComponentsObjectV32 | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toComponentsV3: ({ components, stackTrail, context }: ToComponentsV3Args) => OasComponents | undefined;

package/script/parse/v3-2/components/toComponentsV3.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toComponentsV3 = void 0;
+const toResponseV3_js_1 = require("../response/toResponseV3.js");
+const toHeadersV3_js_1 = require("../header/toHeadersV3.js");
+const toLinksV3_js_1 = require("../link/toLinksV3.js");
+const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
+const toParameterV3_js_1 = require("../parameter/toParameterV3.js");
+const toExamplesV3_js_1 = require("../example/toExamplesV3.js");
+const toRequestBodiesV3_js_1 = require("../requestBody/toRequestBodiesV3.js");
+const Components_js_1 = require("../../../oas/components/Components.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const toSecuritySchemes_js_1 = require("../securitySchemes/toSecuritySchemes.js");
+const toComponentsV3 = ({ components, stackTrail, context }) => {
+    if (!components) {
+        return undefined;
+    }
+    // `mediaTypes` is resolved where it is referenced, inside
+    // `toMediaTypeItemsV3`, so it is read here only to keep it off `skipped`.
+    const { schemas, responses, parameters, examples, requestBodies, headers, securitySchemes, links, mediaTypes: _mediaTypes, ...skipped } = components;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: components,
+        context,
+        stackTrail,
+        parentType: 'components'
+    });
+    const fields = {
+        schemas: stackTrail.trace('schemas', st => (0, toSchemasV3_js_1.toOptionalSchemasV3)({ schemas, stackTrail: st, context })),
+        responses: stackTrail.trace('responses', st => (0, toResponseV3_js_1.toOptionalResponsesV3)({ responses, stackTrail: st, context })),
+        parameters: stackTrail.trace('parameters', st => (0, toParameterV3_js_1.toOptionalParametersV3)({ parameters, stackTrail: st, context })),
+        examples: (0, toExamplesV3_js_1.toExamplesV3)({
+            examples,
+            example: undefined,
+            exampleKey: 'TEMP',
+            stackTrail,
+            context
+        }),
+        requestBodies: stackTrail.trace('requestBodies', st => (0, toRequestBodiesV3_js_1.toRequestBodiesV3)({ requestBodies, stackTrail: st, context })),
+        headers: stackTrail.trace('headers', st => (0, toHeadersV3_js_1.toHeadersV3)({ headers, stackTrail: st, context })),
+        securitySchemes: stackTrail.trace('securitySchemes', st => (0, toSecuritySchemes_js_1.toSecuritySchemesV3)({ securitySchemes, stackTrail: st, context })),
+        links: stackTrail.trace('links', st => (0, toLinksV3_js_1.toLinksV3)({ links, stackTrail: st, context })),
+        extensionFields
+    };
+    return new Components_js_1.OasComponents(fields);
+};
+exports.toComponentsV3 = toComponentsV3;

package/script/parse/v3-2/contact/toContactV3.d.ts

@@ -0,0 +1,5 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasContact } from '../../../oas/contact/Contact.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export declare const toContactV3: (contact: OpenAPIV3.ContactObject, stackTrail: StackTrail, context: ParseContextType) => OasContact;

package/script/parse/v3-2/contact/toContactV3.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toContactV3 = void 0;
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const Contact_js_1 = require("../../../oas/contact/Contact.js");
+const toContactV3 = (contact, stackTrail, context) => {
+    const { name, url, email, ...skipped } = contact;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: contact,
+        context,
+        stackTrail,
+        parentType: 'contact'
+    });
+    return new Contact_js_1.OasContact({
+        name,
+        url,
+        email,
+        extensionFields
+    });
+};
+exports.toContactV3 = toContactV3;

package/script/parse/v3-2/discriminator/toDiscriminatorV3.d.ts

@@ -0,0 +1,14 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasDiscriminator } from '../../../oas/discriminator/Discriminator.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/** A 3.2 Discriminator Object: the 3.0 shape plus `defaultMapping`. */
+export type DiscriminatorObjectV32 = OpenAPIV3.DiscriminatorObject & {
+    defaultMapping?: string;
+};
+export type ToDiscriminatorV3Args = {
+    discriminator: DiscriminatorObjectV32 | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toDiscriminatorV3: ({ discriminator, stackTrail, context }: ToDiscriminatorV3Args) => OasDiscriminator | undefined;

package/script/parse/v3-2/discriminator/toDiscriminatorV3.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDiscriminatorV3 = void 0;
+const Discriminator_js_1 = require("../../../oas/discriminator/Discriminator.js");
+const isEmpty_js_1 = require("../../../helpers/isEmpty.js");
+const toDiscriminatorV3 = ({ discriminator, stackTrail, context }) => {
+    if (!discriminator) {
+        return undefined;
+    }
+    const { propertyName, mapping, defaultMapping, ...skipped } = discriminator;
+    if (!(0, isEmpty_js_1.isEmpty)(skipped)) {
+        context.logSkippedFields({
+            skipped,
+            parent: discriminator,
+            parentType: 'discriminator',
+            stackTrail
+        });
+    }
+    return new Discriminator_js_1.OasDiscriminator({
+        propertyName,
+        mapping,
+        defaultMapping
+    });
+};
+exports.toDiscriminatorV3 = toDiscriminatorV3;

package/script/parse/v3-2/document/toDocumentFieldsV3.d.ts

@@ -0,0 +1,16 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { type WebhooksObject } from '../webhook/toWebhooksV3.js';
+import type { DocumentFields } from '../../../oas/document/Document.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToDocumentV3Args = {
+    documentObject: Omit<OpenAPIV3.Document, 'paths'> & {
+        paths?: OpenAPIV3.PathsObject;
+        webhooks?: WebhooksObject;
+        /** The document's own URI (3.2) */
+        $self?: string;
+    };
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toDocumentFieldsV3: ({ documentObject, stackTrail, context }: ToDocumentV3Args) => DocumentFields;

package/script/parse/v3-2/document/toDocumentFieldsV3.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDocumentFieldsV3 = void 0;
+const toTagsV3_js_1 = require("../tag/toTagsV3.js");
+const toOperationsV3_js_1 = require("../operation/toOperationsV3.js");
+const toWebhooksV3_js_1 = require("../webhook/toWebhooksV3.js");
+const toComponentsV3_js_1 = require("../components/toComponentsV3.js");
+const toInfoV3_js_1 = require("../info/toInfoV3.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const toServerV3_js_1 = require("../server/toServerV3.js");
+const toSecurityRequirement_js_1 = require("../securityRequirement/toSecurityRequirement.js");
+const toExternalDocs_js_1 = require("../externalDocs/toExternalDocs.js");
+const toDocumentFieldsV3 = ({ documentObject, stackTrail, context }) => {
+    const { openapi, $self, info, paths, components, tags, servers, security, externalDocs, webhooks, ...skipped } = documentObject;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: documentObject,
+        context,
+        stackTrail,
+        parentType: 'document'
+    });
+    return {
+        openapi,
+        $self,
+        info: stackTrail.trace('info', st => (0, toInfoV3_js_1.toInfoV3)({ info, stackTrail: st, context })),
+        servers: stackTrail.trace('servers', st => (0, toServerV3_js_1.toOptionalServersV3)({ servers, stackTrail: st, context })),
+        operations: stackTrail.trace('paths', st => (0, toOperationsV3_js_1.toOperationsV3)({ paths, stackTrail: st, context })),
+        webhooks: stackTrail.trace('webhooks', st => (0, toWebhooksV3_js_1.toWebhooksV3)({ webhooks, stackTrail: st, context })),
+        components: stackTrail.trace('components', st => (0, toComponentsV3_js_1.toComponentsV3)({ components, stackTrail: st, context })),
+        tags: stackTrail.trace('tags', st => (0, toTagsV3_js_1.toTagsV3)({ tags, stackTrail: st, context })),
+        security: stackTrail.trace('security', st => (0, toSecurityRequirement_js_1.toSecurityRequirementsV3)({ security, stackTrail: st, context })),
+        extensionFields,
+        externalDocs: stackTrail.trace('externalDocs', st => (0, toExternalDocs_js_1.toExternalDocs)({ externalDocs, stackTrail: st, context }))
+    };
+};
+exports.toDocumentFieldsV3 = toDocumentFieldsV3;
+// stackTrail.trace('info', (x) => formatNumber(x))