@qwickapps/react-framework 1.3.1 → 1.3.3

package/dist/index.js

@@ -3,7 +3,6 @@
 var jsxRuntime = require('react/jsx-runtime');
 var material = require('@mui/material');
 var React = require('react');
-var logging = require('@qwickapps/logging');
 var schema = require('@qwickapps/schema');
 var classValidator = require('class-validator');
 var classTransformer = require('class-transformer');
@@ -469,6 +468,63 @@ function useBaseProps(props) {
   };
 }
 
+/**
+ * QwickApps React Framework - Logger Utility
+ *
+ * Optional logging with fallback to console when @qwickapps/logging is not available
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+/**
+ * Console-based logger fallback
+ */
+class ConsoleLogger {
+  constructor(name) {
+    this.name = name;
+  }
+  debug(message, ...args) {
+    {
+      console.debug(`[${this.name}] ${message}`, ...args);
+    }
+  }
+  info(message, ...args) {
+    console.info(`[${this.name}] ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    console.warn(`[${this.name}] ${message}`, ...args);
+  }
+  error(message, ...args) {
+    console.error(`[${this.name}] ${message}`, ...args);
+  }
+}
+/**
+ * Create logger with optional @qwickapps/logging dependency
+ */
+function createLogger(name) {
+  try {
+    // Try to use @qwickapps/logging if available
+    const logging = require('@qwickapps/logging');
+    return logging.createLogger(name);
+  } catch {
+    // Fallback to console-based logger
+    return new ConsoleLogger(name);
+  }
+}
+/**
+ * Framework-specific loggers
+ */
+const loggers = {
+  scaffold: createLogger('Scaffold'),
+  navigation: createLogger('Navigation'),
+  auth: createLogger('Auth'),
+  theme: createLogger('Theme'),
+  palette: createLogger('Palette'),
+  form: createLogger('Form'),
+  layout: createLogger('Layout'),
+  menu: createLogger('Menu'),
+  router: createLogger('Router')
+};
+
 /**
 * ContentResolver provides a unified interface to fetch and render content
 * using data providers, template resolvers, and optional caching.
@@ -507,10 +563,7 @@ function useBaseProps(props) {
  */
 class TemplateResolver {
   constructor(config) {
-    this.log = new logging.Logger({
-      namespace: 'ContentResolver',
-      enabled: config.enableLogging || false
-    });
+    this.log = createLogger('ContentResolver');
     this.enableLogging = config.enableLogging || false;
     this.templateResolver = config.templateResolver || new schema.MustacheTemplateProvider();
     if (config.cacheProvider === true) {
@@ -13122,6 +13175,22 @@ const defaultMarkdownRules = [
     return null;
   }
 }];
+/**
+ * Parse style string into React style object
+ */
+function parseStyleString(styleStr) {
+  const styles = {};
+  if (!styleStr) return styles;
+  styleStr.split(';').forEach(declaration => {
+    const [property, value] = declaration.split(':').map(s => s.trim());
+    if (property && value) {
+      // Convert kebab-case to camelCase
+      const camelProperty = property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+      styles[camelProperty] = value;
+    }
+  });
+  return styles;
+}
 /**
  * Default fallback component - renders element as-is with SafeSpan content
  */
@@ -13129,6 +13198,9 @@ const defaultFallback = (element, key) => {
   const tagName = element.tagName.toLowerCase();
   // Check if this is a void element (self-closing)
   const voidElements = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+  // Handle style attribute separately to convert to object
+  const styleAttr = element.getAttribute('style');
+  const style = styleAttr ? parseStyleString(styleAttr) : undefined;
   const props = {
     key,
     ...(element.className ? {
@@ -13137,7 +13209,10 @@ const defaultFallback = (element, key) => {
     ...(element.id ? {
       id: element.id
     } : {}),
-    ...Object.fromEntries(Array.from(element.attributes).filter(attr => !['class', 'id'].includes(attr.name)).map(attr => [attr.name, attr.value]))
+    ...(style ? {
+      style
+    } : {}),
+    ...Object.fromEntries(Array.from(element.attributes).filter(attr => !['class', 'id', 'style'].includes(attr.name)).map(attr => [attr.name, attr.value]))
   };
   if (voidElements.has(tagName)) {
     // Void elements can't have children
@@ -13182,6 +13257,9 @@ function transformElement(element, key, config = {
     const children = Array.from(element.children);
     const tagName = element.tagName.toLowerCase();
     const transformedChildren = children.map((child, index) => transformElement(child, `${key}-${index}`, config));
+    // Handle style attribute separately to convert to object
+    const styleAttr = element.getAttribute('style');
+    const style = styleAttr ? parseStyleString(styleAttr) : undefined;
     return /*#__PURE__*/React.createElement(tagName, {
       key,
       ...(element.className ? {
@@ -13190,12 +13268,39 @@ function transformElement(element, key, config = {
       ...(element.id ? {
         id: element.id
       } : {}),
-      ...Object.fromEntries(Array.from(element.attributes).filter(attr => !['class', 'id'].includes(attr.name)).map(attr => [attr.name, attr.value]))
+      ...(style ? {
+        style
+      } : {}),
+      ...Object.fromEntries(Array.from(element.attributes).filter(attr => !['class', 'id', 'style'].includes(attr.name)).map(attr => [attr.name, attr.value]))
     }, ...transformedChildren);
   }
   // No transformation needed - use fallback
   return fallbackComponent(element, key);
 }
+/**
+ * Clean up invalid DOM nesting that can cause React errors
+ */
+function cleanupInvalidNesting(html) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, 'text/html');
+  // Find paragraphs that contain block-level elements (invalid nesting)
+  const paragraphs = doc.querySelectorAll('p');
+  const blockElements = ['div', 'section', 'article', 'aside', 'header', 'footer', 'nav', 'main', 'figure', 'blockquote', 'pre', 'table', 'form', 'fieldset', 'address'];
+  paragraphs.forEach(p => {
+    const hasBlockChildren = Array.from(p.children).some(child => blockElements.includes(child.tagName.toLowerCase()));
+    if (hasBlockChildren) {
+      // Convert paragraph to div to allow block children
+      const div = doc.createElement('div');
+      div.innerHTML = p.innerHTML;
+      // Copy attributes
+      Array.from(p.attributes).forEach(attr => {
+        div.setAttribute(attr.name, attr.value);
+      });
+      p.parentNode?.replaceChild(div, p);
+    }
+  });
+  return doc.body.innerHTML;
+}
 /**
  * Transform HTML string to React components
  */
@@ -13203,8 +13308,10 @@ function transformHtmlToReact(html, config = {
   rules: defaultArticleRules
 }) {
   if (!html.trim()) return [];
+  // Clean up invalid DOM nesting first
+  const cleanHtml = cleanupInvalidNesting(html);
   const parser = new DOMParser();
-  const doc = parser.parseFromString(html, 'text/html');
+  const doc = parser.parseFromString(cleanHtml, 'text/html');
   return Array.from(doc.body.children).map((element, index) => transformElement(element, index.toString(), config));
 }
 /**
@@ -20129,29 +20236,6 @@ const FormPage = ({
   });
 };
 
-/**
- * QwickApps React Framework - Logger Utility
- *
- * Re-exports from @qwickapps/logging with framework-specific loggers
- *
- * Copyright (c) 2025 QwickApps.com. All rights reserved.
- */
-// Re-export everything from the logging package
-/**
- * Framework-specific loggers
- */
-const loggers = {
-  scaffold: logging.createLogger('Scaffold'),
-  navigation: logging.createLogger('Navigation'),
-  auth: logging.createLogger('Auth'),
-  theme: logging.createLogger('Theme'),
-  palette: logging.createLogger('Palette'),
-  form: logging.createLogger('Form'),
-  layout: logging.createLogger('Layout'),
-  menu: logging.createLogger('Menu'),
-  router: logging.createLogger('Router')
-};
-
 const logger = loggers.scaffold;
 // Material UI breakpoints
 const BREAKPOINTS = {
@@ -20497,6 +20581,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 React.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 jsxRuntime.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: [jsxRuntime.jsxs("div", {
+          style: {
+            marginBottom: '1.5rem'
+          },
+          children: [jsxRuntime.jsx("h2", {
+            style: {
+              fontSize: '1.5rem',
+              fontWeight: 'bold',
+              marginBottom: '0.5rem',
+              color: '#991b1b'
+            },
+            children: "Something went wrong"
+          }), jsxRuntime.jsx("p", {
+            style: {
+              color: '#7f1d1d',
+              marginBottom: '1rem'
+            },
+            children: "An unexpected error occurred in the application. Please try again or refresh the page."
+          })]
+        }), jsxRuntime.jsxs("div", {
+          style: {
+            display: 'flex',
+            gap: '0.75rem',
+            justifyContent: 'center',
+            marginBottom: '1rem'
+          },
+          children: [jsxRuntime.jsx(Button, {
+            variant: "contained",
+            onClick: this.handleRetry,
+            style: {
+              backgroundColor: '#dc2626',
+              color: 'white'
+            },
+            children: "Try Again"
+          }), jsxRuntime.jsx(Button, {
+            variant: "outlined",
+            onClick: this.handleRefresh,
+            style: {
+              borderColor: '#dc2626',
+              color: '#dc2626'
+            },
+            children: "Refresh Page"
+          })]
+        }), this.state.error && jsxRuntime.jsxs("details", {
+          style: {
+            textAlign: 'left',
+            marginTop: '1rem',
+            padding: '1rem',
+            backgroundColor: '#f9fafb',
+            border: '1px solid #d1d5db',
+            borderRadius: '6px'
+          },
+          children: [jsxRuntime.jsx("summary", {
+            style: {
+              cursor: 'pointer',
+              fontWeight: 'bold',
+              marginBottom: '0.5rem',
+              color: '#374151'
+            },
+            children: "Error Details (Development Mode)"
+          }), jsxRuntime.jsxs("pre", {
+            style: {
+              fontSize: '0.75rem',
+              color: '#374151',
+              whiteSpace: 'pre-wrap',
+              overflow: 'auto'
+            },
+            children: [this.state.error.toString(), this.state.errorInfo?.componentStack && jsxRuntime.jsxs(jsxRuntime.Fragment, {
+              children: [jsxRuntime.jsx("br", {}), jsxRuntime.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 => jsxRuntime.jsx(ErrorBoundary, {
+    ...errorBoundaryProps,
+    children: jsxRuntime.jsx(WrappedComponent, {
+      ...props
+    })
+  });
+  WithErrorBoundaryComponent.displayName = `withErrorBoundary(${WrappedComponent.displayName || WrappedComponent.name || 'Component'})`;
+  return WithErrorBoundaryComponent;
+}
+
+const AccessibilityContext = /*#__PURE__*/React.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] = React.useReducer(accessibilityReducer, initialState);
+  React.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
+  React.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 jsxRuntime.jsx(AccessibilityContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+};
+/**
+ * Hook to access accessibility context
+ */
+const useAccessibility = () => {
+  const context = React.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 jsxRuntime.jsx(WrappedComponent, {
+      ...props,
+      accessibility: accessibility
+    });
+  };
+  AccessibilityEnhancedComponent.displayName = `withAccessibility(${WrappedComponent.displayName || WrappedComponent.name || 'Component'})`;
+  return AccessibilityEnhancedComponent;
+};
+
 const QwickApp = ({
   children,
   className,
@@ -20558,16 +21241,20 @@ const QwickApp = ({
     dataSource: dataSource,
     children: content
   }) : content;
-  const appContent = jsxRuntime.jsx("div", {
-    className: `qwick-app ${className || ''}`,
-    style: style,
-    children: jsxRuntime.jsx(ThemeProvider, {
-      appId: appId,
-      defaultTheme: defaultTheme,
-      defaultPalette: defaultPalette,
-      children: jsxRuntime.jsx(QwickAppContext.Provider, {
-        value: contextValue,
-        children: wrappedContent
+  const appContent = jsxRuntime.jsx(ErrorBoundary, {
+    children: jsxRuntime.jsx(AccessibilityProvider, {
+      children: jsxRuntime.jsx("div", {
+        className: `qwick-app ${className || ''}`,
+        style: style,
+        children: jsxRuntime.jsx(ThemeProvider, {
+          appId: appId,
+          defaultTheme: defaultTheme,
+          defaultPalette: defaultPalette,
+          children: jsxRuntime.jsx(QwickAppContext.Provider, {
+            value: contextValue,
+            children: wrappedContent
+          })
+        })
       })
     })
   });
@@ -20675,6 +21362,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 jsxRuntime.jsx("nav", {
+    className: `breadcrumbs ${className}`,
+    role: "navigation",
+    "aria-label": "Breadcrumb navigation",
+    style: {
+      display: 'flex',
+      alignItems: 'center',
+      fontSize: '14px',
+      color: '#6b7280',
+      ...defaultStyles.nav
+    },
+    children: jsxRuntime.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 jsxRuntime.jsxs("li", {
+          style: {
+            display: 'flex',
+            alignItems: 'center'
+          },
+          children: [isClickable ? jsxRuntime.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 && jsxRuntime.jsx("span", {
+              style: {
+                display: 'flex',
+                alignItems: 'center'
+              },
+              "aria-hidden": "true",
+              children: item.icon
+            }), jsxRuntime.jsx("span", {
+              children: item.label
+            })]
+          }) : jsxRuntime.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 && jsxRuntime.jsx("span", {
+              style: {
+                display: 'flex',
+                alignItems: 'center'
+              },
+              "aria-hidden": "true",
+              children: item.icon
+            }), jsxRuntime.jsx("span", {
+              children: item.label
+            })]
+          }), !isLast && jsxRuntime.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,
@@ -24142,9 +25009,11 @@ exports.ActionType = void 0;
 })(exports.ActionType || (exports.ActionType = {}));
 
 exports.AVAILABLE_PALETTES = AVAILABLE_PALETTES;
+exports.AccessibilityProvider = AccessibilityProvider;
 exports.AllPalettes = AllPalettes;
 exports.Article = Article;
 exports.BasePage = BasePage;
+exports.Breadcrumbs = Breadcrumbs;
 exports.Button = Button;
 exports.CardListGrid = CardListGrid;
 exports.ChoiceInputField = ChoiceInputField;
@@ -24154,6 +25023,7 @@ exports.CoverImageHeader = CoverImageHeader;
 exports.DataProvider = DataProvider;
 exports.DataProxy = DataProxy;
 exports.DimensionsProvider = DimensionsProvider;
+exports.ErrorBoundary = ErrorBoundary;
 exports.FeatureCard = FeatureCard;
 exports.FeatureGrid = FeatureGrid;
 exports.Footer = Footer;
@@ -24191,6 +25061,7 @@ exports.ThemeSwitcher = ThemeSwitcher;
 exports.applyCustomPalette = applyCustomPalette;
 exports.clearUserPalettePreference = clearUserPalettePreference;
 exports.clearUserThemePreference = clearUserThemePreference;
+exports.createLogger = createLogger;
 exports.createPaletteFromCurrentTheme = createPaletteFromCurrentTheme;
 exports.deleteCustomPalette = deleteCustomPalette;
 exports.exportPalette = exportPalette;
@@ -24224,7 +25095,9 @@ exports.setCSSVariable = setCSSVariable;
 exports.setPalette = setPalette;
 exports.setTheme = setTheme;
 exports.t = t;
+exports.useAccessibility = useAccessibility;
 exports.useBaseProps = useBaseProps;
+exports.useBreadcrumbs = useBreadcrumbs;
 exports.useData = useData;
 exports.useDataBinding = useDataBinding;
 exports.useDataContext = useDataContext;
@@ -24237,9 +25110,5 @@ exports.useSafeLocation = useSafeLocation;
 exports.useSafeNavigate = useSafeNavigate;
 exports.useTemplate = useTemplate;
 exports.useTheme = useTheme;
-Object.keys(logging).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-        enumerable: true,
-        get: function () { return logging[k]; }
-    });
-});
+exports.withAccessibility = withAccessibility;
+exports.withErrorBoundary = withErrorBoundary;