@stacksjs/stx 0.2.95 → 0.2.96

package/dist/forms.js

@@ -1,2 +1,709 @@
-// @bun
-import{Nv as a,Ov as b,Pv as c,Qv as d,Rv as e,Sv as f,Tv as g,Uv as h,Vv as i,Wv as j,Xv as k,Yv as l,Zv as m,_v as n}from"./chunk-4deg33rw.js";import"./chunk-w3b6m427.js";import"./chunk-xv34zbp4.js";export{l as validateValueEnhanced,m as validateFormEnhanced,h as validateFields,g as validateField,f as registerValidationRule,k as registerEnhancedValidationRule,i as processValidateDirective,b as processForms,d as processFormInputDirectives,e as processErrorDirective,c as processBasicFormDirectives,n as generateValidationScript,j as enhancedValidationRules,a as defaultFormClasses};
+import crypto from "node:crypto";
+import { isExpressionSafe, safeEvaluate } from "./safe-evaluator.js";
+function escapeAttr(str) {
+  return String(str ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+export const defaultFormClasses = {
+  input: "form-control",
+  inputError: "is-invalid",
+  checkInput: "form-check-input",
+  label: "form-label",
+  errorFeedback: "invalid-feedback"
+};
+function getFormClasses(options) {
+  return {
+    ...defaultFormClasses,
+    ...options.forms?.classes
+  };
+}
+function buildClassString(existingClass, defaultClass, hasError, errorClass) {
+  const baseClass = existingClass || defaultClass;
+  return hasError ? `${baseClass} ${errorClass}` : baseClass;
+}
+function genId() {
+  return crypto.randomUUID();
+}
+export function processForms(template, context, _filePath, options) {
+  const classes = getFormClasses(options);
+  let output = template;
+  output = processValidateDirective(output, context);
+  output = processBasicFormDirectives(output, context);
+  output = processFormInputDirectives(output, context, classes);
+  output = processErrorDirective(output, context, classes);
+  return output;
+}
+export function processBasicFormDirectives(template, context) {
+  let result = template;
+  result = result.replace(/@csrf/g, () => {
+    if (!context.csrf || typeof context.csrf !== "object") {
+      const token = genId();
+      context.csrf = { token };
+    }
+    if (context.csrf.field)
+      return context.csrf.field;
+    if (context.csrf.token)
+      return `<input type="hidden" name="_token" value="${escapeAttr(context.csrf.token)}">`;
+    return '<input type="hidden" name="_token" value="">';
+  });
+  result = result.replace(/@method\(['"]([^'"]+)['"]\)/g, (match, method) => {
+    const upperMethod = method.toUpperCase();
+    if (method && !["GET", "POST"].includes(upperMethod))
+      return `<input type="hidden" name="_method" value="${escapeAttr(upperMethod)}">`;
+    return match;
+  });
+  return result;
+}
+export function processFormInputDirectives(template, context, classes = defaultFormClasses) {
+  let result = template;
+  result = result.replace(/@form\(\s*(?:(?:'([^']+)'|"([^"]+)")\s*)?(?:,\s*(?:'([^']+)'|"([^"]+)")?)?\s*(?:,\s*\{([^}]+)\}\s*)?\)/g, (_match, singleQuoteMethod, doubleQuoteMethod, singleQuoteAction, doubleQuoteAction, attributes = "") => {
+    const method = singleQuoteMethod || doubleQuoteMethod || "POST", action = singleQuoteAction || doubleQuoteAction || "", attrs = parseAttributes(attributes), methodStr = method.toUpperCase(), htmlMethod = ["GET", "POST"].includes(methodStr) ? methodStr : "POST";
+    let formHtml = `<form method="${escapeAttr(htmlMethod)}" action="${escapeAttr(action)}"${attrs ? ` ${attrs}` : ""}>`;
+    formHtml += `
+  ${processBasicFormDirectives("@csrf", context)}`;
+    if (!["GET", "POST"].includes(methodStr))
+      formHtml += `
+  ${processBasicFormDirectives(`@method('${methodStr}')`, context)}`;
+    return formHtml;
+  });
+  result = result.replace(/@endform/g, "</form>");
+  result = result.replace(/@input\(\s*(?:'([^']+)'|"([^"]+)")\s*(?:,\s*(?:(?:'([^']*)'|"([^"]*)")\s*)?)?(?:,\s*\{([^}]+)\})?\s*\)/g, (_match, singleQuoteName, doubleQuoteName, singleQuoteValue, doubleQuoteValue, attributes = "") => {
+    const name = singleQuoteName || doubleQuoteName || "", value = singleQuoteValue || doubleQuoteValue || "", attrs = parseAttributes(attributes), rawOldValue = getOldValue(name, context), oldValue = rawOldValue !== void 0 && rawOldValue !== null ? rawOldValue : value || "", typeMatch = attrs.match(/type=['"]([^'"]+)['"]/i), type = typeMatch ? typeMatch[1] : "text", hasError = hasFieldError(name, context), classMatch = attrs.match(/class=['"]([^'"]+)['"]/i), className = buildClassString(classMatch ? classMatch[1] : "", classes.input, hasError, classes.inputError);
+    let attrsWithoutClassAndType = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    attrsWithoutClassAndType = attrsWithoutClassAndType.replace(/type=['"][^'"]+['"]/i, "");
+    return `<input type="${escapeAttr(type)}" name="${escapeAttr(name)}" value="${escapeAttr(oldValue)}" class="${className}"${attrsWithoutClassAndType ? ` ${attrsWithoutClassAndType}` : ""}>`;
+  });
+  result = result.replace(/@textarea\(\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]+)\})?\)([\s\S]*?)@endtextarea/g, (_match, name, attributes = "", content = "") => {
+    const attrs = parseAttributes(attributes), oldValue = getOldValue(name, context) || content.trim(), hasError = hasFieldError(name, context), classMatch = attrs.match(/class=['"]([^'"]+)['"]/i), className = buildClassString(classMatch ? classMatch[1] : "", classes.input, hasError, classes.inputError), attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    return `<textarea name="${escapeAttr(name)}" class="${className}"${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>${escapeAttr(oldValue)}</textarea>`;
+  });
+  result = result.replace(/@select\(\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]+)\})?\)([\s\S]*?)@endselect/g, (_match, name, attributes = "", content) => {
+    const attrs = parseAttributes(attributes), oldValue = getOldValue(name, context), hasError = hasFieldError(name, context), classMatch = attrs.match(/class=['"]([^'"]+)['"]/i), className = buildClassString(classMatch ? classMatch[1] : "", classes.input, hasError, classes.inputError), attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    let processedContent = content;
+    if (oldValue !== void 0)
+      processedContent = content.replace(/(<option[^>]*value=['"]([^'"]+)['"][^>]*>)/gi, (optionMatch, optionTag, optionValue) => {
+        if ((Array.isArray(oldValue) ? oldValue.some((v) => String(v) === optionValue) : String(oldValue) === optionValue) && !optionTag.includes("selected"))
+          return optionTag.replace(/(<option)/, "$1 selected");
+        return optionMatch;
+      });
+    return `<select name="${escapeAttr(name)}" class="${className}"${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>${processedContent}</select>`;
+  });
+  result = result.replace(/@checkbox\(\s*['"]([^'"]+)['"]\s*(?:,\s*['"]([^'"]+)['"]\s*)?(?:,\s*\{([^}]+)\})?\)/g, (_match, name, value = "1", attributes = "") => {
+    const attrs = parseAttributes(attributes), oldValues = getOldValue(name, context), isChecked = oldValues !== void 0 && (Array.isArray(oldValues) ? oldValues.some((v) => String(v) === value) : oldValues === !0 || String(oldValues) === value), classMatch = attrs.match(/class=['"]([^'"]+)['"]/i), className = classMatch ? classMatch[1] : classes.checkInput, attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    return `<input type="checkbox" name="${escapeAttr(name)}" value="${escapeAttr(value)}" class="${className}"${isChecked ? " checked" : ""}${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>`;
+  });
+  result = result.replace(/@radio\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]+)\})?\)/g, (_match, name, value, attributes = "") => {
+    const attrs = parseAttributes(attributes), oldValue = getOldValue(name, context), isChecked = oldValue !== void 0 && oldValue === value, classMatch = attrs.match(/class=['"]([^'"]+)['"]/i), className = classMatch ? classMatch[1] : classes.checkInput, attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    return `<input type="radio" name="${escapeAttr(name)}" value="${escapeAttr(value)}" class="${className}"${isChecked ? " checked" : ""}${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>`;
+  });
+  result = result.replace(/@file\(\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]+)\})?\)/g, (_match, name, attributes = "") => {
+    const attrs = parseAttributes(attributes), acceptMatch = attrs.match(/accept=['"]([^'"]+)['"]/i), accept = acceptMatch ? acceptMatch[1] : "", isMultiple = attrs.includes("multiple"), hasError = hasFieldError(name, context), classMatch = attrs.match(/class=['"]([^'"]+)['"]/i), className = buildClassString(classMatch ? classMatch[1] : "", classes.input, hasError, classes.inputError), attrsWithoutHandled = attrs.replace(/class=['"][^'"]+['"]/gi, "").replace(/accept=['"][^'"]+['"]/gi, "").replace(/\bmultiple\b/gi, "").trim(), parts = [
+      `<input type="file" name="${escapeAttr(name)}"`,
+      `class="${className}"`
+    ];
+    if (accept)
+      parts.push(`accept="${escapeAttr(accept)}"`);
+    if (isMultiple)
+      parts.push("multiple");
+    if (attrsWithoutHandled)
+      parts.push(attrsWithoutHandled);
+    return `${parts.join(" ")}>`;
+  });
+  result = result.replace(/@label\(\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]+)\})?\)([\s\S]*?)@endlabel/g, (_match, forAttr, attributes = "", content) => {
+    const attrs = parseAttributes(attributes), classMatch = attrs.match(/class=['"]([^'"]+)['"]/i), className = classMatch ? classMatch[1] : classes.label, attrsWithoutClass = attrs.replace(/class=['"][^'"]+['"]/i, "");
+    return `<label for="${escapeAttr(forAttr)}" class="${className}"${attrsWithoutClass ? ` ${attrsWithoutClass}` : ""}>${content}</label>`;
+  });
+  return result;
+}
+export function processErrorDirective(template, context, _classes = defaultFormClasses) {
+  return template.replace(/@error\(['"]([^'"]+)['"]\)([\s\S]*?)@enderror/g, (match, field, content) => {
+    try {
+      if (hasFieldError(field, context))
+        return content.replace(/\{\{([^}]+)\}\}/g, (_, expr) => {
+          try {
+            if (expr.trim() === "$message" || expr.trim() === "message")
+              return getErrorMessage(field, context);
+            if (expr.trim().includes("errors.first") || expr.trim().includes("$errors.first")) {
+              if (typeof context.errors?.first === "function")
+                return context.errors.first(field);
+              return getErrorMessage(field, context);
+            }
+            const trimmedExpr = expr.trim();
+            if (isExpressionSafe(trimmedExpr)) {
+              const result = safeEvaluate(trimmedExpr, context);
+              return result !== void 0 ? String(result) : trimmedExpr;
+            }
+            return trimmedExpr;
+          } catch {
+            return expr;
+          }
+        });
+      return "";
+    } catch (error) {
+      console.error("Error processing @error directive:", error);
+      return match;
+    }
+  });
+}
+function hasFieldError(field, context) {
+  if (!context.errors)
+    return !1;
+  if (typeof context.errors.has === "function")
+    return context.errors.has(field);
+  if (typeof context.errors === "object")
+    return Object.prototype.hasOwnProperty.call(context.errors, field);
+  return !1;
+}
+function getErrorMessage(field, context) {
+  if (!context.errors)
+    return "";
+  if (typeof context.errors.get === "function")
+    return context.errors.get(field);
+  if (typeof context.errors === "object" && Object.prototype.hasOwnProperty.call(context.errors, field)) {
+    const error = context.errors[field];
+    return Array.isArray(error) ? error[0] : String(error);
+  }
+  return "";
+}
+function getOldValue(field, context) {
+  let value;
+  if (context.old && typeof context.old === "function")
+    return context.old(field);
+  if (context.old && typeof context.old === "object")
+    return context.old[field];
+  if (field.endsWith("[]")) {
+    const baseName = field.slice(0, -2);
+    value = context[baseName];
+    if (value !== void 0)
+      return value;
+  }
+  return context[field];
+}
+function parseAttributes(attributesStr) {
+  if (!attributesStr.trim())
+    return "";
+  const attrs = [], trimmed = attributesStr.trim(), attrRegex = /([\w-]+)\s*:\s*(['"]?)([^,'"]*)\2(?:\s*,\s*|\s*$)/g;
+  let match;
+  while ((match = attrRegex.exec(trimmed)) !== null) {
+    const [, name, , value] = match;
+    attrs.push(`${name}="${value.trim()}"`);
+  }
+  return attrs.join(" ");
+}
+const validationRules = {
+  required: (value, _params, field) => {
+    if (value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0)
+      return `The ${field} field is required.`;
+    return null;
+  },
+  email: (value, _params, field) => {
+    if (!value)
+      return null;
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value)))
+      return `The ${field} field must be a valid email address.`;
+    return null;
+  },
+  min: (value, params, field) => {
+    if (!value)
+      return null;
+    const min = Number(params[0]);
+    if (typeof value === "string" && value.length < min)
+      return `The ${field} field must be at least ${min} characters.`;
+    if (typeof value === "number" && value < min)
+      return `The ${field} field must be at least ${min}.`;
+    if (Array.isArray(value) && value.length < min)
+      return `The ${field} field must have at least ${min} items.`;
+    return null;
+  },
+  max: (value, params, field) => {
+    if (!value)
+      return null;
+    const max = Number(params[0]);
+    if (typeof value === "string" && value.length > max)
+      return `The ${field} field must not exceed ${max} characters.`;
+    if (typeof value === "number" && value > max)
+      return `The ${field} field must not exceed ${max}.`;
+    if (Array.isArray(value) && value.length > max)
+      return `The ${field} field must not have more than ${max} items.`;
+    return null;
+  },
+  confirmed: (value, params, field) => {
+    if (params[0] !== void 0 && value !== params[0])
+      return `The ${field} confirmation does not match.`;
+    return null;
+  },
+  numeric: (value, _params, field) => {
+    if (!value)
+      return null;
+    if (Number.isNaN(Number(value)))
+      return `The ${field} field must be a number.`;
+    return null;
+  },
+  integer: (value, _params, field) => {
+    if (!value)
+      return null;
+    if (!Number.isInteger(Number(value)))
+      return `The ${field} field must be an integer.`;
+    return null;
+  },
+  alpha: (value, _params, field) => {
+    if (!value)
+      return null;
+    if (!/^[a-z]+$/i.test(String(value)))
+      return `The ${field} field must only contain letters.`;
+    return null;
+  },
+  alphanumeric: (value, _params, field) => {
+    if (!value)
+      return null;
+    if (!/^[a-z0-9]+$/i.test(String(value)))
+      return `The ${field} field must only contain letters and numbers.`;
+    return null;
+  },
+  url: (value, _params, field) => {
+    if (!value)
+      return null;
+    try {
+      return new URL(String(value)) ? null : null;
+    } catch {
+      return `The ${field} field must be a valid URL.`;
+    }
+  },
+  regex: (value, params, field) => {
+    if (!value)
+      return null;
+    try {
+      if (!new RegExp(params[0]).test(String(value)))
+        return `The ${field} field format is invalid.`;
+      return null;
+    } catch {
+      return `The ${field} field has an invalid validation pattern.`;
+    }
+  },
+  in: (value, params, field) => {
+    if (!value)
+      return null;
+    if (!params.includes(String(value)))
+      return `The ${field} field must be one of: ${params.join(", ")}.`;
+    return null;
+  },
+  notIn: (value, params, field) => {
+    if (!value)
+      return null;
+    if (params.includes(String(value)))
+      return `The ${field} field must not be: ${params.join(", ")}.`;
+    return null;
+  },
+  date: (value, _params, field) => {
+    if (!value)
+      return null;
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+      return `The ${field} field must be a valid date.`;
+    return null;
+  },
+  before: (value, params, field) => {
+    if (!value)
+      return null;
+    const date = new Date(value), beforeDate = new Date(params[0]);
+    if (date >= beforeDate)
+      return `The ${field} field must be before ${params[0]}.`;
+    return null;
+  },
+  after: (value, params, field) => {
+    if (!value)
+      return null;
+    const date = new Date(value), afterDate = new Date(params[0]);
+    if (date <= afterDate)
+      return `The ${field} field must be after ${params[0]}.`;
+    return null;
+  }
+};
+export function registerValidationRule(name, validator) {
+  validationRules[name] = validator;
+}
+function parseValidationRule(ruleStr) {
+  const [name, ...paramParts] = ruleStr.split(":"), params = paramParts.length > 0 ? paramParts.join(":").split(",") : [];
+  return { name: name.trim(), params };
+}
+export function validateField(field, value, rules, context = {}) {
+  const errors = [], ruleList = rules.split("|").map((r) => r.trim()).filter(Boolean);
+  for (const ruleStr of ruleList) {
+    const rule = parseValidationRule(ruleStr), validator = validationRules[rule.name];
+    if (!validator) {
+      console.warn(`Unknown validation rule: ${rule.name}`);
+      continue;
+    }
+    if (rule.name === "confirmed") {
+      const confirmField = `${field}_confirmation`;
+      rule.params = [context[confirmField]];
+    }
+    const error = validator(value, rule.params || [], field);
+    if (error)
+      errors.push(rule.message || error);
+  }
+  return {
+    field,
+    valid: errors.length === 0,
+    errors
+  };
+}
+export function validateFields(data, rules) {
+  const errors = {};
+  for (const [field, fieldRules] of Object.entries(rules)) {
+    const result = validateField(field, data[field], fieldRules, data);
+    if (!result.valid)
+      errors[field] = result.errors;
+  }
+  return errors;
+}
+export function processValidateDirective(template, _context) {
+  return template.replace(/@validate\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]\s*(?:,\s*\{([^}]*)\})?\s*\)/g, (_match, field, rules, _options) => {
+    const ruleList = rules.split("|").map((r) => r.trim()), attrs = [];
+    for (const ruleStr of ruleList) {
+      const rule = parseValidationRule(ruleStr);
+      switch (rule.name) {
+        case "required":
+          attrs.push("required");
+          break;
+        case "email":
+          attrs.push('type="email"');
+          break;
+        case "url":
+          attrs.push('type="url"');
+          break;
+        case "numeric":
+        case "integer":
+          attrs.push('type="number"');
+          if (rule.name === "integer")
+            attrs.push('step="1"');
+          break;
+        case "min":
+          if (rule.params?.[0])
+            attrs.push(`minlength="${rule.params[0]}"`);
+          break;
+        case "max":
+          if (rule.params?.[0])
+            attrs.push(`maxlength="${rule.params[0]}"`);
+          break;
+        case "regex":
+          if (rule.params?.[0])
+            attrs.push(`pattern="${rule.params[0]}"`);
+          break;
+      }
+    }
+    return `<!-- @validate:${field}:${rules} -->${attrs.length > 0 ? `<!-- attrs:${attrs.join(" ")} -->` : ""}`;
+  });
+}
+export const enhancedValidationRules = {
+  required: {
+    name: "required",
+    validate: (value) => {
+      if (value === null || value === void 0 || value === "")
+        return "This field is required";
+      if (Array.isArray(value) && value.length === 0)
+        return "This field is required";
+      return !0;
+    },
+    toHtml5: () => ["required"],
+    message: "This field is required"
+  },
+  email: {
+    name: "email",
+    validate: (value) => {
+      if (!value)
+        return !0;
+      return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value)) || "Please enter a valid email address";
+    },
+    toHtml5: () => ['type="email"'],
+    message: "Please enter a valid email address"
+  },
+  url: {
+    name: "url",
+    validate: (value) => {
+      if (!value)
+        return !0;
+      try {
+        return new URL(String(value)).protocol.startsWith("http") || "Please enter a valid URL";
+      } catch {
+        return "Please enter a valid URL";
+      }
+    },
+    toHtml5: () => ['type="url"'],
+    message: "Please enter a valid URL"
+  },
+  numeric: {
+    name: "numeric",
+    validate: (value) => {
+      if (!value)
+        return !0;
+      return !Number.isNaN(Number(value)) || "Please enter a number";
+    },
+    toHtml5: () => ['type="number"'],
+    message: "Please enter a number"
+  },
+  integer: {
+    name: "integer",
+    validate: (value) => {
+      if (!value)
+        return !0;
+      const num = Number(value);
+      return Number.isInteger(num) || "Please enter a whole number";
+    },
+    toHtml5: () => ['type="number"', 'step="1"'],
+    message: "Please enter a whole number"
+  },
+  alpha: {
+    name: "alpha",
+    validate: (value) => {
+      if (!value)
+        return !0;
+      return /^[a-z]+$/i.test(String(value)) || "Please enter only letters";
+    },
+    toHtml5: () => ['pattern="[a-zA-Z]+"'],
+    message: "Please enter only letters"
+  },
+  alphanumeric: {
+    name: "alphanumeric",
+    validate: (value) => {
+      if (!value)
+        return !0;
+      return /^[a-z0-9]+$/i.test(String(value)) || "Please enter only letters and numbers";
+    },
+    toHtml5: () => ['pattern="[a-zA-Z0-9]+"'],
+    message: "Please enter only letters and numbers"
+  },
+  min: {
+    name: "min",
+    validate: (value, params) => {
+      if (!value)
+        return !0;
+      const min = Number(params[0]);
+      if (typeof value === "string")
+        return value.length >= min || `Must be at least ${min} characters`;
+      if (typeof value === "number")
+        return value >= min || `Must be at least ${min}`;
+      if (Array.isArray(value))
+        return value.length >= min || `Must have at least ${min} items`;
+      return !0;
+    },
+    toHtml5: (params) => [`minlength="${params[0]}"`, `min="${params[0]}"`],
+    message: "Must be at least {{param}} characters"
+  },
+  max: {
+    name: "max",
+    validate: (value, params) => {
+      if (!value)
+        return !0;
+      const max = Number(params[0]);
+      if (typeof value === "string")
+        return value.length <= max || `Must be no more than ${max} characters`;
+      if (typeof value === "number")
+        return value <= max || `Must be no more than ${max}`;
+      if (Array.isArray(value))
+        return value.length <= max || `Must have no more than ${max} items`;
+      return !0;
+    },
+    toHtml5: (params) => [`maxlength="${params[0]}"`, `max="${params[0]}"`],
+    message: "Must be no more than {{param}} characters"
+  },
+  between: {
+    name: "between",
+    validate: (value, params) => {
+      if (!value)
+        return !0;
+      const [min, max] = params.map(Number);
+      if (typeof value === "string")
+        return value.length >= min && value.length <= max || `Must be between ${min} and ${max} characters`;
+      if (typeof value === "number")
+        return value >= min && value <= max || `Must be between ${min} and ${max}`;
+      return !0;
+    },
+    toHtml5: (params) => [`minlength="${params[0]}"`, `maxlength="${params[1]}"`],
+    message: "Must be between {{min}} and {{max}}"
+  },
+  confirmed: {
+    name: "confirmed",
+    validate: (value, _params, allValues) => {
+      const fieldNames = Object.keys(allValues);
+      for (const key of fieldNames)
+        if (key.endsWith("_confirmation") && allValues[key] === value)
+          return !0;
+      return "Confirmation does not match";
+    },
+    message: "Confirmation does not match"
+  },
+  in: {
+    name: "in",
+    validate: (value, params) => {
+      if (!value)
+        return !0;
+      return params.includes(String(value)) || `Must be one of: ${params.join(", ")}`;
+    },
+    message: "Must be one of: {{values}}"
+  },
+  notIn: {
+    name: "notIn",
+    validate: (value, params) => {
+      if (!value)
+        return !0;
+      return !params.includes(String(value)) || `Must not be: ${params.join(", ")}`;
+    },
+    message: "Must not be: {{values}}"
+  },
+  regex: {
+    name: "regex",
+    validate: (value, params) => {
+      if (!value)
+        return !0;
+      try {
+        return new RegExp(params[0]).test(String(value)) || "Invalid format";
+      } catch {
+        return "Invalid format";
+      }
+    },
+    toHtml5: (params) => [`pattern="${params[0]}"`],
+    message: "Invalid format"
+  },
+  date: {
+    name: "date",
+    validate: (value) => {
+      if (!value)
+        return !0;
+      const date = new Date(String(value));
+      return !Number.isNaN(date.getTime()) || "Please enter a valid date";
+    },
+    toHtml5: () => ['type="date"'],
+    message: "Please enter a valid date"
+  },
+  before: {
+    name: "before",
+    validate: (value, params) => {
+      if (!value)
+        return !0;
+      const inputDate = new Date(String(value)), beforeDate = new Date(params[0]);
+      return inputDate < beforeDate || `Must be before ${params[0]}`;
+    },
+    toHtml5: (params) => [`max="${params[0]}"`],
+    message: "Must be before {{date}}"
+  },
+  after: {
+    name: "after",
+    validate: (value, params) => {
+      if (!value)
+        return !0;
+      const inputDate = new Date(String(value)), afterDate = new Date(params[0]);
+      return inputDate > afterDate || `Must be after ${params[0]}`;
+    },
+    toHtml5: (params) => [`min="${params[0]}"`],
+    message: "Must be after {{date}}"
+  },
+  size: {
+    name: "size",
+    validate: (value, params) => {
+      if (!value)
+        return !0;
+      const size = Number(params[0]);
+      if (typeof value === "string")
+        return value.length === size || `Must be exactly ${size} characters`;
+      if (Array.isArray(value))
+        return value.length === size || `Must have exactly ${size} items`;
+      return !0;
+    },
+    message: "Must be exactly {{size}}"
+  },
+  phone: {
+    name: "phone",
+    validate: (value) => {
+      if (!value)
+        return !0;
+      return /^\+?\(?\d{1,4}\)?[-\s./\d]*$/.test(String(value)) || "Please enter a valid phone number";
+    },
+    toHtml5: () => ['type="tel"', 'pattern="\\+?\\(?\\d{1,4}\\)?[-\\s./\\d]*"'],
+    message: "Please enter a valid phone number"
+  }
+};
+export function registerEnhancedValidationRule(rule) {
+  enhancedValidationRules[rule.name] = rule;
+}
+export function validateValueEnhanced(value, rules, allValues = {}) {
+  const errors = [], ruleList = rules.split("|").map((r) => r.trim());
+  for (const ruleStr of ruleList) {
+    const parsed = parseValidationRule(ruleStr), ruleDef = enhancedValidationRules[parsed.name];
+    if (!ruleDef) {
+      console.warn(`Unknown validation rule: ${parsed.name}`);
+      continue;
+    }
+    const result = ruleDef.validate(value, parsed.params || [], allValues);
+    if (result !== !0)
+      errors.push(result);
+  }
+  return { valid: errors.length === 0, errors };
+}
+export function validateFormEnhanced(values, rules) {
+  const errors = {};
+  let valid = !0;
+  for (const [field, fieldRules] of Object.entries(rules)) {
+    const result = validateValueEnhanced(values[field], fieldRules, values);
+    if (!result.valid) {
+      valid = !1;
+      errors[field] = result.errors;
+    }
+  }
+  return { valid, errors };
+}
+export function generateValidationScript(formId, rules) {
+  const rulesJson = JSON.stringify(rules);
+  return `
+<script>
+(function() {
+  const form = document.getElementById('${formId}');
+  if (!form) return;
+
+  const rules = ${rulesJson};
+  const validators = {
+    required: (v) => v !== null && v !== undefined && v !== '' ? true : 'This field is required',
+    email: (v) => !v || /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(v) ? true : 'Please enter a valid email',
+    url: (v) => { if (!v) return true; try { new URL(v); return true; }
+catch { return 'Please enter a valid URL'; } },
+    numeric: (v) => !v || !isNaN(Number(v)) ? true : 'Please enter a number',
+    integer: (v) => !v || Number.isInteger(Number(v)) ? true : 'Please enter a whole number',
+    min: (v, p) => !v || (typeof v === 'string' ? v.length >= p : v >= p) ? true : 'Too short/small',
+    max: (v, p) => !v || (typeof v === 'string' ? v.length <= p : v <= p) ? true : 'Too long/large',
+    regex: (v, p) => !v || new RegExp(p).test(v) ? true : 'Invalid format',
+  };
+
+  form.addEventListener('submit', function(e) {
+    let valid = true;
+    const errors = {};
+
+    for (const [field, fieldRules] of Object.entries(rules)) {
+      const input = form.querySelector('[name="' + field + '"]');
+      if (!input) continue;
+
+      const value = input.value;
+      const ruleList = fieldRules.split('|');
+
+      for (const rule of ruleList) {
+        const [name, param] = rule.split(':');
+        const validator = validators[name];
+        if (validator) {
+          const result = validator(value, param);
+          if (result !== true) {
+            valid = false;
+            errors[field] = errors[field] || [];
+            errors[field].push(result);
+            input.classList.add('is-invalid');
+            break;
+          }
+        }
+      }
+    }
+
+    if (!valid) {
+      e.preventDefault();
+      console.log('Validation errors:', errors);
+    }
+  });
+})();
+</script>`.trim();
+}