@jmruthers/pace-core 0.6.4 → 0.6.6

package/dist/{chunk-6SOIHG6Z.js → chunk-S7DKJPLT.js}

@@ -1,9 +1,103 @@
-import {
-  logger
-} from "./chunk-PWLANIRT.js";
+import { logger } from './chunk-TTRFSOKR.js';
+import * as React from 'react';
+import { useRef, useCallback, useEffect, useState, useMemo } from 'react';
 
-// src/hooks/useToast.ts
-import * as React from "react";
+var DEFAULT_FOCUSABLE_SELECTOR = [
+  "button:not([disabled])",
+  "[href]",
+  "input:not([disabled])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[tabindex]:not([tabindex="-1"])',
+  '[contenteditable="true"]'
+].join(", ");
+function useFocusTrap(options = {}) {
+  const {
+    isActive = false,
+    autoFocus = false,
+    restoreFocus = false,
+    onEscape,
+    focusableSelector = DEFAULT_FOCUSABLE_SELECTOR
+  } = options;
+  const containerRef = useRef(null);
+  const previouslyFocusedElement = useRef(null);
+  const getFocusableElements = useCallback(() => {
+    if (!containerRef.current) return [];
+    return Array.from(
+      containerRef.current.querySelectorAll(focusableSelector)
+    ).filter((element) => {
+      return (
+        // visible check
+        !element.hasAttribute("disabled") && !element.hasAttribute("hidden") && element.offsetParent !== null
+      );
+    });
+  }, [focusableSelector]);
+  const focusFirst = useCallback(() => {
+    const elements = getFocusableElements();
+    if (elements.length > 0) {
+      elements[0].focus();
+    }
+  }, [getFocusableElements]);
+  const focusLast = useCallback(() => {
+    const elements = getFocusableElements();
+    if (elements.length > 0) {
+      elements[elements.length - 1].focus();
+    }
+  }, [getFocusableElements]);
+  useEffect(() => {
+    if (!isActive || !containerRef.current) return;
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape" && onEscape) {
+        onEscape();
+        return;
+      }
+      if (event.key === "Tab") {
+        const focusableElements = getFocusableElements();
+        if (focusableElements.length === 0) return;
+        const firstElement = focusableElements[0];
+        const lastElement = focusableElements[focusableElements.length - 1];
+        if (event.shiftKey) {
+          if (document.activeElement === firstElement) {
+            event.preventDefault();
+            lastElement.focus();
+          }
+        } else {
+          if (document.activeElement === lastElement) {
+            event.preventDefault();
+            firstElement.focus();
+          }
+        }
+      }
+    };
+    const container = containerRef.current;
+    container.addEventListener("keydown", handleKeyDown);
+    return () => {
+      container.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [isActive, onEscape, getFocusableElements]);
+  useEffect(() => {
+    if (!isActive) return;
+    if (restoreFocus) {
+      previouslyFocusedElement.current = document.activeElement;
+    }
+    if (autoFocus) {
+      const timer = setTimeout(focusFirst, 0);
+      return () => clearTimeout(timer);
+    }
+    return () => {
+      if (restoreFocus && previouslyFocusedElement.current) {
+        previouslyFocusedElement.current.focus();
+        previouslyFocusedElement.current = null;
+      }
+    };
+  }, [isActive, autoFocus, restoreFocus, focusFirst]);
+  return {
+    containerRef,
+    focusFirst,
+    focusLast,
+    getFocusableElements
+  };
+}
 var TOAST_LIMIT = 5;
 var TOAST_REMOVE_DELAY = 1e3;
 var DEFAULT_TOAST_DURATION = 5e3;
@@ -407,9 +501,6 @@ function safeExecute(fn, fallback) {
     return fallback;
   }
 }
-
-// src/hooks/useDataTablePerformance.ts
-import { useState as useState2, useEffect as useEffect2, useCallback, useMemo, useRef } from "react";
 function useDataTablePerformance({
   data,
   performance = {},
@@ -420,24 +511,24 @@ function useDataTablePerformance({
   onError,
   enableErrorRecovery = true
 }) {
-  const [isLoading, setIsLoading] = useState2(false);
-  const [searchQuery, setSearchQuery] = useState2("");
-  const [searchResults, setSearchResults] = useState2([]);
-  const [serverData, setServerData] = useState2(null);
-  const [memoryUsage, setMemoryUsage] = useState2(0);
-  const [errorState, setErrorState] = useState2({
+  const [isLoading, setIsLoading] = useState(false);
+  const [searchQuery, setSearchQuery] = useState("");
+  const [searchResults, setSearchResults] = useState([]);
+  const [serverData, setServerData] = useState(null);
+  const [memoryUsage, setMemoryUsage] = useState(0);
+  const [errorState, setErrorState] = useState({
     hasErrors: false,
     errorCount: 0,
     lastError: null,
     fallbacksActive: []
   });
-  const [lastFailedOperation, setLastFailedOperation] = useState2(null);
+  const [lastFailedOperation, setLastFailedOperation] = useState(null);
   const chunkManagerRef = useRef(null);
   const searchIndexRef = useRef(null);
   const visibilityTrackerRef = useRef(null);
   const errorRecoveryManagerRef = useRef(new ErrorRecoveryManager(fallbackConfig));
   const memoryMonitorRef = useRef(null);
-  const circuitBreakerRef = useRef(new CircuitBreaker());
+  useRef(new CircuitBreaker());
   const paginationMode = useMemo(() => {
     if (serverSide) return "server";
     return determinePaginationMode(data?.length || 0, performance.serverSideThreshold);
@@ -462,12 +553,12 @@ function useDataTablePerformance({
     }
     return processedData?.length || 0;
   }, [serverData, processedData?.length, serverSide]);
-  useEffect2(() => {
+  useEffect(() => {
     if (chunking && !chunkManagerRef.current) {
       chunkManagerRef.current = new DataChunkManager(chunking);
     }
   }, [chunking]);
-  useEffect2(() => {
+  useEffect(() => {
     if (searchIndex && !searchIndexRef.current) {
       searchIndexRef.current = new SearchIndex(searchIndex);
     }
@@ -487,7 +578,7 @@ function useDataTablePerformance({
     }), performance.debounceSearch ?? 300),
     [performance.debounceSearch]
   );
-  useEffect2(() => {
+  useEffect(() => {
     debouncedSearch(searchQuery);
   }, [searchQuery, debouncedSearch]);
   const fetchServerData = useCallback(async (params) => {
@@ -502,7 +593,7 @@ function useDataTablePerformance({
       setIsLoading(false);
     }
   }, [serverSide]);
-  useEffect2(() => {
+  useEffect(() => {
     if (!visibilityTrackerRef.current) {
       visibilityTrackerRef.current = new VisibilityTracker();
     }
@@ -511,7 +602,7 @@ function useDataTablePerformance({
     });
     return unsubscribe;
   }, [totalCount, isVirtualized, paginationMode]);
-  useEffect2(() => {
+  useEffect(() => {
     const updateMemoryUsage = () => {
       let usage = 0;
       if (chunkManagerRef.current) {
@@ -528,7 +619,7 @@ function useDataTablePerformance({
       }
     };
   }, [processedData]);
-  const handleError = useCallback(async (error, operation) => {
+  useCallback(async (error, operation) => {
     if (enableErrorRecovery) {
       try {
         const recovery = await errorRecoveryManagerRef.current.handleError(error);
@@ -575,7 +666,7 @@ function useDataTablePerformance({
     visibilityTrackerRef.current?.destroy();
     memoryMonitorRef.current?.stopMonitoring();
   }, []);
-  useEffect2(() => {
+  useEffect(() => {
     return cleanup;
   }, [cleanup]);
   return {
@@ -605,24 +696,4 @@ function useDataTablePerformance({
   };
 }
 
-export {
-  toast,
-  useToast,
-  determinePaginationMode,
-  getOptimalPageSizeOptions,
-  chunkData,
-  DataChunkManager,
-  SearchIndex,
-  debounce,
-  throttle,
-  VisibilityTracker,
-  DEFAULT_FALLBACK_CONFIG,
-  DataTableErrorType,
-  DataTableError,
-  ErrorRecoveryManager,
-  MemoryMonitor,
-  CircuitBreaker,
-  safeExecute,
-  useDataTablePerformance
-};
-//# sourceMappingURL=chunk-6SOIHG6Z.js.map
+export { CircuitBreaker, DEFAULT_FALLBACK_CONFIG, DataChunkManager, DataTableError, DataTableErrorType, ErrorRecoveryManager, MemoryMonitor, SearchIndex, VisibilityTracker, chunkData, debounce, determinePaginationMode, getOptimalPageSizeOptions, safeExecute, throttle, toast, useDataTablePerformance, useFocusTrap, useToast };

package/dist/{chunk-FMUCXFII.js → chunk-SD6WQY43.js}

@@ -69,8 +69,4 @@ performanceBudgetMonitor.setBudget("CHUNK_COUNT", 10, "warning");
 performanceBudgetMonitor.setBudget("TREESHAKING_SCORE", 70, "warning");
 performanceBudgetMonitor.setBudget("ERROR_BOUNDARY_TRIGGER", 5, "error");
 
-export {
-  PERFORMANCE_BUDGETS,
-  performanceBudgetMonitor
-};
-//# sourceMappingURL=chunk-FMUCXFII.js.map
+export { PERFORMANCE_BUDGETS, performanceBudgetMonitor };

package/dist/{chunk-PWLANIRT.js → chunk-TTRFSOKR.js}

@@ -118,10 +118,4 @@ function createLogger(component) {
   return Logger.createScopedLogger(component);
 }
 
-export {
-  LogLevel,
-  Logger,
-  logger,
-  createLogger
-};
-//# sourceMappingURL=chunk-PWLANIRT.js.map
+export { LogLevel, Logger, createLogger, logger };

package/dist/{chunk-5DRSZLL2.js → chunk-UH3NTO3F.js}

@@ -12,9 +12,4 @@ function getAllStylePaths() {
   return Object.values(styleConfig).map((config) => config.path);
 }
 
-export {
-  styleConfig,
-  getStylePath,
-  getAllStylePaths
-};
-//# sourceMappingURL=chunk-5DRSZLL2.js.map
+export { getAllStylePaths, getStylePath, styleConfig };

package/dist/{chunk-FFQEQTNW.js → chunk-UIYSCEV7.js}

@@ -1,10 +1,8 @@
-import {
-  formatInTimeZone,
-  getTimezoneAbbreviation
-} from "./chunk-J36DSWQK.js";
-import {
-  createLogger
-} from "./chunk-PWLANIRT.js";
+import { formatInTimeZone, getTimezoneAbbreviation } from './chunk-2HGJFNAH.js';
+import { createLogger } from './chunk-TTRFSOKR.js';
+import { z } from 'zod';
+import { createClient } from '@supabase/supabase-js';
+import { parseISO, isValid } from 'date-fns';
 
 // src/utils/context/sessionTracking.ts
 var log = createLogger("SessionTracking");
@@ -83,9 +81,6 @@ function useSessionTracking(supabaseClient, appName) {
     trackSessionExpired
   };
 }
-
-// src/utils/validation/common.ts
-import { z } from "zod";
 var emailSchema = z.string().min(1, "Email is required").email("Invalid email format").max(254, "Email too long");
 var nameSchema = z.string().min(1, "Name is required").max(100, "Name too long").regex(/^[a-zA-Z\s'-]+$/, "Name contains invalid characters");
 var phoneSchema = z.string().regex(/^\+?[\d\s\-\(\)]+$/, "Invalid phone number format").min(10, "Phone number too short").max(20, "Phone number too long");
@@ -94,9 +89,6 @@ var dateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-M
   const parsed = new Date(date);
   return !isNaN(parsed.getTime());
 }, "Invalid date");
-
-// src/utils/validation/passwordSchema.ts
-import { z as z2 } from "zod";
 var COMMON_PASSWORDS = /* @__PURE__ */ new Set([
   "password",
   "123456",
@@ -119,7 +111,7 @@ var WEAK_PATTERNS = [
   /^(abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz)+/i
   // Sequential letters
 ];
-var securePasswordSchema = z2.string().min(8, "Password must be at least 8 characters long").max(128, "Password must not exceed 128 characters").refine(
+z.string().min(8, "Password must be at least 8 characters long").max(128, "Password must not exceed 128 characters").refine(
   (password) => /[a-z]/.test(password),
   "Password must contain at least one lowercase letter"
 ).refine(
@@ -146,7 +138,7 @@ var securePasswordSchema = z2.string().min(8, "Password must be at least 8 chara
   },
   "Password contains keyboard patterns. Please choose a more secure password"
 );
-var passwordSchema = z2.string().min(6, "Password must be at least 6 characters long").max(128, "Password must not exceed 128 characters");
+var passwordSchema = z.string().min(6, "Password must be at least 6 characters long").max(128, "Password must not exceed 128 characters");
 function calculatePasswordStrength(password) {
   let score = 0;
   const feedback = [];
@@ -179,6 +171,89 @@ function calculatePasswordStrength(password) {
   else level = "strong";
   return { score: Math.max(0, Math.min(100, score)), feedback, level };
 }
+var DEFAULT_OPTIONS = {
+  allowHtml: false,
+  allowedTags: [],
+  maxLength: 1e3,
+  trim: true,
+  removeScripts: true,
+  removeEvents: true
+};
+function sanitizeUserInput(input, options = {}) {
+  if (typeof input !== "string") {
+    return "";
+  }
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let sanitized = input;
+  if (opts.trim) {
+    sanitized = sanitized.trim();
+  }
+  if (opts.maxLength && sanitized.length > opts.maxLength) {
+    sanitized = sanitized.substring(0, opts.maxLength);
+  }
+  if (!opts.allowHtml) {
+    sanitized = sanitized.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/\//g, "&#x2F;");
+  } else if (opts.allowedTags && opts.allowedTags.length > 0) {
+    const allowedTagsRegex = new RegExp(`<(?!/?(?:${opts.allowedTags.join("|")})s*/?>)[^>]+>`, "gi");
+    sanitized = sanitized.replace(allowedTagsRegex, "");
+  }
+  if (opts.removeScripts) {
+    sanitized = sanitized.replace(/<script[^>]*>.*?<\/script>/gi, "").replace(/javascript:/gi, "").replace(/vbscript:/gi, "").replace(/data:/gi, "");
+  }
+  if (opts.removeEvents) {
+    sanitized = sanitized.replace(/on\w+\s*=/gi, "");
+  }
+  return sanitized;
+}
+function sanitizeEmail(email) {
+  if (typeof email !== "string") {
+    return "";
+  }
+  return email.trim().toLowerCase().replace(/[^\w@.-]/g, "");
+}
+function sanitizeFormData(data, schema, sanitizationRules) {
+  try {
+    if (sanitizationRules && typeof data === "object" && data !== null) {
+      const sanitizedData = { ...data };
+      Object.entries(sanitizationRules).forEach(([field, options]) => {
+        if (typeof sanitizedData[field] === "string") {
+          sanitizedData[field] = sanitizeUserInput(sanitizedData[field], options);
+        }
+      });
+      data = sanitizedData;
+    }
+    const result = schema.parse(data);
+    return { success: true, data: result };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return {
+        success: false,
+        error: error.errors.map((e) => e.message).join(", ")
+      };
+    }
+    return {
+      success: false,
+      error: "Validation failed"
+    };
+  }
+}
+var secureEmailSchema = z.string().min(1, "Email is required").email("Invalid email format").max(254, "Email too long").refine(
+  (email) => {
+    if (!email || typeof email !== "string") return false;
+    const domain = email.split("@")[1];
+    return domain && domain.includes(".") && domain.length > 3;
+  },
+  "Invalid email domain"
+).transform((email) => sanitizeEmail(email));
+z.string().min(1, "Email is required").email("Invalid email format");
+z.string().min(1, "Name is required").max(100, "Name too long").regex(/^[a-zA-Z\s'-]+$/, "Name contains invalid characters");
+z.string().regex(/^[\+]?[1-9][\d]{0,15}$/, "Invalid phone number format");
+z.string().url("Invalid URL format");
+z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Invalid date format (YYYY-MM-DD)");
+z.object({
+  email: secureEmailSchema,
+  password: z.string().min(1, "Password is required")
+});
 
 // src/utils/app/appConfig.ts
 var currentAppConfig = null;
@@ -201,9 +276,49 @@ function getCurrentAppName() {
 function getCurrentAppId() {
   return getAppConfig().appId;
 }
-
-// src/utils/formatting/formatting.ts
-import { parseISO, isValid } from "date-fns";
+var ALLOWED_FILE_PATTERNS = [
+  /[\/\\]main\.(tsx?|jsx?)(\?|:|\s|$)/i,
+  /[\/\\]App\.(tsx?|jsx?)(\?|:|\s|$)/i,
+  /[\/\\]lib[\/\\]supabase\.(tsx?|jsx?)(\?|:|\s|$)/i,
+  /[\/\\]src[\/\\]supabase\.(tsx?|jsx?)(\?|:|\s|$)/i
+];
+function isAllowedContext() {
+  if (typeof process !== "undefined" && true) {
+    return true;
+  }
+  try {
+    const stack = new Error().stack;
+    if (!stack) return false;
+    const stackLines = stack.split("\n");
+    for (const line of stackLines) {
+      for (const pattern of ALLOWED_FILE_PATTERNS) {
+        if (pattern.test(line)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+function createBaseClient(supabaseUrl, supabaseKey) {
+  if (!isAllowedContext()) {
+    const error = new Error(
+      "createBaseClient() can only be called from main.tsx, App.tsx, or lib/supabase.ts.\nThis is a security requirement to ensure the base client is only created once and passed to UnifiedAuthProvider.\nSee: https://github.com/jmruthers/pace-core/blob/main/packages/core/docs/standards/00-pace-core-compliance.md"
+    );
+    console.error("[pace-core Security Error]", error);
+    throw error;
+  }
+  return createClient(supabaseUrl, supabaseKey, {
+    auth: {
+      autoRefreshToken: true,
+      persistSession: true,
+      detectSessionInUrl: true,
+      flowType: "pkce"
+    }
+  });
+}
 function formatDate(date) {
   const dateObj = typeof date === "string" || typeof date === "number" ? new Date(date) : date;
   return dateObj.toLocaleDateString("en-GB", {
@@ -357,30 +472,4 @@ function formatDateTimeForMap(utcDate, timezone) {
   }
 }
 
-export {
-  useSessionTracking,
-  emailSchema,
-  nameSchema,
-  phoneSchema,
-  urlSchema,
-  dateSchema,
-  passwordSchema,
-  calculatePasswordStrength,
-  setAppConfig,
-  getAppConfig,
-  getCurrentAppName,
-  getCurrentAppId,
-  formatDate,
-  formatTime,
-  formatDateTime,
-  formatCurrency,
-  formatNumber,
-  formatPercent,
-  formatCompactNumber,
-  formatFileSize,
-  formatDateTimeForDisplay,
-  formatDateOnlyForDisplay,
-  formatDateTimeForTable,
-  formatDateTimeForMap
-};
-//# sourceMappingURL=chunk-FFQEQTNW.js.map
+export { calculatePasswordStrength, createBaseClient, dateSchema, emailSchema, formatCompactNumber, formatCurrency, formatDate, formatDateOnlyForDisplay, formatDateTime, formatDateTimeForDisplay, formatDateTimeForMap, formatDateTimeForTable, formatFileSize, formatNumber, formatPercent, formatTime, getAppConfig, getCurrentAppId, getCurrentAppName, nameSchema, passwordSchema, phoneSchema, sanitizeFormData, sanitizeUserInput, setAppConfig, urlSchema, useSessionTracking };