@topconsultnpm/sdkui-react 6.17.0-test10

package/lib/components/forms/Login/Chooser.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+import { ValidationItem } from '@topconsultnpm/sdk-ts';
+import { AdditionalIconProps } from "./TextBox";
+export interface ChooserColumn<T> {
+    field: keyof T;
+    caption: string;
+    type?: 'string' | 'boolean' | 'number' | 'date' | 'datetime';
+}
+interface ChooserProps<T> {
+    dataSource: T[];
+    columns: Array<ChooserColumn<T>>;
+    value: keyof T;
+    additionalIcons?: AdditionalIconProps[];
+    label?: string;
+    icon?: any;
+    placeHolder?: string;
+    disabled?: boolean;
+    validationItems?: ValidationItem[];
+    title?: string;
+    selectedRow?: T;
+    onSelectionChanged?: (value: T) => void;
+    onChooserClick?: () => void;
+    onClose?: () => void;
+    isDropDown?: boolean;
+}
+declare const Chooser: <T>({ dataSource, columns, value, additionalIcons, validationItems, title, label, icon, placeHolder, disabled, selectedRow, onChooserClick, onSelectionChanged, onClose, isDropDown }: ChooserProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default Chooser;
+export declare function IconDropDown(props: React.SVGProps<SVGSVGElement>): import("react/jsx-runtime").JSX.Element;

package/lib/components/forms/Login/Chooser.js

@@ -0,0 +1,145 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useRef, useEffect, useMemo } from "react";
+import styled from "styled-components";
+import DataGrid, { Column, Selection } from "devextreme-react/data-grid";
+import TextBox from "./TextBox";
+import { createPortal } from 'react-dom';
+import { IconSearch, SDKUI_Localizator, IconArrowLeft, IconApply } from "../../../helper";
+import TMButton from "../../base/TMButton";
+const PopupContainer = styled.div `
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: rgba(0, 0, 0, 0.4);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 100;
+`;
+const PopupHeaderContainer = styled.div `
+    display: flex;
+    padding: 10px;
+    align-items: center;
+    justify-content: space-between;
+`;
+const DropdownContainer = styled.div `
+  position: fixed;
+  background: white;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+  box-shadow: 0px 4px 6px rgba(0, 0, 0, 0.1);
+  max-height: 35vh;
+  overflow-y: auto;
+  z-index: 9999;
+  width: fit-content;
+  resize: both;
+`;
+const PopupContent = styled.div `
+  background: white;
+  padding: 20px;
+  border-radius: 8px;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+`;
+const Chooser = ({ dataSource, columns, value, additionalIcons = [], validationItems = [], title, label = '', icon, placeHolder, disabled, selectedRow, onChooserClick, onSelectionChanged, onClose, isDropDown = false }) => {
+    const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+    const [isPopupOpen, setIsPopupOpen] = useState(false);
+    const [focusedRow, setFocusedRow] = useState(null);
+    const dropdownRef = useRef(null);
+    const dropdownPortalRef = useRef(null);
+    const [dropdownPosition, setDropdownPosition] = useState({ top: 0, left: 0, width: 0, minWidth: 0, maxWidth: 0 });
+    useEffect(() => {
+        if (isDropdownOpen && dropdownRef.current) {
+            const rect = dropdownRef.current.getBoundingClientRect();
+            setDropdownPosition({
+                top: rect.bottom + window.scrollY,
+                left: rect.left + window.scrollX,
+                width: 'min-content',
+                minWidth: rect.width,
+                maxWidth: 550
+            });
+        }
+    }, [isDropdownOpen]);
+    const handleOpen = () => {
+        if (!disabled) {
+            if (isDropDown) {
+                setIsDropdownOpen((prev) => !prev);
+            }
+            else {
+                setIsPopupOpen(true);
+            }
+            onChooserClick?.();
+        }
+    };
+    const handleClose = () => {
+        setIsDropdownOpen(false);
+        setIsPopupOpen(false);
+        onClose?.();
+    };
+    const handlePopupApplySelection = () => {
+        if (focusedRow) {
+            onSelectionChanged?.(focusedRow);
+            handleClose();
+        }
+    };
+    const handleDropdownApplySelection = (e) => {
+        onSelectionChanged?.(e.data);
+        handleClose();
+    };
+    const handleKeyDown = (event) => {
+        if (event.key === " ") {
+            event.preventDefault();
+            handleOpen();
+        }
+        if (event.key === "Escape") {
+            event.preventDefault();
+            handleClose();
+        }
+    };
+    useEffect(() => {
+        function handleClickOutside(event) {
+            const target = event.target;
+            const clickedOutsideMain = dropdownRef.current && !dropdownRef.current.contains(target);
+            const clickedOutsidePortal = dropdownPortalRef.current && !dropdownPortalRef.current.contains(target);
+            if (clickedOutsideMain && clickedOutsidePortal) {
+                handleClose();
+            }
+        }
+        document.addEventListener("mousedown", handleClickOutside);
+        return () => {
+            document.removeEventListener("mousedown", handleClickOutside);
+        };
+    }, []);
+    const fixedChooserIcon = {
+        icon: isDropDown ? _jsx(IconDropDown, { fontSize: 18 }) : _jsx(IconSearch, {}),
+        tooltip: !isDropDown ? SDKUI_Localizator.Update : undefined,
+        onClick: handleOpen,
+        color: "#313131"
+    };
+    const dataGridOnKeyDown = (e) => {
+        switch (e.event?.key) {
+            case 'Enter':
+                handlePopupApplySelection();
+                break;
+            case 'Escape':
+                handleClose();
+                break;
+            default: break;
+        }
+    };
+    const defaultSelectedRowKey = useMemo(() => { return [selectedRow]; }, [selectedRow]);
+    const combinedIcons = !isDropDown ? [fixedChooserIcon, ...additionalIcons] : [...additionalIcons, fixedChooserIcon];
+    return (_jsxs("div", { style: { width: '100%' }, ref: dropdownRef, children: [_jsx(TextBox, { value: selectedRow ? selectedRow[value] : "", onValueChanged: () => { }, readOnly: false, type: "text", label: label, icon: icon, placeHolder: placeHolder, disabled: disabled, additionalIcons: combinedIcons, onClick: handleOpen, cursor: "pointer", validationItems: validationItems, onKeyDown: handleKeyDown }), isDropDown && isDropdownOpen && createPortal(_jsx(DropdownContainer, { ref: dropdownPortalRef, style: {
+                    top: dropdownPosition.top,
+                    left: dropdownPosition.left,
+                    width: dropdownPosition.width,
+                    minWidth: dropdownPosition.minWidth,
+                    maxWidth: dropdownPosition.maxWidth
+                }, children: _jsxs(DataGrid, { dataSource: dataSource, showBorders: true, onSelectionChanged: (e) => setFocusedRow(e.selectedRowsData[0] || null), defaultSelectedRowKeys: defaultSelectedRowKey, onRowClick: handleDropdownApplySelection, onKeyDown: dataGridOnKeyDown, width: '100%', children: [_jsx(Selection, { mode: "single" }), columns.map((col, index) => (_jsx(Column, { width: 'auto', allowResizing: true, dataField: col.field, caption: col.caption, dataType: col.type }, index * 2)))] }) }), document.body), !isDropDown && isPopupOpen && (_jsx(PopupContainer, { children: _jsxs(PopupContent, { children: [_jsxs(PopupHeaderContainer, { children: [_jsx(TMButton, { btnStyle: "icon", caption: SDKUI_Localizator.Back, onClick: handleClose, icon: _jsx(IconArrowLeft, {}) }), _jsx("h2", { children: title ?? label }), _jsx(TMButton, { btnStyle: "toolbar", caption: SDKUI_Localizator.Apply, onClick: handlePopupApplySelection, disabled: !focusedRow, color: "success", icon: _jsx(IconApply, {}) })] }), _jsxs(DataGrid, { dataSource: dataSource, showBorders: true, onSelectionChanged: (e) => setFocusedRow(e.selectedRowsData[0] || null), defaultSelectedRowKeys: defaultSelectedRowKey, onRowDblClick: handlePopupApplySelection, children: [_jsx(Selection, { mode: "single" }), columns.map((col, index) => (_jsx(Column, { dataField: col.field, caption: col.caption, dataType: col.type }, index * 2)))] })] }) }))] }));
+};
+export default Chooser;
+export function IconDropDown(props) { return (_jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", width: "1em", height: "1em", ...props, children: [" ", _jsx("path", { fill: "currentColor", d: "M7.41 8.59L12 13.17l4.59-4.58L18 10l-6 6l-6-6z" }), " "] })); } //NOSONAR

package/lib/components/forms/Login/LOGINLocalizator.d.ts

@@ -0,0 +1,29 @@
+import { CultureIDs } from '@topconsultnpm/sdk-ts';
+export declare class LOGINLocalizator {
+    private static _cultureID;
+    static setLanguage(culture: CultureIDs): void;
+    static get QuickAccess(): string;
+    static get ConfigureAuthenticator(): string;
+    static get OtpCodeSent(): string;
+    static get LicenseLoadingError(): string;
+    static get TopMediaWithMFA(): string;
+    static get QuickAccessExistsReplace(): string;
+    static get QuickAccessExists(): string;
+    static get SetupAuthenticator(): string;
+    static get SendOtpByEmail(): string;
+    static get Continue(): string;
+    static get NewPasswordSameAsOld(): string;
+    static get NewPasswordInvalid(): string;
+    static get InvalidPastedCode(): string;
+    static get FailedToResendOtp(): string;
+    static get ResendFailed(): string;
+    static get EnterOtpCode(): string;
+    static get ResendOtp(): string;
+    static get ResendIn(): string;
+    static get SendOtp(): string;
+    static get EnterOtpInstructions(): string;
+    static get CreateNewQuickAccess(): string;
+    static get EnterOtpEmailOnly(): string;
+    static get DidNotReceiveOtpClickResend(): string;
+    static get InvalidOtp(): string;
+}

package/lib/components/forms/Login/LOGINLocalizator.js

@@ -0,0 +1,247 @@
+import { CultureIDs } from '@topconsultnpm/sdk-ts';
+export class LOGINLocalizator {
+    static setLanguage(culture) {
+        this._cultureID = culture;
+    }
+    static get QuickAccess() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Schnellzugriffe";
+            case CultureIDs.En_US: return "Quick Access";
+            case CultureIDs.Es_ES: return "Accesos rápidos";
+            case CultureIDs.Fr_FR: return "Accès rapide";
+            case CultureIDs.Pt_PT: return "Acessos rápidos";
+            default: return "Accessi rapidi";
+        }
+    }
+    static get ConfigureAuthenticator() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Authenticator konfigurieren";
+            case CultureIDs.En_US: return "Configure authenticator";
+            case CultureIDs.Es_ES: return "Configurar autenticador";
+            case CultureIDs.Fr_FR: return "Configurer l’authentificateur";
+            case CultureIDs.Pt_PT: return "Configurar autenticador";
+            default: return "Configurazione authenticator";
+        }
+    }
+    static get OtpCodeSent() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Der OTP-Code wurde per E-Mail gesendet";
+            case CultureIDs.En_US: return "OTP code has been sent via email";
+            case CultureIDs.Es_ES: return "El código OTP se ha enviado por correo";
+            case CultureIDs.Fr_FR: return "Le code OTP a été envoyé par e-mail";
+            case CultureIDs.Pt_PT: return "O código OTP foi enviado por e-mail";
+            default: return "Il codice OTP è stato inviato via mail";
+        }
+    }
+    static get LicenseLoadingError() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Fehler beim Laden der Lizenz";
+            case CultureIDs.En_US: return "License loading error";
+            case CultureIDs.Es_ES: return "Error al cargar la licencia";
+            case CultureIDs.Fr_FR: return "Erreur de chargement de la licence";
+            case CultureIDs.Pt_PT: return "Erro ao carregar licença";
+            default: return "Errore caricamento licenza";
+        }
+    }
+    static get TopMediaWithMFA() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "TopMedia mit MFA";
+            case CultureIDs.En_US: return "TopMedia with MFA";
+            case CultureIDs.Es_ES: return "TopMedia con MFA";
+            case CultureIDs.Fr_FR: return "TopMedia avec MFA";
+            case CultureIDs.Pt_PT: return "TopMedia com MFA";
+            default: return "TopMedia con MFA";
+        }
+    }
+    static get QuickAccessExistsReplace() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ein Schnellzugriff existiert bereits. Möchten Sie ihn ersetzen?";
+            case CultureIDs.En_US: return "A quick access already exists. Do you want to replace it?";
+            case CultureIDs.Es_ES: return "Ya existe un acceso rápido. ¿Desea reemplazarlo?";
+            case CultureIDs.Fr_FR: return "Un accès rapide existe déjà. Voulez-vous le remplacer ?";
+            case CultureIDs.Pt_PT: return "Já existe um acesso rápido. Deseja substituí-lo?";
+            default: return "Esiste già un accesso rapido. Vuoi sostituirlo con quello attuale?";
+        }
+    }
+    static get QuickAccessExists() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Dieser Schnellzugriff existiert bereits";
+            case CultureIDs.En_US: return "This quick access already exists";
+            case CultureIDs.Es_ES: return "Este acceso rápido ya existe";
+            case CultureIDs.Fr_FR: return "Cet accès rapide existe déjà";
+            case CultureIDs.Pt_PT: return "Este acesso rápido já existe";
+            default: return "Esiste già questo accesso rapido";
+        }
+    }
+    static get SetupAuthenticator() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Authenticator einrichten";
+            case CultureIDs.En_US: return "Set up authenticator";
+            case CultureIDs.Es_ES: return "Configurar autenticador";
+            case CultureIDs.Fr_FR: return "Configurer l’authentificateur";
+            case CultureIDs.Pt_PT: return "Configurar autenticador";
+            default: return "Configura authenticator";
+        }
+    }
+    static get SendOtpByEmail() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Sende mir den OTP per E-Mail";
+            case CultureIDs.En_US: return "Send me the OTP via email";
+            case CultureIDs.Es_ES: return "Envíame el OTP por correo";
+            case CultureIDs.Fr_FR: return "Envoyez-moi le code OTP par e-mail";
+            case CultureIDs.Pt_PT: return "Envie-me o OTP por e-mail";
+            default: return "Inviami l'OTP via mail";
+        }
+    }
+    static get Continue() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Fortfahren";
+            case CultureIDs.En_US: return "Continue";
+            case CultureIDs.Es_ES: return "Continuar";
+            case CultureIDs.Fr_FR: return "Continuer";
+            case CultureIDs.Pt_PT: return "Continuar";
+            default: return "Continua";
+        }
+    }
+    static get NewPasswordSameAsOld() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Das neue Passwort darf nicht mit dem alten übereinstimmen";
+            case CultureIDs.En_US: return "New password cannot be the same as the old one";
+            case CultureIDs.Es_ES: return "La nueva contraseña no puede ser igual a la anterior";
+            case CultureIDs.Fr_FR: return "Le nouveau mot de passe ne peut pas être identique à l’ancien";
+            case CultureIDs.Pt_PT: return "A nova senha não pode ser igual à anterior";
+            default: return "La nuova password non può essere uguale con la vecchia password";
+        }
+    }
+    static get NewPasswordInvalid() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Das neue Passwort erfüllt nicht die Anforderungen";
+            case CultureIDs.En_US: return "New password does not meet the requirements";
+            case CultureIDs.Es_ES: return "La nueva contraseña no cumple con los requisitos";
+            case CultureIDs.Fr_FR: return "Le nouveau mot de passe ne respecte pas les exigences";
+            case CultureIDs.Pt_PT: return "A nova senha não atende aos requisitos";
+            default: return "La nuova password non soddisfa i requisiti";
+        }
+    }
+    static get InvalidPastedCode() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Der eingefügte Code muss genau 6 Ziffern lang sein";
+            case CultureIDs.En_US: return "The pasted code must be exactly 6 digits";
+            case CultureIDs.Es_ES: return "El código pegado debe tener exactamente 6 dígitos";
+            case CultureIDs.Fr_FR: return "Le code collé doit contenir exactement 6 chiffres";
+            case CultureIDs.Pt_PT: return "O código colado deve ter exatamente 6 dígitos";
+            default: return "Il codice incollato deve essere esattamente di 6 cifre";
+        }
+    }
+    static get FailedToResendOtp() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "OTP konnte nicht erneut gesendet werden";
+            case CultureIDs.En_US: return "Failed to resend OTP";
+            case CultureIDs.Es_ES: return "Error al reenviar el OTP";
+            case CultureIDs.Fr_FR: return "Échec de renvoi du code OTP";
+            case CultureIDs.Pt_PT: return "Falha ao reenviar o OTP";
+            default: return "Impossibile inviare nuovamente l'OTP";
+        }
+    }
+    static get ResendFailed() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Erneutes Senden fehlgeschlagen";
+            case CultureIDs.En_US: return "Resend failed";
+            case CultureIDs.Es_ES: return "Error al reenviar";
+            case CultureIDs.Fr_FR: return "Échec du renvoi";
+            case CultureIDs.Pt_PT: return "Falha ao reenviar";
+            default: return "Reinvio non riuscito";
+        }
+    }
+    static get EnterOtpCode() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Geben Sie den OTP-Code ein";
+            case CultureIDs.En_US: return "Enter the OTP code";
+            case CultureIDs.Es_ES: return "Introduce el código OTP";
+            case CultureIDs.Fr_FR: return "Entrez le code OTP";
+            case CultureIDs.Pt_PT: return "Digite o código OTP";
+            default: return "Inserisci il codice OTP";
+        }
+    }
+    static get ResendOtp() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "OTP erneut senden";
+            case CultureIDs.En_US: return "Resend OTP";
+            case CultureIDs.Es_ES: return "Reenviar OTP";
+            case CultureIDs.Fr_FR: return "Renvoyer le code OTP";
+            case CultureIDs.Pt_PT: return "Reenviar OTP";
+            default: return "Reinvia OTP";
+        }
+    }
+    static get ResendIn() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Erneut senden in";
+            case CultureIDs.En_US: return "Resend in";
+            case CultureIDs.Es_ES: return "Reenviar en";
+            case CultureIDs.Fr_FR: return "Renvoyer dans";
+            case CultureIDs.Pt_PT: return "Reenviar em";
+            default: return "Reinvia in";
+        }
+    }
+    static get SendOtp() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "OTP senden";
+            case CultureIDs.En_US: return "Send OTP";
+            case CultureIDs.Es_ES: return "Enviar OTP";
+            case CultureIDs.Fr_FR: return "Envoyer le code OTP";
+            case CultureIDs.Pt_PT: return "Enviar OTP";
+            default: return "Invia OTP";
+        }
+    }
+    static get EnterOtpInstructions() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Geben Sie den OTP-Code ein, den Sie per E-Mail oder über Google/Microsoft Authenticator erhalten haben.";
+            case CultureIDs.En_US: return "Enter the OTP code you received via email or Google/Microsoft Authenticator.";
+            case CultureIDs.Es_ES: return "Introduce el código OTP que recibiste por correo electrónico o Google/Microsoft Authenticator.";
+            case CultureIDs.Fr_FR: return "Saisissez le code OTP que vous avez reçu par e-mail ou via Google/Microsoft Authenticator.";
+            case CultureIDs.Pt_PT: return "Insira o código OTP que você recebeu por e-mail ou pelo Google/Microsoft Authenticator.";
+            default: return "Inserisci il codice OTP che hai ricevuto via email o Google/Microsoft Authenticator.";
+        }
+    }
+    static get CreateNewQuickAccess() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Neuen Schnellzugriff erstellen";
+            case CultureIDs.En_US: return "Create new quick access";
+            case CultureIDs.Es_ES: return "Crear nuevo acceso rápido";
+            case CultureIDs.Fr_FR: return "Créer un nouvel accès rapide";
+            case CultureIDs.Pt_PT: return "Criar novo acesso rápido";
+            default: return "Crea nuovo accesso rapido";
+        }
+    }
+    static get EnterOtpEmailOnly() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Geben Sie den OTP-Code ein, den Sie per E-Mail erhalten haben.";
+            case CultureIDs.En_US: return "Enter the OTP code you received via email.";
+            case CultureIDs.Es_ES: return "Introduce el código OTP que recibiste por correo electrónico.";
+            case CultureIDs.Fr_FR: return "Saisissez le code OTP que vous avez reçu par e-mail.";
+            case CultureIDs.Pt_PT: return "Insira o código OTP que você recebeu por e-mail.";
+            default: return "Inserisci il codice OTP che hai ricevuto via email.";
+        }
+    }
+    static get DidNotReceiveOtpClickResend() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return 'Wenn Sie ihn nicht erhalten haben, klicken Sie auf "Erneut senden", um einen neuen zu erhalten.';
+            case CultureIDs.En_US: return 'If you didn’t receive it, click "Resend" to get another one.';
+            case CultureIDs.Es_ES: return 'Si no lo recibiste, haz clic en "Reenviar" para obtener otro.';
+            case CultureIDs.Fr_FR: return 'Si vous ne l’avez pas reçu, cliquez sur "Renvoyer" pour en obtenir un autre.';
+            case CultureIDs.Pt_PT: return 'Se você não o recebeu, clique em "Reenviar" para obter outro.';
+            default: return 'Se non lo hai ricevuto, clicca su "Reinvia" per ottenerne un altro.';
+        }
+    }
+    static get InvalidOtp() {
+        switch (this._cultureID) {
+            case CultureIDs.De_DE: return "Ungültiger OTP";
+            case CultureIDs.En_US: return "Invalid OTP";
+            case CultureIDs.Es_ES: return "OTP no válido";
+            case CultureIDs.Fr_FR: return "OTP invalide";
+            case CultureIDs.Pt_PT: return "OTP inválido";
+            default: return "OTP non valido";
+        }
+    }
+}
+LOGINLocalizator._cultureID = CultureIDs.It_IT;

package/lib/components/forms/Login/LoginValidatorService.d.ts

@@ -0,0 +1,50 @@
+import { ArchiveDescriptor, AuthenticationModes, CultureIDs, ValidationItem } from '@topconsultnpm/sdk-ts';
+import { TMEndpointsType } from './TMLoginForm';
+export interface LoginData {
+    endpoint: TMEndpointsType;
+    dcmtArchive: ArchiveDescriptor;
+    authenticationMode: AuthenticationModes;
+    username?: string;
+    password?: string;
+    cultureID: CultureIDs;
+    saveAsRapidAccess?: boolean;
+    rapidAccessName?: string;
+    otp?: string;
+    authDomainOnBehalfOf?: string;
+    usernameOnBehalfOf?: string;
+    passwordOnBehalfOf?: string;
+    authDomain?: string;
+}
+export interface ChangePasswordData {
+    username: string;
+    oldPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+    changePassword: boolean;
+    isValid: boolean;
+}
+export interface RecoverPasswordData {
+    email: string;
+    otp: string;
+}
+export declare class LoginValidator {
+    static validate(data: LoginData): {
+        fieldValidations: Map<string, ValidationItem[]>;
+        totalValidationItems: ValidationItem[];
+    };
+    private static validateBaseFields;
+    private static validateAuthModeFields;
+    private static validateRapidAccess;
+}
+export declare class ChangePasswordValidator {
+    static validate(data: ChangePasswordData): {
+        fieldValidations: Map<string, ValidationItem[]>;
+        totalValidationItems: ValidationItem[];
+    };
+}
+export declare class RecoverPasswordValidator {
+    static validate(data: RecoverPasswordData): {
+        fieldValidations: Map<string, ValidationItem[]>;
+        totalValidationItems: ValidationItem[];
+    };
+}

package/lib/components/forms/Login/LoginValidatorService.js

@@ -0,0 +1,162 @@
+import { AuthenticationModes, CultureIDs, ResultTypes } from '@topconsultnpm/sdk-ts';
+import { LOGINLocalizator } from './LOGINLocalizator';
+import { SDKUI_Localizator } from '../../../helper';
+export class LoginValidator {
+    static validate(data) {
+        const validations = new Map();
+        const addError = (field, message) => {
+            const item = {
+                ResultType: ResultTypes.ERROR,
+                Message: message,
+                PropertyName: field,
+                PropertyScopes: []
+            };
+            const existing = validations.get(field) || [];
+            validations.set(field, [...existing, item]);
+        };
+        this.validateBaseFields(data, addError);
+        this.validateAuthModeFields(data, addError);
+        this.validateRapidAccess(data, addError);
+        const totalValidationItems = Array.from(validations.values()).flat();
+        return {
+            fieldValidations: validations,
+            totalValidationItems
+        };
+    }
+    static validateBaseFields(data, addError) {
+        if (!data.endpoint?.Description?.trim()) {
+            addError("endpoint", SDKUI_Localizator.RequiredField);
+        }
+        if (!data.dcmtArchive?.description?.trim()) {
+            addError("dcmtArchive", SDKUI_Localizator.RequiredField);
+        }
+        if (!data.authenticationMode || data.authenticationMode === AuthenticationModes.None) {
+            addError("authenticationMode", SDKUI_Localizator.RequiredField);
+        }
+        if (!data.cultureID || data.cultureID === CultureIDs.None) {
+            addError("cultureID", SDKUI_Localizator.RequiredField);
+        }
+    }
+    static validateAuthModeFields(data, addError) {
+        const authMode = data.authenticationMode;
+        const requireUsernameAndPassword = [
+            AuthenticationModes.TopMedia,
+            AuthenticationModes.Windows,
+            AuthenticationModes.WindowsWithAlternativeCredentials
+        ];
+        if (requireUsernameAndPassword.includes(authMode)) {
+            if (!data.username?.trim())
+                addError("username", SDKUI_Localizator.RequiredField);
+            if (!data.password?.trim())
+                addError("password", SDKUI_Localizator.RequiredField);
+        }
+        if (authMode === AuthenticationModes.TopMediaWithMFA) {
+            if (!data.username?.trim())
+                addError("username", SDKUI_Localizator.RequiredField);
+            if (!data.password?.trim())
+                addError("password", SDKUI_Localizator.RequiredField);
+            if (!data.otp || !/^\d{6}$/.test(data.otp)) {
+                addError("otp", SDKUI_Localizator.RequiredField);
+            }
+        }
+        if (authMode === AuthenticationModes.TopMediaOnBehalfOf) {
+            if (!data.username?.trim())
+                addError("username", SDKUI_Localizator.RequiredField);
+            if (!data.password?.trim())
+                addError("password", SDKUI_Localizator.RequiredField);
+            if (!data.authDomainOnBehalfOf?.trim())
+                addError("authDomainOnBehalfOf", SDKUI_Localizator.RequiredField);
+            if (!data.usernameOnBehalfOf?.trim())
+                addError("usernameOnBehalfOf", SDKUI_Localizator.RequiredField);
+            if (!data.passwordOnBehalfOf?.trim())
+                addError("passwordOnBehalfOf", SDKUI_Localizator.RequiredField);
+        }
+        if (authMode === AuthenticationModes.WindowsThroughTopMedia) {
+            if (!data.username?.trim())
+                addError("username", SDKUI_Localizator.RequiredField);
+            if (!data.password?.trim())
+                addError("password", SDKUI_Localizator.RequiredField);
+            if (!data.authDomain?.trim())
+                addError("authDomain", SDKUI_Localizator.RequiredField);
+        }
+    }
+    static validateRapidAccess(data, addError) {
+        if (data.saveAsRapidAccess && !data.rapidAccessName?.trim()) {
+            addError("rapidAccessName", SDKUI_Localizator.RequiredField);
+        }
+    }
+}
+export class ChangePasswordValidator {
+    static validate(data) {
+        const validations = new Map();
+        const addError = (field, message) => {
+            const item = {
+                ResultType: ResultTypes.ERROR,
+                Message: message,
+                PropertyName: field,
+                PropertyScopes: []
+            };
+            const existing = validations.get(field) || [];
+            validations.set(field, [...existing, item]);
+        };
+        if (data.changePassword && !data.oldPassword?.trim()) {
+            addError("oldPassword", SDKUI_Localizator.RequiredField);
+        }
+        if (!data.newPassword?.trim()) {
+            addError("newPassword", SDKUI_Localizator.RequiredField);
+        }
+        else if (data.username) {
+            const lowerPassword = data.newPassword.toLowerCase();
+            const lowerUsername = data.username.toLowerCase();
+            if (lowerPassword === data.oldPassword.toLocaleLowerCase()) {
+                addError("newPassword", LOGINLocalizator.NewPasswordSameAsOld);
+            }
+            if (lowerPassword === lowerUsername) {
+                addError("newPassword", SDKUI_Localizator.PasswordEqualsUsernameError);
+            }
+            else if (lowerPassword.includes(lowerUsername)) {
+                addError("newPassword", SDKUI_Localizator.PasswordContainsUsernameError);
+            }
+        }
+        if (!data.isValid && data.newPassword?.trim()) {
+            addError("newPassword", LOGINLocalizator.NewPasswordInvalid);
+        }
+        if (data.newPassword?.trim() && data.confirmPassword !== data.newPassword) {
+            addError("confirmPassword", SDKUI_Localizator.PasswordConfirmError);
+        }
+        const totalValidationItems = Array.from(validations.values()).flat();
+        return {
+            fieldValidations: validations,
+            totalValidationItems
+        };
+    }
+}
+export class RecoverPasswordValidator {
+    static validate(data) {
+        const validations = new Map();
+        const addValidationItem = (field, message, type = ResultTypes.ERROR) => {
+            const item = {
+                ResultType: type,
+                Message: message,
+                PropertyName: field,
+                PropertyScopes: []
+            };
+            const existing = validations.get(field) || [];
+            validations.set(field, [...existing, item]);
+        };
+        if (!data.email?.trim()) {
+            addValidationItem("email", SDKUI_Localizator.RequiredField);
+        }
+        else if (!/^[\w-.]+@([\w-]+\.)+[\w-]{2,4}$/.test(data.email)) {
+            addValidationItem("email", SDKUI_Localizator.EmailIsNotValid, ResultTypes.WARNING);
+        }
+        if (!data.otp || !/^\d{6}$/.test(data.otp)) {
+            addValidationItem("otp", SDKUI_Localizator.RequiredField);
+        }
+        const totalValidationItems = Array.from(validations.values()).flat();
+        return {
+            fieldValidations: validations,
+            totalValidationItems
+        };
+    }
+}

package/lib/components/forms/Login/Menu.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+interface MenuProps {
+    visible?: boolean;
+    children: React.ReactNode;
+    x: number | string;
+    y: number | string;
+    onClose: () => void;
+}
+declare const Menu: React.FC<MenuProps>;
+export default Menu;