@localazy/strapi-plugin 1.0.4 → 1.0.9

package/dist/_chunks/{index-Bbwk3kp3.js → strapi-api-base-DjeKGUw7.mjs}

@@ -1,84 +1,4 @@
-"use strict";
-const React = require("react");
-const jsxRuntime = require("react/jsx-runtime");
-const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
-const React__default = /* @__PURE__ */ _interopDefault(React);
-const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
-  const v = glob[path];
-  if (v) {
-    return typeof v === "function" ? v() : Promise.resolve(v);
-  }
-  return new Promise((_, reject) => {
-    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
-      reject.bind(
-        null,
-        new Error(
-          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
-        )
-      )
-    );
-  });
-};
-const strapi = {
-  name: "localazy"
-};
-const pluginPkg = {
-  strapi
-};
-const PLUGIN_ID = pluginPkg.strapi.name;
-const getTranslation = (id) => `${PLUGIN_ID}.${id}`;
-const Initializer = ({ setPlugin }) => {
-  const ref = React.useRef(setPlugin);
-  React.useEffect(() => {
-    ref.current(PLUGIN_ID);
-  }, []);
-  return null;
-};
-const Localazy = () => {
-  return /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "24", height: "24", viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", fill: "#8e8ea9", children: [
-    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M16.4517 2.56643L16.3247 2.87501L15.5632 4.67576H7.49071C7.18595 4.67576 6.98278 4.98434 7.1013 5.26333L9.05259 9.91314C9.12031 10.0695 9.27269 10.171 9.442 10.171H12.6211C12.9216 10.171 13.1247 10.4753 13.0147 10.7501L12.8919 11.046L12.1353 12.8468H10.9192C10.6187 12.8468 10.4113 13.1553 10.5298 13.4343L13.8229 21.2925C13.9626 21.6265 13.7171 21.9942 13.353 21.9942H11.3256C11.1224 21.9942 10.9362 21.8716 10.8557 21.6814L3.1056 3.17091C2.8728 2.61293 3.27915 2 3.88443 2H16.0538C16.3501 2 16.5533 2.29167 16.4517 2.56643Z" }),
-    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M17.2937 13.5315L21.0354 4.63345C21.2724 4.07548 20.8619 3.45832 20.2566 3.46255L17.2267 3.46255L16.4794 5.23793C16.4794 5.24638 16.4752 5.25484 16.4709 5.26329L16.4709 5.26329L16.3482 5.55074C16.2297 5.82973 16.4371 6.1383 16.7376 6.1383H16.8069C17.1074 6.1383 17.3148 6.44688 17.1963 6.72587L15.2408 11.3757C15.1773 11.5321 15.0207 11.6335 14.8514 11.6335H13.7902L12.9112 13.7217C12.7927 14.0007 13.0001 14.3093 13.3006 14.3093H16.1212C16.6334 14.3093 17.0947 14.0007 17.2937 13.5315Z" })
-  ] });
-};
-const emptyIdentity = {
-  accessToken: "",
-  project: {
-    id: "",
-    image: "",
-    name: "",
-    url: ""
-  },
-  scope: "",
-  user: {
-    id: "",
-    name: ""
-  }
-};
-const LocalazyIdentityContextType = React.createContext(void 0);
-const LocalazyIdentityProvider = ({ children }) => {
-  const [identity, setIdentity] = React.useState(emptyIdentity);
-  const [isFetchingIdentity, setIsFetchingIdentity] = React.useState(true);
-  const isLoggedIn = React.useMemo(() => !!identity.accessToken, [identity.accessToken]);
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    LocalazyIdentityContextType.Provider,
-    {
-      value: { identity, setIdentity, isLoggedIn, isFetchingIdentity, setIsFetchingIdentity },
-      children
-    }
-  );
-};
-const useLocalazyIdentity = () => {
-  const context = React.useContext(LocalazyIdentityContextType);
-  if (context === void 0) {
-    throw new Error("useLocalazyIdentity must be used within a LocalazyIdentityProvider");
-  }
-  return context;
-};
-const localazyIdentity = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  LocalazyIdentityProvider,
-  useLocalazyIdentity
-}, Symbol.toStringTag, { value: "Module" }));
+import { P as PLUGIN_ID } from "./index-DsrYI6aB.mjs";
 function bind(fn, thisArg) {
   return function wrap() {
     return fn.apply(thisArg, arguments);
@@ -595,10 +515,10 @@ function toFormData$1(obj, formData, options) {
         value = JSON.stringify(value);
       } else if (utils$1.isArray(value) && isFlatArray(value) || (utils$1.isFileList(value) || utils$1.endsWith(key, "[]")) && (arr = utils$1.toArray(value))) {
         key = removeBrackets(key);
-        arr.forEach(function each(el, index2) {
+        arr.forEach(function each(el, index) {
           !(utils$1.isUndefined(el) || el === null) && formData.append(
             // eslint-disable-next-line no-nested-ternary
-            indexes === true ? renderKey([key], index2, dots) : indexes === null ? key : key + "[]",
+            indexes === true ? renderKey([key], index, dots) : indexes === null ? key : key + "[]",
             convertValue(el)
           );
         });
@@ -829,11 +749,11 @@ function arrayToObject(arr) {
   return obj;
 }
 function formDataToJSON(formData) {
-  function buildPath(path, value, target, index2) {
-    let name = path[index2++];
+  function buildPath(path, value, target, index) {
+    let name = path[index++];
     if (name === "__proto__") return true;
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index2 >= path.length;
+    const isLast = index >= path.length;
     name = !name && utils$1.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils$1.hasOwnProp(target, name)) {
@@ -846,7 +766,7 @@ function formDataToJSON(formData) {
     if (!target[name] || !utils$1.isObject(target[name])) {
       target[name] = [];
     }
-    const result = buildPath(path, value, target[name], index2);
+    const result = buildPath(path, value, target[name], index);
     if (result && utils$1.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
     }
@@ -2307,9 +2227,9 @@ let CancelToken$1 = class CancelToken {
     if (!this._listeners) {
       return;
     }
-    const index2 = this._listeners.indexOf(listener);
-    if (index2 !== -1) {
-      this._listeners.splice(index2, 1);
+    const index = this._listeners.indexOf(listener);
+    if (index !== -1) {
+      this._listeners.splice(index, 1);
     }
   }
   toAbortSignal() {
@@ -2465,10 +2385,10 @@ const JWT_TOKEN_NAME = "jwtToken";
 const getToken = () => {
   const jwtTokenCookie = document.cookie.split("; ").find((row) => row.startsWith(`${JWT_TOKEN_NAME}=`));
   const jwtToken = jwtTokenCookie ? jwtTokenCookie.split("=")[1] : "";
-  return jwtToken || localStorage.getItem(JWT_TOKEN_NAME) || sessionStorage.getItem(JWT_TOKEN_NAME) || "";
+  const raw = jwtToken || localStorage.getItem(JWT_TOKEN_NAME) || sessionStorage.getItem(JWT_TOKEN_NAME) || "";
+  return raw.replace(/^["']|["']$/g, "");
 };
 const createStrapiApiAxiosInstance = (baseUrl = null) => {
-  const token = getToken();
   if (baseUrl === null) {
     baseUrl = `${BASE_PLUGIN_PATH}`;
   }
@@ -2483,6 +2403,7 @@ const createStrapiApiAxiosInstance = (baseUrl = null) => {
         // Add this header to identify the request as initiated by the plugin
         "X-Localazy-Initiated-By": "strapi-plugin-localazy"
       });
+      const token = getToken();
       if (token) {
         config.headers.set("Authorization", `Bearer ${token}`);
       }
@@ -2495,159 +2416,11 @@ const createStrapiApiAxiosInstance = (baseUrl = null) => {
   instance.interceptors.response.use(
     (response) => response,
     (error) => {
-      if (error.response?.status === 401) ;
       throw error;
     }
   );
   return instance;
 };
-const BASE_PATH = "/user";
-const strapiApiInstance = createStrapiApiAxiosInstance();
-class LocalazyUserService {
-  static async getIdentity() {
-    try {
-      const result = await strapiApiInstance.get(`${BASE_PATH}`);
-      return result.data;
-    } catch (e) {
-      throw e;
-    }
-  }
-  static async updateIdentity(localazyIdentity2) {
-    try {
-      const result = await strapiApiInstance.put(`${BASE_PATH}`, localazyIdentity2);
-      return result.data;
-    } catch (e) {
-      throw e;
-    }
-  }
-  static async deleteIdentity() {
-    try {
-      const result = await strapiApiInstance.delete(`${BASE_PATH}`);
-      return result.data;
-    } catch (e) {
-      throw e;
-    }
-  }
-}
-const FetchIdentity = () => {
-  const { setIdentity, setIsFetchingIdentity } = useLocalazyIdentity();
-  React.useEffect(() => {
-    const fetchIdentity = async () => {
-      try {
-        setIsFetchingIdentity(true);
-        const fetchedIdentity = await LocalazyUserService.getIdentity();
-        setIdentity(fetchedIdentity || emptyIdentity);
-      } catch (error) {
-        console.error("Error fetching identity:", error);
-      } finally {
-        setIsFetchingIdentity(false);
-      }
-    };
-    fetchIdentity();
-  }, [setIdentity, setIsFetchingIdentity]);
-  return null;
-};
-const index = {
-  register(app) {
-    addMenuLink(app);
-    addSettingsSection(app);
-    addPlugin(app);
-  },
-  async registerTrads({ locales }) {
-    return Promise.all(
-      locales.map(async (locale) => {
-        try {
-          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => Promise.resolve().then(() => require("./en-CRtsEFtl.js")), "./translations/fr.json": () => Promise.resolve().then(() => require("./fr-C8Qw4iPZ.js")) }), `./translations/${locale}.json`, 3);
-          return { data, locale };
-        } catch {
-          return { data: {}, locale };
-        }
-      })
-    );
-  }
-};
-const addMenuLink = (app) => {
-  app.addMenuLink({
-    to: `plugins/${PLUGIN_ID}/`,
-    icon: Localazy,
-    intlLabel: {
-      id: `${PLUGIN_ID}.name`,
-      defaultMessage: getTranslation("name")
-    },
-    Component: async () => {
-      const { App } = await Promise.resolve().then(() => require("./App-NRmSxuW3.js"));
-      const { LocalazyIdentityProvider: LocalazyIdentityProvider2 } = await Promise.resolve().then(() => localazyIdentity);
-      const WrappedApp = () => React__default.default.createElement(LocalazyIdentityProvider2, {
-        children: React__default.default.createElement(React__default.default.Fragment, {}, [
-          React__default.default.createElement(FetchIdentity, {}),
-          React__default.default.createElement(App, {})
-        ])
-      });
-      return WrappedApp;
-    }
-  });
-};
-const addSettingsSection = (app) => {
-  app.createSettingSection(
-    {
-      id: `${PLUGIN_ID}-settings`,
-      intlLabel: {
-        id: `${PLUGIN_ID}.localazy_settings`,
-        defaultMessage: getTranslation("localazy_settings")
-      }
-    },
-    [
-      // General
-      {
-        id: `${PLUGIN_ID}-settings-global`,
-        intlLabel: {
-          id: `${PLUGIN_ID}.localazy_settings`,
-          defaultMessage: getTranslation("localazy_settings")
-        },
-        to: `/settings/${PLUGIN_ID}/global-settings`,
-        Component: async () => {
-          const { GlobalSettings } = await Promise.resolve().then(() => require("./GlobalSettings-CRMPRA3Y.js"));
-          const { LocalazyIdentityProvider: LocalazyIdentityProvider2 } = await Promise.resolve().then(() => localazyIdentity);
-          const WrappedGlobalSettings = () => React__default.default.createElement(LocalazyIdentityProvider2, { children: React__default.default.createElement(GlobalSettings, {}) });
-          return WrappedGlobalSettings;
-        },
-        permissions: []
-      },
-      // Content Transfer Setup
-      {
-        id: `${PLUGIN_ID}-settings-content-transfer-setup`,
-        intlLabel: {
-          id: `${PLUGIN_ID}.content_transfer_setup`,
-          defaultMessage: getTranslation("content_transfer_setup")
-        },
-        to: `/settings/${PLUGIN_ID}/content-transfer-setup`,
-        Component: async () => {
-          const { ContentTransferSetup } = await Promise.resolve().then(() => require("./ContentTransferSetup-DGs8MZPj.js"));
-          const { LocalazyIdentityProvider: LocalazyIdentityProvider2 } = await Promise.resolve().then(() => localazyIdentity);
-          const WrappedContentTransferSetup = () => React__default.default.createElement(LocalazyIdentityProvider2, {
-            children: React__default.default.createElement(React__default.default.Fragment, {}, [
-              React__default.default.createElement(FetchIdentity, {}),
-              React__default.default.createElement(ContentTransferSetup, {})
-            ])
-          });
-          return WrappedContentTransferSetup;
-        },
-        permissions: []
-      }
-    ]
-  );
-};
-const addPlugin = (app) => {
-  app.registerPlugin({
-    id: PLUGIN_ID,
-    initializer: Initializer,
-    isReady: false,
-    name: PLUGIN_ID
-  });
+export {
+  createStrapiApiAxiosInstance as c
 };
-exports.LocalazyUserService = LocalazyUserService;
-exports.PLUGIN_ID = PLUGIN_ID;
-exports.createStrapiApiAxiosInstance = createStrapiApiAxiosInstance;
-exports.emptyIdentity = emptyIdentity;
-exports.index = index;
-exports.useLocalazyIdentity = useLocalazyIdentity;

package/dist/_chunks/useTranslation-BdIl-aLe.js

@@ -0,0 +1,188 @@
+"use strict";
+const React = require("react");
+const initReactI18next = require("./initReactI18next-B0H8_DlW.js");
+const warn = (i18n, code, msg, rest) => {
+  const args = [msg, {
+    code,
+    ...rest || {}
+  }];
+  if (i18n?.services?.logger?.forward) {
+    return i18n.services.logger.forward(args, "warn", "react-i18next::", true);
+  }
+  if (isString(args[0])) args[0] = `react-i18next:: ${args[0]}`;
+  if (i18n?.services?.logger?.warn) {
+    i18n.services.logger.warn(...args);
+  } else if (console?.warn) {
+    console.warn(...args);
+  }
+};
+const alreadyWarned = {};
+const warnOnce = (i18n, code, msg, rest) => {
+  if (isString(msg) && alreadyWarned[msg]) return;
+  if (isString(msg)) alreadyWarned[msg] = /* @__PURE__ */ new Date();
+  warn(i18n, code, msg, rest);
+};
+const loadedClb = (i18n, cb) => () => {
+  if (i18n.isInitialized) {
+    cb();
+  } else {
+    const initialized = () => {
+      setTimeout(() => {
+        i18n.off("initialized", initialized);
+      }, 0);
+      cb();
+    };
+    i18n.on("initialized", initialized);
+  }
+};
+const loadNamespaces = (i18n, ns, cb) => {
+  i18n.loadNamespaces(ns, loadedClb(i18n, cb));
+};
+const loadLanguages = (i18n, lng, ns, cb) => {
+  if (isString(ns)) ns = [ns];
+  if (i18n.options.preload && i18n.options.preload.indexOf(lng) > -1) return loadNamespaces(i18n, ns, cb);
+  ns.forEach((n) => {
+    if (i18n.options.ns.indexOf(n) < 0) i18n.options.ns.push(n);
+  });
+  i18n.loadLanguages(lng, loadedClb(i18n, cb));
+};
+const hasLoadedNamespace = (ns, i18n, options = {}) => {
+  if (!i18n.languages || !i18n.languages.length) {
+    warnOnce(i18n, "NO_LANGUAGES", "i18n.languages were undefined or empty", {
+      languages: i18n.languages
+    });
+    return true;
+  }
+  return i18n.hasLoadedNamespace(ns, {
+    lng: options.lng,
+    precheck: (i18nInstance, loadNotPending) => {
+      if (options.bindI18n?.indexOf("languageChanging") > -1 && i18nInstance.services.backendConnector.backend && i18nInstance.isLanguageChangingTo && !loadNotPending(i18nInstance.isLanguageChangingTo, ns)) return false;
+    }
+  });
+};
+const isString = (obj) => typeof obj === "string";
+const isObject = (obj) => typeof obj === "object" && obj !== null;
+const I18nContext = React.createContext();
+class ReportNamespaces {
+  constructor() {
+    this.usedNamespaces = {};
+  }
+  addUsedNamespaces(namespaces) {
+    namespaces.forEach((ns) => {
+      if (!this.usedNamespaces[ns]) this.usedNamespaces[ns] = true;
+    });
+  }
+  getUsedNamespaces() {
+    return Object.keys(this.usedNamespaces);
+  }
+}
+const usePrevious = (value, ignore) => {
+  const ref = React.useRef();
+  React.useEffect(() => {
+    ref.current = value;
+  }, [value, ignore]);
+  return ref.current;
+};
+const alwaysNewT = (i18n, language, namespace, keyPrefix) => i18n.getFixedT(language, namespace, keyPrefix);
+const useMemoizedT = (i18n, language, namespace, keyPrefix) => React.useCallback(alwaysNewT(i18n, language, namespace, keyPrefix), [i18n, language, namespace, keyPrefix]);
+const useTranslation = (ns, props = {}) => {
+  const {
+    i18n: i18nFromProps
+  } = props;
+  const {
+    i18n: i18nFromContext,
+    defaultNS: defaultNSFromContext
+  } = React.useContext(I18nContext) || {};
+  const i18n = i18nFromProps || i18nFromContext || initReactI18next.getI18n();
+  if (i18n && !i18n.reportNamespaces) i18n.reportNamespaces = new ReportNamespaces();
+  if (!i18n) {
+    warnOnce(i18n, "NO_I18NEXT_INSTANCE", "useTranslation: You will need to pass in an i18next instance by using initReactI18next");
+    const notReadyT = (k, optsOrDefaultValue) => {
+      if (isString(optsOrDefaultValue)) return optsOrDefaultValue;
+      if (isObject(optsOrDefaultValue) && isString(optsOrDefaultValue.defaultValue)) return optsOrDefaultValue.defaultValue;
+      return Array.isArray(k) ? k[k.length - 1] : k;
+    };
+    const retNotReady = [notReadyT, {}, false];
+    retNotReady.t = notReadyT;
+    retNotReady.i18n = {};
+    retNotReady.ready = false;
+    return retNotReady;
+  }
+  if (i18n.options.react?.wait) warnOnce(i18n, "DEPRECATED_OPTION", "useTranslation: It seems you are still using the old wait option, you may migrate to the new useSuspense behaviour.");
+  const i18nOptions = {
+    ...initReactI18next.getDefaults(),
+    ...i18n.options.react,
+    ...props
+  };
+  const {
+    useSuspense,
+    keyPrefix
+  } = i18nOptions;
+  let namespaces = ns || defaultNSFromContext || i18n.options?.defaultNS;
+  namespaces = isString(namespaces) ? [namespaces] : namespaces || ["translation"];
+  i18n.reportNamespaces.addUsedNamespaces?.(namespaces);
+  const ready = (i18n.isInitialized || i18n.initializedStoreOnce) && namespaces.every((n) => hasLoadedNamespace(n, i18n, i18nOptions));
+  const memoGetT = useMemoizedT(i18n, props.lng || null, i18nOptions.nsMode === "fallback" ? namespaces : namespaces[0], keyPrefix);
+  const getT = () => memoGetT;
+  const getNewT = () => alwaysNewT(i18n, props.lng || null, i18nOptions.nsMode === "fallback" ? namespaces : namespaces[0], keyPrefix);
+  const [t, setT] = React.useState(getT);
+  let joinedNS = namespaces.join();
+  if (props.lng) joinedNS = `${props.lng}${joinedNS}`;
+  const previousJoinedNS = usePrevious(joinedNS);
+  const isMounted = React.useRef(true);
+  React.useEffect(() => {
+    const {
+      bindI18n,
+      bindI18nStore
+    } = i18nOptions;
+    isMounted.current = true;
+    if (!ready && !useSuspense) {
+      if (props.lng) {
+        loadLanguages(i18n, props.lng, namespaces, () => {
+          if (isMounted.current) setT(getNewT);
+        });
+      } else {
+        loadNamespaces(i18n, namespaces, () => {
+          if (isMounted.current) setT(getNewT);
+        });
+      }
+    }
+    if (ready && previousJoinedNS && previousJoinedNS !== joinedNS && isMounted.current) {
+      setT(getNewT);
+    }
+    const boundReset = () => {
+      if (isMounted.current) setT(getNewT);
+    };
+    if (bindI18n) i18n?.on(bindI18n, boundReset);
+    if (bindI18nStore) i18n?.store.on(bindI18nStore, boundReset);
+    return () => {
+      isMounted.current = false;
+      if (i18n) bindI18n?.split(" ").forEach((e) => i18n.off(e, boundReset));
+      if (bindI18nStore && i18n) bindI18nStore.split(" ").forEach((e) => i18n.store.off(e, boundReset));
+    };
+  }, [i18n, joinedNS]);
+  React.useEffect(() => {
+    if (isMounted.current && ready) {
+      setT(getT);
+    }
+  }, [i18n, keyPrefix, ready]);
+  const ret = [t, i18n, ready];
+  ret.t = t;
+  ret.i18n = i18n;
+  ret.ready = ready;
+  if (ready) return ret;
+  if (!ready && !useSuspense) return ret;
+  throw new Promise((resolve) => {
+    if (props.lng) {
+      loadLanguages(i18n, props.lng, namespaces, () => resolve());
+    } else {
+      loadNamespaces(i18n, namespaces, () => resolve());
+    }
+  });
+};
+exports.I18nContext = I18nContext;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.useTranslation = useTranslation;
+exports.warn = warn;
+exports.warnOnce = warnOnce;

package/dist/_chunks/useTranslation-CZQ4lU1m.mjs

@@ -0,0 +1,189 @@
+import { createContext, useContext, useCallback, useState, useRef, useEffect } from "react";
+import { g as getI18n, a as getDefaults } from "./initReactI18next-MHHxeg_9.mjs";
+const warn = (i18n, code, msg, rest) => {
+  const args = [msg, {
+    code,
+    ...rest || {}
+  }];
+  if (i18n?.services?.logger?.forward) {
+    return i18n.services.logger.forward(args, "warn", "react-i18next::", true);
+  }
+  if (isString(args[0])) args[0] = `react-i18next:: ${args[0]}`;
+  if (i18n?.services?.logger?.warn) {
+    i18n.services.logger.warn(...args);
+  } else if (console?.warn) {
+    console.warn(...args);
+  }
+};
+const alreadyWarned = {};
+const warnOnce = (i18n, code, msg, rest) => {
+  if (isString(msg) && alreadyWarned[msg]) return;
+  if (isString(msg)) alreadyWarned[msg] = /* @__PURE__ */ new Date();
+  warn(i18n, code, msg, rest);
+};
+const loadedClb = (i18n, cb) => () => {
+  if (i18n.isInitialized) {
+    cb();
+  } else {
+    const initialized = () => {
+      setTimeout(() => {
+        i18n.off("initialized", initialized);
+      }, 0);
+      cb();
+    };
+    i18n.on("initialized", initialized);
+  }
+};
+const loadNamespaces = (i18n, ns, cb) => {
+  i18n.loadNamespaces(ns, loadedClb(i18n, cb));
+};
+const loadLanguages = (i18n, lng, ns, cb) => {
+  if (isString(ns)) ns = [ns];
+  if (i18n.options.preload && i18n.options.preload.indexOf(lng) > -1) return loadNamespaces(i18n, ns, cb);
+  ns.forEach((n) => {
+    if (i18n.options.ns.indexOf(n) < 0) i18n.options.ns.push(n);
+  });
+  i18n.loadLanguages(lng, loadedClb(i18n, cb));
+};
+const hasLoadedNamespace = (ns, i18n, options = {}) => {
+  if (!i18n.languages || !i18n.languages.length) {
+    warnOnce(i18n, "NO_LANGUAGES", "i18n.languages were undefined or empty", {
+      languages: i18n.languages
+    });
+    return true;
+  }
+  return i18n.hasLoadedNamespace(ns, {
+    lng: options.lng,
+    precheck: (i18nInstance, loadNotPending) => {
+      if (options.bindI18n?.indexOf("languageChanging") > -1 && i18nInstance.services.backendConnector.backend && i18nInstance.isLanguageChangingTo && !loadNotPending(i18nInstance.isLanguageChangingTo, ns)) return false;
+    }
+  });
+};
+const isString = (obj) => typeof obj === "string";
+const isObject = (obj) => typeof obj === "object" && obj !== null;
+const I18nContext = createContext();
+class ReportNamespaces {
+  constructor() {
+    this.usedNamespaces = {};
+  }
+  addUsedNamespaces(namespaces) {
+    namespaces.forEach((ns) => {
+      if (!this.usedNamespaces[ns]) this.usedNamespaces[ns] = true;
+    });
+  }
+  getUsedNamespaces() {
+    return Object.keys(this.usedNamespaces);
+  }
+}
+const usePrevious = (value, ignore) => {
+  const ref = useRef();
+  useEffect(() => {
+    ref.current = value;
+  }, [value, ignore]);
+  return ref.current;
+};
+const alwaysNewT = (i18n, language, namespace, keyPrefix) => i18n.getFixedT(language, namespace, keyPrefix);
+const useMemoizedT = (i18n, language, namespace, keyPrefix) => useCallback(alwaysNewT(i18n, language, namespace, keyPrefix), [i18n, language, namespace, keyPrefix]);
+const useTranslation = (ns, props = {}) => {
+  const {
+    i18n: i18nFromProps
+  } = props;
+  const {
+    i18n: i18nFromContext,
+    defaultNS: defaultNSFromContext
+  } = useContext(I18nContext) || {};
+  const i18n = i18nFromProps || i18nFromContext || getI18n();
+  if (i18n && !i18n.reportNamespaces) i18n.reportNamespaces = new ReportNamespaces();
+  if (!i18n) {
+    warnOnce(i18n, "NO_I18NEXT_INSTANCE", "useTranslation: You will need to pass in an i18next instance by using initReactI18next");
+    const notReadyT = (k, optsOrDefaultValue) => {
+      if (isString(optsOrDefaultValue)) return optsOrDefaultValue;
+      if (isObject(optsOrDefaultValue) && isString(optsOrDefaultValue.defaultValue)) return optsOrDefaultValue.defaultValue;
+      return Array.isArray(k) ? k[k.length - 1] : k;
+    };
+    const retNotReady = [notReadyT, {}, false];
+    retNotReady.t = notReadyT;
+    retNotReady.i18n = {};
+    retNotReady.ready = false;
+    return retNotReady;
+  }
+  if (i18n.options.react?.wait) warnOnce(i18n, "DEPRECATED_OPTION", "useTranslation: It seems you are still using the old wait option, you may migrate to the new useSuspense behaviour.");
+  const i18nOptions = {
+    ...getDefaults(),
+    ...i18n.options.react,
+    ...props
+  };
+  const {
+    useSuspense,
+    keyPrefix
+  } = i18nOptions;
+  let namespaces = ns || defaultNSFromContext || i18n.options?.defaultNS;
+  namespaces = isString(namespaces) ? [namespaces] : namespaces || ["translation"];
+  i18n.reportNamespaces.addUsedNamespaces?.(namespaces);
+  const ready = (i18n.isInitialized || i18n.initializedStoreOnce) && namespaces.every((n) => hasLoadedNamespace(n, i18n, i18nOptions));
+  const memoGetT = useMemoizedT(i18n, props.lng || null, i18nOptions.nsMode === "fallback" ? namespaces : namespaces[0], keyPrefix);
+  const getT = () => memoGetT;
+  const getNewT = () => alwaysNewT(i18n, props.lng || null, i18nOptions.nsMode === "fallback" ? namespaces : namespaces[0], keyPrefix);
+  const [t, setT] = useState(getT);
+  let joinedNS = namespaces.join();
+  if (props.lng) joinedNS = `${props.lng}${joinedNS}`;
+  const previousJoinedNS = usePrevious(joinedNS);
+  const isMounted = useRef(true);
+  useEffect(() => {
+    const {
+      bindI18n,
+      bindI18nStore
+    } = i18nOptions;
+    isMounted.current = true;
+    if (!ready && !useSuspense) {
+      if (props.lng) {
+        loadLanguages(i18n, props.lng, namespaces, () => {
+          if (isMounted.current) setT(getNewT);
+        });
+      } else {
+        loadNamespaces(i18n, namespaces, () => {
+          if (isMounted.current) setT(getNewT);
+        });
+      }
+    }
+    if (ready && previousJoinedNS && previousJoinedNS !== joinedNS && isMounted.current) {
+      setT(getNewT);
+    }
+    const boundReset = () => {
+      if (isMounted.current) setT(getNewT);
+    };
+    if (bindI18n) i18n?.on(bindI18n, boundReset);
+    if (bindI18nStore) i18n?.store.on(bindI18nStore, boundReset);
+    return () => {
+      isMounted.current = false;
+      if (i18n) bindI18n?.split(" ").forEach((e) => i18n.off(e, boundReset));
+      if (bindI18nStore && i18n) bindI18nStore.split(" ").forEach((e) => i18n.store.off(e, boundReset));
+    };
+  }, [i18n, joinedNS]);
+  useEffect(() => {
+    if (isMounted.current && ready) {
+      setT(getT);
+    }
+  }, [i18n, keyPrefix, ready]);
+  const ret = [t, i18n, ready];
+  ret.t = t;
+  ret.i18n = i18n;
+  ret.ready = ready;
+  if (ready) return ret;
+  if (!ready && !useSuspense) return ret;
+  throw new Promise((resolve) => {
+    if (props.lng) {
+      loadLanguages(i18n, props.lng, namespaces, () => resolve());
+    } else {
+      loadNamespaces(i18n, namespaces, () => resolve());
+    }
+  });
+};
+export {
+  I18nContext as I,
+  warn as a,
+  isObject as b,
+  isString as i,
+  useTranslation as u,
+  warnOnce as w
+};