@camera.ui/browser 0.0.1

package/dist/src/plugins/schema.js

@@ -0,0 +1,717 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createZodArraySchema = exports.createZodObjectSchema = exports.createEnumSchema = exports.createZodBooleanSchema = exports.createZodNumberSchema = exports.createZodStringSchema = exports.isPrimitiveType = exports.isAnyOfSchema = exports.isArrayType = exports.isObjectTypeWithButtons = exports.isObjectType = exports.isEnumType = exports.isBooleanType = exports.isNumberType = exports.isStringType = exports.generateArraySchema = exports.generateObjectSchemaWithButtons = exports.generateObjectSchema = exports.generateEnumSchema = exports.generateStringSchema = exports.genereateBooleanSchema = exports.generateNumberSchema = exports.generateZodSchema = exports.generateZodSchemaFromRoot = exports.getValueByPath = exports.schemaPathToConfigPath = exports.configPathToSchemaPath = exports.removeFunctionsFromSchema = exports.removeFunctionsFromSchemaForm = exports.generateJsonFromSchemaWithConfig = exports.generateJsonFromSchema = exports.generateJsonFromRootSchema = exports.generateSchema = exports.generateRootSchema = void 0;
+const zod_1 = require("zod");
+const validator_1 = __importDefault(require("validator"));
+/**
+ * Generate root JSON schema from value.
+ *
+ * @param value - Value.
+ * @returns - Root JSON schema.
+ */
+const generateRootSchema = (value) => {
+    const schema = {};
+    Object.entries(value).forEach(([key, subValue]) => {
+        schema[key] = (0, exports.generateSchema)(subValue);
+    });
+    return { schema };
+};
+exports.generateRootSchema = generateRootSchema;
+/**
+ * Generate JSON schema from value.
+ *
+ * @param value - Value.
+ * @returns - JSON schema.
+ */
+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/null.html
+        //  */
+        // case value === null:
+        //   return { type: 'null' };
+        /**
+         * @see https://json-schema.org/understanding-json-schema/reference/numeric.html
+         */
+        case typeof value === 'number':
+            return (0, exports.generateNumberSchema)(value);
+        /**
+         * @see https://json-schema.org/understanding-json-schema/reference/boolean.html
+         */
+        case typeof value === 'boolean':
+            return (0, exports.genereateBooleanSchema)(value);
+        /**
+         * @see https://json-schema.org/understanding-json-schema/reference/string.html
+         */
+        case typeof value === 'string':
+            return (0, exports.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 (0, exports.generateEnumSchema)(value, typeof value[0]);
+            }
+            else {
+                return (0, exports.generateArraySchema)(value);
+            }
+        /**
+         * @see https://json-schema.org/understanding-json-schema/reference/object.html
+         */
+        case value instanceof Object:
+            return (0, exports.generateObjectSchema)(value);
+        default:
+            throw new TypeError(`Invalid JSON value: ${value}`);
+    }
+};
+exports.generateSchema = generateSchema;
+/**
+ * Generate a JSON object from a given Root JSON schema.
+ *
+ * @param rootSchema - The Root JSON schema.
+ * @returns - The generated JSON object.
+ */
+const generateJsonFromRootSchema = (rootSchema) => {
+    const jsonObject = {};
+    Object.entries(rootSchema.schema).forEach(([key, jsonSchema]) => {
+        jsonObject[key] = (0, exports.generateJsonFromSchema)(jsonSchema);
+    });
+    return jsonObject;
+};
+exports.generateJsonFromRootSchema = generateJsonFromRootSchema;
+/**
+ * Generate a JSON object from a JSON schema.
+ *
+ * @param jsonSchema - The JSON schema.
+ * @returns - The generated JSON object.
+ */
+const generateJsonFromSchema = (jsonSchema) => {
+    switch (jsonSchema.type) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+            if ((0, exports.isEnumType)(jsonSchema)) {
+                if (jsonSchema.multiple) {
+                    return jsonSchema.defaultValue !== undefined ? [jsonSchema.defaultValue] : undefined;
+                }
+                else {
+                    return jsonSchema.defaultValue ?? jsonSchema.enum[0];
+                }
+            }
+            else if ((0, exports.isStringType)(jsonSchema)) {
+                return jsonSchema.defaultValue;
+            }
+            else if ((0, exports.isNumberType)(jsonSchema)) {
+                return jsonSchema.defaultValue;
+            }
+            else if ((0, exports.isBooleanType)(jsonSchema)) {
+                return jsonSchema.defaultValue ?? false;
+            }
+        case 'object':
+            if (jsonSchema.properties) {
+                return Object.entries(jsonSchema.properties).reduce((obj, [key, value]) => {
+                    obj[key] = (0, exports.generateJsonFromSchema)(value);
+                    return obj;
+                }, {});
+            }
+            return {};
+        case 'array':
+            if (jsonSchema.items) {
+                if ('anyOf' in jsonSchema.items) {
+                    return jsonSchema.items.anyOf.map(exports.generateJsonFromSchema);
+                }
+                else {
+                    return [(0, exports.generateJsonFromSchema)(jsonSchema.items)];
+                }
+            }
+            return [];
+        default:
+            return null;
+    }
+};
+exports.generateJsonFromSchema = generateJsonFromSchema;
+/**
+ * Generate a JSON object from a given JSON schema and use values from a config file.
+ *
+ * @param jsonSchema - The JSON schema.
+ * @param config - The config file with values to use.
+ * @returns - The generated JSON object.
+ */
+const generateJsonFromSchemaWithConfig = (jsonSchema, config, path = '') => {
+    switch (jsonSchema.type) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+            const value = (0, exports.getValueByPath)(config, path);
+            return value !== undefined ? value : (0, exports.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] = (0, exports.generateJsonFromSchemaWithConfig)(schema, config, newPath);
+                    return obj;
+                }, {});
+            }
+            return {};
+        case 'array':
+            if (jsonSchema.items) {
+                const items = jsonSchema.items;
+                const arrayConfig = (0, exports.getValueByPath)(config, path) ?? [];
+                if ((0, exports.isAnyOfSchema)(items)) {
+                    return arrayConfig.map((itemConfig, index) => (0, exports.generateJsonFromSchemaWithConfig)(items.anyOf[index], itemConfig, path + `[${index}]`));
+                }
+                else {
+                    return arrayConfig.map((itemConfig, index) => (0, exports.generateJsonFromSchemaWithConfig)(items, itemConfig, path + `[${index}]`));
+                }
+            }
+            return [];
+        default:
+            return null;
+    }
+};
+exports.generateJsonFromSchemaWithConfig = generateJsonFromSchemaWithConfig;
+/**
+ * Removes all functions from a given Plugin JSON schema form.
+ *
+ * @param schemaForm - The Plugin JSON schema form from which the functions should be removed.
+ * @returns - The Plugin JSON schema form without functions.
+ */
+const removeFunctionsFromSchemaForm = (schemaForm) => {
+    const filteredSchemaForm = {};
+    Object.keys(schemaForm).forEach((key) => {
+        filteredSchemaForm[key] = (0, exports.removeFunctionsFromSchema)(schemaForm[key]);
+    });
+    return filteredSchemaForm;
+};
+exports.removeFunctionsFromSchemaForm = removeFunctionsFromSchemaForm;
+/**
+ * Removes all functions from a given Plugin JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the functions should be removed.
+ * @returns - The JSON schema without functions.
+ */
+const removeFunctionsFromSchema = (jsonSchema) => {
+    const { onSet, onGet, ...rest } = jsonSchema;
+    return rest;
+};
+exports.removeFunctionsFromSchema = removeFunctionsFromSchema;
+/**
+ * Converts a config path to a schema path.
+ *
+ * @param configPath - The config path to be converted.
+ * @returns - The converted schema path.
+ */
+const configPathToSchemaPath = (configPath) => {
+    const pathParts = configPath.split('.');
+    const schemaPathParts = [];
+    pathParts.forEach((part, index) => {
+        const isNumericIndex = /^\d+$/.test(part);
+        const isLastPart = index === pathParts.length - 1;
+        if (isNumericIndex) {
+            schemaPathParts.push('items', 'properties');
+        }
+        else {
+            schemaPathParts.push(part);
+            const isNumericIndex = /^\d+$/.test(pathParts[index + 1]);
+            // if (!isLastPart && isNaN(parseInt(pathParts[index + 1]))) {
+            if (!isLastPart && !isNumericIndex) {
+                schemaPathParts.push('properties');
+            }
+        }
+    });
+    return schemaPathParts.join('.');
+};
+exports.configPathToSchemaPath = configPathToSchemaPath;
+/**
+ * Converts a schema path to a config path.
+ *
+ * @param schemaPath - The schema path to be converted.
+ * @returns - The converted config path.
+ */
+const schemaPathToConfigPath = (schemaPath) => {
+    const pathParts = schemaPath.split('.');
+    const configPathParts = [];
+    pathParts.forEach((part, index) => {
+        // Exclude 'properties' and 'items' keywords from the path
+        if (part !== 'properties' && part !== 'items') {
+            // Check if the part is a numeric index and format it as an array index
+            const isNumericIndex = /^\d+$/.test(part);
+            if (isNumericIndex) {
+                configPathParts.push(`[${part}]`);
+            }
+            else {
+                configPathParts.push(part);
+            }
+        }
+    });
+    return configPathParts.join('.');
+};
+exports.schemaPathToConfigPath = schemaPathToConfigPath;
+/**
+ * Recursively searches a JSON object for a specific, potentially nested key path and returns its value.
+ *
+ * @param obj - The JSON object to be searched.
+ * @param path - The key path to search for.
+ * @returns - The value of the searched key path, if found, otherwise undefined.
+ */
+const getValueByPath = (obj, path) => {
+    const keys = path.split('.').reduce((acc, key) => {
+        if (key.includes('[')) {
+            const [pathKey, index] = key.split('[');
+            acc.push(pathKey, index.slice(0, -1));
+        }
+        else {
+            acc.push(key);
+        }
+        return acc;
+    }, []);
+    let current = obj;
+    for (const key of keys) {
+        if (current === undefined) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+};
+exports.getValueByPath = getValueByPath;
+/**
+ * Generates a Zod schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be generated.
+ * @returns - The generated Zod schema.
+ */
+const generateZodSchemaFromRoot = (rootSchema) => {
+    const zodObjectSchema = {};
+    Object.entries(rootSchema.schema).forEach(([key, jsonSchema]) => {
+        zodObjectSchema[key] = (0, exports.generateZodSchema)(jsonSchema);
+    });
+    return zod_1.z.object(zodObjectSchema).strict();
+};
+exports.generateZodSchemaFromRoot = generateZodSchemaFromRoot;
+/**
+ * Generates a Zod schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be generated.
+ * @param initial - A boolean indicating whether this is the initial call to the function.
+ *                  This is used for handling nested schemas.
+ * @returns - The generated Zod schema.
+ */
+const generateZodSchema = (jsonSchema) => {
+    switch (jsonSchema.type) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+            if ((0, exports.isEnumType)(jsonSchema)) {
+                return (0, exports.createEnumSchema)(jsonSchema);
+            }
+            else if ((0, exports.isStringType)(jsonSchema)) {
+                return (0, exports.createZodStringSchema)(jsonSchema);
+            }
+            else if ((0, exports.isNumberType)(jsonSchema)) {
+                return (0, exports.createZodNumberSchema)(jsonSchema);
+            }
+            else if ((0, exports.isBooleanType)(jsonSchema)) {
+                return (0, exports.createZodBooleanSchema)(jsonSchema);
+            }
+        case 'object':
+            return (0, exports.createZodObjectSchema)(jsonSchema);
+        case 'array':
+            return (0, exports.createZodArraySchema)(jsonSchema);
+    }
+};
+exports.generateZodSchema = generateZodSchema;
+/**
+ * Generates a JSON schema for a number.
+ *
+ * @param value - The number for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the number.
+ */
+const generateNumberSchema = (value) => {
+    // return { type: Number.isInteger(value) ? 'integer' : 'number' };
+    return { type: 'number' };
+};
+exports.generateNumberSchema = generateNumberSchema;
+/**
+ * Generates a JSON schema for a boolean.
+ *
+ * @param value - The boolean for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the boolean.
+ */
+const genereateBooleanSchema = (value) => {
+    return { type: 'boolean' };
+};
+exports.genereateBooleanSchema = genereateBooleanSchema;
+/**
+ * Generates a JSON schema for a string.
+ *
+ * @param value - The string for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the string.
+ */
+const generateStringSchema = (value) => {
+    const stringObject = { type: 'string' };
+    if (validator_1.default.isISO8601(value)) {
+        stringObject.format = value.includes('T') ? 'date-time' : 'date';
+    }
+    if (validator_1.default.isTime(value.split('+')[0], { mode: 'withSeconds' })) {
+        stringObject.format = 'time';
+    }
+    if (validator_1.default.isEmail(value)) {
+        stringObject.format = 'email';
+    }
+    if (validator_1.default.isUUID(value)) {
+        stringObject.format = 'uuid';
+    }
+    if (validator_1.default.isIP(value, 4)) {
+        stringObject.format = 'ipv4';
+    }
+    if (validator_1.default.isIP(value, 6)) {
+        stringObject.format = 'ipv6';
+    }
+    return stringObject;
+};
+exports.generateStringSchema = generateStringSchema;
+/**
+ * Generates a JSON schema for an enum.
+ *
+ * @param value - The enum for which the JSON schema should be generated.
+ * @param type - The type of the enum.
+ * @returns - The generated JSON schema for the enum.
+ */
+const generateEnumSchema = (value, type) => {
+    return { type, enum: value };
+};
+exports.generateEnumSchema = generateEnumSchema;
+/**
+ * Generates a JSON schema for an object.
+ *
+ * @param value - The object for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the object.
+ */
+const generateObjectSchema = (value) => {
+    if (!Object.keys(value).length) {
+        return { type: 'object' };
+    }
+    return {
+        type: 'object',
+        properties: Object.entries(value).reduce((accumulator, [key, value]) => {
+            accumulator[key] = (0, exports.generateSchema)(value);
+            accumulator[key].key = key;
+            accumulator[key].label = accumulator[key].label || `Label for ${key}`;
+            accumulator[key].description = accumulator[key].description || `Description for ${key}`;
+            accumulator[key].required = accumulator[key].required === undefined ? true : accumulator[key].required;
+            accumulator[key].readonly = accumulator[key].readonly || false;
+            return accumulator;
+        }, {}),
+    };
+};
+exports.generateObjectSchema = generateObjectSchema;
+/**
+ * Generates a JSON schema for an object including up to two buttons.
+ *
+ * @param value - The object for which the JSON schema should be generated.
+ * @param buttons - Array of min one button and up to two buttons to be included in the schema.
+ * @returns - The generated JSON schema for the object.
+ */
+const generateObjectSchemaWithButtons = (value, buttons) => {
+    const baseSchema = (0, exports.generateObjectSchema)(value);
+    if (buttons && buttons.length > 0) {
+        const firstButton = buttons[0];
+        const secondButton = buttons[1];
+        if (firstButton) {
+            baseSchema.buttons = [firstButton];
+        }
+        if (secondButton) {
+            baseSchema.buttons = [firstButton, secondButton];
+        }
+    }
+    return baseSchema;
+};
+exports.generateObjectSchemaWithButtons = generateObjectSchemaWithButtons;
+/**
+ * Generates a JSON schema for an array.
+ *
+ * @param array - The array for which the JSON schema should be generated.
+ * @returns - The generated JSON schema for the array.
+ */
+const generateArraySchema = (array) => {
+    if (array.length === 0) {
+        return { type: 'array' };
+    }
+    const allObjects = array.every((item) => typeof item === 'object' && item !== null && !Array.isArray(item));
+    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] = {
+                        ...(0, exports.generateSchema)(value),
+                        required: isRequired,
+                        title: key,
+                        description: `Description for ${key}`,
+                        readonly: false,
+                    };
+                }
+            });
+        });
+        return {
+            type: 'array',
+            items: { type: 'object', properties: schemaProperties },
+        };
+    }
+    else {
+        const uniqueTypes = new Set(array.map((item) => typeof item));
+        if (uniqueTypes.size === 1) {
+            return { type: 'array', items: (0, exports.generateSchema)(array[0]) };
+        }
+        else {
+            const itemSchemas = array.map(exports.generateSchema);
+            return { type: 'array', items: { anyOf: itemSchemas } };
+        }
+    }
+};
+exports.generateArraySchema = generateArraySchema;
+/**
+ * Checks if the given JSON schema is of string type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of string type, false otherwise.
+ */
+const isStringType = (jsonSchema) => {
+    return jsonSchema.type === 'string' && !('enum' in jsonSchema);
+};
+exports.isStringType = isStringType;
+/**
+ * Checks if the given JSON schema is of number type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of number type, false otherwise.
+ */
+const isNumberType = (jsonSchema) => {
+    return jsonSchema.type === 'number' && !('enum' in jsonSchema);
+};
+exports.isNumberType = isNumberType;
+/**
+ * Checks if the given JSON schema is of boolean type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of boolean type, false otherwise.
+ */
+const isBooleanType = (jsonSchema) => {
+    return jsonSchema.type === 'boolean' && !('enum' in jsonSchema);
+};
+exports.isBooleanType = isBooleanType;
+/**
+ * Checks if the given JSON schema is of enum type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of enum type, false otherwise.
+ */
+const isEnumType = (jsonSchema) => {
+    return (jsonSchema.type === 'string' || jsonSchema.type === 'number' || jsonSchema.type === 'boolean') && 'enum' in jsonSchema;
+};
+exports.isEnumType = isEnumType;
+/**
+ * Checks if the given JSON schema is of object type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of object type, false otherwise.
+ */
+const isObjectType = (jsonSchema) => {
+    return jsonSchema.type === 'object';
+};
+exports.isObjectType = isObjectType;
+/**
+ * Checks if the given JSON schema is of object type with buttons.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of object type with buttons, false otherwise.
+ */
+const isObjectTypeWithButtons = (jsonSchema) => {
+    return (0, exports.isObjectType)(jsonSchema) && 'buttons' in jsonSchema;
+};
+exports.isObjectTypeWithButtons = isObjectTypeWithButtons;
+/**
+ * Checks if the given JSON schema is of array type.
+ *
+ * @param jsonSchema - The JSON schema to check.
+ * @returns - True if the JSON schema is of array type, false otherwise.
+ */
+const isArrayType = (jsonSchema) => {
+    return jsonSchema.type === 'array';
+};
+exports.isArrayType = isArrayType;
+/**
+ * Checks if the given value is a JSON AnyOf Schema.
+ *
+ * @param value - The value to check.
+ * @returns - True if the value is a JSON AnyOf schema, false otherwise.
+ */
+const isAnyOfSchema = (value) => {
+    return value && 'anyOf' in value;
+};
+exports.isAnyOfSchema = isAnyOfSchema;
+/**
+ * Checks if the given value is a JSON Primitive schema.
+ *
+ * @param value - The value to check.
+ * @returns - True if the value is a JSON schema, false otherwise.
+ */
+const isPrimitiveType = (value) => {
+    return 'onGet' in value || 'onSet' in value;
+};
+exports.isPrimitiveType = isPrimitiveType;
+/**
+ * Creates a Zod string schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod string schema.
+ */
+const createZodStringSchema = (jsonSchema) => {
+    let schema = zod_1.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) => validator_1.default.isISO8601(value) && value.includes('T'), { message: 'Invalid date-time' });
+                break;
+            case 'date':
+                schema = schema.refine((value) => validator_1.default.isISO8601(value), { message: 'Invalid date' });
+                break;
+            case 'time':
+                schema = schema.refine((value) => validator_1.default.isTime(value.split('+')[0], { mode: 'withSeconds' }), { message: 'Invalid time' });
+                break;
+            case 'email':
+                schema = schema.refine((value) => validator_1.default.isEmail(value), { message: 'Invalid email' });
+                break;
+            case 'uuid':
+                schema = schema.refine((value) => validator_1.default.isUUID(value), { message: 'Invalid uuid' });
+                break;
+            case 'ipv4':
+                schema = schema.refine((value) => validator_1.default.isIP(value, 4), { message: 'Invalid ipv4' });
+                break;
+            case 'ipv6':
+                schema = schema.refine((value) => validator_1.default.isIP(value, 6), { message: 'Invalid ipv6' });
+                break;
+            // case 'password':
+            //   schema = schema.refine((value) => validator.isStrongPassword(value), { message: 'Invalid password' });
+            //   break;
+            // case 'qrCode':
+            //   schema = schema.refine((value) => validator.isBase64(value), { message: 'Invalid qrCode' });
+            //   break;
+        }
+    }
+    return jsonSchema.required ? schema : schema.optional();
+};
+exports.createZodStringSchema = createZodStringSchema;
+/**
+ * Creates a Zod number schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod number schema.
+ */
+const createZodNumberSchema = (jsonSchema) => {
+    let schema = zod_1.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();
+};
+exports.createZodNumberSchema = createZodNumberSchema;
+/**
+ * Creates a Zod boolean schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod boolean schema.
+ */
+const createZodBooleanSchema = (jsonSchema) => {
+    const schema = zod_1.z.boolean();
+    return jsonSchema.required ? schema : schema.optional();
+};
+exports.createZodBooleanSchema = createZodBooleanSchema;
+/**
+ * Creates a Zod union schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod union schema.
+ */
+const createEnumSchema = (jsonSchema) => {
+    const enumValues = jsonSchema.enum.map((item) => zod_1.z.literal(item));
+    const schema = zod_1.z.union(enumValues);
+    if (jsonSchema.multiple) {
+        return jsonSchema.required ? schema.array() : schema.array().optional();
+    }
+    return jsonSchema.required ? schema : schema.optional();
+};
+exports.createEnumSchema = createEnumSchema;
+/**
+ * Creates a Zod object schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod object schema.
+ */
+const createZodObjectSchema = (jsonSchema) => {
+    let schema;
+    if (jsonSchema.properties) {
+        const zodObjectProperties = Object.entries(jsonSchema.properties).reduce((acc, [key, value]) => {
+            acc[key] = (0, exports.generateZodSchema)(value);
+            return acc;
+        }, {});
+        schema = zod_1.z.object(zodObjectProperties).strict();
+    }
+    else {
+        schema = zod_1.z.record(zod_1.z.any());
+    }
+    return jsonSchema.required ? schema : schema.optional();
+};
+exports.createZodObjectSchema = createZodObjectSchema;
+/**
+ * Creates a Zod array schema from a given JSON schema.
+ *
+ * @param jsonSchema - The JSON schema from which the Zod schema should be created.
+ * @returns - The created Zod array schema.
+ */
+const createZodArraySchema = (jsonSchema) => {
+    let schema;
+    if (jsonSchema.items) {
+        if ('anyOf' in jsonSchema.items) {
+            const schemas = jsonSchema.items.anyOf.map((itemSchema) => (0, exports.generateZodSchema)(itemSchema));
+            schema = zod_1.z.union(schemas).array();
+        }
+        else {
+            schema = (0, exports.generateZodSchema)(jsonSchema.items).array();
+        }
+    }
+    else {
+        schema = zod_1.z.any().array();
+    }
+    return jsonSchema.required ? schema : schema.optional();
+};
+exports.createZodArraySchema = createZodArraySchema;
+//# sourceMappingURL=schema.js.map