Module Systems Rules

/**
 * 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
}

// ❌ 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");

/**
 * 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
}

// ❌ 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
}

/**
 * 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
}

// ❌ 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 };

/**
 * 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
}

// ❌ 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

/**
 * 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
}

// ❌ 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";

// 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"
  }
};

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
  }
}];

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
  }
}];

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