@jmruthers/pace-core 0.5.190 → 0.5.193

package/dist/chunk-6C4YBBJM 5.js

@@ -0,0 +1,628 @@
+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

package/dist/chunk-7D4SUZUM.js 2.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}