eslint-config-typed 3.7.1 → 3.8.0

package/dist/plugins/ts-restrictions/rules/check-destructuring-completeness.d.mts

@@ -0,0 +1,11 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [
+    Readonly<{
+        alwaysCheckReactComponentProps?: boolean;
+        directiveKeyword?: string;
+    }>?
+];
+type MessageIds = 'incompleteDestructuring';
+export declare const checkDestructuringCompleteness: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=check-destructuring-completeness.d.mts.map

package/dist/plugins/ts-restrictions/rules/check-destructuring-completeness.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-destructuring-completeness.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-restrictions/rules/check-destructuring-completeness.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAGlC,KAAK,OAAO,GAAG,SAAS;IACtB,QAAQ,CAAC;QACP,8BAA8B,CAAC,EAAE,OAAO,CAAC;QACzC,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,UAAU,GAAG,yBAAyB,CAAC;AA8D5C,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,UAAU,CAC9D,UAAU,EACV,OAAO,CAmOR,CAAC"}

package/dist/plugins/ts-restrictions/rules/check-destructuring-completeness.mjs

@@ -0,0 +1,217 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+const DEFAULT_DIRECTIVE_KEYWORD = '@check-destructuring-completeness';
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const getObjectTypeProperties = (type) => {
+    try {
+        const properties = type.getProperties();
+        // Limit to reasonable number of properties to avoid hangs
+        if (properties.length > 1000) {
+            return [];
+        }
+        return properties
+            .map((prop) => prop.name)
+            .filter((name) => 
+        // Filter out symbol properties and internal properties
+        !name.startsWith('__') &&
+            // Only include string property names
+            typeof name === 'string' &&
+            name.length > 0);
+    }
+    catch {
+        // If there's any error getting properties, return empty array
+        return [];
+    }
+};
+const isReactComponentFunction = (node) => {
+    if (node === undefined || node === null)
+        return false;
+    // Arrow function component
+    if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+        const { body } = node;
+        if (body.type === AST_NODE_TYPES.BlockStatement) {
+            return body.body.some((statement) => {
+                if (statement.type !== AST_NODE_TYPES.ReturnStatement)
+                    return false;
+                const { argument } = statement;
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (argument === null || argument === undefined)
+                    return false;
+                const argType = argument.type;
+                return argType === 'JSXElement' || argType === 'JSXFragment';
+            });
+        }
+        const bodyType = body.type;
+        return bodyType === 'JSXElement' || bodyType === 'JSXFragment';
+    }
+    return false;
+};
+const checkDestructuringCompleteness = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensure all properties are destructured from an object when explicitly requested',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    alwaysCheckReactComponentProps: {
+                        type: 'boolean',
+                        description: 'Always check React component props destructuring without directive keyword',
+                    },
+                    directiveKeyword: {
+                        type: 'string',
+                        description: 'Custom directive keyword to enable checking (default: "@check-destructuring-completeness")',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            incompleteDestructuring: 'Not all properties are destructured. Missing: {{missingProps}}',
+        },
+    },
+    create: (context) => {
+        const parserServices = context.sourceCode.parserServices;
+        if (parserServices?.program === undefined ||
+            parserServices.program === null ||
+            parserServices.esTreeNodeToTSNodeMap === undefined) {
+            return {};
+        }
+        const options = context.options[0] ?? {};
+        const alwaysCheckReactComponentProps = options.alwaysCheckReactComponentProps ?? true;
+        const directiveKeyword = options.directiveKeyword ?? DEFAULT_DIRECTIVE_KEYWORD;
+        const typeChecker = parserServices.program.getTypeChecker();
+        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
+        const sourceCode = context.sourceCode;
+        const hasDirectiveComment = (node) => {
+            // Get the parent VariableDeclaration
+            const parent = node.parent;
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (parent?.type !== AST_NODE_TYPES.VariableDeclaration) {
+                return false;
+            }
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            const comments = sourceCode.getCommentsBefore(parent);
+            return comments.some((comment) => comment.value.includes(directiveKeyword));
+        };
+        const isReactComponentPropsDestructuring = (node) => {
+            if (!alwaysCheckReactComponentProps)
+                return false;
+            const parent = node.parent;
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (parent === undefined)
+                return false;
+            // Case 1: const { a, b } = props; inside component
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (parent.type === AST_NODE_TYPES.VariableDeclaration) {
+                const grandParent = parent.parent;
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (grandParent === undefined)
+                    return false;
+                // Check if we're inside a BlockStatement of an arrow function component
+                if (grandParent.type === AST_NODE_TYPES.BlockStatement) {
+                    const greatGrandParent = grandParent.parent;
+                    if (
+                    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                    greatGrandParent?.type === AST_NODE_TYPES.ArrowFunctionExpression &&
+                        node.init?.type === AST_NODE_TYPES.Identifier) {
+                        const initName = 
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                        node.init.type === AST_NODE_TYPES.Identifier
+                            ? node.init.name
+                            : undefined;
+                        if (initName !== undefined &&
+                            greatGrandParent.params.some((param) => param.type === AST_NODE_TYPES.Identifier &&
+                                param.name === initName)) {
+                            return isReactComponentFunction(greatGrandParent);
+                        }
+                    }
+                }
+                if (grandParent.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+                    return isReactComponentFunction(grandParent);
+                }
+            }
+            return false;
+        };
+        const checkNode = (node) => {
+            if (node.id.type !== AST_NODE_TYPES.ObjectPattern)
+                return;
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (node.init === undefined || node.init === null)
+                return;
+            const shouldCheck = hasDirectiveComment(node) || isReactComponentPropsDestructuring(node);
+            if (!shouldCheck)
+                return;
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            const tsNode = esTreeNodeToTSNodeMap.get(node.init);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (tsNode === undefined)
+                return;
+            const type = typeChecker.getTypeAtLocation(tsNode);
+            const objectProps = getObjectTypeProperties(type);
+            const destructuredProps = new Set();
+            for (const prop of node.id.properties) {
+                if (prop.type === AST_NODE_TYPES.Property &&
+                    prop.key.type === AST_NODE_TYPES.Identifier) {
+                    // eslint-disable-next-line functional/immutable-data
+                    destructuredProps.add(prop.key.name);
+                }
+            }
+            const missingProps = objectProps.filter((prop) => !destructuredProps.has(prop));
+            if (missingProps.length > 0) {
+                context.report({
+                    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                    node: node.id,
+                    messageId: 'incompleteDestructuring',
+                    data: {
+                        missingProps: missingProps.join(', '),
+                    },
+                });
+            }
+        };
+        return {
+            VariableDeclarator: checkNode,
+            ArrowFunctionExpression: (node) => {
+                if (!alwaysCheckReactComponentProps)
+                    return;
+                if (!isReactComponentFunction(node))
+                    return;
+                for (const param of node.params) {
+                    if (param.type === AST_NODE_TYPES.ObjectPattern) {
+                        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+                        const tsNode = esTreeNodeToTSNodeMap.get(param);
+                        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                        if (tsNode === undefined)
+                            continue;
+                        const type = typeChecker.getTypeAtLocation(tsNode);
+                        const objectProps = getObjectTypeProperties(type);
+                        const destructuredProps = new Set();
+                        for (const prop of param.properties) {
+                            if (prop.type === AST_NODE_TYPES.Property &&
+                                prop.key.type === AST_NODE_TYPES.Identifier) {
+                                // eslint-disable-next-line functional/immutable-data
+                                destructuredProps.add(prop.key.name);
+                            }
+                        }
+                        const missingProps = objectProps.filter((prop) => !destructuredProps.has(prop));
+                        if (missingProps.length > 0) {
+                            context.report({
+                                node: param,
+                                messageId: 'incompleteDestructuring',
+                                data: {
+                                    missingProps: missingProps.join(', '),
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+    defaultOptions: [],
+};
+
+export { checkDestructuringCompleteness };
+//# sourceMappingURL=check-destructuring-completeness.mjs.map

package/dist/plugins/ts-restrictions/rules/check-destructuring-completeness.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-destructuring-completeness.mjs","sources":["../../../../src/plugins/ts-restrictions/rules/check-destructuring-completeness.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/plugins/ts-restrictions/rules/rules.d.mts

@@ -1,4 +1,8 @@
 export declare const tsRestrictionsRules: {
+    readonly 'check-destructuring-completeness': import("@typescript-eslint/utils/ts-eslint").RuleModule<"incompleteDestructuring", readonly [(Readonly<{
+        alwaysCheckReactComponentProps?: boolean;
+        directiveKeyword?: string;
+    }> | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'no-restricted-cast-name': import("@typescript-eslint/utils/ts-eslint").RuleModule<"restrictedCast", readonly (string | Readonly<{
         name: string;
         fixWith?: Readonly<{

package/dist/plugins/ts-restrictions/rules/rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-restrictions/rules/rules.mts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;CAGU,CAAC"}
+{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/ts-restrictions/rules/rules.mts"],"names":[],"mappings":"AAKA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;CAIU,CAAC"}

package/dist/plugins/ts-restrictions/rules/rules.mjs

@@ -1,7 +1,9 @@
+import { checkDestructuringCompleteness } from './check-destructuring-completeness.mjs';
 import { noRestrictedCastName } from './no-restricted-cast-name.mjs';
 import { noRestrictedSyntax } from './no-restricted-syntax.mjs';
 
 const tsRestrictionsRules = {
+    'check-destructuring-completeness': checkDestructuringCompleteness,
     'no-restricted-cast-name': noRestrictedCastName,
     'no-restricted-syntax': noRestrictedSyntax,
 };

package/dist/plugins/ts-restrictions/rules/rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/ts-restrictions/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIO,MAAM,mBAAmB,GAAG;AACjC,IAAA,yBAAyB,EAAE,oBAAoB;AAC/C,IAAA,sBAAsB,EAAE,kBAAkB;;;;;"}
+{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/ts-restrictions/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKO,MAAM,mBAAmB,GAAG;AACjC,IAAA,kCAAkC,EAAE,8BAA8B;AAClE,IAAA,yBAAyB,EAAE,oBAAoB;AAC/C,IAAA,sBAAsB,EAAE,kBAAkB;;;;;"}

package/dist/rules/eslint-ts-restrictions-rules.d.mts

@@ -1,5 +1,6 @@
 export declare const eslintTsRestrictionsRules: {
     readonly 'ts-restrictions/no-restricted-syntax': "off";
     readonly 'ts-restrictions/no-restricted-cast-name': "off";
+    readonly 'ts-restrictions/check-destructuring-completeness': 2 | 1;
 };
 //# sourceMappingURL=eslint-ts-restrictions-rules.d.mts.map

package/dist/rules/eslint-ts-restrictions-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-ts-restrictions-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-ts-restrictions-rules.mts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB;;;CAGQ,CAAC"}
+{"version":3,"file":"eslint-ts-restrictions-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-ts-restrictions-rules.mts"],"names":[],"mappings":"AAKA,eAAO,MAAM,yBAAyB;;;;CAKQ,CAAC"}

package/dist/rules/eslint-ts-restrictions-rules.mjs

@@ -1,6 +1,9 @@
+import { withDefaultOption } from '../types/rule-severity-with-default-option.mjs';
+
 const eslintTsRestrictionsRules = {
     'ts-restrictions/no-restricted-syntax': 'off',
     'ts-restrictions/no-restricted-cast-name': 'off',
+    'ts-restrictions/check-destructuring-completeness': withDefaultOption('error'),
 };
 
 export { eslintTsRestrictionsRules };

package/dist/rules/eslint-ts-restrictions-rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-ts-restrictions-rules.mjs","sources":["../../src/rules/eslint-ts-restrictions-rules.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEO,MAAM,yBAAyB,GAAG;AACvC,IAAA,sCAAsC,EAAE,KAAK;AAC7C,IAAA,yCAAyC,EAAE,KAAK;;;;;"}
+{"version":3,"file":"eslint-ts-restrictions-rules.mjs","sources":["../../src/rules/eslint-ts-restrictions-rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAKO,MAAM,yBAAyB,GAAG;AACvC,IAAA,sCAAsC,EAAE,KAAK;AAC7C,IAAA,yCAAyC,EAAE,KAAK;AAChD,IAAA,kDAAkD,EAChD,iBAAiB,CAAC,OAAO,CAAC;;;;;"}

package/dist/types/rules/eslint-ts-restrictions-rules.d.mts

@@ -1,5 +1,53 @@
 import { type Linter } from 'eslint';
 type SpreadOptionsIfIsArray<T extends readonly [Linter.StringSeverity, unknown]> = T[1] extends readonly unknown[] ? readonly [Linter.StringSeverity, ...T[1]] : T;
+/**
+ * Ensure all properties are destructured from an object when explicitly
+ * requested
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * ```
+ */
+declare namespace CheckDestructuringCompleteness {
+    /**
+     * ### schema
+     *
+     * ```json
+     * [
+     *   {
+     *     "type": "object",
+     *     "properties": {
+     *       "alwaysCheckReactComponentProps": {
+     *         "type": "boolean",
+     *         "description": "Always check React component props destructuring without directive keyword"
+     *       },
+     *       "directiveKeyword": {
+     *         "type": "string",
+     *         "description": "Custom directive keyword to enable checking (default: \"@check-destructuring-completeness\")"
+     *       }
+     *     },
+     *     "additionalProperties": false
+     *   }
+     * ]
+     * ```
+     */
+    type Options = {
+        /**
+         * Always check React component props destructuring without directive
+         * keyword
+         */
+        readonly alwaysCheckReactComponentProps?: boolean;
+        /**
+         * Custom directive keyword to enable checking (default:
+         * "@check-destructuring-completeness")
+         */
+        readonly directiveKeyword?: string;
+    };
+    type RuleEntry = Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]> | 'off';
+}
 /**
  * Disallow type assertions with specified type names
  *
@@ -139,10 +187,12 @@ declare namespace NoRestrictedSyntax {
     type RuleEntry = Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]> | 'off';
 }
 export type EslintTsRestrictionsRules = {
+    readonly 'ts-restrictions/check-destructuring-completeness': CheckDestructuringCompleteness.RuleEntry;
     readonly 'ts-restrictions/no-restricted-cast-name': NoRestrictedCastName.RuleEntry;
     readonly 'ts-restrictions/no-restricted-syntax': NoRestrictedSyntax.RuleEntry;
 };
 export type EslintTsRestrictionsRulesOption = {
+    readonly 'ts-restrictions/check-destructuring-completeness': CheckDestructuringCompleteness.Options;
     readonly 'ts-restrictions/no-restricted-cast-name': NoRestrictedCastName.Options;
     readonly 'ts-restrictions/no-restricted-syntax': NoRestrictedSyntax.Options;
 };

package/dist/types/rules/eslint-ts-restrictions-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-ts-restrictions-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-ts-restrictions-rules.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,KAAK,sBAAsB,CACzB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,IACjD,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC/B,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GACzC,CAAC,CAAC;AAEN;;;;;;;;;;GAUG;AACH,kBAAU,oBAAoB,CAAC;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4DG;IACH,kBAAkB;IAClB,KAAY,OAAO,GAAG,SAAS,CAC3B,MAAM,GACN;QACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,OAAO,CAAC,EACb;YACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;YAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;SACvB,GACD;YACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;SACvB,CAAC;KACP,CACJ,EAAE,CAAC;IAEJ,KAAY,SAAS,GACjB,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,GACjE,KAAK,CAAC;CACX;AAED;;;;;;;;;;;;GAYG;AACH,kBAAU,kBAAkB,CAAC;IAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,kBAAkB;IAClB,KAAY,OAAO,GAAG,SAAS,CAC3B,MAAM,GACN;QACE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;KAC3B,CACJ,EAAE,CAAC;IAEJ,KAAY,SAAS,GACjB,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,GACjE,KAAK,CAAC;CACX;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,yCAAyC,EAAE,oBAAoB,CAAC,SAAS,CAAC;IACnF,QAAQ,CAAC,sCAAsC,EAAE,kBAAkB,CAAC,SAAS,CAAC;CAC/E,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,CAAC,yCAAyC,EAAE,oBAAoB,CAAC,OAAO,CAAC;IACjF,QAAQ,CAAC,sCAAsC,EAAE,kBAAkB,CAAC,OAAO,CAAC;CAC7E,CAAC"}
+{"version":3,"file":"eslint-ts-restrictions-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-ts-restrictions-rules.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,KAAK,sBAAsB,CACzB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,IACjD,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC/B,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GACzC,CAAC,CAAC;AAEN;;;;;;;;;;GAUG;AACH,kBAAU,8BAA8B,CAAC;IACvC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAY,OAAO,GAAG;QACpB;;;WAGG;QACH,QAAQ,CAAC,8BAA8B,CAAC,EAAE,OAAO,CAAC;QAClD;;;WAGG;QACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;KACpC,CAAC;IAEF,KAAY,SAAS,GACjB,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,GACjE,KAAK,CAAC;CACX;AAED;;;;;;;;;;GAUG;AACH,kBAAU,oBAAoB,CAAC;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4DG;IACH,kBAAkB;IAClB,KAAY,OAAO,GAAG,SAAS,CAC3B,MAAM,GACN;QACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,OAAO,CAAC,EACb;YACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;YAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;SACvB,GACD;YACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;SACvB,CAAC;KACP,CACJ,EAAE,CAAC;IAEJ,KAAY,SAAS,GACjB,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,GACjE,KAAK,CAAC;CACX;AAED;;;;;;;;;;;;GAYG;AACH,kBAAU,kBAAkB,CAAC;IAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,kBAAkB;IAClB,KAAY,OAAO,GAAG,SAAS,CAC3B,MAAM,GACN;QACE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;KAC3B,CACJ,EAAE,CAAC;IAEJ,KAAY,SAAS,GACjB,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,GACjE,KAAK,CAAC;CACX;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,kDAAkD,EAAE,8BAA8B,CAAC,SAAS,CAAC;IACtG,QAAQ,CAAC,yCAAyC,EAAE,oBAAoB,CAAC,SAAS,CAAC;IACnF,QAAQ,CAAC,sCAAsC,EAAE,kBAAkB,CAAC,SAAS,CAAC;CAC/E,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,CAAC,kDAAkD,EAAE,8BAA8B,CAAC,OAAO,CAAC;IACpG,QAAQ,CAAC,yCAAyC,EAAE,oBAAoB,CAAC,OAAO,CAAC;IACjF,QAAQ,CAAC,sCAAsC,EAAE,kBAAkB,CAAC,OAAO,CAAC;CAC7E,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-typed",
-  "version": "3.7.1",
+  "version": "3.8.0",
   "private": false,
   "keywords": [
     "typescript"

package/src/plugins/ts-restrictions/rules/check-destructuring-completeness.mts

@@ -0,0 +1,306 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import type * as ts from 'typescript';
+
+type Options = readonly [
+  Readonly<{
+    alwaysCheckReactComponentProps?: boolean;
+    directiveKeyword?: string;
+  }>?,
+];
+
+type MessageIds = 'incompleteDestructuring';
+
+const DEFAULT_DIRECTIVE_KEYWORD = '@check-destructuring-completeness';
+
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const getObjectTypeProperties = (type: ts.Type): readonly string[] => {
+  try {
+    const properties = type.getProperties();
+
+    // Limit to reasonable number of properties to avoid hangs
+    if (properties.length > 1000) {
+      return [];
+    }
+
+    return properties
+      .map((prop) => prop.name)
+      .filter(
+        (name) =>
+          // Filter out symbol properties and internal properties
+          !name.startsWith('__') &&
+          // Only include string property names
+          typeof name === 'string' &&
+          name.length > 0,
+      );
+  } catch {
+    // If there's any error getting properties, return empty array
+    return [];
+  }
+};
+
+const isReactComponentFunction = (
+  node: DeepReadonly<TSESTree.Node> | undefined | null,
+): boolean => {
+  if (node === undefined || node === null) return false;
+
+  // Arrow function component
+  if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+    const { body } = node;
+
+    if (body.type === AST_NODE_TYPES.BlockStatement) {
+      return body.body.some((statement) => {
+        if (statement.type !== AST_NODE_TYPES.ReturnStatement) return false;
+
+        const { argument } = statement;
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (argument === null || argument === undefined) return false;
+
+        const argType = (argument as { type?: string }).type;
+
+        return argType === 'JSXElement' || argType === 'JSXFragment';
+      });
+    }
+
+    const bodyType = (body as { type?: string }).type;
+
+    return bodyType === 'JSXElement' || bodyType === 'JSXFragment';
+  }
+
+  return false;
+};
+
+export const checkDestructuringCompleteness: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Ensure all properties are destructured from an object when explicitly requested',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          alwaysCheckReactComponentProps: {
+            type: 'boolean',
+            description:
+              'Always check React component props destructuring without directive keyword',
+          },
+          directiveKeyword: {
+            type: 'string',
+            description:
+              'Custom directive keyword to enable checking (default: "@check-destructuring-completeness")',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      incompleteDestructuring:
+        'Not all properties are destructured. Missing: {{missingProps}}',
+    },
+  },
+
+  create: (context) => {
+    const parserServices = context.sourceCode.parserServices;
+
+    if (
+      parserServices?.program === undefined ||
+      parserServices.program === null ||
+      parserServices.esTreeNodeToTSNodeMap === undefined
+    ) {
+      return {};
+    }
+
+    const options = context.options[0] ?? {};
+
+    const alwaysCheckReactComponentProps =
+      options.alwaysCheckReactComponentProps ?? true;
+
+    const directiveKeyword =
+      options.directiveKeyword ?? DEFAULT_DIRECTIVE_KEYWORD;
+
+    const typeChecker = parserServices.program.getTypeChecker();
+    const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
+    const sourceCode = context.sourceCode;
+
+    const hasDirectiveComment = (
+      node: DeepReadonly<TSESTree.VariableDeclarator>,
+    ): boolean => {
+      // Get the parent VariableDeclaration
+      const parent = node.parent;
+
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (parent?.type !== AST_NODE_TYPES.VariableDeclaration) {
+        return false;
+      }
+
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      const comments = sourceCode.getCommentsBefore(parent as never);
+
+      return comments.some((comment) =>
+        comment.value.includes(directiveKeyword),
+      );
+    };
+
+    const isReactComponentPropsDestructuring = (
+      node: DeepReadonly<TSESTree.VariableDeclarator>,
+    ): boolean => {
+      if (!alwaysCheckReactComponentProps) return false;
+
+      const parent = node.parent;
+
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (parent === undefined) return false;
+
+      // Case 1: const { a, b } = props; inside component
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (parent.type === AST_NODE_TYPES.VariableDeclaration) {
+        const grandParent = parent.parent;
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (grandParent === undefined) return false;
+
+        // Check if we're inside a BlockStatement of an arrow function component
+        if (grandParent.type === AST_NODE_TYPES.BlockStatement) {
+          const greatGrandParent = grandParent.parent;
+
+          if (
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            greatGrandParent?.type === AST_NODE_TYPES.ArrowFunctionExpression &&
+            node.init?.type === AST_NODE_TYPES.Identifier
+          ) {
+            const initName =
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+              node.init.type === AST_NODE_TYPES.Identifier
+                ? node.init.name
+                : undefined;
+
+            if (
+              initName !== undefined &&
+              greatGrandParent.params.some(
+                (param) =>
+                  param.type === AST_NODE_TYPES.Identifier &&
+                  param.name === initName,
+              )
+            ) {
+              return isReactComponentFunction(greatGrandParent);
+            }
+          }
+        }
+
+        if (grandParent.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+          return isReactComponentFunction(grandParent);
+        }
+      }
+
+      return false;
+    };
+
+    const checkNode = (
+      node: DeepReadonly<TSESTree.VariableDeclarator>,
+    ): void => {
+      if (node.id.type !== AST_NODE_TYPES.ObjectPattern) return;
+
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (node.init === undefined || node.init === null) return;
+
+      const shouldCheck =
+        hasDirectiveComment(node) || isReactComponentPropsDestructuring(node);
+
+      if (!shouldCheck) return;
+
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      const tsNode = esTreeNodeToTSNodeMap.get(node.init as never);
+
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (tsNode === undefined) return;
+
+      const type = typeChecker.getTypeAtLocation(tsNode);
+
+      const objectProps = getObjectTypeProperties(type);
+      const destructuredProps = new Set<string>();
+
+      for (const prop of node.id.properties) {
+        if (
+          prop.type === AST_NODE_TYPES.Property &&
+          prop.key.type === AST_NODE_TYPES.Identifier
+        ) {
+          // eslint-disable-next-line functional/immutable-data
+          destructuredProps.add(prop.key.name);
+        }
+      }
+
+      const missingProps = objectProps.filter(
+        (prop) => !destructuredProps.has(prop),
+      );
+
+      if (missingProps.length > 0) {
+        context.report({
+          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+          node: node.id as never,
+          messageId: 'incompleteDestructuring',
+          data: {
+            missingProps: missingProps.join(', '),
+          },
+        });
+      }
+    };
+
+    return {
+      VariableDeclarator: checkNode,
+      ArrowFunctionExpression: (node) => {
+        if (!alwaysCheckReactComponentProps) return;
+
+        if (!isReactComponentFunction(node)) return;
+
+        for (const param of node.params) {
+          if (param.type === AST_NODE_TYPES.ObjectPattern) {
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            const tsNode = esTreeNodeToTSNodeMap.get(param as never);
+
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (tsNode === undefined) continue;
+
+            const type = typeChecker.getTypeAtLocation(tsNode);
+
+            const objectProps = getObjectTypeProperties(type);
+            const destructuredProps = new Set<string>();
+
+            for (const prop of param.properties) {
+              if (
+                prop.type === AST_NODE_TYPES.Property &&
+                prop.key.type === AST_NODE_TYPES.Identifier
+              ) {
+                // eslint-disable-next-line functional/immutable-data
+                destructuredProps.add(prop.key.name);
+              }
+            }
+
+            const missingProps = objectProps.filter(
+              (prop) => !destructuredProps.has(prop),
+            );
+
+            if (missingProps.length > 0) {
+              context.report({
+                node: param,
+                messageId: 'incompleteDestructuring',
+                data: {
+                  missingProps: missingProps.join(', '),
+                },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+};

package/src/plugins/ts-restrictions/rules/check-destructuring-completeness.test.mts

@@ -0,0 +1,158 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { checkDestructuringCompleteness } from './check-destructuring-completeness.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      ecmaFeatures: {
+        jsx: true,
+      },
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../../../..`,
+    },
+  },
+});
+
+describe('check-destructuring-completeness', () => {
+  tester.run(
+    'check-destructuring-completeness',
+    checkDestructuringCompleteness,
+    {
+      valid: [
+        {
+          name: 'ignore incomplete destructuring without directive comment',
+          code: dedent`
+            const obj = { a: 1, b: 2, c: 3 };
+            const { a } = obj;
+          `,
+        },
+        {
+          name: 'validates destructuring with default directive - complete',
+          code: dedent`
+            const obj = { a: 1, b: 2, c: 3 };
+            // @check-destructuring-completeness
+            const { a, b, c } = obj;
+          `,
+        },
+        {
+          name: 'validates destructuring with unknown directive',
+          code: dedent`
+            const obj: { a: number; b: string; c: boolean } = { a: 1, b: 'hello', c: true };
+            // @unknown-directive
+            const { a, b } = obj;
+          `,
+        },
+        {
+          name: 'works with custom directive keyword - custom check',
+          code: dedent`
+            const obj: { a: number; b: string } = { a: 1, b: 'hello' };
+            // @custom-check
+            const { a, b } = obj;
+          `,
+          options: [{ directiveKeyword: '@custom-check' }],
+        },
+        {
+          name: 'custom directive ignores default directive',
+          code: dedent`
+            const obj = { a: 1, b: 2, c: 3 };
+            // @check-destructuring-completeness
+            const { a, b } = obj;
+          `,
+          options: [{ directiveKeyword: '@custom-check' }],
+        },
+        {
+          name: 'custom directive ignores unknown directive',
+          code: dedent`
+            const obj: { a: number; b: string; c: boolean } = { a: 1, b: 'hello', c: true };
+            // @unknown-directive
+            const { a, b } = obj;
+          `,
+          options: [{ directiveKeyword: '@custom-check' }],
+        },
+        {
+          name: 'checks React component props - parameter destructuring',
+          code: dedent`
+            type Props = { a: number; b: string };
+            const MyComponent = ({ a, b }: Props) => <div>{a}{b}</div>;
+          `,
+        },
+        {
+          name: 'checks React component props - internal destructuring',
+          code: dedent`
+            type Props = { a: number; b: string };
+            const MyComponent = (props: Props) => {
+              const { a, b } = props;
+              return <div>{a}{b}</div>;
+            };
+          `,
+        },
+        {
+          name: 'does not check React component props when disabled - parameter',
+          code: dedent`
+            type Props = { a: number; b: string; c: boolean };
+            const MyComponent = ({ a, b }: Props) => <div>{a}{b}</div>;
+          `,
+          options: [{ alwaysCheckReactComponentProps: false }],
+        },
+        {
+          name: 'does not check React component props when disabled - internal',
+          code: dedent`
+            type Props = { a: number; b: string; c: boolean };
+            const MyComponent = (props: Props) => {
+              const { a, b } = props;
+              return <div>{a}{b}</div>;
+            };
+          `,
+          options: [{ alwaysCheckReactComponentProps: false }],
+        },
+      ],
+      invalid: [
+        {
+          name: 'validates destructuring with default directive - incomplete',
+          code: dedent`
+            const obj: { a: number; b: string; c: boolean } = { a: 1, b: 'hello', c: true };
+            // @check-destructuring-completeness
+            const { a, b } = obj;
+          `,
+          errors: [{ messageId: 'incompleteDestructuring' }],
+        },
+        {
+          name: 'custom directive catches incomplete',
+          code: dedent`
+            const obj: { a: number; b: string } = { a: 1, b: 'hello' };
+            // @custom-check
+            const { a } = obj;
+          `,
+          options: [{ directiveKeyword: '@custom-check' }],
+          errors: [{ messageId: 'incompleteDestructuring' }],
+        },
+        {
+          name: 'checks React component props - parameter destructuring incomplete',
+          code: dedent`
+            type Props = { a: number; b: string; c: boolean };
+            const MyComponent = ({ a, b }: Props) => <div>{a}{b}</div>;
+          `,
+          errors: [{ messageId: 'incompleteDestructuring' }],
+        },
+        {
+          name: 'checks React component props - internal destructuring incomplete',
+          code: dedent`
+            type Props = { a: number; b: string; c: boolean };
+            const MyComponent = (props: Props) => {
+              const { a, b } = props;
+              return <div>{a}{b}</div>;
+            };
+          `,
+          errors: [{ messageId: 'incompleteDestructuring' }],
+        },
+      ],
+    },
+  );
+}, 20000);

package/src/plugins/ts-restrictions/rules/rules.mts

@@ -1,8 +1,10 @@
 import { type ESLintPlugin } from '../../../types/index.mjs';
+import { checkDestructuringCompleteness } from './check-destructuring-completeness.mjs';
 import { noRestrictedCastName } from './no-restricted-cast-name.mjs';
 import { noRestrictedSyntax } from './no-restricted-syntax.mjs';
 
 export const tsRestrictionsRules = {
+  'check-destructuring-completeness': checkDestructuringCompleteness,
   'no-restricted-cast-name': noRestrictedCastName,
   'no-restricted-syntax': noRestrictedSyntax,
 } as const satisfies ESLintPlugin['rules'];

package/src/rules/eslint-ts-restrictions-rules.mts

@@ -1,6 +1,11 @@
-import { type EslintTsRestrictionsRules } from '../types/index.mjs';
+import {
+  type EslintTsRestrictionsRules,
+  withDefaultOption,
+} from '../types/index.mjs';
 
 export const eslintTsRestrictionsRules = {
   'ts-restrictions/no-restricted-syntax': 'off',
   'ts-restrictions/no-restricted-cast-name': 'off',
+  'ts-restrictions/check-destructuring-completeness':
+    withDefaultOption('error'),
 } as const satisfies EslintTsRestrictionsRules;

package/src/types/rules/eslint-ts-restrictions-rules.mts

@@ -7,6 +7,59 @@ type SpreadOptionsIfIsArray<
   ? readonly [Linter.StringSeverity, ...T[1]]
   : T;
 
+/**
+ * Ensure all properties are destructured from an object when explicitly
+ * requested
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * ```
+ */
+namespace CheckDestructuringCompleteness {
+  /**
+   * ### schema
+   *
+   * ```json
+   * [
+   *   {
+   *     "type": "object",
+   *     "properties": {
+   *       "alwaysCheckReactComponentProps": {
+   *         "type": "boolean",
+   *         "description": "Always check React component props destructuring without directive keyword"
+   *       },
+   *       "directiveKeyword": {
+   *         "type": "string",
+   *         "description": "Custom directive keyword to enable checking (default: \"@check-destructuring-completeness\")"
+   *       }
+   *     },
+   *     "additionalProperties": false
+   *   }
+   * ]
+   * ```
+   */
+  export type Options = {
+    /**
+     * Always check React component props destructuring without directive
+     * keyword
+     */
+    readonly alwaysCheckReactComponentProps?: boolean;
+    /**
+     * Custom directive keyword to enable checking (default:
+     * "@check-destructuring-completeness")
+     */
+    readonly directiveKeyword?: string;
+  };
+
+  export type RuleEntry =
+    | Linter.Severity
+    | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>
+    | 'off';
+}
+
 /**
  * Disallow type assertions with specified type names
  *
@@ -164,11 +217,13 @@ namespace NoRestrictedSyntax {
 }
 
 export type EslintTsRestrictionsRules = {
+  readonly 'ts-restrictions/check-destructuring-completeness': CheckDestructuringCompleteness.RuleEntry;
   readonly 'ts-restrictions/no-restricted-cast-name': NoRestrictedCastName.RuleEntry;
   readonly 'ts-restrictions/no-restricted-syntax': NoRestrictedSyntax.RuleEntry;
 };
 
 export type EslintTsRestrictionsRulesOption = {
+  readonly 'ts-restrictions/check-destructuring-completeness': CheckDestructuringCompleteness.Options;
   readonly 'ts-restrictions/no-restricted-cast-name': NoRestrictedCastName.Options;
   readonly 'ts-restrictions/no-restricted-syntax': NoRestrictedSyntax.Options;
 };