has-jsx 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Elchin Valiyev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,203 @@
+# has-jsx
+
+Detect JSX in files and strings using AST analysis.
+
+## Why has-jsx?
+
+Detecting JSX isn't as simple as checking file extensions. JavaScript and TypeScript files (`.js`, `.ts`) can contain JSX syntax. This tool uses [ast-grep](https://github.com/ast-grep/ast-grep)'s powerful AST parsing to reliably detect JSX node types from the [JSX specification](https://facebook.github.io/jsx/):
+
+- `jsx_element` - Standard tags: `<div>...</div>`
+- `jsx_self_closing_element` - Self-closing: `<Component />`
+- `jsx_fragment` - Fragments: `<>...</>`
+
+## Installation
+
+```bash
+npm install has-jsx
+```
+
+## CLI Usage
+
+### Check Files
+
+Use the `-f` or `--file` flag to check files:
+
+```bash
+has-jsx -f src/Component.tsx
+# Output: JSX detected
+# Exit code: 0
+
+has-jsx --file src/utils.ts
+# Output: No JSX detected
+# Exit code: 1
+```
+
+### Check Strings
+
+Pass source code directly without any flags:
+
+```bash
+has-jsx "const App = () => <div>Hello</div>"
+# Output: JSX detected
+# Exit code: 0
+
+has-jsx "const x = 5;"
+# Output: No JSX detected
+# Exit code: 1
+```
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `-f, --file <path>` | Check a file for JSX |
+| `--verbose` | Output results as JSON |
+| `--quiet` | Silent mode, exit code only |
+| `--version` | Show version number |
+| `--help` | Show help |
+
+### Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | JSX detected |
+| `1` | No JSX detected |
+| `2` | Error (file not found, read error, etc.) |
+
+## Programmatic API
+
+### File-based Detection
+
+Check if a file contains JSX:
+
+**ESM (recommended):**
+```javascript
+import hasJSX from 'has-jsx';
+
+const result = await hasJSX('src/Component.tsx');
+console.log(result); // true or false
+```
+
+**CommonJS:**
+```javascript
+const { hasJSX } = require('has-jsx');
+
+(async () => {
+  const result = await hasJSX('src/Component.tsx');
+  console.log(result);
+})();
+```
+
+### String-based Detection
+
+Check if a string contains JSX (synchronous, no file I/O):
+
+**ESM:**
+```javascript
+import { hasJSXInString } from 'has-jsx';
+
+const code = `
+  function App() {
+    return <div>Hello World</div>;
+  }
+`;
+
+const result = hasJSXInString(code);
+console.log(result); // true
+```
+
+**CommonJS:**
+```javascript
+const { hasJSXInString } = require('has-jsx');
+
+const code = 'const App = () => <div>Hello</div>';
+const result = hasJSXInString(code);
+console.log(result); // true
+```
+
+### API Reference
+
+#### `hasJSX(filepath: string): Promise<boolean>`
+
+Analyzes a file to detect JSX syntax.
+
+**Parameters:**
+- `filepath` - Path to the file to analyze (relative or absolute)
+
+**Returns:**
+- `Promise<boolean>` - `true` if JSX is detected, `false` otherwise
+
+**Throws:**
+- `Error` - If file doesn't exist, is not a file, or can't be read
+
+**Example:**
+
+```javascript
+import hasJSX from 'has-jsx';
+
+try {
+  const result = await hasJSX('src/Component.tsx');
+  if (result) {
+    console.log('This file contains JSX');
+  }
+} catch (error) {
+  console.error('Error:', error.message);
+}
+```
+
+#### `hasJSXInString(source: string): boolean`
+
+Analyzes a source code string to detect JSX syntax (synchronous).
+
+**Parameters:**
+- `source` - Source code string to analyze
+
+**Returns:**
+- `boolean` - `true` if JSX is detected, `false` otherwise
+
+**Throws:**
+- `TypeError` - If source is not a string
+
+**Example:**
+
+```javascript
+import { hasJSXInString } from 'has-jsx';
+
+const code = 'const Button = () => <button>Click</button>';
+const result = hasJSXInString(code);
+console.log(result); // true
+
+// No false positives for TypeScript generics
+const genericCode = 'function identity<T>(arg: T): T { return arg; }';
+console.log(hasJSXInString(genericCode)); // false
+```
+
+## How It Works
+
+1. **AST Parsing**: Uses [ast-grep](https://github.com/ast-grep/ast-grep) to parse files as TypeScript/TSX
+2. **Node Detection**: Searches the AST for JSX-specific node types defined in the [JSX specification](https://facebook.github.io/jsx/)
+3. **Reliable Results**: Avoids false positives from regex-based detection or angle brackets in comparisons
+
+## Use Cases
+
+- **Build Tools**: Determine which files need JSX transformation
+- **Linters**: Validate JSX usage against project rules
+- **Code Analysis**: Audit codebase for JSX patterns
+- **CI/CD**: Verify file types in automated pipelines
+- **Migration Tools**: Identify files during framework migrations
+
+## Requirements
+
+- Node.js >= 20.0.0
+
+## License
+
+MIT
+
+## Contributing
+
+Issues and pull requests welcome! Please ensure all tests pass before submitting:
+
+```bash
+npm test
+```

package/bin/has-jsx.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { run } from '../src/cli.js';
+
+run(process.argv).catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/dist/index.cjs

@@ -0,0 +1,63 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+let fs_promises = require("fs/promises");
+let fs = require("fs");
+let _ast_grep_napi = require("@ast-grep/napi");
+
+//#region src/utils.js
+/**
+* Reads file content from the filesystem with validation.
+*
+* @param {string} filepath - Absolute or relative path to file
+* @returns {Promise<string>} File content
+* @throws {Error} If file doesn't exist, is not a file, or can't be read
+*/
+async function readFileContent(filepath) {
+	if (!(0, fs.existsSync)(filepath)) throw new Error(`File not found: ${filepath}`);
+	if (!(0, fs.statSync)(filepath).isFile()) throw new Error(`Path is not a file: ${filepath}`);
+	return (0, fs_promises.readFile)(filepath, "utf-8");
+}
+
+//#endregion
+//#region src/detector.js
+/**
+* Detects if source code contains JSX syntax using AST analysis.
+*
+* @param {string} source - Source code to analyze
+* @returns {boolean} true if JSX is detected, false otherwise
+*/
+function containsJSX(source) {
+	try {
+		return _ast_grep_napi.tsx.parse(source).root().findAll({ rule: { any: [{ kind: "jsx_element" }, { kind: "jsx_self_closing_element" }] } }).length > 0;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/index.js
+/**
+* Checks if a file contains JSX syntax.
+*
+* @param {string} filepath - Path to the file to analyze
+* @returns {Promise<boolean>} true if JSX is detected, false otherwise
+* @throws {Error} If file can't be read
+*/
+async function hasJSX(filepath) {
+	return containsJSX(await readFileContent(filepath));
+}
+/**
+* Checks if a string contains JSX syntax.
+*
+* @param {string} source - Source code string to analyze
+* @returns {boolean} true if JSX is detected, false otherwise
+* @throws {TypeError} If source is not a string
+*/
+function hasJSXInString(source) {
+	if (typeof source !== "string") throw new TypeError("Expected source to be a string");
+	return containsJSX(source);
+}
+
+//#endregion
+exports.default = hasJSX;
+exports.hasJSX = hasJSX;
+exports.hasJSXInString = hasJSXInString;

package/dist/index.mjs

@@ -0,0 +1,60 @@
+import { readFile } from "fs/promises";
+import { existsSync, statSync } from "fs";
+import { tsx } from "@ast-grep/napi";
+
+//#region src/utils.js
+/**
+* Reads file content from the filesystem with validation.
+*
+* @param {string} filepath - Absolute or relative path to file
+* @returns {Promise<string>} File content
+* @throws {Error} If file doesn't exist, is not a file, or can't be read
+*/
+async function readFileContent(filepath) {
+	if (!existsSync(filepath)) throw new Error(`File not found: ${filepath}`);
+	if (!statSync(filepath).isFile()) throw new Error(`Path is not a file: ${filepath}`);
+	return readFile(filepath, "utf-8");
+}
+
+//#endregion
+//#region src/detector.js
+/**
+* Detects if source code contains JSX syntax using AST analysis.
+*
+* @param {string} source - Source code to analyze
+* @returns {boolean} true if JSX is detected, false otherwise
+*/
+function containsJSX(source) {
+	try {
+		return tsx.parse(source).root().findAll({ rule: { any: [{ kind: "jsx_element" }, { kind: "jsx_self_closing_element" }] } }).length > 0;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/index.js
+/**
+* Checks if a file contains JSX syntax.
+*
+* @param {string} filepath - Path to the file to analyze
+* @returns {Promise<boolean>} true if JSX is detected, false otherwise
+* @throws {Error} If file can't be read
+*/
+async function hasJSX(filepath) {
+	return containsJSX(await readFileContent(filepath));
+}
+/**
+* Checks if a string contains JSX syntax.
+*
+* @param {string} source - Source code string to analyze
+* @returns {boolean} true if JSX is detected, false otherwise
+* @throws {TypeError} If source is not a string
+*/
+function hasJSXInString(source) {
+	if (typeof source !== "string") throw new TypeError("Expected source to be a string");
+	return containsJSX(source);
+}
+
+//#endregion
+export { hasJSX as default, hasJSX, hasJSXInString };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "has-jsx",
+  "version": "0.0.1",
+  "description": "CLI and programmatic tool to detect JSX in files using AST analysis",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "bin": {
+    "has-jsx": "bin/has-jsx.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npx tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "jsx",
+    "detect",
+    "ast",
+    "cli",
+    "typescript",
+    "react"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@ast-grep/napi": "^0.40.5",
+    "commander": "^14.0.3"
+  },
+  "devDependencies": {
+    "tsdown": "^0.20.3",
+    "vitest": "^4.0.18"
+  }
+}

package/src/cli.js

@@ -0,0 +1,100 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+import { Command } from 'commander';
+
+import { hasJSX, hasJSXInString } from './index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Runs the CLI with the provided arguments.
+ *
+ * @param {string[]} argv - Command line arguments (process.argv)
+ * @returns {Promise<void>}
+ */
+export async function run(argv) {
+  const packageJson = JSON.parse(
+    readFileSync(join(__dirname, '../package.json'), 'utf-8')
+  );
+
+  const program = new Command();
+
+  program
+    .name('has-jsx')
+    .description('Detect JSX in files or strings using AST analysis')
+    .version(packageJson.version)
+    .argument('[source]', 'Source code string to analyze (use -f for files)')
+    .option('-f, --file <filepath>', 'Path to file to analyze')
+    .option('-v, --verbose', 'Show detailed JSON output')
+    .option('-q, --quiet', 'Silent mode (exit codes only)')
+    .exitOverride()
+    .configureOutput({
+      writeOut: (str) => console.log(str.trimEnd()),
+      writeErr: (str) => console.error(str.trimEnd()),
+    })
+    .action(async (source, options) => {
+      try {
+        let result;
+        let inputType;
+        let inputValue;
+
+        if (options.file) {
+          result = await hasJSX(options.file);
+          inputType = 'file';
+          inputValue = options.file;
+        } else if (source) {
+          result = hasJSXInString(source);
+          inputType = 'string';
+          inputValue = source;
+        } else {
+          if (!options.quiet) {
+            console.error('Error: No input provided. Use -f <filepath> or provide source code string.');
+          }
+          process.exit(2);
+          return;
+        }
+
+        const exitCode = result ? 0 : 1;
+
+        if (options.quiet) {
+          process.exit(exitCode);
+        } else if (options.verbose) {
+          const inputKey = inputType === 'file' ? 'file' : 'source';
+          const output = { hasJSX: result, inputType, [inputKey]: inputValue };
+          console.log(JSON.stringify(output, null, 2));
+          process.exit(exitCode);
+        } else {
+          console.log(result ? 'JSX detected' : 'No JSX detected');
+          process.exit(exitCode);
+        }
+      } catch (error) {
+        if (isProcessExitError(error)) {
+          throw error;
+        }
+        if (!options.quiet) {
+          console.error(`Error: ${error.message}`);
+        }
+        process.exit(2);
+      }
+    });
+
+  try {
+    await program.parseAsync(argv);
+  } catch (error) {
+    if (isProcessExitError(error) || isCommanderError(error)) {
+      return;
+    }
+    throw error;
+  }
+}
+
+function isProcessExitError(error) {
+  return error.message?.startsWith('process.exit(');
+}
+
+function isCommanderError(error) {
+  return error.code?.startsWith('commander.');
+}

package/src/detector.js

@@ -0,0 +1,27 @@
+import { tsx } from '@ast-grep/napi';
+
+/**
+ * Detects if source code contains JSX syntax using AST analysis.
+ *
+ * @param {string} source - Source code to analyze
+ * @returns {boolean} true if JSX is detected, false otherwise
+ */
+export function containsJSX(source) {
+  try {
+    const root = tsx.parse(source).root();
+
+    // jsx_element covers standard elements and fragments (<>...</>)
+    const jsxNodes = root.findAll({
+      rule: {
+        any: [
+          { kind: 'jsx_element' },
+          { kind: 'jsx_self_closing_element' },
+        ],
+      },
+    });
+
+    return jsxNodes.length > 0;
+  } catch {
+    return false;
+  }
+}

package/src/index.js

@@ -0,0 +1,30 @@
+import { readFileContent } from './utils.js';
+import { containsJSX } from './detector.js';
+
+/**
+ * Checks if a file contains JSX syntax.
+ *
+ * @param {string} filepath - Path to the file to analyze
+ * @returns {Promise<boolean>} true if JSX is detected, false otherwise
+ * @throws {Error} If file can't be read
+ */
+export async function hasJSX(filepath) {
+  const content = await readFileContent(filepath);
+  return containsJSX(content);
+}
+
+/**
+ * Checks if a string contains JSX syntax.
+ *
+ * @param {string} source - Source code string to analyze
+ * @returns {boolean} true if JSX is detected, false otherwise
+ * @throws {TypeError} If source is not a string
+ */
+export function hasJSXInString(source) {
+  if (typeof source !== 'string') {
+    throw new TypeError('Expected source to be a string');
+  }
+  return containsJSX(source);
+}
+
+export default hasJSX;

package/src/utils.js

@@ -0,0 +1,22 @@
+import { readFile } from 'fs/promises';
+import { existsSync, statSync } from 'fs';
+
+/**
+ * Reads file content from the filesystem with validation.
+ *
+ * @param {string} filepath - Absolute or relative path to file
+ * @returns {Promise<string>} File content
+ * @throws {Error} If file doesn't exist, is not a file, or can't be read
+ */
+export async function readFileContent(filepath) {
+  if (!existsSync(filepath)) {
+    throw new Error(`File not found: ${filepath}`);
+  }
+
+  const stats = statSync(filepath);
+  if (!stats.isFile()) {
+    throw new Error(`Path is not a file: ${filepath}`);
+  }
+
+  return readFile(filepath, 'utf-8');
+}