eslint-config-typed 3.7.0 → 3.8.0

package/README.md

@@ -499,18 +499,20 @@ Pre-configured rule sets that can be imported and customized:
 | **`eslintImportsRules`**                   | `eslint-plugin-import-x`               | Import/export rules                                    |
 | **`eslintSecurityRules`**                  | `eslint-plugin-security`               | Security best practices                                |
 | **`eslintTreeShakableRules`**              | `eslint-plugin-tree-shakable`          | Tree-shaking optimization rules                        |
+| **`eslintStylisticRules`**                 | `@stylistic/eslint-plugin`             | Stylistic formatting rules disabled to mirror Prettier |
+| **`eslintTsRestrictionsRules`**            | `eslint-plugin-ts-restrictions`        | Restrict some syntax in TypeScript                     |
 | **`eslintReactRules`**                     | `eslint-plugin-react`                  | React-specific rules                                   |
 | **`eslintReactHooksRules`**                | `eslint-plugin-react-hooks`            | React Hooks rules                                      |
 | **`eslintReactPerfRules`**                 | `eslint-plugin-react-perf`             | React performance optimization rules                   |
 | **`eslintReactRefreshRules`**              | `eslint-plugin-react-refresh`          | React Refresh (HMR) rules                              |
 | **`eslintReactCodingStyleRules`**          | `eslint-plugin-react-coding-style`     | Opinionated React component style rules                |
-| **`eslintStylisticRules`**                 | `@stylistic/eslint-plugin`             | Stylistic formatting rules disabled to mirror Prettier |
 | **`eslintJsxA11yRules`**                   | `eslint-plugin-jsx-a11y`               | Accessibility rules for JSX                            |
 | **`eslintVitestRules`**                    | `eslint-plugin-vitest`                 | Vitest-specific rules                                  |
 | **`eslintJestRules`**                      | `eslint-plugin-jest`                   | Jest-specific rules                                    |
 | **`eslintTestingLibraryRules`**            | `eslint-plugin-testing-library`        | Testing Library rules                                  |
 | **`eslintPlaywrightRules`**                | `eslint-plugin-playwright`             | Playwright-specific rules                              |
 | **`eslintCypressRules`**                   | `eslint-plugin-cypress`                | Cypress-specific rules                                 |
+| **`eslintVitestCodingStyleRules`**         | `eslint-plugin-vitest-coding-style`    | Vitest best practices                                  |
 | **`eslintPluginRules`**                    | `eslint-plugin-eslint-plugin`          | eslint-plugin development rules                        |
 
 ### Exported Pre-configured Rule Options
@@ -607,18 +609,22 @@ Each plugin provides typed rule definitions:
     - **`EslintStrictDependenciesRules`** & **`EslintStrictDependenciesRulesOption`**
     - **`EslintSecurityRules`** (no options)
     - **`EslintTreeShakableRules`** (no options)
+    - **`EslintStylisticRules`** & **`EslintStylisticRulesOption`**
+    - **`EslintTsRestrictionsRules`** & **`EslintTsRestrictionsRulesOption`**
 - React & JSX
     - **`EslintReactRules`** & **`EslintReactRulesOption`**
     - **`EslintReactHooksRules`** & **`EslintReactHooksRulesOption`**
     - **`EslintReactPerfRules`** & **`EslintReactPerfRulesOption`**
     - **`EslintReactRefreshRules`** & **`EslintReactRefreshRulesOption`**
     - **`EslintJsxA11yRules`** & **`EslintJsxA11yRulesOption`**
+    - **`EslintReactCodingStyleRules`** & **`EslintReactCodingStyleRulesOption`**
 - Testing
     - **`EslintVitestRules`** & **`EslintVitestRulesOption`**
     - **`EslintJestRules`** & **`EslintJestRulesOption`**
     - **`EslintPlaywrightRules`** & **`EslintPlaywrightRulesOption`**
     - **`EslintCypressRules`** & **`EslintCypressRulesOption`**
     - **`EslintTestingLibraryRules`** & **`EslintTestingLibraryRulesOption`**
+    - **`EslintVitestCodingStyleRules`** (no options)
 - Others
     - **`EslintPluginRules`** & **`EslintPluginRulesOption`**
 

package/dist/configs/typescript.mjs

@@ -10,7 +10,7 @@ import { eslintSecurityRules } from '../rules/eslint-security-rules.mjs';
 import { eslintStylisticRules } from '../rules/eslint-stylistic-rules.mjs';
 import { eslintTotalFunctionsRules } from '../rules/eslint-total-functions-rules.mjs';
 import { eslintTreeShakableRules } from '../rules/eslint-tree-shakable-rules.mjs';
-import { eslintCustomRules } from '../rules/eslint-ts-restrictions-rules.mjs';
+import { eslintTsRestrictionsRules } from '../rules/eslint-ts-restrictions-rules.mjs';
 import { eslintUnicornRules } from '../rules/eslint-unicorn-rules.mjs';
 import { typescriptEslintRules } from '../rules/typescript-eslint-rules.mjs';
 import { eslintConfigForTypeScriptWithoutRules } from './typescript-without-rules.mjs';
@@ -36,7 +36,7 @@ const eslintConfigForTypeScript = ({ files, packageDirs, tsconfigFileName, tscon
             ...typescriptEslintRules,
             ...eslintTreeShakableRules,
             ...eslintPluginSortDestructureKeysRules,
-            ...eslintCustomRules,
+            ...eslintTsRestrictionsRules,
             'strict-dependencies/strict-dependencies': ['error', []],
             'import-x/no-extraneous-dependencies': [
                 'error',

package/dist/configs/typescript.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"typescript.mjs","sources":["../../src/configs/typescript.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAmBO,MAAM,yBAAyB,GAAG,CAAC,EACxC,KAAK,EACL,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,gBAAgB,GAOhB,KACA;AACE,IAAA,GAAG,qCAAqC,CAAC;QACvC,gBAAgB;QAChB,eAAe;KAChB,CAAC;AACF,IAAA;AACE,QAAA,KAAK,EAAE,KAAK,IAAI,CAAC,sCAAsC,CAAC;QACxD,KAAK,EAAE,gBAAgB,CAAC;AACtB,YAAA,GAAG,oBAAoB;AACvB,YAAA,GAAG,8BAA8B;AACjC,YAAA,GAAG,qBAAqB;AACxB,YAAA,GAAG,yBAAyB;AAC5B,YAAA,GAAG,kBAAkB;AACrB,YAAA,GAAG,kBAAkB;AACrB,YAAA,GAAG,WAAW;AACd,YAAA,GAAG,oBAAoB;AACvB,YAAA,GAAG,mBAAmB;AACtB,YAAA,GAAG,kBAAkB;AACrB,YAAA,GAAG,qBAAqB;AACxB,YAAA,GAAG,uBAAuB;AAC1B,YAAA,GAAG,oCAAoC;AACvC,YAAA,GAAG,iBAAiB;AAEpB,YAAA,yCAAyC,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC;AAExD,YAAA,qCAAqC,EAAE;gBACrC,OAAO;AACP,gBAAA;AACE,oBAAA,UAAU,EAAE,WAAW;AACxB,iBAAA;AACF,aAAA;YACD,IAAI,gBAAgB,KAAK;AACvB,kBAAE;AACE,oBAAA,iDAAiD,EAAE,KAAK;AACxD,oBAAA,2DAA2D,EACzD,KAAK;AACR;kBACD,EAAE,CAAC;SACR,CAAC;AACH,KAAA;AACD,IAAA;QACE,KAAK,EAAE,CAAC,uBAAuB,CAAC;QAChC,KAAK,EAAE,gBAAgB,CAAC;AACtB,YAAA,kDAAkD,EAAE,KAAK;AACzD,YAAA,8BAA8B,EAAE,KAAK;SACtC,CAAC;AACH,KAAA;AACD,IAAA;QACE,KAAK,EAAE,CAAC,qBAAqB,CAAC;QAC9B,KAAK,EAAE,gBAAgB,CAAC;AACtB,YAAA,2CAA2C,EAAE,KAAK;AAClD,YAAA,sBAAsB,EAAE,KAAK;SAC9B,CAAC;AACH,KAAA;AACD,IAAA;AACE,QAAA,KAAK,EAAE;;;;;;;;YASL,qCAAqC;YAErC,uCAAuC;YAEvC,4CAA4C;YAC5C,gDAAgD;YAChD,qCAAqC;AACtC,SAAA;QACD,KAAK,EAAE,gBAAgB,CAAC;AACtB,YAAA,0CAA0C,EAAE,KAAK;AACjD,YAAA,4BAA4B,EAAE,KAAK;AACnC,YAAA,sCAAsC,EAAE,KAAK;AAC7C,YAAA,8BAA8B,EAAE,KAAK;AACrC,YAAA,8BAA8B,EAAE,KAAK;AACrC,YAAA,oBAAoB,EAAE,KAAK;SAC5B,CAAC;AACH,KAAA;;;;;"}
+{"version":3,"file":"typescript.mjs","sources":["../../src/configs/typescript.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAmBO,MAAM,yBAAyB,GAAG,CAAC,EACxC,KAAK,EACL,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,gBAAgB,GAOhB,KACA;AACE,IAAA,GAAG,qCAAqC,CAAC;QACvC,gBAAgB;QAChB,eAAe;KAChB,CAAC;AACF,IAAA;AACE,QAAA,KAAK,EAAE,KAAK,IAAI,CAAC,sCAAsC,CAAC;QACxD,KAAK,EAAE,gBAAgB,CAAC;AACtB,YAAA,GAAG,oBAAoB;AACvB,YAAA,GAAG,8BAA8B;AACjC,YAAA,GAAG,qBAAqB;AACxB,YAAA,GAAG,yBAAyB;AAC5B,YAAA,GAAG,kBAAkB;AACrB,YAAA,GAAG,kBAAkB;AACrB,YAAA,GAAG,WAAW;AACd,YAAA,GAAG,oBAAoB;AACvB,YAAA,GAAG,mBAAmB;AACtB,YAAA,GAAG,kBAAkB;AACrB,YAAA,GAAG,qBAAqB;AACxB,YAAA,GAAG,uBAAuB;AAC1B,YAAA,GAAG,oCAAoC;AACvC,YAAA,GAAG,yBAAyB;AAE5B,YAAA,yCAAyC,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC;AAExD,YAAA,qCAAqC,EAAE;gBACrC,OAAO;AACP,gBAAA;AACE,oBAAA,UAAU,EAAE,WAAW;AACxB,iBAAA;AACF,aAAA;YACD,IAAI,gBAAgB,KAAK;AACvB,kBAAE;AACE,oBAAA,iDAAiD,EAAE,KAAK;AACxD,oBAAA,2DAA2D,EACzD,KAAK;AACR;kBACD,EAAE,CAAC;SACR,CAAC;AACH,KAAA;AACD,IAAA;QACE,KAAK,EAAE,CAAC,uBAAuB,CAAC;QAChC,KAAK,EAAE,gBAAgB,CAAC;AACtB,YAAA,kDAAkD,EAAE,KAAK;AACzD,YAAA,8BAA8B,EAAE,KAAK;SACtC,CAAC;AACH,KAAA;AACD,IAAA;QACE,KAAK,EAAE,CAAC,qBAAqB,CAAC;QAC9B,KAAK,EAAE,gBAAgB,CAAC;AACtB,YAAA,2CAA2C,EAAE,KAAK;AAClD,YAAA,sBAAsB,EAAE,KAAK;SAC9B,CAAC;AACH,KAAA;AACD,IAAA;AACE,QAAA,KAAK,EAAE;;;;;;;;YASL,qCAAqC;YAErC,uCAAuC;YAEvC,4CAA4C;YAC5C,gDAAgD;YAChD,qCAAqC;AACtC,SAAA;QACD,KAAK,EAAE,gBAAgB,CAAC;AACtB,YAAA,0CAA0C,EAAE,KAAK;AACjD,YAAA,4BAA4B,EAAE,KAAK;AACnC,YAAA,sCAAsC,EAAE,KAAK;AAC7C,YAAA,8BAA8B,EAAE,KAAK;AACrC,YAAA,8BAA8B,EAAE,KAAK;AACrC,YAAA,oBAAoB,EAAE,KAAK;SAC5B,CAAC;AACH,KAAA;;;;;"}

package/dist/entry-point.d.mts

@@ -1,2 +1,2 @@
-export { eslintConfigForTypeScriptWithoutRules, eslintConfigForTypeScript, eslintConfigForBrowser, eslintConfigForNodeJs, eslintConfigForReact, eslintConfigForPreact, eslintConfigForVitest, eslintConfigForJest, eslintConfigForPlaywright, eslintConfigForCypress, eslintConfigForTestingLibrary, eslintRules, typescriptEslintRules, eslintFunctionalRules, eslintTotalFunctionsRules, eslintUnicornRules, eslintArrayFuncRules, eslintPreferArrowFunctionRules, eslintPluginSortDestructureKeysRules, eslintImportsRules, eslintPromiseRules, eslintSecurityRules, eslintTreeShakableRules, eslintReactRules, eslintReactHooksRules, eslintReactPerfRules, eslintReactRefreshRules, eslintVitestRules, eslintJestRules, eslintJsxA11yRules, eslintTestingLibraryRules, eslintCypressRules, eslintPlaywrightRules, eslintPluginRules, restrictedGlobals, restrictedGlobalsForBrowser, restrictedSyntax, eslintPluginTsRestrictions, eslintPluginReactCodingStyle, eslintPluginTotalFunctions, eslintPluginTreeShakable, defineConfig, defineKnownRules, withDefaultOption, plugins, type EslintRules, type EslintRulesOption, type TypeScriptEslintRules, type TypeScriptEslintRulesOption, type EslintFunctionalRules, type EslintFunctionalRulesOption, type EslintTotalFunctionsRules, type EslintUnicornRules, type EslintUnicornRulesOption, type EslintArrayFuncRules, type EslintPreferArrowFunctionRules, type EslintPreferArrowFunctionRulesOption, type EslintPluginSortDestructureKeysRules, type EslintPluginSortDestructureKeysRulesOption, type EslintPromiseRules, type EslintPromiseRulesOption, type EslintImportsRules, type EslintImportsRulesOption, type EslintStrictDependenciesRules, type EslintStrictDependenciesRulesOption, type EslintReactCodingStyleRules, type EslintSecurityRules, type EslintTreeShakableRules, type EslintReactRules, type EslintReactRulesOption, type EslintReactHooksRules, type EslintReactHooksRulesOption, type EslintReactPerfRules, type EslintReactPerfRulesOption, type EslintReactRefreshRules, type EslintReactRefreshRulesOption, type EslintJsxA11yRules, type EslintJsxA11yRulesOption, type EslintVitestRules, type EslintVitestRulesOption, type EslintJestRules, type EslintJestRulesOption, type EslintPlaywrightRules, type EslintPlaywrightRulesOption, type EslintCypressRules, type EslintCypressRulesOption, type EslintTestingLibraryRules, type EslintTestingLibraryRulesOption, type EslintPluginRules, type EslintPluginRulesOption, type FlatConfig, type ESLintPlugin, type Rule, type Rules, } from './index.mjs';
+export { eslintConfigForTypeScriptWithoutRules, eslintConfigForTypeScript, eslintConfigForBrowser, eslintConfigForNodeJs, eslintConfigForReact, eslintConfigForPreact, eslintConfigForVitest, eslintConfigForJest, eslintConfigForPlaywright, eslintConfigForCypress, eslintConfigForTestingLibrary, eslintRules, typescriptEslintRules, eslintFunctionalRules, eslintTotalFunctionsRules, eslintUnicornRules, eslintArrayFuncRules, eslintPreferArrowFunctionRules, eslintPluginSortDestructureKeysRules, eslintImportsRules, eslintPromiseRules, eslintSecurityRules, eslintTreeShakableRules, eslintReactRules, eslintReactHooksRules, eslintReactPerfRules, eslintReactRefreshRules, eslintVitestRules, eslintJestRules, eslintJsxA11yRules, eslintTestingLibraryRules, eslintCypressRules, eslintPlaywrightRules, eslintPluginRules, eslintTsRestrictionsRules, eslintReactCodingStyleRules, eslintStylisticRules, eslintVitestCodingStyleRules, restrictedGlobals, restrictedGlobalsForBrowser, restrictedSyntax, eslintPluginTotalFunctions, eslintPluginTreeShakable, eslintPluginStrictDependencies, eslintPluginTsRestrictions, eslintPluginVitestCodingStyle, eslintPluginReactCodingStyle, defineConfig, defineKnownRules, withDefaultOption, plugins, type EslintRules, type EslintRulesOption, type TypeScriptEslintRules, type TypeScriptEslintRulesOption, type EslintFunctionalRules, type EslintFunctionalRulesOption, type EslintTotalFunctionsRules, type EslintUnicornRules, type EslintUnicornRulesOption, type EslintArrayFuncRules, type EslintPreferArrowFunctionRules, type EslintPreferArrowFunctionRulesOption, type EslintPluginSortDestructureKeysRules, type EslintPluginSortDestructureKeysRulesOption, type EslintPromiseRules, type EslintPromiseRulesOption, type EslintImportsRules, type EslintImportsRulesOption, type EslintStrictDependenciesRules, type EslintStrictDependenciesRulesOption, type EslintReactCodingStyleRules, type EslintReactCodingStyleRulesOption, type EslintSecurityRules, type EslintTreeShakableRules, type EslintReactRules, type EslintReactRulesOption, type EslintReactHooksRules, type EslintReactHooksRulesOption, type EslintReactPerfRules, type EslintReactPerfRulesOption, type EslintReactRefreshRules, type EslintReactRefreshRulesOption, type EslintJsxA11yRules, type EslintJsxA11yRulesOption, type EslintVitestRules, type EslintVitestRulesOption, type EslintJestRules, type EslintJestRulesOption, type EslintPlaywrightRules, type EslintPlaywrightRulesOption, type EslintCypressRules, type EslintCypressRulesOption, type EslintTestingLibraryRules, type EslintTestingLibraryRulesOption, type EslintPluginRules, type EslintPluginRulesOption, type EslintStylisticRules, type EslintStylisticRulesOption, type EslintTsRestrictionsRules, type EslintTsRestrictionsRulesOption, type EslintVitestCodingStyleRules, type FlatConfig, type ESLintPlugin, type Rule, type Rules, } from './index.mjs';
 //# sourceMappingURL=entry-point.d.mts.map

package/dist/entry-point.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point.d.mts","sourceRoot":"","sources":["../src/entry-point.mts"],"names":[],"mappings":"AACA,OAAO,EAEL,qCAAqC,EACrC,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,EACzB,sBAAsB,EACtB,6BAA6B,EAG7B,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,kBAAkB,EAClB,oBAAoB,EACpB,8BAA8B,EAC9B,oCAAoC,EACpC,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EAGjB,iBAAiB,EACjB,2BAA2B,EAC3B,gBAAgB,EAGhB,0BAA0B,EAC1B,4BAA4B,EAC5B,0BAA0B,EAC1B,wBAAwB,EAGxB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EAGjB,OAAO,EAGP,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,8BAA8B,EACnC,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,0CAA0C,EAC/C,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EAClC,KAAK,mCAAmC,EACxC,KAAK,2BAA2B,EAChC,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,+BAA+B,EACpC,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAG5B,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,IAAI,EACT,KAAK,KAAK,GACX,MAAM,aAAa,CAAC"}
+{"version":3,"file":"entry-point.d.mts","sourceRoot":"","sources":["../src/entry-point.mts"],"names":[],"mappings":"AACA,OAAO,EAEL,qCAAqC,EACrC,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,EACzB,sBAAsB,EACtB,6BAA6B,EAG7B,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,kBAAkB,EAClB,oBAAoB,EACpB,8BAA8B,EAC9B,oCAAoC,EACpC,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EACjB,yBAAyB,EACzB,2BAA2B,EAC3B,oBAAoB,EACpB,4BAA4B,EAG5B,iBAAiB,EACjB,2BAA2B,EAC3B,gBAAgB,EAGhB,0BAA0B,EAC1B,wBAAwB,EACxB,8BAA8B,EAC9B,0BAA0B,EAC1B,6BAA6B,EAC7B,4BAA4B,EAG5B,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EAGjB,OAAO,EAGP,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,8BAA8B,EACnC,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,0CAA0C,EAC/C,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EAClC,KAAK,mCAAmC,EACxC,KAAK,2BAA2B,EAChC,KAAK,iCAAiC,EACtC,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC5B,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,+BAA+B,EACpC,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,EAGjC,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,IAAI,EACT,KAAK,KAAK,GACX,MAAM,aAAa,CAAC"}

package/dist/entry-point.mjs

@@ -16,17 +16,20 @@ export { eslintPluginRules } from './rules/eslint-plugin-rules.mjs';
 export { eslintPluginSortDestructureKeysRules } from './rules/eslint-plugin-sort-destructure-keys-rules.mjs';
 export { eslintPreferArrowFunctionRules } from './rules/eslint-prefer-arrow-functions-rules.mjs';
 export { eslintPromiseRules } from './rules/eslint-promise-rules.mjs';
+export { eslintReactCodingStyleRules } from './rules/eslint-react-coding-style-rules.mjs';
 export { eslintReactHooksRules } from './rules/eslint-react-hooks-rules.mjs';
 export { eslintReactPerfRules } from './rules/eslint-react-perf-rules.mjs';
 export { eslintReactRefreshRules } from './rules/eslint-react-refresh-rules.mjs';
 export { eslintReactRules } from './rules/eslint-react-rules.mjs';
 export { eslintRules, restrictedGlobals, restrictedGlobalsForBrowser, restrictedSyntax } from './rules/eslint-rules.mjs';
 export { eslintSecurityRules } from './rules/eslint-security-rules.mjs';
-import './rules/eslint-stylistic-rules.mjs';
+export { eslintStylisticRules } from './rules/eslint-stylistic-rules.mjs';
 export { eslintTestingLibraryRules } from './rules/eslint-testing-library-rules.mjs';
 export { eslintTotalFunctionsRules } from './rules/eslint-total-functions-rules.mjs';
 export { eslintTreeShakableRules } from './rules/eslint-tree-shakable-rules.mjs';
+export { eslintTsRestrictionsRules } from './rules/eslint-ts-restrictions-rules.mjs';
 export { eslintUnicornRules } from './rules/eslint-unicorn-rules.mjs';
+export { eslintVitestCodingStyleRules } from './rules/eslint-vitest-coding-style-rules.mjs';
 export { eslintVitestRules } from './rules/eslint-vitest-rules.mjs';
 export { typescriptEslintRules } from './rules/typescript-eslint-rules.mjs';
 export { defineConfig } from './types/define-config.mjs';
@@ -38,13 +41,9 @@ export { eslintConfigForTypeScriptWithoutRules } from './configs/typescript-with
 export { eslintConfigForTypeScript } from './configs/typescript.mjs';
 export { eslintConfigForVitest } from './configs/vitest.mjs';
 export { eslintPluginReactCodingStyle } from './plugins/react-coding-style/plugin.mjs';
-import 'is-glob';
-import 'micromatch';
-import 'node:path';
-import 'ts-data-forge';
-import 'typescript';
+export { eslintPluginStrictDependencies } from './plugins/strict-dependencies/plugin.mjs';
 export { eslintPluginTotalFunctions } from './plugins/total-functions/plugin.mjs';
 export { eslintPluginTreeShakable } from './plugins/tree-shakable/plugin.mjs';
 export { eslintPluginTsRestrictions } from './plugins/ts-restrictions/plugin.mjs';
-import '@typescript-eslint/utils';
+export { eslintPluginVitestCodingStyle } from './plugins/vitest-coding-style/plugin.mjs';
 //# sourceMappingURL=entry-point.mjs.map

package/dist/entry-point.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.mjs

@@ -40,7 +40,7 @@ export { eslintStylisticRules } from './rules/eslint-stylistic-rules.mjs';
 export { eslintTestingLibraryRules } from './rules/eslint-testing-library-rules.mjs';
 export { eslintTotalFunctionsRules } from './rules/eslint-total-functions-rules.mjs';
 export { eslintTreeShakableRules } from './rules/eslint-tree-shakable-rules.mjs';
-export { eslintCustomRules } from './rules/eslint-ts-restrictions-rules.mjs';
+export { eslintTsRestrictionsRules } from './rules/eslint-ts-restrictions-rules.mjs';
 export { eslintUnicornRules } from './rules/eslint-unicorn-rules.mjs';
 export { eslintVitestCodingStyleRules } from './rules/eslint-vitest-coding-style-rules.mjs';
 export { eslintVitestRules } from './rules/eslint-vitest-rules.mjs';

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 eslintCustomRules: {
+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,iBAAiB;;;CAGgB,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,7 +1,10 @@
-const eslintCustomRules = {
+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 { eslintCustomRules };
+export { eslintTsRestrictionsRules };
 //# sourceMappingURL=eslint-ts-restrictions-rules.mjs.map

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,iBAAiB,GAAG;AAC/B,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/rules/index.mjs

@@ -21,7 +21,7 @@ export { eslintStylisticRules } from './eslint-stylistic-rules.mjs';
 export { eslintTestingLibraryRules } from './eslint-testing-library-rules.mjs';
 export { eslintTotalFunctionsRules } from './eslint-total-functions-rules.mjs';
 export { eslintTreeShakableRules } from './eslint-tree-shakable-rules.mjs';
-export { eslintCustomRules } from './eslint-ts-restrictions-rules.mjs';
+export { eslintTsRestrictionsRules } from './eslint-ts-restrictions-rules.mjs';
 export { eslintUnicornRules } from './eslint-unicorn-rules.mjs';
 export { eslintVitestCodingStyleRules } from './eslint-vitest-coding-style-rules.mjs';
 export { eslintVitestRules } from './eslint-vitest-rules.mjs';

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.0",
+  "version": "3.8.0",
   "private": false,
   "keywords": [
     "typescript"

package/src/configs/typescript.mts

@@ -1,6 +1,5 @@
 import {
   eslintArrayFuncRules,
-  eslintCustomRules,
   eslintFunctionalRules,
   eslintImportsRules,
   eslintPluginSortDestructureKeysRules,
@@ -11,6 +10,7 @@ import {
   eslintStylisticRules,
   eslintTotalFunctionsRules,
   eslintTreeShakableRules,
+  eslintTsRestrictionsRules,
   eslintUnicornRules,
   typescriptEslintRules,
 } from '../rules/index.mjs';
@@ -51,7 +51,7 @@ export const eslintConfigForTypeScript = ({
         ...typescriptEslintRules,
         ...eslintTreeShakableRules,
         ...eslintPluginSortDestructureKeysRules,
-        ...eslintCustomRules,
+        ...eslintTsRestrictionsRules,
 
         'strict-dependencies/strict-dependencies': ['error', []],
 

package/src/entry-point.mts

@@ -37,6 +37,10 @@ export {
   eslintCypressRules,
   eslintPlaywrightRules,
   eslintPluginRules,
+  eslintTsRestrictionsRules,
+  eslintReactCodingStyleRules,
+  eslintStylisticRules,
+  eslintVitestCodingStyleRules,
 
   // Pre-configured rule options
   restrictedGlobals,
@@ -44,10 +48,12 @@ export {
   restrictedSyntax,
 
   // Custom plugins
-  eslintPluginTsRestrictions,
-  eslintPluginReactCodingStyle,
   eslintPluginTotalFunctions,
   eslintPluginTreeShakable,
+  eslintPluginStrictDependencies,
+  eslintPluginTsRestrictions,
+  eslintPluginVitestCodingStyle,
+  eslintPluginReactCodingStyle,
 
   // Utilities
   defineConfig,
@@ -79,6 +85,7 @@ export {
   type EslintStrictDependenciesRules,
   type EslintStrictDependenciesRulesOption,
   type EslintReactCodingStyleRules,
+  type EslintReactCodingStyleRulesOption,
   type EslintSecurityRules,
   type EslintTreeShakableRules,
   type EslintReactRules,
@@ -103,6 +110,11 @@ export {
   type EslintTestingLibraryRulesOption,
   type EslintPluginRules,
   type EslintPluginRulesOption,
+  type EslintStylisticRules,
+  type EslintStylisticRulesOption,
+  type EslintTsRestrictionsRules,
+  type EslintTsRestrictionsRulesOption,
+  type EslintVitestCodingStyleRules,
 
   // Utility types
   type FlatConfig,

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 eslintCustomRules = {
+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;
 };