@archbase/data 3.0.0

package/dist/datasource/v2/ArchbaseRemoteDataSourceV2.d.ts

@@ -0,0 +1,182 @@
+import { Draft } from 'immer';
+import { ArchbaseQueryFilter } from '@archbase/core';
+import { DataSourceListener, IDataSourceValidator } from '../ArchbaseDataSource';
+import { IArchbaseDataSourceBase } from '../IArchbaseDataSourceBase';
+import { ArchbaseRemoteApiService } from '../../service/ArchbaseRemoteApiService';
+/**
+ * Estados possíveis do DataSource
+ */
+type DataSourceState = 'browse' | 'edit' | 'insert';
+/**
+ * Configuração para ArchbaseRemoteDataSourceV2
+ * Suporta configuração inicial com registros ou carregamento remoto
+ */
+export interface ArchbaseRemoteDataSourceV2Config<T> {
+    name: string;
+    label?: string;
+    service: ArchbaseRemoteApiService<T, any>;
+    records?: T[];
+    validator?: IDataSourceValidator;
+    defaultSortFields?: string[];
+    pageSize?: number;
+    onStateChange?: (prevRecords: T[], newRecords: T[]) => void;
+    onFieldError?: (fieldName: string, error: string) => void;
+    onError?: (error: string, originalError?: any) => void;
+}
+/**
+ * ArchbaseRemoteDataSourceV2 - Versão V2 com Immer e suporte a TanStack Query
+ *
+ * Esta implementação:
+ * - Garante imutabilidade completa com Immer
+ * - Preparada para integração com TanStack Query
+ * - Suporte para operações CRUD remotas
+ * - Gestão de cache e sincronização otimizada
+ * - Interface simplificada focada em funcionalidade V2
+ */
+export declare class ArchbaseRemoteDataSourceV2<T> implements IArchbaseDataSourceBase<T> {
+    private name;
+    private label;
+    private service;
+    private records;
+    private filteredRecords;
+    private currentIndex;
+    private state;
+    private listeners;
+    private originalRecord;
+    private validator?;
+    private lastDataChangedAt;
+    private lastDataBrowsingOn;
+    private grandTotalRecords;
+    private defaultSortFields;
+    private pageSize;
+    private active;
+    private onStateChange?;
+    private onFieldError?;
+    private onError?;
+    constructor(config: ArchbaseRemoteDataSourceV2Config<T>);
+    getName(): string;
+    getLabel(): string;
+    isActive(): boolean;
+    close(): void;
+    getCurrentRecord(): T | undefined;
+    getCurrentIndex(): number;
+    getTotalRecords(): number;
+    isEmpty(): boolean;
+    first(): void;
+    last(): void;
+    next(): void;
+    prior(): void;
+    goToRecord(index: number): void;
+    isFirst(): boolean;
+    isLast(): boolean;
+    isBOF(): boolean;
+    isEOF(): boolean;
+    isBrowsing(): boolean;
+    isEditing(): boolean;
+    isInserting(): boolean;
+    edit(): void;
+    cancel(): void;
+    insert(record: T): void;
+    save(callback?: Function): Promise<T>;
+    remove(callback?: Function): Promise<T | undefined>;
+    setFieldValue(fieldName: string, value: any): void;
+    getFieldValue(fieldName: string): any;
+    appendToFieldArray<K extends keyof T>(fieldName: K, item: T[K] extends Array<infer U> ? U : never): void;
+    updateFieldArrayItem<K extends keyof T>(fieldName: K, index: number, updater: (draft: T[K] extends Array<infer U> ? Draft<U> : never) => void): void;
+    removeFromFieldArray<K extends keyof T>(fieldName: K, index: number): void;
+    insertIntoFieldArray<K extends keyof T>(fieldName: K, index: number, item: T[K] extends Array<infer U> ? U : never): void;
+    getFieldArray<K extends keyof T>(fieldName: K): T[K] extends Array<infer U> ? U[] : never;
+    isFieldArray<K extends keyof T>(fieldName: K): boolean;
+    /**
+     * Interface de opções para refreshData - compatibilidade com V1
+     */
+    private currentPage;
+    private currentFilter?;
+    private currentSort?;
+    /**
+     * Atualiza os dados do DataSource com as opções fornecidas.
+     * Compatível com a interface do DataSource V1.
+     *
+     * @param options Opções de refresh incluindo página, filtro e ordenação
+     */
+    refreshData(options?: {
+        currentPage?: number;
+        pageSize?: number;
+        filter?: string;
+        sort?: string[];
+        originFilter?: any;
+        originGlobalFilter?: string;
+    }): void;
+    /**
+     * Carrega dados com filtro RSQL
+     */
+    private getDataWithRsqlFilter;
+    /**
+     * Retorna as opções atuais do DataSource - compatibilidade com V1
+     */
+    getOptions(): {
+        currentPage: number;
+        pageSize: number;
+        filter?: string;
+        sort?: string[];
+        grandTotalRecords: number;
+    };
+    applyRemoteFilter(filter: ArchbaseQueryFilter, page: number, callback?: (() => void) | undefined): void;
+    addListener(listener: DataSourceListener<T>): void;
+    removeListener(listener: DataSourceListener<T>): void;
+    private emit;
+    getGrandTotalRecords(): number;
+    getPageSize(): number;
+    setPageSize(pageSize: number): void;
+    /**
+     * Retorna a página atual (0-indexed)
+     */
+    getCurrentPage(): number;
+    /**
+     * Alias para getRecords - compatibilidade com V1
+     */
+    browseRecords(): T[];
+    getRecords(): T[];
+    /**
+     * Localiza um registro por valores de campos e navega para ele
+     * @param values Objeto com campos/valores para busca
+     * @returns true se encontrou, false caso contrário
+     */
+    locate(values: any): boolean;
+    /**
+     * Vai para um registro pelo seu índice (alias para goToRecord)
+     * @param index Índice do registro
+     */
+    gotoRecord(index: number): void;
+    /**
+     * Vai para um registro pelo seu dado
+     * @param record Dados do registro para navegar
+     * @returns true se encontrou, false caso contrário
+     */
+    gotoRecordByData(record: T): boolean;
+    setRecords(records: T[], totalElements?: number): void;
+    getDebugSnapshot(): {
+        name: string;
+        label: string;
+        recordCount: number;
+        currentIndex: number;
+        currentRecord: T;
+        state: DataSourceState;
+        listeners: number;
+        totalRecords: number;
+        pageSize: number;
+    };
+    private validateDataSourceActive;
+    private publishEventError;
+    private publishEventErrors;
+    private handleSaveError;
+    private notifyStateChange;
+    private setNestedValue;
+    private getNestedValue;
+    private getDataWithFilter;
+    private getDataWithoutFilter;
+    private getDataWithQuickFilter;
+    private getSortFields;
+    private handleRemoteError;
+}
+export {};

package/dist/datasource/v2/ArchbaseTanStackQueryIntegration.d.ts

@@ -0,0 +1,132 @@
+/**
+ * TanStack Query Integration for ArchbaseRemoteDataSourceV2
+ *
+ * This module provides integration between ArchbaseRemoteDataSourceV2 and TanStack Query
+ * for advanced caching, synchronization, and offline capabilities.
+ */
+import { QueryClient } from '@tanstack/react-query';
+import { ArchbaseRemoteDataSourceV2 } from './ArchbaseRemoteDataSourceV2';
+import { ArchbaseRemoteApiService } from '../../service/ArchbaseRemoteApiService';
+import { ArchbaseQueryFilter } from '@archbase/core';
+/**
+ * Configuration for TanStack Query integration
+ */
+export interface ArchbaseTanStackQueryConfig {
+    /** Cache time in milliseconds (default: 5 minutes) */
+    cacheTime?: number;
+    /** Stale time in milliseconds (default: 30 seconds) */
+    staleTime?: number;
+    /** Refetch on window focus (default: false) */
+    refetchOnWindowFocus?: boolean;
+    /** Refetch on reconnect (default: true) */
+    refetchOnReconnect?: boolean;
+    /** Retry count (default: 3) */
+    retry?: number;
+    /** Enable background updates (default: true) */
+    refetchInterval?: number | false;
+}
+/**
+ * Default TanStack Query configuration
+ */
+export declare const DEFAULT_TANSTACK_CONFIG: ArchbaseTanStackQueryConfig;
+/**
+ * Query keys factory for consistent caching
+ */
+export declare class ArchbaseQueryKeys {
+    private static base;
+    static all: readonly ["archbase"];
+    static datasource: (name: string) => readonly ["archbase", "datasource", string];
+    static records: (name: string, filter?: ArchbaseQueryFilter, page?: number) => readonly ["archbase", "datasource", string, "records", {
+        readonly filter: ArchbaseQueryFilter;
+        readonly page: number;
+    }];
+    static record: (name: string, id: any) => readonly ["archbase", "datasource", string, "record", any];
+    static count: (name: string, filter?: ArchbaseQueryFilter) => readonly ["archbase", "datasource", string, "count", {
+        readonly filter: ArchbaseQueryFilter;
+    }];
+}
+/**
+ * Enhanced RemoteDataSource with TanStack Query integration
+ */
+export declare class ArchbaseRemoteDataSourceV2WithQuery<T> extends ArchbaseRemoteDataSourceV2<T> {
+    private queryClient;
+    private queryConfig;
+    constructor(config: {
+        name: string;
+        service: ArchbaseRemoteApiService<T, any>;
+        queryClient: QueryClient;
+        pageSize?: number;
+        queryConfig?: ArchbaseTanStackQueryConfig;
+        onStateChange?: (prevRecords: T[], newRecords: T[]) => void;
+    });
+    /**
+     * Load data with TanStack Query caching
+     */
+    loadWithQuery(filter?: ArchbaseQueryFilter, page?: number): Promise<void>;
+    /**
+     * Save record with optimistic updates
+     */
+    saveWithOptimisticUpdate(): Promise<T>;
+    /**
+     * Remove record with optimistic updates
+     */
+    removeWithOptimisticUpdate(): Promise<T | undefined>;
+    /**
+     * Prefetch next page for better UX
+     */
+    prefetchNextPage(): Promise<void>;
+    /**
+     * Invalidate all cache for this datasource
+     */
+    invalidateCache(): Promise<void>;
+    /**
+     * Get cached data without triggering a request
+     */
+    getCachedData(filter?: ArchbaseQueryFilter, page?: number): T[] | undefined;
+    /**
+     * Check if data is stale and needs refresh
+     */
+    isDataStale(filter?: ArchbaseQueryFilter, page?: number): boolean;
+}
+/**
+ * Result type for useArchbaseRemoteDataSourceWithQuery hook
+ */
+export interface UseArchbaseRemoteDataSourceWithQueryResult<T> {
+    dataSource: ArchbaseRemoteDataSourceV2WithQuery<T>;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isRefetching: boolean;
+    records: T[];
+    currentRecord: T | undefined;
+    totalRecords: number;
+    currentPage: number;
+    totalPages: number;
+    refetch: () => Promise<any>;
+    save: () => Promise<T>;
+    remove: () => Promise<T | undefined>;
+    invalidateCache: () => Promise<void>;
+    prefetchNextPage: () => Promise<void>;
+    isSaving: boolean;
+    isRemoving: boolean;
+    saveError: Error | null;
+    removeError: Error | null;
+}
+/**
+ * React Hook for RemoteDataSource with TanStack Query
+ */
+export declare function useArchbaseRemoteDataSourceWithQuery<T>(config: {
+    name: string;
+    service: ArchbaseRemoteApiService<T, any>;
+    pageSize?: number;
+    queryConfig?: ArchbaseTanStackQueryConfig;
+    filter?: ArchbaseQueryFilter;
+    enabled?: boolean;
+}): UseArchbaseRemoteDataSourceWithQueryResult<T>;
+/**
+ * Hook for real-time data synchronization
+ */
+export declare function useArchbaseRealTimeSync<T>(dataSourceName: string, options?: {
+    interval?: number;
+    enabled?: boolean;
+}): void;

package/dist/datasource/v2/index.d.ts

@@ -0,0 +1,11 @@
+export { ArchbaseDataSourceV2 } from './ArchbaseDataSourceV2';
+export type { ArchbaseDataSourceV2Config } from './ArchbaseDataSourceV2';
+export { ArchbaseRemoteDataSourceV2 } from './ArchbaseRemoteDataSourceV2';
+export type { ArchbaseRemoteDataSourceV2Config } from './ArchbaseRemoteDataSourceV2';
+export { useArchbaseDataSourceV2, useArchbaseDataSourceV2ReadOnly, useArchbaseDataSourceV2Editor } from './useArchbaseDataSourceV2';
+export type { UseArchbaseDataSourceV2Return } from './useArchbaseDataSourceV2';
+export { useArchbaseRemoteDataSourceV2, useArchbaseRemoteDataSourceV2ReadOnly, useArchbaseRemoteDataSourceV2Editor } from './useArchbaseRemoteDataSourceV2';
+export type { UseArchbaseRemoteDataSourceV2Return } from './useArchbaseRemoteDataSourceV2';
+export type { ArchbaseTanStackQueryConfig, ArchbaseQueryOperations, ArchbaseQueryState, ArchbaseQueryHookReturn } from './ArchbaseQueryIntegration';
+export { ArchbaseQueryUtils, ARCHBASE_QUERY_DEFAULTS } from './ArchbaseQueryIntegration';
+export type { DataSourceOptions, FilterFn, IDataSourceValidator, DataSourceEvent, DataSourceEventNames } from '../ArchbaseDataSource';

package/dist/datasource/v2/useArchbaseDataSourceV2.d.ts

@@ -0,0 +1,143 @@
+import { ArchbaseDataSourceV2, ArchbaseDataSourceV2Config } from './ArchbaseDataSourceV2';
+/**
+ * Hook para usar ArchbaseDataSourceV2 de forma reativa no React
+ *
+ * Este hook provê:
+ * - Gerenciamento automático do ciclo de vida do DataSource
+ * - Estado reativo baseado em eventos
+ * - Cleanup automático no unmount
+ * - Type safety completa
+ * - Performance otimizada com callbacks memoizados
+ */
+export declare function useArchbaseDataSourceV2<T, ID = any>(config: ArchbaseDataSourceV2Config<T>): {
+    dataSource: ArchbaseDataSourceV2<T>;
+    currentRecord: T;
+    currentIndex: number;
+    totalRecords: number;
+    isLoading: boolean;
+    canNext: boolean;
+    canPrior: boolean;
+    isEmpty: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+    isBrowsing: boolean;
+    isEditing: boolean;
+    isInserting: boolean;
+    setFieldValue: (fieldName: string, value: any) => void;
+    getFieldValue: (fieldName: string) => any;
+    edit: () => void;
+    save: () => Promise<T>;
+    cancel: () => void;
+    insert: (record: T) => void;
+    remove: (callback?: Function) => Promise<T>;
+    first: () => void;
+    last: () => void;
+    next: () => void;
+    prior: () => void;
+    goToRecord: (index: number) => void;
+    appendToFieldArray: <K extends keyof T>(fieldName: K, item: T[K] extends Array<infer U> ? U : never) => void;
+    updateFieldArrayItem: <K extends keyof T>(fieldName: K, index: number, updater: (draft: any) => void) => void;
+    removeFromFieldArray: <K extends keyof T>(fieldName: K, index: number) => void;
+    insertIntoFieldArray: <K extends keyof T>(fieldName: K, index: number, item: T[K] extends Array<infer U> ? U : never) => void;
+    getFieldArray: <K extends keyof T>(fieldName: K) => any[];
+    isFieldArray: <K extends keyof T>(fieldName: K) => boolean;
+    getDebugInfo: () => {
+        hookState: {
+            currentRecord: T;
+            currentIndex: number;
+            totalRecords: number;
+            isBrowsing: boolean;
+            isEditing: boolean;
+            isInserting: boolean;
+            isLoading: boolean;
+        };
+        name: string;
+        recordCount: number;
+        currentIndex: number;
+        currentRecord: T;
+        state: "insert" | "edit" | "browse";
+        listeners: number;
+    };
+};
+/**
+ * Tipo para o retorno do hook useArchbaseDataSourceV2
+ */
+export type UseArchbaseDataSourceV2Return<T> = ReturnType<typeof useArchbaseDataSourceV2<T, any>>;
+/**
+ * Hook customizado para componentes que precisam apenas de leitura
+ * Otimizado para performance - não re-renderiza em mudanças de campo
+ */
+export declare function useArchbaseDataSourceV2ReadOnly<T, ID = any>(config: ArchbaseDataSourceV2Config<T>): {
+    dataSource: ArchbaseDataSourceV2<T>;
+    currentRecord: T;
+    currentIndex: number;
+    totalRecords: number;
+    canNext: boolean;
+    canPrior: boolean;
+    isEmpty: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+    isBrowsing: boolean;
+    first: () => void;
+    last: () => void;
+    next: () => void;
+    prior: () => void;
+    goToRecord: (index: number) => void;
+    getFieldValue: (fieldName: string) => any;
+    getFieldArray: <K extends keyof T>(fieldName: K) => any[];
+    isFieldArray: <K extends keyof T>(fieldName: K) => boolean;
+};
+/**
+ * Hook customizado para componentes de edição
+ * Inclui todas as operações de modificação
+ */
+export declare function useArchbaseDataSourceV2Editor<T, ID = any>(config: ArchbaseDataSourceV2Config<T>): {
+    dataSource: ArchbaseDataSourceV2<T>;
+    currentRecord: T;
+    currentIndex: number;
+    totalRecords: number;
+    isLoading: boolean;
+    canNext: boolean;
+    canPrior: boolean;
+    isEmpty: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+    isBrowsing: boolean;
+    isEditing: boolean;
+    isInserting: boolean;
+    setFieldValue: (fieldName: string, value: any) => void;
+    getFieldValue: (fieldName: string) => any;
+    edit: () => void;
+    save: () => Promise<T>;
+    cancel: () => void;
+    insert: (record: T) => void;
+    remove: (callback?: Function) => Promise<T>;
+    first: () => void;
+    last: () => void;
+    next: () => void;
+    prior: () => void;
+    goToRecord: (index: number) => void;
+    appendToFieldArray: <K extends keyof T>(fieldName: K, item: T[K] extends (infer U)[] ? U : never) => void;
+    updateFieldArrayItem: <K extends keyof T>(fieldName: K, index: number, updater: (draft: any) => void) => void;
+    removeFromFieldArray: <K extends keyof T>(fieldName: K, index: number) => void;
+    insertIntoFieldArray: <K extends keyof T>(fieldName: K, index: number, item: T[K] extends (infer U)[] ? U : never) => void;
+    getFieldArray: <K extends keyof T>(fieldName: K) => any[];
+    isFieldArray: <K extends keyof T>(fieldName: K) => boolean;
+    getDebugInfo: () => {
+        hookState: {
+            currentRecord: T;
+            currentIndex: number;
+            totalRecords: number;
+            isBrowsing: boolean;
+            isEditing: boolean;
+            isInserting: boolean;
+            isLoading: boolean;
+        };
+        name: string;
+        recordCount: number;
+        currentIndex: number;
+        currentRecord: T;
+        state: "insert" | "edit" | "browse";
+        listeners: number;
+    };
+};

package/dist/datasource/v2/useArchbaseRemoteDataSourceV2.d.ts

@@ -0,0 +1,210 @@
+import { ArchbaseRemoteDataSourceV2, ArchbaseRemoteDataSourceV2Config } from './ArchbaseRemoteDataSourceV2';
+import { ArchbaseQueryFilter } from '@archbase/core';
+/**
+ * Hook para usar ArchbaseRemoteDataSourceV2 de forma reativa no React
+ *
+ * Este hook provê:
+ * - Gerenciamento automático do ciclo de vida do RemoteDataSource
+ * - Estado reativo baseado em eventos
+ * - Cleanup automático no unmount
+ * - Type safety completa
+ * - Performance otimizada com callbacks memoizados
+ * - Operações remotas (CRUD, filtragem, paginação)
+ */
+export declare function useArchbaseRemoteDataSourceV2<T, ID = any>(config: ArchbaseRemoteDataSourceV2Config<T>): {
+    dataSource: ArchbaseRemoteDataSourceV2<T>;
+    currentRecord: T;
+    currentIndex: number;
+    totalRecords: number;
+    grandTotalRecords: number;
+    isLoading: boolean;
+    error: string;
+    canNext: boolean;
+    canPrior: boolean;
+    isEmpty: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+    isBrowsing: boolean;
+    isEditing: boolean;
+    isInserting: boolean;
+    setFieldValue: (fieldName: string, value: any) => void;
+    getFieldValue: (fieldName: string) => any;
+    edit: () => void;
+    save: () => Promise<T>;
+    cancel: () => void;
+    insert: (record: T) => void;
+    remove: (callback?: Function) => Promise<T>;
+    first: () => void;
+    last: () => void;
+    next: () => void;
+    prior: () => void;
+    goToRecord: (index: number) => void;
+    appendToFieldArray: <K extends keyof T>(fieldName: K, item: T[K] extends Array<infer U> ? U : never) => void;
+    updateFieldArrayItem: <K extends keyof T>(fieldName: K, index: number, updater: (draft: any) => void) => void;
+    removeFromFieldArray: <K extends keyof T>(fieldName: K, index: number) => void;
+    insertIntoFieldArray: <K extends keyof T>(fieldName: K, index: number, item: T[K] extends Array<infer U> ? U : never) => void;
+    getFieldArray: <K extends keyof T>(fieldName: K) => T[K] extends (infer U)[] ? U[] : never;
+    isFieldArray: <K extends keyof T>(fieldName: K) => boolean;
+    applyRemoteFilter: (filter: ArchbaseQueryFilter, page: number, callback?: (() => void) | undefined) => void;
+    refreshData: (options?: {
+        currentPage?: number;
+        pageSize?: number;
+        filter?: string;
+        sort?: string[];
+    }) => Promise<void>;
+    setPageSize: (pageSize: number) => void;
+    getPageSize: () => number;
+    getDebugInfo: () => {
+        hookState: {
+            currentRecord: T;
+            currentIndex: number;
+            totalRecords: number;
+            grandTotalRecords: number;
+            isBrowsing: boolean;
+            isEditing: boolean;
+            isInserting: boolean;
+            isLoading: boolean;
+            error: string;
+        };
+        name: string;
+        label: string;
+        recordCount: number;
+        currentIndex: number;
+        currentRecord: T;
+        state: "insert" | "edit" | "browse";
+        listeners: number;
+        totalRecords: number;
+        pageSize: number;
+    };
+};
+/**
+ * Tipo para o retorno do hook useArchbaseRemoteDataSourceV2
+ */
+export type UseArchbaseRemoteDataSourceV2Return<T> = ReturnType<typeof useArchbaseRemoteDataSourceV2<T, any>>;
+/**
+ * Hook customizado para componentes que precisam apenas de leitura
+ * Otimizado para performance - não re-renderiza em mudanças de campo
+ */
+export declare function useArchbaseRemoteDataSourceV2ReadOnly<T, ID = any>(config: ArchbaseRemoteDataSourceV2Config<T>): {
+    dataSource: ArchbaseRemoteDataSourceV2<T>;
+    currentRecord: T;
+    currentIndex: number;
+    totalRecords: number;
+    grandTotalRecords: number;
+    isLoading: boolean;
+    error: string;
+    canNext: boolean;
+    canPrior: boolean;
+    isEmpty: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+    isBrowsing: boolean;
+    first: () => void;
+    last: () => void;
+    next: () => void;
+    prior: () => void;
+    goToRecord: (index: number) => void;
+    getFieldValue: (fieldName: string) => any;
+    getFieldArray: <K extends keyof T>(fieldName: K) => T[K] extends (infer U)[] ? U[] : never;
+    isFieldArray: <K extends keyof T>(fieldName: K) => boolean;
+    applyRemoteFilter: (filter: ArchbaseQueryFilter, page: number, callback?: () => void) => void;
+    refreshData: (options?: {
+        currentPage?: number;
+        pageSize?: number;
+        filter?: string;
+        sort?: string[];
+    }) => Promise<void>;
+    getPageSize: () => number;
+    getDebugInfo: () => {
+        hookState: {
+            currentRecord: T;
+            currentIndex: number;
+            totalRecords: number;
+            grandTotalRecords: number;
+            isBrowsing: boolean;
+            isEditing: boolean;
+            isInserting: boolean;
+            isLoading: boolean;
+            error: string;
+        };
+        name: string;
+        label: string;
+        recordCount: number;
+        currentIndex: number;
+        currentRecord: T;
+        state: "insert" | "edit" | "browse";
+        listeners: number;
+        totalRecords: number;
+        pageSize: number;
+    };
+};
+/**
+ * Hook customizado para componentes de edição
+ * Inclui todas as operações de modificação
+ */
+export declare function useArchbaseRemoteDataSourceV2Editor<T, ID = any>(config: ArchbaseRemoteDataSourceV2Config<T>): {
+    dataSource: ArchbaseRemoteDataSourceV2<T>;
+    currentRecord: T;
+    currentIndex: number;
+    totalRecords: number;
+    grandTotalRecords: number;
+    isLoading: boolean;
+    error: string;
+    canNext: boolean;
+    canPrior: boolean;
+    isEmpty: boolean;
+    isFirst: boolean;
+    isLast: boolean;
+    isBrowsing: boolean;
+    isEditing: boolean;
+    isInserting: boolean;
+    setFieldValue: (fieldName: string, value: any) => void;
+    getFieldValue: (fieldName: string) => any;
+    edit: () => void;
+    save: () => Promise<T>;
+    cancel: () => void;
+    insert: (record: T) => void;
+    remove: (callback?: Function) => Promise<T>;
+    first: () => void;
+    last: () => void;
+    next: () => void;
+    prior: () => void;
+    goToRecord: (index: number) => void;
+    appendToFieldArray: <K extends keyof T>(fieldName: K, item: T[K] extends (infer U)[] ? U : never) => void;
+    updateFieldArrayItem: <K extends keyof T>(fieldName: K, index: number, updater: (draft: any) => void) => void;
+    removeFromFieldArray: <K extends keyof T>(fieldName: K, index: number) => void;
+    insertIntoFieldArray: <K extends keyof T>(fieldName: K, index: number, item: T[K] extends (infer U)[] ? U : never) => void;
+    getFieldArray: <K extends keyof T>(fieldName: K) => T[K] extends (infer U)[] ? U[] : never;
+    isFieldArray: <K extends keyof T>(fieldName: K) => boolean;
+    applyRemoteFilter: (filter: ArchbaseQueryFilter, page: number, callback?: () => void) => void;
+    refreshData: (options?: {
+        currentPage?: number;
+        pageSize?: number;
+        filter?: string;
+        sort?: string[];
+    }) => Promise<void>;
+    setPageSize: (pageSize: number) => void;
+    getPageSize: () => number;
+    getDebugInfo: () => {
+        hookState: {
+            currentRecord: T;
+            currentIndex: number;
+            totalRecords: number;
+            grandTotalRecords: number;
+            isBrowsing: boolean;
+            isEditing: boolean;
+            isInserting: boolean;
+            isLoading: boolean;
+            error: string;
+        };
+        name: string;
+        label: string;
+        recordCount: number;
+        currentIndex: number;
+        currentRecord: T;
+        state: "insert" | "edit" | "browse";
+        listeners: number;
+        totalRecords: number;
+        pageSize: number;
+    };
+};

package/dist/hooks/index.d.ts

@@ -0,0 +1,14 @@
+export * from './useArchbaseDataSource';
+export * from './useArchbaseDataSourceListener';
+export * from './useArchbaseLocalFilterDataSource';
+export * from './useArchbaseRemoteDataSource';
+export * from './useArchbaseRemoteFilterDataSource';
+export * from './useArchbaseRemoteServiceApi';
+export * from './useArchbaseDidMount';
+export * from './useArchbaseDidUpdate';
+export * from './useArchbaseWillUnmount';
+export * from './useArchbaseForceRerender';
+export * from './useArchbaseForceUpdate';
+export * from './useArchbaseStore';
+export type { ArchbaseStore } from '@archbase/core';
+export * from './useArchbaseEventListener';