IBX-10471: [Inputs] Inputs Validators Base

Author: GrabowskiM

packages/components/src/internal/hooks/useValidatorManager.ts

@@ -0,0 +1,13 @@
+import { useContext, useRef } from 'react';
+
+import { TranslatorContext } from '@ids-context/Translator';
+
+import BaseValidator from '../../validators/BaseValidator';
+import ValidatorManager from '../../validators/ValidatorManager';
+
+export default (validators: BaseValidator[] = []) => {
+    const translator = useContext(TranslatorContext);
+    const validatorManagerInstance = useRef(new ValidatorManager(validators, { translator }));
+
+    return validatorManagerInstance.current;
+};

packages/components/src/validators/BaseValidator.ts

@@ -0,0 +1,15 @@
+import { TranslatorType } from '@ids-context/Translator';
+
+export default abstract class BaseValidator {
+    protected _translator!: TranslatorType;
+
+    setTranslator(translator: TranslatorType) {
+        this._translator = translator;
+    }
+
+    abstract getErrorMessage(): string;
+
+    abstract validate(_value: unknown): boolean;
+}
+
+export type BaseValidatorType = typeof BaseValidator;

packages/components/src/validators/IsEmptyStringValidator.ts

@@ -0,0 +1,13 @@
+import BaseValidator from './BaseValidator';
+
+export default class IsEmptyStringValidator extends BaseValidator {
+    getErrorMessage(): string {
+        const Translator = this._translator;
+
+        return Translator.trans(/*@Desc("This field cannot be empty.")*/ 'ibexa.validators.is_empty_string');
+    }
+
+    validate(value: string): boolean {
+        return value.trim() !== '';
+    }
+}

packages/components/src/validators/ValidatorManager.ts

@@ -0,0 +1,39 @@
+import { TranslatorType } from '@ids-context/Translator/Translator.types';
+
+import BaseValidator from './BaseValidator';
+
+interface ValidatorManagerOptions {
+    translator: TranslatorType;
+}
+
+export default class ValidatorManager {
+    private _validators: BaseValidator[];
+    private _translator: TranslatorType;
+
+    constructor(validators: BaseValidator[] = [], { translator }: ValidatorManagerOptions) {
+        validators.forEach((validator) => {
+            validator.setTranslator(translator);
+        });
+
+        this._validators = validators;
+        this._translator = translator;
+    }
+
+    addValidator(validator: BaseValidator): void {
+        validator.setTranslator(this._translator);
+
+        this._validators.push(validator);
+    }
+
+    removeValidator(validator: BaseValidator): void {
+        this._validators = this._validators.filter((savedValidator) => savedValidator !== validator);
+    }
+
+    validate(value: unknown) {
+        const errors = this._validators
+            .filter((validator: BaseValidator) => !validator.validate(value))
+            .map((validator: BaseValidator) => validator.getErrorMessage());
+
+        return { isValid: !errors.length, messages: errors };
+    }
+}