@cnamts/synapse 1.0.19 → 1.0.21

package/dist/components/Customs/Selects/SyAutocomplete/types.d.ts

@@ -0,0 +1,5 @@
+export type ItemType = {
+    [key: string]: unknown;
+};
+export type SelectValue = Record<string, unknown> | string | number | null | undefined;
+export type SelectArray = Array<Record<string, unknown> | string | number>;

package/dist/components/Customs/Selects/SyAutocomplete/utils/ariaManager.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from 'vue';
+export declare const ariaManager: {
+    cleanInputAttributes(inputElement: HTMLElement): void;
+    updateInputState(inputElement: HTMLElement, isOpenValue: boolean, menuId: string, activeDescendant?: string, options?: {
+        ariaAutocomplete?: "list" | "both" | "inline" | "none";
+        ownsId?: string;
+        isBusy?: boolean;
+        popupRendered?: boolean;
+    }): void;
+    updateValidationAttributes(inputElement: HTMLElement, isRequiredValue: boolean, hasErrorValue: boolean): void;
+    cleanParentAttributes(parentElement: HTMLElement): void;
+    cleanAlertAttributes(parentElement: HTMLElement): void;
+    setupAriaAttributesForAutocomplete(textFieldRef: Ref<any>, isOpen: Ref<boolean>, menuId: string, activeDescendant: Ref<string>, loading: boolean, inputLabel?: string): void;
+};

package/dist/components/Customs/Selects/SyAutocomplete/utils/useItemUtils.d.ts

@@ -0,0 +1,16 @@
+import { ComputedRef } from 'vue';
+import { ItemType } from '../types';
+interface ItemUtilsProps {
+    textKey: string;
+    valueKey: string;
+    plainTextKey: string;
+    returnObject: boolean;
+}
+export declare function useItemUtils(props: ItemUtilsProps, formattedItems: ComputedRef<ItemType[]>): {
+    getItemText: (item: unknown) => any;
+    getPlainText: (item: ItemType) => string;
+    getValueKey: (item: ItemType | string | number) => string | number;
+    getStoredValue: (item: ItemType | string | number) => string | number | ItemType;
+    getChipLabel: (chip: ItemType | string | number) => string;
+};
+export {};

package/dist/components/Customs/Selects/SyAutocomplete/utils/useKeyboardHandler.d.ts

@@ -0,0 +1,28 @@
+import { Ref, ComputedRef } from 'vue';
+import { ItemType, SelectValue, SelectArray } from '../types';
+interface KeyboardHandlerProps {
+    multiple: boolean;
+    chips: boolean;
+}
+interface KeyboardHandlerDeps {
+    search: Ref<string>;
+    selected: Ref<SelectValue | SelectArray>;
+    isOpen: Ref<boolean>;
+    selectItem: (item: ItemType | string | number | null | undefined) => void;
+    getItemText: (item: unknown) => unknown;
+    filteredItems: ComputedRef<ItemType[]>;
+    uniqueMenuId: Ref<string>;
+    focusListItem: boolean;
+}
+export declare function useSyAutocompleteKeyboard(props: KeyboardHandlerProps, deps: KeyboardHandlerDeps): {
+    handleKeydown: (e: KeyboardEvent) => void;
+    focusInput: (textFieldRef: Ref<{
+        $el?: HTMLElement;
+        $refs?: {
+            input?: HTMLInputElement;
+        };
+    } | null>, noFocus?: boolean) => void;
+    keyboardActiveId: Ref<string, string>;
+    handleTabKey: () => void;
+};
+export {};

package/dist/components/Customs/Selects/SyAutocomplete/utils/useSelectionLogic.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+import { ItemType, SelectValue, SelectArray } from '../types';
+interface SelectionLogicProps {
+    multiple: boolean;
+    returnObject: boolean;
+    valueKey: string;
+}
+type EmitFunction = (event: 'update:modelValue', value: SelectValue | SelectArray) => void;
+export declare function useSelectionLogic(props: SelectionLogicProps, getValueKey: (item: ItemType | string | number) => string | number, getStoredValue: (item: ItemType | string | number) => ItemType | string | number, getPlainText: (item: ItemType) => string, selected: Ref<SelectValue | SelectArray>, search: Ref<string>, emit: EmitFunction): {
+    updateValue: (item: ItemType | string | number | null) => void;
+};
+export {};

package/dist/components/Customs/Selects/SySelect/composables/useSySelectKeyboard.d.ts

@@ -8,6 +8,8 @@ export interface UseSySelectKeyboardOptions {
     toggleMenu: (skipInitialFocus?: boolean) => void;
     selectItem: (item: ItemType | null | undefined, event?: Event) => void;
     getItemText: (item: unknown) => unknown;
+    optionIdPrefix?: string;
+    focusListItem?: boolean;
 }
 export declare function useSySelectKeyboard(options: UseSySelectKeyboardOptions): {
     activeDescendantId: Ref<string, string>;

package/dist/components/Customs/SyCheckBoxGroup/SyCheckBoxGroup.d.ts

@@ -0,0 +1,160 @@
+import { ValidationRule } from '../../../composables/validation/useValidation';
+import { Option } from './types';
+type __VLS_Props = {
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    color?: string;
+    customRules?: ValidationRule[];
+    customSuccessRules?: ValidationRule[];
+    customWarningRules?: ValidationRule[];
+    density?: 'default' | 'comfortable' | 'compact';
+    disabled?: boolean;
+    disableErrorHandling?: boolean;
+    displayAsterisk?: boolean;
+    errorMessages?: string[] | null;
+    hideDetails?: boolean | 'auto';
+    id?: string;
+    isValidateOnBlur?: boolean;
+    label?: string;
+    modelValue?: (string | number) | (string | number)[] | null;
+    multiple?: boolean;
+    name?: string;
+    options?: Option[];
+    readonly?: boolean;
+    required?: boolean;
+    showSuccessMessages?: boolean;
+    successMessages?: string[] | null;
+    title?: string;
+    warningMessages?: string[] | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    validation: {
+        errors: import('vue').Ref<string[], string[]>;
+        warnings: import('vue').Ref<string[], string[]>;
+        successes: import('vue').Ref<string[], string[]>;
+        hasError: import('vue').ComputedRef<boolean>;
+        hasWarning: import('vue').ComputedRef<boolean>;
+        hasSuccess: import('vue').ComputedRef<boolean>;
+        validateField: (value: unknown, rules?: ValidationRule[], warningRules?: ValidationRule[], successRules?: ValidationRule[]) => import('../../../composables/validation/useValidation').ValidationResult;
+        validateOnSubmit: () => Promise<boolean>;
+        clearValidation: () => void;
+    };
+    validateOnSubmit: () => boolean;
+    checkErrorOnBlur: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    ariaLabel: string;
+    label: string;
+    title: string;
+    color: string;
+    disabled: boolean;
+    density: "default" | "comfortable" | "compact";
+    readonly: boolean;
+    id: string;
+    name: string;
+    options: Option[];
+    modelValue: (string | number) | (string | number)[] | null;
+    multiple: boolean;
+    required: boolean;
+    errorMessages: string[] | null;
+    warningMessages: string[] | null;
+    successMessages: string[] | null;
+    displayAsterisk: boolean;
+    customRules: ValidationRule[];
+    customWarningRules: ValidationRule[];
+    customSuccessRules: ValidationRule[];
+    showSuccessMessages: boolean;
+    isValidateOnBlur: boolean;
+    disableErrorHandling: boolean;
+    hideDetails: boolean | "auto";
+    ariaLabelledby: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    messagesRef: import('vue').CreateComponentPublicInstanceWithMixins<{
+        active: boolean;
+        transition: string | boolean | (import('vue').TransitionProps & {
+            component?: import('vue').Component;
+        }) | {
+            component: import('vue').Component;
+            leaveAbsolute: boolean;
+            group: boolean;
+        } | null;
+        style: import('vue').StyleValue;
+        messages: string | readonly string[];
+    } & {
+        color?: string | undefined;
+        class?: any;
+    } & {
+        $children?: {} | import('vue').VNodeChild | {
+            $stable?: boolean;
+        } | {
+            message?: ((arg: import('vuetify/lib/components/VMessages/VMessages.mjs').VMessageSlot) => import('vue').VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            message?: false | ((arg: import('vuetify/lib/components/VMessages/VMessages.mjs').VMessageSlot) => import('vue').VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:message"?: false | ((arg: import('vuetify/lib/components/VMessages/VMessages.mjs').VMessageSlot) => import('vue').VNodeChild) | undefined;
+    }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+        active: boolean;
+        transition: string | boolean | (import('vue').TransitionProps & {
+            component?: import('vue').Component;
+        }) | {
+            component: import('vue').Component;
+            leaveAbsolute: boolean;
+            group: boolean;
+        } | null;
+        style: import('vue').StyleValue;
+        messages: string | readonly string[];
+    }, true, {}, import('vue').SlotsType<Partial<{
+        message: (arg: import('vuetify/lib/components/VMessages/VMessages.mjs').VMessageSlot) => import('vue').VNode[];
+    }>>, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        active: boolean;
+        transition: string | boolean | (import('vue').TransitionProps & {
+            component?: import('vue').Component;
+        }) | {
+            component: import('vue').Component;
+            leaveAbsolute: boolean;
+            group: boolean;
+        } | null;
+        style: import('vue').StyleValue;
+        messages: string | readonly string[];
+    } & {
+        color?: string | undefined;
+        class?: any;
+    } & {
+        $children?: {} | import('vue').VNodeChild | {
+            $stable?: boolean;
+        } | {
+            message?: ((arg: import('vuetify/lib/components/VMessages/VMessages.mjs').VMessageSlot) => import('vue').VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            message?: false | ((arg: import('vuetify/lib/components/VMessages/VMessages.mjs').VMessageSlot) => import('vue').VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:message"?: false | ((arg: import('vuetify/lib/components/VMessages/VMessages.mjs').VMessageSlot) => import('vue').VNodeChild) | undefined;
+    }, {}, {}, {}, {}, {
+        active: boolean;
+        transition: string | boolean | (import('vue').TransitionProps & {
+            component?: import('vue').Component;
+        }) | {
+            component: import('vue').Component;
+            leaveAbsolute: boolean;
+            group: boolean;
+        } | null;
+        style: import('vue').StyleValue;
+        messages: string | readonly string[];
+    }> | null;
+}, HTMLFieldSetElement>;
+export default _default;

package/dist/components/Customs/SyCheckBoxGroup/locales.d.ts

@@ -0,0 +1,3 @@
+export declare const locales: {
+    labelledbyMessage: string;
+};

package/dist/components/Customs/SyCheckBoxGroup/types.d.ts

@@ -0,0 +1,10 @@
+export type Option = {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+    readonly?: boolean;
+    id?: string;
+    name?: string;
+    ariaLabel?: string;
+    title?: string;
+};