@kravc/schema 2.8.0-alpha.6 → 2.8.0-alpha.8

package/dist/helpers/normalizeProperties.js

@@ -1,170 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const lodash_1 = require("lodash");
-/**
- * Normalizes JSON schema properties by ensuring all properties have an explicit `type` attribute.
- *
- * **Intent:**
- * This function transforms schemas that may have implicit or missing type information into
- * fully normalized schemas with explicit types. It recursively processes nested structures
- * (objects and arrays) to ensure type consistency throughout the schema hierarchy.
- *
- * **Use Cases:**
- * - **Schema Validation Preparation**: Ensures schemas are ready for validation where type
- *   information is required by validators or processing tools
- * - **External Schema Normalization**: Normalizes schemas imported from external sources
- *   (e.g., OpenAPI specs, YAML schemas) that may omit type information
- * - **Type Inference**: Automatically infers types from structural hints (e.g., presence of
- *   `properties` implies `object`, presence of `items` implies `array`)
- * - **Schema Consistency**: Guarantees consistent schema structure before further processing
- *   or transformation
- * - **Default Type Assignment**: Provides sensible defaults (e.g., `string` for primitives)
- *   when type cannot be inferred
- *
- * **Behavior:**
- * - **Enum Schemas**: Sets `type` to `'string'` if missing (preserves existing type if present)
- * - **Reference Properties**: Skips `$ref` properties (they don't need type normalization)
- * - **Type Inference Priority** (when type is missing):
- *   1. If property has `properties` → sets `type: 'object'`
- *   2. Else if property has `items` → sets `type: 'array'`
- *   3. Else → sets `type: 'string'` (default)
- * - **Object Properties**:
- *   - Infers `type: 'object'` from presence of `properties` (if type not already set)
- *   - Creates empty `properties: {}` if `type: 'object'` but no properties exist
- *   - Recursively normalizes nested object properties
- *   - Note: If both `properties` and `items` exist, `properties` takes precedence
- * - **Array Properties**:
- *   - Infers `type: 'array'` from presence of `items` (if type not already set)
- *   - Sets default `items: { type: 'string' }` if array has no items
- *   - Normalizes item schemas: sets `type: 'object'` if items have `properties` (not undefined)
- *     - `properties: null` → treated as having properties (sets type to 'object')
- *     - `properties: undefined` → treated as not having properties (no type set)
- *     - Empty object `{}` → treated as not having properties (no type set)
- *   - Recursively normalizes nested properties within array items
- * - **Primitive Properties**: Sets `type: 'string'` as default when no type, items, or properties exist
- * - **Existing Types**: Never overrides existing type values (even if structure suggests different type)
- * - **Edge Cases**:
- *   - Empty schemas (`{}`) are handled gracefully
- *   - Properties with conflicting structure (e.g., `type: 'object'` with `items`) are normalized
- *     according to the explicit type, ignoring conflicting structural hints
- *
- * **Examples:**
- *
- * @example Enum schema normalization
- * ```typescript
- * const schema: EnumSchema = { enum: ['red', 'green', 'blue'] };
- * normalizeProperties(schema);
- * // Result: { enum: ['red', 'green', 'blue'], type: 'string' }
- * ```
- *
- * @example Object type inference
- * ```typescript
- * const schema: PropertiesSchema = {
- *   user: {
- *     properties: {
- *       name: {}
- *     }
- *   }
- * };
- * normalizeProperties(schema);
- * // Result:
- * // {
- * //   user: {
- * //     type: 'object',
- * //     properties: {
- * //       name: { type: 'string' }
- * //     }
- * //   }
- * // }
- * ```
- *
- * @example Array type inference
- * ```typescript
- * const schema: PropertiesSchema = {
- *   tags: {
- *     items: { type: 'string' }
- *   }
- * };
- * normalizeProperties(schema);
- * // Result:
- * // {
- * //   tags: {
- * //     type: 'array',
- * //     items: { type: 'string' }
- * //   }
- * // }
- * ```
- *
- * @example Complex nested structure
- * ```typescript
- * const schema: PropertiesSchema = {
- *   profile: {
- *     properties: {
- *       name: {},
- *       addresses: {
- *         items: {
- *           properties: {
- *             street: {},
- *             city: {}
- *           }
- *         }
- *       }
- *     }
- *   }
- * };
- * normalizeProperties(schema);
- * // Result:
- * // {
- * //   profile: {
- * //     type: 'object',
- * //     properties: {
- * //       name: { type: 'string' },
- * //       addresses: {
- * //         type: 'array',
- * //         items: {
- * //           type: 'object',
- * //           properties: {
- * //             street: { type: 'string' },
- * //             city: { type: 'string' }
- * //           }
- * //         }
- * //       }
- * //     }
- * //   }
- * // }
- * ```
- *
- * @example Reference properties are skipped
- * ```typescript
- * const schema: PropertiesSchema = {
- *   refField: { $ref: '#/definitions/User' },
- *   normalField: {}
- * };
- * normalizeProperties(schema);
- * // Result:
- * // {
- * //   refField: { $ref: '#/definitions/User' }, // Unchanged
- * //   normalField: { type: 'string' }
- * // }
- * ```
- *
- * @example Default type assignment
- * ```typescript
- * const schema: PropertiesSchema = {
- *   title: {},
- *   count: { type: 'number' }
- * };
- * normalizeProperties(schema);
- * // Result:
- * // {
- * //   title: { type: 'string' }, // Default assigned
- * //   count: { type: 'number' }  // Existing preserved
- * // }
- * ```
- *
- * @param schema - The schema to normalize (either an EnumSchema or PropertiesSchema)
- * @modifies The schema object is mutated in place with normalized types
- */
+/** Normalizes JSON schema properties by ensuring all properties have an explicit `type` attribute. */
 const normalizeProperties = (schema) => {
     const { enum: isEnum } = schema;
     if (isEnum) {

package/dist/helpers/normalizeProperties.js.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeProperties.js","sourceRoot":"","sources":["../../src/helpers/normalizeProperties.ts"],"names":[],"mappings":";;AAAA,mCAA+C;AAU/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmKG;AACH,MAAM,mBAAmB,GAAG,CAAC,MAAqC,EAAE,EAAE;IACpE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAI,MAAqB,CAAC;IAEhD,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,UAAU,GAAI,MAAqB,CAAC;QAC1C,UAAU,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,IAAI,QAAQ,CAAC;QAE9C,OAAO;IACT,CAAC;IAED,MAAM,UAAU,GAAI,MAA2B,CAAC;IAEhD,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;QAElC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAI,QAAoC,CAAC;QAE9D,IAAI,KAAK,EAAE,CAAC;YACV,SAAS;QACX,CAAC;QAED,MAAM,OAAO,GAAG,CAAC,CAAC,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACxC,MAAM,QAAQ,GAAG,CAAC,CAAC,IAAA,YAAG,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC1C,MAAM,aAAa,GAAG,CAAC,CAAC,IAAA,YAAG,EAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAEpD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,aAAa,EAAE,CAAC;gBAClB,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;YAElC,CAAC;iBAAM,IAAI,QAAQ,EAAE,CAAC;gBACpB,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YAEjC,CAAC;iBAAM,CAAC;gBACN,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;YAElC,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GAAG,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAEnC,MAAM,QAAQ,GAAG,IAAI,KAAK,QAAQ,CAAC;QAEnC,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC,aAAa,EAAE,CAAC;gBAClB,QAAiC,CAAC,UAAU,GAAG,EAAE,CAAC;YACrD,CAAC;YAED,qGAAqG;YACrG,mBAAmB,CAAE,QAAiC,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC;QAC3E,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,KAAK,OAAO,CAAC;QAEjC,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,QAAQ,EAAE,CAAC;gBACb,oGAAoG;gBACpG,MAAM,EAAE,KAAK,GAAG,EAAE,EAAE,GAAI,QAAgC,CAAC;gBAEzD,MAAM,YAAY,GAAG,CAAC,IAAA,oBAAW,EAAE,KAA8B,CAAC,UAAU,CAAC,CAAC;gBAE9E,IAAI,YAAY,EAAE,CAAC;oBACjB,IAAA,YAAG,EAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;oBAE7B,mBAAmB,CAAE,KAA8B,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC;gBACxE,CAAC;YAEH,CAAC;iBAAM,CAAC;gBACL,QAAgC,CAAC,KAAK,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;YAE/D,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAEF,kBAAe,mBAAmB,CAAC"}
+{"version":3,"file":"normalizeProperties.js","sourceRoot":"","sources":["../../src/helpers/normalizeProperties.ts"],"names":[],"mappings":";;AAAA,mCAA+C;AAE/C,sGAAsG;AACtG,MAAM,mBAAmB,GAAG,CAAC,MAAqC,EAAE,EAAE;IACpE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAI,MAAqB,CAAC;IAEhD,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,UAAU,GAAI,MAAqB,CAAC;QAC1C,UAAU,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,IAAI,QAAQ,CAAC;QAE9C,OAAO;IACT,CAAC;IAED,MAAM,UAAU,GAAI,MAA2B,CAAC;IAEhD,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;QAElC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAI,QAAoC,CAAC;QAE9D,IAAI,KAAK,EAAE,CAAC;YACV,SAAS;QACX,CAAC;QAED,MAAM,OAAO,GAAG,CAAC,CAAC,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACxC,MAAM,QAAQ,GAAG,CAAC,CAAC,IAAA,YAAG,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC1C,MAAM,aAAa,GAAG,CAAC,CAAC,IAAA,YAAG,EAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAEpD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,aAAa,EAAE,CAAC;gBAClB,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;YAElC,CAAC;iBAAM,IAAI,QAAQ,EAAE,CAAC;gBACpB,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YAEjC,CAAC;iBAAM,CAAC;gBACN,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;YAElC,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GAAG,IAAA,YAAG,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAEnC,MAAM,QAAQ,GAAG,IAAI,KAAK,QAAQ,CAAC;QAEnC,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC,aAAa,EAAE,CAAC;gBAClB,QAAiC,CAAC,UAAU,GAAG,EAAE,CAAC;YACrD,CAAC;YAED,qGAAqG;YACrG,mBAAmB,CAAE,QAAiC,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC;QAC3E,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,KAAK,OAAO,CAAC;QAEjC,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,QAAQ,EAAE,CAAC;gBACb,oGAAoG;gBACpG,MAAM,EAAE,KAAK,GAAG,EAAE,EAAE,GAAI,QAAgC,CAAC;gBAEzD,MAAM,YAAY,GAAG,CAAC,IAAA,oBAAW,EAAE,KAA8B,CAAC,UAAU,CAAC,CAAC;gBAE9E,IAAI,YAAY,EAAE,CAAC;oBACjB,IAAA,YAAG,EAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;oBAE7B,mBAAmB,CAAE,KAA8B,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC;gBACxE,CAAC;YAEH,CAAC;iBAAM,CAAC;gBACL,QAAgC,CAAC,KAAK,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;YAE/D,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAEF,kBAAe,mBAAmB,CAAC"}

package/dist/helpers/normalizeRequired.d.ts

@@ -1,159 +1,7 @@
-import type { JsonSchema, ObjectPropertySchema, ReferencePropertySchema } from './JsonSchema';
 /**
  * Normalizes required field declarations in JSON schemas by converting property-level
  * `required` flags to schema-level `required` arrays and `x-required` metadata flags.
- *
- * **Intent:**
- * This function transforms JSON schemas from a property-centric required field model
- * (where each property has its own `required: true/false` flag) to the standard JSON Schema
- * format (where required fields are listed in a top-level `required` array). This normalization
- * ensures compatibility with JSON Schema validators while preserving the original required
- * field information through the `x-required` extension attribute.
- *
- * **Use Cases:**
- * 1. **Schema Standardization**: Convert custom schema formats to standard JSON Schema format
- *    for validator compatibility
- * 2. **Schema Transformation**: Prepare schemas for validation libraries that expect
- *    required fields in array format
- * 3. **Metadata Preservation**: Maintain required field information in both standard format
- *    (`required` array) and extension format (`x-required` flag) for different use cases
- * 4. **Schema Processing Pipeline**: Normalize schemas before validation, credential generation,
- *    or API documentation generation
- *
- * **Behavior:**
- * - Mutates the input schema in-place
- * - Moves `required: true` from property level to schema-level `required` array
- * - Sets `x-required: true` on properties that were marked as required
- * - Deletes the `required` property from individual property schemas
- * - Recursively processes nested object properties
- * - Recursively processes array items (including nested objects within arrays)
- * - Skips reference properties (`$ref`) as they are resolved elsewhere
- * - Skips EnumSchema (returns early)
- * - Only sets `required` array if at least one field is required
- *
- * **Examples:**
- *
- * ```typescript
- * // Example 1: Simple object schema
- * const schema = {
- *   id: 'User',
- *   properties: {
- *     name: { type: 'string', required: true },
- *     email: { type: 'string', required: true },
- *     age: { type: 'number', required: false }
- *   }
- * };
- *
- * normalizeRequired(schema);
- * // Result:
- * // schema.required = ['name', 'email']
- * // schema.properties.name['x-required'] = true
- * // schema.properties.email['x-required'] = true
- * // schema.properties.name.required = undefined (deleted)
- * // schema.properties.email.required = undefined (deleted)
- * ```
- *
- * ```typescript
- * // Example 2: Nested objects
- * const schema = {
- *   id: 'Order',
- *   properties: {
- *     user: {
- *       type: 'object',
- *       required: true,
- *       properties: {
- *         name: { type: 'string', required: true },
- *         address: {
- *           type: 'object',
- *           properties: {
- *             street: { type: 'string', required: true }
- *           }
- *         }
- *       }
- *     }
- *   }
- * };
- *
- * normalizeRequired(schema);
- * // Result:
- * // schema.required = ['user']
- * // schema.properties.user['x-required'] = true
- * // schema.properties.user.required = ['name']
- * // schema.properties.user.properties.name['x-required'] = true
- * // schema.properties.user.properties.address.required = ['street']
- * // schema.properties.user.properties.address.properties.street['x-required'] = true
- * ```
- *
- * ```typescript
- * // Example 3: Arrays with object items
- * const schema = {
- *   id: 'Order',
- *   properties: {
- *     items: {
- *       type: 'array',
- *       required: true,
- *       items: {
- *         type: 'object',
- *         properties: {
- *           productId: { type: 'string', required: true },
- *           quantity: { type: 'number', required: true }
- *         }
- *       }
- *     }
- *   }
- * };
- *
- * normalizeRequired(schema);
- * // Result:
- * // schema.required = ['items']
- * // schema.properties.items['x-required'] = true
- * // schema.properties.items.items.required = ['productId', 'quantity']
- * // schema.properties.items.items.properties.productId['x-required'] = true
- * // schema.properties.items.items.properties.quantity['x-required'] = true
- * ```
- *
- * ```typescript
- * // Example 4: Mixed structure
- * const schema = {
- *   id: 'Profile',
- *   properties: {
- *     name: { type: 'string', required: true },
- *     address: {
- *       type: 'object',
- *       required: true,
- *       properties: {
- *         street: { type: 'string', required: true },
- *         city: { type: 'string' }
- *       }
- *     },
- *     tags: {
- *       type: 'array',
- *       items: {
- *         type: 'object',
- *         properties: {
- *           label: { type: 'string', required: true }
- *         }
- *       }
- *     }
- *   }
- * };
- *
- * normalizeRequired(schema);
- * // Result:
- * // schema.required = ['name', 'address']
- * // All nested required fields are normalized recursively
- * ```
- *
- * **Limitations:**
- * - Only processes schemas with a `properties` field (ObjectSchema or ObjectPropertySchema)
- * - EnumSchema is accepted but returns early without processing
- * - Reference properties (`$ref`) are skipped and not processed
- * - The function mutates the input schema object
- * - Does not resolve `$ref` references (they must be resolved separately)
- *
- * @param jsonSchema - The JSON schema to normalize (ObjectSchema, ObjectPropertySchema, or ReferencePropertySchema)
- * @returns void (mutates the input schema in-place)
  */
-declare const normalizeRequired: (jsonSchema: JsonSchema | ObjectPropertySchema | ReferencePropertySchema) => void;
+declare const normalizeRequired: (jsonSchema: EnumSchema | ObjectSchema | ObjectPropertySchema | ReferencePropertySchema) => void;
 export default normalizeRequired;
 //# sourceMappingURL=normalizeRequired.d.ts.map

package/dist/helpers/normalizeRequired.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeRequired.d.ts","sourceRoot":"","sources":["../../src/helpers/normalizeRequired.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EAIV,oBAAoB,EACpB,uBAAuB,EACxB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0JG;AACH,QAAA,MAAM,iBAAiB,GAAI,YAAY,UAAU,GAAG,oBAAoB,GAAG,uBAAuB,SAgEjG,CAAC;AAEF,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"normalizeRequired.d.ts","sourceRoot":"","sources":["../../src/helpers/normalizeRequired.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,QAAA,MAAM,iBAAiB,GAAI,YAAY,UAAU,GAAG,YAAY,GAAG,oBAAoB,GAAG,uBAAuB,SAgEhH,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/dist/helpers/normalizeRequired.js

@@ -4,157 +4,6 @@ const lodash_1 = require("lodash");
 /**
  * Normalizes required field declarations in JSON schemas by converting property-level
  * `required` flags to schema-level `required` arrays and `x-required` metadata flags.
- *
- * **Intent:**
- * This function transforms JSON schemas from a property-centric required field model
- * (where each property has its own `required: true/false` flag) to the standard JSON Schema
- * format (where required fields are listed in a top-level `required` array). This normalization
- * ensures compatibility with JSON Schema validators while preserving the original required
- * field information through the `x-required` extension attribute.
- *
- * **Use Cases:**
- * 1. **Schema Standardization**: Convert custom schema formats to standard JSON Schema format
- *    for validator compatibility
- * 2. **Schema Transformation**: Prepare schemas for validation libraries that expect
- *    required fields in array format
- * 3. **Metadata Preservation**: Maintain required field information in both standard format
- *    (`required` array) and extension format (`x-required` flag) for different use cases
- * 4. **Schema Processing Pipeline**: Normalize schemas before validation, credential generation,
- *    or API documentation generation
- *
- * **Behavior:**
- * - Mutates the input schema in-place
- * - Moves `required: true` from property level to schema-level `required` array
- * - Sets `x-required: true` on properties that were marked as required
- * - Deletes the `required` property from individual property schemas
- * - Recursively processes nested object properties
- * - Recursively processes array items (including nested objects within arrays)
- * - Skips reference properties (`$ref`) as they are resolved elsewhere
- * - Skips EnumSchema (returns early)
- * - Only sets `required` array if at least one field is required
- *
- * **Examples:**
- *
- * ```typescript
- * // Example 1: Simple object schema
- * const schema = {
- *   id: 'User',
- *   properties: {
- *     name: { type: 'string', required: true },
- *     email: { type: 'string', required: true },
- *     age: { type: 'number', required: false }
- *   }
- * };
- *
- * normalizeRequired(schema);
- * // Result:
- * // schema.required = ['name', 'email']
- * // schema.properties.name['x-required'] = true
- * // schema.properties.email['x-required'] = true
- * // schema.properties.name.required = undefined (deleted)
- * // schema.properties.email.required = undefined (deleted)
- * ```
- *
- * ```typescript
- * // Example 2: Nested objects
- * const schema = {
- *   id: 'Order',
- *   properties: {
- *     user: {
- *       type: 'object',
- *       required: true,
- *       properties: {
- *         name: { type: 'string', required: true },
- *         address: {
- *           type: 'object',
- *           properties: {
- *             street: { type: 'string', required: true }
- *           }
- *         }
- *       }
- *     }
- *   }
- * };
- *
- * normalizeRequired(schema);
- * // Result:
- * // schema.required = ['user']
- * // schema.properties.user['x-required'] = true
- * // schema.properties.user.required = ['name']
- * // schema.properties.user.properties.name['x-required'] = true
- * // schema.properties.user.properties.address.required = ['street']
- * // schema.properties.user.properties.address.properties.street['x-required'] = true
- * ```
- *
- * ```typescript
- * // Example 3: Arrays with object items
- * const schema = {
- *   id: 'Order',
- *   properties: {
- *     items: {
- *       type: 'array',
- *       required: true,
- *       items: {
- *         type: 'object',
- *         properties: {
- *           productId: { type: 'string', required: true },
- *           quantity: { type: 'number', required: true }
- *         }
- *       }
- *     }
- *   }
- * };
- *
- * normalizeRequired(schema);
- * // Result:
- * // schema.required = ['items']
- * // schema.properties.items['x-required'] = true
- * // schema.properties.items.items.required = ['productId', 'quantity']
- * // schema.properties.items.items.properties.productId['x-required'] = true
- * // schema.properties.items.items.properties.quantity['x-required'] = true
- * ```
- *
- * ```typescript
- * // Example 4: Mixed structure
- * const schema = {
- *   id: 'Profile',
- *   properties: {
- *     name: { type: 'string', required: true },
- *     address: {
- *       type: 'object',
- *       required: true,
- *       properties: {
- *         street: { type: 'string', required: true },
- *         city: { type: 'string' }
- *       }
- *     },
- *     tags: {
- *       type: 'array',
- *       items: {
- *         type: 'object',
- *         properties: {
- *           label: { type: 'string', required: true }
- *         }
- *       }
- *     }
- *   }
- * };
- *
- * normalizeRequired(schema);
- * // Result:
- * // schema.required = ['name', 'address']
- * // All nested required fields are normalized recursively
- * ```
- *
- * **Limitations:**
- * - Only processes schemas with a `properties` field (ObjectSchema or ObjectPropertySchema)
- * - EnumSchema is accepted but returns early without processing
- * - Reference properties (`$ref`) are skipped and not processed
- * - The function mutates the input schema object
- * - Does not resolve `$ref` references (they must be resolved separately)
- *
- * @param jsonSchema - The JSON schema to normalize (ObjectSchema, ObjectPropertySchema, or ReferencePropertySchema)
- * @returns void (mutates the input schema in-place)
  */
 const normalizeRequired = (jsonSchema) => {
     const { enum: enumItems } = jsonSchema;

package/dist/helpers/normalizeRequired.js.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeRequired.js","sourceRoot":"","sources":["../../src/helpers/normalizeRequired.ts"],"names":[],"mappings":";;AAAA,mCAAqC;AAWrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0JG;AACH,MAAM,iBAAiB,GAAG,CAAC,UAAuE,EAAE,EAAE;IACpG,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAI,UAAyB,CAAC;IAEvD,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,CAAC;IAE3B,IAAI,MAAM,EAAE,CAAC;QACX,OAAO;IACT,CAAC;IAED,MAAM,YAAY,GAAI,UAA2B,CAAC;IAClD,MAAM,EAAE,UAAU,EAAE,GAAG,YAAY,CAAC;IAEpC,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO;IACT,CAAC;IAED,MAAM,QAAQ,GAAG,EAAE,CAAC;IAEpB,KAAK,MAAM,YAAY,IAAI,UAAU,EAAE,CAAC;QACtC,MAAM,QAAQ,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;QAE1C,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,GAAI,QAAoC,CAAC;QAEpE,MAAM,WAAW,GAAG,CAAC,IAAA,oBAAW,EAAC,WAAW,CAAC,CAAC;QAE9C,iEAAiE;QACjE,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACtB,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;YAC9B,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC9B,CAAC;QAED,sEAAsE;QACtE,OAAO,QAAQ,CAAC,QAAQ,CAAC;QAEzB,qDAAqD;QACrD,IAAI,WAAW,EAAE,CAAC;YAChB,SAAS;QACX,CAAC;QAED,MAAM,EAAE,IAAI,EAAE,GAAI,QAAuD,CAAC;QAE1E,MAAM,QAAQ,GAAG,IAAI,KAAK,QAAQ,CAAC;QAEnC,IAAI,QAAQ,EAAE,CAAC;YACb,iBAAiB,CAAC,QAAgC,CAAC,CAAC;YACpD,SAAS;QACX,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,KAAK,OAAO,CAAC;QAEjC,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,EAAE,KAAK,EAAE,GAAI,QAAgC,CAAC;YAEpD,IAAI,KAAK,EAAE,CAAC;gBACV,iBAAiB,CAAC,KAAuD,CAAC,CAAC;YAC7E,CAAC;YAED,SAAS;QACX,CAAC;IACH,CAAC;IAED,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,YAAY,CAAC,QAAQ,GAAG,QAAQ,CAAC;IACnC,CAAC;AACH,CAAC,CAAC;AAEF,kBAAe,iBAAiB,CAAC"}
+{"version":3,"file":"normalizeRequired.js","sourceRoot":"","sources":["../../src/helpers/normalizeRequired.ts"],"names":[],"mappings":";;AAAA,mCAAqC;AAErC;;;GAGG;AACH,MAAM,iBAAiB,GAAG,CAAC,UAAsF,EAAE,EAAE;IACnH,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAI,UAAyB,CAAC;IAEvD,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,CAAC;IAE3B,IAAI,MAAM,EAAE,CAAC;QACX,OAAO;IACT,CAAC;IAED,MAAM,YAAY,GAAI,UAA2B,CAAC;IAClD,MAAM,EAAE,UAAU,EAAE,GAAG,YAAY,CAAC;IAEpC,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO;IACT,CAAC;IAED,MAAM,QAAQ,GAAG,EAAE,CAAC;IAEpB,KAAK,MAAM,YAAY,IAAI,UAAU,EAAE,CAAC;QACtC,MAAM,QAAQ,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;QAE1C,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,GAAI,QAAoC,CAAC;QAEpE,MAAM,WAAW,GAAG,CAAC,IAAA,oBAAW,EAAC,WAAW,CAAC,CAAC;QAE9C,iEAAiE;QACjE,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;YACtB,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;YAC9B,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC9B,CAAC;QAED,sEAAsE;QACtE,OAAO,QAAQ,CAAC,QAAQ,CAAC;QAEzB,qDAAqD;QACrD,IAAI,WAAW,EAAE,CAAC;YAChB,SAAS;QACX,CAAC;QAED,MAAM,EAAE,IAAI,EAAE,GAAI,QAAuD,CAAC;QAE1E,MAAM,QAAQ,GAAG,IAAI,KAAK,QAAQ,CAAC;QAEnC,IAAI,QAAQ,EAAE,CAAC;YACb,iBAAiB,CAAC,QAAgC,CAAC,CAAC;YACpD,SAAS;QACX,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,KAAK,OAAO,CAAC;QAEjC,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,EAAE,KAAK,EAAE,GAAI,QAAgC,CAAC;YAEpD,IAAI,KAAK,EAAE,CAAC;gBACV,iBAAiB,CAAC,KAAuD,CAAC,CAAC;YAC7E,CAAC;YAED,SAAS;QACX,CAAC;IACH,CAAC;IAED,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,YAAY,CAAC,QAAQ,GAAG,QAAQ,CAAC;IACnC,CAAC;AACH,CAAC,CAAC;AAEF,kBAAe,iBAAiB,CAAC"}

package/dist/helpers/normalizeType.d.ts

@@ -1,81 +1,5 @@
 type ValueType = 'number' | 'integer' | 'boolean' | 'string' | 'object' | 'array';
-/**
- * Normalizes a value to match a specified JSON Schema type.
- *
- * ## Intent
- *
- * This function is designed to coerce values into their expected types based on JSON Schema
- * type definitions. It's particularly useful when processing data from external sources (like
- * form inputs, query parameters, or API responses) where values may arrive as strings but
- * need to be converted to their proper types according to a schema definition.
- *
- * The function performs type coercion where appropriate, but preserves the original value
- * when conversion is not possible or when the value is already of the correct type. This
- * makes it safe to use in data normalization pipelines without losing information.
- *
- * ## Use Cases
- *
- * 1. **Schema-based data normalization**: When processing objects against JSON Schema
- *    definitions, ensuring property values match their declared types.
- *
- * 2. **Form data processing**: Converting string values from HTML forms (which are always
- *    strings) to their expected types (numbers, booleans) based on schema definitions.
- *
- * 3. **API response normalization**: Normalizing API responses where types may be ambiguous
- *    or incorrectly serialized (e.g., numbers as strings, booleans as strings).
- *
- * 4. **Configuration parsing**: Parsing configuration values from environment variables or
- *    config files where everything is initially a string but needs type coercion.
- *
- * ## Behavior by Type
- *
- * - **number/integer**: Attempts to convert strings and booleans to numbers. Preserves
- *   original value if conversion fails or value is already a number.
- *
- * - **boolean**: Converts numbers (0 → false, non-zero → true) and recognized string
- *   values ('yes', 'true', '1' → true; 'no', 'false', '0' → false). Preserves original
- *   value for unrecognized strings or non-convertible types.
- *
- * - **string/object/array**: Returns the value as-is (no conversion performed).
- *
- * - **null/undefined**: Always preserved regardless of target type.
- *
- * ## Examples
- *
- * ### Number Conversion
- * ```typescript
- * normalizeType('number', '123')      // → 123
- * normalizeType('number', '45.67')    // → 45.67
- * normalizeType('number', '0')        // → 0
- * normalizeType('number', true)       // → 1
- * normalizeType('number', 'abc')      // → 'abc' (conversion failed, original preserved)
- * ```
- *
- * ### Boolean Conversion
- * ```typescript
- * normalizeType('boolean', 0)         // → false
- * normalizeType('boolean', 1)         // → true
- * normalizeType('boolean', 'yes')     // → true
- * normalizeType('boolean', 'true')    // → true
- * normalizeType('boolean', '1')       // → true
- * normalizeType('boolean', 'no')      // → false
- * normalizeType('boolean', 'false')   // → false
- * normalizeType('boolean', 'maybe')   // → 'maybe' (unrecognized, original preserved)
- * ```
- *
- * ### Type Preservation
- * ```typescript
- * normalizeType('string', 'hello')    // → 'hello'
- * normalizeType('string', 123)        // → 123 (no conversion for string type)
- * normalizeType('object', { a: 1 })   // → { a: 1 }
- * normalizeType('array', [1, 2, 3])   // → [1, 2, 3]
- * normalizeType('number', null)       // → null (null always preserved)
- * ```
- *
- * @param type - The target JSON Schema type ('number', 'integer', 'boolean', 'string', 'object', 'array')
- * @param value - The value to normalize (can be any type)
- * @returns The normalized value, or the original value if normalization is not applicable
- */
+/** Normalizes a value to match a specified JSON Schema type. */
 declare const normalizeType: (type: ValueType, value: unknown) => string | number | boolean | unknown;
 export default normalizeType;
 //# sourceMappingURL=normalizeType.d.ts.map

package/dist/helpers/normalizeType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeType.d.ts","sourceRoot":"","sources":["../../src/helpers/normalizeType.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AA2FlF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,QAAA,MAAM,aAAa,GAAI,MAAM,SAAS,EAAE,OAAO,OAAO,KAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAgEpF,CAAC;AAEF,eAAe,aAAa,CAAC"}
+{"version":3,"file":"normalizeType.d.ts","sourceRoot":"","sources":["../../src/helpers/normalizeType.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAuClF,gEAAgE;AAChE,QAAA,MAAM,aAAa,GAAI,MAAM,SAAS,EAAE,OAAO,OAAO,KAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAgEpF,CAAC;AAEF,eAAe,aAAa,CAAC"}