@skmtc/core 0.0.983 → 0.16.1

package/script/parse/v3-1/server/toServerV3.d.ts

@@ -0,0 +1,23 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasServer } from '../../../oas/server/Server.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToServersV3Args = {
+    servers: OpenAPIV3.ServerObject[];
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toServersV3: ({ servers, stackTrail, context }: ToServersV3Args) => OasServer[];
+export type ToOptionalServersV3Args = {
+    servers: OpenAPIV3.ServerObject[] | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalServersV3: ({ servers, stackTrail, context }: ToOptionalServersV3Args) => OasServer[] | undefined;
+export type ToServerV3Args = {
+    server: OpenAPIV3.ServerObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toServerV3: ({ server, stackTrail, context }: ToServerV3Args) => OasServer;
+//# sourceMappingURL=toServerV3.d.ts.map

package/script/parse/v3-1/server/toServerV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toServerV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/server/toServerV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,SAAS,CAAC,YAAY,EAAE,CAAA;IACjC,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,kCAAkC,eAAe,KAAG,SAAS,EAMxF,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,OAAO,EAAE,SAAS,CAAC,YAAY,EAAE,GAAG,SAAS,CAAA;IAC7C,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,kCAIjC,uBAAuB,KAAG,SAAS,EAAE,GAAG,SAM1C,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,SAAS,CAAC,YAAY,CAAA;IAC9B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,iCAAiC,cAAc,KAAG,SAiB5E,CAAA"}

package/script/parse/v3-1/server/toServerV3.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toServerV3 = exports.toOptionalServersV3 = exports.toServersV3 = void 0;
+const Server_js_1 = require("../../../oas/server/Server.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const toServerVariableV3_js_1 = require("../serverVariable/toServerVariableV3.js");
+const toServersV3 = ({ servers, stackTrail, context }) => {
+    return servers.map((server, index) => {
+        return stackTrail.trace(server.url ?? index, st => (0, exports.toServerV3)({ server, stackTrail: st, context }));
+    });
+};
+exports.toServersV3 = toServersV3;
+const toOptionalServersV3 = ({ servers, stackTrail, context }) => {
+    if (!servers) {
+        return undefined;
+    }
+    return (0, exports.toServersV3)({ servers, stackTrail, context });
+};
+exports.toOptionalServersV3 = toOptionalServersV3;
+const toServerV3 = ({ server, stackTrail, context }) => {
+    const { description, url, variables, ...skipped } = server;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: server,
+        context,
+        stackTrail,
+        parentType: 'server'
+    });
+    return new Server_js_1.OasServer({
+        description,
+        url,
+        variables: (0, toServerVariableV3_js_1.toOptionalServerVariablesV3)({ serverVariables: variables, stackTrail, context }),
+        extensionFields
+    });
+};
+exports.toServerV3 = toServerV3;

package/script/parse/v3-1/serverVariable/toServerVariableV3.d.ts

@@ -0,0 +1,23 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasServerVariable } from '../../../oas/serverVariable/ServerVariable.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToServerVariablesV3Args = {
+    serverVariables: Record<string, OpenAPIV3.ServerVariableObject>;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toServerVariablesV3: ({ serverVariables, stackTrail, context }: ToServerVariablesV3Args) => Record<string, OasServerVariable>;
+export type ToOptionalServerVariablesV3Args = {
+    serverVariables: Record<string, OpenAPIV3.ServerVariableObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalServerVariablesV3: ({ serverVariables, stackTrail, context }: ToOptionalServerVariablesV3Args) => Record<string, OasServerVariable> | undefined;
+export type ToServerVariableV3Args = {
+    serverVariable: OpenAPIV3.ServerVariableObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toServerVariableV3: ({ serverVariable, stackTrail, context }: ToServerVariableV3Args) => OasServerVariable;
+//# sourceMappingURL=toServerVariableV3.d.ts.map

package/script/parse/v3-1/serverVariable/toServerVariableV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toServerVariableV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/serverVariable/toServerVariableV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAA;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAA;IAC/D,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,0CAIjC,uBAAuB,KAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAO5D,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG;IAC5C,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,oBAAoB,CAAC,GAAG,SAAS,CAAA;IAC3E,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,2BAA2B,GAAI,0CAIzC,+BAA+B,KAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,SAMxE,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,SAAS,CAAC,oBAAoB,CAAA;IAC9C,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,yCAIhC,sBAAsB,KAAG,iBAiB3B,CAAA"}

package/script/parse/v3-1/serverVariable/toServerVariableV3.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toServerVariableV3 = exports.toOptionalServerVariablesV3 = exports.toServerVariablesV3 = void 0;
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const ServerVariable_js_1 = require("../../../oas/serverVariable/ServerVariable.js");
+const toServerVariablesV3 = ({ serverVariables, stackTrail, context }) => {
+    return Object.fromEntries(Object.entries(serverVariables).map(([key, serverVariable]) => [
+        key,
+        (0, exports.toServerVariableV3)({ serverVariable, stackTrail, context })
+    ]));
+};
+exports.toServerVariablesV3 = toServerVariablesV3;
+const toOptionalServerVariablesV3 = ({ serverVariables, stackTrail, context }) => {
+    if (!serverVariables) {
+        return undefined;
+    }
+    return (0, exports.toServerVariablesV3)({ serverVariables, stackTrail, context });
+};
+exports.toOptionalServerVariablesV3 = toOptionalServerVariablesV3;
+const toServerVariableV3 = ({ serverVariable, stackTrail, context }) => {
+    const { description, default: defaultValue, enum: enums, ...skipped } = serverVariable;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: serverVariable,
+        context,
+        stackTrail,
+        parentType: 'serverVariable'
+    });
+    return new ServerVariable_js_1.OasServerVariable({
+        description,
+        default: defaultValue,
+        enums,
+        extensionFields
+    });
+};
+exports.toServerVariableV3 = toServerVariableV3;

package/script/parse/v3-1/specificationExtensions/toSpecificationExtensionsV3.d.ts

@@ -0,0 +1,15 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToSpecificationExtensionsV3Args = {
+    skipped: Record<string, unknown>;
+    parent: unknown;
+    parentType: string;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSpecificationExtensionsV3: ({ skipped: s, parent, parentType, stackTrail, context }: ToSpecificationExtensionsV3Args) => Record<string, unknown> | undefined;
+export declare const extractExtensions: (item: Record<string, unknown>) => {
+    skipped: Record<string, unknown> | undefined;
+    extensionFields: Record<string, unknown> | undefined;
+};
+//# sourceMappingURL=toSpecificationExtensionsV3.d.ts.map

package/script/parse/v3-1/specificationExtensions/toSpecificationExtensionsV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSpecificationExtensionsV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/specificationExtensions/toSpecificationExtensionsV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,+BAA+B,GAAG;IAC5C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,MAAM,EAAE,OAAO,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,2BAA2B,GAAI,yDAMzC,+BAA+B,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAQ9D,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;CAkB9D,CAAA"}

package/script/parse/v3-1/specificationExtensions/toSpecificationExtensionsV3.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractExtensions = exports.toSpecificationExtensionsV3 = void 0;
+const isEmpty_js_1 = require("../../../helpers/isEmpty.js");
+const toSpecificationExtensionsV3 = ({ skipped: s, parent, parentType, stackTrail, context }) => {
+    const { skipped, extensionFields } = (0, exports.extractExtensions)(s);
+    if (skipped) {
+        context.logSkippedFields({ skipped, parent, stackTrail, parentType });
+    }
+    return extensionFields;
+};
+exports.toSpecificationExtensionsV3 = toSpecificationExtensionsV3;
+const extractExtensions = (item) => {
+    const entries = Object.entries(item);
+    const skipped = {};
+    const extensionFields = {};
+    for (const [key, value] of entries) {
+        if (!key.startsWith('x-')) {
+            skipped[key] = value;
+        }
+        else {
+            extensionFields[key] = value;
+        }
+    }
+    return {
+        skipped: (0, isEmpty_js_1.isEmpty)(skipped) ? undefined : skipped,
+        extensionFields: (0, isEmpty_js_1.isEmpty)(extensionFields) ? undefined : extensionFields
+    };
+};
+exports.extractExtensions = extractExtensions;

package/script/parse/v3-1/string/toString.d.ts

@@ -0,0 +1,147 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasString } from '../../../oas/string/String.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * Arguments for transforming an OpenAPI string schema into OAS representation.
+ */
+export type ToStringArgs = {
+    /** The OpenAPI v3 schema object to transform (must be type 'string') */
+    value: OpenAPIV3.SchemaObject;
+    /** The stack trail for tracing */
+    stackTrail: StackTrail;
+    /** Parse context providing utilities and tracing capabilities */
+    context: ParseContextType;
+};
+/**
+ * Transforms an OpenAPI v3 string schema object into an internal OAS string representation.
+ *
+ * This function processes OpenAPI string 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 string representation with proper validation
+ * of string formats and constraints.
+ *
+ * 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 OasString instance with format validation
+ *
+ * @param args - Transformation arguments
+ * @param args.context - Parse context providing utilities and tracing
+ * @param args.value - The OpenAPI v3 string schema object to transform
+ * @returns Transformed OAS string object with parsed properties
+ *
+ * @example Basic string transformation
+ * ```typescript
+ * import { toString } from '@skmtc/core';
+ *
+ * const openApiString = {
+ *   type: 'string',
+ *   format: 'email',
+ *   maxLength: 255,
+ *   pattern: '^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$'
+ * };
+ *
+ * const oasString = toString({
+ *   context: parseContext,
+ *   value: openApiString
+ * });
+ *
+ * console.log(oasString.format); // 'email'
+ * console.log(oasString.maxLength); // 255
+ * ```
+ *
+ * @example String with nullable and enums
+ * ```typescript
+ * const statusString = {
+ *   type: 'string',
+ *   nullable: true,
+ *   enum: ['active', 'inactive', 'pending', null],
+ *   default: 'active',
+ *   example: 'pending'
+ * };
+ *
+ * const oasString = toString({
+ *   context: parseContext,
+ *   value: statusString
+ * });
+ *
+ * console.log(oasString.nullable); // true
+ * console.log(oasString.enums); // ['active', 'inactive', 'pending', null]
+ * ```
+ */
+export declare const toString: ({ context, value, stackTrail }: ToStringArgs) => OasString;
+type ToParsedStringArgs<Nullable extends boolean | undefined> = {
+    value: Omit<OpenAPIV3.SchemaObject, 'nullable' | 'example' | 'enums' | 'default'>;
+    context: ParseContextType;
+    nullable: Nullable;
+    example: Nullable extends true ? string | null | undefined : string | undefined;
+    enums: Nullable extends true ? (string | null)[] | undefined : string[] | undefined;
+    defaultValue: Nullable extends true ? string | null | undefined : string | undefined;
+    stackTrail: StackTrail;
+};
+/**
+ * Creates an OAS string instance from pre-parsed string schema components.
+ *
+ * This function is the final step in the string transformation pipeline, taking
+ * already-parsed nullable, example, enum, and default values and combining them
+ * with the remaining string properties to create the complete OasString instance.
+ *
+ * The function handles format validation against known OpenAPI string formats,
+ * length constraints parsing, pattern validation, and specification extension
+ * processing. It logs warnings for unrecognized formats while still preserving
+ * them in the output.
+ *
+ * @template Nullable - Boolean type indicating if the string can be null
+ * @param args - Pre-parsed string components
+ * @param args.context - Parse context for tracing and issue logging
+ * @param args.nullable - Parsed nullable flag
+ * @param args.example - Parsed example value (type-safe with nullable)
+ * @param args.enums - Parsed enumeration constraints (type-safe with nullable)
+ * @param args.defaultValue - Parsed default value (type-safe with nullable)
+ * @param args.value - OpenAPI string object without parsed fields
+ * @returns Complete OAS string instance with all properties and validation
+ *
+ * @example Date-time string with validation
+ * ```typescript
+ * const dateTimeString = toParsedString({
+ *   context: parseContext,
+ *   nullable: false,
+ *   example: '2023-12-25T10:00:00Z',
+ *   enums: undefined,
+ *   defaultValue: undefined,
+ *   value: {
+ *     type: 'string',
+ *     format: 'date-time',
+ *     title: 'Event Date',
+ *     description: 'When the event occurs'
+ *   }
+ * });
+ *
+ * console.log(dateTimeString.format); // 'date-time'
+ * ```
+ *
+ * @example String with custom format (generates warning)
+ * ```typescript
+ * const customFormatString = toParsedString({
+ *   context: parseContext,
+ *   nullable: false,
+ *   example: 'ABC123',
+ *   enums: undefined,
+ *   defaultValue: undefined,
+ *   value: {
+ *     type: 'string',
+ *     format: 'custom-id', // Unknown format, will log warning
+ *     pattern: '^[A-Z]{3}[0-9]{3}$'
+ *   }
+ * });
+ *
+ * // Logs: "Unexpected format: custom-id"
+ * console.log(customFormatString.format); // 'custom-id' (still preserved)
+ * ```
+ */
+export declare const toParsedString: <Nullable extends boolean | undefined>({ context, nullable, example, enums, defaultValue, value, stackTrail }: ToParsedStringArgs<Nullable>) => OasString<Nullable>;
+export {};
+//# sourceMappingURL=toString.d.ts.map

package/script/parse/v3-1/string/toString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toString.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/string/toString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAA;AAQzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wEAAwE;IACxE,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,kCAAkC;IAClC,UAAU,EAAE,UAAU,CAAA;IACtB,iEAAiE;IACjE,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,QAAQ,GAAI,gCAAgC,YAAY,KAAG,SAwDvE,CAAA;AAED,KAAK,kBAAkB,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC9D,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC,CAAA;IACjF,OAAO,EAAE,gBAAgB,CAAA;IACzB,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAA;IAC/E,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAAA;IACnF,YAAY,EAAE,QAAQ,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAA;IACpF,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,SAAS,OAAO,GAAG,SAAS,EAAE,wEAQlE,kBAAkB,CAAC,QAAQ,CAAC,KAAG,SAAS,CAAC,QAAQ,CA2DnD,CAAA"}

package/script/parse/v3-1/string/toString.js

@@ -0,0 +1,256 @@
+"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.toParsedString = exports.toString = void 0;
+const String_js_1 = require("../../../oas/string/String.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const string_types_js_1 = require("../../../oas/string/string-types.js");
+const v = __importStar(require("valibot"));
+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");
+/**
+ * Transforms an OpenAPI v3 string schema object into an internal OAS string representation.
+ *
+ * This function processes OpenAPI string 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 string representation with proper validation
+ * of string formats and constraints.
+ *
+ * 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 OasString instance with format validation
+ *
+ * @param args - Transformation arguments
+ * @param args.context - Parse context providing utilities and tracing
+ * @param args.value - The OpenAPI v3 string schema object to transform
+ * @returns Transformed OAS string object with parsed properties
+ *
+ * @example Basic string transformation
+ * ```typescript
+ * import { toString } from '@skmtc/core';
+ *
+ * const openApiString = {
+ *   type: 'string',
+ *   format: 'email',
+ *   maxLength: 255,
+ *   pattern: '^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$'
+ * };
+ *
+ * const oasString = toString({
+ *   context: parseContext,
+ *   value: openApiString
+ * });
+ *
+ * console.log(oasString.format); // 'email'
+ * console.log(oasString.maxLength); // 255
+ * ```
+ *
+ * @example String with nullable and enums
+ * ```typescript
+ * const statusString = {
+ *   type: 'string',
+ *   nullable: true,
+ *   enum: ['active', 'inactive', 'pending', null],
+ *   default: 'active',
+ *   example: 'pending'
+ * };
+ *
+ * const oasString = toString({
+ *   context: parseContext,
+ *   value: statusString
+ * });
+ *
+ * console.log(oasString.nullable); // true
+ * console.log(oasString.enums); // ['active', 'inactive', 'pending', null]
+ * ```
+ */
+const toString = ({ context, value, stackTrail }) => {
+    if (value.type === 'string' && Object.keys(value).length === 1) {
+        return context.withStackTrail(stackTrail, () => new String_js_1.OasString({}, context));
+    }
+    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: isString,
+        toMessage: item => `Removed invalid example. Expected "string", got: ${item}`,
+        stackTrail
+    });
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = (0, parseEnum_js_1.parseEnum)({
+        value: unparsedEnums,
+        nullable,
+        parent: valueWithoutExample,
+        context,
+        check: isString,
+        toMessage: item => `Removed invalid enum. Expected "string", got: ${item}`,
+        stackTrail
+    });
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = (0, parseDefault_js_1.parseDefault)({
+        value: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable,
+        check: isString,
+        toMessage: item => `Removed invalid default. Expected "string", got: ${item}`,
+        stackTrail
+    });
+    return (0, exports.toParsedString)({
+        context,
+        nullable,
+        example,
+        enums,
+        defaultValue,
+        value: valueWithoutDefault,
+        stackTrail
+    });
+};
+exports.toString = toString;
+/**
+ * Creates an OAS string instance from pre-parsed string schema components.
+ *
+ * This function is the final step in the string transformation pipeline, taking
+ * already-parsed nullable, example, enum, and default values and combining them
+ * with the remaining string properties to create the complete OasString instance.
+ *
+ * The function handles format validation against known OpenAPI string formats,
+ * length constraints parsing, pattern validation, and specification extension
+ * processing. It logs warnings for unrecognized formats while still preserving
+ * them in the output.
+ *
+ * @template Nullable - Boolean type indicating if the string can be null
+ * @param args - Pre-parsed string components
+ * @param args.context - Parse context for tracing and issue logging
+ * @param args.nullable - Parsed nullable flag
+ * @param args.example - Parsed example value (type-safe with nullable)
+ * @param args.enums - Parsed enumeration constraints (type-safe with nullable)
+ * @param args.defaultValue - Parsed default value (type-safe with nullable)
+ * @param args.value - OpenAPI string object without parsed fields
+ * @returns Complete OAS string instance with all properties and validation
+ *
+ * @example Date-time string with validation
+ * ```typescript
+ * const dateTimeString = toParsedString({
+ *   context: parseContext,
+ *   nullable: false,
+ *   example: '2023-12-25T10:00:00Z',
+ *   enums: undefined,
+ *   defaultValue: undefined,
+ *   value: {
+ *     type: 'string',
+ *     format: 'date-time',
+ *     title: 'Event Date',
+ *     description: 'When the event occurs'
+ *   }
+ * });
+ *
+ * console.log(dateTimeString.format); // 'date-time'
+ * ```
+ *
+ * @example String with custom format (generates warning)
+ * ```typescript
+ * const customFormatString = toParsedString({
+ *   context: parseContext,
+ *   nullable: false,
+ *   example: 'ABC123',
+ *   enums: undefined,
+ *   defaultValue: undefined,
+ *   value: {
+ *     type: 'string',
+ *     format: 'custom-id', // Unknown format, will log warning
+ *     pattern: '^[A-Z]{3}[0-9]{3}$'
+ *   }
+ * });
+ *
+ * // Logs: "Unexpected format: custom-id"
+ * console.log(customFormatString.format); // 'custom-id' (still preserved)
+ * ```
+ */
+const toParsedString = ({ context, nullable, example, enums, defaultValue, value, stackTrail }) => {
+    if (!v.is(string_types_js_1.oasStringData, value)) {
+        v.parse(string_types_js_1.oasStringData, value);
+    }
+    const { type: _type, title, description, format, maxLength, minLength, pattern, readOnly, writeOnly, deprecated, ...skipped } = value;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:string'
+    });
+    if (format && !v.is(string_types_js_1.stringFormat, format)) {
+        context.logIssue({
+            key: 'format',
+            level: 'warning',
+            message: `Unexpected format: ${format}`,
+            parent: value,
+            stackTrail,
+            type: 'UNEXPECTED_FORMAT'
+        });
+    }
+    return context.withStackTrail(stackTrail, () => new String_js_1.OasString({
+        title,
+        description,
+        enums,
+        nullable,
+        example,
+        format,
+        maxLength,
+        minLength,
+        pattern,
+        readOnly,
+        writeOnly,
+        default: defaultValue,
+        extensionFields,
+        deprecated
+    }, context));
+};
+exports.toParsedString = toParsedString;
+const isString = (value) => {
+    return typeof value === 'string';
+};

package/script/parse/v3-1/tag/toTagsV3.d.ts

@@ -0,0 +1,17 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasTag } from '../../../oas/tag/Tag.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToTagsV3Args = {
+    tags: OpenAPIV3.TagObject[] | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toTagsV3: ({ tags, stackTrail, context }: ToTagsV3Args) => OasTag[] | undefined;
+export type ToTagV3Args = {
+    tag: OpenAPIV3.TagObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toTagV3: ({ tag, stackTrail, context }: ToTagV3Args) => OasTag;
+//# sourceMappingURL=toTagsV3.d.ts.map

package/script/parse/v3-1/tag/toTagsV3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toTagsV3.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/tag/toTagsV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAIhD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,SAAS,CAAC,SAAS,EAAE,GAAG,SAAS,CAAA;IACvC,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,+BAA+B,YAAY,KAAG,MAAM,EAAE,GAAG,SAMjF,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,SAAS,CAAC,SAAS,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,8BAA8B,WAAW,KAAG,MAuBnE,CAAA"}

package/script/parse/v3-1/tag/toTagsV3.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTagV3 = exports.toTagsV3 = void 0;
+const Tag_js_1 = require("../../../oas/tag/Tag.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const toExternalDocs_js_1 = require("../externalDocs/toExternalDocs.js");
+const toTagsV3 = ({ tags, stackTrail, context }) => {
+    if (!tags) {
+        return undefined;
+    }
+    return tags.map(tag => (0, exports.toTagV3)({ tag, stackTrail, context }));
+};
+exports.toTagsV3 = toTagsV3;
+const toTagV3 = ({ tag, stackTrail, context }) => {
+    const { name, description, externalDocs, ...skipped } = tag;
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => (0, toExternalDocs_js_1.toExternalDocs)({ externalDocs, stackTrail: st, context }));
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: tag,
+        context,
+        stackTrail,
+        parentType: 'tag'
+    });
+    const fields = {
+        name,
+        description,
+        externalDocs: parsedExternalDocs,
+        extensionFields
+    };
+    return new Tag_js_1.OasTag(fields);
+};
+exports.toTagV3 = toTagV3;

package/script/parse/v3-1/union/toUnion.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasUnion } from '../../../oas/union/Union.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToUnionArgs = {
+    value: OpenAPIV3.SchemaObject;
+    members: (OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject)[];
+    parentType: 'anyOf' | 'oneOf';
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toUnion: ({ value, members, parentType, stackTrail, context }: ToUnionArgs) => OasUnion;
+//# sourceMappingURL=toUnion.d.ts.map

package/script/parse/v3-1/union/toUnion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toUnion.d.ts","sourceRoot":"","sources":["../../../../src/parse/v3-1/union/toUnion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AAStD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,CAAC,YAAY,CAAA;IAC7B,OAAO,EAAE,CAAC,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,YAAY,CAAC,EAAE,CAAA;IAC/D,UAAU,EAAE,OAAO,GAAG,OAAO,CAAA;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,qDAMrB,WAAW,KAAG,QA0EhB,CAAA"}