@plentymarkets/shop-core 1.14.2 → 1.14.3

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@plentymarkets/shop-core",
   "configKey": "shopCore",
-  "version": "1.14.2",
+  "version": "1.14.3",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,8 +1,8 @@
 import { defineNuxtModule, createResolver, addImports } from '@nuxt/kit';
 import { ofetch } from 'ofetch';
-import { mkdir, writeFile } from 'fs/promises';
+import { access, mkdir, writeFile } from 'fs/promises';
 import { join } from 'path';
-import { existsSync } from 'fs';
+import { constants } from 'fs';
 
 const fetchAllTranslations = async (url, configId) => {
   return await ofetch(
@@ -35,7 +35,9 @@ const module$1 = defineNuxtModule({
     };
     const overridesDir = resolver.resolve("./runtime/lang/overrides");
     const allLocalesForOverride = [];
-    if (!existsSync(overridesDir)) {
+    try {
+      await access(overridesDir, constants.F_OK);
+    } catch {
       await mkdir(overridesDir, { recursive: true });
     }
     if (_options.apiEndpoint && _options.configId) {
@@ -51,7 +53,9 @@ const module$1 = defineNuxtModule({
       }
     }
     nuxt.hook("i18n:registerModule", (register) => {
-      console.log(`[shop-core] Hook(i18n:registerModule) Registering language overrides for locales: "${allLocalesForOverride.join(", ")}"`);
+      console.log(
+        `[shop-core] Hook(i18n:registerModule) Registering language overrides for locales: "${allLocalesForOverride.join(", ")}"`
+      );
       if (allLocalesForOverride.length > 0) {
         register({
           langDir: resolver.resolve("./runtime/lang/overrides"),

package/dist/runtime/composables/localization/helpers/loadKeysHelper.js

@@ -1,41 +1,69 @@
 import { useRuntimeConfig } from "nuxt/app";
 import { useSdk } from "../../useSdk.js";
 import { flattenTranslations } from "./transformationHelper.js";
-import { createEmptyMessage } from "./messageHelper.js";
+import { createEmptyMessage, cloneEmptyMessage } from "./messageHelper.js";
 import { extractKeysWithValues } from "./extractKeysWithValuesHelper.js";
+const processKeysForLocale = (keysWithValues, keysMap, locale, emptyMessageTemplate) => {
+  const keys = Object.keys(keysWithValues);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key.startsWith("translated.")) continue;
+    if (!keysMap.has(key)) keysMap.set(key, cloneEmptyMessage(emptyMessageTemplate));
+    const translations = keysMap.get(key);
+    translations[locale] = keysWithValues[key];
+  }
+};
+const processTranslatedKeysForLocale = (keysWithValues, keysMap, locale, emptyMessageTemplate) => {
+  const keys = Object.keys(keysWithValues);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (!keysMap.has(key)) keysMap.set(key, cloneEmptyMessage(emptyMessageTemplate));
+    const translations = keysMap.get(key);
+    if (translations[locale]) {
+      translations[locale].value = keysWithValues[key].value;
+      translations[locale].input = keysWithValues[key].input;
+    } else {
+      translations[locale] = keysWithValues[key];
+    }
+  }
+};
+const processBackendTranslations = (translations, keysMap, lang, emptyMessageTemplate) => {
+  const keys = Object.keys(translations);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const value = translations[key];
+    if (!keysMap.has(key)) keysMap.set(key, cloneEmptyMessage(emptyMessageTemplate));
+    const localeTranslations = keysMap.get(key);
+    if (localeTranslations[lang]) {
+      localeTranslations[lang].isDeployed = localeTranslations[lang].value === value;
+      localeTranslations[lang].value = value;
+      localeTranslations[lang].input = value;
+    } else {
+      localeTranslations[lang] = { value, input: value, isDeployed: false };
+    }
+  }
+};
 export const loadDefaultKeys = async (keysMap, $i18n) => {
-  for (const locale of $i18n.availableLocales) {
+  const locales = $i18n.availableLocales;
+  const emptyMessageTemplate = createEmptyMessage(locales);
+  for (let i = 0; i < locales.length; i++) {
+    const locale = locales[i];
     await $i18n.loadLocaleMessages(locale);
     const messages = $i18n.getLocaleMessage(locale);
     const keysWithValues = extractKeysWithValues(messages);
-    for (const [key, value] of Object.entries(keysWithValues)) {
-      if (key.startsWith("translated.")) continue;
-      if (!keysMap.has(key)) {
-        keysMap.set(key, createEmptyMessage($i18n.availableLocales));
-      }
-      const translations = keysMap.get(key);
-      translations[locale] = value;
-    }
+    processKeysForLocale(keysWithValues, keysMap, locale, emptyMessageTemplate);
   }
 };
 export const loadTranslatedKeys = (keysMap, $i18n) => {
-  for (const locale of $i18n.availableLocales) {
+  const locales = $i18n.availableLocales;
+  const emptyMessageTemplate = createEmptyMessage(locales);
+  for (let i = 0; i < locales.length; i++) {
+    const locale = locales[i];
     const messages = $i18n.getLocaleMessage(locale);
     const translatedMessages = messages["translated"];
     if (!translatedMessages) continue;
     const keysWithValues = extractKeysWithValues(translatedMessages);
-    for (const [key, value] of Object.entries(keysWithValues)) {
-      if (!keysMap.has(key)) {
-        keysMap.set(key, createEmptyMessage($i18n.availableLocales));
-      }
-      const translations = keysMap.get(key);
-      if (translations[locale]) {
-        translations[locale].value = value.value;
-        translations[locale].input = value.input;
-      } else {
-        translations[locale] = value;
-      }
-    }
+    processTranslatedKeysForLocale(keysWithValues, keysMap, locale, emptyMessageTemplate);
   }
 };
 export const loadKeysFromBackend = async (keysMap, $i18n, backendLanguages) => {
@@ -45,25 +73,13 @@ export const loadKeysFromBackend = async (keysMap, $i18n, backendLanguages) => {
     if (!configId) return;
     const { data } = await useSdk().plentysystems.getAllTranslations({ configId });
     const flattened = flattenTranslations(data);
-    for (const [lang, translations] of Object.entries(flattened)) {
+    const emptyMessageTemplate = createEmptyMessage($i18n.availableLocales);
+    const langs = Object.keys(flattened);
+    for (let i = 0; i < langs.length; i++) {
+      const lang = langs[i];
+      const translations = flattened[lang];
       if (backendLanguages && Object.keys(translations).length > 0) backendLanguages.add(lang);
-      for (const [key, value] of Object.entries(translations)) {
-        if (!keysMap.has(key)) {
-          keysMap.set(key, createEmptyMessage($i18n.availableLocales));
-        }
-        const localeTranslations = keysMap.get(key);
-        if (localeTranslations[lang]) {
-          localeTranslations[lang].isDeployed = localeTranslations[lang].value === value;
-          localeTranslations[lang].value = value;
-          localeTranslations[lang].input = value;
-        } else {
-          localeTranslations[lang] = {
-            value,
-            input: value,
-            isDeployed: false
-          };
-        }
-      }
+      processBackendTranslations(translations, keysMap, lang, emptyMessageTemplate);
     }
   } catch {
   }

package/dist/runtime/composables/localization/helpers/messageHelper.d.ts

@@ -8,4 +8,14 @@ export declare const isCompiledMessage: (value: unknown) => boolean;
  * Create an empty message object for all locales
  * @param availableLocales
  */
-export declare const createEmptyMessage: (availableLocales: string[]) => {};
+export declare const createEmptyMessage: (availableLocales: string[]) => Record<string, {
+    value: string;
+    input: string;
+    isDeployed: boolean;
+}>;
+/**
+ * Clone an empty message template with all locale properties
+ * More efficient than creating a new message for each key
+ * @param template - The template message object to clone
+ */
+export declare const cloneEmptyMessage: (template: Record<string, any>) => Record<string, any>;

package/dist/runtime/composables/localization/helpers/messageHelper.js

@@ -2,16 +2,25 @@ export const isCompiledMessage = (value) => {
   return typeof value === "object" && value !== null && ("loc" in value && typeof value.loc === "object" && value.loc !== null && "source" in value.loc && typeof value.loc.source === "string" || "b" in value && typeof value.b === "object" && value.b !== null && "s" in value.b && typeof value.b.s === "string");
 };
 export const createEmptyMessage = (availableLocales) => {
-  let data = {};
+  const data = {};
   for (const locale of availableLocales) {
-    data = {
-      ...data,
-      [locale]: {
-        value: "",
-        input: "",
-        isDeployed: true
-      }
-    };
+    data[locale] = { value: "", input: "", isDeployed: true };
   }
   return data;
 };
+export const cloneEmptyMessage = (template) => {
+  const clone = {};
+  const locales = Object.keys(template);
+  const length = locales.length;
+  for (let i = 0; i < length; i++) {
+    const locale = locales[i];
+    const source = template[locale];
+    clone[locale] = {
+      value: source.value,
+      input: source.input,
+      isDeployed: source.isDeployed,
+      ...source.default !== void 0 && { default: source.default }
+    };
+  }
+  return clone;
+};

package/dist/runtime/composables/localization/helpers/transformationHelper.d.ts

@@ -1,4 +1,4 @@
-import type { TranslationObject } from "@plentymarkets/shop-api";
+import type { TranslationObject } from '@plentymarkets/shop-api';
 /**
  * Flatten nested translation objects into dot notation
  * e.g. { module: { key: 'value' } } => { 'module.key': 'value' }

package/dist/runtime/composables/localization/helpers/transformationHelper.js

@@ -17,18 +17,24 @@ export const flattenTranslations = (data) => {
   }
   return result;
 };
+const navigateAndCreatePath = (root, parts) => {
+  let current = root;
+  const lastIndex = parts.length - 1;
+  for (let i = 0; i < lastIndex; i++) {
+    const part = parts[i];
+    if (!current[part]) current[part] = {};
+    current = current[part];
+  }
+  return current;
+};
 export const unflattenTranslations = (flat) => {
   const result = {};
-  for (const [key, value] of Object.entries(flat)) {
+  const entries = Object.entries(flat);
+  for (let i = 0; i < entries.length; i++) {
+    const [key, value] = entries[i];
     const parts = key.split(".");
-    let current = result;
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i];
-      if (!current[part]) current[part] = {};
-      current = current[part];
-    }
-    const lastPart = parts[parts.length - 1];
-    current[lastPart] = value;
+    const target = navigateAndCreatePath(result, parts);
+    target[parts[parts.length - 1]] = value;
   }
   return result;
 };

package/dist/runtime/composables/localization/useEditorLocalizationKeys.d.ts

@@ -4,7 +4,7 @@ export declare const useEditorLocalizationKeys: () => {
     checkHasUnsavedChanges: () => boolean;
     collectChangedTranslations: () => Record<string, Record<string, string>>;
     loadKeys: () => Promise<void>;
-    filterKeys: (searchTerm: string, activeLocales: string[]) => void;
+    filterKeys: (searchTerm: string, activeLocales: string[], showOnlyMissing?: boolean) => void;
     getTranslatedCount: (locale: string) => {
         translated: number;
         undeployed: number;
@@ -14,6 +14,7 @@ export declare const useEditorLocalizationKeys: () => {
     getKeyFromFullKey: (key: string) => string;
     saveLocalizations: () => Promise<void>;
     keys: import("vue").Ref<MultilingualKeysState[], MultilingualKeysState[]>;
+    keysMap: import("vue").Ref<Map<string, MultilingualKeysState>, Map<string, MultilingualKeysState>>;
     filteredKeys: import("vue").Ref<MultilingualKeysState[] | null, MultilingualKeysState[] | null>;
     drawerOpen: import("vue").Ref<boolean, boolean>;
     hasChanges: import("vue").Ref<boolean, boolean>;

package/dist/runtime/composables/localization/useEditorLocalizationKeys.js

@@ -4,9 +4,114 @@ import { loadDefaultKeys, loadTranslatedKeys, loadKeysFromBackend } from "./help
 import { useSdk, useNotification, useEditorLocalizationLocales } from "#imports";
 import { allLanguages } from "./useEditorLocalizationLocales.js";
 import { unflattenTranslations } from "./helpers/transformationHelper.js";
+const containsSearchTerm = (text, searchQuery) => {
+  return text.toLowerCase().indexOf(searchQuery) !== -1;
+};
+const hasMatchingTranslation = (translations, searchQuery, activeLocalesSet) => {
+  for (const locale of activeLocalesSet) {
+    const translation = translations[locale];
+    if (translation && containsSearchTerm(translation.input, searchQuery)) {
+      return true;
+    }
+  }
+  return false;
+};
+const matchesSearchQuery = (keyEntry, searchQuery, activeLocalesSet) => {
+  if (containsSearchTerm(keyEntry.key, searchQuery)) return true;
+  return hasMatchingTranslation(keyEntry.translations, searchQuery, activeLocalesSet);
+};
+const hasMissingTranslations = (keyEntry, activeLocalesSet) => {
+  for (const locale of activeLocalesSet) {
+    const translation = keyEntry.translations[locale];
+    if (!translation || !translation.value || translation.value.trim().length === 0) return true;
+  }
+  return false;
+};
+const processKeyChanges = (keyState, selectedLocalesSet, translationsByLocale) => {
+  for (const locale in keyState.translations) {
+    if (!selectedLocalesSet.has(locale)) continue;
+    const translation = keyState.translations[locale];
+    if (translation && translation.input !== translation.value) {
+      if (!translationsByLocale[locale]) translationsByLocale[locale] = {};
+      translationsByLocale[locale][keyState.key] = translation.input;
+    }
+  }
+};
+const keyHasUnsavedChanges = (keyState, selectedLocalesSet) => {
+  for (const locale in keyState.translations) {
+    if (!selectedLocalesSet.has(locale)) continue;
+    const translation = keyState.translations[locale];
+    if (translation && translation.input !== translation.value) return true;
+  }
+  return false;
+};
+const collectChanges = (keys, selectedLocalesSet) => {
+  const translationsByLocale = {};
+  for (let i = 0; i < keys.length; i++) {
+    processKeyChanges(keys[i], selectedLocalesSet, translationsByLocale);
+  }
+  return translationsByLocale;
+};
+const hasUnsavedChanges = (keys, selectedLocalesSet) => {
+  for (let i = 0; i < keys.length; i++) {
+    if (keyHasUnsavedChanges(keys[i], selectedLocalesSet)) return true;
+  }
+  return false;
+};
+const saveLanguageTranslations = async (language, configId, translations, backendLanguages) => {
+  try {
+    const nestedTranslations = unflattenTranslations(translations);
+    const languageExistsInBackend = backendLanguages.has(language);
+    const sdk = useSdk().plentysystems;
+    const saveMethod = languageExistsInBackend ? sdk.patchMergeTranslations : sdk.doCreateTranslations;
+    await saveMethod({ configId, language, translations: nestedTranslations });
+    if (!languageExistsInBackend) backendLanguages.add(language);
+    return { language, success: true };
+  } catch (error) {
+    return { language, success: false, error };
+  }
+};
+const updateLocalStateAfterSave = (keys, language, savedTranslations) => {
+  for (let i = 0; i < keys.length; i++) {
+    const keyState = keys[i];
+    const translation = keyState.translations[language];
+    if (translation && savedTranslations[keyState.key] !== void 0) {
+      translation.isDeployed = true;
+      translation.value = translation.input;
+    }
+  }
+};
+const notifySaveResults = (results) => {
+  const { send } = useNotification();
+  const successful = [];
+  const failed = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const displayName = allLanguages[result.language] || result.language.toUpperCase();
+    if (result.success) {
+      successful.push(displayName);
+    } else {
+      failed.push(displayName);
+    }
+  }
+  if (successful.length > 0) {
+    send({
+      message: `Translations for ${successful.join(", ")} saved successfully`,
+      type: "positive"
+    });
+  }
+  if (failed.length > 0) {
+    send({
+      message: `Failed to save translations for ${failed.join(", ")}`,
+      type: "negative",
+      persist: true
+    });
+  }
+};
 export const useEditorLocalizationKeys = () => {
   const state = useState("useEditorLocalizationKeys", () => ({
     keys: [],
+    keysMap: /* @__PURE__ */ new Map(),
     filteredKeys: null,
     drawerOpen: false,
     hasChanges: false,
@@ -27,36 +132,40 @@ export const useEditorLocalizationKeys = () => {
       key,
       translations
     })).sort((a, b) => a.key.localeCompare(b.key));
+    state.value.keysMap.clear();
+    for (let i = 0; i < state.value.keys.length; i++) {
+      const keyState = state.value.keys[i];
+      state.value.keysMap.set(keyState.key, keyState);
+    }
     state.value.loading = false;
     state.value.drawerOpen = true;
   };
-  const filterKeys = (searchTerm, activeLocales) => {
-    if (searchTerm.trim().length === 0) {
+  const filterKeys = (searchTerm, activeLocales, showOnlyMissing = false) => {
+    if (searchTerm.trim().length === 0 && !showOnlyMissing) {
       state.value.filteredKeys = null;
       return;
     }
     const searchQuery = searchTerm.trim().toLowerCase();
-    state.value.filteredKeys = state.value.keys.filter((keyEntry) => {
-      if (keyEntry.key.toLowerCase().includes(searchQuery)) {
-        return true;
-      }
-      return activeLocales.some((locale) => {
-        const translation = keyEntry.translations[locale];
-        if (!translation) return false;
-        return translation.input.toLowerCase().includes(searchQuery);
-      });
-    });
+    const activeLocalesSet = new Set(activeLocales);
+    const filtered = [];
+    const hasSearchTerm = searchQuery.length > 0;
+    for (let i = 0; i < state.value.keys.length; i++) {
+      const keyEntry = state.value.keys[i];
+      const matchesSearch = !hasSearchTerm || matchesSearchQuery(keyEntry, searchQuery, activeLocalesSet);
+      const matchesMissing = !showOnlyMissing || hasMissingTranslations(keyEntry, activeLocalesSet);
+      if (matchesSearch && matchesMissing) filtered.push(keyEntry);
+    }
+    state.value.filteredKeys = filtered;
   };
   const getTranslatedCount = (locale) => {
     let translatedCount = 0;
     let undeployedCount = 0;
-    let totalCount = state.value.keys.length;
-    for (const keyState of state.value.keys) {
-      if (keyState.translations[locale] && keyState.translations[locale].value.length > 0) {
+    const totalCount = state.value.keys.length;
+    for (let i = 0; i < totalCount; i++) {
+      const translation = state.value.keys[i].translations[locale];
+      if (translation && translation.value.length > 0) {
         translatedCount++;
-        if (!keyState.translations[locale].isDeployed) {
-          undeployedCount++;
-        }
+        if (!translation.isDeployed) undeployedCount++;
       }
     }
     return {
@@ -77,38 +186,17 @@ export const useEditorLocalizationKeys = () => {
   const collectChangedTranslations = () => {
     const { selectedLocales } = useEditorLocalizationLocales();
     if (!selectedLocales.value || selectedLocales.value.length === 0) return {};
-    const translationsByLocale = {};
     const selectedLocalesSet = new Set(selectedLocales.value);
-    for (let i = 0; i < state.value.keys.length; i++) {
-      const keyState = state.value.keys[i];
-      for (const locale in keyState.translations) {
-        if (!selectedLocalesSet.has(locale)) continue;
-        const translation = keyState.translations[locale];
-        if (translation && translation.input !== translation.value) {
-          if (!translationsByLocale[locale]) translationsByLocale[locale] = {};
-          translationsByLocale[locale][keyState.key] = translation.input;
-        }
-      }
-    }
-    return translationsByLocale;
+    return collectChanges(state.value.keys, selectedLocalesSet);
   };
   const checkHasUnsavedChanges = () => {
     const { selectedLocales } = useEditorLocalizationLocales();
     if (!selectedLocales.value || selectedLocales.value.length === 0) return false;
     const selectedLocalesSet = new Set(selectedLocales.value);
-    for (const keyState of state.value.keys) {
-      for (const locale in keyState.translations) {
-        if (!selectedLocalesSet.has(locale)) continue;
-        const translation = keyState.translations[locale];
-        if (translation && translation.input !== translation.value) {
-          return true;
-        }
-      }
-    }
-    return false;
+    return hasUnsavedChanges(state.value.keys, selectedLocalesSet);
   };
   const updateTranslationInput = (key, locale, newInput) => {
-    const keyState = state.value.keys.find((k) => k.key === key);
+    const keyState = state.value.keysMap.get(key);
     if (!keyState || !keyState.translations[locale]) return;
     const translation = keyState.translations[locale];
     translation.input = newInput;
@@ -118,47 +206,6 @@ export const useEditorLocalizationKeys = () => {
       state.value.hasChanges = checkHasUnsavedChanges();
     }
   };
-  const saveLanguageTranslations = async (language, configId, translations) => {
-    try {
-      const nestedTranslations = unflattenTranslations(translations);
-      const languageExistsInBackend = state.value.backendLanguages.has(language);
-      const sdk = useSdk().plentysystems;
-      const saveMethod = languageExistsInBackend ? sdk.patchMergeTranslations : sdk.doCreateTranslations;
-      await saveMethod({ configId, language, translations: nestedTranslations });
-      if (!languageExistsInBackend) state.value.backendLanguages.add(language);
-      return { language, success: true };
-    } catch (error) {
-      return { language, success: false, error };
-    }
-  };
-  const updateLocalStateAfterSave = (language, savedTranslations) => {
-    for (let i = 0; i < state.value.keys.length; i++) {
-      const keyState = state.value.keys[i];
-      const translation = keyState.translations[language];
-      if (translation && savedTranslations[keyState.key] !== void 0) {
-        translation.isDeployed = true;
-        translation.value = translation.input;
-      }
-    }
-  };
-  const notifySaveResults = (results) => {
-    const { send } = useNotification();
-    const successful = results.filter((r) => r.success).map((r) => allLanguages[r.language] || r.language.toUpperCase());
-    const failed = results.filter((r) => !r.success).map((r) => allLanguages[r.language] || r.language.toUpperCase());
-    if (successful.length > 0) {
-      send({
-        message: `Translations for ${successful.join(", ")} saved successfully`,
-        type: "positive"
-      });
-    }
-    if (failed.length > 0) {
-      send({
-        message: `Failed to save translations for ${failed.join(", ")}`,
-        type: "negative",
-        persist: true
-      });
-    }
-  };
   const saveLocalizations = async () => {
     const config = useRuntimeConfig().public.shopCore;
     const configId = config?.configId;
@@ -169,11 +216,12 @@ export const useEditorLocalizationKeys = () => {
     state.value.loading = true;
     try {
       const savePromises = localesToSave.map(
-        (language) => saveLanguageTranslations(language, configId, translationsByLocale[language])
+        (language) => saveLanguageTranslations(language, configId, translationsByLocale[language], state.value.backendLanguages)
       );
       const results = await Promise.all(savePromises);
       results.forEach((result) => {
-        if (result.success) updateLocalStateAfterSave(result.language, translationsByLocale[result.language]);
+        if (result.success)
+          updateLocalStateAfterSave(state.value.keys, result.language, translationsByLocale[result.language]);
       });
       notifySaveResults(results);
       state.value.hasChanges = false;

package/dist/runtime/composables/localization/useEditorLocalizationLocales.js

@@ -42,22 +42,25 @@ export const useEditorLocalizationLocales = () => {
     }
   };
   const removeLocale = (locale) => {
-    state.value.selectedLocales = state.value.selectedLocales.filter((l) => l !== locale);
+    const index = state.value.selectedLocales.indexOf(locale);
+    if (index > -1) state.value.selectedLocales.splice(index, 1);
     saveLocales();
   };
   const toggleLocale = (locale) => {
-    if (state.value.selectedLocales.includes(locale)) {
-      removeLocale(locale);
-    } else {
-      selectLocale(locale);
-    }
+    const index = state.value.selectedLocales.indexOf(locale);
+    index > -1 ? state.value.selectedLocales.splice(index, 1) : state.value.selectedLocales.push(locale);
     saveLocales();
   };
   const initializeLocales = () => {
     const selectedLocales = localStorage.getItem("editorLocalizationSelectedLocales");
     if (selectedLocales) {
       const parsedLocales = JSON.parse(selectedLocales);
-      state.value.selectedLocales = parsedLocales.filter((l) => allLanguages.hasOwnProperty(l));
+      const validLanguages = new Set(Object.keys(allLanguages));
+      const validLocales = [];
+      for (let i = 0; i < parsedLocales.length; i++) {
+        if (validLanguages.has(parsedLocales[i])) validLocales.push(parsedLocales[i]);
+      }
+      state.value.selectedLocales = validLocales;
     } else {
       state.value.selectedLocales = ["de", "en"];
     }

package/dist/runtime/composables/sdk.client.d.ts

@@ -1,2 +1,3 @@
 import type { AxiosRequestConfig } from 'axios';
+export declare const handleHttpError: (error: unknown) => never;
 export declare const httpClient: (url: string, params: unknown, config: AxiosRequestConfig<unknown> | undefined) => Promise<any>;

package/dist/runtime/composables/sdk.client.js

@@ -1,6 +1,6 @@
 import axios from "axios";
 import { ApiError } from "@plentymarkets/shop-api";
-const handleHttpError = (error) => {
+export const handleHttpError = (error) => {
   const axiosError = error;
   const data = axiosError?.response?.data?.data || axiosError?.response?.data;
   const events = axiosError?.response?.data?.events;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plentymarkets/shop-core",
-  "version": "1.14.2",
+  "version": "1.14.3",
   "description": "Core module for PlentyONE Shop",
   "repository": {
     "type": "git",
@@ -45,7 +45,7 @@
     "test:types": "vue-tsc --noEmit"
   },
   "dependencies": {
-    "@plentymarkets/shop-api": "^0.148.0",
+    "@plentymarkets/shop-api": "^0.148.1",
     "@vue-storefront/sdk": "^3.4.1",
     "cookie": "^1.0.2",
     "js-sha256": "^0.11.0",