eslint-plugin-restrict-replace-import 1.1.0 → 1.2.1

package/README.md

@@ -33,7 +33,7 @@ Then configure the rules you want to use under the rules section.
 ```json
 {
   "rules": {
-    "restrict-import/rule-name": [
+    "restrict-replace-import/restrict-import": [
       "error",
       ["restricted-package1", "restricted-package2"]
     ]
@@ -46,16 +46,35 @@ You can also specify an alternative package to import instead:
 ```json
 {
   "rules": {
-    "restrict-import/rule-name": [
+    "restrict-replace-import/restrict-import": [
       "error",
       [
         {
-          "name": "restricted-package1",
-          "alternative": "replacement-package1"
+          "target": "restricted-package1",
+          "replacement": "replacement-package1"
         },
         {
-          "name": "restricted-package2",
-          "alternative": "replacement-package2"
+          "target": "restricted-package2",
+          "replacement": "replacement-package2"
+        }
+      ]
+    ]
+  }
+}
+```
+
+You can use RegExp for package name:
+
+```json
+{
+  "rules": {
+    "restrict-replace-import/restrict-import": [
+      "error",
+      [
+        "with(?:-regex)?-support",
+        {
+          "target": "restricted-.*",
+          "replacement": "replacement-package"
         }
       ]
     ]

package/docs/rules/restrict-import.md

@@ -23,8 +23,8 @@ Example configuration:
       "error",
       [
         {
-          "name": "test-package",
-          "alternative": "replacement-package"
+          "target": "test-package",
+          "replacement": "replacement-package"
         },
         "another-package"
         "with(?:-regex)?-support"

package/lib/rules/restrict-import.js

@@ -23,43 +23,41 @@ module.exports = {
         "`{{ name }}` is restricted from being used. Replace it with `{{ replacement }}`.",
     },
 
-    schema: [
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          restrictedPackages: {
-            type: "array",
-            items: {
-              anyOf: [
-                {
+    schema: {
+      type: "array",
+      maxLength: 1,
+      minLength: 1,
+      items: {
+        type: "array",
+        items: {
+          oneOf: [
+            {
+              type: "string",
+            },
+            {
+              type: "object",
+              properties: {
+                target: {
                   type: "string",
                 },
-                {
-                  type: "object",
-                  properties: {
-                    target: {
-                      type: "string",
-                    },
-                    replacement: {
-                      type: "string",
-                    },
-                  },
+                replacement: {
+                  type: "string",
                 },
-              ],
+              },
+              required: ["target"],
+              additionalProperties: false,
             },
-          },
+          ],
         },
       },
-    ],
+    },
   },
 
   create(context) {
-    const option = context.options[0];
-
     const restrictedPackages = new Map();
+    const restrictedPackagesOption = context.options[0];
 
-    option.restrictedPackages.forEach((packageName) => {
+    restrictedPackagesOption.forEach((packageName) => {
       if (typeof packageName === "string") {
         restrictedPackages.set(
           new RegExp(`^${packageName}$`),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-restrict-replace-import",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "ESLint Plugin for Restricting and Replacing Import",
   "keywords": [
     "eslint",

package/tests/lib/rules/restrict-import.js

@@ -1,139 +0,0 @@
-/**
- * @fileoverview Prevent the Import of a Specific Package
- * @author shiwoo.park
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const rule = require("../../../lib/rules/restrict-import"),
-  RuleTester = require("eslint").RuleTester;
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 2015,
-    sourceType: "module",
-  },
-});
-
-const OPTIONS = [
-  {
-    restrictedPackages: [
-      "lodash",
-      {
-        target: "react",
-        replacement: "preact",
-      },
-      {
-        target: "any-other-with(?:regex)",
-        replacement: "any-other-replacement",
-      },
-      "other-with(?:regex)",
-      {
-        target: "with(?:-regex)?-support",
-        replacement: "with-support-replacement",
-      },
-    ],
-  },
-];
-
-ruleTester.run("restrict-import", rule, {
-  valid: [
-    {
-      code: "import _ from 'underscore'",
-      options: OPTIONS,
-    },
-    {
-      code: "import _ from 'lodash-es'",
-      options: OPTIONS,
-    },
-    {
-      code: "import { useState } from 'preact'",
-      options: OPTIONS,
-    },
-  ],
-
-  invalid: [
-    {
-      code: "import _ from 'lodash'",
-      errors: [
-        {
-          message:
-            "`lodash` is restricted from being used.",
-          type: "ImportDeclaration",
-        },
-      ],
-      options: OPTIONS,
-      output: null,
-    },
-    {
-      code: "import { useState } from 'react'",
-      errors: [
-        {
-          message:
-            "`react` is restricted from being used. Replace it with `preact`.",
-          type: "ImportDeclaration",
-        },
-      ],
-      options: OPTIONS,
-      output: "import { useState } from 'preact'",
-    },
-    {
-      code: "import { useState } from 'any-other-withregex'",
-      errors: [
-        {
-          message:
-            "`any-other-with(?:regex)` is restricted from being used. Replace it with `any-other-replacement`.",
-          type: "ImportDeclaration",
-        },
-      ],
-      options: OPTIONS,
-      output:
-        "import { useState } from 'any-other-replacement'",
-    },
-    {
-      code: "import { useState } from 'other-withregex'",
-      errors: [
-        {
-          message:
-            "`other-with(?:regex)` is restricted from being used.",
-          type: "ImportDeclaration",
-        },
-      ],
-      options: OPTIONS,
-      output: null,
-    },
-    {
-      code: "import { useState } from 'with-regex-support'",
-      errors: [
-        {
-          message:
-            "`with(?:-regex)?-support` is restricted from being used. Replace it with `with-support-replacement`.",
-          type: "ImportDeclaration",
-        },
-      ],
-      options: OPTIONS,
-      output:
-        "import { useState } from 'with-support-replacement'",
-    },
-    {
-      code: "import { useState } from 'with-support'",
-      errors: [
-        {
-          message:
-            "`with(?:-regex)?-support` is restricted from being used. Replace it with `with-support-replacement`.",
-          type: "ImportDeclaration",
-        },
-      ],
-      options: OPTIONS,
-      output:
-        "import { useState } from 'with-support-replacement'",
-    },
-  ],
-});