@koine/i18n 2.0.0-beta.26 → 2.0.0-beta.28

package/_helpers.d.ts

@@ -0,0 +1,4 @@
+import type { ToRoute, ToRouteDynamic, ToRouteStatic } from "./types.js";
+export declare function routeHasDynamicPortion(routeIdOrPortion: string): boolean;
+export declare function isStaticRouteId(routeId: ToRoute): routeId is ToRouteStatic;
+export declare function isDynamicRouteId(routeId: ToRoute): routeId is ToRouteDynamic;

package/_helpers.js

@@ -0,0 +1,9 @@
+export function routeHasDynamicPortion(routeIdOrPortion) {
+    return /\[/.test(routeIdOrPortion);
+}
+export function isStaticRouteId(routeId) {
+    return !routeHasDynamicPortion(routeId);
+}
+export function isDynamicRouteId(routeId) {
+    return routeHasDynamicPortion(routeId);
+}

package/createTo.d.ts

@@ -0,0 +1,3 @@
+import type { ToRoute, ToRouteDynamicParams, ToTranslate } from "./types.js";
+export declare const createTo: <TLocales extends readonly string[] | string[]>(_locales: TLocales, defaultLocale: TLocales[number], hideDefaultLocaleInUrl?: boolean) => <TRoute extends ToRoute>(locale: TLocales[number], t: ToTranslate, routeId: TRoute, routeParams?: ToRouteDynamicParams<TRoute> | undefined) => string;
+export default createTo;

package/createTo.js

@@ -0,0 +1,18 @@
+export var createTo = function (_locales, defaultLocale, hideDefaultLocaleInUrl) {
+    return function (locale, t, routeId, routeParams) {
+        var relative = "";
+        if (routeParams) {
+            relative = t(routeId, routeParams).replace("*", "");
+        }
+        else {
+            relative = t(routeId);
+        }
+        if (hideDefaultLocaleInUrl) {
+            if (locale !== defaultLocale) {
+                return "/".concat(locale).concat(relative);
+            }
+        }
+        return relative;
+    };
+};
+export default createTo;

package/i18nGenerateSummary.d.ts

@@ -0,0 +1,28 @@
+import type { I18nIndexedFile } from "./types.js";
+export type I18nGenerateSummaryConfig = {
+    defaultLocale: string;
+    sourceUrl: string;
+};
+type Locale = string & {
+    branded: true;
+};
+type I18nGenerateSummaryOptions = I18nGenerateSummaryConfig & {
+    files: I18nIndexedFile[];
+};
+type I18nSummary = Record<Locale, {
+    words: number;
+    characters: number;
+    files: I18nSummaryFile[];
+}>;
+type I18nSummaryFile = {
+    locale: Locale;
+    path: string;
+    url: string;
+    words: number;
+    characters: number;
+};
+export declare function i18nGenerateSummary(options: I18nGenerateSummaryOptions): Promise<{
+    data: I18nSummary;
+    md: string;
+}>;
+export {};

package/i18nGenerateSummary.js

@@ -0,0 +1,131 @@
+import { __awaiter, __generator, __read } from "tslib";
+import { arraySum, forin } from "@koine/utils";
+function getWords(value, options) {
+    if (options === void 0) { options = {}; }
+    var out = "";
+    if (value && typeof value === "string") {
+        out += " " + value.trim();
+    }
+    else if (Array.isArray(value)) {
+        for (var i = 0; i < value.length; i++) {
+            out += getWords(value[i], options);
+        }
+    }
+    else if (typeof value === "object") {
+        for (var _key in value) {
+            var key = _key;
+            var single = value[key];
+            out += getWords(single, options);
+        }
+    }
+    return out;
+}
+function i18nSummaryGetDataEntry(options, file) {
+    var locale = file.locale, path = file.path;
+    var url = "".concat(options.sourceUrl, "/").concat(locale, "/").concat(path);
+    var words = getWords(file.data);
+    var wordsCount = words.split(" ").filter(Boolean).length;
+    var characters = words.split(" ").filter(Boolean).join("").length;
+    return {
+        locale: locale,
+        path: path,
+        url: url,
+        words: wordsCount,
+        characters: characters,
+    };
+}
+function i18nSummaryGetData(options) {
+    var files = options.files, defaultLocale = options.defaultLocale;
+    var data = {};
+    for (var i = 0; i < files.length; i++) {
+        var file = files[i];
+        var locale = file.locale;
+        var entry = i18nSummaryGetDataEntry(options, file);
+        data[locale] = data[locale] || {};
+        data[locale].files = data[locale].files || [];
+        data[locale].files.push(entry);
+    }
+    data = Object.fromEntries(Object.entries(data).sort(function (_a) {
+        var _b = __read(_a, 1), a = _b[0];
+        return a === defaultLocale ? -1 : 1;
+    }));
+    forin(data, function (locale, dataPerLocale) {
+        data[locale].words = arraySum(dataPerLocale.files.map(function (f) { return f.words; }));
+        data[locale].characters = arraySum(dataPerLocale.files.map(function (f) { return f.characters; }));
+    });
+    return data;
+}
+function i18nSummaryGetDataByPath(data) {
+    var out = {};
+    forin(data, function (locale, dataPerLocale) {
+        var files = dataPerLocale.files;
+        for (var i = 0; i < files.length; i++) {
+            var file = files[i];
+            var path = file.path;
+            out[path] = out[path] || {};
+            out[path][locale] = file;
+        }
+    });
+    return out;
+}
+function i18nGenerateSummaryMarkdownByPath(_options, data) {
+    var dataByPath = i18nSummaryGetDataByPath(data);
+    var output = "";
+    var body = "";
+    var locales = [];
+    var styleBorder = "style=\"border-right:1px solid grey\"";
+    forin(dataByPath, function (path, dataPerPath) {
+        body += "<tr>";
+        body += "<td ".concat(styleBorder, ">").concat(path, "</td>");
+        forin(dataPerPath, function (locale, file) {
+            var characters = file.characters, words = file.words, url = file.url;
+            if (!locales.includes(locale))
+                locales.push(locale);
+            body += "<td><a href=\"".concat(url, "\">").concat(locale, "</a></td>");
+            body += "<td>".concat(words, "</td>");
+            body += "<td ".concat(styleBorder, ">").concat(characters, "</td>");
+        });
+        body += "</tr>";
+    });
+    output += "<table><thead><tr>";
+    output += "<th ".concat(styleBorder, ">file path</th>");
+    output += locales.map(function () { return "<th>lang</th><th>words</th><th ".concat(styleBorder, ">chars</th>"); });
+    output += "</tr></thead><tbody>".concat(body, "</tbody></table>\n");
+    return output;
+}
+function i18nGenerateSummaryMarkdownByLocale(options, data) {
+    var output = "";
+    var body = "";
+    forin(data, function (locale, dataPerLocale) {
+        var files = dataPerLocale.files, characters = dataPerLocale.characters, words = dataPerLocale.words;
+        var url = "".concat(options.sourceUrl, "/").concat(locale);
+        body += "<tr>";
+        body += "<th><a href=\"".concat(url, "\">").concat(locale, "</a></th>");
+        body += "<td>".concat(files.length, "</td>");
+        body += "<td>".concat(words, "</td>");
+        body += "<td>".concat(characters, "</td>");
+        body += "</tr>";
+    });
+    output += "<table><thead><tr>";
+    output += "<th>locale</th><th>files</th><th>words</th><th>chars</th>";
+    output += "</tr></thead><tbody>".concat(body, "</tbody></table>\n");
+    return output;
+}
+function i18nGenerateSummaryMarkdown(options, data) {
+    var output = "# Summary\n";
+    output += "\n### By locale\n\n";
+    output += i18nGenerateSummaryMarkdownByLocale(options, data);
+    output += "\n### By file path\n\n";
+    output += i18nGenerateSummaryMarkdownByPath(options, data);
+    return output;
+}
+export function i18nGenerateSummary(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var data, md;
+        return __generator(this, function (_a) {
+            data = i18nSummaryGetData(options);
+            md = i18nGenerateSummaryMarkdown(options, data);
+            return [2, { data: data, md: md }];
+        });
+    });
+}

package/i18nGenerateTypes.d.ts

@@ -1,4 +1,4 @@
-import { I18nIndexedFile } from "./i18nGetFsData.js";
+import type { I18nIndexedFile } from "./types.js";
 export declare function i18nGenerateTypes(options: {
     defaultLocale: string;
     files: I18nIndexedFile[];

package/i18nGenerateTypes.js

@@ -1,7 +1,12 @@
 import { __awaiter, __generator } from "tslib";
-import { format } from "prettier";
+var pluralSuffixes = ["_zero", "_one", "_two", "_few", "_many", "_other"];
 var filterTranslationKey = function (key) {
-    return key.endsWith("_one") || key.endsWith("_zero") || key.endsWith("_other");
+    var parts = key.split("_").filter(Boolean);
+    if (parts.length > 1) {
+        var lastPart = parts[parts.length - 1];
+        return /^[0-9]+$/.test(lastPart) || pluralSuffixes.includes(lastPart);
+    }
+    return false;
 };
 function getType(value, options) {
     if (options === void 0) { options = {}; }
@@ -42,26 +47,20 @@ export function i18nGenerateTypes(options) {
     return __awaiter(this, void 0, void 0, function () {
         var defaultLocale, files, defaultLocaleFiles, header, footer, out, i, _a, path, data, namespace;
         return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    defaultLocale = options.defaultLocale, files = options.files;
-                    defaultLocaleFiles = files.filter(function (f) { return f.locale === defaultLocale; });
-                    header = "\n/* eslint-disable @typescript-eslint/ban-types */\n/* eslint-disable @typescript-eslint/no-namespace */\n\ndeclare namespace Koine {\n  interface Translations {\n";
-                    footer = "\n  }\n}\n";
-                    out = header;
-                    for (i = 0; i < defaultLocaleFiles.length; i++) {
-                        _a = defaultLocaleFiles[i], path = _a.path, data = _a.data;
-                        namespace = path.replace(".json", "");
-                        out += "\"".concat(namespace, "\": ").concat(getType(data), "\n");
-                    }
-                    out += footer;
-                    return [4, format(out, {
-                            parser: "typescript",
-                        })];
-                case 1:
-                    out = _b.sent();
-                    return [2, out];
+            defaultLocale = options.defaultLocale, files = options.files;
+            defaultLocaleFiles = files.filter(function (f) { return f.locale === defaultLocale; });
+            header = "\n/* eslint-disable @typescript-eslint/ban-types */\n/* eslint-disable @typescript-eslint/no-namespace */\n\ndeclare namespace Koine {\n  interface Translations {\n";
+            footer = "\n  }\n}\n";
+            out = header;
+            for (i = 0; i < defaultLocaleFiles.length; i++) {
+                _a = defaultLocaleFiles[i], path = _a.path, data = _a.data;
+                namespace = path.replace(".json", "");
+                out += "\"".concat(namespace, "\": ").concat(getType(data), "\n");
+            }
+            out += footer;
+            if (!process.env["JEST_WORKER_ID"]) {
             }
+            return [2, out];
         });
     });
 }

package/i18nGetFsData.d.ts

@@ -1,11 +1,4 @@
-import { I18nIndexedLocale } from "./i18nGetLocalesFolders.js";
-export type I18nIndexedFile = {
-    path: string;
-    locale: string;
-    data: {
-        [key: string]: any;
-    };
-};
+import type { I18nIndexedFile, I18nIndexedLocale } from "./types.js";
 type I18nGetFsDataOutput = {
     locales: I18nIndexedLocale[];
     files: I18nIndexedFile[];

package/i18nGetFsData.js

@@ -2,7 +2,7 @@ import { __awaiter, __generator } from "tslib";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { glob } from "glob";
-import { i18nGetLocalesFolders, } from "./i18nGetLocalesFolders.js";
+import { i18nGetLocalesFolders } from "./i18nGetLocalesFolders.js";
 export function i18nGetFsData(options) {
     return __awaiter(this, void 0, void 0, function () {
         var cwd, _a, onlyFilesForLocales, locales, dataOutput;
@@ -15,8 +15,9 @@ export function i18nGetFsData(options) {
                 case 1:
                     locales = _b.sent();
                     dataOutput = { locales: locales, files: [] };
-                    if (onlyFilesForLocales)
+                    if (onlyFilesForLocales.length) {
                         locales = locales.filter(function (l) { return onlyFilesForLocales.includes(l.code); });
+                    }
                     return [4, Promise.all(locales.map(function (locale) { return __awaiter(_this, void 0, void 0, function () {
                             var jsonFiles;
                             var _this = this;

package/i18nGetLocalesFolders.d.ts

@@ -1,7 +1,4 @@
-export type I18nIndexedLocale = {
-    path: string;
-    code: string;
-};
+import type { I18nIndexedLocale } from "./types.js";
 export declare function i18nGetLocalesFolders(options: {
     cwd: string;
 }): Promise<I18nIndexedLocale[]>;

package/i18nWriteSummary.d.ts

@@ -0,0 +1,9 @@
+import { type I18nGenerateSummaryConfig } from "./i18nGenerateSummary.js";
+export declare function i18nWriteSummary(options: {
+    cwd: string;
+    outputJson: string;
+    outputMarkdown: string;
+} & I18nGenerateSummaryConfig): Promise<{
+    locales: import("./types").I18nIndexedLocale[];
+    files: import("./types").I18nIndexedFile[];
+}>;

package/i18nWriteSummary.js

@@ -0,0 +1,35 @@
+import { __awaiter, __generator } from "tslib";
+import { join } from "node:path";
+import { fsWrite } from "@koine/node";
+import { i18nGenerateSummary, } from "./i18nGenerateSummary.js";
+import { i18nGetFsData } from "./i18nGetFsData.js";
+export function i18nWriteSummary(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var cwd, defaultLocale, outputJson, outputMarkdown, sourceUrl, data, summary;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    cwd = options.cwd, defaultLocale = options.defaultLocale, outputJson = options.outputJson, outputMarkdown = options.outputMarkdown, sourceUrl = options.sourceUrl;
+                    return [4, i18nGetFsData({
+                            cwd: cwd,
+                        })];
+                case 1:
+                    data = _a.sent();
+                    return [4, i18nGenerateSummary({
+                            files: data.files,
+                            defaultLocale: defaultLocale,
+                            sourceUrl: sourceUrl,
+                        })];
+                case 2:
+                    summary = _a.sent();
+                    return [4, fsWrite(join(cwd, outputJson), JSON.stringify(summary.data, null, 2))];
+                case 3:
+                    _a.sent();
+                    return [4, fsWrite(join(cwd, outputMarkdown), summary.md)];
+                case 4:
+                    _a.sent();
+                    return [2, data];
+            }
+        });
+    });
+}

package/i18nWriteTypes.d.ts

@@ -3,6 +3,6 @@ export declare function i18nWriteTypes(options: {
     defaultLocale: string;
     outputTypes: string;
 }): Promise<{
-    locales: import("./i18nGetLocalesFolders").I18nIndexedLocale[];
-    files: import("./i18nGetFsData").I18nIndexedFile[];
+    locales: import("./types").I18nIndexedLocale[];
+    files: import("./types").I18nIndexedFile[];
 }>;

package/index.d.ts

@@ -1,4 +1,8 @@
+export { createTo } from "./createTo.js";
+export { i18nGenerateSummary } from "./i18nGenerateSummary.js";
 export { i18nGenerateTypes } from "./i18nGenerateTypes.js";
 export { i18nGetFsData } from "./i18nGetFsData.js";
 export { i18nGetLocalesFolders } from "./i18nGetLocalesFolders.js";
 export { i18nWriteTypes } from "./i18nWriteTypes.js";
+export { i18nWriteSummary } from "./i18nWriteSummary.js";
+export * from "./types.js";

package/index.js

@@ -1,4 +1,8 @@
+export { createTo } from "./createTo.js";
+export { i18nGenerateSummary } from "./i18nGenerateSummary.js";
 export { i18nGenerateTypes } from "./i18nGenerateTypes.js";
 export { i18nGetFsData } from "./i18nGetFsData.js";
 export { i18nGetLocalesFolders } from "./i18nGetLocalesFolders.js";
 export { i18nWriteTypes } from "./i18nWriteTypes.js";
+export { i18nWriteSummary } from "./i18nWriteSummary.js";
+export * from "./types.js";

package/package.json

@@ -2,7 +2,7 @@
   "name": "@koine/i18n",
   "sideEffects": false,
   "dependencies": {
-    "@koine/node": "2.0.0-beta.26"
+    "@koine/node": "2.0.0-beta.28"
   },
   "module": "./index.js",
   "type": "module",
@@ -10,6 +10,12 @@
     ".": {
       "import": "./index.js"
     },
+    "./createTo": {
+      "import": "./createTo.js"
+    },
+    "./i18nGenerateSummary": {
+      "import": "./i18nGenerateSummary.js"
+    },
     "./i18nGenerateTypes": {
       "import": "./i18nGenerateTypes.js"
     },
@@ -19,10 +25,16 @@
     "./i18nGetLocalesFolders": {
       "import": "./i18nGetLocalesFolders.js"
     },
+    "./i18nWriteSummary": {
+      "import": "./i18nWriteSummary.js"
+    },
     "./i18nWriteTypes": {
       "import": "./i18nWriteTypes.js"
+    },
+    "./types": {
+      "import": "./types.js"
     }
   },
   "peerDependencies": {},
-  "version": "2.0.0-beta.26"
+  "version": "2.0.0-beta.28"
 }

package/types.d.ts

@@ -0,0 +1,80 @@
+import type { Split } from "@koine/utils";
+export type I18nLocale = string & {
+    branded: true;
+};
+export type I18nIndexedFile = {
+    path: string;
+    locale: I18nLocale;
+    data: {
+        [key: string]: any;
+    };
+};
+export type I18nIndexedLocale = {
+    path: string;
+    code: I18nLocale;
+};
+type MergeDictionaries<T, K> = Omit<T, keyof K> & K;
+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;
+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;
+type Get<BaseType, Path extends string | readonly string[]> = GetWithPath<BaseType, Path extends string ? Split<Path, "."> : Path>;
+type TranslationsDictionaryDefault = {
+    "~": {
+        test: string;
+        static: string;
+        dynamic: {
+            static: string;
+            "[key]": {
+                index: string;
+                "[id]": string;
+            };
+        };
+    };
+};
+export type TranslationsDictionary = MergeDictionaries<TranslationsDictionaryDefault, Koine.Translations>;
+export type TranslateNamespace = Extract<keyof TranslationsDictionary, string>;
+export type TranslationAtPathFromNamespace<TNamespace extends TranslateNamespace, TPath extends TranslationsPaths<TranslationsDictionary[TNamespace]>> = TNamespace extends TranslateNamespace ? TPath extends string ? Get<TranslationsDictionary[TNamespace], TPath> : TranslationsDictionary[TNamespace] : never;
+export type TranslationAtPathGeneric = TranslateNamespace | TranslationsAllPaths;
+export type TranslationAtPath<TPath extends TranslationAtPathGeneric> = TPath extends TranslateNamespace ? TranslationsDictionary[TPath] : TPath extends `${infer Namespace}:${infer Path}` ? Namespace extends TranslateNamespace ? Get<TranslationsDictionary[Namespace], Path> : never : never;
+export type TranslationPathsFrom<TPath extends TranslationAtPathGeneric> = TPath extends TranslateNamespace ? TranslationsPaths<TranslationsDictionary[TPath]> : TPath extends `${infer Namespace}:${infer Path}` ? Namespace extends TranslateNamespace ? Get<TranslationsDictionary[Namespace], Path> extends object ? TranslationsPaths<Get<TranslationsDictionary[Namespace], Path>> : TranslationsPaths<TranslationsDictionary[Namespace]> : never : never;
+export type TranslationsPathsAncestors<TPath extends string, TSeparator extends string = "."> = BuildRecursiveJoin<Split<TPath, TSeparator>, TSeparator>;
+export type TranslationsPaths<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, TranslationsPaths<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 TranslationsAllPaths = {
+    [N in Extract<keyof TranslationsDictionary, string>]: {
+        [K in Extract<keyof TranslationsDictionary[N], string>]: TranslationsDictionary[N][K] extends Record<string, never> | never[] | "" ? never : TranslationsDictionary[N][K] extends Record<string, unknown> ? `${N}:${K}` | JoinObjectPath<K extends string ? `${N}:${K}` : `${N}:`, TranslationsPaths<TranslationsDictionary[N][K]>> : TranslationsDictionary[N][K] extends string | number | boolean | Array<string | number | boolean | object> ? `${N}:${K}` : never;
+    }[Extract<keyof TranslationsDictionary[N], string>];
+}[Extract<keyof TranslationsDictionary, string>] extends infer O ? O : never;
+export type TranslationShortcut = "obj" | "";
+export type TranslationQuery = undefined | null | TranslationShortcut | {
+    [key: string]: string | number | boolean;
+};
+export type TranslationOptions = undefined | TranslationShortcut | {
+    returnObjects?: boolean;
+    fallback?: string | string[];
+    default?: string;
+};
+export type Translate<TNamespace extends TranslateNamespace | undefined = TranslateNamespace> = TNamespace extends TranslateNamespace ? TranslateNamespaced<TNamespace> : TranslateDefault;
+export type TranslateDefault = <TPath extends TranslationsAllPaths>(s: TPath, q?: TranslationQuery, o?: TranslationOptions) => TranslationAtPath<TPath>;
+export type TranslateNamespaced<TNamespace extends TranslateNamespace> = <TPath extends TranslationsPaths<TranslationsDictionary[TNamespace]>>(s: TPath, q?: TranslationQuery, o?: TranslationOptions) => TranslationAtPathFromNamespace<TNamespace, TPath>;
+export type TranslateLoose = (s?: any, q?: TranslationQuery, o?: TranslationOptions) => string;
+export type TranslatedRoute = TranslationsPaths<TranslationsDictionary["~"], false>;
+export type TranslatedRoutesChildrenOf<TStarts extends string, T extends string = TranslatedRoute> = T extends `${TStarts}.${infer First}.${infer Second}` ? First | `${First}.${Second}` : T extends `${TStarts}.${infer First}` ? First : never;
+type OnlyStatic<T extends string> = T extends `${string}.[${string}].${string}` | `${string}.[${string}]` | `[${string}].${string}` | `[${string}]` ? never : T;
+type OnlyDynamic<T extends string> = T extends `${string}.[${string}].${string}` | `${string}.[${string}]` | `[${string}].${string}` | `[${string}]` ? T : never;
+export type ToRouteDynamicParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}[${infer Param}].${infer Rest}` ? {
+    [k in Param | keyof ToRouteDynamicParams<Rest>]: string | number;
+} : T extends `${string}[${infer Param}]` ? {
+    [k in Param]: string | number;
+} : {};
+export type ToTranslate = TranslateNamespaced<"~">;
+export type ToRouteDynamic = OnlyDynamic<TranslatedRoute>;
+export type ToRouteStatic = OnlyStatic<TranslatedRoute>;
+export type ToRoute = ToRouteDynamic | ToRouteStatic;
+export type ToArgs<TRoute extends ToRoute> = TRoute extends ToRouteDynamic ? [TRoute, ToRouteDynamicParams<TRoute>] : [TRoute];
+export {};

package/types.js

@@ -0,0 +1 @@
+export {};

package/typings.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Types specifically related to `@koine/i18n` exposed on the global unique
+ * namespace `Koine`. Most of the types here should be prefixed by `I18n`, e.g.
+ * `I18nSomeFeature` accessible anywhere from `Koine.I18nSomeFeature`
+ */
+declare namespace Koine {
+  /**
+   * Translations dictionary extracted from JSON files.
+   * You need to augment this type with something like:
+   *
+   * ```ts
+   * declare namespace Koine {
+   *   interface Translations {
+   *     "~": typeof import("./locales/en/~.json");
+   *     "_": typeof import("./locales/en/_.json");
+   *     "$team": typeof import("./locales/en/$team.json");
+   *     "home": typeof import("./locales/en/home.json");
+   *     "Header": typeof import("./locales/en/Header.json");
+   *   }
+   * }
+   * ```
+   *
+   * Best to follow a convention to name the files which become the namespaces:
+   *
+   * - `~`: for app wide **urls** translated definitions
+   * - `_`: for app wide **common** translations
+   * - `${data}`: dollar prefix for static **data** like arrays, objects, .etc
+   * - `{route-name}`: lower cased for **route** specific data
+   * - `{ComponentName}`: pascal cased for **components** specific data
+   *
+   * This works through using [type augmentation](https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation)
+   * and [merging interfaces](https://www.typescriptlang.org/docs/handbook/declaration-merging.html#merging-interfaces).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface Translations {}
+}