@mage-ui/components 1.0.16 → 1.0.18

package/dist/components/forms/controls/FormCheckbox.mjs

@@ -0,0 +1,2 @@
+import{jsx as e,jsxs as t}from"react/jsx-runtime";const n=({$rule:n,error:r,isSubmitting:i,children:a,...o})=>t(`div`,{children:[t(`label`,{style:{display:`flex`,gap:`0.5rem`,alignItems:`center`},children:[e(`input`,{type:`checkbox`,disabled:i,...o}),a]}),r&&e(`span`,{style:{color:`red`,fontSize:`12px`},children:r})]});n.displayName=`Form.Checkbox`;export{n as FormCheckbox};
+//# sourceMappingURL=FormCheckbox.mjs.map

package/dist/components/forms/controls/FormCheckbox.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormCheckbox.mjs","names":[],"sources":["../../../../src/components/forms/controls/FormCheckbox.tsx"],"sourcesContent":["import type React from 'react';\n\nexport const FormCheckbox = ({\n  $rule,\n  error,\n  isSubmitting,\n  children,\n  ...props\n}: {\n  $rule?: string;\n  error?: string;\n  isSubmitting?: boolean;\n  name: string;\n} & React.InputHTMLAttributes<HTMLInputElement>) => {\n  return (\n    <div>\n      <label style={{ display: 'flex', gap: '0.5rem', alignItems: 'center' }}>\n        <input type='checkbox' disabled={isSubmitting} {...props} />\n        {children}\n      </label>\n      {error && <span style={{ color: 'red', fontSize: '12px' }}>{error}</span>}\n    </div>\n  );\n};\n\nFormCheckbox.displayName = 'Form.Checkbox';\n"],"mappings":"kDAEA,MAAa,GAAgB,CAC3B,QACA,QACA,eACA,WACA,GAAG,KAQD,EAAC,MAAA,CAAA,SAAA,CACC,EAAC,QAAA,CAAM,MAAO,CAAE,QAAS,OAAQ,IAAK,SAAU,WAAY,SAAU,WACpE,EAAC,QAAA,CAAM,KAAK,WAAW,SAAU,EAAc,GAAI,GAAS,CAC3D,EAAA,EACK,CACP,GAAS,EAAC,OAAA,CAAK,MAAO,CAAE,MAAO,MAAO,SAAU,OAAQ,UAAG,GAAa,CAAA,CAAA,CACrE,CAIV,EAAa,YAAc"}

package/dist/components/forms/controls/FormHidden.mjs

@@ -0,0 +1,2 @@
+import{jsx as e}from"react/jsx-runtime";const t=({name:t,value:n,...r})=>e(`input`,{type:`hidden`,name:t,value:n,...r});t.displayName=`Form.Hidden`;export{t as FormHidden};
+//# sourceMappingURL=FormHidden.mjs.map

package/dist/components/forms/controls/FormHidden.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormHidden.mjs","names":[],"sources":["../../../../src/components/forms/controls/FormHidden.tsx"],"sourcesContent":["import type React from 'react';\n\nexport const FormHidden = ({\n  name,\n  value,\n  ...props\n}: {\n  name?: string;\n  value?: string;\n  defaultValue?: string;\n} & React.InputHTMLAttributes<HTMLInputElement>) => {\n  return <input type='hidden' name={name} value={value} {...props} />;\n};\n\nFormHidden.displayName = 'Form.Hidden';\n"],"mappings":"wCAEA,MAAa,GAAc,CACzB,OACA,QACA,GAAG,KAMI,EAAC,QAAA,CAAM,KAAK,SAAe,OAAa,QAAO,GAAI,GAAS,CAGrE,EAAW,YAAc"}

package/dist/components/forms/controls/FormPassword.mjs

@@ -0,0 +1,2 @@
+import{PasswordInput as e}from"../../controls/password-input/PasswordInput.mjs";import{PasswordStrengthInput as t}from"../../controls/password-input/PasswordStrengthInput.mjs";import{usePasswordRules as n}from"../../controls/password-input/usePasswordRules.mjs";import{jsx as r}from"react/jsx-runtime";import{Controller as i,useFormContext as a}from"react-hook-form";const o=({error:o,isSubmitting:s=!1,strengthBar:c=!1,value:l,name:u,rules:d,segments:f})=>{let{t:p}=a();return r(i,{name:u,defaultValue:l||``,render:({field:{value:i,...a}})=>{let l=n(i||``,d||[],p),u={disabled:s,value:i,error:o,...a};return c?r(t,{segments:f||[],rules:l,...u}):r(e,{...u})}})};o.displayName=`Form.Password`;export{o as FormPassword};
+//# sourceMappingURL=FormPassword.mjs.map

package/dist/components/forms/controls/FormPassword.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormPassword.mjs","names":[],"sources":["../../../../src/components/forms/controls/FormPassword.tsx"],"sourcesContent":["import { Controller, useFormContext } from 'react-hook-form';\n\nimport { PasswordInput } from '@/components/controls/password-input/PasswordInput';\nimport {\n  type PasswordSegment,\n  PasswordStrengthInput,\n} from '@/components/controls/password-input/PasswordStrengthInput';\nimport {\n  type PasswordRuleDefinition,\n  usePasswordRules,\n} from '@/components/controls/password-input/usePasswordRules';\n\nexport const FormPassword = ({\n  error,\n  isSubmitting = false,\n  strengthBar = false,\n  value,\n  name,\n  rules,\n  segments,\n}: {\n  $rule?: string;\n  error?: string;\n  isSubmitting?: boolean;\n  strengthBar?: boolean;\n  value?: string;\n  name: string;\n  rules?: PasswordRuleDefinition[];\n  segments?: PasswordSegment[];\n}) => {\n  const { t } = useFormContext() as unknown as {\n    t?: (\n      key: string,\n      bindings?: Record<string, string>,\n      fallback?: string,\n    ) => string;\n  };\n\n  return (\n    <Controller\n      name={name}\n      defaultValue={value || ''}\n      render={({ field: { value, ...fieldProps } }) => {\n        const computedRules = usePasswordRules(value || '', rules || [], t);\n\n        const props = {\n          disabled: isSubmitting,\n          value,\n          error,\n          ...fieldProps,\n        };\n\n        if (strengthBar) {\n          return (\n            <PasswordStrengthInput\n              segments={segments || []}\n              rules={computedRules}\n              {...props}\n            />\n          );\n        }\n        return <PasswordInput {...props} />;\n      }}\n    />\n  );\n};\n\nFormPassword.displayName = 'Form.Password';\n"],"mappings":"+WAYA,MAAa,GAAgB,CAC3B,QACA,eAAe,GACf,cAAc,GACd,QACA,OACA,QACA,cAUI,CACJ,GAAM,CAAE,KAAM,GAAgB,CAQ9B,OACE,EAAC,EAAA,CACO,OACN,aAAc,GAAS,GACvB,QAAS,CAAE,MAAO,CAAE,QAAO,GAAG,MAAmB,CAC/C,IAAM,EAAgB,EAAiB,GAAS,GAAI,GAAS,EAAE,CAAE,EAAE,CAE7D,EAAQ,CACZ,SAAU,EACV,QACA,QACA,GAAG,EACJ,CAWD,OATI,EAEA,EAAC,EAAA,CACC,SAAU,GAAY,EAAE,CACxB,MAAO,EACP,GAAI,GACJ,CAGC,EAAC,EAAA,CAAc,GAAI,EAAA,CAAS,GAErC,EAIN,EAAa,YAAc"}

package/dist/components/forms/controls/FormSubmit.mjs

@@ -0,0 +1,2 @@
+import{ButtonAction as e}from"../../buttons/button-action/ButtonAction.mjs";import{jsx as t}from"react/jsx-runtime";import{useFormContext as n}from"react-hook-form";const r=({children:r})=>{let{formState:{isSubmitSuccessful:i,isSubmitting:a}}=n();return t(e,{type:`submit`,loading:a,loadingText:`Enviando...`,successText:i?`Adelante`:void 0,successDuration:2e3,children:r})};r.displayName=`Form.Submit`;export{r as FormSubmit};
+//# sourceMappingURL=FormSubmit.mjs.map

package/dist/components/forms/controls/FormSubmit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormSubmit.mjs","names":[],"sources":["../../../../src/components/forms/controls/FormSubmit.tsx"],"sourcesContent":["import { useFormContext } from 'react-hook-form';\n\nimport { ButtonAction } from '@/components/buttons';\n\nexport const FormSubmit = ({ children }: { children: React.ReactNode }) => {\n  const {\n    formState: { isSubmitSuccessful, isSubmitting },\n  } = useFormContext();\n\n  return (\n    <ButtonAction\n      type='submit'\n      loading={isSubmitting}\n      loadingText='Enviando...'\n      successText={isSubmitSuccessful ? 'Adelante' : undefined}\n      successDuration={2000}\n    >\n      {children}\n    </ButtonAction>\n  );\n};\n\nFormSubmit.displayName = 'Form.Submit';\n"],"mappings":"qKAIA,MAAa,GAAc,CAAE,cAA8C,CACzE,GAAM,CACJ,UAAW,CAAE,qBAAoB,iBAC/B,GAAgB,CAEpB,OACE,EAAC,EAAA,CACC,KAAK,SACL,QAAS,EACT,YAAY,cACZ,YAAa,EAAqB,WAAa,IAAA,GAC/C,gBAAiB,IAEhB,YACY,EAInB,EAAW,YAAc"}

package/dist/components/forms/controls/FormTextInput.mjs

@@ -0,0 +1,2 @@
+import{TextInput as e}from"../../controls/text-input/TextInput.mjs";import{jsx as t}from"react/jsx-runtime";const n=({$rule:n,isSubmitting:r,...i})=>t(e,{disabled:r,type:`text`,...i});n.displayName=`Form.TextInput`;export{n as FormTextInput};
+//# sourceMappingURL=FormTextInput.mjs.map

package/dist/components/forms/controls/FormTextInput.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormTextInput.mjs","names":[],"sources":["../../../../src/components/forms/controls/FormTextInput.tsx"],"sourcesContent":["import {\n  TextInput,\n  type TextInputProps,\n} from '@/components/controls/text-input/TextInput';\n\nexport const FormTextInput = ({\n  $rule,\n  isSubmitting,\n  ...props\n}: {\n  $rule?: string;\n  error?: string;\n  isSubmitting?: boolean;\n} & TextInputProps) => {\n  return <TextInput disabled={isSubmitting} type='text' {...props} />;\n};\n\nFormTextInput.displayName = 'Form.TextInput';\n"],"mappings":"4GAKA,MAAa,GAAiB,CAC5B,QACA,eACA,GAAG,KAMI,EAAC,EAAA,CAAU,SAAU,EAAc,KAAK,OAAO,GAAI,GAAS,CAGrE,EAAc,YAAc"}

package/dist/components/forms/controls/find-form-components.mjs

@@ -0,0 +1,2 @@
+import{Children as e,isValidElement as t}from"react";const n=(r,i)=>{let a=[];return e.forEach(r,e=>{if(!t(e))return;i.some(t=>{let n=e.type,r=t;return e.type===t||r.displayName===n.displayName})&&a.push(e);let r=e.props;if(r.children){let e=n(r.children,i);a.push(...e)}}),a};export{n as findFormComponents};
+//# sourceMappingURL=find-form-components.mjs.map

package/dist/components/forms/controls/find-form-components.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-form-components.mjs","names":[],"sources":["../../../../src/components/forms/controls/find-form-components.ts"],"sourcesContent":["import type React from 'react';\nimport { Children, isValidElement } from 'react';\n\ninterface ComponentWithDisplayName {\n  displayName?: string;\n}\n\nexport const findFormComponents = (\n  children: React.ReactNode,\n  componentTypes: React.ComponentType[],\n): React.ReactElement[] => {\n  const components: React.ReactElement[] = [];\n\n  Children.forEach(children, (child) => {\n    if (!isValidElement(child)) {\n      return;\n    }\n\n    if (\n      componentTypes.some((type) => {\n        const childType = child.type as ComponentWithDisplayName;\n        const componentType = type as ComponentWithDisplayName;\n        return (\n          child.type === type ||\n          componentType.displayName === childType.displayName\n        );\n      })\n    ) {\n      components.push(child);\n    }\n\n    const childProps = child.props as { children?: React.ReactNode };\n    if (childProps.children) {\n      const nestedComponents = findFormComponents(\n        childProps.children,\n        componentTypes,\n      );\n      components.push(...nestedComponents);\n    }\n  });\n\n  return components;\n};\n"],"mappings":"qDAOA,MAAa,GACX,EACA,IACyB,CACzB,IAAM,EAAmC,EAAE,CA8B3C,OA5BA,EAAS,QAAQ,EAAW,GAAU,CACpC,GAAI,CAAC,EAAe,EAAM,CACxB,OAIA,EAAe,KAAM,GAAS,CAC5B,IAAM,EAAY,EAAM,KAClB,EAAgB,EACtB,OACE,EAAM,OAAS,GACf,EAAc,cAAgB,EAAU,aAE1C,EAEF,EAAW,KAAK,EAAM,CAGxB,IAAM,EAAa,EAAM,MACzB,GAAI,EAAW,SAAU,CACvB,IAAM,EAAmB,EACvB,EAAW,SACX,EACD,CACD,EAAW,KAAK,GAAG,EAAiB,GAEtC,CAEK"}

package/dist/components/forms/controls/index.mjs

@@ -0,0 +1,2 @@
+import{FormCheckbox as e}from"./FormCheckbox.mjs";import{FormHidden as t}from"./FormHidden.mjs";import{FormPassword as n}from"./FormPassword.mjs";import{FormSubmit as r}from"./FormSubmit.mjs";import{FormTextInput as i}from"./FormTextInput.mjs";const a=[r,i,n,t,e];export{a as controls};
+//# sourceMappingURL=index.mjs.map

package/dist/components/forms/controls/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/components/forms/controls/index.ts"],"sourcesContent":["import { FormCheckbox } from './FormCheckbox';\nimport { FormHidden } from './FormHidden';\nimport { FormPassword } from './FormPassword';\nimport { FormSubmit } from './FormSubmit';\nimport { FormTextInput } from './FormTextInput';\n\nexport const controls = [\n  FormSubmit,\n  FormTextInput,\n  FormPassword,\n  FormHidden,\n  FormCheckbox,\n] as React.ComponentType[];\n"],"mappings":"oPAMA,MAAa,EAAW,CACtB,EACA,EACA,EACA,EACA,EACD"}

package/dist/components/forms/controls/register-components.mjs

@@ -0,0 +1,2 @@
+"use client";import{Fragment as e,jsx as t}from"react/jsx-runtime";import{Children as n,cloneElement as r,isValidElement as i}from"react";const a=(e,t,n)=>{if(e)try{let r=JSON.parse(e),i={...r.bindings,attribute:t},a=n?n(r.key,i,r.fallback):r.fallback;return String(a).replace(/{attribute}/g,t)}catch{return e.replace(/{attribute}/g,t)}},o=({children:o,register:s,componentTypes:c,errors:l={},t:u})=>{let d=e=>n.map(e,e=>{if(!i(e))return e;let t=e.props;if(c.some(t=>e.type===t)){let n=l[t.name??``]?.message?.toString(),i=t.name?a(n,t.name,u):void 0;return r(e,{...t.name&&{...s(t.name),error:i}})}return t.children?r(e,{children:d(t.children)}):e});return t(e,{children:d(o)})};export{o as RegisteredFormChildren};
+//# sourceMappingURL=register-components.mjs.map

package/dist/components/forms/controls/register-components.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-components.mjs","names":[],"sources":["../../../../src/components/forms/controls/register-components.tsx"],"sourcesContent":["'use client';\n\nimport type React from 'react';\nimport { Children, cloneElement, isValidElement } from 'react';\nimport type { FieldErrors, UseFormRegister } from 'react-hook-form';\n\ninterface TranslationMessage {\n  key: string;\n  bindings: Record<string, string>;\n  fallback: string;\n}\n\nconst parseAndTranslate = (\n  message: string | undefined,\n  fieldName: string,\n  t?: (\n    key: string,\n    bindings?: Record<string, string>,\n    fallback?: string,\n  ) => string | React.ReactNode,\n): string | undefined => {\n  if (!message) return undefined;\n\n  try {\n    const parsed: TranslationMessage = JSON.parse(message);\n    const bindings = { ...parsed.bindings, attribute: fieldName };\n    const result = t\n      ? t(parsed.key, bindings, parsed.fallback)\n      : parsed.fallback;\n    return String(result).replace(/{attribute}/g, fieldName);\n  } catch {\n    return message.replace(/{attribute}/g, fieldName);\n  }\n};\n\ninterface RegisteredFormChildrenProps {\n  children: React.ReactNode;\n  register: UseFormRegister<Record<string, unknown>>;\n  componentTypes: React.ComponentType[];\n  errors?: FieldErrors<Record<string, unknown>>;\n  t?: (\n    key: string,\n    bindings?: Record<string, string>,\n    fallback?: string,\n  ) => string | React.ReactNode;\n}\n\nexport const RegisteredFormChildren = ({\n  children,\n  register,\n  componentTypes,\n  errors = {},\n  t,\n}: RegisteredFormChildrenProps): React.ReactNode => {\n  const processChildren = (nodes: React.ReactNode): React.ReactNode => {\n    return Children.map(nodes, (child) => {\n      if (!isValidElement(child)) {\n        return child;\n      }\n\n      const childProps = child.props as {\n        name?: string;\n        children?: React.ReactNode;\n      };\n\n      if (\n        componentTypes.some((type: React.ComponentType) => child.type === type)\n      ) {\n        const errorMessage = errors[childProps.name ?? '']?.message?.toString();\n        const translatedError = childProps.name\n          ? parseAndTranslate(errorMessage, childProps.name, t)\n          : undefined;\n\n        return cloneElement(child, {\n          ...(childProps.name && {\n            ...register(childProps.name),\n            error: translatedError,\n          }),\n        } as Partial<typeof child.props>);\n      }\n\n      if (childProps.children) {\n        return cloneElement(child, {\n          children: processChildren(childProps.children),\n        } as Partial<typeof child.props>);\n      }\n\n      return child;\n    });\n  };\n\n  return <>{processChildren(children)}</>;\n};\n"],"mappings":"0IAYA,MAAM,GACJ,EACA,EACA,IAKuB,CAClB,KAEL,GAAI,CACF,IAAM,EAA6B,KAAK,MAAM,EAAQ,CAChD,EAAW,CAAE,GAAG,EAAO,SAAU,UAAW,EAAW,CACvD,EAAS,EACX,EAAE,EAAO,IAAK,EAAU,EAAO,SAAS,CACxC,EAAO,SACX,OAAO,OAAO,EAAO,CAAC,QAAQ,eAAgB,EAAU,MAClD,CACN,OAAO,EAAQ,QAAQ,eAAgB,EAAU,GAgBxC,GAA0B,CACrC,WACA,WACA,iBACA,SAAS,EAAE,CACX,OACkD,CAClD,IAAM,EAAmB,GAChB,EAAS,IAAI,EAAQ,GAAU,CACpC,GAAI,CAAC,EAAe,EAAM,CACxB,OAAO,EAGT,IAAM,EAAa,EAAM,MAKzB,GACE,EAAe,KAAM,GAA8B,EAAM,OAAS,EAAK,CACvE,CACA,IAAM,EAAe,EAAO,EAAW,MAAQ,KAAK,SAAS,UAAU,CACjE,EAAkB,EAAW,KAC/B,EAAkB,EAAc,EAAW,KAAM,EAAE,CACnD,IAAA,GAEJ,OAAO,EAAa,EAAO,CACzB,GAAI,EAAW,MAAQ,CACrB,GAAG,EAAS,EAAW,KAAK,CAC5B,MAAO,EACR,CACF,CAAgC,CASnC,OANI,EAAW,SACN,EAAa,EAAO,CACzB,SAAU,EAAgB,EAAW,SAAS,CAC/C,CAAgC,CAG5B,GACP,CAGJ,OAAO,EAAA,EAAA,CAAA,SAAG,EAAgB,EAAS,CAAA,CAAI"}

package/dist/components/forms/index.d.mts

@@ -0,0 +1,3 @@
+import { Form, FormProps } from "./Form.mjs";
+import { PASSWORD_RULES } from "./rules/password-rules.mjs";
+import { z } from "./rules/zod.mjs";

package/dist/components/forms/rules/confirmed.mjs

@@ -0,0 +1,2 @@
+import{createRule as e}from"./create-rule.mjs";var t=e(`confirmed`,{fallback:`La confirmación no coincide.`,validate:()=>!0});export{t as default};
+//# sourceMappingURL=confirmed.mjs.map

package/dist/components/forms/rules/confirmed.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirmed.mjs","names":[],"sources":["../../../../src/components/forms/rules/confirmed.ts"],"sourcesContent":["import { createRule } from './create-rule';\n\n// This rule is a marker. The actual validation logic is handled in extract-form-rules.ts\n// to check against the _confirmation field at the object level.\nexport default createRule('confirmed', {\n  fallback: 'La confirmación no coincide.',\n  validate: () => true,\n});\n"],"mappings":"+CAIA,IAAA,EAAe,EAAW,YAAa,CACrC,SAAU,+BACV,aAAgB,GACjB,CAAC"}

package/dist/components/forms/rules/create-rule.d.mts

@@ -0,0 +1 @@
+import { ZodType } from "zod";

package/dist/components/forms/rules/create-rule.mjs

@@ -0,0 +1,2 @@
+function e(e,t){return(n,...r)=>{let[i,a]=r,o=t.bindings?.(i)??{},s=JSON.stringify({key:t.key??e,bindings:o,fallback:t.fallback}),c=n.refine(n=>e!==`required`&&(n==null||n===``)?!0:t.validate(n,i),{message:a??s});return t.transform&&(c=c.transform(e=>t.transform?.(e,i))),c}}export{e as createRule};
+//# sourceMappingURL=create-rule.mjs.map

package/dist/components/forms/rules/create-rule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-rule.mjs","names":[],"sources":["../../../../src/components/forms/rules/create-rule.ts"],"sourcesContent":["import type { ZodType } from 'zod';\n\nexport type RuleDefinition = (schema: ZodType, ...args: unknown[]) => ZodType;\n\nexport type ValidateFn = (value: unknown, args?: unknown) => boolean;\nexport type TransformFn = (value: unknown, args?: unknown) => unknown;\n\nexport interface RuleConfig {\n  key?: string;\n  bindings?: (args?: unknown) => Record<string, string>;\n  fallback: string;\n  validate: ValidateFn;\n  transform?: TransformFn;\n}\n\nexport function createRule(name: string, config: RuleConfig): RuleDefinition {\n  return (schema, ...args) => {\n    const [argsValue, customMessage] = args;\n    const bindings = config.bindings?.(argsValue) ?? {};\n\n    const defaultMessage = JSON.stringify({\n      key: config.key ?? name,\n      bindings,\n      fallback: config.fallback,\n    });\n\n    let result = schema.refine(\n      (val: unknown) => {\n        if (\n          name !== 'required' &&\n          (val === undefined || val === null || val === '')\n        ) {\n          return true;\n        }\n        return config.validate(val, argsValue);\n      },\n      {\n        message: (customMessage as string) ?? defaultMessage,\n      },\n    );\n\n    if (config.transform) {\n      result = result.transform((val: unknown) =>\n        config.transform?.(val, argsValue),\n      );\n    }\n\n    return result;\n  };\n}\n"],"mappings":"AAeA,SAAgB,EAAW,EAAc,EAAoC,CAC3E,OAAQ,EAAQ,GAAG,IAAS,CAC1B,GAAM,CAAC,EAAW,GAAiB,EAC7B,EAAW,EAAO,WAAW,EAAU,EAAI,EAAE,CAE7C,EAAiB,KAAK,UAAU,CACpC,IAAK,EAAO,KAAO,EACnB,WACA,SAAU,EAAO,SAClB,CAAC,CAEE,EAAS,EAAO,OACjB,GAEG,IAAS,aACR,GAA6B,MAAQ,IAAQ,IAEvC,GAEF,EAAO,SAAS,EAAK,EAAU,CAExC,CACE,QAAU,GAA4B,EACvC,CACF,CAQD,OANI,EAAO,YACT,EAAS,EAAO,UAAW,GACzB,EAAO,YAAY,EAAK,EAAU,CACnC,EAGI"}

package/dist/components/forms/rules/extract-form-rules.mjs

@@ -0,0 +1,2 @@
+import{findFormComponents as e}from"../controls/find-form-components.mjs";import{PASSWORD_RULES as t}from"./password-rules.mjs";import n from"./password.mjs";import{parseRules as r}from"./zod.mjs";import{z as i}from"zod";const a=(a,o)=>{let s={},c=e(a,o),l=[];c.forEach(e=>{let a=e.props;if(a.name){if(a.$rule?.includes(`confirmed`)){let e=a.$rule.split(`|`).find(e=>e.startsWith(`confirmed`)),t=e?.includes(`:`)?e.split(`:`)[1]:`${a.name}_confirmation`;l.push({field:a.name,target:t})}if(e.type.displayName===`Form.Checkbox`)s[a.name]=a.$rule?r(a.$rule):i.boolean().optional();else if(e.type.displayName===`Form.Password`){let e=i.string(),o=a.$rule?a.$rule.split(`|`).filter(e=>e.trim()!==`password`).join(`|`):``;o&&(e=r(o));let c=a.rules||(a.$rule?.includes(`password`)?t:[]);c.length>0&&(e=n(e,c));let l=!a.$rule||a.$rule.includes(`optional`)||o.includes(`optional`);s[a.name]=l?e.optional():e}else s[a.name]=a.$rule?r(a.$rule):i.string().optional()}});let u=i.object(s);return l.length>0?u.superRefine((e,t)=>{l.forEach(({field:n,target:r})=>{e[n]!==e[r]&&t.addIssue({code:i.ZodIssueCode.custom,message:JSON.stringify({key:`confirmed`,fallback:`La confirmación no coincide.`,bindings:{}}),path:[r]})})}):u};export{a as extractFormRules};
+//# sourceMappingURL=extract-form-rules.mjs.map

package/dist/components/forms/rules/extract-form-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-form-rules.mjs","names":["passwordRule"],"sources":["../../../../src/components/forms/rules/extract-form-rules.ts"],"sourcesContent":["import type React from 'react';\nimport { type ZodTypeAny, z } from 'zod';\n\nimport type { PasswordRuleDefinition } from '@/components/controls/password-input/usePasswordRules';\n\nimport { findFormComponents } from '../controls/find-form-components';\nimport passwordRule from './password';\nimport { PASSWORD_RULES } from './password-rules';\nimport { parseRules } from './zod';\n\nexport const extractFormRules = (\n  children: React.ReactNode,\n  componentTypes: React.ComponentType[],\n): ZodTypeAny => {\n  const rules: Record<string, ZodTypeAny> = {};\n\n  const components = findFormComponents(children, componentTypes);\n  const confirmedFields: { field: string; target: string }[] = [];\n\n  components.forEach((component) => {\n    const props = component.props as { name?: string; $rule?: string };\n    if (props.name) {\n      if (props.$rule?.includes('confirmed')) {\n        const rulesList = props.$rule.split('|');\n        const confirmedRule = rulesList.find((r) => r.startsWith('confirmed'));\n        const target = confirmedRule?.includes(':')\n          ? confirmedRule.split(':')[1]\n          : `${props.name}_confirmation`;\n\n        confirmedFields.push({ field: props.name, target });\n      }\n\n      if (\n        (component.type as { displayName?: string }).displayName ===\n        'Form.Checkbox'\n      ) {\n        rules[props.name] = props.$rule\n          ? parseRules(props.$rule)\n          : z.boolean().optional();\n      } else if (\n        (component.type as { displayName?: string }).displayName ===\n        'Form.Password'\n      ) {\n        let baseSchema: ZodTypeAny = z.string();\n        const otherRules = props.$rule\n          ? props.$rule\n              .split('|')\n              .filter((r) => r.trim() !== 'password')\n              .join('|')\n          : '';\n\n        if (otherRules) {\n          baseSchema = parseRules(otherRules);\n        }\n\n        const passwordRules =\n          (props as { rules?: PasswordRuleDefinition[] }).rules ||\n          (props.$rule?.includes('password') ? PASSWORD_RULES : []);\n\n        // Apply password rule directly\n        if (passwordRules.length > 0) {\n          baseSchema = passwordRule(baseSchema, passwordRules);\n        }\n\n        const isOptional =\n          !props.$rule ||\n          props.$rule.includes('optional') ||\n          otherRules.includes('optional');\n\n        rules[props.name] = isOptional ? baseSchema.optional() : baseSchema;\n      } else {\n        rules[props.name] = props.$rule\n          ? parseRules(props.$rule)\n          : z.string().optional();\n      }\n    }\n  });\n\n  const schema = z.object(rules);\n\n  if (confirmedFields.length > 0) {\n    return schema.superRefine((data, ctx) => {\n      confirmedFields.forEach(({ field, target }) => {\n        if (data[field] !== data[target]) {\n          ctx.addIssue({\n            code: z.ZodIssueCode.custom,\n            message: JSON.stringify({\n              key: 'confirmed',\n              fallback: 'La confirmación no coincide.',\n              bindings: {},\n            }),\n            path: [target],\n          });\n        }\n      });\n    });\n  }\n\n  return schema;\n};\n"],"mappings":"6NAUA,MAAa,GACX,EACA,IACe,CACf,IAAM,EAAoC,EAAE,CAEtC,EAAa,EAAmB,EAAU,EAAe,CACzD,EAAuD,EAAE,CAE/D,EAAW,QAAS,GAAc,CAChC,IAAM,EAAQ,EAAU,MACxB,GAAI,EAAM,KAAM,CACd,GAAI,EAAM,OAAO,SAAS,YAAY,CAAE,CAEtC,IAAM,EADY,EAAM,MAAM,MAAM,IAAI,CACR,KAAM,GAAM,EAAE,WAAW,YAAY,CAAC,CAChE,EAAS,GAAe,SAAS,IAAI,CACvC,EAAc,MAAM,IAAI,CAAC,GACzB,GAAG,EAAM,KAAK,eAElB,EAAgB,KAAK,CAAE,MAAO,EAAM,KAAM,SAAQ,CAAC,CAGrD,GACG,EAAU,KAAkC,cAC7C,gBAEA,EAAM,EAAM,MAAQ,EAAM,MACtB,EAAW,EAAM,MAAM,CACvB,EAAE,SAAS,CAAC,UAAU,SAEzB,EAAU,KAAkC,cAC7C,gBACA,CACA,IAAI,EAAyB,EAAE,QAAQ,CACjC,EAAa,EAAM,MACrB,EAAM,MACH,MAAM,IAAI,CACV,OAAQ,GAAM,EAAE,MAAM,GAAK,WAAW,CACtC,KAAK,IAAI,CACZ,GAEA,IACF,EAAa,EAAW,EAAW,EAGrC,IAAM,EACH,EAA+C,QAC/C,EAAM,OAAO,SAAS,WAAW,CAAG,EAAiB,EAAE,EAGtD,EAAc,OAAS,IACzB,EAAaA,EAAa,EAAY,EAAc,EAGtD,IAAM,EACJ,CAAC,EAAM,OACP,EAAM,MAAM,SAAS,WAAW,EAChC,EAAW,SAAS,WAAW,CAEjC,EAAM,EAAM,MAAQ,EAAa,EAAW,UAAU,CAAG,OAEzD,EAAM,EAAM,MAAQ,EAAM,MACtB,EAAW,EAAM,MAAM,CACvB,EAAE,QAAQ,CAAC,UAAU,GAG7B,CAEF,IAAM,EAAS,EAAE,OAAO,EAAM,CAoB9B,OAlBI,EAAgB,OAAS,EACpB,EAAO,aAAa,EAAM,IAAQ,CACvC,EAAgB,SAAS,CAAE,QAAO,YAAa,CACzC,EAAK,KAAW,EAAK,IACvB,EAAI,SAAS,CACX,KAAM,EAAE,aAAa,OACrB,QAAS,KAAK,UAAU,CACtB,IAAK,YACL,SAAU,+BACV,SAAU,EAAE,CACb,CAAC,CACF,KAAM,CAAC,EAAO,CACf,CAAC,EAEJ,EACF,CAGG"}

package/dist/components/forms/rules/in.mjs

@@ -0,0 +1,2 @@
+import{createRule as e}from"./create-rule.mjs";function t(e){return typeof e==`string`?e.split(`,`).map(e=>e.trim()):Array.isArray(e)?e.map(String):[]}var n=e(`in`,{fallback:`El campo {attribute} debe ser uno de los siguientes valores: {values}.`,bindings:e=>({values:t(e).join(`, `)}),validate:(e,n)=>t(n).includes(String(e))});export{n as default};
+//# sourceMappingURL=in.mjs.map

package/dist/components/forms/rules/in.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"in.mjs","names":[],"sources":["../../../../src/components/forms/rules/in.ts"],"sourcesContent":["import { createRule } from './create-rule';\n\nfunction parseValues(args: unknown): string[] {\n  if (typeof args === 'string') {\n    return args.split(',').map((v) => v.trim());\n  }\n  if (Array.isArray(args)) {\n    return args.map(String);\n  }\n  return [];\n}\n\nexport default createRule('in', {\n  fallback:\n    'El campo {attribute} debe ser uno de los siguientes valores: {values}.',\n  bindings: (args) => ({ values: parseValues(args).join(', ') }),\n  validate: (val, args) => parseValues(args).includes(String(val)),\n});\n"],"mappings":"+CAEA,SAAS,EAAY,EAAyB,CAO5C,OANI,OAAO,GAAS,SACX,EAAK,MAAM,IAAI,CAAC,IAAK,GAAM,EAAE,MAAM,CAAC,CAEzC,MAAM,QAAQ,EAAK,CACd,EAAK,IAAI,OAAO,CAElB,EAAE,CAGX,IAAA,EAAe,EAAW,KAAM,CAC9B,SACE,yEACF,SAAW,IAAU,CAAE,OAAQ,EAAY,EAAK,CAAC,KAAK,KAAK,CAAE,EAC7D,UAAW,EAAK,IAAS,EAAY,EAAK,CAAC,SAAS,OAAO,EAAI,CAAC,CACjE,CAAC"}

package/dist/components/forms/rules/index.mjs

@@ -0,0 +1,2 @@
+import e from"./password.mjs";import t from"./confirmed.mjs";import n from"./in.mjs";import r from"./numeric.mjs";import i from"./required.mjs";const a={required:i,numeric:r,in:n,password:e,confirmed:t};export{a as ruleDefinitions};
+//# sourceMappingURL=index.mjs.map

package/dist/components/forms/rules/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["inRule"],"sources":["../../../../src/components/forms/rules/index.ts"],"sourcesContent":["import type { PasswordRuleDefinition } from '@/components/controls/password-input/usePasswordRules';\n\nimport confirmed from './confirmed';\nimport type { RuleDefinition } from './create-rule';\nimport inRule from './in';\nimport numeric from './numeric';\nimport password from './password';\nimport required from './required';\n\nexport const ruleDefinitions: Record<string, RuleDefinition> = {\n  required,\n  numeric,\n  in: inRule,\n  password,\n  confirmed,\n};\n\ndeclare module 'zod' {\n  interface ZodString {\n    required(message?: string): ZodString;\n    numeric(message?: string): ZodString;\n    in(values: string | string[], message?: string): ZodString;\n    password(rules?: PasswordRuleDefinition[], message?: string): ZodString;\n    confirmed(message?: string): ZodString;\n  }\n}\n"],"mappings":"gJASA,MAAa,EAAkD,CAC7D,SAAA,EACA,QAAA,EACA,GAAIA,EACJ,SAAA,EACA,UAAA,EACD"}

package/dist/components/forms/rules/numeric.mjs

@@ -0,0 +1,2 @@
+import{createRule as e}from"./create-rule.mjs";var t=e(`numeric`,{fallback:`El campo {attribute} debe ser un número.`,validate:e=>e===``||!Number.isNaN(Number(e)),transform:e=>e===void 0||e===``?void 0:Number(e)});export{t as default};
+//# sourceMappingURL=numeric.mjs.map

package/dist/components/forms/rules/numeric.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric.mjs","names":[],"sources":["../../../../src/components/forms/rules/numeric.ts"],"sourcesContent":["import { createRule } from './create-rule';\n\nexport default createRule('numeric', {\n  fallback: 'El campo {attribute} debe ser un número.',\n  validate: (val) => val === '' || !Number.isNaN(Number(val)),\n  transform: (val) =>\n    val === undefined || val === '' ? undefined : Number(val),\n});\n"],"mappings":"+CAEA,IAAA,EAAe,EAAW,UAAW,CACnC,SAAU,2CACV,SAAW,GAAQ,IAAQ,IAAM,CAAC,OAAO,MAAM,OAAO,EAAI,CAAC,CAC3D,UAAY,GACV,IAAQ,IAAA,IAAa,IAAQ,GAAK,IAAA,GAAY,OAAO,EAAI,CAC5D,CAAC"}

package/dist/components/forms/rules/password-rules.d.mts

@@ -0,0 +1,7 @@
+import { PasswordRuleDefinition } from "../../controls/password-input/usePasswordRules.mjs";
+
+//#region src/components/forms/rules/password-rules.d.ts
+declare const PASSWORD_RULES: PasswordRuleDefinition[];
+//#endregion
+export { PASSWORD_RULES };
+//# sourceMappingURL=password-rules.d.mts.map

package/dist/components/forms/rules/password-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-rules.d.mts","names":[],"sources":["../../../../src/components/forms/rules/password-rules.ts"],"mappings":";;;cAEa,cAAA,EAAgB,sBAAA"}

package/dist/components/forms/rules/password-rules.mjs

@@ -0,0 +1,2 @@
+const e=[{key:`password.rules.min`,text:`Mínimo 12 caracteres`,validate:e=>e.length>=12},{key:`password.rules.lower`,text:`Al menos una minúscula`,validate:e=>/[a-z]/.test(e)},{key:`password.rules.upper`,text:`Al menos una mayúscula`,validate:e=>/[A-Z]/.test(e)},{key:`password.rules.digit`,text:`Al menos un número`,validate:e=>/[0-9]/.test(e)},{key:`password.rules.symbol`,text:`Al menos un símbolo`,validate:e=>/[\W_]/.test(e)},{key:`password.rules.whitespace`,text:`Sin espacios en blanco`,validate:e=>!/\s/.test(e)}];export{e as PASSWORD_RULES};
+//# sourceMappingURL=password-rules.mjs.map

package/dist/components/forms/rules/password-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-rules.mjs","names":[],"sources":["../../../../src/components/forms/rules/password-rules.ts"],"sourcesContent":["import type { PasswordRuleDefinition } from '@/components/controls/password-input/usePasswordRules';\n\nexport const PASSWORD_RULES: PasswordRuleDefinition[] = [\n  {\n    key: 'password.rules.min',\n    text: 'Mínimo 12 caracteres',\n    validate: (v) => v.length >= 12,\n  },\n  {\n    key: 'password.rules.lower',\n    text: 'Al menos una minúscula',\n    validate: (v) => /[a-z]/.test(v),\n  },\n  {\n    key: 'password.rules.upper',\n    text: 'Al menos una mayúscula',\n    validate: (v) => /[A-Z]/.test(v),\n  },\n  {\n    key: 'password.rules.digit',\n    text: 'Al menos un número',\n    validate: (v) => /[0-9]/.test(v),\n  },\n  {\n    key: 'password.rules.symbol',\n    text: 'Al menos un símbolo',\n    validate: (v) => /[\\W_]/.test(v),\n  },\n  {\n    key: 'password.rules.whitespace',\n    text: 'Sin espacios en blanco',\n    validate: (v) => !/\\s/.test(v),\n  },\n];\n"],"mappings":"AAEA,MAAa,EAA2C,CACtD,CACE,IAAK,qBACL,KAAM,uBACN,SAAW,GAAM,EAAE,QAAU,GAC9B,CACD,CACE,IAAK,uBACL,KAAM,yBACN,SAAW,GAAM,QAAQ,KAAK,EAAE,CACjC,CACD,CACE,IAAK,uBACL,KAAM,yBACN,SAAW,GAAM,QAAQ,KAAK,EAAE,CACjC,CACD,CACE,IAAK,uBACL,KAAM,qBACN,SAAW,GAAM,QAAQ,KAAK,EAAE,CACjC,CACD,CACE,IAAK,wBACL,KAAM,sBACN,SAAW,GAAM,QAAQ,KAAK,EAAE,CACjC,CACD,CACE,IAAK,4BACL,KAAM,yBACN,SAAW,GAAM,CAAC,KAAK,KAAK,EAAE,CAC/B,CACF"}

package/dist/components/forms/rules/password.mjs

@@ -0,0 +1,2 @@
+import{PASSWORD_RULES as e}from"./password-rules.mjs";import{z as t}from"zod";var n=(n,r)=>n.superRefine((n,i)=>{n==null||n===``||typeof n==`string`&&(Array.isArray(r)?r:e).forEach(e=>{e.validate(n)||i.addIssue({code:t.ZodIssueCode.custom,message:JSON.stringify({key:e.key,fallback:e.text,bindings:{}})})})});export{n as default};
+//# sourceMappingURL=password.mjs.map

package/dist/components/forms/rules/password.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.mjs","names":[],"sources":["../../../../src/components/forms/rules/password.ts"],"sourcesContent":["import { z } from 'zod';\n\nimport type { PasswordRuleDefinition } from '@/components/controls/password-input/usePasswordRules';\n\nimport type { RuleDefinition } from './create-rule';\nimport { PASSWORD_RULES } from './password-rules';\n\nconst password: RuleDefinition = (schema, rules) => {\n  return schema.superRefine((val, ctx) => {\n    if (val === undefined || val === null || val === '') {\n      return;\n    }\n\n    if (typeof val !== 'string') {\n      return;\n    }\n\n    const activeRules = Array.isArray(rules)\n      ? (rules as PasswordRuleDefinition[])\n      : PASSWORD_RULES;\n\n    activeRules.forEach((rule) => {\n      if (!rule.validate(val)) {\n        ctx.addIssue({\n          code: z.ZodIssueCode.custom,\n          message: JSON.stringify({\n            key: rule.key,\n            fallback: rule.text,\n            bindings: {},\n          }),\n        });\n      }\n    });\n  });\n};\n\nexport default password;\n"],"mappings":"8EAoCA,IAAA,GA7BkC,EAAQ,IACjC,EAAO,aAAa,EAAK,IAAQ,CAClC,GAA6B,MAAQ,IAAQ,IAI7C,OAAO,GAAQ,WAIC,MAAM,QAAQ,EAAM,CACnC,EACD,GAEQ,QAAS,GAAS,CACvB,EAAK,SAAS,EAAI,EACrB,EAAI,SAAS,CACX,KAAM,EAAE,aAAa,OACrB,QAAS,KAAK,UAAU,CACtB,IAAK,EAAK,IACV,SAAU,EAAK,KACf,SAAU,EAAE,CACb,CAAC,CACH,CAAC,EAEJ,EACF"}

package/dist/components/forms/rules/required.mjs

@@ -0,0 +1,2 @@
+import{createRule as e}from"./create-rule.mjs";var t=e(`required`,{fallback:`El campo {attribute} es obligatorio.`,validate:e=>typeof e==`string`?e.trim().length>0:e!=null});export{t as default};
+//# sourceMappingURL=required.mjs.map

package/dist/components/forms/rules/required.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"required.mjs","names":[],"sources":["../../../../src/components/forms/rules/required.ts"],"sourcesContent":["import { createRule } from './create-rule';\n\nexport default createRule('required', {\n  fallback: 'El campo {attribute} es obligatorio.',\n  validate: (val) => {\n    if (typeof val === 'string') return val.trim().length > 0;\n    return val !== null && val !== undefined;\n  },\n});\n"],"mappings":"+CAEA,IAAA,EAAe,EAAW,WAAY,CACpC,SAAU,uCACV,SAAW,GACL,OAAO,GAAQ,SAAiB,EAAI,MAAM,CAAC,OAAS,EACjD,GAAQ,KAElB,CAAC"}

package/dist/components/forms/rules/zod.d.mts

@@ -0,0 +1,298 @@
+import "./create-rule.mjs";
+import { ZodString, ZodType, z } from "zod";
+
+//#region src/components/forms/rules/zod.d.ts
+declare function parseRules(rulesString: string): ZodType;
+declare const z$1: {
+  rules: Record<string, (...args: unknown[]) => ZodString>;
+  parseRules: typeof parseRules;
+  core: typeof z.core;
+  globalRegistry: z.core.$ZodRegistry<z.core.GlobalMeta, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+  registry: typeof z.core.registry;
+  config: typeof z.core.config;
+  $output: typeof z.core.$output;
+  $input: typeof z.core.$input;
+  $brand: typeof z.core.$brand;
+  clone: typeof z.core.util.clone;
+  regexes: typeof z.core.regexes;
+  treeifyError: typeof z.core.treeifyError;
+  prettifyError: typeof z.core.prettifyError;
+  formatError: typeof z.core.formatError;
+  flattenError: typeof z.core.flattenError;
+  TimePrecision: {
+    readonly Any: null;
+    readonly Minute: -1;
+    readonly Second: 0;
+    readonly Millisecond: 3;
+    readonly Microsecond: 6;
+  };
+  util: typeof z.core.util;
+  NEVER: never;
+  toJSONSchema: typeof z.core.toJSONSchema;
+  fromJSONSchema: typeof z.fromJSONSchema;
+  locales: typeof z.core.locales;
+  ZodISODateTime: z.core.$constructor<z.ZodISODateTime, z.core.$ZodISODateTimeDef>;
+  ZodISODate: z.core.$constructor<z.ZodISODate, z.core.$ZodStringFormatDef<"date">>;
+  ZodISOTime: z.core.$constructor<z.ZodISOTime, z.core.$ZodISOTimeDef>;
+  ZodISODuration: z.core.$constructor<z.ZodISODuration, z.core.$ZodStringFormatDef<"duration">>;
+  iso: typeof z.iso;
+  coerce: typeof z.coerce;
+  string(params?: string | z.core.$ZodStringParams): ZodString;
+  string<T extends string>(params?: string | z.core.$ZodStringParams): z.core.$ZodType<T, T>;
+  email(params?: string | z.core.$ZodEmailParams): z.ZodEmail;
+  guid(params?: string | z.core.$ZodGUIDParams): z.ZodGUID;
+  uuid(params?: string | z.core.$ZodUUIDParams): z.ZodUUID;
+  uuidv4(params?: string | z.core.$ZodUUIDv4Params): z.ZodUUID;
+  uuidv6(params?: string | z.core.$ZodUUIDv6Params): z.ZodUUID;
+  uuidv7(params?: string | z.core.$ZodUUIDv7Params): z.ZodUUID;
+  url(params?: string | z.core.$ZodURLParams): z.ZodURL;
+  httpUrl(params?: string | Omit<z.core.$ZodURLParams, "protocol" | "hostname">): z.ZodURL;
+  emoji(params?: string | z.core.$ZodEmojiParams): z.ZodEmoji;
+  nanoid(params?: string | z.core.$ZodNanoIDParams): z.ZodNanoID;
+  cuid(params?: string | z.core.$ZodCUIDParams): z.ZodCUID;
+  cuid2(params?: string | z.core.$ZodCUID2Params): z.ZodCUID2;
+  ulid(params?: string | z.core.$ZodULIDParams): z.ZodULID;
+  xid(params?: string | z.core.$ZodXIDParams): z.ZodXID;
+  ksuid(params?: string | z.core.$ZodKSUIDParams): z.ZodKSUID;
+  ipv4(params?: string | z.core.$ZodIPv4Params): z.ZodIPv4;
+  mac(params?: string | z.core.$ZodMACParams): z.ZodMAC;
+  ipv6(params?: string | z.core.$ZodIPv6Params): z.ZodIPv6;
+  cidrv4(params?: string | z.core.$ZodCIDRv4Params): z.ZodCIDRv4;
+  cidrv6(params?: string | z.core.$ZodCIDRv6Params): z.ZodCIDRv6;
+  base64(params?: string | z.core.$ZodBase64Params): z.ZodBase64;
+  base64url(params?: string | z.core.$ZodBase64URLParams): z.ZodBase64URL;
+  e164(params?: string | z.core.$ZodE164Params): z.ZodE164;
+  jwt(params?: string | z.core.$ZodJWTParams): z.ZodJWT;
+  stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => z.core.util.MaybeAsync<unknown>) | RegExp, _params?: string | z.core.$ZodStringFormatParams): z.ZodCustomStringFormat<Format>;
+  hostname(_params?: string | z.core.$ZodStringFormatParams): z.ZodCustomStringFormat<"hostname">;
+  hex(_params?: string | z.core.$ZodStringFormatParams): z.ZodCustomStringFormat<"hex">;
+  hash<Alg extends z.core.util.HashAlgorithm, Enc extends z.core.util.HashEncoding = "hex">(alg: Alg, params?: {
+    enc?: Enc;
+  } & z.core.$ZodStringFormatParams): z.ZodCustomStringFormat<`${Alg}_${Enc}`>;
+  number(params?: string | z.core.$ZodNumberParams): z.ZodNumber;
+  int(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodInt;
+  float32(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodFloat32;
+  float64(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodFloat64;
+  int32(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodInt32;
+  uint32(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodUInt32;
+  boolean(params?: string | z.core.$ZodBooleanParams): z.ZodBoolean;
+  bigint(params?: string | z.core.$ZodBigIntParams): z.ZodBigInt;
+  int64(params?: string | z.core.$ZodBigIntFormatParams): z.ZodBigIntFormat;
+  uint64(params?: string | z.core.$ZodBigIntFormatParams): z.ZodBigIntFormat;
+  symbol(params?: string | z.core.$ZodSymbolParams): z.ZodSymbol;
+  any(): z.ZodAny;
+  unknown(): z.ZodUnknown;
+  never(params?: string | z.core.$ZodNeverParams): z.ZodNever;
+  date(params?: string | z.core.$ZodDateParams): z.ZodDate;
+  array<T extends z.core.SomeType>(element: T, params?: string | z.core.$ZodArrayParams): z.ZodArray<T>;
+  keyof<T extends z.ZodObject>(schema: T): z.ZodEnum<z.core.util.KeysEnum<T["_zod"]["output"]>>;
+  object<T extends z.core.$ZodLooseShape = Partial<Record<never, z.core.SomeType>>>(shape?: T, params?: string | z.core.$ZodObjectParams): z.ZodObject<z.core.util.Writeable<T>, z.core.$strip>;
+  strictObject<T extends z.core.$ZodLooseShape>(shape: T, params?: string | z.core.$ZodObjectParams): z.ZodObject<T, z.core.$strict>;
+  looseObject<T extends z.core.$ZodLooseShape>(shape: T, params?: string | z.core.$ZodObjectParams): z.ZodObject<T, z.core.$loose>;
+  union<const T extends readonly z.core.SomeType[]>(options: T, params?: string | z.core.$ZodUnionParams): z.ZodUnion<T>;
+  xor<const T extends readonly z.core.SomeType[]>(options: T, params?: string | z.core.$ZodXorParams): z.ZodXor<T>;
+  discriminatedUnion<Types extends readonly [z.core.$ZodTypeDiscriminable, ...z.core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | z.core.$ZodDiscriminatedUnionParams): z.ZodDiscriminatedUnion<Types, Disc>;
+  intersection<T extends z.core.SomeType, U extends z.core.SomeType>(left: T, right: U): z.ZodIntersection<T, U>;
+  tuple<T extends readonly [z.core.SomeType, ...z.core.SomeType[]]>(items: T, params?: string | z.core.$ZodTupleParams): z.ZodTuple<T, null>;
+  tuple<T extends readonly [z.core.SomeType, ...z.core.SomeType[]], Rest extends z.core.SomeType>(items: T, rest: Rest, params?: string | z.core.$ZodTupleParams): z.ZodTuple<T, Rest>;
+  tuple(items: [], params?: string | z.core.$ZodTupleParams): z.ZodTuple<[], null>;
+  record<Key extends z.core.$ZodRecordKey, Value extends z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z.core.$ZodRecordParams): z.ZodRecord<Key, Value>;
+  partialRecord<Key extends z.core.$ZodRecordKey, Value extends z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z.core.$ZodRecordParams): z.ZodRecord<Key & z.core.$partial, Value>;
+  looseRecord<Key extends z.core.$ZodRecordKey, Value extends z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z.core.$ZodRecordParams): z.ZodRecord<Key, Value>;
+  map<Key extends z.core.SomeType, Value extends z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z.core.$ZodMapParams): z.ZodMap<Key, Value>;
+  set<Value extends z.core.SomeType>(valueType: Value, params?: string | z.core.$ZodSetParams): z.ZodSet<Value>;
+  nativeEnum<T extends z.core.util.EnumLike>(entries: T, params?: string | z.core.$ZodEnumParams): z.ZodEnum<T>;
+  literal<const T extends ReadonlyArray<z.core.util.Literal>>(value: T, params?: string | z.core.$ZodLiteralParams): z.ZodLiteral<T[number]>;
+  literal<const T extends z.core.util.Literal>(value: T, params?: string | z.core.$ZodLiteralParams): z.ZodLiteral<T>;
+  file(params?: string | z.core.$ZodFileParams): z.ZodFile;
+  transform<I = unknown, O = I>(fn: (input: I, ctx: z.core.ParsePayload) => O): z.ZodTransform<Awaited<O>, I>;
+  optional<T extends z.core.SomeType>(innerType: T): z.ZodOptional<T>;
+  exactOptional<T extends z.core.SomeType>(innerType: T): z.ZodExactOptional<T>;
+  nullable<T extends z.core.SomeType>(innerType: T): z.ZodNullable<T>;
+  nullish<T extends z.core.SomeType>(innerType: T): z.ZodOptional<z.ZodNullable<T>>;
+  _default<T extends z.core.SomeType>(innerType: T, defaultValue: z.core.util.NoUndefined<z.core.output<T>> | (() => z.core.util.NoUndefined<z.core.output<T>>)): z.ZodDefault<T>;
+  prefault<T extends z.core.SomeType>(innerType: T, defaultValue: z.core.input<T> | (() => z.core.input<T>)): z.ZodPrefault<T>;
+  nonoptional<T extends z.core.SomeType>(innerType: T, params?: string | z.core.$ZodNonOptionalParams): z.ZodNonOptional<T>;
+  success<T extends z.core.SomeType>(innerType: T): z.ZodSuccess<T>;
+  nan(params?: string | z.core.$ZodNaNParams): z.ZodNaN;
+  pipe<const A extends z.core.SomeType, B extends z.core.$ZodType<unknown, z.core.output<A>> = z.core.$ZodType<unknown, z.core.output<A>, z.core.$ZodTypeInternals<unknown, z.core.output<A>>>>(in_: A, out: B | z.core.$ZodType<unknown, z.core.output<A>>): z.ZodPipe<A, B>;
+  codec<const A extends z.core.SomeType, B extends z.core.SomeType = z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(in_: A, out: B, params: {
+    decode: (value: z.core.output<A>, payload: z.core.ParsePayload<z.core.output<A>>) => z.core.util.MaybeAsync<z.core.input<B>>;
+    encode: (value: z.core.input<B>, payload: z.core.ParsePayload<z.core.input<B>>) => z.core.util.MaybeAsync<z.core.output<A>>;
+  }): z.ZodCodec<A, B>;
+  readonly<T extends z.core.SomeType>(innerType: T): z.ZodReadonly<T>;
+  templateLiteral<const Parts extends z.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | z.core.$ZodTemplateLiteralParams): z.ZodTemplateLiteral<z.core.$PartsToTemplateLiteral<Parts>>;
+  lazy<T extends z.core.SomeType>(getter: () => T): z.ZodLazy<T>;
+  promise<T extends z.core.SomeType>(innerType: T): z.ZodPromise<T>;
+  _function(): z.ZodFunction;
+  _function<const In extends ReadonlyArray<z.core.$ZodType>>(params: {
+    input: In;
+  }): z.ZodFunction<z.ZodTuple<In, null>, z.core.$ZodFunctionOut>;
+  _function<const In extends ReadonlyArray<z.core.$ZodType>, const Out extends z.core.$ZodFunctionOut = z.core.$ZodFunctionOut>(params: {
+    input: In;
+    output: Out;
+  }): z.ZodFunction<z.ZodTuple<In, null>, Out>;
+  _function<const In extends z.core.$ZodFunctionIn = z.core.$ZodFunctionArgs>(params: {
+    input: In;
+  }): z.ZodFunction<In, z.core.$ZodFunctionOut>;
+  _function<const Out extends z.core.$ZodFunctionOut = z.core.$ZodFunctionOut>(params: {
+    output: Out;
+  }): z.ZodFunction<z.core.$ZodFunctionIn, Out>;
+  _function<In extends z.core.$ZodFunctionIn = z.core.$ZodFunctionArgs, Out extends z.core.$ZodType = z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>(params?: {
+    input: In;
+    output: Out;
+  }): z.ZodFunction<In, Out>;
+  check<O = unknown>(fn: z.core.CheckFn<O>): z.core.$ZodCheck<O>;
+  custom<O>(fn?: (data: unknown) => unknown, _params?: string | z.core.$ZodCustomParams | undefined): z.ZodCustom<O, O>;
+  refine<T>(fn: (arg: NoInfer<T>) => z.core.util.MaybeAsync<unknown>, _params?: string | z.core.$ZodCustomParams): z.core.$ZodCheck<T>;
+  superRefine<T>(fn: (arg: T, payload: z.core.$RefinementCtx<T>) => void | Promise<void>): z.core.$ZodCheck<T>;
+  json(params?: string | z.core.$ZodCustomParams): z.ZodJSONSchema;
+  preprocess<A, U extends z.core.SomeType, B = unknown>(fn: (arg: B, ctx: z.core.$RefinementCtx) => A, schema: U): z.ZodPipe<z.ZodTransform<A, B>, U>;
+  ZodType: z.core.$constructor<ZodType>;
+  _ZodString: z.core.$constructor<z._ZodString>;
+  ZodString: z.core.$constructor<ZodString>;
+  ZodStringFormat: z.core.$constructor<z.ZodStringFormat>;
+  ZodEmail: z.core.$constructor<z.ZodEmail>;
+  ZodGUID: z.core.$constructor<z.ZodGUID>;
+  ZodUUID: z.core.$constructor<z.ZodUUID>;
+  ZodURL: z.core.$constructor<z.ZodURL>;
+  ZodEmoji: z.core.$constructor<z.ZodEmoji>;
+  ZodNanoID: z.core.$constructor<z.ZodNanoID>;
+  ZodCUID: z.core.$constructor<z.ZodCUID>;
+  ZodCUID2: z.core.$constructor<z.ZodCUID2>;
+  ZodULID: z.core.$constructor<z.ZodULID>;
+  ZodXID: z.core.$constructor<z.ZodXID>;
+  ZodKSUID: z.core.$constructor<z.ZodKSUID>;
+  ZodIPv4: z.core.$constructor<z.ZodIPv4>;
+  ZodMAC: z.core.$constructor<z.ZodMAC>;
+  ZodIPv6: z.core.$constructor<z.ZodIPv6>;
+  ZodCIDRv4: z.core.$constructor<z.ZodCIDRv4>;
+  ZodCIDRv6: z.core.$constructor<z.ZodCIDRv6>;
+  ZodBase64: z.core.$constructor<z.ZodBase64>;
+  ZodBase64URL: z.core.$constructor<z.ZodBase64URL>;
+  ZodE164: z.core.$constructor<z.ZodE164>;
+  ZodJWT: z.core.$constructor<z.ZodJWT>;
+  ZodCustomStringFormat: z.core.$constructor<z.ZodCustomStringFormat>;
+  ZodNumber: z.core.$constructor<z.ZodNumber>;
+  ZodNumberFormat: z.core.$constructor<z.ZodNumberFormat>;
+  ZodBoolean: z.core.$constructor<z.ZodBoolean>;
+  ZodBigInt: z.core.$constructor<z.ZodBigInt>;
+  ZodBigIntFormat: z.core.$constructor<z.ZodBigIntFormat>;
+  ZodSymbol: z.core.$constructor<z.ZodSymbol>;
+  ZodUndefined: z.core.$constructor<z.ZodUndefined>;
+  undefined: typeof z.undefined;
+  ZodNull: z.core.$constructor<z.ZodNull>;
+  null: typeof z.null;
+  ZodAny: z.core.$constructor<z.ZodAny>;
+  ZodUnknown: z.core.$constructor<z.ZodUnknown>;
+  ZodNever: z.core.$constructor<z.ZodNever>;
+  ZodVoid: z.core.$constructor<z.ZodVoid>;
+  void: typeof z.void;
+  ZodDate: z.core.$constructor<z.ZodDate>;
+  ZodArray: z.core.$constructor<z.ZodArray>;
+  ZodObject: z.core.$constructor<z.ZodObject>;
+  ZodUnion: z.core.$constructor<z.ZodUnion>;
+  ZodXor: z.core.$constructor<z.ZodXor>;
+  ZodDiscriminatedUnion: z.core.$constructor<z.ZodDiscriminatedUnion>;
+  ZodIntersection: z.core.$constructor<z.ZodIntersection>;
+  ZodTuple: z.core.$constructor<z.ZodTuple>;
+  ZodRecord: z.core.$constructor<z.ZodRecord>;
+  ZodMap: z.core.$constructor<z.ZodMap>;
+  ZodSet: z.core.$constructor<z.ZodSet>;
+  ZodEnum: z.core.$constructor<z.ZodEnum>;
+  enum: typeof z.enum;
+  ZodLiteral: z.core.$constructor<z.ZodLiteral>;
+  ZodFile: z.core.$constructor<z.ZodFile>;
+  ZodTransform: z.core.$constructor<z.ZodTransform>;
+  ZodOptional: z.core.$constructor<z.ZodOptional>;
+  ZodExactOptional: z.core.$constructor<z.ZodExactOptional>;
+  ZodNullable: z.core.$constructor<z.ZodNullable>;
+  ZodDefault: z.core.$constructor<z.ZodDefault>;
+  ZodPrefault: z.core.$constructor<z.ZodPrefault>;
+  ZodNonOptional: z.core.$constructor<z.ZodNonOptional>;
+  ZodSuccess: z.core.$constructor<z.ZodSuccess>;
+  ZodCatch: z.core.$constructor<z.ZodCatch>;
+  catch: typeof z.catch;
+  ZodNaN: z.core.$constructor<z.ZodNaN>;
+  ZodPipe: z.core.$constructor<z.ZodPipe>;
+  ZodCodec: z.core.$constructor<z.ZodCodec>;
+  ZodReadonly: z.core.$constructor<z.ZodReadonly>;
+  ZodTemplateLiteral: z.core.$constructor<z.ZodTemplateLiteral>;
+  ZodLazy: z.core.$constructor<z.ZodLazy>;
+  ZodPromise: z.core.$constructor<z.ZodPromise>;
+  ZodFunction: z.core.$constructor<z.ZodFunction>;
+  function: typeof z._function;
+  ZodCustom: z.core.$constructor<z.ZodCustom>;
+  describe: typeof z.core.describe;
+  meta: typeof z.core.meta;
+  instanceof: typeof z.instanceof;
+  stringbool: (_params?: string | z.core.$ZodStringBoolParams) => z.ZodCodec<ZodString, z.ZodBoolean>;
+  lt: typeof z.core._lt;
+  lte: typeof z.core._lte;
+  gt: typeof z.core._gt;
+  gte: typeof z.core._gte;
+  positive: typeof z.core._positive;
+  negative: typeof z.core._negative;
+  nonpositive: typeof z.core._nonpositive;
+  nonnegative: typeof z.core._nonnegative;
+  multipleOf: typeof z.core._multipleOf;
+  maxSize: typeof z.core._maxSize;
+  minSize: typeof z.core._minSize;
+  size: typeof z.core._size;
+  maxLength: typeof z.core._maxLength;
+  minLength: typeof z.core._minLength;
+  length: typeof z.core._length;
+  regex: typeof z.core._regex;
+  lowercase: typeof z.core._lowercase;
+  uppercase: typeof z.core._uppercase;
+  includes: typeof z.core._includes;
+  startsWith: typeof z.core._startsWith;
+  endsWith: typeof z.core._endsWith;
+  property: typeof z.core._property;
+  mime: typeof z.core._mime;
+  overwrite: typeof z.core._overwrite;
+  normalize: typeof z.core._normalize;
+  trim: typeof z.core._trim;
+  toLowerCase: typeof z.core._toLowerCase;
+  toUpperCase: typeof z.core._toUpperCase;
+  slugify: typeof z.core._slugify;
+  ZodError: z.core.$constructor<z.ZodError>;
+  ZodRealError: z.core.$constructor<z.ZodError>;
+  parse: <T extends z.core.$ZodType>(schema: T, value: unknown, _ctx?: z.core.ParseContext<z.core.$ZodIssue>, _params?: {
+    callee?: z.core.util.AnyFunc;
+    Err?: z.core.$ZodErrorClass;
+  }) => z.core.output<T>;
+  parseAsync: <T extends z.core.$ZodType>(schema: T, value: unknown, _ctx?: z.core.ParseContext<z.core.$ZodIssue>, _params?: {
+    callee?: z.core.util.AnyFunc;
+    Err?: z.core.$ZodErrorClass;
+  }) => Promise<z.core.output<T>>;
+  safeParse: <T extends z.core.$ZodType>(schema: T, value: unknown, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.ZodSafeParseResult<z.core.output<T>>;
+  safeParseAsync: <T extends z.core.$ZodType>(schema: T, value: unknown, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<z.core.output<T>>>;
+  encode: <T extends z.core.$ZodType>(schema: T, value: z.core.output<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.core.input<T>;
+  decode: <T extends z.core.$ZodType>(schema: T, value: z.core.input<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.core.output<T>;
+  encodeAsync: <T extends z.core.$ZodType>(schema: T, value: z.core.output<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.core.input<T>>;
+  decodeAsync: <T extends z.core.$ZodType>(schema: T, value: z.core.input<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.core.output<T>>;
+  safeEncode: <T extends z.core.$ZodType>(schema: T, value: z.core.output<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.ZodSafeParseResult<z.core.input<T>>;
+  safeDecode: <T extends z.core.$ZodType>(schema: T, value: z.core.input<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => z.ZodSafeParseResult<z.core.output<T>>;
+  safeEncodeAsync: <T extends z.core.$ZodType>(schema: T, value: z.core.output<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<z.core.input<T>>>;
+  safeDecodeAsync: <T extends z.core.$ZodType>(schema: T, value: z.core.input<T>, _ctx?: z.core.ParseContext<z.core.$ZodIssue>) => Promise<z.ZodSafeParseResult<z.core.output<T>>>;
+  setErrorMap(map: z.core.$ZodErrorMap): void;
+  getErrorMap(): z.core.$ZodErrorMap<z.core.$ZodIssue> | undefined;
+  ZodIssueCode: {
+    readonly invalid_type: "invalid_type";
+    readonly too_big: "too_big";
+    readonly too_small: "too_small";
+    readonly invalid_format: "invalid_format";
+    readonly not_multiple_of: "not_multiple_of";
+    readonly unrecognized_keys: "unrecognized_keys";
+    readonly invalid_union: "invalid_union";
+    readonly invalid_key: "invalid_key";
+    readonly invalid_element: "invalid_element";
+    readonly invalid_value: "invalid_value";
+    readonly custom: "custom";
+  };
+  ZodFirstPartyTypeKind: typeof z.ZodFirstPartyTypeKind;
+};
+//#endregion
+export { z$1 as z };
+//# sourceMappingURL=zod.d.mts.map

package/dist/components/forms/rules/zod.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.d.mts","names":[],"sources":["../../../../src/components/forms/rules/zod.ts"],"mappings":";;;;iBA+CgB,UAAA,CAAW,WAAA,WAAsB,OAAA;AAAA,cAwBpC,GAAA;gDA3BwD,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgCk3c,GAAA;EAAA;;;;;;;;;;;;;;;;;0EAAwgQ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAu7pB,CAAA,CAAA,IAAA,CAAA,oBAAA,KAAA,CAAA,CAAA,QAAA,CAAA,SAAA,EAAA,CAAA,CAAA,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAhEr32C,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,GAAA,OAAA;aAEqB,CAAA,CAAA,IAAA,CAAA,IAAA,CAAA,OAAA;UAA6B,CAAA,CAAA,IAAA,CAAA,cAAA;EAAA;4EAStC,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,GAAA,OAAA;aACI,CAAA,CAAA,IAAA,CAAA,IAAA,CAAA,OAAA;UAA6B,CAAA,CAAA,IAAA,CAAA,cAAA;EAAA;2EAGO,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,CAAA,CAAA,kBAAA,CAAA,CAAA,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;gFAQ/C,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,OAAA,CAAA,CAAA,CAAA,kBAAA,CAAA,CAAA,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;iFAMY,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,CAAA,CAAA,IAAA,CAAA,KAAA,CAAA,CAAA;gFAMc,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,CAAA,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;sFAGrB,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,OAAA,CAAA,CAAA,CAAA,IAAA,CAAA,KAAA,CAAA,CAAA;qFAMQ,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,OAAA,CAAA,CAAA,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;qFAEyC,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,CAAA,CAAA,kBAAA,CAAA,CAAA,CAAA,IAAA,CAAA,KAAA,CAAA,CAAA;oFASrD,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,CAAA,CAAA,kBAAA,CAAA,CAAA,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;0FASkF,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,OAAA,CAAA,CAAA,CAAA,kBAAA,CAAA,CAAA,CAAA,IAAA,CAAA,KAAA,CAAA,CAAA;yFAA0L,CAAA,CAAA,IAAA,CAAA,YAAA,CAAA,CAAA,CAAA,IAAA,CAAA,SAAA,MAAA,OAAA,CAAA,CAAA,CAAA,kBAAA,CAAA,CAAA,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA"}

package/dist/components/forms/rules/zod.mjs

@@ -0,0 +1,2 @@
+import{ruleDefinitions as e}from"./index.mjs";import{ZodString as t,z as n}from"zod";function r(t){for(let n of Object.keys(e)){let i=n;i in t||(t[i]=function(...t){return r(e[i](this,...t))})}return t}for(let n of Object.keys(e)){let i=n;t.prototype[i]=function(...t){return r(e[i](this,...t))}}const i=Object.keys(e).reduce((e,t)=>{let r=t;return e[r]=(...e)=>n.string()[r](...e),e},{});function a(e){let t=e.split(`|`).map(e=>e.trim()),r=n.string();for(let e of t){let[t,n]=e.split(`:`);if(t in i&&typeof r[t]==`function`){let e=n?[n]:[];r=r[t](...e)}}return n.preprocess(e=>e??``,r)}const o={...n,rules:i,parseRules:a};export{a as parseRules,o as z};
+//# sourceMappingURL=zod.mjs.map

package/dist/components/forms/rules/zod.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.mjs","names":["zod","z"],"sources":["../../../../src/components/forms/rules/zod.ts"],"sourcesContent":["import { ZodString, type ZodType, z as zod } from 'zod';\n\nimport { ruleDefinitions } from './index';\n\nexport type { RuleDefinition } from './create-rule';\n\nfunction extendSchema(schema: ZodType): ZodType {\n  for (const key of Object.keys(ruleDefinitions)) {\n    const ruleName = key as keyof typeof ruleDefinitions;\n    if (!(ruleName in schema)) {\n      (schema as unknown as Record<string, unknown>)[ruleName] = function (\n        ...args: unknown[]\n      ) {\n        return extendSchema(\n          ruleDefinitions[ruleName](this as unknown as ZodType, ...args),\n        );\n      };\n    }\n  }\n  return schema;\n}\n\nfor (const key of Object.keys(ruleDefinitions)) {\n  const ruleName = key as keyof typeof ruleDefinitions;\n  (ZodString.prototype as unknown as Record<string, unknown>)[ruleName] =\n    function (...args: unknown[]) {\n      return extendSchema(\n        ruleDefinitions[ruleName](this as unknown as ZodType, ...args),\n      );\n    };\n}\n\nconst rules = Object.keys(ruleDefinitions).reduce(\n  (acc, key) => {\n    const ruleName = key as keyof typeof ruleDefinitions;\n    acc[ruleName] = (...args: unknown[]) =>\n      (\n        zod.string() as unknown as Record<\n          string,\n          (...args: unknown[]) => ZodString\n        >\n      )[ruleName](...args);\n    return acc;\n  },\n  {} as Record<keyof typeof ruleDefinitions, (...args: unknown[]) => ZodString>,\n);\n\nexport function parseRules(rulesString: string): ZodType {\n  const ruleStrings = rulesString.split('|').map((r) => r.trim());\n  let schema = zod.string() as unknown as Record<\n    string,\n    (...args: unknown[]) => ZodType\n  >;\n\n  for (const ruleString of ruleStrings) {\n    const [ruleName, argsString] = ruleString.split(':');\n    if (ruleName in rules && typeof schema[ruleName] === 'function') {\n      const args = argsString ? [argsString] : [];\n      schema = schema[ruleName](...args) as unknown as Record<\n        string,\n        (...args: unknown[]) => ZodType\n      >;\n    }\n  }\n\n  return zod.preprocess(\n    (val) => (val === undefined || val === null ? '' : val),\n    schema as unknown as ZodType,\n  );\n}\n\nexport const z = {\n  ...zod,\n  rules,\n  parseRules,\n};\n"],"mappings":"qFAMA,SAAS,EAAa,EAA0B,CAC9C,IAAK,IAAM,KAAO,OAAO,KAAK,EAAgB,CAAE,CAC9C,IAAM,EAAW,EACX,KAAY,IACf,EAA8C,GAAY,SACzD,GAAG,EACH,CACA,OAAO,EACL,EAAgB,GAAU,KAA4B,GAAG,EAAK,CAC/D,GAIP,OAAO,EAGT,IAAK,IAAM,KAAO,OAAO,KAAK,EAAgB,CAAE,CAC9C,IAAM,EAAW,EAChB,EAAU,UAAiD,GAC1D,SAAU,GAAG,EAAiB,CAC5B,OAAO,EACL,EAAgB,GAAU,KAA4B,GAAG,EAAK,CAC/D,EAIP,MAAM,EAAQ,OAAO,KAAK,EAAgB,CAAC,QACxC,EAAK,IAAQ,CACZ,IAAM,EAAW,EAQjB,MAPA,GAAI,IAAa,GAAG,IAEhBA,EAAI,QAAQ,CAIZ,GAAU,GAAG,EAAK,CACf,GAET,EAAE,CACH,CAED,SAAgB,EAAW,EAA8B,CACvD,IAAM,EAAc,EAAY,MAAM,IAAI,CAAC,IAAK,GAAM,EAAE,MAAM,CAAC,CAC3D,EAASA,EAAI,QAAQ,CAKzB,IAAK,IAAM,KAAc,EAAa,CACpC,GAAM,CAAC,EAAU,GAAc,EAAW,MAAM,IAAI,CACpD,GAAI,KAAY,GAAS,OAAO,EAAO,IAAc,WAAY,CAC/D,IAAM,EAAO,EAAa,CAAC,EAAW,CAAG,EAAE,CAC3C,EAAS,EAAO,GAAU,GAAG,EAAK,EAOtC,OAAOA,EAAI,WACR,GAAS,GAAoC,GAC9C,EACD,CAGH,MAAaC,EAAI,CACf,GAAGD,EACH,QACA,aACD"}