@jmruthers/pace-core 0.5.193 → 0.6.2

package/dist/chunk-6C4YBBJM.js

@@ -1,628 +0,0 @@
-import {
-  logger
-} from "./chunk-PWLANIRT.js";
-
-// 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) => {
-      if (current && typeof current === "object" && key in current) {
-        return current[key];
-      }
-      return void 0;
-    }, 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) {
-      logger.error("useDataTablePerformance", "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) {
-        logger.error("useDataTablePerformance", "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) {
-        logger.error("useDataTablePerformance", "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-6C4YBBJM.js.map