@codella-software/react 2.2.27 → 2.3.0

package/dist/filters-and-sort/useFiltersAndSort.d.ts

@@ -1,37 +1,76 @@
-import { FiltersAndSortService } from '@codella-software/utils';
+import { FiltersAndSortService, FilterAndSortState, SortDirection } from '@codella-software/utils';
+/**
+ * Configuration for creating a new FiltersAndSortService instance
+ */
+export interface FiltersAndSortConfig<T extends Record<string, any> = Record<string, any>> {
+    /** Unique storage key for persistence */
+    storageKey: string;
+    /** Whether to persist state to storage (default: true) */
+    persistToStorage?: boolean;
+    /** Initial state override */
+    initialState?: Partial<FilterAndSortState<T>>;
+    /** Default filter values used when clearing filters */
+    defaultFilters?: T;
+    /** Skip hydrating state from storage on init */
+    skipStorageHydration?: boolean;
+    /** Debounce time for storage persistence in ms (default: 300) */
+    storageDebounceMs?: number;
+    /** Optional storage key prefix */
+    storageKeyPrefix?: string;
+}
 /**
  * Hook options for useFiltersAndSort
  */
-export interface UseFiltersAndSortOptions {
-    /** FiltersAndSortService instance */
-    service: FiltersAndSortService;
+export interface UseFiltersAndSortOptions<T extends Record<string, any> = Record<string, any>> {
+    /** An existing FiltersAndSortService instance to use */
+    service?: FiltersAndSortService<T>;
+    /** Configuration to create a new service instance (mutually exclusive with service) */
+    config?: FiltersAndSortConfig<T>;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom equality function for state comparison */
+    isEqual?: (prev: FilterAndSortState<T>, next: FilterAndSortState<T>) => boolean;
 }
 /**
  * Hook return value for useFiltersAndSort
  */
-export interface UseFiltersAndSortReturn {
+export interface UseFiltersAndSortReturn<T extends Record<string, any> = Record<string, any>> {
     /** Current filter state */
-    filters: Record<string, any>;
+    filters: T;
     /** Current sort field */
     sortBy: string | null;
     /** Current sort direction */
-    sortDirection: 'asc' | 'desc';
+    sortDirection: SortDirection;
     /** Current page (0-based) */
     page: number;
     /** Page size */
     pageSize: number;
     /** Current search query */
     query: string;
-    /** Set filter */
-    setFilter: (key: string, value: any) => void;
-    /** Clear specific filter */
-    clearFilter: (key: string) => void;
-    /** Clear all filters */
+    /** Full state object for advanced use cases */
+    state: FilterAndSortState<T>;
+    /** Set a single filter value */
+    setFilter: <K extends keyof T>(key: K, value: T[K]) => void;
+    /** Set multiple filters at once */
+    setFilters: (filters: Partial<T>) => void;
+    /** Clear a specific filter */
+    clearFilter: <K extends keyof T>(key: K) => void;
+    /** Clear all filters (resets to defaultFilters) */
     clearAllFilters: () => void;
+    /** Check if a specific filter is active */
+    hasFilter: <K extends keyof T>(key: K) => boolean;
+    /** Check if any filters are active */
+    hasAnyFilters: () => boolean;
+    /** Get count of active filters */
+    activeFilterCount: number;
     /** Set/toggle sort (auto-toggles between asc -> desc -> none) */
     setSort: (field: string) => void;
     /** Toggle sort direction for field (alias for setSort) */
     toggleSort: (field: string) => void;
+    /** Clear current sort */
+    clearSort: () => void;
+    /** Check if a field is currently sorted */
+    isSortedBy: (field: string) => boolean;
     /** Set page */
     setPage: (page: number) => void;
     /** Set page size */
@@ -40,34 +79,78 @@ export interface UseFiltersAndSortReturn {
     nextPage: () => void;
     /** Go to previous page */
     prevPage: () => void;
+    /** Go to first page */
+    firstPage: () => void;
+    /** Check if on first page */
+    isFirstPage: boolean;
+    /** Calculate offset for API requests */
+    offset: number;
     /** Set search query */
     setQuery: (query: string) => void;
+    /** Clear search query */
+    clearQuery: () => void;
     /** Reset to initial state */
     reset: () => void;
+    /** Clear storage and reset */
+    clearStorageAndReset: () => void;
+    /** Get the storage key being used */
+    storageKey: string;
+    /** Direct access to the underlying service (for advanced use cases) */
+    getService: () => FiltersAndSortService<T>;
 }
 /**
- * React hook that wraps FiltersAndSortService
+ * React hook that wraps FiltersAndSortService with enhanced functionality
  *
- * @param options - Hook options including FiltersAndSortService instance
+ * @typeParam T - The filters object type
+ * @param options - Hook options including service instance or config
  * @returns Filters and sort state with control methods
  *
  * @example
  * ```tsx
- * const service = new FiltersAndSortService({ storageKey: 'my-filters' });
+ * // Option 1: Create service externally (recommended for sharing between components)
+ * const service = new FiltersAndSortService<MyFilters>({ storageKey: 'my-filters' });
  *
  * function MyTable() {
- *   const filters = useFiltersAndSort({ service });
+ *   const {
+ *     filters,
+ *     setFilter,
+ *     clearAllFilters,
+ *     hasAnyFilters,
+ *     activeFilterCount
+ *   } = useFiltersAndSort({ service });
+ *
  *   return (
  *     <div>
  *       <input
- *         value={filters.filters.name || ''}
- *         onChange={(e) => filters.setFilter('name', e.target.value)}
+ *         value={filters.name || ''}
+ *         onChange={(e) => setFilter('name', e.target.value)}
  *       />
- *       <button onClick={() => filters.clearAllFilters()}>Clear</button>
+ *       {hasAnyFilters() && (
+ *         <button onClick={clearAllFilters}>
+ *           Clear ({activeFilterCount})
+ *         </button>
+ *       )}
  *     </div>
  *   );
  * }
+ *
+ * // Option 2: Let the hook create the service (simpler for single-component use)
+ * function SimpleTable() {
+ *   const filters = useFiltersAndSort({
+ *     config: {
+ *       storageKey: 'simple-table',
+ *       defaultFilters: { status: 'all' }
+ *     }
+ *   });
+ *   // ...
+ * }
  * ```
  */
-export declare function useFiltersAndSort(options: UseFiltersAndSortOptions): UseFiltersAndSortReturn;
+export declare function useFiltersAndSort<T extends Record<string, any> = Record<string, any>>(options: UseFiltersAndSortOptions<T>): UseFiltersAndSortReturn<T>;
+/**
+ * Convenience hook for creating a filters service with simpler API
+ * Equivalent to useFiltersAndSort({ config: ... })
+ */
+export declare function useFilters<T extends Record<string, any> = Record<string, any>>(storageKey: string, options?: Omit<FiltersAndSortConfig<T>, 'storageKey'>): UseFiltersAndSortReturn<T>;
+export type { FilterAndSortState, SortDirection };
 //# sourceMappingURL=useFiltersAndSort.d.ts.map

package/dist/filters-and-sort/useFiltersAndSort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useFiltersAndSort.d.ts","sourceRoot":"","sources":["../../src/filters-and-sort/useFiltersAndSort.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAA2B,MAAM,yBAAyB,CAAA;AAGxF;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,qCAAqC;IACrC,OAAO,EAAE,qBAAqB,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC5B,yBAAyB;IACzB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,6BAA6B;IAC7B,aAAa,EAAE,KAAK,GAAG,MAAM,CAAA;IAC7B,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,iBAAiB;IACjB,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;IAC5C,4BAA4B;IAC5B,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IAClC,wBAAwB;IACxB,eAAe,EAAE,MAAM,IAAI,CAAA;IAC3B,iEAAiE;IACjE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAChC,0DAA0D;IAC1D,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,eAAe;IACf,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/B,oBAAoB;IACpB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,sBAAsB;IACtB,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,uBAAuB;IACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,6BAA6B;IAC7B,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,wBAAwB,GAChC,uBAAuB,CAkFzB"}
+{"version":3,"file":"useFiltersAndSort.d.ts","sourceRoot":"","sources":["../../src/filters-and-sort/useFiltersAndSort.ts"],"names":[],"mappings":"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"}

package/dist/index.cjs

@@ -1,77 +1,298 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@codella-software/utils");
 const react = require("react");
 const jsxRuntime = require("react/jsx-runtime");
 const liveUpdates = require("@codella-software/utils/live-updates");
 const richContent = require("@codella-software/utils/rich-content");
 const tabs = require("@codella-software/utils/tabs");
+function defaultIsEqual(prev, next) {
+  if (prev === next) return true;
+  if (prev.query !== next.query) return false;
+  if (prev.pagination.page !== next.pagination.page) return false;
+  if (prev.pagination.limit !== next.pagination.limit) return false;
+  const prevSort = prev.sort;
+  const nextSort = next.sort;
+  if ((prevSort == null ? void 0 : prevSort.fieldName) !== (nextSort == null ? void 0 : nextSort.fieldName)) return false;
+  if ((prevSort == null ? void 0 : prevSort.direction) !== (nextSort == null ? void 0 : nextSort.direction)) return false;
+  const prevFilters = prev.filters;
+  const nextFilters = next.filters;
+  const prevKeys = Object.keys(prevFilters);
+  const nextKeys = Object.keys(nextFilters);
+  if (prevKeys.length !== nextKeys.length) return false;
+  for (const key of prevKeys) {
+    if (prevFilters[key] !== nextFilters[key]) return false;
+  }
+  return true;
+}
+function countActiveFilters(filters, defaultFilters) {
+  let count = 0;
+  const keys = Object.keys(filters);
+  for (const key of keys) {
+    const value = filters[key];
+    const defaultValue = defaultFilters == null ? void 0 : defaultFilters[key];
+    const isDefault = value === defaultValue;
+    const isEmpty = value === null || value === void 0 || value === "";
+    const isEmptyArray = Array.isArray(value) && value.length === 0;
+    if (!isEmpty && !isEmptyArray && !isDefault) {
+      count++;
+    }
+  }
+  return count;
+}
 function useFiltersAndSort(options) {
-  const { service } = options;
-  if (!service) {
-    throw new Error("useFiltersAndSort: service is required");
+  const { service: externalService, config, debug = false, isEqual = defaultIsEqual } = options;
+  if (!externalService && !config) {
+    throw new Error(
+      "useFiltersAndSort: either `service` or `config` must be provided. Pass an existing FiltersAndSortService instance via `service`, or provide a `config` object to create a new service."
+    );
   }
-  const [state, setState] = react.useState(() => {
-    return service.getCurrentState();
-  });
+  if (externalService && config) {
+    if (debug) {
+      console.warn(
+        "useFiltersAndSort: both `service` and `config` were provided. The `service` will be used and `config` will be ignored."
+      );
+    }
+  }
+  const ownsServiceRef = react.useRef(false);
+  const serviceRef = react.useRef(null);
+  const isEqualRef = react.useRef(isEqual);
   react.useEffect(() => {
-    if (!service) {
-      return;
+    isEqualRef.current = isEqual;
+  }, [isEqual]);
+  if (!serviceRef.current) {
+    if (externalService) {
+      serviceRef.current = externalService;
+      ownsServiceRef.current = false;
+    } else if (config) {
+      serviceRef.current = new utils.FiltersAndSortService({
+        storageKey: config.storageKey,
+        persistToStorage: config.persistToStorage,
+        initialState: config.initialState,
+        defaultFilters: config.defaultFilters,
+        skipStorageHydration: config.skipStorageHydration,
+        storageDebounceMs: config.storageDebounceMs,
+        storageKeyPrefix: config.storageKeyPrefix
+      });
+      ownsServiceRef.current = true;
+      if (debug) {
+        console.log(`useFiltersAndSort: created service with key "${config.storageKey}"`);
+      }
     }
-    const subscription = service.getState().subscribe((newState) => {
-      setState(newState);
+  }
+  const svc = serviceRef.current;
+  const defaultFiltersRef = react.useRef(config == null ? void 0 : config.defaultFilters);
+  const subscribe = react.useCallback(
+    (onStoreChange) => {
+      const subscription = svc.getState().subscribe(() => {
+        onStoreChange();
+      });
+      return () => subscription.unsubscribe();
+    },
+    [svc]
+  );
+  const getSnapshot = react.useCallback(() => svc.getCurrentState(), [svc]);
+  const getServerSnapshot = react.useCallback(() => svc.getDefaultState(), [svc]);
+  const state = react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  react.useEffect(() => {
+    if (!debug) return;
+    const sub = svc.getState().subscribe((newState) => {
+      console.log(`useFiltersAndSort [${svc.getStorageKey()}]:`, newState);
     });
-    return () => subscription.unsubscribe();
-  }, [service]);
-  const callbacks = react.useMemo(() => ({
-    setFilter: (key, value) => {
-      service.setFilters({ [key]: value });
+    return () => sub.unsubscribe();
+  }, [svc, debug]);
+  react.useEffect(() => {
+    return () => {
+      if (ownsServiceRef.current && serviceRef.current) {
+        if (debug) {
+          console.log(`useFiltersAndSort: destroying owned service "${serviceRef.current.getStorageKey()}"`);
+        }
+        serviceRef.current.destroy();
+        serviceRef.current = null;
+      }
+    };
+  }, [debug]);
+  const setFilter = react.useCallback(
+    (key, value) => {
+      svc.setFilters({ [key]: value });
     },
-    clearFilter: (key) => {
-      service.removeFilter(key);
+    [svc]
+  );
+  const setFilters = react.useCallback(
+    (filters) => {
+      svc.setFilters(filters);
     },
-    clearAllFilters: () => {
-      service.clearFilters();
+    [svc]
+  );
+  const clearFilter = react.useCallback(
+    (key) => {
+      svc.removeFilter(key);
     },
-    setSort: (field) => {
-      service.setSort(field);
+    [svc]
+  );
+  const clearAllFilters = react.useCallback(() => {
+    svc.clearFilters();
+  }, [svc]);
+  const hasFilter = react.useCallback(
+    (key) => {
+      var _a;
+      const value = svc.getCurrentState().filters[key];
+      const defaultValue = (_a = defaultFiltersRef.current) == null ? void 0 : _a[key];
+      if (value === defaultValue) return false;
+      if (value === null || value === void 0 || value === "") return false;
+      if (Array.isArray(value) && value.length === 0) return false;
+      return true;
     },
-    toggleSort: (field) => {
-      service.setSort(field);
+    [svc]
+  );
+  const hasAnyFilters = react.useCallback(() => {
+    return countActiveFilters(svc.getCurrentState().filters, defaultFiltersRef.current) > 0;
+  }, [svc]);
+  const setSort = react.useCallback(
+    (field) => {
+      svc.setSort(field);
     },
-    setPage: (page) => {
-      service.setPagination(page);
+    [svc]
+  );
+  const clearSort = react.useCallback(() => {
+    svc.setSort("");
+  }, [svc]);
+  const isSortedBy = react.useCallback(
+    (field) => {
+      var _a;
+      return ((_a = svc.getCurrentState().sort) == null ? void 0 : _a.fieldName) === field;
     },
-    setPageSize: (size) => {
-      const currentPage = state.pagination.page;
-      service.setPagination(currentPage, size);
+    [svc]
+  );
+  const setPage = react.useCallback(
+    (page) => {
+      if (page < 0) {
+        if (debug) {
+          console.warn("useFiltersAndSort: setPage called with negative value, clamping to 0");
+        }
+        page = 0;
+      }
+      svc.setPagination(page);
     },
-    nextPage: () => {
-      service.setPagination(state.pagination.page + 1);
+    [svc, debug]
+  );
+  const setPageSize = react.useCallback(
+    (size) => {
+      if (size < 1) {
+        if (debug) {
+          console.warn("useFiltersAndSort: setPageSize called with value < 1, clamping to 1");
+        }
+        size = 1;
+      }
+      const currentPage = svc.getCurrentState().pagination.page;
+      svc.setPagination(currentPage, size);
     },
-    prevPage: () => {
-      const newPage = Math.max(0, state.pagination.page - 1);
-      service.setPagination(newPage);
+    [svc, debug]
+  );
+  const nextPage = react.useCallback(() => {
+    svc.setPagination(svc.getCurrentState().pagination.page + 1);
+  }, [svc]);
+  const prevPage = react.useCallback(() => {
+    const newPage = Math.max(0, svc.getCurrentState().pagination.page - 1);
+    svc.setPagination(newPage);
+  }, [svc]);
+  const firstPage = react.useCallback(() => {
+    svc.setPagination(0);
+  }, [svc]);
+  const setQuery = react.useCallback(
+    (query) => {
+      svc.setQuery(query);
     },
-    setQuery: (query) => {
-      service.setQuery(query);
+    [svc]
+  );
+  const clearQuery = react.useCallback(() => {
+    svc.setQuery("");
+  }, [svc]);
+  const reset = react.useCallback(() => {
+    svc.reset();
+  }, [svc]);
+  const clearStorageAndReset = react.useCallback(() => {
+    svc.clearStorage();
+    svc.reset();
+  }, [svc]);
+  const getService = react.useCallback(() => svc, [svc]);
+  const activeFilterCount = react.useMemo(
+    () => countActiveFilters(state.filters, defaultFiltersRef.current),
+    [state.filters]
+  );
+  const isFirstPage = state.pagination.page === 0;
+  const offset = state.pagination.page * state.pagination.limit;
+  return react.useMemo(
+    () => {
+      var _a, _b;
+      return {
+        // State
+        filters: state.filters,
+        sortBy: ((_a = state.sort) == null ? void 0 : _a.fieldName) ?? null,
+        sortDirection: ((_b = state.sort) == null ? void 0 : _b.direction) ?? "asc",
+        page: state.pagination.page,
+        pageSize: state.pagination.limit,
+        query: state.query,
+        state,
+        // Filter actions
+        setFilter,
+        setFilters,
+        clearFilter,
+        clearAllFilters,
+        hasFilter,
+        hasAnyFilters,
+        activeFilterCount,
+        // Sort actions
+        setSort,
+        toggleSort: setSort,
+        clearSort,
+        isSortedBy,
+        // Pagination actions
+        setPage,
+        setPageSize,
+        nextPage,
+        prevPage,
+        firstPage,
+        isFirstPage,
+        offset,
+        // Query actions
+        setQuery,
+        clearQuery,
+        // General actions
+        reset,
+        clearStorageAndReset,
+        storageKey: svc.getStorageKey(),
+        // Service access
+        getService
+      };
     },
-    reset: () => {
-      service.reset();
-    }
-  }), [service, state.pagination.page]);
-  const memoizedReturn = react.useMemo(() => {
-    var _a, _b;
-    return {
-      filters: state.filters,
-      sortBy: ((_a = state.sort) == null ? void 0 : _a.fieldName) || null,
-      sortDirection: ((_b = state.sort) == null ? void 0 : _b.direction) || "asc",
-      page: state.pagination.page,
-      pageSize: state.pagination.limit,
-      query: state.query,
-      ...callbacks
-    };
-  }, [state, callbacks]);
-  return memoizedReturn;
+    [
+      state,
+      setFilter,
+      setFilters,
+      clearFilter,
+      clearAllFilters,
+      hasFilter,
+      hasAnyFilters,
+      activeFilterCount,
+      setSort,
+      clearSort,
+      isSortedBy,
+      setPage,
+      setPageSize,
+      nextPage,
+      prevPage,
+      firstPage,
+      isFirstPage,
+      offset,
+      setQuery,
+      clearQuery,
+      reset,
+      clearStorageAndReset,
+      svc,
+      getService
+    ]
+  );
 }
 function useFormBuilder(options) {
   const { builder } = options;