@koine/i18n 2.0.0-beta.22

package/i18nGenerateTypes.d.ts

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

package/i18nGenerateTypes.js

@@ -0,0 +1,67 @@
+import { __awaiter, __generator } from "tslib";
+import { format } from "prettier";
+var filterTranslationKey = function (key) {
+    return key.endsWith("_one") || key.endsWith("_zero") || key.endsWith("_other");
+};
+function getType(value, options) {
+    if (options === void 0) { options = {}; }
+    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, options), "[];");
+    }
+    else if (typeof value === "object") {
+        out += "{";
+        for (var _key in value) {
+            var key = _key;
+            if (!filterTranslationKey(key)) {
+                var single = value[key];
+                out += "'".concat(key, "': ").concat(getType(single, options));
+            }
+        }
+        out += "};";
+    }
+    out = out.replace(/;\[\];/g, "[];");
+    out = out.replace(/;+/g, ";");
+    return out;
+}
+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];
+            }
+        });
+    });
+}

package/i18nGetFsData.d.ts

@@ -0,0 +1,17 @@
+import { I18nIndexedLocale } from "./i18nGetLocalesFolders.js";
+export type I18nIndexedFile = {
+    path: string;
+    locale: string;
+    data: {
+        [key: string]: any;
+    };
+};
+type I18nGetFsDataOutput = {
+    locales: I18nIndexedLocale[];
+    files: I18nIndexedFile[];
+};
+export declare function i18nGetFsData(options: {
+    cwd: string;
+    onlyFilesForLocales?: string[];
+}): Promise<I18nGetFsDataOutput>;
+export {};

package/i18nGetFsData.js

@@ -0,0 +1,62 @@
+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";
+export function i18nGetFsData(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, i18nGetLocalesFolders({ cwd: cwd })];
+                case 1:
+                    locales = _b.sent();
+                    dataOutput = { locales: locales, files: [] };
+                    if (onlyFilesForLocales)
+                        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/i18nGetLocalesFolders.d.ts

@@ -0,0 +1,7 @@
+export type I18nIndexedLocale = {
+    path: string;
+    code: string;
+};
+export declare function i18nGetLocalesFolders(options: {
+    cwd: string;
+}): Promise<I18nIndexedLocale[]>;

package/i18nGetLocalesFolders.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 i18nGetLocalesFolders(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/i18nWriteTypes.d.ts

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

package/i18nWriteTypes.js

@@ -0,0 +1,29 @@
+import { __awaiter, __generator } from "tslib";
+import { join } from "node:path";
+import { fsWrite } from "@koine/node";
+import { i18nGenerateTypes } from "./i18nGenerateTypes.js";
+import { i18nGetFsData } from "./i18nGetFsData.js";
+export function i18nWriteTypes(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, i18nGetFsData({
+                            cwd: cwd,
+                            onlyFilesForLocales: [defaultLocale],
+                        })];
+                case 1:
+                    data = _a.sent();
+                    return [4, i18nGenerateTypes({ 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/index.d.ts

@@ -0,0 +1,4 @@
+export { i18nGenerateTypes } from "./i18nGenerateTypes.js";
+export { i18nGetFsData } from "./i18nGetFsData.js";
+export { i18nGetLocalesFolders } from "./i18nGetLocalesFolders.js";
+export { i18nWriteTypes } from "./i18nWriteTypes.js";

package/index.js

@@ -0,0 +1,4 @@
+export { i18nGenerateTypes } from "./i18nGenerateTypes.js";
+export { i18nGetFsData } from "./i18nGetFsData.js";
+export { i18nGetLocalesFolders } from "./i18nGetLocalesFolders.js";
+export { i18nWriteTypes } from "./i18nWriteTypes.js";

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@koine/i18n",
+  "sideEffects": false,
+  "dependencies": {
+    "@koine/node": "2.0.0-beta.22"
+  },
+  "module": "./index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./index.js"
+    },
+    "./i18nGenerateTypes": {
+      "import": "./i18nGenerateTypes.js"
+    },
+    "./i18nGetFsData": {
+      "import": "./i18nGetFsData.js"
+    },
+    "./i18nGetLocalesFolders": {
+      "import": "./i18nGetLocalesFolders.js"
+    },
+    "./i18nWriteTypes": {
+      "import": "./i18nWriteTypes.js"
+    }
+  },
+  "peerDependencies": {},
+  "version": "2.0.0-beta.22"
+}