@camera.ui/server 0.0.49 → 0.0.50-internal.1

package/dist/server/src/plugins/schema.js

@@ -1,420 +1,409 @@
-import { z } from 'zod';
-import { generateJsonFromSchema, getValueByPath, isArrayType, isEnumType, isNumberType, isObjectType, isStringType } from '@camera.ui/plugineer/schema';
-const isISO8601 = (value) => {
-    const iso8601Regex = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/;
-    return iso8601Regex.test(value);
+import { isEqual } from '@camera.ui/common/utils';
+import * as zod from 'zod';
+// Type guards for schema identification
+export const isStringType = (schema) => {
+    return schema.type === 'string' && !('enum' in schema);
 };
-const isTime = (value, options) => {
-    const timeRegex = options.mode === 'withSeconds' ? /^([01]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/ : /^([01]?[0-9]|2[0-3]):([0-5][0-9])$/;
-    return timeRegex.test(value);
+export const isNumberType = (schema) => {
+    return schema.type === 'number';
 };
-const isEmail = (value) => {
-    const emailRegex = /^\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b$/;
-    return emailRegex.test(value);
+export const isBooleanType = (schema) => {
+    return schema.type === 'boolean';
 };
-const isUUID = (value) => {
-    const uuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
-    return uuidRegex.test(value);
+export const isEnumType = (schema) => {
+    return schema.type === 'string' && 'enum' in schema;
 };
-const isIP = (value, version) => {
-    const ipRegex = version === 4 ? /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/ : /^\s*([0-9a-fA-F]{1,4}:){7}([0-9a-fA-F]{1,4})\s*$/;
-    return ipRegex.test(value);
+export const isArrayType = (schema) => {
+    return schema.type === 'array';
 };
-export const generateSchema = (value) => {
-    switch (true) {
-        case value === undefined:
-        case typeof value === 'undefined':
-        case typeof value === 'function':
-        case typeof value === 'symbol':
-        case value instanceof Date:
-            throw new TypeError(`Invalid JSON value: ${String(value)}`);
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/numeric.html
-         */
-        case typeof value === 'number':
-            return generateNumberSchema();
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/boolean.html
-         */
-        case typeof value === 'boolean':
-            return genereateBooleanSchema();
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/string.html
-         */
-        case typeof value === 'string':
-            return generateStringSchema(value);
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/array.html
-         */
-        case Array.isArray(value):
-            const allPrimitives = value.every((item) => typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean');
-            if (allPrimitives) {
-                return generateEnumSchema(value);
-            }
-            else {
-                return generateArraySchema(value);
-            }
-        /**
-         * @see https://json-schema.org/understanding-json-schema/reference/object.html
-         */
-        case value instanceof Object:
-            return generateObjectSchema(value);
-        default:
-            throw new TypeError(`Invalid JSON value: ${value}`);
-    }
+export const isButtonType = (schema) => {
+    return schema.type === 'button';
 };
-export const generateRootSchema = (value) => {
-    const schema = {};
-    Object.entries(value).forEach(([key, subValue]) => {
-        schema[key] = generateSchema(subValue);
-    });
-    return { schema };
+export const isSubmitType = (schema) => {
+    return schema.type === 'submit';
+};
+export const isValidableStringType = (schema) => {
+    return isStringType(schema) && (!schema.format || (schema.format !== 'qrCode' && schema.format !== 'image'));
 };
-export const generateJsonFromSchemaWithConfig = (jsonSchema, config, path = '') => {
-    switch (jsonSchema.type) {
+export const isConfigDefault = (config, schemas) => {
+    // Early exit for empty config
+    if (!config || Object.keys(config).length === 0) {
+        return true; // Empty config is considered default
+    }
+    // Filter out button and submit types as they don't have values
+    const validSchemas = schemas.filter((schema) => !isButtonType(schema) && !isSubmitType(schema));
+    // Check each schema field
+    for (const schema of validSchemas) {
+        const currentValue = getValueByKey(config, schema.key);
+        const defaultValue = generateDefaultValue(schema);
+        // Skip comparison if the field is not in the config
+        if (currentValue === undefined)
+            continue;
+        // Compare values based on type
+        if (!isEqual(currentValue, defaultValue, true)) {
+            return false; // Found a non-default value
+        }
+    }
+    return true; // All values match defaults
+};
+// Generate default value for a schema field
+export const generateDefaultValue = (schema) => {
+    // Return explicit default if provided
+    if ('defaultValue' in schema && schema.defaultValue !== undefined) {
+        return schema.defaultValue;
+    }
+    // Generate default based on type
+    switch (schema.type) {
         case 'string':
+            if (isEnumType(schema)) {
+                return schema.multiple ? [] : schema.required ? schema.enum[0] : '';
+            }
+            return '';
         case 'number':
+            return 0;
         case 'boolean':
-            const value = getValueByPath(config, path);
-            return value !== undefined ? value : generateJsonFromSchema(jsonSchema);
-        case 'object':
-            if (jsonSchema.properties) {
-                return Object.entries(jsonSchema.properties).reduce((obj, [key, schema]) => {
-                    const newPath = path + (path.length > 0 ? '.' : '') + key;
-                    obj[key] = generateJsonFromSchemaWithConfig(schema, config, newPath);
-                    return obj;
-                }, {});
-            }
-            return {};
+            return false;
         case 'array':
-            if (jsonSchema.items) {
-                const items = jsonSchema.items;
-                const arrayConfig = getValueByPath(config, path) ?? [];
-                return arrayConfig.map((itemConfig, index) => generateJsonFromSchemaWithConfig(items, itemConfig, path + `[${index}]`));
-            }
             return [];
         default:
             return undefined;
     }
 };
-export const generateStorableConfig = (jsonSchema, config) => {
-    const newConfig = {};
-    const processSchema = (schema, value) => {
-        if (isObjectType(schema) && schema.properties) {
-            const result = {};
-            Object.entries(schema.properties).forEach(([key, propSchema]) => {
-                const propValue = processSchema(propSchema, value?.[key]);
-                if (propValue !== undefined) {
-                    result[key] = propValue;
-                }
-            });
-            return Object.keys(result).length > 0 ? result : undefined;
-        }
-        else if (isArrayType(schema) && schema.items && Array.isArray(value)) {
-            const result = value.map((item) => processSchema(schema.items, item)).filter((item) => item !== undefined);
-            return result.length > 0 ? result : undefined;
-        }
-        else if (schema.store) {
-            return value;
-        }
-        return undefined;
-    };
-    Object.entries(jsonSchema).forEach(([key, schema]) => {
-        const result = processSchema(schema, config[key]);
-        if (result !== undefined) {
-            newConfig[key] = result;
-        }
-    });
-    return newConfig;
+// Generate a config object from schema definitions
+export const generateConfigFromSchemas = (schemas) => {
+    const config = {};
+    for (const schema of schemas) {
+        // Skip button and submit types as they don't have values
+        if (isButtonType(schema) || isSubmitType(schema))
+            continue;
+        config[schema.key] = generateDefaultValue(schema);
+    }
+    return config;
 };
-export const schemaIsReadonly = (jsonSchema, group) => {
-    if (!group) {
-        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-        return jsonSchema.readonly !== undefined
-            ? jsonSchema.readonly
-            : isObjectType(jsonSchema) && jsonSchema.properties
-                ? Object.values(jsonSchema.properties).some((property) => schemaIsReadonly(property))
-                : isArrayType(jsonSchema) && jsonSchema.items
-                    ? schemaIsReadonly(jsonSchema.items)
-                    : false;
+// Get value from config by key
+export const getValueByKey = (config = {}, key) => {
+    // For simple keys without nesting
+    if (!key.includes('.') && !key.includes('[')) {
+        return config[key];
     }
-    else {
-        if (!jsonSchema.group || jsonSchema.group !== group) {
-            return true;
-        }
-        if (jsonSchema.group === group) {
-            if (isObjectType(jsonSchema) && jsonSchema.properties) {
-                const groupedSchema = Object.values(jsonSchema.properties);
-                return groupedSchema.every((property) => schemaIsReadonly(property));
-            }
-            else if (isArrayType(jsonSchema) && jsonSchema.items) {
-                return schemaIsReadonly(jsonSchema.items, group);
-            }
-            return jsonSchema.readonly ?? false;
+    // For nested keys or array access
+    const keys = key.split('.').reduce((acc, part) => {
+        if (part.includes('[')) {
+            const [keyPart, indexPart] = part.split('[');
+            acc.push(keyPart, indexPart.slice(0, -1)); // Remove closing bracket
         }
-        else if (isObjectType(jsonSchema) && jsonSchema.properties) {
-            const groupedSchema = Object.values(jsonSchema.properties).filter((property) => property.group === group);
-            return groupedSchema.every((property) => schemaIsReadonly(property, group));
+        else {
+            acc.push(part);
         }
-        else if (isArrayType(jsonSchema) && jsonSchema.items) {
-            return schemaIsReadonly(jsonSchema.items, group);
+        return acc;
+    }, []);
+    let current = config;
+    for (const k of keys) {
+        if (current === undefined || current === null) {
+            return undefined;
         }
-        return false;
+        current = current[k];
     }
+    return current;
 };
-export const schemaIsStorable = (jsonSchema, group) => {
-    if (!group) {
-        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-        return jsonSchema.store !== undefined
-            ? jsonSchema.store
-            : isObjectType(jsonSchema) && jsonSchema.properties
-                ? Object.values(jsonSchema.properties).some((property) => schemaIsStorable(property))
-                : isArrayType(jsonSchema) && jsonSchema.items
-                    ? schemaIsStorable(jsonSchema.items)
-                    : false;
+// Set value in config by key
+export const setValueByKey = (config, key, value) => {
+    // For simple keys without nesting
+    if (!key.includes('.') && !key.includes('[')) {
+        config[key] = value;
+        return;
     }
-    else {
-        if (!jsonSchema.group || jsonSchema.group !== group) {
-            return false;
+    // For nested keys or array access
+    const keys = key.split('.').reduce((acc, part) => {
+        if (part.includes('[')) {
+            const [keyPart, indexPart] = part.split('[');
+            acc.push(keyPart, indexPart.slice(0, -1)); // Remove closing bracket
         }
-        if (jsonSchema.group === group) {
-            if (isObjectType(jsonSchema) && jsonSchema.properties) {
-                const groupedSchema = Object.values(jsonSchema.properties);
-                return groupedSchema.some((property) => schemaIsStorable(property));
-            }
-            else if (isArrayType(jsonSchema) && jsonSchema.items) {
-                return schemaIsStorable(jsonSchema.items, group);
-            }
-            return jsonSchema.store ?? false;
-        }
-        else if (isObjectType(jsonSchema) && jsonSchema.properties) {
-            const groupedSchema = Object.values(jsonSchema.properties).filter((property) => property.group === group);
-            return groupedSchema.some((property) => schemaIsStorable(property));
+        else {
+            acc.push(part);
         }
-        else if (isArrayType(jsonSchema) && jsonSchema.items) {
-            return schemaIsStorable(jsonSchema.items, group);
+        return acc;
+    }, []);
+    const lastKey = keys.pop();
+    if (!lastKey)
+        return;
+    let current = config;
+    for (const k of keys) {
+        if (current[k] === undefined || current[k] === null) {
+            // Create object or array as needed
+            const nextKey = keys[keys.indexOf(k) + 1];
+            current[k] = !isNaN(Number(nextKey)) ? [] : {};
         }
-        return false;
+        current = current[k];
     }
+    current[lastKey] = value;
 };
-export const generateZodSchemaFromRoot = (rootSchema) => {
-    const zodObjectSchema = {};
-    Object.entries(rootSchema.schema).forEach(([key, jsonSchema]) => {
-        zodObjectSchema[key] = generateZodSchema(jsonSchema);
-    });
-    return z.object(zodObjectSchema).strict();
+// Find schema by key
+export const findSchemaByKey = (schemas, key) => {
+    return schemas.find((schema) => schema.key === key);
 };
-export const generateZodSchema = (jsonSchema) => {
-    switch (jsonSchema.type) {
-        case 'string':
-        case 'number':
-        case 'boolean':
-            if (isEnumType(jsonSchema)) {
-                return createEnumSchema(jsonSchema);
-            }
-            else if (isStringType(jsonSchema)) {
-                return createZodStringSchema(jsonSchema);
-            }
-            else if (isNumberType(jsonSchema)) {
-                return createZodNumberSchema(jsonSchema);
-            }
-            else {
-                return createZodBooleanSchema(jsonSchema);
-            }
-        case 'object':
-            return createZodObjectSchema(jsonSchema);
-        case 'array':
-            return createZodArraySchema(jsonSchema);
-        case 'button':
-            return z.any();
+// Remove callback functions from schema - useful for serialization
+export const removeCallbacksFromSchema = (schema) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { onSet, onGet, onClick, ...rest } = schema;
+    if (isArrayType(rest) && rest.items) {
+        rest.items = removeCallbacksFromSchema(rest.items);
     }
+    return rest;
 };
-export const generateNumberSchema = () => {
-    // return { type: Number.isInteger(value) ? 'integer' : 'number' };
-    return { type: 'number' };
-};
-export const genereateBooleanSchema = () => {
-    return { type: 'boolean' };
+// Remove callbacks from all schemas
+export const removeCallbacksFromSchemas = (schemas) => {
+    return schemas.map((schema) => removeCallbacksFromSchema(schema));
 };
-export const generateStringSchema = (value) => {
-    const stringObject = { type: 'string' };
-    if (isISO8601(value)) {
-        stringObject.format = value.includes('T') ? 'date-time' : 'date';
-    }
-    if (isTime(value.split('+')[0], { mode: 'withSeconds' })) {
-        stringObject.format = 'time';
-    }
-    if (isEmail(value)) {
-        stringObject.format = 'email';
-    }
-    if (isUUID(value)) {
-        stringObject.format = 'uuid';
-    }
-    if (isIP(value, 4)) {
-        stringObject.format = 'ipv4';
-    }
-    if (isIP(value, 6)) {
-        stringObject.format = 'ipv6';
+// Generate storable config (only include fields with store: true)
+export const generateStorableConfig = (schemas, config) => {
+    const storableConfig = {};
+    for (const schema of schemas) {
+        if ('store' in schema && schema.store && !isButtonType(schema) && !isSubmitType(schema)) {
+            const value = getValueByKey(config, schema.key);
+            if (value !== undefined) {
+                storableConfig[schema.key] = value;
+            }
+        }
     }
-    return stringObject;
+    return storableConfig;
 };
-export const generateEnumSchema = (value) => {
-    return { type: 'string', enum: value.map((item) => item.toString()) };
+// Check if schema fields have a specific group
+export const getSchemasByGroup = (schemas, group) => {
+    if (!group)
+        return schemas;
+    return schemas.filter((schema) => 'group' in schema && schema.group === group);
 };
-export const generateObjectSchema = (value) => {
-    if (!Object.keys(value).length) {
-        return { type: 'object' };
-    }
-    const properties = {};
-    Object.entries(value).forEach(([key, value]) => {
-        const schema = generateSchema(value);
-        schema.key = key;
-        schema.description = schema.description ?? `Description for ${key}`;
-        schema.required = schema.required ?? true;
-        schema.readonly = schema.readonly ?? false;
-        properties[key] = schema;
-    });
-    return { type: 'object', properties };
+// Check if all schemas in a group are readonly
+export const schemaGroupIsReadonly = (schemas, group) => {
+    const groupSchemas = getSchemasByGroup(schemas, group);
+    return groupSchemas.length > 0 && groupSchemas.every((schema) => 'readonly' in schema && schema.readonly);
 };
-export const generateObjectSchemaWithButtons = (value, buttons) => {
-    const baseSchema = {
-        ...generateObjectSchema(value),
-        buttons: buttons,
+// Check if any schema in a group is storable
+export const schemaGroupIsStorable = (schemas, group) => {
+    const groupSchemas = getSchemasByGroup(schemas, group);
+    return groupSchemas.length > 0 && groupSchemas.some((schema) => 'store' in schema && schema.store);
+};
+// Format validation for string types
+export const isValidFormat = (value, format) => {
+    if (!format)
+        return true;
+    const validations = {
+        'date-time': (val) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d+)?(Z|[+-]\d{2}:\d{2})?$/.test(val),
+        date: (val) => /^\d{4}-\d{2}-\d{2}$/.test(val),
+        time: (val) => /^([01]?[0-9]|2[0-3]):([0-5][0-9])(:([0-5][0-9]))?$/.test(val),
+        email: (val) => /^\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b$/.test(val),
+        uuid: (val) => /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/.test(val),
+        ipv4: (val) => /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(val),
+        ipv6: (val) => /^\s*([0-9a-fA-F]{1,4}:){7}([0-9a-fA-F]{1,4})\s*$/.test(val),
+        // Add more validations as needed
     };
-    return baseSchema;
+    return format in validations ? validations[format](value) : true;
 };
-export const generateArraySchema = (array) => {
-    if (array.length === 0) {
-        return { type: 'array' };
+// Validate a value against a schema
+export const validateValue = (value, schema) => {
+    if (isButtonType(schema) || isSubmitType(schema))
+        return true;
+    // Check required fields
+    if ('required' in schema && schema.required && (value === undefined || value === null || value === '')) {
+        return false;
     }
-    const allObjects = array.every((item) => typeof item === 'object' && item !== null && !Array.isArray(item));
-    const allStrings = array.every((item) => typeof item === 'string');
-    const allNumbers = array.every((item) => typeof item === 'number');
-    if (allObjects) {
-        const schemaProperties = {};
-        const keyPresenceCount = {};
-        // Gather all keys and their presence count
-        array.forEach((obj) => {
-            Object.keys(obj).forEach((key) => {
-                keyPresenceCount[key] = (keyPresenceCount[key] || 0) + 1;
-            });
-        });
-        array.forEach((obj) => {
-            Object.entries(obj).forEach(([key, value]) => {
-                if (!schemaProperties[key]) {
-                    const isRequired = keyPresenceCount[key] === array.length;
-                    schemaProperties[key] = {
-                        ...generateSchema(value),
-                        required: isRequired,
-                        title: key,
-                        description: `Description for ${key}`,
-                        readonly: false,
-                    };
+    switch (schema.type) {
+        case 'string':
+            if (isEnumType(schema)) {
+                if (schema.multiple) {
+                    return Array.isArray(value) && value.every((v) => schema.enum.includes(v));
                 }
-            });
-        });
-        return {
-            type: 'array',
-            items: { type: 'object', properties: schemaProperties },
-        };
-    }
-    else if (allStrings) {
-        return { type: 'array', items: { type: 'string' } };
-    }
-    else if (allNumbers) {
-        return { type: 'array', items: { type: 'number' } };
-    }
-    else {
-        return { type: 'array', items: { type: 'boolean' } };
+                else {
+                    return schema.enum.includes(value);
+                }
+            }
+            else {
+                if (typeof value !== 'string')
+                    return false;
+                if (schema.minLength !== undefined && value.length < schema.minLength)
+                    return false;
+                if (schema.maxLength !== undefined && value.length > schema.maxLength)
+                    return false;
+                if (schema.format)
+                    return isValidFormat(value, schema.format);
+                return true;
+            }
+        case 'number':
+            if (typeof value !== 'number')
+                return false;
+            if (schema.minimum !== undefined && value < schema.minimum)
+                return false;
+            if (schema.maximum !== undefined && value > schema.maximum)
+                return false;
+            return true;
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'array':
+            if (!Array.isArray(value))
+                return false;
+            return value.every((item) => validateValue(item, schema.items));
+        default:
+            return true;
     }
 };
-export const createZodStringSchema = (jsonSchema) => {
-    let schema = z.string();
-    if (jsonSchema.required)
-        schema = schema.nonempty('Required');
-    if (jsonSchema.minLength !== undefined)
-        schema = schema.min(jsonSchema.minLength);
-    if (jsonSchema.maxLength !== undefined)
-        schema = schema.max(jsonSchema.maxLength);
-    if (jsonSchema.format) {
-        switch (jsonSchema.format) {
-            case 'date-time':
-                schema = schema.refine((value) => isISO8601(value) && value.includes('T'), { message: 'Invalid date-time' });
-                break;
-            case 'date':
-                schema = schema.refine((value) => isISO8601(value), { message: 'Invalid date' });
-                break;
-            case 'time':
-                schema = schema.refine((value) => isTime(value.split('+')[0], { mode: 'withSeconds' }), { message: 'Invalid time' });
-                break;
-            case 'email':
-                schema = schema.refine((value) => isEmail(value), { message: 'Invalid email' });
-                break;
-            case 'uuid':
-                schema = schema.refine((value) => isUUID(value), { message: 'Invalid uuid' });
-                break;
-            case 'ipv4':
-                schema = schema.refine((value) => isIP(value, 4), { message: 'Invalid ipv4' });
-                break;
-            case 'ipv6':
-                schema = schema.refine((value) => isIP(value, 6), { message: 'Invalid ipv6' });
-                break;
-            // case 'password':
-            //   schema = schema.refine((value) => isStrongPassword(value), { message: 'Invalid password' });
-            //   break;
-            // case 'qrCode':
-            //   schema = schema.refine((value) => isBase64(value), { message: 'Invalid qrCode' });
-            //   break;
+// Validate entire config against schema
+export const validateConfig = (config, schemas) => {
+    const errors = {};
+    for (const schema of schemas) {
+        // Skip button and submit types
+        if (isButtonType(schema) || isSubmitType(schema))
+            continue;
+        const value = getValueByKey(config, schema.key);
+        const fieldErrors = [];
+        // Required field check
+        if ('required' in schema && schema.required && (value === undefined || value === null || value === '')) {
+            fieldErrors.push('This field is required');
+        }
+        // Type-specific validation
+        if (value !== undefined && value !== null) {
+            if (isStringType(schema)) {
+                if (typeof value !== 'string') {
+                    fieldErrors.push('Value must be a string');
+                }
+                else {
+                    if (schema.minLength !== undefined && value.length < schema.minLength) {
+                        fieldErrors.push(`Minimum length is ${schema.minLength}`);
+                    }
+                    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+                        fieldErrors.push(`Maximum length is ${schema.maxLength}`);
+                    }
+                    if (schema.format && !isValidFormat(value, schema.format)) {
+                        fieldErrors.push(`Invalid ${schema.format} format`);
+                    }
+                }
+            }
+            else if (isNumberType(schema)) {
+                if (typeof value !== 'number') {
+                    fieldErrors.push('Value must be a number');
+                }
+                else {
+                    if (schema.minimum !== undefined && value < schema.minimum) {
+                        fieldErrors.push(`Minimum value is ${schema.minimum}`);
+                    }
+                    if (schema.maximum !== undefined && value > schema.maximum) {
+                        fieldErrors.push(`Maximum value is ${schema.maximum}`);
+                    }
+                }
+            }
+            else if (isBooleanType(schema)) {
+                if (typeof value !== 'boolean') {
+                    fieldErrors.push('Value must be a boolean');
+                }
+            }
+            else if (isEnumType(schema)) {
+                if (schema.multiple) {
+                    if (!Array.isArray(value)) {
+                        fieldErrors.push('Value must be an array');
+                    }
+                    else if (!value.every((v) => schema.enum.includes(v))) {
+                        fieldErrors.push('Invalid selection');
+                    }
+                }
+                else if (!schema.enum.includes(value)) {
+                    fieldErrors.push('Invalid selection');
+                }
+            }
+            else if (isArrayType(schema)) {
+                if (!Array.isArray(value)) {
+                    fieldErrors.push('Value must be an array');
+                }
+                else {
+                    value.forEach((item, index) => {
+                        if (!validateValue(item, schema.items)) {
+                            fieldErrors.push(`Invalid item at index ${index}`);
+                        }
+                    });
+                }
+            }
+        }
+        if (fieldErrors.length > 0) {
+            errors[schema.key] = fieldErrors;
         }
     }
-    return jsonSchema.required ? schema : schema.optional();
-};
-export const createZodNumberSchema = (jsonSchema) => {
-    let schema = z.number();
-    if (jsonSchema.minimum !== undefined)
-        schema = schema.min(jsonSchema.minimum);
-    if (jsonSchema.maximum !== undefined)
-        schema = schema.max(jsonSchema.maximum);
-    if (jsonSchema.required)
-        schema = schema.refine((value) => value !== undefined && typeof value === 'number', { message: 'Required' });
-    return jsonSchema.required ? schema : schema.optional();
-};
-export const createZodBooleanSchema = (jsonSchema) => {
-    const schema = z.boolean();
-    return jsonSchema.required ? schema : schema.optional();
-};
-export const createEnumSchema = (jsonSchema) => {
-    const enumValues = jsonSchema.enum.map((item) => (jsonSchema.required ? z.literal(item) : z.literal(item).optional()));
-    const schema = jsonSchema.required
-        ? z.union(enumValues)
-        : z.any().transform((val) => (!val || val === '' || !jsonSchema.enum.some((v) => v === val) ? undefined : val));
-    if (jsonSchema.multiple) {
-        return jsonSchema.required ? schema.array() : schema.array().optional();
-    }
-    return jsonSchema.required ? schema : schema.optional();
+    return errors;
 };
-export const createZodObjectSchema = (jsonSchema) => {
-    let schema;
-    if (jsonSchema.properties) {
-        const zodObjectProperties = Object.entries(jsonSchema.properties).reduce((acc, [key, value]) => {
-            acc[key] = generateZodSchema(value);
-            return acc;
-        }, {});
-        schema = z.object(zodObjectProperties).strict();
+// Generate a Zod schema for a single JSON schema field
+export const generateZodSchemaField = (schema) => {
+    // Skip validation for button and submit types
+    if (isButtonType(schema) || isSubmitType(schema)) {
+        return zod.any();
     }
-    else {
-        schema = z.record(z.any());
+    // Build schema based on type
+    switch (schema.type) {
+        case 'string':
+            // Handle enum type
+            if (isEnumType(schema)) {
+                if (schema.multiple) {
+                    // Multiple selection
+                    let arraySchema = zod.array(zod.string().refine((val) => schema.enum.includes(val), { message: 'Invalid selection' }));
+                    if (schema.required) {
+                        arraySchema = arraySchema.min(1, { message: 'Required' });
+                    }
+                    return schema.required ? arraySchema : arraySchema.optional();
+                }
+                else {
+                    // Single selection
+                    const enumSchema = zod.enum(schema.enum);
+                    return schema.required ? enumSchema : enumSchema.optional();
+                }
+            }
+            // Regular string
+            let strSchema = zod.string();
+            // Add validation for required fields
+            if (schema.required) {
+                strSchema = strSchema.nonempty('Required');
+            }
+            // Add length validations
+            if (schema.minLength !== undefined) {
+                strSchema = strSchema.min(schema.minLength);
+            }
+            if (schema.maxLength !== undefined) {
+                strSchema = strSchema.max(schema.maxLength);
+            }
+            // Add validation for format
+            if (schema.format) {
+                strSchema = strSchema.refine((val) => !val || val.trim() === '' || isValidFormat(val, schema.format), {
+                    message: `Invalid ${schema.format} format`,
+                });
+            }
+            return schema.required ? strSchema : strSchema.optional();
+        case 'number':
+            let numSchema = zod.number();
+            if (schema.minimum !== undefined) {
+                numSchema = numSchema.min(schema.minimum);
+            }
+            if (schema.maximum !== undefined) {
+                numSchema = numSchema.max(schema.maximum);
+            }
+            if (schema.required) {
+                numSchema = numSchema.refine((val) => val !== undefined && val !== null, { message: 'Required' });
+            }
+            return schema.required ? numSchema : numSchema.optional();
+        case 'boolean':
+            return schema.required ? zod.boolean() : zod.boolean().optional();
+        case 'array':
+            const schemaItems = generateZodSchemaField(schema.items);
+            const arraySchema = zod.array(schemaItems);
+            return schema.required ? arraySchema : arraySchema.optional();
+        default:
+            return schema.required ? zod.any() : zod.any().optional();
     }
-    return jsonSchema.required ? schema : schema.optional();
 };
-export const createZodArraySchema = (jsonSchema) => {
-    let schema;
-    if (jsonSchema.items) {
-        schema = generateZodSchema(jsonSchema.items).array();
-    }
-    else {
-        schema = z.any().array();
-    }
-    return jsonSchema.required ? schema : schema.optional();
+// // Generate a complete Zod schema from an array of JSON schemas
+export const generateZodSchema = (schemas) => {
+    const zodSchemaObj = {};
+    schemas.forEach((schema) => {
+        // Skip button and submit types as they don't need validation
+        if (!isButtonType(schema) && !isSubmitType(schema)) {
+            zodSchemaObj[schema.key] = generateZodSchemaField(schema);
+        }
+    });
+    return zod.object(zodSchemaObj);
 };
 //# sourceMappingURL=schema.js.map