@skmtc/core 0.0.926 → 0.0.929

package/esm/oas/_helpers/parseDefault.d.ts

@@ -1,164 +0,0 @@
-import type { OpenAPIV3 } from 'openapi-types';
-import type { ParseContext } from '../../context/ParseContext.js';
-import * as v from 'valibot';
-/**
- * Arguments for parsing OpenAPI schema default values.
- *
- * @template T - The expected type of the default value
- * @template Nullable - Whether the schema allows null values
- * @template Value - The OpenAPI schema object type
- */
-type ParseDefaultArgs<T, Nullable extends boolean | undefined, Value extends OpenAPIV3.SchemaObject> = {
-    /** The OpenAPI schema object without nullable, example, and enum properties */
-    value: Omit<Value, 'nullable' | 'example' | 'enum'>;
-    /** Whether the schema allows null values */
-    nullable: Nullable;
-    /** Valibot schema for validating the default value */
-    valibotSchema: v.GenericSchema<T>;
-    /** Parse context for error handling */
-    context: ParseContext;
-};
-/**
- * Return type for parsed default value data.
- *
- * @template T - The expected type of the default value
- * @template Nullable - Whether the schema allows null values
- * @template Value - The OpenAPI schema object type
- */
-type ParseDefaultReturn<T, Nullable extends boolean | undefined, Value extends OpenAPIV3.SchemaObject> = {
-    /** The parsed and validated default value */
-    default: Nullable extends true ? T | null | undefined : T | undefined;
-    /** The schema object with all processed properties removed */
-    value: Omit<Value, 'nullable' | 'example' | 'enum' | 'default'>;
-};
-/**
- * Parses and validates OpenAPI schema default values with type safety.
- *
- * This function extracts and validates default values from OpenAPI schema objects,
- * ensuring they conform to the expected type and handling nullable schemas correctly.
- * Invalid default values are removed and logged as warnings through the parse context.
- *
- * The function provides full type safety, with the return type reflecting whether
- * null values are allowed based on the nullable parameter. This ensures that
- * generated code maintains proper type constraints for default values.
- *
- * @template T - The expected type of the default value
- * @template Nullable - Whether the schema allows null as a default
- * @template Value - The OpenAPI schema object type
- *
- * @param args - Parsing configuration
- * @returns Parsed default data with the validated default value and cleaned schema
- *
- * @example Basic string default parsing
- * ```typescript
- * import { parseDefault } from '@skmtc/core/oas/_helpers';
- * import * as v from 'valibot';
- *
- * const result = parseDefault({
- *   value: {
- *     type: 'string',
- *     default: 'hello world',
- *     minLength: 5
- *   },
- *   nullable: false,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // 'hello world'
- * console.log(result.value);   // { type: 'string', minLength: 5 }
- * ```
- *
- * @example Nullable default value
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'string',
- *     default: null,
- *     format: 'email'
- *   },
- *   nullable: true,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // null (valid for nullable schema)
- * // Type: string | null | undefined
- * ```
- *
- * @example Number default with constraints
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'number',
- *     default: 42,
- *     minimum: 0,
- *     maximum: 100
- *   },
- *   nullable: false,
- *   valibotSchema: v.number(),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // 42
- * console.log(result.value);   // { type: 'number', minimum: 0, maximum: 100 }
- * ```
- *
- * @example Invalid default handling
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'boolean',
- *     default: 'not a boolean', // Invalid default
- *     description: 'A boolean flag'
- *   },
- *   nullable: false,
- *   valibotSchema: v.boolean(),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // undefined (invalid default removed)
- * // Context will log a warning about the invalid default
- * ```
- *
- * @example Array default value
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'array',
- *     items: { type: 'string' },
- *     default: ['item1', 'item2']
- *   },
- *   nullable: false,
- *   valibotSchema: v.array(v.string()),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // ['item1', 'item2']
- * ```
- *
- * @example Object default value
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'object',
- *     properties: {
- *       name: { type: 'string' },
- *       age: { type: 'number' }
- *     },
- *     default: { name: 'John', age: 30 }
- *   },
- *   nullable: false,
- *   valibotSchema: v.object({
- *     name: v.string(),
- *     age: v.number()
- *   }),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // { name: 'John', age: 30 }
- * ```
- */
-export declare const parseDefault: <T, Nullable extends boolean | undefined, Value extends OpenAPIV3.SchemaObject>({ value, nullable, valibotSchema, context }: ParseDefaultArgs<T, Nullable, Value>) => ParseDefaultReturn<T, Nullable, Value>;
-export {};
-//# sourceMappingURL=parseDefault.d.ts.map

package/esm/oas/_helpers/parseDefault.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseDefault.d.ts","sourceRoot":"","sources":["../../../src/oas/_helpers/parseDefault.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;GAMG;AACH,KAAK,gBAAgB,CACnB,CAAC,EACD,QAAQ,SAAS,OAAO,GAAG,SAAS,EACpC,KAAK,SAAS,SAAS,CAAC,YAAY,IAClC;IACF,+EAA+E;IAC/E,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC,CAAA;IACnD,4CAA4C;IAC5C,QAAQ,EAAE,QAAQ,CAAA;IAClB,sDAAsD;IACtD,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAA;IACjC,uCAAuC;IACvC,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;GAMG;AACH,KAAK,kBAAkB,CACrB,CAAC,EACD,QAAQ,SAAS,OAAO,GAAG,SAAS,EACpC,KAAK,SAAS,SAAS,CAAC,YAAY,IAClC;IACF,6CAA6C;IAC7C,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,CAAC,GAAG,SAAS,CAAA;IACrE,8DAA8D;IAC9D,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC,CAAA;CAChE,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+HG;AACH,eAAO,MAAM,YAAY,GACvB,CAAC,EACD,QAAQ,SAAS,OAAO,GAAG,SAAS,EACpC,KAAK,SAAS,SAAS,CAAC,YAAY,EACpC,6CAKC,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,KAAG,kBAAkB,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAgB9E,CAAA"}

package/esm/oas/_helpers/parseDefault.js

@@ -1,144 +0,0 @@
-import * as v from 'valibot';
-/**
- * Parses and validates OpenAPI schema default values with type safety.
- *
- * This function extracts and validates default values from OpenAPI schema objects,
- * ensuring they conform to the expected type and handling nullable schemas correctly.
- * Invalid default values are removed and logged as warnings through the parse context.
- *
- * The function provides full type safety, with the return type reflecting whether
- * null values are allowed based on the nullable parameter. This ensures that
- * generated code maintains proper type constraints for default values.
- *
- * @template T - The expected type of the default value
- * @template Nullable - Whether the schema allows null as a default
- * @template Value - The OpenAPI schema object type
- *
- * @param args - Parsing configuration
- * @returns Parsed default data with the validated default value and cleaned schema
- *
- * @example Basic string default parsing
- * ```typescript
- * import { parseDefault } from '@skmtc/core/oas/_helpers';
- * import * as v from 'valibot';
- *
- * const result = parseDefault({
- *   value: {
- *     type: 'string',
- *     default: 'hello world',
- *     minLength: 5
- *   },
- *   nullable: false,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // 'hello world'
- * console.log(result.value);   // { type: 'string', minLength: 5 }
- * ```
- *
- * @example Nullable default value
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'string',
- *     default: null,
- *     format: 'email'
- *   },
- *   nullable: true,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // null (valid for nullable schema)
- * // Type: string | null | undefined
- * ```
- *
- * @example Number default with constraints
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'number',
- *     default: 42,
- *     minimum: 0,
- *     maximum: 100
- *   },
- *   nullable: false,
- *   valibotSchema: v.number(),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // 42
- * console.log(result.value);   // { type: 'number', minimum: 0, maximum: 100 }
- * ```
- *
- * @example Invalid default handling
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'boolean',
- *     default: 'not a boolean', // Invalid default
- *     description: 'A boolean flag'
- *   },
- *   nullable: false,
- *   valibotSchema: v.boolean(),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // undefined (invalid default removed)
- * // Context will log a warning about the invalid default
- * ```
- *
- * @example Array default value
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'array',
- *     items: { type: 'string' },
- *     default: ['item1', 'item2']
- *   },
- *   nullable: false,
- *   valibotSchema: v.array(v.string()),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // ['item1', 'item2']
- * ```
- *
- * @example Object default value
- * ```typescript
- * const result = parseDefault({
- *   value: {
- *     type: 'object',
- *     properties: {
- *       name: { type: 'string' },
- *       age: { type: 'number' }
- *     },
- *     default: { name: 'John', age: 30 }
- *   },
- *   nullable: false,
- *   valibotSchema: v.object({
- *     name: v.string(),
- *     age: v.number()
- *   }),
- *   context: parseContext
- * });
- *
- * console.log(result.default); // { name: 'John', age: 30 }
- * ```
- */
-export const parseDefault = ({ value, nullable, valibotSchema, context }) => {
-    const { default: defaultValue, ...rest } = value;
-    const parsedDefault = context.provisionalParse({
-        key: 'default',
-        value: defaultValue,
-        parent: value,
-        schema: nullable === true ? v.nullable(valibotSchema) : valibotSchema,
-        toMessage: value => `Removed invalid default. Expected ${valibotSchema.type}, got: ${value}`,
-        type: 'INVALID_DEFAULT'
-    });
-    return {
-        default: parsedDefault,
-        value: rest
-    };
-};

package/esm/oas/_helpers/parseExample.d.ts

@@ -1,123 +0,0 @@
-import type { OpenAPIV3 } from 'openapi-types';
-import type { ParseContext } from '../../context/ParseContext.js';
-import * as v from 'valibot';
-/**
- * Arguments for parsing OpenAPI schema examples.
- *
- * @template T - The expected type of the example value
- * @template Nullable - Whether the schema allows null values
- * @template Value - The OpenAPI schema object type
- */
-type ParseExampleArgs<T, Nullable extends boolean | undefined, Value extends OpenAPIV3.SchemaObject> = {
-    /** The OpenAPI schema object without nullable property */
-    value: Omit<Value, 'nullable'>;
-    /** Whether the schema allows null values */
-    nullable: Nullable;
-    /** Valibot schema for validating the example */
-    valibotSchema: v.GenericSchema<T>;
-    /** Parse context for error handling */
-    context: ParseContext;
-};
-/**
- * Return type for parsed example data.
- *
- * @template T - The expected type of the example value
- * @template Nullable - Whether the schema allows null values
- * @template Value - The OpenAPI schema object type
- */
-type ParseExampleReturn<T, Nullable extends boolean | undefined, Value extends OpenAPIV3.SchemaObject> = {
-    /** The parsed and validated example value */
-    example: Nullable extends true ? T | null | undefined : T | undefined;
-    /** The schema object without example and nullable properties */
-    value: Omit<Value, 'nullable' | 'example'>;
-};
-/**
- * Parses and validates OpenAPI schema examples with type safety.
- *
- * This function extracts and validates example values from OpenAPI schema objects,
- * ensuring they conform to the expected type and handling nullable schemas correctly.
- * Invalid examples are removed and logged as warnings through the parse context.
- *
- * The function provides full type safety, with the return type reflecting whether
- * null values are allowed based on the nullable parameter.
- *
- * @template T - The expected type of the example value
- * @template Nullable - Whether the schema allows null values
- * @template Value - The OpenAPI schema object type
- *
- * @param args - Parsing configuration
- * @returns Parsed example data with the validated example and cleaned schema
- *
- * @example Basic string example parsing
- * ```typescript
- * import { parseExample } from '@skmtc/core/oas/_helpers';
- * import * as v from 'valibot';
- *
- * const result = parseExample({
- *   value: {
- *     type: 'string',
- *     example: 'hello world',
- *     format: 'text'
- *   },
- *   nullable: false,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.example); // 'hello world'
- * console.log(result.value);   // { type: 'string', format: 'text' }
- * ```
- *
- * @example Nullable schema example
- * ```typescript
- * const result = parseExample({
- *   value: {
- *     type: 'string',
- *     example: null,
- *     minLength: 1
- *   },
- *   nullable: true,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.example); // null (valid for nullable schema)
- * // Type: string | null | undefined
- * ```
- *
- * @example Invalid example handling
- * ```typescript
- * const result = parseExample({
- *   value: {
- *     type: 'number',
- *     example: 'not a number', // Invalid example
- *     minimum: 0
- *   },
- *   nullable: false,
- *   valibotSchema: v.number(),
- *   context: parseContext
- * });
- *
- * console.log(result.example); // undefined (invalid example removed)
- * // Context will log a warning about the invalid example
- * ```
- *
- * @example Array example parsing
- * ```typescript
- * const result = parseExample({
- *   value: {
- *     type: 'array',
- *     items: { type: 'string' },
- *     example: ['item1', 'item2', 'item3']
- *   },
- *   nullable: false,
- *   valibotSchema: v.array(v.string()),
- *   context: parseContext
- * });
- *
- * console.log(result.example); // ['item1', 'item2', 'item3']
- * ```
- */
-export declare const parseExample: <T, Nullable extends boolean | undefined, Value extends OpenAPIV3.SchemaObject>({ value, nullable, valibotSchema, context }: ParseExampleArgs<T, Nullable, Value>) => ParseExampleReturn<T, Nullable, Value>;
-export {};
-//# sourceMappingURL=parseExample.d.ts.map

package/esm/oas/_helpers/parseExample.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseExample.d.ts","sourceRoot":"","sources":["../../../src/oas/_helpers/parseExample.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;GAMG;AACH,KAAK,gBAAgB,CACnB,CAAC,EACD,QAAQ,SAAS,OAAO,GAAG,SAAS,EACpC,KAAK,SAAS,SAAS,CAAC,YAAY,IAClC;IACF,0DAA0D;IAC1D,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,CAAA;IAC9B,4CAA4C;IAC5C,QAAQ,EAAE,QAAQ,CAAA;IAClB,gDAAgD;IAChD,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAA;IACjC,uCAAuC;IACvC,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;GAMG;AACH,KAAK,kBAAkB,CACrB,CAAC,EACD,QAAQ,SAAS,OAAO,GAAG,SAAS,EACpC,KAAK,SAAS,SAAS,CAAC,YAAY,IAClC;IACF,6CAA6C;IAC7C,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,CAAC,GAAG,SAAS,CAAA;IACrE,gEAAgE;IAChE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAAC,CAAA;CAC3C,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,eAAO,MAAM,YAAY,GACvB,CAAC,EACD,QAAQ,SAAS,OAAO,GAAG,SAAS,EACpC,KAAK,SAAS,SAAS,CAAC,YAAY,EACpC,6CAKC,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,KAAG,kBAAkB,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAgB9E,CAAA"}

package/esm/oas/_helpers/parseExample.js

@@ -1,103 +0,0 @@
-import * as v from 'valibot';
-/**
- * Parses and validates OpenAPI schema examples with type safety.
- *
- * This function extracts and validates example values from OpenAPI schema objects,
- * ensuring they conform to the expected type and handling nullable schemas correctly.
- * Invalid examples are removed and logged as warnings through the parse context.
- *
- * The function provides full type safety, with the return type reflecting whether
- * null values are allowed based on the nullable parameter.
- *
- * @template T - The expected type of the example value
- * @template Nullable - Whether the schema allows null values
- * @template Value - The OpenAPI schema object type
- *
- * @param args - Parsing configuration
- * @returns Parsed example data with the validated example and cleaned schema
- *
- * @example Basic string example parsing
- * ```typescript
- * import { parseExample } from '@skmtc/core/oas/_helpers';
- * import * as v from 'valibot';
- *
- * const result = parseExample({
- *   value: {
- *     type: 'string',
- *     example: 'hello world',
- *     format: 'text'
- *   },
- *   nullable: false,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.example); // 'hello world'
- * console.log(result.value);   // { type: 'string', format: 'text' }
- * ```
- *
- * @example Nullable schema example
- * ```typescript
- * const result = parseExample({
- *   value: {
- *     type: 'string',
- *     example: null,
- *     minLength: 1
- *   },
- *   nullable: true,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.example); // null (valid for nullable schema)
- * // Type: string | null | undefined
- * ```
- *
- * @example Invalid example handling
- * ```typescript
- * const result = parseExample({
- *   value: {
- *     type: 'number',
- *     example: 'not a number', // Invalid example
- *     minimum: 0
- *   },
- *   nullable: false,
- *   valibotSchema: v.number(),
- *   context: parseContext
- * });
- *
- * console.log(result.example); // undefined (invalid example removed)
- * // Context will log a warning about the invalid example
- * ```
- *
- * @example Array example parsing
- * ```typescript
- * const result = parseExample({
- *   value: {
- *     type: 'array',
- *     items: { type: 'string' },
- *     example: ['item1', 'item2', 'item3']
- *   },
- *   nullable: false,
- *   valibotSchema: v.array(v.string()),
- *   context: parseContext
- * });
- *
- * console.log(result.example); // ['item1', 'item2', 'item3']
- * ```
- */
-export const parseExample = ({ value, nullable, valibotSchema, context }) => {
-    const { example, ...rest } = value;
-    const parsedExample = context.provisionalParse({
-        key: 'example',
-        value: example,
-        parent: value,
-        schema: nullable === true ? v.nullable(valibotSchema) : valibotSchema,
-        toMessage: value => `Removed invalid example. Expected ${valibotSchema.type}, got: ${value}`,
-        type: 'INVALID_EXAMPLE'
-    });
-    return {
-        example: parsedExample,
-        value: rest
-    };
-};