@uxf/scripts 11.69.2 → 11.74.0

package/package.json

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

package/src/uxf-dependencies-check/index.js

@@ -93,8 +93,10 @@ async function checkUxfDependencies(excludedPackages = new Set()) {
         for (const { name, versions } of conflicts) {
             console.log(`- ${name}: ${versions.join(", ")}`);
         }
+        process.exit(1);
     } else {
         console.log("Všechny závislosti UXF balíčků mají jednotnou verzi.");
+        process.exit(0);
     }
 }
 

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

@@ -64,6 +64,80 @@ 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) {
+    const resolvedFiles = [];
+
+    if (!fs.existsSync(filePath)) {
+        return [filePath];
+    }
+
+    try {
+        const content = fs.readFileSync(filePath, "utf8");
+
+        // Check if this is a re-export file (contains export { } from)
+        const reexportMatches = content.match(/export\s*\{[^}]*\}\s*from\s*['"]([^'"]+)['"]/g);
+
+        if (reexportMatches) {
+            const fileDir = path.dirname(filePath);
+
+            for (const match of reexportMatches) {
+                const pathMatch = match.match(/from\s*['"]([^'"]+)['"]/);
+                if (pathMatch) {
+                    let relativePath = pathMatch[1];
+
+                    // Resolve relative path
+                    let resolvedPath = path.resolve(fileDir, relativePath);
+
+                    // Try different extensions if file doesn't exist
+                    const extensions = [".ts", ".tsx", ".js", ".jsx"];
+                    let foundFile = false;
+
+                    for (const ext of extensions) {
+                        const pathWithExt = resolvedPath + ext;
+                        if (fs.existsSync(pathWithExt)) {
+                            resolvedFiles.push(pathWithExt);
+                            foundFile = true;
+                            break;
+                        }
+                    }
+
+                    // 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;
+                            }
+                        }
+                    }
+
+                    if (!foundFile) {
+                        console.warn(`Could not resolve re-export: ${relativePath} from ${filePath}`);
+                    }
+                }
+            }
+
+            // 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);
+    }
+
+    // If no re-exports found or error occurred, return the original file
+    return [filePath];
+}
+
 /**
  * @param include string[]
  * @param output string
@@ -83,6 +157,10 @@ function main(include, output, defaultNamespaces, pagesDirectory, fileExtensions
         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();
 
@@ -90,14 +168,36 @@ function main(include, output, defaultNamespaces, pagesDirectory, fileExtensions
             let namespaces = [];
             const filesOnPath = [];
 
+            // Always include the entry point file itself (for cases when page does not import anything with translations)
+            filesOnPath.push(entryPoint);
+
             getTree([entryPoint], tree, filesOnPath);
 
-            const flattenFilesOnPath = Array.from(new Set(filesOnPath.flat(Number.POSITIVE_INFINITY)));
+            let flattenFilesOnPath = Array.from(new Set(filesOnPath.flat(Number.POSITIVE_INFINITY)));
 
+            // Resolve re-exports to get actual component files
+            const resolvedFiles = [];
             for (const file of flattenFilesOnPath) {
-                const fileContent = readFileSync(file).toString();
+                if (file && typeof file === "string") {
+                    resolvedFiles.push(...resolveReexports(file));
+                }
+            }
+
+            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);
 
-                namespaces = [...namespaces, ...findNamespaces(fileContent)];
+                    namespaces = [...namespaces, ...fileNamespaces];
+                } catch (error) {
+                    console.warn(`Error reading file ${file}:`, error.message);
+                }
             }
 
             namespaces = Array.from(new Set(namespaces)).sort();