@club-employes/utopia 4.71.0 → 4.73.0

package/dist/components/organisms/Table/types.d.ts

@@ -0,0 +1,545 @@
+import { IconSize } from '../../atoms/Icon/types';
+import { TextSize, TextWeight } from '../../atoms/Text/types';
+import { DropDownOption } from '../../molecules/DropDown/types';
+import { DataTableFilterMeta } from 'primevue/datatable';
+import { ButtonVariant, ButtonSize } from '../../atoms/Button/types';
+export type ColumnFilterMatchModeOptions = Record<string, string>;
+export declare enum CellFilterType {
+    TEXT = "text",
+    TAG = "tag",
+    DATE = "date",
+    DATE_RANGE = "dateRange",
+    SELECT = "select",
+    EMAIL = "email",
+    NUMBER = "number"
+}
+export declare enum CellContentType {
+    TEXT_IMAGE = "textImage",
+    TAG = "tag",
+    PRICE = "price",
+    DATE = "date",
+    TIME = "time",
+    DATE_TIME = "dateTime",
+    DATE_RANGE = "dateRange",
+    DROPDOWN = "dropdown",
+    TOGGLE = "toggle",
+    PROGRESS_BAR = "progressBar",
+    ACTIONS = "actions",
+    CUSTOM = "custom"
+}
+export type CellContent = TextImageContentType | DateContentType | DateRangeContentType | PriceContentType | TagContentType | DropdownContentType | ProgressBarContentType | ActionsContentType | ToggleContentType;
+export interface ColumnType {
+    columnKey: string;
+    label: string;
+    content: CellContent;
+    contentType: CellContentType;
+    filterType?: CellFilterType;
+    field?: string | ((item: string) => string | number | boolean | null | undefined);
+    sortField?: string | ((item: string) => string | number | boolean | null | undefined);
+    filterField?: string | ((item: string) => string | number | boolean | null | undefined);
+    format?: (value: string | number | boolean | null | undefined) => string | number | boolean | null | undefined;
+    order?: number;
+    /**
+     * Désactive le tri pour cette colonne spécifique.
+     * Si `undefined`, utilise la valeur globale `sortable` du tableau.
+     * Si `false`, désactive le tri même si `sortable` est `true` sur le tableau.
+     */
+    sortable?: boolean;
+    /**
+     * Masque la ligne de recherche/filtre pour cette colonne (contrôle l'affichage).
+     * Si `undefined`, utilise la valeur globale `searchable` du tableau.
+     * Si `false`, masque la ligne de recherche même si `searchable` est `true` sur le tableau.
+     */
+    searchable?: boolean;
+    /**
+     * Désactive le filtrage pour cette colonne (contrôle la fonctionnalité).
+     * Si `undefined`, utilise la valeur globale `filterable` du tableau.
+     * Si `false`, désactive le filtrage même si `filterable` est `true` sur le tableau.
+     */
+    filterable?: boolean;
+    /**
+     * Désactive l'édition pour cette colonne.
+     * Si `undefined`, utilise la valeur globale `editable` du tableau.
+     * Si `false`, désactive l'édition même si `editable` est `true` sur le tableau.
+     */
+    editable?: boolean;
+    /**
+     * Désactive la réorganisation pour cette colonne.
+     * Si `undefined`, utilise la valeur globale `reorderableColumns` du tableau.
+     * Si `false`, désactive la réorganisation même si `reorderableColumns` est `true` sur le tableau.
+     */
+    reorderableColumn?: boolean;
+    filterMatchModeOptions?: ColumnFilterMatchModeOptions[];
+    showFilterMatchModes?: boolean;
+    showFilterOperator?: boolean;
+    showClearButton?: boolean;
+    showApplyButton?: boolean;
+    excludeGlobalFilter?: boolean;
+    /** Largeur minimale de la colonne (ex: '200px') */
+    minWidth?: string;
+    /** Alignement du contenu dans les cellules */
+    align?: 'left' | 'center' | 'right';
+    /**
+     * Colonne "gelée" (fixe lors du défilement horizontal).
+     * ⚠️ **IMPORTANT** : Pour que cette propriété fonctionne, la prop `scrollable` du tableau doit être `true`.
+     * @example
+     * ```vue
+     * <Table :data="data" :columns="columns" scrollable>
+     *   <!-- Colonnes avec frozen: true -->
+     * </Table>
+     * ```
+     */
+    frozen?: boolean;
+    /**
+     * Alignement de la colonne gelée (gauche ou droite).
+     * ⚠️ **IMPORTANT** : Ne s'applique que si `frozen` est `true` et que `scrollable` est `true` sur le tableau.
+     * @default 'left'
+     */
+    alignFrozen?: 'left' | 'right';
+    dataType?: string;
+    header?: string;
+    footer?: string;
+    style?: string | object;
+    class?: string | object;
+    classes?: string;
+    headerStyle?: string | object;
+    headerClass?: string | object;
+    bodyStyle?: string | object;
+    bodyClass?: string | object;
+    footerStyle?: string | object;
+    footerClass?: string | object;
+    filter?: boolean;
+    filterMatchMode?: string;
+    maxConstraints?: number;
+    selectionMode?: 'single' | 'multiple';
+    expander?: boolean;
+    rowReorder?: boolean;
+    rowReorderIcon?: string;
+    colspan?: number;
+    rowspan?: number;
+    exportable?: boolean;
+    exportHeader?: string;
+    exportFooter?: string;
+    hidden?: boolean;
+    pt?: Record<string, string | number | boolean | null | undefined>;
+    ptOptions?: Record<string, string | number | boolean | null | undefined>;
+    unstyled?: boolean;
+}
+/**
+ * Type pour représenter une erreur de validation d'un champ
+ * Les erreurs sont ajoutées par le backend après validation
+ */
+/**
+ * Type pour les valeurs de validation min/max avec support de différents formats
+ */
+export type ValidationValue = number | Date | string | {
+    /** Valeur de la validation (peut être un nombre, une date ISO, 'today', ou un nom de champ) */
+    value: number | string;
+    /** Type de la validation : 'number' | 'date' | 'field' */
+    type: 'number' | 'date' | 'field';
+};
+export interface ErrorType {
+    /** Nom du champ concerné par l'erreur */
+    field: string;
+    /** Message d'erreur à afficher */
+    message: string;
+    /** Code d'erreur optionnel */
+    code?: string;
+    /** Pattern regex pour valider le format (ex: email, téléphone) */
+    pattern?: string;
+    /** Longueur minimale (pour les strings) */
+    minLength?: number;
+    /** Longueur maximale (pour les strings) */
+    maxLength?: number;
+    /**
+     * Valeur minimale (pour les nombres) ou date minimale (pour les dates).
+     * Peut être :
+     * - Un nombre : `min: 10`
+     * - Une Date : `min: new Date('2025-01-01')`
+     * - Une string (date ISO) : `min: '2025-01-01'`
+     * - Un objet avec value et type : `min: { value: 10, type: 'number' }` ou `min: { value: 'today', type: 'date' }` ou `min: { value: 'startDate', type: 'field' }`
+     */
+    min?: ValidationValue;
+    /**
+     * Valeur maximale (pour les nombres) ou date maximale (pour les dates).
+     * Peut être :
+     * - Un nombre : `max: 100`
+     * - Une Date : `max: new Date()`
+     * - Une string (date ISO) : `max: '2025-12-31'`
+     * - Un objet avec value et type : `max: { value: 100, type: 'number' }` ou `max: { value: 'today', type: 'date' }` ou `max: { value: 'maxPrice', type: 'field' }`
+     */
+    max?: ValidationValue;
+    /** Indique si le champ est requis */
+    required?: boolean;
+}
+/**
+ * Type générique pour les données d'une ligne du tableau.
+ * Permet d'avoir un attribut `errors` optionnel pour la validation backend.
+ *
+ * @example
+ * interface User {
+ *   id: number
+ *   name: string
+ *   email: string
+ *   profile: { avatar: string }
+ * }
+ *
+ * type UserWithErrors = TableRowData<User>
+ * // Résultat: User & { errors?: ErrorType[] }
+ */
+export type TableRowData<T = Record<string, any>> = T & {
+    /** Tableau d'erreurs de validation pour cette ligne (ajouté par le backend) */
+    errors?: ErrorType[];
+};
+export interface TableProps<T = Record<string, any>> {
+    /** Données du tableau. Chaque ligne peut avoir un attribut `errors` pour les erreurs de validation */
+    data?: TableRowData<T>[];
+    filters?: DataTableFilterMeta;
+    filterDisplay?: 'menu' | 'row';
+    globalFilterFields?: string[];
+    filterLocale?: string;
+    /**
+     * Autorise le tri sur toutes les colonnes.
+     * Peut être surchargé par colonne avec `ColumnType.sortable`.
+     * @default true
+     */
+    sortable?: boolean;
+    /**
+     * Affiche la ligne de recherche/filtre (contrôle l'affichage).
+     * Peut être surchargé par colonne avec `ColumnType.searchable`.
+     * @default true
+     */
+    searchable?: boolean;
+    /**
+     * Autorise le filtrage sur toutes les colonnes (contrôle la fonctionnalité).
+     * Peut être surchargé par colonne avec `ColumnType.filterable`.
+     * @default true
+     */
+    filterable?: boolean;
+    /**
+     * Autorise le redimensionnement des colonnes par glisser-déposer.
+     * @default false
+     */
+    resizableColumns?: boolean;
+    /**
+     * Mode de redimensionnement des colonnes.
+     * - `'fit'` : Ajuste les autres colonnes pour maintenir la largeur totale
+     * - `'expand'` : Agrandit le tableau pour accommoder la nouvelle largeur
+     * @default 'fit'
+     */
+    columnResizeMode?: 'fit' | 'expand';
+    /**
+     * Autorise la réorganisation des colonnes par glisser-déposer.
+     * Peut être surchargé par colonne avec `ColumnType.reorderableColumn`.
+     * @default true
+     */
+    reorderableColumns?: boolean;
+    /**
+     *  si c'est le mode de vérification des données CSV ou non.
+     * @default false
+     */
+    isCsvDataCheckMode?: boolean;
+    size?: 'small' | 'large';
+    onSizeChange?: (event: {
+        size: number;
+    }) => void;
+    doSelection?: boolean;
+    selectionMode?: 'single' | 'multiple';
+    dataKey?: string;
+    selection?: TableRowData<T>[] | TableRowData<T> | undefined;
+    compareSelectionBy?: 'equals' | 'deepEquals';
+    metaKeySelection?: boolean;
+    loading?: boolean;
+    showPaginator?: boolean;
+    rowsPerPageOptions?: number[];
+    columns: ColumnType[];
+    activatedColumns?: string[];
+    rows?: number;
+    language?: string;
+    totalRecords?: number;
+    currentPage?: number;
+    totalPages?: number;
+    pageSize?: number;
+    /**
+     * Détermine l'ordre de tri des valeurs nulles.
+     * - `1` : Les valeurs nulles sont placées en premier (comportement ASC)
+     * - `-1` : Les valeurs nulles sont placées en dernier (comportement DESC)
+     * @default undefined (comportement par défaut de PrimeVue)
+     * @example
+     * ```vue
+     * <Table :data="data" :columns="columns" :nullSortOrder="1" />
+     * <!-- Les valeurs nulles apparaîtront en premier lors du tri -->
+     * ```
+     */
+    nullSortOrder?: 1 | -1;
+    /**
+     * Ordre de tri par défaut lors du premier clic sur une colonne.
+     * - `1` : Tri croissant (ASC)
+     * - `-1` : Tri décroissant (DESC)
+     * @default undefined
+     */
+    defaultSortOrder?: 1 | -1;
+    multiSortMeta?: unknown[];
+    sortMode?: 'single' | 'multiple';
+    /**
+     * Active la possibilité de retirer le tri d'une colonne (état non-trié).
+     * Lorsque activé, un troisième clic sur l'en-tête de colonne retire le tri.
+     * @default false
+     */
+    removableSort?: boolean;
+    rowHover?: boolean;
+    csvSeparator?: string;
+    exportFilename?: string;
+    exportFunction?: (options: {
+        data: TableRowData<T>;
+        field: string;
+    }) => string | number | boolean | null | undefined;
+    expandedRows?: object | null;
+    expandedRowIcon?: string;
+    collapsedRowIcon?: string;
+    rowGroupMode?: 'subheader' | 'rowspan';
+    groupRowsBy?: string | string[] | ((data: TableRowData<T>) => string | number | boolean | null | undefined);
+    expandableRowGroups?: boolean;
+    expandedRowGroups?: object;
+    stateStorage?: 'session' | 'local';
+    stateKey?: string;
+    canEdit?: boolean;
+    editable?: boolean;
+    editMode?: 'cell' | 'row';
+    editingRows?: object | undefined;
+    rowClass?: (data: TableRowData<T>) => string | object;
+    rowStyle?: (data: TableRowData<T>) => object | object[];
+    /**
+     * Active le défilement vertical/horizontal du tableau.
+     * ⚠️ **IMPORTANT** : Cette propriété doit être `true` pour que les colonnes avec `frozen: true` fonctionnent correctement.
+     * @default false
+     */
+    scrollable?: boolean;
+    /** Hauteur de défilement (ex: '400px' ou 'flex') */
+    scrollHeight?: string;
+    virtualScrollerOptions?: object;
+    breakpoint?: string;
+    showGridlines?: boolean;
+    stripedRows?: boolean;
+    highlightOnSelect?: boolean;
+    tableStyle?: string | object;
+    tableClass?: string | object;
+}
+export interface CellProps {
+    /** Données de la ligne, peut contenir un attribut `errors` pour les erreurs de validation */
+    data: TableRowData<any>;
+    content?: CellContent;
+    language?: string;
+    columnConfig: ColumnType;
+    /** Mode de vérification CSV activé (pour afficher les tooltips d'erreur) */
+    isCsvDataCheckMode?: boolean;
+    format?: (value: string | number | boolean | null | undefined) => string | number | boolean | null | undefined;
+    formatDate?: (value: string | number | boolean | null | undefined) => string | number | boolean | null | undefined;
+    formatDateTime?: (value: string) => {
+        date: string;
+        time: string;
+    };
+}
+export interface CellEditorProps {
+    /** Données de la ligne, peut contenir un attribut `errors` pour les erreurs de validation */
+    data: TableRowData<any>;
+    content?: CellContent;
+    language?: string;
+    field: string;
+    columnConfig: ColumnType;
+    /** Erreurs de validation pour ce champ spécifique (filtrées depuis data.errors) */
+    fieldErrors?: ErrorType[];
+    format?: (value: string | number | boolean | null | undefined) => string | number | boolean | null | undefined;
+    formatDate?: (value: string | number | boolean | null | undefined) => string | number | boolean | null | undefined;
+    formatDateTime?: (value: string) => {
+        date: string;
+        time: string;
+    };
+}
+export interface TextImageContentType {
+    image?: {
+        key: string;
+        alt?: string;
+        title?: string;
+    };
+    title: {
+        key?: string;
+        size?: TextSize;
+        weight?: TextWeight;
+        color?: string;
+        format?: (value: string | number | boolean | null | undefined) => string | number | boolean | null | undefined;
+        icon?: {
+            key?: string;
+            size?: IconSize;
+            color?: string;
+            strokeWidth?: number;
+            position?: 'left' | 'right';
+        };
+    };
+    subtitle?: {
+        key?: string;
+        size?: TextSize;
+        weight?: TextWeight;
+        color?: string;
+        format?: (value: string | number | boolean | null | undefined) => string | number | boolean | null | undefined;
+        icon?: {
+            key?: string;
+            size?: IconSize;
+            color?: string;
+            strokeWidth?: number;
+            position?: 'left' | 'right';
+        };
+    };
+    supportingText?: {
+        key?: string;
+        size?: TextSize;
+        weight?: TextWeight;
+        color?: string;
+        format?: (value: string) => string | number | boolean | null | undefined;
+        icon?: {
+            key?: string;
+            size?: IconSize;
+            color?: string;
+            strokeWidth?: number;
+            position?: 'left' | 'right';
+        };
+    };
+}
+export interface TagContentType {
+    key: string;
+    size?: 'extra-small' | 'small' | 'medium' | 'large';
+    variant?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+    ghost?: boolean;
+    options?: DropDownOption[];
+    format?: (value: string) => string | number | boolean | null | undefined;
+}
+export interface PriceContentType {
+    key: string;
+    price?: number;
+    formattedPrice?: string;
+    formattedOldPrice?: string;
+    oldPrice?: number;
+    currency?: string;
+    variantCount?: number;
+    isDiscounted?: boolean;
+    isSubventioned?: boolean;
+    language?: 'fr' | 'en';
+    size?: TextSize;
+    weight?: TextWeight;
+    color?: string;
+}
+export interface DateContentType {
+    key: string;
+    date?: Date;
+    dateTime?: Date;
+    size?: TextSize;
+    weight?: TextWeight;
+    color?: string;
+    format?: (value: string) => string | number | boolean | null | undefined;
+    formatDate?: (value: string) => string;
+    formatTime?: (value: string) => string;
+    formatDateTime?: (value: string) => {
+        date: string;
+        time: string;
+    };
+}
+export interface DateRangeContentType {
+    key: string;
+    fromKey: string;
+    toKey: string;
+    fromSize?: TextSize;
+    toSize?: TextSize;
+    fromWeight?: TextWeight;
+    toWeight?: TextWeight;
+    fromColor?: string;
+    toColor?: string;
+    format?: (value: string) => string | number | boolean | null | undefined;
+}
+export interface DropdownContentType {
+    key: string;
+    options?: DropDownOption[];
+    placeholder?: string;
+    multiple?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    maxHeight?: string;
+}
+export interface ProgressBarContentType {
+    key: string;
+    value?: number;
+    maxKey?: string;
+    unit?: string;
+    size?: 'medium' | 'large';
+    valueSize?: TextSize;
+    valueWeight?: TextWeight;
+    labelSize?: TextSize;
+    labelWeight?: TextWeight;
+    label?: string;
+    hideValue?: boolean;
+    hideMax?: boolean;
+    showPercentage?: boolean;
+    loading?: boolean;
+}
+export interface ActionsContentType {
+    key: string;
+    actions?: ActionContentType[];
+}
+export interface ActionContentType {
+    key: string;
+    icon?: string;
+    color?: string;
+    size?: ButtonSize;
+    variant?: ButtonVariant;
+    disabled?: boolean;
+    loading?: boolean;
+    actionName?: string;
+}
+export interface ToggleContentType {
+    key: string;
+    modelValue?: boolean;
+    label?: string;
+    disabled?: boolean;
+    size?: 'small' | 'medium' | 'large';
+    options?: DropDownOption[];
+}
+export type MatchMode = 'contains' | 'equals' | 'notEquals' | 'startsWith' | 'endsWith' | 'contains' | 'notContains' | 'between' | 'notBetween' | 'in' | 'notIn' | 'any' | 'none' | 'all' | 'not';
+/**
+ * Type pour représenter un tri (single ou multi-sort)
+ */
+export interface SortConfig {
+    field: string;
+    order: 1 | -1;
+}
+/**
+ * Type pour représenter un filtre actif (uniquement les colonnes avec un filtrage non vide)
+ */
+export interface ActiveFilter {
+    columnKey: string;
+    value: string | boolean | number | Date[] | Date | null | undefined;
+    matchMode: MatchMode;
+}
+/**
+ * Type pour représenter l'ordre des colonnes
+ */
+export interface ColumnOrder {
+    columnKey: string;
+    order: number;
+}
+/**
+ * Objet TableRequestData qui englobe tous les états du tableau gérés par le composant
+ * pour préparer l'envoi d'un appel API ou l'export CSV.
+ *
+ * Note: activatedColumns et filters.global sont gérés à l'extérieur du composant
+ * et doivent être combinés avec cet objet pour obtenir le RequestData complet.
+ */
+export interface TableRequestData {
+    columnOrder: ColumnOrder[];
+    pagination: {
+        currentPage: number;
+        pageSize: number;
+    };
+    sort: SortConfig[];
+    filters: {
+        columns: ActiveFilter[];
+    };
+}

package/dist/components/organisms/Table/utils/errorValidation.d.ts

@@ -0,0 +1,34 @@
+import { ErrorType } from '../types';
+/**
+ * Vérifie si une erreur est toujours valide en fonction de la valeur actuelle du champ.
+ * Cette fonction est utilisée pour déterminer si une erreur de validation doit encore être affichée
+ * après que l'utilisateur ait modifié la valeur du champ.
+ *
+ * @param error - L'erreur à vérifier
+ * @param currentValue - La valeur actuelle du champ
+ * @param rowData - Les données complètes de la ligne (optionnel, nécessaire pour les références à d'autres champs)
+ * @returns true si l'erreur est toujours valide (la valeur ne respecte toujours pas la règle), false sinon
+ *
+ * @example
+ * ```typescript
+ * // Erreur de pattern email
+ * isErrorStillValid(
+ *   { field: 'email', message: 'Email invalide', pattern: '^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$' },
+ *   'invalid-email' // → true (l'erreur est toujours valide)
+ * )
+ *
+ * // Erreur de date minimum
+ * isErrorStillValid(
+ *   { field: 'createdAt', message: 'Date doit être au passé', min: new Date('2025-01-01') },
+ *   '2024-12-31' // → true (l'erreur est toujours valide)
+ * )
+ *
+ * // Erreur avec référence à un autre champ
+ * isErrorStillValid(
+ *   { field: 'endDate', message: 'Date de fin doit être après date de début', min: { value: 'startDate', type: 'field' } },
+ *   '2025-01-01',
+ *   { startDate: '2025-01-15', endDate: '2025-01-01' } // → true (endDate < startDate)
+ * )
+ * ```
+ */
+export declare function isErrorStillValid(error: ErrorType, currentValue: any, rowData?: any): boolean;

package/dist/components/organisms/Table/utils/getColumnErrors.d.ts

@@ -0,0 +1,10 @@
+import { ColumnType, ErrorType, TableRowData } from '../types';
+/**
+ * Récupère toutes les erreurs pertinentes pour une colonne donnée.
+ * Pour les colonnes composites (DATE_RANGE, PROGRESS_BAR), inclut les erreurs des champs sous-jacents.
+ *
+ * @param data - Les données de la ligne
+ * @param column - La configuration de la colonne
+ * @returns Liste des erreurs valides pour cette colonne
+ */
+export declare function getColumnErrors(data: TableRowData<any>, column: ColumnType): ErrorType[];

package/dist/components/organisms/index.d.ts

@@ -2,12 +2,13 @@ export { BalanceCard } from './BalanceCard';
 export type { BalanceCardProps } from './BalanceCard';
 export { BalanceCardGroup } from './BalanceCardGroup';
 export type { BalanceCardData, BalanceCardGroupProps } from './BalanceCardGroup';
-export { DataTable } from './DataTable';
 export { Breadcrumbs } from './Breadcrumbs';
 export { ProductCard } from './ProductCard';
 export { FilterPrice } from './FilterPrice';
 export { PageNavigation } from './PageNavigation';
+export { Table } from './Table';
+export type { TableProps, ColumnType, CellEditorProps, CellProps, CellContentType, CellFilterType, TableRequestData, SortConfig, ActiveFilter, ColumnOrder, MatchMode, ErrorType, TableRowData, TextImageContentType, TagContentType, PriceContentType, DateContentType, DateRangeContentType, DropdownContentType, ProgressBarContentType, ActionsContentType, ActionContentType, ToggleContentType } from './Table';
 export { DropFile } from './DropFile';
-export type { DropFileProps, DropFileVariant, DropFileI18n, DropFileErrorCode, DropFileFileData, DropFileDropEvent, DropFileErrorEvent } from './DropFile';
+export type { DropFileProps, DropFileVariant, DropFileErrorCode, DropFileFileData, DropFileDropEvent, DropFileErrorEvent } from './DropFile';
 export { FilterGroup } from './FilterGroup';
 export type { FilterGroupProps, Filter, Sort } from './FilterGroup/types';

package/dist/composables/index.d.ts

@@ -4,3 +4,11 @@ export { useScrollShadows, type UseScrollShadowsOptions, type UseScrollShadowsRe
 export { useTheme, type BrandTheme, type ThemeMode } from './useTheme';
 export { useBreakpoints } from './useBreakpoints';
 export { useCurrency } from './useCurrency';
+export { useTableTranslations, type TableLanguage } from './useTableTranslations';
+export { useTableSelection, type SelectionMode, type UseTableSelectionOptions, type UseTableSelectionReturn } from './useTableSelection';
+export { useTablePagination, type UseTablePaginationOptions, type UseTablePaginationReturn } from './useTablePagination';
+export { useTableSort, type UseTableSortReturn } from './useTableSort';
+export { useTableColumns, type UseTableColumnsReturn } from './useTableColumns';
+export { useTableFilters, type UseTableFiltersReturn } from './useTableFilters';
+export { useTableRequestData, type UseTableRequestDataOptions, type UseTableRequestDataReturn } from './useTableRequestData';
+export { useDateFormatters, type DateFormatters } from './useDateFormatters';

package/dist/composables/useDateFormatters.d.ts

@@ -0,0 +1,12 @@
+import { ComputedRef } from 'vue';
+import { DateContentType } from '../components/organisms/Table/types';
+export interface DateFormatters {
+    data: (val: string) => string | number | boolean | null | undefined;
+    date: (val: string) => string;
+    time: (val: string) => string;
+    dateTime: (val: string) => {
+        date: string;
+        time: string;
+    };
+}
+export declare function useDateFormatters(dateConfig: ComputedRef<DateContentType | undefined>): DateFormatters;

package/dist/composables/useIsoDate.d.ts

@@ -0,0 +1,4 @@
+import { WritableComputedRef } from 'vue';
+export declare function useIsoDate(getValue: () => string | null | undefined, setValue: (val: string | undefined) => void, options: {
+    enableTime: boolean;
+}): WritableComputedRef<Date | undefined, Date | null | undefined>;

package/dist/composables/useTableColumns.d.ts

@@ -0,0 +1,7 @@
+import { Ref, ComputedRef } from 'vue';
+import { ColumnType } from '../components/organisms/Table/types';
+export interface UseTableColumnsReturn {
+    localColumns: Ref<ColumnType[]>;
+    handleColumnReorder: (event: any) => void;
+}
+export declare function useTableColumns(columns: ColumnType[] | ComputedRef<ColumnType[]>, emit: (value: any) => void): UseTableColumnsReturn;

package/dist/composables/useTableFilters.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { ColumnFilterMatchModeOptions } from 'primevue/column';
+import { ColumnType } from '../components/organisms/Table/types';
+export interface UseTableFiltersReturn {
+    allFilters: Ref<Record<string, any>>;
+    doUpdateFilter: (filter: Record<string, any>) => void;
+    getFilterOptions: (col: ColumnType) => ColumnFilterMatchModeOptions[];
+}
+export declare function useTableFilters(initialFilters: Record<string, any>, emit: (value: Record<string, any>) => void, translations: {
+    filter: Record<string, string>;
+}): UseTableFiltersReturn;

package/dist/composables/useTablePagination.d.ts

@@ -0,0 +1,19 @@
+import { Ref, ComputedRef } from 'vue';
+export interface UseTablePaginationOptions {
+    currentPage?: number;
+    pageSize?: number;
+    totalRecords: number;
+    totalPages?: number;
+    dataLength: number;
+}
+export interface UseTablePaginationReturn {
+    internalCurrentPage: Ref<number>;
+    internalPageSize: Ref<number>;
+    handlePageChange: (page: number) => void;
+    handlePageSizeChange: (size: number) => void;
+    footerDetails: ComputedRef<string>;
+}
+export declare function useTablePagination(options: UseTablePaginationOptions, emitPageChange: (value: number) => void, emitPageSizeChange: (value: number) => void, translations: ComputedRef<{
+    to: string;
+    elements: string;
+}>): UseTablePaginationReturn;