ngx-locatorjs 0.1.0

package/dist/node/config-setup.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const root = process.cwd();
+const CONFIG_FILENAME = 'ngx-locatorjs.config.json';
+const PROXY_FILENAME = 'ngx-locatorjs.proxy.json';
+const configPath = path.resolve(root, CONFIG_FILENAME);
+const proxyConfigPath = resolveProxyConfigPath();
+console.log('🚀 LocatorJs (Open-in-Editor) Configuration Setup\n');
+if (fs.existsSync(configPath)) {
+    console.log(`⚠️  ${CONFIG_FILENAME} already exists!`);
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    rl.question('Do you want to overwrite it? (y/N): ', (answer) => {
+        rl.close();
+        if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+            console.log('Setup cancelled.');
+            process.exit(0);
+        }
+        startSetup();
+    });
+}
+else {
+    startSetup();
+}
+async function startSetup() {
+    try {
+        const config = {
+            port: await promptPort(),
+            workspaceRoot: await promptWorkspaceRoot(),
+            editor: await selectEditor(),
+            fallbackEditor: 'code',
+            scan: await promptScanSettings(),
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        const proxyConfig = {
+            '/__open-in-editor': {
+                target: `http://localhost:${config.port}`,
+                secure: false,
+                changeOrigin: true,
+            },
+            '/__open-in-editor-search': {
+                target: `http://localhost:${config.port}`,
+                secure: false,
+                changeOrigin: true,
+            },
+            '/__cmp-map': {
+                target: `http://localhost:${config.port}`,
+                secure: false,
+                changeOrigin: true,
+            },
+        };
+        const mergedProxyConfig = mergeProxyConfig(proxyConfigPath, proxyConfig);
+        fs.writeFileSync(proxyConfigPath, JSON.stringify(mergedProxyConfig, null, 2));
+        console.log('\n✅ Configuration saved successfully!');
+        console.log(`📁 Config: ${path.relative(root, configPath)}`);
+        console.log(`🔗 Proxy: ${path.relative(root, proxyConfigPath)} (port: ${config.port})`);
+        ensureGitignoreEntries(['.open-in-editor/']);
+        console.log('\n🔍 Running component scan...');
+        const scanScript = path.resolve(__dirname, 'cmp-scan.js');
+        if (fs.existsSync(scanScript)) {
+            try {
+                const scanProcess = spawn(process.execPath, [scanScript], {
+                    stdio: 'inherit',
+                    cwd: root,
+                });
+                scanProcess.on('close', (code) => {
+                    if (code === 0) {
+                        console.log('\n✅ Component scan completed!');
+                        printNextSteps(proxyConfigPath);
+                    }
+                    else {
+                        console.log('\n⚠️  Component scan failed, but config is saved.');
+                        printManualScan(proxyConfigPath);
+                    }
+                });
+            }
+            catch {
+                console.log('\n⚠️  Could not run component scan automatically.');
+                printManualScan(proxyConfigPath);
+            }
+        }
+        else {
+            console.log('\n⚠️  scan script not found.');
+            printManualScan(proxyConfigPath);
+        }
+    }
+    catch (error) {
+        console.error('\n❌ Setup failed:', error?.message || error);
+        process.exit(1);
+    }
+}
+function printManualScan(proxyPath) {
+    console.log('Please run it manually: npx locatorjs-scan');
+    printNextSteps(proxyPath);
+}
+function printNextSteps(proxyPath) {
+    console.log('\n🚀 Next steps:');
+    console.log('   npx locatorjs-open-in-editor');
+    console.log(`   (run your Angular dev server with --proxy-config ${path.relative(root, proxyPath)})`);
+}
+function mergeProxyConfig(proxyConfigPath, addition) {
+    const existing = readProxyConfig(proxyConfigPath);
+    if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+        return {
+            ...existing,
+            ...addition,
+        };
+    }
+    if (fs.existsSync(proxyConfigPath)) {
+        console.log('⚠️  Existing proxy config is not valid JSON. Overwriting with locator config.');
+    }
+    return addition;
+}
+function readProxyConfig(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        const existing = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+            return existing;
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return null;
+}
+function resolveProxyConfigPath() {
+    const angularProxyPath = findProxyConfigFromAngularJson();
+    if (angularProxyPath) {
+        if (path.extname(angularProxyPath) !== '.json') {
+            console.log(`⚠️  proxyConfig in angular.json is not a JSON file (${path.basename(angularProxyPath)}). Creating ${PROXY_FILENAME} instead.`);
+            return path.resolve(root, PROXY_FILENAME);
+        }
+        return angularProxyPath;
+    }
+    const defaultProxy = path.resolve(root, 'proxy.conf.json');
+    if (fs.existsSync(defaultProxy))
+        return defaultProxy;
+    return path.resolve(root, PROXY_FILENAME);
+}
+function findProxyConfigFromAngularJson() {
+    const angularJsonPath = path.resolve(root, 'angular.json');
+    if (!fs.existsSync(angularJsonPath))
+        return null;
+    try {
+        const angularJson = JSON.parse(fs.readFileSync(angularJsonPath, 'utf8'));
+        const projects = angularJson?.projects ?? {};
+        for (const project of Object.values(projects)) {
+            const targets = project?.architect || project?.targets;
+            const serve = targets?.serve;
+            if (!serve)
+                continue;
+            const direct = serve?.options?.proxyConfig;
+            if (typeof direct === 'string' && direct.trim().length > 0) {
+                return path.resolve(root, direct);
+            }
+            const configurations = serve?.configurations;
+            if (configurations && typeof configurations === 'object') {
+                for (const config of Object.values(configurations)) {
+                    const confProxy = config?.proxyConfig;
+                    if (typeof confProxy === 'string' && confProxy.trim().length > 0) {
+                        return path.resolve(root, confProxy);
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // ignore parse errors
+    }
+    return null;
+}
+function ensureGitignoreEntries(entries) {
+    const gitignorePath = path.resolve(root, '.gitignore');
+    if (!fs.existsSync(gitignorePath))
+        return;
+    const content = fs.readFileSync(gitignorePath, 'utf8');
+    const lines = content.split(/\r?\n/);
+    const missing = entries.filter((entry) => !lines.includes(entry));
+    if (missing.length === 0)
+        return;
+    const suffix = content.endsWith('\n') ? '' : '\n';
+    const block = `${suffix}# ngx-locatorjs\n${missing.join('\n')}\n`;
+    fs.appendFileSync(gitignorePath, block);
+    console.log(`🧹 Added to .gitignore: ${missing.join(', ')}`);
+}
+function promptPort() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question('🔌 Enter port number (press Enter for default: 4123): ', (answer) => {
+            rl.close();
+            const port = answer.trim();
+            const portNum = port === '' ? 4123 : parseInt(port, 10) || 4123;
+            console.log(`   → Port: ${portNum}`);
+            resolve(portNum);
+        });
+    });
+}
+function promptWorkspaceRoot() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log(`\n📁 Current directory: ${process.cwd()}`);
+    const askWorkspaceRoot = () => {
+        return new Promise((resolve) => {
+            rl.question('📁 Enter workspace root (press Enter for current directory "."): ', (answer) => {
+                const workspaceRoot = answer.trim();
+                const result = workspaceRoot === '' ? '.' : workspaceRoot;
+                const resolvedPath = path.resolve(process.cwd(), result);
+                if (!fs.existsSync(resolvedPath)) {
+                    console.log(`   ❌ Path does not exist: ${resolvedPath}`);
+                    console.log('   Please try again...\n');
+                    askWorkspaceRoot().then(resolve);
+                    return;
+                }
+                const stat = fs.statSync(resolvedPath);
+                if (!stat.isDirectory()) {
+                    console.log(`   ❌ Path is not a directory: ${resolvedPath}`);
+                    console.log('   Please try again...\n');
+                    askWorkspaceRoot().then(resolve);
+                    return;
+                }
+                console.log(`   → Workspace root: ${result}`);
+                console.log(`   → Resolved path: ${resolvedPath}`);
+                rl.close();
+                resolve(result);
+            });
+        });
+    };
+    return askWorkspaceRoot();
+}
+function selectEditor() {
+    const availableEditors = [
+        { name: 'Cursor', value: 'cursor' },
+        { name: 'VS Code', value: 'code' },
+        { name: 'WebStorm', value: 'webstorm' },
+    ];
+    if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== 'function') {
+        console.log('\n🎯 Please select your editor:');
+        availableEditors.forEach((editor, index) => {
+            console.log(`   ${index + 1}. ${editor.name}`);
+        });
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question('\nEnter number (1-3, default: 1 for Cursor): ', (answer) => {
+                rl.close();
+                const choice = parseInt(answer.trim(), 10) || 1;
+                const selected = availableEditors[Math.max(0, Math.min(choice - 1, availableEditors.length - 1))];
+                console.log(`   → Selected: ${selected.name}`);
+                resolve(selected.value);
+            });
+        });
+    }
+    let selectedIndex = 0;
+    const renderMenu = () => {
+        console.clear();
+        console.log('\n🎯 Please select your editor:');
+        console.log('   Use ↑↓ to navigate, Enter to select (default: Cursor)\n');
+        availableEditors.forEach((editor, index) => {
+            const isSelected = index === selectedIndex;
+            const pointer = isSelected ? '▶' : ' ';
+            const highlight = isSelected ? '\x1b[36m' : '';
+            const reset = isSelected ? '\x1b[0m' : '';
+            console.log(`${highlight}${pointer} ${editor.name}${reset}`);
+        });
+    };
+    return new Promise((resolve) => {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        renderMenu();
+        const handleKeypress = (key) => {
+            switch (key) {
+                case '\u001b[A':
+                    selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : availableEditors.length - 1;
+                    renderMenu();
+                    break;
+                case '\u001b[B':
+                    selectedIndex = selectedIndex < availableEditors.length - 1 ? selectedIndex + 1 : 0;
+                    renderMenu();
+                    break;
+                case '\r':
+                case '\n':
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    process.stdin.removeListener('data', handleKeypress);
+                    const selected = availableEditors[selectedIndex];
+                    console.log(`\n✨ Selected: ${selected.name}`);
+                    resolve(selected.value);
+                    break;
+                case '\u0003':
+                    console.log('\n\nCancelled. Setting Cursor as default.');
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    resolve('cursor');
+                    break;
+            }
+        };
+        process.stdin.on('data', handleKeypress);
+    });
+}
+function promptScanSettings() {
+    const defaultInclude = [
+        'src/**/*.{ts,tsx}',
+        'projects/**/*.{ts,tsx}',
+        'apps/**/*.{ts,tsx}',
+        'libs/**/*.{ts,tsx}',
+    ];
+    const defaultExclude = [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/.angular/**',
+        '**/coverage/**',
+        '**/*.spec.ts',
+        '**/*.test.ts',
+        '**/*.e2e.ts',
+    ];
+    console.log('\n📂 Scan settings (using defaults):');
+    console.log(`   → Include: ${JSON.stringify(defaultInclude)}`);
+    console.log(`   → Exclude: ${JSON.stringify(defaultExclude)}`);
+    console.log(`   💡 You can modify these later in ${CONFIG_FILENAME}`);
+    return Promise.resolve({
+        includeGlobs: defaultInclude,
+        excludeGlobs: defaultExclude,
+    });
+}

package/dist/node/file-opener.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import express from 'express';
+import fs from 'fs';
+import path from 'path';
+import childProcess from 'child_process';
+const root = process.cwd();
+const CONFIG_FILENAME = 'ngx-locatorjs.config.json';
+const configPath = path.resolve(root, CONFIG_FILENAME);
+if (!fs.existsSync(configPath)) {
+    console.log(`🚀 ${CONFIG_FILENAME} not found!`);
+    console.log('Please run: npx locatorjs-config');
+    console.log('Or manually create the config file.');
+    process.exit(1);
+}
+const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+const PORT = Number(process.env.OPEN_IN_EDITOR_PORT || cfg.port || 4123);
+const MAP_PATH = path.resolve(root, '.open-in-editor/component-map.json');
+const editorCLICache = {};
+function checkEditorCLI(editorName, cliCommand = editorName) {
+    if (editorCLICache[editorName] !== undefined)
+        return editorCLICache[editorName];
+    try {
+        childProcess.execSync(`which ${cliCommand}`, { stdio: 'ignore' });
+        editorCLICache[editorName] = true;
+        console.log(`[file-opener] ${editorName} CLI found, using precise line navigation`);
+    }
+    catch {
+        editorCLICache[editorName] = false;
+        console.log(`[file-opener] ${editorName} CLI not found, using fallback method`);
+    }
+    return editorCLICache[editorName];
+}
+const MAC_APP_NAMES = {
+    cursor: 'Cursor',
+    code: 'Visual Studio Code',
+    webstorm: 'WebStorm',
+};
+function detectAvailableEditors() {
+    const editors = ['cursor', 'code', 'webstorm'];
+    const available = [];
+    for (const editor of editors) {
+        if (checkEditorCLI(editor)) {
+            available.push({ name: editor, hasCliPrecision: true });
+        }
+    }
+    return available;
+}
+const AVAILABLE_EDITORS = detectAvailableEditors();
+const DEFAULT_EDITOR = process.env.LAUNCH_EDITOR || cfg.editor || AVAILABLE_EDITORS[0]?.name || 'cursor';
+const FALLBACK_EDITOR = cfg.fallbackEditor || AVAILABLE_EDITORS[1]?.name || 'code';
+const COMMAND_TEMPLATES = {
+    cursor: (file) => {
+        if (checkEditorCLI('cursor')) {
+            return ['cursor', ['--goto', file]];
+        }
+        const filePath = file.split(':')[0];
+        return ['open', ['-a', MAC_APP_NAMES.cursor, filePath]];
+    },
+    code: (file) => {
+        if (checkEditorCLI('code')) {
+            return ['code', ['--goto', file]];
+        }
+        const filePath = file.split(':')[0];
+        return ['open', ['-a', MAC_APP_NAMES.code, filePath]];
+    },
+    webstorm: (file) => {
+        if (checkEditorCLI('webstorm')) {
+            const [filePath, line, col] = file.split(':');
+            const args = [filePath];
+            if (line)
+                args.push('--line', line);
+            if (col)
+                args.push('--column', col);
+            return ['webstorm', args];
+        }
+        const filePath = file.split(':')[0];
+        return ['open', ['-a', MAC_APP_NAMES.webstorm, filePath]];
+    },
+};
+function launchInEditor(fileWithPos, preferred = DEFAULT_EDITOR) {
+    if (process.env.EDITOR_CMD) {
+        const [cmd, ...rest] = process.env.EDITOR_CMD.split(' ');
+        try {
+            childProcess.spawn(cmd, [...rest, fileWithPos], { stdio: 'ignore', detached: true }).unref();
+            return true;
+        }
+        catch (e) {
+            console.log(`[file-opener] EDITOR_CMD failed: ${e.message}`);
+        }
+    }
+    const tryRun = (editor) => {
+        const mk = COMMAND_TEMPLATES[editor];
+        if (!mk)
+            return false;
+        const [cmd, args] = mk(fileWithPos);
+        try {
+            childProcess.spawn(cmd, args, { stdio: 'ignore', detached: true }).unref();
+            return true;
+        }
+        catch (e) {
+            console.log(`[file-opener] ${editor} failed: ${e.message}`);
+            return false;
+        }
+    };
+    if (tryRun(preferred))
+        return true;
+    if (FALLBACK_EDITOR && tryRun(FALLBACK_EDITOR))
+        return true;
+    return false;
+}
+const app = express();
+app.get('/__cmp-map', (req, res) => {
+    if (!fs.existsSync(MAP_PATH))
+        return res.status(404).send('component-map.json not found');
+    res.setHeader('Content-Type', 'application/json');
+    fs.createReadStream(MAP_PATH).pipe(res);
+});
+function findBestLineInFile(filePath, searchTerms) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split('\n');
+        const scores = new Array(lines.length).fill(0);
+        searchTerms.forEach((term, termIndex) => {
+            const weight = Math.max(1, searchTerms.length - termIndex);
+            lines.forEach((line, lineIndex) => {
+                const lowerLine = line.toLowerCase();
+                const lowerTerm = term.toLowerCase();
+                if (lowerLine.includes(lowerTerm)) {
+                    scores[lineIndex] += weight * 2;
+                    if (new RegExp(`\\b${lowerTerm.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&')}\\b`).test(lowerLine)) {
+                        scores[lineIndex] += weight * 3;
+                    }
+                    if (lowerLine.trim().startsWith(lowerTerm)) {
+                        scores[lineIndex] += weight * 1.5;
+                    }
+                }
+            });
+        });
+        let bestLine = 1;
+        let bestScore = 0;
+        scores.forEach((score, index) => {
+            if (score > bestScore) {
+                bestScore = score;
+                bestLine = index + 1;
+            }
+        });
+        return bestScore > 0 ? bestLine : 1;
+    }
+    catch (e) {
+        console.warn(`[file-opener] Failed to search in file: ${e.message}`);
+        return 1;
+    }
+}
+app.get('/__open-in-editor', (req, res) => {
+    let file = req.query.file;
+    const line = req.query.line || '1';
+    const col = req.query.col || '1';
+    if (!file)
+        return res.status(400).send('file is required');
+    file = decodeURIComponent(file);
+    console.log(`[file-opener] Opening file: ${file}:${line}:${col}`);
+    const fileWithPos = `${file}:${line}:${col}`;
+    const ok = launchInEditor(fileWithPos);
+    if (!ok) {
+        return res.status(500).send('Failed to launch editor. Check PATH or set EDITOR_CMD.');
+    }
+    res.end('ok');
+});
+app.get('/__open-in-editor-search', (req, res) => {
+    let file = req.query.file;
+    const searchParam = req.query.search;
+    if (!file)
+        return res.status(400).send('file is required');
+    if (!searchParam)
+        return res.status(400).send('search terms required');
+    file = decodeURIComponent(file);
+    try {
+        const searchTerms = JSON.parse(decodeURIComponent(searchParam));
+        const bestLine = findBestLineInFile(file, searchTerms);
+        const fileWithPos = `${file}:${bestLine}:1`;
+        const ok = launchInEditor(fileWithPos);
+        if (!ok) {
+            return res.status(500).send('Failed to launch editor');
+        }
+        res.end(`Opened at line ${bestLine}`);
+    }
+    catch (e) {
+        console.warn(`[file-opener] Search error: ${e.message}`);
+        res.status(500).send('Search failed: ' + e.message);
+    }
+});
+app
+    .listen(PORT, () => {
+    console.log(`[file-opener] http://localhost:${PORT}`);
+    console.log(` - map: ${path.relative(root, MAP_PATH)}`);
+    console.log(` - editor: ${DEFAULT_EDITOR} (fallback: ${FALLBACK_EDITOR})`);
+    if (AVAILABLE_EDITORS.length > 0) {
+        console.log(' - detected editors:');
+        AVAILABLE_EDITORS.forEach((editor) => {
+            const precision = editor.hasCliPrecision ? ' (precise line navigation)' : ' (app only)';
+            console.log(`   • ${editor.name}${precision}`);
+        });
+    }
+})
+    .on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+        console.log(`[file-opener] Port ${PORT} already in use - another file:opener is already running`);
+        process.exit(0);
+    }
+    else {
+        console.error('[file-opener] Server error:', err);
+        process.exit(1);
+    }
+});

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "ngx-locatorjs",
+  "version": "0.1.0",
+  "description": "LocatorJs open-in-editor tools for Angular projects",
+  "author": "antepost24",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "angular",
+    "locatorjs",
+    "open-in-editor",
+    "devtools",
+    "component"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ea-st-ring/ngx-locator.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Ea-st-ring/ngx-locator/issues"
+  },
+  "homepage": "https://github.com/Ea-st-ring/ngx-locator#readme",
+  "main": "dist/browser/index.js",
+  "types": "dist/browser/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/browser/index.d.ts",
+      "import": "./dist/browser/index.js",
+      "default": "./dist/browser/index.js"
+    },
+    "./auto": {
+      "types": "./dist/browser/auto.d.ts",
+      "import": "./dist/browser/auto.js",
+      "default": "./dist/browser/auto.js"
+    }
+  },
+  "bin": {
+    "locatorjs-open-in-editor": "dist/node/file-opener.js",
+    "locatorjs-config": "dist/node/config-setup.js",
+    "locatorjs-scan": "dist/node/cmp-scan.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npm run build:browser && npm run build:node",
+    "build:browser": "tsc -p tsconfig.browser.json",
+    "build:node": "tsc -p tsconfig.node.json",
+    "clean": "rm -rf dist",
+    "prepare": "npm run build",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "format": "prettier --write \"**/*.{ts,tsx,js,jsx,json,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,tsx,js,jsx,json,md}\""
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "ts-morph": "^27.0.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "@types/express": "^4.17.17",
+    "@types/node": "^18.18.0",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.2.5",
+    "typescript": "^5.5.4"
+  }
+}