@caffeinebounce/ui 0.62.2

package/dist/chunk-LQCVRWVF.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var chunkADIDI7AJ_js = require('./chunk-ADIDI7AJ.js');
+var SeparatorPrimitive = require('@radix-ui/react-separator');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var SeparatorPrimitive__namespace = /*#__PURE__*/_interopNamespace(SeparatorPrimitive);
+
+function Separator({
+  className,
+  orientation = "horizontal",
+  decorative = true,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SeparatorPrimitive__namespace.Root,
+    {
+      "data-slot": "separator",
+      decorative,
+      orientation,
+      className: chunkADIDI7AJ_js.cn(
+        "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
+        className
+      ),
+      ...props
+    }
+  );
+}
+
+exports.Separator = Separator;

package/dist/chunk-MHZXUOGN.mjs

@@ -0,0 +1,168 @@
+import { RefreshCcw, AlertTriangle, AlertCircle, Database, LoaderCircle } from 'lucide-react';
+
+// src/utils/avatar-gradient.ts
+var GRADIENT_PAIRS = [
+  // Vibrant contrasts
+  { from: "#f97316", to: "#ec4899" },
+  // Orange → Pink
+  { from: "#ef4444", to: "#a855f7" },
+  // Red → Purple
+  { from: "#f59e0b", to: "#ef4444" },
+  // Amber → Red
+  { from: "#ec4899", to: "#8b5cf6" },
+  // Pink → Violet
+  { from: "#f43f5e", to: "#fb923c" },
+  // Rose → Orange
+  // Cool gradients
+  { from: "#3b82f6", to: "#a855f7" },
+  // Blue → Purple
+  { from: "#6366f1", to: "#ec4899" },
+  // Indigo → Pink
+  { from: "#8b5cf6", to: "#06b6d4" },
+  // Violet → Cyan
+  { from: "#a855f7", to: "#3b82f6" },
+  // Purple → Blue
+  { from: "#06b6d4", to: "#10b981" },
+  // Cyan → Emerald
+  // Bold combos
+  { from: "#10b981", to: "#3b82f6" },
+  // Emerald → Blue
+  { from: "#14b8a6", to: "#8b5cf6" },
+  // Teal → Violet
+  { from: "#22c55e", to: "#06b6d4" },
+  // Green → Cyan
+  { from: "#0ea5e9", to: "#f43f5e" },
+  // Sky → Rose
+  { from: "#eab308", to: "#22c55e" }
+  // Yellow → Green
+];
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+function getAvatarGradient(userId) {
+  const index = hashString(userId) % GRADIENT_PAIRS.length;
+  const gradient = GRADIENT_PAIRS[index];
+  return {
+    from: gradient.from,
+    to: gradient.to,
+    style: {
+      background: `linear-gradient(135deg, ${gradient.from} 0%, ${gradient.to} 100%)`
+    },
+    className: "text-white"
+  };
+}
+function getGradientIndex(userId) {
+  return hashString(userId) % GRADIENT_PAIRS.length;
+}
+function getGradientPairs() {
+  return GRADIENT_PAIRS;
+}
+var DATA_STATE_COPY = {
+  loading: {
+    title: "Loading data",
+    description: "Please wait while we prepare your finance data."
+  },
+  empty: {
+    title: "No data yet",
+    description: "There\u2019s no data for this selection yet."
+  },
+  stale: {
+    title: "Showing older data",
+    description: "This view may be out of date. Refresh to see the latest values."
+  },
+  partial: {
+    title: "Some data is missing",
+    description: "We loaded what we could, but part of this view is unavailable."
+  },
+  error: {
+    title: "Something went wrong",
+    description: "We couldn\u2019t load this data right now. Please try again."
+  },
+  unauthorized: {
+    title: "Access needed",
+    description: "You don\u2019t currently have permission to view this data."
+  },
+  misconfigured: {
+    title: "Setup required",
+    description: "This view needs additional setup before data can be shown."
+  }
+};
+function resolveDataState({
+  error,
+  data,
+  metadata,
+  hasData
+}) {
+  const normalizedError = error;
+  const isUnauthorized = metadata?.isUnauthorized || normalizedError?.status === 401 || normalizedError?.status === 403 || normalizedError?.code === "unauthorized";
+  const isMisconfigured = metadata?.isMisconfigured || normalizedError?.status === 501 || normalizedError?.code === "misconfigured";
+  const computedHasData = hasData ? hasData(data) : metadata?.hasData ?? (Array.isArray(data) ? data.length > 0 : data != null && (typeof data !== "object" || Object.keys(data).length > 0));
+  if (metadata?.isLoading || metadata?.isFetching) {
+    return {
+      state: "loading",
+      retryable: false,
+      copy: DATA_STATE_COPY.loading
+    };
+  }
+  if (isUnauthorized) {
+    return {
+      state: "unauthorized",
+      retryable: false,
+      copy: DATA_STATE_COPY.unauthorized
+    };
+  }
+  if (isMisconfigured) {
+    return {
+      state: "misconfigured",
+      retryable: false,
+      copy: DATA_STATE_COPY.misconfigured
+    };
+  }
+  if (error) {
+    return { state: "error", retryable: true, copy: DATA_STATE_COPY.error };
+  }
+  if (metadata?.isPartial) {
+    return { state: "partial", retryable: true, copy: DATA_STATE_COPY.partial };
+  }
+  if (metadata?.isStale) {
+    return { state: "stale", retryable: true, copy: DATA_STATE_COPY.stale };
+  }
+  if (metadata?.isEmpty || !computedHasData) {
+    return { state: "empty", retryable: false, copy: DATA_STATE_COPY.empty };
+  }
+  return { state: null, retryable: false };
+}
+function getDataStateIcon(state) {
+  switch (state) {
+    case "loading":
+      return LoaderCircle;
+    case "empty":
+      return Database;
+    case "error":
+    case "unauthorized":
+    case "misconfigured":
+      return AlertCircle;
+    case "partial":
+      return AlertTriangle;
+    default:
+      return RefreshCcw;
+  }
+}
+function getDataStateIconClassName(state) {
+  switch (state) {
+    case "loading":
+      return "animate-spin";
+    case "empty":
+      return "animate-pulse";
+    default:
+      return "";
+  }
+}
+
+export { DATA_STATE_COPY, getAvatarGradient, getDataStateIcon, getDataStateIconClassName, getGradientIndex, getGradientPairs, resolveDataState };

package/dist/chunk-MPZFPU4X.js

@@ -0,0 +1,349 @@
+'use strict';
+
+var chunkESZ7CBA2_js = require('./chunk-ESZ7CBA2.js');
+var chunkSORWLKOK_js = require('./chunk-SORWLKOK.js');
+var chunkADIDI7AJ_js = require('./chunk-ADIDI7AJ.js');
+var client = require('@caffeinebounce/logger/client');
+var lucideReact = require('lucide-react');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function FormWizard({
+  steps,
+  currentStep,
+  onStepChange,
+  getStepStatus,
+  getStepTooltip,
+  enableKeyboardNavigation = true,
+  scopeToDialog = true,
+  onCancel,
+  onSubmit,
+  onReset,
+  autoFocusSelector,
+  persistKey,
+  formData,
+  onDataRestored,
+  children,
+  className
+}) {
+  const totalSteps = steps.length;
+  const isFirstStep = currentStep === 0;
+  const isLastStep = currentStep === totalSteps - 1;
+  const { logError } = client.useErrorLoggerSafe();
+  const [storedValue, setStoredValue, , isLoaded] = chunkESZ7CBA2_js.useLocalStorage(
+    persistKey,
+    null
+  );
+  const debouncedData = chunkESZ7CBA2_js.useDebounce(formData, 500);
+  const [hasRestored, setHasRestored] = react.useState(false);
+  const isRestoring = react.useRef(false);
+  const formDataRef = react.useRef(formData);
+  const restoredDataRef = react.useRef(null);
+  react.useEffect(() => {
+    formDataRef.current = formData;
+  }, [formData]);
+  const hasRestoredDataPropagated = react.useCallback(() => {
+    if (!restoredDataRef.current) return true;
+    const restored = restoredDataRef.current;
+    const current = debouncedData;
+    for (const key of Object.keys(restored)) {
+      const restoredVal = restored[key];
+      const currentVal = current?.[key];
+      if (!restoredVal || restoredVal === "") continue;
+      if (Array.isArray(restoredVal) && restoredVal.length === 0) continue;
+      const isObjectLike = typeof restoredVal === "object" && restoredVal !== null;
+      const valuesMatch = isObjectLike ? JSON.stringify(currentVal) === JSON.stringify(restoredVal) : currentVal === restoredVal;
+      if (!valuesMatch) {
+        return false;
+      }
+    }
+    restoredDataRef.current = null;
+    return true;
+  }, [debouncedData]);
+  react.useEffect(() => {
+    if (hasRestored && persistKey && debouncedData) {
+      if (isRestoring.current) {
+        return;
+      }
+      if (restoredDataRef.current && !hasRestoredDataPropagated()) {
+        return;
+      }
+      setStoredValue(debouncedData);
+    }
+  }, [
+    hasRestored,
+    persistKey,
+    debouncedData,
+    setStoredValue,
+    hasRestoredDataPropagated
+  ]);
+  react.useEffect(() => {
+    return () => {
+      if (hasRestored && persistKey && formDataRef.current) {
+        if (isRestoring.current) {
+          return;
+        }
+        if (restoredDataRef.current) {
+          return;
+        }
+        try {
+          window.localStorage.setItem(
+            persistKey,
+            JSON.stringify(formDataRef.current)
+          );
+        } catch (e) {
+          logError(e, {
+            component: "FormWizard",
+            action: "saveOnUnmount",
+            metadata: { persistKey }
+          });
+        }
+      }
+    };
+  }, [hasRestored, persistKey, logError]);
+  react.useEffect(() => {
+    if (!isLoaded) {
+      return;
+    }
+    if (persistKey && storedValue && !hasRestored && onDataRestored) {
+      restoredDataRef.current = storedValue;
+      onDataRestored(storedValue);
+      isRestoring.current = true;
+      setTimeout(() => {
+        isRestoring.current = false;
+      }, 600);
+      setHasRestored(true);
+    } else if (persistKey && !storedValue && !hasRestored) {
+      setHasRestored(true);
+    }
+  }, [isLoaded, persistKey, storedValue, hasRestored, onDataRestored]);
+  react.useEffect(() => {
+    if (!autoFocusSelector) return;
+    const timeoutId = setTimeout(() => {
+      const element = document.querySelector(autoFocusSelector);
+      element?.focus();
+    }, 0);
+    return () => clearTimeout(timeoutId);
+  }, [autoFocusSelector]);
+  const stepStatuses = react.useMemo(() => {
+    return steps.map((_, index) => getStepStatus(index));
+  }, [steps, getStepStatus]);
+  const handleStepClick = react.useCallback(
+    (stepIndex) => {
+      onStepChange(stepIndex);
+    },
+    [onStepChange]
+  );
+  const handleNext = react.useCallback(() => {
+    if (!isLastStep) {
+      onStepChange(currentStep + 1);
+    }
+  }, [currentStep, isLastStep, onStepChange]);
+  const handleBack = react.useCallback(() => {
+    if (!isFirstStep) {
+      onStepChange(currentStep - 1);
+    }
+  }, [currentStep, isFirstStep, onStepChange]);
+  react.useEffect(() => {
+    if (!enableKeyboardNavigation) return;
+    const handleKeyDown = (e) => {
+      if (scopeToDialog) {
+        const target = e.target;
+        const isInDialog = target.closest('[role="dialog"]');
+        if (!isInDialog) return;
+      }
+      if (e.key === "Escape" && onCancel) {
+        e.preventDefault();
+        e.stopPropagation();
+        onCancel();
+        return;
+      }
+      if (e.key === "Enter" && (e.metaKey || e.ctrlKey) && onSubmit) {
+        e.preventDefault();
+        e.stopPropagation();
+        onSubmit();
+        return;
+      }
+      if ((e.key === "r" || e.key === "\xAE" || e.code === "KeyR") && e.altKey && !e.shiftKey && !e.metaKey && !e.ctrlKey && onReset) {
+        e.preventDefault();
+        e.stopPropagation();
+        if (persistKey) {
+          try {
+            window.localStorage.removeItem(persistKey);
+            setStoredValue(null);
+          } catch (err) {
+            logError(err, {
+              component: "FormWizard",
+              action: "clearStorageOnReset",
+              metadata: { persistKey }
+            });
+          }
+        }
+        onReset();
+        return;
+      }
+      if (!e.altKey) return;
+      if (e.key === "ArrowLeft" && !isFirstStep) {
+        e.preventDefault();
+        e.stopPropagation();
+        handleBack();
+      } else if (e.key === "ArrowRight" && !isLastStep) {
+        e.preventDefault();
+        e.stopPropagation();
+        handleNext();
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown, true);
+    return () => window.removeEventListener("keydown", handleKeyDown, true);
+  }, [
+    enableKeyboardNavigation,
+    scopeToDialog,
+    isFirstStep,
+    isLastStep,
+    handleBack,
+    handleNext,
+    onCancel,
+    onSubmit,
+    onReset,
+    persistKey,
+    setStoredValue,
+    logError
+  ]);
+  const getStatusStyles = react.useCallback(
+    (stepIndex) => {
+      const status = stepStatuses[stepIndex];
+      const isCurrent = stepIndex === currentStep;
+      const step = steps[stepIndex];
+      const Icon = step.icon;
+      const tooltip = getStepTooltip?.(stepIndex, status) ?? null;
+      switch (status) {
+        case "error":
+          return {
+            border: "border-destructive bg-destructive",
+            text: "text-destructive",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(Icon, { className: "w-5 h-5 text-white" }),
+            tooltip: tooltip || "This section has errors"
+          };
+        case "complete":
+          return {
+            border: "border-foreground bg-foreground text-background",
+            text: "text-foreground",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Check, { className: "w-5 h-5" }),
+            tooltip: null
+          };
+        case "incomplete":
+          return {
+            border: "border-yellow-500 bg-yellow-500 text-white",
+            text: "text-yellow-600 dark:text-yellow-500",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(Icon, { className: "w-5 h-5" }),
+            tooltip: tooltip || "This section is incomplete"
+          };
+        case "in-progress":
+          return {
+            border: "border-primary bg-primary text-primary-foreground",
+            text: "text-primary",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(Icon, { className: "w-5 h-5" }),
+            tooltip: null
+          };
+        default:
+          return {
+            border: isCurrent ? "border-muted-foreground bg-muted-foreground text-background dark:border-muted dark:bg-muted dark:text-foreground" : "border-transparent bg-background",
+            text: isCurrent ? "text-foreground" : "text-muted-foreground",
+            icon: /* @__PURE__ */ jsxRuntime.jsx(Icon, { className: "w-5 h-5" }),
+            tooltip: null
+          };
+      }
+    },
+    [stepStatuses, currentStep, steps, getStepTooltip]
+  );
+  const progressPercentage = react.useMemo(() => {
+    if (totalSteps <= 1) return 0;
+    return currentStep / (totalSteps - 1) * 100;
+  }, [currentStep, totalSteps]);
+  return /* @__PURE__ */ jsxRuntime.jsx(chunkSORWLKOK_js.TooltipProvider, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chunkADIDI7AJ_js.cn("space-y-8", className), children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-4", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "absolute top-5 left-5 right-5 h-[2px]", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "absolute inset-0 bg-border/60 rounded-full" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            className: "absolute inset-y-0 left-0 bg-foreground rounded-full transition-all duration-500 ease-out",
+            style: { width: `${progressPercentage}%` }
+          }
+        )
+      ] }),
+      steps.map((step, index) => {
+        const styles = getStatusStyles(index);
+        const stepButton = /* @__PURE__ */ jsxRuntime.jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => handleStepClick(index),
+            "aria-label": `Step ${index + 1}: ${step.label}`,
+            "aria-current": index === currentStep ? "step" : void 0,
+            className: chunkADIDI7AJ_js.cn(
+              "relative z-10 flex flex-col items-center gap-2 transition-colors cursor-pointer",
+              styles.text
+            ),
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  className: chunkADIDI7AJ_js.cn(
+                    "w-10 h-10 rounded-full flex items-center justify-center border-2 transition-colors",
+                    styles.border
+                  ),
+                  children: styles.icon
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium hidden sm:block", children: step.label })
+            ]
+          },
+          step.id
+        );
+        if (styles.tooltip) {
+          return /* @__PURE__ */ jsxRuntime.jsxs(chunkSORWLKOK_js.Tooltip, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(chunkSORWLKOK_js.TooltipTrigger, { asChild: true, children: stepButton }),
+            /* @__PURE__ */ jsxRuntime.jsx(chunkSORWLKOK_js.TooltipContent, { className: "whitespace-pre-line", children: styles.tooltip })
+          ] }, step.id);
+        }
+        return stepButton;
+      })
+    ] }) }),
+    children
+  ] }) });
+}
+function useFormWizardNavigation(currentStep, totalSteps, onStepChange) {
+  const isFirstStep = currentStep === 0;
+  const isLastStep = currentStep === totalSteps - 1;
+  const goNext = react.useCallback(() => {
+    if (!isLastStep) {
+      onStepChange(currentStep + 1);
+    }
+  }, [currentStep, isLastStep, onStepChange]);
+  const goBack = react.useCallback(() => {
+    if (!isFirstStep) {
+      onStepChange(currentStep - 1);
+    }
+  }, [currentStep, isFirstStep, onStepChange]);
+  const goToStep = react.useCallback(
+    (index) => {
+      if (index >= 0 && index < totalSteps) {
+        onStepChange(index);
+      }
+    },
+    [totalSteps, onStepChange]
+  );
+  return {
+    goNext,
+    goBack,
+    goToStep,
+    isFirstStep,
+    isLastStep,
+    currentStep,
+    totalSteps
+  };
+}
+
+exports.FormWizard = FormWizard;
+exports.useFormWizardNavigation = useFormWizardNavigation;

package/dist/chunk-MVYRNJA6.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var chunkADIDI7AJ_js = require('./chunk-ADIDI7AJ.js');
+var TabsPrimitive = require('@radix-ui/react-tabs');
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var TabsPrimitive__namespace = /*#__PURE__*/_interopNamespace(TabsPrimitive);
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var Tabs = TabsPrimitive__namespace.Root;
+var TabsList = React__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  TabsPrimitive__namespace.List,
+  {
+    ref,
+    className: chunkADIDI7AJ_js.cn("inline-flex h-auto items-center gap-0.5", className),
+    ...props
+  }
+));
+TabsList.displayName = TabsPrimitive__namespace.List.displayName;
+var TabsTrigger = React__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  TabsPrimitive__namespace.Trigger,
+  {
+    ref,
+    className: chunkADIDI7AJ_js.cn(
+      "relative inline-flex items-center justify-center whitespace-nowrap px-2 py-1 text-sm transition-colors rounded-box",
+      "ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+      "disabled:pointer-events-none disabled:opacity-50",
+      "text-muted-foreground data-[state=inactive]:hover:text-foreground data-[state=inactive]:hover:bg-accent/50",
+      "data-[state=active]:text-foreground data-[state=active]:font-medium",
+      // Active indicator line
+      "after:absolute after:bottom-0 after:left-2 after:right-2 after:h-0.5 after:rounded-full",
+      "after:bg-transparent data-[state=active]:after:bg-foreground",
+      className
+    ),
+    ...props
+  }
+));
+TabsTrigger.displayName = TabsPrimitive__namespace.Trigger.displayName;
+var TabsContent = React__namespace.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+  TabsPrimitive__namespace.Content,
+  {
+    ref,
+    className: chunkADIDI7AJ_js.cn(
+      "mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+      className
+    ),
+    ...props
+  }
+));
+TabsContent.displayName = TabsPrimitive__namespace.Content.displayName;
+
+exports.Tabs = Tabs;
+exports.TabsContent = TabsContent;
+exports.TabsList = TabsList;
+exports.TabsTrigger = TabsTrigger;