@dvukovic/style-guide 0.3.119 → 0.3.120

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dvukovic/style-guide",
-    "version": "0.3.119",
+    "version": "0.3.120",
     "description": "My own style guide",
     "repository": {
         "type": "git",

package/src/eslint/plugins/package-json.js

@@ -24,17 +24,18 @@ export const packageJson = {
         "dvukovic/no-restricted-dependencies": [
             "error",
             {
-                packages: [
+                dependencies: [
                     "@types/*",
                     "cspell",
                     "eslint",
+                    "lambda",
                     "lodash",
-                    "npm-package-json-lint",
                     "prettier",
                     "ramda",
                     "stylelint",
                     "typeorm",
                 ],
+                peerDependencies: ["@types/*"],
             },
         ],
         "dvukovic/require-properties": ["error", { properties: ["volta.node"] }],

package/src/eslint/rules/no-restricted-dependencies/no-restricted-dependencies.js

@@ -1,9 +1,11 @@
-const DEPENDENCY_TYPES = new Set([
+const DEPENDENCY_TYPES = [
     "dependencies",
     "devDependencies",
     "optionalDependencies",
     "peerDependencies",
-])
+]
+
+const DEPENDENCY_TYPES_SET = new Set(DEPENDENCY_TYPES)
 
 /**
  * Checks if a package name matches a restriction pattern. Supports exact matches and glob-like
@@ -28,11 +30,6 @@ function matchesPattern(packageName, pattern) {
 export const noRestrictedDependencies = {
     create(context) {
         const options = context.options[0] || {}
-        const restricted = options.packages || []
-
-        if (restricted.length === 0) {
-            return {}
-        }
 
         return {
             JSONProperty(node) {
@@ -42,7 +39,7 @@ export const noRestrictedDependencies = {
 
                 const propertyName = node.key.value
 
-                if (!DEPENDENCY_TYPES.has(propertyName)) {
+                if (!DEPENDENCY_TYPES_SET.has(propertyName)) {
                     return
                 }
 
@@ -50,6 +47,12 @@ export const noRestrictedDependencies = {
                     return
                 }
 
+                const patterns = options[propertyName] || []
+
+                if (patterns.length === 0) {
+                    return
+                }
+
                 for (const dep of node.value.properties) {
                     if (dep.key.type !== "JSONLiteral" || typeof dep.key.value !== "string") {
                         continue
@@ -57,7 +60,7 @@ export const noRestrictedDependencies = {
 
                     const packageName = dep.key.value
 
-                    for (const pattern of restricted) {
+                    for (const pattern of patterns) {
                         if (matchesPattern(packageName, pattern)) {
                             context.report({
                                 data: {
@@ -86,9 +89,23 @@ export const noRestrictedDependencies = {
             {
                 additionalProperties: false,
                 properties: {
-                    packages: {
-                        description:
-                            "List of restricted package names or patterns (supports * wildcard)",
+                    dependencies: {
+                        description: "Restricted patterns in dependencies",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                    devDependencies: {
+                        description: "Restricted patterns in devDependencies",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                    optionalDependencies: {
+                        description: "Restricted patterns in optionalDependencies",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                    peerDependencies: {
+                        description: "Restricted patterns in peerDependencies",
                         items: { type: "string" },
                         type: "array",
                     },

package/src/eslint/rules/no-restricted-dependencies/no-restricted-dependencies.test.js

@@ -3,7 +3,7 @@ import jsoncParser from "jsonc-eslint-parser"
 
 import { noRestrictedDependencies } from "./no-restricted-dependencies.js"
 
-const createEslint = (packages) => {
+const createEslint = (options) => {
     return new ESLint({
         overrideConfig: [
             {
@@ -19,7 +19,7 @@ const createEslint = (packages) => {
                     },
                 },
                 rules: {
-                    "custom/no-restricted-dependencies": ["error", { packages }],
+                    "custom/no-restricted-dependencies": ["error", options],
                 },
             },
         ],
@@ -27,9 +27,19 @@ const createEslint = (packages) => {
     })
 }
 
+const getErrors = async (eslint, packageJson) => {
+    const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+
+    return (
+        results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/no-restricted-dependencies"
+        }) ?? []
+    )
+}
+
 describe("no-restricted-dependencies", () => {
     test("detects restricted package in dependencies", async () => {
-        const eslint = createEslint(["lodash"])
+        const eslint = createEslint({ dependencies: ["lodash"] })
         const packageJson = JSON.stringify(
             {
                 dependencies: {
@@ -41,17 +51,14 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(1)
-        expect(errors?.[0]?.message).toContain("lodash")
+        expect(errors.length).toBe(1)
+        expect(errors[0]?.message).toContain("lodash")
     })
 
     test("detects restricted package in devDependencies", async () => {
-        const eslint = createEslint(["jest"])
+        const eslint = createEslint({ devDependencies: ["jest"] })
         const packageJson = JSON.stringify(
             {
                 devDependencies: {
@@ -63,16 +70,13 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(1)
+        expect(errors.length).toBe(1)
     })
 
     test("detects pattern with wildcard", async () => {
-        const eslint = createEslint(["@types/*"])
+        const eslint = createEslint({ devDependencies: ["@types/*"] })
         const packageJson = JSON.stringify(
             {
                 devDependencies: {
@@ -85,16 +89,13 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(2)
+        expect(errors.length).toBe(2)
     })
 
     test("allows non-restricted packages", async () => {
-        const eslint = createEslint(["lodash"])
+        const eslint = createEslint({ dependencies: ["lodash"] })
         const packageJson = JSON.stringify(
             {
                 dependencies: {
@@ -106,16 +107,13 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(0)
+        expect(errors.length).toBe(0)
     })
 
     test("detects multiple restricted packages", async () => {
-        const eslint = createEslint(["lodash", "ramda", "underscore"])
+        const eslint = createEslint({ dependencies: ["lodash", "ramda", "underscore"] })
         const packageJson = JSON.stringify(
             {
                 dependencies: {
@@ -129,16 +127,13 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
-        })
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(2)
+        expect(errors.length).toBe(2)
     })
 
-    test("handles empty packages list", async () => {
-        const eslint = createEslint([])
+    test("handles empty options", async () => {
+        const eslint = createEslint({})
         const packageJson = JSON.stringify(
             {
                 dependencies: {
@@ -150,11 +145,93 @@ describe("no-restricted-dependencies", () => {
             4,
         )
 
-        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
-        const errors = results[0]?.messages.filter((message) => {
-            return message.ruleId === "custom/no-restricted-dependencies"
+        const errors = await getErrors(eslint, packageJson)
+
+        expect(errors.length).toBe(0)
+    })
+
+    test("restricts @types/* in dependencies but allows in devDependencies", async () => {
+        const eslint = createEslint({ dependencies: ["@types/*"] })
+        const packageJson = JSON.stringify(
+            {
+                dependencies: {
+                    "@types/node": "^20.0.0",
+                },
+                devDependencies: {
+                    "@types/react": "^18.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const errors = await getErrors(eslint, packageJson)
+
+        expect(errors.length).toBe(1)
+        expect(errors[0]?.message).toContain("@types/node")
+        expect(errors[0]?.message).toContain("dependencies")
+    })
+
+    test("restricts different patterns in different dependency types", async () => {
+        const eslint = createEslint({
+            dependencies: ["@types/*", "lodash"],
+            devDependencies: ["jest"],
         })
+        const packageJson = JSON.stringify(
+            {
+                dependencies: {
+                    "@types/node": "^20.0.0",
+                    lodash: "^4.0.0",
+                },
+                devDependencies: {
+                    "@types/react": "^18.0.0",
+                    jest: "^29.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const errors = await getErrors(eslint, packageJson)
+
+        expect(errors.length).toBe(3)
+    })
+
+    test("restricts in peerDependencies", async () => {
+        const eslint = createEslint({ peerDependencies: ["react"] })
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+                peerDependencies: {
+                    react: "^18.0.0",
+                },
+            },
+            null,
+            4,
+        )
+
+        const errors = await getErrors(eslint, packageJson)
+
+        expect(errors.length).toBe(1)
+    })
+
+    test("restricts in optionalDependencies", async () => {
+        const eslint = createEslint({ optionalDependencies: ["fsevents"] })
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+                optionalDependencies: {
+                    fsevents: "^2.0.0",
+                },
+            },
+            null,
+            4,
+        )
+
+        const errors = await getErrors(eslint, packageJson)
 
-        expect(errors?.length).toBe(0)
+        expect(errors.length).toBe(1)
     })
 })