next-data-fetcher/dist/index.d.ts

A flexible data fetching system for Next.js applications with real-time updates and pagination

import * as react_jsx_runtime from 'react/jsx-runtime';
import React from 'react';

type DataSourceType = "json" | "csv" | "txt" | "api";
interface PaginationOptions {
    page: number;
    limit: number;
    enabled: boolean;
}
interface FetcherOptions {
    dataSource?: DataSourceType;
    componentId: string;
    endpoint?: string;
    pagination?: PaginationOptions;
}
declare abstract class BaseFetcher<T> {
    protected options: FetcherOptions;
    protected baseServerUrl: string;
    private static serverCache;
    private clientCache;
    private cacheExpirationTime;
    private unsubscribe;
    constructor(options: FetcherOptions);
    private setupRealtimeSubscription;
    private handleDataChange;
    invalidateCache(): void;
    abstract parseData(data: any): T[];
    private getUrl;
    fetchJsonData(isServer: boolean): Promise<{
        data: T[];
        totalItems?: number;
        totalPages?: number;
    }>;
    fetchCsvData(isServer: boolean): Promise<{
        data: T[];
    }>;
    fetchTxtData(isServer: boolean): Promise<{
        data: T[];
    }>;
    fetchApiData(isServer: boolean): Promise<{
        data: T[];
    }>;
    getMockData(): T[];
    setPagination(page: number, limit: number, enabled?: boolean): void;
    publishDataChange(action: "create" | "update" | "delete" | "refresh", data?: any, id?: string | number): void;
    fetchData(isServer?: boolean): Promise<{
        data: T[];
        totalItems?: number;
        totalPages?: number;
    }>;
}

declare class FetcherRegistry {
    private static instance;
    private fetchers;
    private apiBasePath;
    private baseUrl;
    private constructor();
    static getInstance(): FetcherRegistry;
    register(componentId: string, fetcher: BaseFetcher<any>): void;
    getFetcher(componentId: string): BaseFetcher<any> | undefined;
    setApiBasePath(path: string): void;
    getApiBasePath(): string;
    setBaseUrl(url: string): void;
    getBaseUrl(): string;
    getDataUrl(componentId: string, dataSource?: DataSourceType, isServer?: boolean): string;
}

type DataChangeEvent = {
    componentId: string;
    action: "create" | "update" | "delete" | "refresh";
    data?: any;
    id?: string | number;
};
declare class RealtimeManager {
    private static instance;
    private emitter;
    private sseClients;
    private isServerSide;
    private constructor();
    static getInstance(): RealtimeManager;
    subscribe(componentId: string, callback: (event: DataChangeEvent) => void): () => void;
    publish(event: DataChangeEvent): void;
    registerSSEClient(id: string, send: (data: string) => void): void;
    unregisterSSEClient(id: string): void;
    private broadcastToSSEClients;
}
declare const realtimeManager: RealtimeManager;

declare function useRealtimeUpdates(componentId: string, onUpdate: () => void): void;

interface WithClientFetchingOptions {
    dataSource?: DataSourceType;
    enableRealtime?: boolean;
    defaultItemsPerPage?: number;
    loadingComponent?: React.ReactNode;
    errorComponent?: React.ReactNode;
}
declare function withClientFetching<T, P extends {
    data?: T[];
}>(WrappedComponent: React.ComponentType<P>, componentId: string, options?: WithClientFetchingOptions): {
    (props: Omit<P, "data">): react_jsx_runtime.JSX.Element;
    displayName: string;
};

interface WithServerFetchingOptions {
    defaultItemsPerPage?: number;
    loadingComponent?: React.ReactNode;
    errorComponent?: React.ReactNode;
}
declare function withServerFetching<T, P extends {
    data?: T[];
}>(WrappedComponent: React.ComponentType<P>, componentId: string, options?: WithServerFetchingOptions): {
    (props: Omit<P, "data">): Promise<react_jsx_runtime.JSX.Element>;
    displayName: string;
};

interface ListRendererProps<T> {
    data: T[];
    renderItem: (item: T, index: number) => React.ReactNode;
    title: string;
    className?: string;
    listClassName?: string;
    itemClassName?: string;
}
declare function ListRenderer<T>({ data, renderItem, title, className, listClassName, itemClassName, }: ListRendererProps<T>): react_jsx_runtime.JSX.Element;

interface DynamicListRendererProps<T> {
    data: T[];
    title: string;
    priorityFields?: string[];
    excludeFields?: string[];
    itemsPerPage?: number;
    virtualized?: boolean;
    className?: string;
    listClassName?: string;
    itemClassName?: string;
}
declare function DynamicListRenderer<T extends Record<string, any>>({ data, title, priorityFields, excludeFields, itemsPerPage: defaultItemsPerPage, virtualized, className, listClassName, itemClassName, }: DynamicListRendererProps<T>): react_jsx_runtime.JSX.Element;

interface DynamicDataDisplayProps {
    data: Record<string, any>;
    excludeFields?: string[];
    priorityFields?: string[];
    className?: string;
}
declare function DynamicDataDisplay({ data, excludeFields, priorityFields, className, }: DynamicDataDisplayProps): react_jsx_runtime.JSX.Element;

interface PaginationProps {
    currentPage: number;
    totalPages: number;
    onPageChange: (page: number) => void;
    itemsPerPage: number;
    onItemsPerPageChange?: (itemsPerPage: number) => void;
    totalItems?: number;
    showItemsPerPage?: boolean;
    className?: string;
}
declare function Pagination({ currentPage, totalPages, onPageChange, itemsPerPage, onItemsPerPageChange, totalItems, showItemsPerPage, className, }: PaginationProps): react_jsx_runtime.JSX.Element;

interface ToggleProps {
    onToggleMode: (isServer: boolean) => void;
    onChangeDataSource: (dataSource: DataSourceType) => void;
    onRefresh?: () => void;
    isServer: boolean;
    dataSource: DataSourceType;
    isRealtime?: boolean;
    onToggleRealtime?: () => void;
    className?: string;
}
declare function Toggle({ onToggleMode, onChangeDataSource, onRefresh, isServer, dataSource, isRealtime, onToggleRealtime, className, }: ToggleProps): react_jsx_runtime.JSX.Element;

/**
 * Creates a simple API route handler for Next.js that reads data from files
 * @param dataDir Directory where data files are stored
 * @returns A handler function for Next.js API routes
 */
declare function createDataApiHandler(dataDir?: string): (req: Request) => Promise<Response>;
/**
 * Creates a simple SSE handler for Next.js
 * @returns A handler function for Next.js API routes
 */
declare function createSseHandler(): (req: Request) => Promise<Response>;

export { BaseFetcher, DataChangeEvent, DataSourceType, DynamicDataDisplay, DynamicDataDisplayProps, DynamicListRenderer, DynamicListRendererProps, FetcherOptions, FetcherRegistry, ListRenderer, ListRendererProps, Pagination, PaginationOptions, PaginationProps, Toggle, ToggleProps, WithClientFetchingOptions, WithServerFetchingOptions, createDataApiHandler, createSseHandler, realtimeManager, useRealtimeUpdates, withClientFetching, withServerFetching };