@lion/ui 0.5.3 → 0.5.5

package/components/validate-messages/src/loadDefaultFeedbackMessagesNoSideEffects.js

@@ -1,197 +1,27 @@
 /* eslint-disable import/no-extraneous-dependencies */
-import { MatchesOption } from '@lion/ui/combobox.js';
-import {
-  DefaultSuccess,
-  EqualsLength,
-  IsDate,
-  IsDateDisabled,
-  IsEmail,
-  IsNumber,
-  MaxDate,
-  MaxLength,
-  MaxNumber,
-  MinDate,
-  MinLength,
-  MinMaxDate,
-  MinMaxLength,
-  MinMaxNumber,
-  MinNumber,
-  Pattern,
-  Required,
-} from '@lion/ui/form-core.js';
-import { PhoneNumber } from '@lion/ui/input-tel.js';
+import { loadComboboxMessagesNoSideEffects } from './per-entrypoint/loadComboboxMessagesNoSideEffects.js';
+import { loadFormCoreMessagesNoSideEffects } from './per-entrypoint/loadFormCoreMessagesNoSideEffects.js';
+import { loadInputTelMessagesNoSideEffects } from './per-entrypoint/loadInputTelMessagesNoSideEffects.js';
 
 /**
  * @typedef {import('../../form-core/types/validate/validate.js').FeedbackMessageData} FeedbackMessageData
  * @typedef {import('@lion/ui/localize.js').LocalizeManager} LocalizeManager
  */
 
-let loaded = false;
+let isLoaded = false;
 
 /**
  * @param {{localize: LocalizeManager}} opts allow multiple lion/extension lib versions to provide their deduped instance of LocalizeManager
  * @returns
  */
 export function loadDefaultFeedbackMessagesNoSideEffects({ localize }) {
-  if (loaded === true) {
+  if (isLoaded === true) {
     return;
   }
 
-  const forMessagesToBeReady = () =>
-    localize.loadNamespace(
-      {
-        'lion-validate': /** @param {string} locale */ locale => {
-          switch (locale) {
-            case 'bg-BG':
-              return import('@lion/ui/validate-messages-translations/bg-BG.js');
-            case 'bg':
-              return import('@lion/ui/validate-messages-translations/bg.js');
-            case 'cs-CZ':
-              return import('@lion/ui/validate-messages-translations/cs-CZ.js');
-            case 'cs':
-              return import('@lion/ui/validate-messages-translations/cs.js');
-            case 'de-DE':
-              return import('@lion/ui/validate-messages-translations/de-DE.js');
-            case 'de':
-              return import('@lion/ui/validate-messages-translations/de.js');
-            case 'en-AU':
-              return import('@lion/ui/validate-messages-translations/en-AU.js');
-            case 'en-GB':
-              return import('@lion/ui/validate-messages-translations/en-GB.js');
-            case 'en-US':
-              return import('@lion/ui/validate-messages-translations/en-US.js');
-            case 'en-PH':
-              return import('@lion/ui/validate-messages-translations/en-PH.js');
-            case 'en':
-              return import('@lion/ui/validate-messages-translations/en.js');
-            case 'es-ES':
-              return import('@lion/ui/validate-messages-translations/es-ES.js');
-            case 'es':
-              return import('@lion/ui/validate-messages-translations/es.js');
-            case 'fr-FR':
-              return import('@lion/ui/validate-messages-translations/fr-FR.js');
-            case 'fr-BE':
-              return import('@lion/ui/validate-messages-translations/fr-BE.js');
-            case 'fr':
-              return import('@lion/ui/validate-messages-translations/fr.js');
-            case 'hu-HU':
-              return import('@lion/ui/validate-messages-translations/hu-HU.js');
-            case 'hu':
-              return import('@lion/ui/validate-messages-translations/hu.js');
-            case 'it-IT':
-              return import('@lion/ui/validate-messages-translations/it-IT.js');
-            case 'it':
-              return import('@lion/ui/validate-messages-translations/it.js');
-            case 'nl-BE':
-              return import('@lion/ui/validate-messages-translations/nl-BE.js');
-            case 'nl-NL':
-              return import('@lion/ui/validate-messages-translations/nl-NL.js');
-            case 'nl':
-              return import('@lion/ui/validate-messages-translations/nl.js');
-            case 'pl-PL':
-              return import('@lion/ui/validate-messages-translations/pl-PL.js');
-            case 'pl':
-              return import('@lion/ui/validate-messages-translations/pl.js');
-            case 'ro-RO':
-              return import('@lion/ui/validate-messages-translations/ro-RO.js');
-            case 'ro':
-              return import('@lion/ui/validate-messages-translations/ro.js');
-            case 'ru-RU':
-              return import('@lion/ui/validate-messages-translations/ru-RU.js');
-            case 'ru':
-              return import('@lion/ui/validate-messages-translations/ru.js');
-            case 'sk-SK':
-              return import('@lion/ui/validate-messages-translations/sk-SK.js');
-            case 'sk':
-              return import('@lion/ui/validate-messages-translations/sk.js');
-            case 'uk-UA':
-              return import('@lion/ui/validate-messages-translations/uk-UA.js');
-            case 'uk':
-              return import('@lion/ui/validate-messages-translations/uk.js');
-            case 'zh-CN':
-            case 'zh':
-              return import('@lion/ui/validate-messages-translations/zh.js');
-            default:
-              return import('@lion/ui/validate-messages-translations/en.js');
-          }
-        },
-      },
-      { locale: localize.locale },
-    );
+  loadComboboxMessagesNoSideEffects({ localize });
+  loadFormCoreMessagesNoSideEffects({ localize });
+  loadInputTelMessagesNoSideEffects({ localize });
 
-  /**
-   * @param {FeedbackMessageData} data
-   * @returns {Promise<string|Element>}
-   */
-  const getLocalizedMessage = async data => {
-    await forMessagesToBeReady();
-    if (data) {
-      return localize.msg(`lion-validate:${data.type}.${data.name}`, data);
-    }
-    return '';
-  };
-
-  /** @param {FeedbackMessageData} data */
-  Required.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  EqualsLength.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MinLength.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MaxLength.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MinMaxLength.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  Pattern.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  IsEmail.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  IsNumber.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MinNumber.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MaxNumber.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MinMaxNumber.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  IsDate.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MinDate.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MaxDate.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MinMaxDate.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  IsDateDisabled.getMessage = async data => getLocalizedMessage(data);
-  /** @param {FeedbackMessageData} data */
-  MatchesOption.getMessage = async data => getLocalizedMessage(data);
-
-  DefaultSuccess.getMessage = async data => {
-    await forMessagesToBeReady();
-    const randomKeys = localize.msg('lion-validate:success.RandomOk').split(',');
-    const key = randomKeys[Math.floor(Math.random() * randomKeys.length)].trim();
-    return localize.msg(`lion-validate:${key}`, data);
-  };
-
-  /** @param {FeedbackMessageData} data */
-  // @ts-ignore
-  PhoneNumber.getMessage = async data => {
-    await forMessagesToBeReady();
-    const { type, outcome } = data;
-    if (outcome === 'too-long') {
-      // TODO: get max-length of country and use MaxLength validator
-      return localize.msg(`lion-validate:${type}.Pattern`, data);
-    }
-    if (outcome === 'too-short') {
-      // TODO: get min-length of country and use MinLength validator
-      return localize.msg(`lion-validate:${type}.Pattern`, data);
-    }
-    // TODO: add a more specific message here
-    if (outcome === 'invalid-country-code') {
-      return localize.msg(`lion-validate:${type}.Pattern`, data);
-    }
-    return localize.msg(`lion-validate:${type}.Pattern`, data);
-  };
-
-  loaded = true;
+  isLoaded = true;
 }

package/components/validate-messages/src/per-entrypoint/README.md

@@ -0,0 +1,16 @@
+For optimized bundling, it's reccommended to load feedback messages per entrypoint. For instance, when you only use form-core in your app:
+
+```js
+import { LionInputTel } from '@lion/ui/input-tel.js';
+import { getLocalizeManager } from '@lion/ui/localize-no-side-effects.js';
+import { loadInputTelMessagesNoSideEffects } from '@lion/ui/validate-messages-no-side-effects.js';
+
+export class MyInputTel extends LionInputTel {
+  constructor() {
+    super();
+    loadInputTelMessagesNoSideEffects({ localize: getLocalizeManager() });
+  }
+}
+```
+
+This prevents you from loading unused entrypoints like input-tel (which loads a full phone validation library) etc.

package/components/validate-messages/src/per-entrypoint/loadComboboxMessagesNoSideEffects.js

@@ -0,0 +1,22 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { MatchesOption } from '@lion/ui/combobox.js';
+import { getLocalizedMessage } from '../getLocalizedMessage.js';
+
+/**
+ * @typedef {import('../../../form-core/types/validate/validate.js').FeedbackMessageData} FeedbackMessageData
+ * @typedef {import('@lion/ui/localize.js').LocalizeManager} LocalizeManager
+ */
+
+let isLoaded = false;
+
+/**
+ * @param {{localize: LocalizeManager}} opts allow multiple lion/extension lib versions to provide their deduped instance of LocalizeManager
+ */
+export function loadComboboxMessagesNoSideEffects({ localize }) {
+  if (isLoaded === true) return;
+
+  /** @param {FeedbackMessageData} data */
+  MatchesOption.getMessage = async data => getLocalizedMessage({ data, localize });
+
+  isLoaded = true;
+}

package/components/validate-messages/src/per-entrypoint/loadFormCoreMessagesNoSideEffects.js

@@ -0,0 +1,77 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import {
+  DefaultSuccess,
+  EqualsLength,
+  IsDate,
+  IsDateDisabled,
+  IsEmail,
+  IsNumber,
+  MaxDate,
+  MaxLength,
+  MaxNumber,
+  MinDate,
+  MinLength,
+  MinMaxDate,
+  MinMaxLength,
+  MinMaxNumber,
+  MinNumber,
+  Pattern,
+  Required,
+} from '@lion/ui/form-core.js';
+import { getLocalizedMessage, loadValidateNamespace } from '../getLocalizedMessage.js';
+
+/**
+ * @typedef {import('../../../form-core/types/validate/validate.js').FeedbackMessageData} FeedbackMessageData
+ * @typedef {import('@lion/ui/localize.js').LocalizeManager} LocalizeManager
+ */
+
+let isLoaded = false;
+
+/**
+ * @param {{localize: LocalizeManager}} opts allow multiple lion/extension lib versions to provide their deduped instance of LocalizeManager
+ */
+export function loadFormCoreMessagesNoSideEffects({ localize }) {
+  if (isLoaded === true) return;
+
+  /** @param {FeedbackMessageData} data */
+  Required.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  EqualsLength.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  MinLength.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  MaxLength.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  MinMaxLength.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  Pattern.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  IsEmail.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  IsNumber.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  MinNumber.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  MaxNumber.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  MinMaxNumber.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  IsDate.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  MinDate.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  MaxDate.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  MinMaxDate.getMessage = async data => getLocalizedMessage({ data, localize });
+  /** @param {FeedbackMessageData} data */
+  IsDateDisabled.getMessage = async data => getLocalizedMessage({ data, localize });
+
+  DefaultSuccess.getMessage = async data => {
+    await loadValidateNamespace({ localize });
+    const randomKeys = localize.msg('lion-validate:success.RandomOk').split(',');
+    const key = randomKeys[Math.floor(Math.random() * randomKeys.length)].trim();
+    return localize.msg(`lion-validate:${key}`, data);
+  };
+
+  isLoaded = true;
+}

package/components/validate-messages/src/per-entrypoint/loadInputTelMessagesNoSideEffects.js

@@ -0,0 +1,39 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { PhoneNumber } from '@lion/ui/input-tel.js';
+import { loadValidateNamespace } from '../getLocalizedMessage.js';
+
+/**
+ * @typedef {import('../../../form-core/types/validate/validate.js').FeedbackMessageData} FeedbackMessageData
+ * @typedef {import('@lion/ui/localize.js').LocalizeManager} LocalizeManager
+ */
+
+let isLoaded = false;
+
+/**
+ * @param {{localize: LocalizeManager}} opts allow multiple lion/extension lib versions to provide their deduped instance of LocalizeManager
+ */
+export function loadInputTelMessagesNoSideEffects({ localize }) {
+  if (isLoaded === true) return;
+
+  /** @param {FeedbackMessageData} data */
+  // @ts-ignore
+  PhoneNumber.getMessage = async data => {
+    await loadValidateNamespace({ localize });
+    const { type, outcome } = data;
+    if (outcome === 'too-long') {
+      // TODO: get max-length of country and use MaxLength validator
+      return localize.msg(`lion-validate:${type}.Pattern`, data);
+    }
+    if (outcome === 'too-short') {
+      // TODO: get min-length of country and use MinLength validator
+      return localize.msg(`lion-validate:${type}.Pattern`, data);
+    }
+    // TODO: add a more specific message here
+    if (outcome === 'invalid-country-code') {
+      return localize.msg(`lion-validate:${type}.Pattern`, data);
+    }
+    return localize.msg(`lion-validate:${type}.Pattern`, data);
+  };
+
+  isLoaded = true;
+}

package/components/validate-messages/test/loadDefaultFeedbackMessagesNoSideEffects.test.js

@@ -0,0 +1,105 @@
+/* eslint-disable no-unused-vars, no-param-reassign */
+import { expect } from '@open-wc/testing';
+import { getLocalizeManager } from '@lion/ui/localize-no-side-effects.js';
+import { MinDate, MinLength, Required } from '@lion/ui/form-core.js';
+import { loadDefaultFeedbackMessagesNoSideEffects } from '@lion/ui/validate-messages-no-side-effects.js';
+
+/**
+ * @typedef {import('../../form-core/src/validate/Validator.js').Validator} Validator
+ */
+
+/**
+ * @param {Validator} validatorEl
+ */
+function getProtectedMembers(validatorEl) {
+  // @ts-ignore protected members allowed in test
+  return {
+    // @ts-ignore
+    getMessage: (...args) => validatorEl._getMessage(...args),
+  };
+}
+
+/**
+ * @typedef {import('@lion/ui/types/form-core.js').FormControlHost} FormControlHost
+ * @typedef {ArrayConstructor | ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor | DateConstructor | 'iban' | 'email'} modelValueType
+ */
+
+describe('loadDefaultFeedbackMessagesNoSideEffects', () => {
+  const localizeManager = getLocalizeManager();
+
+  it('will set default feedback message for Required', async () => {
+    const el = new Required();
+    const { getMessage } = getProtectedMembers(el);
+    expect(await getMessage()).to.equals(
+      'Please configure an error message for "Required" by overriding "static async getMessage()"',
+    );
+
+    loadDefaultFeedbackMessagesNoSideEffects({ localize: localizeManager });
+    expect(await getMessage({ fieldName: 'password' })).to.equal('Please enter a(n) password.');
+  });
+
+  it('passes data to the feedback message', async () => {
+    const el = new MinLength(10);
+    const { getMessage } = getProtectedMembers(el);
+
+    loadDefaultFeedbackMessagesNoSideEffects({ localize: localizeManager });
+    expect(await getMessage({ fieldName: 'password' })).to.equal(
+      'Please enter a correct password (at least 10 characters).',
+    );
+
+    const el2 = new MinDate(new Date('2024-01-29'));
+    // @ts-ignore protected members allowed in test
+    expect(await el2._getMessage({ fieldName: 'date' })).to.equal(
+      'Please enter a(n) date after or equal to 29/01/2024.',
+    );
+  });
+
+  it('will set select specific feedback message for Required when operationMode is set', async () => {
+    const el = new Required();
+    loadDefaultFeedbackMessagesNoSideEffects({ localize: localizeManager });
+    const { getMessage } = getProtectedMembers(el);
+    const formControl = { operationMode: 'select' };
+    expect(await getMessage({ fieldName: 'password', formControl })).to.equal(
+      'Please select a(n) password.',
+    );
+  });
+
+  it('will set upload specific feedback message for Required when operationMode is set', async () => {
+    const el = new Required();
+    const { getMessage } = getProtectedMembers(el);
+
+    loadDefaultFeedbackMessagesNoSideEffects({ localize: localizeManager });
+    const formControl = { operationMode: 'upload' };
+    expect(await getMessage({ fieldName: 'password', formControl })).to.equal(
+      'Please upload a(n) password.',
+    );
+  });
+
+  it('will set ignore the operationMode for any other validator then Required, e.g. MinLength', async () => {
+    const el = new MinLength(10);
+    const { getMessage } = getProtectedMembers(el);
+
+    loadDefaultFeedbackMessagesNoSideEffects({ localize: localizeManager });
+    const formControl = { operationMode: 'select' };
+    expect(await getMessage({ fieldName: 'password', formControl })).to.equal(
+      'Please enter a correct password (at least 10 characters).',
+    );
+  });
+
+  it('will await loading of translations when switching locale', async () => {
+    const el = new Required();
+    const { getMessage } = getProtectedMembers(el);
+    loadDefaultFeedbackMessagesNoSideEffects({ localize: localizeManager });
+    expect(await getMessage({ fieldName: 'password' })).to.equal('Please enter a(n) password.');
+    expect(await getMessage({ fieldName: 'user name' })).to.equal('Please enter a(n) user name.');
+
+    localizeManager.locale = 'de-DE';
+    await localizeManager.loadingComplete;
+    expect(await getMessage({ fieldName: 'Password' })).to.equal(
+      'Password muss ausgefüllt werden.',
+    );
+    expect(await getMessage({ fieldName: 'Benutzername' })).to.equal(
+      'Benutzername muss ausgefüllt werden.',
+    );
+  });
+});

package/components/validate-messages/translations/bg.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: 'Моля, въведете също {fieldName}.',
+    _RequiredUpload: 'Моля, качете {fieldName}.',
+    _RequiredSelect: 'Wählen Sie auch einen Wert für {fieldName} aus.',
     EqualsLength: 'Моля, въведете правилно {fieldName} от точно {params} знака.',
     MinLength: 'Моля, въведете правилен {fieldName} (поне {params}).',
     MaxLength: 'Моля, въведете правилен {fieldName} (до {params} знака).',
@@ -22,6 +24,8 @@ export default {
   },
   warning: {
     Required: 'Моля, въведете също {fieldName}.',
+    _RequiredUpload: 'Моля, качете {fieldName}.',
+    _RequiredSelect: 'Wählen Sie auch einen Wert für {fieldName} aus.',
     EqualsLength: 'Моля, въведете правилно {fieldName} от точно {params} знака.',
     MinLength: 'Моля, въведете правилен {fieldName} (поне {params}).',
     MaxLength: 'Моля, въведете правилен {fieldName} (до {params} знака).',

package/components/validate-messages/translations/cs.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: 'Zadejte rovněž {fieldName}.',
+    _RequiredUpload: 'Nahrajte {fieldname}.',
+    _RequiredSelect: 'Vyberte rovněž {fieldname}.',
     EqualsLength: 'Zadejte správné {fieldName}, přesně {params} znaků.',
     MinLength: 'Zadejte správné {fieldName} (alespoň {params}).',
     MaxLength: 'Zadejte správné {fieldName} (až {params} znaků).',
@@ -21,6 +23,8 @@ export default {
   },
   warning: {
     Required: 'Zadejte rovněž {fieldName}.',
+    _RequiredUpload: 'Nahrajte {fieldname}.',
+    _RequiredSelect: 'Vyberte rovněž {fieldname}.',
     EqualsLength: 'Zadejte správné {fieldName}, přesně {params} znaků.',
     MinLength: 'Zadejte správné {fieldName} (alespoň {params}).',
     MaxLength: 'Zadejte správné {fieldName} (až {params} znaků).',

package/components/validate-messages/translations/de.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: '{fieldName} muss ausgefüllt werden.',
+    _RequiredUpload: 'Bitte laden Sie ein/e/n {fieldName} hoch.',
+    _RequiredSelect: 'Wählen Sie auch einen Wert für {fieldName} aus.',
     EqualsLength: 'Geben Sie einen korrekten Wert für {fieldName} mit exakt {params} Zeichen ein.',
     MinLength: 'Du musst mindestens {params} Zeichen eingeben.',
     MaxLength: 'Du kannst maximal {params} Zeichen eingeben.',
@@ -23,6 +25,8 @@ export default {
   },
   warning: {
     Required: '{fieldName} sollte ausgefüllt werden.',
+    _RequiredUpload: 'Bitte laden Sie ein/e/n {fieldName} hoch.',
+    _RequiredSelect: 'Wählen Sie auch einen Wert für {fieldName} aus.',
     EqualsLength: 'Geben Sie einen korrekten Wert für {fieldName} mit exakt {params} Zeichen ein.',
     MinLength: 'Du solltest mindestens {params} Zeichen eingeben.',
     MaxLength: 'Du kannst maximal {params} Zeichen eingeben.',

package/components/validate-messages/translations/en.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: 'Please enter a(n) {fieldName}.',
+    _RequiredUpload: 'Please upload a(n) {fieldName}.',
+    _RequiredSelect: 'Please select a(n) {fieldName}.',
     EqualsLength: 'Please enter a correct {fieldName} of exactly {params} characters.',
     MinLength: 'Please enter a correct {fieldName} (at least {params} characters).',
     MaxLength: 'Please enter a correct {fieldName} (up to {params} characters).',
@@ -22,8 +24,10 @@ export default {
   },
   warning: {
     Required: 'Please enter a(n) {fieldName}.',
+    _RequiredUpload: 'Please upload a(n) {fieldName}.',
+    _RequiredSelect: 'Please select a(n) {fieldName}.',
     EqualsLength: 'Please enter a correct {fieldName} of exactly {params} characters.',
-    MinLength: 'Please enter a correct {fieldName} (at least {params}).',
+    MinLength: 'Please enter a correct {fieldName} (at least {params} characters).',
     MaxLength: 'Please enter a correct {fieldName} (up to {params} characters).',
     MinMaxLength:
       'Please enter a correct {fieldName} (between {params.min} and {params.max} characters).',

package/components/validate-messages/translations/es.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: 'Introduzca también un/a {fieldName}.',
+    _RequiredUpload: 'Cargue un {fieldName}.',
+    _RequiredSelect: 'Seleccione también un/a {fieldname}.',
     EqualsLength: 'Introduzca un/a {fieldName} correcto/a de exactamente {params} caracteres.',
     MinLength: 'Introduzca un/a {fieldName} correcto/a (de al menos {params} caracteres).',
     MaxLength: 'Introduzca un/a {fieldName} correcto/a (hasta {params} caracteres).',
@@ -23,6 +25,8 @@ export default {
   },
   warning: {
     Required: 'Introduzca también un/a {fieldName}.',
+    _RequiredUpload: 'Cargue un {fieldName}.',
+    _RequiredSelect: 'Seleccione también un/a {fieldname}.',
     EqualsLength: 'Introduzca un/a {fieldName} correcto/a de exactamente {params} caracteres.',
     MinLength: 'Introduzca un/a {fieldName} correcto/a (de al menos {params} caracteres).',
     MaxLength: 'Introduzca un/a {fieldName} correcto/a (hasta {params} caracteres).',

package/components/validate-messages/translations/fr.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: 'Veuillez également indiquer un(e) {fieldName}.',
+    _RequiredUpload: 'Veuillez télécharger un(e) {fieldName}.',
+    _RequiredSelect: 'Veuillez également sélectionner un(e) {fieldName}.',
     EqualsLength:
       'Veuillez saisir un(e) {fieldName} correct(e) comptant précisément {params} caractères.',
     MinLength: 'Veuillez indiquer un(e) {fieldName} correct(e) (au moins {params}).',
@@ -24,6 +26,8 @@ export default {
   },
   warning: {
     Required: 'Veuillez également indiquer un(e) {fieldName}.',
+    _RequiredUpload: 'Veuillez télécharger un(e) {fieldName}.',
+    _RequiredSelect: 'Veuillez également sélectionner un(e) {fieldName}.',
     EqualsLength:
       'Veuillez saisir un(e) {fieldName} correct(e) comptant précisément {params} caractères.',
     MinLength: 'Veuillez indiquer un(e) {fieldName} correct(e) (au moins {params}).',

package/components/validate-messages/translations/hu.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: 'Továbbá adjon meg egy {fieldName} értéket.',
+    _RequiredUpload: 'Töltsön fel egy {fieldName} elemet.',
+    _RequiredSelect: 'Továbbá válasszon ki egy {fieldname} értéket.',
     EqualsLength: 'Adjon meg egy helyes {fieldName} értéket (pontosan {params} karakter).',
     MinLength: 'Adjon meg egy helyes {fieldName} értéket (legalább {params}).',
     MaxLength: 'Adjon meg egy helyes {fieldName} értéket (legfeljebb {params} karakter).',
@@ -23,6 +25,8 @@ export default {
   },
   warning: {
     Required: 'Továbbá adjon meg egy {fieldName} értéket.',
+    _RequiredUpload: 'Töltsön fel egy {fieldName} elemet.',
+    _RequiredSelect: 'Továbbá válasszon ki egy {fieldname} értéket.',
     EqualsLength: 'Adjon meg egy helyes {fieldName} értéket (pontosan {params} karakter).',
     MinLength: 'Adjon meg egy helyes {fieldName} értéket (legalább {params}).',
     MaxLength: 'Adjon meg egy helyes {fieldName} értéket (legfeljebb {params} karakter).',

package/components/validate-messages/translations/it.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: 'Inserire anche un(a) {fieldName}.',
+    _RequiredUpload: 'Caricare un {fieldName}.',
+    _RequiredSelect: 'Selezionare anche un(a) {fieldname}.',
     EqualsLength: 'Inserire un(a) {fieldName} corretto(a) di esattamente {params} caratteri.',
     MinLength: 'Inserire un(a) {fieldName} corretto(a) (almeno {params}).',
     MaxLength: 'Inserire un(a) {fieldName} corretto(a) (fino a {params} caratteri).',
@@ -23,6 +25,8 @@ export default {
   },
   warning: {
     Required: 'Inserire anche un(a) {fieldName}.',
+    _RequiredUpload: 'Caricare un {fieldName}.',
+    _RequiredSelect: 'Selezionare anche un(a) {fieldname}.',
     EqualsLength: 'Inserire un(a) {fieldName} corretto(a) di esattamente {params} caratteri.',
     MinLength: 'Inserire un(a) {fieldName} corretto(a) (almeno {params}).',
     MaxLength: 'Inserire un(a) {fieldName} corretto(a) (fino a {params} caratteri).',

package/components/validate-messages/translations/nl.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: 'Vul een {fieldName} in.',
+    _RequiredUpload: 'Upload een {fieldName}.',
+    _RequiredSelect: 'Selecteer een {fieldname}.',
     EqualsLength: 'Vul een {fieldName} in gelijk aan {params} karakters.',
     MinLength: 'Vul een {fieldName} in van minimaal {params} karakters.',
     MaxLength: 'Vul een {fieldName} in van maximaal {params} karakters.',
@@ -22,6 +24,8 @@ export default {
   },
   warning: {
     Required: 'Vul een {fieldName} in.',
+    _RequiredUpload: 'Upload een {fieldName}.',
+    _RequiredSelect: 'Selecteer een {fieldname}.',
     EqualsLength: 'Vul een {fieldName} in gelijk aan {params} karakters.',
     MinLength: 'Vul een {fieldName} in van minimaal {params} karakters.',
     MaxLength: 'Vul een {fieldName} in van maximaal {params} karakters.',

package/components/validate-messages/translations/pl.js

@@ -1,6 +1,8 @@
 export default {
   error: {
     Required: 'Proszę również podać wartość {fieldName}.',
+    _RequiredUpload: 'Prześlij plik {fieldName}.',
+    _RequiredSelect: 'Wprowadź prawidłową wartość w polu {fieldname}.',
     EqualsLength: 'Wprowadź prawidłową wartość w polu {fieldName} (maks. liczba znaków: {params}).',
     MinLength: 'Proszę podać prawidłową wartość {fieldName} (co najmniej {params} znaków).',
     MaxLength: 'Proszę podać prawidłową wartość {fieldName} (maks. {params} znaków).',
@@ -22,6 +24,8 @@ export default {
   },
   warning: {
     Required: 'Proszę również podać wartość {fieldName}.',
+    _RequiredUpload: 'Prześlij plik {fieldName}.',
+    _RequiredSelect: 'Wprowadź prawidłową wartość w polu {fieldname}.',
     EqualsLength: 'Wprowadź prawidłową wartość w polu {fieldName} (maks. liczba znaków: {params}).',
     MinLength: 'Proszę podać prawidłową wartość {fieldName} (co najmniej {params} znaków).',
     MaxLength: 'Proszę podać prawidłową wartość {fieldName} (maks. {params} znaków).',