@skmtc/core 0.29.0 → 0.31.0

package/script/parse/v3-2/_merge-all-of/merge-number-constraints.js

@@ -0,0 +1,77 @@
+"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.mergeNumberConstraints = mergeNumberConstraints;
+const generic_merge_js_1 = require("./generic-merge.js");
+const v = __importStar(require("valibot"));
+const check_type_conflicts_js_1 = require("./check-type-conflicts.js");
+function mergeNumberConstraints(first, second, getRef) {
+    (0, check_type_conflicts_js_1.checkTypeConflicts)(first, second);
+    // First merge enum values if present
+    const result = (0, generic_merge_js_1.genericMerge)(first, second, getRef, v.number());
+    // Then merge other constraints
+    result.type = 'number';
+    // Merge minimum and exclusiveMinimum
+    if (first.minimum !== undefined || second.minimum !== undefined) {
+        const minA = first.minimum ?? -Infinity;
+        const minB = second.minimum ?? -Infinity;
+        result.minimum = Math.max(minA, minB);
+        // If either minimum is exclusive, the result is exclusive
+        if (first.exclusiveMinimum || second.exclusiveMinimum) {
+            result.exclusiveMinimum = true;
+        }
+    }
+    // Merge maximum and exclusiveMaximum
+    if (first.maximum !== undefined || second.maximum !== undefined) {
+        const maxA = first.maximum ?? Infinity;
+        const maxB = second.maximum ?? Infinity;
+        result.maximum = Math.min(maxA, maxB);
+        // If either maximum is exclusive, the result is exclusive
+        if (first.exclusiveMaximum || second.exclusiveMaximum) {
+            result.exclusiveMaximum = true;
+        }
+    }
+    // Merge multipleOf
+    if (first.multipleOf !== undefined && second.multipleOf !== undefined) {
+        result.multipleOf = first.multipleOf * second.multipleOf;
+    }
+    else if (first.multipleOf !== undefined) {
+        result.multipleOf = first.multipleOf;
+    }
+    else if (second.multipleOf !== undefined) {
+        result.multipleOf = second.multipleOf;
+    }
+    return result;
+}

package/script/parse/v3-2/_merge-all-of/merge-object-constraints.d.ts

@@ -0,0 +1,5 @@
+import type { OpenAPIV3 } from 'openapi-types';
+type SchemaObject = OpenAPIV3.SchemaObject;
+type ReferenceObject = OpenAPIV3.ReferenceObject;
+export declare const mergeObjectConstraints: (first: SchemaObject, second: SchemaObject, getRef: (ref: ReferenceObject) => SchemaObject) => SchemaObject;
+export {};

package/script/parse/v3-2/_merge-all-of/merge-object-constraints.js

@@ -0,0 +1,65 @@
+"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.mergeObjectConstraints = void 0;
+const merge_js_1 = require("./merge.js");
+const generic_merge_js_1 = require("./generic-merge.js");
+const v = __importStar(require("valibot"));
+const check_type_conflicts_js_1 = require("./check-type-conflicts.js");
+const mergeObjectConstraints = (first, second, getRef) => {
+    // Check for type conflicts
+    (0, check_type_conflicts_js_1.checkTypeConflicts)(first, second);
+    const result = (0, generic_merge_js_1.genericMerge)(first, second, getRef, v.record(v.string(), v.any()));
+    if (typeof second.additionalProperties === 'object' &&
+        typeof first.additionalProperties === 'object') {
+        // If both have additionalProperties as schemas, merge them
+        result.additionalProperties = (0, merge_js_1.mergeSchemasOrRefs)(first.additionalProperties, second.additionalProperties, getRef);
+    }
+    else if (second.additionalProperties !== undefined) {
+        result.additionalProperties = second.additionalProperties;
+    }
+    else if (first.additionalProperties !== undefined) {
+        result.additionalProperties = first.additionalProperties;
+    }
+    // Merge minProperties and maxProperties
+    if (second.minProperties !== undefined || first.minProperties !== undefined) {
+        result.minProperties = Math.max(second.minProperties ?? 0, first.minProperties ?? 0);
+    }
+    if (second.maxProperties !== undefined || first.maxProperties !== undefined) {
+        result.maxProperties = Math.min(second.maxProperties ?? Infinity, first.maxProperties ?? Infinity);
+    }
+    return result;
+};
+exports.mergeObjectConstraints = mergeObjectConstraints;

package/script/parse/v3-2/_merge-all-of/merge-properties.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaObject, GetRefFn } from './types.js';
+export declare const mergeProperties: (first: SchemaObject, second: SchemaObject, getRef: GetRefFn) => SchemaObject | undefined;

package/script/parse/v3-2/_merge-all-of/merge-properties.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeProperties = void 0;
+const merge_js_1 = require("./merge.js");
+const mergeProperties = (first, second, getRef) => {
+    if (containsProperties(first, second)) {
+        const properties = { ...first.properties };
+        if (!properties) {
+            return {
+                properties: second.properties
+            };
+        }
+        for (const key in second.properties) {
+            if (key in properties) {
+                properties[key] = (0, merge_js_1.mergeSchemasOrRefs)(properties[key], second.properties[key], getRef);
+            }
+            else {
+                properties[key] = second.properties[key];
+            }
+        }
+        return {
+            properties
+        };
+    }
+};
+exports.mergeProperties = mergeProperties;
+const containsProperties = (first, second) => {
+    return Boolean(first.properties || second.properties);
+};

package/script/parse/v3-2/_merge-all-of/merge-required.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaObject } from './types.js';
+export declare const containsRequired: (first: SchemaObject, second: SchemaObject) => boolean;
+export declare const mergeRequired: (first: SchemaObject, second: SchemaObject) => SchemaObject | undefined;

package/script/parse/v3-2/_merge-all-of/merge-required.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeRequired = exports.containsRequired = void 0;
+const containsRequired = (first, second) => {
+    return Boolean(first.required || second.required);
+};
+exports.containsRequired = containsRequired;
+const mergeRequired = (first, second) => {
+    if ((0, exports.containsRequired)(first, second)) {
+        return {
+            required: [...(first.required ?? []), ...(second.required ?? [])]
+        };
+    }
+};
+exports.mergeRequired = mergeRequired;

package/script/parse/v3-2/_merge-all-of/merge-string-constraints.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { GetRefFn } from './types.js';
+export declare function mergeStringConstraints(first: OpenAPIV3.SchemaObject, second: OpenAPIV3.SchemaObject, getRef: GetRefFn): OpenAPIV3.SchemaObject;

package/script/parse/v3-2/_merge-all-of/merge-string-constraints.js

@@ -0,0 +1,91 @@
+"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.mergeStringConstraints = mergeStringConstraints;
+const generic_merge_js_1 = require("./generic-merge.js");
+const v = __importStar(require("valibot"));
+const check_type_conflicts_js_1 = require("./check-type-conflicts.js");
+const check_at_least_one_type_match_js_1 = require("./check-at-least-one-type-match.js");
+function mergeStringConstraints(first, second, getRef) {
+    (0, check_type_conflicts_js_1.checkTypeConflicts)(first, second);
+    if (!(0, check_at_least_one_type_match_js_1.checkAtLeastOneTypeMatch)(first, second, 'string')) {
+        return (0, generic_merge_js_1.genericMerge)(first, second, getRef);
+    }
+    // First merge enum values if present
+    const result = (0, generic_merge_js_1.genericMerge)(first, second, getRef, v.string());
+    // Then merge other constraints
+    result.type = 'string';
+    // Merge minLength
+    if (first.minLength !== undefined || second.minLength !== undefined) {
+        const minA = first.minLength ?? 0;
+        const minB = second.minLength ?? 0;
+        result.minLength = Math.max(minA, minB);
+    }
+    // Merge maxLength
+    if (first.maxLength !== undefined || second.maxLength !== undefined) {
+        const maxA = first.maxLength ?? Infinity;
+        const maxB = second.maxLength ?? Infinity;
+        result.maxLength = Math.min(maxA, maxB);
+    }
+    // Merge pattern
+    if (first.pattern !== undefined && second.pattern !== undefined) {
+        // If both have patterns, they must match
+        if (first.pattern !== second.pattern) {
+            throw new Error(`Cannot merge schemas: conflicting patterns '${first.pattern}' and '${second.pattern}'`);
+        }
+        result.pattern = first.pattern;
+    }
+    else if (first.pattern !== undefined) {
+        result.pattern = first.pattern;
+    }
+    else if (second.pattern !== undefined) {
+        result.pattern = second.pattern;
+    }
+    // Merge format
+    if (first.format !== undefined && second.format !== undefined) {
+        // If both have formats, they must match
+        if (first.format !== second.format) {
+            throw new Error('Incompatible string formats');
+        }
+        result.format = first.format;
+    }
+    else if (first.format !== undefined) {
+        result.format = first.format;
+    }
+    else if (second.format !== undefined) {
+        result.format = second.format;
+    }
+    return result;
+}

package/script/parse/v3-2/_merge-all-of/merge-union.d.ts

@@ -0,0 +1,15 @@
+import type { GetRefFn, SchemaOrReference, SchemaObject } from './types.js';
+type MergeUnionArgs = {
+    schema: SchemaObject;
+    getRef: GetRefFn;
+    groupType: 'oneOf' | 'anyOf';
+};
+export declare const mergeUnion: ({ schema, getRef, groupType }: MergeUnionArgs) => SchemaOrReference;
+type MergeCrossProductArgs = {
+    first: SchemaObject;
+    second: SchemaObject;
+    getRef: GetRefFn;
+    groupType: 'oneOf' | 'anyOf';
+};
+export declare const mergeCrossProduct: ({ first, second, getRef, groupType }: MergeCrossProductArgs) => SchemaObject;
+export {};

package/script/parse/v3-2/_merge-all-of/merge-union.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeCrossProduct = exports.mergeUnion = void 0;
+const decompose_union_js_1 = require("./decompose-union.js");
+const merge_js_1 = require("./merge.js");
+const cross_product_js_1 = require("./cross-product.js");
+const refFns_js_1 = require("../../../helpers/refFns.js");
+const mergeUnion = ({ schema, getRef, groupType }) => {
+    const { beforeExcluded, decomposed, afterExcluded } = (0, decompose_union_js_1.decomposeUnion)({ schema, groupType });
+    // if (decomposed.length === 1) {
+    //   console.log('DECOMPOSED', JSON.stringify(decomposed[0], null, 2))
+    //   const result = {
+    //     ...beforeExcluded,
+    //     ...decomposed[0],
+    //     ...afterExcluded
+    //   }
+    //   console.log('MERGED UNION - SHORT', JSON.stringify(result, null, 2))
+    //   return result
+    // }
+    const dereffed = decomposed.map(decomposed => {
+        return '$ref' in decomposed ? getRef(decomposed) : decomposed;
+    });
+    const result = dereffed.reduce((acc, decomposed) => {
+        const merged = (0, exports.mergeCrossProduct)({ first: acc, second: decomposed, getRef, groupType });
+        return merged;
+    }, {});
+    const output = {
+        ...beforeExcluded,
+        ...result,
+        ...afterExcluded
+    };
+    return output;
+};
+exports.mergeUnion = mergeUnion;
+const mergeCrossProduct = ({ first, second, getRef, groupType }) => {
+    const firstGroup = Array.isArray(first[groupType]) ? first[groupType] : [first];
+    const secondGroup = Array.isArray(second[groupType]) ? second[groupType] : [second];
+    const mergedGroup = (0, cross_product_js_1.crossProduct)(firstGroup, secondGroup)
+        .map(([firstItem, secondItem]) => {
+        try {
+            const result = (0, merge_js_1.mergeSchemasOrRefs)(firstItem, secondItem, getRef);
+            return result;
+        }
+        catch (_error) {
+            return undefined;
+        }
+    })
+        .filter(item => item !== undefined);
+    return {
+        [groupType]: mergedGroup.flatMap(item => {
+            if (!(0, refFns_js_1.isRef)(item) && Array.isArray(item[groupType])) {
+                return item[groupType];
+            }
+            return [item];
+        })
+    };
+};
+exports.mergeCrossProduct = mergeCrossProduct;

package/script/parse/v3-2/_merge-all-of/merge.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaOrReference, GetRefFn } from './types.js';
+export declare const mergeSchemasOrRefs: (first: SchemaOrReference, second: SchemaOrReference, getRef: GetRefFn) => SchemaOrReference;

package/script/parse/v3-2/_merge-all-of/merge.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSchemasOrRefs = void 0;
+const refFns_js_1 = require("../../../helpers/refFns.js");
+const check_type_conflicts_js_1 = require("./check-type-conflicts.js");
+const check_read_only_write_only_conflicts_js_1 = require("./check-read-only-write-only-conflicts.js");
+const check_format_conflicts_js_1 = require("./check-format-conflicts.js");
+const check_enum_conflicts_js_1 = require("./check-enum-conflicts.js");
+const check_number_constraints_conflicts_js_1 = require("./check-number-constraints-conflicts.js");
+const check_array_item_type_conflicts_js_1 = require("./check-array-item-type-conflicts.js");
+const merge_object_constraints_js_1 = require("./merge-object-constraints.js");
+const merge_array_constraints_js_1 = require("./merge-array-constraints.js");
+const merge_string_constraints_js_1 = require("./merge-string-constraints.js");
+const merge_number_constraints_js_1 = require("./merge-number-constraints.js");
+const merge_integer_constraints_js_1 = require("./merge-integer-constraints.js");
+const merge_boolean_constraints_js_1 = require("./merge-boolean-constraints.js");
+const generic_merge_js_1 = require("./generic-merge.js");
+const check_at_least_one_type_match_js_1 = require("./check-at-least-one-type-match.js");
+const merge_intersection_js_1 = require("./merge-intersection.js");
+const merge_union_js_1 = require("./merge-union.js");
+const isEmpty_js_1 = require("../../../helpers/isEmpty.js");
+const nullable_merge_js_1 = require("./nullable-merge.js");
+const mergeSchemasOrRefs = (first, second, getRef) => {
+    if (containsRef(first, second)) {
+        return mergeWithRef(first, second, getRef);
+    }
+    if ((0, refFns_js_1.isRef)(first)) {
+        throw new Error('Ref in first');
+    }
+    if ((0, refFns_js_1.isRef)(second)) {
+        throw new Error('Ref in second');
+    }
+    if (containsAllOf(first) || containsAllOf(second)) {
+        const mergedFirst = containsAllOf(first) ? (0, merge_intersection_js_1.mergeIntersection)({ schema: first, getRef }) : first;
+        const mergedSecond = containsAllOf(second)
+            ? (0, merge_intersection_js_1.mergeIntersection)({ schema: second, getRef })
+            : second;
+        return (0, exports.mergeSchemasOrRefs)(mergedFirst, mergedSecond, getRef);
+    }
+    if (containsOneOf(first, second)) {
+        return (0, merge_union_js_1.mergeCrossProduct)({ first, second, getRef, groupType: 'oneOf' });
+    }
+    if (containsAnyOf(first, second)) {
+        return (0, merge_union_js_1.mergeCrossProduct)({ first, second, getRef, groupType: 'anyOf' });
+    }
+    if ((0, nullable_merge_js_1.isNullOnly)(first)) {
+        return (0, nullable_merge_js_1.mergeNullOnly)(second);
+    }
+    if ((0, nullable_merge_js_1.isNullOnly)(second)) {
+        return (0, nullable_merge_js_1.mergeNullOnly)(first);
+    }
+    return mergeSchemas(first, second, getRef);
+};
+exports.mergeSchemasOrRefs = mergeSchemasOrRefs;
+const containsAllOf = (schema) => {
+    if (schema.allOf) {
+        if (schema.allOf?.length) {
+            return true;
+        }
+        throw new Error('Empty allOf');
+    }
+    return false;
+};
+const containsAnyOf = (first, second) => {
+    if (first.anyOf) {
+        if (first.anyOf?.length) {
+            return true;
+        }
+        throw new Error('Empty anyOf');
+    }
+    if (second.anyOf) {
+        if (second.anyOf?.length) {
+            return true;
+        }
+        throw new Error('Empty anyOf');
+    }
+    return false;
+};
+const containsOneOf = (first, second) => {
+    if (first.oneOf) {
+        if (first.oneOf?.length) {
+            return true;
+        }
+        throw new Error('Empty oneOf');
+    }
+    if (second.oneOf) {
+        if (second.oneOf?.length) {
+            return true;
+        }
+        throw new Error('Empty oneOf');
+    }
+    return false;
+};
+const containsRef = (first, second) => {
+    return (0, refFns_js_1.isRef)(first) || (0, refFns_js_1.isRef)(second);
+};
+const mergeSchemas = (first, second, getRef) => {
+    try {
+        (0, check_type_conflicts_js_1.checkTypeConflicts)(first, second);
+    }
+    catch (e) {
+        throw e;
+    }
+    (0, check_read_only_write_only_conflicts_js_1.checkReadOnlyWriteOnlyConflicts)(first, second);
+    (0, check_format_conflicts_js_1.checkFormatConflicts)(first, second);
+    (0, check_enum_conflicts_js_1.checkEnumConflicts)(first, second);
+    (0, check_number_constraints_conflicts_js_1.checkNumberConstraintsConflicts)(first, second);
+    (0, check_array_item_type_conflicts_js_1.checkArrayItemTypeConflicts)(first, second);
+    if (first.not || second.not) {
+        throw new Error('Merging schemas with "not" keyword is not supported');
+    }
+    return typedMerge(first, second, getRef);
+};
+const typedMerge = (first, second, getRef) => {
+    if (!first.type && !second.type) {
+        return (0, generic_merge_js_1.genericMerge)(first, second, getRef);
+    }
+    if ((0, check_at_least_one_type_match_js_1.checkAtLeastOneTypeMatch)(first, second, 'object')) {
+        return (0, merge_object_constraints_js_1.mergeObjectConstraints)(first, second, getRef);
+    }
+    if ((0, check_at_least_one_type_match_js_1.checkAtLeastOneTypeMatch)(first, second, 'array')) {
+        return (0, merge_array_constraints_js_1.mergeArrayConstraints)(first, second, getRef);
+    }
+    if ((0, check_at_least_one_type_match_js_1.checkAtLeastOneTypeMatch)(first, second, 'string')) {
+        return (0, merge_string_constraints_js_1.mergeStringConstraints)(first, second, getRef);
+    }
+    if ((0, check_at_least_one_type_match_js_1.checkAtLeastOneTypeMatch)(first, second, 'number')) {
+        return (0, merge_number_constraints_js_1.mergeNumberConstraints)(first, second, getRef);
+    }
+    if ((0, check_at_least_one_type_match_js_1.checkAtLeastOneTypeMatch)(first, second, 'integer')) {
+        return (0, merge_integer_constraints_js_1.mergeIntegerConstraints)(first, second, getRef);
+    }
+    if ((0, check_at_least_one_type_match_js_1.checkAtLeastOneTypeMatch)(first, second, 'boolean')) {
+        return (0, merge_boolean_constraints_js_1.mergeBooleanConstraints)(first, second, getRef);
+    }
+    throw new Error(`Cannot merge schemas with type "${first.type}" with type "${second.type}"`);
+};
+const mergeWithRef = (first, second, getRef) => {
+    if ((0, refFns_js_1.isRef)(first) && (0, refFns_js_1.isRef)(second)) {
+        if (first.$ref === second.$ref) {
+            return {
+                ...first,
+                ...second
+            };
+        }
+        else {
+            return mergeSchemas(getRef(first), getRef(second), getRef);
+        }
+    }
+    if ((0, refFns_js_1.isRef)(first) && !(0, refFns_js_1.isRef)(second)) {
+        const merged = (0, isEmpty_js_1.isEmpty)(second) ? first : mergeSchemas(getRef(first), second, getRef);
+        return merged;
+    }
+    if (!(0, refFns_js_1.isRef)(first) && (0, refFns_js_1.isRef)(second)) {
+        const merged = (0, isEmpty_js_1.isEmpty)(first) ? second : mergeSchemas(first, getRef(second), getRef);
+        return merged;
+    }
+    throw new Error('Invalid input');
+};

package/script/parse/v3-2/_merge-all-of/nullable-merge.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const mergeNullOnly: (schema: OpenAPIV3.SchemaObject) => OpenAPIV3.SchemaObject;
+export declare const isNullOnly: (schema: OpenAPIV3.SchemaObject) => boolean;

package/script/parse/v3-2/_merge-all-of/nullable-merge.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNullOnly = exports.mergeNullOnly = void 0;
+const isEmpty_js_1 = require("../../../helpers/isEmpty.js");
+const mergeNullOnly = (schema) => {
+    if (schema.enum && !schema.enum.includes(null)) {
+        schema.enum.push(null);
+    }
+    schema.nullable = true;
+    return schema;
+};
+exports.mergeNullOnly = mergeNullOnly;
+const isNullOnly = (schema) => {
+    const { type: _type, nullable, enum: enumValues, ...rest } = schema;
+    return (Boolean(nullable) && enumValues?.length === 1 && enumValues[0] === null && (0, isEmpty_js_1.isEmpty)(rest ?? {}));
+};
+exports.isNullOnly = isNullOnly;

package/script/parse/v3-2/_merge-all-of/types.d.ts

@@ -0,0 +1,14 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import * as v from 'valibot';
+export type GetRefFn = (ref: OpenAPIV3.ReferenceObject) => OpenAPIV3.SchemaObject;
+export type OneOfObject = {
+    oneOf?: (OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject)[];
+} & OpenAPIV3.SchemaObject;
+export type AnyOfObject = {
+    anyOf?: (OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject)[];
+} & OpenAPIV3.SchemaObject;
+export type SchemaObject = OpenAPIV3.SchemaObject;
+export type ReferenceObject = OpenAPIV3.ReferenceObject;
+export type SchemaOrReference = SchemaObject | ReferenceObject;
+export type ArraySchemaObject = OpenAPIV3.ArraySchemaObject;
+export declare const IntegerSchema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, "The number must be an integer.">]>;

package/script/parse/v3-2/_merge-all-of/types.js

@@ -0,0 +1,38 @@
+"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.IntegerSchema = void 0;
+const v = __importStar(require("valibot"));
+exports.IntegerSchema = v.pipe(v.number(), v.integer('The number must be an integer.'));