@fayz-ai/ui 0.14.0 → 0.15.0

package/dist/chunk-AASANYXN.js

@@ -0,0 +1,601 @@
+import { ImageDrop, Switch, OptionChips, OptionCards, ColorPalette, StepProgress, ConfirmDialog } from './chunk-3OVZ5JJQ.js';
+import { cn, Button } from './chunk-OKZ6WQB3.js';
+import * as React from 'react';
+import { Loader2, Sparkles, X, ArrowLeft, ArrowRight } from 'lucide-react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/wizard/logic.ts
+function isEmpty(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+}
+function visibleSteps(steps, values) {
+  return steps.filter((s) => s.visibleWhen ? s.visibleWhen(values) : true);
+}
+function visibleFields(step, values) {
+  return (step?.fields ?? []).filter((f) => f.visibleWhen ? f.visibleWhen(values) : true);
+}
+function fieldErrors(fields, values, asyncErrors = {}) {
+  const out = {};
+  for (const field of fields) {
+    const value = values[field.id];
+    out[field.id] = (isEmpty(value) ? null : field.validate?.(value, values)) ?? asyncErrors[field.id] ?? null;
+  }
+  return out;
+}
+function canAdvance(step, fields, values, errors) {
+  if (!step) return false;
+  if (fields.some((f) => f.required && isEmpty(values[f.id]))) return false;
+  if (Object.values(errors).some(Boolean)) return false;
+  return !step.validate?.(values);
+}
+function acceptableSuggestion(patch, knownFieldIds, answered) {
+  const accepted = {};
+  for (const [id, value] of Object.entries(patch)) {
+    if (!knownFieldIds.has(id)) continue;
+    if (answered.has(id)) continue;
+    if (isEmpty(value)) continue;
+    accepted[id] = value;
+  }
+  return accepted;
+}
+function allFieldIds(steps) {
+  return new Set(steps.flatMap((s) => (s.fields ?? []).map((f) => f.id)));
+}
+function parseDraft(raw) {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    const values = parsed.values && typeof parsed.values === "object" ? parsed.values : {};
+    return { index: typeof parsed.index === "number" ? parsed.index : 0, values };
+  } catch {
+    return null;
+  }
+}
+function readDraft(key) {
+  if (!key || typeof localStorage === "undefined") return null;
+  try {
+    return parseDraft(localStorage.getItem(key));
+  } catch {
+    return null;
+  }
+}
+function useWizard({ steps, initialValues, draftKey, onSubmit }) {
+  const [draft] = React.useState(() => readDraft(draftKey));
+  const [values, setValues] = React.useState(() => ({ ...initialValues, ...draft?.values }));
+  const [index, setIndex] = React.useState(() => draft?.index ?? 0);
+  const [submitting, setSubmitting] = React.useState(false);
+  const [touched, setTouched] = React.useState(() => Object.keys(draft?.values ?? {}).length > 0);
+  const [error, setError] = React.useState(null);
+  const [asyncErrors, setAsyncErrors] = React.useState({});
+  const [suggesting, setSuggesting] = React.useState(null);
+  const [suggested, setSuggested] = React.useState(() => /* @__PURE__ */ new Set());
+  const visibleSteps2 = React.useMemo(() => visibleSteps(steps, values), [steps, values]);
+  const safeIndex = Math.min(index, Math.max(visibleSteps2.length - 1, 0));
+  const step = visibleSteps2[safeIndex];
+  const visibleFields2 = React.useMemo(() => visibleFields(step, values), [step, values]);
+  const derivedRef = React.useRef(/* @__PURE__ */ new Set());
+  React.useEffect(() => {
+    const seeds = visibleFields2.filter((f) => f.derive && !derivedRef.current.has(f.id) && isEmpty(values[f.id])).map((f) => [f, f.derive(values)]).filter(([, derived]) => !isEmpty(derived));
+    if (seeds.length === 0) return;
+    setValues((prev) => {
+      const next2 = { ...prev };
+      for (const [field, derived] of seeds) {
+        derivedRef.current.add(field.id);
+        next2[field.id] = derived;
+      }
+      return next2;
+    });
+  }, [visibleFields2, values]);
+  React.useEffect(() => {
+    if (!draftKey || !touched || typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(draftKey, JSON.stringify({ index: safeIndex, values }));
+    } catch {
+    }
+  }, [draftKey, touched, safeIndex, values]);
+  const answeredRef = React.useRef(new Set(Object.keys(draft?.values ?? {})));
+  const setValue = React.useCallback((id, value) => {
+    setTouched(true);
+    answeredRef.current.add(id);
+    setValues((prev) => ({ ...prev, [id]: value }));
+    setAsyncErrors((prev) => prev[id] ? { ...prev, [id]: null } : prev);
+    setSuggested((prev) => {
+      if (!prev.has(id)) return prev;
+      const next2 = new Set(prev);
+      next2.delete(id);
+      return next2;
+    });
+  }, []);
+  const clearSuggestion = React.useCallback((id) => {
+    answeredRef.current.add(id);
+    setValues((prev) => {
+      if (!(id in prev)) return prev;
+      const next2 = { ...prev };
+      delete next2[id];
+      return next2;
+    });
+    setSuggested((prev) => {
+      if (!prev.has(id)) return prev;
+      const next2 = new Set(prev);
+      next2.delete(id);
+      return next2;
+    });
+  }, []);
+  const checkable = visibleFields2.filter((f) => f.checkAsync);
+  const checkSignature = checkable.map((f) => `${f.id}:${String(values[f.id] ?? "")}`).join("|");
+  React.useEffect(() => {
+    if (checkable.length === 0) return;
+    let cancelled = false;
+    const timer = setTimeout(() => {
+      for (const field of checkable) {
+        const raw = values[field.id];
+        if (typeof raw !== "string" || raw.trim() === "") continue;
+        void field.checkAsync(raw, values).then((message) => {
+          if (!cancelled) setAsyncErrors((prev) => ({ ...prev, [field.id]: message }));
+        }).catch(() => {
+          if (!cancelled) setAsyncErrors((prev) => ({ ...prev, [field.id]: null }));
+        });
+      }
+    }, 400);
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [checkSignature]);
+  const knownFieldIds = React.useMemo(() => allFieldIds(steps), [steps]);
+  const applySuggestion = React.useCallback(
+    (patch) => {
+      const accepted = acceptableSuggestion(patch, knownFieldIds, answeredRef.current);
+      const ids = Object.keys(accepted);
+      if (ids.length === 0) return;
+      setValues((prev) => ({ ...prev, ...accepted }));
+      setSuggested((prev) => {
+        const next2 = new Set(prev);
+        for (const id of ids) next2.add(id);
+        return next2;
+      });
+    },
+    [knownFieldIds]
+  );
+  const suggestable = visibleFields2.filter((f) => f.suggest);
+  const suggestSignature = suggestable.map((f) => `${f.id}:${String(values[f.id] ?? "")}`).join("|");
+  const suggestedForRef = React.useRef(/* @__PURE__ */ new Map());
+  const suggestRunRef = React.useRef(0);
+  React.useEffect(() => {
+    if (suggestable.length === 0) return;
+    const pending = suggestable.filter((field) => {
+      const raw = values[field.id];
+      if (typeof raw !== "string" || raw.trim() === "") return false;
+      return suggestedForRef.current.get(field.id) !== raw.trim();
+    });
+    if (pending.length === 0) return;
+    let cancelled = false;
+    const timer = setTimeout(() => {
+      const run = ++suggestRunRef.current;
+      for (const field of pending) {
+        const raw = String(values[field.id]).trim();
+        suggestedForRef.current.set(field.id, raw);
+        setSuggesting(field.id);
+        void field.suggest(raw, values).then((patch) => {
+          if (cancelled || run !== suggestRunRef.current) return;
+          if (patch) applySuggestion(patch);
+        }).catch(() => {
+        }).finally(() => {
+          if (!cancelled && run === suggestRunRef.current) setSuggesting(null);
+        });
+      }
+    }, 900);
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [suggestSignature]);
+  const fieldErrors2 = React.useMemo(
+    () => fieldErrors(visibleFields2, values, asyncErrors),
+    [visibleFields2, values, asyncErrors]
+  );
+  const blocker = React.useMemo(() => step?.validate?.(values) ?? null, [step, values]);
+  const canAdvance2 = !submitting && canAdvance(step, visibleFields2, values, fieldErrors2);
+  const isLast = safeIndex >= visibleSteps2.length - 1;
+  const clearDraft = React.useCallback(() => {
+    if (!draftKey || typeof localStorage === "undefined") return;
+    try {
+      localStorage.removeItem(draftKey);
+    } catch {
+    }
+  }, [draftKey]);
+  const submit = React.useCallback(async () => {
+    if (!onSubmit) return;
+    setSubmitting(true);
+    setError(null);
+    try {
+      await onSubmit(values);
+      clearDraft();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setSubmitting(false);
+    }
+  }, [onSubmit, values, clearDraft]);
+  const next = React.useCallback(() => {
+    if (!canAdvance2) return;
+    if (isLast) {
+      void submit();
+      return;
+    }
+    setIndex((i) => Math.min(i + 1, visibleSteps2.length - 1));
+  }, [canAdvance2, isLast, submit, visibleSteps2.length]);
+  const back = React.useCallback(() => setIndex((i) => Math.max(i - 1, 0)), []);
+  const goTo = React.useCallback(
+    (target) => setIndex(Math.max(0, Math.min(target, visibleSteps2.length - 1))),
+    [visibleSteps2.length]
+  );
+  return {
+    steps: visibleSteps2,
+    step,
+    index: safeIndex,
+    total: visibleSteps2.length,
+    values,
+    setValue,
+    fieldErrors: fieldErrors2,
+    blocker,
+    canAdvance: canAdvance2,
+    isFirst: safeIndex === 0,
+    isLast,
+    submitting,
+    error,
+    next,
+    back,
+    goTo,
+    submit,
+    touched,
+    clearDraft,
+    visibleFields: visibleFields2,
+    suggesting,
+    suggested,
+    clearSuggestion
+  };
+}
+var FIELD_CLASS = "h-12 w-full rounded-lg border border-border bg-card px-4 text-base text-foreground placeholder:text-muted-foreground transition-colors focus:border-foreground/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50";
+var INPUT_TYPE = {
+  email: "email",
+  phone: "tel"
+};
+function WizardField({
+  field,
+  values,
+  onChange,
+  error,
+  autoFocus,
+  shortcuts,
+  busy,
+  suggested,
+  onClearSuggestion,
+  suggestedLabel
+}) {
+  const value = values[field.id];
+  const set = (next) => onChange(field.id, next);
+  const body = (() => {
+    switch (field.kind) {
+      case "palette":
+        return /* @__PURE__ */ jsx(
+          ColorPalette,
+          {
+            value: Array.isArray(value) ? value : void 0,
+            onChange: set,
+            slots: field.slots
+          }
+        );
+      case "cards":
+        return /* @__PURE__ */ jsx(
+          OptionCards,
+          {
+            options: field.options ?? [],
+            value,
+            onChange: set,
+            multi: field.multi,
+            columns: field.columns,
+            shortcuts,
+            "aria-label": field.label
+          }
+        );
+      case "chips":
+        return /* @__PURE__ */ jsx(
+          OptionChips,
+          {
+            options: field.options ?? [],
+            value,
+            onChange: set,
+            multi: field.multi,
+            shortcuts,
+            "aria-label": field.label
+          }
+        );
+      case "toggle":
+        return /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-4 rounded-lg border border-border bg-card px-4 py-3", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-sm text-foreground", children: field.label }),
+          /* @__PURE__ */ jsx(Switch, { checked: Boolean(value), onCheckedChange: (checked) => set(checked) })
+        ] });
+      case "image":
+        return /* @__PURE__ */ jsx(
+          ImageDrop,
+          {
+            value: typeof value === "string" ? value : void 0,
+            onUpload: field.onUpload,
+            onChange: (url) => set(url),
+            label: field.label,
+            hint: field.hint
+          }
+        );
+      case "textarea":
+        return /* @__PURE__ */ jsx(
+          "textarea",
+          {
+            rows: 3,
+            className: cn(FIELD_CLASS, "h-auto py-3 leading-relaxed"),
+            placeholder: field.placeholder,
+            value: typeof value === "string" ? value : "",
+            autoFocus,
+            onChange: (e) => set(e.target.value)
+          }
+        );
+      default:
+        return /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: INPUT_TYPE[field.kind] ?? "text",
+              className: cn(FIELD_CLASS, busy && "pr-11", error && "border-destructive"),
+              placeholder: field.placeholder,
+              value: typeof value === "string" ? value : "",
+              autoFocus,
+              autoComplete: field.kind === "email" ? "email" : "off",
+              onChange: (e) => set(field.normalize ? field.normalize(e.target.value) : e.target.value)
+            }
+          ),
+          busy && // The wrapper does the positioning and the icon does nothing but
+          // spin. Both on one element fights: `animate-spin`'s keyframe sets
+          // a bare `transform: rotate(...)`, which replaces the composed
+          // transform that `-translate-y-1/2` lives in — so the icon drops
+          // half its height on every frame and the rotation reads as a
+          // stutter. `inset-y-0` + `items-center` centres with no transform
+          // at all, leaving the animation the only one.
+          /* @__PURE__ */ jsx("span", { className: "pointer-events-none absolute inset-y-0 right-4 flex items-center", children: /* @__PURE__ */ jsx(Loader2, { className: "h-4 w-4 animate-spin text-muted-foreground" }) })
+        ] });
+    }
+  })();
+  const labelAbove = field.label && field.kind !== "toggle" && field.kind !== "image";
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+    (labelAbove || suggested) && /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-2", children: [
+      labelAbove ? /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-foreground", children: field.label }) : /* @__PURE__ */ jsx("span", {}),
+      suggested && suggestedLabel && /* @__PURE__ */ jsx(SuggestedBadge, { label: suggestedLabel, onClear: onClearSuggestion })
+    ] }),
+    body,
+    field.hint && field.kind !== "image" && !error && /* @__PURE__ */ jsx("p", { className: "text-xs leading-relaxed text-muted-foreground", children: field.hint }),
+    error && /* @__PURE__ */ jsx("p", { className: "text-xs text-destructive", children: error })
+  ] });
+}
+function SuggestedBadge({ label, onClear }) {
+  return /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-[11px] text-muted-foreground", children: [
+    /* @__PURE__ */ jsx(Sparkles, { className: "h-3 w-3" }),
+    label,
+    onClear && /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: onClear,
+        "aria-label": `${label} \u2014 descartar`,
+        className: "ml-0.5 rounded-full text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring",
+        children: /* @__PURE__ */ jsx(X, { className: "h-3 w-3" })
+      }
+    )
+  ] });
+}
+var DEFAULT_LABELS = {
+  back: "Back",
+  next: "Continue",
+  finish: "Finish",
+  exit: "Exit",
+  // `{current}` and `{total}` are substituted.
+  stepOf: "Step {current} of {total}",
+  exitTitle: "Leave setup?",
+  exitDescription: "You have already started \u2014 leaving now loses what you filled in.",
+  exitConfirm: "Leave",
+  exitCancel: "Go back",
+  suggested: "from your site"
+};
+function MediaFallback() {
+  return /* @__PURE__ */ jsxs("div", { className: "relative h-full w-full overflow-hidden bg-sidebar", children: [
+    /* @__PURE__ */ jsx("div", { className: "absolute inset-0 bg-gradient-to-br from-primary/25 via-transparent to-sidebar" }),
+    /* @__PURE__ */ jsx("div", { className: "absolute -right-24 -top-24 h-96 w-96 rounded-full bg-primary/20 blur-3xl" }),
+    /* @__PURE__ */ jsx("div", { className: "absolute -bottom-32 -left-16 h-96 w-96 rounded-full bg-primary/10 blur-3xl" })
+  ] });
+}
+function MediaPanel({ media }) {
+  if (!media) return /* @__PURE__ */ jsx(MediaFallback, {});
+  if (media.node) return /* @__PURE__ */ jsx("div", { className: "h-full w-full overflow-auto bg-sidebar", children: media.node });
+  if (!media.src) return /* @__PURE__ */ jsx(MediaFallback, {});
+  return /* @__PURE__ */ jsxs("picture", { className: "block h-full w-full", children: [
+    media.srcDark && /* @__PURE__ */ jsx("source", { srcSet: media.srcDark, media: "(prefers-color-scheme: dark)" }),
+    /* @__PURE__ */ jsx("img", { src: media.src, alt: media.alt ?? "", className: "h-full w-full object-cover" })
+  ] });
+}
+function Wizard({
+  steps,
+  initialValues,
+  draftKey,
+  onSubmit,
+  onExit,
+  logo,
+  fallbackMedia,
+  labels,
+  className
+}) {
+  const text = { ...DEFAULT_LABELS, ...labels };
+  const w = useWizard({ steps, initialValues, draftKey, onSubmit });
+  const [confirmExit, setConfirmExit] = React.useState(false);
+  const [direction, setDirection] = React.useState("forward");
+  const goNext = React.useCallback(() => {
+    setDirection("forward");
+    w.next();
+  }, [w]);
+  const goBack = React.useCallback(() => {
+    setDirection("back");
+    w.back();
+  }, [w]);
+  React.useEffect(() => {
+    function onKey(e) {
+      if (confirmExit) return;
+      const target = e.target;
+      const typing = target?.tagName === "TEXTAREA";
+      if (e.key === "Enter" && !typing && !e.shiftKey) {
+        e.preventDefault();
+        goNext();
+      }
+      if (e.key === "ArrowLeft" && target?.tagName !== "INPUT" && !typing && !w.isFirst) goBack();
+    }
+    document.addEventListener("keydown", onKey);
+    return () => document.removeEventListener("keydown", onKey);
+  }, [goNext, goBack, w.isFirst, confirmExit]);
+  React.useEffect(() => {
+    if (typeof document === "undefined") return;
+    const previous = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = previous;
+    };
+  }, []);
+  const requestExit = () => {
+    if (!onExit) return;
+    if (!w.touched) {
+      onExit();
+      return;
+    }
+    setConfirmExit(true);
+  };
+  const [pendingAdvance, setPendingAdvance] = React.useState(null);
+  const setValue = React.useCallback(
+    (id, value) => {
+      w.setValue(id, value);
+      if (w.isLast || !w.step || w.step.render) return;
+      const field = w.visibleFields.find((f) => f.id === id);
+      if (!field || field.multi || field.kind !== "cards" && field.kind !== "chips") return;
+      if (w.visibleFields.length !== 1) return;
+      if (visibleFields(w.step, { ...w.values, [id]: value }).length !== 1) return;
+      setPendingAdvance(w.step.id);
+    },
+    [w]
+  );
+  React.useEffect(() => {
+    if (!pendingAdvance) return;
+    if (pendingAdvance !== w.step?.id) {
+      setPendingAdvance(null);
+      return;
+    }
+    if (!w.canAdvance) return;
+    const timer = setTimeout(() => {
+      setPendingAdvance(null);
+      setDirection("forward");
+      w.next();
+    }, 320);
+    return () => clearTimeout(timer);
+  }, [pendingAdvance, w.step?.id, w.canAdvance, w.next]);
+  const choiceFields = w.visibleFields.filter((f) => f.kind === "cards" || f.kind === "chips");
+  const shortcutFieldId = (choiceFields.find((f) => isEmpty(w.values[f.id])) ?? choiceFields[0])?.id;
+  const step = w.step;
+  if (!step) return null;
+  const nextLabel = step.nextLabel ?? (w.isLast ? text.finish : text.next);
+  return /* @__PURE__ */ jsxs("div", { className: cn("fixed inset-0 z-50 flex bg-background", className), children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-1 flex-col lg:w-[58%] lg:flex-none lg:basis-[58%]", children: [
+      /* @__PURE__ */ jsx("div", { className: "flex-1 overflow-y-auto px-6 pt-10 sm:px-12 lg:px-16", children: /* @__PURE__ */ jsxs("div", { className: "mx-auto w-full max-w-xl", children: [
+        logo && /* @__PURE__ */ jsx("div", { className: "mb-8", children: logo }),
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: direction === "forward" ? "saas-nav-forward" : "saas-nav-back",
+            children: [
+              step.eyebrow && /* @__PURE__ */ jsx("p", { className: "mb-2 text-xs font-semibold uppercase tracking-[0.14em] text-primary", children: step.eyebrow }),
+              /* @__PURE__ */ jsx("h1", { className: "text-3xl font-bold leading-tight tracking-tight text-foreground sm:text-4xl", children: step.title }),
+              step.subtitle && /* @__PURE__ */ jsx("p", { className: "mt-3 text-base leading-relaxed text-muted-foreground", children: step.subtitle }),
+              /* @__PURE__ */ jsxs("div", { className: "mt-8 space-y-6 pb-10", children: [
+                step.render ? step.render({ values: w.values, setValue, steps: w.steps, index: w.index, submitting: w.submitting }) : w.visibleFields.map((field, i) => /* @__PURE__ */ jsx(
+                  WizardField,
+                  {
+                    field,
+                    values: w.values,
+                    onChange: setValue,
+                    error: w.fieldErrors[field.id],
+                    autoFocus: i === 0 && (field.kind === "text" || field.kind === "email" || field.kind === "slug"),
+                    shortcuts: field.id === shortcutFieldId,
+                    busy: w.suggesting === field.id,
+                    suggested: w.suggested.has(field.id),
+                    suggestedLabel: text.suggested,
+                    onClearSuggestion: () => w.clearSuggestion(field.id)
+                  },
+                  field.id
+                )),
+                w.blocker && /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", children: w.blocker }),
+                w.error && /* @__PURE__ */ jsx("p", { className: "text-sm text-destructive", children: w.error })
+              ] })
+            ]
+          },
+          step.id
+        )
+      ] }) }),
+      /* @__PURE__ */ jsx("div", { className: "border-t border-border/60 px-6 pb-6 pt-4 sm:px-12 lg:px-16", children: /* @__PURE__ */ jsxs("div", { className: "mx-auto w-full max-w-xl", children: [
+        /* @__PURE__ */ jsx(
+          StepProgress,
+          {
+            total: w.total,
+            current: w.index,
+            onSelect: (i) => {
+              setDirection("back");
+              w.goTo(i);
+            },
+            "aria-label": text.stepOf.replace("{current}", String(w.index + 1)).replace("{total}", String(w.total)),
+            className: "mb-4"
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-3", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+            !w.isFirst && /* @__PURE__ */ jsxs(Button, { variant: "outline", size: "lg", onClick: goBack, disabled: w.submitting, children: [
+              /* @__PURE__ */ jsx(ArrowLeft, { className: "h-4 w-4" }),
+              text.back
+            ] }),
+            onExit && /* @__PURE__ */ jsx(Button, { variant: "ghost", size: "lg", onClick: requestExit, disabled: w.submitting, children: text.exit })
+          ] }),
+          /* @__PURE__ */ jsxs(Button, { size: "lg", onClick: goNext, disabled: !w.canAdvance, children: [
+            w.submitting ? /* @__PURE__ */ jsx(Loader2, { className: "h-4 w-4 animate-spin" }) : null,
+            nextLabel,
+            !w.submitting && !w.isLast && /* @__PURE__ */ jsx(ArrowRight, { className: "h-4 w-4" })
+          ] })
+        ] })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "hidden lg:block lg:flex-1", children: /* @__PURE__ */ jsx(MediaPanel, { media: step.media ?? fallbackMedia }) }),
+    /* @__PURE__ */ jsx(
+      ConfirmDialog,
+      {
+        open: confirmExit,
+        title: text.exitTitle,
+        description: text.exitDescription,
+        confirmLabel: text.exitConfirm,
+        cancelLabel: text.exitCancel,
+        variant: "warning",
+        onConfirm: () => {
+          setConfirmExit(false);
+          w.clearDraft();
+          onExit?.();
+        },
+        onCancel: () => setConfirmExit(false)
+      }
+    )
+  ] });
+}
+
+export { Wizard, WizardField, canAdvance, fieldErrors, isEmpty, parseDraft, useWizard, visibleFields, visibleSteps };
+//# sourceMappingURL=chunk-AASANYXN.js.map
+//# sourceMappingURL=chunk-AASANYXN.js.map