@uxf/velo 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# @uxf/velo
+
+A TypeScript dependency tree generator using Rust and WebAssembly.
+
+## Features
+- Fast TypeScript/TSX parsing using `swc`.
+- Aggregates i18n namespaces from components and their dependencies.
+- Generates an optimized route-to-namespace map.
+- Can be published to npm and used as a CLI.
+
+## Installation
+```bash
+npm install -g @uxf/velo
+```
+
+## Usage
+```bash
+uxf-velo <project-dir>
+```
+
+Starting from the `src/pages/` directory (standard for Next.js), it builds a dependency graph and extracts i18n namespaces (e.g., from `t("ns:key")` or `<Trans i18nKey="ns:key" />`).
+
+## Build from Source
+Requirements:
+- Rust (latest)
+- wasm-pack
+
+### Initialization
+Before the first build, run:
+```bash
+npm run init
+```
+This ensures the Rust target for WebAssembly is installed and all dependencies are present.
+
+### Building
+To build the package:
+```bash
+npm run build
+```
+
+## Production Release and Publishing
+This package includes a full publish pipeline:
+
+1. **Test the package**:
+   ```bash
+   npm run test
+   ```
+
+2. **Full Release (Automated)**:
+   ```bash
+   npm run release
+   ```
+   This script performs the following steps:
+   - Sets the Rust target for WebAssembly.
+   - Builds the WebAssembly package.
+   - Runs all tests.
+   - Increments the version (patch).
+   - Publishes to npm with public access.
+
+Alternatively, you can manually run `npm publish`. The `prepublishOnly` script will automatically ensure the package is built and tested before being sent to the npm registry.
+
+## Output Format
+The tool outputs a sorted JSON object mapping route keys to an array of unique, aggregated namespaces:
+```json
+{
+    "*": [
+        "common",
+        "auth"
+    ],
+    "/": [
+        "auth",
+        "common",
+        "uxf-form-text-input"
+    ],
+    "/about": [
+        "about",
+        "common"
+    ]
+}
+```

package/cli.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { globSync } = require('glob');
+const wasm = require('./pkg/velo.js');
+require.extensions['.ts'] = () => {};
+require.extensions['.tsx'] = () => {};
+require.extensions['.jsx'] = () => {};
+
+const projectDir = process.argv[2] || '.';
+const absoluteProjectDir = path.resolve(projectDir);
+
+if (!fs.existsSync(absoluteProjectDir)) {
+    console.error(`Error: Project directory "${projectDir}" does not exist.`);
+    process.exit(1);
+}
+
+// Load tsconfig.json if it exists
+let tsConfig = null;
+const tsConfigPath = path.join(absoluteProjectDir, 'tsconfig.json');
+if (fs.existsSync(tsConfigPath)) {
+    try {
+        const rawContent = fs.readFileSync(tsConfigPath, 'utf8');
+        // Simple comment removal (doesn't handle all cases, but should be enough for basic ones)
+        const cleanContent = rawContent.replace(/\/\/.*/g, '');
+        tsConfig = JSON.parse(cleanContent);
+    } catch (e) {
+        console.error(`Error: Failed to parse tsconfig.json (${tsConfigPath}):`, e);
+        process.exit(1);
+    }
+} else {
+    console.error(`Error: tsconfig.json (${tsConfigPath}) not found in the project directory "${projectDir}".`);
+    process.exit(1);
+}
+
+// 1. Find entrypoints in 'src/pages/' directory
+const entrypoints = globSync('src/pages/**/*.{ts,tsx}', {
+    cwd: absoluteProjectDir,
+    ignore: ['node_modules/**'],
+    nodir: true,
+    posix: true
+}).map(f => path.resolve(absoluteProjectDir, f));
+
+if (entrypoints.length === 0) {
+    console.warn('Warning: No .ts or .tsx files found in the "src/pages" directory.');
+}
+
+function readFile(filepath) {
+    try {
+        const ext = path.extname(filepath);
+        if (['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext) || ext === '') {
+            return fs.readFileSync(filepath, 'utf8');
+        }
+    } catch (e) {
+        // ignore
+    }
+    return null;
+}
+
+function resolveAlias(specifier) {
+    if (!tsConfig || !tsConfig.compilerOptions || !tsConfig.compilerOptions.paths) {
+        return null;
+    }
+    const { paths, baseUrl = '.' } = tsConfig.compilerOptions;
+    const absoluteBaseUrl = path.resolve(absoluteProjectDir, baseUrl);
+
+    for (const [alias, aliasPaths] of Object.entries(paths)) {
+        if (alias.endsWith('/*')) {
+            const prefix = alias.slice(0, -2);
+            if (specifier === prefix || specifier.startsWith(prefix + '/')) {
+                const subPath = specifier === prefix ? '' : specifier.slice(prefix.length + 1);
+                for (const aliasPath of aliasPaths) {
+                    const resolvedAliasPath = aliasPath.replace('*', subPath);
+                    const absolutePath = path.resolve(absoluteBaseUrl, resolvedAliasPath);
+                    try {
+                        return require.resolve(absolutePath);
+                    } catch (e) {}
+                }
+            }
+        } else if (alias === specifier || specifier.startsWith(alias + '/')) {
+            const subPath = specifier === alias ? '' : specifier.slice(alias.length + 1);
+            for (const aliasPath of aliasPaths) {
+                const absolutePath = subPath ? path.resolve(absoluteBaseUrl, aliasPath, subPath) : path.resolve(absoluteBaseUrl, aliasPath);
+                try {
+                    return require.resolve(absolutePath);
+                } catch (e) {}
+            }
+        }
+    }
+
+    return null;
+}
+
+function filterResolved(resolved) {
+    const nm = 'node_modules' + path.sep;
+    const uxf = nm + '@uxf' + path.sep;
+
+    const resolvedNmIndex = resolved.lastIndexOf(nm);
+    if (resolvedNmIndex !== -1 && !resolved.startsWith(uxf, resolvedNmIndex)) {
+        return null;
+    }
+
+    return resolved;
+}
+
+function resolveImport(specifier, parentPath) {
+    try {
+        // 1. Try alias resolution first
+        const aliasResolved = resolveAlias(specifier);
+        if (aliasResolved) {
+            return filterResolved(aliasResolved);
+        }
+
+        // 2. Try baseUrl resolution if not relative and baseUrl is set
+        if (!specifier.startsWith('.') && !path.isAbsolute(specifier) && tsConfig && tsConfig.compilerOptions && tsConfig.compilerOptions.baseUrl) {
+            const absoluteBaseUrl = path.resolve(absoluteProjectDir, tsConfig.compilerOptions.baseUrl);
+            try {
+                const baseUrlResolved = require.resolve(path.resolve(absoluteBaseUrl, specifier));
+                if (baseUrlResolved) {
+                    return filterResolved(baseUrlResolved);
+                }
+            } catch (e) {}
+        }
+
+        const resolved = require.resolve(specifier, {
+            paths: [path.dirname(parentPath)]
+        });
+
+        return filterResolved(resolved);
+    } catch (e) {
+        return null;
+    }
+}
+
+try {
+    const tree = wasm.build_tree_map_js(entrypoints, absoluteProjectDir, readFile, resolveImport);
+    process.stdout.write(JSON.stringify(tree, null, 4) + '\n');
+} catch (e) {
+    console.error('Error building dependency tree:', e);
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@uxf/velo",
+  "version": "0.1.0",
+  "description": "TypeScript dependency tree generator using Rust WebAssembly",
+  "main": "./pkg/velo.js",
+  "types": "./pkg/velo.d.ts",
+  "bin": {
+    "uxf-velo": "cli.js"
+  },
+  "scripts": {
+    "init": "rustup target add wasm32-unknown-unknown && npm install",
+    "build": "rustup target add wasm32-unknown-unknown && wasm-pack build --target nodejs",
+    "test": "node test_structure.js && node test_cli_format.js && node test_sort.js",
+    "lint": "cargo clippy -- -D warnings",
+    "fmt": "cargo fmt -- --check",
+    "prepublishOnly": "npm run build && npm run test",
+    "release": "npm run build && npm run test && npm version patch && npm publish --access public",
+    "dev": "node cli.js ./example"
+  },
+  "dependencies": {
+    "glob": "^11.1.0"
+  },
+  "files": [
+    "pkg/",
+    "cli.js"
+  ],
+  "devDependencies": {
+    "@headlessui/react": "^1.7.19",
+    "@uxf/form": "^11.110.0",
+    "@uxf/ui": "^11.110.0",
+    "react": "^18.3.1",
+    "typescript": "^6.0.2",
+    "wasm-pack": "^0.14.0"
+  }
+}