@jmruthers/pace-core 0.2.4

package/dist/components.js

@@ -0,0 +1,3759 @@
+import {
+  Avatar,
+  AvatarFallback,
+  AvatarImage,
+  Card,
+  CardActions,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+  ErrorBoundary,
+  EventLogo,
+  EventLogoCompact,
+  EventLogoLarge,
+  EventSelector,
+  FileUpload,
+  Footer,
+  Form,
+  Header,
+  Label,
+  LoginForm,
+  NavigationMenu,
+  OrganisationSelector,
+  PaceAppLayout,
+  PaceLoginPage,
+  PasswordResetForm,
+  Progress,
+  PublicLoadingSkeleton,
+  PublicLoadingSpinner,
+  PublicLoadingSpinnerFullPage,
+  PublicPageContextChecker,
+  PublicPageDebugger,
+  PublicPageDiagnostic,
+  PublicPageFooter,
+  PublicPageHeader,
+  PublicPageLayout,
+  Toast,
+  ToastAction,
+  ToastClose,
+  ToastDescription,
+  ToastProvider,
+  ToastTitle,
+  ToastViewport,
+  Toaster,
+  UserMenu,
+  useFileUpload,
+  usePublicPageContext as usePublicPageContext2,
+  useStorage,
+  useToast
+} from "./chunk-7JL3T7BO.js";
+import {
+  Alert,
+  AlertDescription,
+  AlertTitle,
+  Checkbox,
+  DataTable,
+  Input,
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectLabel,
+  SelectSeparator,
+  SelectTrigger,
+  SelectValue,
+  Table,
+  TableBody,
+  TableCaption,
+  TableCell,
+  TableFooter,
+  TableHead,
+  TableHeader,
+  TableRow
+} from "./chunk-WYB6MBZA.js";
+import "./chunk-6ZQVSHKL.js";
+import "./chunk-7BNPOCLL.js";
+import {
+  init_EventProvider,
+  useEvents
+} from "./chunk-TMRLB2LA.js";
+import {
+  DefaultPublicErrorFallback,
+  PublicErrorBoundary,
+  PublicPageProvider,
+  useErrorBoundary,
+  useIsPublicPage,
+  usePublicPageContext
+} from "./chunk-2MKP6IYD.js";
+import "./chunk-SS3E6QLB.js";
+import {
+  UnifiedAuthProvider,
+  init_OrganisationProvider,
+  init_UnifiedAuthProvider,
+  useOrganisations,
+  useUnifiedAuth
+} from "./chunk-DY5E3AT7.js";
+import {
+  Button,
+  Dialog,
+  DialogBody,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipRoot,
+  TooltipTrigger,
+  init_Dialog,
+  init_Tooltip2 as init_Tooltip
+} from "./chunk-ETEJVKYK.js";
+import "./chunk-YDJW5XTN.js";
+import {
+  LoadingSpinner
+} from "./chunk-CDQ3PX7L.js";
+import "./chunk-74C6SNEC.js";
+import "./chunk-2V3Y6YBC.js";
+import {
+  cn,
+  init_cn
+} from "./chunk-OHXGNT3K.js";
+import "./chunk-PLDDJCW6.js";
+
+// src/components/index.ts
+init_UnifiedAuthProvider();
+init_Dialog();
+init_Tooltip();
+
+// src/components/Form/FormField.tsx
+init_cn();
+import { useFormContext, Controller } from "react-hook-form";
+import { jsx, jsxs } from "react/jsx-runtime";
+function FormField({
+  name,
+  label,
+  type = "text",
+  placeholder,
+  inputProps,
+  validation,
+  render,
+  "data-testid": testId,
+  className
+}) {
+  const { control, formState: { errors } } = useFormContext();
+  const fieldError = errors[name];
+  const errorMessage = fieldError && typeof fieldError === "object" && "message" in fieldError ? String(fieldError.message) : void 0;
+  return /* @__PURE__ */ jsxs("div", { className: cn("space-y-2", className), children: [
+    label && /* @__PURE__ */ jsxs(Label, { htmlFor: name, children: [
+      label,
+      validation?.required && /* @__PURE__ */ jsx("span", { className: "text-destructive ml-1", "aria-label": "required", children: "*" })
+    ] }),
+    /* @__PURE__ */ jsx(
+      Controller,
+      {
+        name,
+        control,
+        rules: validation,
+        render: ({ field }) => {
+          if (render) {
+            return render({ field });
+          }
+          return /* @__PURE__ */ jsx(
+            "input",
+            {
+              ...field,
+              id: name,
+              type,
+              placeholder,
+              "data-testid": testId,
+              className: cn(
+                "flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+                fieldError && "border-destructive focus-visible:ring-destructive"
+              ),
+              ...inputProps
+            }
+          );
+        }
+      }
+    ),
+    errorMessage && /* @__PURE__ */ jsx("p", { className: "text-destructive", role: "alert", children: errorMessage })
+  ] });
+}
+
+// src/components/Form/FormErrorSummary.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function FormErrorSummary({
+  errors = {},
+  title = "Please fix the following errors:",
+  showFieldNames = false
+}) {
+  const errorEntries = Object.entries(errors).filter(([, value]) => Boolean(value));
+  if (errorEntries.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx2(Alert, { variant: "destructive", className: "mb-4", children: /* @__PURE__ */ jsxs2("div", { children: [
+    /* @__PURE__ */ jsx2("h3", { children: title }),
+    /* @__PURE__ */ jsx2("ul", { className: "list-disc list-inside space-y-1", children: errorEntries.map(([field, error], index) => {
+      const message = typeof error === "object" && error.message ? error.message : String(error);
+      return /* @__PURE__ */ jsx2("li", { className: "text-sm", children: showFieldNames ? `${field}: ${message}` : message }, index);
+    }) })
+  ] }) });
+}
+
+// src/components/Form/FormLiveRegion.tsx
+init_cn();
+import { useEffect, useState } from "react";
+import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
+function FormLiveRegion({
+  form,
+  politeness = "polite",
+  delay = 500,
+  successMessage = "Form submitted successfully",
+  className,
+  enableFieldAnnouncements = true
+}) {
+  const [message, setMessage] = useState("");
+  const { formState } = form;
+  useEffect(() => {
+    let timeoutId;
+    if (formState.isSubmitting) {
+      setMessage("Submitting form...");
+    } else if (formState.isSubmitSuccessful) {
+      timeoutId = setTimeout(() => {
+        setMessage(successMessage);
+      }, delay);
+    } else if (formState.errors && Object.keys(formState.errors).length > 0) {
+      const errorCount = Object.keys(formState.errors).length;
+      const errorFields = Object.keys(formState.errors).join(", ");
+      setMessage(`Form has ${errorCount} error${errorCount === 1 ? "" : "s"} in: ${errorFields}`);
+    } else if (formState.isValid && formState.isDirty) {
+      setMessage("Form is valid");
+    } else {
+      setMessage("");
+    }
+    return () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [formState, delay, successMessage]);
+  useEffect(() => {
+    if (!enableFieldAnnouncements) return;
+    let timeoutId;
+    const fieldErrors = formState.errors;
+    const touchedFields = formState.touchedFields;
+    const newErrors = Object.keys(fieldErrors).filter((field) => {
+      const touchedField = touchedFields;
+      return touchedField[field] && fieldErrors[field];
+    });
+    if (newErrors.length > 0) {
+      timeoutId = setTimeout(() => {
+        const errorField = newErrors[0];
+        const errorData = fieldErrors[errorField];
+        const errorMessage = errorData?.message;
+        if (errorMessage) {
+          setMessage(`${errorField}: ${errorMessage}`);
+        }
+      }, delay);
+    }
+    return () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, [formState.errors, formState.touchedFields, enableFieldAnnouncements, delay]);
+  if (!message) {
+    return /* @__PURE__ */ jsx3(Fragment, {});
+  }
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      role: "status",
+      "aria-live": politeness,
+      "aria-atomic": "true",
+      className: cn("sr-only", className),
+      style: {
+        position: "absolute",
+        left: "-10000px",
+        width: "1px",
+        height: "1px",
+        overflow: "hidden"
+      },
+      children: message
+    }
+  );
+}
+
+// src/components/Form/FormFieldset.tsx
+init_cn();
+import React2 from "react";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var FormFieldset = React2.forwardRef(
+  ({ legend, description, required, className, children, ...props }, ref) => {
+    const descriptionId = React2.useId();
+    return /* @__PURE__ */ jsxs3(
+      "fieldset",
+      {
+        ref,
+        className: cn("space-y-4 border border-input rounded-lg p-4", className),
+        "aria-describedby": description ? descriptionId : void 0,
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxs3("legend", { className: "px-2", children: [
+            legend,
+            required && /* @__PURE__ */ jsx4("span", { className: "text-destructive ml-1", children: "*" })
+          ] }),
+          description && /* @__PURE__ */ jsx4("p", { id: descriptionId, className: "text-muted-foreground", children: description }),
+          children
+        ]
+      }
+    );
+  }
+);
+FormFieldset.displayName = "FormFieldset";
+
+// src/hooks/useRBAC.ts
+init_UnifiedAuthProvider();
+init_OrganisationProvider();
+init_EventProvider();
+import { useState as useState2, useEffect as useEffect2, useCallback, useMemo } from "react";
+function useRBAC(pageId) {
+  const { user, session, supabase, appName } = useUnifiedAuth();
+  const { selectedOrganisation } = useOrganisations();
+  let selectedEvent = null;
+  try {
+    const eventsContext = useEvents();
+    selectedEvent = eventsContext.selectedEvent;
+  } catch (error2) {
+    console.debug("useRBAC: EventProvider not available, continuing without event context");
+  }
+  const [globalRole, setGlobalRole] = useState2(null);
+  const [organisationRole, setOrganisationRole] = useState2(null);
+  const [eventAppRole, setEventAppRole] = useState2(null);
+  const [permissions, setPermissions] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const loadRBACContext = useCallback(async () => {
+    if (!user || !session || !supabase || !appName) {
+      console.log("[useRBAC] Missing required dependencies, clearing RBAC state");
+      setGlobalRole(null);
+      setOrganisationRole(null);
+      setEventAppRole(null);
+      setPermissions([]);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const { data: appData, error: appError } = await supabase.from("rbac_apps").select("id").eq("name", appName).eq("is_active", true).single();
+      if (appError || !appData) {
+        console.warn("App not found or inactive:", appName);
+        setIsLoading(false);
+        return;
+      }
+      const { data, error: rpcError } = await supabase.rpc("get_rbac_permissions", {
+        p_user_id: user.id,
+        p_app_id: appData.id,
+        p_event_id: selectedEvent?.event_id || null,
+        p_organisation_id: selectedOrganisation?.id || null,
+        p_page_id: pageId || null
+      });
+      if (rpcError) {
+        throw new Error(`Failed to load RBAC permissions: ${rpcError.message}`);
+      }
+      if (data) {
+        const globalPerms = data.filter((p) => p.permission_type === "all_permissions");
+        const orgPerms = data.filter((p) => p.permission_type === "organisation_access");
+        const eventPerms = data.filter((p) => p.permission_type === "event_app_access");
+        setGlobalRole(globalPerms.length > 0 ? "super_admin" : null);
+        setOrganisationRole(orgPerms.length > 0 ? orgPerms[0].role_name : null);
+        setEventAppRole(eventPerms.length > 0 ? eventPerms[0].role_name : null);
+        setPermissions(data);
+      } else {
+        setPermissions([]);
+      }
+    } catch (err) {
+      console.error("RBAC Context Loading Error:", err);
+      setError(err instanceof Error ? err : new Error("Unknown error loading RBAC context"));
+      setPermissions([]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [user?.id, session, supabase, appName, selectedEvent?.event_id, selectedOrganisation?.id, pageId]);
+  const hasPermission = useCallback(async (operation, targetPageId) => {
+    if (!user || !session || !supabase || !appName) return false;
+    if (globalRole === "super_admin") {
+      return true;
+    }
+    try {
+      const { data: appData, error: appError } = await supabase.from("rbac_apps").select("id").eq("name", appName).eq("is_active", true).single();
+      if (appError || !appData) {
+        console.warn("App not found or inactive:", appName);
+        return false;
+      }
+      const { data, error: error2 } = await supabase.rpc("check_page_permission", {
+        p_user_id: user.id,
+        p_app_id: appData.id,
+        p_page_id: targetPageId || pageId || "default",
+        p_operation: operation,
+        p_event_id: selectedEvent?.event_id,
+        p_organisation_id: selectedOrganisation?.id
+      });
+      if (error2) {
+        console.error("Permission check failed:", error2);
+        return false;
+      }
+      return data === true;
+    } catch (err) {
+      console.error("Permission check error:", err);
+      return false;
+    }
+  }, [user, supabase, appName, selectedEvent, selectedOrganisation, pageId, globalRole]);
+  const hasGlobalPermission = useCallback((permission) => {
+    if (globalRole === "super_admin") {
+      return true;
+    }
+    if (permission === "super_admin") {
+      return globalRole === "super_admin";
+    }
+    if (permission === "org_admin") {
+      return organisationRole === "org_admin" || globalRole === "super_admin";
+    }
+    return false;
+  }, [globalRole, organisationRole]);
+  const isSuperAdmin = useMemo(() => globalRole === "super_admin", [globalRole]);
+  const isOrgAdmin = useMemo(() => organisationRole === "org_admin", [organisationRole]);
+  const isEventAdmin = useMemo(() => eventAppRole === "event_admin", [eventAppRole]);
+  const canManageOrganisation = useMemo(
+    () => isSuperAdmin || isOrgAdmin,
+    [isSuperAdmin, isOrgAdmin]
+  );
+  const canManageEvent = useMemo(
+    () => isSuperAdmin || isEventAdmin,
+    [isSuperAdmin, isEventAdmin]
+  );
+  useEffect2(() => {
+    loadRBACContext();
+  }, [loadRBACContext]);
+  return {
+    user,
+    // Add user to the returned context
+    globalRole,
+    organisationRole,
+    eventAppRole,
+    hasPermission,
+    hasGlobalPermission,
+    isSuperAdmin,
+    isOrgAdmin,
+    isEventAdmin,
+    canManageOrganisation,
+    canManageEvent,
+    isLoading,
+    error
+  };
+}
+
+// src/components/SuperAdminGuard.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function SuperAdminGuard({
+  children,
+  fallback = null,
+  showDebugInfo = false
+}) {
+  const { isSuperAdmin, hasGlobalPermission, isLoading } = useRBAC();
+  if (isLoading) {
+    return /* @__PURE__ */ jsxs4("div", { className: "super-admin-guard-loading", children: [
+      /* @__PURE__ */ jsx5("div", { className: "loading-spinner" }),
+      /* @__PURE__ */ jsx5("span", { children: "Checking permissions..." })
+    ] });
+  }
+  if (showDebugInfo) {
+    console.log("[SuperAdminGuard] Debug Info:", {
+      isSuperAdmin,
+      isLoading
+    });
+  }
+  if (isSuperAdmin) {
+    return /* @__PURE__ */ jsx5("div", { className: "super-admin-content", children });
+  }
+  return /* @__PURE__ */ jsx5("div", { className: "super-admin-fallback", children: fallback });
+}
+function SuperAdminBadge() {
+  const { isSuperAdmin } = useRBAC();
+  if (!isSuperAdmin) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx5("div", { className: "super-admin-badge", children: /* @__PURE__ */ jsx5("span", { className: "badge-text", children: "SUPER ADMIN" }) });
+}
+function SuperAdminDebugPanel() {
+  const { isSuperAdmin, isLoading } = useRBAC();
+  if (!isSuperAdmin) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs4("div", { className: "super-admin-debug-panel", children: [
+    /* @__PURE__ */ jsx5("h4", { children: "Super Admin Debug Info" }),
+    /* @__PURE__ */ jsxs4("div", { className: "debug-info", children: [
+      /* @__PURE__ */ jsxs4("p", { children: [
+        /* @__PURE__ */ jsx5("strong", { children: "Is Super Admin:" }),
+        " ",
+        isSuperAdmin ? "Yes" : "No"
+      ] }),
+      /* @__PURE__ */ jsxs4("p", { children: [
+        /* @__PURE__ */ jsx5("strong", { children: "Is Loading:" }),
+        " ",
+        isLoading ? "Yes" : "No"
+      ] }),
+      /* @__PURE__ */ jsxs4("p", { children: [
+        /* @__PURE__ */ jsx5("strong", { children: "Environment:" }),
+        " ",
+        "production"
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/PrintLayout/PrintLayout.tsx
+init_cn();
+
+// src/components/PrintLayout/PrintLayoutContext.tsx
+import { createContext, useContext, useState as useState3, useEffect as useEffect3 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var PrintLayoutContext = createContext(void 0);
+function PrintLayoutProvider({
+  children,
+  pageSize,
+  orientation,
+  hasFirstPageHeader,
+  hasSubsequentPageHeader
+}) {
+  const [isFirstPage, setIsFirstPage] = useState3(true);
+  useEffect3(() => {
+    const handleResize = () => {
+      setIsFirstPage(true);
+    };
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
+  const value = {
+    isFirstPage,
+    pageSize,
+    orientation,
+    hasFirstPageHeader,
+    hasSubsequentPageHeader
+  };
+  return /* @__PURE__ */ jsx6(PrintLayoutContext.Provider, { value, children });
+}
+function usePrintLayout() {
+  const context = useContext(PrintLayoutContext);
+  if (context === void 0) {
+    throw new Error("usePrintLayout must be used within a PrintLayoutProvider");
+  }
+  return context;
+}
+
+// src/components/PrintLayout/PrintLayout.tsx
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function PrintLayout({
+  children,
+  orientation = "portrait",
+  pageSize = "A4",
+  showHeader = true,
+  showFooter = true,
+  firstPageHeader,
+  subsequentPageHeader,
+  className,
+  ...props
+}) {
+  const hasFirstPageHeader = Boolean(firstPageHeader);
+  const hasSubsequentPageHeader = Boolean(subsequentPageHeader);
+  const getPageSizeClass = () => {
+    if (pageSize === "A4") {
+      return orientation === "landscape" ? "print-a4-landscape" : "print-a4-portrait";
+    }
+    return "print-a4-portrait";
+  };
+  const getHeaderClass = () => {
+    if (hasFirstPageHeader && hasSubsequentPageHeader) {
+      return "print-first-page-header print-subsequent-header";
+    }
+    if (hasFirstPageHeader) {
+      return "print-first-page-header";
+    }
+    if (hasSubsequentPageHeader) {
+      return "print-subsequent-header";
+    }
+    return "";
+  };
+  return /* @__PURE__ */ jsx7(
+    PrintLayoutProvider,
+    {
+      pageSize,
+      orientation,
+      hasFirstPageHeader,
+      hasSubsequentPageHeader,
+      children: /* @__PURE__ */ jsxs5(
+        "div",
+        {
+          className: cn(
+            "print-layout",
+            getPageSizeClass(),
+            getHeaderClass(),
+            className
+          ),
+          ...props,
+          children: [
+            hasFirstPageHeader && /* @__PURE__ */ jsx7("div", { className: "print-first-page-only", children: firstPageHeader }),
+            hasSubsequentPageHeader && /* @__PURE__ */ jsx7("div", { className: "print-subsequent-pages-only", children: subsequentPageHeader }),
+            /* @__PURE__ */ jsx7("div", { className: "print-text", children })
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/components/PrintHeader/PrintHeader.tsx
+init_cn();
+
+// src/components/PrintText/PrintText.tsx
+init_cn();
+import { jsx as jsx8 } from "react/jsx-runtime";
+function PrintText({
+  children,
+  variant = "body",
+  weight = "normal",
+  color = "primary",
+  printOptimized = true,
+  className,
+  as: Component = "p",
+  ...props
+}) {
+  const getVariantClasses = (variant2) => {
+    const baseClasses = "print-text";
+    switch (variant2) {
+      case "heading":
+        return cn(baseClasses, "text-2xl leading-tight");
+      case "subheading":
+        return cn(baseClasses, "text-xl leading-snug");
+      case "body":
+        return cn(baseClasses, "text-base leading-relaxed");
+      case "caption":
+        return cn(baseClasses, "text-sm leading-normal");
+      case "small":
+        return cn(baseClasses, "text-xs leading-tight");
+      default:
+        return baseClasses;
+    }
+  };
+  const getWeightClasses = (weight2) => {
+    switch (weight2) {
+      case "normal":
+        return "font-normal";
+      case "medium":
+        return "font-medium";
+      case "semibold":
+        return "font-semibold";
+      case "bold":
+        return "font-bold";
+      default:
+        return "font-normal";
+    }
+  };
+  const getColorClasses = (color2) => {
+    switch (color2) {
+      case "primary":
+        return "text-foreground";
+      case "secondary":
+        return "text-secondary-foreground";
+      case "muted":
+        return "text-muted-foreground";
+      case "accent":
+        return "text-accent-foreground";
+      default:
+        return "text-foreground";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print-text",
+      // Print-specific font sizing
+      "print:text-sm print:leading-tight",
+      // High contrast for print
+      "print:text-black print:bg-white"
+    );
+  };
+  return /* @__PURE__ */ jsx8(
+    Component,
+    {
+      className: cn(
+        getVariantClasses(variant),
+        getWeightClasses(weight),
+        getColorClasses(color),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintHeader/PrintHeader.tsx
+import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+function PrintHeader({
+  title,
+  subtitle,
+  branding,
+  metadata = [],
+  printDate = true,
+  className
+}) {
+  const formatPrintDate = () => {
+    return (/* @__PURE__ */ new Date()).toLocaleDateString("en-AU", {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+  };
+  const renderBranding = (branding2) => {
+    const { logo, companyName, projectName, version, tagline } = branding2;
+    return /* @__PURE__ */ jsxs6("div", { className: "flex items-center space-x-4 mb-4", children: [
+      logo && /* @__PURE__ */ jsx9(
+        "img",
+        {
+          src: logo,
+          alt: companyName || "Company Logo",
+          className: "h-8 w-auto print:h-6"
+        }
+      ),
+      /* @__PURE__ */ jsxs6("div", { className: "flex-1", children: [
+        companyName && /* @__PURE__ */ jsx9(PrintText, { variant: "subheading", weight: "semibold", className: "mb-1", children: companyName }),
+        projectName && /* @__PURE__ */ jsx9(PrintText, { variant: "body", color: "muted", className: "mb-1", children: projectName }),
+        version && /* @__PURE__ */ jsx9(PrintText, { variant: "small", color: "muted", children: version }),
+        tagline && /* @__PURE__ */ jsx9(PrintText, { variant: "small", color: "muted", className: "italic", children: tagline })
+      ] })
+    ] });
+  };
+  const renderMetadata = (metadata2) => {
+    if (metadata2.length === 0) return null;
+    return /* @__PURE__ */ jsx9("div", { className: "grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4 mb-4", children: metadata2.map((item, index) => /* @__PURE__ */ jsxs6("div", { className: "flex items-center space-x-2", children: [
+      item.icon && /* @__PURE__ */ jsx9(item.icon, { className: "h-4 w-4 text-muted-foreground print:h-3 print:w-3" }),
+      /* @__PURE__ */ jsxs6("div", { children: [
+        /* @__PURE__ */ jsx9(PrintText, { variant: "small", color: "muted", className: "block", children: item.label }),
+        /* @__PURE__ */ jsx9(PrintText, { variant: "body", weight: "medium", className: "block", children: item.value })
+      ] })
+    ] }, index)) });
+  };
+  return /* @__PURE__ */ jsxs6("header", { className: cn("print-header border-b border-border pb-4 mb-6", className), children: [
+    branding && renderBranding(branding),
+    /* @__PURE__ */ jsxs6("div", { className: "mb-4", children: [
+      /* @__PURE__ */ jsx9(PrintText, { variant: "heading", className: "mb-2", children: title }),
+      subtitle && /* @__PURE__ */ jsx9(PrintText, { variant: "subheading", color: "muted", children: subtitle })
+    ] }),
+    metadata.length > 0 && renderMetadata(metadata),
+    printDate && /* @__PURE__ */ jsx9("div", { className: "flex justify-end", children: /* @__PURE__ */ jsxs6(PrintText, { variant: "small", color: "muted", children: [
+      "Printed on ",
+      formatPrintDate()
+    ] }) })
+  ] });
+}
+
+// src/components/PrintHeader/PrintCoverHeader.tsx
+init_cn();
+import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+function PrintCoverHeader({
+  title,
+  subtitle,
+  branding,
+  metadata = [],
+  printDate = true,
+  coverStyle = true,
+  logoSize = "medium",
+  titleSize = "large",
+  showDivider = false,
+  backgroundImage,
+  backgroundColor,
+  className
+}) {
+  const formatPrintDate = () => {
+    return (/* @__PURE__ */ new Date()).toLocaleDateString("en-AU", {
+      year: "numeric",
+      month: "long",
+      day: "numeric"
+    });
+  };
+  const getLogoSizeClasses = (size) => {
+    switch (size) {
+      case "small":
+        return "h-16 w-auto print:h-12";
+      case "medium":
+        return "h-24 w-auto print:h-20";
+      case "large":
+        return "h-32 w-auto print:h-24";
+      default:
+        return "h-24 w-auto print:h-20";
+    }
+  };
+  const getTitleSizeClasses = (size) => {
+    switch (size) {
+      case "small":
+        return "text-3xl print:text-2xl";
+      case "medium":
+        return "text-4xl print:text-3xl";
+      case "large":
+        return "text-5xl print:text-4xl";
+      case "xl":
+        return "text-6xl print:text-5xl";
+      default:
+        return "text-4xl print:text-3xl";
+    }
+  };
+  const getBackgroundStyle = () => {
+    const style = {};
+    if (backgroundImage) {
+      style.backgroundImage = `url(${backgroundImage})`;
+      style.backgroundSize = "cover";
+      style.backgroundPosition = "center";
+      style.backgroundRepeat = "no-repeat";
+    }
+    if (backgroundColor) {
+      style.backgroundColor = backgroundColor;
+    }
+    return style;
+  };
+  const renderBranding = () => {
+    if (!branding) return null;
+    const { logo, companyName, projectName, version, tagline } = branding;
+    return /* @__PURE__ */ jsxs7("div", { className: "flex flex-col items-center text-center mb-8", children: [
+      logo && /* @__PURE__ */ jsx10(
+        "img",
+        {
+          src: logo,
+          alt: companyName || "Company Logo",
+          className: cn(
+            getLogoSizeClasses(logoSize),
+            "mb-4"
+          )
+        }
+      ),
+      companyName && /* @__PURE__ */ jsx10(PrintText, { variant: "subheading", weight: "semibold", className: "mb-2", children: companyName }),
+      projectName && /* @__PURE__ */ jsx10(PrintText, { variant: "body", color: "muted", className: "mb-2", children: projectName }),
+      version && /* @__PURE__ */ jsx10(PrintText, { variant: "small", color: "muted", className: "mb-2", children: version }),
+      tagline && /* @__PURE__ */ jsx10(PrintText, { variant: "small", color: "muted", className: "italic", children: tagline })
+    ] });
+  };
+  const renderMetadata = () => {
+    if (metadata.length === 0) return null;
+    return /* @__PURE__ */ jsx10("div", { className: "grid grid-cols-1 sm:grid-cols-2 gap-6 mb-8", children: metadata.map((item, index) => /* @__PURE__ */ jsxs7("div", { className: "flex items-center space-x-3", children: [
+      item.icon && /* @__PURE__ */ jsx10(item.icon, { className: "h-5 w-5 text-muted-foreground print:h-4 print:w-4" }),
+      /* @__PURE__ */ jsxs7("div", { children: [
+        /* @__PURE__ */ jsx10(PrintText, { variant: "small", color: "muted", className: "block", children: item.label }),
+        /* @__PURE__ */ jsx10(PrintText, { variant: "body", weight: "medium", className: "block", children: item.value })
+      ] })
+    ] }, index)) });
+  };
+  return /* @__PURE__ */ jsxs7(
+    "header",
+    {
+      className: cn(
+        "print-cover-header min-h-[400px] flex flex-col justify-center px-8 py-12",
+        "print:min-h-[300px] print:px-6 print:py-8",
+        className
+      ),
+      style: getBackgroundStyle(),
+      children: [
+        renderBranding(),
+        /* @__PURE__ */ jsxs7("div", { className: "text-center mb-8", children: [
+          /* @__PURE__ */ jsx10(
+            PrintText,
+            {
+              variant: "heading",
+              className: cn(
+                "mb-4",
+                getTitleSizeClasses(titleSize)
+              ),
+              children: title
+            }
+          ),
+          subtitle && /* @__PURE__ */ jsx10(PrintText, { variant: "subheading", color: "muted", className: "max-w-3xl mx-auto", children: subtitle })
+        ] }),
+        showDivider && /* @__PURE__ */ jsx10("div", { className: "w-24 h-1 bg-primary mx-auto mb-8" }),
+        renderMetadata(),
+        printDate && /* @__PURE__ */ jsx10("div", { className: "flex justify-center mt-auto", children: /* @__PURE__ */ jsxs7(PrintText, { variant: "small", color: "muted", children: [
+          "Printed on ",
+          formatPrintDate()
+        ] }) })
+      ]
+    }
+  );
+}
+
+// src/components/PrintDataTable/PrintDataTable.tsx
+init_cn();
+
+// src/components/PrintDataTable/PrintTableGroup.tsx
+init_cn();
+
+// src/components/PrintDataTable/PrintTableRow.tsx
+init_cn();
+import { jsx as jsx11 } from "react/jsx-runtime";
+function PrintTableRow({
+  row,
+  columns,
+  styling = {
+    headerStyle: "solid",
+    rowStyle: "striped",
+    cellPadding: "normal"
+  },
+  printOptimized = true,
+  isEven = false
+}) {
+  const getRowClasses = () => {
+    const baseClasses = "border-b border-border";
+    switch (styling.rowStyle) {
+      case "striped":
+        return cn(baseClasses, isEven ? "bg-muted/30" : "bg-background");
+      case "solid":
+        return cn(baseClasses, "bg-background");
+      case "bordered":
+        return cn(baseClasses, "border border-border bg-background");
+      default:
+        return baseClasses;
+    }
+  };
+  const getCellPaddingClasses = () => {
+    switch (styling.cellPadding) {
+      case "compact":
+        return "px-2 py-1 print:px-1 print:py-0.5";
+      case "spacious":
+        return "px-6 py-4 print:px-4 print:py-2";
+      case "normal":
+      default:
+        return "px-4 py-2 print:px-2 print:py-1";
+    }
+  };
+  return /* @__PURE__ */ jsx11("tr", { className: getRowClasses(), children: columns.map((column) => /* @__PURE__ */ jsx11(
+    "td",
+    {
+      className: cn(
+        getCellPaddingClasses(),
+        "text-left",
+        column.align === "center" && "text-center",
+        column.align === "right" && "text-right",
+        column.printBreak === "avoid" && "print-break-avoid"
+      ),
+      children: /* @__PURE__ */ jsx11(PrintText, { variant: "small", children: column.render ? column.render(row[column.key], row) : row[column.key] ?? "" })
+    },
+    column.key
+  )) });
+}
+
+// src/components/PrintDataTable/PrintTableGroup.tsx
+import { Fragment as Fragment2, jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+function PrintTableGroup({
+  groupKey,
+  groupData,
+  columns,
+  groupHeader,
+  styling = {
+    headerStyle: "solid",
+    rowStyle: "striped",
+    cellPadding: "normal"
+  },
+  printOptimized = true
+}) {
+  const getGroupHeaderClasses = () => {
+    const baseClasses = "bg-muted text-muted-foreground font-semibold";
+    if (printOptimized) {
+      return cn(
+        baseClasses,
+        "print:bg-gray-100 print:text-black print:font-bold"
+      );
+    }
+    return baseClasses;
+  };
+  const getCellPaddingClasses = () => {
+    switch (styling.cellPadding) {
+      case "compact":
+        return "px-2 py-1 print:px-1 print:py-0.5";
+      case "spacious":
+        return "px-6 py-4 print:px-4 print:py-2";
+      case "normal":
+      default:
+        return "px-4 py-2 print:px-2 print:py-1";
+    }
+  };
+  return /* @__PURE__ */ jsxs8(Fragment2, { children: [
+    /* @__PURE__ */ jsx12("tr", { className: getGroupHeaderClasses(), children: /* @__PURE__ */ jsx12(
+      "td",
+      {
+        colSpan: columns.length,
+        className: cn(
+          getCellPaddingClasses(),
+          "print-break-avoid"
+        ),
+        children: groupHeader ? groupHeader(groupKey) : /* @__PURE__ */ jsx12(PrintText, { variant: "small", weight: "semibold", children: groupKey })
+      }
+    ) }),
+    groupData.map((row, index) => /* @__PURE__ */ jsx12(
+      PrintTableRow,
+      {
+        row,
+        columns,
+        styling,
+        printOptimized,
+        isEven: index % 2 === 0
+      },
+      index
+    ))
+  ] });
+}
+
+// src/components/PrintDataTable/PrintDataTable.tsx
+import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+function PrintDataTable({
+  data,
+  columns,
+  title,
+  showTitle = true,
+  grouping,
+  styling = {
+    headerStyle: "solid",
+    rowStyle: "striped",
+    cellPadding: "normal"
+  },
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getTableClasses = () => {
+    const baseClasses = "w-full border-collapse";
+    if (printOptimized) {
+      return cn(
+        baseClasses,
+        "print:text-xs print:leading-tight",
+        "print:border-black print:border-solid"
+      );
+    }
+    return baseClasses;
+  };
+  const getHeaderClasses = () => {
+    const baseClasses = "text-left font-semibold";
+    switch (styling.headerStyle) {
+      case "solid":
+        return cn(baseClasses, "bg-primary text-primary-foreground");
+      case "outline":
+        return cn(baseClasses, "border-2 border-primary text-primary");
+      default:
+        return baseClasses;
+    }
+  };
+  const getRowClasses = (isEven) => {
+    const baseClasses = "border-b border-border";
+    switch (styling.rowStyle) {
+      case "striped":
+        return cn(baseClasses, isEven ? "bg-muted/30" : "bg-background");
+      case "solid":
+        return cn(baseClasses, "bg-background");
+      case "bordered":
+        return cn(baseClasses, "border border-border bg-background");
+      default:
+        return baseClasses;
+    }
+  };
+  const getCellPaddingClasses = () => {
+    switch (styling.cellPadding) {
+      case "compact":
+        return "px-2 py-1 print:px-1 print:py-0.5";
+      case "spacious":
+        return "px-6 py-4 print:px-4 print:py-2";
+      case "normal":
+      default:
+        return "px-4 py-2 print:px-2 print:py-1";
+    }
+  };
+  const renderTableHeader = () => /* @__PURE__ */ jsx13("thead", { children: /* @__PURE__ */ jsx13("tr", { className: getHeaderClasses(), children: columns.map((column) => /* @__PURE__ */ jsx13(
+    "th",
+    {
+      className: cn(
+        getCellPaddingClasses(),
+        "text-left",
+        column.align === "center" && "text-center",
+        column.align === "right" && "text-right",
+        column.printBreak === "avoid" && "print-break-avoid",
+        column.printBreak === "always" && "print-break-before"
+      ),
+      style: { width: column.width },
+      children: /* @__PURE__ */ jsx13(PrintText, { variant: "small", weight: "semibold", children: column.header })
+    },
+    column.key
+  )) }) });
+  const renderTableBody = () => {
+    if (grouping?.enabled) {
+      const groupedData = groupDataByField(data, grouping.groupBy);
+      return /* @__PURE__ */ jsx13("tbody", { children: Object.entries(groupedData).map(([groupKey, groupData], groupIndex) => /* @__PURE__ */ jsx13(
+        PrintTableGroup,
+        {
+          groupKey,
+          groupData,
+          columns,
+          groupHeader: grouping.groupHeader,
+          styling,
+          printOptimized
+        },
+        groupKey
+      )) });
+    }
+    return /* @__PURE__ */ jsx13("tbody", { children: data.map((row, index) => /* @__PURE__ */ jsx13(
+      "tr",
+      {
+        className: getRowClasses(index % 2 === 0),
+        children: columns.map((column) => /* @__PURE__ */ jsx13(
+          "td",
+          {
+            className: cn(
+              getCellPaddingClasses(),
+              "text-left",
+              column.align === "center" && "text-center",
+              column.align === "right" && "text-right",
+              column.printBreak === "avoid" && "print-break-avoid"
+            ),
+            children: /* @__PURE__ */ jsx13(PrintText, { variant: "small", children: column.render ? column.render(row[column.key], row) : row[column.key] })
+          },
+          column.key
+        ))
+      },
+      index
+    )) });
+  };
+  return /* @__PURE__ */ jsxs9("div", { className: cn("print-data-table", className), ...props, children: [
+    title && showTitle && /* @__PURE__ */ jsx13("div", { className: "mb-4", children: /* @__PURE__ */ jsx13(PrintText, { variant: "subheading", weight: "semibold", children: title }) }),
+    /* @__PURE__ */ jsx13("div", { className: "overflow-x-auto print:overflow-visible", children: /* @__PURE__ */ jsxs9("table", { className: getTableClasses(), children: [
+      renderTableHeader(),
+      renderTableBody()
+    ] }) })
+  ] });
+}
+function groupDataByField(data, field) {
+  return data.reduce((groups, item) => {
+    const key = item[field] || "Unknown";
+    if (!groups[key]) {
+      groups[key] = [];
+    }
+    groups[key].push(item);
+    return groups;
+  }, {});
+}
+
+// src/components/PrintCard/PrintCard.tsx
+init_cn();
+import { jsx as jsx14, jsxs as jsxs10 } from "react/jsx-runtime";
+function PrintCard({
+  children,
+  title,
+  subtitle,
+  variant = "default",
+  size = "md",
+  layout = "vertical",
+  showBorder = true,
+  backgroundColor = "white",
+  textColor = "primary",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getVariantClasses = (variant2) => {
+    switch (variant2) {
+      case "outlined":
+        return "border-2 border-border bg-transparent";
+      case "filled":
+        return "border-0 bg-muted";
+      case "elevated":
+        return "shadow-lg border-0 bg-background";
+      default:
+        return "border border-border bg-background";
+    }
+  };
+  const getSizeClasses = (size2) => {
+    switch (size2) {
+      case "sm":
+        return "p-3";
+      case "lg":
+        return "p-6";
+      case "xl":
+        return "p-8";
+      default:
+        return "p-4";
+    }
+  };
+  const getLayoutClasses = (layout2) => {
+    switch (layout2) {
+      case "horizontal":
+        return "flex-row items-center";
+      case "compact":
+        return "p-2";
+      default:
+        return "flex-col";
+    }
+  };
+  const getBackgroundClasses = (backgroundColor2, variant2) => {
+    if (variant2 === "outlined" && backgroundColor2 === "white") {
+      return "bg-transparent";
+    }
+    switch (backgroundColor2) {
+      case "gray":
+        return "bg-muted";
+      case "primary":
+        return "bg-primary text-primary-foreground";
+      case "secondary":
+        return "bg-secondary text-secondary-foreground";
+      case "accent":
+        return "bg-accent text-accent-foreground";
+      default:
+        return "";
+    }
+  };
+  const getTextColorClasses = (textColor2, backgroundColor2) => {
+    if (backgroundColor2 === "primary") {
+      return "text-primary-foreground";
+    }
+    if (backgroundColor2 === "secondary") {
+      return "text-secondary-foreground";
+    }
+    if (backgroundColor2 === "accent") {
+      return "text-accent-foreground";
+    }
+    switch (textColor2) {
+      case "secondary":
+        return "text-secondary-foreground";
+      case "muted":
+        return "text-muted-foreground";
+      case "accent":
+        return "text-accent-foreground";
+      case "destructive":
+        return "text-destructive-foreground";
+      default:
+        return "text-foreground";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:shadow-none",
+      "print:border-black",
+      "print:bg-white",
+      "print:text-black"
+    );
+  };
+  return /* @__PURE__ */ jsxs10(
+    "div",
+    {
+      className: cn(
+        "print-card",
+        "flex",
+        "rounded-lg",
+        getVariantClasses(variant),
+        getBackgroundClasses(backgroundColor, variant),
+        getTextColorClasses(textColor, backgroundColor),
+        getSizeClasses(size),
+        getLayoutClasses(layout),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children: [
+        title && /* @__PURE__ */ jsxs10("div", { className: "mb-2", children: [
+          /* @__PURE__ */ jsx14(PrintText, { variant: "heading", weight: "semibold", children: title }),
+          subtitle && /* @__PURE__ */ jsx14(PrintText, { variant: "caption", color: "muted", className: "mt-1", children: subtitle })
+        ] }),
+        children
+      ]
+    }
+  );
+}
+
+// src/components/PrintCard/PrintCardHeader.tsx
+init_cn();
+import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+function PrintCardHeader({
+  children,
+  title,
+  subtitle,
+  actions,
+  align = "left",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "center":
+        return "text-center";
+      case "right":
+        return "text-right";
+      default:
+        return "text-left";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-after-avoid",
+      "print:mb-2"
+    );
+  };
+  return /* @__PURE__ */ jsxs11(
+    "div",
+    {
+      className: cn(
+        "print-card-header",
+        "flex",
+        "items-center",
+        "justify-between",
+        "mb-4",
+        getAlignmentClasses(align),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsxs11("div", { className: "flex-1", children: [
+          title && /* @__PURE__ */ jsx15(PrintText, { variant: "heading", weight: "semibold", children: title }),
+          subtitle && /* @__PURE__ */ jsx15(PrintText, { variant: "caption", color: "muted", className: "mt-1", children: subtitle }),
+          children
+        ] }),
+        actions && /* @__PURE__ */ jsx15("div", { className: "ml-4 flex-shrink-0", children: actions })
+      ]
+    }
+  );
+}
+
+// src/components/PrintCard/PrintCardContent.tsx
+init_cn();
+import { jsx as jsx16 } from "react/jsx-runtime";
+function PrintCardContent({
+  children,
+  padding = "md",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getPaddingClasses = (padding2) => {
+    switch (padding2) {
+      case "none":
+        return "p-0";
+      case "sm":
+        return "p-2";
+      case "lg":
+        return "p-6";
+      default:
+        return "p-4";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:text-sm",
+      "print:leading-tight"
+    );
+  };
+  return /* @__PURE__ */ jsx16(
+    "div",
+    {
+      "data-testid": "print-card-content",
+      className: cn(
+        "print-card-content",
+        getPaddingClasses(padding),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintCard/PrintCardFooter.tsx
+init_cn();
+import { jsx as jsx17 } from "react/jsx-runtime";
+function PrintCardFooter({
+  children,
+  align = "left",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "center":
+        return "text-center";
+      case "right":
+        return "text-right";
+      default:
+        return "text-left";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-before-avoid",
+      "print:mt-2",
+      "print:pt-2",
+      "print:border-t",
+      "print:border-gray-300"
+    );
+  };
+  return /* @__PURE__ */ jsx17(
+    "div",
+    {
+      className: cn(
+        "print-card-footer",
+        "mt-4",
+        "pt-4",
+        "border-t",
+        "border-border",
+        getAlignmentClasses(align),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintCard/PrintCardImage.tsx
+init_cn();
+import { jsx as jsx18 } from "react/jsx-runtime";
+function PrintCardImage({
+  src,
+  alt,
+  width,
+  height,
+  aspectRatio = "auto",
+  objectFit = "cover",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getAspectRatioClasses = (aspectRatio2) => {
+    switch (aspectRatio2) {
+      case "square":
+        return "aspect-square";
+      case "portrait":
+        return "aspect-[3/4]";
+      case "landscape":
+        return "aspect-[4/3]";
+      default:
+        return "";
+    }
+  };
+  const getObjectFitClasses = (objectFit2) => {
+    switch (objectFit2) {
+      case "contain":
+        return "object-contain";
+      case "fill":
+        return "object-fill";
+      case "none":
+        return "object-none";
+      case "scale-down":
+        return "object-scale-down";
+      default:
+        return "object-cover";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:max-w-full",
+      "print:h-auto",
+      "print:break-inside-avoid"
+    );
+  };
+  return /* @__PURE__ */ jsx18(
+    "img",
+    {
+      src,
+      alt,
+      width,
+      height,
+      className: cn(
+        "print-card-image",
+        "w-full",
+        "h-auto",
+        "rounded-md",
+        getAspectRatioClasses(aspectRatio),
+        getObjectFitClasses(objectFit),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props
+    }
+  );
+}
+
+// src/components/PrintCard/PrintCardGrid.tsx
+init_cn();
+import { jsx as jsx19 } from "react/jsx-runtime";
+function PrintCardGrid({
+  children,
+  columns = 3,
+  gap = "md",
+  rowGap = "md",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getColumnClasses = (columns2) => {
+    switch (columns2) {
+      case 1:
+        return "grid-cols-1";
+      case 2:
+        return "grid-cols-2";
+      case 4:
+        return "grid-cols-4";
+      case 5:
+        return "grid-cols-5";
+      case 6:
+        return "grid-cols-6";
+      default:
+        return "grid-cols-3";
+    }
+  };
+  const getGapClasses = (gap2) => {
+    switch (gap2) {
+      case "sm":
+        return "gap-2";
+      case "lg":
+        return "gap-6";
+      case "xl":
+        return "gap-8";
+      default:
+        return "gap-4";
+    }
+  };
+  const getRowGapClasses = (rowGap2) => {
+    switch (rowGap2) {
+      case "sm":
+        return "gap-y-2";
+      case "lg":
+        return "gap-y-6";
+      case "xl":
+        return "gap-y-8";
+      default:
+        return "gap-y-4";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:grid-cols-2",
+      "print:gap-2",
+      "print:break-inside-avoid"
+    );
+  };
+  return /* @__PURE__ */ jsx19(
+    "div",
+    {
+      className: cn(
+        "print-card-grid",
+        "grid",
+        getColumnClasses(columns),
+        getGapClasses(gap),
+        getRowGapClasses(rowGap),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintSection/PrintSection.tsx
+init_cn();
+import { jsx as jsx20, jsxs as jsxs12 } from "react/jsx-runtime";
+function PrintSection({
+  children,
+  title,
+  subtitle,
+  layout = "single",
+  gap = "md",
+  spacing = "md",
+  showBorder = false,
+  background = "transparent",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getLayoutClasses = (layout2) => {
+    switch (layout2) {
+      case "two-column":
+        return "grid grid-cols-2";
+      case "three-column":
+        return "grid grid-cols-3";
+      case "four-column":
+        return "grid grid-cols-4";
+      default:
+        return "block";
+    }
+  };
+  const getGapClasses = (gap2) => {
+    switch (gap2) {
+      case "sm":
+        return "gap-2";
+      case "lg":
+        return "gap-6";
+      case "xl":
+        return "gap-8";
+      default:
+        return "gap-4";
+    }
+  };
+  const getSpacingClasses = (spacing2) => {
+    switch (spacing2) {
+      case "none":
+        return "py-0";
+      case "sm":
+        return "py-2";
+      case "lg":
+        return "py-6";
+      case "xl":
+        return "py-8";
+      default:
+        return "py-4";
+    }
+  };
+  const getBackgroundClasses = (background2) => {
+    switch (background2) {
+      case "white":
+        return "bg-background";
+      case "gray":
+        return "bg-muted";
+      case "primary":
+        return "bg-primary text-primary-foreground";
+      case "secondary":
+        return "bg-secondary text-secondary-foreground";
+      default:
+        return "bg-transparent";
+    }
+  };
+  const getBorderClasses = () => {
+    if (!showBorder) return "";
+    return "border border-border rounded-lg p-4";
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:mb-4",
+      "print:border-black",
+      "print:bg-white",
+      "print:text-black"
+    );
+  };
+  return /* @__PURE__ */ jsxs12(
+    "section",
+    {
+      className: cn(
+        "print-section",
+        getLayoutClasses(layout),
+        getGapClasses(gap),
+        getSpacingClasses(spacing),
+        getBackgroundClasses(background),
+        getBorderClasses(),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children: [
+        title && /* @__PURE__ */ jsxs12("div", { className: "mb-4", children: [
+          /* @__PURE__ */ jsx20(PrintText, { variant: "heading", weight: "semibold", children: title }),
+          subtitle && /* @__PURE__ */ jsx20(PrintText, { variant: "caption", color: "muted", className: "mt-1", children: subtitle })
+        ] }),
+        children
+      ]
+    }
+  );
+}
+
+// src/components/PrintSection/PrintSectionHeader.tsx
+init_cn();
+import { jsx as jsx21, jsxs as jsxs13 } from "react/jsx-runtime";
+function PrintSectionHeader({
+  children,
+  title,
+  subtitle,
+  level = 2,
+  align = "left",
+  showDivider = false,
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "center":
+        return "text-center";
+      case "right":
+        return "text-right";
+      default:
+        return "text-left";
+    }
+  };
+  const getDividerClasses = () => {
+    if (!showDivider) return "";
+    return "border-b border-border pb-2 mb-4";
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-after-avoid",
+      "print:mb-2",
+      "print:border-black"
+    );
+  };
+  const getHeadingVariant = (level2) => {
+    switch (level2) {
+      case 1:
+        return "heading";
+      case 2:
+        return "heading";
+      case 3:
+        return "subheading";
+      case 4:
+        return "subheading";
+      case 5:
+        return "body";
+      case 6:
+        return "body";
+      default:
+        return "heading";
+    }
+  };
+  const HeadingTag = `h${level}`;
+  return /* @__PURE__ */ jsxs13(
+    HeadingTag,
+    {
+      className: cn(
+        "print-section-header",
+        "mb-4",
+        getAlignmentClasses(align),
+        getDividerClasses(),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children: [
+        title && /* @__PURE__ */ jsx21(PrintText, { variant: getHeadingVariant(level), weight: "semibold", children: title }),
+        subtitle && /* @__PURE__ */ jsx21(PrintText, { variant: "caption", color: "muted", className: "mt-1", children: subtitle }),
+        children
+      ]
+    }
+  );
+}
+
+// src/components/PrintSection/PrintSectionContent.tsx
+init_cn();
+import { jsx as jsx22 } from "react/jsx-runtime";
+function PrintSectionContent({
+  children,
+  padding = "md",
+  background = "transparent",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getPaddingClasses = (padding2) => {
+    switch (padding2) {
+      case "none":
+        return "p-0";
+      case "sm":
+        return "p-2";
+      case "lg":
+        return "p-6";
+      default:
+        return "p-4";
+    }
+  };
+  const getBackgroundClasses = (background2) => {
+    switch (background2) {
+      case "white":
+        return "bg-background";
+      case "gray":
+        return "bg-muted";
+      case "primary":
+        return "bg-primary text-primary-foreground";
+      case "secondary":
+        return "bg-secondary text-secondary-foreground";
+      default:
+        return "bg-transparent";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:text-sm",
+      "print:leading-tight",
+      "print:bg-white",
+      "print:text-black"
+    );
+  };
+  return /* @__PURE__ */ jsx22(
+    "div",
+    {
+      className: cn(
+        "print-section-content",
+        getPaddingClasses(padding),
+        getBackgroundClasses(background),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintSection/PrintColumn.tsx
+init_cn();
+import { jsx as jsx23 } from "react/jsx-runtime";
+function PrintColumn({
+  children,
+  width = "auto",
+  align = "left",
+  verticalAlign = "top",
+  padding = "md",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getWidthClasses = (width2) => {
+    switch (width2) {
+      case "1/2":
+        return "col-span-1";
+      case "1/3":
+        return "col-span-1";
+      case "2/3":
+        return "col-span-2";
+      case "1/4":
+        return "col-span-1";
+      case "3/4":
+        return "col-span-3";
+      case "full":
+        return "col-span-full";
+      default:
+        return "";
+    }
+  };
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "center":
+        return "text-center";
+      case "right":
+        return "text-right";
+      default:
+        return "text-left";
+    }
+  };
+  const getVerticalAlignmentClasses = (verticalAlign2) => {
+    switch (verticalAlign2) {
+      case "middle":
+        return "flex items-center";
+      case "bottom":
+        return "flex items-end";
+      default:
+        return "flex items-start";
+    }
+  };
+  const getPaddingClasses = (padding2) => {
+    switch (padding2) {
+      case "none":
+        return "p-0";
+      case "sm":
+        return "p-2";
+      case "lg":
+        return "p-6";
+      default:
+        return "p-4";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:mb-2",
+      "print:text-sm",
+      "print:leading-tight"
+    );
+  };
+  return /* @__PURE__ */ jsx23(
+    "div",
+    {
+      className: cn(
+        "print-column",
+        getWidthClasses(width),
+        getAlignmentClasses(align),
+        getVerticalAlignmentClasses(verticalAlign),
+        getPaddingClasses(padding),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintSection/PrintDivider.tsx
+init_cn();
+import { jsx as jsx24 } from "react/jsx-runtime";
+function PrintDivider({
+  style = "solid",
+  color = "default",
+  thickness = "thin",
+  spacing = "md",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getStyleClasses = (style2) => {
+    switch (style2) {
+      case "dashed":
+        return "border-dashed";
+      case "dotted":
+        return "border-dotted";
+      case "thick":
+        return "border-solid border-4";
+      default:
+        return "border-solid";
+    }
+  };
+  const getColorClasses = (color2) => {
+    switch (color2) {
+      case "muted":
+        return "border-muted-foreground";
+      case "primary":
+        return "border-primary";
+      case "secondary":
+        return "border-secondary";
+      case "accent":
+        return "border-accent";
+      default:
+        return "border-border";
+    }
+  };
+  const getThicknessClasses = (thickness2, style2) => {
+    if (style2 === "thick") return "";
+    switch (thickness2) {
+      case "medium":
+        return "border-2";
+      case "thick":
+        return "border-4";
+      default:
+        return "border";
+    }
+  };
+  const getSpacingClasses = (spacing2) => {
+    switch (spacing2) {
+      case "none":
+        return "my-0";
+      case "sm":
+        return "my-2";
+      case "lg":
+        return "my-6";
+      default:
+        return "my-4";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:border-black",
+      "print:break-inside-avoid"
+    );
+  };
+  return /* @__PURE__ */ jsx24(
+    "hr",
+    {
+      className: cn(
+        "print-divider",
+        "border-t",
+        getStyleClasses(style),
+        getColorClasses(color),
+        getThicknessClasses(thickness, style),
+        getSpacingClasses(spacing),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props
+    }
+  );
+}
+
+// src/components/PrintButton/PrintButton.tsx
+init_cn();
+import { useState as useState4 } from "react";
+import { jsx as jsx25, jsxs as jsxs14 } from "react/jsx-runtime";
+function PrintButton({
+  children,
+  variant = "primary",
+  size = "md",
+  shape = "default",
+  state = "default",
+  printFunction = "print",
+  printSelector,
+  printOptions = {},
+  onClick,
+  onPrint,
+  onPrintStart,
+  onPrintEnd,
+  showIcon = true,
+  icon,
+  iconPosition = "left",
+  fullWidth = false,
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const [isPrinting, setIsPrinting] = useState4(false);
+  const getVariantClasses = (variant2) => {
+    switch (variant2) {
+      case "secondary":
+        return "bg-secondary text-secondary-foreground hover:bg-secondary/80";
+      case "outline":
+        return "border border-input bg-background hover:bg-accent hover:text-accent-foreground";
+      case "ghost":
+        return "hover:bg-accent hover:text-accent-foreground";
+      case "destructive":
+        return "bg-destructive text-destructive-foreground hover:bg-destructive/90";
+      default:
+        return "bg-primary text-primary-foreground hover:bg-primary/90";
+    }
+  };
+  const getSizeClasses = (size2) => {
+    switch (size2) {
+      case "sm":
+        return "h-8 px-3 text-xs";
+      case "lg":
+        return "h-12 px-8 text-base";
+      case "xl":
+        return "h-14 px-10 text-lg";
+      default:
+        return "h-10 px-4 text-sm";
+    }
+  };
+  const getShapeClasses = (shape2) => {
+    switch (shape2) {
+      case "rounded":
+        return "rounded-lg";
+      case "pill":
+        return "rounded-full";
+      case "square":
+        return "rounded-none";
+      default:
+        return "rounded-md";
+    }
+  };
+  const getStateClasses = (state2) => {
+    switch (state2) {
+      case "loading":
+        return "opacity-50 cursor-not-allowed";
+      case "disabled":
+        return "opacity-50 cursor-not-allowed pointer-events-none";
+      default:
+        return "cursor-pointer";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:hidden",
+      "print:opacity-0",
+      "print:pointer-events-none"
+    );
+  };
+  const getDefaultIcon = () => {
+    if (icon) return icon;
+    switch (printFunction) {
+      case "printSelection":
+        return "\u{1F4C4}";
+      case "printPage":
+        return "\u{1F4C3}";
+      case "printElement":
+        return "\u{1F3AF}";
+      default:
+        return "\u{1F5A8}\uFE0F";
+    }
+  };
+  const handlePrint = async () => {
+    if (isPrinting || state === "disabled" || state === "loading") return;
+    setIsPrinting(true);
+    onPrintStart?.();
+    try {
+      switch (printFunction) {
+        case "print":
+          await printDocument(printOptions);
+          break;
+        case "printSelection":
+          if (printSelector) {
+            await printSelection(printSelector, printOptions);
+          }
+          break;
+        case "printPage":
+          await printPage(printOptions);
+          break;
+        case "printElement":
+          if (printSelector) {
+            await printElement(printSelector, printOptions);
+          }
+          break;
+      }
+      onPrint?.(true);
+    } catch (error) {
+      onPrint?.(false, error);
+    } finally {
+      setIsPrinting(false);
+      onPrintEnd?.();
+    }
+  };
+  const handleClick = (event) => {
+    if (printFunction) {
+      event.preventDefault();
+      handlePrint();
+    }
+    onClick?.(event);
+  };
+  const isDisabled = state === "disabled" || state === "loading" || isPrinting;
+  return /* @__PURE__ */ jsxs14(
+    "button",
+    {
+      type: "button",
+      className: cn(
+        "print-button",
+        "inline-flex",
+        "items-center",
+        "justify-center",
+        "whitespace-nowrap",
+        "font-medium",
+        "ring-offset-background",
+        "transition-colors",
+        "focus-visible:outline-none",
+        "focus-visible:ring-2",
+        "focus-visible:ring-ring",
+        "focus-visible:ring-offset-2",
+        "disabled:pointer-events-none",
+        "disabled:opacity-50",
+        getVariantClasses(variant),
+        getSizeClasses(size),
+        getShapeClasses(shape),
+        getStateClasses(state),
+        fullWidth && "w-full",
+        getPrintOptimizedClasses(),
+        className
+      ),
+      disabled: isDisabled,
+      onClick: handleClick,
+      ...props,
+      children: [
+        showIcon && iconPosition === "left" && /* @__PURE__ */ jsx25("span", { className: "mr-2", children: getDefaultIcon() }),
+        children,
+        showIcon && iconPosition === "right" && /* @__PURE__ */ jsx25("span", { className: "ml-2", children: getDefaultIcon() })
+      ]
+    }
+  );
+}
+async function printDocument(options) {
+  return new Promise((resolve, reject) => {
+    try {
+      if (options.stylesheetUrl) {
+        const link = document.createElement("link");
+        link.rel = "stylesheet";
+        link.href = options.stylesheetUrl;
+        link.media = options.mediaQuery || "print";
+        document.head.appendChild(link);
+      }
+      const printWindow = window.open("", "_blank");
+      if (!printWindow) {
+        reject(new Error("Unable to open print window"));
+        return;
+      }
+      printWindow.document.write(`
+        <html>
+          <head>
+            <title>${options.title || "Print Document"}</title>
+            <style>
+              @page {
+                margin: ${options.margins?.top || "0.5in"} ${options.margins?.right || "0.5in"} ${options.margins?.bottom || "0.5in"} ${options.margins?.left || "0.5in"};
+                size: ${options.orientation === "landscape" ? "A4 landscape" : "A4 portrait"};
+              }
+              body { 
+                font-family: Arial, sans-serif; 
+                line-height: 1.4;
+                color: #000;
+                background: #fff;
+              }
+              @media print {
+                * { -webkit-print-color-adjust: ${options.colorAdjust || "exact"}; }
+              }
+            </style>
+          </head>
+          <body>
+            ${document.documentElement.outerHTML}
+          </body>
+        </html>
+      `);
+      printWindow.document.close();
+      printWindow.focus();
+      printWindow.print();
+      printWindow.close();
+      resolve();
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+async function printSelection(selector, options) {
+  const element = document.querySelector(selector);
+  if (!element) {
+    throw new Error(`Element with selector "${selector}" not found`);
+  }
+  return printElement(selector, options);
+}
+async function printPage(options) {
+  return printDocument(options);
+}
+async function printElement(selector, options) {
+  const element = document.querySelector(selector);
+  if (!element) {
+    throw new Error(`Element with selector "${selector}" not found`);
+  }
+  return new Promise((resolve, reject) => {
+    try {
+      const printWindow = window.open("", "_blank");
+      if (!printWindow) {
+        reject(new Error("Unable to open print window"));
+        return;
+      }
+      printWindow.document.write(`
+        <html>
+          <head>
+            <title>${options.title || "Print Element"}</title>
+            <style>
+              @page {
+                margin: ${options.margins?.top || "0.5in"} ${options.margins?.right || "0.5in"} ${options.margins?.bottom || "0.5in"} ${options.margins?.left || "0.5in"};
+                size: ${options.orientation === "landscape" ? "A4 landscape" : "A4 portrait"};
+              }
+              body { 
+                font-family: Arial, sans-serif; 
+                line-height: 1.4;
+                color: #000;
+                background: #fff;
+              }
+              @media print {
+                * { -webkit-print-color-adjust: ${options.colorAdjust || "exact"}; }
+              }
+            </style>
+          </head>
+          <body>
+            ${element.outerHTML}
+          </body>
+        </html>
+      `);
+      printWindow.document.close();
+      printWindow.focus();
+      printWindow.print();
+      printWindow.close();
+      resolve();
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+// src/components/PrintButton/PrintButtonGroup.tsx
+init_cn();
+import { jsx as jsx26 } from "react/jsx-runtime";
+function PrintButtonGroup({
+  children,
+  orientation = "horizontal",
+  spacing = "md",
+  align = "left",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getOrientationClasses = (orientation2) => {
+    switch (orientation2) {
+      case "vertical":
+        return "flex-col";
+      default:
+        return "flex-row";
+    }
+  };
+  const getSpacingClasses = (spacing2) => {
+    switch (spacing2) {
+      case "none":
+        return "gap-0";
+      case "sm":
+        return "gap-2";
+      case "lg":
+        return "gap-6";
+      default:
+        return "gap-4";
+    }
+  };
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "center":
+        return "justify-center";
+      case "right":
+        return "justify-end";
+      case "stretch":
+        return "justify-stretch";
+      default:
+        return "justify-start";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:hidden",
+      "print:opacity-0",
+      "print:pointer-events-none"
+    );
+  };
+  return /* @__PURE__ */ jsx26(
+    "div",
+    {
+      className: cn(
+        "print-button-group",
+        "flex",
+        "items-center",
+        getOrientationClasses(orientation),
+        getSpacingClasses(spacing),
+        getAlignmentClasses(align),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintButton/PrintToolbar.tsx
+init_cn();
+import { jsx as jsx27 } from "react/jsx-runtime";
+function PrintToolbar({
+  children,
+  position = "top",
+  align = "left",
+  showOnPrint = false,
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getPositionClasses = (position2) => {
+    switch (position2) {
+      case "bottom":
+        return "fixed bottom-0 left-0 right-0";
+      case "fixed":
+        return "fixed top-4 right-4";
+      default:
+        return "relative";
+    }
+  };
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "center":
+        return "justify-center";
+      case "right":
+        return "justify-end";
+      default:
+        return "justify-start";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    if (showOnPrint) {
+      return cn(
+        "print:block",
+        "print:opacity-100",
+        "print:pointer-events-auto"
+      );
+    } else {
+      return cn(
+        "print:hidden",
+        "print:opacity-0",
+        "print:pointer-events-none"
+      );
+    }
+  };
+  const getZIndexClasses = () => {
+    if (position === "fixed" || position === "bottom") {
+      return "z-50";
+    }
+    return "";
+  };
+  return /* @__PURE__ */ jsx27(
+    "div",
+    {
+      className: cn(
+        "print-toolbar",
+        "flex",
+        "items-center",
+        "gap-2",
+        "p-4",
+        "bg-background",
+        "border",
+        "border-border",
+        "rounded-lg",
+        "shadow-lg",
+        getPositionClasses(position),
+        getAlignmentClasses(align),
+        getZIndexClasses(),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintGrid/PrintGrid.tsx
+init_cn();
+import { jsx as jsx28 } from "react/jsx-runtime";
+function PrintGrid({
+  children,
+  columns = 12,
+  gap = "md",
+  rowGap,
+  columnGap,
+  align = "stretch",
+  justify = "start",
+  printColumns,
+  printGap,
+  printRowGap,
+  printColumnGap,
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getColumnsClasses = (cols) => {
+    switch (cols) {
+      case 1:
+        return "grid-cols-1";
+      case 2:
+        return "grid-cols-2";
+      case 3:
+        return "grid-cols-3";
+      case 4:
+        return "grid-cols-4";
+      case 5:
+        return "grid-cols-5";
+      case 6:
+        return "grid-cols-6";
+      case 12:
+        return "grid-cols-12";
+      default:
+        return "grid-cols-12";
+    }
+  };
+  const getGapClasses = (gap2) => {
+    switch (gap2) {
+      case "none":
+        return "gap-0";
+      case "sm":
+        return "gap-2";
+      case "lg":
+        return "gap-6";
+      case "xl":
+        return "gap-8";
+      default:
+        return "gap-4";
+    }
+  };
+  const getRowGapClasses = (gap2) => {
+    switch (gap2) {
+      case "none":
+        return "gap-y-0";
+      case "sm":
+        return "gap-y-2";
+      case "lg":
+        return "gap-y-6";
+      case "xl":
+        return "gap-y-8";
+      default:
+        return "gap-y-4";
+    }
+  };
+  const getColumnGapClasses = (gap2) => {
+    switch (gap2) {
+      case "none":
+        return "gap-x-0";
+      case "sm":
+        return "gap-x-2";
+      case "lg":
+        return "gap-x-6";
+      case "xl":
+        return "gap-x-8";
+      default:
+        return "gap-x-4";
+    }
+  };
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "start":
+        return "items-start";
+      case "center":
+        return "items-center";
+      case "end":
+        return "items-end";
+      default:
+        return "items-stretch";
+    }
+  };
+  const getJustifyClasses = (justify2) => {
+    switch (justify2) {
+      case "center":
+        return "justify-center";
+      case "end":
+        return "justify-end";
+      case "between":
+        return "justify-between";
+      case "around":
+        return "justify-around";
+      case "evenly":
+        return "justify-evenly";
+      default:
+        return "justify-start";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:mb-4"
+    );
+  };
+  const getPrintColumnsClasses = () => {
+    if (!printColumns) return "";
+    return cn(
+      "print:grid",
+      `print:${getColumnsClasses(printColumns)}`
+    );
+  };
+  const getPrintGapClasses = () => {
+    if (!printGap) return "";
+    return `print:${getGapClasses(printGap)}`;
+  };
+  const getPrintRowGapClasses = () => {
+    if (!printRowGap) return "";
+    return `print:${getRowGapClasses(printRowGap)}`;
+  };
+  const getPrintColumnGapClasses = () => {
+    if (!printColumnGap) return "";
+    return `print:${getColumnGapClasses(printColumnGap)}`;
+  };
+  return /* @__PURE__ */ jsx28(
+    "div",
+    {
+      className: cn(
+        "print-grid",
+        "grid",
+        getColumnsClasses(columns),
+        getGapClasses(gap),
+        rowGap && getRowGapClasses(rowGap),
+        columnGap && getColumnGapClasses(columnGap),
+        getAlignmentClasses(align),
+        getJustifyClasses(justify),
+        getPrintOptimizedClasses(),
+        getPrintColumnsClasses(),
+        getPrintGapClasses(),
+        getPrintRowGapClasses(),
+        getPrintColumnGapClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintGrid/PrintGridItem.tsx
+init_cn();
+import { jsx as jsx29 } from "react/jsx-runtime";
+function PrintGridItem({
+  children,
+  colSpan = 1,
+  rowSpan = 1,
+  colStart,
+  rowStart,
+  align = "stretch",
+  justify = "start",
+  printColSpan,
+  printRowSpan,
+  printColStart,
+  printRowStart,
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getColSpanClasses = (span) => {
+    if (span === "full") return "col-span-full";
+    switch (span) {
+      case 1:
+        return "col-span-1";
+      case 2:
+        return "col-span-2";
+      case 3:
+        return "col-span-3";
+      case 4:
+        return "col-span-4";
+      case 5:
+        return "col-span-5";
+      case 6:
+        return "col-span-6";
+      case 12:
+        return "col-span-12";
+      default:
+        return "col-span-1";
+    }
+  };
+  const getRowSpanClasses = (span) => {
+    if (span === "full") return "row-span-full";
+    switch (span) {
+      case 1:
+        return "row-span-1";
+      case 2:
+        return "row-span-2";
+      case 3:
+        return "row-span-3";
+      case 4:
+        return "row-span-4";
+      case 5:
+        return "row-span-5";
+      case 6:
+        return "row-span-6";
+      default:
+        return "row-span-1";
+    }
+  };
+  const getColStartClasses = (start) => {
+    if (start === "auto") return "col-start-auto";
+    switch (start) {
+      case 1:
+        return "col-start-1";
+      case 2:
+        return "col-start-2";
+      case 3:
+        return "col-start-3";
+      case 4:
+        return "col-start-4";
+      case 5:
+        return "col-start-5";
+      case 6:
+        return "col-start-6";
+      case 7:
+        return "col-start-7";
+      case 8:
+        return "col-start-8";
+      case 9:
+        return "col-start-9";
+      case 10:
+        return "col-start-10";
+      case 11:
+        return "col-start-11";
+      case 12:
+        return "col-start-12";
+      case 13:
+        return "col-start-13";
+      default:
+        return "col-start-auto";
+    }
+  };
+  const getRowStartClasses = (start) => {
+    if (start === "auto") return "row-start-auto";
+    switch (start) {
+      case 1:
+        return "row-start-1";
+      case 2:
+        return "row-start-2";
+      case 3:
+        return "row-start-3";
+      case 4:
+        return "row-start-4";
+      case 5:
+        return "row-start-5";
+      case 6:
+        return "row-start-6";
+      case 7:
+        return "row-start-7";
+      case 8:
+        return "row-start-8";
+      case 9:
+        return "row-start-9";
+      case 10:
+        return "row-start-10";
+      case 11:
+        return "row-start-11";
+      case 12:
+        return "row-start-12";
+      case 13:
+        return "row-start-13";
+      default:
+        return "row-start-auto";
+    }
+  };
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "start":
+        return "self-start";
+      case "center":
+        return "self-center";
+      case "end":
+        return "self-end";
+      default:
+        return "self-stretch";
+    }
+  };
+  const getJustifyClasses = (justify2) => {
+    switch (justify2) {
+      case "center":
+        return "justify-self-center";
+      case "end":
+        return "justify-self-end";
+      case "stretch":
+        return "justify-self-stretch";
+      default:
+        return "justify-self-start";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:mb-2"
+    );
+  };
+  const getPrintColSpanClasses = () => {
+    if (!printColSpan) return "";
+    return `print:${getColSpanClasses(printColSpan)}`;
+  };
+  const getPrintRowSpanClasses = () => {
+    if (!printRowSpan) return "";
+    return `print:${getRowSpanClasses(printRowSpan)}`;
+  };
+  const getPrintColStartClasses = () => {
+    if (!printColStart) return "";
+    return `print:${getColStartClasses(printColStart)}`;
+  };
+  const getPrintRowStartClasses = () => {
+    if (!printRowStart) return "";
+    return `print:${getRowStartClasses(printRowStart)}`;
+  };
+  return /* @__PURE__ */ jsx29(
+    "div",
+    {
+      className: cn(
+        "print-grid-item",
+        getColSpanClasses(colSpan),
+        getRowSpanClasses(rowSpan),
+        colStart && getColStartClasses(colStart),
+        rowStart && getRowStartClasses(rowStart),
+        getAlignmentClasses(align),
+        getJustifyClasses(justify),
+        getPrintOptimizedClasses(),
+        getPrintColSpanClasses(),
+        getPrintRowSpanClasses(),
+        getPrintColStartClasses(),
+        getPrintRowStartClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintGrid/PrintGridContainer.tsx
+init_cn();
+import { jsx as jsx30 } from "react/jsx-runtime";
+function PrintGridContainer({
+  children,
+  maxWidth = "full",
+  padding = "md",
+  margin = "none",
+  background = "transparent",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getMaxWidthClasses = (maxWidth2) => {
+    switch (maxWidth2) {
+      case "sm":
+        return "max-w-sm";
+      case "md":
+        return "max-w-md";
+      case "lg":
+        return "max-w-lg";
+      case "xl":
+        return "max-w-xl";
+      case "2xl":
+        return "max-w-2xl";
+      case "3xl":
+        return "max-w-3xl";
+      case "4xl":
+        return "max-w-4xl";
+      case "5xl":
+        return "max-w-5xl";
+      case "6xl":
+        return "max-w-6xl";
+      case "7xl":
+        return "max-w-7xl";
+      case "full":
+        return "max-w-full";
+      default:
+        return "max-w-full";
+    }
+  };
+  const getPaddingClasses = (padding2) => {
+    switch (padding2) {
+      case "none":
+        return "p-0";
+      case "sm":
+        return "p-2";
+      case "lg":
+        return "p-6";
+      case "xl":
+        return "p-8";
+      default:
+        return "p-4";
+    }
+  };
+  const getMarginClasses = (margin2) => {
+    switch (margin2) {
+      case "none":
+        return "m-0";
+      case "sm":
+        return "m-2";
+      case "md":
+        return "m-4";
+      case "lg":
+        return "m-6";
+      case "xl":
+        return "m-8";
+      case "auto":
+        return "mx-auto";
+      default:
+        return "m-0";
+    }
+  };
+  const getBackgroundClasses = (background2) => {
+    switch (background2) {
+      case "white":
+        return "bg-background";
+      case "gray":
+        return "bg-muted";
+      case "primary":
+        return "bg-primary text-primary-foreground";
+      case "secondary":
+        return "bg-secondary text-secondary-foreground";
+      default:
+        return "bg-transparent";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:max-w-full",
+      "print:break-inside-avoid",
+      "print:mb-4"
+    );
+  };
+  return /* @__PURE__ */ jsx30(
+    "div",
+    {
+      className: cn(
+        "print-grid-container",
+        "w-full",
+        getMaxWidthClasses(maxWidth),
+        getPaddingClasses(padding),
+        getMarginClasses(margin),
+        getBackgroundClasses(background),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintGrid/PrintGridBreakpoint.tsx
+init_cn();
+import { jsx as jsx31 } from "react/jsx-runtime";
+function PrintGridBreakpoint({
+  children,
+  size = "md",
+  columns = 12,
+  gap = "md",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getSizeClasses = (size2) => {
+    switch (size2) {
+      case "sm":
+        return "sm:";
+      case "md":
+        return "md:";
+      case "lg":
+        return "lg:";
+      case "xl":
+        return "xl:";
+      case "2xl":
+        return "2xl:";
+      default:
+        return "md:";
+    }
+  };
+  const getColumnsClasses = (cols) => {
+    switch (cols) {
+      case 1:
+        return "grid-cols-1";
+      case 2:
+        return "grid-cols-2";
+      case 3:
+        return "grid-cols-3";
+      case 4:
+        return "grid-cols-4";
+      case 5:
+        return "grid-cols-5";
+      case 6:
+        return "grid-cols-6";
+      case 12:
+        return "grid-cols-12";
+      default:
+        return "grid-cols-12";
+    }
+  };
+  const getGapClasses = (gap2) => {
+    switch (gap2) {
+      case "none":
+        return "gap-0";
+      case "sm":
+        return "gap-2";
+      case "lg":
+        return "gap-6";
+      case "xl":
+        return "gap-8";
+      default:
+        return "gap-4";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:mb-4"
+    );
+  };
+  const getResponsiveClasses = () => {
+    const sizePrefix = getSizeClasses(size);
+    const columnsClass = getColumnsClasses(columns);
+    const gapClass = getGapClasses(gap);
+    return cn(
+      `${sizePrefix}grid`,
+      `${sizePrefix}${columnsClass}`,
+      `${sizePrefix}${gapClass}`
+    );
+  };
+  return /* @__PURE__ */ jsx31(
+    "div",
+    {
+      className: cn(
+        "print-grid-breakpoint",
+        getResponsiveClasses(),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintFooter/PrintFooter.tsx
+init_cn();
+
+// src/components/PrintFooter/PrintPageNumber.tsx
+init_cn();
+import { jsx as jsx32 } from "react/jsx-runtime";
+function PrintPageNumber({
+  children,
+  format = "1",
+  template,
+  position = "right",
+  showTotal = false,
+  currentPage = 1,
+  totalPages = 1,
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getPositionClasses = (position2) => {
+    switch (position2) {
+      case "left":
+        return "justify-start";
+      case "center":
+        return "justify-center";
+      default:
+        return "justify-end";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:text-sm",
+      "print:font-medium"
+    );
+  };
+  const formatPageNumber = () => {
+    if (template) {
+      return template.replace("{current}", currentPage.toString()).replace("{total}", totalPages.toString()).replace("{page}", currentPage.toString());
+    }
+    switch (format) {
+      case "1 of 5":
+        return `${currentPage} of ${totalPages}`;
+      case "Page 1":
+        return `Page ${currentPage}`;
+      case "Page 1 of 5":
+        return `Page ${currentPage} of ${totalPages}`;
+      case "1/5":
+        return `${currentPage}/${totalPages}`;
+      case "custom":
+        return template || currentPage.toString();
+      default:
+        return currentPage.toString();
+    }
+  };
+  return /* @__PURE__ */ jsx32(
+    "div",
+    {
+      className: cn(
+        "print-page-number",
+        "flex",
+        "items-center",
+        getPositionClasses(position),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children: children || /* @__PURE__ */ jsx32(PrintText, { variant: "small", color: "muted", children: formatPageNumber() })
+    }
+  );
+}
+
+// src/components/PrintFooter/PrintFooter.tsx
+import { jsx as jsx33, jsxs as jsxs15 } from "react/jsx-runtime";
+function PrintFooter({
+  children,
+  text,
+  position = "relative",
+  align = "center",
+  showPageNumbers = false,
+  pageNumberFormat = "1",
+  pageNumberTemplate,
+  pageNumberPosition = "right",
+  showTotalPages = false,
+  background = "transparent",
+  showBorder = false,
+  padding = "md",
+  margin = "none",
+  height = "auto",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getPositionClasses = (position2) => {
+    switch (position2) {
+      case "fixed":
+        return "fixed bottom-0 left-0 right-0";
+      case "absolute":
+        return "absolute bottom-0 left-0 right-0";
+      case "sticky":
+        return "sticky bottom-0";
+      default:
+        return "relative";
+    }
+  };
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "left":
+        return "justify-start";
+      case "center":
+        return "justify-center";
+      case "right":
+        return "justify-end";
+      case "between":
+        return "justify-between";
+      case "around":
+        return "justify-around";
+      case "evenly":
+        return "justify-evenly";
+      default:
+        return "justify-center";
+    }
+  };
+  const getBackgroundClasses = (background2) => {
+    switch (background2) {
+      case "white":
+        return "bg-background";
+      case "gray":
+        return "bg-muted";
+      case "primary":
+        return "bg-primary text-primary-foreground";
+      case "secondary":
+        return "bg-secondary text-secondary-foreground";
+      default:
+        return "bg-transparent";
+    }
+  };
+  const getPaddingClasses = (padding2) => {
+    switch (padding2) {
+      case "none":
+        return "p-0";
+      case "sm":
+        return "p-2";
+      case "lg":
+        return "p-6";
+      case "xl":
+        return "p-8";
+      default:
+        return "p-4";
+    }
+  };
+  const getMarginClasses = (margin2) => {
+    switch (margin2) {
+      case "none":
+        return "m-0";
+      case "sm":
+        return "m-2";
+      case "md":
+        return "m-4";
+      case "lg":
+        return "m-6";
+      case "xl":
+        return "m-8";
+      default:
+        return "m-0";
+    }
+  };
+  const getHeightClasses = (height2) => {
+    switch (height2) {
+      case "sm":
+        return "h-8";
+      case "md":
+        return "h-12";
+      case "lg":
+        return "h-16";
+      case "xl":
+        return "h-20";
+      default:
+        return "h-auto";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:mb-4",
+      "print:border-black",
+      "print:bg-white",
+      "print:text-black"
+    );
+  };
+  const getBorderClasses = () => {
+    if (!showBorder) return "";
+    return "border-t border-border";
+  };
+  return /* @__PURE__ */ jsxs15(
+    "footer",
+    {
+      className: cn(
+        "print-footer",
+        "flex",
+        "items-center",
+        "w-full",
+        getPositionClasses(position),
+        getAlignmentClasses(align),
+        getBackgroundClasses(background),
+        getPaddingClasses(padding),
+        getMarginClasses(margin),
+        getHeightClasses(height),
+        getBorderClasses(),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children: [
+        text && /* @__PURE__ */ jsx33(PrintText, { variant: "small", color: "muted", children: text }),
+        children,
+        showPageNumbers && /* @__PURE__ */ jsx33(
+          PrintPageNumber,
+          {
+            format: pageNumberFormat,
+            template: pageNumberTemplate,
+            position: pageNumberPosition,
+            showTotal: showTotalPages,
+            printOptimized
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/PrintFooter/PrintFooterContent.tsx
+init_cn();
+import { jsx as jsx34 } from "react/jsx-runtime";
+function PrintFooterContent({
+  children,
+  align = "left",
+  padding = "none",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "center":
+        return "text-center";
+      case "right":
+        return "text-right";
+      default:
+        return "text-left";
+    }
+  };
+  const getPaddingClasses = (padding2) => {
+    switch (padding2) {
+      case "none":
+        return "p-0";
+      case "sm":
+        return "p-2";
+      case "lg":
+        return "p-6";
+      case "xl":
+        return "p-8";
+      default:
+        return "p-4";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:text-sm",
+      "print:leading-tight"
+    );
+  };
+  return /* @__PURE__ */ jsx34(
+    "div",
+    {
+      className: cn(
+        "print-footer-content",
+        getAlignmentClasses(align),
+        getPaddingClasses(padding),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/PrintFooter/PrintFooterInfo.tsx
+init_cn();
+import { jsx as jsx35 } from "react/jsx-runtime";
+function PrintFooterInfo({
+  children,
+  align = "left",
+  background = "transparent",
+  showBorder = false,
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getAlignmentClasses = (align2) => {
+    switch (align2) {
+      case "center":
+        return "text-center";
+      case "right":
+        return "text-right";
+      default:
+        return "text-left";
+    }
+  };
+  const getBackgroundClasses = (background2) => {
+    switch (background2) {
+      case "white":
+        return "bg-background";
+      case "gray":
+        return "bg-muted";
+      case "primary":
+        return "bg-primary text-primary-foreground";
+      case "secondary":
+        return "bg-secondary text-secondary-foreground";
+      default:
+        return "bg-transparent";
+    }
+  };
+  const getBorderClasses = () => {
+    if (!showBorder) return "";
+    return "border border-border rounded";
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:text-sm",
+      "print:leading-tight",
+      "print:border-black",
+      "print:bg-white",
+      "print:text-black"
+    );
+  };
+  return /* @__PURE__ */ jsx35(
+    "div",
+    {
+      className: cn(
+        "print-footer-info",
+        "p-3",
+        "rounded",
+        getAlignmentClasses(align),
+        getBackgroundClasses(background),
+        getBorderClasses(),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ jsx35(PrintText, { variant: "small", color: "muted", children })
+    }
+  );
+}
+
+// src/components/PrintPageBreak/PrintPageBreak.tsx
+init_cn();
+
+// src/components/PrintPageBreak/PrintPageBreakIndicator.tsx
+init_cn();
+import { jsx as jsx36 } from "react/jsx-runtime";
+function PrintPageBreakIndicator({
+  children,
+  type = "line",
+  color = "default",
+  size = "md",
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getTypeClasses = () => {
+    switch (type) {
+      case "dotted":
+        return "border-dotted";
+      case "dashed":
+        return "border-dashed";
+      case "text":
+        return "text-center";
+      case "icon":
+        return "text-center";
+      default:
+        return "border-solid";
+    }
+  };
+  const getColorClasses = () => {
+    switch (color) {
+      case "primary":
+        return "border-primary text-primary";
+      case "secondary":
+        return "border-secondary text-secondary";
+      case "muted":
+        return "border-muted-foreground text-muted-foreground";
+      case "accent":
+        return "border-accent text-accent";
+      default:
+        return "border-border text-foreground";
+    }
+  };
+  const getSizeClasses = () => {
+    switch (size) {
+      case "sm":
+        return "h-1 text-xs";
+      case "lg":
+        return "h-3 text-lg";
+      default:
+        return "h-2 text-sm";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:border-black",
+      "print:text-black"
+    );
+  };
+  const renderContent = () => {
+    if (children) {
+      return children;
+    }
+    switch (type) {
+      case "text":
+        return "--- Page Break ---";
+      case "icon":
+        return "\u{1F4C4}";
+      case "line":
+        return "--- Page Break ---";
+      default:
+        return "--- Page Break ---";
+    }
+  };
+  const isLineType = type === "line" || type === "dotted" || type === "dashed";
+  return /* @__PURE__ */ jsx36(
+    "div",
+    {
+      className: cn(
+        "print-page-break-indicator",
+        "flex",
+        "items-center",
+        "justify-center",
+        "w-full",
+        getTypeClasses(),
+        getColorClasses(),
+        getSizeClasses(),
+        isLineType && "border-t",
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children: renderContent()
+    }
+  );
+}
+
+// src/components/PrintPageBreak/PrintPageBreak.tsx
+import { jsx as jsx37, jsxs as jsxs16 } from "react/jsx-runtime";
+function PrintPageBreak({
+  type = "auto",
+  strength = "normal",
+  showIndicator = false,
+  indicator,
+  label,
+  description,
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getBreakClass = () => {
+    const baseClass = "print-page-break";
+    switch (type) {
+      case "before":
+        return cn(baseClass, "print-break-before");
+      case "after":
+        return cn(baseClass, "print-break-after");
+      case "avoid":
+        return cn(baseClass, "print-break-avoid");
+      case "always":
+        return cn(baseClass, "print-break-before print-break-after");
+      case "left":
+        return cn(baseClass, "print-break-before", "print:page-break-before:left");
+      case "right":
+        return cn(baseClass, "print-break-before", "print:page-break-before:right");
+      default:
+        return baseClass;
+    }
+  };
+  const getStrengthClass = () => {
+    switch (strength) {
+      case "weak":
+        return "print:page-break-inside:avoid";
+      case "strong":
+        return "print:page-break-inside:avoid print:break-inside-avoid";
+      default:
+        return "";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:mb-4"
+    );
+  };
+  const renderIndicator = () => {
+    if (!showIndicator) return null;
+    if (indicator) {
+      return indicator;
+    }
+    return /* @__PURE__ */ jsx37(
+      PrintPageBreakIndicator,
+      {
+        type: "line",
+        color: "muted",
+        size: "md",
+        printOptimized
+      }
+    );
+  };
+  const renderLabel = () => {
+    if (!label) return null;
+    return /* @__PURE__ */ jsx37(PrintText, { variant: "small", color: "muted", className: "text-center", children: label });
+  };
+  const renderDescription = () => {
+    if (!description) return null;
+    return /* @__PURE__ */ jsx37(PrintText, { variant: "small", color: "muted", className: "text-center mt-1", children: description });
+  };
+  return /* @__PURE__ */ jsxs16(
+    "div",
+    {
+      className: cn(
+        getBreakClass(),
+        getStrengthClass(),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      "aria-hidden": "true",
+      ...props,
+      children: [
+        renderIndicator(),
+        renderLabel(),
+        renderDescription()
+      ]
+    }
+  );
+}
+
+// src/components/PrintPageBreak/PrintPageBreakGroup.tsx
+init_cn();
+import { jsx as jsx38, jsxs as jsxs17 } from "react/jsx-runtime";
+function PrintPageBreakGroup({
+  children,
+  type = "auto",
+  strength = "normal",
+  label,
+  description,
+  printOptimized = true,
+  className,
+  ...props
+}) {
+  const getBreakClass = () => {
+    const baseClass = "print-page-break-group";
+    switch (type) {
+      case "before":
+        return cn(baseClass, "print-break-before");
+      case "after":
+        return cn(baseClass, "print-break-after");
+      case "avoid":
+        return cn(baseClass, "print-break-avoid");
+      case "always":
+        return cn(baseClass, "print-break-before print-break-after");
+      case "left":
+        return cn(baseClass, "print-break-before", "print:page-break-before:left");
+      case "right":
+        return cn(baseClass, "print-break-before", "print:page-break-before:right");
+      default:
+        return baseClass;
+    }
+  };
+  const getStrengthClass = () => {
+    switch (strength) {
+      case "weak":
+        return "print:page-break-inside:avoid";
+      case "strong":
+        return "print:page-break-inside:avoid print:break-inside-avoid";
+      default:
+        return "";
+    }
+  };
+  const getPrintOptimizedClasses = () => {
+    if (!printOptimized) return "";
+    return cn(
+      "print:break-inside-avoid",
+      "print:mb-4"
+    );
+  };
+  return /* @__PURE__ */ jsxs17(
+    "div",
+    {
+      className: cn(
+        getBreakClass(),
+        getStrengthClass(),
+        getPrintOptimizedClasses(),
+        className
+      ),
+      ...props,
+      children: [
+        label && /* @__PURE__ */ jsx38(PrintText, { variant: "small", color: "muted", className: "mb-2", children: label }),
+        children,
+        description && /* @__PURE__ */ jsx38(PrintText, { variant: "small", color: "muted", className: "mt-2", children: description })
+      ]
+    }
+  );
+}
+export {
+  Alert,
+  AlertDescription,
+  AlertTitle,
+  Avatar,
+  AvatarFallback,
+  AvatarImage,
+  Button,
+  Card,
+  CardActions,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+  Checkbox,
+  DataTable,
+  DefaultPublicErrorFallback,
+  Dialog,
+  DialogBody,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger,
+  ErrorBoundary,
+  EventLogo,
+  EventLogoCompact,
+  EventLogoLarge,
+  EventSelector,
+  FileUpload,
+  Footer,
+  Form,
+  FormErrorSummary,
+  FormField,
+  FormFieldset,
+  FormLiveRegion,
+  Header,
+  Input,
+  Label,
+  LoadingSpinner,
+  LoginForm,
+  NavigationMenu,
+  OrganisationSelector,
+  PaceAppLayout,
+  PaceLoginPage,
+  PasswordResetForm,
+  PrintButton,
+  PrintButtonGroup,
+  PrintCard,
+  PrintCardContent,
+  PrintCardFooter,
+  PrintCardGrid,
+  PrintCardHeader,
+  PrintCardImage,
+  PrintColumn,
+  PrintCoverHeader,
+  PrintDataTable,
+  PrintDivider,
+  PrintFooter,
+  PrintFooterContent,
+  PrintFooterInfo,
+  PrintGrid,
+  PrintGridBreakpoint,
+  PrintGridContainer,
+  PrintGridItem,
+  PrintHeader,
+  PrintLayout,
+  PrintLayoutProvider,
+  PrintPageBreak,
+  PrintPageBreakGroup,
+  PrintPageBreakIndicator,
+  PrintPageNumber,
+  PrintSection,
+  PrintSectionContent,
+  PrintSectionHeader,
+  PrintTableGroup,
+  PrintTableRow,
+  PrintText,
+  PrintToolbar,
+  Progress,
+  PublicErrorBoundary,
+  PublicLoadingSkeleton,
+  PublicLoadingSpinner,
+  PublicLoadingSpinnerFullPage,
+  PublicPageContextChecker,
+  PublicPageDebugger,
+  PublicPageDiagnostic,
+  PublicPageFooter,
+  PublicPageHeader,
+  PublicPageLayout,
+  PublicPageProvider,
+  Select,
+  SelectContent,
+  SelectGroup,
+  SelectItem,
+  SelectLabel,
+  SelectSeparator,
+  SelectTrigger,
+  SelectValue,
+  SuperAdminBadge,
+  SuperAdminDebugPanel,
+  SuperAdminGuard,
+  Table,
+  TableBody,
+  TableCaption,
+  TableCell,
+  TableFooter,
+  TableHead,
+  TableHeader,
+  TableRow,
+  Toast,
+  ToastAction,
+  ToastClose,
+  ToastDescription,
+  ToastProvider,
+  ToastTitle,
+  ToastViewport,
+  Toaster,
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipRoot,
+  TooltipTrigger,
+  UnifiedAuthProvider,
+  UserMenu,
+  useErrorBoundary,
+  useFileUpload,
+  useIsPublicPage,
+  usePrintLayout,
+  usePublicPageContext2 as usePublicPageContext,
+  usePublicPageContext as usePublicPageProviderContext,
+  useStorage,
+  useToast,
+  useUnifiedAuth
+};
+//# sourceMappingURL=components.js.map