forlogic-core 1.15.2 → 1.15.4

package/dist/types.d.ts

@@ -0,0 +1,499 @@
+import React from 'react';
+export type LoadingState = 'idle' | 'loading' | 'success' | 'error';
+export type ViewMode = 'table';
+export type SortDirection = 'asc' | 'desc';
+export type ActionType = 'create' | 'update' | 'delete' | 'fetch' | 'export';
+/**
+ * BaseEntity - Interface mínima para todas as entidades
+ * Contém apenas campos essenciais presentes em todas as tabelas
+ */
+export interface BaseEntity {
+    id: string;
+    alias: string;
+    created_at: string;
+    updated_at: string;
+    is_removed: boolean;
+    is_actived: boolean;
+}
+/**
+ * BaseEntityPayload - Payload básico para criação de entidades
+ * IMPORTANTE: Customize conforme as propriedades da sua entidade específica
+ */
+export interface BaseEntityPayload {
+    alias: string;
+}
+export interface QueryParams {
+    page?: number;
+    limit?: number;
+    search?: string;
+    sortField?: string;
+    sortDirection?: SortDirection;
+}
+export interface PaginatedResponse<T = unknown> {
+    data: T[];
+    currentPage: number;
+    totalPages: number;
+    totalItems: number;
+    itemsPerPage: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+}
+export interface SortState {
+    field: string;
+    direction: SortDirection;
+}
+export interface CrudManager<T extends BaseEntity> {
+    entities: T[];
+    pagination: PaginatedResponse<T>;
+    isLoading: boolean;
+    isDeleting: boolean;
+    searchTerm: string;
+    sortField: string;
+    sortDirection: SortDirection;
+    currentPage: number;
+    itemsPerPage: number;
+    handleSearch: (search: string) => void;
+    handleSort: (field: string) => void;
+    handlePageChange: (page: number) => void;
+    handleItemsPerPageChange: (limit: number) => void;
+    clearFilters: () => void;
+    deleteEntity: (id: string) => void;
+    refetch: () => void;
+    selectedIds: string[];
+    selectItem: (id: string) => void;
+    selectAll: () => void;
+    clearSelection: () => void;
+    isAllSelected: boolean;
+    bulkDelete?: (ids: string[]) => Promise<void>;
+    isBulkDeleting?: boolean;
+}
+export interface CrudEntity extends BaseEntity {
+}
+export interface CrudColumn<T = any> {
+    key: keyof T;
+    header: string;
+    label?: string;
+    type?: 'text' | 'number' | 'date' | 'boolean' | 'select' | 'textarea' | 'email' | 'tel';
+    required?: boolean;
+    sortable?: boolean;
+    filterable?: boolean;
+    searchable?: boolean;
+    options?: Array<{
+        label: string;
+        value: any;
+    }>;
+    render?: (item: T) => React.ReactNode;
+    validation?: (value: any) => string | undefined;
+    className?: string;
+    /** Minimum width in pixels (only applied in desktop view) */
+    minWidth?: number;
+    /** Maximum width in pixels for column resize */
+    maxWidth?: number;
+    /** Flex weight for distributing remaining space (only applied in desktop view) */
+    weight?: number;
+    /** Fixed width (overrides minWidth and weight) */
+    width?: number;
+    /** Whether the column can be resized (default: true when enableColumnResize is enabled) */
+    resizable?: boolean;
+}
+/**
+ * Filtro customizado para páginas CRUD
+ *
+ * Permite adicionar filtros personalizados (busca, selects, checkboxes, etc)
+ * nas páginas CRUD geradas automaticamente.
+ *
+ * **Tipos de filtro:**
+ * - `'search'`: Campo de busca padrão (integrado com `manager.searchTerm`)
+ * - `'select'`: Select nativo com opções predefinidas
+ * - `'custom'`: Componente React customizado (Select, Checkbox, etc)
+ *
+ * **Posicionamento:**
+ * - Desktop: Filtros aparecem inline na Action Bar (ao lado do botão "Novo")
+ * - Mobile: Filtros empilhados verticalmente abaixo do botão "Novo"
+ *
+ * @example
+ * ```typescript
+ * // Filtro de busca padrão
+ * const filters: CrudFilter[] = [
+ *   { type: 'search' }
+ * ];
+ *
+ * // Filtro select nativo
+ * const filters: CrudFilter[] = [
+ *   {
+ *     type: 'select',
+ *     placeholder: 'Filtrar por status',
+ *     options: [
+ *       { label: 'Todos', value: 'all' },
+ *       { label: 'Ativos', value: 'active' },
+ *       { label: 'Inativos', value: 'inactive' }
+ *     ],
+ *     value: statusFilter,
+ *     onChange: setStatusFilter
+ *   }
+ * ];
+ *
+ * // Filtro customizado com Select
+ * import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from 'forlogic-core';
+ *
+ * const filters: CrudFilter[] = [
+ *   {
+ *     type: 'custom',
+ *     component: ({ value, onChange }) => (
+ *       <Select value={value} onValueChange={onChange}>
+ *         <SelectTrigger className="w-[180px]">
+ *           <SelectValue placeholder="Status" />
+ *         </SelectTrigger>
+ *         <SelectContent>
+ *           <SelectItem value="all">Todos</SelectItem>
+ *           <SelectItem value="active">Ativos</SelectItem>
+ *           <SelectItem value="inactive">Inativos</SelectItem>
+ *         </SelectContent>
+ *       </Select>
+ *     ),
+ *     props: { value: statusFilter, onChange: setStatusFilter }
+ *   }
+ * ];
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Múltiplos filtros customizados
+ * function ProcessesPage() {
+ *   const [statusFilter, setStatusFilter] = useState('all');
+ *   const [typeFilter, setTypeFilter] = useState('all');
+ *
+ *   const filters: CrudFilter[] = [
+ *     { type: 'search' },
+ *     {
+ *       type: 'select',
+ *       placeholder: 'Status',
+ *       options: [
+ *         { label: 'Todos', value: 'all' },
+ *         { label: 'Ativos', value: 'active' },
+ *         { label: 'Inativos', value: 'inactive' }
+ *       ],
+ *       value: statusFilter,
+ *       onChange: setStatusFilter
+ *     },
+ *     {
+ *       type: 'custom',
+ *       component: TypeSelect,
+ *       props: { value: typeFilter, onChange: setTypeFilter }
+ *     }
+ *   ];
+ *
+ *   // Filtrar dados baseado nos filtros customizados
+ *   const filteredData = useMemo(() => {
+ *     let data = manager.entities;
+ *     if (statusFilter !== 'all') {
+ *       data = data.filter(item => item.status === statusFilter);
+ *     }
+ *     if (typeFilter !== 'all') {
+ *       data = data.filter(item => item.type === typeFilter);
+ *     }
+ *     return data;
+ *   }, [manager.entities, statusFilter, typeFilter]);
+ *
+ *   return <CrudPage manager={{ ...manager, entities: filteredData }} />;
+ * }
+ * ```
+ *
+ * @see {@link FilterBar} - Componente que renderiza os filtros
+ */
+export interface CrudFilter {
+    /** Tipo do filtro: 'search' para busca padrão, 'select' para select nativo, 'custom' para componente personalizado */
+    type: 'search' | 'select' | 'custom';
+    /** Placeholder para select (quando type='select') */
+    placeholder?: string;
+    /** Opções para select (quando type='select') */
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    /** Valor atual do filtro (quando type='select') */
+    value?: string;
+    /** Callback quando o valor muda (quando type='select') */
+    onChange?: (value: string) => void;
+    /** Componente React customizado (obrigatório quando type='custom') */
+    component?: React.ComponentType<any>;
+    /** Props passadas para o componente customizado (value, onChange, etc) */
+    props?: Record<string, any>;
+    /** Função para controlar visibilidade do filtro baseado no estado do manager */
+    show?: (manager: CrudManager<any>) => boolean;
+}
+export interface BulkAction<T extends BaseEntity> {
+    label: string;
+    icon?: React.ComponentType<{
+        size?: number;
+        className?: string;
+    }>;
+    variant?: 'default' | 'destructive' | 'outline';
+    action: (items: T[]) => void | Promise<void>;
+    confirmMessage?: string;
+    /** Se a ação está desabilitada */
+    disabled?: boolean;
+    /** Motivo do bloqueio (exibido em tooltip quando disabled=true) */
+    disabledReason?: string;
+}
+export interface CrudPageConfig<T extends CrudEntity> {
+    entityName: string;
+    entityNamePlural: string;
+    filters?: CrudFilter[];
+    columns: CrudColumn<T>[];
+    cardFields?: Array<{
+        key: keyof T;
+        label: string;
+        render?: (value: any, item: T) => React.ReactNode;
+    }>;
+    onNew?: () => void;
+    onEdit?: (entity: T) => void;
+    useCustomRouting?: boolean;
+    /** @deprecated Use showNewButton={false} instead */
+    hideNewButton?: boolean;
+    /** Exibir botão "Novo" (default: true) */
+    showNewButton?: boolean;
+    /** Texto customizado para o botão "Novo" */
+    newButtonLabel?: string;
+    newButtonText?: string;
+    title?: string;
+    searchPlaceholder?: string;
+    /** Exibir busca integrada na Action Bar (default: false - usa busca global) */
+    showSearch?: boolean;
+    /** Exibir Action Bar (default: true) */
+    showActionBar?: boolean;
+    enableBulkActions?: boolean;
+    bulkActions?: BulkAction<T>[];
+    customActions?: Array<{
+        label: string;
+        icon?: React.ComponentType<{
+            size?: number;
+            className?: string;
+        }>;
+        variant?: 'default' | 'destructive' | 'outline' | 'ghost';
+        action: () => void;
+        /** Se a ação está desabilitada */
+        disabled?: boolean;
+        /** Motivo do bloqueio (exibido em tooltip quando disabled=true) */
+        disabledReason?: string;
+    }>;
+    customRowActions?: (item: T) => Array<{
+        icon: any;
+        label: string;
+        onClick: () => void;
+    }>;
+    customListView?: (items: T[], manager?: CrudManager<T>) => React.ReactNode;
+}
+export interface EntityWithId {
+    id: string | number;
+}
+export type CreateEntityInput<T extends EntityWithId> = Omit<T, 'id' | 'created_at' | 'updated_at'>;
+export type UpdateEntityInput<T extends EntityWithId> = Partial<CreateEntityInput<T>>;
+export interface CrudOperations<T extends EntityWithId> {
+    getAll: () => Promise<T[]>;
+    getById: (id: string | number) => Promise<T | null>;
+    create: (data: CreateEntityInput<T>) => Promise<T>;
+    update: (id: string | number, data: UpdateEntityInput<T>) => Promise<T>;
+    delete: (id: string | number) => Promise<void>;
+    search?: (query: string) => Promise<T[]>;
+}
+export interface CrudConfig<T extends EntityWithId> {
+    title: string;
+    columns: CrudColumn<T>[];
+    searchPlaceholder?: string;
+    itemsPerPage?: number;
+    enableCreate?: boolean;
+    enableEdit?: boolean;
+    enableDelete?: boolean;
+    enableSearch?: boolean;
+    enableFilters?: boolean;
+    customActions?: Array<{
+        label: string;
+        icon?: React.ComponentType;
+        onClick: (item: T) => void;
+        variant?: 'default' | 'destructive' | 'outline';
+    }>;
+}
+export interface FormField {
+    name: string;
+    label: string;
+    type: 'text' | 'textarea' | 'select' | 'multiselect' | 'date' | 'datetime-local' | 'number' | 'user-select' | 'group' | 'checkbox' | 'switch' | 'email' | 'password' | 'color' | 'color-picker' | 'icon-picker' | 'custom';
+    required?: boolean;
+    disabled?: boolean;
+    options?: {
+        label: string;
+        value: string | number;
+    }[];
+    placeholder?: string;
+    component?: React.ComponentType<any>;
+    componentProps?: Record<string, any>;
+    value?: any;
+    defaultValue?: any;
+    dependsOn?: string;
+    computedValue?: (formData: any) => any;
+    validation?: {
+        custom?: (value: any, formData?: any) => string | undefined;
+    } | ((value: any, formData?: any) => string | undefined);
+    layout?: 'horizontal' | 'vertical';
+    className?: string;
+    fields?: FormField[];
+    onValueChange?: (value: any) => void;
+    step?: number;
+    rows?: number;
+    mode?: 'single' | 'multiple';
+    columns?: number;
+    render?: (props: {
+        value: any;
+        onChange: (value: any) => void;
+        error?: string;
+        disabled?: boolean;
+    }) => React.ReactNode;
+}
+export interface FormSection {
+    id: string;
+    title: string;
+    label?: string;
+    fields: FormField[];
+    component?: React.ComponentType<any>;
+    disabled?: boolean;
+    condition?: (formData: any) => boolean;
+}
+export interface BaseFormConfig<T> {
+    title: string;
+    sections: FormSection[];
+    initialData?: Partial<T>;
+    onSubmit: (data: T) => void;
+    onCancel: () => void;
+    submitButtonText?: string;
+    isMobile?: boolean;
+}
+export interface BaseFormProps<T> extends BaseFormConfig<T> {
+    open: boolean;
+}
+export interface GenericQueryConfig<TData, TParams> {
+    queryKey: string[];
+    queryFn: (params: TParams) => Promise<TData>;
+    params: TParams;
+    hookName: string;
+    enabled?: boolean;
+    defaultPagination?: {
+        currentPage: number;
+        totalPages: number;
+        totalItems: number;
+        itemsPerPage: number;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+    };
+    dataMapper?: (data: TData) => unknown;
+    dataExtractor?: (response: TData) => unknown;
+    paginationExtractor?: (response: TData) => unknown;
+}
+export interface GenericDataQueryResult<TItem> {
+    data: TItem[];
+    pagination: unknown;
+    isLoading: boolean;
+    error: unknown;
+    refetch: () => void;
+}
+export interface AuthTokens {
+    accessToken: string;
+    idToken: string;
+    supabaseToken?: string;
+}
+export interface UserInfo {
+    id: string;
+    email: string;
+    name: string;
+    identifier: string;
+    alias?: string;
+}
+export interface Company {
+    id: string;
+    alias: string;
+    name: string;
+}
+export interface SelectedUnit {
+    id: string;
+    name: string;
+    alias: string;
+}
+export interface CompanyTokenData {
+    id: string;
+    alias: string;
+    name: string;
+    payload: any;
+}
+export interface AuthState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    user: UserInfo | null;
+    alias: string | null;
+    companies: Company[];
+    selectedUnit: SelectedUnit | null;
+    userId: string | null;
+    userAlias: string | null;
+    placeId: string | null;
+    placeName: string | null;
+    activePlaceId?: string | null;
+    activePlaceName?: string | null;
+}
+export interface IdTokenPayload {
+    subNewId: string;
+    email: string;
+    name: string;
+    identifier: string;
+    default?: string;
+    [key: string]: any;
+}
+export interface AccessTokenPayload {
+    default?: string;
+    [key: string]: any;
+}
+export interface QualiexUser {
+    id?: string;
+    userId?: string;
+    userName?: string;
+    userEmail?: string;
+    displayName?: string;
+    placeId?: string | null;
+    placeName?: string | null;
+    roleId?: string;
+    roleName?: string;
+    companyId?: string;
+    companyName?: string;
+}
+export interface QualiexUserFieldMapping {
+    /** Nome do campo de ID de usuário na entidade (ex: "target_user_id") */
+    idField: string;
+    /** Nome do campo de saída para o nome (ex: "target_user_name"). Default: idField + "_name" */
+    nameField?: string;
+    /** Nome do campo de saída para o email (ex: "target_user_email"). Default: idField + "_email" */
+    emailField?: string;
+    /** Nome do campo de saída para o username (ex: "target_user_username"). Default: idField + "_username" */
+    usernameField?: string;
+}
+export interface QualiexEnrichmentConfig {
+    /** Sufixo padrão para campos de nome (default: "_name") */
+    userNameFieldSuffix?: string;
+    /** Sufixo padrão para campos de email (default: "_email") */
+    userEmailFieldSuffix?: string;
+    /** Sufixo padrão para campos de username (default: "_username") */
+    userUsernameFieldSuffix?: string;
+}
+export interface ApiResponse<T = unknown> {
+    data: T;
+    success: boolean;
+    message?: string;
+    error?: string;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings?: string[];
+}
+export interface NotificationConfig {
+    title: string;
+    description?: string;
+    type: 'success' | 'error' | 'warning' | 'info';
+    duration?: number;
+}

package/dist/utils/formatters/currencyFormatters.d.ts

@@ -0,0 +1 @@
+export declare const formatCurrency: (value: number | undefined | null, currency?: string, locale?: string) => string;

package/dist/utils/formatters/dateFormatters.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Formata uma string ISO 8601 para o formato de data/hora especificado,
+ * convertendo para o timezone do usuário
+ *
+ * @param dateString - String de data no formato ISO 8601 (ex: "2024-03-15T14:30:00Z")
+ * @param datetimeFormat - Máscara de formato date-fns (ex: "dd/MM/yyyy HH:mm")
+ * @param timezone - Identificador IANA do fuso horário (ex: "America/Sao_Paulo")
+ * @param locale - Código do locale para formatação de nomes de mês/dia
+ * @returns String formatada no timezone especificado ou mensagem de erro
+ *
+ * @example
+ * ```ts
+ * // Data UTC sendo exibida em Brasília (UTC-3)
+ * formatDatetime("2024-03-15T17:30:00Z", "dd/MM/yyyy HH:mm", "America/Sao_Paulo");
+ * // "15/03/2024 14:30"
+ *
+ * // Mesma data em Tokyo (UTC+9)
+ * formatDatetime("2024-03-15T17:30:00Z", "dd/MM/yyyy HH:mm", "Asia/Tokyo");
+ * // "16/03/2024 02:30"
+ *
+ * // Com formato americano
+ * formatDatetime("2024-03-15T17:30:00Z", "MM/dd/yyyy hh:mm a", "America/New_York", "en-US");
+ * // "03/15/2024 01:30 PM"
+ * ```
+ */
+export declare const formatDatetime: (dateString: string, datetimeFormat?: string, timezone?: string, locale?: string) => string;
+/**
+ * Formata uma string ISO 8601 para formato de data localizado (sem hora),
+ * convertendo para o timezone do usuário
+ *
+ * Usa o formato 'PP' do date-fns que se adapta automaticamente ao locale:
+ * - pt-BR: "15 de mar. de 2024"
+ * - en-US: "Mar 15, 2024"
+ * - es-ES: "15 mar 2024"
+ *
+ * @param dateString - String de data no formato ISO 8601
+ * @param locale - Código do locale para formatação
+ * @param timezone - Identificador IANA do fuso horário (para determinar a data correta)
+ * @returns String formatada ou mensagem de erro
+ *
+ * @example
+ * ```ts
+ * // Data UTC às 23:00 em Brasília ainda é dia 15
+ * formatDate("2024-03-15T23:00:00Z", "pt-BR", "America/Sao_Paulo");
+ * // "15 de mar. de 2024"
+ *
+ * // Mas em Tokyo (UTC+9) já é dia 16
+ * formatDate("2024-03-15T23:00:00Z", "en-US", "Asia/Tokyo");
+ * // "Mar 16, 2024"
+ * ```
+ */
+export declare const formatDate: (dateString: string, locale?: string, timezone?: string) => string;

package/dist/utils/index.d.ts

@@ -0,0 +1,8 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+export declare const trimTextFields: (data: any) => any;
+export declare const formatDatetime: (dateString: string) => string;
+export declare const formatCurrency: (value: number | undefined | null) => string;
+export declare const debounce: <T extends (...args: any[]) => any>(func: T, wait: number) => ((...args: Parameters<T>) => void);
+export declare const slugify: (text: string) => string;
+export { handleExternalLink } from './linkHelpers';

package/dist/utils/linkHelpers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Abre link externo em nova aba ou copia para clipboard se bloqueado pelo navegador
+ */
+export declare function handleExternalLink(url: string, e?: React.MouseEvent): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forlogic-core",
-  "version": "1.15.2",
+  "version": "1.15.4",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",