@jmruthers/pace-core 0.2.4

package/dist/chunk-SS3E6QLB.js

@@ -0,0 +1,695 @@
+// src/components/DataTable/utils/performanceUtils.ts
+function determinePaginationMode(dataLength, serverSideThreshold = 1e4) {
+  if (dataLength <= 1e3) return "client";
+  if (dataLength <= serverSideThreshold) return "hybrid";
+  return "server";
+}
+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/hooks/useDataTablePerformance.ts
+import { useState, useEffect, useCallback, useMemo, useRef } from "react";
+
+// src/components/DataTable/utils/errorHandling.ts
+var DataTableError = class extends Error {
+  constructor(message, type, context, recoverable = true) {
+    super(message);
+    this.name = "DataTableError";
+    this.type = type;
+    this.timestamp = Date.now();
+    this.context = context;
+    this.recoverable = recoverable;
+  }
+};
+var DEFAULT_FALLBACK_CONFIG = {
+  fallbackPaginationMode: "client",
+  fallbackPageSizeOptions: [10, 25, 50],
+  maxRetries: 3,
+  retryDelay: 1e3,
+  maxMemoryUsage: 100,
+  // 100MB
+  enableGracefulDegradation: true
+};
+var VirtualizationErrorRecovery = class {
+  canRecover(error) {
+    return error.type === "VIRTUALIZATION_ERROR" /* VIRTUALIZATION_ERROR */ && error.recoverable;
+  }
+  recover(error) {
+    console.warn("Virtualization failed, falling back to standard rendering:", error.message);
+    return {
+      enableVirtualization: false,
+      fallbackMessage: "Virtual scrolling disabled due to compatibility issues"
+    };
+  }
+  getFallback() {
+    return {
+      enableVirtualization: false,
+      height: 400,
+      overscan: 0
+    };
+  }
+};
+var SearchIndexErrorRecovery = class {
+  canRecover(error) {
+    return error.type === "SEARCH_INDEX_ERROR" /* SEARCH_INDEX_ERROR */ && error.recoverable;
+  }
+  recover(error) {
+    console.warn("Search indexing failed, falling back to basic search:", error.message);
+    return {
+      enableSearchIndex: false,
+      fallbackMessage: "Advanced search disabled, using basic text search"
+    };
+  }
+  getFallback() {
+    return {
+      enableSearchIndex: false,
+      fuzzySearch: false
+    };
+  }
+};
+var DataChunkErrorRecovery = class {
+  canRecover(error) {
+    return error.type === "DATA_CHUNK_ERROR" /* DATA_CHUNK_ERROR */ && error.recoverable;
+  }
+  recover(error) {
+    console.warn("Data chunking failed, loading all data:", error.message);
+    return {
+      enableChunking: false,
+      fallbackMessage: "Memory optimization disabled, all data loaded"
+    };
+  }
+  getFallback() {
+    return {
+      enableChunking: false,
+      chunkSize: Number.MAX_SAFE_INTEGER
+    };
+  }
+};
+var ServerFetchErrorRecovery = class {
+  constructor(config = DEFAULT_FALLBACK_CONFIG) {
+    this.retryCount = 0;
+    this.maxRetries = config.maxRetries;
+    this.retryDelay = config.retryDelay;
+  }
+  canRecover(error) {
+    return error.type === "SERVER_FETCH_ERROR" /* SERVER_FETCH_ERROR */ && this.retryCount < this.maxRetries;
+  }
+  async recover(error, retryFn) {
+    this.retryCount++;
+    const delay = this.retryDelay * Math.pow(2, this.retryCount - 1);
+    console.warn(`Server fetch failed, retrying in ${delay}ms (attempt ${this.retryCount}/${this.maxRetries}):`, error.message);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    if (retryFn) {
+      try {
+        const result = await retryFn();
+        this.retryCount = 0;
+        return result;
+      } catch (retryError) {
+        if (this.retryCount >= this.maxRetries) {
+          throw new DataTableError(
+            "Max retry attempts exceeded",
+            "SERVER_FETCH_ERROR" /* SERVER_FETCH_ERROR */,
+            { originalError: error, retryCount: this.retryCount },
+            false
+          );
+        }
+        return this.recover(error, retryFn);
+      }
+    }
+    return this.getFallback(error);
+  }
+  getFallback(error) {
+    return {
+      paginationMode: "client",
+      fallbackMessage: "Server unavailable, switched to client-side mode",
+      data: [],
+      totalCount: 0
+    };
+  }
+};
+var MemoryErrorRecovery = class {
+  constructor(config = DEFAULT_FALLBACK_CONFIG) {
+    this.maxMemoryUsage = config.maxMemoryUsage;
+  }
+  canRecover(error) {
+    return error.type === "MEMORY_ERROR" /* MEMORY_ERROR */;
+  }
+  recover(error) {
+    console.warn("Memory usage too high, enabling aggressive optimizations:", error.message);
+    return {
+      enableChunking: true,
+      chunkSize: 100,
+      // Smaller chunks
+      maxChunksInMemory: 2,
+      // Fewer chunks in memory
+      enableVirtualization: true,
+      fallbackMessage: "Memory optimization enabled to reduce usage"
+    };
+  }
+  getFallback() {
+    return {
+      paginationMode: "server",
+      enableChunking: true,
+      chunkSize: 50,
+      maxChunksInMemory: 1
+    };
+  }
+};
+var ErrorRecoveryManager = class {
+  constructor(config = DEFAULT_FALLBACK_CONFIG) {
+    this.strategies = /* @__PURE__ */ new Map();
+    this.errorLog = [];
+    this.maxErrorLogSize = 100;
+    this.strategies.set("VIRTUALIZATION_ERROR" /* VIRTUALIZATION_ERROR */, new VirtualizationErrorRecovery());
+    this.strategies.set("SEARCH_INDEX_ERROR" /* SEARCH_INDEX_ERROR */, new SearchIndexErrorRecovery());
+    this.strategies.set("DATA_CHUNK_ERROR" /* DATA_CHUNK_ERROR */, new DataChunkErrorRecovery());
+    this.strategies.set("SERVER_FETCH_ERROR" /* SERVER_FETCH_ERROR */, new ServerFetchErrorRecovery(config));
+    this.strategies.set("MEMORY_ERROR" /* MEMORY_ERROR */, new MemoryErrorRecovery(config));
+  }
+  /**
+   * Handle error with appropriate recovery strategy
+   */
+  async handleError(error, context) {
+    this.logError(error);
+    const strategy = this.strategies.get(error.type);
+    if (!strategy) {
+      console.error("No recovery strategy found for error type:", error.type);
+      throw error;
+    }
+    if (strategy.canRecover(error)) {
+      try {
+        return await strategy.recover(error, context);
+      } catch (recoveryError) {
+        console.error("Recovery failed:", recoveryError);
+        return strategy.getFallback(error);
+      }
+    }
+    return strategy.getFallback(error);
+  }
+  /**
+   * Log error for debugging and monitoring
+   */
+  logError(error) {
+    this.errorLog.push(error);
+    if (this.errorLog.length > this.maxErrorLogSize) {
+      this.errorLog.shift();
+    }
+    console.error("DataTable Error:", {
+      type: error.type,
+      message: error.message,
+      timestamp: new Date(error.timestamp).toISOString(),
+      context: error.context,
+      recoverable: error.recoverable
+    });
+  }
+  /**
+   * Get error statistics for monitoring
+   */
+  getErrorStats() {
+    const errorsByType = {};
+    for (const error of this.errorLog) {
+      errorsByType[error.type] = (errorsByType[error.type] || 0) + 1;
+    }
+    return {
+      totalErrors: this.errorLog.length,
+      errorsByType,
+      recentErrors: this.errorLog.slice(-10)
+      // Last 10 errors
+    };
+  }
+  /**
+   * Clear error log
+   */
+  clearErrorLog() {
+    this.errorLog = [];
+  }
+};
+var CircuitBreaker = class {
+  constructor(failureThreshold = 5, timeout = 6e4) {
+    this.failureThreshold = failureThreshold;
+    this.timeout = timeout;
+    this.failureCount = 0;
+    this.lastFailureTime = 0;
+    this.state = "CLOSED";
+  }
+  async execute(operation) {
+    if (this.state === "OPEN") {
+      if (Date.now() - this.lastFailureTime > this.timeout) {
+        this.state = "HALF_OPEN";
+      } else {
+        throw new DataTableError(
+          "Circuit breaker is OPEN",
+          "SERVER_FETCH_ERROR" /* SERVER_FETCH_ERROR */,
+          { state: this.state, failureCount: this.failureCount },
+          false
+        );
+      }
+    }
+    try {
+      const result = await operation();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+  onSuccess() {
+    this.failureCount = 0;
+    this.state = "CLOSED";
+  }
+  onFailure() {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+    if (this.failureCount >= this.failureThreshold) {
+      this.state = "OPEN";
+    }
+  }
+  getState() {
+    return {
+      state: this.state,
+      failureCount: this.failureCount,
+      lastFailureTime: this.lastFailureTime
+    };
+  }
+};
+
+// src/hooks/useDataTablePerformance.ts
+function useDataTablePerformance({
+  data,
+  performance: performance2 = {},
+  serverSide,
+  chunking,
+  searchIndex,
+  fallbackConfig = DEFAULT_FALLBACK_CONFIG,
+  onError,
+  enableErrorRecovery = true
+}) {
+  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] = 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());
+  const paginationMode = useMemo(() => {
+    if (serverSide) return "server";
+    return determinePaginationMode(data?.length || 0, performance2.serverSideThreshold);
+  }, [data?.length, performance2.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]);
+  useEffect(() => {
+    if (chunking && !chunkManagerRef.current) {
+      chunkManagerRef.current = new DataChunkManager(chunking);
+    }
+  }, [chunking]);
+  useEffect(() => {
+    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);
+    }, performance2.debounceSearch ?? 300),
+    [performance2.debounceSearch]
+  );
+  useEffect(() => {
+    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]);
+  useEffect(() => {
+    if (!visibilityTrackerRef.current) {
+      visibilityTrackerRef.current = new VisibilityTracker();
+    }
+    const tracker = visibilityTrackerRef.current;
+    const unsubscribe = tracker.onVisibilityChange((visibleCount) => {
+    });
+    return unsubscribe;
+  }, [totalCount, isVirtualized, paginationMode]);
+  useEffect(() => {
+    const updateMemoryUsage = () => {
+      let usage = 0;
+      if (chunkManagerRef.current) {
+        usage += chunkManagerRef.current.getMemoryUsage();
+      }
+      usage += JSON.stringify(processedData || []).length / (1024 * 1024);
+      setMemoryUsage(usage);
+    };
+    updateMemoryUsage();
+    const interval = typeof process !== "undefined" && true ? 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();
+  }, []);
+  useEffect(() => {
+    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 {
+  determinePaginationMode,
+  getOptimalPageSizeOptions,
+  chunkData,
+  DataChunkManager,
+  SearchIndex,
+  debounce,
+  throttle,
+  VisibilityTracker,
+  useDataTablePerformance
+};
+//# sourceMappingURL=chunk-SS3E6QLB.js.map