tessl/npm-eslint-plugin-import

ESLint plugin that enforces ES2015+ import/export syntax rules and prevents common issues with module imports.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Module Systems Rules

Name: tessl/npm-eslint-plugin-import
Author: tessl

Rules that enforce ES modules vs CommonJS/AMD usage, helping maintain consistent module system usage across your codebase.

Capabilities

no-amd

Forbids AMD require and define calls.

/**
 * Forbid AMD require and define calls
 * @type {Rule.RuleModule}
 */
"import/no-amd": {
  meta: {
    type: "suggestion",
    docs: {
      category: "Module systems",
      description: "Forbid AMD `require` and `define` calls.",
      url: "https://github.com/import-js/eslint-plugin-import/blob/v2.32.0/docs/rules/no-amd.md"
    },
    schema: []
  },
  create: (context) => Rule.RuleListener
}

Usage Examples:

// ❌ Invalid - AMD require calls
require(["jquery", "lodash"], function($, _) {
  // Error: AMD require calls are not allowed
});

// ❌ Invalid - AMD define calls  
define(["jquery"], function($) {
  // Error: AMD define calls are not allowed
  return { /* ... */ };
});

// ✅ Valid - ES6 imports
import $ from "jquery";
import _ from "lodash";

// ✅ Valid - CommonJS (if allowed by other rules)
const $ = require("jquery");

no-commonjs

Forbids CommonJS require calls and module.exports or exports.*.

/**
 * Forbid CommonJS require calls and module.exports or exports.*
 * @type {Rule.RuleModule}
 */
"import/no-commonjs": {
  meta: {
    type: "suggestion",
    docs: {
      category: "Module systems",
      description: "Forbid CommonJS `require` calls and `module.exports` or `exports.*`.",
      url: "https://github.com/import-js/eslint-plugin-import/blob/v2.32.0/docs/rules/no-commonjs.md"
    },
    schema: [{
      type: "object",
      properties: {
        allowRequire: { type: "boolean", default: false },
        allowConditionalRequire: { type: "boolean", default: true },
        allowPrimitiveModules: { type: "boolean", default: false }
      },
      additionalProperties: false
    }]
  },
  create: (context) => Rule.RuleListener
}

Usage Examples:

// ❌ Invalid - CommonJS require
const fs = require("fs"); // Error: CommonJS require not allowed

// ❌ Invalid - CommonJS exports
module.exports = { foo: "bar" }; // Error: CommonJS exports not allowed
exports.foo = "bar"; // Error: CommonJS exports not allowed

// ✅ Valid - ES6 imports/exports
import fs from "fs";
export const foo = "bar";
export default { foo: "bar" };

// ✅ Valid - conditional require (with allowConditionalRequire: true)
if (typeof window === "undefined") {
  const fs = require("fs"); // OK in conditional context
}

no-import-module-exports

Forbids import statements with CommonJS module.exports.

/**
 * Forbid import statements with CommonJS module.exports
 * @type {Rule.RuleModule}
 */
"import/no-import-module-exports": {
  meta: {
    type: "problem",
    docs: {
      category: "Module systems",
      description: "Forbid import statements with CommonJS module.exports.",
      url: "https://github.com/import-js/eslint-plugin-import/blob/v2.32.0/docs/rules/no-import-module-exports.md"
    },
    schema: [{
      type: "object",
      properties: {
        exceptions: {
          type: "array",
          items: { type: "string" }
        }
      },
      additionalProperties: false
    }],
    fixable: "code"
  },
  create: (context) => Rule.RuleListener
}

Usage Examples:

// ❌ Invalid - mixing import with module.exports
import { foo } from "./foo";
module.exports = { bar }; // Error: Cannot use import with module.exports

// ❌ Invalid - mixing import with exports
import { foo } from "./foo";
exports.bar = bar; // Error: Cannot use import with exports

// ✅ Valid - ES6 only
import { foo } from "./foo";
export { bar };

// ✅ Valid - CommonJS only
const { foo } = require("./foo");
module.exports = { bar };

no-nodejs-modules

Forbids Node.js builtin modules.

/**
 * Forbid Node.js builtin modules
 * @type {Rule.RuleModule}
 */
"import/no-nodejs-modules": {
  meta: {
    type: "suggestion",
    docs: {
      category: "Module systems",
      description: "Forbid Node.js builtin modules.",
      url: "https://github.com/import-js/eslint-plugin-import/blob/v2.32.0/docs/rules/no-nodejs-modules.md"
    },
    schema: [{
      type: "object",
      properties: {
        allow: {
          type: "array",
          items: { type: "string" }
        }
      },
      additionalProperties: false
    }]
  },
  create: (context) => Rule.RuleListener
}

Usage Examples:

// ❌ Invalid - Node.js builtin modules
import fs from "fs"; // Error: Node.js builtin modules not allowed
import path from "path"; // Error: Node.js builtin modules not allowed
import crypto from "crypto"; // Error: Node.js builtin modules not allowed

// ❌ Invalid - Node.js builtin with node: protocol
import fs from "node:fs"; // Error: Node.js builtin modules not allowed

// ✅ Valid - external packages
import lodash from "lodash";
import express from "express";

// ✅ Valid - allowed builtins (with allow: ["util"])
import util from "util"; // OK if util is in allow list

unambiguous

Forbids potentially ambiguous parse goal (script vs. module).

/**
 * Forbid potentially ambiguous parse goal (script vs. module)
 * @type {Rule.RuleModule}
 */
"import/unambiguous": {
  meta: {
    type: "suggestion",
    docs: {
      category: "Module systems",
      description: "Forbid potentially ambiguous parse goal (`script` vs. `module`).",
      url: "https://github.com/import-js/eslint-plugin-import/blob/v2.32.0/docs/rules/unambiguous.md"
    },
    schema: []
  },
  create: (context) => Rule.RuleListener
}

Usage Examples:

// ❌ Invalid - ambiguous module (no imports/exports)
const foo = "bar";
console.log(foo);
// Error: This file could be parsed as script or module

// ✅ Valid - clear module with import
import { utils } from "./utils";
const foo = "bar";

// ✅ Valid - clear module with export
const foo = "bar";
export { foo };

// ✅ Valid - clear module with import and export
import { utils } from "./utils";
export const foo = "bar";

Rule Configuration

Module systems rules can be configured in your ESLint configuration:

// ESLint flat config
export default [{
  plugins: { import: importPlugin },
  rules: {
    "import/no-amd": "error",
    "import/no-commonjs": ["error", {
      "allowRequire": false,
      "allowConditionalRequire": true,
      "allowPrimitiveModules": false
    }],
    "import/no-import-module-exports": ["error", {
      "exceptions": ["./special-case.js"]
    }],
    "import/no-nodejs-modules": ["error", {
      "allow": ["util", "path"]
    }],
    "import/unambiguous": "error"
  }
}];

// Legacy ESLint config
module.exports = {
  plugins: ["import"],
  rules: {
    "import/no-amd": "error",
    "import/no-commonjs": "error",
    "import/no-import-module-exports": "error", 
    "import/no-nodejs-modules": "error",
    "import/unambiguous": "error"
  }
};

Common Configuration Patterns

Browser-only Projects

export default [{
  plugins: { import: importPlugin },
  rules: {
    "import/no-nodejs-modules": "error", // Forbid Node.js modules
    "import/no-commonjs": "error",       // Force ES modules
    "import/no-amd": "error",           // Forbid AMD
    "import/unambiguous": "error"        // Require clear module syntax
  }
}];

Node.js Projects

export default [{
  plugins: { import: importPlugin },
  rules: {
    "import/no-amd": "error",                    // Forbid AMD
    "import/no-import-module-exports": "error",  // Prevent mixing imports/CommonJS
    "import/unambiguous": "error"                // Require clear module syntax
    // Allow Node.js modules and CommonJS
  }
}];

Strict ES Modules Only

export default [{
  plugins: { import: importPlugin },
  rules: {
    "import/no-amd": "error",
    "import/no-commonjs": "error",
    "import/no-import-module-exports": "error",
    "import/unambiguous": "error"
  }
}];