@katlux/providers 0.1.0-alpha.81

package/dist/index.d.ts

@@ -0,0 +1,482 @@
+import { Ref } from 'vue';
+
+declare enum EDataFilterOperator {
+    Equal = "==",
+    NotEqual = "!=",
+    GreaterThan = ">",
+    LessThan = "<",
+    GreaterThanOrEqual = ">=",
+    LessThanOrEqual = "<=",
+    In = "in",
+    NotIn = "nin",
+    And = "and",
+    Or = "or",
+    Nand = "nand",
+    Nor = "nor"
+}
+declare enum ECacheStrategy {
+    Application = "Application",
+    Session = "Session",
+    Memory = "Memory",
+    LocalStorage = "LocalStorage",
+    IndexedDB = "IndexedDB",
+    Cookie = "Cookie"
+}
+interface ICacheEntry<T> {
+    data: T;
+    timestamp: number;
+    lifetime: number;
+}
+interface IRequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    body?: any;
+    headers?: Record<string, string>;
+    cacheStrategy?: ECacheStrategy;
+    lifetime?: number;
+    key?: string;
+    cacheKey?: string;
+    query?: Record<string, any>;
+    deduplicate?: boolean;
+    nuxtApp?: any;
+    disableCache?: boolean;
+}
+interface IKDatatableAction {
+    action: Function;
+    label: string;
+    icon?: string;
+    iconOnly?: boolean;
+    type?: 'default' | 'primary' | 'danger' | 'success' | 'warning' | 'info' | 'light' | 'dark';
+    visible?: Function;
+}
+type TDataRow = {
+    [key: string]: any;
+};
+interface IDataFilter {
+    operator: EDataFilterOperator;
+    field: TDataRow | IDataFilter[];
+    active: Boolean;
+}
+interface IDataSort {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+interface IDataResult {
+    rowCount: number;
+    rows: TDataRow[];
+}
+type TPageDataHandler = (currentPage: number, pageSize: number, filter: IDataFilter, sortList: IDataSort[], options?: {
+    disableCache?: boolean;
+}) => IDataResult | Promise<IDataResult>;
+interface IDataProviderOptions {
+    filter?: IDataFilter;
+    sortList?: IDataSort[];
+    pageSize?: number;
+    currentPage?: number;
+    SSR?: boolean;
+    cacheStrategy?: ECacheStrategy;
+    cacheLifetime?: number;
+    deduplicate?: boolean;
+    nuxtApp?: any;
+    urlPageParam?: string;
+    refreshOnMutation?: boolean;
+}
+interface ITreeNode {
+    data: TDataRow;
+    id: string | number;
+    parentId: string | number | null;
+    depth: number;
+    hasChildren: boolean;
+    isExpanded: boolean;
+}
+interface ITreeNodeStatic {
+    data: TDataRow;
+    id: string | number;
+    parentId: string | number | null;
+    depth: number;
+    hasChildren: boolean;
+}
+type TreePaginationMode = 'all' | 'root';
+interface ITreeDataProviderOptions extends IDataProviderOptions {
+    parentKey?: string;
+    idKey?: string;
+    expandedByDefault?: boolean;
+    paginateBy?: TreePaginationMode;
+}
+interface KProductItemData {
+    id: string | number;
+    title: string;
+    image?: string;
+    price?: number;
+    currency?: string;
+    description?: string;
+    [key: string]: any;
+}
+interface KProductRowAction {
+    label: string;
+    icon?: string;
+    action: (item: KProductItemData) => void;
+    color?: 'primary' | 'danger' | 'success' | 'warning' | 'info' | 'light' | 'dark' | 'default';
+}
+
+declare abstract class ADataProvider {
+    filter: Ref<IDataFilter | null>;
+    sortList: Ref<IDataSort[]>;
+    currentPage: Ref<number>;
+    pageSize: Ref<number>;
+    pageData: Ref<TDataRow[]>;
+    rowCount: Ref<number>;
+    loading: Ref<Boolean>;
+    SSR: Ref<Boolean>;
+    deduplicate: Ref<Boolean>;
+    nuxtApp: any;
+    urlPageParam: Ref<string>;
+    selectedRows: Ref<any[]>;
+    selectAll: Ref<boolean>;
+    constructor(options?: IDataProviderOptions);
+    setFilter(filter: IDataFilter | null): void;
+    setSortList(sortList: IDataSort[]): void;
+    setCurrentPage(currentPage: number): void;
+    setPageSize(pageSize: number): void;
+    abstract loadPageData(): void;
+    refresh(hardRefresh?: boolean): Promise<void>;
+}
+
+declare class CFlatClientDataProvider extends ADataProvider {
+    allData: Ref<TDataRow[]>;
+    filteredData: Ref<TDataRow[]>;
+    constructor(options?: IDataProviderOptions);
+    setData(data: TDataRow[]): void;
+    loadPageData(): Promise<void>;
+}
+
+declare abstract class ACacheProvider {
+    constructor();
+    abstract getKeyList(nuxtApp?: any): Array<string> | Promise<Array<string>>;
+    abstract get<T>(key: string, nuxtApp?: any): Promise<T | null>;
+    abstract set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
+    abstract remove(key: string, nuxtApp?: any): Promise<void>;
+    abstract removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
+    abstract getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    abstract cleanupExpired(): Promise<void>;
+}
+
+declare class RequestProvider {
+    cacheProvider: ACacheProvider | null;
+    cacheLifetime: number | null;
+    deduplicate: boolean;
+    cacheKey: string;
+    private static requestQueue;
+    private static executing;
+    private static requestsInFlight;
+    private lastUrl?;
+    private lastOptions?;
+    private dataReceivedCallback?;
+    constructor(provider?: ACacheProvider | ECacheStrategy, lifetime?: number, deduplicate?: boolean);
+    setCacheProvider(provider?: ACacheProvider | ECacheStrategy): void;
+    setCacheLifetime(lifetime: number): void;
+    setDeduplicate(deduplicate: boolean): void;
+    onDataReceived(callback: (data: any) => void): void;
+    hasLastUrl(): boolean;
+    refresh(hardRefresh?: boolean): Promise<any>;
+    private getUniqueKey;
+    registerRequest<T>(url: string, options?: IRequestOptions): Promise<T>;
+    static executeAll(): void;
+    request<T>(url: string, options?: IRequestOptions): Promise<T>;
+}
+
+declare abstract class AAPIDataProvider {
+    apiUrl: Ref<string>;
+    cacheStrategy: Ref<ECacheStrategy | null>;
+    cacheLifetime: Ref<number>;
+    requestProvider: RequestProvider;
+    refreshOnMutation: Ref<boolean | undefined>;
+    constructor(options?: IDataProviderOptions);
+    abstract setAPIUrl(url: string): void;
+    abstract create(item: any): Promise<void>;
+    abstract update(item: any): Promise<void>;
+    abstract delete(items: any[]): Promise<void>;
+}
+
+declare class CAPIFlatClientDataProvider extends CFlatClientDataProvider implements AAPIDataProvider {
+    apiUrl: Ref<string>;
+    contextKey: Ref<string>;
+    initialLoad: Ref<boolean>;
+    requestProvider: RequestProvider;
+    cacheStrategy: Ref<ECacheStrategy | null>;
+    cacheLifetime: Ref<number>;
+    refreshOnMutation: Ref<boolean | undefined>;
+    constructor(options?: IDataProviderOptions);
+    setContextKey(key: string): void;
+    refresh(hardRefresh?: boolean): Promise<void>;
+    refreshData(options?: {
+        disableCache?: boolean;
+    }): Promise<void>;
+    private _initialFetch;
+    setAPIUrl(url: string): Promise<void>;
+    create(item: any): Promise<void>;
+    update(item: any): Promise<void>;
+    delete(items: any[]): Promise<void>;
+}
+
+declare class CFlatServerDataProvider extends ADataProvider {
+    pageDataHandler: Ref<TPageDataHandler>;
+    contextKey: Ref<string>;
+    initialLoad: Ref<boolean>;
+    constructor(options?: IDataProviderOptions);
+    setContextKey(key: string): void;
+    setPageDataHandler(handler: TPageDataHandler): Promise<void>;
+    loadPageData(options?: {
+        disableCache?: boolean;
+    }): Promise<void>;
+    refresh(hardRefresh?: boolean): Promise<void>;
+}
+
+declare class CAPIFlatServerDataProvider extends CFlatServerDataProvider implements AAPIDataProvider {
+    apiUrl: Ref<string>;
+    requestProvider: RequestProvider;
+    cacheStrategy: Ref<ECacheStrategy | null>;
+    cacheLifetime: Ref<number>;
+    refreshOnMutation: Ref<boolean | undefined>;
+    constructor(options?: IDataProviderOptions);
+    refresh(hardRefresh?: boolean): Promise<void>;
+    refreshData(options?: {
+        disableCache?: boolean;
+    }): Promise<void>;
+    setAPIUrl(url: string): Promise<void>;
+    delete(items: any[]): Promise<void>;
+}
+
+declare class CTreeClientDataProvider extends CFlatClientDataProvider {
+    parentKey: string;
+    idKey: string;
+    expandedByDefault: boolean;
+    paginateBy: TreePaginationMode;
+    expandedNodes: Ref<Set<string | number>>;
+    private _staticNodes;
+    private _nodeMap;
+    private _sortedNodeIds;
+    constructor(options?: ITreeDataProviderOptions);
+    private buildStaticNodes;
+    private computeSortedIds;
+    private updatePageData;
+    private isNodeVisible;
+    private paginateNodes;
+    loadPageData(): Promise<void>;
+    get treeNodes(): ITreeNode[];
+    get visibleRows(): ITreeNode[];
+    toggleNode(nodeId: string | number): void;
+    expand(nodeId: string | number): void;
+    collapse(nodeId: string | number): void;
+    expandAll(): void;
+    collapseAll(): void;
+    getNode(nodeId: string | number): ITreeNode | undefined;
+    getChildren(nodeId: string | number): ITreeNode[];
+    getParent(nodeId: string | number): ITreeNode | undefined;
+}
+
+declare class CAPITreeClientDataProvider extends CTreeClientDataProvider implements AAPIDataProvider {
+    apiUrl: Ref<string>;
+    contextKey: Ref<string>;
+    initialLoad: Ref<boolean>;
+    requestProvider: RequestProvider;
+    cacheStrategy: Ref<ECacheStrategy | null>;
+    cacheLifetime: Ref<number>;
+    refreshOnMutation: Ref<boolean | undefined>;
+    constructor(options?: ITreeDataProviderOptions);
+    setContextKey(key: string): void;
+    refresh(hardRefresh?: boolean): Promise<void>;
+    refreshData(options?: {
+        disableCache?: boolean;
+    }): Promise<void>;
+    private _initialFetch;
+    setAPIUrl(url: string): Promise<void>;
+    create(item: any): Promise<void>;
+    update(item: any): Promise<void>;
+    delete(items: any[]): Promise<void>;
+}
+
+/**
+ * Tree-specific page data handler that includes tree parameters
+ * Server handles tree building, visibility, and pagination
+ */
+type TTreePageDataHandler = (currentPage: number, pageSize: number, filter: IDataFilter, sortList: IDataSort[], treeParams: {
+    expandedNodes: (string | number)[];
+    parentKey: string;
+    idKey: string;
+    paginateBy: TreePaginationMode;
+    expandedByDefault: boolean;
+}, options?: {
+    disableCache?: boolean;
+}) => IDataResult | Promise<IDataResult>;
+/**
+ * Server-side Tree Data Provider
+ *
+ * Key difference from CTreeClientDataProvider:
+ * - Tree structure, visibility, and pagination are handled SERVER-SIDE
+ * - Client only sends expanded state to server
+ * - Server returns already-paginated visible rows with __treeNode metadata
+ * - No allData - server handles everything
+ */
+declare class CTreeServerDataProvider extends ADataProvider {
+    parentKey: string;
+    idKey: string;
+    expandedByDefault: boolean;
+    paginateBy: TreePaginationMode;
+    expandedNodes: Ref<Set<string | number>>;
+    pageDataHandler: Ref<TTreePageDataHandler | null>;
+    contextKey: Ref<string>;
+    initialLoad: Ref<boolean>;
+    constructor(options?: ITreeDataProviderOptions);
+    setContextKey(key: string): void;
+    setPageDataHandler(handler: TTreePageDataHandler): Promise<void>;
+    /**
+     * Load page data from server
+     * Server handles tree building, visibility, and pagination
+     */
+    loadPageData(options?: {
+        disableCache?: boolean;
+    }): Promise<void>;
+    refresh(hardRefresh?: boolean): Promise<void>;
+    toggleNode(nodeId: string | number): void;
+    expand(nodeId: string | number): void;
+    collapse(nodeId: string | number): void;
+    collapseAll(): void;
+    isExpanded(nodeId: string | number): boolean;
+}
+
+/**
+ * API-based Server-side Tree Data Provider
+ *
+ * Extends CTreeServerDataProvider with:
+ * - API URL configuration
+ * - Request management (caching, deduplication)
+ * - Automatic tree parameter serialization in query
+ */
+declare class CAPITreeServerDataProvider extends CTreeServerDataProvider implements AAPIDataProvider {
+    apiUrl: Ref<string>;
+    requestProvider: RequestProvider;
+    cacheStrategy: Ref<ECacheStrategy | null>;
+    cacheLifetime: Ref<number>;
+    refreshOnMutation: Ref<boolean | undefined>;
+    constructor(options?: ITreeDataProviderOptions);
+    refresh(hardRefresh?: boolean): Promise<void>;
+    refreshData(options?: {
+        disableCache?: boolean;
+    }): Promise<void>;
+    setAPIUrl(url: string): Promise<void>;
+    delete(items: any[]): Promise<void>;
+}
+
+declare class CacheProviderFactory {
+    static getProvider(strategy: ECacheStrategy): ACacheProvider | null;
+}
+
+declare class CSessionCache extends ACacheProvider {
+    private static instance;
+    static getInstance(): CSessionCache;
+    private static get storage();
+    static getSnapshot(): Map<string, Map<string, ICacheEntry<any>>>;
+    private sessionIdCache;
+    private sessionId;
+    private readonly SESSION_ID_KEY;
+    private constructor();
+    /**
+     * Generate a UUID v4 sessionId
+     */
+    private generateSessionId;
+    /**
+     * Get or create sessionId
+     */
+    private getSessionId;
+    getKeyList(nuxtApp?: any): Promise<Array<string>>;
+    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
+    remove(key: string, nuxtApp?: any): Promise<void>;
+    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
+    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    cleanupExpired(): Promise<void>;
+}
+
+declare class CCookieCache extends ACacheProvider {
+    private static instance;
+    static getInstance(): CCookieCache;
+    type: string;
+    private constructor();
+    getKeyList(nuxtApp?: any): Promise<Array<string>>;
+    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
+    remove(key: string, nuxtApp?: any): Promise<void>;
+    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    cleanupExpired(): Promise<void>;
+}
+
+declare class CLocalStorageCache extends ACacheProvider {
+    private static instance;
+    static getInstance(): CLocalStorageCache;
+    type: string;
+    private constructor();
+    private _hydrateFromPayload;
+    getKeyList(nuxtApp?: any): Promise<Array<string>>;
+    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
+    remove(key: string, nuxtApp?: any): Promise<void>;
+    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
+    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    cleanupExpired(): Promise<void>;
+}
+
+declare class CIndexedDBCache extends ACacheProvider {
+    private static instance;
+    static getInstance(): CIndexedDBCache;
+    private dbName;
+    private storeName;
+    private version;
+    private dbPromise;
+    setStore(storeName?: string): void;
+    private constructor();
+    private _hydrateFromPayload;
+    private openDB;
+    private getStore;
+    getKeyList(nuxtApp?: any): Promise<Array<string>>;
+    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
+    remove(key: string, nuxtApp?: any): Promise<void>;
+    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
+    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    cleanupExpired(): Promise<void>;
+}
+
+declare class CMemoryCache extends ACacheProvider {
+    private static instance;
+    private static _storage;
+    private static get storage();
+    static getInstance(): CMemoryCache;
+    private constructor();
+    private _hydrateFromPayload;
+    getKeyList(nuxtApp?: any): Promise<Array<string>>;
+    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
+    remove(key: string, nuxtApp?: any): Promise<void>;
+    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
+    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    cleanupExpired(): Promise<void>;
+}
+
+declare class CApplicationCache extends ACacheProvider {
+    private static instance;
+    private static _storage;
+    private static get storage();
+    static getInstance(): CApplicationCache;
+    static getSnapshot(): Map<string, ICacheEntry<any>>;
+    private constructor();
+    getKeyList(nuxtApp?: any): Promise<Array<string>>;
+    get<T>(key: string, nuxtApp?: any): Promise<T | null>;
+    set<T>(key: string, data: T, lifetime: number, nuxtApp?: any): Promise<void>;
+    remove(key: string, nuxtApp?: any): Promise<void>;
+    removeByPrefix(prefix: string, nuxtApp?: any): Promise<void>;
+    getRemainingTime(key: string, nuxtApp?: any): Promise<number | null>;
+    cleanupExpired(): Promise<void>;
+}
+
+export { AAPIDataProvider, ADataProvider, CAPIFlatClientDataProvider, CAPIFlatServerDataProvider, CAPITreeClientDataProvider, CAPITreeServerDataProvider, CApplicationCache, CCookieCache, CFlatClientDataProvider, CFlatServerDataProvider, CIndexedDBCache, CLocalStorageCache, CMemoryCache, CSessionCache, CTreeClientDataProvider, CTreeServerDataProvider, CacheProviderFactory, ECacheStrategy, EDataFilterOperator, RequestProvider };
+export type { ICacheEntry, IDataFilter, IDataProviderOptions, IDataResult, IDataSort, IKDatatableAction, IRequestOptions, ITreeDataProviderOptions, ITreeNode, ITreeNodeStatic, KProductItemData, KProductRowAction, TDataRow, TPageDataHandler, TreePaginationMode };