@koine/i18n 2.0.0-beta.72 → 2.0.0-beta.73

package/adapter-js/code/config.cjs.js

@@ -0,0 +1,14 @@
+export default ({ config }) => `
+const { locales } = require("./locales");
+const { defaultLocale } = require("./defaultLocale");
+
+const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${config.hideDefaultLocaleInUrl},
+};
+
+exports.config = config;
+
+module.exports = config;
+`;

package/adapter-js/code/config.js

@@ -0,0 +1,14 @@
+export default ({ config }) => `
+import { locales } from "./locales";
+import { defaultLocale } from "./defaultLocale";
+
+/**
+ */
+export const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${config.hideDefaultLocaleInUrl},
+}
+
+export default config;
+`;

package/adapter-js/code/defaultLocale.js

@@ -0,0 +1,7 @@
+export default ({ config }) => `
+import type { I18n } from "./types";
+
+export const defaultLocale: I18n.Locale = "${config.defaultLocale}";
+
+export default defaultLocale;
+`;

package/adapter-js/code/deriveLocalisedPathnames.js

@@ -0,0 +1,78 @@
+export default () => `
+import { locales } from "./locales";
+import { to } from "./to";
+import type { I18n } from "./types";
+
+function getPathnameDynamicPortionName(pathname: string) {
+  const res = pathname.match(/\\[(.+)\\]/);
+  return res ? res[1] : false;
+}
+
+function isStaticPathname(pathname: string) {
+  return !/\\[/.test(pathname);
+}
+
+// e.g. ['my', 'path', 'id', 'view'] or ['nl' 'my', 'path', 'id', 'view']
+// where the first might be the locale (depending on hideDefaultLocaleInUrl)
+function getPathnameParts(pathname: string) {
+  return pathname
+    .split("/")
+    .slice(1)
+    .filter((p, i) => (i === 0 ? !locales.includes(p as I18n.Locale) : true));
+}
+
+function localisePathname(
+  locale: I18n.Locale,
+  // e.g. "my.path.[id].view"
+  routeId: I18n.RouteIdDynamic | I18n.RouteIdStatic,
+  locationLike: LocationLike
+) {
+  const toPathname = to(routeId as I18n.RouteIdStatic, locale);
+
+  if (isStaticPathname(toPathname)) {
+    return toPathname;
+  }
+  // e.g. ['my', 'path', '[id]', 'view']
+  const toPathnameParts = getPathnameParts(toPathname);
+  // e.g. "my.path.[id].view"
+  const routeIdDynamic = routeId as I18n.RouteIdDynamic;
+  // e.g. /my/path/123/view
+  const currentPathname = locationLike.pathname;
+  // e.g. ['my', 'path', '123', 'view']
+  const currentPathnameParts = getPathnameParts(currentPathname);
+  // e.g. { id: "123" }
+  const params: Record<string, string> = {};
+
+  for (let i = 0; i < toPathnameParts.length; i++) {
+    // e.g. "my" or "[id]"
+    const part = toPathnameParts[i];
+    // e.g. "id"
+    const name = getPathnameDynamicPortionName(part);
+    if (name) {
+      // e.g. "123"
+      const value = currentPathnameParts[i];
+      if (value) {
+        params[name] = value;
+      }
+    }
+  }
+
+  return (
+    to(routeIdDynamic, params as never, locale) +
+    location?.search || "" +
+    location?.hash || ""
+  );
+}
+
+type LocationLike = { pathname: string; search?: string; hash?: string; };
+
+export type LocalisedPathnames = Record<I18n.Locale, string>;
+
+export const deriveLocalisedPathnames = (routeId: I18n.RouteId, locationLike: LocationLike) =>
+  locales.reduce((pathnames, locale) => {
+    pathnames[locale] = localisePathname(locale, routeId, locationLike);
+    return pathnames;
+  }, {} as LocalisedPathnames);
+
+export default deriveLocalisedPathnames;
+`;

package/adapter-js/code/index.js

@@ -0,0 +1,57 @@
+import config from "./config";
+import configCjs from "./config.cjs";
+import defaultLocale from "./defaultLocale";
+import deriveLocalisedPathnames from "./deriveLocalisedPathnames";
+import isLocale from "./isLocale";
+import locales from "./locales";
+import pathnameToRouteId from "./pathnameToRouteId";
+import routes from "./routes";
+import routesSlim from "./routesSlim";
+import routesSpa from "./routesSpa";
+import tFns from "./tFns";
+import tInterpolateParams from "./tInterpolateParams";
+import tPluralise from "./tPluralise";
+import to from "./to";
+import toFns from "./toFns";
+import toFormat from "./toFormat";
+import toSpa from "./toSpa";
+import types from "./types";
+const adapter = () => {
+    return {
+        files: [
+            { name: "config.cjs", fn: configCjs, ext: "js" },
+            { name: "config", fn: config, ext: "ts", index: true },
+            { name: "defaultLocale", fn: defaultLocale, ext: "ts", index: true },
+            {
+                name: "deriveLocalisedPathnames",
+                fn: deriveLocalisedPathnames,
+                ext: "ts",
+                index: true,
+            },
+            { name: "isLocale", fn: isLocale, ext: "ts", index: true },
+            { name: "locales", fn: locales, ext: "ts", index: true },
+            {
+                name: "pathnameToRouteId",
+                fn: pathnameToRouteId,
+                ext: "ts",
+                index: true,
+            },
+            { name: "routes", fn: routes, ext: "ts" },
+            { name: "routesSlim", fn: routesSlim, ext: "ts" },
+            { name: "routesSpa", fn: routesSpa, ext: "ts" },
+            { name: "tFns", fn: tFns, ext: "ts" },
+            {
+                name: "tInterpolateParams",
+                fn: tInterpolateParams,
+                ext: "ts",
+            },
+            { name: "to", fn: to, ext: "ts", index: true },
+            { name: "toFns", fn: toFns, ext: "ts", index: true },
+            { name: "toFormat", fn: toFormat, ext: "ts", index: true },
+            { name: "toSpa", fn: toSpa, ext: "ts", index: true },
+            { name: "tPluralise", fn: tPluralise, ext: "ts" },
+            { name: "types", fn: types, ext: "ts", index: true },
+        ],
+    };
+};
+export default adapter;

package/adapter-js/code/isLocale.js

@@ -0,0 +1,9 @@
+export default () => `
+import { locales } from "./locales";
+import type { I18n } from "./types";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isLocale = (payload: any): payload is I18n.Locale => locales.includes(payload);
+
+export default isLocale;
+`;

package/adapter-js/code/locales.js

@@ -0,0 +1,8 @@
+export default ({ config }) => {
+    const value = `[${config.locales.map((l) => `"${l}"`).join(", ")}]`;
+    return `
+export const locales = ${value} as const;
+
+export default locales;
+`;
+};

package/adapter-js/code/pathnameToRouteId.js

@@ -0,0 +1,20 @@
+import { escapeRegExp } from "@koine/utils";
+export default ({ options }) => {
+    const { idDelimiter, optionalCatchAll, catchAll } = options.routes.tokens;
+    return `
+/**
+ * Convert a URL like pathname to a "named route"
+ * E.g. it transforms:
+ * - \`/dashboard/user/[id]\` into \`dashboard.user.[id]\`
+ */
+export const pathnameToRouteId = (pathname: string) =>
+  pathname
+    .replace(/^\\//g, "")
+    .replace(/\\//g, "${idDelimiter}")
+    .replace(/${escapeRegExp(idDelimiter)}${escapeRegExp(optionalCatchAll.start)}.+$/, "")
+    .replace(/${escapeRegExp(idDelimiter)}${escapeRegExp(catchAll.start)}.+$/, "")
+    .replace(/\\/index$/, "");
+
+export default pathnameToRouteId;
+`;
+};

package/adapter-js/code/routes.js

@@ -0,0 +1,10 @@
+export default ({ routes }) => {
+    const value = JSON.stringify(Object.fromEntries(Object.entries(routes.byId)
+        .map(([routeId, { pathnames }]) => [routeId, pathnames])
+        .sort()), null, 2);
+    return `
+export const routes = ${value} as const;
+
+export default routes;
+`;
+};

package/adapter-js/code/routesSlim.js

@@ -0,0 +1,13 @@
+export default ({ routes }) => {
+    const value = JSON.stringify(Object.fromEntries(Object.entries(routes.byId)
+        .map(([routeId, { pathnamesSlim, pathnames }]) => [
+        routeId,
+        pathnamesSlim || pathnames,
+    ])
+        .sort()), null, 2);
+    return `
+export const routesSlim = ${value} as const;
+
+export default routesSlim;
+`;
+};

package/adapter-js/code/routesSpa.js

@@ -0,0 +1,11 @@
+export default ({ routes }) => {
+    const value = JSON.stringify(Object.fromEntries(Object.entries(routes.byId)
+        .filter(([, { pathnamesSpa }]) => !!pathnamesSpa)
+        .map(([routeId, { pathnamesSpa }]) => [routeId, pathnamesSpa])
+        .sort()), null, 2);
+    return `
+export const routesSpa = ${value} as const;
+
+export default routesSpa;
+`;
+};

package/adapter-js/code/tFns.js

@@ -0,0 +1,75 @@
+import { areEqual, isArray, isBoolean, isNumber, isPrimitive, isString, } from "@koine/utils";
+import { dataParamsToTsInterfaceBody } from "../../compiler/helpers";
+const getTranslationValueOutput = (value) => {
+    if (isString(value) || isNumber(value)) {
+        return `"${value}"`;
+    }
+    else if (isBoolean(value)) {
+        return `${value}`;
+    }
+    else if (isArray(value)) {
+        return JSON.stringify(value);
+    }
+    return `(${JSON.stringify(value)})`;
+};
+const areEqualTranslationsValues = (a, b) => areEqual(a, b);
+const getFunctionBodyWithLocales = (config, perLocaleValues) => {
+    const { defaultLocale } = config;
+    let output = "";
+    for (const locale in perLocaleValues) {
+        const value = perLocaleValues[locale];
+        if (locale !== defaultLocale &&
+            !areEqualTranslationsValues(value, perLocaleValues[defaultLocale])) {
+            output += `locale === "${locale}" ? ${getTranslationValueOutput(value)} : `;
+        }
+    }
+    output += getTranslationValueOutput(perLocaleValues[defaultLocale]);
+    return output;
+};
+export default ({ config, options, translations }) => {
+    let output = `
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-const */
+import type { I18n } from "./types";
+import { tInterpolateParams } from "./tInterpolateParams";
+import { tPluralise } from "./tPluralise";
+
+`;
+    for (const translationId in translations) {
+        let { values, params, plural } = translations[translationId];
+        const name = `${options.translations.fnsPrefix}${translationId}`;
+        if (plural) {
+            if (params) {
+                params["count"] = "number";
+            }
+            else {
+                params = { count: "number" };
+            }
+        }
+        const argParam = params
+            ? `params: { ${dataParamsToTsInterfaceBody(params)} }`
+            : "";
+        const argLocale = "locale?: I18n.Locale";
+        const args = [argParam, argLocale].filter(Boolean).join(", ");
+        output += `export let ${name} = (${args}) => `;
+        let outputFnReturn = "";
+        if (isPrimitive(values)) {
+            outputFnReturn += getTranslationValueOutput(values);
+        }
+        else {
+            outputFnReturn += getFunctionBodyWithLocales(config, values);
+        }
+        if (plural) {
+            outputFnReturn = `tPluralise(${outputFnReturn}, params.count)`;
+        }
+        if (params) {
+            outputFnReturn = `tInterpolateParams(${outputFnReturn}, params);`;
+        }
+        else {
+            outputFnReturn = `${outputFnReturn};`;
+        }
+        output += outputFnReturn;
+        output += `\n`;
+    }
+    return output;
+};

package/adapter-js/code/tInterpolateParams.js

@@ -0,0 +1,21 @@
+const escapeEachChar = (input) => input
+    .split("")
+    .map((v) => `\\${v}`)
+    .join("");
+export default ({ options }) => {
+    const { start, end } = options.translations.dynamicDelimiters;
+    return `
+/* eslint-disable prefer-const */
+export let tInterpolateParams = (
+  value: string,
+  params?: object,
+) =>
+  params ? value.replace(
+    /${escapeEachChar(start)}(.*?)${escapeEachChar(end)}/g,
+    (_, key) =>
+      params[key.trim() as keyof typeof params] + "",
+  ) : value;
+
+export default tInterpolateParams;
+`;
+};

package/adapter-js/code/tPluralise.js

@@ -0,0 +1,12 @@
+export default () => {
+    return `
+/* eslint-disable prefer-const */
+let pluralRules = new Intl.PluralRules();
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export let tPluralise = (values: any, count: number) =>
+  values[count] || values[pluralRules.select(count)] || (count === 0 ? values.zero : values["other"]);
+
+export default tPluralise;
+`;
+};

package/adapter-js/code/to.js

@@ -0,0 +1,32 @@
+export default ({ config }) => `
+import { isLocale } from "./isLocale";
+import { toFormat } from "./toFormat";
+import { routesSlim } from "./routesSlim";
+import type { I18n } from "./types";
+
+/**
+ * *To* route utility
+ * 
+ * @returns A localised relative URL based on your i18nCompiler configuration
+ */
+export function to<Id extends I18n.RouteId>(
+  id: Id,
+  ...args: Id extends I18n.RouteIdDynamic
+    ?
+        | [I18n.RouteParams[Id]]
+        | [I18n.RouteParams[Id], I18n.Locale]
+    : [] | [I18n.Locale]
+) {
+  const locale = (isLocale(args[0]) ? args[0] : args[1]) || "${config.defaultLocale}";
+
+  return toFormat(
+    locale,
+    (routesSlim[id] as Record<string, string>)[locale] ??
+      (routesSlim[id] as Record<string, string>)["${config.defaultLocale}"] ??
+      routesSlim[id],
+    isLocale(args[0]) ? undefined : args[0]
+  ) as I18n.RoutePathnames[Id];
+}
+
+export default to;
+`;

package/adapter-js/code/toFns.js

@@ -0,0 +1,41 @@
+import { changeCaseSnake, isString } from "@koine/utils";
+const getFunctionBodyWithLocales = (config, perLocaleValues) => {
+    const { defaultLocale } = config;
+    let output = "";
+    for (const locale in perLocaleValues) {
+        const value = perLocaleValues[locale];
+        if (locale !== defaultLocale && value !== perLocaleValues[defaultLocale]) {
+            output += `locale === "${locale}" ? "${value}" : `;
+        }
+    }
+    output += '"' + perLocaleValues[defaultLocale] + '"';
+    return output;
+};
+export default ({ config, routes, options }) => {
+    const hasOneLocale = config.locales.length === 1;
+    let output = `
+/* eslint-disable prefer-const */
+import { toFormat } from "./toFormat";
+import type { I18n } from "./types";
+
+`;
+    for (const routeId in routes.byId) {
+        const { pathnames, params } = routes.byId[routeId];
+        const name = `${options.routes.fnsPrefix}${changeCaseSnake(routeId)}`;
+        const paramsType = `I18n.RouteParams["${routeId}"]`;
+        const argParam = params ? `params: ${paramsType}` : "";
+        const argLocale = hasOneLocale ? "" : "locale?: I18n.Locale";
+        const args = [argParam, argLocale].filter(Boolean).join(", ");
+        const formatArgLocale = hasOneLocale ? `""` : "locale";
+        const formatArgParams = params ? ", params" : "";
+        output += `export let ${name} = (${args}) => `;
+        if (isString(pathnames)) {
+            output += `toFormat(${formatArgLocale}, "${pathnames}"${formatArgParams});`;
+        }
+        else {
+            output += `toFormat(${formatArgLocale}, ${getFunctionBodyWithLocales(config, pathnames)}${formatArgParams});`;
+        }
+        output += `\n`;
+    }
+    return output;
+};

package/adapter-js/code/toFormat.js

@@ -0,0 +1,58 @@
+export default ({ config }) => `
+export function toFormat(
+  locale: string | undefined,
+  pathname: string,
+  params?: object,
+) {
+  locale = locale || "${config.defaultLocale}";
+  if (process.env["NODE_ENV"] === "development") {
+    if (params) {
+      pathname.replace(/\\[(.*?)\\]/g, (_, dynamicKey) => {
+        const key = dynamicKey as Extract<keyof typeof params, string>;
+
+        if (!(key in params)) {
+          console.warn(
+            "[@koine/i18n]::interpolateTo, using '" +
+              pathname +
+              "' without param '" +
+              key +
+              "'",
+              { params }
+          );
+        }
+
+        if (!["string", "number"].includes(typeof params[key])) {
+          console.warn(
+            "[@koine/i18n]::toFormat, using '" +
+              pathname +
+              "' with unserializable param  '" +
+              key +
+              "' (type '" +
+              Object.prototype.toString.call((params[key])).slice(8, -1) +
+              "')",
+          );
+        }
+        return "";
+      });
+    }
+  }
+
+  if (params) {
+    pathname = pathname.replace(
+        /\\[(.*?)\\]/g,
+        (_, key) =>
+          params[key as keyof typeof params] + "",
+      )
+  }
+  ${config.hideDefaultLocaleInUrl
+    ? `
+  if (locale !== "${config.defaultLocale}") {
+    return "/" + locale + pathname;
+  }
+  `
+    : ``}
+  return pathname;
+}
+
+export default toFormat;
+`;

package/adapter-js/code/toSpa.js

@@ -0,0 +1,42 @@
+export default ({ config, options }) => {
+    const { idDelimiter } = options.routes.tokens;
+    return `
+import { isLocale } from "./isLocale";
+import { routesSpa } from "./routesSpa";
+import { toFormat } from "./toFormat";
+import type { I18n } from "./types";
+
+/**
+ * *To spa* route utility
+ *
+ * @returns A localised relative URL based on your i18nCompiler configuration
+ */
+export function toSpa<
+  Root extends keyof I18n.RouteSpa,
+  Path extends Extract<keyof I18n.RouteSpa[Root], string>,
+>(
+  rootId: Root,
+  pathId: Path,
+  ...args: I18n.RouteJoinedId<Root, Path> extends I18n.RouteIdDynamic
+    ?
+        | [I18n.RouteParams[I18n.RouteJoinedId<Root, Path>]]
+        | [I18n.RouteParams[I18n.RouteJoinedId<Root, Path>], I18n.Locale]
+    : [] | [I18n.Locale]
+) {
+  const locale = (isLocale(args[0]) ? args[0] : args[1]) || "${config.defaultLocale}";
+  const fullId = \`\${rootId}${idDelimiter}\${pathId}\` as I18n.RouteJoinedId<Root, Path>;
+  return toFormat(
+    // FIXME: actually the locale will be prepended if hideDefaultLocaleInUrl will be false
+    "", // do not pass the locale so that won't be prepended
+    (routesSpa[fullId] as Record<string, string>)[locale],
+    args.length === 2
+      ? args[0]
+      : args[0] && !isLocale(args[0])
+        ? args[0]
+        : void 0,
+  ) as I18n.RouteSpa[Root][Path];
+}
+
+export default toSpa;
+`;
+};