@dvukovic/style-guide 0.3.116 → 0.3.117

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dvukovic/style-guide",
-    "version": "0.3.116",
+    "version": "0.3.117",
     "description": "My own style guide",
     "repository": {
         "type": "git",
@@ -30,7 +30,7 @@
     },
     "dependencies": {
         "@eslint-community/eslint-plugin-eslint-comments": "4.5.0",
-        "@eslint/compat": "^2.0.0",
+        "@eslint/compat": "2.0.0",
         "@next/eslint-plugin-next": "16.1.0",
         "@prettier/plugin-xml": "3.4.2",
         "@rimac-technology/eslint-plugin": "1.5.0",
@@ -42,6 +42,7 @@
         "eslint-plugin-jest": "29.4.0",
         "eslint-plugin-mobx": "0.0.13",
         "eslint-plugin-n": "17.23.1",
+        "eslint-plugin-package-json": "0.88.1",
         "eslint-plugin-playwright": "2.4.0",
         "eslint-plugin-promise": "7.2.1",
         "eslint-plugin-react": "7.37.5",
@@ -56,6 +57,7 @@
         "eslint-plugin-unicorn": "62.0.0",
         "eslint-plugin-unused-imports": "4.3.0",
         "globals": "16.5.0",
+        "jsonc-eslint-parser": "2.4.2",
         "prettier-plugin-embed": "0.5.1",
         "prettier-plugin-jsdoc": "1.8.0",
         "prettier-plugin-packagejson": "2.5.20",
@@ -77,19 +79,17 @@
         "cspell": "9.4.0",
         "eslint": "9.39.2",
         "jest": "30.2.0",
-        "npm-package-json-lint": "9.0.0",
         "prettier": "3.7.4",
         "react": "19.2.3",
         "release-it": "19.1.0",
-        "storybook": "^10.1.10",
+        "storybook": "10.1.10",
         "stylelint": "16.26.1",
         "typescript": "5.9.3",
-        "vitest": "^4.0.16"
+        "vitest": "4.0.16"
     },
     "peerDependencies": {
         "cspell": "9",
         "eslint": "^9",
-        "npm-package-json-lint": "9",
         "prettier": "3",
         "stylelint": "16"
     },
@@ -100,9 +100,6 @@
         "eslint": {
             "optional": true
         },
-        "npm-package-json-lint": {
-            "optional": true
-        },
         "prettier": {
             "optional": true
         },
@@ -112,7 +109,7 @@
     },
     "packageManager": "yarn@4.12.0",
     "engines": {
-        "node": ">=20.0.0"
+        "node": ">=24.0.0"
     },
     "publishConfig": {
         "access": "public",

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

@@ -0,0 +1,17 @@
+import { packageJson as packageJsonRules } from "../plugins/package-json.js"
+
+export const packageJsonConfigs = [packageJsonRules]
+
+/**
+ * Package.json ESLint configuration
+ *
+ * @param {import("@eslint/config-helpers").ConfigWithExtends} [config]
+ * @returns {import("@eslint/config-helpers").ConfigWithExtends}
+ */
+export function packageJson(config) {
+    return {
+        extends: [...packageJsonConfigs, ...(config?.extends ?? [])],
+        files: ["**/package.json"],
+        ...config,
+    }
+}

package/src/eslint/configs/package-json.test.js

@@ -0,0 +1,50 @@
+import { ESLint } from "eslint"
+
+import { packageJsonConfigs } from "./package-json.js"
+
+const eslint = new ESLint({
+    overrideConfig: [...packageJsonConfigs, { files: ["**/package.json"] }],
+    overrideConfigFile: true,
+})
+
+describe("package-json", () => {
+    test("loads without errors", async () => {
+        const validPackageJson = JSON.stringify(
+            {
+                author: "Test Author",
+                description: "A test package",
+                engines: {
+                    node: ">=20.0.0",
+                },
+                license: "MIT",
+                name: "test-package",
+                repository: {
+                    type: "git",
+                    url: "https://github.com/test/test",
+                },
+                version: "1.0.0",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(validPackageJson, { filePath: "package.json" })
+
+        expect(results).toBeDefined()
+        expect(results[0]?.fatalErrorCount).toBe(0)
+    })
+
+    test("detects missing required fields", async () => {
+        const invalidPackageJson = JSON.stringify(
+            {
+                name: "test-package",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(invalidPackageJson, { filePath: "package.json" })
+
+        expect(results[0]?.errorCount).toBeGreaterThan(0)
+    })
+})

package/src/eslint/index.js

@@ -30,6 +30,7 @@ export * from "./configs/jest.js"
 export * from "./configs/mobx.js"
 export * from "./configs/next.js"
 export * from "./configs/node.js"
+export * from "./configs/package-json.js"
 export * from "./configs/playwright.js"
 export * from "./configs/react.js"
 export * from "./configs/typescript.js"

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

@@ -0,0 +1,97 @@
+import plugin from "eslint-plugin-package-json"
+import jsoncParser from "jsonc-eslint-parser"
+
+import { noRestrictedDependencies } from "../rules/no-restricted-dependencies/no-restricted-dependencies.js"
+import { validEnginesNode } from "../rules/valid-engines-node/valid-engines-node.js"
+
+/** @type {import("@eslint/config-helpers").Config} */
+export const packageJson = {
+    languageOptions: {
+        parser: jsoncParser,
+    },
+    plugins: {
+        dvukovic: {
+            rules: {
+                "no-restricted-dependencies": noRestrictedDependencies,
+                "valid-engines-node": validEnginesNode,
+            },
+        },
+        "package-json": plugin,
+    },
+    rules: {
+        "dvukovic/no-restricted-dependencies": [
+            "error",
+            {
+                packages: [
+                    "@types/*",
+                    "cspell",
+                    "eslint",
+                    "lodash",
+                    "npm-package-json-lint",
+                    "prettier",
+                    "ramda",
+                    "stylelint",
+                    "typeorm",
+                ],
+            },
+        ],
+        "dvukovic/valid-engines-node": ["error", { versions: ["24"] }],
+        "package-json/bin-name-casing": "error",
+        "package-json/no-empty-fields": "error",
+        "package-json/no-redundant-files": "error",
+        "package-json/no-redundant-publishConfig": "error",
+        "package-json/order-properties": "error",
+        "package-json/repository-shorthand": "error",
+        "package-json/require-author": "error",
+        "package-json/require-description": "error",
+        "package-json/require-engines": "error",
+        "package-json/require-license": "error",
+        "package-json/require-name": "error",
+        "package-json/require-repository": "error",
+        "package-json/require-version": "error",
+        "package-json/restrict-dependency-ranges": [
+            "error",
+            {
+                forDependencyTypes: ["dependencies", "devDependencies", "optionalDependencies"],
+                rangeType: "pin",
+            },
+        ],
+        "package-json/scripts-name-casing": "error",
+        "package-json/sort-collections": "error",
+        "package-json/specify-peers-locally": "error",
+        "package-json/unique-dependencies": "error",
+        "package-json/valid-author": "error",
+        "package-json/valid-bin": "error",
+        "package-json/valid-bundleDependencies": "error",
+        "package-json/valid-config": "error",
+        "package-json/valid-contributors": "error",
+        "package-json/valid-cpu": "error",
+        "package-json/valid-dependencies": "error",
+        "package-json/valid-description": "error",
+        "package-json/valid-devDependencies": "error",
+        "package-json/valid-directories": "error",
+        "package-json/valid-engines": "error",
+        "package-json/valid-exports": "error",
+        "package-json/valid-files": "error",
+        "package-json/valid-homepage": "error",
+        "package-json/valid-keywords": "error",
+        "package-json/valid-license": "error",
+        "package-json/valid-main": "error",
+        "package-json/valid-man": "error",
+        "package-json/valid-module": "error",
+        "package-json/valid-name": "error",
+        "package-json/valid-optionalDependencies": "error",
+        "package-json/valid-os": "error",
+        "package-json/valid-package-definition": "error",
+        "package-json/valid-peerDependencies": "error",
+        "package-json/valid-private": "error",
+        "package-json/valid-publishConfig": "error",
+        "package-json/valid-repository": "error",
+        "package-json/valid-repository-directory": "error",
+        "package-json/valid-scripts": "error",
+        "package-json/valid-sideEffects": "error",
+        "package-json/valid-type": "error",
+        "package-json/valid-version": "error",
+        "package-json/valid-workspaces": "error",
+    },
+}

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

@@ -0,0 +1,101 @@
+const DEPENDENCY_TYPES = new Set([
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies",
+])
+
+/**
+ * Checks if a package name matches a restriction pattern. Supports exact matches and glob-like
+ * patterns with * wildcard.
+ *
+ * @param {string} packageName - The package name to check
+ * @param {string} pattern - The restriction pattern
+ * @returns {boolean} True if the package matches the pattern
+ */
+function matchesPattern(packageName, pattern) {
+    if (pattern.includes("*")) {
+        const regexPattern = pattern.replaceAll("*", ".*").replaceAll("/", String.raw`\/`)
+        // eslint-disable-next-line security-node/non-literal-reg-expr -- Pattern comes from trusted ESLint config
+        const regex = new RegExp(`^${regexPattern}$`)
+
+        return regex.test(packageName)
+    }
+
+    return packageName === pattern
+}
+
+export const noRestrictedDependencies = {
+    create(context) {
+        const options = context.options[0] || {}
+        const restricted = options.packages || []
+
+        if (restricted.length === 0) {
+            return {}
+        }
+
+        return {
+            JSONProperty(node) {
+                if (node.key.type !== "JSONLiteral" || typeof node.key.value !== "string") {
+                    return
+                }
+
+                const propertyName = node.key.value
+
+                if (!DEPENDENCY_TYPES.has(propertyName)) {
+                    return
+                }
+
+                if (node.value.type !== "JSONObjectExpression") {
+                    return
+                }
+
+                for (const dep of node.value.properties) {
+                    if (dep.key.type !== "JSONLiteral" || typeof dep.key.value !== "string") {
+                        continue
+                    }
+
+                    const packageName = dep.key.value
+
+                    for (const pattern of restricted) {
+                        if (matchesPattern(packageName, pattern)) {
+                            context.report({
+                                data: {
+                                    dependencyType: propertyName,
+                                    package: packageName,
+                                    pattern,
+                                },
+                                messageId: "restricted",
+                                node: dep.key,
+                            })
+                            break
+                        }
+                    }
+                }
+            },
+        }
+    },
+    meta: {
+        docs: {
+            description: "Disallow specified packages from being used as dependencies.",
+        },
+        messages: {
+            restricted: `Package "{{package}}" is restricted (matched pattern: "{{pattern}}") in {{dependencyType}}.`,
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    packages: {
+                        description:
+                            "List of restricted package names or patterns (supports * wildcard)",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+}

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

@@ -0,0 +1,160 @@
+import { ESLint } from "eslint"
+import jsoncParser from "jsonc-eslint-parser"
+
+import { noRestrictedDependencies } from "./no-restricted-dependencies.js"
+
+const createEslint = (packages) => {
+    return new ESLint({
+        overrideConfig: [
+            {
+                files: ["**/package.json"],
+                languageOptions: {
+                    parser: jsoncParser,
+                },
+                plugins: {
+                    custom: {
+                        rules: {
+                            "no-restricted-dependencies": noRestrictedDependencies,
+                        },
+                    },
+                },
+                rules: {
+                    "custom/no-restricted-dependencies": ["error", { packages }],
+                },
+            },
+        ],
+        overrideConfigFile: true,
+    })
+}
+
+describe("no-restricted-dependencies", () => {
+    test("detects restricted package in dependencies", async () => {
+        const eslint = createEslint(["lodash"])
+        const packageJson = JSON.stringify(
+            {
+                dependencies: {
+                    lodash: "^4.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/no-restricted-dependencies"
+        })
+
+        expect(errors?.length).toBe(1)
+        expect(errors?.[0]?.message).toContain("lodash")
+    })
+
+    test("detects restricted package in devDependencies", async () => {
+        const eslint = createEslint(["jest"])
+        const packageJson = JSON.stringify(
+            {
+                devDependencies: {
+                    jest: "^29.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/no-restricted-dependencies"
+        })
+
+        expect(errors?.length).toBe(1)
+    })
+
+    test("detects pattern with wildcard", async () => {
+        const eslint = createEslint(["@types/*"])
+        const packageJson = JSON.stringify(
+            {
+                devDependencies: {
+                    "@types/node": "^20.0.0",
+                    "@types/react": "^18.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/no-restricted-dependencies"
+        })
+
+        expect(errors?.length).toBe(2)
+    })
+
+    test("allows non-restricted packages", async () => {
+        const eslint = createEslint(["lodash"])
+        const packageJson = JSON.stringify(
+            {
+                dependencies: {
+                    react: "^18.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/no-restricted-dependencies"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+
+    test("detects multiple restricted packages", async () => {
+        const eslint = createEslint(["lodash", "ramda", "underscore"])
+        const packageJson = JSON.stringify(
+            {
+                dependencies: {
+                    lodash: "^4.0.0",
+                    ramda: "^0.29.0",
+                    react: "^18.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/no-restricted-dependencies"
+        })
+
+        expect(errors?.length).toBe(2)
+    })
+
+    test("handles empty packages list", async () => {
+        const eslint = createEslint([])
+        const packageJson = JSON.stringify(
+            {
+                dependencies: {
+                    lodash: "^4.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/no-restricted-dependencies"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+})

package/src/eslint/rules/valid-engines-node/valid-engines-node.js

@@ -0,0 +1,86 @@
+const DEFAULT_ALLOWED_VERSIONS = ["24"]
+
+/**
+ * Extracts the major version number from a node engine string. Handles formats like ">=20",
+ * ">=20.0.0", "^20", "20.x", "20", etc.
+ *
+ * @param {string} engineValue - The engines.node value
+ * @returns {string | null} The major version number or null if not parsable
+ */
+function extractMajorVersion(engineValue) {
+    const match = /(\d+)/.exec(engineValue)
+
+    return match?.[1] ?? null
+}
+
+export const validEnginesNode = {
+    create(context) {
+        const options = context.options[0] || {}
+        const allowedVersions = options.versions || DEFAULT_ALLOWED_VERSIONS
+
+        return {
+            JSONProperty(node) {
+                if (node.key.type !== "JSONLiteral" || node.key.value !== "engines") {
+                    return
+                }
+
+                if (node.value.type !== "JSONObjectExpression") {
+                    return
+                }
+
+                const nodeEngine = node.value.properties.find((prop) => {
+                    return prop.key.type === "JSONLiteral" && prop.key.value === "node"
+                })
+
+                if (!nodeEngine) {
+                    return
+                }
+
+                if (nodeEngine.value.type !== "JSONLiteral") {
+                    return
+                }
+
+                const engineValue = nodeEngine.value.value
+
+                if (typeof engineValue !== "string") {
+                    return
+                }
+
+                const majorVersion = extractMajorVersion(engineValue)
+
+                if (!majorVersion || !allowedVersions.includes(majorVersion)) {
+                    context.report({
+                        data: {
+                            allowed: allowedVersions.join(", "),
+                            value: engineValue,
+                        },
+                        messageId: "invalidVersion",
+                        node: nodeEngine.value,
+                    })
+                }
+            },
+        }
+    },
+    meta: {
+        docs: {
+            description: "Restrict engines.node to specific LTS versions.",
+        },
+        messages: {
+            invalidVersion: `Node engine "{{value}}" is not allowed. Use one of the LTS versions: {{allowed}}.`,
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    versions: {
+                        description: "List of allowed major Node.js versions",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+}

package/src/eslint/rules/valid-engines-node/valid-engines-node.test.js

@@ -0,0 +1,154 @@
+import { ESLint } from "eslint"
+import jsoncParser from "jsonc-eslint-parser"
+
+import { validEnginesNode } from "./valid-engines-node.js"
+
+const createEslint = (versions) => {
+    return new ESLint({
+        overrideConfig: [
+            {
+                files: ["**/package.json"],
+                languageOptions: {
+                    parser: jsoncParser,
+                },
+                plugins: {
+                    custom: {
+                        rules: {
+                            "valid-engines-node": validEnginesNode,
+                        },
+                    },
+                },
+                rules: {
+                    "custom/valid-engines-node": ["error", { versions }],
+                },
+            },
+        ],
+        overrideConfigFile: true,
+    })
+}
+
+describe("valid-engines-node", () => {
+    test("allows valid LTS version", async () => {
+        const eslint = createEslint(["24"])
+        const packageJson = JSON.stringify(
+            {
+                engines: {
+                    node: ">=24.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/valid-engines-node"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+
+    test("allows version with just major number", async () => {
+        const eslint = createEslint(["24"])
+        const packageJson = JSON.stringify(
+            {
+                engines: {
+                    node: ">=24",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/valid-engines-node"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+
+    test("rejects non-LTS version", async () => {
+        const eslint = createEslint(["24"])
+        const packageJson = JSON.stringify(
+            {
+                engines: {
+                    node: ">=18.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/valid-engines-node"
+        })
+
+        expect(errors?.length).toBe(1)
+        expect(errors?.[0]?.message).toContain("18.0.0")
+    })
+
+    test("rejects odd version numbers", async () => {
+        const eslint = createEslint(["24"])
+        const packageJson = JSON.stringify(
+            {
+                engines: {
+                    node: ">=21.0.0",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/valid-engines-node"
+        })
+
+        expect(errors?.length).toBe(1)
+    })
+
+    test("handles missing engines field", async () => {
+        const eslint = createEslint(["24"])
+        const packageJson = JSON.stringify(
+            {
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/valid-engines-node"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+
+    test("handles missing node in engines", async () => {
+        const eslint = createEslint(["24"])
+        const packageJson = JSON.stringify(
+            {
+                engines: {
+                    npm: ">=9",
+                },
+                name: "test",
+            },
+            null,
+            4,
+        )
+
+        const results = await eslint.lintText(packageJson, { filePath: "package.json" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "custom/valid-engines-node"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+})

package/src/package-json/configs/core.js

@@ -1,8 +0,0 @@
-import packageJsonCore from "../plugins/package-json.js"
-
-/** @type {import("npm-package-json-lint/dist/src/configuration").Config} */
-const config = {
-    ...packageJsonCore,
-}
-
-export default config

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

@@ -1,81 +0,0 @@
-/** @type {import("npm-package-json-lint/dist/src/configuration").Config} */
-const plugin = {
-    rules: {
-        "bin-type": "error",
-        "bundledDependencies-type": "error",
-        "config-type": "error",
-        "cpu-type": "error",
-        "dependencies-type": "error",
-        "description-format": [
-            "error",
-            {
-                "name-format": "error",
-                "no-duplicate-properties": "error",
-                requireCapitalFirstLetter: true,
-                requireEndingPeriod: false,
-
-                "version-format": "error",
-            },
-        ],
-        "description-type": "error",
-        "devDependencies-type": "error",
-        "directories-type": "error",
-        "engines-type": "error",
-        "files-type": "error",
-        "homepage-type": "error",
-        "keywords-type": "error",
-        "license-type": "error",
-        "main-type": "error",
-        "man-type": "error",
-        "name-type": "error",
-        "no-archive-dependencies": "error",
-        "no-archive-devDependencies": "error",
-        "no-caret-version-dependencies": "error",
-        "no-caret-version-devDependencies": "error",
-        "no-file-dependencies": "error",
-        "no-file-devDependencies": "error",
-        "no-git-dependencies": "error",
-        "no-git-devDependencies": "error",
-        "no-repeated-dependencies": "error",
-        "no-restricted-dependencies": [
-            "error",
-            [
-                "typeorm",
-                "ramda",
-                "lodash",
-                "@types/*",
-                "eslint",
-                "prettier",
-                "cspell",
-                "npm-package-json-lint",
-                "stylelint",
-            ],
-        ],
-        "no-tilde-version-dependencies": "error",
-        "no-tilde-version-devDependencies": "error",
-        "optionalDependencies-type": "error",
-        "os-type": "error",
-        "peerDependencies-type": "error",
-        "prefer-absolute-version-devDependencies": "error",
-        "prefer-alphabetical-dependencies": "error",
-        "preferGlobal-type": "error",
-        "private-type": "error",
-        "repository-type": "error",
-        "require-author": "error",
-        "require-description": "error",
-        "require-engines": "error",
-        "require-license": "error",
-        "require-name": "error",
-        "require-repository": "error",
-        "require-version": "error",
-        "scripts-type": "error",
-        "type-type": "error",
-        "valid-values-engines": [
-            "error",
-            [{ node: ">=18.0.0" }, { node: ">=20.0.0" }, { node: ">=22.0.0" }],
-        ],
-        "version-type": "error",
-    },
-}
-
-export default plugin