@caffeinebounce/ui 0.62.2

package/dist/chunk-ESZ7CBA2.js

@@ -0,0 +1,1007 @@
+'use strict';
+
+var chunkUM7WMXIU_js = require('./chunk-UM7WMXIU.js');
+var react = require('react');
+var dateFns = require('date-fns');
+var sonner = require('sonner');
+
+var DEFAULT_MAX_ERRORS = 20;
+var DEFAULT_STORAGE_KEY = "session_errors";
+var listenersInitialized = false;
+var currentStorageKey = DEFAULT_STORAGE_KEY;
+var currentMaxErrors = DEFAULT_MAX_ERRORS;
+function addError(error) {
+  if (typeof window === "undefined") return;
+  try {
+    const stored = sessionStorage.getItem(currentStorageKey);
+    const errors = stored ? JSON.parse(stored) : [];
+    const truncatedError = {
+      ...error,
+      stack: error.stack?.slice(0, 2e3)
+    };
+    errors.push(truncatedError);
+    if (errors.length > currentMaxErrors) {
+      errors.shift();
+    }
+    sessionStorage.setItem(currentStorageKey, JSON.stringify(errors));
+  } catch (e) {
+    if (e instanceof DOMException && (e.name === "QuotaExceededError" || e.code === 22)) {
+      console.warn(
+        "[useSessionErrors] sessionStorage quota exceeded. Recent errors may not be tracked."
+      );
+    } else {
+      console.warn("[useSessionErrors] Failed to store error:", e);
+    }
+  }
+}
+function initializeErrorListeners() {
+  if (listenersInitialized || typeof window === "undefined") return;
+  listenersInitialized = true;
+  const handleError = (event) => {
+    addError({
+      message: event.message || "Unknown error",
+      stack: event.error?.stack,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "error"
+    });
+  };
+  const handleRejection = (event) => {
+    const reason = event.reason;
+    addError({
+      message: reason instanceof Error ? reason.message : String(reason) || "Unhandled promise rejection",
+      stack: reason instanceof Error ? reason.stack : void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "unhandledrejection"
+    });
+  };
+  window.addEventListener("error", handleError);
+  window.addEventListener("unhandledrejection", handleRejection);
+}
+function useSessionErrors(options = {}) {
+  const { maxErrors = DEFAULT_MAX_ERRORS, storageKey = DEFAULT_STORAGE_KEY } = options;
+  if (!listenersInitialized) {
+    currentMaxErrors = maxErrors;
+    currentStorageKey = storageKey;
+  } else if (process.env.NODE_ENV !== "production" && (maxErrors !== currentMaxErrors || storageKey !== currentStorageKey)) {
+    console.warn(
+      `[useSessionErrors] Hook called with different options than initial configuration. Global listeners use: { maxErrors: ${currentMaxErrors}, storageKey: "${currentStorageKey}" }. Received: { maxErrors: ${maxErrors}, storageKey: "${storageKey}" }. Only the first configuration is used for global error listeners.`
+    );
+  }
+  react.useEffect(() => {
+    initializeErrorListeners();
+  }, []);
+  const getErrors = react.useCallback(() => {
+    if (typeof window === "undefined") return [];
+    try {
+      const stored = sessionStorage.getItem(storageKey);
+      return stored ? JSON.parse(stored) : [];
+    } catch {
+      return [];
+    }
+  }, [storageKey]);
+  const clearErrors = react.useCallback(() => {
+    if (typeof window === "undefined") return;
+    try {
+      sessionStorage.removeItem(storageKey);
+    } catch {
+    }
+  }, [storageKey]);
+  return { getErrors, clearErrors };
+}
+function useComparisonData({
+  useDataHook,
+  currentParams,
+  comparisonRanges,
+  comparisonMode,
+  comparisonPeriods,
+  toEntries,
+  getPeriodKey
+}) {
+  const { data: response, isLoading } = useDataHook(currentParams);
+  const shouldFetchComparison = comparisonMode !== "none";
+  const comparisonEnabled = [0, 1, 2].map(
+    (index) => shouldFetchComparison && !!comparisonRanges[index]
+  );
+  const { data: compResp0 } = useDataHook({
+    ...currentParams,
+    periodStart: comparisonRanges[0]?.start ?? "",
+    periodEnd: comparisonRanges[0]?.end ?? "",
+    enabled: comparisonEnabled[0],
+    keepPrevious: true
+  });
+  const { data: compResp1 } = useDataHook({
+    ...currentParams,
+    periodStart: comparisonRanges[1]?.start ?? "",
+    periodEnd: comparisonRanges[1]?.end ?? "",
+    enabled: comparisonEnabled[1],
+    keepPrevious: true
+  });
+  const { data: compResp2 } = useDataHook({
+    ...currentParams,
+    periodStart: comparisonRanges[2]?.start ?? "",
+    periodEnd: comparisonRanges[2]?.end ?? "",
+    enabled: comparisonEnabled[2],
+    keepPrevious: true
+  });
+  const rawData = response?.data ?? [];
+  const entries = react.useMemo(() => {
+    const current = toEntries(rawData);
+    if (comparisonMode === "none") return current;
+    const compDataSets = [compResp0, compResp1, compResp2].filter(Boolean);
+    const compEntries = compDataSets.flatMap(
+      (result) => toEntries(result?.data ?? [])
+    );
+    return [...compEntries, ...current];
+  }, [rawData, comparisonMode, compResp0, compResp1, compResp2, toEntries]);
+  const currentPeriodCount = react.useMemo(
+    () => new Set(rawData.map(getPeriodKey)).size,
+    [rawData, getPeriodKey]
+  );
+  const currentPeriodKeys = react.useMemo(
+    () => Array.from(new Set(rawData.map(getPeriodKey))).sort(
+      (a, b) => b.localeCompare(a)
+    ),
+    [rawData, getPeriodKey]
+  );
+  const totalVisiblePeriodCount = react.useMemo(
+    () => new Set(entries.map((entry) => entry.period_first_day)).size,
+    [entries]
+  );
+  const showVariance = totalVisiblePeriodCount === 2 && !(comparisonMode === "previous" && comparisonPeriods > 1);
+  return {
+    response,
+    isLoading,
+    rawData,
+    entries,
+    currentPeriodCount,
+    currentPeriodKeys,
+    totalVisiblePeriodCount,
+    showVariance,
+    classes: response?.classes ?? [],
+    departments: response?.departments ?? []
+  };
+}
+function fallbackCopy(text) {
+  try {
+    const textarea = document.createElement("textarea");
+    textarea.value = text;
+    textarea.style.position = "fixed";
+    textarea.style.left = "-9999px";
+    textarea.style.top = "-9999px";
+    document.body.appendChild(textarea);
+    textarea.select();
+    const ok = document.execCommand("copy");
+    document.body.removeChild(textarea);
+    return ok;
+  } catch {
+    return false;
+  }
+}
+function useCopyToClipboard({
+  timeout = 2e3
+} = {}) {
+  const [isCopied, setIsCopied] = react.useState(false);
+  const [copiedId, setCopiedId] = react.useState(null);
+  const copyToClipboard = react.useCallback(
+    (value, id) => {
+      if (typeof window === "undefined" || !value) return;
+      const onSuccess = () => {
+        setIsCopied(true);
+        if (id) setCopiedId(id);
+        setTimeout(() => {
+          setIsCopied(false);
+          if (id) setCopiedId(null);
+        }, timeout);
+      };
+      if (navigator.clipboard?.writeText) {
+        navigator.clipboard.writeText(value).then(onSuccess).catch(() => {
+          fallbackCopy(value) && onSuccess();
+        });
+        return;
+      }
+      fallbackCopy(value) && onSuccess();
+    },
+    [timeout]
+  );
+  return { isCopied, copiedId, copyToClipboard };
+}
+function useDebounce(value, delay = 500) {
+  const [debouncedValue, setDebouncedValue] = react.useState(value);
+  react.useEffect(() => {
+    const timer = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+function getDefaultLtmRange() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = now.getMonth();
+  const start = new Date(year - 1, month, 1);
+  const end = new Date(year, month + 1, 0);
+  return {
+    start: start.toISOString().slice(0, 10),
+    end: end.toISOString().slice(0, 10)
+  };
+}
+function useFinancialStatementState({
+  initialGranularity = "ltm",
+  initialComparisonMode = "none",
+  initialComparisonPeriods = 1
+} = {}) {
+  const defaultRange = react.useMemo(() => getDefaultLtmRange(), []);
+  const [granularity, setGranularity] = react.useState(initialGranularity);
+  const [periodStart, setPeriodStart] = react.useState(defaultRange.start);
+  const [periodEnd, setPeriodEnd] = react.useState(defaultRange.end);
+  const [timeUnit, setTimeUnit] = react.useState("month");
+  const [comparisonMode, setComparisonMode] = react.useState(
+    initialComparisonMode
+  );
+  const [comparisonPeriods, setComparisonPeriods] = react.useState(
+    initialComparisonPeriods
+  );
+  const [comparisonCustomStart, setComparisonCustomStart] = react.useState();
+  const [comparisonCustomEnd, setComparisonCustomEnd] = react.useState();
+  const [selectedClass, setSelectedClass] = react.useState("");
+  const [selectedDepartment, setSelectedDepartment] = react.useState("");
+  const [mobileFiltersOpen, setMobileFiltersOpen] = react.useState(false);
+  const [hideZeroRows, setHideZeroRows] = react.useState(true);
+  const [showRowTotals, setShowRowTotals] = react.useState(false);
+  const handlePeriodChange = react.useCallback(
+    (params) => {
+      setGranularity(params.granularity);
+      setPeriodStart(params.periodStart);
+      setPeriodEnd(params.periodEnd);
+      setTimeUnit(params.timeUnit);
+    },
+    []
+  );
+  const handleComparisonChange = react.useCallback(
+    (params) => {
+      if (granularity === "ltm") {
+        const ltmDefault = params.mode === "previous" && params.periods === 11;
+        if (!ltmDefault) {
+          const end = dateFns.endOfMonth(dateFns.parseISO(periodEnd));
+          const start = dateFns.startOfMonth(end);
+          setGranularity("month");
+          setTimeUnit("month");
+          setPeriodStart(start.toISOString().slice(0, 10));
+          setPeriodEnd(end.toISOString().slice(0, 10));
+        }
+      }
+      setComparisonMode(params.mode);
+      setComparisonPeriods(params.periods);
+      setComparisonCustomStart(params.customStart);
+      setComparisonCustomEnd(params.customEnd);
+    },
+    [granularity, periodEnd]
+  );
+  const priorRange = react.useMemo(() => {
+    const start = /* @__PURE__ */ new Date(`${periodStart}T00:00:00`);
+    const end = /* @__PURE__ */ new Date(`${periodEnd}T00:00:00`);
+    const durationMs = end.getTime() - start.getTime();
+    const priorEnd = new Date(start.getTime() - 1);
+    const priorStart = new Date(priorEnd.getTime() - durationMs);
+    return {
+      start: priorStart.toISOString().slice(0, 10),
+      end: priorEnd.toISOString().slice(0, 10)
+    };
+  }, [periodStart, periodEnd]);
+  const comparisonRanges = react.useMemo(() => {
+    if (comparisonMode === "none") return [];
+    if (comparisonMode === "custom" && comparisonCustomStart && comparisonCustomEnd) {
+      return [{ start: comparisonCustomStart, end: comparisonCustomEnd }];
+    }
+    const start = /* @__PURE__ */ new Date(`${periodStart}T00:00:00`);
+    const end = /* @__PURE__ */ new Date(`${periodEnd}T00:00:00`);
+    const durationMs = end.getTime() - start.getTime();
+    const ranges = [];
+    if (comparisonMode === "previous") {
+      const dayCount = Math.round(durationMs / 864e5) + 1;
+      const cEnd = new Date(start);
+      cEnd.setDate(cEnd.getDate() - 1);
+      const cStart = new Date(cEnd);
+      cStart.setDate(cStart.getDate() - (dayCount * comparisonPeriods - 1));
+      return [
+        {
+          start: cStart.toISOString().slice(0, 10),
+          end: cEnd.toISOString().slice(0, 10)
+        }
+      ];
+    }
+    for (let i = 1; i <= comparisonPeriods; i++) {
+      if (comparisonMode === "same-period-last-year") {
+        const cStart = new Date(start);
+        cStart.setFullYear(cStart.getFullYear() - i);
+        const cEnd = new Date(end);
+        cEnd.setFullYear(cEnd.getFullYear() - i);
+        ranges.push({
+          start: cStart.toISOString().slice(0, 10),
+          end: cEnd.toISOString().slice(0, 10)
+        });
+      }
+    }
+    return ranges;
+  }, [
+    comparisonMode,
+    comparisonPeriods,
+    comparisonCustomStart,
+    comparisonCustomEnd,
+    periodStart,
+    periodEnd
+  ]);
+  const formatPeriodLabel = react.useCallback((periodKey) => {
+    if (!periodKey) return "\u2014";
+    return dateFns.format(dateFns.parseISO(periodKey), "MMM yy");
+  }, []);
+  const activeFilterCount = (selectedClass ? 1 : 0) + (selectedDepartment ? 1 : 0) + (comparisonMode !== "none" ? 1 : 0);
+  const periodChipLabel = granularity === "ltm" ? "LTM" : granularity === "ytd" ? "YTD" : granularity === "month" ? "Month" : granularity === "quarter" ? "Quarter" : granularity === "year" ? "Year" : "Custom";
+  const comparisonChipLabel = granularity === "ltm" ? "vs Previous 11" : comparisonMode === "none" ? "No comparison" : comparisonMode === "previous" ? `vs Previous ${comparisonPeriods}` : comparisonMode === "same-period-last-year" ? `vs Last year (${comparisonPeriods})` : "Custom comparison";
+  const resetFilters = react.useCallback(() => {
+    setSelectedClass("");
+    setSelectedDepartment("");
+    setComparisonMode("none");
+    setComparisonPeriods(1);
+    setComparisonCustomStart(void 0);
+    setComparisonCustomEnd(void 0);
+  }, []);
+  return {
+    granularity,
+    periodStart,
+    periodEnd,
+    timeUnit,
+    selectedClass,
+    selectedDepartment,
+    comparisonMode,
+    comparisonPeriods,
+    comparisonCustomStart,
+    comparisonCustomEnd,
+    mobileFiltersOpen,
+    hideZeroRows,
+    showRowTotals,
+    priorRange,
+    comparisonRanges,
+    periodChipLabel,
+    comparisonChipLabel,
+    activeFilterCount,
+    formatPeriodLabel,
+    setSelectedClass,
+    setSelectedDepartment,
+    setMobileFiltersOpen,
+    setHideZeroRows,
+    setShowRowTotals,
+    handlePeriodChange,
+    handleComparisonChange,
+    resetFilters
+  };
+}
+function matchesShortcut(event, shortcut) {
+  if (shortcut.enabled === false) return false;
+  const ctrlMatch = shortcut.ctrl ? event.ctrlKey : !event.ctrlKey;
+  const shiftMatch = shortcut.shift ? event.shiftKey : !event.shiftKey;
+  const altMatch = shortcut.alt ? event.altKey : !event.altKey;
+  const metaMatch = shortcut.meta ? event.metaKey : !event.metaKey;
+  const keyMatch = event.key === shortcut.key;
+  return ctrlMatch && shiftMatch && altMatch && metaMatch && keyMatch;
+}
+function useKeyboardShortcut(shortcut, callback, options = {}) {
+  const {
+    enabled = true,
+    target = typeof document !== "undefined" ? document : null,
+    capture = false,
+    preventDefault = false,
+    stopPropagation = false
+  } = options;
+  const callbackRef = react.useRef(callback);
+  react.useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  react.useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (!enabled || !target) {
+      return;
+    }
+    const handler = (event) => {
+      const keyboardEvent = event;
+      const target2 = keyboardEvent.target;
+      if (target2.tagName === "INPUT" || target2.tagName === "TEXTAREA" || target2.isContentEditable) {
+        return;
+      }
+      if (matchesShortcut(keyboardEvent, shortcut)) {
+        if (preventDefault) {
+          keyboardEvent.preventDefault();
+        }
+        if (stopPropagation) {
+          keyboardEvent.stopPropagation();
+        }
+        callbackRef.current(keyboardEvent);
+      }
+    };
+    target.addEventListener("keydown", handler, capture);
+    return () => {
+      target.removeEventListener("keydown", handler, capture);
+    };
+  }, [shortcut, enabled, target, capture, preventDefault, stopPropagation]);
+}
+function formatShortcut(shortcut, usePlatformSymbols = false) {
+  const parts = [];
+  const isMac = typeof navigator !== "undefined" && /Mac|iPhone|iPad|iPod/.test(navigator.userAgent);
+  if (shortcut.ctrl) {
+    parts.push(usePlatformSymbols && isMac ? "\u2303" : "Ctrl");
+  }
+  if (shortcut.alt) {
+    parts.push(usePlatformSymbols && isMac ? "\u2325" : "Alt");
+  }
+  if (shortcut.shift) {
+    parts.push(usePlatformSymbols && isMac ? "\u21E7" : "Shift");
+  }
+  if (shortcut.meta) {
+    parts.push(usePlatformSymbols && isMac ? "\u2318" : "Meta");
+  }
+  const keyDisplay = shortcut.key.length === 1 ? shortcut.key.toUpperCase() : shortcut.key;
+  parts.push(keyDisplay);
+  return parts.join(usePlatformSymbols ? "" : "+");
+}
+function useLocalStorage(key, initialValue) {
+  const readValue = react.useCallback(() => {
+    if (typeof window === "undefined" || !key) {
+      return initialValue;
+    }
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch (error) {
+      console.warn(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  }, [initialValue, key]);
+  const [storedValue, setStoredValue] = react.useState(initialValue);
+  const [isLoaded, setIsLoaded] = react.useState(false);
+  react.useEffect(() => {
+    setStoredValue(readValue());
+    setIsLoaded(true);
+  }, [readValue]);
+  const setValue = react.useCallback(
+    (value) => {
+      try {
+        setStoredValue((prevStoredValue) => {
+          const valueToStore = value instanceof Function ? value(prevStoredValue) : value;
+          if (typeof window !== "undefined" && key) {
+            window.localStorage.setItem(key, JSON.stringify(valueToStore));
+            window.dispatchEvent(
+              new StorageEvent("storage", {
+                key,
+                newValue: JSON.stringify(valueToStore),
+                url: window.location.href
+              })
+            );
+          }
+          return valueToStore;
+        });
+      } catch (error) {
+        console.warn(`Error setting localStorage key "${key}":`, error);
+      }
+    },
+    [key]
+  );
+  const removeValue = react.useCallback(() => {
+    try {
+      if (typeof window !== "undefined" && key) {
+        window.localStorage.removeItem(key);
+        window.dispatchEvent(
+          new StorageEvent("storage", {
+            key,
+            newValue: null
+          })
+        );
+      }
+      setStoredValue(initialValue);
+    } catch (error) {
+      console.warn(`Error removing localStorage key "${key}":`, error);
+    }
+  }, [initialValue, key]);
+  react.useEffect(() => {
+    if (!key) return;
+    const handleStorageChange = (event) => {
+      if (event.key === key && event.newValue !== null) {
+        try {
+          setStoredValue(JSON.parse(event.newValue));
+        } catch {
+        }
+      } else if (event.key === key && event.newValue === null) {
+        setStoredValue(initialValue);
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => window.removeEventListener("storage", handleStorageChange);
+  }, [initialValue, key]);
+  return [storedValue, setValue, removeValue, isLoaded];
+}
+function useMediaQuery(query) {
+  const [matches, setMatches] = react.useState(false);
+  react.useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const mediaQuery = window.matchMedia(query);
+    setMatches(mediaQuery.matches);
+    const handleChange = (event) => {
+      setMatches(event.matches);
+    };
+    mediaQuery.addEventListener("change", handleChange);
+    return () => {
+      mediaQuery.removeEventListener("change", handleChange);
+    };
+  }, [query]);
+  return matches;
+}
+var breakpoints = {
+  sm: "(min-width: 640px)",
+  md: "(min-width: 768px)",
+  lg: "(min-width: 1024px)",
+  xl: "(min-width: 1280px)",
+  "2xl": "(min-width: 1536px)"
+};
+function useBreakpoints() {
+  const isSm = useMediaQuery(breakpoints.sm);
+  const isMd = useMediaQuery(breakpoints.md);
+  const isLg = useMediaQuery(breakpoints.lg);
+  const isXl = useMediaQuery(breakpoints.xl);
+  const is2xl = useMediaQuery(breakpoints["2xl"]);
+  return {
+    /** Below 640px */
+    isMobile: !isSm,
+    /** 640px - 767px */
+    isSm: isSm && !isMd,
+    /** 768px - 1023px */
+    isTablet: isMd && !isLg,
+    /** 768px+ */
+    isMd,
+    /** 1024px+ */
+    isDesktop: isLg,
+    /** 1024px - 1279px */
+    isLg: isLg && !isXl,
+    /** 1280px+ */
+    isXl,
+    /** 1536px+ */
+    is2xl
+  };
+}
+function useStatementExport({
+  entries,
+  config,
+  timeUnit,
+  subtotalRules,
+  hideZeroRows,
+  periodStart,
+  periodEnd,
+  filenamePrefix,
+  worksheetName
+}) {
+  return react.useCallback(
+    (format2) => {
+      const { rows: flat, periodKeys } = chunkUM7WMXIU_js.flattenStatementForExport(
+        entries,
+        config,
+        timeUnit,
+        subtotalRules,
+        hideZeroRows
+      );
+      const headers = ["Account", ...periodKeys, "Total"];
+      const dataRows = flat.map((row) => [
+        row.account,
+        ...periodKeys.map((periodKey) => String(row[periodKey] ?? 0)),
+        String(row.total ?? 0)
+      ]);
+      const filename = `${filenamePrefix}-${periodStart}-to-${periodEnd}`;
+      if (format2 === "csv") {
+        const escapeCsv = (value) => `"${value.replace(/"/g, '""')}"`;
+        const csv = [
+          headers.map(escapeCsv).join(","),
+          ...dataRows.map((row) => row.map(escapeCsv).join(","))
+        ].join("\n");
+        const blob = new Blob([csv], { type: "text/csv;charset=utf-8;" });
+        const url = URL.createObjectURL(blob);
+        const anchor = document.createElement("a");
+        anchor.href = url;
+        anchor.download = `${filename}.csv`;
+        anchor.click();
+        URL.revokeObjectURL(url);
+        return;
+      }
+      const rowStart = 2;
+      const firstValueColumn = 1;
+      const lastValueColumn = periodKeys.length;
+      const totalColumn = headers.length - 1;
+      const rows = [
+        headers.map((header, index) => ({
+          value: header,
+          style: index === totalColumn ? "totalLabel" : "header"
+        })),
+        ...flat.map((row, rowIndex) => {
+          const excelRow = rowStart + rowIndex;
+          const totalFormula = `SUM(${chunkUM7WMXIU_js.excelColumnName(firstValueColumn)}${excelRow}:${chunkUM7WMXIU_js.excelColumnName(lastValueColumn)}${excelRow})`;
+          const periodCells = periodKeys.map(
+            (periodKey) => ({
+              value: Number(row[periodKey] ?? 0),
+              style: "currency",
+              type: "Number"
+            })
+          );
+          return [
+            { value: row.account, style: "text" },
+            ...periodCells,
+            {
+              formula: totalFormula,
+              value: Number(row.total ?? 0),
+              style: "totalNumber",
+              type: "Number"
+            }
+          ];
+        })
+      ];
+      const xml = chunkUM7WMXIU_js.buildSpreadsheetWorkbookXml({
+        worksheetName,
+        rows
+      });
+      chunkUM7WMXIU_js.downloadExcelXml(xml, filename);
+    },
+    [
+      config,
+      entries,
+      filenamePrefix,
+      hideZeroRows,
+      periodEnd,
+      periodStart,
+      subtotalRules,
+      timeUnit,
+      worksheetName
+    ]
+  );
+}
+function useStatementMobileMode({
+  isMobile,
+  entries,
+  currentPeriodKeys,
+  comparisonMode
+}) {
+  const normalizedPeriodKeys = react.useMemo(
+    () => Array.from(new Set(currentPeriodKeys)).sort((a, b) => b.localeCompare(a)),
+    [currentPeriodKeys]
+  );
+  const [activePeriodIndex, setActivePeriodIndex] = react.useState(0);
+  const [compareEnabled, setCompareEnabled] = react.useState(false);
+  react.useEffect(() => {
+    setActivePeriodIndex(
+      (index) => normalizedPeriodKeys.length === 0 ? 0 : Math.min(index, normalizedPeriodKeys.length - 1)
+    );
+  }, [normalizedPeriodKeys.length]);
+  const activePeriod = normalizedPeriodKeys[activePeriodIndex] ?? normalizedPeriodKeys[0];
+  const comparisonPeriodKeys = react.useMemo(
+    () => Array.from(new Set(entries.map((entry) => entry.period_first_day))).filter((period) => !normalizedPeriodKeys.includes(period)).sort((a, b) => b.localeCompare(a)),
+    [entries, normalizedPeriodKeys]
+  );
+  const hasComparisonCandidate = comparisonMode === "none" ? normalizedPeriodKeys.length > 1 : comparisonPeriodKeys.length > 0;
+  react.useEffect(() => {
+    if (!hasComparisonCandidate) setCompareEnabled(false);
+  }, [hasComparisonCandidate]);
+  const mobileComparisonPeriod = react.useMemo(() => {
+    if (!compareEnabled || !activePeriod) return void 0;
+    if (comparisonMode !== "none") return comparisonPeriodKeys[0];
+    const activeIndex = normalizedPeriodKeys.indexOf(activePeriod);
+    return activeIndex >= 0 ? normalizedPeriodKeys[activeIndex + 1] : void 0;
+  }, [
+    compareEnabled,
+    activePeriod,
+    comparisonMode,
+    comparisonPeriodKeys,
+    normalizedPeriodKeys
+  ]);
+  const mobileVisiblePeriods = react.useMemo(() => {
+    if (!isMobile || !activePeriod) return null;
+    return mobileComparisonPeriod ? [activePeriod, mobileComparisonPeriod] : [activePeriod];
+  }, [isMobile, activePeriod, mobileComparisonPeriod]);
+  const mobileEntries = react.useMemo(() => {
+    if (!mobileVisiblePeriods) return entries;
+    const visible = new Set(mobileVisiblePeriods);
+    return entries.filter((entry) => visible.has(entry.period_first_day));
+  }, [entries, mobileVisiblePeriods]);
+  return {
+    activePeriodIndex,
+    setActivePeriodIndex,
+    compareEnabled,
+    setCompareEnabled,
+    mobileEntries,
+    periodLabel: activePeriod ?? "",
+    compareLabel: mobileComparisonPeriod,
+    hasPrev: activePeriodIndex > 0,
+    hasNext: normalizedPeriodKeys.length > 0 && activePeriodIndex < normalizedPeriodKeys.length - 1,
+    hasComparisonCandidate,
+    activePeriod
+  };
+}
+function toast(options) {
+  const { title, description, variant, duration } = options;
+  const message = title || description || "";
+  const toastOptions = {
+    description: title ? description : void 0,
+    duration
+  };
+  if (variant === "destructive") {
+    return sonner.toast.error(message, toastOptions);
+  }
+  return sonner.toast(message, toastOptions);
+}
+function useToast() {
+  return { toast };
+}
+function createDataRestorationHandler(form, defaultValues, onComplete) {
+  return (data) => {
+    const dataWithPossibleValues = data;
+    const { values: _ignoredValues, ...cleanData } = dataWithPossibleValues;
+    const actualData = Object.keys(cleanData).length > 0 ? cleanData : data;
+    const newValues = { ...defaultValues };
+    const keys = Object.keys(defaultValues);
+    for (const key of keys) {
+      const restoredValue = actualData[key];
+      if (restoredValue !== void 0 && restoredValue !== null) {
+        newValues[key] = restoredValue;
+      }
+    }
+    requestAnimationFrame(() => {
+      for (const key of keys) {
+        form.setFieldValue(key, newValues[key]);
+      }
+      setTimeout(() => {
+        for (const key of keys) {
+          form.validateField(key, "change");
+        }
+        onComplete?.();
+      }, 100);
+    });
+  };
+}
+function extractZodErrors(zodResult, fieldFilter) {
+  if (zodResult.success || !zodResult.error) {
+    return [];
+  }
+  const issues = zodResult.error.issues;
+  if (!fieldFilter) {
+    return issues.map((issue) => issue.message);
+  }
+  return issues.filter((issue) => {
+    const fieldName = issue.path[0];
+    return typeof fieldName === "string" && fieldFilter.includes(fieldName);
+  }).map((issue) => issue.message);
+}
+function createStepHasFieldErrors(steps, formFieldMeta) {
+  return (stepIndex) => {
+    const fields = steps[stepIndex]?.fields ?? [];
+    for (const fieldName of fields) {
+      const meta = formFieldMeta[fieldName];
+      if (meta?.errors && meta.errors.length > 0) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function createFormResetHandler(form, defaultValues, resetWizardState, clearSubmitError) {
+  return () => {
+    form.reset();
+    const keys = Object.keys(defaultValues);
+    for (const key of keys) {
+      form.setFieldValue(key, defaultValues[key]);
+    }
+    resetWizardState();
+    clearSubmitError?.();
+  };
+}
+function createFormSubmitHandler(form, markAsSubmitted, options) {
+  const {
+    validateStep,
+    totalSteps,
+    errorLogger,
+    componentName,
+    getStepStatuses,
+    showValidationToast
+  } = options;
+  return () => {
+    markAsSubmitted();
+    form.validateAllFields("change");
+    const allValid = Array.from({ length: totalSteps }, (_, i) => i).every(
+      (index) => validateStep(index)
+    );
+    if (!allValid) {
+      showValidationToast?.(
+        "Please fix the errors in the highlighted sections."
+      );
+      errorLogger?.logError(new Error(`${componentName} validation failed`), {
+        component: componentName,
+        action: "submit",
+        metadata: { stepStatuses: getStepStatuses?.() }
+      });
+      return;
+    }
+    return form.handleSubmit();
+  };
+}
+function useWizardForm(options, currentValues) {
+  const {
+    steps,
+    validateStep,
+    getStepErrors,
+    stepHasFieldErrors,
+    initialStep = 0
+  } = options;
+  const [currentStep, setCurrentStep] = react.useState(initialStep);
+  const [highestStepReached, setHighestStepReached] = react.useState(initialStep);
+  const [stepsWithErrorsShown, setStepsWithErrorsShown] = react.useState(
+    /* @__PURE__ */ new Set()
+  );
+  const [hasAttemptedFinalSubmit, setHasAttemptedFinalSubmit] = react.useState(false);
+  const totalSteps = steps.length;
+  const isFirstStep = currentStep === 0;
+  const isLastStep = currentStep === totalSteps - 1;
+  const stepStatuses = react.useMemo(() => {
+    return steps.map((step, index) => {
+      const isCurrentStepIndex = index === currentStep;
+      const isValid = validateStep(index, currentValues);
+      step.optional ?? false;
+      const shouldShowErrors = hasAttemptedFinalSubmit || stepsWithErrorsShown.has(index);
+      const hasFieldErrors = shouldShowErrors && stepHasFieldErrors?.(index);
+      const hasMovedPastThisStep = index < highestStepReached;
+      const isFutureStep = index > highestStepReached;
+      if (shouldShowErrors && (!isValid || hasFieldErrors)) {
+        return "error";
+      }
+      if (isFutureStep && !hasAttemptedFinalSubmit) {
+        return "not-started";
+      }
+      if (isValid) {
+        return "complete";
+      }
+      if (hasMovedPastThisStep && !isCurrentStepIndex) {
+        return "incomplete";
+      }
+      return "not-started";
+    });
+  }, [
+    steps,
+    currentStep,
+    highestStepReached,
+    hasAttemptedFinalSubmit,
+    stepsWithErrorsShown,
+    validateStep,
+    stepHasFieldErrors,
+    currentValues
+  ]);
+  const hasIncompleteOrErrorSteps = react.useMemo(() => {
+    return stepStatuses.some(
+      (status) => status === "incomplete" || status === "error"
+    );
+  }, [stepStatuses]);
+  const isCurrentStepValid = react.useMemo(() => {
+    return validateStep(currentStep, currentValues);
+  }, [validateStep, currentStep, currentValues]);
+  const handleNext = react.useCallback(() => {
+    setStepsWithErrorsShown((prev) => new Set(prev).add(currentStep));
+    const nextStep = currentStep + 1;
+    if (nextStep < totalSteps) {
+      setCurrentStep(nextStep);
+      setHighestStepReached((prev) => Math.max(prev, nextStep));
+    }
+  }, [currentStep, totalSteps]);
+  const handleBack = react.useCallback(() => {
+    if (!isFirstStep) {
+      const prevStep = currentStep - 1;
+      setCurrentStep(prevStep);
+    }
+  }, [currentStep, isFirstStep]);
+  const handleStepClick = react.useCallback(
+    (stepIndex) => {
+      if (stepIndex !== currentStep) {
+        setStepsWithErrorsShown((prev) => new Set(prev).add(currentStep));
+      }
+      setCurrentStep(stepIndex);
+      if (stepIndex > highestStepReached) {
+        setHighestStepReached(stepIndex);
+      }
+    },
+    [currentStep, highestStepReached]
+  );
+  const markAsSubmitted = react.useCallback(() => {
+    setHasAttemptedFinalSubmit(true);
+  }, []);
+  const resetWizardState = react.useCallback(() => {
+    setCurrentStep(initialStep);
+    setHighestStepReached(initialStep);
+    setStepsWithErrorsShown(/* @__PURE__ */ new Set());
+    setHasAttemptedFinalSubmit(false);
+  }, [initialStep]);
+  const shouldShowErrorsForStep = react.useCallback(
+    (stepIndex) => {
+      return hasAttemptedFinalSubmit || stepsWithErrorsShown.has(stepIndex);
+    },
+    [hasAttemptedFinalSubmit, stepsWithErrorsShown]
+  );
+  const getStepStatus = react.useCallback(
+    (stepIndex) => stepStatuses[stepIndex],
+    [stepStatuses]
+  );
+  const getStepTooltip = react.useCallback(
+    (stepIndex, status) => {
+      if (status !== "error" && status !== "incomplete") return null;
+      if (getStepErrors) {
+        const stepErrors = getStepErrors(stepIndex, currentValues);
+        if (stepErrors.length > 0) {
+          return `${stepErrors.length} issue${stepErrors.length > 1 ? "s" : ""}:
+\u2022 ${stepErrors.join("\n\u2022 ")}`;
+        }
+      }
+      return null;
+    },
+    [getStepErrors, currentValues]
+  );
+  const getStepFields = react.useCallback(
+    (stepIndex) => {
+      return steps[stepIndex]?.fields ?? [];
+    },
+    [steps]
+  );
+  return {
+    // Navigation state
+    currentStep,
+    totalSteps,
+    isFirstStep,
+    isLastStep,
+    highestStepReached,
+    // Validation state
+    stepsWithErrorsShown,
+    hasAttemptedFinalSubmit,
+    stepStatuses,
+    hasIncompleteOrErrorSteps,
+    isCurrentStepValid,
+    // Navigation handlers
+    handleNext,
+    handleBack,
+    handleStepClick,
+    // Submit handlers
+    markAsSubmitted,
+    resetWizardState,
+    // Utility functions
+    shouldShowErrorsForStep,
+    getStepStatus,
+    getStepTooltip,
+    getStepFields
+  };
+}
+
+exports.breakpoints = breakpoints;
+exports.createDataRestorationHandler = createDataRestorationHandler;
+exports.createFormResetHandler = createFormResetHandler;
+exports.createFormSubmitHandler = createFormSubmitHandler;
+exports.createStepHasFieldErrors = createStepHasFieldErrors;
+exports.extractZodErrors = extractZodErrors;
+exports.formatShortcut = formatShortcut;
+exports.getDefaultLtmRange = getDefaultLtmRange;
+exports.matchesShortcut = matchesShortcut;
+exports.useBreakpoints = useBreakpoints;
+exports.useComparisonData = useComparisonData;
+exports.useCopyToClipboard = useCopyToClipboard;
+exports.useDebounce = useDebounce;
+exports.useFinancialStatementState = useFinancialStatementState;
+exports.useKeyboardShortcut = useKeyboardShortcut;
+exports.useLocalStorage = useLocalStorage;
+exports.useMediaQuery = useMediaQuery;
+exports.useSessionErrors = useSessionErrors;
+exports.useStatementExport = useStatementExport;
+exports.useStatementMobileMode = useStatementMobileMode;
+exports.useToast = useToast;
+exports.useWizardForm = useWizardForm;