@qwickapps/react-framework 1.3.2 → 1.3.4

package/dist/index.esm.js

@@ -1,11 +1,11 @@
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
-import { CircularProgress, Button as Button$1, Paper, Typography, useTheme as useTheme$1, Box, Container as Container$8, Stack, Tooltip, IconButton, Snackbar, Alert, useMediaQuery, Avatar, Chip, Menu, MenuItem, Grid, Divider, Link, ListItemIcon, ListItemText, Card, CardContent, ButtonGroup, Collapse, TextField as TextField$1, FormControl, InputLabel, Select, FormHelperText } from '@mui/material';
-import React, { useMemo, useContext, useState, useEffect, createContext, useRef, useCallback, cloneElement } from 'react';
+import { CircularProgress, Button as Button$1, Paper, Typography, useTheme as useTheme$1, Box, Container as Container$8, Stack, Tooltip, IconButton, Snackbar, Alert, useMediaQuery, Avatar, Chip, Menu, MenuItem, Grid, Divider, Collapse, Link, ListItemIcon, ListItemText, Card, CardContent, ButtonGroup, TextField as TextField$1, FormControl, InputLabel, Select, FormHelperText, FormControlLabel, Switch } from '@mui/material';
+import React, { useMemo, useContext, useState, useEffect, createContext, useId, useCallback, useRef, Component, useReducer, cloneElement } from 'react';
 import { MustacheTemplateProvider, MemoryCacheProvider, CachedDataProvider, Field, Editor, FieldType, Schema, Model, DataType } from '@qwickapps/schema';
 import { IsOptional, IsString, IsIn, IsUrl, IsArray, ValidateNested, IsNumber, Min, Max, IsBoolean, IsNotEmpty, IsObject } from 'class-validator';
 import { Type } from 'class-transformer';
 import 'reflect-metadata';
-import { Check, ContentCopy, MoreVert, Schedule, Visibility, Launch, LightMode, DarkMode, SettingsSystemDaydream, Palette, Circle, VisibilityOff, Help, FormatBold, FormatItalic, FormatUnderlined, Code as Code$1, Add, RadioButtonUnchecked } from '@mui/icons-material';
+import { Check, ContentCopy, MoreVert, ExpandMore, ExpandLess, Schedule, Visibility, Launch, LightMode, DarkMode, SettingsSystemDaydream, Palette, Circle, VisibilityOff, Help, FormatBold, FormatItalic, FormatUnderlined, Code as Code$1, Add, RadioButtonUnchecked } from '@mui/icons-material';
 import { createTheme, ThemeProvider as ThemeProvider$1 } from '@mui/material/styles';
 import { useLocation, useNavigate } from 'react-router-dom';
 
@@ -15334,6 +15334,689 @@ const GridCell = props => {
 };
 GridCell.displayName = 'GridCell';
 
+/**
+ * CollapsibleLayout Schema - Data model for collapsible layout component
+ *
+ * Advanced expandable/collapsible container with header controls, animations,
+ * content management, and state persistence capabilities.
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+let CollapsibleLayoutModel = class CollapsibleLayoutModel extends Model {};
+__decorate([Field({
+  defaultValue: false
+}), Editor({
+  field_type: FieldType.BOOLEAN,
+  label: 'Collapsed',
+  description: 'Whether the layout is currently collapsed'
+}), IsOptional(), IsBoolean(), __metadata("design:type", Boolean)], CollapsibleLayoutModel.prototype, "collapsed", void 0);
+__decorate([Field({
+  defaultValue: false
+}), Editor({
+  field_type: FieldType.BOOLEAN,
+  label: 'Default Collapsed',
+  description: 'Initial collapsed state for uncontrolled usage'
+}), IsOptional(), IsBoolean(), __metadata("design:type", Boolean)], CollapsibleLayoutModel.prototype, "defaultCollapsed", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXT,
+  label: 'Title',
+  description: 'Main title displayed in the header',
+  placeholder: 'Enter title...'
+}), IsOptional(), IsString(), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "title", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXT,
+  label: 'Subtitle',
+  description: 'Secondary text displayed below the title',
+  placeholder: 'Enter subtitle...'
+}), IsOptional(), IsString(), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "subtitle", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXT,
+  label: 'Lead Icon',
+  description: 'Icon displayed before the title (icon identifier or HTML)',
+  placeholder: 'Icon identifier...'
+}), IsOptional(), IsString(), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "leadIcon", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXTAREA,
+  label: 'Header Actions',
+  description: 'Additional controls displayed in header (HTML/React content)',
+  placeholder: 'Enter header actions HTML...'
+}), IsOptional(), IsString(), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "headerActions", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXTAREA,
+  label: 'Collapsed View',
+  description: 'Summary content shown when collapsed (HTML supported)',
+  placeholder: 'Enter collapsed view content...'
+}), IsOptional(), IsString(), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "collapsedView", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXTAREA,
+  label: 'Content',
+  description: 'Main content shown when expanded (HTML supported)',
+  placeholder: 'Enter main content...'
+}), IsOptional(), IsString(), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "children", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXTAREA,
+  label: 'Footer View',
+  description: 'Always visible footer content (HTML supported)',
+  placeholder: 'Enter footer content...'
+}), IsOptional(), IsString(), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "footerView", void 0);
+__decorate([Field({
+  defaultValue: 'header'
+}), Editor({
+  field_type: FieldType.SELECT,
+  label: 'Trigger Area',
+  description: 'Area that responds to clicks for toggle functionality',
+  validation: {
+    options: [{
+      label: 'Button Only',
+      value: 'button'
+    }, {
+      label: 'Header Area',
+      value: 'header'
+    }, {
+      label: 'Button and Header',
+      value: 'both'
+    }]
+  }
+}), IsOptional(), IsIn(['button', 'header', 'both']), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "triggerArea", void 0);
+__decorate([Field({
+  defaultValue: 'slide'
+}), Editor({
+  field_type: FieldType.SELECT,
+  label: 'Animation Style',
+  description: 'Animation variant for expand/collapse transitions',
+  validation: {
+    options: [{
+      label: 'Fade',
+      value: 'fade'
+    }, {
+      label: 'Slide',
+      value: 'slide'
+    }, {
+      label: 'Scale',
+      value: 'scale'
+    }]
+  }
+}), IsOptional(), IsIn(['fade', 'slide', 'scale']), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "animationStyle", void 0);
+__decorate([Field({
+  defaultValue: false
+}), Editor({
+  field_type: FieldType.BOOLEAN,
+  label: 'Persist State',
+  description: 'Save collapse state in local storage'
+}), IsOptional(), IsBoolean(), __metadata("design:type", Boolean)], CollapsibleLayoutModel.prototype, "persistState", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXT,
+  label: 'Collapsed Icon',
+  description: 'Icon shown when content is collapsed (default: VisibilityIcon)',
+  placeholder: 'Icon identifier...'
+}), IsOptional(), IsString(), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "collapsedIcon", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXT,
+  label: 'Expanded Icon',
+  description: 'Icon shown when content is expanded (default: VisibilityOffIcon)',
+  placeholder: 'Icon identifier...'
+}), IsOptional(), IsString(), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "expandedIcon", void 0);
+__decorate([Field({
+  defaultValue: true
+}), Editor({
+  field_type: FieldType.BOOLEAN,
+  label: 'Show Divider',
+  description: 'Show divider lines between header, content, and footer sections'
+}), IsOptional(), IsBoolean(), __metadata("design:type", Boolean)], CollapsibleLayoutModel.prototype, "showDivider", void 0);
+__decorate([Field({
+  defaultValue: 'default'
+}), Editor({
+  field_type: FieldType.SELECT,
+  label: 'Variant',
+  description: 'Visual style variant for the layout container',
+  validation: {
+    options: [{
+      label: 'Default',
+      value: 'default'
+    }, {
+      label: 'Outlined',
+      value: 'outlined'
+    }, {
+      label: 'Elevated',
+      value: 'elevated'
+    }, {
+      label: 'Filled',
+      value: 'filled'
+    }]
+  }
+}), IsOptional(), IsIn(['default', 'outlined', 'elevated', 'filled']), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "variant", void 0);
+__decorate([Field({
+  defaultValue: 'comfortable'
+}), Editor({
+  field_type: FieldType.SELECT,
+  label: 'Header Spacing',
+  description: 'Padding/spacing within the header area',
+  validation: {
+    options: [{
+      label: 'Compact',
+      value: 'compact'
+    }, {
+      label: 'Comfortable',
+      value: 'comfortable'
+    }, {
+      label: 'Spacious',
+      value: 'spacious'
+    }]
+  }
+}), IsOptional(), IsIn(['compact', 'comfortable', 'spacious']), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "headerSpacing", void 0);
+__decorate([Field({
+  defaultValue: 'comfortable'
+}), Editor({
+  field_type: FieldType.SELECT,
+  label: 'Content Spacing',
+  description: 'Padding/spacing within the content area',
+  validation: {
+    options: [{
+      label: 'Compact',
+      value: 'compact'
+    }, {
+      label: 'Comfortable',
+      value: 'comfortable'
+    }, {
+      label: 'Spacious',
+      value: 'spacious'
+    }]
+  }
+}), IsOptional(), IsIn(['compact', 'comfortable', 'spacious']), __metadata("design:type", String)], CollapsibleLayoutModel.prototype, "contentSpacing", void 0);
+CollapsibleLayoutModel = __decorate([Schema('CollapsibleLayout', '1.0.0')], CollapsibleLayoutModel);
+var CollapsibleLayoutModel$1 = CollapsibleLayoutModel;
+
+/**
+ * TypeScript type definitions for CollapsibleLayout component
+ *
+ * Provides TypeScript interfaces that extend the schema model with React-specific types
+ * and component-level functionality for the CollapsibleLayout component.
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+/**
+ * Type guard to check if a component has CollapsibleLayout props
+ */
+function isCollapsibleLayoutProps(props) {
+  return props && typeof props === 'object' && ('collapsed' in props || 'defaultCollapsed' in props);
+}
+/**
+ * Default props for CollapsibleLayout component
+ */
+const defaultCollapsibleLayoutProps = {
+  // Note: collapsed is intentionally omitted so components can be uncontrolled
+  defaultCollapsed: false,
+  triggerArea: 'both',
+  animationStyle: 'slide',
+  persistState: false,
+  showDivider: true,
+  variant: 'default',
+  headerSpacing: 'comfortable',
+  contentSpacing: 'comfortable',
+  animationDuration: 300,
+  disableAnimations: false,
+  toggleAriaLabel: 'Toggle content visibility'
+};
+const animationConfigs = {
+  fade: {
+    duration: 300,
+    easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
+    opacity: [0, 1]
+  },
+  slide: {
+    duration: 300,
+    easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
+    transform: 'translateY(-10px)'
+  },
+  scale: {
+    duration: 200,
+    easing: 'cubic-bezier(0.34, 1.56, 0.64, 1)',
+    transform: 'scale(0.95)',
+    opacity: [0, 1]
+  }
+};
+const spacingConfigs = {
+  compact: {
+    padding: '8px 12px',
+    gap: '4px'
+  },
+  comfortable: {
+    padding: '16px 20px',
+    gap: '8px'
+  },
+  spacious: {
+    padding: '24px 32px',
+    gap: '16px'
+  }
+};
+
+/**
+ * Custom hook for managing collapsible state - simplified approach
+ */
+function useCollapsibleState(controlled, collapsedProp, defaultCollapsedProp, onToggleProp, persistState, storageKey) {
+  const id = useId();
+  const finalStorageKey = storageKey || `collapsible-${id}`;
+  // For controlled components, use the prop; for uncontrolled, use internal state
+  const [internalCollapsed, setInternalCollapsed] = useState(() => {
+    if (controlled) {
+      return collapsedProp ?? false;
+    }
+    // Try localStorage first if persistence is enabled
+    if (persistState && typeof window !== 'undefined') {
+      const stored = localStorage.getItem(finalStorageKey);
+      if (stored !== null) {
+        return JSON.parse(stored);
+      }
+    }
+    return defaultCollapsedProp ?? false;
+  });
+  // Sync with controlled prop changes
+  useEffect(() => {
+    if (controlled && collapsedProp !== undefined) {
+      setInternalCollapsed(collapsedProp);
+    }
+  }, [controlled, collapsedProp]);
+  // Persist to localStorage for uncontrolled components
+  useEffect(() => {
+    if (!controlled && persistState && typeof window !== 'undefined') {
+      localStorage.setItem(finalStorageKey, JSON.stringify(internalCollapsed));
+    }
+  }, [controlled, internalCollapsed, persistState, finalStorageKey]);
+  const toggle = useCallback(() => {
+    const currentState = controlled ? collapsedProp ?? false : internalCollapsed;
+    const newCollapsed = !currentState;
+    // Always update internal state for visual updates
+    setInternalCollapsed(newCollapsed);
+    // Call callback to notify parent
+    onToggleProp?.(newCollapsed);
+  }, [controlled, collapsedProp, internalCollapsed, onToggleProp]);
+  const setCollapsed = useCallback(collapsed => {
+    setInternalCollapsed(collapsed);
+    onToggleProp?.(collapsed);
+  }, [onToggleProp]);
+  // Return the appropriate state
+  const finalCollapsed = controlled ? collapsedProp ?? false : internalCollapsed;
+  return {
+    collapsed: finalCollapsed,
+    toggle,
+    setCollapsed,
+    isControlled: controlled
+  };
+}
+/**
+ * Core CollapsibleLayout View component
+ */
+function CollapsibleLayoutView({
+  // State props
+  collapsed: collapsedProp,
+  defaultCollapsed = false,
+  onToggle,
+  // Content props  
+  title,
+  subtitle,
+  leadIcon,
+  headerActions,
+  collapsedView,
+  children,
+  footerView,
+  // Behavior props
+  triggerArea = 'both',
+  animationStyle = 'slide',
+  persistState = false,
+  storageKey,
+  animationDuration = 300,
+  disableAnimations = false,
+  // Icons
+  collapsedIcon,
+  expandedIcon,
+  // Layout props
+  showDivider = true,
+  variant = 'default',
+  headerSpacing = 'comfortable',
+  contentSpacing = 'comfortable',
+  // Accessibility
+  toggleAriaLabel = 'Toggle content visibility',
+  'aria-describedby': ariaDescribedBy,
+  contentAriaProps = {},
+  // CSS classes
+  containerClassName,
+  headerClassName,
+  contentClassName,
+  footerClassName,
+  ...restProps
+}) {
+  const theme = useTheme$1();
+  const {
+    styleProps,
+    htmlProps,
+    restProps: otherProps
+  } = useBaseProps(restProps);
+  // Mark as QwickApp component
+  CollapsibleLayoutView[QWICKAPP_COMPONENT] = true;
+  // Determine controlled vs uncontrolled usage
+  const controlled = collapsedProp !== undefined;
+  // State management
+  const {
+    collapsed,
+    toggle,
+    setCollapsed
+  } = useCollapsibleState(controlled, collapsedProp, defaultCollapsed, onToggle, persistState, storageKey);
+  // Get spacing configurations
+  const headerSpacingConfig = spacingConfigs[headerSpacing];
+  const contentSpacingConfig = spacingConfigs[contentSpacing];
+  // Get animation configuration
+  const animationConfig = animationConfigs[animationStyle];
+  // Generate unique IDs for accessibility
+  const headerId = useId();
+  const contentId = useId();
+  // Handle click events
+  const handleHeaderClick = useCallback(event => {
+    if (triggerArea === 'header' || triggerArea === 'both') {
+      event.preventDefault();
+      toggle();
+    }
+  }, [triggerArea, toggle]);
+  const handleButtonClick = useCallback(event => {
+    event.stopPropagation();
+    toggle();
+  }, [toggle]);
+  // Render icons
+  const renderIcon = useCallback((icon, defaultIcon) => {
+    if (/*#__PURE__*/React.isValidElement(icon)) {
+      return icon;
+    }
+    if (typeof icon === 'string') {
+      return jsx(Html, {
+        children: icon
+      });
+    }
+    return defaultIcon;
+  }, []);
+  const toggleIcon = renderIcon(collapsed ? collapsedIcon : expandedIcon, collapsed ? jsx(ExpandMore, {}) : jsx(ExpandLess, {}));
+  // Container styles based on variant
+  const containerSx = useMemo(() => {
+    const baseSx = {
+      width: '100%',
+      position: 'relative',
+      ...styleProps.sx
+    };
+    switch (variant) {
+      case 'outlined':
+        return {
+          ...baseSx,
+          border: `1px solid ${theme.palette.divider}`,
+          borderRadius: 1,
+          backgroundColor: 'var(--theme-surface)'
+        };
+      case 'elevated':
+        return {
+          ...baseSx,
+          boxShadow: theme.shadows[2],
+          borderRadius: 1,
+          backgroundColor: theme.palette.background.paper
+        };
+      case 'filled':
+        return {
+          ...baseSx,
+          backgroundColor: 'var(--theme-surface-variant)',
+          borderRadius: 1
+        };
+      default:
+        return baseSx;
+    }
+  }, [variant, theme, styleProps.sx]);
+  // Header styles
+  const headerSx = useMemo(() => ({
+    ...headerSpacingConfig,
+    cursor: triggerArea === 'header' || triggerArea === 'both' ? 'pointer' : 'default',
+    userSelect: 'none',
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    '&:hover': triggerArea === 'header' || triggerArea === 'both' ? {
+      backgroundColor: 'rgba(0, 0, 0, 0.04)'
+    } : {}
+  }), [headerSpacingConfig, triggerArea]);
+  // Content styles
+  const contentSx = useMemo(() => ({
+    ...contentSpacingConfig
+  }), [contentSpacingConfig]);
+  // Animation props for Collapse component
+  const collapseProps = useMemo(() => {
+    if (disableAnimations) {
+      return {
+        timeout: 0
+      };
+    }
+    const baseProps = {
+      timeout: animationDuration
+    };
+    switch (animationStyle) {
+      case 'fade':
+        return {
+          ...baseProps,
+          sx: {
+            '& .MuiCollapse-wrapper': {
+              opacity: collapsed ? 0 : 1,
+              transition: `opacity ${animationDuration}ms ${animationConfig.easing}`
+            }
+          }
+        };
+      case 'scale':
+        return {
+          ...baseProps,
+          sx: {
+            '& .MuiCollapse-wrapper': {
+              transform: collapsed ? 'scale(0.95)' : 'scale(1)',
+              opacity: collapsed ? 0 : 1,
+              transition: `all ${animationDuration}ms ${animationConfig.easing}`
+            }
+          }
+        };
+      default:
+        // slide
+        return baseProps;
+    }
+  }, [disableAnimations, animationDuration, animationStyle, animationConfig, collapsed]);
+  // Render content based on type
+  const renderContent = useCallback(content => {
+    if (!content) return null;
+    if (typeof content === 'string') {
+      return jsx(Html, {
+        children: content
+      });
+    }
+    return content;
+  }, []);
+  // Container content that will be wrapped
+  const containerContent = jsxs(Fragment, {
+    children: [(title || subtitle || leadIcon || headerActions || triggerArea === 'button' || triggerArea === 'both') && jsxs(Fragment, {
+      children: [jsxs(Box, {
+        id: headerId,
+        className: headerClassName,
+        sx: headerSx,
+        onClick: handleHeaderClick,
+        role: triggerArea === 'header' || triggerArea === 'both' ? 'button' : undefined,
+        tabIndex: triggerArea === 'header' || triggerArea === 'both' ? 0 : undefined,
+        "aria-expanded": !collapsed,
+        "aria-controls": contentId,
+        "aria-describedby": ariaDescribedBy,
+        onKeyDown: e => {
+          if ((triggerArea === 'header' || triggerArea === 'both') && (e.key === 'Enter' || e.key === ' ')) {
+            e.preventDefault();
+            toggle();
+          }
+        },
+        children: [jsxs(Stack, {
+          direction: "row",
+          spacing: 2,
+          alignItems: "center",
+          sx: {
+            minWidth: 0,
+            flex: 1
+          },
+          children: [leadIcon && jsx(Box, {
+            sx: {
+              flexShrink: 0
+            },
+            children: renderContent(leadIcon)
+          }), (title || subtitle) && jsxs(Box, {
+            sx: {
+              minWidth: 0,
+              flex: 1
+            },
+            children: [title && jsx(Typography, {
+              variant: "h6",
+              component: "h3",
+              sx: {
+                fontWeight: 600,
+                lineHeight: 1.2,
+                ...(subtitle && {
+                  mb: 0.5
+                })
+              },
+              children: title
+            }), subtitle && jsx(Typography, {
+              variant: "body2",
+              color: "text.secondary",
+              sx: {
+                lineHeight: 1.3
+              },
+              children: subtitle
+            })]
+          })]
+        }), jsxs(Stack, {
+          direction: "row",
+          spacing: 1,
+          alignItems: "center",
+          sx: {
+            flexShrink: 0
+          },
+          children: [headerActions && jsx(Box, {
+            children: renderContent(headerActions)
+          }), jsx(IconButton, {
+            onClick: handleButtonClick,
+            size: "small",
+            "aria-label": toggleAriaLabel,
+            "aria-expanded": !collapsed,
+            "aria-controls": contentId,
+            children: toggleIcon
+          })]
+        })]
+      }), showDivider && jsx(Divider, {})]
+    }), collapsed && collapsedView && jsxs(Fragment, {
+      children: [jsx(Box, {
+        className: contentClassName,
+        sx: contentSx,
+        children: renderContent(collapsedView)
+      }), showDivider && footerView && jsx(Divider, {})]
+    }), jsxs(Collapse, {
+      in: !collapsed,
+      ...collapseProps,
+      children: [jsx(Box, {
+        id: contentId,
+        className: contentClassName,
+        sx: contentSx,
+        role: "region",
+        "aria-labelledby": title ? headerId : undefined,
+        ...contentAriaProps,
+        children: renderContent(children)
+      }), showDivider && footerView && jsx(Divider, {})]
+    }), footerView && jsx(Box, {
+      className: footerClassName,
+      sx: contentSx,
+      children: renderContent(footerView)
+    })]
+  });
+  // Return appropriate container based on variant
+  if (variant === 'outlined') {
+    return jsx(Paper, {
+      variant: "outlined",
+      elevation: 0,
+      ...htmlProps,
+      ...otherProps,
+      className: containerClassName,
+      sx: containerSx,
+      children: containerContent
+    });
+  }
+  if (variant === 'elevated') {
+    return jsx(Paper, {
+      elevation: 2,
+      ...htmlProps,
+      ...otherProps,
+      className: containerClassName,
+      sx: containerSx,
+      children: containerContent
+    });
+  }
+  // Default variant (default, filled)
+  return jsx(Box, {
+    ...htmlProps,
+    ...otherProps,
+    className: containerClassName,
+    sx: containerSx,
+    children: containerContent
+  });
+}
+/**
+ * Main CollapsibleLayout component with data binding support
+ */
+function CollapsibleLayout(props) {
+  const {
+    dataSource,
+    bindingOptions,
+    ...restProps
+  } = props;
+  // If no dataSource, use traditional props
+  if (!dataSource) {
+    return jsx(CollapsibleLayoutView, {
+      ...restProps
+    });
+  }
+  // Use data binding
+  const {
+    dataSource: _source,
+    loading,
+    error,
+    cached,
+    ...collapsibleProps
+  } = useDataBinding(dataSource, restProps, CollapsibleLayoutModel$1.getSchema(), {
+    cache: true,
+    cacheTTL: 300000,
+    strict: false,
+    ...bindingOptions
+  });
+  // Show loading state
+  if (loading) {
+    return jsx(CollapsibleLayoutView, {
+      ...restProps,
+      title: "Loading...",
+      variant: "default",
+      headerSpacing: "comfortable",
+      contentSpacing: "comfortable"
+    });
+  }
+  if (error) {
+    console.error('Error loading collapsible layout:', error);
+    {
+      return jsx(CollapsibleLayoutView, {
+        ...restProps,
+        title: "Error Loading Layout",
+        subtitle: error.message,
+        variant: "outlined",
+        headerSpacing: "comfortable",
+        contentSpacing: "comfortable"
+      });
+    }
+  }
+  return jsx(CollapsibleLayoutView, {
+    ...collapsibleProps
+  });
+}
+// Set default props
+CollapsibleLayout.defaultProps = defaultCollapsibleLayoutProps;
+
 /**
  * FeatureCard Schema - Schema definition for FeatureCard component
  *
@@ -18726,7 +19409,7 @@ function FormBlockView({
   title,
   description,
   coverImage,
-  form,
+  children: form,
   footer,
   status,
   message,
@@ -19684,8 +20367,195 @@ function SelectInputField(props) {
     strict: false,
     ...bindingOptions
   });
-  // Show loading state
-  if (loading) {
+  // Show loading state
+  if (loading) {
+    return jsxs(Paper, {
+      variant: "outlined",
+      sx: {
+        p: 2,
+        textAlign: 'center'
+      },
+      children: [jsx(Typography, {
+        variant: "body2",
+        children: "Loading SelectInputField..."
+      }), jsx(Typography, {
+        variant: "caption",
+        color: "text.secondary",
+        children: "Loading select field configuration from data source..."
+      })]
+    });
+  }
+  if (error) {
+    console.error('Error loading select input field:', error);
+    {
+      return jsx(Paper, {
+        variant: "outlined",
+        sx: {
+          p: 2,
+          textAlign: 'center',
+          borderColor: 'error.main'
+        },
+        children: jsxs(Typography, {
+          variant: "body2",
+          color: "error",
+          children: ["Error loading select field: ", error.message]
+        })
+      });
+    }
+  }
+  return jsx(SelectInputFieldView, {
+    ...selectInputFieldProps
+  });
+}
+// Mark as QwickApp component
+SelectInputField[QWICKAPP_COMPONENT] = true;
+
+/**
+ * SwitchInputField Schema - Data model for switch input field component
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+let SwitchInputFieldModel = class SwitchInputFieldModel extends Model {};
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXT,
+  label: 'Label',
+  description: 'The label text for the switch'
+}), IsOptional(), IsString(), __metadata("design:type", String)], SwitchInputFieldModel.prototype, "label", void 0);
+__decorate([Field({
+  defaultValue: false
+}), Editor({
+  field_type: FieldType.BOOLEAN,
+  label: 'Checked',
+  description: 'Whether the switch is checked'
+}), IsOptional(), IsBoolean(), __metadata("design:type", Boolean)], SwitchInputFieldModel.prototype, "checked", void 0);
+__decorate([Field({
+  defaultValue: false
+}), Editor({
+  field_type: FieldType.BOOLEAN,
+  label: 'Required',
+  description: 'Whether the field is required'
+}), IsOptional(), IsBoolean(), __metadata("design:type", Boolean)], SwitchInputFieldModel.prototype, "required", void 0);
+__decorate([Field({
+  defaultValue: false
+}), Editor({
+  field_type: FieldType.BOOLEAN,
+  label: 'Disabled',
+  description: 'Whether the field is disabled'
+}), IsOptional(), IsBoolean(), __metadata("design:type", Boolean)], SwitchInputFieldModel.prototype, "disabled", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXT,
+  label: 'Error',
+  description: 'Error message to display'
+}), IsOptional(), IsString(), __metadata("design:type", String)], SwitchInputFieldModel.prototype, "error", void 0);
+__decorate([Field(), Editor({
+  field_type: FieldType.TEXT,
+  label: 'Helper Text',
+  description: 'Helper text to display below the switch'
+}), IsOptional(), IsString(), __metadata("design:type", String)], SwitchInputFieldModel.prototype, "helperText", void 0);
+__decorate([Field({
+  defaultValue: 'medium'
+}), Editor({
+  field_type: FieldType.SELECT,
+  label: 'Size',
+  description: 'Size of the switch'
+}), IsOptional(), IsString(), __metadata("design:type", String)], SwitchInputFieldModel.prototype, "size", void 0);
+__decorate([Field({
+  defaultValue: 'primary'
+}), Editor({
+  field_type: FieldType.SELECT,
+  label: 'Color',
+  description: 'Color theme of the switch'
+}), IsOptional(), IsString(), __metadata("design:type", String)], SwitchInputFieldModel.prototype, "color", void 0);
+SwitchInputFieldModel = __decorate([Schema('SwitchInputField', '1.0.0')], SwitchInputFieldModel);
+var SwitchInputFieldModel$1 = SwitchInputFieldModel;
+
+// View component - handles the actual rendering
+function SwitchInputFieldView({
+  label,
+  checked = false,
+  onChange,
+  onFocus,
+  required = false,
+  disabled = false,
+  error,
+  helperText,
+  size = 'medium',
+  color = 'primary',
+  ...restProps
+}) {
+  const {
+    styleProps,
+    htmlProps
+  } = useBaseProps(restProps);
+  const handleChange = event => {
+    if (onChange) {
+      onChange(event.target.checked);
+    }
+  };
+  return jsxs(FormControl, {
+    ...htmlProps,
+    ...styleProps,
+    error: !!error,
+    required: required,
+    disabled: disabled,
+    sx: {
+      display: 'block',
+      ...styleProps.sx
+    },
+    children: [jsx(FormControlLabel, {
+      control: jsx(Switch, {
+        checked: checked,
+        onChange: handleChange,
+        onFocus: onFocus,
+        size: size,
+        color: color,
+        disabled: disabled
+      }),
+      label: label,
+      disabled: disabled
+    }), (error || helperText) && jsx(FormHelperText, {
+      children: error || helperText
+    })]
+  });
+}
+/**
+ * SwitchInputField component with data binding support
+ * Supports both traditional props and dataSource-driven rendering
+ */
+function SwitchInputField(props) {
+  const {
+    dataSource,
+    bindingOptions,
+    ...restProps
+  } = props;
+  // If no dataSource, use traditional props
+  if (!dataSource) {
+    return jsx(SwitchInputFieldView, {
+      ...restProps
+    });
+  }
+  // Use data binding
+  const bindingResult = useDataBinding(dataSource, restProps, SwitchInputFieldModel$1.getSchema(), {
+    cache: true,
+    cacheTTL: 300000,
+    strict: false,
+    ...bindingOptions
+  });
+  // Check if we're still loading data using the metadata properties
+  const bindingLoading = bindingResult.$loading;
+  // Extract all the actual switch properties (excluding metadata)
+  const {
+    dataSource: _source,
+    $loading,
+    $error,
+    $dataSource,
+    $cached,
+    cached,
+    ...switchInputFieldProps
+  } = bindingResult;
+  const error = bindingResult.$error;
+  // Show loading state while fetching data
+  if (bindingLoading) {
     return jsxs(Paper, {
       variant: "outlined",
       sx: {
@@ -19694,16 +20564,16 @@ function SelectInputField(props) {
       },
       children: [jsx(Typography, {
         variant: "body2",
-        children: "Loading SelectInputField..."
+        children: "Loading SwitchInputField..."
       }), jsx(Typography, {
         variant: "caption",
         color: "text.secondary",
-        children: "Loading select field configuration from data source..."
+        children: "Loading switch field configuration from data source..."
       })]
     });
   }
   if (error) {
-    console.error('Error loading select input field:', error);
+    console.error('Error loading switch input field:', error);
     {
       return jsx(Paper, {
         variant: "outlined",
@@ -19715,17 +20585,17 @@ function SelectInputField(props) {
         children: jsxs(Typography, {
           variant: "body2",
           color: "error",
-          children: ["Error loading select field: ", error.message]
+          children: ["Error loading switch field: ", error.message]
         })
       });
     }
   }
-  return jsx(SelectInputFieldView, {
-    ...selectInputFieldProps
+  return jsx(SwitchInputFieldView, {
+    ...switchInputFieldProps
   });
 }
 // Mark as QwickApp component
-SelectInputField[QWICKAPP_COMPONENT] = true;
+SwitchInputField[QWICKAPP_COMPONENT] = true;
 
 const TextField = /*#__PURE__*/React.forwardRef((props, ref) => {
   const {
@@ -20223,7 +21093,7 @@ const FormPage = ({
     title: title,
     description: description,
     coverImage: coverImage,
-    form: form,
+    children: form,
     footer: footer,
     status: status,
     message: message,
@@ -20579,6 +21449,605 @@ const Scaffold = ({
 
 loggers.menu;
 
+/**
+ * Generic ErrorBoundary component for catching and handling React errors
+ *
+ * Features:
+ * - Catches JavaScript errors anywhere in child component tree
+ * - Displays fallback UI with retry functionality
+ * - Shows error details in development mode
+ * - Customizable error handling and fallback UI
+ * - Automatic error logging
+ */
+class ErrorBoundary extends Component {
+  constructor(props) {
+    super(props);
+    this.handleRetry = () => {
+      this.setState({
+        hasError: false,
+        error: null,
+        errorInfo: null
+      });
+    };
+    this.handleRefresh = () => {
+      if (typeof window !== 'undefined') {
+        window.location.reload();
+      }
+    };
+    this.state = {
+      hasError: false,
+      error: null,
+      errorInfo: null
+    };
+  }
+  static getDerivedStateFromError(error) {
+    // Update state so the next render will show the fallback UI
+    return {
+      hasError: true,
+      error,
+      errorInfo: null
+    };
+  }
+  componentDidCatch(error, errorInfo) {
+    // Log error details
+    this.setState({
+      error,
+      errorInfo
+    });
+    // Log to console for debugging
+    console.error('ErrorBoundary caught an error:', error, errorInfo);
+    // Custom error handler
+    if (this.props.onError) {
+      this.props.onError(error, errorInfo);
+    }
+    // Send error to logging service if available
+    if (typeof window !== 'undefined') {
+      // @ts-ignore - Global error logging service
+      if (window.qwickapps?.logError) {
+        window.qwickapps.logError(error, errorInfo);
+      }
+    }
+  }
+  render() {
+    if (this.state.hasError) {
+      // Custom fallback UI
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+      // Default error UI
+      return jsxs("div", {
+        className: "error-boundary",
+        role: "alert",
+        style: {
+          padding: '2rem',
+          textAlign: 'center',
+          backgroundColor: '#fef2f2',
+          border: '1px solid #fecaca',
+          borderRadius: '8px',
+          margin: '1rem',
+          color: '#991b1b'
+        },
+        children: [jsxs("div", {
+          style: {
+            marginBottom: '1.5rem'
+          },
+          children: [jsx("h2", {
+            style: {
+              fontSize: '1.5rem',
+              fontWeight: 'bold',
+              marginBottom: '0.5rem',
+              color: '#991b1b'
+            },
+            children: "Something went wrong"
+          }), jsx("p", {
+            style: {
+              color: '#7f1d1d',
+              marginBottom: '1rem'
+            },
+            children: "An unexpected error occurred in the application. Please try again or refresh the page."
+          })]
+        }), jsxs("div", {
+          style: {
+            display: 'flex',
+            gap: '0.75rem',
+            justifyContent: 'center',
+            marginBottom: '1rem'
+          },
+          children: [jsx(Button, {
+            variant: "contained",
+            onClick: this.handleRetry,
+            style: {
+              backgroundColor: '#dc2626',
+              color: 'white'
+            },
+            children: "Try Again"
+          }), jsx(Button, {
+            variant: "outlined",
+            onClick: this.handleRefresh,
+            style: {
+              borderColor: '#dc2626',
+              color: '#dc2626'
+            },
+            children: "Refresh Page"
+          })]
+        }), this.state.error && jsxs("details", {
+          style: {
+            textAlign: 'left',
+            marginTop: '1rem',
+            padding: '1rem',
+            backgroundColor: '#f9fafb',
+            border: '1px solid #d1d5db',
+            borderRadius: '6px'
+          },
+          children: [jsx("summary", {
+            style: {
+              cursor: 'pointer',
+              fontWeight: 'bold',
+              marginBottom: '0.5rem',
+              color: '#374151'
+            },
+            children: "Error Details (Development Mode)"
+          }), jsxs("pre", {
+            style: {
+              fontSize: '0.75rem',
+              color: '#374151',
+              whiteSpace: 'pre-wrap',
+              overflow: 'auto'
+            },
+            children: [this.state.error.toString(), this.state.errorInfo?.componentStack && jsxs(Fragment, {
+              children: [jsx("br", {}), jsx("br", {}), "Component Stack:", this.state.errorInfo.componentStack]
+            })]
+          })]
+        })]
+      });
+    }
+    return this.props.children;
+  }
+}
+/**
+ * Higher-order component that wraps a component with ErrorBoundary
+ */
+function withErrorBoundary(WrappedComponent, errorBoundaryProps) {
+  const WithErrorBoundaryComponent = props => jsx(ErrorBoundary, {
+    ...errorBoundaryProps,
+    children: jsx(WrappedComponent, {
+      ...props
+    })
+  });
+  WithErrorBoundaryComponent.displayName = `withErrorBoundary(${WrappedComponent.displayName || WrappedComponent.name || 'Component'})`;
+  return WithErrorBoundaryComponent;
+}
+
+const AccessibilityContext = /*#__PURE__*/createContext(null);
+// Reducer
+const accessibilityReducer = (state, action) => {
+  switch (action.type) {
+    case 'SET_HIGH_CONTRAST':
+      return {
+        ...state,
+        highContrast: action.payload
+      };
+    case 'SET_REDUCED_MOTION':
+      return {
+        ...state,
+        reducedMotion: action.payload
+      };
+    case 'SET_LARGE_TEXT':
+      return {
+        ...state,
+        largeText: action.payload
+      };
+    case 'SET_FOCUS_VISIBLE':
+      return {
+        ...state,
+        focusVisible: action.payload
+      };
+    case 'SET_KEYBOARD_USER':
+      return {
+        ...state,
+        isKeyboardUser: action.payload
+      };
+    case 'ADD_ISSUE':
+      return {
+        ...state,
+        issues: [...state.issues, action.payload]
+      };
+    case 'CLEAR_ISSUES':
+      return {
+        ...state,
+        issues: []
+      };
+    case 'SET_ANNOUNCEMENT':
+      return {
+        ...state,
+        lastAnnouncement: action.payload
+      };
+    default:
+      return state;
+  }
+};
+// Initial state
+const initialState = {
+  highContrast: false,
+  reducedMotion: false,
+  largeText: false,
+  focusVisible: true,
+  isKeyboardUser: false,
+  issues: [],
+  lastAnnouncement: null,
+  preferences: {}
+};
+// ARIA Live Manager
+class AriaLiveManager {
+  constructor() {
+    this.politeRegion = null;
+    this.assertiveRegion = null;
+    this.createLiveRegions();
+  }
+  createLiveRegions() {
+    if (typeof document === 'undefined') return;
+    // Polite announcements
+    this.politeRegion = document.createElement('div');
+    this.politeRegion.setAttribute('aria-live', 'polite');
+    this.politeRegion.setAttribute('aria-atomic', 'true');
+    this.politeRegion.setAttribute('id', 'qwickapps-aria-live-polite');
+    this.politeRegion.style.cssText = `
+			position: absolute !important;
+			left: -10000px !important;
+			width: 1px !important;
+			height: 1px !important;
+			overflow: hidden !important;
+		`;
+    document.body.appendChild(this.politeRegion);
+    // Assertive announcements
+    this.assertiveRegion = document.createElement('div');
+    this.assertiveRegion.setAttribute('aria-live', 'assertive');
+    this.assertiveRegion.setAttribute('aria-atomic', 'true');
+    this.assertiveRegion.setAttribute('id', 'qwickapps-aria-live-assertive');
+    this.assertiveRegion.style.cssText = `
+			position: absolute !important;
+			left: -10000px !important;
+			width: 1px !important;
+			height: 1px !important;
+			overflow: hidden !important;
+		`;
+    document.body.appendChild(this.assertiveRegion);
+  }
+  announce(message, level = 'polite') {
+    if (level === 'assertive') {
+      this.announceAssertive(message);
+    } else {
+      this.announcePolite(message);
+    }
+  }
+  announcePolite(message) {
+    if (!this.politeRegion) return;
+    this.politeRegion.textContent = '';
+    // Small delay ensures screen readers detect the change
+    setTimeout(() => {
+      if (this.politeRegion) {
+        this.politeRegion.textContent = message;
+      }
+    }, 100);
+  }
+  announceAssertive(message) {
+    if (!this.assertiveRegion) return;
+    this.assertiveRegion.textContent = '';
+    // Small delay ensures screen readers detect the change
+    setTimeout(() => {
+      if (this.assertiveRegion) {
+        this.assertiveRegion.textContent = message;
+      }
+    }, 100);
+  }
+}
+const ariaLiveManager = new AriaLiveManager();
+/**
+ * Accessibility Provider Component
+ * Provides comprehensive accessibility context and utilities
+ *
+ * Features:
+ * - System preference detection (high contrast, reduced motion)
+ * - Keyboard navigation detection
+ * - ARIA live announcements
+ * - Focus management
+ * - Accessibility auditing
+ * - Settings persistence
+ */
+const AccessibilityProvider = ({
+  children,
+  enableAudit = "development" === 'development'
+}) => {
+  const [state, dispatch] = useReducer(accessibilityReducer, initialState);
+  useEffect(() => {
+    // Detect user preferences from system
+    detectUserPreferences();
+    // Set up keyboard detection
+    const keyboardCleanup = setupKeyboardDetection();
+    // Initialize focus management
+    initializeFocusManagement();
+    // Run initial accessibility audit
+    if (enableAudit) {
+      runAccessibilityAudit();
+    }
+    // Cleanup
+    return () => {
+      if (keyboardCleanup) keyboardCleanup();
+    };
+  }, [enableAudit]);
+  const detectUserPreferences = () => {
+    if (typeof window === 'undefined') return;
+    // High contrast mode
+    if (window.matchMedia && window.matchMedia('(prefers-contrast: high)').matches) {
+      dispatch({
+        type: 'SET_HIGH_CONTRAST',
+        payload: true
+      });
+    }
+    // Reduced motion
+    if (window.matchMedia && window.matchMedia('(prefers-reduced-motion: reduce)').matches) {
+      dispatch({
+        type: 'SET_REDUCED_MOTION',
+        payload: true
+      });
+    }
+    // Listen for changes
+    if (window.matchMedia) {
+      const contrastMedia = window.matchMedia('(prefers-contrast: high)');
+      const motionMedia = window.matchMedia('(prefers-reduced-motion: reduce)');
+      const contrastHandler = e => {
+        dispatch({
+          type: 'SET_HIGH_CONTRAST',
+          payload: e.matches
+        });
+      };
+      const motionHandler = e => {
+        dispatch({
+          type: 'SET_REDUCED_MOTION',
+          payload: e.matches
+        });
+      };
+      contrastMedia.addEventListener('change', contrastHandler);
+      motionMedia.addEventListener('change', motionHandler);
+      // Return cleanup function
+      return () => {
+        contrastMedia.removeEventListener('change', contrastHandler);
+        motionMedia.removeEventListener('change', motionHandler);
+      };
+    }
+  };
+  const setupKeyboardDetection = () => {
+    if (typeof document === 'undefined') return;
+    let keyboardUser = false;
+    const handleKeyDown = e => {
+      if (e.key === 'Tab') {
+        keyboardUser = true;
+        dispatch({
+          type: 'SET_KEYBOARD_USER',
+          payload: true
+        });
+        document.body.classList.add('keyboard-user');
+      }
+    };
+    const handleMouseDown = () => {
+      if (keyboardUser) {
+        keyboardUser = false;
+        dispatch({
+          type: 'SET_KEYBOARD_USER',
+          payload: false
+        });
+        document.body.classList.remove('keyboard-user');
+      }
+    };
+    document.addEventListener('keydown', handleKeyDown);
+    document.addEventListener('mousedown', handleMouseDown);
+    return () => {
+      document.removeEventListener('keydown', handleKeyDown);
+      document.removeEventListener('mousedown', handleMouseDown);
+    };
+  };
+  const initializeFocusManagement = () => {
+    if (typeof document === 'undefined') return;
+    // Enhanced focus indicators for keyboard users
+    const style = document.createElement('style');
+    style.textContent = `
+			.keyboard-user *:focus {
+				outline: 3px solid #005cee !important;
+				outline-offset: 2px !important;
+			}
+			
+			.high-contrast *:focus {
+				outline: 3px solid #ffffff !important;
+				outline-offset: 2px !important;
+				box-shadow: 0 0 0 1px #000000 !important;
+			}
+			
+			.reduced-motion * {
+				animation-duration: 0.01ms !important;
+				animation-iteration-count: 1 !important;
+				transition-duration: 0.01ms !important;
+			}
+			
+			.large-text {
+				font-size: 1.2em !important;
+			}
+		`;
+    document.head.appendChild(style);
+  };
+  const runAccessibilityAudit = () => {
+    if (typeof document === 'undefined') return;
+    setTimeout(() => {
+      const issues = [];
+      // Check for images without alt text
+      const images = document.querySelectorAll('img:not([alt])');
+      images.forEach(img => {
+        issues.push({
+          type: 'missing-alt-text',
+          message: 'Image missing alt attribute',
+          level: 'error',
+          element: img
+        });
+      });
+      // Check for buttons without accessible names
+      const buttons = document.querySelectorAll('button:not([aria-label]):not([title])');
+      buttons.forEach(button => {
+        if (!button.textContent?.trim()) {
+          issues.push({
+            type: 'unnamed-button',
+            message: 'Button missing accessible name',
+            level: 'error',
+            element: button
+          });
+        }
+      });
+      // Check for form inputs without labels
+      const inputs = document.querySelectorAll('input:not([aria-label]):not([title])');
+      inputs.forEach(input => {
+        const id = input.getAttribute('id');
+        if (id) {
+          const label = document.querySelector(`label[for="${id}"]`);
+          if (!label) {
+            issues.push({
+              type: 'unlabeled-input',
+              message: 'Form input missing label',
+              level: 'error',
+              element: input
+            });
+          }
+        } else {
+          issues.push({
+            type: 'unlabeled-input',
+            message: 'Form input missing label',
+            level: 'error',
+            element: input
+          });
+        }
+      });
+      dispatch({
+        type: 'CLEAR_ISSUES'
+      });
+      issues.forEach(issue => {
+        dispatch({
+          type: 'ADD_ISSUE',
+          payload: issue
+        });
+      });
+      if (issues.length > 0) {
+        console.group('🔍 Accessibility Issues Found');
+        issues.forEach(issue => {
+          const logMethod = issue.level === 'error' ? console.error : console.warn;
+          logMethod(`${issue.type}: ${issue.message}`);
+        });
+        console.groupEnd();
+      }
+    }, 1000);
+  };
+  // Context value
+  const contextValue = {
+    ...state,
+    // Actions
+    setHighContrast: enabled => dispatch({
+      type: 'SET_HIGH_CONTRAST',
+      payload: enabled
+    }),
+    setReducedMotion: enabled => dispatch({
+      type: 'SET_REDUCED_MOTION',
+      payload: enabled
+    }),
+    setLargeText: enabled => dispatch({
+      type: 'SET_LARGE_TEXT',
+      payload: enabled
+    }),
+    setFocusVisible: enabled => dispatch({
+      type: 'SET_FOCUS_VISIBLE',
+      payload: enabled
+    }),
+    // Utilities
+    announce: (message, level = 'polite') => {
+      ariaLiveManager.announce(message, level);
+      dispatch({
+        type: 'SET_ANNOUNCEMENT',
+        payload: {
+          message,
+          level,
+          timestamp: Date.now()
+        }
+      });
+    },
+    announcePolite: message => {
+      ariaLiveManager.announcePolite(message);
+      dispatch({
+        type: 'SET_ANNOUNCEMENT',
+        payload: {
+          message,
+          level: 'polite',
+          timestamp: Date.now()
+        }
+      });
+    },
+    announceAssertive: message => {
+      ariaLiveManager.announceAssertive(message);
+      dispatch({
+        type: 'SET_ANNOUNCEMENT',
+        payload: {
+          message,
+          level: 'assertive',
+          timestamp: Date.now()
+        }
+      });
+    },
+    addIssue: issue => dispatch({
+      type: 'ADD_ISSUE',
+      payload: issue
+    }),
+    clearIssues: () => dispatch({
+      type: 'CLEAR_ISSUES'
+    }),
+    // Audit function
+    runAudit: runAccessibilityAudit
+  };
+  // Apply CSS classes based on preferences
+  useEffect(() => {
+    if (typeof document === 'undefined') return;
+    const {
+      highContrast,
+      reducedMotion,
+      largeText
+    } = state;
+    document.body.classList.toggle('high-contrast', highContrast);
+    document.body.classList.toggle('reduced-motion', reducedMotion);
+    document.body.classList.toggle('large-text', largeText);
+  }, [state.highContrast, state.reducedMotion, state.largeText]);
+  return jsx(AccessibilityContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+};
+/**
+ * Hook to access accessibility context
+ */
+const useAccessibility = () => {
+  const context = useContext(AccessibilityContext);
+  if (!context) {
+    throw new Error('useAccessibility must be used within an AccessibilityProvider');
+  }
+  return context;
+};
+/**
+ * Higher-Order Component for accessibility enhancements
+ */
+const withAccessibility = WrappedComponent => {
+  const AccessibilityEnhancedComponent = props => {
+    const accessibility = useAccessibility();
+    return jsx(WrappedComponent, {
+      ...props,
+      accessibility: accessibility
+    });
+  };
+  AccessibilityEnhancedComponent.displayName = `withAccessibility(${WrappedComponent.displayName || WrappedComponent.name || 'Component'})`;
+  return AccessibilityEnhancedComponent;
+};
+
 const QwickApp = ({
   children,
   className,
@@ -20640,16 +22109,20 @@ const QwickApp = ({
     dataSource: dataSource,
     children: content
   }) : content;
-  const appContent = jsx("div", {
-    className: `qwick-app ${className || ''}`,
-    style: style,
-    children: jsx(ThemeProvider, {
-      appId: appId,
-      defaultTheme: defaultTheme,
-      defaultPalette: defaultPalette,
-      children: jsx(QwickAppContext.Provider, {
-        value: contextValue,
-        children: wrappedContent
+  const appContent = jsx(ErrorBoundary, {
+    children: jsx(AccessibilityProvider, {
+      children: jsx("div", {
+        className: `qwick-app ${className || ''}`,
+        style: style,
+        children: jsx(ThemeProvider, {
+          appId: appId,
+          defaultTheme: defaultTheme,
+          defaultPalette: defaultPalette,
+          children: jsx(QwickAppContext.Provider, {
+            value: contextValue,
+            children: wrappedContent
+          })
+        })
       })
     })
   });
@@ -20757,6 +22230,186 @@ const setCSSVariable = (property, value) => {
   document.documentElement.style.setProperty(property, value);
 };
 
+/**
+ * Generic Breadcrumbs component for navigation hierarchy
+ *
+ * Features:
+ * - Accessible navigation with proper ARIA labels
+ * - Customizable separators and icons
+ * - Responsive design with item truncation
+ * - Support for custom navigation handlers
+ * - Keyboard navigation support
+ * - Screen reader friendly
+ */
+const Breadcrumbs = ({
+  items,
+  separator = '/',
+  className = '',
+  onNavigate,
+  maxItems,
+  showRoot = true
+}) => {
+  // Filter and prepare items
+  let displayItems = showRoot ? items : items.slice(1);
+  // Handle max items with ellipsis
+  if (maxItems && displayItems.length > maxItems) {
+    const firstItems = displayItems.slice(0, 1);
+    const lastItems = displayItems.slice(-Math.max(1, maxItems - 2));
+    displayItems = [...firstItems, {
+      label: '...',
+      href: undefined,
+      current: false
+    }, ...lastItems];
+  }
+  const handleItemClick = (e, item, index) => {
+    if (onNavigate) {
+      e.preventDefault();
+      onNavigate(item, index);
+    }
+  };
+  const handleKeyDown = (e, item, index) => {
+    if (e.key === 'Enter' || e.key === ' ') {
+      e.preventDefault();
+      if (onNavigate) {
+        onNavigate(item, index);
+      } else if (item.href) {
+        window.location.href = item.href;
+      }
+    }
+  };
+  if (displayItems.length <= 1) {
+    return null;
+  }
+  return jsx("nav", {
+    className: `breadcrumbs ${className}`,
+    role: "navigation",
+    "aria-label": "Breadcrumb navigation",
+    style: {
+      display: 'flex',
+      alignItems: 'center',
+      fontSize: '14px',
+      color: '#6b7280',
+      ...defaultStyles.nav
+    },
+    children: jsx("ol", {
+      style: {
+        display: 'flex',
+        alignItems: 'center',
+        listStyle: 'none',
+        margin: 0,
+        padding: 0,
+        gap: '8px'
+      },
+      children: displayItems.map((item, index) => {
+        const isLast = index === displayItems.length - 1;
+        const isClickable = (item.href || onNavigate) && !item.current && item.label !== '...';
+        return jsxs("li", {
+          style: {
+            display: 'flex',
+            alignItems: 'center'
+          },
+          children: [isClickable ? jsxs("a", {
+            href: item.href,
+            onClick: e => handleItemClick(e, item, index),
+            onKeyDown: e => handleKeyDown(e, item, index),
+            style: {
+              ...defaultStyles.link,
+              color: isLast ? '#374151' : '#6b7280',
+              textDecoration: 'none',
+              display: 'flex',
+              alignItems: 'center',
+              gap: '4px'
+            },
+            tabIndex: 0,
+            "aria-current": item.current ? 'page' : undefined,
+            children: [item.icon && jsx("span", {
+              style: {
+                display: 'flex',
+                alignItems: 'center'
+              },
+              "aria-hidden": "true",
+              children: item.icon
+            }), jsx("span", {
+              children: item.label
+            })]
+          }) : jsxs("span", {
+            style: {
+              ...defaultStyles.current,
+              color: isLast ? '#111827' : '#6b7280',
+              fontWeight: isLast ? 600 : 400,
+              display: 'flex',
+              alignItems: 'center',
+              gap: '4px'
+            },
+            "aria-current": item.current ? 'page' : undefined,
+            children: [item.icon && jsx("span", {
+              style: {
+                display: 'flex',
+                alignItems: 'center'
+              },
+              "aria-hidden": "true",
+              children: item.icon
+            }), jsx("span", {
+              children: item.label
+            })]
+          }), !isLast && jsx("span", {
+            style: {
+              display: 'flex',
+              alignItems: 'center',
+              marginLeft: '8px',
+              color: '#d1d5db',
+              fontSize: '12px'
+            },
+            "aria-hidden": "true",
+            children: separator
+          })]
+        }, `${item.label}-${index}`);
+      })
+    })
+  });
+};
+// Default styles
+const defaultStyles = {
+  nav: {
+    padding: '8px 0'
+  },
+  link: {
+    transition: 'color 0.2s ease',
+    cursor: 'pointer',
+    borderRadius: '4px',
+    padding: '4px',
+    margin: '-4px'
+  },
+  current: {
+    padding: '4px'
+  }
+};
+/**
+ * Hook for managing breadcrumb state
+ */
+const useBreadcrumbs = () => {
+  const [breadcrumbs, setBreadcrumbs] = React.useState([]);
+  const addBreadcrumb = React.useCallback(item => {
+    setBreadcrumbs(prev => [...prev, item]);
+  }, []);
+  const removeBreadcrumb = React.useCallback(index => {
+    setBreadcrumbs(prev => prev.filter((_, i) => i !== index));
+  }, []);
+  const setBreadcrumbsCurrent = React.useCallback(items => {
+    setBreadcrumbs(items);
+  }, []);
+  const clearBreadcrumbs = React.useCallback(() => {
+    setBreadcrumbs([]);
+  }, []);
+  return {
+    breadcrumbs,
+    addBreadcrumb,
+    removeBreadcrumb,
+    setBreadcrumbs: setBreadcrumbsCurrent,
+    clearBreadcrumbs
+  };
+};
+
 const QwickAppsLogo = props => {
   const {
     styleProps,
@@ -24223,4 +25876,4 @@ var ActionType;
   ActionType["CANCEL"] = "cancel";
 })(ActionType || (ActionType = {}));
 
-export { AVAILABLE_PALETTES, ActionModel, ActionType, AllPalettes, Article, ArticleModel, BasePage, Button, CardListGrid, CardListGridModel, ChoiceInputField, ChoiceInputFieldModel, Code, CodeModel, Content, ContentModel, CoverImageHeader, CoverImageHeaderModel, DataProvider, DataProxy, DimensionsProvider, FeatureCard, FeatureCardActionModel, FeatureCardModel, FeatureGrid, FeatureGridModel, FeatureItemModel, Footer, FooterItemModel, FooterModel, FooterSectionModel, FormBlock, FormBlockModel, FormMethod, FormPage, GridCell, GridLayout, HeaderActionModel, HeroBlock, HeroBlockModel, Html, HtmlInputField, Logo, Markdown, MetadataItemModel, Page, PageBannerHeader, PageBannerHeaderModel, PaletteAutumn, PaletteCosmic, PaletteDefault, PaletteOcean, PaletteProvider, PaletteSpring, PaletteSwitcher, PaletteSwitcherModel, PaletteWinter, ProductCard, ProductCardActionModel, ProductCardModel, ProductModel, QWICKAPP_COMPONENT, QwickApp, QwickAppsLogo, SafeSpan, SafeSpanModel, Section, SectionModel, SelectInputField, T, TextField, TextInputField, TextInputFieldModel, ThemeProvider, ThemeSwitcher, ThemeSwitcherModel, applyCustomPalette, clearUserPalettePreference, clearUserThemePreference, createLogger, createPaletteFromCurrentTheme, deleteCustomPalette, exportPalette, getCSSVariable, getComputedTheme, getCurrentPalette, getCurrentTheme, getCustomPalettes, getPaletteConfig, getPaletteName, getSystemTheme, getThemePerformanceStats, importPalette, initializePalette, initializeTheme, loadUserPalettePreference, loadUserThemePreference, logThemePerformanceStats, loggers, resetThemePerformanceStats, resolveDimension, resolveDimensions, resolveSpacing, resolveSpacingProps, saveCustomPalette, savePalettePreference, saveThemePreference, saveUserPalettePreference, saveUserThemePreference, setCSSVariable, setPalette, setTheme, t, useBaseProps, useData, useDataBinding, useDataContext, useDataProvider, useDimensions, usePalette, useQwickApp, useResolveTemplate, useSafeLocation, useSafeNavigate, useTemplate, useTheme };
+export { AVAILABLE_PALETTES, AccessibilityProvider, ActionModel, ActionType, AllPalettes, Article, ArticleModel, BasePage, Breadcrumbs, Button, CardListGrid, CardListGridModel, ChoiceInputField, ChoiceInputFieldModel, Code, CodeModel, CollapsibleLayout, CollapsibleLayoutView, Content, ContentModel, CoverImageHeader, CoverImageHeaderModel, DataProvider, DataProxy, DimensionsProvider, ErrorBoundary, FeatureCard, FeatureCardActionModel, FeatureCardModel, FeatureGrid, FeatureGridModel, FeatureItemModel, Footer, FooterItemModel, FooterModel, FooterSectionModel, FormBlock, FormBlockModel, FormMethod, FormPage, GridCell, GridLayout, HeaderActionModel, HeroBlock, HeroBlockModel, Html, HtmlInputField, Logo, Markdown, MetadataItemModel, Page, PageBannerHeader, PageBannerHeaderModel, PaletteAutumn, PaletteCosmic, PaletteDefault, PaletteOcean, PaletteProvider, PaletteSpring, PaletteSwitcher, PaletteSwitcherModel, PaletteWinter, ProductCard, ProductCardActionModel, ProductCardModel, ProductModel, QWICKAPP_COMPONENT, QwickApp, QwickAppsLogo, SafeSpan, SafeSpanModel, Section, SectionModel, SelectInputField, SwitchInputField, T, TextField, TextInputField, TextInputFieldModel, ThemeProvider, ThemeSwitcher, ThemeSwitcherModel, animationConfigs, applyCustomPalette, clearUserPalettePreference, clearUserThemePreference, createLogger, createPaletteFromCurrentTheme, defaultCollapsibleLayoutProps, deleteCustomPalette, exportPalette, getCSSVariable, getComputedTheme, getCurrentPalette, getCurrentTheme, getCustomPalettes, getPaletteConfig, getPaletteName, getSystemTheme, getThemePerformanceStats, importPalette, initializePalette, initializeTheme, isCollapsibleLayoutProps, loadUserPalettePreference, loadUserThemePreference, logThemePerformanceStats, loggers, resetThemePerformanceStats, resolveDimension, resolveDimensions, resolveSpacing, resolveSpacingProps, saveCustomPalette, savePalettePreference, saveThemePreference, saveUserPalettePreference, saveUserThemePreference, setCSSVariable, setPalette, setTheme, spacingConfigs, t, useAccessibility, useBaseProps, useBreadcrumbs, useCollapsibleState, useData, useDataBinding, useDataContext, useDataProvider, useDimensions, usePalette, useQwickApp, useResolveTemplate, useSafeLocation, useSafeNavigate, useTemplate, useTheme, withAccessibility, withErrorBoundary };