@uipath/apollo-wind 0.7.2-pr188.4865fad

package/dist/components/forms/schema-serializer.js

@@ -0,0 +1,213 @@
+function serializeOptions(options) {
+    return options.map((opt)=>({
+            label: opt.label,
+            value: opt.value,
+            ...void 0 !== opt.disabled && {
+                disabled: opt.disabled
+            }
+        }));
+}
+function serializeValidationConfig(config) {
+    const result = {};
+    if (void 0 !== config.required) result.required = config.required;
+    if (void 0 !== config.minLength) result.minLength = config.minLength;
+    if (void 0 !== config.maxLength) result.maxLength = config.maxLength;
+    if (void 0 !== config.pattern) result.pattern = config.pattern;
+    if (void 0 !== config.email) result.email = config.email;
+    if (void 0 !== config.url) result.url = config.url;
+    if (void 0 !== config.min) result.min = config.min;
+    if (void 0 !== config.max) result.max = config.max;
+    if (void 0 !== config.integer) result.integer = config.integer;
+    if (void 0 !== config.positive) result.positive = config.positive;
+    if (void 0 !== config.negative) result.negative = config.negative;
+    if (void 0 !== config.minItems) result.minItems = config.minItems;
+    if (void 0 !== config.maxItems) result.maxItems = config.maxItems;
+    if (void 0 !== config.maxFileSize) result.maxFileSize = config.maxFileSize;
+    if (void 0 !== config.allowedTypes) result.allowedTypes = config.allowedTypes;
+    if (void 0 !== config.custom) result.custom = config.custom;
+    if (config.messages && Object.keys(config.messages).length > 0) {
+        const messages = {};
+        const m = config.messages;
+        if (m.required) messages.required = m.required;
+        if (m.minLength) messages.minLength = m.minLength;
+        if (m.maxLength) messages.maxLength = m.maxLength;
+        if (m.pattern) messages.pattern = m.pattern;
+        if (m.min) messages.min = m.min;
+        if (m.max) messages.max = m.max;
+        if (m.email) messages.email = m.email;
+        if (m.url) messages.url = m.url;
+        if (m.integer) messages.integer = m.integer;
+        if (m.positive) messages.positive = m.positive;
+        if (m.negative) messages.negative = m.negative;
+        if (m.minItems) messages.minItems = m.minItems;
+        if (m.maxItems) messages.maxItems = m.maxItems;
+        if (m.custom) messages.custom = m.custom;
+        if (Object.keys(messages).length > 0) result.messages = messages;
+    }
+    return result;
+}
+function serializeActions(actions) {
+    return actions.map((action)=>({
+            id: action.id,
+            type: action.type,
+            label: action.label,
+            ...action.variant && {
+                variant: action.variant
+            },
+            ...void 0 !== action.loading && {
+                loading: action.loading
+            },
+            ...void 0 !== action.disabled && {
+                disabled: action.disabled
+            },
+            ...action.conditions && {
+                conditions: action.conditions.map(serializeCondition)
+            }
+        }));
+}
+function serializeCondition(condition) {
+    const result = {
+        when: condition.when
+    };
+    if (void 0 !== condition.is) result.is = condition.is;
+    if (void 0 !== condition.isNot) result.isNot = condition.isNot;
+    if (void 0 !== condition.in) result.in = condition.in;
+    if (void 0 !== condition.notIn) result.notIn = condition.notIn;
+    if (void 0 !== condition.matches) result.matches = condition.matches;
+    if (void 0 !== condition.custom) result.custom = condition.custom;
+    return result;
+}
+function serializeRule(rule) {
+    const result = {
+        id: rule.id,
+        conditions: rule.conditions.map(serializeCondition)
+    };
+    if (rule.operator && 'AND' !== rule.operator) result.operator = rule.operator;
+    const effects = {};
+    if (void 0 !== rule.effects.visible) effects.visible = rule.effects.visible;
+    if (void 0 !== rule.effects.disabled) effects.disabled = rule.effects.disabled;
+    if (void 0 !== rule.effects.required) effects.required = rule.effects.required;
+    if (void 0 !== rule.effects.value) effects.value = rule.effects.value;
+    if (rule.effects.validate) effects.validate = serializeValidationConfig(rule.effects.validate);
+    if (rule.effects.options) effects.options = serializeDataSource(rule.effects.options);
+    result.effects = effects;
+    return result;
+}
+function serializeDataSource(dataSource) {
+    switch(dataSource.type){
+        case 'static':
+            return {
+                type: 'static',
+                options: serializeOptions(dataSource.options)
+            };
+        case 'fetch':
+            return {
+                type: 'fetch',
+                url: dataSource.url,
+                ...dataSource.method && {
+                    method: dataSource.method
+                },
+                ...dataSource.transform && {
+                    transform: dataSource.transform
+                },
+                ...dataSource.params && {
+                    params: dataSource.params
+                }
+            };
+        case 'remote':
+            return {
+                type: 'remote',
+                endpoint: dataSource.endpoint,
+                ...dataSource.method && {
+                    method: dataSource.method
+                },
+                ...dataSource.params && {
+                    params: dataSource.params
+                },
+                ...dataSource.transform && {
+                    transform: dataSource.transform
+                }
+            };
+        case 'computed':
+            return {
+                type: 'computed',
+                dependency: dataSource.dependency,
+                compute: dataSource.compute
+            };
+    }
+}
+function serializeField(field) {
+    const result = {
+        name: field.name,
+        type: field.type,
+        label: field.label
+    };
+    if (field.placeholder) result.placeholder = field.placeholder;
+    if (field.description) result.description = field.description;
+    if (void 0 !== field.defaultValue) result.defaultValue = field.defaultValue;
+    if (field.validation) result.validation = serializeValidationConfig(field.validation);
+    if (field.dataSource) result.dataSource = serializeDataSource(field.dataSource);
+    if (field.rules && field.rules.length > 0) result.rules = field.rules.map(serializeRule);
+    if (field.grid) result.grid = field.grid;
+    if (field.ariaLabel) result.ariaLabel = field.ariaLabel;
+    if (field.ariaDescribedBy) result.ariaDescribedBy = field.ariaDescribedBy;
+    if ('options' in field && field.options) result.options = serializeOptions(field.options);
+    if ('rows' in field && field.rows) result.rows = field.rows;
+    if ('min' in field && void 0 !== field.min) result.min = field.min;
+    if ('max' in field && void 0 !== field.max) result.max = field.max;
+    if ('step' in field && void 0 !== field.step) result.step = field.step;
+    if ('maxSelected' in field && field.maxSelected) result.maxSelected = field.maxSelected;
+    if ('accept' in field && field.accept) result.accept = field.accept;
+    if ('multiple' in field && field.multiple) result.multiple = field.multiple;
+    if ('maxSize' in field && field.maxSize) result.maxSize = field.maxSize;
+    if ('showPreview' in field && field.showPreview) result.showPreview = field.showPreview;
+    if ('use12Hour' in field && field.use12Hour) result.use12Hour = field.use12Hour;
+    if ('component' in field && field.component) result.component = field.component;
+    if ('componentProps' in field && field.componentProps) result.componentProps = field.componentProps;
+    return result;
+}
+function serializeSection(section) {
+    const result = {
+        id: section.id,
+        fields: section.fields.map(serializeField)
+    };
+    if (section.title) result.title = section.title;
+    if (section.description) result.description = section.description;
+    if (void 0 !== section.collapsible) result.collapsible = section.collapsible;
+    if (void 0 !== section.defaultExpanded) result.defaultExpanded = section.defaultExpanded;
+    if (section.conditions && section.conditions.length > 0) result.conditions = section.conditions.map(serializeCondition);
+    return result;
+}
+function serializeStep(step) {
+    const result = {
+        id: step.id,
+        title: step.title,
+        sections: step.sections.map(serializeSection)
+    };
+    if (step.description) result.description = step.description;
+    if (step.validation) result.validation = step.validation;
+    if (void 0 !== step.canSkip) result.canSkip = step.canSkip;
+    if (step.conditions && step.conditions.length > 0) result.conditions = step.conditions.map(serializeCondition);
+    return result;
+}
+function serializeSchema(schema) {
+    const result = {
+        id: schema.id,
+        title: schema.title
+    };
+    if (schema.description) result.description = schema.description;
+    if (schema.version) result.version = schema.version;
+    if (schema.initialData) result.initialData = schema.initialData;
+    if (schema.mode) result.mode = schema.mode;
+    if (schema.reValidateMode) result.reValidateMode = schema.reValidateMode;
+    if (schema.actions && schema.actions.length > 0) result.actions = serializeActions(schema.actions);
+    if (schema.layout) result.layout = schema.layout;
+    if (schema.metadata) result.metadata = schema.metadata;
+    if ('sections' in schema && schema.sections) result.sections = schema.sections.map(serializeSection);
+    if ('steps' in schema && schema.steps) result.steps = schema.steps.map(serializeStep);
+    return result;
+}
+function schemaToJson(schema, indent = 2) {
+    return JSON.stringify(serializeSchema(schema), null, indent);
+}
+export { schemaToJson, serializeSchema };

package/dist/components/forms/schema-viewer.cjs

@@ -0,0 +1,157 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    withSchemaViewer: ()=>withSchemaViewer,
+    FormWithSchemaViewer: ()=>FormWithSchemaViewer,
+    SchemaViewer: ()=>SchemaViewer
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const external_lucide_react_namespaceObject = require("lucide-react");
+const external_sonner_namespaceObject = require("sonner");
+const external_schema_serializer_cjs_namespaceObject = require("./schema-serializer.cjs");
+const button_cjs_namespaceObject = require("../ui/button.cjs");
+const sheet_cjs_namespaceObject = require("../ui/sheet.cjs");
+const scroll_area_cjs_namespaceObject = require("../ui/scroll-area.cjs");
+function SchemaViewer({ schema, triggerLabel = 'View Schema' }) {
+    const [copied, setCopied] = (0, external_react_namespaceObject.useState)(false);
+    const jsonString = (0, external_schema_serializer_cjs_namespaceObject.schemaToJson)(schema);
+    const handleCopy = async ()=>{
+        try {
+            await navigator.clipboard.writeText(jsonString);
+            setCopied(true);
+            external_sonner_namespaceObject.toast.success('Schema copied to clipboard');
+            setTimeout(()=>setCopied(false), 2000);
+        } catch  {
+            external_sonner_namespaceObject.toast.error('Failed to copy schema');
+        }
+    };
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(sheet_cjs_namespaceObject.Sheet, {
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(sheet_cjs_namespaceObject.SheetTrigger, {
+                asChild: true,
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(button_cjs_namespaceObject.Button, {
+                    variant: "outline",
+                    size: "sm",
+                    className: "gap-2",
+                    children: [
+                        /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_lucide_react_namespaceObject.Code2, {
+                            className: "h-4 w-4"
+                        }),
+                        triggerLabel
+                    ]
+                })
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(sheet_cjs_namespaceObject.SheetContent, {
+                side: "right",
+                className: "w-full sm:max-w-2xl",
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(sheet_cjs_namespaceObject.SheetHeader, {
+                        children: [
+                            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(sheet_cjs_namespaceObject.SheetTitle, {
+                                className: "flex items-center gap-2",
+                                children: [
+                                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                                        children: "Schema JSON"
+                                    }),
+                                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(button_cjs_namespaceObject.Button, {
+                                        variant: "outline",
+                                        size: "sm",
+                                        onClick: handleCopy,
+                                        className: "gap-2",
+                                        children: [
+                                            copied ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_lucide_react_namespaceObject.Check, {
+                                                className: "h-4 w-4"
+                                            }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_lucide_react_namespaceObject.Copy, {
+                                                className: "h-4 w-4"
+                                            }),
+                                            copied ? 'Copied!' : 'Copy'
+                                        ]
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(sheet_cjs_namespaceObject.SheetDescription, {
+                                children: "JSON representation of the form schema."
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(scroll_area_cjs_namespaceObject.ScrollArea, {
+                        className: "mt-4 h-[calc(100vh-10rem)] rounded-md border bg-muted/50",
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("pre", {
+                            className: "p-2 text-sm font-mono whitespace-pre-wrap break-words",
+                            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("code", {
+                                children: jsonString
+                            })
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+function withSchemaViewer(WrappedComponent) {
+    return function(props) {
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+            className: "space-y-4",
+            children: [
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+                    className: "flex justify-end",
+                    children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SchemaViewer, {
+                        schema: props.schema
+                    })
+                }),
+                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(WrappedComponent, {
+                    ...props
+                })
+            ]
+        });
+    };
+}
+function FormWithSchemaViewer({ schema, children }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+        className: "space-y-4",
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
+                className: "flex justify-end",
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SchemaViewer, {
+                    schema: schema
+                })
+            }),
+            children
+        ]
+    });
+}
+exports.FormWithSchemaViewer = __webpack_exports__.FormWithSchemaViewer;
+exports.SchemaViewer = __webpack_exports__.SchemaViewer;
+exports.withSchemaViewer = __webpack_exports__.withSchemaViewer;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "FormWithSchemaViewer",
+    "SchemaViewer",
+    "withSchemaViewer"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/forms/schema-viewer.d.ts

@@ -0,0 +1,29 @@
+import type { FormSchema } from './form-schema';
+interface SchemaViewerProps {
+    schema: FormSchema;
+    triggerLabel?: string;
+}
+/**
+ * SchemaViewer - Displays form schema JSON with copy functionality
+ *
+ * Shows the backing JSON schema in a slide-out sheet panel.
+ * Includes syntax highlighting and one-click copy to clipboard.
+ */
+export declare function SchemaViewer({ schema, triggerLabel }: SchemaViewerProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * withSchemaViewer - HOC to wrap a form component with schema viewer
+ *
+ * Adds a "View Schema" button above the form.
+ */
+export declare function withSchemaViewer<P extends {
+    schema: FormSchema;
+}>(WrappedComponent: React.ComponentType<P>): (props: P) => import("react/jsx-runtime").JSX.Element;
+/**
+ * FormWithSchemaViewer - Render children with a schema viewer button
+ */
+interface FormWithSchemaViewerProps {
+    schema: FormSchema;
+    children: React.ReactNode;
+}
+export declare function FormWithSchemaViewer({ schema, children }: FormWithSchemaViewerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/forms/schema-viewer.js

@@ -0,0 +1,117 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Check, Code2, Copy } from "lucide-react";
+import { toast } from "sonner";
+import { schemaToJson } from "./schema-serializer.js";
+import { Button } from "../ui/button.js";
+import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle, SheetTrigger } from "../ui/sheet.js";
+import { ScrollArea } from "../ui/scroll-area.js";
+function SchemaViewer({ schema, triggerLabel = 'View Schema' }) {
+    const [copied, setCopied] = useState(false);
+    const jsonString = schemaToJson(schema);
+    const handleCopy = async ()=>{
+        try {
+            await navigator.clipboard.writeText(jsonString);
+            setCopied(true);
+            toast.success('Schema copied to clipboard');
+            setTimeout(()=>setCopied(false), 2000);
+        } catch  {
+            toast.error('Failed to copy schema');
+        }
+    };
+    return /*#__PURE__*/ jsxs(Sheet, {
+        children: [
+            /*#__PURE__*/ jsx(SheetTrigger, {
+                asChild: true,
+                children: /*#__PURE__*/ jsxs(Button, {
+                    variant: "outline",
+                    size: "sm",
+                    className: "gap-2",
+                    children: [
+                        /*#__PURE__*/ jsx(Code2, {
+                            className: "h-4 w-4"
+                        }),
+                        triggerLabel
+                    ]
+                })
+            }),
+            /*#__PURE__*/ jsxs(SheetContent, {
+                side: "right",
+                className: "w-full sm:max-w-2xl",
+                children: [
+                    /*#__PURE__*/ jsxs(SheetHeader, {
+                        children: [
+                            /*#__PURE__*/ jsxs(SheetTitle, {
+                                className: "flex items-center gap-2",
+                                children: [
+                                    /*#__PURE__*/ jsx("span", {
+                                        children: "Schema JSON"
+                                    }),
+                                    /*#__PURE__*/ jsxs(Button, {
+                                        variant: "outline",
+                                        size: "sm",
+                                        onClick: handleCopy,
+                                        className: "gap-2",
+                                        children: [
+                                            copied ? /*#__PURE__*/ jsx(Check, {
+                                                className: "h-4 w-4"
+                                            }) : /*#__PURE__*/ jsx(Copy, {
+                                                className: "h-4 w-4"
+                                            }),
+                                            copied ? 'Copied!' : 'Copy'
+                                        ]
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ jsx(SheetDescription, {
+                                children: "JSON representation of the form schema."
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsx(ScrollArea, {
+                        className: "mt-4 h-[calc(100vh-10rem)] rounded-md border bg-muted/50",
+                        children: /*#__PURE__*/ jsx("pre", {
+                            className: "p-2 text-sm font-mono whitespace-pre-wrap break-words",
+                            children: /*#__PURE__*/ jsx("code", {
+                                children: jsonString
+                            })
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+function withSchemaViewer(WrappedComponent) {
+    return function(props) {
+        return /*#__PURE__*/ jsxs("div", {
+            className: "space-y-4",
+            children: [
+                /*#__PURE__*/ jsx("div", {
+                    className: "flex justify-end",
+                    children: /*#__PURE__*/ jsx(SchemaViewer, {
+                        schema: props.schema
+                    })
+                }),
+                /*#__PURE__*/ jsx(WrappedComponent, {
+                    ...props
+                })
+            ]
+        });
+    };
+}
+function FormWithSchemaViewer({ schema, children }) {
+    return /*#__PURE__*/ jsxs("div", {
+        className: "space-y-4",
+        children: [
+            /*#__PURE__*/ jsx("div", {
+                className: "flex justify-end",
+                children: /*#__PURE__*/ jsx(SchemaViewer, {
+                    schema: schema
+                })
+            }),
+            children
+        ]
+    });
+}
+export { FormWithSchemaViewer, SchemaViewer, withSchemaViewer };

package/dist/components/forms/validation-converter.cjs

@@ -0,0 +1,154 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildZodSchemaFromFields: ()=>buildZodSchemaFromFields,
+    validationConfigToZod: ()=>validationConfigToZod,
+    mergeValidationConfigs: ()=>mergeValidationConfigs
+});
+const external_zod_namespaceObject = require("zod");
+function validationConfigToZod(config, fieldType) {
+    let schema = getBaseSchemaForType(fieldType);
+    if (!config) return schema.optional();
+    schema = applyStringConstraints(schema, config, fieldType);
+    schema = applyNumberConstraints(schema, config, fieldType);
+    schema = applyArrayConstraints(schema, config, fieldType);
+    if (config.required) {
+        if (isStringType(fieldType) && !config.minLength) schema = schema.min(1, config.messages?.required || 'This field is required');
+        return schema;
+    }
+    return schema.optional();
+}
+function getBaseSchemaForType(fieldType) {
+    switch(fieldType){
+        case 'text':
+        case 'textarea':
+            return external_zod_namespaceObject.z.string();
+        case 'email':
+            return external_zod_namespaceObject.z.string().email();
+        case 'number':
+        case 'slider':
+            return external_zod_namespaceObject.z.coerce.number();
+        case 'checkbox':
+        case 'switch':
+            return external_zod_namespaceObject.z.boolean();
+        case 'select':
+        case 'radio':
+            return external_zod_namespaceObject.z.string();
+        case 'multiselect':
+            return external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string());
+        case 'date':
+            return external_zod_namespaceObject.z.coerce.date();
+        case 'datetime':
+            return external_zod_namespaceObject.z.coerce.date();
+        case 'file':
+            return external_zod_namespaceObject.z.any();
+        case 'custom':
+            return external_zod_namespaceObject.z.any();
+        default:
+            return external_zod_namespaceObject.z.string();
+    }
+}
+function isStringType(fieldType) {
+    return [
+        'text',
+        'textarea',
+        'email',
+        'select',
+        'radio'
+    ].includes(fieldType);
+}
+function isNumberType(fieldType) {
+    return [
+        'number',
+        'slider'
+    ].includes(fieldType);
+}
+function isArrayType(fieldType) {
+    return [
+        'multiselect'
+    ].includes(fieldType);
+}
+function applyStringConstraints(schema, config, fieldType) {
+    if (!isStringType(fieldType)) return schema;
+    let stringSchema = schema;
+    if (null != config.minLength) stringSchema = stringSchema.min(config.minLength, config.messages?.minLength || `Must be at least ${config.minLength} characters`);
+    if (null != config.maxLength) stringSchema = stringSchema.max(config.maxLength, config.messages?.maxLength || `Must be at most ${config.maxLength} characters`);
+    if (config.pattern) try {
+        const regex = new RegExp(config.pattern);
+        stringSchema = stringSchema.regex(regex, config.messages?.pattern || 'Invalid format');
+    } catch  {
+        console.warn(`Invalid regex pattern: ${config.pattern}`);
+    }
+    if (config.email && 'email' !== fieldType) stringSchema = stringSchema.email(config.messages?.email || 'Invalid email address');
+    if (config.url) stringSchema = stringSchema.url(config.messages?.url || 'Invalid URL');
+    return stringSchema;
+}
+function applyNumberConstraints(schema, config, fieldType) {
+    if (!isNumberType(fieldType)) return schema;
+    let numberSchema = schema;
+    if (config.integer) numberSchema = numberSchema.int(config.messages?.integer || 'Must be a whole number');
+    if (null != config.min) numberSchema = numberSchema.min(config.min, config.messages?.min || `Must be at least ${config.min}`);
+    if (null != config.max) numberSchema = numberSchema.max(config.max, config.messages?.max || `Must be at most ${config.max}`);
+    if (config.positive) numberSchema = numberSchema.positive(config.messages?.positive || 'Must be a positive number');
+    if (config.negative) numberSchema = numberSchema.negative(config.messages?.negative || 'Must be a negative number');
+    return numberSchema;
+}
+function applyArrayConstraints(schema, config, fieldType) {
+    if (!isArrayType(fieldType)) return schema;
+    let arraySchema = schema;
+    if (null != config.minItems) arraySchema = arraySchema.min(config.minItems, config.messages?.minItems || `Select at least ${config.minItems} item(s)`);
+    if (null != config.maxItems) arraySchema = arraySchema.max(config.maxItems, config.messages?.maxItems || `Select at most ${config.maxItems} item(s)`);
+    return arraySchema;
+}
+function buildZodSchemaFromFields(fields) {
+    const shape = {};
+    for (const field of fields)shape[field.name] = validationConfigToZod(field.validation, field.type);
+    return external_zod_namespaceObject.z.object(shape);
+}
+function mergeValidationConfigs(base, override) {
+    if (!base && !override) return;
+    if (!base) return override;
+    if (!override) return base;
+    return {
+        ...base,
+        ...override,
+        messages: {
+            ...base.messages,
+            ...override.messages
+        }
+    };
+}
+exports.buildZodSchemaFromFields = __webpack_exports__.buildZodSchemaFromFields;
+exports.mergeValidationConfigs = __webpack_exports__.mergeValidationConfigs;
+exports.validationConfigToZod = __webpack_exports__.validationConfigToZod;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "buildZodSchemaFromFields",
+    "mergeValidationConfigs",
+    "validationConfigToZod"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});