eslint-plugin-no-server-imports 1.0.0

package/dist/index.js

@@ -0,0 +1,931 @@
+"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 index_exports = {};
+__export(index_exports, {
+  FRAMEWORK_DEFAULTS: () => FRAMEWORK_DEFAULTS,
+  clearFrameworkCache: () => clearFrameworkCache,
+  default: () => index_default,
+  detectFramework: () => detectFramework,
+  getFrameworkDefaults: () => getFrameworkDefaults,
+  rule: () => rule
+});
+module.exports = __toCommonJS(index_exports);
+var import_utils = require("@typescript-eslint/utils");
+var import_picomatch = __toESM(require("picomatch"));
+
+// src/framework-detection.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var FRAMEWORK_DEFAULTS = {
+  next: {
+    clientFilePatterns: [
+      "**/app/**",
+      "**/src/app/**",
+      "**/pages/**",
+      "**/components/**"
+    ],
+    serverFilePatterns: [
+      "**/*.server.ts",
+      "**/*.server.tsx",
+      "**/api/**",
+      "**/server/**",
+      "**/actions/**"
+    ]
+  },
+  astro: {
+    clientFilePatterns: [
+      "**/src/pages/**",
+      "**/src/components/**",
+      "**/src/islands/**"
+    ],
+    serverFilePatterns: [
+      "**/*.server.ts",
+      "**/*.server.tsx",
+      "**/server/**",
+      "**/api/**/*.ts"
+    ]
+  },
+  sveltekit: {
+    clientFilePatterns: [
+      "**/src/routes/**",
+      "**/src/lib/components/**"
+    ],
+    serverFilePatterns: [
+      "**/*.server.ts",
+      "**/*.server.js",
+      "**/+server.ts",
+      "**/+server.js",
+      "**/+page.server.ts",
+      "**/+layout.server.ts"
+    ]
+  },
+  unknown: {
+    clientFilePatterns: [
+      "**/routes/**",
+      "**/pages/**",
+      "**/components/**",
+      "**/islands/**",
+      "**/src/app/**"
+    ],
+    serverFilePatterns: [
+      "**/*.server.ts",
+      "**/*.server.tsx",
+      "**/*.server.js",
+      "**/server/**",
+      "**/api/**",
+      "**/_server/**"
+    ]
+  }
+};
+function findProjectRoot(startDir) {
+  let current = startDir;
+  while (current !== import_node_path.default.dirname(current)) {
+    if ((0, import_node_fs.existsSync)(import_node_path.default.join(current, "package.json"))) {
+      return current;
+    }
+    current = import_node_path.default.dirname(current);
+  }
+  return null;
+}
+function configExists(dir, baseName) {
+  const extensions = [".js", ".mjs", ".cjs", ".ts", ".mts"];
+  return extensions.some((ext) => (0, import_node_fs.existsSync)(import_node_path.default.join(dir, `${baseName}${ext}`)));
+}
+function checkPackageJsonDependencies(projectRoot) {
+  const packageJsonPath = import_node_path.default.join(projectRoot, "package.json");
+  if (!(0, import_node_fs.existsSync)(packageJsonPath)) {
+    return "unknown";
+  }
+  try {
+    const content = (0, import_node_fs.readFileSync)(packageJsonPath, "utf8");
+    const pkg = JSON.parse(content);
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    if (allDeps["next"]) {
+      return "next";
+    }
+    if (allDeps["@sveltejs/kit"]) {
+      return "sveltekit";
+    }
+    if (allDeps["astro"]) {
+      return "astro";
+    }
+  } catch {
+  }
+  return "unknown";
+}
+function checkConfigFiles(projectRoot) {
+  if (configExists(projectRoot, "next.config")) {
+    return "next";
+  }
+  if (configExists(projectRoot, "svelte.config")) {
+    return "sveltekit";
+  }
+  if (configExists(projectRoot, "astro.config")) {
+    return "astro";
+  }
+  return "unknown";
+}
+var cachedFramework = null;
+var cachedProjectRoot = null;
+function isDirectory(filePath) {
+  try {
+    return (0, import_node_fs.existsSync)(filePath) && (0, import_node_fs.statSync)(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function detectFramework(filePath) {
+  let startDir;
+  if (!filePath) {
+    startDir = process.cwd();
+  } else if (isDirectory(filePath)) {
+    startDir = filePath;
+  } else {
+    startDir = import_node_path.default.dirname(filePath);
+  }
+  const projectRoot = findProjectRoot(startDir) || process.cwd();
+  if (cachedProjectRoot === projectRoot && cachedFramework !== null) {
+    return cachedFramework;
+  }
+  let framework = checkConfigFiles(projectRoot);
+  if (framework === "unknown") {
+    framework = checkPackageJsonDependencies(projectRoot);
+  }
+  cachedProjectRoot = projectRoot;
+  cachedFramework = framework;
+  return framework;
+}
+function getFrameworkDefaults(filePath) {
+  const framework = detectFramework(filePath);
+  return FRAMEWORK_DEFAULTS[framework];
+}
+function clearFrameworkCache() {
+  cachedFramework = null;
+  cachedProjectRoot = null;
+}
+
+// src/index.ts
+var DEFAULT_SERVER_MODULES = [
+  // Logging
+  "pino",
+  "pino-pretty",
+  "pino-roll",
+  "winston",
+  "bunyan",
+  // Database
+  "better-sqlite3",
+  "pg",
+  "mysql2",
+  "mongodb",
+  "mongoose",
+  "prisma",
+  "@prisma/client",
+  "drizzle-orm",
+  "kysely",
+  "@libsql/client",
+  "libsql",
+  "@mikro-orm/core",
+  "@mikro-orm/knex",
+  "sqlite3",
+  // Authentication & Security
+  "argon2",
+  "@node-rs/argon2",
+  "bcrypt",
+  "@node-rs/bcrypt",
+  "oslo",
+  // AWS SDK
+  "@aws-sdk/client-s3",
+  "@aws-sdk/s3-presigned-post",
+  "aws-crt",
+  // Monitoring & Observability
+  "@appsignal/nodejs",
+  "@highlight-run/node",
+  "@sentry/profiling-node",
+  "dd-trace",
+  "newrelic",
+  "@statsig/statsig-node-core",
+  // AI & ML
+  "@huggingface/transformers",
+  "@xenova/transformers",
+  "chromadb-default-embed",
+  "onnxruntime-node",
+  // Blockchain
+  "@blockfrost/blockfrost-js",
+  "@jpg-store/lucid-cardano",
+  // Build Tools & Compilers
+  "@swc/core",
+  "autoprefixer",
+  "postcss",
+  "prettier",
+  "typescript",
+  "ts-node",
+  "ts-morph",
+  "webpack",
+  "eslint",
+  // Testing
+  "cypress",
+  "jest",
+  "playwright",
+  "playwright-core",
+  "puppeteer",
+  "puppeteer-core",
+  // Browser Automation
+  "@sparticuz/chromium",
+  "@sparticuz/chromium-min",
+  // Content & Document Generation
+  "@react-pdf/renderer",
+  "mdx-bundler",
+  "next-mdx-remote",
+  "next-seo",
+  "shiki",
+  "vscode-oniguruma",
+  // Image Processing
+  "canvas",
+  "sharp",
+  // Utilities
+  "config",
+  "keyv",
+  "node-cron",
+  "rimraf",
+  "thread-stream",
+  // Runtime & Framework
+  "@alinea/generated",
+  "@zenstackhq/runtime",
+  "express",
+  "firebase-admin",
+  "htmlrewriter",
+  // Native Node.js addons
+  "cpu-features",
+  "isolated-vm",
+  "node-pty",
+  "node-web-audio-api",
+  "websocket",
+  "zeromq",
+  // Module System Patchers
+  "import-in-the-middle",
+  "require-in-the-middle",
+  // DOM & Browser APIs
+  "jsdom",
+  // Database (additional)
+  "ravendb",
+  // Node.js built-ins
+  "fs",
+  "node:fs",
+  "fs/promises",
+  "node:fs/promises",
+  "path",
+  "node:path",
+  "crypto",
+  "node:crypto",
+  "child_process",
+  "node:child_process",
+  "os",
+  "node:os",
+  "net",
+  "node:net",
+  "dns",
+  "node:dns",
+  "cluster",
+  "node:cluster",
+  "worker_threads",
+  "node:worker_threads"
+];
+var DEFAULT_SERVER_FILE_PATTERNS = [
+  "**/*.server.ts",
+  "**/*.server.tsx",
+  "**/*.server.js",
+  "**/server/**",
+  "**/api/**",
+  "**/_server/**"
+];
+var DEFAULT_CLIENT_FILE_PATTERNS = [
+  "**/routes/**",
+  "**/pages/**",
+  "**/components/**",
+  "**/islands/**",
+  "**/src/app/**"
+  // Next.js app directory (in src)
+  // Note: For Next.js root-level app/, users should configure clientFilePatterns
+  // We can't use '**/app/**' as it's too broad and matches paths like '/myapp/src/...'
+];
+var createRule = import_utils.ESLintUtils.RuleCreator(
+  () => "https://github.com/jagreehal/eslint-plugin-no-server-imports#readme"
+);
+function hasValueImportSpecifiers(node) {
+  if (node.importKind === "type") {
+    return false;
+  }
+  if (node.specifiers.length === 0) {
+    return true;
+  }
+  return node.specifiers.some((specifier) => {
+    if (specifier.type === import_utils.AST_NODE_TYPES.ImportDefaultSpecifier) {
+      return true;
+    }
+    if (specifier.type === import_utils.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+      return true;
+    }
+    if (specifier.type === import_utils.AST_NODE_TYPES.ImportSpecifier) {
+      return specifier.importKind !== "type";
+    }
+    return true;
+  });
+}
+function hasValueExportSpecifiers(node) {
+  if (node.exportKind === "type") {
+    return false;
+  }
+  if (node.specifiers.length === 0) {
+    return true;
+  }
+  return node.specifiers.some((specifier) => {
+    return specifier.exportKind !== "type";
+  });
+}
+function getValueImportNames(node) {
+  if (node.importKind === "type") {
+    return [];
+  }
+  const names = [];
+  for (const specifier of node.specifiers) {
+    switch (specifier.type) {
+      case import_utils.AST_NODE_TYPES.ImportDefaultSpecifier:
+      case import_utils.AST_NODE_TYPES.ImportNamespaceSpecifier: {
+        names.push(specifier.local.name);
+        break;
+      }
+      case import_utils.AST_NODE_TYPES.ImportSpecifier: {
+        if (specifier.importKind !== "type") {
+          names.push(specifier.local.name);
+        }
+        break;
+      }
+    }
+  }
+  return names;
+}
+function isNodeInsideScope(node, scopeNode) {
+  let current = node;
+  while (current) {
+    if (current === scopeNode) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function isDirectivePrologue(node) {
+  return node.type === import_utils.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils.AST_NODE_TYPES.Literal && typeof node.expression.value === "string";
+}
+function hasUseClientDirective(sourceCode) {
+  const ast = sourceCode.ast;
+  if (!ast.body || ast.body.length === 0) return false;
+  for (const node of ast.body) {
+    if (!isDirectivePrologue(node)) break;
+    const expr = node.expression;
+    if (expr.value === "use client") return true;
+  }
+  return false;
+}
+function findServerOnlyMarkerInsertNode(sourceCode) {
+  const ast = sourceCode.ast;
+  if (!ast.body || ast.body.length === 0) {
+    return null;
+  }
+  let insertIndex = 0;
+  for (const node of ast.body) {
+    if (isDirectivePrologue(node)) {
+      insertIndex++;
+    } else {
+      break;
+    }
+  }
+  if (insertIndex >= ast.body.length) {
+    return null;
+  }
+  return ast.body[insertIndex];
+}
+function createServerOnlyMarkerSuggestion(sourceCode) {
+  if (hasUseClientDirective(sourceCode)) {
+    return [];
+  }
+  const text = sourceCode.getText();
+  const hasMarker = /^import\s+['"]server-only['"]/m.test(text);
+  return [
+    {
+      messageId: "suggestServerOnlyMarker",
+      data: {},
+      fix: (fixer) => {
+        if (hasMarker) {
+          return fixer.insertTextBeforeRange([0, 0], "");
+        }
+        const insertNode = findServerOnlyMarkerInsertNode(sourceCode);
+        if (insertNode) {
+          return fixer.insertTextBefore(insertNode, "import 'server-only';\n");
+        }
+        return fixer.insertTextBeforeRange([0, 0], "import 'server-only';\n");
+      }
+    }
+  ];
+}
+function createImportSuggestions(sourceCode) {
+  return createServerOnlyMarkerSuggestion(sourceCode);
+}
+function createSideEffectImportSuggestions(_moduleName, sourceCode) {
+  return createServerOnlyMarkerSuggestion(sourceCode);
+}
+function createRequireSuggestions(sourceCode) {
+  return createServerOnlyMarkerSuggestion(sourceCode);
+}
+function createReexportSuggestions(sourceCode) {
+  return createServerOnlyMarkerSuggestion(sourceCode);
+}
+var rule = createRule({
+  name: "no-server-imports",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prevent server-only module imports in client code"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          serverModules: {
+            type: "array",
+            items: { type: "string" },
+            description: "Additional server-only modules to check"
+          },
+          serverFilePatterns: {
+            type: "array",
+            items: { type: "string" },
+            description: "Additional server-only file patterns"
+          },
+          clientFilePatterns: {
+            type: "array",
+            items: { type: "string" },
+            description: "File patterns that indicate client code"
+          },
+          ignoreFiles: {
+            type: "array",
+            items: { type: "string" },
+            description: "File patterns to ignore"
+          },
+          checkServerOnlyMarker: {
+            type: "boolean",
+            description: "Check for 'server-only' import marker"
+          },
+          checkServerFunctions: {
+            type: "boolean",
+            description: "Check for server function usage"
+          },
+          serverFunctionNames: {
+            type: "array",
+            items: { type: "string" },
+            description: "Server function names to check for"
+          },
+          reportUnusedImports: {
+            type: "boolean",
+            description: "Whether to report unused server-only imports (default: true)"
+          },
+          mode: {
+            type: "string",
+            enum: ["client-only", "all-non-server"],
+            description: "File selection mode"
+          },
+          serverExternalPackages: {
+            type: "array",
+            items: { type: "string" },
+            description: "Next.js serverExternalPackages to treat as server-only"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    hasSuggestions: true,
+    messages: {
+      serverOnlyImport: 'Server-only module "{{module}}" imported in client code. Use dynamic import in a server function: const mod = await import("{{module}}")',
+      serverOnlyRequire: 'Server-only module "{{module}}" required in client code. Use dynamic import in a server function instead.',
+      suggestServerOnlyMarker: "Add import 'server-only' to mark this file as server-only"
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options = {}]) {
+    const serverModules = [
+      ...DEFAULT_SERVER_MODULES,
+      ...options.serverModules || [],
+      ...options.serverExternalPackages || []
+      // Next.js integration
+    ];
+    const serverFilePatterns = [
+      ...DEFAULT_SERVER_FILE_PATTERNS,
+      ...options.serverFilePatterns || []
+    ];
+    const clientFilePatterns = options.clientFilePatterns || DEFAULT_CLIENT_FILE_PATTERNS;
+    const ignoreFiles = options.ignoreFiles || [];
+    const checkServerOnlyMarker = options.checkServerOnlyMarker ?? true;
+    const checkServerFunctions = options.checkServerFunctions ?? true;
+    const serverFunctionNames = options.serverFunctionNames || [
+      "createServerFn",
+      "createIsomorphicFn",
+      "server$",
+      "action$",
+      "loader$"
+    ];
+    const reportUnusedImports = options.reportUnusedImports ?? true;
+    const mode = options.mode || "client-only";
+    const serverModuleSet = new Set(serverModules);
+    const rawFilename = context.getFilename();
+    const filename = rawFilename.replaceAll("\\", "/");
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    let hasServerOnlyImport = false;
+    const serverOnlyImports = [];
+    const serverFunctionScopes = /* @__PURE__ */ new Set();
+    function shouldIgnoreFile() {
+      if (ignoreFiles.length > 0) {
+        const isMatch = (0, import_picomatch.default)(ignoreFiles);
+        if (isMatch(filename)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function isServerFile() {
+      const isMatch = (0, import_picomatch.default)(serverFilePatterns);
+      return isMatch(filename);
+    }
+    function isClientFile() {
+      const isMatch = (0, import_picomatch.default)(clientFilePatterns);
+      return isMatch(filename);
+    }
+    function isServerOnlyModule(importSource) {
+      if (serverModuleSet.has(importSource)) {
+        return true;
+      }
+      return serverModules.some(
+        (mod) => importSource.startsWith(`${mod}/`)
+      );
+    }
+    function findServerFunctionCall(node) {
+      if (node.callee.type === import_utils.AST_NODE_TYPES.Identifier && serverFunctionNames.includes(node.callee.name)) {
+        return node;
+      }
+      if (node.callee.type === import_utils.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils.AST_NODE_TYPES.CallExpression) {
+        return findServerFunctionCall(node.callee.object);
+      }
+      return null;
+    }
+    function extractCallbacksFromChain(node) {
+      const callbacks = [];
+      let current = node;
+      while (current.type === import_utils.AST_NODE_TYPES.CallExpression) {
+        for (const arg of current.arguments) {
+          if (arg.type === import_utils.AST_NODE_TYPES.ArrowFunctionExpression || arg.type === import_utils.AST_NODE_TYPES.FunctionExpression) {
+            callbacks.push(arg);
+          }
+        }
+        if (current.parent?.type === import_utils.AST_NODE_TYPES.MemberExpression && current.parent.parent?.type === import_utils.AST_NODE_TYPES.CallExpression) {
+          current = current.parent.parent;
+        } else {
+          break;
+        }
+      }
+      return callbacks;
+    }
+    function getRequireSource(node) {
+      if (node.callee.type === import_utils.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments.length > 0) {
+        const arg = node.arguments[0];
+        if (arg.type === import_utils.AST_NODE_TYPES.Literal && typeof arg.value === "string") {
+          return arg.value;
+        }
+      }
+      return null;
+    }
+    if (shouldIgnoreFile()) {
+      return {};
+    }
+    if (isServerFile()) {
+      return {};
+    }
+    if (mode === "client-only" && // Only check files matching clientFilePatterns
+    !isClientFile()) {
+      return {};
+    }
+    const serverOnlyRequires = [];
+    const bareRequireViolations = [];
+    const sideEffectImportViolations = [];
+    const reexportViolations = [];
+    function isInsideServerScope(node) {
+      for (const scope of serverFunctionScopes) {
+        if (isNodeInsideScope(node, scope)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return {
+      // Collect server-only imports and their local names
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        if (checkServerOnlyMarker && source === "server-only") {
+          hasServerOnlyImport = true;
+          return;
+        }
+        if (typeof source !== "string" || !isServerOnlyModule(source)) {
+          return;
+        }
+        if (!hasValueImportSpecifiers(node)) {
+          return;
+        }
+        if (node.specifiers.length === 0) {
+          sideEffectImportViolations.push({ node, module: source });
+          return;
+        }
+        const valueNames = new Set(getValueImportNames(node));
+        const variables = sourceCode.getDeclaredVariables(node).filter((variable) => valueNames.has(variable.name));
+        if (variables.length > 0) {
+          serverOnlyImports.push({
+            module: source,
+            node,
+            variables
+          });
+        }
+      },
+      CallExpression(node) {
+        const requireSource = getRequireSource(node);
+        if (requireSource) {
+          if (checkServerOnlyMarker && requireSource === "server-only") {
+            hasServerOnlyImport = true;
+            return;
+          }
+          if (isServerOnlyModule(requireSource)) {
+            const parent = node.parent;
+            if (parent?.type === import_utils.AST_NODE_TYPES.VariableDeclarator) {
+              const varDecl = parent.parent;
+              if (varDecl?.type === import_utils.AST_NODE_TYPES.VariableDeclaration) {
+                const variables = sourceCode.getDeclaredVariables(varDecl);
+                if (variables.length > 0) {
+                  serverOnlyRequires.push({
+                    module: requireSource,
+                    node,
+                    variables
+                  });
+                  return;
+                }
+              }
+            }
+            bareRequireViolations.push({
+              node: node.arguments[0],
+              module: requireSource
+            });
+          }
+          return;
+        }
+        if (!checkServerFunctions) {
+          return;
+        }
+        const serverFnCall = findServerFunctionCall(node);
+        if (serverFnCall) {
+          const callbacks = extractCallbacksFromChain(node);
+          for (const callback of callbacks) {
+            serverFunctionScopes.add(callback);
+          }
+        }
+      },
+      // Check export declarations - collect for reporting in Program:exit
+      ExportAllDeclaration(node) {
+        const source = node.source.value;
+        if (node.exportKind === "type") {
+          return;
+        }
+        if (typeof source === "string" && isServerOnlyModule(source)) {
+          reexportViolations.push({ node: node.source, module: source });
+        }
+      },
+      ExportNamedDeclaration(node) {
+        if (!node.source) return;
+        const source = node.source.value;
+        if (typeof source !== "string" || !isServerOnlyModule(source)) {
+          return;
+        }
+        if (!hasValueExportSpecifiers(node)) {
+          return;
+        }
+        reexportViolations.push({ node: node.source, module: source });
+      },
+      // Final analysis at end of file
+      "Program:exit"() {
+        if (hasServerOnlyImport) {
+          return;
+        }
+        for (const { node, module: module2 } of sideEffectImportViolations) {
+          context.report({
+            node,
+            messageId: "serverOnlyImport",
+            data: { module: module2 },
+            suggest: createSideEffectImportSuggestions(module2, sourceCode)
+          });
+        }
+        for (const { node, module: module2 } of reexportViolations) {
+          context.report({
+            node,
+            messageId: "serverOnlyImport",
+            data: { module: module2 },
+            suggest: createReexportSuggestions(sourceCode)
+          });
+        }
+        for (const violation of bareRequireViolations) {
+          if (!isInsideServerScope(violation.node)) {
+            context.report({
+              node: violation.node,
+              messageId: "serverOnlyRequire",
+              data: { module: violation.module },
+              suggest: createRequireSuggestions(sourceCode)
+            });
+          }
+        }
+        for (const { module: module2, node, variables } of serverOnlyRequires) {
+          if (isInsideServerScope(node)) {
+            continue;
+          }
+          let hasViolation = false;
+          for (const variable of variables) {
+            const valueReferences = variable.references.filter(
+              (reference) => reference.isRead()
+            );
+            if (valueReferences.length === 0) {
+              if (reportUnusedImports) {
+                hasViolation = true;
+                break;
+              }
+              continue;
+            }
+            const hasClientUsage = valueReferences.some((reference) => {
+              return !isInsideServerScope(reference.identifier);
+            });
+            if (hasClientUsage) {
+              hasViolation = true;
+              break;
+            }
+          }
+          if (hasViolation) {
+            context.report({
+              node: node.arguments[0],
+              messageId: "serverOnlyRequire",
+              data: { module: module2 },
+              suggest: createRequireSuggestions(sourceCode)
+            });
+          }
+        }
+        for (const { module: module2, node, variables } of serverOnlyImports) {
+          let hasViolation = false;
+          for (const variable of variables) {
+            const valueReferences = variable.references.filter(
+              (reference) => reference.isRead()
+            );
+            if (valueReferences.length === 0) {
+              if (reportUnusedImports) {
+                hasViolation = true;
+                break;
+              }
+              continue;
+            }
+            const hasClientUsage = valueReferences.some((reference) => {
+              return !isInsideServerScope(reference.identifier);
+            });
+            if (hasClientUsage) {
+              hasViolation = true;
+              break;
+            }
+          }
+          if (hasViolation) {
+            context.report({
+              node: node.source,
+              messageId: "serverOnlyImport",
+              data: { module: module2 },
+              suggest: createImportSuggestions(sourceCode)
+            });
+          }
+        }
+      }
+    };
+  }
+});
+var plugin = {
+  rules: {
+    "no-server-imports": rule
+  },
+  configs: {
+    /**
+     * Recommended config - uses sensible defaults that work across frameworks.
+     * For framework-specific optimizations, use one of the framework presets.
+     */
+    recommended: {
+      plugins: ["no-server-imports"],
+      rules: {
+        "no-server-imports/no-server-imports": "error"
+      }
+    },
+    /**
+     * Next.js optimized configuration.
+     * Best for Next.js App Router and Pages Router projects.
+     */
+    "recommended-next": {
+      plugins: ["no-server-imports"],
+      rules: {
+        "no-server-imports/no-server-imports": [
+          "error",
+          {
+            clientFilePatterns: FRAMEWORK_DEFAULTS.next.clientFilePatterns,
+            serverFilePatterns: FRAMEWORK_DEFAULTS.next.serverFilePatterns
+          }
+        ]
+      }
+    },
+    /**
+     * Astro optimized configuration.
+     * Best for Astro projects with islands architecture.
+     */
+    "recommended-astro": {
+      plugins: ["no-server-imports"],
+      rules: {
+        "no-server-imports/no-server-imports": [
+          "error",
+          {
+            clientFilePatterns: FRAMEWORK_DEFAULTS.astro.clientFilePatterns,
+            serverFilePatterns: FRAMEWORK_DEFAULTS.astro.serverFilePatterns
+          }
+        ]
+      }
+    },
+    /**
+     * SvelteKit optimized configuration.
+     * Best for SvelteKit projects.
+     */
+    "recommended-sveltekit": {
+      plugins: ["no-server-imports"],
+      rules: {
+        "no-server-imports/no-server-imports": [
+          "error",
+          {
+            clientFilePatterns: FRAMEWORK_DEFAULTS.sveltekit.clientFilePatterns,
+            serverFilePatterns: FRAMEWORK_DEFAULTS.sveltekit.serverFilePatterns
+          }
+        ]
+      }
+    }
+  },
+  meta: {
+    name: "eslint-plugin-no-server-imports"
+  }
+};
+var index_default = plugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FRAMEWORK_DEFAULTS,
+  clearFrameworkCache,
+  detectFramework,
+  getFrameworkDefaults,
+  rule
+});
+/**
+ * ESLint Plugin: eslint-plugin-no-server-imports
+ * ===============================================
+ * Prevents server-only module imports in client code.
+ * Catches bundling issues in your editor instead of at build time.
+ *
+ * @author Jag Reehal [@jagreehal] <jag@jagreehal.com>
+ * @license MIT
+ */
+//# sourceMappingURL=index.js.map