eslint-plugin-no-unused-type-properties 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# eslint-plugin-no-unused-type-properties
+
+Standalone ESLint plugin providing the `no-unused-type-properties` rule.
+
+## Usage (flat config)
+
+```ts
+import pluginNoUnusedTypeProperties from 'eslint-plugin-no-unused-type-properties'
+
+export default [
+  {
+    plugins: {
+      random: pluginNoUnusedTypeProperties,
+    },
+    rules: {
+      'random/no-unused-type-properties': 'error',
+    },
+  },
+]
+```
+# eslint-plugin-no-unused-type-properties

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export declare const rules: {
+    'no-unused-type-properties': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedProperties", [], import("./types").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+};
+declare const plugin: {
+    rules: {
+        'no-unused-type-properties': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedProperties", [], import("./types").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;CAEjB,CAAA;AAED,QAAA,MAAM,MAAM;;;;;;CAEX,CAAA;AAED,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -0,0 +1,8 @@
+import { noUnusedTypePropertiesRule } from './rules/no-unused-type-properties';
+export const rules = {
+    'no-unused-type-properties': noUnusedTypePropertiesRule,
+};
+const plugin = {
+    rules,
+};
+export default plugin;

package/dist/rules/no-unused-type-properties.d.ts

@@ -0,0 +1,5 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare const noUnusedTypePropertiesRule: TSESLint.RuleModule<"unusedProperties", [], import("../types").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+//# sourceMappingURL=no-unused-type-properties.d.ts.map

package/dist/rules/no-unused-type-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-type-properties.d.ts","sourceRoot":"","sources":["../../src/rules/no-unused-type-properties.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AA+DxD,eAAO,MAAM,0BAA0B;;CAgIrC,CAAA"}

package/dist/rules/no-unused-type-properties.js

@@ -0,0 +1,129 @@
+/* eslint-disable unicorn/no-array-callback-reference */
+import { AST_NODE_TYPES } from '@typescript-eslint/types';
+import { createRule } from '../utils/create-rule';
+function isProperty(property) {
+    return property.type === AST_NODE_TYPES.Property;
+}
+function isObjectPattern(param) {
+    return param.type === AST_NODE_TYPES.ObjectPattern;
+}
+function isTypeAliasDeclaration(item) {
+    return item.type === AST_NODE_TYPES.TSTypeAliasDeclaration;
+}
+function getTypeAliasDeclaration(item) {
+    if (isTypeAliasDeclaration(item)) {
+        return item;
+    }
+    if (item.type === AST_NODE_TYPES.ExportNamedDeclaration &&
+        item.declaration &&
+        item.declaration.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
+        return item.declaration;
+    }
+    return undefined;
+}
+function isInterfaceDeclaration(item) {
+    return item.type === AST_NODE_TYPES.TSInterfaceDeclaration;
+}
+function getInterfaceDeclaration(item) {
+    if (isInterfaceDeclaration(item)) {
+        return item;
+    }
+    if (item.type === AST_NODE_TYPES.ExportNamedDeclaration &&
+        item.declaration &&
+        item.declaration.type === AST_NODE_TYPES.TSInterfaceDeclaration) {
+        return item.declaration;
+    }
+    return undefined;
+}
+export const noUnusedTypePropertiesRule = createRule({
+    name: 'no-unused-type-properties',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallows unused type properties for destructured function arguments',
+            recommended: false,
+            requiresTypeChecking: false,
+        },
+        messages: {
+            unusedProperties: "Property '{{propertyName}}' is defined in type '{{typeName}}' but is not used in the destructuring. Remove it or use Omit<{{typeName}}, '{{propertyName}}'> to explicitly exclude it.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const checkIfPropertyIsPresent = (objectPattern, typeName) => (typeProperty) => {
+            if (typeProperty.type !== AST_NODE_TYPES.TSPropertySignature) {
+                return;
+            }
+            if (typeProperty.key.type !== AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            const propertyName = typeProperty.key.name;
+            const properties = objectPattern.properties.filter(isProperty);
+            const property = properties.find(property => property.key.type === AST_NODE_TYPES.Identifier && property.key.name === propertyName);
+            if (!property) {
+                context.report({
+                    node: objectPattern,
+                    messageId: 'unusedProperties',
+                    data: {
+                        propertyName,
+                        typeName,
+                    },
+                });
+                return;
+            }
+            if (typeProperty.typeAnnotation && property.value.type === AST_NODE_TYPES.ObjectPattern) {
+                recursiveCheck(property.value, typeProperty.typeAnnotation);
+            }
+        };
+        const recursiveCheck = (object, type) => {
+            const restElement = object.properties.find(property => property.type === AST_NODE_TYPES.RestElement);
+            if (restElement) {
+                return;
+            }
+            if (type.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference &&
+                type.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier) {
+                const typeName = type.typeAnnotation.typeName.name;
+                const typeDeclaration = context.sourceCode.ast.body
+                    .map(getTypeAliasDeclaration)
+                    .find((decl) => decl !== undefined && decl.id.name === typeName);
+                if (typeDeclaration) {
+                    if (typeDeclaration.typeAnnotation.type !== AST_NODE_TYPES.TSTypeLiteral) {
+                        return;
+                    }
+                    typeDeclaration.typeAnnotation.members.forEach(checkIfPropertyIsPresent(object, typeName));
+                    return;
+                }
+                const interfaceDeclaration = context.sourceCode.ast.body
+                    .map(getInterfaceDeclaration)
+                    .find((decl) => decl !== undefined && decl.id.name === typeName);
+                if (!interfaceDeclaration) {
+                    return;
+                }
+                interfaceDeclaration.body.body.forEach(checkIfPropertyIsPresent(object, typeName));
+                return;
+            }
+            if (type.typeAnnotation.type === AST_NODE_TYPES.TSTypeLiteral) {
+                const inlineTypeName = context.sourceCode.getText(type.typeAnnotation);
+                type.typeAnnotation.members.forEach(checkIfPropertyIsPresent(object, inlineTypeName));
+            }
+        };
+        const checkParameter = (paramObjectPattern) => {
+            if (!paramObjectPattern.typeAnnotation) {
+                return;
+            }
+            recursiveCheck(paramObjectPattern, paramObjectPattern.typeAnnotation);
+        };
+        return {
+            FunctionDeclaration(node) {
+                node.params.filter(isObjectPattern).forEach(checkParameter);
+            },
+            ArrowFunctionExpression(node) {
+                node.params.filter(isObjectPattern).forEach(checkParameter);
+            },
+            FunctionExpression(node) {
+                node.params.filter(isObjectPattern).forEach(checkParameter);
+            },
+        };
+    },
+});

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+export interface ESLintPluginDocs {
+    description: string;
+    recommended: boolean;
+    requiresTypeChecking: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,OAAO,CAAA;IACpB,oBAAoB,EAAE,OAAO,CAAA;CAC9B"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/create-rule.d.ts

@@ -0,0 +1,6 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import type { ESLintPluginDocs } from '../types';
+export declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, ESLintPluginDocs>>) => ESLintUtils.RuleModule<MessageIds, Options, ESLintPluginDocs, ESLintUtils.RuleListener> & {
+    name: string;
+};
+//# sourceMappingURL=create-rule.d.ts.map

package/dist/utils/create-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-rule.d.ts","sourceRoot":"","sources":["../../src/utils/create-rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,eAAO,MAAM,UAAU;;CAEtB,CAAA"}

package/dist/utils/create-rule.js

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export const createRule = ESLintUtils.RuleCreator(name => `https://typescript-eslint.io/rules/${name}`);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "eslint-plugin-no-unused-type-properties",
+  "version": "0.1.0",
+  "description": "ESLint plugin containing no-unused-type-properties rule",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "peerDependencies": {
+    "@typescript-eslint/types": "^8.57.1",
+    "@typescript-eslint/utils": "^8.57.1",
+    "eslint": "^9.0.0 || ^10.0.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/types": "^8.57.1",
+    "@typescript-eslint/utils": "^8.57.1",
+    "eslint": "^10.0.3",
+    "typescript": "^5.9.3"
+  }
+}