@skmtc/core 0.0.984 → 0.16.1

package/esm/parse/v3-0/webhook/toWebhooksV3.js

@@ -0,0 +1,130 @@
+import { toRequestBodyV3 } from '../requestBody/toRequestBodiesV3.js';
+import { toResponsesV3 } from '../response/toResponseV3.js';
+import { toParameterListV3 } from '../parameter/toParameterV3.js';
+import { OasWebhook } from '../../../oas/webhook/Webhook.js';
+import { toPathItemV3 } from '../pathItem/toPathItemV3.js';
+import { methodValues } from '../../../types/Method.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toSecurityRequirementsV3 } from '../securityRequirement/toSecurityRequirement.js';
+import { isEmpty } from '../../../helpers/isEmpty.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+import { toOptionalServersV3 } from '../server/toServerV3.js';
+/**
+ * Parses a single webhook Operation Object into an {@link OasWebhook}.
+ *
+ * Mirrors `toOperationV3` and reuses the same leaf field parsers
+ * (`toParameterListV3` / `toRequestBodyV3` / `toResponsesV3` / …) — the
+ * inner Operation Object is structurally identical. Only the orchestration
+ * is duplicated (the dialect-shaped glue), and the output is an
+ * `OasWebhook` carrying a `name`, not an `OasOperation` carrying a `path`.
+ */
+export const toWebhookV3 = ({ operation, webhookInfo, stackTrail, context }) => {
+    const { method, name, pathItem } = webhookInfo;
+    const { operationId, tags, summary, description, parameters, requestBody, responses, deprecated, security, externalDocs, servers, ...skipped } = operation;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: operation,
+        context,
+        stackTrail,
+        parentType: 'operation'
+    });
+    const parsedParameters = stackTrail.trace('parameters', st => toParameterListV3({ parameters, stackTrail: st, context }));
+    const parsedRequestBody = stackTrail.trace('requestBody', st => toRequestBodyV3({ requestBody, stackTrail: st, context }));
+    const parsedResponses = stackTrail.trace('responses', st => toResponsesV3({ responses, stackTrail: st, context }));
+    const parsedSecurity = stackTrail.trace('security', st => toSecurityRequirementsV3({ security, stackTrail: st, context }));
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context }));
+    const parsedServers = stackTrail.trace('servers', st => toOptionalServersV3({ servers, stackTrail: st, context }));
+    return context.withStackTrail(stackTrail, () => new OasWebhook({
+        pathItem,
+        name,
+        method,
+        operationId,
+        summary,
+        tags,
+        description,
+        parameters: parsedParameters,
+        requestBody: parsedRequestBody,
+        responses: parsedResponses,
+        deprecated,
+        security: parsedSecurity,
+        externalDocs: parsedExternalDocs,
+        servers: parsedServers,
+        extensionFields
+    }, context));
+};
+/**
+ * Flattens the 3.1 `webhooks` map into `OasWebhook[]`, mirroring
+ * `toOperationsV3`'s `paths` → `OasOperation[]` flattening. Returns `[]`
+ * when no `webhooks` object is present (the common 3.0 / no-webhook case).
+ * The stack trail nests `webhooks` → `<name>` → `<method>` so
+ * `OasDocument.removeItem` can locate a webhook by name.
+ */
+export const toWebhooksV3 = ({ webhooks, stackTrail, context }) => {
+    if (!webhooks) {
+        return [];
+    }
+    return Object.entries(webhooks).flatMap(([name, pathItem]) => {
+        return stackTrail.trace(name, nameStack => {
+            if (!pathItem) {
+                return [];
+            }
+            const cleaned = Object.entries(pathItem).reduce(({ rest, methodObject }, [key, operation]) => {
+                const isMethod = methodValues.includes(key);
+                if (isMethod) {
+                    const { [key]: _deleted, ...remaining } = rest;
+                    return {
+                        rest: remaining,
+                        methodObject: {
+                            ...methodObject,
+                            [key]: operation
+                        }
+                    };
+                }
+                return { rest, methodObject };
+            }, {
+                rest: pathItem,
+                methodObject: {}
+            });
+            const pathItemObject = !isEmpty(cleaned.rest)
+                ? toPathItemV3({ pathItem: cleaned.rest, stackTrail: nameStack, context })
+                : undefined;
+            return Object.entries(cleaned.methodObject)
+                .map(([method, operation]) => {
+                // Use `nameStack` (the trail with the webhook name already
+                // pushed) so downstream traces record webhooks:<name>:<method>:…
+                // — the trail `OasDocument.removeItem` matches a webhook on.
+                return nameStack.trace(method, st => {
+                    if (!operation) {
+                        return;
+                    }
+                    try {
+                        return toWebhookV3({
+                            operation,
+                            webhookInfo: {
+                                method: method,
+                                name,
+                                pathItem: pathItemObject
+                            },
+                            stackTrail: st,
+                            context
+                        });
+                    }
+                    catch (error) {
+                        const normalized = error instanceof Error ? error : new Error(String(error));
+                        context.logIssue({
+                            key: method,
+                            parent: operation,
+                            level: 'error',
+                            message: normalized.message,
+                            cause: normalized,
+                            stackTrail: st,
+                            type: 'INVALID_OPERATION'
+                        });
+                        return undefined;
+                    }
+                });
+            })
+                .filter((item) => Boolean(item));
+        });
+    });
+};

package/esm/parse/v3-1/_helpers/parseDefault.d.ts

@@ -0,0 +1,44 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for parsing the `default` property from OpenAPI schemas.
+ *
+ * @template Value - The narrowed type a valid (non-null) default holds
+ */
+export type ParseDefaultArgs<Value> = {
+    /** The raw `default` value extracted from the schema */
+    value: unknown;
+    /** The parsed nullable flag — `null` is only a valid default when this is `true` */
+    nullable: boolean | undefined;
+    /** The surrounding schema object, used as the issue location's parent */
+    parent: unknown;
+    /** Type guard narrowing an acceptable non-null default to `Value` */
+    check: (item: unknown) => item is Value;
+    /** Builds the warning message for a rejected default */
+    toMessage: (item: unknown) => string;
+    /** Parse context for logging issues */
+    context: ParseContextType;
+    /** Stack trail for tracking the current parsing location */
+    stackTrail: StackTrail;
+};
+/**
+ * Parses and validates the `default` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no default present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_DEFAULT` warning and dropped
+ *
+ * This mirrors the OpenAPI 3.0 rule that a `default` MUST conform to the
+ * schema's type, where `nullable: true` widens that type to include `null`.
+ * The function is fail-open: an invalid default is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid default holds
+ * @param args - Parsing configuration
+ * @returns The validated default (`Value`), `null` (nullable), or `undefined`
+ */
+export declare const parseDefault: <Value>({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseDefaultArgs<Value>) => Value | null | undefined;
+//# sourceMappingURL=parseDefault.d.ts.map

package/esm/parse/v3-1/_helpers/parseDefault.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDefault.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/_helpers/parseDefault.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,IAAI;IACpC,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAA;IACd,oFAAoF;IACpF,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,yEAAyE;IACzE,MAAM,EAAE,OAAO,CAAA;IACf,qEAAqE;IACrE,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,KAAK,CAAA;IACvC,wDAAwD;IACxD,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAA;IACpC,uCAAuC;IACvC,OAAO,EAAE,gBAAgB,CAAA;IACzB,4DAA4D;IAC5D,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,EAAE,oEAQjC,gBAAgB,CAAC,KAAK,CAAC,KAAG,KAAK,GAAG,IAAI,GAAG,SAuB3C,CAAA"}

package/esm/parse/v3-1/_helpers/parseDefault.js

@@ -0,0 +1,39 @@
+/**
+ * Parses and validates the `default` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no default present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_DEFAULT` warning and dropped
+ *
+ * This mirrors the OpenAPI 3.0 rule that a `default` MUST conform to the
+ * schema's type, where `nullable: true` widens that type to include `null`.
+ * The function is fail-open: an invalid default is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid default holds
+ * @param args - Parsing configuration
+ * @returns The validated default (`Value`), `null` (nullable), or `undefined`
+ */
+export const parseDefault = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (nullable && value === null) {
+        return null;
+    }
+    if (!check(value)) {
+        context.logIssue({
+            key: 'default',
+            level: 'warning',
+            message: toMessage(value),
+            parent,
+            stackTrail,
+            type: 'INVALID_DEFAULT'
+        });
+        return undefined;
+    }
+    return value;
+};

package/esm/parse/v3-1/_helpers/parseEnum.d.ts

@@ -0,0 +1,14 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+type ParseEnumArgs = {
+    value: unknown;
+    nullable: boolean | undefined;
+    parent: unknown;
+    check: (item: unknown) => boolean;
+    toMessage: (item: unknown) => string;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+export declare const parseEnum: ({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseEnumArgs) => any[] | undefined;
+export {};
+//# sourceMappingURL=parseEnum.d.ts.map

package/esm/parse/v3-1/_helpers/parseEnum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnum.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/_helpers/parseEnum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAA;IACjC,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAA;IACpC,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,oEAQvB,aAAa,sBA2Bf,CAAA"}

package/esm/parse/v3-1/_helpers/parseEnum.js

@@ -0,0 +1,23 @@
+export const parseEnum = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (nullable && item === null) {
+                continue;
+            }
+            if (check(item)) {
+                continue;
+            }
+            context.logIssue({
+                key: 'enum',
+                level: 'warning',
+                message: toMessage(item),
+                parent,
+                stackTrail,
+                type: 'INVALID_ENUM'
+            });
+            return undefined;
+        }
+        return value;
+    }
+    return undefined;
+};

package/esm/parse/v3-1/_helpers/parseExample.d.ts

@@ -0,0 +1,42 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for parsing the `example` property from OpenAPI schemas.
+ *
+ * @template Value - The narrowed type a valid (non-null) example holds
+ */
+export type ParseExampleArgs<Value> = {
+    /** The raw `example` value extracted from the schema */
+    value: unknown;
+    /** The parsed nullable flag — `null` is only a valid example when this is `true` */
+    nullable: boolean | undefined;
+    /** The surrounding schema object, used as the issue location's parent */
+    parent: unknown;
+    /** Type guard narrowing an acceptable non-null example to `Value` */
+    check: (item: unknown) => item is Value;
+    /** Builds the warning message for a rejected example */
+    toMessage: (item: unknown) => string;
+    /** Parse context for logging issues */
+    context: ParseContextType;
+    /** Stack trail for tracking the current parsing location */
+    stackTrail: StackTrail;
+};
+/**
+ * Parses and validates the `example` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no example present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_EXAMPLE` warning and dropped
+ *
+ * The function is fail-open: an invalid example is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid example holds
+ * @param args - Parsing configuration
+ * @returns The validated example (`Value`), `null` (nullable), or `undefined`
+ */
+export declare const parseExample: <Value>({ value, nullable, parent, context, check, toMessage, stackTrail }: ParseExampleArgs<Value>) => Value | null | undefined;
+//# sourceMappingURL=parseExample.d.ts.map

package/esm/parse/v3-1/_helpers/parseExample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseExample.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/_helpers/parseExample.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,IAAI;IACpC,wDAAwD;IACxD,KAAK,EAAE,OAAO,CAAA;IACd,oFAAoF;IACpF,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,yEAAyE;IACzE,MAAM,EAAE,OAAO,CAAA;IACf,qEAAqE;IACrE,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,IAAI,KAAK,CAAA;IACvC,wDAAwD;IACxD,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAA;IACpC,uCAAuC;IACvC,OAAO,EAAE,gBAAgB,CAAA;IACzB,4DAA4D;IAC5D,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,EAAE,oEAQjC,gBAAgB,CAAC,KAAK,CAAC,KAAG,KAAK,GAAG,IAAI,GAAG,SAuB3C,CAAA"}

package/esm/parse/v3-1/_helpers/parseExample.js

@@ -0,0 +1,37 @@
+/**
+ * Parses and validates the `example` property of an OpenAPI scalar/structural
+ * schema, applying the nullable-conditional rule shared by `example`, `enum`,
+ * and `default`:
+ *
+ * - `undefined` → `undefined` (no example present)
+ * - `null` → kept only when `nullable` is `true`; otherwise rejected
+ * - a value passing `check` → kept
+ * - anything else → logged as an `INVALID_EXAMPLE` warning and dropped
+ *
+ * The function is fail-open: an invalid example is stripped and recorded as a
+ * `ParseIssue`, never thrown.
+ *
+ * @template Value - The narrowed type a valid example holds
+ * @param args - Parsing configuration
+ * @returns The validated example (`Value`), `null` (nullable), or `undefined`
+ */
+export const parseExample = ({ value, nullable, parent, context, check, toMessage, stackTrail }) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (nullable && value === null) {
+        return null;
+    }
+    if (!check(value)) {
+        context.logIssue({
+            key: 'example',
+            level: 'warning',
+            message: toMessage(value),
+            parent,
+            stackTrail,
+            type: 'INVALID_EXAMPLE'
+        });
+        return undefined;
+    }
+    return value;
+};

package/esm/parse/v3-1/_helpers/parseNullable.d.ts

@@ -0,0 +1,142 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for parsing the nullable property from OpenAPI schemas.
+ *
+ * @template Value - The OpenAPI schema object type
+ */
+export type ParseNullableArgs<Value extends OpenAPIV3.SchemaObject> = {
+    /** The OpenAPI schema object containing the nullable property */
+    value: Value;
+    /** Stack trail for tracking current parsing context */
+    stackTrail: StackTrail;
+    /** Parse context for error handling */
+    context: ParseContextType;
+};
+/**
+ * Return type for parsed nullable data.
+ *
+ * @template Value - The OpenAPI schema object type
+ */
+export type ParseNullableReturn<Value extends OpenAPIV3.SchemaObject> = {
+    /** The validated nullable flag (true, false, or undefined) */
+    nullable: boolean | undefined;
+    /** The schema object without the nullable property */
+    value: Omit<Value, 'nullable'>;
+};
+/**
+ * Parses and validates the nullable property from OpenAPI schema objects.
+ *
+ * This function extracts and validates the `nullable` property from OpenAPI
+ * schema objects, ensuring it's a valid boolean value. Invalid nullable values
+ * are removed and logged as warnings through the parse context.
+ *
+ * The nullable property determines whether a schema value can be null in addition
+ * to its primary type, which affects type generation and validation logic.
+ *
+ * @template Value - The OpenAPI schema object type
+ *
+ * @param args - Parsing configuration
+ * @returns Parsed nullable data with the validated flag and cleaned schema
+ *
+ * @example Valid nullable property
+ * ```typescript
+ * import { parseNullable } from '@skmtc/core/oas/_helpers';
+ *
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     nullable: true,
+ *     description: 'An optional string that can be null'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * console.log(result.value);    // { type: 'string', description: 'An optional string that can be null' }
+ * ```
+ *
+ * @example Explicitly non-nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'number',
+ *     nullable: false,
+ *     minimum: 0
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // false
+ * console.log(result.value);    // { type: 'number', minimum: 0 }
+ * ```
+ *
+ * @example Missing nullable property (undefined)
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     format: 'email'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (property not present)
+ * console.log(result.value);    // { type: 'string', format: 'email' }
+ * ```
+ *
+ * @example Invalid nullable value
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'boolean',
+ *     nullable: 'yes', // Invalid - should be boolean
+ *     description: 'A flag'
+ *   } as any,
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (invalid value removed)
+ * console.log(result.value);    // { type: 'boolean', description: 'A flag' }
+ * // Context will log a warning about the invalid nullable value
+ * ```
+ *
+ * @example Usage in type generation
+ * ```typescript
+ * function generateTypeScript(schema: OpenAPIV3.SchemaObject) {
+ *   const { nullable, value } = parseNullable({ value: schema, context });
+ *
+ *   const baseType = generateBaseType(value);
+ *   const nullableType = nullable ? ` | null` : '';
+ *
+ *   return `${baseType}${nullableType}`;
+ * }
+ *
+ * // Examples:
+ * // nullable: true  -> 'string | null'
+ * // nullable: false -> 'string'
+ * // nullable: undefined -> 'string' (default behavior)
+ * ```
+ *
+ * @example Complex schema with nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       age: { type: 'number' }
+ *     },
+ *     required: ['name'],
+ *     nullable: true // The entire object can be null
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * // Generated type might be: { name: string; age?: number } | null
+ * ```
+ */
+export declare const parseNullable: <Value extends OpenAPIV3.SchemaObject>({ value, stackTrail, context }: ParseNullableArgs<Value>) => ParseNullableReturn<Value>;
+//# sourceMappingURL=parseNullable.d.ts.map

package/esm/parse/v3-1/_helpers/parseNullable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseNullable.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/_helpers/parseNullable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAAI;IACpE,iEAAiE;IACjE,KAAK,EAAE,KAAK,CAAA;IACZ,uDAAuD;IACvD,UAAU,EAAE,UAAU,CAAA;IACtB,uCAAuC;IACvC,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAAI;IACtE,8DAA8D;IAC9D,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,sDAAsD;IACtD,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,UAAU,CAAC,CAAA;CAC/B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgHG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,SAAS,SAAS,CAAC,YAAY,EAAE,gCAIjE,iBAAiB,CAAC,KAAK,CAAC,KAAG,mBAAmB,CAAC,KAAK,CA8BtD,CAAA"}

package/esm/parse/v3-1/_helpers/parseNullable.js

@@ -0,0 +1,140 @@
+/**
+ * Parses and validates the nullable property from OpenAPI schema objects.
+ *
+ * This function extracts and validates the `nullable` property from OpenAPI
+ * schema objects, ensuring it's a valid boolean value. Invalid nullable values
+ * are removed and logged as warnings through the parse context.
+ *
+ * The nullable property determines whether a schema value can be null in addition
+ * to its primary type, which affects type generation and validation logic.
+ *
+ * @template Value - The OpenAPI schema object type
+ *
+ * @param args - Parsing configuration
+ * @returns Parsed nullable data with the validated flag and cleaned schema
+ *
+ * @example Valid nullable property
+ * ```typescript
+ * import { parseNullable } from '@skmtc/core/oas/_helpers';
+ *
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     nullable: true,
+ *     description: 'An optional string that can be null'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * console.log(result.value);    // { type: 'string', description: 'An optional string that can be null' }
+ * ```
+ *
+ * @example Explicitly non-nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'number',
+ *     nullable: false,
+ *     minimum: 0
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // false
+ * console.log(result.value);    // { type: 'number', minimum: 0 }
+ * ```
+ *
+ * @example Missing nullable property (undefined)
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'string',
+ *     format: 'email'
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (property not present)
+ * console.log(result.value);    // { type: 'string', format: 'email' }
+ * ```
+ *
+ * @example Invalid nullable value
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'boolean',
+ *     nullable: 'yes', // Invalid - should be boolean
+ *     description: 'A flag'
+ *   } as any,
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // undefined (invalid value removed)
+ * console.log(result.value);    // { type: 'boolean', description: 'A flag' }
+ * // Context will log a warning about the invalid nullable value
+ * ```
+ *
+ * @example Usage in type generation
+ * ```typescript
+ * function generateTypeScript(schema: OpenAPIV3.SchemaObject) {
+ *   const { nullable, value } = parseNullable({ value: schema, context });
+ *
+ *   const baseType = generateBaseType(value);
+ *   const nullableType = nullable ? ` | null` : '';
+ *
+ *   return `${baseType}${nullableType}`;
+ * }
+ *
+ * // Examples:
+ * // nullable: true  -> 'string | null'
+ * // nullable: false -> 'string'
+ * // nullable: undefined -> 'string' (default behavior)
+ * ```
+ *
+ * @example Complex schema with nullable
+ * ```typescript
+ * const result = parseNullable({
+ *   value: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       age: { type: 'number' }
+ *     },
+ *     required: ['name'],
+ *     nullable: true // The entire object can be null
+ *   },
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.nullable); // true
+ * // Generated type might be: { name: string; age?: number } | null
+ * ```
+ */
+export const parseNullable = ({ value, stackTrail, context }) => {
+    if (value.nullable === undefined) {
+        return {
+            nullable: undefined,
+            value: value
+        };
+    }
+    const { nullable, ...rest } = value;
+    if (typeof nullable === 'boolean') {
+        return {
+            nullable: nullable,
+            value: rest
+        };
+    }
+    context.logIssue({
+        key: 'nullable',
+        stackTrail,
+        parent: value,
+        level: 'warning',
+        message: `Invalid nullable: ${value}`,
+        type: 'INVALID_NULLABLE'
+    });
+    return {
+        nullable: undefined,
+        value: rest
+    };
+};

package/esm/parse/v3-1/_merge-all-of/check-array-item-type-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-array-item-type-conflicts.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/_merge-all-of/check-array-item-type-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,2BAA2B,GACtC,GAAG,SAAS,CAAC,YAAY,EACzB,GAAG,SAAS,CAAC,YAAY,KACxB,IAUF,CAAA"}

package/esm/parse/v3-1/_merge-all-of/check-array-item-type-conflicts.js

@@ -0,0 +1,9 @@
+export const checkArrayItemTypeConflicts = (a, b) => {
+    if (a.type === 'array' && b.type === 'array' && 'items' in a && 'items' in b) {
+        const aItems = a.items;
+        const bItems = b.items;
+        if (aItems.type && bItems.type && aItems.type !== bItems.type) {
+            throw new Error(`Cannot merge schemas: array items have conflicting types '${aItems.type}' and '${bItems.type}'`);
+        }
+    }
+};

package/esm/parse/v3-1/_merge-all-of/check-at-least-one-type-match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-at-least-one-type-match.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/_merge-all-of/check-at-least-one-type-match.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,KAAK,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAA;AAElF,eAAO,MAAM,wBAAwB,GACnC,OAAO,YAAY,EACnB,QAAQ,YAAY,EACpB,MAAM,UAAU,KACf,OAMF,CAAA"}

package/esm/parse/v3-1/_merge-all-of/check-at-least-one-type-match.js

@@ -0,0 +1,5 @@
+export const checkAtLeastOneTypeMatch = (first, second, type) => {
+    return ((first.type === type && second.type === type) ||
+        (first.type === type && !second.type) ||
+        (!first.type && second.type === type));
+};

package/esm/parse/v3-1/_merge-all-of/check-enum-conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-enum-conflicts.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/_merge-all-of/check-enum-conflicts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,eAAO,MAAM,kBAAkB,GAC7B,OAAO,SAAS,CAAC,YAAY,EAC7B,QAAQ,SAAS,CAAC,YAAY,KAC7B,IAYF,CAAA"}