inviton-powerduck 0.0.75 → 0.0.76

package/app/powerduck-state.ts

@@ -1,7 +1,6 @@
 import { Language } from "../common/enums/language";
 import { ModalSectionMode } from "../common/enums/modal";
 import { isNullOrEmpty } from "../common/utils/is-null-or-empty";
-import { LanguageUtils } from "../common/utils/language-utils";
 import { IDynamicComponentContainer } from "../components/app/dynamic-component-contracts";
 import { IPowerduckSystemResources } from "./powerduck-system-resources";
 
@@ -40,11 +39,7 @@ export default class PowerduckState {
     }
 
     static getCurrentLanguage(): Language {
-        return this._language ?? Language.Slovak;
-    }
-
-    static getCurrentLanguageCode(): string {
-        return LanguageUtils.getLanguageCode(PowerduckState.getCurrentLanguage())
+        return this._language ?? Language.sk;
     }
 
     static getIntransparentBlockerHtml(): string {

package/app/powerduck-system-resources.ts

@@ -51,14 +51,13 @@ export interface IPowerduckSystemResources {
     quickEditItemsCount: string
     quickEditErrorNamed: string
 
-    language0: string;
-    language1: string;
-    language2: string;
-    language3: string;
-    language4: string;
-    language5: string;
-    language6: string;
-    language7: string;
+    languageSK: string;
+    languageEN: string;
+    languageCS: string;
+    languageDE: string;
+    languagePL: string;
+    languageIT: string;
+    languageHU: string;
 
     errorsOnForm: string;
     validationErrorRequired: string;

package/common/date-wrapper.ts

@@ -33,7 +33,7 @@ export class DateWrapper {
         opts.timeZone = 'UTC';
 
         try {
-            return this._dte.toLocaleDateString(opts.language || PowerduckState.getCurrentLanguageCode(), opts);
+            return this._dte.toLocaleDateString(opts.language || PowerduckState.getCurrentLanguage(), opts);
         } catch (e) {
             return this._dte.toString();
         }
@@ -43,7 +43,7 @@ export class DateWrapper {
         opts.timeZone = 'UTC';
 
         try {
-            return this._dte.toLocaleTimeString(opts.language || PowerduckState.getCurrentLanguageCode(), opts);
+            return this._dte.toLocaleTimeString(opts.language || PowerduckState.getCurrentLanguage(), opts);
         } catch (e) {
             return this._dte.toString();
         }
@@ -98,7 +98,7 @@ export class DateWrapper {
         }
 
         try {
-            return this._dte.toLocaleDateString(opts.language || PowerduckState.getCurrentLanguageCode(), args);
+            return this._dte.toLocaleDateString(opts.language || PowerduckState.getCurrentLanguage(), args);
         } catch (e) {
             return this._dte.toString();
         }
@@ -121,7 +121,7 @@ export class DateWrapper {
         }
 
         try {
-            return this._dte.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), args);
+            return this._dte.toLocaleDateString(PowerduckState.getCurrentLanguage(), args);
         } catch (e) {
             return this._dte.toString();
         }

package/common/enum-translation/currency-code-translator.ts

@@ -1,17 +1,17 @@
-import { CURRENCY_CODE } from "../enums/currency";
+import { Currency } from "../enums/currency";
 
 export default class CurrencyCodeTranslator {
-    static getString(val: CURRENCY_CODE) {
+    static getString(val: Currency) {
         switch (val) {
-            case CURRENCY_CODE.EUR:
+            case Currency.EUR:
                 return "€";
-            case CURRENCY_CODE.CZK:
+            case Currency.CZK:
                 return "Kč";
-            case CURRENCY_CODE.GBP:
+            case Currency.GBP:
                 return "£";
-            case CURRENCY_CODE.PLN:
+            case Currency.PLN:
                 return "zł";
-            case CURRENCY_CODE.USD:
+            case Currency.USD:
                 return "$";
             default:
                 return "";

package/common/enum-translation/day-translator.ts

@@ -1,11 +1,11 @@
-import { DAY } from "./../enums/day";
+import { Day } from "./../enums/day";
 import PowerduckState from './../../app/powerduck-state';
 import { capitalize } from "./../utils/capitalize-string";
 
 export default class DayTranslator {
     private static _dayMap: { [index: string]: string } = null as any;
 
-    static getString(day: DAY): string {
+    static getString(day: Day): string {
         this.initMap();
         return this._dayMap[day];
     }
@@ -16,7 +16,7 @@ export default class DayTranslator {
         }
 
         this._dayMap = {};
-        const locale = PowerduckState.getCurrentLanguageCode();
+        const locale = PowerduckState.getCurrentLanguage();
         for (var i = 7; i < 15; i++) {
             const dayDate = new Date(Date.UTC(2015, 5, i));
             const dayName = capitalize(dayDate.toLocaleDateString(locale, { weekday: "long", timeZone: "UTC" }));

package/common/enum-translation/language-translator.ts

@@ -1,14 +1,8 @@
-import { LANGUAGE, Language } from "./../enums/language";
-import { PortalUtils } from "../utils/utils";
-import { LanguageUtils } from "../utils/language-utils";
 import PowerduckState from "../../app/powerduck-state";
+import { Language } from "./../enums/language";
 
 export default class LanguageTranslator {
-    static getString(lang: LANGUAGE | Language) {
-        if (PortalUtils.isString(lang)) {
-            lang = LanguageUtils.getLanguageEnum(lang as any) as any; 
-        }
-
+    static getString(lang: Language | Language) {
         return PowerduckState.getResourceValue('language' + lang as any);
     }
 }

package/common/enums/currency.ts

@@ -1,4 +1,4 @@
-export enum CURRENCY_CODE {
+export enum Currency {
     PLN = "PLN",
     CZK = "CZK",
     EUR = "EUR",

package/common/enums/day.ts

@@ -1,4 +1,4 @@
-export enum DAY {
+export enum Day {
     MONDAY = "MONDAY",
     TUESDAY = "TUESDAY",
     WEDNESDAY = "WEDNESDAY",

package/common/enums/language.ts

@@ -1,15 +1,4 @@
 export enum Language {
-    Slovak = 0,
-    English = 1,
-    Czech = 2,
-    German = 3,
-    Latvian = 4,
-    Polish = 5,
-    Italian = 6,
-    Hungarian = 7,
-}
-
-export enum LANGUAGE {
     sk = "sk",
     en = "en",
     cs = "cs",

package/common/localized-value-helper.ts

@@ -1,7 +1,6 @@
-import LocalizedText from './localized-text';
-import LanguageEnumNormalizer from "./enum-translation/language-enum-normalizer";
 import PowerduckState from '../app/powerduck-state';
-import { LANGUAGE } from './enums/language';
+import { Language } from './enums/language';
+import LocalizedText from './localized-text';
 import { isNullOrEmpty } from './utils/is-null-or-empty';
 
 export default class LocalizedValueHelper {
@@ -10,28 +9,28 @@ export default class LocalizedValueHelper {
             return null as any;
         }
 
-        const lang = LanguageEnumNormalizer.getCodedLanguage(PowerduckState.getCurrentLanguage());
+        const lang = PowerduckState.getCurrentLanguage();
         const inLang = value[lang];
 
         if (inLang != null) {
             return inLang;
         }
 
-        if (lang == LANGUAGE.cs) {
-            const fbLang = value[LANGUAGE.sk];
+        if (lang == Language.cs) {
+            const fbLang = value[Language.sk];
             if (fbLang != null) {
                 return fbLang;
             }
         }
 
-        if (lang == LANGUAGE.sk) {
-            const fbLang = value[LANGUAGE.cs];
+        if (lang == Language.sk) {
+            const fbLang = value[Language.cs];
             if (fbLang != null) {
                 return fbLang;
             }
         }
 
-        const enVal = value[LANGUAGE.en];
+        const enVal = value[Language.en];
         if (enVal != null) {
             return enVal;
         }

package/common/utils/country-utils.ts

@@ -19,7 +19,7 @@ export default class CountryUtils {
         let countryNamesLocalizer: any;
 
         try {
-            countryNamesLocalizer = new (Intl as any).DisplayNames([PowerduckState.getCurrentLanguageCode()], { type: 'region' });
+            countryNamesLocalizer = new (Intl as any).DisplayNames([PowerduckState.getCurrentLanguage()], { type: 'region' });
         } catch (error) {
             countryNamesLocalizer = null;
         }
@@ -50,7 +50,7 @@ export default class CountryUtils {
         }
 
         try {
-            const collator = new Intl.Collator(PowerduckState.getCurrentLanguageCode(), { numeric: true, sensitivity: "base" });
+            const collator = new Intl.Collator(PowerduckState.getCurrentLanguage(), { numeric: true, sensitivity: "base" });
             localizedCountryList = [...localizedCountryList].sort((a, b) => collator.compare(a.text, b.text));
         } catch (error) {
             localizedCountryList = arraySort([...localizedCountryList], p => p.text);

package/common/utils/currency-utils.ts

@@ -1,5 +1,5 @@
 
-import { CURRENCY_CODE } from "../enums/currency";
+import { Currency } from "../enums/currency";
 import { LanguageUtils } from "./language-utils";
 
 export class CurrencyUtils {
@@ -9,11 +9,11 @@ export class CurrencyUtils {
      * @param value Number
      * @param currency Currency symbol
      */
-    static floatToCurrency(value: number, currency: CURRENCY_CODE | string | any, killZeroCents?: boolean): string {
+    static floatToCurrency(value: number, currency: Currency | string | any, killZeroCents?: boolean): string {
         return LanguageUtils.floatToCurrency(value, currency, killZeroCents);
     }
 
-    static getCurrencySymbol(currency: CURRENCY_CODE | string | any) {
+    static getCurrencySymbol(currency: Currency | string | any) {
         return CurrencyUtils.floatToCurrency(1.11, currency).replace("1.11", "").replace("1,11", "").trim();
     }
 }

package/common/utils/date-localization-utils.ts

@@ -6,7 +6,7 @@ import { capitalize } from "./capitalize-string";
 export default class DateLocalizationUtils {
 	private static readonly DATE_FORMAT_FOR_RANGE_PICKER = (function () {
 		const dummyDate = new Date(Date.UTC(2022, 11, 20));
-		const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+		const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 			day: '2-digit',
 			month: '2-digit',
 			year: "numeric",
@@ -19,7 +19,7 @@ export default class DateLocalizationUtils {
 	private static readonly MONTH_IS_FIRST: boolean = (function () {
 		const dummyDate = new Date(Date.UTC(2024, 9, 20));
 		try {
-			const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+			const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 				day: '2-digit',
 				month: '2-digit',
 				timeZone: 'UTC'
@@ -37,13 +37,13 @@ export default class DateLocalizationUtils {
 	private static readonly PATTERN_WITHOUT_YEAR: string = (function () {
 		const dummyDate = new Date(Date.UTC(2024, 9, 30));
 		try {
-			const monthName = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+			const monthName = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 				day: '2-digit',
 				month: 'long',
 				timeZone: 'UTC'
 			}).split('30').join('').split('.').join('').trim();
 
-			const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+			const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 				day: '2-digit',
 				month: 'long',
 				timeZone: 'UTC'
@@ -59,13 +59,13 @@ export default class DateLocalizationUtils {
 	private static readonly PATTERN_WITH_YEAR: string = (function () {
 		const dummyDate = new Date(Date.UTC(2024, 9, 30));
 		try {
-			const monthName = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+			const monthName = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 				day: '2-digit',
 				month: 'long',
 				timeZone: 'UTC'
 			}).split('30').join('').split('.').join('').trim();
 
-			const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+			const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 				day: '2-digit',
 				year: 'numeric',
 				month: 'long',
@@ -82,12 +82,12 @@ export default class DateLocalizationUtils {
 	private static readonly PATTERN_PLACEHOLDERED: string = (function () {
 		const dummyDate = new Date(Date.UTC(2024, 9, 30));
 		try {
-			const monthName = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+			const monthName = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 				month: 'long',
 				timeZone: 'UTC'
 			});
 
-			const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+			const formatted = dummyDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 				year: 'numeric',
 				month: 'long',
 				timeZone: 'UTC'
@@ -105,7 +105,7 @@ export default class DateLocalizationUtils {
 			const convertDate = new Date(Date.UTC(from.getFullYear(), from.getMonth(), from.getDate()));
 			convertDate.setDate(28);
 
-			const monthName = convertDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+			const monthName = convertDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 				day: '2-digit',
 				month: 'long',
 				timeZone: 'UTC'
@@ -138,7 +138,7 @@ export default class DateLocalizationUtils {
 	private static getFormatted = (dte: DateWrapper, pattern: string, day: "numeric" | "2-digit" | undefined, month?: "numeric" | "2-digit" | "long" | "short" | "narrow" | undefined, year?: "numeric" | "2-digit" | undefined): string => {
 		let monthVal: string;
 		try {
-			monthVal = capitalize(dte.innerDate.toLocaleDateString(PowerduckState.getCurrentLanguageCode(), {
+			monthVal = capitalize(dte.innerDate.toLocaleDateString(PowerduckState.getCurrentLanguage(), {
 				month: month,
 				timeZone: 'UTC'
 			}));

package/common/utils/language-utils.ts

@@ -1,11 +1,12 @@
 import PowerduckState from "../../app/powerduck-state";
-import { CURRENCY_CODE } from "../enums/currency";
+import LanguageTranslator from "../enum-translation/language-translator";
+import { Currency } from "../enums/currency";
 import { Language } from "../enums/language";
 import { arraySort } from "./array-sort";
 import { PortalUtils } from "./utils";
 
 export namespace LanguageUtils {
-    export let supportedLanguages = [Language.Slovak, Language.English];
+    export let supportedLanguages = [Language.sk, Language.en];
 
     export interface LanguageListItem {
         text: string;
@@ -25,37 +26,34 @@ export namespace LanguageUtils {
     export function getLanguageList(): Array<LanguageListItem> {
         let retVal = <Array<LanguageListItem>>[];
 
-        const getLanguage = (langId: number): LanguageListItem => {
+        const getLanguage = (langCode: Language): LanguageListItem => {
             let newOption = <LanguageListItem>{
-                id: langId,
-                text: getAdjectiveName(PowerduckState.getResourceValue("language" + langId as any)),
-                value: langId.toString(),
+                id: langCode,
+                text: getAdjectiveName(LanguageTranslator.getString(langCode)),
+                value: langCode.toString(),
                 flag: null,
             };
 
-            switch (langId) {
-                case 0:
+            switch (langCode) {
+                case 'sk':
                     newOption.flag = "svk";
                     break;
-                case 1:
+                case 'en':
                     newOption.flag = "gbr";
                     break;
-                case 2:
+                case 'cs':
                     newOption.flag = "cze";
                     break;
-                case 3:
+                case 'de':
                     newOption.flag = "ger";
                     break;
-                case 4:
-                    newOption.flag = "lat";
-                    break;
-                case 5:
+                case 'pl':
                     newOption.flag = "pol";
                     break;
-                case 6:
+                case 'it':
                     newOption.flag = "ita";
                     break;
-                case 7:
+                case 'hu':
                     newOption.flag = "hun";
                     break;
                 default:
@@ -65,9 +63,9 @@ export namespace LanguageUtils {
             return newOption;
         };
 
-        for (let i = 0; i <= 7; i++) {
-            if (supportedLanguages.indexOf(i) > -1) {
-                retVal.push(getLanguage(i));
+        for (const langCode of [Language.sk, Language.en, Language.cs, Language, Language.pl, Language.it, Language.hu]) {
+            if (supportedLanguages.includes(langCode as any)) {
+                retVal.push(getLanguage(langCode as any));
             }
         }
 
@@ -84,97 +82,14 @@ export namespace LanguageUtils {
         };
         return retVal;
     }
-    export function getLanguageCode(langEnum: Language): string {
-        switch (langEnum) {
-            case Language.Slovak:
-                return "sk";
-            case Language.English:
-                return "en";
-            case Language.Czech:
-                return "cs";
-            case Language.German:
-                return "de";
-            case Language.Latvian:
-                return "lv";
-            case Language.Polish:
-                return "pl";
-            case Language.Italian:
-                return "it";
-            case Language.Hungarian:
-                return "hu";
-            default:
-                return null;
-        }
-    }
-    export function getLocalizedStringProperty(langEnum: Language): string {
-        switch (langEnum) {
-            case Language.Slovak:
-                return "Slovak";
-            case Language.English:
-                return "English";
-            case Language.Czech:
-                return "Czech";
-            case Language.German:
-                return "German";
-            case Language.Latvian:
-                return "Latvian";
-            case Language.Polish:
-                return "Polish";
-            case Language.Italian:
-                return "Italian";
-            case Language.Hungarian:
-                return "Hungarian";
-            default:
-                return null;
-        }
-    }
-
-    export function getLocalizedStringLanguageByPropertyName(propName: string): Language {
-        switch (propName) {
-            case "Slovak":
-                return Language.Slovak;
-            case "Czech":
-                return Language.Czech;
-            case "English":
-                return Language.English;
-            case "German":
-                return Language.German;
-            case "Latvian":
-                return Language.Latvian;
-            case "Polish":
-                return Language.Polish;
-            case "Italian":
-                return Language.Italian;
-            case "Hungarian":
-                return Language.Hungarian;
-            default:
-                return null;
-        }
-    }
 
     /**
      * Returns enum value from string language code
      *
      * @param langCode 2-letter language code [sk, en, cs...]
      */
-    export function getLanguageEnum(langCode: string): number {
-        if (langCode == "sk") {
-            return Language.Slovak;
-        } else if (langCode == "cs") {
-            return Language.Czech;
-        } else if (langCode == "de") {
-            return Language.German;
-        } else if (langCode == "pl") {
-            return Language.Polish;
-        } else if (langCode == "lv") {
-            return Language.Latvian;
-        } else if (langCode == "it") {
-            return Language.Italian;
-        } else if (langCode == "hu") {
-            return Language.Hungarian;
-        } else {
-            return Language.English; //Default EN
-        }
+    export function getLanguageEnum(langCode: string): Language {
+        return (langCode as any) ?? Language.en;
     }
 
     export function getLanguageFlagUrl(languageFlag: string, svg?: boolean): string {
@@ -185,7 +100,7 @@ export namespace LanguageUtils {
         }
     }
 
-    export function floatToCurrency(value: number, currency: string | CURRENCY_CODE | number | any, killZeroCents?: boolean): string {
+    export function floatToCurrency(value: number, currency: string | Currency | number | any, killZeroCents?: boolean): string {
         var currencyISO: string;
         if (currency == null || currency == "") {
             currencyISO = "?";
@@ -195,7 +110,7 @@ export namespace LanguageUtils {
 
         if (killZeroCents) {
             try {
-                return (Math.round(value * 100) / 100).toLocaleString(PowerduckState.getCurrentLanguageCode(), {
+                return (Math.round(value * 100) / 100).toLocaleString(PowerduckState.getCurrentLanguage(), {
                     style: "currency",
                     currency: currencyISO,
                 }).split('PLN').join('zł').split('CZK').join('kč').replace(' ,00', '').replace(' .00', '').replace(',00', '').replace('.00', '');
@@ -204,7 +119,7 @@ export namespace LanguageUtils {
             }
         } else {
             try {
-                return (Math.round(value * 100) / 100).toLocaleString(PowerduckState.getCurrentLanguageCode(), {
+                return (Math.round(value * 100) / 100).toLocaleString(PowerduckState.getCurrentLanguage(), {
                     style: "currency",
                     currency: currencyISO,
                 }).split('PLN').join('zł').split('CZK').join('kč');

package/common/utils/localized-string.ts

@@ -24,61 +24,49 @@ export default class LocalizedStringHelper {
             return null;
         }
 
-        var langEnum: Language;
-        if (typeof lang === "string" || <any>lang instanceof String) {
-            langEnum = LanguageUtils.getLanguageEnum(<string>lang);
-        } else {
-            langEnum = lang;
-        }
-
-        if (langEnum == Language.Slovak) {
-            const skVal = getValueForPair(value, 'sk', Language.Slovak);
+        if (lang == Language.sk) {
+            const skVal = getValueForPair(value, 'sk', Language.sk);
             if (!isNullOrEmpty(skVal)) {
                 return skVal;
             }
 
-            const csVal = getValueForPair(value, 'cs', Language.Czech);
+            const csVal = getValueForPair(value, 'cs', Language.cs);
             if (!isNullOrEmpty(csVal)) {
                 return csVal;
             }
-        } else if (langEnum == Language.Czech) {
-            const csVal = getValueForPair(value, 'cs', Language.Czech);
+        } else if (lang == Language.cs) {
+            const csVal = getValueForPair(value, 'cs', Language.cs);
             if (!isNullOrEmpty(csVal)) {
                 return csVal;
             }
 
-            const skVal = getValueForPair(value, 'sk', Language.Slovak);
+            const skVal = getValueForPair(value, 'sk', Language.sk);
             if (!isNullOrEmpty(skVal)) {
                 return skVal;
             }
-        } else if (langEnum == Language.German) {
-            const val = getValueForPair(value, 'de', Language.German);
-            if (!isNullOrEmpty(val)) {
-                return val;
-            }
-        } else if (langEnum == Language.Latvian) {
-            const val = getValueForPair(value, 'lv', Language.Latvian);
+        } else if (lang == Language.de) {
+            const val = getValueForPair(value, 'de', Language.de);
             if (!isNullOrEmpty(val)) {
                 return val;
             }
-        } else if (langEnum == Language.Polish) {
-            const val = getValueForPair(value, 'pl', Language.Polish);
+        } else if (lang == Language.pl) {
+            const val = getValueForPair(value, 'pl', Language.pl);
             if (!isNullOrEmpty(val)) {
                 return val;
             }
-        } else if (langEnum == Language.Italian) {
-            const val = getValueForPair(value, 'it', Language.Italian);
+        } else if (lang == Language.it) {
+            const val = getValueForPair(value, 'it', Language.it);
             if (!isNullOrEmpty(val)) {
                 return val;
             }
-        } else if (langEnum == Language.Hungarian) {
-            const val = getValueForPair(value, 'hu', Language.Hungarian);
+        } else if (lang == Language.hu) {
+            const val = getValueForPair(value, 'hu', Language.hu);
             if (!isNullOrEmpty(val)) {
                 return val;
             }
         }
 
-        const lastTry = getValueForPair(value, 'sk', Language.Slovak);
+        const lastTry = getValueForPair(value, 'sk', Language.sk);
         if (!isNullOrEmpty(lastTry)) {
             return lastTry;
         }

package/common/utils/localized-text-util.ts

@@ -1,8 +1,8 @@
 import LocalizedText from './../localized-text';
-import { LANGUAGE } from './../enums/language';
+import { Language } from './../enums/language';
 
 export default class LocalizedTextUtil {
-    static getLocalizedTextValue(value: LocalizedText, langKey: string | LANGUAGE): string {
+    static getLocalizedTextValue(value: LocalizedText, langKey: string | Language): string {
         if (value == null) {
             return null as any;
         }

package/common/utils/upload-image-helper.ts

@@ -24,7 +24,7 @@ export class UploadImageHelper {
             body: formData,
             headers: {
                 Authorization: "Bearer " + AppHttpProvider.bearerToken,
-                "Accept-Language": PowerduckState.getCurrentLanguageCode(),
+                "Accept-Language": PowerduckState.getCurrentLanguage(),
             },
         });
 

package/common/validation.ts

@@ -158,7 +158,7 @@ export class ValidationBuilder {
 
     requiredLocalizedString(): ValidationBuilder {
         this._validationArgs.requiredLocalizedString = (value) => {
-            if (value == null || isNullOrEmpty(LocalizedStringHelper.getValue(value, 0))) {
+            if (value == null || isNullOrEmpty(LocalizedStringHelper.getValue(value, 'sk'))) {
                 return false;
             }