@digiform/wizard 0.2.10 → 0.2.16

package/wizard/src/features/validation-system/validation/ActionValidation.js

@@ -0,0 +1,234 @@
+"use client";
+/* empty css                               */
+import { isTemplateDialogConfig as p } from "../../../../../ui/src/lib/types/guards.js";
+import { resolveTemplateDialog as d } from "../../../../../ui/src/lib/utils/templateDialogResolver.js";
+class m extends Error {
+  constructor(t, e, i, r) {
+    super(i), this.actionId = t, this.actionType = e, this.details = r, this.name = "ActionValidationError";
+  }
+}
+class n {
+  /**
+   * Validates a single action configuration
+   */
+  static validateAction(t) {
+    const e = [];
+    if (t.id || e.push("Action ID is required"), t.type || e.push("Action type is required"), t.trigger || e.push("Action trigger is required"), (typeof t.order != "number" || t.order < 0) && e.push("Action order must be a non-negative number"), t.config || e.push("Action config is required"), t.config)
+      switch (t.type) {
+        case "apiCall": {
+          const i = n.validateApiCallConfig(
+            t.config
+          );
+          e.push(...i);
+          break;
+        }
+        case "showDialog": {
+          const i = n.validateDialogConfig(
+            t.config
+          );
+          e.push(...i);
+          break;
+        }
+        case "navigate": {
+          const i = n.validateNavigationConfig(
+            t.config
+          );
+          e.push(...i);
+          break;
+        }
+        default:
+          e.push(`Unknown action type: ${t.type}`);
+      }
+    if (t.conditions && t.conditions.length > 0)
+      for (const i of t.conditions)
+        i.field || e.push("Condition field is required"), i.operator || e.push("Condition operator is required");
+    return {
+      isValid: e.length === 0,
+      errors: e
+    };
+  }
+  /**
+   * Validates API call configuration
+   */
+  static validateApiCallConfig(t) {
+    const e = [];
+    if (t.method ? ["GET", "POST", "PUT", "DELETE"].includes(t.method) || e.push("Invalid HTTP method") : e.push("HTTP method is required"), !t.url)
+      e.push("URL is required");
+    else
+      try {
+        !t.url.startsWith("/") && !t.url.startsWith("http") && e.push("URL must be a valid path or full URL");
+      } catch {
+        e.push("Invalid URL format");
+      }
+    if (t.timeout && (t.timeout < 1e3 || t.timeout > 6e4) && e.push("Timeout must be between 1000ms and 60000ms"), t.retryCount && (t.retryCount < 0 || t.retryCount > 5) && e.push("Retry count must be between 0 and 5"), t.fieldMappings)
+      for (const [i, r] of Object.entries(
+        t.fieldMappings
+      ))
+        (!i || typeof i != "string") && e.push("Field mapping form field must be a non-empty string"), (!r || typeof r != "string") && e.push("Field mapping API field must be a non-empty string");
+    return e;
+  }
+  /**
+   * Validates dialog configuration - supports both direct and template-based configs
+   */
+  static validateDialogConfig(t) {
+    const e = [];
+    if (p(t))
+      return n.validateTemplateDialogConfig(t);
+    const i = t;
+    if (i.title || e.push("Dialog title is required"), i.content || e.push("Dialog content is required"), i.type ? ["modal", "toast", "sidebar"].includes(i.type) || e.push("Invalid dialog type") : e.push("Dialog type is required"), !i.buttons || i.buttons.length === 0)
+      e.push("At least one dialog button is required");
+    else
+      for (const [r, o] of i.buttons.entries())
+        if (o.label || e.push(`Button ${r + 1} label is required`), o.variant ? ["primary", "secondary", "danger"].includes(o.variant) || e.push(`Button ${r + 1} has invalid variant`) : e.push(`Button ${r + 1} variant is required`), !o.action)
+          e.push(`Button ${r + 1} action is required`);
+        else {
+          const s = n.validateDialogButtonAction(
+            o.action,
+            r + 1
+          );
+          e.push(...s);
+        }
+    return e;
+  }
+  /**
+   * Validates template-based dialog configuration
+   */
+  static validateTemplateDialogConfig(t) {
+    const e = [];
+    if (!t.template)
+      return e.push("Template configuration is required"), e;
+    if ((!t.template.typeId || t.template.typeId.trim() === "") && e.push("Template typeId is required"), (!t.template.config || typeof t.template.config != "object") && e.push("Template config is required and must be an object"), e.length > 0)
+      return e;
+    try {
+      const i = d(t);
+      return n.validateResolvedDialogConfig(i);
+    } catch (i) {
+      e.push(
+        `Failed to resolve template dialog: ${i.message}`
+      );
+    }
+    return e;
+  }
+  /**
+   * Validates resolved dialog configuration (after template resolution)
+   */
+  static validateResolvedDialogConfig(t) {
+    const e = [];
+    if (t.title || e.push("Resolved dialog title is required"), t.content || e.push("Resolved dialog content is required"), t.type ? ["modal", "toast", "sidebar"].includes(t.type) || e.push("Invalid resolved dialog type") : e.push("Resolved dialog type is required"), !t.buttons || t.buttons.length === 0)
+      e.push("At least one resolved dialog button is required");
+    else
+      for (const [i, r] of t.buttons.entries())
+        r.label || e.push(`Resolved button ${i + 1} label is required`), r.variant ? ["primary", "secondary", "danger"].includes(r.variant) || e.push(`Resolved button ${i + 1} has invalid variant`) : e.push(`Resolved button ${i + 1} variant is required`), r.action || e.push(`Resolved button ${i + 1} action is required`);
+    return e;
+  }
+  /**
+   * Validates dialog button action
+   */
+  static validateDialogButtonAction(t, e) {
+    const i = [];
+    if (!t.type)
+      return i.push(`Button ${e} action type is required`), i;
+    switch (t.type) {
+      case "navigate":
+        t.targetStep && typeof t.targetStep != "string" && i.push(
+          `Button ${e} navigation target step must be a string`
+        ), t.direction && !["next", "previous"].includes(t.direction) && i.push(
+          `Button ${e} navigation direction must be 'next' or 'previous'`
+        );
+        break;
+      case "custom":
+        t.handler || i.push(
+          `Button ${e} custom action handler is required`
+        );
+        break;
+      case "close":
+        break;
+      default:
+        i.push(
+          `Button ${e} has unknown action type: ${t.type}`
+        );
+    }
+    return i;
+  }
+  /**
+   * Validates navigation configuration
+   */
+  static validateNavigationConfig(t) {
+    const e = [];
+    return t.type ? ["next", "previous", "step"].includes(t.type) || e.push("Invalid navigation type") : e.push("Navigation type is required"), t.type === "step" && !t.targetStep && e.push("Target step is required for step navigation"), e;
+  }
+  /**
+   * Validates all actions in a step
+   */
+  static validateStepActions(t) {
+    const e = [];
+    if (!t.actions || t.actions.length === 0)
+      return { isValid: !0, errors: [] };
+    const i = t.actions.map((s) => s.id), r = i.filter(
+      (s, a) => i.indexOf(s) !== a
+    );
+    r.length > 0 && e.push(`Duplicate action IDs found: ${r.join(", ")}`);
+    const o = /* @__PURE__ */ new Map();
+    for (const s of t.actions)
+      o.has(s.trigger) || o.set(s.trigger, []), o.get(s.trigger)?.push(s.order);
+    for (const [s, a] of o) {
+      const u = a.filter(
+        (l, f) => a.indexOf(l) !== f
+      );
+      u.length > 0 && e.push(
+        `Duplicate action orders for trigger '${s}': ${u.join(", ")}`
+      );
+    }
+    for (const s of t.actions) {
+      const a = n.validateAction(s);
+      a.isValid || e.push(`Action '${s.id}': ${a.errors.join(", ")}`);
+    }
+    return {
+      isValid: e.length === 0,
+      errors: e
+    };
+  }
+  /**
+   * Validates navigation targets exist
+   */
+  static validateNavigationTargets(t, e) {
+    const i = [];
+    if (!t.actions)
+      return { isValid: !0, errors: [] };
+    const r = new Set(e.map((o) => o.id));
+    for (const o of t.actions) {
+      if (o.type === "navigate") {
+        const s = o.config;
+        s.type === "step" && s.targetStep && (r.has(s.targetStep) || i.push(
+          `Navigation action '${o.id}' references non-existent step: ${s.targetStep}`
+        ));
+      }
+      if (o.type === "showDialog")
+        try {
+          const s = o.config;
+          let a;
+          if (p(s) ? a = d(s) : a = s, a.buttons) {
+            for (const u of a.buttons)
+              if (u.action.type === "navigate" && u.action.targetStep) {
+                const l = u.action.targetStep;
+                r.has(l) || i.push(
+                  `Dialog button in action '${o.id}' references non-existent step: ${l}`
+                );
+              }
+          }
+        } catch (s) {
+          i.push(
+            `Failed to resolve dialog template in action '${o.id}': ${s.message}`
+          );
+        }
+    }
+    return {
+      isValid: i.length === 0,
+      errors: i
+    };
+  }
+}
+export {
+  m as ActionValidationError,
+  n as ActionValidator
+};

package/wizard/src/features/validation-system/validation/SchemaBuilder.js

@@ -0,0 +1,239 @@
+"use client";
+import { z as l } from "zod";
+class d {
+  messageStyle;
+  secureValidatorConfig;
+  constructor(i = "withLabel", a) {
+    this.messageStyle = i, this.secureValidatorConfig = a;
+  }
+  /**
+   * Creates a Zod schema for a component
+   */
+  createComponentSchema(i) {
+    console.log("🔍 [SchemaBuilder] Creating schema for component:", {
+      id: i.id,
+      type: i.type,
+      validation: i.validation
+    });
+    let a;
+    switch (i.type) {
+      case "text":
+      case "tel":
+      case "password":
+      case "textarea":
+        a = l.string();
+        break;
+      case "email":
+        console.log(
+          `🔍 [SchemaBuilder] Creating EMAIL schema for component ${i.id}`
+        ), a = l.string().email("Please enter a valid email address"), console.log(
+          `✅ [SchemaBuilder] Email schema created for component ${i.id}:`,
+          { schemaType: a.constructor.name }
+        );
+        break;
+      case "number":
+        a = l.number();
+        break;
+      case "checkbox":
+        a = l.boolean();
+        break;
+      case "date":
+      case "time":
+      case "datetime-local":
+        a = l.string();
+        break;
+      case "radioGroup":
+      case "radio":
+      case "select":
+      case "dropdown":
+        a = l.string();
+        break;
+      case "range":
+        a = l.number();
+        break;
+      case "file":
+        a = l.any();
+        break;
+      case "hidden":
+        a = l.string().optional();
+        break;
+      default:
+        a = l.any();
+    }
+    if (i.validation) {
+      const e = i.validation, r = typeof e.required == "object" && e.required !== null ? e.required : null;
+      if (r && r.value === !0) {
+        const t = r.message || "This field is required";
+        console.log(
+          `🔍 [SchemaBuilder] Applying REQUIRED validation for ${i.id}:`,
+          {
+            message: t,
+            componentType: i.type,
+            requiredRule: r
+          }
+        ), i.type === "text" || i.type === "email" || i.type === "tel" || i.type === "password" || i.type === "textarea" ? (a = a.min(1, t), console.log(
+          `🔍 [SchemaBuilder] Applied .min(1) for required text field ${i.id}`
+        )) : (i.type === "radioGroup" || i.type === "radio" || i.type === "select" || i.type === "dropdown") && (a = a.refine(
+          (s) => s != null && s !== "",
+          {
+            message: t
+          }
+        ), console.log(
+          `🔍 [SchemaBuilder] Applied .refine() for required selection field ${i.id}`
+        ));
+      }
+      if (e.minLength) {
+        console.log(
+          `🔍 [SchemaBuilder] Processing MINLENGTH validation for ${i.id}:`,
+          {
+            validationMinLength: e.minLength,
+            rawValue: e.minLength.value,
+            valueType: typeof e.minLength.value
+          }
+        );
+        const t = typeof e.minLength.value == "string" ? Number(e.minLength.value) : e.minLength.value;
+        if (console.log(
+          `🔍 [SchemaBuilder] Converted minLength value for ${i.id}:`,
+          {
+            originalValue: e.minLength.value,
+            convertedValue: t,
+            convertedType: typeof t,
+            isValidNumber: typeof t == "number" && !Number.isNaN(t)
+          }
+        ), typeof t == "number" && !Number.isNaN(t)) {
+          if (a instanceof l.ZodString) {
+            const s = e.minLength.message || `Must be at least ${t} characters`;
+            console.log(
+              `🔍 [SchemaBuilder] Applying MINLENGTH validation for ${i.id}:`,
+              {
+                minLengthValue: t,
+                message: s,
+                schemaBeforeMinLength: a._def,
+                schemaType: a.constructor.name
+              }
+            ), a = a.min(t, s), console.log(
+              `🔍 [SchemaBuilder] Applied .min(${t}) for ${i.id}:`,
+              {
+                schemaAfterMinLength: a._def,
+                schemaType: a.constructor.name
+              }
+            );
+          }
+        } else
+          console.warn(
+            `[SchemaBuilder] Invalid minLength value for component: ${i.id}. Expected number, got:`,
+            e.minLength.value
+          );
+      }
+      if (e.maxLength) {
+        const t = typeof e.maxLength.value == "string" ? Number(e.maxLength.value) : e.maxLength.value;
+        if (typeof t == "number" && !Number.isNaN(t)) {
+          if (a instanceof l.ZodString) {
+            const s = e.maxLength.message || `Must be no more than ${t} characters`;
+            a = a.max(t, s);
+          }
+        } else
+          console.warn(
+            `[SchemaBuilder] Invalid maxLength value for component: ${i.id}. Expected number, got:`,
+            e.maxLength.value
+          );
+      }
+      if (e.pattern && a instanceof l.ZodString) {
+        const t = typeof e.pattern == "string" ? { value: e.pattern, message: "Invalid format" } : e.pattern;
+        if (t.value) {
+          const s = t.message || "Invalid format";
+          a = a.regex(new RegExp(t.value), s);
+        }
+      }
+      if (e.email && i.type !== "email" && a instanceof l.ZodString) {
+        const t = typeof e.email == "boolean" && e.email ? { value: !0, message: "Please enter a valid email address" } : typeof e.email == "object" && e.email !== null ? e.email : null;
+        if (t && (t.value === !0 || typeof e.email == "object" && e.email !== null && !("value" in e.email))) {
+          const n = t?.message || "Please enter a valid email address";
+          a = a.email(n);
+        }
+      }
+      if (e.email && i.type === "email" && a instanceof l.ZodString) {
+        const t = typeof e.email == "boolean" && e.email ? { message: "Please enter a valid email address" } : typeof e.email == "object" && e.email !== null ? e.email : null;
+        t && t.message && (console.log(
+          `🔍 [SchemaBuilder] Using custom email validation message for component ${i.id}:`,
+          { customMessage: t.message }
+        ), a = l.string().email(t.message));
+      }
+      if (i.type === "number" || i.type === "range") {
+        if (e.min) {
+          const t = typeof e.min == "number" ? {
+            value: e.min,
+            message: `Must be at least ${e.min}`
+          } : e.min, s = typeof t.value == "string" ? Number(t.value) : t.value;
+          if (typeof s == "number" && !Number.isNaN(s)) {
+            const n = t.message || `Must be at least ${s}`;
+            a = a.min(s, n);
+          } else
+            console.warn(
+              `[SchemaBuilder] Invalid min value for component: ${i.id}. Expected number, got:`,
+              t.value
+            );
+        }
+        if (e.max) {
+          const t = typeof e.max == "number" ? {
+            value: e.max,
+            message: `Must be no more than ${e.max}`
+          } : e.max, s = typeof t.value == "string" ? Number(t.value) : t.value;
+          if (typeof s == "number" && !Number.isNaN(s)) {
+            const n = t.message || `Must be no more than ${s}`;
+            a = a.max(s, n);
+          } else
+            console.warn(
+              `[SchemaBuilder] Invalid max value for component: ${i.id}. Expected number, got:`,
+              t.value
+            );
+        }
+      }
+    }
+    return this.isComponentRequired(i) || (a = a.optional()), a;
+  }
+  /**
+   * Creates a Zod schema for a step
+   */
+  createStepSchema(i) {
+    const a = {};
+    return i.sections?.forEach((o) => {
+      o.components?.forEach((e) => {
+        if (e.type === "button" || e.type === "submit" || e.type === "reset" || e.type === "paragraph" || e.type === "heading" || e.type === "alert")
+          return;
+        const r = this.createComponentSchema(e);
+        a[e.id] = r;
+      });
+    }), l.object(a);
+  }
+  /**
+   * Updates the message style
+   */
+  updateMessageStyle(i) {
+    this.messageStyle = i;
+  }
+  /**
+   * Updates the secure validator config
+   */
+  updateSecureValidatorConfig(i) {
+    this.secureValidatorConfig = { ...this.secureValidatorConfig, ...i };
+  }
+  /**
+   * Gets the current message style
+   */
+  getMessageStyle() {
+    return this.messageStyle;
+  }
+  /**
+   * Checks if a component is required based on its validation configuration
+   */
+  isComponentRequired(i) {
+    if (!i.validation)
+      return !1;
+    const a = i.validation;
+    return typeof a.required == "boolean" ? a.required : typeof a.required == "object" && a.required !== null ? a.required.value === !0 : !1;
+  }
+}
+export {
+  d as SchemaBuilder
+};

package/wizard/src/features/validation-system/validation/ValidationCache.js

@@ -0,0 +1,76 @@
+"use client";
+class s {
+  schemaBuilder;
+  componentSchemaCache = /* @__PURE__ */ new Map();
+  stepSchemaCache = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this.schemaBuilder = e;
+  }
+  /**
+   * Gets or creates a component schema with caching
+   */
+  getComponentSchema(e) {
+    const c = `component_${e.id}`;
+    (e.id === "text-i05t2ttw" || e.id === "radioGroup-c5q6aj4v" || e.id === "text-1759502191578-gci6gq1pm") && (console.log(
+      `🧪 [ValidationCache] CLEARING CACHE for debugging component: ${e.id}`
+    ), this.componentSchemaCache.delete(c));
+    const a = this.componentSchemaCache.get(c);
+    if (a)
+      return console.log(
+        `📋 [ValidationCache] Using cached schema for ${e.id}:`,
+        {
+          cacheKey: c,
+          schemaType: a.constructor.name
+        }
+      ), a;
+    console.log(
+      `🔄 [ValidationCache] Creating new schema for ${e.id}:`,
+      {
+        cacheKey: c,
+        componentType: e.type,
+        hasValidation: !!e.validation
+      }
+    );
+    const t = this.schemaBuilder.createComponentSchema(e);
+    return this.componentSchemaCache.set(c, t), t;
+  }
+  /**
+   * Gets or creates a step schema with caching
+   */
+  getStepSchema(e) {
+    const c = `step_${e.id}`, a = this.stepSchemaCache.get(c);
+    if (a)
+      return a;
+    const t = this.schemaBuilder.createStepSchema(e);
+    return this.stepSchemaCache.set(c, t), t;
+  }
+  /**
+   * Clears all cached schemas
+   */
+  clearCache() {
+    this.componentSchemaCache.clear(), this.stepSchemaCache.clear();
+  }
+  /**
+   * Invalidates cache when message style changes
+   */
+  invalidateOnMessageStyleChange() {
+    this.clearCache();
+  }
+  /**
+   * Clears cache for a specific component
+   */
+  clearComponentCache(e) {
+    const c = `component_${e}`;
+    this.componentSchemaCache.delete(c);
+  }
+  /**
+   * Clears cache for a specific step
+   */
+  clearStepCache(e) {
+    const c = `step_${e}`;
+    this.stepSchemaCache.delete(c);
+  }
+}
+export {
+  s as ValidationCache
+};

package/wizard/src/features/validation-system/validation/ValidationEngine.js

@@ -0,0 +1,97 @@
+"use client";
+import { SchemaBuilder as d } from "./SchemaBuilder.js";
+import { ValidationCache as o } from "./ValidationCache.js";
+import { ValidationExecutor as l } from "./ValidationExecutor.js";
+class c {
+  debounceTimers = /* @__PURE__ */ new Map();
+  debounceMs;
+  schemaBuilder;
+  validationExecutor;
+  validationCache;
+  constructor(e = {}) {
+    this.debounceMs = e.debounceMs || 300, this.schemaBuilder = new d(
+      e.messageStyle || "withLabel",
+      e.secureValidatorConfig
+    ), this.validationExecutor = new l(this.schemaBuilder), this.validationCache = new o(this.schemaBuilder);
+  }
+  /**
+   * Validates a single field with debouncing
+   */
+  async validateFieldDebounced(e, i) {
+    return new Promise((a) => {
+      const t = `field_${e.id}`;
+      if (this.debounceTimers.has(t)) {
+        const n = this.debounceTimers.get(t);
+        n && clearTimeout(n);
+      }
+      const r = setTimeout(() => {
+        const n = this.validateField(e, i);
+        this.debounceTimers.delete(t), a(n);
+      }, this.debounceMs);
+      this.debounceTimers.set(t, r);
+    });
+  }
+  /**
+   * Validates a single field immediately (synchronous)
+   */
+  validateField(e, i) {
+    const a = this.validationCache.getComponentSchema(e);
+    return this.validationExecutor.validateFieldSync(i, a);
+  }
+  /**
+   * Validates all fields in a step
+   */
+  async validateStep(e, i) {
+    const a = this.validationCache.getStepSchema(e);
+    return await this.validationExecutor.validateStep(i, a);
+  }
+  /**
+   * Validates an entire form
+   */
+  async validateForm(e, i) {
+    return await this.validationExecutor.validateForm(e, i);
+  }
+  /**
+   * Creates and caches a Zod schema for a component
+   */
+  getComponentSchema(e) {
+    return this.validationCache.getComponentSchema(e);
+  }
+  /**
+   * Creates a Zod schema for an entire step
+   */
+  getStepSchema(e) {
+    return this.validationCache.getStepSchema(e);
+  }
+  /**
+   * Clears the schema cache (useful when component configurations change)
+   */
+  clearCache() {
+    this.validationCache.clearCache();
+  }
+  /**
+   * Clears debounce timers
+   */
+  cancelPendingValidations() {
+    for (const e of Array.from(this.debounceTimers.values()))
+      clearTimeout(e);
+    this.debounceTimers.clear();
+  }
+  /**
+   * Updates validation options
+   */
+  updateOptions(e) {
+    e.messageStyle && (this.schemaBuilder.updateMessageStyle(e.messageStyle), this.validationCache.invalidateOnMessageStyleChange()), e.debounceMs !== void 0 && (this.debounceMs = e.debounceMs), e.secureValidatorConfig && (this.schemaBuilder.updateSecureValidatorConfig(
+      e.secureValidatorConfig
+    ), this.validationCache.clearCache());
+  }
+}
+const v = new c();
+function g(s) {
+  return new c(s);
+}
+export {
+  c as ValidationEngine,
+  g as createValidationEngine,
+  v as defaultValidationEngine
+};