feat: add ban-dependencies rule

Drops the other rules and merges into one jumbo rule:
`ban-dependencies`.

This can be configured with `presets`. For example, `presets:
['native']` would ban dependencies which have equivalent native
alternatives in your node version.

README.md

@@ -41,9 +41,7 @@ export default [
 
 ## Rules
 
-- [`depend/redundant-polyfills`](./docs/rules/redundant-polyfills.md)
-- [`depend/avoid-micro-utilities`](./docs/rules/avoid-micro-utilities.md)
-- [`depend/prefer-light-dependencies`](./docs/rules/prefer-light-dependencies.md)
+- [`depend/ban-dependencies`](./docs/rules/ban-dependencies.md)
 
 ## License
 

docs/rules/ban-dependencies.md

@@ -0,0 +1,76 @@
+# Bans a list of dependencies from being used
+
+This rule bans dependencies based on a preset list or a user defined list.
+
+## Options
+
+### `presets`
+
+You may choose a preset list of dependencies (or none). The following are
+available:
+
+- `microutilities` - micro utilities (e.g. one liners)
+- `native` - redundant packages with native equivalents
+  - Note that this preset will take into account `engines` in your
+`package.json` if it is set. In that only native functionality available in your
+defined `engines.node` version range will be considered (or all if it isn't
+set)
+- `preferred` - an opinionated list of packages with better maintained and
+lighter alternatives
+  - Note the list for this is sourced from
+[`module-replacements`](https://github.com/es-tooling/module-replacements)
+
+Example config:
+
+```json
+{
+  "rules": {
+    "depend/ban-dependencies": ["error", {
+      "presets": ["native"]
+    }
+  }
+}
+```
+
+The **default** is `['native', 'microutilities', 'preferred']`.
+
+### `modules`
+
+You may also specify your own list of packages which will be disallowed
+in code.
+
+For example:
+
+```json
+{
+  "rules": {
+    "depend/ban-dependencies": ["error", {
+      "modules": ["im-a-banned-package"]
+    }
+  }
+}
+```
+
+## Rule Details
+
+This rule bans certain dependencies from being used.
+
+The following patterns are considered warnings:
+
+```ts
+// with `presets: ['native']`
+const isNaN = require('is-nan');
+isNaN(v);
+```
+
+The following patterns are not warnings:
+
+```ts
+// with `presets: ['native']`
+Number.isNaN(v);
+```
+
+## When Not To Use It
+
+If you prefer not to restrict which dependencies are used, this rule should
+be disabled.

src/main.ts

@@ -1,14 +1,10 @@
 import {recommended} from './configs/recommended.js';
-import {rule as redundantPolyfills} from './rules/redundant-polyfills.js';
-import {rule as avoidMicroUtils} from './rules/avoid-micro-utilities.js';
-import {rule as preferLightDependencies} from './rules/prefer-light-dependencies.js';
+import {rule as banDependencies} from './rules/ban-dependencies.js';
 
 export const configs = {
   recommended
 };
 
 export const rules = {
-  'redundant-polyfills': redundantPolyfills,
-  'avoid-micro-utilities': avoidMicroUtils,
-  'prefer-light-dependencies': preferLightDependencies
+  'ban-dependencies': banDependencies
 };

src/replacements.ts

@@ -20,12 +20,17 @@ export interface DocumentedReplacement extends ReplacementLike {
   moduleName: string;
 }
 
+export interface NoReplacement extends ReplacementLike {
+  type: 'none';
+}
+
 export type Replacement =
   | NativeReplacement
   | DocumentedReplacement
-  | SimpleReplacement;
+  | SimpleReplacement
+  | NoReplacement;
 
-export const lighterReplacements: Replacement[] = [
+export const preferredReplacements: Replacement[] = [
   {
     type: 'documented',
     moduleName: 'npm-run-all',

src/rules/ban-dependencies.ts

@@ -0,0 +1,93 @@
+import {Rule} from 'eslint';
+import {getDocsUrl} from '../util/rule-meta.js';
+import {
+  microUtilities,
+  preferredReplacements,
+  nativeReplacements,
+  Replacement
+} from '../replacements.js';
+import {createReplacementListener} from '../util/imports.js';
+
+interface BanDependenciesOptions {
+  presets?: string[];
+  modules?: string[];
+}
+
+const availablePresets: Record<string, Replacement[]> = {
+  microutilities: microUtilities,
+  native: nativeReplacements,
+  preferred: preferredReplacements
+};
+
+const defaultPresets = ['microutilities', 'native', 'preferred'];
+
+export const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Bans a list of dependencies from being used',
+      url: getDocsUrl('ban-dependencies')
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          presets: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          },
+          modules: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      nativeReplacement:
+        '"{{name}}" should be replaced with native functionality. ' +
+        'You can instead use {{replacement}}. Read more here: {{url}}',
+      documentedReplacement:
+        '"{{name}}" should be replaced with an alternative package. ' +
+        'Read more here: {{url}}',
+      simpleReplacement:
+        '"{{name}}" should be replaced with inline/local logic.' +
+        '{{replacement}}',
+      noneReplacement:
+        '"{{name}}" is a banned dependency. An alternative should be used.'
+    }
+  },
+  create: (context) => {
+    const options = context.options[0] as BanDependenciesOptions | undefined;
+    const replacements: Replacement[] = [];
+    const presets = options?.presets ?? defaultPresets;
+    const modules = options?.modules;
+
+    for (const preset of presets) {
+      const presetReplacements = availablePresets[preset];
+      if (presetReplacements) {
+        for (const rep of presetReplacements) {
+          replacements.push(rep);
+        }
+      }
+    }
+
+    if (modules) {
+      for (const mod of modules) {
+        replacements.push({
+          type: 'none',
+          moduleName: mod
+        });
+      }
+    }
+
+    return {
+      ...createReplacementListener(context, replacements)
+    };
+  }
+};