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

package/actions/helpers-git.js

@@ -0,0 +1,45 @@
+import * as t from "@actions/core";
+import { simpleGit as i } from "simple-git";
+function e(i, e) {
+    e && console.log(e), i && t.error(i);
+}
+export class Git {
+    constructor(i, e){
+        this.errors = [], this.baseDir = i, this.afterFetch = e, this.outputs = {
+            committed: "false",
+            commit_sha: void 0,
+            pushed: "false"
+        }, Object.entries(this.outputs).forEach(([i, e])=>t.setOutput(i, e));
+    }
+    async run() {
+        let s = i({
+            baseDir: this.baseDir
+        }), o = process.env.GITHUB_REF?.substring(11) || "main";
+        t.info(`Running in folder ${this.baseDir}...`), t.info("> Pulling from remote..."), await s.fetch(void 0, e).pull(void 0, void 0, void 0, e), await this.afterFetch(), t.info("> Checking for uncommitted changes in the git working tree...");
+        let r = (await s.status()).files.length;
+        r ? (t.info(`> Found ${r} changed files.`), await s.fetch([
+            "--tags",
+            "--force"
+        ], e), t.info("> Re-staging files..."), await s.add(".").catch((t)=>{
+            if (t.message.includes("fatal: pathspec") && t.message.includes("did not match any files")) this.errors.push(Error("Add command did not match any file"));
+            else throw t;
+        }), t.info("> Creating commit..."), await s.commit("chore(action): auto commit", void 0, {}, (t, i)=>(i && (this.setOutput("committed", "true"), this.setOutput("commit_sha", i.commit)), e(t, i))), t.info("> Pushing commit to repo..."), await s.push("origin", o, {
+            "--set-upstream": null
+        }, (t, i)=>(i && this.setOutput("pushed", "true"), e(t, i))), t.endGroup(), t.info("> Task completed!!!")) : (t.endGroup(), t.info("> Working tree clean. Nothing to commit."));
+    }
+    setOutput(i, e) {
+        this.outputs[i] = e, t.setOutput(i, e);
+    }
+    logOutputs() {
+        for(let i in t.startGroup("Outputs"), this.outputs)t.info(`${i}: ${this.outputs[i]}`);
+        t.endGroup();
+    }
+    success() {
+        if (1 === this.errors.length) throw this.errors[0];
+        if (this.errors.length > 1) throw this.errors.forEach((i)=>t.error(i)), "There have been multiple runtime errors.";
+        this.logOutputs();
+    }
+    error(i) {
+        t.endGroup(), this.logOutputs(), t.setFailed(i);
+    }
+}

package/actions/helpers-i18n.js

@@ -0,0 +1,27 @@
+import { getConfig as o } from "../compiler/config";
+import { getInputDataLocal as r } from "../compiler/input/data-local";
+import { writeInput as t } from "../compiler/input/write";
+import { getSummaryData as i } from "../compiler/summary/data";
+import { writeSummary as m } from "../compiler/summary/write";
+export let i18nAction = async (p)=>{
+    let { cwd: u, source: e = ".", url: a, output: { input: l, summaryJson: c, summaryMarkdown: n }, ...s } = p, f = await r({
+        cwd: u,
+        source: e,
+        ...s
+    }), w = [];
+    if (l && w.push(t({
+        cwd: u,
+        output: l
+    }, f)), c || n) {
+        let r = i(o(f), {
+            sourceUrl: a
+        }, f);
+        w.push(m({
+            cwd: u,
+            outputJson: c,
+            outputMarkdown: n,
+            sourceUrl: a
+        }, r));
+    }
+    return await Promise.all(w), f;
+};

package/actions/i18n.js

@@ -0,0 +1,17 @@
+import { getInput as o, info as s } from "@actions/core";
+import { Git as r } from "./helpers-git";
+import { i18nAction as t } from "./helpers-i18n";
+let e = async ()=>{
+    let r = process.env.GITHUB_REPOSITORY, e = process.env.GITHUB_REF.replace("refs/heads/", ""), u = `https://github.com/${r}/blob/${e}`, n = await t({
+        url: u,
+        output: {
+            input: o("output_input") || ".github/input.json",
+            summaryJson: o("output_summary_json") || ".github/summary.json",
+            summaryMarkdown: o("output_summary_md") || ".github/summary.md"
+        }
+    });
+    s(`Found locales: ${n.localesFolders.join(", ")}`), s(`Found ${n.translationFiles.length} JSON files`);
+}, u = new r(process.cwd(), e);
+u.run().then(()=>u.success()).catch((o)=>{
+    u.error(o), console.error(o);
+});

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

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

package/adapter-js/code/config.js

@@ -1,4 +1,4 @@
-export default ({ config }) => `
+export default (({ config: e })=>`
 import { locales } from "./locales";
 import { defaultLocale } from "./defaultLocale";
 
@@ -7,8 +7,8 @@ import { defaultLocale } from "./defaultLocale";
 export const config = {
   locales,
   defaultLocale,
-  hideDefaultLocaleInUrl: ${config.hideDefaultLocaleInUrl},
+  hideDefaultLocaleInUrl: ${e.hideDefaultLocaleInUrl},
 }
 
 export default config;
-`;
+`);

package/adapter-js/code/defaultLocale.js

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

package/adapter-js/code/deriveLocalisedPathnames.js

@@ -1,4 +1,4 @@
-export default () => `
+export default (()=>`
 import { locales } from "./locales";
 import { to } from "./to";
 import type { I18n } from "./types";
@@ -75,4 +75,4 @@ export const deriveLocalisedPathnames = (routeId: I18n.RouteId, locationLike: Lo
   }, {} as LocalisedPathnames);
 
 export default deriveLocalisedPathnames;
-`;
+`);

package/adapter-js/code/index.js

@@ -1,57 +1,123 @@
-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 {
+import t from "./config";
+import e from "./config.cjs";
+import o from "./defaultLocale";
+import m from "./deriveLocalisedPathnames";
+import n from "./isLocale";
+import r from "./locales";
+import a from "./pathnameToRouteId";
+import s from "./routes";
+import f from "./routesSlim";
+import i from "./routesSpa";
+import x from "./tFns";
+import p from "./tInterpolateParams";
+import l from "./tPluralise";
+import d from "./to";
+import c from "./toFns";
+import u from "./toFormat";
+import F from "./toSpa";
+import L from "./types";
+export default (()=>({
         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: "config.cjs",
+                fn: e,
+                ext: "js"
+            },
+            {
+                name: "config",
+                fn: t,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "defaultLocale",
+                fn: o,
+                ext: "ts",
+                index: !0
+            },
             {
                 name: "deriveLocalisedPathnames",
-                fn: deriveLocalisedPathnames,
+                fn: m,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "isLocale",
+                fn: n,
                 ext: "ts",
-                index: true,
+                index: !0
+            },
+            {
+                name: "locales",
+                fn: r,
+                ext: "ts",
+                index: !0
             },
-            { name: "isLocale", fn: isLocale, ext: "ts", index: true },
-            { name: "locales", fn: locales, ext: "ts", index: true },
             {
                 name: "pathnameToRouteId",
-                fn: pathnameToRouteId,
+                fn: a,
                 ext: "ts",
-                index: true,
+                index: !0
+            },
+            {
+                name: "routes",
+                fn: s,
+                ext: "ts"
+            },
+            {
+                name: "routesSlim",
+                fn: f,
+                ext: "ts"
+            },
+            {
+                name: "routesSpa",
+                fn: i,
+                ext: "ts"
+            },
+            {
+                name: "tFns",
+                fn: x,
+                ext: "ts"
             },
-            { 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;
+                fn: p,
+                ext: "ts"
+            },
+            {
+                name: "to",
+                fn: d,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "toFns",
+                fn: c,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "toFormat",
+                fn: u,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "toSpa",
+                fn: F,
+                ext: "ts",
+                index: !0
+            },
+            {
+                name: "tPluralise",
+                fn: l,
+                ext: "ts"
+            },
+            {
+                name: "types",
+                fn: L,
+                ext: "ts",
+                index: !0
+            }
+        ]
+    }));

package/adapter-js/code/isLocale.js

@@ -1,4 +1,4 @@
-export default () => `
+export default (()=>`
 import { locales } from "./locales";
 import type { I18n } from "./types";
 
@@ -6,4 +6,4 @@ import type { I18n } from "./types";
 export const isLocale = (payload: any): payload is I18n.Locale => locales.includes(payload);
 
 export default isLocale;
-`;
+`);

package/adapter-js/code/locales.js

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

package/adapter-js/code/pathnameToRouteId.js

@@ -1,6 +1,6 @@
-import { escapeRegExp } from "@koine/utils";
-export default ({ options }) => {
-    const { idDelimiter, optionalCatchAll, catchAll } = options.routes.tokens;
+import { escapeRegExp as e } from "@koine/utils";
+export default (({ options: t })=>{
+    let { idDelimiter: a, optionalCatchAll: r, catchAll: o } = t.routes.tokens;
     return `
 /**
  * Convert a URL like pathname to a "named route"
@@ -10,11 +10,11 @@ export default ({ options }) => {
 export const pathnameToRouteId = (pathname: string) =>
   pathname
     .replace(/^\\//g, "")
-    .replace(/\\//g, "${idDelimiter}")
-    .replace(/${escapeRegExp(idDelimiter)}${escapeRegExp(optionalCatchAll.start)}.+$/, "")
-    .replace(/${escapeRegExp(idDelimiter)}${escapeRegExp(catchAll.start)}.+$/, "")
+    .replace(/\\//g, "${a}")
+    .replace(/${e(a)}${e(r.start)}.+$/, "")
+    .replace(/${e(a)}${e(o.start)}.+$/, "")
     .replace(/\\/index$/, "");
 
 export default pathnameToRouteId;
 `;
-};
+});

package/adapter-js/code/routes.js

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

package/adapter-js/code/routesSlim.js

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

package/adapter-js/code/routesSpa.js

@@ -1,11 +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);
+export default (({ routes: t })=>{
+    let e = JSON.stringify(Object.fromEntries(Object.entries(t.byId).filter(([, { pathnamesSpa: t }])=>!!t).map(([t, { pathnamesSpa: e }])=>[
+            t,
+            e
+        ]).sort()), null, 2);
     return `
-export const routesSpa = ${value} as const;
+export const routesSpa = ${e} as const;
 
 export default routesSpa;
 `;
-};
+});

package/adapter-js/code/tFns.js

@@ -1,33 +1,15 @@
-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}"`;
+import { areEqual as t, isArray as e, isBoolean as r, isNumber as l, isPrimitive as o, isString as a } from "@koine/utils";
+import { dataParamsToTsInterfaceBody as n } from "../../compiler/helpers";
+let i = (t)=>a(t) || l(t) ? `"${t}"` : r(t) ? `${t}` : e(t) ? JSON.stringify(t) : `(${JSON.stringify(t)})`, s = (e, r)=>t(e, r), p = (t, e)=>{
+    let { defaultLocale: r } = t, l = "";
+    for(let t in e){
+        let o = e[t];
+        t === r || s(o, e[r]) || (l += `locale === "${t}" ? ${i(o)} : `);
     }
-    else if (isBoolean(value)) {
-        return `${value}`;
-    }
-    else if (isArray(value)) {
-        return JSON.stringify(value);
-    }
-    return `(${JSON.stringify(value)})`;
+    return l + i(e[r]);
 };
-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 = `
+export default (({ config: t, options: e, translations: r })=>{
+    let l = `
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable prefer-const */
 import type { I18n } from "./types";
@@ -35,41 +17,18 @@ 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`;
+    for(let a in r){
+        let { values: s, params: m, plural: f } = r[a], u = `${e.translations.fnsPrefix}${a}`;
+        f && (m ? m.count = "number" : m = {
+            count: "number"
+        });
+        let $ = [
+            m ? `params: { ${n(m)} }` : "",
+            "locale?: I18n.Locale"
+        ].filter(Boolean).join(", ");
+        l += `export let ${u} = (${$}) => `;
+        let c = "";
+        o(s) ? c += i(s) : c += p(t, s), f && (c = `tPluralise(${c}, params.count)`), l += (c = m ? `tInterpolateParams(${c}, params);` : `${c};`) + `\n`;
     }
-    return output;
-};
+    return l;
+});

package/adapter-js/code/tInterpolateParams.js

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

package/adapter-js/code/tPluralise.js

@@ -1,5 +1,4 @@
-export default () => {
-    return `
+export default (()=>`
 /* eslint-disable prefer-const */
 let pluralRules = new Intl.PluralRules();
 
@@ -8,5 +7,4 @@ 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

@@ -1,4 +1,4 @@
-export default ({ config }) => `
+export default (({ config: o })=>`
 import { isLocale } from "./isLocale";
 import { toFormat } from "./toFormat";
 import { routesSlim } from "./routesSlim";
@@ -17,16 +17,16 @@ export function to<Id extends I18n.RouteId>(
         | [I18n.RouteParams[Id], I18n.Locale]
     : [] | [I18n.Locale]
 ) {
-  const locale = (isLocale(args[0]) ? args[0] : args[1]) || "${config.defaultLocale}";
+  const locale = (isLocale(args[0]) ? args[0] : args[1]) || "${o.defaultLocale}";
 
   return toFormat(
     locale,
     (routesSlim[id] as Record<string, string>)[locale] ??
-      (routesSlim[id] as Record<string, string>)["${config.defaultLocale}"] ??
+      (routesSlim[id] as Record<string, string>)["${o.defaultLocale}"] ??
       routesSlim[id],
     isLocale(args[0]) ? undefined : args[0]
   ) as I18n.RoutePathnames[Id];
 }
 
 export default to;
-`;
+`);