@cnamts/synapse 1.0.23 → 1.0.25

package/dist/components/Tables/common/types.d.ts

@@ -2,8 +2,8 @@ export type SortOptions = {
     key: string;
     order: 'desc' | 'asc';
 };
-export type FilterType = 'text' | 'number' | 'date' | 'period' | 'select' | 'custom';
-type FilterValue = string | number | Date | Array<string | number | Date> | {
+export type FilterType = 'text' | 'number' | 'date' | 'period' | 'select' | 'autocomplete' | 'custom';
+type FilterValue = string | number | Date | Array<string | number | Date | Record<string, unknown>> | {
     from: string | null;
     to: string | null;
 } | Record<string, unknown> | null | undefined;
@@ -46,6 +46,7 @@ export type DataTableHeaders = {
     maxWidth?: string | number;
     minWidth?: string | number;
     headerProps?: Record<string, unknown>;
+    cellProps?: Record<string, unknown>;
 };
 export type TableColumnHeader = {
     title?: string;
@@ -68,7 +69,8 @@ export type TableColumnHeader = {
     children?: unknown[];
     maxWidth?: string | number;
     minWidth?: string | number;
-    headerProps?: Record<string, unknown>;
+    headerProps?: unknown;
+    cellProps?: unknown;
     [key: string]: unknown;
 };
 export type SyTableProps = {
@@ -85,12 +87,20 @@ export type SyTableProps = {
     headers?: DataTableHeaders[];
     showSelect?: boolean;
     showSelectSingle?: boolean;
+    stickySelect?: boolean;
     showExpand?: boolean;
     selectionKey?: string;
     multiSort?: boolean;
     mustSort?: boolean;
     itemsPerPageOptions?: number[];
     headingLevel?: 1 | 2 | 3 | 4 | 5 | 6;
+    pinnedColumns?: Array<string | {
+        key: string;
+        side?: 'left' | 'right';
+    }>;
+    pinnedColumnKey?: string;
+    clickableRow?: boolean;
+    pageInput?: boolean;
 };
 export type SyServerTableProps = {
     serverItemsLength: number;
@@ -107,11 +117,19 @@ export type SyServerTableProps = {
     headers?: DataTableHeaders[];
     showSelect?: boolean;
     showSelectSingle?: boolean;
+    stickySelect?: boolean;
     showExpand?: boolean;
     selectionKey?: string;
     multiSort?: boolean;
     mustSort?: boolean;
     itemsPerPageOptions?: number[];
     headingLevel?: 1 | 2 | 3 | 4 | 5 | 6;
+    pinnedColumns?: Array<string | {
+        key: string;
+        side?: 'left' | 'right';
+    }>;
+    pinnedColumnKey?: string;
+    clickableRow?: boolean;
+    pageInput?: boolean;
 };
 export {};

package/dist/components/Tables/common/useClickableTableRow.d.ts

@@ -0,0 +1,17 @@
+import { ComputedRef, Ref } from 'vue';
+type ClickableTableItem = Record<string, unknown>;
+type TableRowData = {
+    index: number;
+    item: ClickableTableItem;
+    internalItem: unknown;
+};
+type TableRowProps = Record<string, unknown>;
+export type ClickableTableRowPropsInput = TableRowProps | ((data: TableRowData) => TableRowProps) | undefined;
+export declare function useClickableTableRow({ clickableRow, rowProps, onRowClick, }: {
+    clickableRow: Ref<boolean>;
+    rowProps: ComputedRef<ClickableTableRowPropsInput>;
+    onRowClick: (item: ClickableTableItem) => void;
+}): {
+    clickableRowProps: ComputedRef<ClickableTableRowPropsInput>;
+};
+export {};

package/dist/components/Tables/common/usePagination.d.ts

@@ -7,13 +7,15 @@ import { DataOptions } from './types';
  * @param itemsLength - Total number of items (for client-side) or serverItemsLength (for server-side)
  * @returns Pagination utilities and computed properties
  */
-export declare function usePagination({ options, itemsLength, }: {
+export declare function usePagination({ options, itemsLength, updateOptions, }: {
     options: Ref<Partial<DataOptions>>;
     itemsLength: Ref<number>;
+    updateOptions: (opts: Partial<DataOptions>) => void;
 }): {
     page: import('vue').WritableComputedRef<number, number>;
     pageCount: import('vue').ComputedRef<number>;
     itemsPerPageValue: import('vue').ComputedRef<number>;
     updateItemsPerPage: (newItemsPerPage: number) => Promise<void>;
     isUpdatingItemsPerPage: Ref<boolean, boolean>;
+    onUpdateOptions: (newOptions: Partial<DataOptions>) => void;
 };

package/dist/components/Tables/common/usePinnedColumns.d.ts

@@ -0,0 +1,31 @@
+import { Ref } from 'vue';
+import { DataTableHeaders } from './types';
+interface UsePinnedColumnsOptions {
+    displayHeaders: Ref<DataTableHeaders[] | undefined>;
+    reactiveColumnWidths: Ref<Record<string, number | string>>;
+    pinnedColumns: Ref<Array<string | {
+        key: string;
+        side?: 'left' | 'right';
+    }> | undefined>;
+    pinnedColumnKey: Ref<string | undefined>;
+    stickySelect: Ref<boolean>;
+    showSelect: Ref<boolean>;
+    showSelectSingle: Ref<boolean>;
+    tableRef: Ref<{
+        $el?: Element;
+    } | undefined>;
+}
+export declare function usePinnedColumns({ displayHeaders, reactiveColumnWidths, pinnedColumns, pinnedColumnKey, stickySelect, showSelect, showSelectSingle, tableRef, }: UsePinnedColumnsOptions): {
+    showPinnedLeftShadow: Ref<boolean, boolean>;
+    showPinnedRightShadow: Ref<boolean, boolean>;
+    hasPinnedSelectLeft: import('vue').ComputedRef<boolean>;
+    pinnedMeta: import('vue').ComputedRef<{
+        left: Record<string, number>;
+        right: Record<string, number>;
+        totalLeft: number;
+        totalRight: number;
+    }>;
+    pinnedEdgeVars: import('vue').ComputedRef<Record<string, string>>;
+    displayHeadersWithPinned: import('vue').ComputedRef<DataTableHeaders[] | undefined>;
+};
+export {};

package/dist/components/Tables/common/useTableHeaders.d.ts

@@ -35,6 +35,7 @@ export declare function useTableHeaders({ headersProp, storedHeaders, filterInpu
         maxWidth?: string | number | undefined;
         minWidth?: string | number | undefined;
         headerProps?: Record<string, unknown> | undefined;
+        cellProps?: Record<string, unknown> | undefined;
     }[] | undefined, DataTableHeaders[] | {
         title?: string | undefined;
         text?: string | undefined;
@@ -58,6 +59,7 @@ export declare function useTableHeaders({ headersProp, storedHeaders, filterInpu
         maxWidth?: string | number | undefined;
         minWidth?: string | number | undefined;
         headerProps?: Record<string, unknown> | undefined;
+        cellProps?: Record<string, unknown> | undefined;
     }[] | undefined>;
     displayHeaders: import('vue').ComputedRef<DataTableHeaders[] | undefined>;
     filterableHeaders: import('vue').ComputedRef<DataTableHeaders[]>;

package/dist/components/Tables/common/useTableRowCheckboxAccessibility.d.ts

@@ -0,0 +1,5 @@
+export declare function useTableRowCheckboxAccessibility({ uniqueTableId, }: {
+    uniqueTableId: string;
+}): {
+    accessibilityRowCheckboxes: () => void;
+};

package/dist/components/UploadWorkflow/UploadWorkflow.d.ts

@@ -125,10 +125,10 @@ declare function __VLS_template(): {
         } & Widthable> & Readonly<{
             onError?: ((value: string[]) => any) | undefined;
             "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
-        }>, "fileInput" | "openFileDialog" | ("disabled" | "locales" | "multiple" | "allowedExtensions" | "fileSizeUnits" | "fileSizeMax")> & import('vue').ShallowUnwrapRef<{
-            fileInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        }>, "fileInput" | "openFileDialog" | ("disabled" | "locales" | "multiple" | "allowedExtensions" | "fileSizeUnits" | "fileSizeMax")> & {
+            fileInput: HTMLInputElement | null;
             openFileDialog: () => void;
-        }> & {} & import('vue').ComponentCustomProperties & {} & {
+        } & {} & import('vue').ComponentCustomProperties & {} & {
             $slots: Readonly<{
                 default(): void;
             } & import('../FileUpload/FileUploadContent').FileUploadContentSlots> & {
@@ -153,6 +153,7 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
 }>, {
     headingLevel: 1 | 2 | 3 | 4 | 5 | 6;
     locales: typeof defaultLocales;
+    uploadList: UploadItem[];
     sectionTitle: string;
     showFilePreview: boolean;
     infoText: string;
@@ -251,10 +252,10 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     } & Widthable> & Readonly<{
         onError?: ((value: string[]) => any) | undefined;
         "onUpdate:modelValue"?: ((value: File[]) => any) | undefined;
-    }>, "fileInput" | "openFileDialog" | ("disabled" | "locales" | "multiple" | "allowedExtensions" | "fileSizeUnits" | "fileSizeMax")> & import('vue').ShallowUnwrapRef<{
-        fileInput: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    }>, "fileInput" | "openFileDialog" | ("disabled" | "locales" | "multiple" | "allowedExtensions" | "fileSizeUnits" | "fileSizeMax")> & {
+        fileInput: HTMLInputElement | null;
         openFileDialog: () => void;
-    }> & {} & import('vue').ComponentCustomProperties & {} & {
+    } & {} & import('vue').ComponentCustomProperties & {} & {
         $slots: Readonly<{
             default(): void;
         } & import('../FileUpload/FileUploadContent').FileUploadContentSlots> & {

package/dist/composables/date/useDatePickerAccessibility.d.ts

@@ -4,7 +4,7 @@
  */
 export declare function useDatePickerAccessibility(): {
     updateAccessibility: () => Promise<void>;
-    handleKeyDown: (event: Event) => void;
+    handleKeyDown: (event: KeyboardEvent) => void;
     fixAriaAttributes: () => void;
 };
 export default useDatePickerAccessibility;

package/dist/composables/rules/useFieldValidation.d.ts

@@ -4,21 +4,21 @@ export type ValidationResult = {
     error?: string;
     warning?: string;
 };
-export type RuleOptions = {
+export type RuleOptions<T = any> = {
     message?: string;
     successMessage?: string;
     warningMessage?: string;
     fieldName?: string;
     fieldIdentifier?: string;
-    value?: any;
+    value?: T;
     length?: number;
     pattern?: RegExp;
     ignoreSpace?: boolean;
     isWarning?: boolean;
-    validate?: (value: any) => boolean | string;
+    validate?: ((value: T) => boolean | string) | ((value: T) => Promise<boolean | string>);
     date?: string | Date;
 };
-export type ValidationRule = (value: any) => ValidationResult;
+export type ValidationRule = (value: any) => ValidationResult | Promise<ValidationResult>;
 export declare function useFieldValidation(): {
     generateRules: (fieldRules: Array<{
         type: string;

package/dist/composables/unifyValidation/documentationValidationProps.d.ts

@@ -0,0 +1,230 @@
+export declare function getValidationDocumentation(type?: 'date' | 'number' | 'string' | 'all'): {
+    readonly: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            defaultValue: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    disabled: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            defaultValue: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    required: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            defaultValue: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    isValidateOnBlur: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            defaultValue: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    showSuccessMessages: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            defaultValue: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    disableErrorHandling: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            defaultValue: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    useVuetifyValidation: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            defaultValue: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    label: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    rules: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+                detail: string;
+            };
+            category: string;
+        };
+    };
+    customRules: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+                detail: string;
+            };
+            category: string;
+        };
+    };
+    customWarningRules: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+                detail: string;
+            };
+            category: string;
+        };
+    };
+    customSuccessRules: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+                detail: string;
+            };
+            category: string;
+        };
+    };
+    errorMessages: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    warningMessages: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    successMessages: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    hasError: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    hasWarning: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    hasSuccess: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    hideDetails: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            defaultValue: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+    maxErrors: {
+        description: string;
+        control: string;
+        table: {
+            type: {
+                summary: string;
+            };
+            category: string;
+        };
+    };
+};

package/dist/composables/unifyValidation/useCustomValidation.d.ts

@@ -0,0 +1,8 @@
+import { ValidationRule } from '../validation/useValidation';
+import { Ref } from 'vue';
+/**
+ * Interface between the validation entrypoint "useValidation" composable and the custom validation logic.
+ */
+export declare function useCustomValidation(modelValue: Ref<unknown>, customRules: Ref<ValidationRule[]> | undefined, customWarningRules: Ref<ValidationRule[]> | undefined, customSuccessRules: Ref<ValidationRule[]> | undefined, errors: Ref<string[]>, warnings: Ref<string[]>, successes: Ref<string[]>, showSuccessMessages: Ref<boolean>, label: Ref<string>, focused: Ref<boolean>, isValidateOnBlur: Ref<boolean>, disableErrorHandling: Ref<boolean>, readonly?: Ref<boolean>, disabled?: Ref<boolean>): {
+    validate: () => Promise<import('../validation/useValidation').ValidationResult>;
+};

package/dist/composables/unifyValidation/useValidation.d.ts

@@ -0,0 +1,102 @@
+import { ValidationRule as SyValidationRule } from '../validation/useValidation';
+import { Ref } from 'vue';
+import { ValidationRule as VuetifyValidationRule } from 'vuetify';
+export interface FieldValidationProps {
+    modelValue?: unknown;
+    readonly?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    isValidateOnBlur?: boolean;
+    showSuccessMessages?: boolean;
+    disableErrorHandling?: boolean;
+    useVuetifyValidation?: boolean;
+    label: string;
+    rules?: VuetifyValidationRule[];
+    customRules?: SyValidationRule[];
+    customWarningRules?: SyValidationRule[];
+    customSuccessRules?: SyValidationRule[];
+    errorMessages?: string[] | null;
+    warningMessages?: string[] | null;
+    successMessages?: string[] | null;
+    hasError?: boolean;
+    hasWarning?: boolean;
+    hasSuccess?: boolean;
+    maxErrors?: number;
+}
+/**
+ * Entrypoint to handle validation in fields components.
+ * It handles both Vuetify native validation (if useVuetifyValidation is true) and Synapse custom validation (if customRules are provided).
+ * It also provides a unified interface to handle errors, warnings and successes, and to trigger validation on demand.
+ */
+export declare const validationPropsDefaults: {
+    readonly: boolean;
+    disabled: boolean;
+    required: boolean;
+    isValidateOnBlur: boolean;
+    showSuccessMessages: boolean;
+    disableErrorHandling: boolean;
+    customRules: () => never[];
+    customWarningRules: () => never[];
+    customSuccessRules: () => never[];
+    errorMessages: null;
+    warningMessages: null;
+    successMessages: null;
+    useVuetifyValidation: boolean;
+    hasError: boolean;
+    hasWarning: boolean;
+    hasSuccess: boolean;
+    maxErrors: number;
+};
+export declare function useValidation(params: {
+    modelValue: Ref<unknown>;
+    readonly: Ref<boolean>;
+    disabled: Ref<boolean>;
+    required: Ref<boolean>;
+    isValidateOnBlur: Ref<boolean>;
+    showSuccessMessages: Ref<boolean>;
+    disableErrorHandling: Ref<boolean>;
+    label: Ref<string>;
+    focused: Ref<boolean>;
+    errorMessages?: Ref<string[] | null | undefined>;
+    warningMessages?: Ref<string[] | null | undefined>;
+    successMessages?: Ref<string[] | null | undefined>;
+    hasErrorProp?: Ref<boolean>;
+    hasWarningProp?: Ref<boolean>;
+    hasSuccessProp?: Ref<boolean>;
+} & ({
+    useVuetifyValidation: true;
+    rules: Ref<VuetifyValidationRule[] | undefined>;
+    customRules?: never;
+    customWarningRules?: never;
+    customSuccessRules?: never;
+    maxErrors?: Ref<number>;
+} | {
+    useVuetifyValidation: false;
+    customRules: Ref<SyValidationRule[]>;
+    customWarningRules?: Ref<SyValidationRule[]>;
+    customSuccessRules?: Ref<SyValidationRule[]>;
+    rules?: never;
+} | {
+    useVuetifyValidation: Ref<boolean>;
+    customRules: Ref<SyValidationRule[]>;
+    customWarningRules?: Ref<SyValidationRule[]>;
+    customSuccessRules?: Ref<SyValidationRule[]>;
+    rules: Ref<VuetifyValidationRule[] | undefined>;
+    maxErrors?: Ref<number>;
+})): {
+    errors: Ref<string[], string[]>;
+    warnings: Ref<string[], string[]>;
+    successes: Ref<string[], string[]>;
+    hasError: import('vue').ComputedRef<boolean>;
+    hasWarning: import('vue').ComputedRef<boolean>;
+    hasSuccess: import('vue').ComputedRef<boolean>;
+    validate: () => Promise<boolean>;
+} | {
+    errors: import('vue').ComputedRef<string[]>;
+    warnings: import('vue').ComputedRef<string[]>;
+    successes: import('vue').ComputedRef<string[]>;
+    hasError: import('vue').ComputedRef<boolean | undefined>;
+    hasWarning: import('vue').ComputedRef<boolean | undefined>;
+    hasSuccess: import('vue').ComputedRef<boolean | undefined>;
+    validate: () => Promise<boolean>;
+};

package/dist/composables/unifyValidation/useVuetifyValidation.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'vue';
+import { ValidationRule } from 'vuetify';
+/** Interface between the validation entrypoint "useValidation" composable and the Vuetify validation logic. */
+export declare function useVuetifyValidation(modelValue: Ref<unknown>, rules: Ref<ValidationRule[] | undefined>, disabled: Ref<boolean>, errors: Ref<string[]>, error: Ref<boolean>, errorMessages: Ref<string[]>, focused: Ref<boolean>, maxErrors: Ref<number> | undefined, name: Ref<string>, label: Ref<string>, readonly: Ref<boolean>, validateOn: Ref<'input' | 'blur' | 'submit'>): {
+    errorMessages: import('vue').ComputedRef<string[]>;
+    isDirty: import('vue').ComputedRef<boolean>;
+    isDisabled: import('vue').ComputedRef<boolean>;
+    isReadonly: import('vue').ComputedRef<boolean>;
+    isPristine: import('vue').ShallowRef<boolean, boolean>;
+    isValid: import('vue').ComputedRef<boolean | null>;
+    isValidating: import('vue').ShallowRef<boolean, boolean>;
+    reset: () => Promise<void>;
+    resetValidation: () => Promise<void>;
+    validate: (silent?: boolean) => Promise<string[]>;
+    validationClasses: import('vue').ComputedRef<{
+        [x: string]: boolean;
+    }>;
+};

package/dist/composables/useFormFieldErrorHandling.d.ts

@@ -24,8 +24,8 @@ export interface UseFormFieldErrorHandlingReturn {
     errors: Ref<string[]>;
     warnings: Ref<string[]>;
     successes: Ref<string[]>;
-    validateField: (value: unknown) => boolean;
-    validateOnSubmit: () => boolean;
+    validateField: (value: unknown) => Promise<boolean>;
+    validateOnSubmit: () => Promise<boolean>;
     checkErrorOnBlur: () => void;
 }
 export declare const useFormFieldErrorHandling: (props: UseFormFieldErrorHandlingProps, modelValue: Ref<unknown>, emitUpdate?: () => void) => UseFormFieldErrorHandlingReturn;

package/dist/composables/validation/useFormValidation.d.ts

@@ -1,9 +1,12 @@
 import { Ref } from 'vue';
-export interface ValidatableComponent {
+export type ValidatableComponent = {
     validateOnSubmit: () => Promise<boolean> | boolean;
     clearValidation?: () => void;
     reset?: () => void;
-}
+    $props?: {
+        label?: string;
+    };
+};
 /**
  * Hook pour le formulaire parent qui fournit un registre pour les composants validables
  * @returns Fonctions pour gérer la validation des composants enfants
@@ -14,10 +17,16 @@ export declare function useFormValidation(): {
         validateOnSubmit: () => Promise<boolean> | boolean;
         clearValidation?: (() => void) | undefined;
         reset?: (() => void) | undefined;
+        $props?: {
+            label?: string | undefined;
+        } | undefined;
     }[], ValidatableComponent[] | {
         validateOnSubmit: () => Promise<boolean> | boolean;
         clearValidation?: (() => void) | undefined;
         reset?: (() => void) | undefined;
+        $props?: {
+            label?: string | undefined;
+        } | undefined;
     }[]>;
     clearAll: () => void;
     resetAll: () => void;