@uxf/scripts 10.0.0-beta.45 → 10.0.0-beta.46

package/bin/uxf-i18n-namespaces-gen.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+require("../src/uxf-i18n-namespaces-gen/cli")()
+    .then((exitCode) => {
+        process.exitCode = exitCode;
+    })
+    .catch(() => {
+        process.exitCode = 1;
+    });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxf/scripts",
-  "version": "10.0.0-beta.45",
+  "version": "10.0.0-beta.46",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -26,6 +26,7 @@
     "@commitlint/parse": "^12.1.1",
     "axios": "^0.20.0",
     "cheerio": "^1.0.0-rc.3",
+    "madge": "6.1.0",
     "moment": "^2.29.0",
     "yargs": "^16.0.3"
   }

package/src/uxf-i18n-namespaces-gen/cli.js

@@ -0,0 +1,26 @@
+const { argv, env } = require("process");
+
+module.exports = async () => {
+    const cli = require("yargs")
+        .command("$0", "UXF i18n namespaces generator", (yargs) => {
+            yargs.demandCommand(0, 0).usage(`UXF i18n namespaces generator
+Usage:
+  uxf-i18n-namespaces-gen [options]`);
+        })
+        .option("h", { alias: "help", group: "Options" })
+        .strict(false)
+        .exitProcess(false);
+
+    try {
+        const { help, ...options } = cli.parse(argv.slice(2));
+
+        if (Boolean(help)) {
+            return 0;
+        }
+
+        await require("./index");
+    } catch (e) {
+        console.error(e);
+        return 1;
+    }
+};

package/src/uxf-i18n-namespaces-gen/index.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+const madge = require("madge");
+const path = require("path");
+const fs = require("fs");
+const { readFileSync, readdirSync, writeFileSync } = require("fs");
+const join = require("node:path").join;
+
+const INCLUDE = ["src"];
+const EXCLUDE = [];
+
+const FILE_EXTENSIONS = ["ts", "tsx"];
+
+const TS_CONFIG_PATH = path.resolve(process.cwd(), "tsconfig.json");
+const TS_CONFIG = fs.existsSync(TS_CONFIG_PATH) ? TS_CONFIG_PATH : undefined;
+
+const result = { "*": ["common"] };
+
+function removeTrailingSlash(str) {
+    return str.replace(/\/$/, "");
+}
+
+const walk = (dirPath) => {
+    const dir = readdirSync(dirPath, { withFileTypes: true });
+
+    return dir.map((entry) => {
+        const childPath = join(dirPath, entry.name);
+
+        return entry.isDirectory() ? walk(childPath) : childPath;
+    });
+};
+
+const findTFunctionNamespaces = (pageContent) => {
+    const regex = /\bt\("([^:]+):[^"]+"\)/g;
+    const matches = pageContent.matchAll(regex);
+    const namespaces = new Set();
+
+    for (const match of matches) {
+        const translationKey = match[0];
+        const separatorIndex = translationKey.indexOf(":");
+        if (separatorIndex !== -1) {
+            const namespace = translationKey.substring(3, separatorIndex);
+            namespaces.add(namespace);
+        }
+    }
+
+    return Array.from(namespaces);
+};
+
+const findTransComponentNamespaces = (pageContent) => {
+    const regex = /<Trans[^>]*?i18nKey=(['"])(.*?)\1[^>]*\/>/g;
+    const matches = pageContent.matchAll(regex);
+    const namespaces = new Set();
+
+    for (const match of matches) {
+        const [, , translationKey] = match;
+        const separatorIndex = translationKey.indexOf(":");
+        if (separatorIndex !== -1) {
+            const namespace = translationKey.substring(0, separatorIndex);
+            namespaces.add(namespace);
+        }
+    }
+
+    return Array.from(namespaces);
+};
+
+const findNamespaces = (pageContent) => {
+    const namespaces = [...findTFunctionNamespaces(pageContent), ...findTransComponentNamespaces(pageContent)];
+
+    return Array.from(new Set(namespaces));
+};
+
+const getTree = (subtree, tree, destination, viewedFiles = []) => {
+    if (!subtree || subtree.length === 0) {
+        return;
+    }
+
+    for (let child of subtree) {
+        if (viewedFiles.includes(child)) {
+            continue;
+        }
+
+        const nextSubtree = tree[child];
+
+        viewedFiles.push(child);
+
+        if (nextSubtree) {
+            destination.push(nextSubtree);
+        }
+
+        if (nextSubtree && nextSubtree.length > 0) {
+            getTree(nextSubtree, tree, destination, viewedFiles);
+        }
+    }
+};
+
+const filePathToRoute = (filePath) => {
+    const route = filePath.replace("src/pages", "").replace(".tsx", "").replace("/index", "/");
+
+    if (route === "/") {
+        return route;
+    }
+
+    return removeTrailingSlash(route);
+};
+
+function main() {
+    // Negative lookahead – ignore searching for any files
+    // that aren't part of our include list
+    const searchDirs = new RegExp(`^(?!(${INCLUDE.join("|")}))`, "i");
+
+    const pages = walk("src/pages").flat(Number.POSITIVE_INFINITY);
+
+    madge(process.cwd(), {
+        tsConfig: TS_CONFIG,
+        excludeRegExp: [searchDirs, ...EXCLUDE],
+        fileExtensions: FILE_EXTENSIONS,
+    }).then((res) => {
+        const tree = res.obj();
+
+        for (const entryPoint of pages) {
+            let namespaces = [];
+            const filesOnPath = [];
+
+            getTree([entryPoint], tree, filesOnPath);
+
+            const flattenFilesOnPath = Array.from(new Set(filesOnPath.flat(Number.POSITIVE_INFINITY)));
+
+            for (const file of flattenFilesOnPath) {
+                const fileContent = readFileSync(file).toString();
+
+                namespaces = [...namespaces, ...findNamespaces(fileContent)];
+            }
+
+            namespaces = Array.from(new Set(namespaces)).sort();
+
+            const page = filePathToRoute(entryPoint);
+
+            if (namespaces.length > 0) {
+                result[page] = namespaces;
+            }
+        }
+
+        writeFileSync(path.resolve(process.cwd(), "i18n-pages.json"), JSON.stringify(result, null, 4));
+
+        console.log("Namespaces generated!");
+    });
+}
+
+try {
+    main();
+} catch (e) {
+    console.error("Error:", e);
+}