@koine/i18n 2.0.0-beta.124 → 2.0.0-beta.126

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

@@ -0,0 +1,70 @@
+'use strict';
+
+var createAdapter = require('../../compiler/createAdapter.cjs.js');
+
+var o = createAdapter.createGenerator("js", (e)=>{
+    let { config: o } = e, l = `[${o.locales.map((e)=>`"${e}"`).join(", ")}]`;
+    return {
+        locales: {
+            name: "locales",
+            ext: "ts",
+            index: !0,
+            content: ()=>/* js */ `
+export const locales = ${l} as const;
+
+export default locales;
+`
+        },
+        defaultLocale: {
+            name: "defaultLocale",
+            ext: "ts",
+            index: !0,
+            content: ()=>/* js */ `
+import type { I18n } from "./types";
+
+export const defaultLocale: I18n.Locale = "${o.defaultLocale}";
+
+export default defaultLocale;
+`
+        },
+        config: {
+            name: "config",
+            ext: "ts",
+            index: !0,
+            content: ()=>/* js */ `
+import { locales } from "./locales";
+import { defaultLocale } from "./defaultLocale";
+
+/**
+ */
+export const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${o.hideDefaultLocaleInUrl},
+}
+
+export default config;
+`
+        },
+        configCjs: {
+            name: "config.cjs",
+            ext: "js",
+            content: ()=>/* js */ `
+const { locales } = require("./locales");
+const { defaultLocale } = require("./defaultLocale");
+
+const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${o.hideDefaultLocaleInUrl},
+};
+
+exports.config = config;
+
+module.exports = config;
+`
+        }
+    };
+});
+
+module.exports = o;

package/adapter-js/generators/config.esm.js

@@ -0,0 +1,68 @@
+import { createGenerator } from '../../compiler/createAdapter.esm.js';
+
+var o = createGenerator("js", (e)=>{
+    let { config: o } = e, l = `[${o.locales.map((e)=>`"${e}"`).join(", ")}]`;
+    return {
+        locales: {
+            name: "locales",
+            ext: "ts",
+            index: !0,
+            content: ()=>/* js */ `
+export const locales = ${l} as const;
+
+export default locales;
+`
+        },
+        defaultLocale: {
+            name: "defaultLocale",
+            ext: "ts",
+            index: !0,
+            content: ()=>/* js */ `
+import type { I18n } from "./types";
+
+export const defaultLocale: I18n.Locale = "${o.defaultLocale}";
+
+export default defaultLocale;
+`
+        },
+        config: {
+            name: "config",
+            ext: "ts",
+            index: !0,
+            content: ()=>/* js */ `
+import { locales } from "./locales";
+import { defaultLocale } from "./defaultLocale";
+
+/**
+ */
+export const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${o.hideDefaultLocaleInUrl},
+}
+
+export default config;
+`
+        },
+        configCjs: {
+            name: "config.cjs",
+            ext: "js",
+            content: ()=>/* js */ `
+const { locales } = require("./locales");
+const { defaultLocale } = require("./defaultLocale");
+
+const config = {
+  locales,
+  defaultLocale,
+  hideDefaultLocaleInUrl: ${o.hideDefaultLocaleInUrl},
+};
+
+exports.config = config;
+
+module.exports = config;
+`
+        }
+    };
+});
+
+export { o as default };

package/adapter-js/generators/createT.cjs.js

@@ -0,0 +1,201 @@
+'use strict';
+
+var createAdapter = require('../../compiler/createAdapter.cjs.js');
+var helpers = require('../../compiler/helpers.cjs.js');
+
+var t = createAdapter.createGenerator("js", (e)=>{
+    let { options: n } = e, { start: r, end: a } = n.translations.tokens.dynamicDelimiters;
+    return {
+        createT: {
+            name: "createT",
+            ext: "ts",
+            index: !0,
+            content: ()=>/* js */ `
+import type { I18n } from "./types";
+import { defaultLocale } from "./defaultLocale";
+import { tInterpolateParams } from "./tInterpolateParams";
+
+// An optional parameter allowEmptyStrings - true as default.
+// If allowEmptyStrings parameter is marked as false,
+// it should log an error when an empty string is attempted to be translated
+// and return the namespace and key as result of the translation.
+const allowEmptyStrings = true;
+
+/**
+ * @see https://github.com/aralroca/next-translate/blob/master/src/transCore.tsx
+ */
+export function createT<TNamespace extends I18n.TranslateNamespace>(
+  dictionaries: I18n.Dictionaries,
+  pluralRules: Intl.PluralRules,
+  locale: string = defaultLocale,
+) {
+  const interpolateUnknown = (
+    value: unknown,
+    query?: I18n.TranslationQuery | null,
+  ): typeof value => {
+    if (Array.isArray(value)) {
+      return value.map((val) => interpolateUnknown(val, query));
+    }
+    if (value instanceof Object) {
+      return objectInterpolation(
+        value as Record<string, unknown>,
+        query,
+        locale,
+      );
+    }
+    return interpolation(value as string, query, locale);
+  };
+
+  return <
+    TPath extends I18n.TranslationsAllPaths,
+    TReturn = I18n.TranslationAtPath<TPath>,
+  >(
+    path: TPath,
+    query?: I18n.TranslationQuery,
+    options?: I18n.TranslationOptions,
+  ): TReturn => {
+    const [namespace, key] = path.split("${n.translations.tokens.namespaceDelimiter}");
+    const dic = (namespace && dictionaries[namespace]) || {};
+    const pluralisedKey = getPluralisedKey(pluralRules, dic, key, query, options);
+    const dicValue = getDicValue(dic, pluralisedKey, query, options);
+    const value =
+      typeof dicValue === "object"
+        ? JSON.parse(JSON.stringify(dicValue))
+        : dicValue;
+
+    const empty =
+      typeof value === "undefined" ||
+      (typeof value === "object" && !Object.keys(value).length) ||
+      (value === "" && !allowEmptyStrings);
+
+    // no need to try interpolation
+    if (empty) {
+      return (query === "" ? "" : path) as unknown as TReturn;
+    }
+
+    // this can return an empty string if either value was already empty
+    // or it contained only an interpolation (e.g. "{{name}}") and the query param was empty
+    return interpolateUnknown(value, query) as TReturn;
+  };
+}
+
+// const Empty = new Symbol("Empty tranlsation message")
+
+/**
+ * Get value from key (allow nested keys as parent.children)
+ */
+function getDicValue(
+  dic: I18n.TranslationsDictionaryLoose,
+  key: string = "",
+  query?: I18n.TranslationQuery,
+  options?: I18n.TranslationOptions,
+): unknown | undefined {
+  const keySeparator = ".";
+  const keyParts = keySeparator ? key.split(keySeparator) : [key];
+  const returnObjects =
+    query === "obj" ||
+    options === "obj" ||
+    (options instanceof Object && options.returnObjects);
+
+  if (key === keySeparator && returnObjects) return dic;
+
+  const value: string | object = keyParts.reduce(
+    (val: I18n.TranslationsDictionaryLoose | string, key: string) => {
+      if (typeof val === "string") {
+        return {};
+      }
+
+      const res = val[key as keyof typeof val];
+
+      // pass all truthy values or (empty) strings
+      return res || (typeof res === "string" ? res : {});
+    },
+    dic,
+  );
+
+  if (
+    typeof value === "string" ||
+    (returnObjects && Object.keys(value).length > 0)
+  ) {
+    return value;
+  }
+
+  if (Array.isArray(value) && returnObjects) return value;
+  return undefined;
+}
+
+/**
+ * Control plural keys depending the {{count}} variable
+ */
+function getPluralisedKey(
+  pluralRules: Intl.PluralRules,
+  dic: I18n.TranslationsDictionaryLoose,
+  key: string,
+  query?: I18n.TranslationQuery | null,
+  options?: I18n.TranslationOptions,
+): string {
+  const count = query instanceof Object ? query["count"] : null;
+
+  if (!query || typeof count !== "number") return key;
+
+  const numKey = \`\${key}_\${count}\`;
+  if (getDicValue(dic, numKey, query, options) !== undefined) return numKey;
+
+  const pluralKey = \`\${key}_\${pluralRules.select(count)}\`;
+  if (getDicValue(dic, pluralKey, query, options) !== undefined) {
+    return pluralKey;
+  }
+
+  const nestedNumKey = \`\${key}.\${count}\`;
+  if (getDicValue(dic, nestedNumKey, query, options) !== undefined)
+    return nestedNumKey;
+
+  const nestedKey = \`\${key}.\${pluralRules.select(count)}\`;
+  if (getDicValue(dic, nestedKey, query, options) !== undefined)
+    return nestedKey;
+
+  return key;
+}
+
+/**
+ * Replace {{variables}} to query values
+ */
+function interpolation(
+  text?: string,
+  query?: I18n.TranslationQuery | null,
+  _locale?: string | undefined,
+): string {
+  if (!text || !query || query === "obj") return text || "";
+
+  return tInterpolateParams(text, query);
+  // return Object.keys(query).reduce((all, key) => {
+  //   const regex = new RegExp(\`${helpers.escapeEachChar(r)}\\s*\${key}(?:[\\s,]+([\\w-]*))?\\s*\$${helpers.escapeEachChar(a)}\`, "gm");
+  //   return all.replace(regex, (_match) => query[key as keyof typeof query] as string);
+  // }, text);
+}
+
+function objectInterpolation(
+  obj: Record<string, string | unknown>,
+  query?: I18n.TranslationQuery | null,
+  locale?: string,
+) {
+  if (!query || Object.keys(query).length === 0) return obj;
+  Object.keys(obj).forEach((key) => {
+    if (obj[key] instanceof Object)
+      objectInterpolation(
+        obj[key] as Record<string, string | unknown>,
+        query,
+        locale,
+      );
+    if (typeof obj[key] === "string")
+      obj[key] = interpolation(obj[key] as string, query, locale);
+  });
+
+  return obj;
+}
+`
+        }
+    };
+});
+
+module.exports = t;

package/adapter-js/generators/createT.esm.js

@@ -0,0 +1,199 @@
+import { createGenerator } from '../../compiler/createAdapter.esm.js';
+import { escapeEachChar } from '../../compiler/helpers.esm.js';
+
+var t = createGenerator("js", (e)=>{
+    let { options: n } = e, { start: r, end: a } = n.translations.tokens.dynamicDelimiters;
+    return {
+        createT: {
+            name: "createT",
+            ext: "ts",
+            index: !0,
+            content: ()=>/* js */ `
+import type { I18n } from "./types";
+import { defaultLocale } from "./defaultLocale";
+import { tInterpolateParams } from "./tInterpolateParams";
+
+// An optional parameter allowEmptyStrings - true as default.
+// If allowEmptyStrings parameter is marked as false,
+// it should log an error when an empty string is attempted to be translated
+// and return the namespace and key as result of the translation.
+const allowEmptyStrings = true;
+
+/**
+ * @see https://github.com/aralroca/next-translate/blob/master/src/transCore.tsx
+ */
+export function createT<TNamespace extends I18n.TranslateNamespace>(
+  dictionaries: I18n.Dictionaries,
+  pluralRules: Intl.PluralRules,
+  locale: string = defaultLocale,
+) {
+  const interpolateUnknown = (
+    value: unknown,
+    query?: I18n.TranslationQuery | null,
+  ): typeof value => {
+    if (Array.isArray(value)) {
+      return value.map((val) => interpolateUnknown(val, query));
+    }
+    if (value instanceof Object) {
+      return objectInterpolation(
+        value as Record<string, unknown>,
+        query,
+        locale,
+      );
+    }
+    return interpolation(value as string, query, locale);
+  };
+
+  return <
+    TPath extends I18n.TranslationsAllPaths,
+    TReturn = I18n.TranslationAtPath<TPath>,
+  >(
+    path: TPath,
+    query?: I18n.TranslationQuery,
+    options?: I18n.TranslationOptions,
+  ): TReturn => {
+    const [namespace, key] = path.split("${n.translations.tokens.namespaceDelimiter}");
+    const dic = (namespace && dictionaries[namespace]) || {};
+    const pluralisedKey = getPluralisedKey(pluralRules, dic, key, query, options);
+    const dicValue = getDicValue(dic, pluralisedKey, query, options);
+    const value =
+      typeof dicValue === "object"
+        ? JSON.parse(JSON.stringify(dicValue))
+        : dicValue;
+
+    const empty =
+      typeof value === "undefined" ||
+      (typeof value === "object" && !Object.keys(value).length) ||
+      (value === "" && !allowEmptyStrings);
+
+    // no need to try interpolation
+    if (empty) {
+      return (query === "" ? "" : path) as unknown as TReturn;
+    }
+
+    // this can return an empty string if either value was already empty
+    // or it contained only an interpolation (e.g. "{{name}}") and the query param was empty
+    return interpolateUnknown(value, query) as TReturn;
+  };
+}
+
+// const Empty = new Symbol("Empty tranlsation message")
+
+/**
+ * Get value from key (allow nested keys as parent.children)
+ */
+function getDicValue(
+  dic: I18n.TranslationsDictionaryLoose,
+  key: string = "",
+  query?: I18n.TranslationQuery,
+  options?: I18n.TranslationOptions,
+): unknown | undefined {
+  const keySeparator = ".";
+  const keyParts = keySeparator ? key.split(keySeparator) : [key];
+  const returnObjects =
+    query === "obj" ||
+    options === "obj" ||
+    (options instanceof Object && options.returnObjects);
+
+  if (key === keySeparator && returnObjects) return dic;
+
+  const value: string | object = keyParts.reduce(
+    (val: I18n.TranslationsDictionaryLoose | string, key: string) => {
+      if (typeof val === "string") {
+        return {};
+      }
+
+      const res = val[key as keyof typeof val];
+
+      // pass all truthy values or (empty) strings
+      return res || (typeof res === "string" ? res : {});
+    },
+    dic,
+  );
+
+  if (
+    typeof value === "string" ||
+    (returnObjects && Object.keys(value).length > 0)
+  ) {
+    return value;
+  }
+
+  if (Array.isArray(value) && returnObjects) return value;
+  return undefined;
+}
+
+/**
+ * Control plural keys depending the {{count}} variable
+ */
+function getPluralisedKey(
+  pluralRules: Intl.PluralRules,
+  dic: I18n.TranslationsDictionaryLoose,
+  key: string,
+  query?: I18n.TranslationQuery | null,
+  options?: I18n.TranslationOptions,
+): string {
+  const count = query instanceof Object ? query["count"] : null;
+
+  if (!query || typeof count !== "number") return key;
+
+  const numKey = \`\${key}_\${count}\`;
+  if (getDicValue(dic, numKey, query, options) !== undefined) return numKey;
+
+  const pluralKey = \`\${key}_\${pluralRules.select(count)}\`;
+  if (getDicValue(dic, pluralKey, query, options) !== undefined) {
+    return pluralKey;
+  }
+
+  const nestedNumKey = \`\${key}.\${count}\`;
+  if (getDicValue(dic, nestedNumKey, query, options) !== undefined)
+    return nestedNumKey;
+
+  const nestedKey = \`\${key}.\${pluralRules.select(count)}\`;
+  if (getDicValue(dic, nestedKey, query, options) !== undefined)
+    return nestedKey;
+
+  return key;
+}
+
+/**
+ * Replace {{variables}} to query values
+ */
+function interpolation(
+  text?: string,
+  query?: I18n.TranslationQuery | null,
+  _locale?: string | undefined,
+): string {
+  if (!text || !query || query === "obj") return text || "";
+
+  return tInterpolateParams(text, query);
+  // return Object.keys(query).reduce((all, key) => {
+  //   const regex = new RegExp(\`${escapeEachChar(r)}\\s*\${key}(?:[\\s,]+([\\w-]*))?\\s*\$${escapeEachChar(a)}\`, "gm");
+  //   return all.replace(regex, (_match) => query[key as keyof typeof query] as string);
+  // }, text);
+}
+
+function objectInterpolation(
+  obj: Record<string, string | unknown>,
+  query?: I18n.TranslationQuery | null,
+  locale?: string,
+) {
+  if (!query || Object.keys(query).length === 0) return obj;
+  Object.keys(obj).forEach((key) => {
+    if (obj[key] instanceof Object)
+      objectInterpolation(
+        obj[key] as Record<string, string | unknown>,
+        query,
+        locale,
+      );
+    if (typeof obj[key] === "string")
+      obj[key] = interpolation(obj[key] as string, query, locale);
+  });
+
+  return obj;
+}
+`
+        }
+    };
+});
+
+export { t as default };

package/adapter-js/generators/defaultI18nMetadata.cjs.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var createAdapter = require('../../compiler/createAdapter.cjs.js');
+
+var e = createAdapter.createGenerator("js", (t)=>({
+        defaultI18nMetadata: {
+            // dir: createGenerator.dirs.internal,
+            name: "defaultI18nMetadata",
+            ext: "ts",
+            content: ()=>/* js */ `
+import type { I18n } from "./types";
+
+/**
+ * @internal
+ */
+export const defaultI18nMetadata: I18n.Metadata = {
+  canonical: "",
+  alternates: {}
+}
+`
+        }
+    }));
+
+module.exports = e;

package/adapter-js/generators/defaultI18nMetadata.esm.js

@@ -0,0 +1,22 @@
+import { createGenerator } from '../../compiler/createAdapter.esm.js';
+
+var e = createGenerator("js", (t)=>({
+        defaultI18nMetadata: {
+            // dir: createGenerator.dirs.internal,
+            name: "defaultI18nMetadata",
+            ext: "ts",
+            content: ()=>/* js */ `
+import type { I18n } from "./types";
+
+/**
+ * @internal
+ */
+export const defaultI18nMetadata: I18n.Metadata = {
+  canonical: "",
+  alternates: {}
+}
+`
+        }
+    }));
+
+export { e as default };

package/adapter-js/generators/formatTo.cjs.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var createAdapter = require('../../compiler/createAdapter.cjs.js');
+
+var a = createAdapter.createGenerator("js", (e)=>{
+    let { config: a } = e;
+    return {
+        formatTo: {
+            name: "formatTo",
+            ext: "ts",
+            content: ()=>/* js */ `
+import { defaultLocale } from "./defaultLocale";
+
+/**
+ * @internal
+ */
+export function formatTo(
+  locale: string | undefined,
+  pathname: string,
+  params?: object,
+) {
+  locale = locale || 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]::formatTo, using '" +
+              pathname +
+              "' without param '" +
+              key +
+              "'",
+              { params }
+          );
+        }
+
+        if (!["string", "number"].includes(typeof params[key])) {
+          console.warn(
+            "[@koine/i18n]::formatTo, 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] + "",
+      )
+  }
+  ${a.hideDefaultLocaleInUrl ? `
+  if (locale !== defaultLocale) {
+    return "/" + locale + (pathname === "/" ? "" : pathname);
+  }
+  ` : ""}
+  return pathname;
+}
+
+// export default formatTo;
+`
+        }
+    };
+});
+
+module.exports = a;