vovk 3.5.1 → 3.7.0

package/dist/samples/object-to-code.js

@@ -0,0 +1,38 @@
+export function objectToCode(obj, options) {
+    const { stripQuotes = false, indent = 0, nestingIndent = 2, quote = '"' } = options || {};
+    // Use JSON.stringify with the nesting indent
+    let result = JSON.stringify(obj, null, nestingIndent);
+    // Replace double quotes with single quotes for string values if requested
+    if (quote === "'") {
+        // First, escape any existing single quotes in string values
+        result = result.replace(/"([^"]*)"/g, (match, content) => {
+            // Check if this is a key (followed by colon) or a value
+            const matchIndex = result.indexOf(match);
+            const afterMatch = result.substring(matchIndex + match.length);
+            if (afterMatch.startsWith(':')) {
+                // This is a key, keep it for now
+                return match;
+            }
+            // This is a value, replace quotes and escape single quotes
+            const escaped = content.replace(/'/g, "\\'");
+            return `'${escaped}'`;
+        });
+    }
+    // Strip quotes from keys if requested
+    if (stripQuotes) {
+        // Remove quotes from keys that are valid JavaScript identifiers
+        // Keep quotes for keys with special characters (like 'x-foo', spaces, etc.)
+        const keyQuote = quote === "'" ? "'" : '"';
+        const pattern = new RegExp(`${keyQuote}([a-zA-Z_$][a-zA-Z0-9_$]*)${keyQuote}:`, 'g');
+        result = result.replace(pattern, '$1:');
+    }
+    // Apply base indentation if specified
+    if (indent > 0) {
+        const indentStr = ' '.repeat(indent);
+        result = result
+            .split('\n')
+            .map((line, i) => (i === 0 ? line : indentStr + line))
+            .join('\n');
+    }
+    return result;
+}

package/dist/samples/schema-to-code.d.ts

@@ -0,0 +1,11 @@
+import type { VovkJSONSchemaBase } from '../types/json-schema.js';
+interface SamplerOptions {
+    comment?: '//' | '#';
+    stripQuotes?: boolean;
+    indent?: number;
+    nestingIndent?: number;
+    ignoreBinary?: boolean;
+}
+export declare function schemaToCode(schema: VovkJSONSchemaBase, options: SamplerOptions, rootSchema?: VovkJSONSchemaBase): string;
+export declare function getSampleValue(schema: VovkJSONSchemaBase, rootSchema?: VovkJSONSchemaBase, ignoreBinary?: boolean): unknown;
+export {};

package/dist/samples/schema-to-code.js

@@ -0,0 +1,264 @@
+export function schemaToCode(schema, options, rootSchema) {
+    const { comment = '//', stripQuotes = false, indent = 0, nestingIndent = 4, ignoreBinary = false } = options;
+    if (!schema || typeof schema !== 'object')
+        return 'null';
+    // Use the input schema as the root if not provided
+    rootSchema = rootSchema || schema;
+    // Get the sample value
+    const sampleValue = getSampleValue(schema, rootSchema, ignoreBinary);
+    // Format the output with descriptions
+    return formatWithDescriptions(sampleValue, schema, rootSchema, comment, stripQuotes, indent, nestingIndent, ignoreBinary, true // isTopLevel
+    );
+}
+export function getSampleValue(schema, rootSchema, ignoreBinary) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    rootSchema = rootSchema || schema;
+    // Check if this is a binary string schema and should be ignored
+    if (ignoreBinary && schema.type === 'string' && schema.format === 'binary') {
+        return undefined;
+    }
+    // If there's an example, use it
+    if (schema.example !== undefined) {
+        return schema.example;
+    }
+    // If there are examples, use one of them
+    if (schema.examples && schema.examples.length > 0) {
+        return schema.examples[0];
+    }
+    // Handle const if present
+    if (schema.const !== undefined) {
+        return schema.const;
+    }
+    // Handle $ref if present
+    if (schema.$ref) {
+        return handleRef(schema.$ref, rootSchema, ignoreBinary);
+    }
+    // Handle enum if present
+    if (schema.enum && schema.enum.length > 0) {
+        return schema.enum[0];
+    }
+    // Handle oneOf, anyOf, allOf
+    if (schema.oneOf && schema.oneOf.length > 0) {
+        return getSampleValue(schema.oneOf[0], rootSchema, ignoreBinary);
+    }
+    if (schema.anyOf && schema.anyOf.length > 0) {
+        return getSampleValue(schema.anyOf[0], rootSchema, ignoreBinary);
+    }
+    if (schema.allOf && schema.allOf.length > 0) {
+        // Merge all schemas in allOf
+        const mergedSchema = schema.allOf.reduce((acc, s) => Object.assign(acc, s), {});
+        return getSampleValue(mergedSchema, rootSchema, ignoreBinary);
+    }
+    // Handle different types
+    if (schema.type) {
+        switch (schema.type) {
+            case 'string':
+                return handleString(schema);
+            case 'number':
+            case 'integer':
+                return handleNumber(schema);
+            case 'boolean':
+                return handleBoolean();
+            case 'object':
+                return handleObject(schema, rootSchema, ignoreBinary);
+            case 'array':
+                return handleArray(schema, rootSchema, ignoreBinary);
+            case 'null':
+                return null;
+            default:
+                return null;
+        }
+    }
+    // If type is not specified but properties are, treat it as an object
+    if (schema.properties) {
+        return handleObject(schema, rootSchema, ignoreBinary);
+    }
+    // Default fallback
+    return null;
+}
+function formatWithDescriptions(value, schema, rootSchema, comment, stripQuotes, indent, nestingIndent, ignoreBinary, isTopLevel) {
+    const indentStr = ' '.repeat(indent);
+    const nestIndentStr = ' '.repeat(nestingIndent); // Create nesting indent string
+    // Handle undefined (for ignored binary fields)
+    if (value === undefined) {
+        return '';
+    }
+    // Handle null
+    if (value === null) {
+        return 'null';
+    }
+    // Handle primitives
+    if (typeof value !== 'object' || value instanceof Date) {
+        return JSON.stringify(value);
+    }
+    // Handle arrays
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '[]';
+        const items = value.map((item) => {
+            const itemSchema = schema.items && typeof schema.items === 'object' ? schema.items : {};
+            const formattedItem = formatWithDescriptions(item, itemSchema, rootSchema, comment, stripQuotes, indent + nestingIndent, // Use nestingIndent instead of hardcoded 4
+            nestingIndent, ignoreBinary, false);
+            return `${indentStr}${nestIndentStr}${formattedItem}`; // Use nestIndentStr for item indentation
+        });
+        return `[\n${items.join(',\n')}\n${indentStr}]`;
+    }
+    // Handle objects
+    if (typeof value === 'object') {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return '{}';
+        const formattedEntries = [];
+        // Add top-level description for objects
+        if (isTopLevel && schema.type === 'object' && schema.description) {
+            const descLines = schema.description.split('\n');
+            formattedEntries.push(`${indentStr}${nestIndentStr}${comment} -----`);
+            descLines.forEach((line) => {
+                formattedEntries.push(`${indentStr}${nestIndentStr}${comment} ${line.trim()}`);
+            });
+            formattedEntries.push(`${indentStr}${nestIndentStr}${comment} -----`);
+        }
+        entries.forEach(([key, val], index) => {
+            const propSchema = schema.properties?.[key] ?? {};
+            // Handle $ref in property schema
+            let resolvedPropSchema = propSchema;
+            if (propSchema.$ref) {
+                resolvedPropSchema = resolveRef(propSchema.$ref, rootSchema);
+            }
+            // Add property description if it exists
+            if (resolvedPropSchema.description) {
+                const descLines = resolvedPropSchema.description.split('\n');
+                descLines.forEach((line) => {
+                    formattedEntries.push(`${indentStr}${nestIndentStr}${comment} ${line.trim()}`);
+                });
+            }
+            // Format the key
+            const formattedKey = stripQuotes && /^[A-Za-z_$][0-9A-Za-z_$]*$/.test(key) ? key : JSON.stringify(key);
+            // Format the value
+            const formattedValue = formatWithDescriptions(val, resolvedPropSchema, rootSchema, comment, stripQuotes, indent + nestingIndent, nestingIndent, ignoreBinary, false);
+            formattedEntries.push(`${indentStr}${nestIndentStr}${formattedKey}: ${formattedValue}${index < entries.length - 1 ? ',' : ''}`);
+        });
+        return `{\n${formattedEntries.join('\n')}\n${indentStr}}`;
+    }
+    return JSON.stringify(value);
+}
+function resolveRef(ref, rootSchema) {
+    const path = ref.split('/').slice(1); // Remove the initial '#'
+    let current = rootSchema;
+    for (const segment of path) {
+        current = current[segment];
+        if (current === undefined) {
+            return {};
+        }
+    }
+    return current;
+}
+function handleRef(ref, rootSchema, ignoreBinary) {
+    const resolved = resolveRef(ref, rootSchema);
+    return getSampleValue(resolved, rootSchema, ignoreBinary);
+}
+function handleString(schema) {
+    if (schema.format) {
+        switch (schema.format) {
+            case 'email':
+            case 'idn-email':
+                return 'user@example.com';
+            case 'uri':
+            case 'url':
+            case 'iri':
+                return 'https://example.com';
+            case 'date':
+                return '2023-01-01';
+            case 'date-time':
+                return '2023-01-01T00:00:00Z';
+            case 'time':
+                return '12:00:00Z';
+            case 'duration':
+                return 'PT1H';
+            case 'uuid':
+                return '00000000-0000-0000-0000-000000000000';
+            case 'regex':
+                return '^[a-zA-Z0-9]+$';
+            case 'relative-json-pointer':
+                return '/some/relative/path';
+            case 'color':
+                return '#000000';
+            case 'hostname':
+                return 'example.com';
+            case 'zipcode':
+                return '12345';
+            case 'phone':
+                return '+123-456-7890';
+            case 'password':
+                return '******';
+            case 'binary':
+                return 'binary-data';
+            default:
+                return 'string';
+        }
+    }
+    if (schema.pattern) {
+        return 'pattern-string';
+    }
+    return 'string';
+}
+function handleNumber(schema) {
+    if (schema.minimum !== undefined && schema.maximum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.minimum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.maximum !== undefined) {
+        return schema.maximum;
+    }
+    return 0;
+}
+function handleBoolean() {
+    return true;
+}
+function handleObject(schema, rootSchema, ignoreBinary) {
+    const result = {};
+    if (schema.properties) {
+        const required = schema.required || [];
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+            if (required.includes(key) || required.length === 0) {
+                const value = getSampleValue(propSchema, rootSchema, ignoreBinary);
+                // Only add the property if it's not undefined (which happens when ignoreBinary is true and it's a binary field)
+                if (value !== undefined) {
+                    result[key] = value;
+                }
+            }
+        }
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        const value = getSampleValue(schema.additionalProperties, rootSchema, ignoreBinary);
+        if (value !== undefined) {
+            result.additionalProp = value;
+        }
+    }
+    return result;
+}
+function handleArray(schema, rootSchema, ignoreBinary) {
+    if (schema.items) {
+        // If items is a boolean, return empty array (true means any items allowed, false means no items)
+        if (typeof schema.items === 'boolean') {
+            return schema.items ? [null] : [];
+        }
+        const itemSchema = schema.items;
+        // Check if the items are binary strings that should be ignored
+        if (ignoreBinary && itemSchema.type === 'string' && itemSchema.format === 'binary') {
+            return undefined;
+        }
+        const minItems = schema.minItems || 1;
+        const numItems = Math.min(minItems, 3);
+        const items = Array.from({ length: numItems }, () => getSampleValue(itemSchema, rootSchema, ignoreBinary)).filter((item) => item !== undefined); // Filter out undefined values from ignored binary items
+        // If all items were filtered out (e.g., all were binary), return undefined instead of empty array
+        if (items.length === 0 && numItems > 0) {
+            return undefined;
+        }
+        return items;
+    }
+    return [];
+}

package/dist/samples/schema-to-object.d.ts

@@ -0,0 +1,2 @@
+import type { VovkJSONSchemaBase } from '../types/json-schema.js';
+export declare function schemaToObject(schema: VovkJSONSchemaBase, rootSchema?: VovkJSONSchemaBase): unknown;

package/dist/samples/schema-to-object.js

@@ -0,0 +1,164 @@
+export function schemaToObject(schema, rootSchema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    // Use the input schema as the root if not provided
+    rootSchema = rootSchema || schema;
+    // If there's an example, use it
+    if (schema.example !== undefined) {
+        return schema.example;
+    }
+    // If there are examples, use one of them
+    if (schema.examples && schema.examples.length > 0) {
+        return schema.examples[0];
+    }
+    // Handle const if present
+    if (schema.const !== undefined) {
+        return schema.const;
+    }
+    // Handle $ref if present
+    if (schema.$ref) {
+        return handleRef(schema.$ref, rootSchema);
+    }
+    // Handle enum if present
+    if (schema.enum && schema.enum.length > 0) {
+        return schema.enum[0];
+    }
+    // Handle oneOf, anyOf, allOf
+    if (schema.oneOf && schema.oneOf.length > 0) {
+        return schemaToObject(schema.oneOf[0], rootSchema);
+    }
+    if (schema.anyOf && schema.anyOf.length > 0) {
+        return schemaToObject(schema.anyOf[0], rootSchema);
+    }
+    if (schema.allOf && schema.allOf.length > 0) {
+        // Merge all schemas in allOf
+        const mergedSchema = schema.allOf.reduce((acc, s) => Object.assign(acc, s), {});
+        return schemaToObject(mergedSchema, rootSchema);
+    }
+    // Handle different types
+    if (schema.type) {
+        switch (schema.type) {
+            case 'string':
+                return handleString(schema);
+            case 'number':
+            case 'integer':
+                return handleNumber(schema);
+            case 'boolean':
+                return handleBoolean();
+            case 'object':
+                return handleObject(schema, rootSchema);
+            case 'array':
+                return handleArray(schema, rootSchema);
+            case 'null':
+                return null;
+            default:
+                return null;
+        }
+    }
+    // If type is not specified but properties are, treat it as an object
+    if (schema.properties) {
+        return handleObject(schema, rootSchema);
+    }
+    // Default fallback
+    return null;
+}
+function handleRef(ref, rootSchema) {
+    // Parse the reference path
+    const path = ref.split('/').slice(1); // Remove the initial '#'
+    // Navigate through the schema to find the referenced definition
+    let current = rootSchema;
+    for (const segment of path) {
+        current = current[segment];
+        if (current === undefined) {
+            return null; // Reference not found
+        }
+    }
+    // Process the referenced schema
+    return schemaToObject(current, rootSchema);
+}
+function handleString(schema) {
+    if (schema.format) {
+        switch (schema.format) {
+            case 'email':
+            case 'idn-email':
+                return 'user@example.com';
+            case 'uri':
+            case 'url':
+            case 'iri':
+                return 'https://example.com';
+            case 'date':
+                return '2023-01-01';
+            case 'date-time':
+                return '2023-01-01T00:00:00Z';
+            case 'time':
+                return '12:00:00Z';
+            case 'duration':
+                return 'PT1H';
+            case 'uuid':
+                return '00000000-0000-0000-0000-000000000000';
+            case 'regex':
+                return '^[a-zA-Z0-9]+$';
+            case 'relative-json-pointer':
+                return '/some/relative/path';
+            case 'color':
+                return '#000000';
+            case 'hostname':
+                return 'example.com';
+            case 'zipcode':
+                return '12345';
+            case 'phone':
+                return '+123-456-7890';
+            case 'password':
+                return '******';
+            default:
+                return 'string';
+        }
+    }
+    if (schema.pattern) {
+        // For simplicity, return a basic string for patterns
+        return 'pattern-string';
+    }
+    return 'string';
+}
+function handleNumber(schema) {
+    if (schema.minimum !== undefined && schema.maximum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.minimum !== undefined) {
+        return schema.minimum;
+    }
+    else if (schema.maximum !== undefined) {
+        return schema.maximum;
+    }
+    return 0;
+}
+function handleBoolean() {
+    return true;
+}
+function handleObject(schema, rootSchema) {
+    const result = {};
+    if (schema.properties) {
+        const required = schema.required || [];
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+            // Only include required properties or as a basic example
+            if (required.includes(key) || required.length === 0) {
+                result[key] = schemaToObject(propSchema, rootSchema);
+            }
+        }
+    }
+    // Handle additionalProperties
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        result.additionalProp = schemaToObject(schema.additionalProperties, rootSchema);
+    }
+    return result;
+}
+function handleArray(schema, rootSchema) {
+    if (schema.items && typeof schema.items === 'object') {
+        const itemSchema = schema.items;
+        const minItems = schema.minItems || 1;
+        // Create minimum number of items (capped at a reasonable max for examples)
+        const numItems = Math.min(minItems, 3);
+        return Array.from({ length: numItems }, () => schemaToObject(itemSchema, rootSchema));
+    }
+    return [];
+}

package/dist/samples/schema-to-ts-type.d.ts

@@ -0,0 +1,2 @@
+import type { VovkJSONSchemaBase } from 'vovk';
+export declare function schemaToTsType(jsonSchema: VovkJSONSchemaBase | boolean): string;

package/dist/samples/schema-to-ts-type.js

@@ -0,0 +1,114 @@
+export function schemaToTsType(jsonSchema) {
+    if (jsonSchema === true)
+        return 'unknown';
+    if (jsonSchema === false)
+        return 'never';
+    if (jsonSchema === null || jsonSchema === undefined)
+        return 'unknown';
+    if (typeof jsonSchema !== 'object')
+        return 'unknown';
+    // Handle const
+    if ('const' in jsonSchema) {
+        return JSON.stringify(jsonSchema.const);
+    }
+    // Handle enum
+    if (jsonSchema.enum) {
+        return jsonSchema.enum.map((v) => JSON.stringify(v)).join(' | ') || 'never';
+    }
+    // Handle allOf (intersection)
+    if (jsonSchema.allOf) {
+        const parts = jsonSchema.allOf.map((s) => schemaToTsType(s));
+        return parts.length ? `(${parts.join(' & ')})` : 'unknown';
+    }
+    // Handle anyOf (union)
+    if (jsonSchema.anyOf) {
+        const parts = jsonSchema.anyOf.map((s) => schemaToTsType(s));
+        return parts.length ? `(${parts.join(' | ')})` : 'never';
+    }
+    // Handle oneOf (union)
+    if (jsonSchema.oneOf) {
+        const parts = jsonSchema.oneOf.map((s) => schemaToTsType(s));
+        return parts.length ? `(${parts.join(' | ')})` : 'never';
+    }
+    // Handle not (negate - approximate as unknown)
+    if (jsonSchema.not) {
+        return 'unknown';
+    }
+    // Handle type as array (union of types)
+    if (Array.isArray(jsonSchema.type)) {
+        const types = jsonSchema.type.map((t) => schemaToTsType({ ...jsonSchema, type: t }));
+        return types.length ? `(${types.join(' | ')})` : 'unknown';
+    }
+    const type = jsonSchema.type;
+    // Primitives
+    if (type === 'string')
+        return 'string';
+    if (type === 'number' || type === 'integer')
+        return 'number';
+    if (type === 'boolean')
+        return 'boolean';
+    if (type === 'null')
+        return 'null';
+    // Object
+    if (type === 'object' || jsonSchema.properties || jsonSchema.additionalProperties !== undefined) {
+        const props = jsonSchema.properties || {};
+        const required = jsonSchema.required || [];
+        const propEntries = Object.entries(props);
+        const propStrings = propEntries.map(([key, value]) => {
+            const isRequired = required.includes(key);
+            const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+            return `${safeName}${isRequired ? '' : '?'}: ${schemaToTsType(value)}`;
+        });
+        // Handle additionalProperties
+        let additionalType = null;
+        if (jsonSchema.additionalProperties === true) {
+            additionalType = 'unknown';
+        }
+        else if (jsonSchema.additionalProperties && typeof jsonSchema.additionalProperties === 'object') {
+            additionalType = schemaToTsType(jsonSchema.additionalProperties);
+        }
+        if (propStrings.length === 0 && additionalType) {
+            return `{ [key: string]: ${additionalType} }`;
+        }
+        if (propStrings.length === 0 && !additionalType) {
+            return jsonSchema.additionalProperties === false ? '{}' : '{ [key: string]: unknown }';
+        }
+        let result = `{ ${propStrings.join('; ')} }`;
+        if (additionalType) {
+            result = `(${result} & { [key: string]: ${additionalType} })`;
+        }
+        return result;
+    }
+    // Array
+    if (type === 'array' || jsonSchema.items || jsonSchema.prefixItems) {
+        // Tuple (prefixItems)
+        if (jsonSchema.prefixItems) {
+            const tupleTypes = jsonSchema.prefixItems.map((s) => schemaToTsType(s));
+            if (jsonSchema.items === false) {
+                return `[${tupleTypes.join(', ')}]`;
+            }
+            const restType = jsonSchema.items ? schemaToTsType(jsonSchema.items) : 'unknown';
+            return `[${tupleTypes.join(', ')}, ...${restType}[]]`;
+        }
+        // Regular array
+        if (jsonSchema.items) {
+            if (Array.isArray(jsonSchema.items)) {
+                // Legacy tuple syntax
+                const tupleTypes = jsonSchema.items.map((s) => schemaToTsType(s));
+                if (jsonSchema.additionalItems === false) {
+                    return `[${tupleTypes.join(', ')}]`;
+                }
+                const restType = jsonSchema.additionalItems ? schemaToTsType(jsonSchema.additionalItems) : 'unknown';
+                return `[${tupleTypes.join(', ')}, ...${restType}[]]`;
+            }
+            return `${schemaToTsType(jsonSchema.items)}[]`;
+        }
+        return 'unknown[]';
+    }
+    // No type specified - try to infer from structure
+    if (jsonSchema.properties) {
+        return schemaToTsType({ ...jsonSchema, type: 'object' });
+    }
+    // Fallback for empty or unknown schema
+    return 'unknown';
+}