es-guard 1.6.0 → 1.8.0

package/dist/cli.js

@@ -4,9 +4,9 @@ import * as fs from "fs";
 import packageJson from "../package.json" with { type: "json" };
 import { checkCompatibility, formatViolationMessage } from "./lib/checkCompatiblity.js";
 import { getBrowserTargetsFromString } from "./lib/getBrowserTargets.js";
-import { detectTarget, detectOutputDir } from "./lib/detectTarget.js";
+import { detectProjectConfig, getConfigFileNames } from "./lib/detectTarget.js";
+import { getCurrentProjectType } from "./lib/projectType.js";
 import { setVerboseMode } from "./lib/globalState.js";
-import path from "path";
 const version = packageJson.version;
 // Create the main program
 const program = new Command();
@@ -71,22 +71,30 @@ program.action(async (directory, options) => {
     try {
         // Set global verbose mode
         setVerboseMode(options.verbose || false);
-        // Auto-detect output directory if not specified
+        // Auto-detect configuration if not specified
         let scanDirectory;
         let outputDirSource;
+        let target;
+        let targetSource;
+        let browserTargets;
+        let browserslistSource;
+        if (options.verbose) {
+            console.log("🔍 Auto-detecting project configuration...");
+            console.log(`📂 Searching in: ${process.cwd()}`);
+            // Detect and log project type
+            const projectType = getCurrentProjectType();
+            console.log(`🏗️  Project type: ${projectType}`);
+            console.log("");
+        }
+        // Use unified detection to get all configuration at once
+        const detectedConfig = detectProjectConfig(process.cwd());
+        // Handle directory detection
         if (!directory) {
-            if (options.verbose) {
-                console.log("🔍 No directory specified, auto-detecting output directory from project configuration files...");
-                console.log(`📂 Searching in: ${process.cwd()}`);
-                console.log("");
-            }
-            // Try to detect output directory from current working directory
-            const detectedOutput = detectOutputDir(process.cwd());
-            if (detectedOutput) {
-                scanDirectory = detectedOutput.outputDir;
-                outputDirSource = `auto-detected from ${detectedOutput.source}`;
+            if (detectedConfig.outputDir) {
+                scanDirectory = detectedConfig.outputDir;
+                outputDirSource = `auto-detected from ${detectedConfig.outputSource}`;
                 if (options.verbose) {
-                    console.log(`✅ Found output directory: ${scanDirectory} in ${detectedOutput.source}`);
+                    console.log(`✅ Found output directory: ${scanDirectory} in ${detectedConfig.outputSource}`);
                 }
             }
             else {
@@ -113,80 +121,51 @@ program.action(async (directory, options) => {
             console.error(`Error: "${scanDirectory}" is not a directory`);
             process.exit(1);
         }
-        // Determine target - use provided target or auto-detect
-        let target = options.target;
-        let targetSource = "specified";
-        if (!target) {
+        // Handle target detection
+        if (options.target) {
+            target = options.target;
+            targetSource = "specified";
+        }
+        else if (detectedConfig.target) {
+            target = detectedConfig.target;
+            targetSource = `auto-detected from ${detectedConfig.targetSource}`;
+        }
+        else {
             if (options.verbose) {
-                console.log("🔍 Auto-detecting ES target from project configuration files...");
-                console.log(`📂 Searching in: ${process.cwd()}`);
+                console.log("❌ No valid configuration files found for target detection");
+                console.log("📋 Searched for:");
+                const configFileNames = getConfigFileNames();
+                configFileNames.forEach((filename, index) => {
+                    console.log(`   ${index + 1}. ${filename}`);
+                });
                 console.log("");
             }
-            // 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 {
-                if (options.verbose) {
-                    console.log("❌ No valid configuration files found for target detection");
-                    console.log("📋 Searched for:");
-                    console.log("   - package.json (browserslist field)");
-                    console.log("   - .browserslistrc/.browserslist");
-                    console.log("   - tsconfig.json (compilerOptions.target)");
-                    console.log("   - babel.config.js/.babelrc (@babel/preset-env targets)");
-                    console.log("   - vite.config.js/ts (esbuild target)");
-                    console.log("   - webpack.config.js/ts (target)");
-                    console.log("   - next.config.js/ts (output directory)");
-                    console.log("");
-                }
-                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);
-            }
+            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
-        let browserTargets;
+        // Handle browser targets detection
         if (options.browsers) {
             browserTargets = options.browsers;
+            browserslistSource = "specified";
             if (options.verbose) {
                 console.log(`🌐 Using specified browser targets: ${browserTargets}`);
             }
         }
-        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.`);
-                }
+        else if (detectedConfig.browserslist) {
+            // Use the detected browserslist
+            browserTargets = detectedConfig.browserslist.join(", ");
+            browserslistSource = `auto-detected from ${detectedConfig.browserslistSource}`;
+            if (options.verbose) {
+                console.log(`🌐 Using detected browserslist: ${browserTargets} (from ${detectedConfig.browserslistSource})`);
             }
+        }
+        else {
+            // No browserslist detected, auto-determine from target
             browserTargets = getBrowserTargetsFromString(target);
+            browserslistSource = "auto-determined from target";
             if (options.verbose) {
-                console.log(`🌐 Auto-determined browser targets: ${browserTargets}`);
+                console.log(`🌐 No browserslist detected, auto-determining from target: ${browserTargets}`);
             }
         }
         if (options.verbose) {
@@ -195,6 +174,7 @@ program.action(async (directory, options) => {
             console.log(`   Target ES version: ${target}`);
             console.log(`   Target source: ${targetSource}`);
             console.log(`   Browser targets: ${browserTargets}`);
+            console.log(`   Browserslist source: ${browserslistSource}`);
             console.log(`   Scan directory: ${scanDirectory}`);
             console.log(`   Output directory source: ${outputDirSource}`);
             console.log("");
@@ -202,7 +182,7 @@ program.action(async (directory, options) => {
         console.log(`🔍 ES-Guard v${version}`);
         console.log(`📁 Scanning directory: ${scanDirectory}`);
         console.log(`🎯 Target ES version: ${target} (${targetSource})`);
-        console.log(`🌐 Browser targets: ${browserTargets}${options.browsers ? "" : " (auto-determined)"}`);
+        console.log(`🌐 Browser targets: ${browserTargets} (${browserslistSource})`);
         console.log("");
         const { errors, warnings } = await checkCompatibility({
             dir: scanDirectory,

package/dist/lib/defaults.js

@@ -0,0 +1,77 @@
+/**
+ * Default configurations for different project types
+ */
+/**
+ * Next.js default browserslist configuration
+ * Source: https://nextjs.org/docs/basic-features/supported-browsers-features
+ */
+export const NEXTJS_DEFAULT_BROWSERSLIST = ["chrome 64", "edge 79", "firefox 67", "opera 51", "safari 12"];
+/**
+ * Default output directories for different project types
+ */
+export const DEFAULT_OUTPUT_DIRS = {
+    nextjs: ".next/static",
+    vite: "dist",
+    webpack: "dist",
+    rollup: "dist",
+    parcel: "dist",
+    generic: "dist",
+};
+/**
+ * Project type detection helpers
+ */
+export const PROJECT_TYPES = {
+    nextjs: "nextjs",
+    vite: "vite",
+    webpack: "webpack",
+    rollup: "rollup",
+    parcel: "parcel",
+    generic: "generic",
+};
+export const ProjectTypeKeys = new Set(Object.keys(PROJECT_TYPES));
+export const isProjectType = (projectType) => {
+    return ProjectTypeKeys.has(projectType);
+};
+/**
+ * Get default browserslist for a project type
+ */
+export function getDefaultBrowserslist(projectType) {
+    switch (projectType) {
+        case PROJECT_TYPES.nextjs:
+            return [...NEXTJS_DEFAULT_BROWSERSLIST];
+        // Add more project types here as needed
+        default:
+            return null;
+    }
+}
+/**
+ * Get default output directory for a project type
+ */
+export function getDefaultOutputDir(projectType) {
+    if (isProjectType(projectType)) {
+        return DEFAULT_OUTPUT_DIRS[projectType];
+    }
+    return DEFAULT_OUTPUT_DIRS.generic;
+}
+/**
+ * Detect project type from package.json dependencies
+ */
+export function detectProjectType(dependencies = {}, devDependencies = {}) {
+    const allDeps = { ...dependencies, ...devDependencies };
+    if (allDeps.next) {
+        return PROJECT_TYPES.nextjs;
+    }
+    if (allDeps.vite) {
+        return PROJECT_TYPES.vite;
+    }
+    if (allDeps.webpack) {
+        return PROJECT_TYPES.webpack;
+    }
+    if (allDeps.rollup) {
+        return PROJECT_TYPES.rollup;
+    }
+    if (allDeps.parcel) {
+        return PROJECT_TYPES.parcel;
+    }
+    return PROJECT_TYPES.generic;
+}

package/dist/lib/detectTarget.js

@@ -1,6 +1,9 @@
 import * as fs from "fs";
 import * as path from "path";
 import { verboseMode } from "./globalState.js";
+import { NEXTJS_DEFAULT_BROWSERSLIST } from "./defaults.js";
+import { getCurrentProjectType } from "./projectType.js";
+import { readJsonFile, readTextFile, evaluateJsFile, isPackageJson, isTsConfig, isBabelRc, isViteConfig, isWebpackConfig, isNextConfig, } from "./utils.js";
 // Shared utilities for ES version parsing and conversion
 const CONFIG_FILE_NAMES = [
     "package.json",
@@ -24,23 +27,6 @@ const CONFIG_FILE_NAMES = [
     "next.config.cjs",
     "next.config.mjs",
 ];
-/**
- * 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
  */
@@ -69,80 +55,6 @@ const TARGET_MAP = {
     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);
-};
-/**
- * Helper to read text file safely
- */
-const readTextFile = (filePath) => {
-    return fs.readFileSync(filePath, "utf-8");
-};
-/**
- * Helper to safely evaluate JavaScript files (for config files)
- */
-const evaluateJsFile = (filePath) => {
-    const content = readTextFile(filePath);
-    // Create a safe evaluation context
-    const module = { exports: {} };
-    const require = (id) => {
-        if (id === "path")
-            return path;
-        if (id === "fs")
-            return fs;
-        throw new Error(`Cannot require '${id}' in config evaluation`);
-    };
-    try {
-        // Use Function constructor to create a safe evaluation environment
-        const fn = new Function("module", "exports", "require", "path", "fs", "__dirname", content);
-        fn(module, module.exports, require, path, fs, path.dirname(filePath));
-        return module.exports;
-    }
-    catch (error) {
-        console.warn(`Error evaluating ${filePath}:`, error);
-        return null;
-    }
-};
-/**
- * Type guard for package.json structure
- */
-const isPackageJson = (obj) => {
-    return typeof obj === "object" && obj !== null;
-};
-/**
- * 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;
-};
-/**
- * Type guard for vite config structure
- */
-const isViteConfig = (obj) => {
-    return typeof obj === "object" && obj !== null;
-};
-/**
- * Type guard for webpack config structure
- */
-const isWebpackConfig = (obj) => {
-    return typeof obj === "object" && obj !== null;
-};
-/**
- * Type guard for next.js config structure
- */
-const isNextConfig = (obj) => {
-    return typeof obj === "object" && obj !== null;
-};
 /**
  * Get parser function for a given config file
  */
@@ -172,19 +84,18 @@ const getParser = (filename) => {
 /**
  * Get all possible config file names for detection
  */
-const getConfigFileNames = () => {
+export const getConfigFileNames = () => {
     return CONFIG_FILE_NAMES;
 };
 /**
- * Detects both ES target and output directory 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 detected target and output directory information
+ * Detection function that extracts all configuration in a single pass
+ * This is more efficient than separate detection functions
  */
-export const detectTargetAndOutput = (cwd = process.cwd()) => {
+export const detectProjectConfig = (cwd = process.cwd()) => {
     const configFileNames = getConfigFileNames();
     const result = {};
     if (verboseMode) {
-        console.log("🔍 Starting configuration file detection...");
+        console.log("🔍 Starting configuration detection...");
         console.log(`📂 Scanning directory: ${cwd}`);
         console.log("📋 Files to check:");
         configFileNames.forEach((filename, index) => {
@@ -230,7 +141,7 @@ export const detectTargetAndOutput = (cwd = process.cwd()) => {
                 // Update output directory if found and not already set
                 if (detection.outputDir && !result.outputDir) {
                     result.outputDir = detection.outputDir;
-                    result.outputSource = filename;
+                    result.outputSource = detection.outputSource || filename;
                     if (verboseMode) {
                         console.log(`      📁 Output directory: ${detection.outputDir}`);
                     }
@@ -241,10 +152,24 @@ export const detectTargetAndOutput = (cwd = process.cwd()) => {
                 else if (verboseMode) {
                     console.log(`      📁 Output directory: not found`);
                 }
-                // If we found both target and output directory, we can stop searching
-                if (result.target && result.outputDir) {
+                // Update browserslist if found and not already set
+                if (detection.browserslist && !result.browserslist) {
+                    result.browserslist = detection.browserslist;
+                    result.browserslistSource = detection.browserslistSource || filename;
                     if (verboseMode) {
-                        console.log(`   ✅ Both target and output directory found, stopping search`);
+                        console.log(`      🌐 Browserslist: ${detection.browserslist.join(", ")} (from ${result.browserslistSource})`);
+                    }
+                }
+                else if (verboseMode && detection.browserslist) {
+                    console.log(`      🌐 Browserslist: ${detection.browserslist.join(", ")} (already found in ${result.browserslistSource})`);
+                }
+                else if (verboseMode) {
+                    console.log(`      🌐 Browserslist: not found`);
+                }
+                // If we found all three (target, output directory, and browserslist), we can stop searching
+                if (result.target && result.outputDir && result.browserslist) {
+                    if (verboseMode) {
+                        console.log(`   ✅ All configuration found, stopping search`);
                     }
                     break;
                 }
@@ -278,6 +203,12 @@ export const detectTargetAndOutput = (cwd = process.cwd()) => {
         else {
             console.log(`   📁 Output directory: not found`);
         }
+        if (result.browserslist) {
+            console.log(`   🌐 Browserslist: ${result.browserslist.join(", ")} (from ${result.browserslistSource})`);
+        }
+        else {
+            console.log(`   🌐 Browserslist: not found`);
+        }
         console.log("");
     }
     return result;
@@ -286,16 +217,37 @@ export const detectTargetAndOutput = (cwd = process.cwd()) => {
  * Legacy function for backward compatibility - detects only ES target
  */
 export const detectTarget = (cwd = process.cwd()) => {
-    const result = detectTargetAndOutput(cwd);
+    const result = detectProjectConfig(cwd);
     return result.target ? { target: result.target, source: result.targetSource } : null;
 };
 /**
  * Legacy function for backward compatibility - detects only output directory
  */
 export const detectOutputDir = (cwd = process.cwd()) => {
-    const result = detectTargetAndOutput(cwd);
+    const result = detectProjectConfig(cwd);
     return result.outputDir ? { outputDir: result.outputDir, source: result.outputSource } : null;
 };
+/**
+ * Legacy function for backward compatibility - detects only browserslist
+ */
+export const detectBrowserslist = (cwd = process.cwd()) => {
+    const result = detectProjectConfig(cwd);
+    return result.browserslist ? { browserslist: result.browserslist, source: result.browserslistSource } : null;
+};
+/**
+ * Legacy function for backward compatibility - detects target and output directory
+ */
+export const detectTargetAndOutput = (cwd = process.cwd()) => {
+    const result = detectProjectConfig(cwd);
+    return {
+        target: result.target,
+        targetSource: result.targetSource,
+        outputDir: result.outputDir,
+        outputSource: result.outputSource,
+        browserslist: result.browserslist,
+        browserslistSource: result.browserslistSource,
+    };
+};
 /**
  * Parse package.json for both target and output directory
  */
@@ -306,20 +258,14 @@ const parsePackageJson = (filePath) => {
         return {};
     }
     const result = {};
-    // Check for browserslist field for target
+    // 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) {
-                    result.target = target;
-                    break;
-                }
-            }
-        }
+        // Store the full browserslist for CLI defaults
+        result.browserslist = browserslist.filter((browser) => typeof browser === "string");
     }
+    // Use global project type detection (lazy initialization)
+    const projectType = getCurrentProjectType(path.dirname(filePath));
     // Check for output directory hints
     if (pkg.dist) {
         result.outputDir = pkg.dist;
@@ -330,9 +276,15 @@ const parsePackageJson = (filePath) => {
     else if (pkg.main && pkg.main.startsWith("./dist/")) {
         result.outputDir = "dist";
     }
-    else if (pkg.dependencies?.next || pkg.devDependencies?.next) {
-        // Next.js apps default to .next directory
+    else if (projectType === "nextjs") {
+        // Set default output directory for Next.js projects
         result.outputDir = ".next/static";
+        result.outputSource = "package.json (default)";
+    }
+    // If no browserslist was found, use default for detected project type
+    if (!result.browserslist && projectType === "nextjs") {
+        result.browserslist = [...NEXTJS_DEFAULT_BROWSERSLIST];
+        result.browserslistSource = "Next.js default";
     }
     return result;
 };
@@ -363,6 +315,7 @@ const parseTsConfig = (filePath) => {
  */
 const parseBabelConfig = (filePath) => {
     const content = readTextFile(filePath);
+    const result = {};
     // Look for @babel/preset-env configuration
     const presetEnvMatch = content.match(/@babel\/preset-env.*?targets.*?(\{[^}]*\})/s);
     if (presetEnvMatch) {
@@ -371,13 +324,16 @@ const parseBabelConfig = (filePath) => {
         const browsersMatch = targetsStr.match(/browsers.*?\[(.*?)\]/);
         if (browsersMatch) {
             const browsers = browsersMatch[1];
-            const target = parseESVersion(browsers);
-            if (target) {
-                return { target };
-            }
+            // Parse browsers array from string
+            const browsersList = browsers
+                .split(",")
+                .map((b) => b.trim().replace(/['"]/g, ""))
+                .filter((b) => b);
+            // Store the full browserslist for CLI defaults
+            result.browserslist = browsersList;
         }
     }
-    return {};
+    return result;
 };
 /**
  * Parse .babelrc for target
@@ -388,23 +344,20 @@ const parseBabelRc = (filePath) => {
         console.warn(`Warning: ${filePath} does not look like a valid .babelrc (missing or invalid presets field).`);
         return {};
     }
+    const result = {};
     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 };
-                        }
-                    }
+                    // Store the full browserslist for CLI defaults
+                    result.browserslist = browsers;
                 }
             }
         }
     }
-    return {};
+    return result;
 };
 /**
  * Parse vite.config.js/ts for both target and output directory
@@ -454,7 +407,7 @@ const parseWebpackConfig = (filePath) => {
     return result;
 };
 /**
- * Parse .browserslistrc or .browserslist file for ES target
+ * Parse .browserslistrc or .browserslist file for browserslist
  */
 const parseBrowserslistFile = (filePath) => {
     const content = readTextFile(filePath);
@@ -462,13 +415,10 @@ const parseBrowserslistFile = (filePath) => {
         .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 {};
+    const result = {};
+    // Store the full browserslist for CLI defaults
+    result.browserslist = lines;
+    return result;
 };
 /**
  * Parse next.config.js/ts/cjs/mjs for output directory

package/dist/lib/globalState.js

@@ -1,7 +1,9 @@
-// Global state management for CLI options
+// Global state management for CLI options and project configuration
 // Static global state variables
 export let verboseMode = false;
 export let debugMode = false;
+export let projectType = undefined;
+export let projectTypeDetected = false;
 /**
  * Set the global verbose mode
  */
@@ -21,6 +23,8 @@ export const getGlobalState = () => {
     return {
         verbose: verboseMode,
         debug: debugMode,
+        projectType,
+        projectTypeDetected,
     };
 };
 /**
@@ -31,6 +35,10 @@ export const setGlobalState = (options) => {
         verboseMode = options.verbose;
     if (options.debug !== undefined)
         debugMode = options.debug;
+    if (options.projectType !== undefined)
+        projectType = options.projectType;
+    if (options.projectTypeDetected !== undefined)
+        projectTypeDetected = options.projectTypeDetected;
 };
 /**
  * Reset global state to defaults
@@ -38,4 +46,25 @@ export const setGlobalState = (options) => {
 export const resetGlobalState = () => {
     verboseMode = false;
     debugMode = false;
+    projectType = undefined;
+    projectTypeDetected = false;
+};
+/**
+ * Set the detected project type globally
+ */
+export const setProjectType = (detectedType) => {
+    projectType = detectedType;
+    projectTypeDetected = true;
+};
+/**
+ * Get the detected project type (lazy detection if not already done)
+ */
+export const getProjectType = () => {
+    return projectType;
+};
+/**
+ * Check if project type has been detected
+ */
+export const isProjectTypeDetected = () => {
+    return projectTypeDetected;
 };

package/dist/lib/projectType.js

@@ -0,0 +1,46 @@
+import * as fs from "fs";
+import * as path from "path";
+import { verboseMode, setProjectType, getProjectType, isProjectTypeDetected } from "./globalState.js";
+import { detectProjectType } from "./defaults.js";
+import { readJsonFile, isPackageJson } from "./utils.js";
+/**
+ * Detect and cache project type globally (lazy initialization)
+ */
+export const detectAndCacheProjectType = (cwd = process.cwd()) => {
+    // Return cached result if already detected
+    if (isProjectTypeDetected()) {
+        return getProjectType() || null;
+    }
+    // Detect project type from package.json
+    const packageJsonPath = path.join(cwd, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = readJsonFile(packageJsonPath);
+            if (isPackageJson(pkg)) {
+                const detectedType = detectProjectType(pkg.dependencies, pkg.devDependencies);
+                setProjectType(detectedType);
+                if (verboseMode) {
+                    console.log(`🔍 Project type detected: ${detectedType}`);
+                }
+                return detectedType;
+            }
+        }
+        catch (error) {
+            // Ignore errors when detecting project type
+            if (verboseMode) {
+                console.log(`   ⚠️  Error detecting project type: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    // No project type detected
+    if (verboseMode) {
+        console.log(`🔍 No project type detected`);
+    }
+    return null;
+};
+/**
+ * Get the current project type (detects if not already cached)
+ */
+export const getCurrentProjectType = (cwd = process.cwd()) => {
+    return detectAndCacheProjectType(cwd) || "generic";
+};

package/dist/lib/utils.js

@@ -0,0 +1,76 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Helper to read and parse JSON file safely
+ */
+export const readJsonFile = (filePath) => {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+};
+/**
+ * Helper to read text file safely
+ */
+export const readTextFile = (filePath) => {
+    return fs.readFileSync(filePath, "utf-8");
+};
+/**
+ * Helper to safely evaluate JavaScript files (for config files)
+ */
+export const evaluateJsFile = (filePath) => {
+    const content = readTextFile(filePath);
+    // Create a safe evaluation context
+    const module = { exports: {} };
+    const require = (id) => {
+        if (id === "path")
+            return path;
+        if (id === "fs")
+            return fs;
+        throw new Error(`Cannot require '${id}' in config evaluation`);
+    };
+    try {
+        // Use Function constructor to create a safe evaluation environment
+        const fn = new Function("module", "exports", "require", "path", "fs", "__dirname", content);
+        fn(module, module.exports, require, path, fs, path.dirname(filePath));
+        return module.exports;
+    }
+    catch (error) {
+        console.warn(`Error evaluating ${filePath}:`, error);
+        return null;
+    }
+};
+/**
+ * Type guard for package.json structure
+ */
+export const isPackageJson = (obj) => {
+    return typeof obj === "object" && obj !== null;
+};
+/**
+ * Type guard for tsconfig.json structure
+ */
+export const isTsConfig = (obj) => {
+    return typeof obj === "object" && obj !== null && "compilerOptions" in obj;
+};
+/**
+ * Type guard for .babelrc structure
+ */
+export const isBabelRc = (obj) => {
+    return typeof obj === "object" && obj !== null && "presets" in obj;
+};
+/**
+ * Type guard for vite config structure
+ */
+export const isViteConfig = (obj) => {
+    return typeof obj === "object" && obj !== null;
+};
+/**
+ * Type guard for webpack config structure
+ */
+export const isWebpackConfig = (obj) => {
+    return typeof obj === "object" && obj !== null;
+};
+/**
+ * Type guard for next.js config structure
+ */
+export const isNextConfig = (obj) => {
+    return typeof obj === "object" && obj !== null;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-guard",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "A tool to check JavaScript compatibility with target environments",
   "type": "module",
   "main": "dist/cli.js",