eslint-plugin-func-params-args 3.0.0 → 4.0.0

package/README.md

@@ -1,242 +1,235 @@
-# eslint-plugin-func-params-args
-
-Limit the number of function parameters and arguments with ease and flexibility!
-
-This plugin intends to give you control over how many parameters are used in function definitions (declarations), function expressions, and arrow function expressions. In addition to this, you can also set limits on how many arguments can be used when calling functions, where you can set a global limit, and have even finer control by providing limits for specific function calls (set by configuring/providing the name of a function).
-
-[![Travis (.com) branch](https://img.shields.io/travis/com/abdusabri/eslint-plugin-func-params-args/master)](https://app.travis-ci.com/github/abdusabri/eslint-plugin-func-params-args) [![Coveralls github branch](https://img.shields.io/coveralls/github/abdusabri/eslint-plugin-func-params-args/master?logo=coveralls&style=flat-square)](https://coveralls.io/github/abdusabri/eslint-plugin-func-params-args) ![Depfu](https://img.shields.io/depfu/abdusabri/eslint-plugin-func-params-args?style=flat-square)
-
-## Table of contents
-
-- [Why](#why)
-
-- [Installation](#installation)
-
-- [General usage notes](#general-usage-notes)
-
-  - [No defaults](#no-defaults)
-
-  - [Non-JavaScript files](#non-javascript-files)
-
-- [Available rules](#available-rules)
-
-- [What is next](#what-is-next)
-
-- [Contributing](#contributing)
-
-  - [General guidelines](#general-guidelines)
-
-  - [Development guidelines](#general-guidelines)
-
-- [Code of conduct](#code-of-conduct)
-
-- [Inspiration and credits](#Inspiration-and-credits)
-
-## Why
-
-This plugin has two rules, one for parameters (when defining functions or expressions), and one for arguments when calling functions (including built-in or 3rd party functions). Why each?
-
-- **Function Parameters:** ESLint has its own `max-params` rule, but it only provides one global setting, and that's not flexible enough. Let's say we need to call `array.reduce`, where sometimes there is a need to use all of the 4 arguments provided to the reducer callback in an arrow function expression (like `array.reduce((acc, val, index, arr) => {}, {})` for example). Using the built-in `max-params`, we would need to set it to 4 and that would be the global limit. This plugin's rule (`func-params`) allows for more flexibility when handling such cases. One approach would be to set the global setting for (`func-params`) to 3, and override this value to allow arrow function expressions to have 4 parameters instead of 3
-
-- **Function Arguments:** The role of the first rule ends when defining functions or expressions, but what about calling functions, especially 3rd party or built-in functions? Let's take migrating from Vue v2 to v3 as an example. Vue v3 recommends using a library called `mitt` as an event bus implementation. Vue v2's own implementation allows more than 2 arguments to be used (passed in) when emitting events (`$emit`), however, `mitt`'s implementation only accepts 2 arguments. So, to help with doing such migration, we can use this plugin's rule (`func-args`) to allow only 2 arguments to be used whenever `$emit` is called. Of course this is only an example, and this rule is flexible to cover any user-configured named function calls - that's in addition to a global limit as well
-
-## Installation
-
-If you don't already have [ESLint](http://eslint.org) installed, you'll first need to install it:
-
-```shell
-npm install eslint --save-dev
-
-# or yarn add eslint --dev
-```
-
-Next, install `eslint-plugin-func-params-args`:
-
-```shell
-npm install eslint-plugin-func-params-args --save-dev
-
-# or yarn add eslint-plugin-func-params-args --dev
-```
-
-## General usage notes
-
-Add `func-params-args` to the plugins section of your `.eslintrc.json` configuration file. You can omit the `eslint-plugin-` prefix:
-
-```json
-{
-  "plugins": ["func-params-args"]
-}
-```
-
-Or `.eslintrc.yml`
-
-```yml
-plugins:
-  - func-params-args
-```
-
-Then configure the rules you want to use under the rules section.
-
-(`json`)
-
-```json
-{
-  "rules": {
-    "func-params-args/func-args": [
-      "warn",
-      {
-        "global": 3,
-        "$emit": 2
-      }
-    ]
-  }
-}
-```
-
-Or (`yml`)
-
-```yml
-rules:
-  func-params-args/func-args:
-    - 'warn'
-    - 'global': 3
-      '$emit': 2
-```
-
-As shown in the example above, the configuration approach for this plugin's rules uses a simple object structure (no arrays or nested objects), where keys like `$emit` are the options, and the value of a given key is the limit (like `2`). So, in the example above, it means that any calls to `$emit` function should have no more than `2` arguments, and the global limit for any other function call is `3`.
-
-### No defaults
-
-By design, this plugin's rules don't have pre-set defaults. So, you've to configure them as shown in the example above and as explained in details in the docs of each rule ([Available rules](#available-rules)).
-
-### Non-JavaScript files
-
-ESLint's eco-system is full of parsers and plugins taking care of non-JavaScript files, like TypeScript and JSX for example. This plugin doesn't provide its own parser (nor does it have a custom AST parsing logic). So, handling non-JS files depends on your existing ESLint setup.
-
-As an example, to use this plugin in TS files, you may configure parsing options in your `.eslintrc` file as follows:
-
-If you don't have any existing parsers (or other plugins that are already taking care of handling TS files)
-
-```json
-"parser": "@typescript-eslint/parser"
-```
-
-Or you may override only the parsing of TS files if you've other parsers or plugins that are doing their own parsing
-
-```json
-"overrides": [
-  {
-    "files": "*.ts",
-    "parser": "@typescript-eslint/parser"
-  }
-]
-```
-
-In both examples above, you would need to install `@typescript-eslint/parser` from npm.
-
-## Available rules
-
-- [enforce the number of parameters used in a function definition or expression (func-params)](./docs/rules/func-params.md)
-
-- [enforce the number of arguments used in a function call (func-args)](./docs/rules/func-args.md)
-
-## What is next
-
-In general, all feedback is welcome, and I would love to get more ideas and contributions to make this project better. As of now, here are a few items I can think of:
-
-- Instead of only setting a value as an upper limit when configuring a rule, let's say 3 parameters or arguments max, would setting a min limit as well be a useful addition? Maybe for some function calls you want to allow between 1-3 arguments, but not without any arguments and not with more than 3
-
-- Add more examples on how to handle non-JS files, like `.vue` files for instance
-
-- Currently, in `func-params` rule, when there is an error reported, in addition to the code location (file and line number), an error message like `function has too many parameters (3). Maximum allowed is (2).` is reported. An improvement would be to report the name of the function (or the variable name in the case of a function expression) in the message instead of the generic `function`. For example, a message like `function has too many parameters...` could be `handleSubmit has too many parameters...` instead
-
-- Consider adding options for pattern matching. Maybe as a start, support `startsWith` and `endsWith` options. Could be useful if you use or have Node-style function names that end with a specific pattern like `[whatever]Sync` or `[whatever]Async`
-
-- Adopt the [all-contributors](https://github.com/all-contributors/all-contributors) specification for recognizing contributors
-
-## Contributing
-
-If you want to report a bug, request a feature, or ask questions, please feel free to open a new issue.
-
-All contributions are welcome and appreciated. If you want to help out, please follow the guidelines outlined below. The objective is to ensure that your time and effort are will spent, and to avoid a situation where you might spend time on something that someone else is already working on. Contributors time is valuable, and I hope these guidelines ensure that we can make the best out of it 🙏
-
-### General guidelines
-
-- Working on your first Pull Request? You can learn how from this free series [How to Contribute to an Open Source Project on GitHub](https://egghead.io/courses/how-to-contribute-to-an-open-source-project-on-github) - Thanks to [Kent C. Dodds](https://github.com/kentcdodds)
-
-- Please follow [this guide for your commit messages](https://chris.beams.io/posts/git-commit/). Though the recommended length of the subject line is 50, it is fine to go up to 72 if you need to
-
-- For documentation improvements or fixing typos, feel free to open a PR without an existing issue. Otherwise, please follow the development guidelines outlined below
-
-#### Documentation notes
-
-- You may sometimes find open issues related to documentation. Such issues will have `documentation` label
-
-- For minor documentation updates or fixing typos, it is usually fine to do so directly on GitHub website. For large documentation updates, it is recommended to clone the repo and ensure that the project dependencies are installed (by running `npm install` or `yarn`). This is because [Prettier](https://prettier.io/) is used to ensure consistent style/formatting in the docs (all `.md` files), and having the dependencies installed will automatically fix style/formatting issues upon committing
-
-### Development guidelines
-
-- If you are new to ESLint plugin development, the resources in [Inspiration and credits](#inspiration-and-credits) should help you get started
-
-- Check open issues to see if an existing one is already addressing what you want to contribute/help with, or if there is one that is interesting for you to work on. If you want to work on (grab) an existing issue, please ensure that it has the label `up for grabs`, and comment on it to signal your interest. I will then assign the issue to you and add the `assigned` label to it (will remove `up for grabs` as well). [Here is a link to open issues that are up for grabs](https://github.com/abdusabri/eslint-plugin-func-params-args/labels/up%20for%20grabs)
-
-- If you don't find an existing issue addressing what you want to contribute/help with, create a new issue and include a short description
-
-- If the changes you are working on require documentation updates, please update the docs accordingly
-
-- When you are ready to open a PR (all pull requests should be opened against master branch):
-
-  - Add a summary explaining your changes
-
-  - Add `Fixes #[issue number]` or `Closes #[issue number]` in the PR description
-
-- Here is [a nice article](https://medium.engineering/the-code-review-mindset-3280a4af0a89) about code reviews that I found helpful. Knew about it from [Automattic's Calypso contributing guide](https://github.com/Automattic/wp-calypso/blob/master/docs/CONTRIBUTING.md)
-
-#### Development notes
-
-- Please run `npm install` or `yarn` to ensure that the required dev dependencies are properly installed
-
-- The target for test coverage is `100%`. If not met, a PR will fail on CI (Travis Continuous Integration). You can run `npm run test` locally as well
-
-- The project uses Prettier for code formatting and style, and there is a pre-commit hook that auto-fixes any code style issues. This is also checked and will fail on CI if there are issues reported by Prettier
-
-## Code of conduct
-
-This project adopts Contributor Covenant's Code of Conduct. You can read it in full [here](./CODE_OF_CONDUCT.md), which has my email address included.
-
-## Inspiration and credits
-
-This work wouldn't have been possible without the power of open source and people who share their knowledge and experiences. Following are some sources of inspiration and references that helped me while creating this plugin/project.
-
-- [@gitlab/eslint-plugin](https://gitlab.com/gitlab-org/frontend/eslint-plugin), especially [this Merge Request (MR)](https://gitlab.com/gitlab-org/frontend/eslint-plugin/-/merge_requests/19) and [my MR](https://gitlab.com/gitlab-org/frontend/eslint-plugin/-/merge_requests/20) :)
-
-- [AST explorer](https://astexplorer.net/)
-
-- ESLint's developer guide, especially [Working with Plugins](https://eslint.org/docs/developer-guide/working-with-plugins) and [Working with Rules
-  ](https://eslint.org/docs/developer-guide/working-with-rules)
-
-- ESlint's [max-params rule](https://eslint.org/docs/rules/max-params#enforce-a-maximum-number-of-parameters-in-function-definitions-max-params), and its linked sources on GitHub
-
-- [eslint-plugin-import](https://github.com/benmosher/eslint-plugin-import)
-
-- [You-Dont-Need-Lodash-Underscore](https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore)
-
-- Articles and Q&A
-
-  - [Create custom ESLint rules in 2 minutes](https://blog.webiny.com/create-custom-eslint-rules-in-2-minutes-e3d41cb6a9a0)
-
-  - [Writing custom EsLint rules](https://www.kenneth-truyers.net/2016/05/27/writing-custom-eslint-rules/)
-
-  - [How To Write Your First ESLint Plugin](https://dev.to/spukas/how-to-write-your-first-eslint-plugin-145)
-
-  - [I can't make my custom eslint rule to work](https://stackoverflow.com/questions/60750019/i-cant-make-my-custom-eslint-rule-to-work)
-
-  - [Writing Custom Lint Rules for Your Picky Developers](https://flexport.engineering/writing-custom-lint-rules-for-your-picky-developers-67732afa1803)
-
-  - [Creating an ESLint Plugin](https://medium.com/@bjrnt/creating-an-eslint-plugin-87f1cb42767f)
-
-- This course [Creating an Open Source JavaScript Library on Github](https://frontendmasters.com/courses/open-source/), and its associated [GitHub repo](https://github.com/kentcdodds/starwars-names)
-
-- This course [Code Transformation and Linting with ASTs](https://frontendmasters.com/courses/linting-asts/)
-
-- Badges from [shields.io](https://shields.io/)
+# eslint-plugin-func-params-args
+
+Limit the number of function parameters and arguments with ease and flexibility!
+
+This plugin intends to give you control over how many parameters are used in function definitions (declarations), function expressions, arrow function expressions, and TypeScript function type annotations. In addition to this, you can also set limits on how many arguments can be used when calling functions, where you can set a global limit, and have even finer control by providing limits for specific function calls (set by configuring/providing the name of a function).
+
+[![Travis (.com) branch](https://img.shields.io/travis/com/abdusabri/eslint-plugin-func-params-args/master)](https://app.travis-ci.com/github/abdusabri/eslint-plugin-func-params-args) [![Coveralls github branch](https://img.shields.io/coveralls/github/abdusabri/eslint-plugin-func-params-args/master?logo=coveralls&style=flat-square)](https://coveralls.io/github/abdusabri/eslint-plugin-func-params-args) ![Depfu](https://img.shields.io/depfu/abdusabri/eslint-plugin-func-params-args?style=flat-square)
+
+## Table of contents
+
+- [eslint-plugin-func-params-args](#eslint-plugin-func-params-args)
+  - [Table of contents](#table-of-contents)
+  - [Why](#why)
+  - [Installation](#installation)
+  - [General usage notes](#general-usage-notes)
+    - [No defaults](#no-defaults)
+    - [Non-JavaScript files](#non-javascript-files)
+  - [Available rules](#available-rules)
+  - [What is next](#what-is-next)
+  - [Contributing](#contributing)
+    - [General guidelines](#general-guidelines)
+      - [Documentation notes](#documentation-notes)
+    - [Development guidelines](#development-guidelines)
+      - [Development notes](#development-notes)
+  - [Code of conduct](#code-of-conduct)
+  - [Inspiration and credits](#inspiration-and-credits)
+
+## Why
+
+This plugin has two rules, one for parameters (when defining functions or expressions), and one for arguments when calling functions (including built-in or 3rd party functions). Why each?
+
+- **Function Parameters:** ESLint has its own `max-params` rule, but it only provides one global setting, and that's not flexible enough. Let's say we need to call `array.reduce`, where sometimes there is a need to use all of the 4 arguments provided to the reducer callback in an arrow function expression (like `array.reduce((acc, val, index, arr) => {}, {})` for example). Using the built-in `max-params`, we would need to set it to 4 and that would be the global limit. This plugin's rule (`func-params`) allows for more flexibility when handling such cases. One approach would be to set the global setting for (`func-params`) to 3, and override this value to allow arrow function expressions to have 4 parameters instead of 3
+
+- **Function Arguments:** The role of the first rule ends when defining functions or expressions, but what about calling functions, especially 3rd party or built-in functions? Let's take migrating from Vue v2 to v3 as an example. Vue v3 recommends using a library called `mitt` as an event bus implementation. Vue v2's own implementation allows more than 2 arguments to be used (passed in) when emitting events (`$emit`), however, `mitt`'s implementation only accepts 2 arguments. So, to help with doing such migration, we can use this plugin's rule (`func-args`) to allow only 2 arguments to be used whenever `$emit` is called. Of course this is only an example, and this rule is flexible to cover any user-configured named function calls - that's in addition to a global limit as well
+
+## Installation
+
+If you don't already have [ESLint](http://eslint.org) installed, you'll first need to install it:
+
+```shell
+npm install eslint --save-dev
+
+# or yarn add eslint --dev
+```
+
+Next, install `eslint-plugin-func-params-args`:
+
+```shell
+npm install eslint-plugin-func-params-args --save-dev
+
+# or yarn add eslint-plugin-func-params-args --dev
+```
+
+## General usage notes
+
+Add `func-params-args` to the plugins section of your `.eslintrc.json` configuration file. You can omit the `eslint-plugin-` prefix:
+
+```json
+{
+  "plugins": ["func-params-args"]
+}
+```
+
+Or `.eslintrc.yml`
+
+```yml
+plugins:
+  - func-params-args
+```
+
+Then configure the rules you want to use under the rules section.
+
+(`json`)
+
+```json
+{
+  "rules": {
+    "func-params-args/func-args": [
+      "warn",
+      {
+        "global": 3,
+        "$emit": 2
+      }
+    ]
+  }
+}
+```
+
+Or (`yml`)
+
+```yml
+rules:
+  func-params-args/func-args:
+    - 'warn'
+    - 'global': 3
+      '$emit': 2
+```
+
+As shown in the example above, the configuration approach for this plugin's rules uses a simple object structure (no arrays or nested objects), where keys like `$emit` are the options, and the value of a given key is the limit (like `2`). So, in the example above, it means that any calls to `$emit` function should have no more than `2` arguments, and the global limit for any other function call is `3`.
+
+### No defaults
+
+By design, this plugin's rules don't have pre-set defaults. So, you've to configure them as shown in the example above and as explained in details in the docs of each rule ([Available rules](#available-rules)).
+
+### Non-JavaScript files
+
+ESLint's eco-system is full of parsers and plugins taking care of non-JavaScript files, like TypeScript and JSX for example. This plugin doesn't provide its own parser (nor does it have a custom AST parsing logic). So, handling non-JS files depends on your existing ESLint setup.
+
+As an example, to use this plugin in TS files, you may configure parsing options in your `.eslintrc` file as follows:
+
+If you don't have any existing parsers (or other plugins that are already taking care of handling TS files)
+
+```json
+"parser": "@typescript-eslint/parser"
+```
+
+Or you may override only the parsing of TS files if you've other parsers or plugins that are doing their own parsing
+
+```json
+"overrides": [
+  {
+    "files": "*.ts",
+    "parser": "@typescript-eslint/parser"
+  }
+]
+```
+
+In both examples above, you would need to install `@typescript-eslint/parser` from npm.
+
+## Available rules
+
+- [enforce the number of parameters used in a function definition or expression (func-params)](./docs/rules/func-params.md)
+
+- [enforce the number of arguments used in a function call (func-args)](./docs/rules/func-args.md)
+
+## What is next
+
+In general, all feedback is welcome, and I would love to get more ideas and contributions to make this project better. As of now, here are a few items I can think of:
+
+- Instead of only setting a value as an upper limit when configuring a rule, let's say 3 parameters or arguments max, would setting a min limit as well be a useful addition? Maybe for some function calls you want to allow between 1-3 arguments, but not without any arguments and not with more than 3
+
+- Add more examples on how to handle non-JS files, like `.vue` files for instance
+
+- ~~Currently, in `func-params` rule, when there is an error reported, in addition to the code location (file and line number), an error message like `function has too many parameters (3). Maximum allowed is (2).` is reported. An improvement would be to report the name of the function (or the variable name in the case of a function expression) in the message instead of the generic `function`. For example, a message like `function has too many parameters...` could be `handleSubmit has too many parameters...` instead~~ **Added in v3**
+
+- Consider adding options for pattern matching. Maybe as a start, support `startsWith` and `endsWith` options. Could be useful if you use or have Node-style function names that end with a specific pattern like `[whatever]Sync` or `[whatever]Async`
+
+- Adopt the [all-contributors](https://github.com/all-contributors/all-contributors) specification for recognizing contributors
+
+## Contributing
+
+If you want to report a bug, request a feature, or ask questions, please feel free to open a new issue.
+
+All contributions are welcome and appreciated. If you want to help out, please follow the guidelines outlined below. The objective is to ensure that your time and effort are will spent, and to avoid a situation where you might spend time on something that someone else is already working on. Contributors time is valuable, and I hope these guidelines ensure that we can make the best out of it 🙏
+
+### General guidelines
+
+- Working on your first Pull Request? You can learn how from this free series [How to Contribute to an Open Source Project on GitHub](https://egghead.io/courses/how-to-contribute-to-an-open-source-project-on-github) - Thanks to [Kent C. Dodds](https://github.com/kentcdodds)
+
+- Please follow [this guide for your commit messages](https://chris.beams.io/posts/git-commit/). Though the recommended length of the subject line is 50, it is fine to go up to 72 if you need to
+
+- For documentation improvements or fixing typos, feel free to open a PR without an existing issue. Otherwise, please follow the development guidelines outlined below
+
+#### Documentation notes
+
+- You may sometimes find open issues related to documentation. Such issues will have `documentation` label
+
+- For minor documentation updates or fixing typos, it is usually fine to do so directly on GitHub website. For large documentation updates, it is recommended to clone the repo and ensure that the project dependencies are installed (by running `npm install` or `yarn`). This is because [Prettier](https://prettier.io/) is used to ensure consistent style/formatting in the docs (all `.md` files), and having the dependencies installed will automatically fix style/formatting issues upon committing
+
+### Development guidelines
+
+- If you are new to ESLint plugin development, the resources in [Inspiration and credits](#inspiration-and-credits) should help you get started
+
+- Check open issues to see if an existing one is already addressing what you want to contribute/help with, or if there is one that is interesting for you to work on. If you want to work on (grab) an existing issue, please ensure that it has the label `up for grabs`, and comment on it to signal your interest. I will then assign the issue to you and add the `assigned` label to it (will remove `up for grabs` as well). [Here is a link to open issues that are up for grabs](https://github.com/abdusabri/eslint-plugin-func-params-args/labels/up%20for%20grabs)
+
+- If you don't find an existing issue addressing what you want to contribute/help with, create a new issue and include a short description
+
+- If the changes you are working on require documentation updates, please update the docs accordingly
+
+- When you are ready to open a PR (all pull requests should be opened against master branch):
+
+  - Add a summary explaining your changes
+
+  - Add `Fixes #[issue number]` or `Closes #[issue number]` in the PR description
+
+- Here is [a nice article](https://medium.engineering/the-code-review-mindset-3280a4af0a89) about code reviews that I found helpful. Knew about it from [Automattic's Calypso contributing guide](https://github.com/Automattic/wp-calypso/blob/master/docs/CONTRIBUTING.md)
+
+#### Development notes
+
+- Please run `npm install` or `yarn` to ensure that the required dev dependencies are properly installed
+
+- The target for test coverage is `100%`. If not met, a PR will fail on CI (Travis Continuous Integration). You can run `npm run test` locally as well
+
+- The project uses Prettier for code formatting and style, and there is a pre-commit hook that auto-fixes any code style issues. This is also checked and will fail on CI if there are issues reported by Prettier
+
+## Code of conduct
+
+This project adopts Contributor Covenant's Code of Conduct. You can read it in full [here](./CODE_OF_CONDUCT.md), which has my email address included.
+
+## Inspiration and credits
+
+This work wouldn't have been possible without the power of open source and people who share their knowledge and experiences. Following are some sources of inspiration and references that helped me while creating this plugin/project.
+
+- [@gitlab/eslint-plugin](https://gitlab.com/gitlab-org/frontend/eslint-plugin), especially [this Merge Request (MR)](https://gitlab.com/gitlab-org/frontend/eslint-plugin/-/merge_requests/19) and [my MR](https://gitlab.com/gitlab-org/frontend/eslint-plugin/-/merge_requests/20) :)
+
+- [AST explorer](https://astexplorer.net/)
+
+- ESLint's developer guide, especially [Working with Plugins](https://eslint.org/docs/developer-guide/working-with-plugins) and [Working with Rules
+  ](https://eslint.org/docs/developer-guide/working-with-rules)
+
+- ESlint's [max-params rule](https://eslint.org/docs/rules/max-params#enforce-a-maximum-number-of-parameters-in-function-definitions-max-params), and its linked sources on GitHub
+
+- [eslint-plugin-import](https://github.com/benmosher/eslint-plugin-import)
+
+- [You-Dont-Need-Lodash-Underscore](https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore)
+
+- Articles and Q&A
+
+  - [Create custom ESLint rules in 2 minutes](https://blog.webiny.com/create-custom-eslint-rules-in-2-minutes-e3d41cb6a9a0)
+
+  - [Writing custom EsLint rules](https://www.kenneth-truyers.net/2016/05/27/writing-custom-eslint-rules/)
+
+  - [How To Write Your First ESLint Plugin](https://dev.to/spukas/how-to-write-your-first-eslint-plugin-145)
+
+  - [I can't make my custom eslint rule to work](https://stackoverflow.com/questions/60750019/i-cant-make-my-custom-eslint-rule-to-work)
+
+  - [Writing Custom Lint Rules for Your Picky Developers](https://flexport.engineering/writing-custom-lint-rules-for-your-picky-developers-67732afa1803)
+
+  - [Creating an ESLint Plugin](https://medium.com/@bjrnt/creating-an-eslint-plugin-87f1cb42767f)
+
+- This course [Creating an Open Source JavaScript Library on Github](https://frontendmasters.com/courses/open-source/), and its associated [GitHub repo](https://github.com/kentcdodds/starwars-names)
+
+- This course [Code Transformation and Linting with ASTs](https://frontendmasters.com/courses/linting-asts/)
+
+- Badges from [shields.io](https://shields.io/)

package/docs/rules/func-args.md

@@ -1,117 +1,117 @@
-# enforce the number of arguments used in a function call (func-args)
-
-This rule allows you to set a max limit for the number of arguments used in function calls. It allows you to set a global limit, and to override this global limit for any number of named functions you want.
-
-## Rule Details
-
-By design, this plugin's rules don't have pre-set defaults. So, you've to configure this rule as described here in order to use it. Noting that all the options are used as keys in a single config object (no arrays or nested objects).
-
-### Options
-
-Here are the available options for this rule:
-
-- `global`: accepts an integer indicating the max number of arguments used in a function call. This applies to all function calls unless overridden for specifically configured function names
-
-- `[functionName]`: `functionName` is a placeholder for a key that represents the name of a function (`foo`, `bar`, `doSomething`, etc.), and accepts an integer indicating the max number of arguments for a call to `functionName`. This overrides the global limit. You can add as many keys for as many function names you would like to override/set a limit to
-
-If you have a need to set the value of an option to `0`, it is a valid limit that's supported by this rule.
-
-If you want to disable this rule (removing all restrictions) for any of the options, you can set its value to `-1`. For example, adding an option like `"baz": -1` in the config, allows you to call `baz` with any number of arguments (basically from 0 to an unlimited number of argument). This overrides the global limit.
-
-**Error message example:** `foo has been called with too many arguments (3). Maximum allowed is (2).`
-
-#### Example (A)
-
-With a config like:
-
-```json
-{
-  "rules": {
-    "func-params-args/func-args": [
-      "warn",
-      {
-        "global": 3,
-        "bar": 2,
-        "baz": 1
-      }
-    ]
-  }
-}
-```
-
-Examples of **incorrect** code for this rule:
-
-```js
-foo('arg1', 'arg2', arg3, arg4);
-a.foo('arg1', 'arg2', arg3, arg4);
-
-bar('arg1', 'arg2', arg3);
-b.bar('arg1', 'arg2', arg3);
-
-baz('arg1', arg2);
-b.baz('arg1', arg2);
-```
-
-Examples of **correct** code for this rule:
-
-```js
-foo('arg1', 'arg2', arg3);
-foo('arg1', 'arg2');
-foo('arg1');
-a.foo('arg1', 'arg2', arg3);
-a.foo('arg1', 'arg2');
-a.foo('arg1');
-
-bar('arg1', arg2);
-bar('arg1');
-b.bar('arg1', arg2);
-b.bar('arg1');
-
-baz();
-a.baz();
-baz('arg1');
-b.baz('arg1');
-```
-
-#### Example (B)
-
-With a config like:
-
-```json
-{
-  "rules": {
-    "func-params-args/func-args": [
-      "warn",
-      {
-        "foo": 2
-      }
-    ]
-  }
-}
-```
-
-Examples of **incorrect** code for this rule:
-
-```js
-foo('arg1', 'arg2', arg3);
-a.foo('arg1', 'arg2', arg3);
-```
-
-Examples of **correct** code for this rule:
-
-```js
-foo('arg1', 'arg2');
-foo('arg1');
-foo();
-a.b.foo('arg1', 'arg2');
-a.b.c.foo('arg1');
-a.b.foo();
-
-bar('arg1', 'arg2', arg3, arg4);
-a.bar('arg1', 'arg2', arg3, arg4);
-
-// whatever else function calls
-
-// any other function call than foo would have no restrictions
-// since the 'global' option is not configured
-```
+# enforce the number of arguments used in a function call (func-args)
+
+This rule allows you to set a max limit for the number of arguments used in function calls. It allows you to set a global limit, and to override this global limit for any number of named functions you want.
+
+## Rule Details
+
+By design, this plugin's rules don't have pre-set defaults. So, you've to configure this rule as described here in order to use it. Noting that all the options are used as keys in a single config object (no arrays or nested objects).
+
+### Options
+
+Here are the available options for this rule:
+
+- `global`: accepts an integer indicating the max number of arguments used in a function call. This applies to all function calls unless overridden for specifically configured function names
+
+- `[functionName]`: `functionName` is a placeholder for a key that represents the name of a function (`foo`, `bar`, `doSomething`, etc.), and accepts an integer indicating the max number of arguments for a call to `functionName`. This overrides the global limit. You can add as many keys for as many function names you would like to override/set a limit to
+
+If you have a need to set the value of an option to `0`, it is a valid limit that's supported by this rule.
+
+If you want to disable this rule (removing all restrictions) for any of the options, you can set its value to `-1`. For example, adding an option like `"baz": -1` in the config, allows you to call `baz` with any number of arguments (basically from 0 to an unlimited number of argument). This overrides the global limit.
+
+**Error message example:** `foo has been called with too many arguments (3). Maximum allowed is (2).`
+
+#### Example (A)
+
+With a config like:
+
+```json
+{
+  "rules": {
+    "func-params-args/func-args": [
+      "warn",
+      {
+        "global": 3,
+        "bar": 2,
+        "baz": 1
+      }
+    ]
+  }
+}
+```
+
+Examples of **incorrect** code for this rule:
+
+```js
+foo('arg1', 'arg2', arg3, arg4);
+a.foo('arg1', 'arg2', arg3, arg4);
+
+bar('arg1', 'arg2', arg3);
+b.bar('arg1', 'arg2', arg3);
+
+baz('arg1', arg2);
+b.baz('arg1', arg2);
+```
+
+Examples of **correct** code for this rule:
+
+```js
+foo('arg1', 'arg2', arg3);
+foo('arg1', 'arg2');
+foo('arg1');
+a.foo('arg1', 'arg2', arg3);
+a.foo('arg1', 'arg2');
+a.foo('arg1');
+
+bar('arg1', arg2);
+bar('arg1');
+b.bar('arg1', arg2);
+b.bar('arg1');
+
+baz();
+a.baz();
+baz('arg1');
+b.baz('arg1');
+```
+
+#### Example (B)
+
+With a config like:
+
+```json
+{
+  "rules": {
+    "func-params-args/func-args": [
+      "warn",
+      {
+        "foo": 2
+      }
+    ]
+  }
+}
+```
+
+Examples of **incorrect** code for this rule:
+
+```js
+foo('arg1', 'arg2', arg3);
+a.foo('arg1', 'arg2', arg3);
+```
+
+Examples of **correct** code for this rule:
+
+```js
+foo('arg1', 'arg2');
+foo('arg1');
+foo();
+a.b.foo('arg1', 'arg2');
+a.b.c.foo('arg1');
+a.b.foo();
+
+bar('arg1', 'arg2', arg3, arg4);
+a.bar('arg1', 'arg2', arg3, arg4);
+
+// whatever else function calls
+
+// any other function call than foo would have no restrictions
+// since the 'global' option is not configured
+```

package/docs/rules/func-params.md

@@ -1,180 +1,180 @@
-# enforce the number of parameters used in a function definition or expression (func-params)
-
-This rule allows you to set a max limit for the number of parameters used in function definitions, function expressions, and arrow function expressions. It allows you to set a global limit, and to override this global limit for each of the types (definitions and expressions).
-
-## Rule Details
-
-By design, this plugin's rules don't have pre-set defaults. So, you've to configure this rule as described here in order to use it. Noting that all the options are used as keys in a single config object (no arrays or nested objects).
-
-### Options
-
-Here are the available options for this rule:
-
-- `global`: accepts an integer indicating the max number of parameters used in a function definition or expression. This applies to all types unless overridden for a specific type
-
-- `funcDefinition`: accepts an integer indicating the max number of parameters used in a function definition. This overrides the global limit
-
-- `funcExpression`: accepts an integer indicating the max number of parameters used in a function expression. This overrides the global limit
-
-- `arrowFuncExpression`: accepts an integer indicating the max number of parameters used in an arrow function expression. This overrides the global limit
-
-- `funcTypeAnnotation`: accepts an integer indicating the max number of parameters used in a TypeScript function type annotation. This overrides the global limit
-
-If you have a need to set the value of an option to `0`, it is a valid limit that's supported by this rule.
-
-If you want to disable this rule (removing all restrictions) for any of the options, you can set its value to `-1`. For example, setting an option like `"arrowFuncExpression": -1` in the config, allows you to use arrow functions with any number of parameters (basically from 0 to an unlimited number of parameters). This overrides the global limit.
-
-**Error message examples:**
-
-- `function 'foo' has too many parameters (3). Maximum allowed is (1).`
-- `arrow function 'b' has too many parameters (3). Maximum allowed is (1).`
-- `arrow function has too many parameters (3). Maximum allowed is (1).`
-- `function 'onBar' has too many parameters (3). Maximum allowed is (1).` [TS key in interface or object type]
-- `function 'onBarFn' has too many parameters (3). Maximum allowed is (1).` [TS function type alias]
-- `function 'myFunction' has too many parameters (3). Maximum allowed is (1).` [TS method signature]
-
-#### Example (A)
-
-With a config like:
-
-```json
-{
-  "rules": {
-    "func-params-args/func-params": [
-      "warn",
-      {
-        "global": 3,
-        "arrowFuncExpression": 4
-      }
-    ]
-  }
-}
-```
-
-Examples of **incorrect** code for this rule:
-
-```ts
-function foo(param1, param2, param3, param4) {}
-
-a = function (param1, param2, param3, param4) {};
-
-b = (param1, param2, param3, param4, param5) => {};
-
-c = async function (param1, param2, param3, param4) {};
-
-c.reduce((param1, param2, param3, param4, param5) => {});
-
-interface IFoo {
-  onBar: (
-    param1: string,
-    param2: string,
-    param3: string,
-    param4: string
-  ) => void;
-}
-
-type FooType = {
-  onBar: (
-    param1: number,
-    param2: number,
-    param3: number,
-    param4: number
-  ) => void;
-};
-
-type onBarFn = (
-  param1: number,
-  param2: number,
-  param3: number,
-  param4: number
-) => void;
-
-interface MyInterface {
-  myFunction(
-    param1: string,
-    param2: string,
-    param3: string,
-    param4: string
-  ): void;
-}
-
-const func2: (
-  param1: string,
-  param2: string,
-  param3: string,
-  param3: string
-) => void = (arg1, arg2, arg3, arg4) => {};
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-function foo(param1, param2, param3) {}
-
-a = function (param1, param2, param3) {};
-
-b = (param1, param2, param3, param4) => {};
-
-c.reduce((param1, param2, param3, param4) => {});
-
-function foo(param1) {}
-
-a = function (param1, param2) {};
-
-b = () => {};
-
-c.reduce((param1, param2, param3) => {});
-
-interface IFoo {
-  onBar: (param1: string, param2: string, param3: string) => void;
-}
-
-type FooType = {
-  onBar: (param1: number, param2: number, param3: number) => void;
-};
-
-type onBarFn = (param1: number, param2: number, param3: number) => void;
-```
-
-#### Example (B)
-
-With a config like:
-
-```json
-{
-  "rules": {
-    "func-params-args/func-params": [
-      "warn",
-      {
-        "funcDefinition": 1,
-        "funcExpression": 2
-      }
-    ]
-  }
-}
-```
-
-Examples of **incorrect** code for this rule:
-
-```js
-function foo(param1, param2) {}
-
-a = function (param1, param2, param3) {};
-```
-
-Examples of **correct** code for this rule:
-
-```js
-function foo(param1) {}
-
-a = function (param1, param2) {};
-
-// No restrictions below on arrow function expressions
-// since the 'global' option is not configured
-
-b = (param1, param2, param3, param4, param5) => {};
-
-c = () => {};
-
-c.reduce((param1, param2, param3, param4) => {});
-```
+# enforce the number of parameters used in a function definition or expression (func-params)
+
+This rule allows you to set a max limit for the number of parameters used in function definitions, function expressions, and arrow function expressions. It allows you to set a global limit, and to override this global limit for each of the types (definitions and expressions).
+
+## Rule Details
+
+By design, this plugin's rules don't have pre-set defaults. So, you've to configure this rule as described here in order to use it. Noting that all the options are used as keys in a single config object (no arrays or nested objects).
+
+### Options
+
+Here are the available options for this rule:
+
+- `global`: accepts an integer indicating the max number of parameters used in a function definition or expression. This applies to all types unless overridden for a specific type
+
+- `funcDefinition`: accepts an integer indicating the max number of parameters used in a function definition. This overrides the global limit
+
+- `funcExpression`: accepts an integer indicating the max number of parameters used in a function expression. This overrides the global limit
+
+- `arrowFuncExpression`: accepts an integer indicating the max number of parameters used in an arrow function expression. This overrides the global limit
+
+- `funcTypeAnnotation`: accepts an integer indicating the max number of parameters used in a TypeScript function type annotation. This overrides the global limit
+
+If you have a need to set the value of an option to `0`, it is a valid limit that's supported by this rule.
+
+If you want to disable this rule (removing all restrictions) for any of the options, you can set its value to `-1`. For example, setting an option like `"arrowFuncExpression": -1` in the config, allows you to use arrow functions with any number of parameters (basically from 0 to an unlimited number of parameters). This overrides the global limit.
+
+**Error message examples:**
+
+- `function 'foo' has too many parameters (3). Maximum allowed is (1).`
+- `arrow function 'b' has too many parameters (3). Maximum allowed is (1).`
+- `arrow function has too many parameters (3). Maximum allowed is (1).`
+- `function 'onBar' has too many parameters (3). Maximum allowed is (1).` [TS key in interface or object type]
+- `function 'onBarFn' has too many parameters (3). Maximum allowed is (1).` [TS function type alias]
+- `function 'myFunction' has too many parameters (3). Maximum allowed is (1).` [TS method signature]
+
+#### Example (A)
+
+With a config like:
+
+```json
+{
+  "rules": {
+    "func-params-args/func-params": [
+      "warn",
+      {
+        "global": 3,
+        "arrowFuncExpression": 4
+      }
+    ]
+  }
+}
+```
+
+Examples of **incorrect** code for this rule:
+
+```ts
+function foo(param1, param2, param3, param4) {}
+
+a = function (param1, param2, param3, param4) {};
+
+b = (param1, param2, param3, param4, param5) => {};
+
+c = async function (param1, param2, param3, param4) {};
+
+c.reduce((param1, param2, param3, param4, param5) => {});
+
+interface IFoo {
+  onBar: (
+    param1: string,
+    param2: string,
+    param3: string,
+    param4: string,
+  ) => void;
+}
+
+type FooType = {
+  onBar: (
+    param1: number,
+    param2: number,
+    param3: number,
+    param4: number,
+  ) => void;
+};
+
+type onBarFn = (
+  param1: number,
+  param2: number,
+  param3: number,
+  param4: number,
+) => void;
+
+interface MyInterface {
+  myFunction(
+    param1: string,
+    param2: string,
+    param3: string,
+    param4: string,
+  ): void;
+}
+
+const func2: (
+  param1: string,
+  param2: string,
+  param3: string,
+  param3: string,
+) => void = (arg1, arg2, arg3, arg4) => {};
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+function foo(param1, param2, param3) {}
+
+a = function (param1, param2, param3) {};
+
+b = (param1, param2, param3, param4) => {};
+
+c.reduce((param1, param2, param3, param4) => {});
+
+function foo(param1) {}
+
+a = function (param1, param2) {};
+
+b = () => {};
+
+c.reduce((param1, param2, param3) => {});
+
+interface IFoo {
+  onBar: (param1: string, param2: string, param3: string) => void;
+}
+
+type FooType = {
+  onBar: (param1: number, param2: number, param3: number) => void;
+};
+
+type onBarFn = (param1: number, param2: number, param3: number) => void;
+```
+
+#### Example (B)
+
+With a config like:
+
+```json
+{
+  "rules": {
+    "func-params-args/func-params": [
+      "warn",
+      {
+        "funcDefinition": 1,
+        "funcExpression": 2
+      }
+    ]
+  }
+}
+```
+
+Examples of **incorrect** code for this rule:
+
+```js
+function foo(param1, param2) {}
+
+a = function (param1, param2, param3) {};
+```
+
+Examples of **correct** code for this rule:
+
+```js
+function foo(param1) {}
+
+a = function (param1, param2) {};
+
+// No restrictions below on arrow function expressions
+// since the 'global' option is not configured
+
+b = (param1, param2, param3, param4, param5) => {};
+
+c = () => {};
+
+c.reduce((param1, param2, param3, param4) => {});
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-func-params-args",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Limit the number of function parameters and arguments with ease and flexibility",
   "author": "Abdulrahman (Abdu) Assabri <abdusabri@abdusabri.com>",
   "keywords": [
@@ -24,7 +24,7 @@
   },
   "license": "MIT",
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
   "main": "dist/index.js",
   "scripts": {
@@ -45,16 +45,16 @@
     "eslint": "^6 || ^7.1.0 || ^8.0.0"
   },
   "devDependencies": {
-    "@typescript-eslint/parser": "^5.4.0",
+    "@typescript-eslint/parser": "^6.12.0",
     "babel-minify": "^0.5.1",
     "coveralls": "^3.1.0",
     "eslint": "^8.2.0",
     "husky": "^8.0.2",
-    "lint-staged": "^13.0.4",
+    "lint-staged": "^15.0.2",
     "mocha": "^10.0.0",
     "nyc": "^15.1.0",
-    "prettier": "^2.2.1",
-    "rimraf": "^4.4.0",
+    "prettier": "^3.1.0",
+    "rimraf": "^5.0.5",
     "typescript": "^5.0.2"
   },
   "files": [