@cnamts/synapse 1.0.23 → 1.0.24

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> & {
@@ -251,10 +251,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/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;

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

@@ -1,15 +1,20 @@
 import { RuleOptions } from '../rules/useFieldValidation';
-export type ValidationRule = {
-    type: string;
+export type BuiltInRuleType = 'required' | 'email' | 'minLength' | 'maxLength';
+interface CustomValidationRule {
+    type: 'custom';
+    options: RuleOptions & {
+        validate: NonNullable<RuleOptions['validate']>;
+    };
+}
+interface StandardValidationRule {
+    type: BuiltInRuleType | ({} & string);
     options: RuleOptions;
-};
+}
+export type ValidationRule = CustomValidationRule | StandardValidationRule;
 export interface ValidationOptions {
     showSuccessMessages?: boolean;
-    fieldIdentifier?: string;
-    customRules?: ValidationRule[];
-    warningRules?: ValidationRule[];
-    successRules?: ValidationRule[];
     disableErrorHandling?: boolean;
+    fieldIdentifier?: string;
 }
 export interface ValidationState {
     errors: string[];
@@ -34,7 +39,8 @@ export declare function useValidation(options?: ValidationOptions): {
     hasError: import('vue').ComputedRef<boolean>;
     hasWarning: import('vue').ComputedRef<boolean>;
     hasSuccess: import('vue').ComputedRef<boolean>;
-    validateField: (value: unknown, rules?: ValidationRule[], warningRules?: ValidationRule[], successRules?: ValidationRule[]) => ValidationResult;
-    validateOnSubmit: () => Promise<boolean>;
+    validateField: (value: unknown, rules?: ValidationRule[], warningRules?: ValidationRule[], successRules?: ValidationRule[]) => ValidationResult | Promise<ValidationResult>;
+    validateOnSubmit: () => boolean;
     clearValidation: () => void;
 };
+export {};

package/dist/design-system-v3.d.ts

@@ -0,0 +1,2 @@
+export * from './main'
+export {}