@koine/i18n 2.0.0-beta.29 → 2.0.0-beta.31

package/generate/generateSummary.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 generateSummary(options: I18nGenerateSummaryOptions): Promise<{
+    data: I18nSummary;
+    md: string;
+}>;
+export {};

package/generate/generateSummary.js

@@ -0,0 +1,137 @@
+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 getSummaryDataEntry(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 {
+        characters: characters,
+        locale: locale,
+        path: path,
+        url: url,
+        words: wordsCount,
+    };
+}
+function getSummaryData(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 = getSummaryDataEntry(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, _b) {
+        var _c = __read(_a, 1), a = _c[0];
+        var _d = __read(_b, 1), b = _d[0];
+        return a === defaultLocale ? -1 : a.localeCompare(b);
+    }));
+    forin(data, function (locale, dataPerLocale) {
+        data[locale].characters = arraySum(dataPerLocale.files.map(function (f) { return f.characters; }));
+        data[locale].files = data[locale].files.sort(function (a, b) {
+            return a.path.localeCompare(b.path);
+        });
+        data[locale].words = arraySum(dataPerLocale.files.map(function (f) { return f.words; }));
+        data[locale] = Object.fromEntries(Object.entries(data[locale]).sort());
+    });
+    return data;
+}
+function getSummaryDataByPath(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;
+        }
+    });
+    out = Object.fromEntries(Object.entries(out).sort());
+    return out;
+}
+function generateSummaryMarkdownByPath(_options, data) {
+    var dataByPath = getSummaryDataByPath(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>"); }).join("");
+    output += "</tr></thead><tbody>".concat(body, "</tbody></table>\n");
+    return output;
+}
+function generateSummaryMarkdownByLocale(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 generateSummaryMarkdown(options, data) {
+    var output = "# Summary\n";
+    output += "\n### By locale\n\n";
+    output += generateSummaryMarkdownByLocale(options, data);
+    output += "\n### By file path\n\n";
+    output += generateSummaryMarkdownByPath(options, data);
+    return output;
+}
+export function generateSummary(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var data, md;
+        return __generator(this, function (_a) {
+            data = getSummaryData(options);
+            md = generateSummaryMarkdown(options, data);
+            return [2, { data: data, md: md }];
+        });
+    });
+}

package/generate/generateTypes.d.ts

@@ -0,0 +1,5 @@
+import type { I18nIndexedFile } from "./types.js";
+export declare function generateTypes(options: {
+    defaultLocale: string;
+    files: I18nIndexedFile[];
+}): Promise<string>;

package/generate/generateTypes.js

@@ -0,0 +1,133 @@
+import { __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { forin, isNumericLiteral, objectPick, split } from "@koine/utils";
+var pluralSuffixes = ["zero", "one", "two", "few", "many", "other"];
+var requiredPluralSuffix = "other";
+var isPluralSuffix = function (suffix) {
+    return (pluralSuffixes.includes(suffix) ||
+        isNumericLiteral(suffix));
+};
+var isPluralKey = function (key) {
+    var _a = __read(split(key, "_"), 2), suffix = _a[1];
+    return isPluralSuffix(suffix);
+};
+var groupPluralsKeysByRoot = function (pluralKeys) {
+    var map = {};
+    pluralKeys.forEach(function (key) {
+        var _a = __read(split(key, "_"), 1), root = _a[0];
+        map[root] = map[root] || [];
+        map[root].push(key);
+    });
+    return map;
+};
+var transformKeysForPlurals = function (keys) {
+    var pluralKeys = keys.filter(isPluralKey);
+    if (pluralKeys.length) {
+        var transformedKeys_1 = __spreadArray([], __read(keys), false);
+        var groupedPlurals = groupPluralsKeysByRoot(pluralKeys);
+        forin(groupedPlurals, function (pluralRoot, pluralKeys) {
+            if (!keys.includes(pluralRoot)) {
+                transformedKeys_1.push(pluralRoot);
+            }
+            pluralKeys.forEach(function (pluralKey) {
+                if (keys.includes(pluralKey)) {
+                    transformedKeys_1 = transformedKeys_1.filter(function (k) { return k !== pluralKey; });
+                }
+            });
+        });
+        return transformedKeys_1;
+    }
+    return keys;
+};
+var analyseObjectPlurals = function (obj) {
+    var keys = Object.keys(obj);
+    var hasPlurals = keys.includes(requiredPluralSuffix);
+    var hasOnlyPluralKeys = false;
+    var newValue = obj;
+    if (hasPlurals) {
+        var nonPluralKeys = keys.filter(function (k) { return !isPluralSuffix(k); });
+        hasOnlyPluralKeys = nonPluralKeys.length === 0;
+        newValue = objectPick(obj, nonPluralKeys);
+    }
+    return {
+        hasPlurals: hasPlurals,
+        hasOnlyPluralKeys: hasOnlyPluralKeys,
+        newValue: newValue,
+    };
+};
+var getTypeForObjectEntry = function (key, value) {
+    if (typeof value === "object") {
+        var _a = analyseObjectPlurals(value), hasPlurals = _a.hasPlurals, hasOnlyPluralKeys = _a.hasOnlyPluralKeys, newValue = _a.newValue;
+        if (hasOnlyPluralKeys) {
+            return "'".concat(key, "': string;");
+        }
+        if (hasPlurals) {
+            return "'".concat(key, "': string | ").concat(getType(newValue));
+        }
+    }
+    return "'".concat(key, "': ").concat(getType(value));
+};
+function getType(value) {
+    var out = "";
+    var primitiveType = "";
+    if (typeof value === "boolean") {
+        primitiveType = "boolean";
+    }
+    else if (typeof value === "string") {
+        primitiveType = "string";
+    }
+    if (primitiveType) {
+        out += primitiveType + ";";
+    }
+    else if (!value) {
+        out += "";
+    }
+    else if (Array.isArray(value)) {
+        var firstValue = value[0];
+        out += "".concat(getType(firstValue), "[];");
+    }
+    else if (typeof value === "object") {
+        out += "{";
+        var keys = transformKeysForPlurals(Object.keys(value));
+        for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            var single = value[key] || "";
+            out += getTypeForObjectEntry(key, single);
+        }
+        out += "};";
+    }
+    out = out.replace(/;\[\];/g, "[];");
+    out = out.replace(/;+/g, ";");
+    return out;
+}
+export function generateTypes(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var defaultLocale, files, defaultLocaleFiles, header, footer, out, i, _a, path, data, namespace, format;
+        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;
+                    if (!!process.env["JEST_WORKER_ID"]) return [3, 3];
+                    return [4, import("prettier")];
+                case 1:
+                    format = (_b.sent()).format;
+                    return [4, format(out, {
+                            parser: "typescript",
+                        })];
+                case 2:
+                    out = _b.sent();
+                    _b.label = 3;
+                case 3: return [2, out];
+            }
+        });
+    });
+}

package/generate/getFsData.d.ts

@@ -0,0 +1,10 @@
+import type { I18nIndexedFile, I18nIndexedLocale } from "./types.js";
+type I18nGetFsDataOutput = {
+    locales: I18nIndexedLocale[];
+    files: I18nIndexedFile[];
+};
+export declare function getFsData(options: {
+    cwd: string;
+    onlyFilesForLocales?: string[];
+}): Promise<I18nGetFsDataOutput>;
+export {};

package/generate/getFsData.js

@@ -0,0 +1,63 @@
+import { __awaiter, __generator } from "tslib";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { glob } from "glob";
+import { getLocalesFolders } from "./getLocalesFolders.js";
+export function getFsData(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var cwd, _a, onlyFilesForLocales, locales, dataOutput;
+        var _this = this;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    cwd = options.cwd, _a = options.onlyFilesForLocales, onlyFilesForLocales = _a === void 0 ? [] : _a;
+                    return [4, getLocalesFolders({ cwd: cwd })];
+                case 1:
+                    locales = _b.sent();
+                    dataOutput = { locales: locales, files: [] };
+                    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;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4, glob("**/*.json", {
+                                            cwd: locale.path,
+                                        })];
+                                    case 1:
+                                        jsonFiles = _a.sent();
+                                        return [4, Promise.all(jsonFiles.map(function (relativePath) { return __awaiter(_this, void 0, void 0, function () {
+                                                var fullPath, rawContent;
+                                                return __generator(this, function (_a) {
+                                                    switch (_a.label) {
+                                                        case 0:
+                                                            fullPath = join(locale.path, relativePath);
+                                                            return [4, readFile(fullPath, "utf8")];
+                                                        case 1:
+                                                            rawContent = _a.sent();
+                                                            if (rawContent) {
+                                                                dataOutput.files.push({
+                                                                    path: relativePath,
+                                                                    data: JSON.parse(rawContent),
+                                                                    locale: locale.code,
+                                                                });
+                                                            }
+                                                            return [2];
+                                                    }
+                                                });
+                                            }); }))];
+                                    case 2:
+                                        _a.sent();
+                                        return [2];
+                                }
+                            });
+                        }); }))];
+                case 2:
+                    _b.sent();
+                    return [2, dataOutput];
+            }
+        });
+    });
+}

package/generate/getLocalesFolders.d.ts

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

package/generate/getLocalesFolders.js

@@ -0,0 +1,29 @@
+import { __awaiter, __generator } from "tslib";
+import { join } from "node:path";
+import { glob } from "glob";
+var ignoredFolderNames = ["node_modules"];
+export function getLocalesFolders(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var cwd, folders, output;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    cwd = options.cwd;
+                    return [4, glob("*", {
+                            cwd: cwd,
+                            withFileTypes: true,
+                        })];
+                case 1:
+                    folders = (_a.sent())
+                        .filter(function (folder) { return folder.isDirectory(); })
+                        .map(function (path) { return path.relative(); })
+                        .filter(function (path) { return !ignoredFolderNames.includes(path); });
+                    output = folders.map(function (locale) { return ({
+                        path: join(cwd, locale),
+                        code: locale,
+                    }); });
+                    return [2, output];
+            }
+        });
+    });
+}

package/generate/index.d.ts

@@ -0,0 +1,7 @@
+export { generateSummary } from "./generateSummary.js";
+export { generateTypes } from "./generateTypes.js";
+export { getFsData } from "./getFsData.js";
+export { getLocalesFolders } from "./getLocalesFolders.js";
+export { writeTypes } from "./writeTypes.js";
+export { writeSummary } from "./writeSummary.js";
+export * from "./types.js";

package/generate/index.js

@@ -0,0 +1,7 @@
+export { generateSummary } from "./generateSummary.js";
+export { generateTypes } from "./generateTypes.js";
+export { getFsData } from "./getFsData.js";
+export { getLocalesFolders } from "./getLocalesFolders.js";
+export { writeTypes } from "./writeTypes.js";
+export { writeSummary } from "./writeSummary.js";
+export * from "./types.js";

package/generate/types.d.ts

@@ -0,0 +1,14 @@
+export type I18nLocale = string & {
+    branded: true;
+};
+export type I18nIndexedFile = {
+    path: string;
+    locale: I18nLocale;
+    data: {
+        [key: string]: any;
+    };
+};
+export type I18nIndexedLocale = {
+    path: string;
+    code: I18nLocale;
+};

package/generate/types.js

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

package/generate/writeSummary.d.ts

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

package/generate/writeSummary.js

@@ -0,0 +1,35 @@
+import { __awaiter, __generator } from "tslib";
+import { join } from "node:path";
+import { fsWrite } from "@koine/node";
+import { generateSummary, } from "./generateSummary.js";
+import { getFsData } from "./getFsData.js";
+export function writeSummary(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, getFsData({
+                            cwd: cwd,
+                        })];
+                case 1:
+                    data = _a.sent();
+                    return [4, generateSummary({
+                            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/generate/writeTypes.d.ts

@@ -0,0 +1,8 @@
+export declare function writeTypes(options: {
+    cwd: string;
+    defaultLocale: string;
+    outputTypes: string;
+}): Promise<{
+    locales: import("./types").I18nIndexedLocale[];
+    files: import("./types").I18nIndexedFile[];
+}>;

package/generate/writeTypes.js

@@ -0,0 +1,29 @@
+import { __awaiter, __generator } from "tslib";
+import { join } from "node:path";
+import { fsWrite } from "@koine/node";
+import { generateTypes } from "./generateTypes.js";
+import { getFsData } from "./getFsData.js";
+export function writeTypes(options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var cwd, defaultLocale, outputTypes, data, types;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    cwd = options.cwd, defaultLocale = options.defaultLocale, outputTypes = options.outputTypes;
+                    return [4, getFsData({
+                            cwd: cwd,
+                            onlyFilesForLocales: [defaultLocale],
+                        })];
+                case 1:
+                    data = _a.sent();
+                    return [4, generateTypes({ files: data.files, defaultLocale: defaultLocale })];
+                case 2:
+                    types = _a.sent();
+                    return [4, fsWrite(join(cwd, outputTypes), types)];
+                case 3:
+                    _a.sent();
+                    return [2, data];
+            }
+        });
+    });
+}

package/i18nGenerateSummary.js

@@ -66,6 +66,7 @@ function i18nSummaryGetDataByPath(data) {
             out[path][locale] = file;
         }
     });
+    out = Object.fromEntries(Object.entries(out).sort());
     return out;
 }
 function i18nGenerateSummaryMarkdownByPath(_options, data) {

package/index.d.ts

@@ -1,8 +1,5 @@
 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 { isDynamicRouteId } from "./isDynamicRouteId.js";
+export { isStaticRouteId } from "./isStaticRouteId.js";
+export { routeHasDynamicPortion } from "./routeHasDynamicPortion.js";
 export * from "./types.js";

package/index.js

@@ -1,8 +1,5 @@
 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 { isDynamicRouteId } from "./isDynamicRouteId.js";
+export { isStaticRouteId } from "./isStaticRouteId.js";
+export { routeHasDynamicPortion } from "./routeHasDynamicPortion.js";
 export * from "./types.js";

package/isDynamicRouteId.d.ts

@@ -0,0 +1,3 @@
+import type { ToRoute, ToRouteDynamic } from "./types.js";
+export declare function isDynamicRouteId(routeId: ToRoute): routeId is ToRouteDynamic;
+export default isDynamicRouteId;

package/isDynamicRouteId.js

@@ -0,0 +1,5 @@
+import { routeHasDynamicPortion } from "./routeHasDynamicPortion.js";
+export function isDynamicRouteId(routeId) {
+    return routeHasDynamicPortion(routeId);
+}
+export default isDynamicRouteId;

package/isStaticRouteId.d.ts

@@ -0,0 +1,3 @@
+import type { ToRoute, ToRouteStatic } from "./types.js";
+export declare function isStaticRouteId(routeId: ToRoute): routeId is ToRouteStatic;
+export default isStaticRouteId;

package/isStaticRouteId.js

@@ -0,0 +1,5 @@
+import { routeHasDynamicPortion } from "./routeHasDynamicPortion.js";
+export function isStaticRouteId(routeId) {
+    return !routeHasDynamicPortion(routeId);
+}
+export default isStaticRouteId;

package/package.json

@@ -2,8 +2,8 @@
   "name": "@koine/i18n",
   "sideEffects": false,
   "dependencies": {
-    "@koine/node": "2.0.0-beta.29",
-    "@koine/utils": "2.0.0-beta.29"
+    "@koine/node": "2.0.0-beta.31",
+    "@koine/utils": "2.0.0-beta.31"
   },
   "peerDependenciesMeta": {
     "prettier": {
@@ -22,6 +22,30 @@
     "./createTo": {
       "import": "./createTo.js"
     },
+    "./generate/generateSummary": {
+      "import": "./generate/generateSummary.js"
+    },
+    "./generate/generateTypes": {
+      "import": "./generate/generateTypes.js"
+    },
+    "./generate/getFsData": {
+      "import": "./generate/getFsData.js"
+    },
+    "./generate/getLocalesFolders": {
+      "import": "./generate/getLocalesFolders.js"
+    },
+    "./generate": {
+      "import": "./generate/index.js"
+    },
+    "./generate/types": {
+      "import": "./generate/types.js"
+    },
+    "./generate/writeSummary": {
+      "import": "./generate/writeSummary.js"
+    },
+    "./generate/writeTypes": {
+      "import": "./generate/writeTypes.js"
+    },
     "./i18nGenerateSummary": {
       "import": "./i18nGenerateSummary.js"
     },
@@ -40,6 +64,15 @@
     "./i18nWriteTypes": {
       "import": "./i18nWriteTypes.js"
     },
+    "./isDynamicRouteId": {
+      "import": "./isDynamicRouteId.js"
+    },
+    "./isStaticRouteId": {
+      "import": "./isStaticRouteId.js"
+    },
+    "./routeHasDynamicPortion": {
+      "import": "./routeHasDynamicPortion.js"
+    },
     "./types": {
       "import": "./types.js"
     }
@@ -48,5 +81,5 @@
     "prettier": "^3.1.1",
     "glob": "^10.3.10"
   },
-  "version": "2.0.0-beta.29"
+  "version": "2.0.0-beta.31"
 }

package/routeHasDynamicPortion.d.ts

@@ -0,0 +1,2 @@
+export declare function routeHasDynamicPortion(routeIdOrPortion: string): boolean;
+export default routeHasDynamicPortion;

package/routeHasDynamicPortion.js

@@ -0,0 +1,4 @@
+export function routeHasDynamicPortion(routeIdOrPortion) {
+    return /\[/.test(routeIdOrPortion);
+}
+export default routeHasDynamicPortion;

package/types.d.ts

@@ -1,18 +1,4 @@
 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,
@@ -60,9 +46,10 @@ export type TranslationOptions = undefined | TranslationShortcut | {
     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 TranslateDefault = <TPath extends TranslationsAllPaths, TReturn = TranslationAtPath<TPath>>(s: TPath, q?: TranslationQuery, o?: TranslationOptions) => TReturn;
+export type TranslateNamespaced<TNamespace extends TranslateNamespace> = <TPath extends TranslationsPaths<TranslationsDictionary[TNamespace]>, TReturn = TranslationAtPathFromNamespace<TNamespace, TPath>>(s: TPath, q?: TranslationQuery, o?: TranslationOptions) => TReturn;
+export type TranslateLoose<TReturn = string> = (s?: any, q?: TranslationQuery, o?: TranslationOptions) => TReturn;
+export type TranslateLoosest<TReturn = any> = (s?: any, q?: TranslationQuery, o?: TranslationOptions) => TReturn;
 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;