@jmruthers/pace-core 0.4.1 → 0.5.1

package/dist/usePublicRouteParams-B6i0KtXW.d.ts

@@ -0,0 +1,477 @@
+import { e as OrganisationRole, f as OrganisationPermission, g as SuperAdminContext } from './organisation-CO3Sh3_D.js';
+import { r as Event } from './unified-CM7T0aTK.js';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { D as Database } from './database-C3Szpi5J.js';
+
+/**
+ * @file useOrganisationPermissions Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/useOrganisationPermissions
+ * @since 0.4.0
+ *
+ * Hook for managing organisation-specific permissions and role validation.
+ * Provides secure access to user's role and permissions within organisations.
+ *
+ * @example
+ * ```tsx
+ * function OrganisationComponent() {
+ *   const {
+ *     isOrgAdmin,
+ *     canManageMembers,
+ *     userRole,
+ *     hasOrganisationAccess
+ *   } = useOrganisationPermissions();
+ *
+ *   return (
+ *     <div>
+ *       {isOrgAdmin && <AdminPanel />}
+ *       {canManageMembers && <MemberManagement />}
+ *       <p>Your role: {userRole}</p>
+ *     </div>
+ *   );
+ * }
+ *
+ * // For specific organisation
+ * function MultiOrgComponent() {
+ *   const permissions = useOrganisationPermissions('org-123');
+ *
+ *   if (!permissions.hasOrganisationAccess) {
+ *     return <div>No access to this organisation</div>;
+ *   }
+ *
+ *   return <div>Role in org-123: {permissions.userRole}</div>;
+ * }
+ * ```
+ *
+ * @security
+ * - Validates user membership in organisation
+ * - Provides role-based permission checks
+ * - Ensures secure access to organisation data
+ * - Real-time permission validation
+ */
+
+interface UseOrganisationPermissionsReturn {
+    /** User's role in the organisation */
+    userRole: OrganisationRole | 'no_access';
+    /** Whether user has organisation admin role */
+    isOrgAdmin: boolean;
+    /** Whether user is a super admin */
+    isSuperAdmin: boolean;
+    /** Whether user can moderate content */
+    canModerate: boolean;
+    /** Whether user can manage members */
+    canManageMembers: boolean;
+    /** Whether user can manage organisation settings */
+    canManageSettings: boolean;
+    /** Whether user can manage events */
+    canManageEvents: boolean;
+    /** Whether user has any admin privileges */
+    hasAdminPrivileges: boolean;
+    /** Whether user has access to the organisation */
+    hasOrganisationAccess: boolean;
+    /** Check if user has specific permission */
+    hasPermission: (permission: OrganisationPermission) => boolean;
+    /** Get all permissions for the user */
+    getAllPermissions: () => OrganisationPermission[];
+    /** Organisation ID being checked */
+    organisationId: string;
+}
+/**
+ * Hook to access organisation-specific permissions and roles
+ *
+ * @param orgId - Optional organisation ID. Defaults to currently selected organisation
+ * @returns Organisation permissions and role information
+ */
+declare function useOrganisationPermissions(orgId?: string): UseOrganisationPermissionsReturn;
+
+/**
+ * @file Organisation Security Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/OrganisationSecurity
+ * @since 0.4.0
+ *
+ * Security-focused hook for organisation access validation and super admin functionality.
+ * Provides utilities for validating user access to organisations and checking permissions.
+ */
+
+interface OrganisationSecurityHook {
+    superAdminContext: SuperAdminContext;
+    validateOrganisationAccess: (orgId: string) => Promise<boolean>;
+    hasMinimumRole: (minRole: string, orgId?: string) => boolean;
+    canAccessChildOrganisations: (orgId?: string) => boolean;
+    hasPermission: (permission: string, orgId?: string) => Promise<boolean>;
+    getUserPermissions: (orgId?: string) => Promise<string[]>;
+    logOrganisationAccess: (action: string, details?: any) => Promise<void>;
+    ensureOrganisationAccess: (orgId: string) => Promise<void>;
+    validateUserAccess: (userId: string, orgId: string) => Promise<boolean>;
+}
+declare const useOrganisationSecurity: () => OrganisationSecurityHook;
+
+/**
+ * @file useAppConfig Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/useAppConfig
+ * @since 0.4.0
+ *
+ * Hook for accessing app configuration like direct access support and event requirements.
+ * This is a convenience hook that extracts app config from the UnifiedAuthProvider.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { supportsDirectAccess, requiresEvent, isLoading } = useAppConfig();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {supportsDirectAccess && (
+ *         <div>This app supports direct access!</div>
+ *       )}
+ *       {requiresEvent && (
+ *         <EventSelector />
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+interface UseAppConfigReturn {
+    supportsDirectAccess: boolean;
+    requiresEvent: boolean;
+    isLoading: boolean;
+    appName: string;
+}
+/**
+ * Hook to access app configuration
+ * Works in both authenticated and public contexts
+ * @returns App configuration and loading state
+ */
+declare function useAppConfig(): UseAppConfigReturn;
+
+/**
+ * @file Public Event Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Public
+ * @since 1.0.0
+ *
+ * A React hook for accessing public event data without authentication.
+ * Provides event information by event_code for public pages.
+ *
+ * Features:
+ * - No authentication required
+ * - Caching for performance
+ * - Error handling and loading states
+ * - TypeScript support
+ * - Automatic refetch capabilities
+ *
+ * @example
+ * ```tsx
+ * import { usePublicEvent } from '@jmruthers/pace-core';
+ *
+ * function PublicEventPage() {
+ *   const { eventCode } = usePublicRouteParams();
+ *   const { event, isLoading, error, refetch } = usePublicEvent(eventCode);
+ *
+ *   if (isLoading) return <div>Loading event...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   if (!event) return <div>Event not found</div>;
+ *
+ *   return (
+ *     <div>
+ *       <h1>{event.event_name}</h1>
+ *       <p>Date: {event.event_date}</p>
+ *       <p>Venue: {event.event_venue}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @accessibility
+ * - No direct accessibility concerns (hook)
+ * - Enables accessible public event display
+ * - Supports screen reader friendly loading states
+ *
+ * @security
+ * - Only returns public-safe event data
+ * - Validates event_code before querying
+ * - No sensitive information exposed
+ * - Rate limiting applied at database level
+ *
+ * @performance
+ * - Built-in caching with TTL
+ * - Minimal re-renders with stable references
+ * - Lazy loading support
+ * - Error boundary integration
+ *
+ * @dependencies
+ * - React 18+ - Hooks and effects
+ * - @supabase/supabase-js - Database integration
+ * - Event types - Type definitions
+ */
+
+interface UsePublicEventReturn {
+    /** The event data, null if not loaded or not found */
+    event: Event | null;
+    /** Whether the data is currently loading */
+    isLoading: boolean;
+    /** Any error that occurred during loading */
+    error: Error | null;
+    /** Function to manually refetch the data */
+    refetch: () => Promise<void>;
+}
+interface UsePublicEventOptions {
+    /** Cache TTL in milliseconds (default: 5 minutes) */
+    cacheTtl?: number;
+    /** Whether to enable caching (default: true) */
+    enableCache?: boolean;
+}
+/**
+ * Hook for accessing public event data by event_code
+ *
+ * This hook provides access to public event information without requiring
+ * authentication. It includes caching, error handling, and loading states.
+ *
+ * @param eventCode - The event code to look up
+ * @param options - Configuration options for caching and behavior
+ * @returns Object containing event data, loading state, error, and refetch function
+ */
+declare function usePublicEvent(eventCode: string, options?: UsePublicEventOptions): UsePublicEventReturn;
+/**
+ * Clear all cached public event data
+ * Useful for testing or when you need to force refresh all data
+ */
+declare function clearPublicEventCache(): void;
+/**
+ * Get cache statistics for debugging
+ */
+declare function getPublicEventCacheStats(): {
+    size: number;
+    keys: string[];
+};
+
+/**
+ * @file Public Event Logo Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Public
+ * @since 1.0.0
+ *
+ * A React hook for accessing public event logo URLs without authentication.
+ * Provides logo URLs with fallback handling for public pages.
+ *
+ * Features:
+ * - No authentication required
+ * - Automatic fallback to event initials
+ * - Caching for performance
+ * - Error handling and loading states
+ * - TypeScript support
+ * - Image validation
+ *
+ * @example
+ * ```tsx
+ * import { usePublicEventLogo } from '@jmruthers/pace-core';
+ *
+ * function EventHeader() {
+ *   const { logoUrl, fallbackText, isLoading, error } = usePublicEventLogo(
+ *     eventId,
+ *     eventName,
+ *     organisationId
+ *   );
+ *
+ *   if (isLoading) return <div>Loading logo...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {logoUrl ? (
+ *         <img src={logoUrl} alt={`${eventName} logo`} />
+ *       ) : (
+ *         <div className="logo-fallback">{fallbackText}</div>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @accessibility
+ * - No direct accessibility concerns (hook)
+ * - Enables accessible logo display with proper alt text
+ * - Supports screen reader friendly fallbacks
+ *
+ * @security
+ * - Only returns public-safe logo URLs
+ * - Validates image existence before returning URL
+ * - No sensitive information exposed
+ * - Rate limiting applied at storage level
+ *
+ * @performance
+ * - Built-in caching with TTL
+ * - Image validation and optimization
+ * - Minimal re-renders with stable references
+ * - Lazy loading support
+ *
+ * @dependencies
+ * - React 18+ - Hooks and effects
+ * - @supabase/supabase-js - Storage integration
+ * - Event types - Type definitions
+ */
+
+interface UsePublicEventLogoReturn {
+    /** The logo URL if available, null if not found or error */
+    logoUrl: string | null;
+    /** Fallback text (event initials) if no logo is available */
+    fallbackText: string;
+    /** Whether the logo is currently loading */
+    isLoading: boolean;
+    /** Any error that occurred during loading */
+    error: Error | null;
+    /** Function to manually refetch the logo */
+    refetch: () => Promise<void>;
+}
+interface UsePublicEventLogoOptions {
+    /** Cache TTL in milliseconds (default: 30 minutes) */
+    cacheTtl?: number;
+    /** Whether to enable caching (default: true) */
+    enableCache?: boolean;
+    /** Whether to validate image existence (default: true) */
+    validateImage?: boolean;
+    /** Custom fallback text generator */
+    generateFallbackText?: (eventName: string) => string;
+    /** Supabase client instance (required) */
+    supabase: SupabaseClient<Database>;
+}
+/**
+ * Hook for accessing public event logo URLs
+ *
+ * This hook provides access to event logo URLs without requiring
+ * authentication. It includes fallback handling and image validation.
+ *
+ * @param eventId - The event ID to fetch logo for
+ * @param eventName - The event name for fallback text generation
+ * @param organisationId - The organisation ID for storage path
+ * @param options - Configuration options for caching and behavior
+ * @returns Object containing logo URL, fallback text, loading state, error, and refetch function
+ */
+declare function usePublicEventLogo(eventId: string | undefined, eventName: string | undefined, organisationId: string | undefined, options: UsePublicEventLogoOptions): UsePublicEventLogoReturn;
+/**
+ * Clear all cached public logo data
+ * Useful for testing or when you need to force refresh all data
+ */
+declare function clearPublicLogoCache(): void;
+/**
+ * Get cache statistics for debugging
+ */
+declare function getPublicLogoCacheStats(): {
+    size: number;
+    keys: string[];
+};
+
+/**
+ * @file Public Route Params Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Public
+ * @since 1.0.0
+ *
+ * A React hook for extracting and validating public route parameters.
+ * Provides event code extraction and validation for public pages.
+ *
+ * Features:
+ * - URL parameter extraction
+ * - Event code validation
+ * - TypeScript support
+ * - Error handling
+ * - Route pattern support
+ *
+ * @example
+ * ```tsx
+ * import { usePublicRouteParams } from '@jmruthers/pace-core';
+ *
+ * function PublicEventPage() {
+ *   const { eventCode, eventId, event, error, isLoading } = usePublicRouteParams();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *   if (!event) return <div>Event not found</div>;
+ *
+ *   return (
+ *     <div>
+ *       <h1>{event.event_name}</h1>
+ *       <p>Event Code: {eventCode}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @accessibility
+ * - No direct accessibility concerns (hook)
+ * - Enables accessible route parameter handling
+ * - Supports screen reader friendly error states
+ *
+ * @security
+ * - Validates event codes before processing
+ * - Sanitizes URL parameters
+ * - No sensitive information exposed
+ * - Rate limiting applied at route level
+ *
+ * @performance
+ * - Minimal re-renders with stable references
+ * - Efficient parameter extraction
+ * - Caching integration
+ *
+ * @dependencies
+ * - React 18+ - Hooks and effects
+ * - React Router - URL parameter extraction
+ * - Event types - Type definitions
+ */
+
+interface UsePublicRouteParamsReturn {
+    /** The event code from the URL */
+    eventCode: string | null;
+    /** The event ID (resolved from event code) */
+    eventId: string | null;
+    /** The full event object */
+    event: Event | null;
+    /** Whether the route parameters are being processed */
+    isLoading: boolean;
+    /** Any error that occurred during processing */
+    error: Error | null;
+    /** Function to manually refetch the event data */
+    refetch: () => Promise<void>;
+}
+interface UsePublicRouteParamsOptions {
+    /** Whether to automatically fetch event data (default: true) */
+    fetchEventData?: boolean;
+    /** Custom event code parameter name (default: 'eventCode') */
+    eventCodeParam?: string;
+    /** Whether to validate event code format (default: true) */
+    validateEventCode?: boolean;
+}
+/**
+ * Hook for extracting and validating public route parameters
+ *
+ * This hook extracts event codes from URL parameters and optionally
+ * fetches the corresponding event data. It provides validation and
+ * error handling for public routes.
+ *
+ * @param options - Configuration options for behavior
+ * @returns Object containing route parameters, event data, loading state, error, and refetch function
+ */
+declare function usePublicRouteParams(options?: UsePublicRouteParamsOptions): UsePublicRouteParamsReturn;
+/**
+ * Hook for extracting just the event code without fetching event data
+ * Useful when you only need the event code and will fetch data separately
+ */
+declare function usePublicEventCode(eventCodeParam?: string): {
+    eventCode: string | null;
+    error: Error | null;
+};
+/**
+ * Utility function to generate public route paths
+ */
+declare function generatePublicRoutePath(eventCode: string, pageName?: string): string;
+/**
+ * Utility function to extract event code from a public route path
+ */
+declare function extractEventCodeFromPath(path: string): string | null;
+
+export { type OrganisationSecurityHook as O, type UsePublicEventReturn as U, useOrganisationSecurity as a, useAppConfig as b, usePublicEvent as c, clearPublicEventCache as d, usePublicEventLogo as e, clearPublicLogoCache as f, getPublicEventCacheStats as g, getPublicLogoCacheStats as h, usePublicRouteParams as i, usePublicEventCode as j, generatePublicRoutePath as k, extractEventCodeFromPath as l, type UsePublicEventOptions as m, type UsePublicEventLogoReturn as n, type UsePublicEventLogoOptions as o, type UsePublicRouteParamsReturn as p, type UseOrganisationPermissionsReturn as q, type UseAppConfigReturn as r, useOrganisationPermissions as u };

package/dist/utils.d.ts

@@ -1,17 +1,94 @@
-export { A as AppConfig, S as SecureDataAccess, a as cn, g as getAppConfig, d as getCurrentAppId, b as getCurrentAppName, s as setAppConfig } from './appConfig-fB1pP_v3.js';
+export { A as AppConfig, S as SecureDataAccess, a as cn, g as getAppConfig, d as getCurrentAppId, b as getCurrentAppName, s as setAppConfig } from './appConfig-BVGyuvI7.js';
 import { z } from 'zod';
-import { RenderResult } from '@testing-library/react';
 export { u as useComponentPerformance } from './useComponentPerformance-DE9l5RkL.js';
 import * as date_fns from 'date-fns';
-import { D as DataTable } from './DataTable-BDBqkU-i.js';
+import { D as DataTable } from './DataTable-ltTFXHS3.js';
 import React__default, { ComponentType } from 'react';
 import { SupabaseClient } from '@supabase/supabase-js';
-import './organisation-DLNNQhPB.js';
+import './organisation-CO3Sh3_D.js';
 import 'clsx';
 import 'react/jsx-runtime';
-import './types-Bavn44NW.js';
+import './types-BRDU7N6w.js';
 import '@tanstack/react-table';
 
+/**
+ * @file Debug Logger Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/DebugLogger
+ * @since 0.4.76
+ */
+/**
+ * Debug logger that respects environment settings
+ * Only logs in development mode to prevent production console spam
+ */
+declare class DebugLogger {
+    private static isDevelopment;
+    /**
+     * Log debug information only in development mode
+     */
+    static log(component: string, message: string, ...args: any[]): void;
+    /**
+     * Log error information (always logged)
+     */
+    static error(component: string, message: string, ...args: any[]): void;
+    /**
+     * Log warning information (always logged)
+     */
+    static warn(component: string, message: string, ...args: any[]): void;
+    /**
+     * Log info information only in development mode
+     */
+    static info(component: string, message: string, ...args: any[]): void;
+}
+
+/**
+ * Utility to resolve the current app name from various sources
+ * Priority: package.json > environment variables > fallback
+ */
+/**
+ * Get the app name from package.json at build time
+ * This works by reading package.json during the build process
+ */
+declare function getAppNameFromPackageJson(): string | null;
+/**
+ * Get the app name from build-time injected variables
+ * This is the preferred method for browser environments
+ */
+declare function getAppNameFromBuildTime(): string | null;
+/**
+ * Get the app name from a global variable set by the consuming app
+ * This is the simplest approach for browser environments
+ */
+declare function getAppNameFromGlobal(): string | null;
+/**
+ * Get the app name from environment variables
+ * Fallback method for when package.json is not available
+ */
+declare function getAppNameFromEnvironment(): string | null;
+/**
+ * Set the app name globally for RBAC resolution
+ * Call this in your app's main entry point (e.g., main.tsx, index.tsx)
+ *
+ * @param appName - The app name from your package.json
+ *
+ * @example
+ * ```tsx
+ * // In your main.tsx or index.tsx
+ * import { setRBACAppName } from '@jmruthers/pace-core/utils';
+ *
+ * // Set the app name from package.json
+ * setRBACAppName('CAKE');
+ *
+ * // Rest of your app setup...
+ * ```
+ */
+declare function setRBACAppName(appName: string): void;
+/**
+ * Get the app name with fallback to a default
+ * Useful when you need a guaranteed app name
+ */
+declare function getCurrentAppNameWithFallback(fallback?: string): string;
+
 /**
  * @file Internal utilities for validation module
  * @internal This file contains implementation details that should not be used directly
@@ -190,60 +267,6 @@ interface SecurityEvent$1 {
 declare function getSecurityHeaders(): Record<string, string>;
 declare function validateSecurityHeaders(headers: Record<string, string>): boolean;
 
-/**
- * Accessibility testing helpers
- */
-
-declare const a11yHelpers: {
-    checkFocus: (element: HTMLElement) => boolean;
-    checkAriaLabel: (element: HTMLElement) => string | null;
-    checkTabIndex: (element: HTMLElement) => number;
-    checkKeyboardNavigation: (element: HTMLElement) => boolean;
-    simulateKeyPress: (element: HTMLElement, key: string) => Promise<void>;
-    /**
-     * Check if element has proper heading hierarchy
-     */
-    checkHeadingHierarchy: (container: HTMLElement) => boolean;
-    /**
-     * Check if form has proper labels
-     */
-    checkFormLabels: (container: HTMLElement) => {
-        valid: boolean;
-        issues: string[];
-    };
-    /**
-     * Test keyboard navigation through focusable elements
-     */
-    testKeyboardNavigation: (container: HTMLElement) => Promise<{
-        success: boolean;
-        focusableElements: number;
-        issues: string[];
-    }>;
-};
-/**
- * Comprehensive accessibility test for any component
- */
-declare function runAccessibilityTests(renderResult: RenderResult, options?: {
-    checkAxe?: boolean;
-    checkKeyboard?: boolean;
-    checkHeadings?: boolean;
-    checkLabels?: boolean;
-}): Promise<{
-    axeResults?: any;
-    keyboardResults?: any;
-    headingResults?: boolean;
-    labelResults?: any;
-    overall: boolean;
-}>;
-/**
- * Screen reader simulation helpers
- */
-declare const screenReaderHelpers: {
-    getAccessibleName: (element: HTMLElement) => string;
-    getAccessibleDescription: (element: HTMLElement) => string;
-    getRoleDescription: (element: HTMLElement) => string;
-};
-
 /**
  * Performance thresholds and constants
  */
@@ -613,4 +636,4 @@ declare function getOrganisationContext(supabase: SupabaseClient): Promise<strin
  */
 declare function isOrganisationContextAvailable(supabase: SupabaseClient): Promise<boolean>;
 
-export { CSP_DIRECTIVES, LazyDataTable, PERFORMANCE_BUDGETS, PERFORMANCE_THRESHOLDS, type PerformanceMetrics$1 as PerformanceMetrics, PermissionType, RateLimiter, type SanitizationOptions, type SecurityEvent$1 as SecurityEvent, a11yHelpers, auditLog, auditLogger, bundleAnalyzer, clearOrganisationContext, combineSchemas, createLazyComponent, createLazyUtility, createPerformanceBenchmark, deepMerge, emailSchema, formatCompactNumber, formatCurrency, formatDate, formatFileSize, formatNumber, formatPercent, generateCSPHeader, generateDeviceFingerprint, getOrganisationContext, getSecurityHeaders, hasAllPermissions, hasAnyPermission, hasPermission, isEmpty, isObject, isOrganisationContextAvailable, isStrongPassword, isValidDate, isValidEmail, isValidUrl, isWithinRange, lazyCSVUtils, lazyChartUtils, lazyDateUtils, lazyFormUtils, lazyLodash, loadCSVUtils, loadChartUtils, loadDateUtils, loadFormUtils, loadLodash, logAuditEvent, logAuthEvent, logPermissionEvent, logSecurityEvent, matchesPattern, measureRenderPerformance, nameSchema, parsePermission, passwordSchema, performanceBudgetMonitor, phoneSchema, pickSchema, runAccessibilityTests, sanitizeEmail, sanitizeFileName, sanitizeFormData, sanitizePhoneNumber, sanitizeSqlInput, sanitizeUrl, sanitizeUserInput, sanitizeUserInput_deprecated, screenReaderHelpers, securityMonitor, setOrganisationContext, trackDynamicImport, transformPermissionMapToBoolean, urlSchema, useSessionTracking, usernameSchema, validateDeviceFingerprint, validateImportPattern, validateSecurityHeaders, validateUserInput };
+export { CSP_DIRECTIVES, DebugLogger, LazyDataTable, PERFORMANCE_BUDGETS, PERFORMANCE_THRESHOLDS, type PerformanceMetrics$1 as PerformanceMetrics, PermissionType, RateLimiter, type SanitizationOptions, type SecurityEvent$1 as SecurityEvent, auditLog, auditLogger, bundleAnalyzer, clearOrganisationContext, combineSchemas, createLazyComponent, createLazyUtility, createPerformanceBenchmark, deepMerge, emailSchema, formatCompactNumber, formatCurrency, formatDate, formatFileSize, formatNumber, formatPercent, generateCSPHeader, generateDeviceFingerprint, getAppNameFromBuildTime, getAppNameFromEnvironment, getAppNameFromGlobal, getAppNameFromPackageJson, getCurrentAppNameWithFallback, getOrganisationContext, getSecurityHeaders, hasAllPermissions, hasAnyPermission, hasPermission, isEmpty, isObject, isOrganisationContextAvailable, isStrongPassword, isValidDate, isValidEmail, isValidUrl, isWithinRange, lazyCSVUtils, lazyChartUtils, lazyDateUtils, lazyFormUtils, lazyLodash, loadCSVUtils, loadChartUtils, loadDateUtils, loadFormUtils, loadLodash, logAuditEvent, logAuthEvent, logPermissionEvent, logSecurityEvent, matchesPattern, measureRenderPerformance, nameSchema, parsePermission, passwordSchema, performanceBudgetMonitor, phoneSchema, pickSchema, sanitizeEmail, sanitizeFileName, sanitizeFormData, sanitizePhoneNumber, sanitizeSqlInput, sanitizeUrl, sanitizeUserInput, sanitizeUserInput_deprecated, securityMonitor, setOrganisationContext, setRBACAppName, trackDynamicImport, transformPermissionMapToBoolean, urlSchema, useSessionTracking, usernameSchema, validateDeviceFingerprint, validateImportPattern, validateSecurityHeaders, validateUserInput };