@maz-ui/translations 4.5.0 → 4.7.0-beta.0

package/dist/chunks/locales.CxxxJnrt.js

@@ -0,0 +1,130 @@
+import { globalState, locale } from "../states.js";
+function getMessage(obj, path) {
+  return path.split(".").reduce((current, key) => current?.[key], obj);
+}
+function setMessage(obj, path, value) {
+  const keys = path.split("."), lastKey = keys.pop(), target = keys.reduce((current, key) => ((!current[key] || typeof current[key] != "object") && (current[key] = {}), current[key]), obj);
+  target[lastKey] = value;
+}
+function isFlattenedObject(obj) {
+  return !obj || typeof obj != "object" ? !1 : Object.keys(obj).some((key) => key.includes("."));
+}
+function flattenToNested(flatObj) {
+  if (!isFlattenedObject(flatObj))
+    return flatObj;
+  const nested = {};
+  for (const [key, value] of Object.entries(flatObj))
+    key.includes(".") ? setMessage(nested, key, value) : nested[key] = value;
+  return nested;
+}
+function mergeMessages(target, source) {
+  const normalizedSource = flattenToNested(source), result = { ...flattenToNested(target) };
+  for (const key in normalizedSource)
+    normalizedSource[key] && typeof normalizedSource[key] == "object" ? result[key] = mergeMessages(result[key] || {}, normalizedSource[key]) : result[key] = normalizedSource[key];
+  return result;
+}
+function interpolate(message, variables) {
+  return variables ? message.replace(/\{(\w+)\}/g, (match, key) => variables[key] !== void 0 ? String(variables[key]) : match) : message;
+}
+function t(key, variables, fallbackLocale) {
+  let message = getMessage(globalState.messages[locale.value], key);
+  if (!message && fallbackLocale && locale.value !== fallbackLocale && (globalState.loadedLocales.has(fallbackLocale) || loadLocale(fallbackLocale).catch((error) => console.error(`[@maz-ui/translations] Failed to load fallback locale: "${fallbackLocale}"`, error)), message = getMessage(globalState.messages[fallbackLocale], key)), !message && fallbackLocale !== "en" && locale.value !== "en") {
+    if (!globalState.loadedLocales.has("en"))
+      return loadLocale("en").catch((error) => console.error('[@maz-ui/translations] Failed to load en locale: "en"', error)), key;
+    message = getMessage(globalState.messages.en, key);
+  }
+  return message ? interpolate(String(message), variables) : (console.warn(`[@maz-ui/translations] Translation not found for key: "${key}"`), key);
+}
+const defaultLocalesLoaders = {
+  "./locales/en.ts": () => import("../locales/en.js").then((m) => ({ default: m.default })),
+  "./locales/de.ts": () => import("../locales/de.js").then((m) => ({ default: m.default })),
+  "./locales/es.ts": () => import("../locales/es.js").then((m) => ({ default: m.default })),
+  "./locales/fr.ts": () => import("../locales/fr.js").then((m) => ({ default: m.default })),
+  "./locales/it.ts": () => import("../locales/it.js").then((m) => ({ default: m.default })),
+  "./locales/ja.ts": () => import("../locales/ja.js").then((m) => ({ default: m.default })),
+  "./locales/pt.ts": () => import("../locales/pt.js").then((m) => ({ default: m.default })),
+  "./locales/zh-CN.ts": () => import("../locales/zh-CN.js").then((m) => ({ default: m.default }))
+}, defaultMessagesCache = /* @__PURE__ */ new Map();
+async function loadDefaultMessages(locale2) {
+  if (defaultMessagesCache.has(locale2))
+    return defaultMessagesCache.get(locale2);
+  const loaderPath = `./locales/${locale2}.ts`, loader = defaultLocalesLoaders[loaderPath];
+  if (!loader)
+    return {};
+  try {
+    const messages = (await loader()).default;
+    return defaultMessagesCache.set(locale2, messages), messages;
+  } catch (error) {
+    return console.error(`Failed to load default messages for locale "${locale2}":`, error), {};
+  }
+}
+function getAvailableLocales() {
+  const locales = /* @__PURE__ */ new Set();
+  for (const [path, loader] of Object.entries(defaultLocalesLoaders))
+    loader && typeof loader == "function" && locales.add(path.replace("./locales/", "").replace(".ts", ""));
+  for (const path of Object.keys(globalState.userMessages))
+    locales.add(path);
+  return Array.from(locales);
+}
+function loadLocale(targetLocale) {
+  if (globalState.loadedLocales.has(targetLocale))
+    return Promise.resolve();
+  if (globalState.loadingPromises.has(targetLocale))
+    return globalState.loadingPromises.get(targetLocale);
+  const loadingPromise = (async () => {
+    try {
+      const localeDefaultMessages = await loadDefaultMessages(targetLocale);
+      let localeUserMessages = {};
+      const userLoader = globalState.userMessages[targetLocale];
+      if (userLoader)
+        if (typeof userLoader == "function")
+          try {
+            const userMessages = await userLoader();
+            localeUserMessages = "default" in userMessages ? userMessages.default : userMessages;
+          } catch (error) {
+            console.error(`Failed to load user translations for locale "${targetLocale}":`, error), localeUserMessages = {};
+          }
+        else
+          localeUserMessages = userLoader;
+      globalState.messages[targetLocale] = mergeMessages(localeDefaultMessages, localeUserMessages), globalState.loadedLocales.add(targetLocale);
+    } catch (error) {
+      console.error(`Failed to load translations for locale "${targetLocale}":`, error), globalState.messages[targetLocale] = {}, globalState.loadedLocales.add(targetLocale);
+    } finally {
+      globalState.loadingPromises.delete(targetLocale);
+    }
+  })();
+  return globalState.loadingPromises.set(targetLocale, loadingPromise), loadingPromise;
+}
+function getMessages() {
+  return globalState.messages;
+}
+function isLocaleLoaded(localeToCheck) {
+  return globalState.loadedLocales.has(localeToCheck);
+}
+function isLocaleLoading(localeToCheck) {
+  return globalState.loadingPromises.has(localeToCheck);
+}
+function setLocaleMessage(targetLocale, messages) {
+  globalState.messages[targetLocale] || (globalState.messages[targetLocale] = {}), globalState.messages[targetLocale] = mergeMessages(globalState.messages[targetLocale], messages), globalState.loadedLocales.add(targetLocale);
+}
+async function setLocale(newLocale) {
+  globalState.loadedLocales.has(newLocale) || await loadLocale(newLocale), locale.value = newLocale;
+}
+function getLoadedLocales() {
+  return Object.keys(globalState.messages);
+}
+export {
+  loadLocale as a,
+  getMessages as b,
+  isLocaleLoading as c,
+  setLocale as d,
+  getLoadedLocales as e,
+  getMessage as f,
+  getAvailableLocales as g,
+  interpolate as h,
+  isLocaleLoaded as i,
+  loadDefaultMessages as l,
+  mergeMessages as m,
+  setLocaleMessage as s,
+  t
+};

package/dist/composables/index.js

@@ -0,0 +1,5 @@
+import "vue";
+import { useTranslations } from "./useTranslations.js";
+export {
+  useTranslations
+};

package/dist/composables/useTranslations.d.ts

@@ -0,0 +1,2 @@
+import { MazUiTranslationsInstance } from '../types';
+export declare function useTranslations(): MazUiTranslationsInstance;

package/dist/composables/useTranslations.js

@@ -0,0 +1,13 @@
+import { inject, getCurrentInstance } from "vue";
+function useTranslations() {
+  const injected = inject("mazTranslations", void 0);
+  if (injected)
+    return injected;
+  const instance = getCurrentInstance();
+  if (instance?.appContext?.app?.config?.globalProperties?.$mazTranslations)
+    return instance.appContext.app.config.globalProperties.$mazTranslations;
+  throw new Error("[@maz-ui/translations] You must install the MazUi or MazUiTranslations plugin, or wrap your components in a MazUiProvider, before using useTranslations composable");
+}
+export {
+  useTranslations
+};