@skmtc/core 0.0.984 → 0.16.1

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

@@ -0,0 +1,66 @@
+"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);
+    // Defensive floor: when both groups are non-empty the cross product is
+    // non-empty, so an empty `mergedGroup` means every merge *failed* (an
+    // unmergeable constraint in `secondGroup`). Keep the un-merged `firstGroup`
+    // rather than collapsing to an empty union. A genuinely empty input union
+    // (`anyOf: []` → empty group) is left empty so `toSchemasV3` still throws.
+    if (mergedGroup.length === 0 && firstGroup.length > 0 && secondGroup.length > 0) {
+        return { [groupType]: firstGroup };
+    }
+    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-0/_merge-all-of/merge.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaOrReference, GetRefFn } from './types.js';
+export declare const mergeSchemasOrRefs: (first: SchemaOrReference, second: SchemaOrReference, getRef: GetRefFn) => SchemaOrReference;
+//# sourceMappingURL=merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/merge.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiC,QAAQ,EAAE,MAAM,YAAY,CAAA;AAoB5F,eAAO,MAAM,kBAAkB,GAC7B,OAAO,iBAAiB,EACxB,QAAQ,iBAAiB,EACzB,QAAQ,QAAQ,KACf,iBAwCF,CAAA"}

package/script/parse/v3-0/_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-0/_merge-all-of/nullable-merge.d.ts

@@ -0,0 +1,4 @@
+import type { OpenAPIV3 } from 'openapi-types';
+export declare const mergeNullOnly: (schema: OpenAPIV3.SchemaObject) => OpenAPIV3.SchemaObject;
+export declare const isNullOnly: (schema: OpenAPIV3.SchemaObject) => boolean;
+//# sourceMappingURL=nullable-merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nullable-merge.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/nullable-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAG9C,eAAO,MAAM,aAAa,GAAI,QAAQ,SAAS,CAAC,YAAY,KAAG,SAAS,CAAC,YAQxE,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,QAAQ,SAAS,CAAC,YAAY,KAAG,OAM3D,CAAA"}

package/script/parse/v3-0/_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-0/_merge-all-of/types.d.ts

@@ -0,0 +1,15 @@
+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.">]>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/_merge-all-of/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,MAAM,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,eAAe,KAAK,SAAS,CAAC,YAAY,CAAA;AAEjF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,EAAE,CAAA;CAC/D,GAAG,SAAS,CAAC,YAAY,CAAA;AAE1B,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,EAAE,CAAA;CAC/D,GAAG,SAAS,CAAC,YAAY,CAAA;AAE1B,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,YAAY,CAAA;AACjD,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC,eAAe,CAAA;AACvD,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,eAAe,CAAA;AAE9D,MAAM,MAAM,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,CAAA;AAE3D,eAAO,MAAM,aAAa,mHAAkE,CAAA"}

package/script/parse/v3-0/array/toArray.d.ts

@@ -0,0 +1,81 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasArray } from '../../../oas/array/Array.js';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToArrayArgs = {
+    value: OpenAPIV3.ArraySchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * 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]
+ * ```
+ */
+export declare const toArray: ({ value, context, stackTrail }: ToArrayArgs) => OasArray;
+type ToParsedArrayArgs<Nullable extends boolean | undefined> = {
+    value: Omit<OpenAPIV3.ArraySchemaObject, 'nullable' | 'example' | 'enums' | 'default'>;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+    nullable: Nullable;
+    example: Nullable extends true ? unknown[] | null | undefined : unknown[] | undefined;
+    enums: Nullable extends true ? (unknown[] | null)[] | undefined : unknown[] | undefined;
+    defaultValue: Nullable extends true ? unknown[] | null | undefined : unknown[] | undefined;
+};
+export declare const toParsedArray: <Nullable extends boolean | undefined>({ context, stackTrail, nullable, example, enums, defaultValue, value }: ToParsedArrayArgs<Nullable>) => OasArray<Nullable>;
+export {};
+//# sourceMappingURL=toArray.d.ts.map

package/script/parse/v3-0/array/toArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toArray.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/array/toArray.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AAEtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAQtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,CAAC,iBAAiB,CAAA;IAClC,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,OAAO,GAAI,gCAAgC,WAAW,KAAG,QAuDrE,CAAA;AAED,KAAK,iBAAiB,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC7D,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC,CAAA;IACtF,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;IACzB,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACrF,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACvF,YAAY,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;CAC3F,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,QAAQ,SAAS,OAAO,GAAG,SAAS,EAAE,wEAQjE,iBAAiB,CAAC,QAAQ,CAAC,KAAG,QAAQ,CAAC,QAAQ,CAqEjD,CAAA"}

package/script/parse/v3-0/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-0/boolean/toBoolean.d.ts

@@ -0,0 +1,79 @@
+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 {};
+//# sourceMappingURL=toBoolean.d.ts.map

package/script/parse/v3-0/boolean/toBoolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toBoolean.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-0/boolean/toBoolean.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAQ5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,eAAO,MAAM,SAAS,GAAI,gCAAgC,aAAa,KAAG,UAoDzE,CAAA;AAED,KAAK,mBAAmB,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC/D,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC,CAAA;IACrE,OAAO,EAAE,gBAAgB,CAAA;IACzB,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;IACjF,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACrF,YAAY,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;IACtF,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,QAAQ,SAAS,OAAO,GAAG,SAAS,EAAE,wEAQnE,mBAAmB,CAAC,QAAQ,CAAC,KAAG,UAAU,CAAC,QAAQ,CAgCrD,CAAA"}