next-i18next-static-site
Version:
i18next solution for static sites build with Next.js (static HTML export / next export)
256 lines (254 loc) • 9.46 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.tsx
var index_exports = {};
__export(index_exports, {
I18nProvider: () => I18nProvider,
Trans: () => import_react_i18next.Trans,
Translation: () => import_react_i18next.Translation,
cookieName: () => cookieName,
defaultLanguage: () => defaultLanguage,
defaultNamespace: () => defaultNamespace,
defaultNamespace2: () => defaultNamespace2,
getAllLanguageSlugs: () => getAllLanguageSlugs,
getLanguage: () => getLanguage,
i18nextInstance: () => i18nextInstance,
languageDetection: () => languageDetection,
languages: () => languages,
namespaces: () => namespaces,
useLanguageDetection: () => useLanguageDetection,
useTranslation: () => import_react_i18next.useTranslation,
withTranslation: () => import_react_i18next.withTranslation
});
module.exports = __toCommonJS(index_exports);
var import_router = require("next/router");
var import_react = require("react");
var import_js_cookie = __toESM(require("js-cookie"));
var import_i18next = __toESM(require("i18next"));
var import_react_i18next = require("react-i18next");
var env = {
languages: ["en"],
defaultLanguage: "en",
namespaces: ["common"],
defaultNamespace: "common"
};
try {
if (process.env.NEXT_PUBLIC_I18N_LANGUAGES) {
env.languages = JSON.parse(process.env.NEXT_PUBLIC_I18N_LANGUAGES);
} else {
throw new Error("NEXT_PUBLIC_I18N_LANGUAGES not set");
}
if (process.env.NEXT_PUBLIC_I18N_DEFAULT_LANGUAGE) {
env.defaultLanguage = process.env.NEXT_PUBLIC_I18N_DEFAULT_LANGUAGE;
} else {
throw new Error("NEXT_PUBLIC_I18N_DEFAULT_LANGUAGE not set");
}
if (process.env.NEXT_PUBLIC_I18N_NAMESPACES) {
env.namespaces = JSON.parse(process.env.NEXT_PUBLIC_I18N_NAMESPACES);
} else {
throw new Error("NEXT_PUBLIC_I18N_NAMESPACES not set");
}
if (process.env.NEXT_PUBLIC_I18N_DEFAULT_NAMESPACE) {
env.defaultNamespace = process.env.NEXT_PUBLIC_I18N_DEFAULT_NAMESPACE;
} else {
throw new Error("NEXT_PUBLIC_I18N_DEFAULT_NAMESPACE not set");
}
if (process.env.NEXT_PUBLIC_I18N_OPTIONS) {
try {
env.options = JSON.parse(process.env.NEXT_PUBLIC_I18N_OPTIONS);
} catch (err) {
throw new Error("NEXT_PUBLIC_I18N_OPTIONS malformed");
}
}
} catch (err) {
console.log(err);
}
var defaultConfig = {
allowHydration: true,
languages: ["en"],
defaultLanguage: "en",
namespaces: ["common"],
defaultNamespace: "common",
cookieName: "lang",
// optional set cookie options, reference:[MDN Set-Cookie docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie)
cookieOptions: { expires: 365, path: "/" }
};
var config = __spreadProps(__spreadValues(__spreadValues({}, defaultConfig), env.options), {
languages: env.languages,
defaultLanguage: env.defaultLanguage,
namespaces: env.namespaces,
defaultNamespace: env.defaultNamespace
});
var languages = config.languages;
var defaultLanguage = config.defaultLanguage;
var namespaces = config.namespaces;
var defaultNamespace = config.defaultNamespace;
var defaultNamespace2 = config.defaultNamespace;
var cookieName = config.cookieName;
var createI18nextInstance = (options) => {
const plugins = [
//
import_react_i18next.initReactI18next
];
plugins.map((plugin) => import_i18next.default.use(plugin));
plugins.map((plugin) => import_i18next.default.use(plugin));
import_i18next.default.init(__spreadValues(__spreadValues({
resources: options.locales,
cleanCode: true,
lng: options.language,
supportedLngs: config.languages,
fallbackLng: options.language ? options.language : config.defaultLanguage,
ns: config.namespaces,
// String or array of namespaces to load
defaultNS: config.defaultNamespace,
// Default namespace used if not passed to translation function
interpolation: {
escapeValue: false
// Not needed for react as it escapes by default
},
react: {
useSuspense: false
// Not compatible with SSR
},
load: "languageOnly"
}, config), options));
return import_i18next.default;
};
var globalI18nextInstance = null;
var i18nextInstance = (options) => {
if (!globalI18nextInstance) {
globalI18nextInstance = createI18nextInstance(options);
return globalI18nextInstance;
} else {
globalI18nextInstance.changeLanguage(options.language);
return globalI18nextInstance;
}
};
var loaded = false;
var I18nProvider = (props) => {
var _a;
const [hydration, setHydration] = (0, import_react.useState)(false);
const options = __spreadValues(__spreadValues({}, config), props.i18n);
if (!((_a = props.i18n) == null ? void 0 : _a.locales)) {
throw new Error("locales object was not passed into I18nProvider");
}
const router = (0, import_router.useRouter)();
const { asPath, query } = router;
const slug = asPath.split("/")[1];
const langSlug = config.languages.includes(slug) && slug;
const language = (query.lang || langSlug || config.defaultLanguage).toString();
const pathLocale = (query.lang || langSlug).toString();
if (pathLocale && pathLocale !== "false") {
import_js_cookie.default.set(config.cookieName, pathLocale, config.cookieOptions);
}
if (!loaded) {
i18nextInstance(__spreadProps(__spreadValues({}, props.i18n), { language }));
}
const { i18n: i18n2 } = (0, import_react_i18next.useTranslation)();
(0, import_react.useEffect)(() => {
i18n2.services.resourceStore.data = props.i18n.locales;
i18n2.changeLanguage(language);
}, [i18n2, language, props.i18n.locales]);
(0, import_react.useEffect)(() => {
loaded = true;
i18n2.changeLanguage(language);
}, [i18n2, language]);
(0, import_react.useEffect)(() => {
const hasWindow = typeof window !== "undefined";
if (hasWindow && options.allowHydration) {
setHydration(true);
}
}, [options.allowHydration]);
return hydration ? props.children : null;
};
function getAllLanguageSlugs() {
return config.languages.map((lang) => {
return { params: { lang } };
});
}
function getLanguage(lang) {
return config.languages.includes(lang) ? lang : config.defaultLanguage;
}
var useLanguageDetection = () => {
const router = (0, import_router.useRouter)();
(0, import_react.useEffect)(() => {
let cookieLocale = import_js_cookie.default.get(cookieName) || void 0;
let browserLocale = (navigator.languages && navigator.languages.length ? navigator.languages[0] : navigator.language) || void 0;
if (browserLocale) {
browserLocale = browserLocale.slice(0, 2);
}
if (cookieLocale && languages.includes(cookieLocale)) {
router.push("/" + cookieLocale);
} else if (browserLocale && languages.includes(browserLocale)) {
router.push("/" + browserLocale);
} else {
router.push("/" + defaultLanguage);
}
}, [router, defaultLanguage]);
return null;
};
var languageDetection = () => {
throw Error("Rename languageDetection() to useLanguageDetection()");
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
I18nProvider,
Trans,
Translation,
cookieName,
defaultLanguage,
defaultNamespace,
defaultNamespace2,
getAllLanguageSlugs,
getLanguage,
i18nextInstance,
languageDetection,
languages,
namespaces,
useLanguageDetection,
useTranslation,
withTranslation
});