@koine/i18n 2.0.0-beta.100

package/next.esm.js

@@ -0,0 +1,329 @@
+import { objectMergeWithDefaults, arrayUniqueByProperties } from '@koine/utils';
+import { g as generateRedirectForPathname, a as generateRewriteForPathname, b as generateRedirects, c as generateRewrites, i as i18nCompiler } from './api.esm.js';
+import { ContextReplacementPlugin } from 'webpack';
+import { createRequire } from 'node:module';
+import { i18nCompilerSync } from './compiler-sync.esm.js';
+import 'next/dist/shared/lib/utils';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import 'glob';
+import 'node:https';
+import 'minimatch';
+import './formatRoutePathname.esm.js';
+import '@koine/node';
+import 'typescript';
+import 'synckit';
+
+// & { _branded: true };
+function r(e, t) {
+    let { [t]: n, ...l } = e;
+    return {
+        [t]: n,
+        ...l
+    };
+}
+/**
+ * Transform the route translated defintion into a `pathname` and a `template`.
+ *
+ * Here we add the wildcard flag maybe found in the pathname to the template
+ * name too, this is because we do not want to have the wildcard in the JSON
+ * keys as those are also used to produce links through the `useTo` hook and
+ * having asterisks there is a bit cumbersome.
+ *
+ * @see https://nextjs.org/docs/messages/invalid-multi-match
+ */ function i(e) {
+    let { pathname: t, template: n } = e, l = t.split("/").filter((e)=>!!e), r = n.split("/").filter((e)=>!!e), i = {};
+    return {
+        pathname: "/" + l.map((e)=>{
+            let t = e.endsWith("*"), n = (e = e.replace("*", "")).startsWith("{{") && e.endsWith("}}"), l = n ? e.match(/{{(.+)}}/)?.[1].trim() ?? "" : e.trim(), r = encodeURIComponent(l) + (t ? "*" : "");
+            return i[l] = {
+                isDynamic: n,
+                hasWildcard: t
+            }, n ? `:${r}` : r;
+        }).join("/"),
+        template: "/" + r.map((e)=>{
+            let t = e.startsWith("[") && e.endsWith("]"), n = t ? e.match(/\[(.+)\]/)?.[1].trim() ?? "" : e.trim(), l = i[n]?.hasWildcard, r = encodeURIComponent(n) + (l ? "*" : "");
+            return t ? `:${r}` : r;
+        }).join("/")
+    };
+}
+/**
+ * Get routes map dictionary
+ */ function a(e = {}, t, n = "", l = "") {
+    let r = Object.keys(t).includes("[spa]");
+    for(let i in t){
+        let o = t[i], s = `${l}/${i}`;
+        "string" == typeof o ? (!r || r && [
+            "[spa]",
+            "index"
+        ].includes(i)) && (e[s] = {
+            template: s,
+            pathname: o,
+            wildcard: o.includes("*")
+        }) : r || a(e, o, n, s);
+    }
+    return e;
+}
+/**
+ * Removes `/index` from a template/url path
+ */ function o(e) {
+    return e.replace(/\/index$/, "");
+}
+/**
+ * Shared options to generate Next.js `rewrites` and `redirects`
+ */ /**
+   * A JSON file containing the routes definition mapping template folders
+   * to localised slugs. It supports slugs's dynamic portions.
+   * All translated slugs needs to be defined starting from root `/`.
+   * The `require("...json")` file for each locale should look like:
+   *
+   * ```json
+   * {
+   *   "home": "/",
+   *   "products": {
+   *     "list": "/products",
+   *     "[category]": "/products/{{ category }}",
+   *     "[tag]": {
+   *       "view": "/products/{{ category }}/{{ tag }}",
+   *       "related": "/products/{{ category }}/{{ tag }}/related"
+   *     }
+   *   },
+   *   "company": {
+   *     "about": "/about",
+   *     "contact": "/contact"
+   *   }
+   * }
+   * ```
+   *
+   * Here we also account for wildcards, those should only be defined in the
+   * pathname part of the JSON file, e.g.:
+   *
+   * ```json
+   * {
+   *   "category": {
+   *     "[slug]": {
+   *       "[id]": "/categories/{{ slug }}/{{ id }}*"
+   *     }
+   *   }
+   * }
+   * ```
+   * This might be desired when we want to have param-based pagination, e.g. when
+   * we have the following folder structure:
+   *
+   * ```yml
+   * |__/category
+   *    |__/[slug]
+   *      |__/[id]
+   *         |__/[[...page]].tsx
+   * ```
+   *
+   * NB:
+   * When `routes` is used be sure to pass before than the `i18n.defaultLocale`
+   * configuration. That is used for localised routing.
+   */ /**
+ * @deprecated Better use the new `withI18n`
+ */ let withI18nLegacy = (s)=>{
+    let { i18nRoutes: c, ...f } = s;
+    if (!c) return f;
+    // set i18n related defaults grabbing them from basic next config i18n object
+    let { locales: u, defaultLocale: d } = f.i18n || {}, m = objectMergeWithDefaults({
+        locales: u || [
+            "en"
+        ],
+        defaultLocale: d || "en",
+        hideDefaultLocaleInUrl: !0,
+        localeParam: ""
+    }, c), { localeParam: p, locales: h, defaultLocale: y, routes: g } = m, b = {
+        ...f
+    };
+    if (p ? // NOTE: passing the i18n settings with the app router messes up everything
+    // especially while migrating from pages to app router, so opt out from that
+    // and only rely on our i18n implementation
+    delete b.i18n : (f.i18n = f.i18n || {
+        locales: h,
+        defaultLocale: y
+    }, f.i18n.defaultLocale = y, f.i18n.locales = h), g) {
+        let { redirects: t, rewrites: s } = b;
+        b.redirects = async ()=>{
+            let l = function(t) {
+                let { routes: l, defaultLocale: s, hideDefaultLocaleInUrl: c, trailingSlash: f, localeParamName: u, permanentRedirects: d, debug: m } = t, p = {
+                    defaultLocale: s,
+                    hideDefaultLocaleInUrl: c,
+                    trailingSlash: f,
+                    localeParamName: u,
+                    permanentRedirects: d
+                }, h = r(l, s), y = [];
+                for(let e in h){
+                    let t = a({}, l[e]);
+                    for(let l in t){
+                        let { template: r, pathname: a } = i(t[l]);
+                        a !== o(r) && generateRedirectForPathname(p, e, o(r), o(a), y);
+                    }
+                }
+                let g = arrayUniqueByProperties(y.filter(Boolean), [
+                    "source",
+                    "destination"
+                ]).map((e)=>u ? e : {
+                        ...e,
+                        locale: !1
+                    });
+                return m && console.info("[@koine/next/plugin-legacy:generateRedirects]", g), g;
+            }(m);
+            return t ? [
+                ...l,
+                ...await t()
+            ] : l;
+        }, b.rewrites = async ()=>{
+            let t = function(t) {
+                let { routes: n, defaultLocale: s, hideDefaultLocaleInUrl: c, trailingSlash: f, localeParamName: u, debug: d } = t, m = {
+                    defaultLocale: s,
+                    hideDefaultLocaleInUrl: c,
+                    trailingSlash: f,
+                    localeParamName: u
+                }, p = r(n, s), h = [];
+                for(let e in p){
+                    let t = a({}, n[e]);
+                    for(let n in t){
+                        let { template: r, pathname: a } = i(t[n]);
+                        generateRewriteForPathname(m, e, o(r), o(a), h);
+                    }
+                }
+                let y = arrayUniqueByProperties(h.filter(Boolean), [
+                    "source",
+                    "destination"
+                ]);
+                return d && console.info("[@koine/next/plugin-legacy:generateRewrites]", y), y;
+            }(m);
+            if (s) {
+                let e = await s();
+                return Array.isArray(e) ? {
+                    beforeFiles: t,
+                    afterFiles: e,
+                    fallback: []
+                } : {
+                    ...e,
+                    beforeFiles: [
+                        ...t,
+                        ...e.beforeFiles || []
+                    ]
+                };
+            }
+            return {
+                beforeFiles: t,
+                afterFiles: [],
+                fallback: []
+            };
+        };
+    }
+    return b;
+};
+
+let tweakNextConfig = (t, r)=>{
+    let { config: { defaultLocale: o, locales: i }, code: { options: { routes: { localeParamName: s } } } } = t;
+    return s ? // NOTE: passing the i18n settings with the app router messes up everything
+    // especially while migrating from pages to app router, so opt out from that
+    // and only rely on our i18n implementation
+    delete r.i18n : (r.i18n = r.i18n || {
+        locales: i,
+        defaultLocale: o
+    }, r.i18n.locales = i, r.i18n.defaultLocale = o), r.webpack = (t)=>(// @see https://github.com/date-fns/date-fns/blob/main/docs/webpack.md#removing-unused-languages-from-dynamic-import
+        t.plugins.push(new ContextReplacementPlugin(/^date-fns[/\\]locale$/, RegExp(`\\.[/\\\\](${i.join("|")})[/\\\\]index\\.js$`))), t), r;
+};
+let getRedirects = async (e, r)=>{
+    let o = generateRedirects(r.config, r.code.options.routes, r.code.routes.byId);
+    return e ? [
+        ...o,
+        ...await e()
+    ] : o;
+};
+let getRewrites = async (e, t)=>{
+    let o = generateRewrites(t.config, t.code.options.routes, t.code.routes.byId);
+    if (e) {
+        let t = await e();
+        return Array.isArray(t) ? {
+            beforeFiles: o,
+            afterFiles: t,
+            fallback: []
+        } : {
+            ...t,
+            beforeFiles: [
+                ...o,
+                ...t.beforeFiles || []
+            ]
+        };
+    }
+    return {
+        beforeFiles: o,
+        afterFiles: [],
+        fallback: []
+    };
+};
+
+/**
+ * See [`withNx`](https://github.com/nrwl/nx/blob/master/packages/next/plugins/with-nx.ts#L216)
+ * next plugin for inspiration on how to structure our async compiler task
+ *
+ * About next.config phases see https://github.com/vercel/next.js/discussions/48736
+ */ let withI18nAsync = (n = {})=>async ()=>/* phase: string */ {
+        let { i18nCompiler: a, redirects: o, rewrites: l, ...p } = n, s = p;
+        // const { PHASE_PRODUCTION_BUILD, PHASE_DEVELOPMENT_SERVER } = await import(
+        //   "next/constants"
+        // );
+        // // bail if we are not building or running the dev server
+        // if (![PHASE_PRODUCTION_BUILD, PHASE_DEVELOPMENT_SERVER].includes(phase)) {
+        //   return nextConfig;
+        // }
+        // bail if user has not defined the compiler options object
+        if (!a) return s;
+        let m = await i18nCompiler(a);
+        (s = tweakNextConfig(m, s)).redirects = ()=>getRedirects(o, m), s.rewrites = ()=>getRewrites(l, m);
+        let { code: { options: { adapter: c } } } = m;
+        if ("next-translate" === c.name && // const options = i18nConfig.code.adapter.options;
+        !1 !== c.options.loader) try {
+            s = (await import('next-translate-plugin').then((t)=>t.default))(s);
+        } // TODO: verify this:
+        // when using the locale param name structure just force to opt-out from
+        // next.js built in i18n support for pages router, this should also
+        // ease the cohexistence of pages and app router
+        // if (i18nResult.code.options.routes.localeParamName) {
+        //   delete nextConfig.i18n;
+        // }
+        catch (t) {}
+        // console.log()
+        return s;
+    };
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore problem with cjs output
+let l = createRequire(import.meta.url);
+let withI18n = (e = {})=>{
+    let { i18nCompiler: n, redirects: m, rewrites: a, ...p } = e, s = p;
+    // bail if user has not defined the compiler options object
+    if (!n) return s;
+    let c = i18nCompilerSync(n);
+    (s = tweakNextConfig(c, s)).redirects = ()=>getRedirects(m, c), s.rewrites = ()=>getRewrites(a, c);
+    let { code: { options: { adapter: d } } } = c;
+    if ("next-translate" === d.name && !1 !== d.options.loader) try {
+        s = l("next-translate-plugin")(s), // TODO: verify this:
+        // when using the locale param name structure just force to opt-out from
+        // next.js built in i18n support for pages router, this should also
+        // ease the cohexistence of pages and app router
+        c.code.options.routes.localeParamName && delete s.i18n;
+    } catch (e) {}
+    // console.log()
+    return s;
+}; // import { I18nWebpackPlugin } from "./webpackPluginI18n";
+ // TODO: move to next-translate adapter?
+ // return withTranslate(newNextConfig);
+ // nextConfig.webpack = (webpackConfig) => {
+ //   // nextConfig.webpack = (_config, options) => {
+ //   //   const webpackConfig =
+ //   //     typeof nextConfig.webpack === "function"
+ //   //       ? nextConfig.webpack(_config, options)
+ //   //       : _config;
+ //   webpackConfig.plugins.push(new I18nWebpackPlugin(config));
+ //   return webpackConfig;
+ // };
+
+export { withI18n, withI18nAsync, withI18nLegacy };

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@koine/i18n",
+  "sideEffects": false,
+  "dependencies": {
+    "@koine/node": "2.0.0-beta.100",
+    "@koine/utils": "2.0.0-beta.100",
+    "glob": "^10.3.10",
+    "webpack": "^5.90.1",
+    "minimatch": "^9.0.3",
+    "synckit": "^0.9.0",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "next": "^14.0.4",
+    "next-translate-plugin": "^2.6.2"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    },
+    "next-translate": {
+      "optional": true
+    },
+    "next-translate-plugin": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    },
+    "./compiler": {
+      "module": "./compiler.esm.js",
+      "import": "./compiler.cjs.mjs",
+      "default": "./compiler.cjs.js"
+    },
+    "./compiler-sync": {
+      "module": "./compiler-sync.esm.js",
+      "import": "./compiler-sync.cjs.mjs",
+      "default": "./compiler-sync.cjs.js"
+    },
+    "./compiler-worker": {
+      "module": "./compiler-worker.esm.js",
+      "import": "./compiler-worker.cjs.mjs",
+      "default": "./compiler-worker.cjs.js"
+    },
+    "./next": {
+      "module": "./next.esm.js",
+      "import": "./next.cjs.mjs",
+      "default": "./next.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "version": "2.0.0-beta.100"
+}

package/types.d.ts

@@ -0,0 +1,48 @@
+import type { JsonObject, Split } from "@koine/utils";
+export declare namespace I18nUtils {
+    export type Join<A, Sep extends string = "", R extends string = ""> = A extends [infer First, ...infer Rest] ? Join<Rest, Sep, R extends "" ? `${First & string}` : `${R}${Sep}${First & string}`> : R;
+    export type BuildRecursiveJoin<TList, TSeparator extends string> = Exclude<TList extends [...infer ButLast, unknown] ? Join<ButLast, TSeparator> | BuildRecursiveJoin<ButLast, TSeparator> : never, "">;
+    type JoinObjectPath<S1, S2> = S1 extends string ? S2 extends string ? `${S1}.${S2}` : S1 : never;
+    type GetWithPath<BaseType, Keys extends readonly string[]> = Keys extends [] ? BaseType : Keys extends readonly [infer Head, ...infer Tail] ? GetWithPath<Head extends keyof BaseType ? BaseType[Head] : unknown, Extract<Tail, string[]>> : never;
+    export type Get<BaseType, Path extends string | readonly string[]> = GetWithPath<BaseType, Path extends string ? Split<Path, "."> : Path>;
+    export type Paths<T, TAsObj extends boolean = true> = {
+        [K in Extract<keyof T, string>]: T[K] extends Record<string, never> | never[] | "" ? never : T[K] extends Record<string, unknown> ? (TAsObj extends true ? `${K}` : never) | JoinObjectPath<K, Paths<T[K], TAsObj>> : T[K] extends string | number | boolean | Array<string | number | boolean | object> ? `${K}` : never;
+    }[Extract<keyof T, string>] extends infer O ? O : never;
+    export type AllPaths<TDictionary extends JsonObject> = {
+        [N in Extract<keyof TDictionary, string>]: {
+            [K in Extract<keyof TDictionary[N], string>]: TDictionary[N][K] extends Record<string, never> | never[] | "" ? never : TDictionary[N][K] extends Record<string, unknown> ? `${N}:${K}` | JoinObjectPath<K extends string ? `${N}:${K}` : `${N}:`, Paths<TDictionary[N][K]>> : TDictionary[N][K] extends string | number | boolean | Array<string | number | boolean | object> ? `${N}:${K}` : never;
+        }[Extract<keyof TDictionary[N], string>];
+    }[Extract<keyof TDictionary, string>] extends infer O ? O : never;
+    type Whitespace = `\u{20}`;
+    type TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;
+    type TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;
+    type Trim<V extends string> = TrimLeft<TrimRight<V>>;
+    type WithDynamicPortion<F extends string, D extends GenericDelimiters> = `${string}${F}${D["start"]}${string}${D["end"]}${F}${string}` | `${string}${F}${D["start"]}${string}${D["end"]}` | `${D["start"]}${string}${D["end"]}${F}${string}` | `${D["start"]}${string}${D["end"]}`;
+    type FilterOnlyStaticRouteId<T extends string, F extends string, D extends GenericDelimiters> = T extends WithDynamicPortion<F, D> ? never : T;
+    type FilterOnlyDynamicRouteId<T extends string, F extends string, D extends GenericDelimiters> = T extends WithDynamicPortion<F, D> ? T : never;
+    type InferredSeparator<T extends string> = T extends `${string}.${string}` ? "." : T extends `${string}/${string}` ? "/" : never;
+    type GenericDelimiters = {
+        start: string;
+        end: string;
+    };
+    type WithDelimitedString<Start extends string, End extends string> = `${string}${Start}${string}${End}${string}` | `${string}${Start}${string}${End}` | `${Start}${string}${End}${string}` | `${Start}${string}${End}`;
+    type InferredDelimiters<T extends string> = T extends WithDelimitedString<"[", "]"> ? {
+        start: "[";
+        end: "]";
+    } : T extends WithDelimitedString<"{{", "}}"> ? {
+        start: "{{";
+        end: "}}";
+    } : T extends WithDelimitedString<"{", "}"> ? {
+        start: "{";
+        end: "}";
+    } : never;
+    export type DynamicParams<T extends string, Separator extends string = InferredSeparator<T>, Delimiters extends GenericDelimiters = InferredDelimiters<T>> = string extends T ? Record<string, string> : T extends `${string}${Delimiters["start"]}${infer Param}${Delimiters["end"]}${Separator}${infer Rest}` ? {
+        [k in Trim<Param> | keyof DynamicParams<Rest>]: string | number;
+    } : T extends `${string}${Delimiters["start"]}${infer Param}${Delimiters["end"]}` ? {
+        [k in Trim<Param>]: string | number;
+    } : {};
+    export type RouteStrictIdStatic<T extends string> = FilterOnlyStaticRouteId<T, InferredSeparator<T>, InferredDelimiters<T>>;
+    export type RouteStrictIdDynamic<T extends string> = FilterOnlyDynamicRouteId<T, InferredSeparator<T>, InferredDelimiters<T>>;
+    export type RouteStrictId<T extends string> = RouteStrictIdStatic<T> | RouteStrictIdDynamic<T>;
+    export {};
+}