vovk 3.0.0-draft.99 → 3.0.2

package/dist/samples/createCodeSamples.js

@@ -0,0 +1,293 @@
+import { schemaToCode, getSampleValue } from './schemaToCode.js';
+import { objectToCode } from './objectToCode.js';
+const toSnakeCase = (str) => str
+    .replace(/-/g, '_') // Replace hyphens with underscores
+    .replace(/([a-z0-9])([A-Z])/g, '$1_$2') // Add underscore between lowercase/digit and uppercase
+    .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1_$2') // Add underscore between uppercase letters if the second one is followed by a lowercase
+    .toLowerCase()
+    .replace(/^_/, ''); // Remove leading underscore
+const getIndentSpaces = (level) => ' '.repeat(level);
+function isTextFormat(mimeType) {
+    if (!mimeType)
+        return false;
+    return (mimeType.startsWith('text/') ||
+        [
+            'application/json',
+            'application/ld+json',
+            'application/xml',
+            'application/xhtml+xml',
+            'application/javascript',
+            'application/typescript',
+            'application/yaml',
+            'application/x-yaml',
+            'application/toml',
+            'application/sql',
+            'application/graphql',
+            'application/x-www-form-urlencoded',
+        ].includes(mimeType) ||
+        mimeType.endsWith('+json') ||
+        mimeType.endsWith('+xml'));
+}
+const isForm = (schema) => {
+    const contentTypes = schema['x-contentType'] ?? [];
+    return contentTypes.some((ct) => ct === 'multipart/form-data' || ct === 'application/x-www-form-urlencoded') ?? false;
+};
+function generateTypeScriptCode({ handlerName, rpcName, packageName, queryValidation, bodyValidation, paramsValidation, outputValidation, iterationValidation, hasArg, config, }) {
+    const getTsSample = (schema, indent) => schemaToCode(schema, { stripQuotes: true, indent: indent ?? 4 });
+    const getTsFormSample = (schema) => {
+        let formSample = '\nconst formData = new FormData();';
+        for (const [key, prop] of Object.entries(schema.properties || {})) {
+            const target = prop.oneOf?.[0] || prop.anyOf?.[0] || prop.allOf?.[0] || prop;
+            const desc = target.description ?? prop.description ?? undefined;
+            if (target.type === 'array' && target.items && typeof target.items !== 'boolean') {
+                formSample += getTsFormAppend(target.items, key, desc);
+                formSample += getTsFormAppend(target.items, key, desc);
+            }
+            else {
+                formSample += getTsFormAppend(target, key, desc);
+            }
+        }
+        return formSample;
+    };
+    const getTsFormAppend = (schema, key, description) => {
+        let sampleValue;
+        if (schema.type === 'string' && schema.format === 'binary') {
+            sampleValue = `new Blob(${isTextFormat(schema.contentMediaType) ? '["text_content"]' : '[binary_data]'}${schema.contentMediaType ? `, { type: "${schema.contentMediaType}" }` : ''})`;
+        }
+        else if (schema.type === 'object') {
+            sampleValue = '"object_unknown"';
+        }
+        else {
+            sampleValue = `"${getSampleValue(schema)}"`;
+        }
+        const desc = schema.description ?? description;
+        return `\n${desc ? `// ${desc}\n` : ''}formData.append("${key}", ${sampleValue});`;
+    };
+    const tsArgs = hasArg
+        ? `{
+${[
+            bodyValidation ? `    body: ${isForm(bodyValidation) ? 'formData' : getTsSample(bodyValidation)},` : null,
+            queryValidation ? `    query: ${getTsSample(queryValidation)},` : null,
+            paramsValidation ? `    params: ${getTsSample(paramsValidation)},` : null,
+            config?.apiRoot ? `    apiRoot: '${config.apiRoot}',` : null,
+            config?.headers
+                ? `    init: {
+      headers: ${objectToCode(config.headers, { stripQuotes: true, indent: 6, nestingIndent: 4 })}
+    },`
+                : null,
+        ]
+            .filter(Boolean)
+            .join('\n')}
+}`
+        : '';
+    const TS_CODE = `import { ${rpcName} } from '${packageName}';
+${bodyValidation && isForm(bodyValidation) ? `${getTsFormSample(bodyValidation)}\n` : ''}
+${iterationValidation ? 'using' : 'const'} response = await ${rpcName}.${handlerName}(${tsArgs});
+${outputValidation
+        ? `
+console.log(response); 
+/* 
+${getTsSample(outputValidation, 0)}
+*/`
+        : ''}${iterationValidation
+        ? `
+for await (const item of response) {
+    console.log(item); 
+    /*
+    ${getTsSample(iterationValidation)}
+    */
+}`
+        : ''}`;
+    return TS_CODE.trim();
+}
+function generatePythonCode({ handlerName, rpcName, packageName, queryValidation, bodyValidation, paramsValidation, outputValidation, iterationValidation, hasArg, config, }) {
+    const getPySample = (schema, indent) => schemaToCode(schema, {
+        stripQuotes: false,
+        indent: indent ?? 4,
+        comment: '#',
+        ignoreBinary: true,
+        nestingIndent: 4,
+    });
+    const handlerNameSnake = toSnakeCase(handlerName);
+    const getFileTouple = (schema) => {
+        return `('name.ext', BytesIO(${isTextFormat(schema.contentMediaType) ? '"text_content".encode("utf-8")' : 'binary_data'})${schema.contentMediaType ? `, "${schema.contentMediaType}"` : ''})`;
+    };
+    const getPyFiles = (schema) => {
+        return Object.entries(schema.properties ?? {}).reduce((acc, [key, prop]) => {
+            const target = prop.oneOf?.[0] || prop.anyOf?.[0] || prop.allOf?.[0] || prop;
+            const desc = target.description ?? prop.description ?? undefined;
+            if (target.type === 'string' && target.format === 'binary') {
+                acc.push(`${desc ? `${getIndentSpaces(8)}# ${desc}\n` : ''}${getIndentSpaces(8)}('${key}', ${getFileTouple(target)})`);
+            }
+            else if (target.type === 'array' &&
+                target.items &&
+                typeof target.items !== 'boolean' &&
+                target.items.format === 'binary') {
+                const val = `${desc ? `${getIndentSpaces(8)}# ${desc}\n` : ''}${getIndentSpaces(8)}('${key}', ${getFileTouple(target.items)})`;
+                acc.push(val, val);
+            }
+            return acc;
+        }, []);
+    };
+    const pyFiles = bodyValidation ? getPyFiles(bodyValidation) : null;
+    const pyFilesArg = pyFiles?.length
+        ? `${getIndentSpaces(4)}files=[\n${pyFiles.join(',\n')}\n${getIndentSpaces(4)}],`
+        : null;
+    const PY_CODE = `from ${packageName} import ${rpcName}
+${bodyValidation && isForm(bodyValidation) ? 'from io import BytesIO\n' : ''}
+response = ${rpcName}.${handlerNameSnake}(${hasArg
+        ? '\n' +
+            [
+                bodyValidation ? `    body=${getPySample(bodyValidation)},` : null,
+                pyFilesArg,
+                queryValidation ? `    query=${getPySample(queryValidation)},` : null,
+                paramsValidation ? `    params=${getPySample(paramsValidation)},` : null,
+                config?.apiRoot ? `    api_root="${config.apiRoot}",` : null,
+                config?.headers
+                    ? `    headers=${objectToCode(config.headers, { stripQuotes: false, indent: 4, nestingIndent: 4 })},`
+                    : null,
+            ]
+                .filter(Boolean)
+                .join('\n') +
+            '\n'
+        : ''})
+
+${outputValidation ? `print(response)\n${getPySample(outputValidation, 0)}` : ''}${iterationValidation
+        ? `for i, item in enumerate(response):
+    print(f"iteration #{i}:\\n {item}")
+    # iteration #0:
+    ${getPySample(iterationValidation)}`
+        : ''}`;
+    return PY_CODE.trim();
+}
+function generateRustCode({ handlerName, rpcName, packageName, queryValidation, bodyValidation, paramsValidation, outputValidation, iterationValidation, config, }) {
+    const getRsJSONSample = (schema, indent) => schemaToCode(schema, { stripQuotes: false, indent: indent ?? 4 });
+    const getRsOutputSample = (schema, indent) => schemaToCode(schema, { stripQuotes: true, indent: indent ?? 4 });
+    const getRsFormSample = (schema) => {
+        let formSample = 'let form = reqwest::multipart::Form::new()';
+        for (const [key, prop] of Object.entries(schema.properties || {})) {
+            const target = prop.oneOf?.[0] || prop.anyOf?.[0] || prop.allOf?.[0] || prop;
+            const desc = target.description ?? prop.description ?? undefined;
+            if (target.type === 'array' && target.items && typeof target.items !== 'boolean') {
+                formSample += getRsFormPart(target.items, key, desc);
+                formSample += getRsFormPart(target.items, key, desc);
+            }
+            else {
+                formSample += getRsFormPart(target, key, desc);
+            }
+        }
+        return formSample;
+    };
+    const getRsFormPart = (schema, key, description) => {
+        let sampleValue;
+        if (schema.type === 'string' && schema.format === 'binary') {
+            sampleValue = isTextFormat(schema.contentMediaType)
+                ? 'reqwest::multipart::Part::text("text_content")'
+                : 'reqwest::multipart::Part::bytes(binary_data)';
+            if (schema.contentMediaType) {
+                sampleValue += `.mime_str("${schema.contentMediaType}").unwrap()`;
+            }
+        }
+        else if (schema.type === 'object') {
+            sampleValue = '"object_unknown"';
+        }
+        else {
+            sampleValue = `"${getSampleValue(schema)}"`;
+        }
+        const desc = schema.description ?? description;
+        return `\n${getIndentSpaces(4)}${desc ? `// ${desc}\n` : ''}${getIndentSpaces(4)}.part("${key}", ${sampleValue});`;
+    };
+    const getHashMapSample = (map, indent = 4) => {
+        const entries = Object.entries(map)
+            .map(([key, value]) => {
+            return `${getIndentSpaces(indent + 2)}("${key}".to_string(), "${value}".to_string())`;
+        })
+            .join(',\n');
+        return `Some(&HashMap::from([\n${entries}\n${getIndentSpaces(4)}]))`;
+    };
+    const getBody = (schema) => {
+        if (isForm(schema)) {
+            return 'form';
+        }
+        return serdeUnwrap(getRsJSONSample(schema));
+    };
+    const handlerNameSnake = toSnakeCase(handlerName);
+    const rpcNameSnake = toSnakeCase(rpcName);
+    const serdeUnwrap = (fake) => `from_value(json!(${fake})).unwrap()`;
+    const RS_CODE = `use ${packageName}::${rpcNameSnake};
+use serde_json::{ 
+  from_value, 
+  json 
+};
+${iterationValidation ? 'use futures_util::StreamExt;\n' : ''}${bodyValidation && isForm(bodyValidation) ? `use reqwest::multipart;\n` : ''}#[tokio::main]
+async fn main() {${bodyValidation && isForm(bodyValidation) ? `\n  ${getRsFormSample(bodyValidation)}\n` : ''}
+  let response = ${rpcNameSnake}::${handlerNameSnake}(
+    ${bodyValidation ? getBody(bodyValidation) : '()'}, /* body */ 
+    ${queryValidation ? serdeUnwrap(getRsJSONSample(queryValidation)) : '()'}, /* query */ 
+    ${paramsValidation ? serdeUnwrap(getRsJSONSample(paramsValidation)) : '()'}, /* params */ 
+    ${config?.headers ? `${getHashMapSample(config.headers)}, /* headers */` : 'None, /* headers (HashMap) */ '}
+    ${config?.apiRoot ? `Some("${config.apiRoot}"), /* api_root */` : 'None, /* api_root */'}
+    false, /* disable_client_validation */
+  ).await;${outputValidation
+        ? `\n\nmatch response {
+    Ok(output) => println!("{:?}", output),
+    /* 
+    output ${getRsOutputSample(outputValidation)} 
+    */
+    Err(e) => println!("error: {:?}", e),
+  }`
+        : ''}${iterationValidation
+        ? `\n\nmatch response {
+    Ok(mut stream) => {
+      let mut i = 0;
+      while let Some(item) = stream.next().await {
+        match item {
+          Ok(value) => {
+            println!("#{}: {:?}", i, value);
+            /*
+            #0: iteration ${getRsOutputSample(iterationValidation, 8)}
+            */
+            i += 1;
+          }
+          Err(e) => {
+            eprintln!("stream error: {:?}", e);
+            break;
+          }
+        }
+      }
+    },
+    Err(e) => println!("Error initiating stream: {:?}", e),
+  }`
+        : ''}
+}`;
+    return RS_CODE.trim();
+}
+export function createCodeSamples({ handlerName, handlerSchema, controllerSchema, package: packageJson, config, }) {
+    const queryValidation = handlerSchema?.validation?.query;
+    const bodyValidation = handlerSchema?.validation?.body;
+    const paramsValidation = handlerSchema?.validation?.params;
+    const outputValidation = handlerSchema?.validation?.output;
+    const iterationValidation = handlerSchema?.validation?.iteration;
+    const hasArg = !!queryValidation || !!bodyValidation || !!paramsValidation || !!config?.apiRoot || !!config?.headers;
+    const rpcName = controllerSchema.rpcModuleName;
+    const packageName = packageJson?.name || 'vovk-client';
+    const packageNameSnake = toSnakeCase(packageName);
+    const pyPackageName = packageJson?.py_name ?? packageNameSnake;
+    const rsPackageName = packageJson?.rs_name ?? packageNameSnake;
+    const commonParams = {
+        handlerName,
+        rpcName,
+        packageName,
+        queryValidation,
+        bodyValidation,
+        paramsValidation,
+        outputValidation,
+        iterationValidation,
+        hasArg,
+        config,
+    };
+    const ts = generateTypeScriptCode(commonParams);
+    const py = generatePythonCode({ ...commonParams, packageName: pyPackageName });
+    const rs = generateRustCode({ ...commonParams, packageName: rsPackageName });
+    return { ts, py, rs };
+}

package/dist/samples/objectToCode.d.ts

@@ -0,0 +1,8 @@
+interface SamplerOptions {
+    stripQuotes?: boolean;
+    indent?: number;
+    nestingIndent?: number;
+    quote?: '"' | "'";
+}
+export declare function objectToCode(obj: unknown, options?: SamplerOptions): string;
+export {};

package/dist/samples/objectToCode.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/schemaToCode.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/schemaToCode.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/schemaToObject.d.ts

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