@uxf/scripts 11.74.5 → 11.76.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/scripts",
-    "version": "11.74.5",
+    "version": "11.76.0",
     "description": "",
     "main": "index.js",
     "bin": {

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

@@ -11,19 +11,18 @@ module.exports = async () => {
         .option("o", { alias: "output", default: "i18n-pages.json" })
         .option("n", { alias: "defaultNamespace", array: true, default: ["common"] })
         .option("p", { alias: "pagesDirectory", default: "src/pages" })
-        .option("e", { alias: "fileExtension", array: true, default: ["ts", "tsx"] })
         .option("h", { alias: "help" })
         .strict(false)
         .exitProcess(false);
 
     try {
-        const { help, include, output, defaultNamespace, pagesDirectory, fileExtension } = cli.parse(argv.slice(2));
+        const { help, include, output, defaultNamespace, pagesDirectory } = cli.parse(argv.slice(2));
 
         if (Boolean(help)) {
             return 0;
         }
 
-        await require("./index")(include, output, defaultNamespace, pagesDirectory, fileExtension);
+        await require("./index")(include, output, defaultNamespace, pagesDirectory);
     } catch (e) {
         console.error(e);
         return 1;

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

@@ -1,14 +1,134 @@
 #!/usr/bin/env node
 const madge = require("madge");
 const path = require("path");
-const fs = require("fs");
-const { readFileSync, readdirSync, writeFileSync } = require("fs");
+const { readFileSync, readdirSync, writeFileSync, statSync, existsSync } = require("fs");
 const { findTFunctionNamespaces } = require("./utils/find-t-function-namespaces");
 const { findTransComponentNamespaces } = require("./utils/find-trans-component-namespaces");
 const join = require("node:path").join;
 
+const UXF_PACKAGES_PATH = "node_modules/@uxf";
+const FILE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "tsx", "d.ts", "mts", "cts", "d.mts", "d.cts"];
 const TS_CONFIG_PATH = path.resolve(process.cwd(), "tsconfig.json");
-const TS_CONFIG = fs.existsSync(TS_CONFIG_PATH) ? TS_CONFIG_PATH : undefined;
+const TS_CONFIG = existsSync(TS_CONFIG_PATH) ? TS_CONFIG_PATH : undefined;
+
+// Lazy-read tsconfig for paths alias resolution
+let TS_PATHS_CACHE = null;
+function getTsPaths() {
+    if (!TS_CONFIG) return null;
+    if (TS_PATHS_CACHE) return TS_PATHS_CACHE;
+    try {
+        const raw = JSON.parse(readFileSync(TS_CONFIG, "utf8"));
+        const compilerOptions = raw && raw.compilerOptions ? raw.compilerOptions : {};
+        const baseUrl = compilerOptions.baseUrl ? path.resolve(process.cwd(), compilerOptions.baseUrl) : process.cwd();
+        const paths = compilerOptions.paths || {};
+        TS_PATHS_CACHE = { baseUrl, paths };
+        return TS_PATHS_CACHE;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Check if a file is allowed to be scanned for translations.
+ * @param {string} file
+ * @returns {boolean}
+ */
+function isAllowedFile(file) {
+    return !file.includes("node_modules") || file.includes(UXF_PACKAGES_PATH);
+}
+
+/**
+ * Resolve a module specifier (bare, relative, or absolute) to a real filesystem path if possible.
+ * Falls back to the original specifier when not resolvable.
+ * Only allows project files and node_modules/@uxf/* to avoid scanning the entire npm tree.
+ * @param {string} spec
+ * @returns {string}
+ */
+function resolveModuleSpecifier(spec) {
+    try {
+        if (!spec || typeof spec !== "string") return spec;
+        if (existsSync(spec)) return spec;
+
+        const ts = getTsPaths();
+        if (ts?.paths) {
+            for (const [pattern, targets] of Object.entries(ts.paths)) {
+                const starIndex = pattern.indexOf("*");
+
+                if (starIndex !== -1) {
+                    const prefix = pattern.slice(0, starIndex);
+                    const suffix = pattern.slice(starIndex + 1);
+
+                    if (spec.startsWith(prefix) && spec.endsWith(suffix)) {
+                        const middle = spec.slice(prefix.length, spec.length - suffix.length);
+
+                        for (const target of targets) {
+                            const mapped = target.includes("*") ? target.replace("*", middle) : target;
+
+                            const candidates = [
+                                path.resolve(ts.baseUrl, mapped),
+                                ...FILE_EXTENSIONS.map((e) => path.resolve(ts.baseUrl, mapped + e)),
+                                ...FILE_EXTENSIONS.map((e) => path.join(ts.baseUrl, mapped, "index" + e)),
+                            ].find(existsSync);
+
+                            if (candidates) return candidates;
+                        }
+                    }
+                } else if (spec === pattern) {
+                    const candidate = targets.map((t) => path.resolve(ts.baseUrl, t)).find(existsSync);
+                    if (candidate) return candidate;
+                }
+            }
+        }
+
+        const resolved = require.resolve(spec, { paths: [process.cwd()] });
+        return isAllowedFile(resolved) ? resolved : spec;
+    } catch {
+        return spec;
+    }
+}
+
+/**
+ * Resolve import specifier in the context of a file path (handles relative imports correctly).
+ * @param {string} spec
+ * @param {string} fromFile
+ * @returns {string}
+ */
+function resolveImportFrom(spec, fromFile) {
+    try {
+        if (!spec || typeof spec !== "string") return spec;
+
+        // Relative path from the file's directory
+        if (spec.startsWith(".")) {
+            const baseDir = path.dirname(fromFile);
+            let candidate = path.resolve(baseDir, spec);
+
+            // Try as file
+            for (const e of FILE_EXTENSIONS) {
+                const c = candidate + e;
+                if (existsSync(c)) return c;
+            }
+            // Try as directory index
+            if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+                for (const e of FILE_EXTENSIONS) {
+                    const idx = path.join(candidate, "index" + e);
+                    if (existsSync(idx)) return idx;
+                }
+            }
+
+            // Fallback to Node resolver with file dir as base
+            const resolved = require.resolve(spec, { paths: [baseDir] });
+            if (isAllowedFile(resolved)) {
+                return resolved;
+            }
+            return spec;
+        }
+
+        // Bare/absolute spec
+        return resolveModuleSpecifier(spec);
+    } catch (_e) {
+        return spec;
+    }
+}
 
 function removeTrailingSlash(str) {
     return str.replace(/\/$/, "");
@@ -64,83 +184,101 @@ const filePathToRoute = (filePath) => {
     return removeTrailingSlash(route);
 };
 
-/**
- * Resolves re-exports to find the actual implementation files
- * @param {string} filePath - The file path to check for re-exports
- * @returns {string[]} - Array of resolved file paths
- */
-function resolveReexports(filePath) {
-    if (filePath.includes("node_modules") && !filePath.includes("node_modules/@uxf/")) {
-        return [];
-    }
-
-    const resolvedFiles = [];
+async function getMadgeTree(entries, include) {
+    // Build madge options; allow traversing UXF packages in node_modules.
+    const options = {
+        tsConfig: TS_CONFIG,
+        fileExtensions: FILE_EXTENSIONS,
+        includeNpm: true,
+        dependencyFilter: (dependency) => {
+            return !dependency.includes("node_modules") || dependency.includes(UXF_PACKAGES_PATH);
+        },
+    };
 
-    if (!fs.existsSync(filePath)) {
-        return [filePath];
+    // If include is provided, limit traversal to those prefixes AND node_modules/@uxf.
+    if (Array.isArray(include) && include.length > 0) {
+        const allowedPrefixes = [...include, UXF_PACKAGES_PATH];
+        const searchDirs = new RegExp(`^(?!(${allowedPrefixes.join("|")}))`, "i");
+        options.excludeRegExp = [searchDirs];
     }
 
-    try {
-        const content = fs.readFileSync(filePath, "utf8");
+    const res = await madge(entries, options);
+    return res.obj();
+}
 
-        // Check if this is a re-export file with relative imports (contains export { } from or export * from "./file")
-        // Absolute imports (export * from "@package/module") are already handled by madge
-        const reexportMatches = content.match(/export\s*(?:\{[^}]*\}|\*)\s*from\s*['"](\.[^'"]+)['"]/g);
+async function getFiles(entryPoint, tree) {
+    const filesOnPath = [];
 
-        if (reexportMatches) {
-            const fileDir = path.dirname(filePath);
+    // Always include the entry point file itself (for cases when page does not import anything with translations)
+    filesOnPath.push(entryPoint);
 
-            for (const match of reexportMatches) {
-                const pathMatch = match.match(/from\s*['"]([^'"]+)['"]/);
-                if (pathMatch) {
-                    let relativePath = pathMatch[1];
+    getTree([entryPoint], tree, filesOnPath);
 
-                    // Resolve relative path
-                    let resolvedPath = path.resolve(fileDir, relativePath);
+    let flattenFilesOnPath = Array.from(new Set(filesOnPath.flat(Number.POSITIVE_INFINITY)));
 
-                    // Try different extensions if file doesn't exist
-                    const extensions = [".ts", ".tsx", ".js", ".jsx"];
-                    let foundFile = false;
+    // Helper: extract module specifiers from file content
+    const extractSpecs = (content) => {
+        const specs = new Set();
+        const reImportFrom = /import\s+[^'"\n;]*?from\s*['"]([^'"\n]+)['"]/g;
+        const reDynamicImport = /import\s*\(\s*['"]([^'"\n]+)['"]\s*\)/g;
+        const reRequire = /require\(\s*['"]([^'"\n]+)['"]\s*\)/g;
+        const reExportFrom = /export\s*(?:\{[^}]*\}|\*)\s*from\s*['"]([^'"\n]+)['"]/g;
+        for (const re of [reImportFrom, reDynamicImport, reRequire, reExportFrom]) {
+            for (const m of content.matchAll(re)) {
+                if (m && m[1]) specs.add(m[1]);
+            }
+        }
+        return Array.from(specs);
+    };
 
-                    for (const ext of extensions) {
-                        const pathWithExt = resolvedPath + ext;
-                        if (fs.existsSync(pathWithExt)) {
-                            resolvedFiles.push(pathWithExt);
-                            foundFile = true;
-                            break;
-                        }
+    // Resolve re-exports to get actual component files and traverse imports recursively
+    const resolvedFiles = [];
+    const queue = [];
+    const visited = new Set();
+
+    // Seed queue with initial files from madge tree
+    for (const file of flattenFilesOnPath) {
+        if (file && typeof file === "string") {
+            const fsPath = resolveModuleSpecifier(file);
+            if (typeof fsPath === "string") {
+                try {
+                    if (isAllowedFile(fsPath) && statSync(fsPath).isFile()) {
+                        queue.push(fsPath);
                     }
+                } catch {}
+            }
+        }
+    }
 
-                    // If still not found, check if it's a directory with index file
-                    if (!foundFile && fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
-                        for (const ext of extensions) {
-                            const indexPath = path.join(resolvedPath, "index" + ext);
-                            if (fs.existsSync(indexPath)) {
-                                // Recursively resolve if the index file also has re-exports
-                                resolvedFiles.push(...resolveReexports(indexPath));
-                                foundFile = true;
-                                break;
+    while (queue.length > 0) {
+        const fsPath = queue.shift();
+        if (!fsPath || visited.has(fsPath)) continue;
+        visited.add(fsPath);
+        resolvedFiles.push(fsPath);
+
+        if (!existsSync(fsPath)) continue;
+
+        // Scan direct imports/requires/exports-from and follow them
+        try {
+            const content = readFileSync(fsPath, "utf8");
+            const specs = extractSpecs(content);
+            for (const spec of specs) {
+                const p = resolveImportFrom(spec, fsPath);
+                // Only follow project files and UXF packages (resolvers already filter others)
+                if (typeof p === "string" && (!p.includes("node_modules") || p.includes(UXF_PACKAGES_PATH))) {
+                    if (!visited.has(p)) {
+                        try {
+                            if (isAllowedFile(fsPath) && statSync(p).isFile()) {
+                                queue.push(p);
                             }
-                        }
-                    }
-
-                    if (!foundFile) {
-                        console.warn(`Could not resolve re-export: ${relativePath} from ${filePath}`);
+                        } catch {}
                     }
                 }
             }
-
-            // If we found re-exports, don't include the original index file
-            if (resolvedFiles.length > 0) {
-                return resolvedFiles;
-            }
-        }
-    } catch (error) {
-        console.warn(`Error reading file ${filePath}:`, error.message);
+        } catch {}
     }
 
-    // If no re-exports found or error occurred, return the original file
-    return [filePath];
+    return Array.from(new Set(resolvedFiles));
 }
 
 /**
@@ -148,76 +286,47 @@ function resolveReexports(filePath) {
  * @param output string
  * @param defaultNamespaces string[]
  * @param pagesDirectory string
- * @param fileExtensions string[]
  */
-function main(include, output, defaultNamespaces, pagesDirectory, fileExtensions) {
+async function main(include, output, defaultNamespaces, pagesDirectory) {
     const result = { "*": defaultNamespaces };
-    // 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(pagesDirectory).flat(Number.POSITIVE_INFINITY);
 
-    madge(process.cwd(), {
-        tsConfig: TS_CONFIG,
-        excludeRegExp: [searchDirs],
-        fileExtensions: fileExtensions,
-        includeNpm: true,
-        dependencyFilter: (dependency) => {
-            return !dependency.includes("node_modules") || dependency.includes("node_modules/@uxf");
-        },
-    }).then((res) => {
-        const tree = res.obj();
-
-        for (const entryPoint of pages) {
-            let namespaces = [];
-            const filesOnPath = [];
-
-            // Always include the entry point file itself (for cases when page does not import anything with translations)
-            filesOnPath.push(entryPoint);
+    // Build a global dependency tree rooted at project to leverage madge resolution across aliases/packages
+    const tree = await getMadgeTree(process.cwd(), include);
 
-            getTree([entryPoint], tree, filesOnPath);
+    for (const entryPoint of pages) {
+        let namespaces = [];
 
-            let flattenFilesOnPath = Array.from(new Set(filesOnPath.flat(Number.POSITIVE_INFINITY)));
+        const uniqueResolvedFiles = await getFiles(entryPoint, tree);
 
-            // Resolve re-exports to get actual component files
-            const resolvedFiles = [];
-            for (const file of flattenFilesOnPath) {
-                if (file && typeof file === "string") {
-                    resolvedFiles.push(...resolveReexports(file));
-                }
+        for (const file of uniqueResolvedFiles) {
+            if (!file || !existsSync(file)) {
+                continue;
             }
 
-            const uniqueResolvedFiles = Array.from(new Set(resolvedFiles));
-
-            for (const file of uniqueResolvedFiles) {
-                if (!file || !fs.existsSync(file)) {
-                    continue;
-                }
-
-                try {
-                    const fileContent = readFileSync(file).toString();
-                    const fileNamespaces = findNamespaces(fileContent);
+            try {
+                const fileContent = readFileSync(file).toString();
+                const fileNamespaces = findNamespaces(fileContent);
 
-                    namespaces = [...namespaces, ...fileNamespaces];
-                } catch (error) {
-                    console.warn(`Error reading file ${file}:`, error.message);
-                }
+                namespaces = [...namespaces, ...fileNamespaces];
+            } catch (error) {
+                console.warn(`Error reading file ${file}:`, error.message);
             }
+        }
 
-            namespaces = Array.from(new Set(namespaces)).sort();
+        namespaces = Array.from(new Set(namespaces)).sort();
 
-            const page = filePathToRoute(entryPoint);
+        const page = filePathToRoute(entryPoint);
 
-            if (namespaces.length > 0) {
-                result[page] = namespaces;
-            }
+        if (namespaces.length > 0) {
+            result[page] = namespaces;
         }
+    }
 
-        writeFileSync(path.resolve(process.cwd(), output), JSON.stringify(result, null, 4));
+    writeFileSync(path.resolve(process.cwd(), output), JSON.stringify(result, null, 4));
 
-        console.log("Namespaces generated!");
-    });
+    console.log("Namespaces generated!");
 }
 
 module.exports = main;