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

package/compiler-sync.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./compiler-sync";

package/compiler-sync.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./compiler-sync.cjs.js').default;

package/compiler-sync.cjs.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var synckit = require('synckit');
+require('@koine/utils');
+require('node:fs');
+require('node:path');
+require('@koine/node');
+require('typescript');
+require('minimatch');
+require('next/dist/shared/lib/utils');
+require('node:fs/promises');
+require('glob');
+require('node:child_process');
+require('node:https');
+
+let i18nCompilerSync = synckit.createSyncFn(require.resolve("./compiler-worker.cjs"));
+
+exports.i18nCompilerSync = i18nCompilerSync;

package/compiler-sync.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './compiler-sync.cjs.js';
+export { _default as default } from './compiler-sync.cjs.default.js';

package/compiler-sync.esm.js

@@ -0,0 +1,16 @@
+import { createSyncFn } from 'synckit';
+import '@koine/utils';
+import 'node:fs';
+import 'node:path';
+import '@koine/node';
+import 'typescript';
+import 'minimatch';
+import 'next/dist/shared/lib/utils';
+import 'node:fs/promises';
+import 'glob';
+import 'node:child_process';
+import 'node:https';
+
+let i18nCompilerSync = createSyncFn(require.resolve("./compiler-worker.cjs"));
+
+export { i18nCompilerSync };

package/compiler-worker.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./compiler-worker";

package/compiler-worker.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./compiler-worker.cjs.js').default;

package/compiler-worker.cjs.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var synckit = require('synckit');
+var api = require('./api.cjs.js');
+require('@koine/utils');
+require('node:fs');
+require('node:path');
+require('@koine/node');
+require('./formatRoutePathname.cjs.js');
+require('typescript');
+require('minimatch');
+require('next/dist/shared/lib/utils');
+require('node:fs/promises');
+require('glob');
+require('node:child_process');
+require('node:https');
+
+synckit.runAsWorker(api.i18nCompiler);

package/compiler-worker.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './compiler-worker.cjs.js';
+export { _default as default } from './compiler-worker.cjs.default.js';

package/compiler-worker.esm.js

@@ -0,0 +1,16 @@
+import { runAsWorker } from 'synckit';
+import { i as i18nCompiler } from './api.esm.js';
+import '@koine/utils';
+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';
+
+runAsWorker(i18nCompiler);

package/compiler.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./compiler";

package/compiler.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./compiler.cjs.js').default;

package/compiler.cjs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var api = require('./api.cjs.js');
+require('@koine/utils');
+require('node:fs');
+require('node:path');
+require('@koine/node');
+require('./formatRoutePathname.cjs.js');
+require('typescript');
+require('minimatch');
+require('next/dist/shared/lib/utils');
+require('node:fs/promises');
+require('glob');
+require('node:child_process');
+require('node:https');
+
+
+
+exports.i18nCompiler = api.i18nCompiler;

package/compiler.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './compiler.cjs.js';
+export { _default as default } from './compiler.cjs.default.js';

package/compiler.esm.js

@@ -0,0 +1,13 @@
+export { i as i18nCompiler } from './api.esm.js';
+import '@koine/utils';
+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';

package/formatRoutePathname.cjs.js

@@ -0,0 +1,12 @@
+'use strict';
+
+let formatRoutePathname = (pathname = "", options) => {
+    const { trailingSlash } = options || {};
+    pathname = ("/" + pathname + "/").replace(/\/+/g, "/");
+    if (!trailingSlash) {
+        pathname = pathname.replace(/\/*$/, "");
+    }
+    return pathname || "/";
+};
+
+exports.formatRoutePathname = formatRoutePathname;

package/formatRoutePathname.esm.js

@@ -0,0 +1,10 @@
+let formatRoutePathname = (pathname = "", options) => {
+    const { trailingSlash } = options || {};
+    pathname = ("/" + pathname + "/").replace(/\/+/g, "/");
+    if (!trailingSlash) {
+        pathname = pathname.replace(/\/*$/, "");
+    }
+    return pathname || "/";
+};
+
+export { formatRoutePathname as f };

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./index";

package/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/index.cjs.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var formatRoutePathname = require('./formatRoutePathname.cjs.js');
+var utils = require('@koine/utils');
+
+function interpolateTo(value, params) {
+    let pathname = value.replace(/\./g, "/");
+    if (process.env["NODE_ENV"] === "development") {
+        if (params) {
+            pathname.replace(/[[{]{1,2}(.*?)[\]}]{1,2}/g, (_, dynamicKey) => {
+                const key = dynamicKey;
+                if (!(key in params)) {
+                    throw new Error("[@koine/i18n]::interpolateTo, using '" +
+                        value +
+                        "' without param '" +
+                        key +
+                        "'");
+                }
+                if (!["string", "number"].includes(typeof params[key])) {
+                    throw new Error("[@koine/i18n]::interpolateTo, using '" +
+                        value +
+                        "' with unserializable param  '" +
+                        key +
+                        "' (type '" +
+                        utils.getType(params[key]) +
+                        "')");
+                }
+                return "";
+            });
+        }
+    }
+    pathname = pathname
+        ? params
+            ? pathname.replace(/[[{]{1,2}(.*?)[\]}]{1,2}/g, (_, dynamicKey) => params[dynamicKey.trim()] + "")
+            : pathname
+        :
+            "/";
+    return formatRoutePathname.formatRoutePathname(pathname);
+}
+
+let routeHasDynamicPortion = (routeIdOrPortion) => /\[/.test(routeIdOrPortion);
+
+exports.formatRoutePathname = formatRoutePathname.formatRoutePathname;
+exports.interpolateTo = interpolateTo;
+exports.routeHasDynamicPortion = routeHasDynamicPortion;

package/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/index.esm.js

@@ -0,0 +1,42 @@
+import { f as formatRoutePathname } from './formatRoutePathname.esm.js';
+export { f as formatRoutePathname } from './formatRoutePathname.esm.js';
+import { getType } from '@koine/utils';
+
+function interpolateTo(value, params) {
+    let pathname = value.replace(/\./g, "/");
+    if (process.env["NODE_ENV"] === "development") {
+        if (params) {
+            pathname.replace(/[[{]{1,2}(.*?)[\]}]{1,2}/g, (_, dynamicKey) => {
+                const key = dynamicKey;
+                if (!(key in params)) {
+                    throw new Error("[@koine/i18n]::interpolateTo, using '" +
+                        value +
+                        "' without param '" +
+                        key +
+                        "'");
+                }
+                if (!["string", "number"].includes(typeof params[key])) {
+                    throw new Error("[@koine/i18n]::interpolateTo, using '" +
+                        value +
+                        "' with unserializable param  '" +
+                        key +
+                        "' (type '" +
+                        getType(params[key]) +
+                        "')");
+                }
+                return "";
+            });
+        }
+    }
+    pathname = pathname
+        ? params
+            ? pathname.replace(/[[{]{1,2}(.*?)[\]}]{1,2}/g, (_, dynamicKey) => params[dynamicKey.trim()] + "")
+            : pathname
+        :
+            "/";
+    return formatRoutePathname(pathname);
+}
+
+let routeHasDynamicPortion = (routeIdOrPortion) => /\[/.test(routeIdOrPortion);
+
+export { interpolateTo, routeHasDynamicPortion };

package/next.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./next";

package/next.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./next.cjs.js').default;

package/next.cjs.js

@@ -0,0 +1,377 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@koine/utils');
+var webpack = require('webpack');
+var api = require('./api.cjs.js');
+var node_module = require('node:module');
+var compilerSync = require('./compiler-sync.cjs.js');
+require('node:fs');
+require('node:path');
+require('@koine/node');
+require('./formatRoutePathname.cjs.js');
+require('typescript');
+require('minimatch');
+require('next/dist/shared/lib/utils');
+require('node:fs/promises');
+require('glob');
+require('node:child_process');
+require('node:https');
+require('synckit');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+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(`/${utils.normaliseUrlPathname(sourcePrefix + template)}`);
+    const destinationPrefix = localeDestination ? `${localeDestination}/` : "";
+    const destination = `/${utils.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 = utils.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 = `/${utils.normaliseUrlPathname(sourcePrefix + pathname)}`;
+    let destinationPrefix = "";
+    if (localeDestination)
+        destinationPrefix = `${localeDestination}/`;
+    else if (localeParam)
+        destinationPrefix = `:${localeParam}/`;
+    const destination = getWithoutIndex(`/${utils.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 = utils.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 webpack.ContextReplacementPlugin(/^date-fns[/\\]locale$/, new RegExp(`\\.[/\\\\](${locales.join("|")})[/\\\\]index\\.js$`)));
+        return webpackConfig;
+    };
+    return nextConfig;
+};
+let getRedirects = async (prevRedirects, { appRouterLocaleParamName, permanentRedirects }, i18nResult) => {
+    const defaultRedirects = api.generateRedirects(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 = api.generateRewrites(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 api.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 Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('next-translate-plugin')); }).then((m) => m.default);
+            nextConfig = withNextTranslate(nextConfig);
+        }
+        catch (e) {
+        }
+    }
+    return nextConfig;
+};
+
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('next.cjs.js', document.baseURI).href)));
+let withI18n = (config = {}) => {
+    const { i18nCompiler: i18nConfig, redirects, rewrites, ...restNextConfig } = config;
+    let nextConfig = restNextConfig;
+    if (!i18nConfig)
+        return nextConfig;
+    const i18nResult = compilerSync.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$1("next-translate-plugin");
+            nextConfig = withNextTranslate(nextConfig);
+        }
+        catch (e) {
+        }
+    }
+    return nextConfig;
+};
+
+exports.withI18n = withI18n;
+exports.withI18nAsync = withI18nAsync;
+exports.withI18nLegacy = withI18nLegacy;

package/next.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './next.cjs.js';
+export { _default as default } from './next.cjs.default.js';