@actschurch/ccms-sdk 0.0.1

package/dist/react/hooks/useAdvanced.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Advanced React Hooks
+ * Infinite queries, prefetching, global loading state, debounce, and more
+ */
+import { PagedResult } from '../../models/common/PagedResult';
+import { QueryBuilder } from '../../utils/query';
+import { StorageAdapter } from '../../utils/storage';
+/**
+ * Debounce hook
+ */
+export declare function useDebounce<T>(value: T, delayMs: number): T;
+/**
+ * Debounced callback hook
+ */
+export declare function useDebouncedCallback<T extends (...args: unknown[]) => unknown>(callback: T, delayMs: number): T;
+/**
+ * Throttle hook
+ */
+export declare function useThrottle<T>(value: T, intervalMs: number): T;
+/**
+ * Previous value hook
+ * Note: Re-exported from utils/hooks to avoid duplication
+ */
+export { usePrevious } from '../../utils/hooks';
+/**
+ * Infinite query state
+ */
+export interface InfiniteQueryState<T> {
+    pages: T[][];
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetching: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    error: Error | null;
+    totalItems?: number;
+    totalPages?: number;
+}
+/**
+ * Infinite query options
+ */
+export interface InfiniteQueryOptions<T> {
+    /** Initial page number (default: 1) */
+    initialPage?: number;
+    /** Items per page (default: 20) */
+    pageSize?: number;
+    /** Enable the query (default: true) */
+    enabled?: boolean;
+    /** Refetch on window focus */
+    refetchOnFocus?: boolean;
+    /** Get next page param from last page */
+    getNextPageParam?: (lastPage: PagedResult<T>, allPages: PagedResult<T>[]) => number | undefined;
+    /** Get previous page param from first page */
+    getPreviousPageParam?: (firstPage: PagedResult<T>, allPages: PagedResult<T>[]) => number | undefined;
+}
+/**
+ * Infinite query hook for paginated data
+ */
+export declare function useInfiniteQuery<T>(endpoint: string, queryBuilder?: QueryBuilder, options?: InfiniteQueryOptions<T>): InfiniteQueryState<T> & {
+    fetchNextPage: () => Promise<void>;
+    fetchPreviousPage: () => Promise<void>;
+    refetch: () => Promise<void>;
+    reset: () => void;
+};
+export declare function trackFetching(key: string): () => void;
+/**
+ * Hook to check if any requests are in flight
+ */
+export declare function useIsFetching(): boolean;
+/**
+ * Hook to get count of in-flight requests
+ */
+export declare function useFetchingCount(): number;
+export declare function usePrefetch(): {
+    prefetch: <T>(endpoint: string, queryBuilder?: QueryBuilder) => Promise<void>;
+    getPrefetched: <T>(endpoint: string, queryBuilder?: QueryBuilder) => T | null;
+    clearPrefetch: (endpoint?: string) => void;
+};
+/**
+ * Polling hook
+ */
+export declare function usePolling<T>(fetcher: () => Promise<T>, intervalMs: number, options?: {
+    enabled?: boolean;
+    onSuccess?: (data: T) => void;
+    onError?: (error: Error) => void;
+}): {
+    data: T | null;
+    error: Error | null;
+    isPolling: boolean;
+    start: () => void;
+    stop: () => void;
+};
+/**
+ * Optimistic update hook
+ */
+export declare function useOptimisticUpdate<T, TVariables>(mutationFn: (variables: TVariables) => Promise<T>, options?: {
+    onMutate?: (variables: TVariables) => T | Promise<T>;
+    onSuccess?: (data: T, variables: TVariables) => void;
+    onError?: (error: Error, variables: TVariables, rollback: T | undefined) => void;
+    onSettled?: (data: T | undefined, error: Error | null, variables: TVariables) => void;
+}): {
+    mutate: (variables: TVariables) => Promise<T>;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * Storage options for useStorage hook
+ */
+export interface UseStorageOptions<T> {
+    /** Custom storage adapter (defaults to global storage) */
+    storage?: StorageAdapter;
+    /** Serializer function (defaults to JSON.stringify) */
+    serialize?: (value: T) => string;
+    /** Deserializer function (defaults to JSON.parse) */
+    deserialize?: (value: string) => T;
+}
+/**
+ * Platform-agnostic storage hook
+ * Works with web localStorage, React Native AsyncStorage, or any custom storage
+ *
+ * @example
+ * // Web (uses localStorage by default)
+ * const [value, setValue, removeValue] = useStorage('key', initialValue);
+ *
+ * @example
+ * // React Native - first configure global storage in app entry:
+ * // import AsyncStorage from '@react-native-async-storage/async-storage';
+ * // setGlobalStorage(AsyncStorage);
+ * // Then use the hook normally:
+ * const [value, setValue, removeValue] = useStorage('key', initialValue);
+ */
+export declare function useStorage<T>(key: string, initialValue: T, options?: UseStorageOptions<T>): [T, (value: T | ((prev: T) => T)) => void, () => void, boolean];
+/**
+ * Alias for useStorage for backward compatibility
+ * @deprecated Use useStorage instead for cross-platform support
+ */
+export declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T | ((prev: T) => T)) => void, () => void];
+/**
+ * Platform-agnostic network status hook
+ * Works with web navigator.onLine and React Native NetInfo
+ *
+ * @example
+ * // Web (uses navigator.onLine by default)
+ * const { isOnline, wasOffline } = useNetworkStatus();
+ *
+ * @example
+ * // React Native - first configure global network status in app entry:
+ * // import NetInfo from '@react-native-community/netinfo';
+ * // setGlobalNetworkStatus({
+ * //   isOnline: async () => (await NetInfo.fetch()).isConnected ?? false,
+ * //   subscribe: (cb) => NetInfo.addEventListener(state => cb(state.isConnected ?? false))
+ * // });
+ * // Then use the hook normally:
+ * const { isOnline, wasOffline } = useNetworkStatus();
+ */
+export declare function useNetworkStatus(): {
+    isOnline: boolean;
+    wasOffline: boolean;
+    isLoading: boolean;
+};
+//# sourceMappingURL=useAdvanced.d.ts.map

package/dist/react/hooks/useAdvanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAdvanced.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/useAdvanced.ts"],"names":[],"mappings":"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"}

package/dist/react/hooks/useAdvanced.js

@@ -0,0 +1,520 @@
+/**
+ * Advanced React Hooks
+ * Infinite queries, prefetching, global loading state, debounce, and more
+ */
+import { useState, useEffect, useCallback, useRef, } from 'react';
+import { useHttpClient } from './useCCMS';
+import { QueryBuilder } from '../../utils/query';
+import { getGlobalStorage, getGlobalNetworkStatus, } from '../../utils/storage';
+/**
+ * Debounce hook
+ */
+export function useDebounce(value, delayMs) {
+    const [debouncedValue, setDebouncedValue] = useState(value);
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            setDebouncedValue(value);
+        }, delayMs);
+        return () => clearTimeout(timer);
+    }, [value, delayMs]);
+    return debouncedValue;
+}
+/**
+ * Debounced callback hook
+ */
+export function useDebouncedCallback(callback, delayMs) {
+    const timeoutRef = useRef();
+    const callbackRef = useRef(callback);
+    // Update callback ref on each render
+    callbackRef.current = callback;
+    const debouncedCallback = useCallback((...args) => {
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(() => {
+            callbackRef.current(...args);
+        }, delayMs);
+    }, [delayMs]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, []);
+    return debouncedCallback;
+}
+/**
+ * Throttle hook
+ */
+export function useThrottle(value, intervalMs) {
+    const [throttledValue, setThrottledValue] = useState(value);
+    const lastUpdated = useRef(Date.now());
+    useEffect(() => {
+        const now = Date.now();
+        const timeSinceLastUpdate = now - lastUpdated.current;
+        if (timeSinceLastUpdate >= intervalMs) {
+            lastUpdated.current = now;
+            setThrottledValue(value);
+        }
+        else {
+            const timer = setTimeout(() => {
+                lastUpdated.current = Date.now();
+                setThrottledValue(value);
+            }, intervalMs - timeSinceLastUpdate);
+            return () => clearTimeout(timer);
+        }
+    }, [value, intervalMs]);
+    return throttledValue;
+}
+/**
+ * Previous value hook
+ * Note: Re-exported from utils/hooks to avoid duplication
+ */
+export { usePrevious } from '../../utils/hooks';
+/**
+ * Infinite query hook for paginated data
+ */
+export function useInfiniteQuery(endpoint, queryBuilder, options = {}) {
+    const http = useHttpClient();
+    const { initialPage = 1, pageSize = 20, enabled = true, refetchOnFocus = false, getNextPageParam = (lastPage) => lastPage.page < lastPage.totalPages ? lastPage.page + 1 : undefined, getPreviousPageParam = (firstPage) => firstPage.page > 1 ? firstPage.page - 1 : undefined, } = options;
+    const [state, setState] = useState({
+        pages: [],
+        hasNextPage: true,
+        hasPreviousPage: false,
+        isFetching: false,
+        isFetchingNextPage: false,
+        isFetchingPreviousPage: false,
+        error: null,
+    });
+    const pagesDataRef = useRef([]);
+    const currentPageRef = useRef(initialPage);
+    const fetchPage = useCallback(async (page) => {
+        const builder = queryBuilder || new QueryBuilder();
+        builder.paginate(page, pageSize);
+        const url = builder.toUrl(endpoint);
+        const response = await http.get(url);
+        if (!response.data) {
+            throw new Error('No data received');
+        }
+        return response.data;
+    }, [http, endpoint, queryBuilder, pageSize]);
+    const fetchInitial = useCallback(async () => {
+        if (!enabled)
+            return;
+        setState((prev) => ({ ...prev, isFetching: true, error: null }));
+        try {
+            const page = await fetchPage(initialPage);
+            pagesDataRef.current = [page];
+            currentPageRef.current = initialPage;
+            setState({
+                pages: [page.items],
+                hasNextPage: getNextPageParam(page, [page]) !== undefined,
+                hasPreviousPage: getPreviousPageParam(page, [page]) !== undefined,
+                isFetching: false,
+                isFetchingNextPage: false,
+                isFetchingPreviousPage: false,
+                error: null,
+                totalItems: page.totalCount,
+                totalPages: page.totalPages,
+            });
+        }
+        catch (error) {
+            setState((prev) => ({
+                ...prev,
+                isFetching: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            }));
+        }
+    }, [enabled, fetchPage, initialPage, getNextPageParam, getPreviousPageParam]);
+    const fetchNextPage = useCallback(async () => {
+        if (!state.hasNextPage || state.isFetchingNextPage)
+            return;
+        const lastPageData = pagesDataRef.current[pagesDataRef.current.length - 1];
+        const nextPageNum = getNextPageParam(lastPageData, pagesDataRef.current);
+        if (nextPageNum === undefined)
+            return;
+        setState((prev) => ({ ...prev, isFetchingNextPage: true }));
+        try {
+            const page = await fetchPage(nextPageNum);
+            pagesDataRef.current = [...pagesDataRef.current, page];
+            setState((prev) => ({
+                ...prev,
+                pages: [...prev.pages, page.items],
+                hasNextPage: getNextPageParam(page, pagesDataRef.current) !== undefined,
+                isFetchingNextPage: false,
+                totalItems: page.totalCount,
+                totalPages: page.totalPages,
+            }));
+        }
+        catch (error) {
+            setState((prev) => ({
+                ...prev,
+                isFetchingNextPage: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            }));
+        }
+    }, [state.hasNextPage, state.isFetchingNextPage, fetchPage, getNextPageParam]);
+    const fetchPreviousPage = useCallback(async () => {
+        if (!state.hasPreviousPage || state.isFetchingPreviousPage)
+            return;
+        const firstPageData = pagesDataRef.current[0];
+        const prevPageNum = getPreviousPageParam(firstPageData, pagesDataRef.current);
+        if (prevPageNum === undefined)
+            return;
+        setState((prev) => ({ ...prev, isFetchingPreviousPage: true }));
+        try {
+            const page = await fetchPage(prevPageNum);
+            pagesDataRef.current = [page, ...pagesDataRef.current];
+            setState((prev) => ({
+                ...prev,
+                pages: [page.items, ...prev.pages],
+                hasPreviousPage: getPreviousPageParam(page, pagesDataRef.current) !== undefined,
+                isFetchingPreviousPage: false,
+            }));
+        }
+        catch (error) {
+            setState((prev) => ({
+                ...prev,
+                isFetchingPreviousPage: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            }));
+        }
+    }, [state.hasPreviousPage, state.isFetchingPreviousPage, fetchPage, getPreviousPageParam]);
+    const reset = useCallback(() => {
+        pagesDataRef.current = [];
+        currentPageRef.current = initialPage;
+        setState({
+            pages: [],
+            hasNextPage: true,
+            hasPreviousPage: false,
+            isFetching: false,
+            isFetchingNextPage: false,
+            isFetchingPreviousPage: false,
+            error: null,
+        });
+    }, [initialPage]);
+    // Initial fetch
+    useEffect(() => {
+        fetchInitial();
+    }, [fetchInitial]);
+    // Refetch on focus
+    useEffect(() => {
+        if (!refetchOnFocus)
+            return;
+        const handleFocus = () => {
+            fetchInitial();
+        };
+        window.addEventListener('focus', handleFocus);
+        return () => window.removeEventListener('focus', handleFocus);
+    }, [refetchOnFocus, fetchInitial]);
+    return {
+        ...state,
+        fetchNextPage,
+        fetchPreviousPage,
+        refetch: fetchInitial,
+        reset,
+    };
+}
+/**
+ * Global fetching state tracker
+ */
+const fetchingRequests = new Set();
+const fetchingListeners = new Set();
+function notifyFetchingListeners() {
+    fetchingListeners.forEach((listener) => listener());
+}
+export function trackFetching(key) {
+    fetchingRequests.add(key);
+    notifyFetchingListeners();
+    return () => {
+        fetchingRequests.delete(key);
+        notifyFetchingListeners();
+    };
+}
+/**
+ * Hook to check if any requests are in flight
+ */
+export function useIsFetching() {
+    const [isFetching, setIsFetching] = useState(fetchingRequests.size > 0);
+    useEffect(() => {
+        const listener = () => {
+            setIsFetching(fetchingRequests.size > 0);
+        };
+        fetchingListeners.add(listener);
+        return () => {
+            fetchingListeners.delete(listener);
+        };
+    }, []);
+    return isFetching;
+}
+/**
+ * Hook to get count of in-flight requests
+ */
+export function useFetchingCount() {
+    const [count, setCount] = useState(fetchingRequests.size);
+    useEffect(() => {
+        const listener = () => {
+            setCount(fetchingRequests.size);
+        };
+        fetchingListeners.add(listener);
+        return () => {
+            fetchingListeners.delete(listener);
+        };
+    }, []);
+    return count;
+}
+/**
+ * Prefetch data for later use
+ */
+const prefetchCache = new Map();
+const PREFETCH_TTL = 5 * 60 * 1000; // 5 minutes
+export function usePrefetch() {
+    const http = useHttpClient();
+    const prefetch = useCallback(async (endpoint, queryBuilder) => {
+        const url = queryBuilder ? queryBuilder.toUrl(endpoint) : endpoint;
+        const cacheKey = url;
+        // Check if already cached and not stale
+        const cached = prefetchCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < PREFETCH_TTL) {
+            return;
+        }
+        try {
+            const response = await http.get(url);
+            if (response.data) {
+                prefetchCache.set(cacheKey, {
+                    data: response.data,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        catch {
+            // Silently fail prefetch
+        }
+    }, [http]);
+    const getPrefetched = useCallback((endpoint, queryBuilder) => {
+        const url = queryBuilder ? queryBuilder.toUrl(endpoint) : endpoint;
+        const cached = prefetchCache.get(url);
+        if (cached && Date.now() - cached.timestamp < PREFETCH_TTL) {
+            return cached.data;
+        }
+        return null;
+    }, []);
+    const clearPrefetch = useCallback((endpoint) => {
+        if (endpoint) {
+            prefetchCache.delete(endpoint);
+        }
+        else {
+            prefetchCache.clear();
+        }
+    }, []);
+    return { prefetch, getPrefetched, clearPrefetch };
+}
+/**
+ * Polling hook
+ */
+export function usePolling(fetcher, intervalMs, options = {}) {
+    const { enabled = true, onSuccess, onError } = options;
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isPolling, setIsPolling] = useState(enabled);
+    const intervalRef = useRef();
+    const poll = useCallback(async () => {
+        try {
+            const result = await fetcher();
+            setData(result);
+            setError(null);
+            onSuccess?.(result);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            onError?.(error);
+        }
+    }, [fetcher, onSuccess, onError]);
+    const start = useCallback(() => {
+        setIsPolling(true);
+    }, []);
+    const stop = useCallback(() => {
+        setIsPolling(false);
+        if (intervalRef.current) {
+            clearInterval(intervalRef.current);
+        }
+    }, []);
+    useEffect(() => {
+        if (!isPolling)
+            return;
+        // Initial poll
+        poll();
+        // Set up interval
+        intervalRef.current = setInterval(poll, intervalMs);
+        return () => {
+            if (intervalRef.current) {
+                clearInterval(intervalRef.current);
+            }
+        };
+    }, [isPolling, poll, intervalMs]);
+    return { data, error, isPolling, start, stop };
+}
+/**
+ * Optimistic update hook
+ */
+export function useOptimisticUpdate(mutationFn, options = {}) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const mutate = useCallback(async (variables) => {
+        setIsLoading(true);
+        setError(null);
+        let rollbackData;
+        try {
+            // Optimistically update
+            if (options.onMutate) {
+                rollbackData = await options.onMutate(variables);
+            }
+            // Perform actual mutation
+            const result = await mutationFn(variables);
+            options.onSuccess?.(result, variables);
+            options.onSettled?.(result, null, variables);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            options.onError?.(error, variables, rollbackData);
+            options.onSettled?.(undefined, error, variables);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [mutationFn, options]);
+    return { mutate, isLoading, error };
+}
+/**
+ * Platform-agnostic storage hook
+ * Works with web localStorage, React Native AsyncStorage, or any custom storage
+ *
+ * @example
+ * // Web (uses localStorage by default)
+ * const [value, setValue, removeValue] = useStorage('key', initialValue);
+ *
+ * @example
+ * // React Native - first configure global storage in app entry:
+ * // import AsyncStorage from '@react-native-async-storage/async-storage';
+ * // setGlobalStorage(AsyncStorage);
+ * // Then use the hook normally:
+ * const [value, setValue, removeValue] = useStorage('key', initialValue);
+ */
+export function useStorage(key, initialValue, options = {}) {
+    const { storage = getGlobalStorage(), serialize = JSON.stringify, deserialize = JSON.parse, } = options;
+    const [storedValue, setStoredValue] = useState(initialValue);
+    const [isLoading, setIsLoading] = useState(true);
+    const storageRef = useRef(storage);
+    // Load initial value from storage
+    useEffect(() => {
+        const loadValue = async () => {
+            try {
+                const item = await Promise.resolve(storageRef.current.getItem(key));
+                if (item !== null) {
+                    setStoredValue(deserialize(item));
+                }
+            }
+            catch {
+                // Use initial value on error
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        loadValue();
+    }, [key, deserialize]);
+    const setValue = useCallback((value) => {
+        try {
+            const valueToStore = value instanceof Function ? value(storedValue) : value;
+            setStoredValue(valueToStore);
+            // Save to storage (handles both sync and async)
+            const serialized = serialize(valueToStore);
+            Promise.resolve(storageRef.current.setItem(key, serialized)).catch(() => {
+                // Ignore storage errors
+            });
+        }
+        catch {
+            // Ignore errors
+        }
+    }, [key, storedValue, serialize]);
+    const removeValue = useCallback(() => {
+        try {
+            setStoredValue(initialValue);
+            Promise.resolve(storageRef.current.removeItem(key)).catch(() => {
+                // Ignore storage errors
+            });
+        }
+        catch {
+            // Ignore errors
+        }
+    }, [key, initialValue]);
+    return [storedValue, setValue, removeValue, isLoading];
+}
+/**
+ * Alias for useStorage for backward compatibility
+ * @deprecated Use useStorage instead for cross-platform support
+ */
+export function useLocalStorage(key, initialValue) {
+    const [value, setValue, removeValue] = useStorage(key, initialValue);
+    return [value, setValue, removeValue];
+}
+/**
+ * Platform-agnostic network status hook
+ * Works with web navigator.onLine and React Native NetInfo
+ *
+ * @example
+ * // Web (uses navigator.onLine by default)
+ * const { isOnline, wasOffline } = useNetworkStatus();
+ *
+ * @example
+ * // React Native - first configure global network status in app entry:
+ * // import NetInfo from '@react-native-community/netinfo';
+ * // setGlobalNetworkStatus({
+ * //   isOnline: async () => (await NetInfo.fetch()).isConnected ?? false,
+ * //   subscribe: (cb) => NetInfo.addEventListener(state => cb(state.isConnected ?? false))
+ * // });
+ * // Then use the hook normally:
+ * const { isOnline, wasOffline } = useNetworkStatus();
+ */
+export function useNetworkStatus() {
+    const [isOnline, setIsOnline] = useState(true);
+    const [wasOffline, setWasOffline] = useState(false);
+    const [isLoading, setIsLoading] = useState(true);
+    useEffect(() => {
+        const networkStatus = getGlobalNetworkStatus();
+        // Get initial status
+        const initStatus = async () => {
+            try {
+                const online = await Promise.resolve(networkStatus.isOnline());
+                setIsOnline(online);
+                if (!online) {
+                    setWasOffline(true);
+                }
+            }
+            catch {
+                // Default to online if we can't determine
+                setIsOnline(true);
+            }
+            finally {
+                setIsLoading(false);
+            }
+        };
+        initStatus();
+        // Subscribe to changes
+        const unsubscribe = networkStatus.subscribe((online) => {
+            setIsOnline(online);
+            if (!online) {
+                setWasOffline(true);
+            }
+        });
+        return unsubscribe;
+    }, []);
+    return { isOnline, wasOffline, isLoading };
+}
+//# sourceMappingURL=useAdvanced.js.map