@plentymarkets/shop-core 1.13.4 → 1.13.5

package/dist/module.d.mts

@@ -1,8 +1,11 @@
 import * as _nuxt_schema from '@nuxt/schema';
-export { Cookie, CookieGroup, CookieGroupFromNuxtConfig, Events, JsonCookie, Notification, PaymentButtonComponent, PaymentButtonComponentProps } from '../dist/runtime/types/index.js';
+export { Cookie, CookieGroup, CookieGroupFromNuxtConfig, Events, JsonCookie, LocalizationMessage, Notification, PaymentButtonComponent, PaymentButtonComponentProps } from '../dist/runtime/types/index.js';
 
 interface ModuleOptions {
     apiUrl: string;
+    apiEndpoint: string;
+    configId: number;
+    securityToken: string;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/module.json

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

package/dist/module.mjs

@@ -1,15 +1,63 @@
 import { defineNuxtModule, createResolver, addImports } from '@nuxt/kit';
+import { ofetch } from 'ofetch';
+import { writeFile } from 'fs/promises';
+import { join } from 'path';
 
-const module = defineNuxtModule({
+const fetchAllTranslations = async (url, configId, securityToken) => {
+  return await ofetch(
+    `${url}/rest/storefront/translations/${configId}/complete`,
+    {
+      method: "GET",
+      headers: {
+        "X-Security-Token": securityToken,
+        "Content-Type": "application/json"
+      }
+    }
+  );
+};
+
+const module$1 = defineNuxtModule({
   meta: {
-    name: "shop-core",
+    name: "@plentymarkets/shop-core",
     configKey: "shopCore"
   },
-  // Default configuration options of the Nuxt module
   defaults: {},
-  async setup(_options, _nuxt) {
+  moduleDependencies: {
+    "@nuxtjs/i18n": {
+      version: ">=9.5.4"
+    }
+  },
+  async setup(_options, nuxt) {
     const resolver = createResolver(import.meta.url);
-    _nuxt.options.runtimeConfig.public.shopCore = _options;
+    nuxt.options.runtimeConfig.public.shopCore = {
+      apiUrl: _options.apiUrl,
+      configId: _options.configId
+    };
+    const overridesDir = resolver.resolve("./runtime/lang/overrides");
+    const allLocalesForOverride = [];
+    if (_options.apiEndpoint && _options.configId && _options.securityToken) {
+      try {
+        const { data } = await fetchAllTranslations(_options.apiEndpoint, _options.configId, _options.securityToken);
+        for (const key of Object.keys(data)) {
+          allLocalesForOverride.push(key);
+          await writeFile(join(overridesDir, `${key}.json`), JSON.stringify({ translated: data[key] }, null, 2));
+        }
+      } catch (error) {
+        console.warn("Failed to fetch translations: ", error);
+      }
+    }
+    nuxt.hook("i18n:registerModule", (register) => {
+      if (allLocalesForOverride.length > 0) {
+        register({
+          langDir: resolver.resolve("./runtime/lang/overrides"),
+          // @ts-ignore
+          locales: allLocalesForOverride.map((locale) => ({
+            code: locale,
+            file: `${locale}.json`
+          }))
+        });
+      }
+    });
     addImports({
       name: "useSdk",
       as: "useSdk",
@@ -55,7 +103,22 @@ const module = defineNuxtModule({
       as: "useCartStockReservation",
       from: resolver.resolve("./runtime/composables/useCartStockReservation")
     });
+    addImports({
+      name: "useEditorLocalizationKeys",
+      as: "useEditorLocalizationKeys",
+      from: resolver.resolve("./runtime/composables/localization/useEditorLocalizationKeys")
+    });
+    addImports({
+      name: "useEditorLocalizationLocales",
+      as: "useEditorLocalizationLocales",
+      from: resolver.resolve("./runtime/composables/localization/useEditorLocalizationLocales")
+    });
+    addImports({
+      name: "t",
+      as: "t",
+      from: resolver.resolve("./runtime/composables/useT")
+    });
   }
 });
 
-export { module as default };
+export { module$1 as default };

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

@@ -0,0 +1,21 @@
+import type { LocalizationMessage, I18nInstance } from '../../types/index.js';
+export declare const unflattenTranslations: (flat: Record<string, string>) => Record<string, any>;
+/**
+ * Load default keys from i18n messages (PWA)
+ * @param keysMap
+ * @param $i18n
+ */
+export declare const loadDefaultKeys: (keysMap: Map<string, Record<string, LocalizationMessage>>, $i18n: I18nInstance) => Promise<void>;
+/**
+ * Load translated keys from i18n messages (Module Overrides)
+ * @param keysMap
+ * @param $i18n
+ */
+export declare const loadTranslatedKeys: (keysMap: Map<string, Record<string, LocalizationMessage>>, $i18n: I18nInstance) => void;
+/**
+ * Load all translations from the backend
+ * @param keysMap
+ * @param $i18n
+ * @param backendLanguages
+ */
+export declare const loadKeysFromBackend: (keysMap: Map<string, Record<string, LocalizationMessage>>, $i18n: I18nInstance, backendLanguages?: Set<string>) => Promise<void>;

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

@@ -0,0 +1,157 @@
+import { useRuntimeConfig } from "nuxt/app";
+import { useSdk } from "#imports";
+function flattenTranslations(data) {
+  const result = {};
+  function flattenObject(obj, prefix = "") {
+    const flattened = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const newKey = prefix ? `${prefix}.${key}` : key;
+      if (typeof value === "string") {
+        flattened[newKey] = value;
+      } else {
+        Object.assign(flattened, flattenObject(value, newKey));
+      }
+    }
+    return flattened;
+  }
+  for (const [lang, modules] of Object.entries(data)) {
+    result[lang] = flattenObject(modules);
+  }
+  return result;
+}
+export const unflattenTranslations = (flat) => {
+  const result = {};
+  for (const [key, value] of Object.entries(flat)) {
+    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;
+  }
+  return result;
+};
+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");
+};
+const createEmptyMessage = (availableLocales) => {
+  let data = {};
+  for (const locale of availableLocales) {
+    data = {
+      ...data,
+      [locale]: {
+        value: "",
+        input: "",
+        isDeployed: true
+      }
+    };
+  }
+  return data;
+};
+const getTranslationValue = (value) => {
+  if (isCompiledMessage(value) && value) {
+    const data = value;
+    return data?.loc?.source ?? data?.b?.s ?? "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return null;
+};
+const isNestedObject = (value) => {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !isCompiledMessage(value);
+};
+const extractKeysWithValues = (obj, prefix = "") => {
+  const result = {};
+  for (const key in obj) {
+    let fullKey = prefix ? `${prefix}.${key}` : key;
+    if (fullKey.endsWith(".body.static")) {
+      continue;
+    }
+    if (fullKey.endsWith(".loc.source")) {
+      fullKey = fullKey.substring(0, fullKey.length - ".loc.source".length);
+    }
+    const value = obj[key];
+    if (isNestedObject(value)) {
+      Object.assign(result, extractKeysWithValues(value, fullKey));
+    } else {
+      const translationValue = getTranslationValue(value);
+      if (translationValue)
+        result[fullKey] = {
+          value: translationValue,
+          default: translationValue,
+          input: translationValue,
+          isDeployed: true
+        };
+    }
+  }
+  return result;
+};
+export const loadDefaultKeys = async (keysMap, $i18n) => {
+  for (const locale of $i18n.availableLocales) {
+    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;
+    }
+  }
+};
+export const loadTranslatedKeys = (keysMap, $i18n) => {
+  for (const locale of $i18n.availableLocales) {
+    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;
+      }
+    }
+  }
+};
+export const loadKeysFromBackend = async (keysMap, $i18n, backendLanguages) => {
+  try {
+    const config = useRuntimeConfig().public.shopCore;
+    const configId = config?.configId;
+    if (!configId) return;
+    const { data } = await useSdk().plentysystems.getAllTranslations({ configId });
+    const flattened = flattenTranslations(data);
+    for (const [lang, translations] of Object.entries(flattened)) {
+      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
+          };
+        }
+      }
+    }
+  } catch {
+  }
+};

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

@@ -0,0 +1,20 @@
+import type { MultilingualKeysState } from '../../types/index.js';
+export declare const useEditorLocalizationKeys: () => {
+    updateTranslationInput: (key: string, locale: string, newInput: string) => void;
+    checkHasUnsavedChanges: () => boolean;
+    collectChangedTranslations: () => Record<string, Record<string, string>>;
+    loadKeys: () => Promise<void>;
+    getTranslatedCount: (locale: string) => {
+        translated: number;
+        undeployed: number;
+        total: number;
+    };
+    getCategoryFromKey: (key: string) => string;
+    getKeyFromFullKey: (key: string) => string;
+    saveLocalizations: () => Promise<void>;
+    keys: import("vue").Ref<MultilingualKeysState[], MultilingualKeysState[]>;
+    drawerOpen: import("vue").Ref<boolean, boolean>;
+    hasChanges: import("vue").Ref<boolean, boolean>;
+    backendLanguages: import("vue").Ref<Set<string>, Set<string>>;
+    loading: import("vue").Ref<boolean, boolean>;
+};

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

@@ -0,0 +1,176 @@
+import { useState, useNuxtApp, useRuntimeConfig } from "nuxt/app";
+import { toRefs } from "vue";
+import { loadDefaultKeys, loadTranslatedKeys, loadKeysFromBackend, unflattenTranslations } from "./helpers.js";
+import { useSdk, useNotification, useEditorLocalizationLocales } from "#imports";
+import { allLanguages } from "./useEditorLocalizationLocales.js";
+export const useEditorLocalizationKeys = () => {
+  const state = useState("useEditorLocalizationKeys", () => ({
+    keys: [],
+    drawerOpen: false,
+    hasChanges: false,
+    backendLanguages: /* @__PURE__ */ new Set(),
+    loading: false
+  }));
+  const loadKeys = async () => {
+    if (state.value.loading) return;
+    const $i18n = useNuxtApp().$i18n;
+    state.value.loading = true;
+    state.value.keys = [];
+    state.value.backendLanguages = /* @__PURE__ */ new Set();
+    const keysMap = /* @__PURE__ */ new Map();
+    await loadDefaultKeys(keysMap, $i18n);
+    loadTranslatedKeys(keysMap, $i18n);
+    await loadKeysFromBackend(keysMap, $i18n, state.value.backendLanguages);
+    state.value.keys = Array.from(keysMap.entries()).map(([key, translations]) => ({
+      key,
+      translations
+    })).sort((a, b) => a.key.localeCompare(b.key));
+    state.value.loading = false;
+    state.value.drawerOpen = true;
+  };
+  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) {
+        translatedCount++;
+        if (!keyState.translations[locale].isDeployed) {
+          undeployedCount++;
+        }
+      }
+    }
+    return {
+      translated: translatedCount,
+      undeployed: undeployedCount,
+      total: totalCount
+    };
+  };
+  const getCategoryFromKey = (key) => {
+    const parts = key.split(".");
+    const category = (parts.length > 1 ? parts[0] : "uncategorized") ?? "";
+    return category.replace(/([A-Z])/g, " $1").replace(/^./, (match) => match.toUpperCase()).trim();
+  };
+  const getKeyFromFullKey = (key) => {
+    const parts = key.split(".");
+    return parts.length > 1 ? parts.slice(1).join(".") : key;
+  };
+  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.input !== translation.value) {
+          if (!translationsByLocale[locale]) translationsByLocale[locale] = {};
+          translationsByLocale[locale][keyState.key] = translation.input;
+        }
+      }
+    }
+    return translationsByLocale;
+  };
+  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.input !== translation.value) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  const updateTranslationInput = (key, locale, newInput) => {
+    const keyState = state.value.keys.find((k) => k.key === key);
+    if (!keyState || !keyState.translations[locale]) return;
+    const translation = keyState.translations[locale];
+    translation.input = newInput;
+    if (newInput !== translation.value) {
+      state.value.hasChanges = true;
+    } else if (state.value.hasChanges) {
+      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;
+    if (!configId) return;
+    const translationsByLocale = collectChangedTranslations();
+    const localesToSave = Object.keys(translationsByLocale);
+    if (localesToSave.length === 0) return;
+    state.value.loading = true;
+    try {
+      const savePromises = localesToSave.map(
+        (language) => saveLanguageTranslations(language, configId, translationsByLocale[language])
+      );
+      const results = await Promise.all(savePromises);
+      results.forEach((result) => {
+        if (result.success) updateLocalStateAfterSave(result.language, translationsByLocale[result.language]);
+      });
+      notifySaveResults(results);
+      state.value.hasChanges = false;
+    } finally {
+      state.value.loading = false;
+    }
+  };
+  return {
+    ...toRefs(state.value),
+    updateTranslationInput,
+    checkHasUnsavedChanges,
+    collectChangedTranslations,
+    loadKeys,
+    getTranslatedCount,
+    getCategoryFromKey,
+    getKeyFromFullKey,
+    saveLocalizations
+  };
+};

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

@@ -0,0 +1,50 @@
+export declare const allLanguages: {
+    de: string;
+    en: string;
+    bg: string;
+    fr: string;
+    it: string;
+    es: string;
+    tr: string;
+    nl: string;
+    pl: string;
+    pt: string;
+    no: string;
+    ro: string;
+    da: string;
+    sv: string;
+    cs: string;
+    ru: string;
+    sk: string;
+    zh: string;
+    vi: string;
+};
+export declare const useEditorLocalizationLocales: () => {
+    allLanguages: {
+        de: string;
+        en: string;
+        bg: string;
+        fr: string;
+        it: string;
+        es: string;
+        tr: string;
+        nl: string;
+        pl: string;
+        pt: string;
+        no: string;
+        ro: string;
+        da: string;
+        sv: string;
+        cs: string;
+        ru: string;
+        sk: string;
+        zh: string;
+        vi: string;
+    };
+    selectLocale: (locale: string) => void;
+    removeLocale: (locale: string) => void;
+    toggleLocale: (locale: string) => void;
+    initializeLocales: () => void;
+    selectedLocales: import("vue").Ref<string[], string[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+};

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

@@ -0,0 +1,67 @@
+import { useState } from "#app";
+import { toRefs } from "vue";
+export const allLanguages = {
+  de: "German (default)",
+  en: "English (default)",
+  bg: "Bulgarian",
+  fr: "French",
+  it: "Italian",
+  es: "Spanish",
+  tr: "Turkish",
+  nl: "Dutch",
+  pl: "Polish",
+  pt: "Portuguese",
+  no: "Norwegian",
+  ro: "Romanian",
+  da: "Danish",
+  sv: "Swedish",
+  cs: "Czech",
+  ru: "Russian",
+  sk: "Slovak",
+  zh: "Chinese",
+  vi: "Vietnamese"
+};
+export const useEditorLocalizationLocales = () => {
+  const state = useState("useEditorLocalizationLocales", () => ({
+    selectedLocales: [],
+    loading: false
+  }));
+  const selectLocale = (locale) => {
+    if (!state.value.selectedLocales.includes(locale)) {
+      state.value.selectedLocales.push(locale);
+      saveLocales();
+    }
+  };
+  const removeLocale = (locale) => {
+    state.value.selectedLocales = state.value.selectedLocales.filter((l) => l !== locale);
+    saveLocales();
+  };
+  const toggleLocale = (locale) => {
+    if (state.value.selectedLocales.includes(locale)) {
+      removeLocale(locale);
+    } else {
+      selectLocale(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));
+    } else {
+      state.value.selectedLocales = ["de", "en"];
+    }
+  };
+  const saveLocales = () => {
+    localStorage.setItem("editorLocalizationSelectedLocales", JSON.stringify(state.value.selectedLocales));
+  };
+  return {
+    ...toRefs(state.value),
+    allLanguages,
+    selectLocale,
+    removeLocale,
+    toggleLocale,
+    initializeLocales
+  };
+};

package/dist/runtime/composables/useT.d.ts

@@ -0,0 +1 @@
+export declare const t: (key: string, listOrNamed?: Record<string, unknown>) => string;

package/dist/runtime/composables/useT.js

@@ -0,0 +1,9 @@
+import { useNuxtApp } from "nuxt/app";
+export const t = (key, listOrNamed) => {
+  const $i18n = useNuxtApp().$i18n;
+  const prefix = "translated.";
+  if ($i18n.te(prefix + key)) {
+    return $i18n.t(prefix + key, listOrNamed ?? {});
+  }
+  return $i18n.t(key, listOrNamed ?? {});
+};

package/dist/runtime/types/index.d.ts

@@ -2,3 +2,4 @@ export * from './cookies.js';
 export * from './events.js';
 export * from './render.js';
 export * from './notification.js';
+export * from './localization.js';

package/dist/runtime/types/index.js

@@ -2,3 +2,4 @@ export * from "./cookies.js";
 export * from "./events.js";
 export * from "./render.js";
 export * from "./notification.js";
+export * from "./localization.js";

package/dist/runtime/types/localization.d.ts

@@ -0,0 +1,42 @@
+export type MultilingualKeysState = {
+    key: string;
+    translations: {
+        [locale: string]: LocalizationMessage;
+    };
+};
+export type CompiledMessage = {
+    type?: number;
+    loc?: {
+        source: string;
+        start: {
+            line: number;
+            column: number;
+            offset: number;
+        };
+        end: {
+            line: number;
+            column: number;
+            offset: number;
+        };
+    };
+    b?: {
+        s: string;
+    };
+    start?: number;
+    end?: number;
+    body?: unknown;
+    items?: unknown[];
+};
+export type LocalizationMessage = {
+    value: string;
+    input: string;
+    default?: string;
+    isDeployed: boolean;
+};
+export interface I18nInstance {
+    availableLocales: string[];
+    loadLocaleMessages: (locale: string) => Promise<void>;
+    getLocaleMessage: (locale: string) => Record<string, unknown>;
+    te: (key: string) => boolean;
+    t: (key: string, params?: Record<string, unknown>) => string;
+}

package/dist/types.d.mts

@@ -1,4 +1,4 @@
-export { type Cookie, type CookieGroup, type CookieGroupFromNuxtConfig, type Events, type JsonCookie, type Notification, type PaymentButtonComponent, type PaymentButtonComponentProps } from '../dist/runtime/types/index.js'
+export { type Cookie, type CookieGroup, type CookieGroupFromNuxtConfig, type Events, type JsonCookie, type LocalizationMessage, type Notification, type PaymentButtonComponent, type PaymentButtonComponentProps } from '../dist/runtime/types/index.js'
 
 export { default } from './module.mjs'
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plentymarkets/shop-core",
-  "version": "1.13.4",
+  "version": "1.13.5",
   "description": "Core module for PlentyONE Shop",
   "repository": {
     "type": "git",
@@ -13,6 +13,10 @@
   },
   "license": "MIT",
   "type": "module",
+  "engines": {
+    "node": ">=20.0.0",
+    "npm": ">=10.0.0"
+  },
   "exports": {
     ".": {
       "require": "./dist/module.mjs",
@@ -38,20 +42,21 @@
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:watch": "vitest watch",
-    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+    "test:types": "vue-tsc --noEmit"
   },
   "dependencies": {
-    "@plentymarkets/shop-api": "^0.142.0",
+    "@plentymarkets/shop-api": "^0.143.0",
     "@vue-storefront/sdk": "^3.4.1",
     "cookie": "^1.0.2",
     "js-sha256": "^0.11.0",
-    "resolve": "^1.22.10"
+    "resolve": "^1.22.10",
+    "ofetch": "^1.5.1"
   },
   "overrides": {
     "prettier": "^3.6.2"
   },
   "devDependencies": {
-    "@nuxt/devtools": "^1.7.0",
+    "@nuxt/devtools": "^3.1.0",
     "@nuxt/eslint-config": "^0.7.6",
     "@nuxt/kit": "^4.1.3",
     "@nuxt/module-builder": "^1.0.2",
@@ -59,19 +64,21 @@
     "@nuxt/test-utils": "^3.19.0",
     "@nuxtjs/i18n": "9.5.4",
     "@types/node": "latest",
+    "@typescript-eslint/parser": "^8.47.0",
     "@vitest/coverage-v8": "^3.2.4",
-    "@vue-storefront/eslint-config": "^4.1.0",
     "@vue/test-utils": "^2.4.6",
     "changelogen": "^0.5.7",
     "eslint": "^9.24.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-vuejs-accessibility": "^2.4.1",
-    "happy-dom": "^16.8.1",
+    "happy-dom": "^20.0.2",
     "nuxi": "3.17.2",
     "nuxt": "^4.1.3",
     "prettier": "^3.6.2",
     "typescript": "~5.9.2",
+    "typescript-eslint": "^8.47.0",
     "vitest": "^3.2.4",
+    "vue-eslint-parser": "^10.2.0",
     "vue-tsc": "^2.2.8"
   }
 }