@skmtc/core 0.0.984 → 0.16.1

package/script/parse/v3-1/mediaType/toMediaTypeItemV3.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOptionalMediaTypeItemsV3 = exports.toMediaTypeItemsV3 = exports.toMediaTypeItemV3 = void 0;
+const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
+const toExamplesV3_js_1 = require("../example/toExamplesV3.js");
+const MediaType_js_1 = require("../../../oas/mediaType/MediaType.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+/**
+ * Transforms an OpenAPI v3 media type object into an internal OAS media type representation.
+ *
+ * This function processes OpenAPI v3 MediaType objects, extracting schema definitions,
+ * examples, encoding information, and specification extensions. It creates a structured
+ * internal representation that can be used by the SKMTC pipeline for code generation
+ * and validation.
+ *
+ * The transformation handles all standard OpenAPI v3 MediaType properties including
+ * schema references, inline schemas, examples, encoding specifications, and custom
+ * extension fields that begin with 'x-'.
+ *
+ * @param args - Transformation arguments
+ * @param args.mediaTypeItem - The OpenAPI v3 media type object to process
+ * @param args.mediaType - The media type identifier (MIME type)
+ * @param args.context - Parsing context for tracing and error handling
+ * @returns Structured OAS media type object for internal processing
+ *
+ * @example Transforming JSON media type
+ * ```typescript
+ * import { toMediaTypeItemV3 } from '@skmtc/core/oas/mediaType';
+ *
+ * const jsonMediaType = {
+ *   schema: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       email: { type: 'string', format: 'email' }
+ *     }
+ *   },
+ *   example: {
+ *     name: 'John Doe',
+ *     email: 'john@example.com'
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemV3({
+ *   mediaTypeItem: jsonMediaType,
+ *   mediaType: 'application/json',
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.mediaType); // 'application/json'
+ * console.log(result.schema); // Processed schema object
+ * ```
+ *
+ * @example Processing form data with encoding
+ * ```typescript
+ * const formMediaType = {
+ *   schema: {
+ *     type: 'object',
+ *     properties: {
+ *       file: { type: 'string', format: 'binary' },
+ *       metadata: { type: 'string' }
+ *     }
+ *   },
+ *   encoding: {
+ *     file: {
+ *       contentType: 'image/png',
+ *       headers: {
+ *         'X-Rate-Limit': {
+ *           schema: { type: 'integer' }
+ *         }
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemV3({
+ *   mediaTypeItem: formMediaType,
+ *   mediaType: 'multipart/form-data',
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.encoding); // Processed encoding configuration
+ * ```
+ *
+ * @example Handling multiple examples
+ * ```typescript
+ * const mediaTypeWithExamples = {
+ *   schema: { type: 'string' },
+ *   examples: {
+ *     success: {
+ *       summary: 'Successful response',
+ *       value: 'Operation completed'
+ *     },
+ *     error: {
+ *       summary: 'Error response',
+ *       value: 'Operation failed'
+ *     }
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemV3({
+ *   mediaTypeItem: mediaTypeWithExamples,
+ *   mediaType: 'text/plain',
+ *   context: parseContext
+ * });
+ *
+ * console.log(Object.keys(result.examples)); // ['success', 'error']
+ * ```
+ */
+const toMediaTypeItemV3 = ({ mediaTypeItem, mediaType, stackTrail, context }) => {
+    const { schema, example, examples, encoding, ...skipped } = mediaTypeItem;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: mediaTypeItem,
+        context,
+        stackTrail,
+        parentType: 'mediaType'
+    });
+    const fields = {
+        mediaType,
+        encoding,
+        schema: stackTrail.trace('schema', st => (0, toSchemasV3_js_1.toOptionalSchemaV3)({ schema, stackTrail: st, context })),
+        examples: stackTrail.trace('examples', st => (0, toExamplesV3_js_1.toExamplesV3)({
+            example,
+            examples,
+            exampleKey: mediaType,
+            stackTrail: st,
+            context
+        })),
+        extensionFields
+    };
+    return context.withStackTrail(stackTrail, () => new MediaType_js_1.OasMediaType(fields, context));
+};
+exports.toMediaTypeItemV3 = toMediaTypeItemV3;
+/**
+ * Transforms multiple OpenAPI v3 media type objects into internal OAS representations.
+ *
+ * This function processes a complete content map from OpenAPI v3, transforming each
+ * media type entry into its internal OAS representation. It's commonly used to process
+ * the `content` property of request bodies, responses, and parameters that support
+ * multiple media types.
+ *
+ * The function maintains the original media type keys while transforming the values
+ * into structured OAS media type objects. Each transformation is traced for debugging
+ * and error tracking purposes.
+ *
+ * @param args - Transformation arguments
+ * @param args.content - Map of media types to OpenAPI MediaType objects
+ * @param args.context - Parsing context for tracing and error handling
+ * @returns Map of media type strings to processed OAS media type objects
+ *
+ * @example Processing multiple content types
+ * ```typescript
+ * import { toMediaTypeItemsV3 } from '@skmtc/core/oas/mediaType';
+ *
+ * const content = {
+ *   'application/json': {
+ *     schema: {
+ *       type: 'object',
+ *       properties: { message: { type: 'string' } }
+ *     }
+ *   },
+ *   'application/xml': {
+ *     schema: {
+ *       type: 'string'
+ *     }
+ *   },
+ *   'text/plain': {
+ *     schema: {
+ *       type: 'string'
+ *     },
+ *     example: 'Plain text response'
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemsV3({
+ *   content,
+ *   context: parseContext
+ * });
+ *
+ * console.log(Object.keys(result)); // ['application/json', 'application/xml', 'text/plain']
+ * console.log(result['application/json'].mediaType); // 'application/json'
+ * ```
+ *
+ * @example Processing request body content types
+ * ```typescript
+ * const requestBodyContent = {
+ *   'application/json': {
+ *     schema: { $ref: '#/components/schemas/CreateUserRequest' }
+ *   },
+ *   'application/x-www-form-urlencoded': {
+ *     schema: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' },
+ *         email: { type: 'string' }
+ *       }
+ *     },
+ *     encoding: {
+ *       email: {
+ *         style: 'form',
+ *         explode: false
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * const processed = toMediaTypeItemsV3({
+ *   content: requestBodyContent,
+ *   context: parseContext
+ * });
+ *
+ * // Each media type is processed with its specific configuration
+ * console.log(processed['application/json'].schema); // Reference object
+ * console.log(processed['application/x-www-form-urlencoded'].encoding); // Form encoding config
+ * ```
+ */
+const toMediaTypeItemsV3 = ({ content, stackTrail, context }) => {
+    const output = {};
+    const entries = Object.entries(content);
+    for (const [mediaType, value] of entries) {
+        output[mediaType] = stackTrail.trace(mediaType, st => (0, exports.toMediaTypeItemV3)({ mediaTypeItem: value, mediaType, stackTrail: st, context }));
+    }
+    return output;
+};
+exports.toMediaTypeItemsV3 = toMediaTypeItemsV3;
+/**
+ * Optionally transforms OpenAPI v3 media type objects when content is provided.
+ *
+ * This function provides a safe way to process media type content that may or may not
+ * be present in the OpenAPI specification. It handles the common pattern where content
+ * properties are optional in OpenAPI objects (like responses without bodies or
+ * operations without request bodies).
+ *
+ * When content is undefined, the function returns undefined without processing.
+ * When content is provided, it delegates to `toMediaTypeItemsV3` for full processing.
+ *
+ * @param args - Transformation arguments
+ * @param args.content - Optional map of media types to OpenAPI MediaType objects
+ * @param args.context - Parsing context for tracing and error handling
+ * @returns Map of processed media types if content exists, undefined otherwise
+ *
+ * @example Handling optional response content
+ * ```typescript
+ * import { toOptionalMediaTypeItemsV3 } from '@skmtc/core/oas/mediaType';
+ *
+ * // Response with content
+ * const responseWithContent = {
+ *   description: 'Successful response',
+ *   content: {
+ *     'application/json': {
+ *       schema: { type: 'object' }
+ *     }
+ *   }
+ * };
+ *
+ * const withContent = toOptionalMediaTypeItemsV3({
+ *   content: responseWithContent.content,
+ *   context: parseContext
+ * });
+ * console.log(withContent); // { 'application/json': OasMediaType }
+ *
+ * // Response without content (like 204 No Content)
+ * const responseNoContent = {
+ *   description: 'No content response'
+ * };
+ *
+ * const noContent = toOptionalMediaTypeItemsV3({
+ *   content: responseNoContent.content, // undefined
+ *   context: parseContext
+ * });
+ * console.log(noContent); // undefined
+ * ```
+ *
+ * @example Processing operations with optional request bodies
+ * ```typescript
+ * function processOperation(operation: OpenAPIV3.OperationObject) {
+ *   const requestBodyContent = toOptionalMediaTypeItemsV3({
+ *     content: operation.requestBody?.content,
+ *     context: parseContext
+ *   });
+ *
+ *   if (requestBodyContent) {
+ *     console.log('Operation has request body with media types:');
+ *     console.log(Object.keys(requestBodyContent));
+ *   } else {
+ *     console.log('Operation has no request body');
+ *   }
+ * }
+ * ```
+ *
+ * @example Safe processing in response handlers
+ * ```typescript
+ * class ResponseProcessor {
+ *   processResponse(response: OpenAPIV3.ResponseObject) {
+ *     const mediaTypes = toOptionalMediaTypeItemsV3({
+ *       content: response.content,
+ *       context: this.context
+ *     });
+ *
+ *     // Safe to check without worrying about undefined content
+ *     const hasJsonResponse = mediaTypes && 'application/json' in mediaTypes;
+ *
+ *     if (hasJsonResponse) {
+ *       const jsonMediaType = mediaTypes['application/json'];
+ *       return this.generateJsonResponseHandler(jsonMediaType);
+ *     }
+ *
+ *     return this.generateEmptyResponseHandler();
+ *   }
+ * }
+ * ```
+ */
+const toOptionalMediaTypeItemsV3 = ({ content, stackTrail, context }) => {
+    if (!content) {
+        return;
+    }
+    return (0, exports.toMediaTypeItemsV3)({ content, stackTrail, context });
+};
+exports.toOptionalMediaTypeItemsV3 = toOptionalMediaTypeItemsV3;

package/script/parse/v3-1/number/toNumber.d.ts

@@ -0,0 +1,11 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasNumber } from '../../../oas/number/Number.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToNumberArgs = {
+    value: OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toNumber: ({ context, value, stackTrail }: ToNumberArgs) => OasNumber;
+//# sourceMappingURL=toNumber.d.ts.map

package/script/parse/v3-1/number/toNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toNumber.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/number/toNumber.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAQzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,gCAAgC,YAAY,KAAG,SAoDvE,CAAA"}

package/script/parse/v3-1/number/toNumber.js

@@ -0,0 +1,149 @@
+"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.toNumber = void 0;
+const Number_js_1 = require("../../../oas/number/Number.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const number_types_js_1 = require("../../../oas/number/number-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 toNumber = ({ context, value, 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: isNumber,
+        toMessage: item => `Removed invalid example. Expected "number", got: ${item}`,
+        stackTrail
+    });
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = (0, parseEnum_js_1.parseEnum)({
+        value: unparsedEnums,
+        nullable,
+        stackTrail,
+        parent: valueWithoutExample,
+        context,
+        check: isNumber,
+        toMessage: item => `Removed invalid enum. Expected "number", got: ${item}`
+    });
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = (0, parseDefault_js_1.parseDefault)({
+        value: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable,
+        check: isNumber,
+        toMessage: item => `Removed invalid default. Expected "number", got: ${item}`,
+        stackTrail
+    });
+    return toParsedNumber({
+        context,
+        nullable,
+        example,
+        enums,
+        defaultValue,
+        value: valueWithoutDefault,
+        stackTrail
+    });
+};
+exports.toNumber = toNumber;
+const toParsedNumber = ({ context, nullable, example, enums, defaultValue, value: valueWithoutEnums, stackTrail }) => {
+    const { format: unparsedFormat, ...valueWithoutFormat } = valueWithoutEnums;
+    const format = parseNumberFormat({
+        format: unparsedFormat,
+        context,
+        stackTrail,
+        parent: valueWithoutEnums
+    });
+    if (!v.is(number_types_js_1.oasNumberData, valueWithoutFormat)) {
+        v.parse(number_types_js_1.oasNumberData, 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: valueWithoutFormat,
+        context,
+        stackTrail,
+        parentType: 'schema:number'
+    });
+    return context.withStackTrail(stackTrail, () => new Number_js_1.OasNumber({
+        title,
+        description,
+        nullable,
+        default: defaultValue,
+        extensionFields,
+        example,
+        enums,
+        format,
+        multipleOf,
+        maximum,
+        exclusiveMaximum,
+        minimum,
+        readOnly,
+        writeOnly,
+        exclusiveMinimum,
+        deprecated
+    }, context));
+};
+const parseNumberFormat = ({ format, context, parent, stackTrail }) => {
+    if (format === undefined) {
+        return undefined;
+    }
+    if (!v.is(number_types_js_1.numberFormat, format)) {
+        context.logIssue({
+            key: 'format',
+            level: 'warning',
+            message: `Invalid format: ${format}`,
+            parent,
+            stackTrail,
+            type: 'INVALID_FORMAT'
+        });
+        return undefined;
+    }
+    return format;
+};
+const isNumber = (value) => {
+    return typeof value === 'number';
+};

package/script/parse/v3-1/object/toAdditionalPropertiesV3.d.ts

@@ -0,0 +1,12 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OasSchema } from '../../../oas/schema/Schema.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToAdditionalPropertiesV3Args = {
+    additionalProperties: boolean | OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toAdditionalPropertiesV3: ({ additionalProperties, stackTrail, context }: ToAdditionalPropertiesV3Args) => OasSchema | OasRef<"schema"> | boolean | undefined;
+//# sourceMappingURL=toAdditionalPropertiesV3.d.ts.map

package/script/parse/v3-1/object/toAdditionalPropertiesV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toAdditionalPropertiesV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/object/toAdditionalPropertiesV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,4BAA4B,GAAG;IACzC,oBAAoB,EAAE,OAAO,GAAG,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,GAAG,SAAS,CAAA;IAC9F,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,wBAAwB,GAAI,+CAItC,4BAA4B,KAAG,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,OAAO,GAAG,SAU1E,CAAA"}

package/script/parse/v3-1/object/toAdditionalPropertiesV3.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAdditionalPropertiesV3 = void 0;
+const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
+const toAdditionalPropertiesV3 = ({ additionalProperties, stackTrail, context }) => {
+    if (typeof additionalProperties === 'boolean') {
+        return additionalProperties;
+    }
+    if (additionalProperties === undefined) {
+        return undefined;
+    }
+    return (0, toSchemasV3_js_1.toSchemaV3)({ schema: additionalProperties, stackTrail, context });
+};
+exports.toAdditionalPropertiesV3 = toAdditionalPropertiesV3;

package/script/parse/v3-1/object/toObject.d.ts

@@ -0,0 +1,11 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasObject } from '../../../oas/object/Object.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToObjectArgs = {
+    value: OpenAPIV3.SchemaObject;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+export declare const toObject: ({ value, context, stackTrail }: ToObjectArgs) => OasObject;
+//# sourceMappingURL=toObject.d.ts.map

package/script/parse/v3-1/object/toObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toObject.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/object/toObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AASzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,gCAAgC,YAAY,KAAG,SAoDvE,CAAA"}

package/script/parse/v3-1/object/toObject.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toObject = void 0;
+const Object_js_1 = require("../../../oas/object/Object.js");
+const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
+const toAdditionalPropertiesV3_js_1 = require("./toAdditionalPropertiesV3.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 toObject = ({ 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: isObject,
+        toMessage: item => `Removed invalid example. Expected "object", got: ${item}`,
+        stackTrail
+    });
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = (0, parseEnum_js_1.parseEnum)({
+        value: unparsedEnums,
+        nullable,
+        parent: valueWithoutExample,
+        context,
+        stackTrail,
+        check: isObject,
+        toMessage: item => `Removed invalid enum. Expected "object", got: ${item}`
+    });
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = (0, parseDefault_js_1.parseDefault)({
+        value: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable,
+        check: isObject,
+        toMessage: item => `Removed invalid default. Expected "object", got: ${item}`,
+        stackTrail
+    });
+    return toParsedObject({
+        context,
+        nullable,
+        example,
+        enums,
+        defaultValue,
+        value: valueWithoutDefault,
+        stackTrail
+    });
+};
+exports.toObject = toObject;
+const toParsedObject = ({ context, stackTrail, nullable, example, enums, defaultValue, value }) => {
+    const { type: _type, title, description, deprecated, properties, required, maxProperties, minProperties, additionalProperties, readOnly, writeOnly, ...skipped } = value;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:object'
+    });
+    return context.withStackTrail(stackTrail, () => new Object_js_1.OasObject({
+        title,
+        description,
+        nullable,
+        example,
+        enums,
+        properties: stackTrail.trace('properties', st => (0, toSchemasV3_js_1.toOptionalSchemasV3)({
+            schemas: properties,
+            stackTrail: st,
+            context
+        })),
+        required,
+        maxProperties,
+        minProperties,
+        additionalProperties: stackTrail.trace('additionalProperties', st => (0, toAdditionalPropertiesV3_js_1.toAdditionalPropertiesV3)({ additionalProperties, stackTrail: st, context })),
+        extensionFields,
+        default: defaultValue,
+        deprecated,
+        readOnly,
+        writeOnly
+    }, context));
+};
+const isObject = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};

package/script/parse/v3-1/operation/toOperationsV3.d.ts

@@ -0,0 +1,26 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { Method } from '../../../types/Method.js';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasOperation } from '../../../oas/operation/Operation.js';
+import type { OasPathItem } from '../../../oas/pathItem/PathItem.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+type OperationInfo = {
+    method: Method;
+    path: string;
+    pathItem: OasPathItem | undefined;
+};
+export type ToOperationV3Args = {
+    operation: OpenAPIV3.OperationObject;
+    operationInfo: OperationInfo;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOperationV3: ({ operation, operationInfo, stackTrail, context }: ToOperationV3Args) => OasOperation;
+export type ToOperationsV3Args = {
+    paths: OpenAPIV3.PathsObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOperationsV3: ({ paths, stackTrail, context }: ToOperationsV3Args) => OasOperation[];
+export {};
+//# sourceMappingURL=toOperationsV3.d.ts.map

package/script/parse/v3-1/operation/toOperationsV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toOperationsV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/operation/toOperationsV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAA;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAItE,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAA;AAElE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAOpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,SAAS,CAAC,eAAe,CAAA;IACpC,aAAa,EAAE,aAAa,CAAA;IAC5B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAOD,eAAO,MAAM,aAAa,GAAI,mDAK3B,iBAAiB,KAAG,YAmEtB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAG/B,KAAK,EAAE,SAAS,CAAC,WAAW,GAAG,SAAS,CAAA;IACxC,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,gCAI5B,kBAAkB,KAAG,YAAY,EAiFnC,CAAA"}