es-guard 1.0.0 → 1.2.0

package/README.md

@@ -162,7 +162,7 @@ npm run dev
 
 ```bash
 npm test
-npm run test:run
+npm run test
 ```
 
 ### Linting

package/dist/cli.js

@@ -4,6 +4,8 @@ import * as fs from "fs";
 import packageJson from "../package.json" with { type: "json" };
 import { checkCompatibility } from "./lib/checkCompatiblity.js";
 import { getBrowserTargetsFromString } from "./lib/getBrowserTargets.js";
+import { detectTarget } from "./lib/detectTarget.js";
+import path from "path";
 const version = packageJson.version;
 // Create the main program
 const program = new Command();
@@ -13,18 +15,30 @@ program
     .description("JavaScript Compatibility Checker - Check if your JavaScript code is compatible with target environments")
     .version(version)
     .argument("[directory]", "Directory to scan for JavaScript files", "dist")
-    .option("-t, --target <version>", "Target ES version (2015, 2016, 2017, etc. or 6, 7, 8, etc. or 'latest')", "2015")
+    .option("-t, --target <version>", "Target ES version (2015, 2016, 2017, etc. or 6, 7, 8, etc. or 'latest'). If not specified, will auto-detect from project config files.")
     .option("-b, --browsers <targets>", "Browser targets for compatibility checking (optional: auto-determined from target)")
     .addHelpText("after", `
 
 Examples:
-  es-guard                           # Check 'dist' directory with ES2015 (auto-determined browsers)
-  es-guard build                     # Check 'build' directory with ES2015 (auto-determined browsers)
+  es-guard                           # Check 'dist' directory with auto-detected target
+  es-guard build                     # Check 'build' directory with auto-detected target
   es-guard -t 2020 build             # Check 'build' directory with ES2020 (auto-determined browsers)
   es-guard -t 6 build                # Check 'build' directory with ES6 (auto-determined browsers)
   es-guard -t latest build           # Check 'build' directory with latest ES (auto-determined browsers)
   es-guard --target 2017 --browsers "> 0.5%, last 2 versions" dist
 
+Auto-detection searches for ES target in:
+  - package.json (browserslist field)
+  - tsconfig.json (compilerOptions.target)
+  - babel.config.js (.babelrc) (@babel/preset-env targets)
+  - vite.config.js/ts (esbuild target)
+  - webpack.config.js/ts (target)
+
+Auto-detection behavior:
+  - Searches in the directory being scanned first
+  - Falls back to current working directory if no config found
+  - Uses the first valid target found (package.json has highest priority)
+
 Browser targets use Browserslist format:
   - If not specified, browsers will be auto-determined from the ES target version
   - "> 1%, last 2 versions, not dead, ie 11" (for ES2015/ES6)
@@ -40,10 +54,12 @@ Exit codes:
 program.hook("preAction", (thisCommand) => {
     const options = thisCommand.opts();
     const target = options.target;
-    // Validate ES target format - accept year format (YYYY), numeric format (N), or "latest"
-    if (!/^\d{4}$/.test(target) && !/^\d+$/.test(target) && target !== "latest") {
-        console.error(`Error: Invalid ES target: "${target}". Expected format: YYYY (e.g., 2015, 2020), numeric (e.g., 6, 11), or "latest"`);
-        process.exit(1);
+    if (target) {
+        // Validate ES target format - accept year format (YYYY), numeric format (N), or "latest"
+        if (!/^\d{4}$/.test(target) && !/^\d+$/.test(target) && target !== "latest") {
+            console.error(`Error: Invalid ES target: "${target}". Expected format: YYYY (e.g., 2015, 2020), numeric (e.g., 6, 11), or "latest"`);
+            process.exit(1);
+        }
     }
 });
 // Main action
@@ -59,16 +75,67 @@ program.action(async (directory, options) => {
             console.error(`Error: "${directory}" is not a directory`);
             process.exit(1);
         }
+        // Determine target - use provided target or auto-detect
+        let target = options.target;
+        let targetSource = "specified";
+        if (!target) {
+            // Try to detect target from current working directory
+            const detectedResult = detectTarget(process.cwd());
+            if (detectedResult) {
+                target = detectedResult.target;
+                targetSource = `auto-detected from ${detectedResult.source}`;
+            }
+            else {
+                console.error("Error: No target specified and could not auto-detect from project configuration files.");
+                console.error("Please specify a target with --target or ensure your project has a valid configuration file.");
+                process.exit(1);
+            }
+        }
         // Determine browser targets
-        const browserTargets = options.browsers || getBrowserTargetsFromString(options.target);
+        let browserTargets;
+        if (options.browsers) {
+            browserTargets = options.browsers;
+        }
+        else {
+            // If auto-detected from package.json or browserslist file, check for ES version strings
+            if (targetSource.startsWith("auto-detected from ")) {
+                const configFile = targetSource.replace("auto-detected from ", "");
+                let browserslistEntries = [];
+                if (configFile === "package.json") {
+                    const pkgPath = path.join(process.cwd(), "package.json");
+                    if (fs.existsSync(pkgPath)) {
+                        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+                        if (pkg.browserslist) {
+                            browserslistEntries = Array.isArray(pkg.browserslist) ? pkg.browserslist : [pkg.browserslist];
+                        }
+                    }
+                }
+                else if (configFile === ".browserslistrc" || configFile === ".browserslist") {
+                    const blPath = path.join(process.cwd(), configFile);
+                    if (fs.existsSync(blPath)) {
+                        browserslistEntries = fs
+                            .readFileSync(blPath, "utf-8")
+                            .split(/\r?\n/)
+                            .map((l) => l.trim())
+                            .filter((l) => l && !l.startsWith("#"));
+                    }
+                }
+                const esVersionRegex = /^es\d{1,4}$/i;
+                const invalidEntries = browserslistEntries.filter((entry) => esVersionRegex.test(entry));
+                if (invalidEntries.length > 0) {
+                    console.warn(`Warning: Detected ES version string(s) in browserslist (${invalidEntries.join(", ")}). These are not valid Browserslist queries and will be ignored for browser compatibility checks.`);
+                }
+            }
+            browserTargets = getBrowserTargetsFromString(target);
+        }
         console.log(`🔍 ES-Guard v${version}`);
         console.log(`📁 Scanning directory: ${directory}`);
-        console.log(`🎯 Target ES version: ${options.target}`);
+        console.log(`🎯 Target ES version: ${target} (${targetSource})`);
         console.log(`🌐 Browser targets: ${browserTargets}${options.browsers ? "" : " (auto-determined)"}`);
         console.log("");
         const violations = await checkCompatibility({
             dir: directory,
-            target: options.target,
+            target: target,
             browsers: browserTargets,
         });
         if (violations.length > 0) {

package/dist/lib/checkCompatiblity.js

@@ -7,6 +7,11 @@ export const checkCompatibility = async (config) => {
         console.log(`No JavaScript files found in directory: ${config.dir}`);
         return [];
     }
+    // Set BROWSERSLIST env variable to override Browserslist file detection
+    const originalBrowserslistEnv = process.env.BROWSERSLIST;
+    if (config.browsers) {
+        process.env.BROWSERSLIST = config.browsers;
+    }
     const eslint = new ESLint(createESLintConfig(config.target, config.browsers));
     const violations = [];
     for (const file of jsFiles) {
@@ -30,5 +35,12 @@ export const checkCompatibility = async (config) => {
             console.warn(`Warning: Could not lint file ${file}:`, error);
         }
     }
+    // Restore original BROWSERSLIST env variable
+    if (originalBrowserslistEnv !== undefined) {
+        process.env.BROWSERSLIST = originalBrowserslistEnv;
+    }
+    else {
+        delete process.env.BROWSERSLIST;
+    }
     return violations;
 };

package/dist/lib/detectTarget.js

@@ -0,0 +1,244 @@
+import * as fs from "fs";
+import * as path from "path";
+// Shared utilities for ES version parsing and conversion
+/**
+ * Parse ES version from string (e.g., "es6", "es2020", "ES2015")
+ * Returns the year as a string, or null if not found
+ */
+const parseESVersion = (str) => {
+    const esMatch = str.match(/es(\d+)/i);
+    if (esMatch) {
+        const esVersion = parseInt(esMatch[1]);
+        // If it's a 4-digit year (like 2020), use it directly
+        if (esVersion >= 2000) {
+            return esVersion.toString();
+        }
+        // Otherwise convert ES version to year: ES6=2015, ES7=2016, ES8=2017, etc.
+        return (2009 + esVersion).toString();
+    }
+    return null;
+};
+/**
+ * Common target mapping for TypeScript, Vite, and Webpack configs
+ */
+const TARGET_MAP = {
+    // TypeScript targets
+    ES2022: "2022",
+    ES2021: "2021",
+    ES2020: "2020",
+    ES2019: "2019",
+    ES2018: "2018",
+    ES2017: "2017",
+    ES2016: "2016",
+    ES2015: "2015",
+    ES6: "2015",
+    ES5: "2009",
+    ES3: "1999",
+    // Vite/Webpack targets (lowercase)
+    es2022: "2022",
+    es2021: "2021",
+    es2020: "2020",
+    es2019: "2019",
+    es2018: "2018",
+    es2017: "2017",
+    es2016: "2016",
+    es2015: "2015",
+    es6: "2015",
+    es5: "2009",
+};
+/**
+ * Helper to read and parse JSON file safely
+ */
+const readJsonFile = (filePath) => {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+};
+/**
+ * Type guard for package.json structure
+ */
+const isPackageJson = (obj) => {
+    return typeof obj === "object" && obj !== null && "browserslist" in obj;
+};
+/**
+ * Type guard for tsconfig.json structure
+ */
+const isTsConfig = (obj) => {
+    return typeof obj === "object" && obj !== null && "compilerOptions" in obj;
+};
+/**
+ * Type guard for .babelrc structure
+ */
+const isBabelRc = (obj) => {
+    return typeof obj === "object" && obj !== null && "presets" in obj;
+};
+/**
+ * Helper to read text file safely
+ */
+const readTextFile = (filePath) => {
+    return fs.readFileSync(filePath, "utf-8");
+};
+/**
+ * Detects ES target from common frontend project configuration files.
+ * Searches in order of preference: package.json, .browserslistrc/.browserslist, tsconfig.json, babel.config.js, .babelrc, vite.config.js, webpack.config.js
+ * Returns an object with the detected target and the source file name, or null if not found
+ */
+export const detectTarget = (cwd = process.cwd()) => {
+    const configFiles = [
+        { name: "package.json", parser: parsePackageJson },
+        { name: ".browserslistrc", parser: parseBrowserslistFile },
+        { name: ".browserslist", parser: parseBrowserslistFile },
+        { name: "tsconfig.json", parser: parseTsConfig },
+        { name: "babel.config.js", parser: parseBabelConfig },
+        { name: ".babelrc", parser: parseBabelRc },
+        { name: "vite.config.js", parser: parseViteConfig },
+        { name: "vite.config.ts", parser: parseViteConfig },
+        { name: "webpack.config.js", parser: parseWebpackConfig },
+        { name: "webpack.config.ts", parser: parseWebpackConfig },
+    ];
+    for (const config of configFiles) {
+        const filePath = path.join(cwd, config.name);
+        if (fs.existsSync(filePath)) {
+            try {
+                const target = config.parser(filePath);
+                if (target) {
+                    return { target, source: config.name };
+                }
+            }
+            catch (error) {
+                console.warn(`Error parsing ${config.name}:`, error);
+                // Continue to next config file if parsing fails
+                continue;
+            }
+        }
+    }
+    return null;
+};
+/**
+ * Parse package.json for ES target in browserslist
+ */
+const parsePackageJson = (filePath) => {
+    const pkg = readJsonFile(filePath);
+    if (!isPackageJson(pkg)) {
+        console.warn(`Warning: ${filePath} does not look like a valid package.json (missing or invalid browserslist field).`);
+        return null;
+    }
+    // Check for browserslist field
+    if (pkg.browserslist) {
+        const browserslist = Array.isArray(pkg.browserslist) ? pkg.browserslist : [pkg.browserslist];
+        // Look for ES target in browserslist
+        for (const browser of browserslist) {
+            if (typeof browser === "string") {
+                const target = parseESVersion(browser);
+                if (target) {
+                    return target;
+                }
+            }
+        }
+    }
+    // Note: engines.node is for development/build tools, not client-side targets
+    // So we don't use it for auto-detection
+    return null;
+};
+/**
+ * Parse tsconfig.json for target
+ */
+const parseTsConfig = (filePath) => {
+    const config = readJsonFile(filePath);
+    if (!isTsConfig(config)) {
+        console.warn(`Warning: ${filePath} does not look like a valid tsconfig.json (missing or invalid compilerOptions field).`);
+        return null;
+    }
+    if (config.compilerOptions?.target) {
+        const target = config.compilerOptions.target;
+        return TARGET_MAP[target] || null;
+    }
+    return null;
+};
+/**
+ * Parse babel.config.js for preset-env target
+ */
+const parseBabelConfig = (filePath) => {
+    const content = readTextFile(filePath);
+    // Look for @babel/preset-env configuration
+    const presetEnvMatch = content.match(/@babel\/preset-env.*?targets.*?(\{[^}]*\})/s);
+    if (presetEnvMatch) {
+        const targetsStr = presetEnvMatch[1];
+        // Look for browsers or esmodules target
+        const browsersMatch = targetsStr.match(/browsers.*?\[(.*?)\]/);
+        if (browsersMatch) {
+            const browsers = browsersMatch[1];
+            return parseESVersion(browsers);
+        }
+    }
+    return null;
+};
+/**
+ * Parse .babelrc for preset-env target
+ */
+const parseBabelRc = (filePath) => {
+    const config = readJsonFile(filePath);
+    if (!isBabelRc(config)) {
+        console.warn(`Warning: ${filePath} does not look like a valid .babelrc (missing or invalid presets field).`);
+        return null;
+    }
+    if (config.presets) {
+        for (const preset of config.presets) {
+            if (Array.isArray(preset) && preset[0] === "@babel/preset-env") {
+                const options = preset[1];
+                if (options?.targets?.browsers) {
+                    const browsers = options.targets.browsers;
+                    for (const browser of browsers) {
+                        const target = parseESVersion(browser);
+                        if (target) {
+                            return target;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return null;
+};
+/**
+ * Parse vite.config.js/ts for target
+ */
+const parseViteConfig = (filePath) => {
+    const content = readTextFile(filePath);
+    // Look for esbuild target - more flexible pattern
+    const esbuildMatch = content.match(/esbuild\s*:\s*\{[^}]*target\s*:\s*['"`]([^'"`]+)['"`]/s);
+    if (esbuildMatch) {
+        const target = esbuildMatch[1];
+        return TARGET_MAP[target] || null;
+    }
+    return null;
+};
+/**
+ * Parse webpack.config.js/ts for target
+ */
+const parseWebpackConfig = (filePath) => {
+    const content = readTextFile(filePath);
+    // Look for target configuration
+    const targetMatch = content.match(/target.*?['"`]([^'"`]+)['"`]/);
+    if (targetMatch) {
+        const target = targetMatch[1];
+        return TARGET_MAP[target] || null;
+    }
+    return null;
+};
+/**
+ * Parse .browserslistrc or .browserslist file for ES target
+ */
+const parseBrowserslistFile = (filePath) => {
+    const content = readTextFile(filePath);
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("#"));
+    for (const browser of lines) {
+        const target = parseESVersion(browser);
+        if (target) {
+            return target;
+        }
+    }
+    return null;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-guard",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "A tool to check JavaScript compatibility with target environments",
   "type": "module",
   "main": "dist/cli.js",
@@ -14,8 +14,10 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/cli.js",
-    "test": "npm run build && vitest",
-    "test:run": "npm run build && vitest run",
+    "test:dev": "npm run build && vitest",
+    "test": "npm run build && vitest run",
+    "test:junit": "npm run build && vitest run --reporter=junit --outputFile=test-report.junit.xml",
+    "test:junit:coverage": "npm run build && vitest run --reporter=junit --outputFile=test-report.junit.xml --coverage",
     "coverage": "vitest run --coverage",
     "coverage:check": "vitest run --coverage --reporter=verbose",
     "lint": "eslint src/**/*.ts",
@@ -72,5 +74,10 @@
     "url": "https://github.com/mkayander/es-guard/issues"
   },
   "homepage": "https://github.com/mkayander/es-guard#readme",
-  "packageManager": "pnpm@10.12.4+sha512.5ea8b0deed94ed68691c9bad4c955492705c5eeb8a87ef86bc62c74a26b037b08ff9570f108b2e4dbd1dd1a9186fea925e527f141c648e85af45631074680184"
+  "packageManager": "pnpm@10.12.4+sha512.5ea8b0deed94ed68691c9bad4c955492705c5eeb8a87ef86bc62c74a26b037b08ff9570f108b2e4dbd1dd1a9186fea925e527f141c648e85af45631074680184",
+  "browserslist": [
+    "es2020",
+    "> 1%",
+    "last 2 versions"
+  ]
 }