@jmruthers/pace-core 0.5.120 → 0.5.121

package/dist/chunk-BDZUMRBD.js 3.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/organisationContext.ts"],"sourcesContent":["/**\n * @file Organisation Context Utility\n * @package @jmruthers/pace-core\n * @module Utils/OrganisationContext\n * @since 0.4.0\n *\n * Utility functions for managing organisation context in database sessions.\n * Provides fallback mechanisms for when database functions are not available.\n */\n\nimport type { SupabaseClient } from '@supabase/supabase-js';\n\n/**\n * Set organisation context in the database session\n * \n * This function attempts to set the organisation context using a database function.\n * If the function is not available, it falls back gracefully without throwing errors.\n * \n * @param supabase - Supabase client instance\n * @param organisationId - The organisation ID to set as context\n * @returns Promise that resolves when context is set (or falls back gracefully)\n */\nexport async function setOrganisationContext(\n  supabase: SupabaseClient,\n  organisationId: string\n): Promise<void> {\n  if (!supabase || !organisationId) {\n    // TODO: Replace with proper logging service integration\n    return;\n  }\n\n  try {\n    // Add timeout to prevent hanging RPC calls\n    const timeoutPromise = new Promise((_, reject) => {\n      setTimeout(() => reject(new Error('RPC timeout after 3 seconds')), 3000);\n    });\n    \n    // Call the database function to set organisation context\n    const rpcPromise = supabase.rpc('set_organisation_context', {\n      org_id: organisationId\n    });\n\n    const { error } = await Promise.race([rpcPromise, timeoutPromise]) as any;\n\n    if (error) {\n      // Function might not exist yet - this is expected during migration\n      // Silent fail - will fall back to client-side filtering\n      console.log('[organisationContext] RPC function not available or failed, continuing without database context');\n    } else {\n      console.log('[organisationContext] Organisation context set in database successfully');\n    }\n  } catch (error) {\n    // Handle any other errors gracefully\n    // Silent fail - will fall back to client-side filtering\n    console.log('[organisationContext] Failed to set database context, continuing without it:', error);\n  }\n}\n\n/**\n * Clear organisation context from the database session\n * \n * @param supabase - Supabase client instance\n * @returns Promise that resolves when context is cleared\n */\nexport async function clearOrganisationContext(\n  supabase: SupabaseClient\n): Promise<void> {\n  if (!supabase) {\n    // TODO: Replace with proper logging service integration\n    return;\n  }\n\n  try {\n    const { error } = await supabase.rpc('rbac_audit_log', {\n      p_event_type: 'organisation_switched',\n      p_metadata: { action: 'clear_context' }\n    });\n    \n    if (error) {\n      // Silent fail - function not available\n      // TODO: Replace with proper logging service integration\n    } else {\n      // TODO: Replace with proper logging service integration\n    }\n  } catch (error) {\n    // Silent fail - error occurred\n    // TODO: Replace with proper logging service integration\n  }\n}\n\n/**\n * Get current organisation context from the database session\n * \n * @param supabase - Supabase client instance\n * @returns Promise that resolves to the current organisation ID or null\n */\nexport async function getOrganisationContext(\n  supabase: SupabaseClient\n): Promise<string | null> {\n  if (!supabase) {\n    // TODO: Replace with proper logging service integration\n    return null;\n  }\n\n  try {\n    // For now, return null since we're not using database context\n    // This will be replaced with proper context management\n    const data = null;\n    const error = null;\n    \n    if (error) {\n      // TODO: Replace with proper logging service integration\n      return null;\n    }\n    \n    // Validate that data is a string (allow empty strings)\n    if (typeof data === 'string') {\n      return data;\n    }\n    \n    // Return null for invalid data formats\n    return null;\n  } catch (error) {\n    // TODO: Replace with proper logging service integration\n    return null;\n  }\n}\n\n/**\n * Check if organisation context functions are available in the database\n * \n * @param supabase - Supabase client instance\n * @returns Promise that resolves to true if functions are available\n */\nexport async function isOrganisationContextAvailable(\n  supabase: SupabaseClient\n): Promise<boolean> {\n  if (!supabase) {\n    return false;\n  }\n\n  try {\n    const { error } = await supabase.rpc('get_organisation_context');\n    \n    if (error) {\n      return false;\n    }\n    \n    return true;\n  } catch (error) {\n    return false;\n  }\n} "],"mappings":";;;;;AAsBA,eAAsB,uBACpB,UACA,gBACe;AACf,MAAI,CAAC,YAAY,CAAC,gBAAgB;AAEhC;AAAA,EACF;AAEA,MAAI;AAEF,UAAM,iBAAiB,IAAI,QAAQ,CAAC,GAAG,WAAW;AAChD,iBAAW,MAAM,OAAO,IAAI,MAAM,6BAA6B,CAAC,GAAG,GAAI;AAAA,IACzE,CAAC;AAGD,UAAM,aAAa,SAAS,IAAI,4BAA4B;AAAA,MAC1D,QAAQ;AAAA,IACV,CAAC;AAED,UAAM,EAAE,MAAM,IAAI,MAAM,QAAQ,KAAK,CAAC,YAAY,cAAc,CAAC;AAEjE,QAAI,OAAO;AAGT,cAAQ,IAAI,iGAAiG;AAAA,IAC/G,OAAO;AACL,cAAQ,IAAI,yEAAyE;AAAA,IACvF;AAAA,EACF,SAAS,OAAO;AAGd,YAAQ,IAAI,gFAAgF,KAAK;AAAA,EACnG;AACF;AAQA,eAAsB,yBACpB,UACe;AACf,MAAI,CAAC,UAAU;AAEb;AAAA,EACF;AAEA,MAAI;AACF,UAAM,EAAE,MAAM,IAAI,MAAM,SAAS,IAAI,kBAAkB;AAAA,MACrD,cAAc;AAAA,MACd,YAAY,EAAE,QAAQ,gBAAgB;AAAA,IACxC,CAAC;AAED,QAAI,OAAO;AAAA,IAGX,OAAO;AAAA,IAEP;AAAA,EACF,SAAS,OAAO;AAAA,EAGhB;AACF;AAQA,eAAsB,uBACpB,UACwB;AACxB,MAAI,CAAC,UAAU;AAEb,WAAO;AAAA,EACT;AAEA,MAAI;AAGF,UAAM,OAAO;AACb,UAAM,QAAQ;AAEd,QAAI,OAAO;AAET,aAAO;AAAA,IACT;AAGA,QAAI,OAAO,SAAS,UAAU;AAC5B,aAAO;AAAA,IACT;AAGA,WAAO;AAAA,EACT,SAAS,OAAO;AAEd,WAAO;AAAA,EACT;AACF;AAQA,eAAsB,+BACpB,UACkB;AAClB,MAAI,CAAC,UAAU;AACb,WAAO;AAAA,EACT;AAEA,MAAI;AACF,UAAM,EAAE,MAAM,IAAI,MAAM,SAAS,IAAI,0BAA0B;AAE/D,QAAI,OAAO;AACT,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,WAAO;AAAA,EACT;AACF;AAxJA;AAAA;AAAA;AAAA;AAAA;","names":[]}

package/dist/chunk-CGURJ27Z.js 2.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/useOrganisations.ts","../src/hooks/useEvents.ts"],"sourcesContent":["/**\n * @file Organisation Hook\n * @package @jmruthers/pace-core\n * @module Hooks\n * @since 0.1.0\n *\n * Convenience hook for accessing organisation context.\n * This hook provides a simple interface for working with organisations.\n * \n * Note: This is a convenience wrapper around the OrganisationService.\n * For better performance, consider using useOrganisationService directly.\n */\n\nimport { useOrganisationService } from './services/useOrganisationService';\nimport { Organisation, OrganisationMembership, OrganisationContextType } from '../types/organisation';\n\n/**\n * Hook to access organisation context\n * \n * @returns Organisation context with selected organisation, organisations list, and helper methods\n * @throws {Error} If used outside OrganisationServiceProvider\n * \n * @example\n * ```tsx\n * function MyComponent() {\n *   const { selectedOrganisation, organisations, switchOrganisation } = useOrganisations();\n *   \n *   return (\n *     <div>\n *       <h1>Current Organisation: {selectedOrganisation.display_name}</h1>\n *       {organisations.map(org => (\n *         <button key={org.id} onClick={() => switchOrganisation(org.id)}>\n *           {org.display_name}\n *         </button>\n *       ))}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useOrganisations(): OrganisationContextType {\n  const organisationService = useOrganisationService();\n\n  const selectedOrg = organisationService.getSelectedOrganisation();\n  \n  return {\n    selectedOrganisation: selectedOrg as Organisation | null,\n    organisations: organisationService.getOrganisations(),\n    userMemberships: organisationService.getUserMemberships(),\n    isLoading: organisationService.isLoading(),\n    error: organisationService.getError(),\n    hasValidOrganisationContext: organisationService.hasValidOrganisationContext(),\n    isContextReady: organisationService.isContextReady(),\n    setSelectedOrganisation: (org: Organisation | null) => organisationService.setSelectedOrganisation(org),\n    switchOrganisation: (orgId: string) => organisationService.switchOrganisation(orgId),\n    getUserRole: (orgId?: string) => organisationService.getUserRole(orgId),\n    validateOrganisationAccess: (orgId: string) => organisationService.validateOrganisationAccess(orgId),\n    refreshOrganisations: () => organisationService.refreshOrganisations(),\n    ensureOrganisationContext: () => organisationService.ensureOrganisationContext(),\n    isOrganisationSecure: () => organisationService.isOrganisationSecure(),\n    getPrimaryOrganisation: () => organisationService.getPrimaryOrganisation(),\n  };\n}\n\n","/**\n * @file Event Hook\n * @package @jmruthers/pace-core\n * @module Hooks\n * @since 0.1.0\n *\n * Convenience hook for accessing event context.\n * This hook provides a simple interface for working with events.\n * \n * Note: This is a convenience wrapper around the EventService.\n * For better performance, consider using useEventService directly.\n */\n\nimport { useEventService } from './services/useEventService';\nimport { Event } from '../types/unified';\n\nexport interface EventContextType {\n  events: Event[];\n  selectedEvent: Event | null;\n  isLoading: boolean;\n  error: Error | null;\n  setSelectedEvent: (event: Event | null) => void;\n  refreshEvents: () => Promise<void>;\n}\n\n/**\n * Hook to access event context\n * \n * @returns Event context with events, selected event, and helper methods\n * @throws {Error} If used outside EventServiceProvider\n * \n * @example\n * ```tsx\n * function MyComponent() {\n *   const { events, selectedEvent, setSelectedEvent } = useEvents();\n *   \n *   return (\n *     <div>\n *       {events.map(event => (\n *         <button key={event.id} onClick={() => setSelectedEvent(event)}>\n *           {event.event_name}\n *         </button>\n *       ))}\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useEvents(): EventContextType {\n  const eventService = useEventService();\n\n  const events = eventService.getEvents();\n\n  return {\n    events,\n    selectedEvent: eventService.getSelectedEvent(),\n    isLoading: eventService.isLoading(),\n    error: eventService.getError(),\n    setSelectedEvent: (event: Event | null) => eventService.setSelectedEvent(event),\n    refreshEvents: () => eventService.refreshEvents(),\n  };\n}\n\n"],"mappings":";;;;;;;;;;;AAwCO,SAAS,mBAA4C;AAC1D,QAAM,sBAAsB,uBAAuB;AAEnD,QAAM,cAAc,oBAAoB,wBAAwB;AAEhE,SAAO;AAAA,IACL,sBAAsB;AAAA,IACtB,eAAe,oBAAoB,iBAAiB;AAAA,IACpD,iBAAiB,oBAAoB,mBAAmB;AAAA,IACxD,WAAW,oBAAoB,UAAU;AAAA,IACzC,OAAO,oBAAoB,SAAS;AAAA,IACpC,6BAA6B,oBAAoB,4BAA4B;AAAA,IAC7E,gBAAgB,oBAAoB,eAAe;AAAA,IACnD,yBAAyB,CAAC,QAA6B,oBAAoB,wBAAwB,GAAG;AAAA,IACtG,oBAAoB,CAAC,UAAkB,oBAAoB,mBAAmB,KAAK;AAAA,IACnF,aAAa,CAAC,UAAmB,oBAAoB,YAAY,KAAK;AAAA,IACtE,4BAA4B,CAAC,UAAkB,oBAAoB,2BAA2B,KAAK;AAAA,IACnG,sBAAsB,MAAM,oBAAoB,qBAAqB;AAAA,IACrE,2BAA2B,MAAM,oBAAoB,0BAA0B;AAAA,IAC/E,sBAAsB,MAAM,oBAAoB,qBAAqB;AAAA,IACrE,wBAAwB,MAAM,oBAAoB,uBAAuB;AAAA,EAC3E;AACF;AA9DA;AAAA;AAAA;AAaA;AAAA;AAAA;;;ACAA;AAmCO,SAAS,YAA8B;AAC5C,QAAM,eAAe,gBAAgB;AAErC,QAAM,SAAS,aAAa,UAAU;AAEtC,SAAO;AAAA,IACL;AAAA,IACA,eAAe,aAAa,iBAAiB;AAAA,IAC7C,WAAW,aAAa,UAAU;AAAA,IAClC,OAAO,aAAa,SAAS;AAAA,IAC7B,kBAAkB,CAAC,UAAwB,aAAa,iBAAiB,KAAK;AAAA,IAC9E,eAAe,MAAM,aAAa,cAAc;AAAA,EAClD;AACF;","names":[]}

package/dist/chunk-GKHF54DI 2.js

@@ -0,0 +1,619 @@
+// src/hooks/useToast.ts
+import * as React from "react";
+var TOAST_LIMIT = 5;
+var TOAST_REMOVE_DELAY = 1e3;
+var DEFAULT_TOAST_DURATION = 5e3;
+var toastTimeouts = /* @__PURE__ */ new Map();
+var memoryState = {
+  toasts: []
+};
+var listeners = [];
+function dispatch(action) {
+  memoryState = reducer(memoryState, action);
+  listeners.forEach((listener) => {
+    listener(memoryState);
+  });
+}
+function genId() {
+  return Math.random().toString(36).substring(2, 9);
+}
+var addToRemoveQueue = (toastId) => {
+  if (toastTimeouts.has(toastId)) {
+    return;
+  }
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId);
+    dispatch({
+      type: "REMOVE_TOAST",
+      toastId
+    });
+  }, TOAST_REMOVE_DELAY);
+  toastTimeouts.set(toastId, timeout);
+};
+function reducer(state, action) {
+  switch (action.type) {
+    case "ADD_TOAST":
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT)
+      };
+    case "UPDATE_TOAST":
+      return {
+        ...state,
+        toasts: state.toasts.map(
+          (t) => t.id === action.toast?.id ? { ...t, ...action.toast } : t
+        )
+      };
+    case "DISMISS_TOAST": {
+      const { toastId } = action;
+      if (toastId) {
+        addToRemoveQueue(toastId);
+      }
+      return {
+        ...state,
+        toasts: state.toasts.map(
+          (t) => t.id === toastId || toastId === void 0 ? {
+            ...t,
+            open: false
+          } : t
+        )
+      };
+    }
+    case "REMOVE_TOAST":
+      if (action.toastId === void 0) {
+        return {
+          ...state,
+          toasts: []
+        };
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId)
+      };
+  }
+}
+function toast(props) {
+  const id = genId();
+  const update = (props2) => dispatch({
+    type: "UPDATE_TOAST",
+    toast: { ...props2, duration: DEFAULT_TOAST_DURATION, id }
+  });
+  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id });
+  dispatch({
+    type: "ADD_TOAST",
+    toast: {
+      ...props,
+      duration: DEFAULT_TOAST_DURATION,
+      id,
+      open: true,
+      dismiss,
+      onOpenChange: (open) => {
+        if (!open) dismiss();
+      }
+    }
+  });
+  return {
+    id,
+    dismiss,
+    update
+  };
+}
+function useToast() {
+  const [state, setState] = React.useState(memoryState);
+  React.useEffect(() => {
+    listeners.push(setState);
+    return () => {
+      const index = listeners.indexOf(setState);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  }, [state]);
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId) => dispatch({ type: "DISMISS_TOAST", toastId })
+  };
+}
+
+// src/components/DataTable/utils/performanceUtils.ts
+function determinePaginationMode(dataLength, serverSideThreshold = 1e4) {
+  if (dataLength <= 1e3) return "client";
+  return "hybrid";
+}
+function getOptimalPageSizeOptions(mode, dataLength) {
+  switch (mode) {
+    case "client":
+      return dataLength <= 100 ? [10, 25, 50] : [10, 25, 50, 100];
+    case "hybrid":
+      return [50, 100, 250, 500];
+    case "server":
+      return [25, 50, 100, 250];
+    default:
+      return [10, 25, 50, 100];
+  }
+}
+function chunkData(data, chunkSize) {
+  const chunks = [];
+  for (let i = 0; i < data.length; i += chunkSize) {
+    chunks.push(data.slice(i, i + chunkSize));
+  }
+  return chunks;
+}
+var DataChunkManager = class {
+  constructor(config) {
+    this.chunks = /* @__PURE__ */ new Map();
+    this.accessOrder = [];
+    this.maxChunks = config.maxChunksInMemory;
+    this.chunkSize = config.chunkSize;
+  }
+  getChunk(chunkIndex, allData) {
+    if (this.chunks.has(chunkIndex)) {
+      this.updateAccessOrder(chunkIndex);
+      return this.chunks.get(chunkIndex);
+    }
+    const startIndex = chunkIndex * this.chunkSize;
+    const endIndex = Math.min(startIndex + this.chunkSize, allData.length);
+    const chunk = allData.slice(startIndex, endIndex);
+    this.addChunk(chunkIndex, chunk);
+    return chunk;
+  }
+  addChunk(chunkIndex, chunk) {
+    if (this.chunks.size >= this.maxChunks && !this.chunks.has(chunkIndex)) {
+      const oldestChunk = this.accessOrder.shift();
+      if (oldestChunk !== void 0) {
+        this.chunks.delete(oldestChunk);
+      }
+    }
+    this.chunks.set(chunkIndex, chunk);
+    this.updateAccessOrder(chunkIndex);
+  }
+  updateAccessOrder(chunkIndex) {
+    const existingIndex = this.accessOrder.indexOf(chunkIndex);
+    if (existingIndex > -1) {
+      this.accessOrder.splice(existingIndex, 1);
+    }
+    this.accessOrder.push(chunkIndex);
+  }
+  clear() {
+    this.chunks.clear();
+    this.accessOrder = [];
+  }
+  getMemoryUsage() {
+    let totalSize = 0;
+    for (const chunk of this.chunks.values()) {
+      totalSize += JSON.stringify(chunk).length;
+    }
+    return totalSize / (1024 * 1024);
+  }
+};
+var SearchIndex = class {
+  constructor(config) {
+    this.index = /* @__PURE__ */ new Map();
+    this.data = [];
+    this.indexedFields = config.indexedFields;
+    this.fuzzySearch = config.fuzzySearch ?? false;
+    this.fuzzyThreshold = config.fuzzyThreshold ?? 0.6;
+  }
+  buildIndex(data) {
+    this.data = data;
+    this.index.clear();
+    data.forEach((row, rowIndex) => {
+      this.indexedFields.forEach((field) => {
+        const value = this.getNestedValue(row, field);
+        if (value != null) {
+          const searchableText = String(value).toLowerCase();
+          const words = this.tokenize(searchableText);
+          words.forEach((word) => {
+            if (!this.index.has(word)) {
+              this.index.set(word, /* @__PURE__ */ new Set());
+            }
+            this.index.get(word).add(rowIndex);
+          });
+        }
+      });
+    });
+  }
+  search(query) {
+    if (!query.trim()) return [];
+    const searchTerms = this.tokenize(query.toLowerCase());
+    const matchingSets = [];
+    searchTerms.forEach((term) => {
+      const matches = /* @__PURE__ */ new Set();
+      if (this.index.has(term)) {
+        this.index.get(term).forEach((index) => matches.add(index));
+      }
+      if (this.fuzzySearch) {
+        for (const [indexedTerm, indices] of this.index.entries()) {
+          if (this.calculateSimilarity(term, indexedTerm) >= this.fuzzyThreshold) {
+            indices.forEach((index) => matches.add(index));
+          }
+        }
+      }
+      matchingSets.push(matches);
+    });
+    if (matchingSets.length === 0) return [];
+    let result = matchingSets[0];
+    for (let i = 1; i < matchingSets.length; i++) {
+      result = new Set([...result].filter((x) => matchingSets[i].has(x)));
+    }
+    return Array.from(result);
+  }
+  getNestedValue(obj, path) {
+    return path.split(".").reduce((current, key) => current?.[key], obj);
+  }
+  tokenize(text) {
+    return text.replace(/[^\w\s]/g, " ").split(/\s+/).filter((word) => word.length > 0);
+  }
+  calculateSimilarity(str1, str2) {
+    const longer = str1.length > str2.length ? str1 : str2;
+    const shorter = str1.length > str2.length ? str2 : str1;
+    if (longer.length === 0) return 1;
+    const editDistance = this.levenshteinDistance(longer, shorter);
+    return (longer.length - editDistance) / longer.length;
+  }
+  levenshteinDistance(str1, str2) {
+    const matrix = Array(str2.length + 1).fill(null).map(
+      () => Array(str1.length + 1).fill(null)
+    );
+    for (let i = 0; i <= str1.length; i++) matrix[0][i] = i;
+    for (let j = 0; j <= str2.length; j++) matrix[j][0] = j;
+    for (let j = 1; j <= str2.length; j++) {
+      for (let i = 1; i <= str1.length; i++) {
+        const substitutionCost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+        matrix[j][i] = Math.min(
+          matrix[j][i - 1] + 1,
+          // insertion
+          matrix[j - 1][i] + 1,
+          // deletion
+          matrix[j - 1][i - 1] + substitutionCost
+          // substitution
+        );
+      }
+    }
+    return matrix[str2.length][str1.length];
+  }
+};
+function debounce(func, delay) {
+  let timeoutId;
+  return (...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => func(...args), delay);
+  };
+}
+function throttle(func, delay) {
+  let lastCall = 0;
+  return (...args) => {
+    const now = Date.now();
+    if (now - lastCall >= delay) {
+      lastCall = now;
+      func(...args);
+    }
+  };
+}
+var VisibilityTracker = class {
+  constructor() {
+    this.observer = null;
+    this.visibleElements = /* @__PURE__ */ new Set();
+    this.callbacks = /* @__PURE__ */ new Set();
+    if (typeof IntersectionObserver !== "undefined") {
+      this.observer = new IntersectionObserver(
+        (entries) => {
+          entries.forEach((entry) => {
+            if (entry.isIntersecting) {
+              this.visibleElements.add(entry.target);
+            } else {
+              this.visibleElements.delete(entry.target);
+            }
+          });
+          this.callbacks.forEach((callback) => {
+            callback(this.visibleElements.size);
+          });
+        },
+        { threshold: 0.1 }
+      );
+    }
+  }
+  observe(element) {
+    this.observer?.observe(element);
+  }
+  unobserve(element) {
+    this.observer?.unobserve(element);
+    this.visibleElements.delete(element);
+  }
+  onVisibilityChange(callback) {
+    this.callbacks.add(callback);
+    return () => this.callbacks.delete(callback);
+  }
+  getVisibleCount() {
+    return this.visibleElements.size;
+  }
+  destroy() {
+    this.observer?.disconnect();
+    this.visibleElements.clear();
+    this.callbacks.clear();
+  }
+};
+
+// src/components/DataTable/utils/errorHandling.ts
+var DEFAULT_FALLBACK_CONFIG = {
+  enabled: false
+};
+var DataTableErrorType = /* @__PURE__ */ ((DataTableErrorType3) => {
+  DataTableErrorType3["VIRTUALIZATION"] = "virtualization";
+  DataTableErrorType3["SEARCH_INDEX"] = "search_index";
+  DataTableErrorType3["DATA_CHUNK"] = "data_chunk";
+  DataTableErrorType3["SERVER_FETCH"] = "server_fetch";
+  DataTableErrorType3["MEMORY"] = "memory";
+  return DataTableErrorType3;
+})(DataTableErrorType || {});
+var DataTableError = class extends Error {
+  constructor(message, type, recoverable = true) {
+    super(message);
+    this.type = type;
+    this.recoverable = recoverable;
+    this.name = "DataTableError";
+  }
+};
+var ErrorRecoveryManager = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async handleError(error) {
+    return { recovered: false, strategy: null };
+  }
+  clearErrorLog() {
+  }
+};
+var MemoryMonitor = class {
+  constructor(threshold = 100) {
+    this.threshold = threshold;
+  }
+  getCurrentUsage() {
+    return 0;
+  }
+  checkThreshold() {
+    return true;
+  }
+  stopMonitoring() {
+  }
+};
+var CircuitBreaker = class {
+  constructor() {
+  }
+  isOpen() {
+    return false;
+  }
+  recordSuccess() {
+  }
+  recordFailure() {
+  }
+  reset() {
+  }
+};
+function safeExecute(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+
+// src/hooks/useDataTablePerformance.ts
+import { useState as useState2, useEffect as useEffect2, useCallback, useMemo, useRef } from "react";
+function useDataTablePerformance({
+  data,
+  performance = {},
+  serverSide,
+  chunking,
+  searchIndex,
+  fallbackConfig = DEFAULT_FALLBACK_CONFIG,
+  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({
+    hasErrors: false,
+    errorCount: 0,
+    lastError: null,
+    fallbacksActive: []
+  });
+  const [lastFailedOperation, setLastFailedOperation] = useState2(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());
+  const paginationMode = useMemo(() => {
+    if (serverSide) return "server";
+    return determinePaginationMode(data?.length || 0, performance.serverSideThreshold);
+  }, [data?.length, performance.serverSideThreshold, serverSide]);
+  const isVirtualized = false;
+  const pageSizeOptions = useMemo(() => {
+    return getOptimalPageSizeOptions(paginationMode, data?.length || 0);
+  }, [paginationMode, data?.length]);
+  const processedData = useMemo(() => {
+    if (serverSide && serverData) {
+      return serverData.data;
+    }
+    let filteredData = data;
+    if (searchQuery && searchResults.length > 0) {
+      filteredData = searchResults.map((index) => data[index]);
+    }
+    return filteredData;
+  }, [data, serverData, searchQuery, searchResults, serverSide]);
+  const totalCount = useMemo(() => {
+    if (serverSide && serverData) {
+      return serverData.totalCount;
+    }
+    return processedData?.length || 0;
+  }, [serverData, processedData?.length, serverSide]);
+  useEffect2(() => {
+    if (chunking && !chunkManagerRef.current) {
+      chunkManagerRef.current = new DataChunkManager(chunking);
+    }
+  }, [chunking]);
+  useEffect2(() => {
+    if (searchIndex && !searchIndexRef.current) {
+      searchIndexRef.current = new SearchIndex(searchIndex);
+    }
+    if (searchIndexRef.current && data.length > 0) {
+      searchIndexRef.current.buildIndex(data);
+    }
+  }, [searchIndex, data]);
+  const debouncedSearch = useCallback(
+    debounce((query) => {
+      if (!searchIndexRef.current) return;
+      if (!query.trim()) {
+        setSearchResults([]);
+        return;
+      }
+      const results = searchIndexRef.current.search(query);
+      setSearchResults(results);
+    }, performance.debounceSearch ?? 300),
+    [performance.debounceSearch]
+  );
+  useEffect2(() => {
+    debouncedSearch(searchQuery);
+  }, [searchQuery, debouncedSearch]);
+  const fetchServerData = useCallback(async (params) => {
+    if (!serverSide) return;
+    setIsLoading(true);
+    try {
+      const response = await serverSide.fetchData(params);
+      setServerData(response);
+    } catch (error) {
+      console.error("Failed to fetch server data:", error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [serverSide]);
+  useEffect2(() => {
+    if (!visibilityTrackerRef.current) {
+      visibilityTrackerRef.current = new VisibilityTracker();
+    }
+    const tracker = visibilityTrackerRef.current;
+    const unsubscribe = tracker.onVisibilityChange((visibleCount) => {
+    });
+    return unsubscribe;
+  }, [totalCount, isVirtualized, paginationMode]);
+  useEffect2(() => {
+    const updateMemoryUsage = () => {
+      let usage = 0;
+      if (chunkManagerRef.current) {
+        usage += chunkManagerRef.current.getMemoryUsage();
+      }
+      usage += JSON.stringify(processedData || []).length / (1024 * 1024);
+      setMemoryUsage(usage);
+    };
+    updateMemoryUsage();
+    const interval = import.meta.env.MODE !== "test" ? setInterval(updateMemoryUsage, 5e3) : null;
+    return () => {
+      if (interval) {
+        clearInterval(interval);
+      }
+    };
+  }, [processedData]);
+  const handleError = useCallback(async (error, operation) => {
+    if (enableErrorRecovery) {
+      try {
+        const recovery = await errorRecoveryManagerRef.current.handleError(error);
+        setErrorState((prev) => ({
+          hasErrors: true,
+          errorCount: prev.errorCount + 1,
+          lastError: error,
+          fallbacksActive: [...prev.fallbacksActive, error.type]
+        }));
+        if (operation) {
+          setLastFailedOperation(() => operation);
+        }
+        onError?.(error);
+        return recovery;
+      } catch (recoveryError) {
+        console.error("Error recovery failed:", recoveryError);
+      }
+    }
+    throw error;
+  }, [enableErrorRecovery, onError]);
+  const retryLastOperation = useCallback(async () => {
+    if (lastFailedOperation) {
+      try {
+        await lastFailedOperation();
+        setLastFailedOperation(null);
+        setErrorState((prev) => ({ ...prev, hasErrors: false }));
+      } catch (error) {
+        console.error("Retry failed:", error);
+      }
+    }
+  }, [lastFailedOperation]);
+  const clearErrors = useCallback(() => {
+    setErrorState({
+      hasErrors: false,
+      errorCount: 0,
+      lastError: null,
+      fallbacksActive: []
+    });
+    setLastFailedOperation(null);
+    errorRecoveryManagerRef.current.clearErrorLog();
+  }, []);
+  const cleanup = useCallback(() => {
+    chunkManagerRef.current?.clear();
+    visibilityTrackerRef.current?.destroy();
+    memoryMonitorRef.current?.stopMonitoring();
+  }, []);
+  useEffect2(() => {
+    return cleanup;
+  }, [cleanup]);
+  return {
+    // Performance state
+    paginationMode,
+    isVirtualized,
+    pageSizeOptions,
+    // Data management
+    processedData,
+    totalCount,
+    isLoading,
+    // Search functionality
+    searchQuery,
+    setSearchQuery,
+    searchResults,
+    // Server-side functionality
+    fetchServerData,
+    serverData,
+    // Performance monitoring
+    memoryUsage,
+    // Error handling and recovery
+    errorState,
+    retryLastOperation,
+    clearErrors,
+    // Cleanup
+    cleanup
+  };
+}
+
+export {
+  toast,
+  useToast,
+  determinePaginationMode,
+  getOptimalPageSizeOptions,
+  chunkData,
+  DataChunkManager,
+  SearchIndex,
+  debounce,
+  throttle,
+  VisibilityTracker,
+  DEFAULT_FALLBACK_CONFIG,
+  DataTableErrorType,
+  DataTableError,
+  ErrorRecoveryManager,
+  MemoryMonitor,
+  CircuitBreaker,
+  safeExecute,
+  useDataTablePerformance
+};
+//# sourceMappingURL=chunk-GKHF54DI.js.map