@skmtc/core 0.28.7 → 0.30.1

package/esm/parse/v3-2/_merge-all-of/decompose-union.js

@@ -0,0 +1,69 @@
+// Convert a schema object into an array of schemas that can be merged iteratively into a new schema
+export const decomposeUnion = ({ schema, groupType }) => {
+    if (!schema[groupType]) {
+        return {
+            beforeExcluded: {},
+            decomposed: [schema],
+            afterExcluded: {}
+        };
+    }
+    let location = 'before';
+    const output = {
+        before: [],
+        inside: [],
+        after: []
+    };
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === groupType) {
+            // do not decompose wrapper for unions (oneOf, anyOf)
+            output.inside = [{ [groupType]: value }];
+            location = 'after';
+        }
+        else {
+            output[location].push([key, value]);
+        }
+    }
+    const { retained: before, excluded: beforeExcluded } = exclude(output.before);
+    const { retained: after, excluded: afterExcluded } = exclude(output.after);
+    const decomposed = [
+        before.length > 0 ? Object.fromEntries(before) : undefined,
+        ...output.inside,
+        after.length > 0 ? Object.fromEntries(after) : undefined
+    ].filter(item => item !== undefined);
+    const result = {
+        beforeExcluded: Object.fromEntries(beforeExcluded),
+        decomposed,
+        afterExcluded: Object.fromEntries(afterExcluded)
+    };
+    return result;
+};
+// Union-level keys: kept on the union (via beforeExcluded/afterExcluded)
+// rather than cross-product-merged into each member. Merging a metadata key
+// *into* a member would resolve `$ref` members (to merge it in), losing their
+// names — `toUnion` already captures these on the union itself.
+// (`not` is deliberately NOT excluded here — it has no faithful TypeScript
+// representation, so a schema using it is refused upstream in `toSchemaV3`
+// rather than silently dropped from the union.)
+const excludedProperties = [
+    'discriminator',
+    'default',
+    'description',
+    'title',
+    'nullable',
+    'example',
+    'examples',
+    'readOnly',
+    'writeOnly',
+    'deprecated'
+];
+const exclude = (entries) => {
+    return entries.reduce((acc, [key, value]) => {
+        if (excludedProperties.includes(key)) {
+            acc.excluded.push([key, value]);
+        }
+        else {
+            acc.retained.push([key, value]);
+        }
+        return acc;
+    }, { retained: [], excluded: [] });
+};

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

@@ -0,0 +1,3 @@
+import type { SchemaObject, GetRefFn } from './types.js';
+import type * as v from 'valibot';
+export declare const genericMerge: <T>(first: SchemaObject, second: SchemaObject, getRef: GetRefFn, typeCheck?: v.GenericSchema<T>) => SchemaObject;

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

@@ -0,0 +1,12 @@
+import { mergeEnumValues } from './merge-enum-values.js';
+import { mergeProperties } from './merge-properties.js';
+import { mergeRequired } from './merge-required.js';
+export const genericMerge = (first, second, getRef, typeCheck) => {
+    return {
+        ...first,
+        ...second,
+        ...mergeProperties(first, second, getRef),
+        ...mergeRequired(first, second),
+        ...mergeEnumValues(first, second, typeCheck)
+    };
+};

package/esm/parse/v3-2/_merge-all-of/is-equal.d.ts

@@ -0,0 +1 @@
+export declare const isEqual: (first: unknown, second: unknown) => boolean;

package/esm/parse/v3-2/_merge-all-of/is-equal.js

@@ -0,0 +1,19 @@
+export const isEqual = (first, second) => {
+    if (Array.isArray(first) && Array.isArray(second)) {
+        if (first.length !== second.length)
+            return false;
+        return first.every((value, index) => isEqual(value, second[index]));
+    }
+    if (typeof first === 'object' &&
+        typeof second === 'object' &&
+        first !== null &&
+        second !== null) {
+        const aKeys = Object.keys(first);
+        const bKeys = Object.keys(second);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every(key => bKeys.includes(key) &&
+            isEqual(first[key], second[key]));
+    }
+    return first === second;
+};

package/esm/parse/v3-2/_merge-all-of/merge-array-constraints.d.ts

@@ -0,0 +1,2 @@
+import type { ArraySchemaObject, GetRefFn, SchemaObject } from './types.js';
+export declare function mergeArrayConstraints(first: ArraySchemaObject | SchemaObject, second: ArraySchemaObject | SchemaObject, getRef: GetRefFn): ArraySchemaObject;

package/esm/parse/v3-2/_merge-all-of/merge-array-constraints.js

@@ -0,0 +1,44 @@
+import { mergeSchemasOrRefs } from './merge.js';
+import { genericMerge } from './generic-merge.js';
+import * as v from 'valibot';
+import { checkTypeConflicts } from './check-type-conflicts.js';
+export function mergeArrayConstraints(first, second, getRef) {
+    checkTypeConflicts(first, second);
+    if (!('items' in first) && !('items' in second)) {
+        throw new Error('Cannot merge array constraints: no items found');
+    }
+    const result = {
+        ...genericMerge(first, second, getRef, v.array(v.any())),
+        type: 'array',
+        items: mergeItems(first, second, getRef)
+    };
+    // Merge minItems
+    if (first.minItems !== undefined || second.minItems !== undefined) {
+        const minA = first.minItems ?? 0;
+        const minB = second.minItems ?? 0;
+        result.minItems = Math.max(minA, minB);
+    }
+    // Merge maxItems
+    if (first.maxItems !== undefined || second.maxItems !== undefined) {
+        const maxA = first.maxItems ?? Infinity;
+        const maxB = second.maxItems ?? Infinity;
+        result.maxItems = Math.min(maxA, maxB);
+    }
+    // Merge uniqueItems
+    if (first.uniqueItems || second.uniqueItems) {
+        result.uniqueItems = true;
+    }
+    return result;
+}
+const mergeItems = (first, second, getRef) => {
+    if ('items' in first && 'items' in second && first.items && second.items) {
+        return mergeSchemasOrRefs(first.items, second.items, getRef);
+    }
+    if ('items' in first && first.items) {
+        return first.items;
+    }
+    if ('items' in second && second.items) {
+        return second.items;
+    }
+    throw new Error('Cannot merge array constraints: no items found');
+};

package/esm/parse/v3-2/_merge-all-of/merge-boolean-constraints.d.ts

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

package/esm/parse/v3-2/_merge-all-of/merge-boolean-constraints.js

@@ -0,0 +1,7 @@
+import { genericMerge } from './generic-merge.js';
+import * as v from 'valibot';
+import { checkTypeConflicts } from './check-type-conflicts.js';
+export function mergeBooleanConstraints(first, second, getRef) {
+    checkTypeConflicts(first, second);
+    return genericMerge(first, second, getRef, v.boolean());
+}

package/esm/parse/v3-2/_merge-all-of/merge-enum-values.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaObject } from './types.js';
+import * as v from 'valibot';
+export declare function mergeEnumValues<T>(first: SchemaObject, second: SchemaObject, typeCheck?: v.GenericSchema<T>): Pick<SchemaObject, 'enum'>;

package/esm/parse/v3-2/_merge-all-of/merge-enum-values.js

@@ -0,0 +1,32 @@
+import { isEqual } from './is-equal.js';
+import * as v from 'valibot';
+const containsEnum = (schema) => {
+    return Array.isArray(schema.enum);
+};
+export function mergeEnumValues(first, second, typeCheck) {
+    if (!containsEnum(first) && !containsEnum(second)) {
+        return {};
+    }
+    if (!containsEnum(first) && containsEnum(second)) {
+        return {
+            enum: second.enum
+        };
+    }
+    if (containsEnum(first) && !containsEnum(second)) {
+        return {
+            enum: first.enum
+        };
+    }
+    // Find intersection of enum values
+    const intersection = first
+        .enum.filter(value => second.enum.some(bValue => isEqual(value, bValue)))
+        .map(value => (typeCheck ? (v.is(typeCheck, value) ? value : undefined) : value));
+    // If intersection is empty, throw error
+    if (intersection.length === 0) {
+        throw new Error('Merged schema has empty enum array');
+    }
+    // Return merged schema with intersection of enum values
+    return {
+        enum: intersection
+    };
+}

package/esm/parse/v3-2/_merge-all-of/merge-integer-constraints.d.ts

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

package/esm/parse/v3-2/_merge-all-of/merge-integer-constraints.js

@@ -0,0 +1,41 @@
+import { genericMerge } from './generic-merge.js';
+import * as v from 'valibot';
+import { checkTypeConflicts } from './check-type-conflicts.js';
+export function mergeIntegerConstraints(first, second, getRef) {
+    checkTypeConflicts(first, second);
+    // First merge enum values if present
+    const result = genericMerge(first, second, getRef, v.number());
+    // Then merge other constraints
+    result.type = 'integer';
+    // 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/esm/parse/v3-2/_merge-all-of/merge-intersection.d.ts

@@ -0,0 +1,8 @@
+import type { GetRefFn, SchemaOrReference, SchemaObject } from './types.js';
+type MergeIntersectionArgs = {
+    schema: SchemaObject;
+    getRef: GetRefFn;
+    throwOnConflict?: boolean;
+};
+export declare const mergeIntersection: ({ schema, getRef }: MergeIntersectionArgs) => SchemaOrReference;
+export {};

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

@@ -0,0 +1,16 @@
+import { decomposeIntersection } from './decompose-intersection.js';
+import { mergeSchemasOrRefs } from './merge.js';
+export const mergeIntersection = ({ schema, getRef }) => {
+    const decomposed = decomposeIntersection({ schema });
+    if (decomposed.length === 1) {
+        return decomposed[0];
+    }
+    const dereffed = decomposed.map(decomposed => {
+        return '$ref' in decomposed ? getRef(decomposed) : decomposed;
+    });
+    const result = dereffed.reduce((acc, decomposed) => {
+        const merged = mergeSchemasOrRefs(acc, decomposed, getRef);
+        return merged;
+    }, {});
+    return result;
+};

package/esm/parse/v3-2/_merge-all-of/merge-number-constraints.d.ts

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

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

@@ -0,0 +1,41 @@
+import { genericMerge } from './generic-merge.js';
+import * as v from 'valibot';
+import { checkTypeConflicts } from './check-type-conflicts.js';
+export function mergeNumberConstraints(first, second, getRef) {
+    checkTypeConflicts(first, second);
+    // First merge enum values if present
+    const result = 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/esm/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/esm/parse/v3-2/_merge-all-of/merge-object-constraints.js

@@ -0,0 +1,28 @@
+import { mergeSchemasOrRefs } from './merge.js';
+import { genericMerge } from './generic-merge.js';
+import * as v from 'valibot';
+import { checkTypeConflicts } from './check-type-conflicts.js';
+export const mergeObjectConstraints = (first, second, getRef) => {
+    // Check for type conflicts
+    checkTypeConflicts(first, second);
+    const result = 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 = 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;
+};

package/esm/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/esm/parse/v3-2/_merge-all-of/merge-properties.js

@@ -0,0 +1,25 @@
+import { mergeSchemasOrRefs } from './merge.js';
+export 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] = mergeSchemasOrRefs(properties[key], second.properties[key], getRef);
+            }
+            else {
+                properties[key] = second.properties[key];
+            }
+        }
+        return {
+            properties
+        };
+    }
+};
+const containsProperties = (first, second) => {
+    return Boolean(first.properties || second.properties);
+};

package/esm/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/esm/parse/v3-2/_merge-all-of/merge-required.js

@@ -0,0 +1,10 @@
+export const containsRequired = (first, second) => {
+    return Boolean(first.required || second.required);
+};
+export const mergeRequired = (first, second) => {
+    if (containsRequired(first, second)) {
+        return {
+            required: [...(first.required ?? []), ...(second.required ?? [])]
+        };
+    }
+};

package/esm/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/esm/parse/v3-2/_merge-all-of/merge-string-constraints.js

@@ -0,0 +1,55 @@
+import { genericMerge } from './generic-merge.js';
+import * as v from 'valibot';
+import { checkTypeConflicts } from './check-type-conflicts.js';
+import { checkAtLeastOneTypeMatch } from './check-at-least-one-type-match.js';
+export function mergeStringConstraints(first, second, getRef) {
+    checkTypeConflicts(first, second);
+    if (!checkAtLeastOneTypeMatch(first, second, 'string')) {
+        return genericMerge(first, second, getRef);
+    }
+    // First merge enum values if present
+    const result = 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/esm/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/esm/parse/v3-2/_merge-all-of/merge-union.js

@@ -0,0 +1,53 @@
+import { decomposeUnion } from './decompose-union.js';
+import { mergeSchemasOrRefs } from './merge.js';
+import { crossProduct } from './cross-product.js';
+import { isRef } from '../../../helpers/refFns.js';
+export const mergeUnion = ({ schema, getRef, groupType }) => {
+    const { beforeExcluded, decomposed, afterExcluded } = 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 = mergeCrossProduct({ first: acc, second: decomposed, getRef, groupType });
+        return merged;
+    }, {});
+    const output = {
+        ...beforeExcluded,
+        ...result,
+        ...afterExcluded
+    };
+    return output;
+};
+export 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 = crossProduct(firstGroup, secondGroup)
+        .map(([firstItem, secondItem]) => {
+        try {
+            const result = mergeSchemasOrRefs(firstItem, secondItem, getRef);
+            return result;
+        }
+        catch (_error) {
+            return undefined;
+        }
+    })
+        .filter(item => item !== undefined);
+    return {
+        [groupType]: mergedGroup.flatMap(item => {
+            if (!isRef(item) && Array.isArray(item[groupType])) {
+                return item[groupType];
+            }
+            return [item];
+        })
+    };
+};

package/esm/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;