console-sniper 1.0.0

package/dist/index.cjs

@@ -0,0 +1,250 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_METHODS: () => DEFAULT_METHODS,
+  PACKAGE_NAME: () => PACKAGE_NAME,
+  PACKAGE_VERSION: () => PACKAGE_VERSION,
+  SUPPORTED_EXTENSIONS: () => SUPPORTED_EXTENSIONS,
+  formatCount: () => formatCount,
+  isSupportedFile: () => isSupportedFile,
+  parseMethodList: () => parseMethodList,
+  resolveOptionsSync: () => resolveOptionsSync,
+  shouldProcessFile: () => shouldProcessFile,
+  stripConsoleFromCode: () => stripConsoleFromCode
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/stripConsole.ts
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var import_generator = __toESM(require("@babel/generator"), 1);
+var t = __toESM(require("@babel/types"), 1);
+
+// src/core/constants.ts
+var PACKAGE_NAME = "console-sniper";
+var PACKAGE_VERSION = "1.0.0";
+var DEFAULT_METHODS = [
+  "log",
+  "warn",
+  "error",
+  "info",
+  "debug"
+];
+var DEFAULT_REMOVE_COMMENTS = true;
+var SUPPORTED_EXTENSIONS = [
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts"
+];
+var CONSOLE_KEYWORD = "console";
+
+// src/core/utils.ts
+var import_node_path = __toESM(require("path"), 1);
+function resolveOptionsSync(options) {
+  return {
+    methods: options?.methods?.length ? options.methods : [...DEFAULT_METHODS],
+    removeComments: options?.removeComments ?? DEFAULT_REMOVE_COMMENTS,
+    include: options?.include ?? [],
+    exclude: options?.exclude ?? [],
+    silent: options?.silent ?? false
+  };
+}
+function isSupportedFile(filePath) {
+  const ext = import_node_path.default.extname(filePath).toLowerCase();
+  return SUPPORTED_EXTENSIONS.includes(ext);
+}
+function shouldProcessFile(filePath, include = [], exclude = []) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (include.length > 0 && !include.some((p) => p.test(normalized))) return false;
+  if (exclude.length > 0 && exclude.some((p) => p.test(normalized))) return false;
+  return true;
+}
+function parseMethodList(input) {
+  return input.split(",").map((m) => m.trim()).filter((m) => m.length > 0);
+}
+function formatCount(count, noun) {
+  return `${count} ${noun}${count !== 1 ? "s" : ""}`;
+}
+
+// src/core/stripConsole.ts
+var traverse = typeof import_traverse.default === "function" ? import_traverse.default : import_traverse.default.default;
+var generate = typeof import_generator.default === "function" ? import_generator.default : import_generator.default.default;
+function stripConsoleFromCode(code, options) {
+  const opts = resolveOptionsSync(options);
+  const methodsToRemove = new Set(opts.methods);
+  const removedMethods = [];
+  const parserOptions = {
+    sourceType: "module",
+    // Support import/export statements
+    strictMode: false,
+    // Don't throw on sloppy-mode code
+    allowImportExportEverywhere: true,
+    allowReturnOutsideFunction: true,
+    allowSuperOutsideMethod: true,
+    plugins: [
+      "typescript",
+      // TypeScript syntax (types, generics, decorators)
+      "jsx",
+      // JSX/TSX syntax
+      "decorators",
+      // @decorator syntax
+      "classProperties",
+      "classPrivateProperties",
+      "classPrivateMethods",
+      "classStaticBlock",
+      "dynamicImport",
+      // import(...)
+      "exportDefaultFrom",
+      "exportNamespaceFrom",
+      "nullishCoalescingOperator",
+      // ??
+      "optionalChaining",
+      // ?.
+      "optionalCatchBinding",
+      "logicalAssignment",
+      // &&=, ||=, ??=
+      "numericSeparator",
+      // 1_000_000
+      "bigInt",
+      "importMeta",
+      // import.meta
+      "topLevelAwait"
+    ]
+  };
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(code, parserOptions);
+  } catch (parseError) {
+    if (!opts.silent) {
+      console.warn(
+        `[console-sniper] Failed to parse code, skipping. Error: ${parseError instanceof Error ? parseError.message : String(parseError)}`
+      );
+    }
+    return {
+      code,
+      removedCount: 0,
+      removedMethods: [],
+      changed: false
+    };
+  }
+  traverse(ast, {
+    ExpressionStatement(nodePath) {
+      const { expression } = nodePath.node;
+      if (!t.isCallExpression(expression)) return;
+      const { callee } = expression;
+      if (!t.isMemberExpression(callee)) return;
+      const { object, property } = callee;
+      if (!t.isIdentifier(object, { name: "console" })) return;
+      let methodName;
+      if (t.isIdentifier(property)) {
+        methodName = property.name;
+      } else if (t.isStringLiteral(property)) {
+        methodName = property.value;
+      }
+      if (!methodName || !methodsToRemove.has(methodName)) return;
+      removedMethods.push(methodName);
+      nodePath.remove();
+    }
+  });
+  if (opts.removeComments) {
+    removeConsoleComments(ast);
+  }
+  const { code: transformedCode } = generate(
+    ast,
+    {
+      retainLines: false,
+      // Compact output; set true if you need line parity
+      compact: false,
+      // Keep human-readable whitespace
+      concise: false,
+      comments: true,
+      // Include non-console comments
+      jsescOption: {
+        minimal: true
+        // Don't over-escape unicode
+      }
+    },
+    code
+    // Original source (used for sourcemap generation)
+  );
+  const removedCount = removedMethods.length;
+  return {
+    code: transformedCode,
+    removedCount,
+    removedMethods,
+    changed: removedCount > 0
+  };
+}
+function removeConsoleComments(ast) {
+  function filterComments(comments) {
+    if (!comments || comments.length === 0) return comments ?? null;
+    return comments.filter(
+      (comment) => !comment.value.includes(CONSOLE_KEYWORD)
+    );
+  }
+  traverse(ast, {
+    enter(nodePath) {
+      const { node } = nodePath;
+      if (node.leadingComments) {
+        const filtered = filterComments(node.leadingComments);
+        node.leadingComments = filtered;
+      }
+      if (node.trailingComments) {
+        const filtered = filterComments(node.trailingComments);
+        node.trailingComments = filtered;
+      }
+      if (node.innerComments) {
+        const filtered = filterComments(node.innerComments);
+        node.innerComments = filtered;
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_METHODS,
+  PACKAGE_NAME,
+  PACKAGE_VERSION,
+  SUPPORTED_EXTENSIONS,
+  formatCount,
+  isSupportedFile,
+  parseMethodList,
+  resolveOptionsSync,
+  shouldProcessFile,
+  stripConsoleFromCode
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/core/stripConsole.ts","../src/core/constants.ts","../src/core/utils.ts"],"sourcesContent":["/**\r\n * @file index.ts\r\n * @description The main public API entry point for console-sniper.\r\n *\r\n * This file re-exports everything that external consumers might need.\r\n * Think of it as the \"public interface\" of the package.\r\n *\r\n * Usage:\r\n *   import { stripConsoleFromCode } from \"console-sniper\"\r\n *   import type { StripConsoleOptions, StripConsoleResult } from \"console-sniper\"\r\n *\r\n * The Vite plugin is intentionally NOT exported from here — it lives at\r\n * \"console-sniper/vite\" to keep Vite as an optional peer dependency.\r\n */\r\n\r\n// Core Engine\r\nexport { stripConsoleFromCode } from \"./core/stripConsole.js\";\r\n\r\n// Types\r\nexport type {\r\n  StripConsoleOptions,\r\n  StripConsoleResult,\r\n  FileProcessResult,\r\n  BatchSummary,\r\n  VitePluginOptions,\r\n  CliOptions,\r\n} from \"./core/types.js\";\r\n\r\n// Constants\r\nexport {\r\n  DEFAULT_METHODS,\r\n  SUPPORTED_EXTENSIONS,\r\n  PACKAGE_NAME,\r\n  PACKAGE_VERSION,\r\n} from \"./core/constants.js\";\r\n\r\n// Utilities\r\nexport {\r\n  resolveOptionsSync,\r\n  isSupportedFile,\r\n  shouldProcessFile,\r\n  parseMethodList,\r\n  formatCount,\r\n} from \"./core/utils.js\";\r\n","/**\r\n * @file stripConsole.ts\r\n * @description The AST-based core engine that removes console statements.\r\n *\r\n * ─── Architecture Note ────────────────────────────────────────────────────────\r\n * This file is the heart of console-sniper. It has ZERO dependencies on Vite,\r\n * the CLI, or Node.js file system APIs. It works purely on source code strings.\r\n *\r\n * This isolation means the same engine can power:\r\n *   • The Vite plugin (src/vite/vitePlugin.ts)\r\n *   • The CLI (src/cli/cli.ts)\r\n *   • Future: Rollup, Webpack, esbuild, Bun plugins\r\n *   • Any programmatic usage\r\n * ─────────────────────────────────────────────────────────────────────────────\r\n *\r\n * How it works (at a high level):\r\n *   1. Parse the source code into an AST (Abstract Syntax Tree)\r\n *   2. Walk the AST looking for `ExpressionStatement` nodes where the\r\n *      expression is a `CallExpression` like `console.log(...)`\r\n *   3. Remove those nodes from the AST\r\n *   4. Optionally scan and remove comments referencing \"console\"\r\n *   5. Re-generate source code from the modified AST\r\n */\r\n\r\nimport { parse, type ParserOptions } from \"@babel/parser\";\r\nimport _traverse from \"@babel/traverse\";\r\nimport _generate from \"@babel/generator\";\r\nimport * as t from \"@babel/types\";\r\n\r\nimport { CONSOLE_KEYWORD } from \"./constants.js\";\r\nimport { resolveOptionsSync } from \"./utils.js\";\r\nimport type { StripConsoleOptions, StripConsoleResult } from \"./types.js\";\r\n\r\n\r\n// CJS/ESM interop fix\r\n\r\n// @babel/traverse and @babel/generator are CommonJS packages. When this\r\n// module is bundled as ESM (or loaded via ts-node/vitest), the default\r\n// import may resolve to the module object rather than the callable function.\r\n// The actual function is always available on `.default` in that case.\r\n// We normalise once here so every call site just works.\r\nconst traverse = (\r\n  typeof _traverse === \"function\" ? _traverse : (_traverse as any).default\r\n) as typeof _traverse;\r\n\r\nconst generate = (\r\n  typeof _generate === \"function\" ? _generate : (_generate as any).default\r\n) as typeof _generate;\r\n\r\n\r\n// Public API\r\n\r\n/**\r\n * Strip `console.*` calls from a source code string using AST parsing.\r\n *\r\n * This is the primary public API of console-sniper. It's pure and stateless —\r\n * give it code, get transformed code back. Nothing is written to disk here.\r\n *\r\n * @param code    - The source code to transform (JS, TS, JSX, TSX)\r\n * @param options - Optional configuration\r\n * @returns       - The transformed code + metadata about what was removed\r\n *\r\n * @example\r\n * ```ts\r\n * const { code, removedCount, changed } = stripConsoleFromCode(`\r\n *   console.log(\"hello\");\r\n *   const x = 1 + 2;\r\n *   console.warn(\"something\");\r\n * `);\r\n * // code     → \"\\nconst x = 1 + 2;\\n\"\r\n * // removed  → 2\r\n * // changed  → true\r\n * ```\r\n */\r\nexport function stripConsoleFromCode(\r\n  code: string,\r\n  options?: StripConsoleOptions\r\n): StripConsoleResult {\r\n  // 1. Resolve options (fills in defaults for anything not specified)\r\n  const opts = resolveOptionsSync(options);\r\n  const methodsToRemove = new Set(opts.methods);\r\n\r\n  // Track what we remove for the metadata result\r\n  const removedMethods: string[] = [];\r\n\r\n  // ── Step 1: Parse ────────────────────────────────────────────\r\n  // We need to tell Babel's parser about all the syntax we might encounter.\r\n  // Using all these plugins means a single parser config handles every file\r\n  // type (JS, TS, JSX, TSX) without needing per-file configuration.\r\n  const parserOptions: ParserOptions = {\r\n    sourceType: \"module\",  // Support import/export statements\r\n    strictMode: false,     // Don't throw on sloppy-mode code\r\n    allowImportExportEverywhere: true,\r\n    allowReturnOutsideFunction: true,\r\n    allowSuperOutsideMethod: true,\r\n    plugins: [\r\n      \"typescript\",     // TypeScript syntax (types, generics, decorators)\r\n      \"jsx\",            // JSX/TSX syntax\r\n      \"decorators\",     // @decorator syntax\r\n      \"classProperties\",\r\n      \"classPrivateProperties\",\r\n      \"classPrivateMethods\",\r\n      \"classStaticBlock\",\r\n      \"dynamicImport\",  // import(...)\r\n      \"exportDefaultFrom\",\r\n      \"exportNamespaceFrom\",\r\n      \"nullishCoalescingOperator\", // ??\r\n      \"optionalChaining\",          // ?.\r\n      \"optionalCatchBinding\",\r\n      \"logicalAssignment\",         // &&=, ||=, ??=\r\n      \"numericSeparator\",          // 1_000_000\r\n      \"bigInt\",\r\n      \"importMeta\",                // import.meta\r\n      \"topLevelAwait\",\r\n    ],\r\n  };\r\n\r\n  let ast: ReturnType<typeof parse>;\r\n\r\n  try {\r\n    ast = parse(code, parserOptions);\r\n  } catch (parseError) {\r\n    // If parsing fails (e.g. unsupported syntax), return the original code\r\n    // unchanged rather than crashing. This is safer for production builds.\r\n    if (!opts.silent) {\r\n      console.warn(\r\n        `[console-sniper] Failed to parse code, skipping. Error: ${\r\n          parseError instanceof Error ? parseError.message : String(parseError)\r\n        }`\r\n      );\r\n    }\r\n    return {\r\n      code,\r\n      removedCount: 0,\r\n      removedMethods: [],\r\n      changed: false,\r\n    };\r\n  }\r\n\r\n  // ── Step 2: Traverse & Remove Console Calls ─────────────────\r\n  //\r\n  // We look for nodes matching this AST pattern:\r\n  //\r\n  //   ExpressionStatement\r\n  //     └── CallExpression\r\n  //           ├── callee: MemberExpression\r\n  //           │     ├── object: Identifier { name: \"console\" }\r\n  //           │     └── property: Identifier { name: \"log\" | \"warn\" | ... }\r\n  //           └── arguments: [...]\r\n  //\r\n  // Matching the full ExpressionStatement (the statement wrapper) rather than\r\n  // just the CallExpression lets us safely remove the entire line — including\r\n  // the trailing semicolon — without leaving orphan syntax behind.\r\n\r\n  traverse(ast, {\r\n    ExpressionStatement(nodePath) {\r\n      const { expression } = nodePath.node;\r\n\r\n      // Must be a function call\r\n      if (!t.isCallExpression(expression)) return;\r\n\r\n      const { callee } = expression;\r\n\r\n      // The callee must be a member expression (object.method)\r\n      if (!t.isMemberExpression(callee)) return;\r\n\r\n      const { object, property } = callee;\r\n\r\n      // The object must be `console` (an Identifier with name \"console\")\r\n      if (!t.isIdentifier(object, { name: \"console\" })) return;\r\n\r\n      // The property must be one of our configured methods\r\n      // Property can be either an Identifier (console.log) or\r\n      // a StringLiteral (console[\"log\"]) — we handle both.\r\n      let methodName: string | undefined;\r\n\r\n      if (t.isIdentifier(property)) {\r\n        methodName = property.name;\r\n      } else if (t.isStringLiteral(property)) {\r\n        methodName = property.value;\r\n      }\r\n\r\n      if (!methodName || !methodsToRemove.has(methodName)) return;\r\n\r\n      // ✅ This is a console call we should remove!\r\n      removedMethods.push(methodName);\r\n\r\n      // `nodePath.remove()` is the safe Babel way to delete a node.\r\n      // It properly handles parent references, scope bindings, etc.\r\n      nodePath.remove();\r\n    },\r\n  });\r\n\r\n  // ── Step 3: Remove Console Comments ─────────────────────────\r\n  //\r\n  // Babel attaches comments to the nearest AST node as `leadingComments`\r\n  // or `trailingComments`. We need to scan ALL nodes and filter out\r\n  // any comments that mention \"console\".\r\n  //\r\n  // We do this AFTER the traverse so we don't interfere with node removal.\r\n\r\n  if (opts.removeComments) {\r\n    removeConsoleComments(ast);\r\n  }\r\n\r\n  // ── Step 4: Re-generate Source Code ─────────────────────────\r\n  //\r\n  // @babel/generator walks the (now modified) AST and prints it back to a\r\n  // string. We enable `retainLines` to preserve line numbers as much as\r\n  // possible — this keeps source maps accurate and diffs readable.\r\n\r\n  const { code: transformedCode } = generate(\r\n    ast,\r\n    {\r\n      retainLines: false,  // Compact output; set true if you need line parity\r\n      compact: false,      // Keep human-readable whitespace\r\n      concise: false,\r\n      comments: true,      // Include non-console comments\r\n      jsescOption: {\r\n        minimal: true,     // Don't over-escape unicode\r\n      },\r\n    },\r\n    code // Original source (used for sourcemap generation)\r\n  );\r\n\r\n  const removedCount = removedMethods.length;\r\n\r\n  return {\r\n    code: transformedCode,\r\n    removedCount,\r\n    removedMethods,\r\n    changed: removedCount > 0,\r\n  };\r\n}\r\n\r\n// Internal Helpers\r\n\r\n/**\r\n * Walk the AST and strip comments that reference \"console\".\r\n *\r\n * Babel stores comments as arrays on AST nodes:\r\n *   node.leadingComments  — comments before the node\r\n *   node.innerComments    — comments inside empty blocks\r\n *   node.trailingComments — comments after the node\r\n *\r\n * We filter each array, removing comments whose `value` contains the\r\n * CONSOLE_KEYWORD (\"console\").\r\n *\r\n * @param ast - The parsed AST (mutated in place)\r\n */\r\nfunction removeConsoleComments(ast: t.File): void {\r\n  /**\r\n   * Filter a comment array, removing any that mention \"console\".\r\n   */\r\n  function filterComments(\r\n    comments: t.Comment[] | null | undefined\r\n  ): t.Comment[] | null {\r\n    if (!comments || comments.length === 0) return comments ?? null;\r\n\r\n    return comments.filter(\r\n      (comment) => !comment.value.includes(CONSOLE_KEYWORD)\r\n    );\r\n  }\r\n\r\n  // We need to visit every node in the AST.\r\n  // `traverse` with no specific node type visits everything.\r\n  traverse(ast, {\r\n    enter(nodePath) {\r\n      const { node } = nodePath;\r\n\r\n      // Filter leading comments (e.g. `// console.log here`)\r\n      if (node.leadingComments) {\r\n        const filtered = filterComments(node.leadingComments);\r\n        // Babel uses `null` when there are no comments\r\n        (node as t.Node & { leadingComments: t.Comment[] | null }).leadingComments =\r\n          filtered;\r\n      }\r\n\r\n      // Filter trailing comments (e.g. `}  // end console block`)\r\n      if (node.trailingComments) {\r\n        const filtered = filterComments(node.trailingComments);\r\n        (node as t.Node & { trailingComments: t.Comment[] | null }).trailingComments =\r\n          filtered;\r\n      }\r\n\r\n      // Filter inner comments (e.g. comments inside empty blocks)\r\n      if (node.innerComments) {\r\n        const filtered = filterComments(node.innerComments);\r\n        (node as t.Node & { innerComments: t.Comment[] | null }).innerComments =\r\n          filtered;\r\n      }\r\n    },\r\n  });\r\n}\r\n","/**\r\n * @file constants.ts\r\n * @description Global constants used across the project.\r\n *\r\n * Centralizing magic strings and default values here prevents typos\r\n * and makes it trivial to change defaults in one place.\r\n */\r\n\r\n\r\n// Package Identity\r\n\r\n/** The package name — used in logs, banners, and plugin names. */\r\nexport const PACKAGE_NAME = \"console-sniper\";\r\n\r\n/** Current version — ideally sync'd with package.json at build time. */\r\nexport const PACKAGE_VERSION = \"1.0.0\";\r\n\r\n\r\n// Console Stripping Defaults\r\n\r\n/**\r\n * Default console methods that are removed when `methods` is not specified.\r\n *\r\n * Extending this list is the primary way to support new console variants\r\n * like `console.table`, `console.time`, `console.group`, etc.\r\n */\r\nexport const DEFAULT_METHODS: readonly string[] = [\r\n  \"log\",\r\n  \"warn\",\r\n  \"error\",\r\n  \"info\",\r\n  \"debug\",\r\n] as const;\r\n\r\n/**\r\n * Whether to remove comments containing \"console\" by default.\r\n */\r\nexport const DEFAULT_REMOVE_COMMENTS = true;\r\n\r\n\r\n// File Extension Filters\r\n\r\n/**\r\n * File extensions that the Babel parser can handle.\r\n * These are used by the CLI file scanner to filter which files to process.\r\n *\r\n * Note: The Babel parser handles TypeScript and JSX natively via plugins.\r\n */\r\nexport const SUPPORTED_EXTENSIONS: readonly string[] = [\r\n  \".js\",\r\n  \".mjs\",\r\n  \".cjs\",\r\n  \".jsx\",\r\n  \".ts\",\r\n  \".tsx\",\r\n  \".mts\",\r\n  \".cts\",\r\n] as const;\r\n\r\n/**\r\n * Default glob patterns for the CLI to EXCLUDE when scanning directories.\r\n */\r\nexport const DEFAULT_EXCLUDE_PATTERNS: readonly string[] = [\r\n  \"**/node_modules/**\",\r\n  \"**/dist/**\",\r\n  \"**/build/**\",\r\n  \"**/.git/**\",\r\n  \"**/*.min.js\",\r\n  \"**/*.d.ts\",\r\n] as const;\r\n\r\n// AST Parser Config\r\n\r\n/**\r\n * The word we look for when scanning comment text.\r\n * Keeping this as a constant prevents subtle bugs from typos.\r\n */\r\nexport const CONSOLE_KEYWORD = \"console\";\r\n","/**\r\n * @file utils.ts\r\n * @description Pure utility functions shared across the core engine.\r\n */\r\n\r\nimport path from \"node:path\";\r\nimport { SUPPORTED_EXTENSIONS, DEFAULT_METHODS, DEFAULT_REMOVE_COMMENTS } from \"./constants.js\";\r\nimport type { StripConsoleOptions } from \"./types.js\";\r\n\r\nexport function resolveOptionsSync(\r\n  options?: StripConsoleOptions\r\n): StripConsoleOptions & {\r\n  methods: string[];\r\n  removeComments: boolean;\r\n  silent: boolean;\r\n} {\r\n  return {\r\n    methods: options?.methods?.length ? options.methods : [...DEFAULT_METHODS],\r\n    removeComments: options?.removeComments ?? DEFAULT_REMOVE_COMMENTS,\r\n    include: options?.include ?? [],\r\n    exclude: options?.exclude ?? [],\r\n    silent: options?.silent ?? false,\r\n  };\r\n}\r\n\r\nexport function isSupportedFile(filePath: string): boolean {\r\n  const ext = path.extname(filePath).toLowerCase();\r\n  return (SUPPORTED_EXTENSIONS as readonly string[]).includes(ext);\r\n}\r\n\r\nexport function shouldProcessFile(\r\n  filePath: string,\r\n  include: RegExp[] = [],\r\n  exclude: RegExp[] = []\r\n): boolean {\r\n  const normalized = filePath.replace(/\\\\/g, \"/\");\r\n  if (include.length > 0 && !include.some((p) => p.test(normalized))) return false;\r\n  if (exclude.length > 0 && exclude.some((p) => p.test(normalized))) return false;\r\n  return true;\r\n}\r\n\r\nexport function parseMethodList(input: string): string[] {\r\n  return input.split(\",\").map((m) => m.trim()).filter((m) => m.length > 0);\r\n}\r\n\r\nexport function formatCount(count: number, noun: string): string {\r\n  return `${count} ${noun}${count !== 1 ? \"s\" : \"\"}`;\r\n}\r\n\r\nexport function isNode(): boolean {\r\n  return typeof process !== \"undefined\" && process.versions?.node != null;\r\n}\r\n"],"mappings":"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","names":["path","_traverse","_generate"]}

package/dist/index.d.cts

@@ -0,0 +1,93 @@
+import { S as StripConsoleOptions, a as StripConsoleResult } from './types-J-TZoPXb.cjs';
+export { B as BatchSummary, C as CliOptions, F as FileProcessResult, V as VitePluginOptions } from './types-J-TZoPXb.cjs';
+
+/**
+ * @file stripConsole.ts
+ * @description The AST-based core engine that removes console statements.
+ *
+ * ─── Architecture Note ────────────────────────────────────────────────────────
+ * This file is the heart of console-sniper. It has ZERO dependencies on Vite,
+ * the CLI, or Node.js file system APIs. It works purely on source code strings.
+ *
+ * This isolation means the same engine can power:
+ *   • The Vite plugin (src/vite/vitePlugin.ts)
+ *   • The CLI (src/cli/cli.ts)
+ *   • Future: Rollup, Webpack, esbuild, Bun plugins
+ *   • Any programmatic usage
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * How it works (at a high level):
+ *   1. Parse the source code into an AST (Abstract Syntax Tree)
+ *   2. Walk the AST looking for `ExpressionStatement` nodes where the
+ *      expression is a `CallExpression` like `console.log(...)`
+ *   3. Remove those nodes from the AST
+ *   4. Optionally scan and remove comments referencing "console"
+ *   5. Re-generate source code from the modified AST
+ */
+
+/**
+ * Strip `console.*` calls from a source code string using AST parsing.
+ *
+ * This is the primary public API of console-sniper. It's pure and stateless —
+ * give it code, get transformed code back. Nothing is written to disk here.
+ *
+ * @param code    - The source code to transform (JS, TS, JSX, TSX)
+ * @param options - Optional configuration
+ * @returns       - The transformed code + metadata about what was removed
+ *
+ * @example
+ * ```ts
+ * const { code, removedCount, changed } = stripConsoleFromCode(`
+ *   console.log("hello");
+ *   const x = 1 + 2;
+ *   console.warn("something");
+ * `);
+ * // code     → "\nconst x = 1 + 2;\n"
+ * // removed  → 2
+ * // changed  → true
+ * ```
+ */
+declare function stripConsoleFromCode(code: string, options?: StripConsoleOptions): StripConsoleResult;
+
+/**
+ * @file constants.ts
+ * @description Global constants used across the project.
+ *
+ * Centralizing magic strings and default values here prevents typos
+ * and makes it trivial to change defaults in one place.
+ */
+/** The package name — used in logs, banners, and plugin names. */
+declare const PACKAGE_NAME = "console-sniper";
+/** Current version — ideally sync'd with package.json at build time. */
+declare const PACKAGE_VERSION = "1.0.0";
+/**
+ * Default console methods that are removed when `methods` is not specified.
+ *
+ * Extending this list is the primary way to support new console variants
+ * like `console.table`, `console.time`, `console.group`, etc.
+ */
+declare const DEFAULT_METHODS: readonly string[];
+/**
+ * File extensions that the Babel parser can handle.
+ * These are used by the CLI file scanner to filter which files to process.
+ *
+ * Note: The Babel parser handles TypeScript and JSX natively via plugins.
+ */
+declare const SUPPORTED_EXTENSIONS: readonly string[];
+
+/**
+ * @file utils.ts
+ * @description Pure utility functions shared across the core engine.
+ */
+
+declare function resolveOptionsSync(options?: StripConsoleOptions): StripConsoleOptions & {
+    methods: string[];
+    removeComments: boolean;
+    silent: boolean;
+};
+declare function isSupportedFile(filePath: string): boolean;
+declare function shouldProcessFile(filePath: string, include?: RegExp[], exclude?: RegExp[]): boolean;
+declare function parseMethodList(input: string): string[];
+declare function formatCount(count: number, noun: string): string;
+
+export { DEFAULT_METHODS, PACKAGE_NAME, PACKAGE_VERSION, SUPPORTED_EXTENSIONS, StripConsoleOptions, StripConsoleResult, formatCount, isSupportedFile, parseMethodList, resolveOptionsSync, shouldProcessFile, stripConsoleFromCode };

package/dist/index.d.ts

@@ -0,0 +1,93 @@
+import { S as StripConsoleOptions, a as StripConsoleResult } from './types-J-TZoPXb.js';
+export { B as BatchSummary, C as CliOptions, F as FileProcessResult, V as VitePluginOptions } from './types-J-TZoPXb.js';
+
+/**
+ * @file stripConsole.ts
+ * @description The AST-based core engine that removes console statements.
+ *
+ * ─── Architecture Note ────────────────────────────────────────────────────────
+ * This file is the heart of console-sniper. It has ZERO dependencies on Vite,
+ * the CLI, or Node.js file system APIs. It works purely on source code strings.
+ *
+ * This isolation means the same engine can power:
+ *   • The Vite plugin (src/vite/vitePlugin.ts)
+ *   • The CLI (src/cli/cli.ts)
+ *   • Future: Rollup, Webpack, esbuild, Bun plugins
+ *   • Any programmatic usage
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * How it works (at a high level):
+ *   1. Parse the source code into an AST (Abstract Syntax Tree)
+ *   2. Walk the AST looking for `ExpressionStatement` nodes where the
+ *      expression is a `CallExpression` like `console.log(...)`
+ *   3. Remove those nodes from the AST
+ *   4. Optionally scan and remove comments referencing "console"
+ *   5. Re-generate source code from the modified AST
+ */
+
+/**
+ * Strip `console.*` calls from a source code string using AST parsing.
+ *
+ * This is the primary public API of console-sniper. It's pure and stateless —
+ * give it code, get transformed code back. Nothing is written to disk here.
+ *
+ * @param code    - The source code to transform (JS, TS, JSX, TSX)
+ * @param options - Optional configuration
+ * @returns       - The transformed code + metadata about what was removed
+ *
+ * @example
+ * ```ts
+ * const { code, removedCount, changed } = stripConsoleFromCode(`
+ *   console.log("hello");
+ *   const x = 1 + 2;
+ *   console.warn("something");
+ * `);
+ * // code     → "\nconst x = 1 + 2;\n"
+ * // removed  → 2
+ * // changed  → true
+ * ```
+ */
+declare function stripConsoleFromCode(code: string, options?: StripConsoleOptions): StripConsoleResult;
+
+/**
+ * @file constants.ts
+ * @description Global constants used across the project.
+ *
+ * Centralizing magic strings and default values here prevents typos
+ * and makes it trivial to change defaults in one place.
+ */
+/** The package name — used in logs, banners, and plugin names. */
+declare const PACKAGE_NAME = "console-sniper";
+/** Current version — ideally sync'd with package.json at build time. */
+declare const PACKAGE_VERSION = "1.0.0";
+/**
+ * Default console methods that are removed when `methods` is not specified.
+ *
+ * Extending this list is the primary way to support new console variants
+ * like `console.table`, `console.time`, `console.group`, etc.
+ */
+declare const DEFAULT_METHODS: readonly string[];
+/**
+ * File extensions that the Babel parser can handle.
+ * These are used by the CLI file scanner to filter which files to process.
+ *
+ * Note: The Babel parser handles TypeScript and JSX natively via plugins.
+ */
+declare const SUPPORTED_EXTENSIONS: readonly string[];
+
+/**
+ * @file utils.ts
+ * @description Pure utility functions shared across the core engine.
+ */
+
+declare function resolveOptionsSync(options?: StripConsoleOptions): StripConsoleOptions & {
+    methods: string[];
+    removeComments: boolean;
+    silent: boolean;
+};
+declare function isSupportedFile(filePath: string): boolean;
+declare function shouldProcessFile(filePath: string, include?: RegExp[], exclude?: RegExp[]): boolean;
+declare function parseMethodList(input: string): string[];
+declare function formatCount(count: number, noun: string): string;
+
+export { DEFAULT_METHODS, PACKAGE_NAME, PACKAGE_VERSION, SUPPORTED_EXTENSIONS, StripConsoleOptions, StripConsoleResult, formatCount, isSupportedFile, parseMethodList, resolveOptionsSync, shouldProcessFile, stripConsoleFromCode };

package/dist/index.js

@@ -0,0 +1,204 @@
+// src/core/stripConsole.ts
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import _generate from "@babel/generator";
+import * as t from "@babel/types";
+
+// src/core/constants.ts
+var PACKAGE_NAME = "console-sniper";
+var PACKAGE_VERSION = "1.0.0";
+var DEFAULT_METHODS = [
+  "log",
+  "warn",
+  "error",
+  "info",
+  "debug"
+];
+var DEFAULT_REMOVE_COMMENTS = true;
+var SUPPORTED_EXTENSIONS = [
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts"
+];
+var CONSOLE_KEYWORD = "console";
+
+// src/core/utils.ts
+import path from "path";
+function resolveOptionsSync(options) {
+  return {
+    methods: options?.methods?.length ? options.methods : [...DEFAULT_METHODS],
+    removeComments: options?.removeComments ?? DEFAULT_REMOVE_COMMENTS,
+    include: options?.include ?? [],
+    exclude: options?.exclude ?? [],
+    silent: options?.silent ?? false
+  };
+}
+function isSupportedFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return SUPPORTED_EXTENSIONS.includes(ext);
+}
+function shouldProcessFile(filePath, include = [], exclude = []) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (include.length > 0 && !include.some((p) => p.test(normalized))) return false;
+  if (exclude.length > 0 && exclude.some((p) => p.test(normalized))) return false;
+  return true;
+}
+function parseMethodList(input) {
+  return input.split(",").map((m) => m.trim()).filter((m) => m.length > 0);
+}
+function formatCount(count, noun) {
+  return `${count} ${noun}${count !== 1 ? "s" : ""}`;
+}
+
+// src/core/stripConsole.ts
+var traverse = typeof _traverse === "function" ? _traverse : _traverse.default;
+var generate = typeof _generate === "function" ? _generate : _generate.default;
+function stripConsoleFromCode(code, options) {
+  const opts = resolveOptionsSync(options);
+  const methodsToRemove = new Set(opts.methods);
+  const removedMethods = [];
+  const parserOptions = {
+    sourceType: "module",
+    // Support import/export statements
+    strictMode: false,
+    // Don't throw on sloppy-mode code
+    allowImportExportEverywhere: true,
+    allowReturnOutsideFunction: true,
+    allowSuperOutsideMethod: true,
+    plugins: [
+      "typescript",
+      // TypeScript syntax (types, generics, decorators)
+      "jsx",
+      // JSX/TSX syntax
+      "decorators",
+      // @decorator syntax
+      "classProperties",
+      "classPrivateProperties",
+      "classPrivateMethods",
+      "classStaticBlock",
+      "dynamicImport",
+      // import(...)
+      "exportDefaultFrom",
+      "exportNamespaceFrom",
+      "nullishCoalescingOperator",
+      // ??
+      "optionalChaining",
+      // ?.
+      "optionalCatchBinding",
+      "logicalAssignment",
+      // &&=, ||=, ??=
+      "numericSeparator",
+      // 1_000_000
+      "bigInt",
+      "importMeta",
+      // import.meta
+      "topLevelAwait"
+    ]
+  };
+  let ast;
+  try {
+    ast = parse(code, parserOptions);
+  } catch (parseError) {
+    if (!opts.silent) {
+      console.warn(
+        `[console-sniper] Failed to parse code, skipping. Error: ${parseError instanceof Error ? parseError.message : String(parseError)}`
+      );
+    }
+    return {
+      code,
+      removedCount: 0,
+      removedMethods: [],
+      changed: false
+    };
+  }
+  traverse(ast, {
+    ExpressionStatement(nodePath) {
+      const { expression } = nodePath.node;
+      if (!t.isCallExpression(expression)) return;
+      const { callee } = expression;
+      if (!t.isMemberExpression(callee)) return;
+      const { object, property } = callee;
+      if (!t.isIdentifier(object, { name: "console" })) return;
+      let methodName;
+      if (t.isIdentifier(property)) {
+        methodName = property.name;
+      } else if (t.isStringLiteral(property)) {
+        methodName = property.value;
+      }
+      if (!methodName || !methodsToRemove.has(methodName)) return;
+      removedMethods.push(methodName);
+      nodePath.remove();
+    }
+  });
+  if (opts.removeComments) {
+    removeConsoleComments(ast);
+  }
+  const { code: transformedCode } = generate(
+    ast,
+    {
+      retainLines: false,
+      // Compact output; set true if you need line parity
+      compact: false,
+      // Keep human-readable whitespace
+      concise: false,
+      comments: true,
+      // Include non-console comments
+      jsescOption: {
+        minimal: true
+        // Don't over-escape unicode
+      }
+    },
+    code
+    // Original source (used for sourcemap generation)
+  );
+  const removedCount = removedMethods.length;
+  return {
+    code: transformedCode,
+    removedCount,
+    removedMethods,
+    changed: removedCount > 0
+  };
+}
+function removeConsoleComments(ast) {
+  function filterComments(comments) {
+    if (!comments || comments.length === 0) return comments ?? null;
+    return comments.filter(
+      (comment) => !comment.value.includes(CONSOLE_KEYWORD)
+    );
+  }
+  traverse(ast, {
+    enter(nodePath) {
+      const { node } = nodePath;
+      if (node.leadingComments) {
+        const filtered = filterComments(node.leadingComments);
+        node.leadingComments = filtered;
+      }
+      if (node.trailingComments) {
+        const filtered = filterComments(node.trailingComments);
+        node.trailingComments = filtered;
+      }
+      if (node.innerComments) {
+        const filtered = filterComments(node.innerComments);
+        node.innerComments = filtered;
+      }
+    }
+  });
+}
+export {
+  DEFAULT_METHODS,
+  PACKAGE_NAME,
+  PACKAGE_VERSION,
+  SUPPORTED_EXTENSIONS,
+  formatCount,
+  isSupportedFile,
+  parseMethodList,
+  resolveOptionsSync,
+  shouldProcessFile,
+  stripConsoleFromCode
+};
+//# sourceMappingURL=index.js.map