@koine/i18n 2.0.0-beta.76 → 2.0.0-beta.78

package/next.esm.js

@@ -0,0 +1,353 @@
+import { arrayUniqueByProperties, normaliseUrlPathname } from '@koine/utils';
+import { ContextReplacementPlugin } from 'webpack';
+import { g as generateRedirects$1, a as generateRewrites$1, i as i18nCompiler } from './api.esm.js';
+import { createRequire } from 'node:module';
+import { i18nCompilerSync } from './compiler-sync.esm.js';
+import 'node:fs';
+import 'node:path';
+import '@koine/node';
+import './formatRoutePathname.esm.js';
+import 'typescript';
+import 'minimatch';
+import 'next/dist/shared/lib/utils';
+import 'node:fs/promises';
+import 'glob';
+import 'node:child_process';
+import 'node:https';
+import 'synckit';
+
+function orderRoutes(routes, defaultLocale) {
+    const { [defaultLocale]: routesForDefaultLocale, ...restRoutes } = routes;
+    return {
+        [defaultLocale]: routesForDefaultLocale,
+        ...restRoutes,
+    };
+}
+function transformRoute(route) {
+    const { pathname: rawPathname, template: rawTemplate } = route;
+    const pathnameParts = rawPathname.split("/").filter((part) => !!part);
+    const templateParts = rawTemplate.split("/").filter((part) => !!part);
+    const mapPartsByIdx = {};
+    const pathname = pathnameParts
+        .map((part) => {
+        const hasWildcard = part.endsWith("*");
+        part = part.replace("*", "");
+        const isDynamic = part.startsWith("{{") && part.endsWith("}}");
+        const asValue = isDynamic
+            ? part.match(/{{(.+)}}/)?.[1].trim() ?? ""
+            : part.trim();
+        const asPath = encodeURIComponent(asValue) + (hasWildcard ? "*" : "");
+        mapPartsByIdx[asValue] = {
+            isDynamic,
+            hasWildcard,
+        };
+        return isDynamic ? `:${asPath}` : asPath;
+    })
+        .join("/");
+    const template = templateParts
+        .map((part) => {
+        const isDynamic = part.startsWith("[") && part.endsWith("]");
+        const asValue = isDynamic
+            ? part.match(/\[(.+)\]/)?.[1].trim() ?? ""
+            : part.trim();
+        const hasWildcard = mapPartsByIdx[asValue]?.hasWildcard;
+        const asPath = encodeURIComponent(asValue) + (hasWildcard ? "*" : "");
+        return isDynamic ? `:${asPath}` : asPath;
+    })
+        .join("/");
+    return { pathname, template };
+}
+function getRoutesMap(map = {}, routesByLocale, pathnameBuffer = "", templateBuffer = "") {
+    const isSpaRoute = Object.keys(routesByLocale).includes("[spa]");
+    for (const key in routesByLocale) {
+        const pathOrNestedRoutes = routesByLocale[key];
+        const template = `${templateBuffer}/${key}`;
+        if (typeof pathOrNestedRoutes === "string") {
+            if (!isSpaRoute || (isSpaRoute && ["[spa]", "index"].includes(key))) {
+                map[template] = {
+                    template,
+                    pathname: pathOrNestedRoutes,
+                    wildcard: pathOrNestedRoutes.includes("*"),
+                };
+            }
+        }
+        else {
+            if (!isSpaRoute) {
+                getRoutesMap(map, pathOrNestedRoutes, pathnameBuffer, template);
+            }
+        }
+    }
+    return map;
+}
+function getWithoutIndex(template) {
+    return template.replace(/\/index$/, "");
+}
+function getPathRedirect(arg) {
+    const { localeSource, localeDestination, route, usePathnameAsSource, permanent, } = arg;
+    const { template: routeTemplate, pathname } = transformRoute(route);
+    const template = usePathnameAsSource ? pathname : routeTemplate;
+    const sourcePrefix = localeSource ? `${localeSource}/` : "";
+    const source = getWithoutIndex(`/${normaliseUrlPathname(sourcePrefix + template)}`);
+    const destinationPrefix = localeDestination ? `${localeDestination}/` : "";
+    const destination = `/${normaliseUrlPathname(destinationPrefix + pathname)}`;
+    if (source === destination)
+        return;
+    const redirect = {
+        source,
+        destination,
+        permanent: Boolean(permanent),
+    };
+    return redirect;
+}
+function generateRedirects(arg) {
+    const { routes, defaultLocale, hideDefaultLocaleInUrl, localeParam, permanent, debug, } = arg;
+    const orderedRoutes = orderRoutes(routes, defaultLocale);
+    const redirects = [];
+    for (const locale in orderedRoutes) {
+        const routesByLocale = routes[locale];
+        const routesMap = getRoutesMap({}, routesByLocale);
+        for (const template in routesMap) {
+            const route = routesMap[template];
+            if (route.pathname !== getWithoutIndex(template)) {
+                const isVisibleDefaultLocale = locale === defaultLocale && !hideDefaultLocaleInUrl;
+                const isHiddenDefaultLocale = locale === defaultLocale && hideDefaultLocaleInUrl;
+                if (localeParam) {
+                    if (isVisibleDefaultLocale) {
+                        redirects.push(getPathRedirect({ localeDestination: locale, route, permanent }));
+                    }
+                    else if (isHiddenDefaultLocale) {
+                        redirects.push(getPathRedirect({ localeSource: locale, route, permanent }));
+                    }
+                    else if (locale !== defaultLocale) {
+                        redirects.push(getPathRedirect({
+                            localeSource: locale,
+                            localeDestination: locale,
+                            route,
+                            permanent,
+                        }));
+                    }
+                    else {
+                        redirects.push(getPathRedirect({ route, permanent }));
+                    }
+                }
+                else {
+                    if (isVisibleDefaultLocale) {
+                        redirects.push(getPathRedirect({ localeDestination: locale, route, permanent }));
+                    }
+                    else if (locale !== defaultLocale) {
+                        redirects.push(getPathRedirect({
+                            localeSource: locale,
+                            localeDestination: locale,
+                            route,
+                            permanent,
+                        }));
+                    }
+                    else {
+                        redirects.push(getPathRedirect({ route, permanent }));
+                    }
+                }
+            }
+        }
+    }
+    const cleaned = arrayUniqueByProperties(redirects.filter(Boolean), ["source", "destination"]).map((rewrite) => localeParam ? rewrite : { ...rewrite, locale: false });
+    if (debug)
+        console.info("[@koine/next/plugin-legacy:generateRedirects]", cleaned);
+    return cleaned;
+}
+function getPathRewrite(arg) {
+    const { localeSource, localeDestination, localeParam, route } = arg;
+    const { pathname, template } = transformRoute(route);
+    let sourcePrefix = "";
+    if (localeSource)
+        sourcePrefix = `${localeSource}/`;
+    else if (localeParam)
+        sourcePrefix = `:${localeParam}/`;
+    const source = `/${normaliseUrlPathname(sourcePrefix + pathname)}`;
+    let destinationPrefix = "";
+    if (localeDestination)
+        destinationPrefix = `${localeDestination}/`;
+    else if (localeParam)
+        destinationPrefix = `:${localeParam}/`;
+    const destination = getWithoutIndex(`/${normaliseUrlPathname(destinationPrefix + template)}`);
+    if (source === destination)
+        return;
+    return {
+        source,
+        destination,
+    };
+}
+function generateRewrites(arg) {
+    const { routes, defaultLocale, hideDefaultLocaleInUrl, localeParam, debug } = arg;
+    const orderedRoutes = orderRoutes(routes, defaultLocale);
+    const rewrites = [];
+    for (const locale in orderedRoutes) {
+        const routesByLocale = routes[locale];
+        const routesMap = getRoutesMap({}, routesByLocale);
+        for (const template in routesMap) {
+            const route = routesMap[template];
+            const isVisibleDefaultLocale = locale === defaultLocale && !hideDefaultLocaleInUrl;
+            const isHiddenDefaultLocale = locale === defaultLocale && hideDefaultLocaleInUrl;
+            if (localeParam) {
+                if (isHiddenDefaultLocale) {
+                    rewrites.push(getPathRewrite({ localeDestination: locale, route }));
+                }
+                else {
+                    rewrites.push(getPathRewrite({ localeParam, route }));
+                }
+            }
+            else {
+                if (route.pathname !== getWithoutIndex(template)) {
+                    if (locale !== defaultLocale || isVisibleDefaultLocale) {
+                        rewrites.push(getPathRewrite({ localeSource: locale, route }));
+                    }
+                    else {
+                        rewrites.push(getPathRewrite({ route }));
+                    }
+                }
+            }
+        }
+    }
+    const cleaned = arrayUniqueByProperties(rewrites.filter(Boolean), ["source", "destination"]);
+    if (debug)
+        console.info("[@koine/next/plugin-legacy:generateRewrites]", cleaned);
+    return cleaned;
+}
+let withI18nLegacy = (config) => {
+    const { i18nRoutes, ...restNextConfig } = config;
+    if (!i18nRoutes)
+        return restNextConfig;
+    const { locales = ["en"], defaultLocale = "en", ...restI18n } = config.i18n || {};
+    restNextConfig.i18n = { ...restI18n, locales, defaultLocale };
+    const options = {
+        hideDefaultLocaleInUrl: true,
+        localeParam: "",
+        ...i18nRoutes,
+        locales,
+        defaultLocale,
+    };
+    const nextConfig = { ...restNextConfig };
+    if (options.routes) {
+        const { redirects, rewrites } = nextConfig;
+        nextConfig.redirects = async () => {
+            const defaults = generateRedirects(options);
+            if (redirects) {
+                const customs = await redirects();
+                return [...defaults, ...customs];
+            }
+            return defaults;
+        };
+        nextConfig.rewrites = async () => {
+            const defaults = generateRewrites(options);
+            if (rewrites) {
+                const customs = await rewrites();
+                if (Array.isArray(customs)) {
+                    return {
+                        beforeFiles: defaults,
+                        afterFiles: customs,
+                        fallback: [],
+                    };
+                }
+                return {
+                    ...customs,
+                    beforeFiles: [...defaults, ...(customs.beforeFiles || [])],
+                };
+            }
+            return {
+                beforeFiles: defaults,
+                afterFiles: [],
+                fallback: [],
+            };
+        };
+    }
+    return nextConfig;
+};
+
+let tweakNextConfig = (options, nextConfig) => {
+    const { defaultLocale, locales, appRouterLocaleParamName } = options;
+    if (appRouterLocaleParamName) {
+        delete nextConfig.i18n;
+    }
+    else {
+        nextConfig.i18n = nextConfig.i18n || { locales, defaultLocale };
+        nextConfig.i18n.locales = locales;
+        nextConfig.i18n.defaultLocale = defaultLocale;
+    }
+    nextConfig.webpack = (webpackConfig) => {
+        webpackConfig.plugins.push(new ContextReplacementPlugin(/^date-fns[/\\]locale$/, new RegExp(`\\.[/\\\\](${locales.join("|")})[/\\\\]index\\.js$`)));
+        return webpackConfig;
+    };
+    return nextConfig;
+};
+let getRedirects = async (prevRedirects, { appRouterLocaleParamName, permanentRedirects }, i18nResult) => {
+    const defaultRedirects = generateRedirects$1(i18nResult.config, i18nResult.code.routes.byId, i18nResult.code.options.routes, appRouterLocaleParamName, permanentRedirects);
+    if (prevRedirects) {
+        const custom = await prevRedirects();
+        return [...defaultRedirects, ...custom];
+    }
+    return defaultRedirects;
+};
+let getRewrites = async (prevRewrites, { appRouterLocaleParamName }, i18nResult) => {
+    const defaultRewrites = generateRewrites$1(i18nResult.config, i18nResult.code.routes.byId, i18nResult.code.options.routes, appRouterLocaleParamName);
+    if (prevRewrites) {
+        const custom = await prevRewrites();
+        if (Array.isArray(custom)) {
+            return {
+                beforeFiles: defaultRewrites,
+                afterFiles: custom,
+                fallback: [],
+            };
+        }
+        return {
+            ...custom,
+            beforeFiles: [...defaultRewrites, ...(custom.beforeFiles || [])],
+        };
+    }
+    return {
+        beforeFiles: defaultRewrites,
+        afterFiles: [],
+        fallback: [],
+    };
+};
+
+let withI18nAsync = (config = {}) => async () => {
+    const { i18nCompiler: i18nConfig, redirects, rewrites, ...restNextConfig } = config;
+    let nextConfig = restNextConfig;
+    if (!i18nConfig)
+        return nextConfig;
+    const i18nResult = await i18nCompiler(i18nConfig);
+    nextConfig = tweakNextConfig(i18nResult.config, nextConfig);
+    nextConfig.redirects = () => getRedirects(redirects, i18nConfig, i18nResult);
+    nextConfig.rewrites = () => getRewrites(rewrites, i18nConfig, i18nResult);
+    if (i18nConfig.code.adapter === "next-translate") {
+        try {
+            const withNextTranslate = await import('next-translate-plugin').then((m) => m.default);
+            nextConfig = withNextTranslate(nextConfig);
+        }
+        catch (e) {
+        }
+    }
+    return nextConfig;
+};
+
+const require = createRequire(import.meta.url);
+let withI18n = (config = {}) => {
+    const { i18nCompiler: i18nConfig, redirects, rewrites, ...restNextConfig } = config;
+    let nextConfig = restNextConfig;
+    if (!i18nConfig)
+        return nextConfig;
+    const i18nResult = i18nCompilerSync(i18nConfig);
+    nextConfig = tweakNextConfig(i18nResult.config, nextConfig);
+    nextConfig.redirects = () => getRedirects(redirects, i18nConfig, i18nResult);
+    nextConfig.rewrites = () => getRewrites(rewrites, i18nConfig, i18nResult);
+    if (i18nConfig.code.adapter === "next-translate") {
+        try {
+            const withNextTranslate = require("next-translate-plugin");
+            nextConfig = withNextTranslate(nextConfig);
+        }
+        catch (e) {
+        }
+    }
+    return nextConfig;
+};
+
+export { withI18n, withI18nAsync, withI18nLegacy };