diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json index 210a5101e3..b3b99502ac 100644 --- a/node_modules/.package-lock.json +++ b/node_modules/.package-lock.json @@ -803,12 +803,6 @@ "dev": true, "license": "0BSD" }, - "node_modules/@rtsao/scc": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz", - "integrity": "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==", - "dev": true - }, "node_modules/@schemastore/package": { "version": "0.0.10", "license": "MIT" @@ -2772,27 +2766,26 @@ } }, "node_modules/eslint-plugin-import": { - "version": "2.30.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.30.0.tgz", - "integrity": "sha512-/mHNE9jINJfiD2EKkg1BKyPyUk4zdnT54YgbOgfjSakWT5oyX/qQLVNTkehyfpcMxZXMy1zyonZ2v7hZTX43Yw==", + "version": "2.29.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.29.1.tgz", + "integrity": "sha512-BbPC0cuExzhiMo4Ff1BTVwHpjjv28C5R+btTOGaCRC7UEz801up0JadwkeSk5Ued6TG34uaczuVuH6qyy5YUxw==", "dev": true, "dependencies": { - "@rtsao/scc": "^1.1.0", - "array-includes": "^3.1.8", - "array.prototype.findlastindex": "^1.2.5", + "array-includes": "^3.1.7", + "array.prototype.findlastindex": "^1.2.3", "array.prototype.flat": "^1.3.2", "array.prototype.flatmap": "^1.3.2", "debug": "^3.2.7", "doctrine": "^2.1.0", "eslint-import-resolver-node": "^0.3.9", - "eslint-module-utils": "^2.9.0", - "hasown": "^2.0.2", - "is-core-module": "^2.15.1", + "eslint-module-utils": "^2.8.0", + "hasown": "^2.0.0", + "is-core-module": "^2.13.1", "is-glob": "^4.0.3", "minimatch": "^3.1.2", - "object.fromentries": "^2.0.8", - "object.groupby": "^1.0.3", - "object.values": "^1.2.0", + "object.fromentries": "^2.0.7", + "object.groupby": "^1.0.1", + "object.values": "^1.1.7", "semver": "^6.3.1", "tsconfig-paths": "^3.15.0" }, diff --git a/node_modules/@rtsao/scc/LICENSE b/node_modules/@rtsao/scc/LICENSE deleted file mode 100644 index a7cb450bed..0000000000 --- a/node_modules/@rtsao/scc/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2019 Ryan Tsao - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/node_modules/@rtsao/scc/README.md b/node_modules/@rtsao/scc/README.md deleted file mode 100644 index 4697edd2ef..0000000000 --- a/node_modules/@rtsao/scc/README.md +++ /dev/null @@ -1,49 +0,0 @@ -# `@rtsao/scc` - -Find strongly connected components of a directed graph using [Tarjan's algorithm](https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm). - -This algorithm efficiently yields both a topological order and list of any cycles. - -## Installation - -``` -yarn add @rtsao/scc -``` - -``` -npm install @rtsao/scc -``` - -## Usage - -```js -const scc = require("@rtsao/scc"); - -const digraph = new Map([ - ["a", new Set(["c", "d"])], - ["b", new Set(["a"])], - ["c", new Set(["b"])], - ["d", new Set(["e"])], - ["e", new Set()] -]); - -const components = scc(digraph); -// [ Set { 'e' }, Set { 'd' }, Set { 'b', 'c', 'a' } ] -``` - -#### Illustration of example input digraph -``` -┌───┐ ┌───┐ -│ d │ ◀── │ a │ ◀┐ -└───┘ └───┘ │ - │ │ │ - ▼ ▼ │ -┌───┐ ┌───┐ │ -│ e │ │ c │ │ -└───┘ └───┘ │ - │ │ - ▼ │ - ┌───┐ │ - │ b │ ─┘ - └───┘ -``` diff --git a/node_modules/@rtsao/scc/index.d.ts b/node_modules/@rtsao/scc/index.d.ts deleted file mode 100644 index ed46b8bc09..0000000000 --- a/node_modules/@rtsao/scc/index.d.ts +++ /dev/null @@ -1 +0,0 @@ -export default function tarjan(graph: Map>): Array> diff --git a/node_modules/@rtsao/scc/index.js b/node_modules/@rtsao/scc/index.js deleted file mode 100644 index b7dd5bb479..0000000000 --- a/node_modules/@rtsao/scc/index.js +++ /dev/null @@ -1,51 +0,0 @@ -"use strict"; - -module.exports = tarjan; - -// Adapted from https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm#The_algorithm_in_pseudocode - -function tarjan(graph) { - const indices = new Map(); - const lowlinks = new Map(); - const onStack = new Set(); - const stack = []; - const scc = []; - let idx = 0; - - function strongConnect(v) { - indices.set(v, idx); - lowlinks.set(v, idx); - idx++; - stack.push(v); - onStack.add(v); - - const deps = graph.get(v); - for (const dep of deps) { - if (!indices.has(dep)) { - strongConnect(dep); - lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(dep))); - } else if (onStack.has(dep)) { - lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(dep))); - } - } - - if (lowlinks.get(v) === indices.get(v)) { - const vertices = new Set(); - let w = null; - while (v !== w) { - w = stack.pop(); - onStack.delete(w); - vertices.add(w); - } - scc.push(vertices); - } - } - - for (const v of graph.keys()) { - if (!indices.has(v)) { - strongConnect(v); - } - } - - return scc; -} diff --git a/node_modules/@rtsao/scc/index.js.flow b/node_modules/@rtsao/scc/index.js.flow deleted file mode 100644 index 479ff4ff6a..0000000000 --- a/node_modules/@rtsao/scc/index.js.flow +++ /dev/null @@ -1,5 +0,0 @@ -// @flow - -declare function tarjan(graph: Map>): Array>; - -declare module.exports: typeof tarjan; diff --git a/node_modules/@rtsao/scc/package.json b/node_modules/@rtsao/scc/package.json deleted file mode 100644 index 67f67ccd99..0000000000 --- a/node_modules/@rtsao/scc/package.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "name": "@rtsao/scc", - "version": "1.1.0", - "repository": "rtsao/scc", - "main": "index.js", - "license": "MIT" -} diff --git a/node_modules/eslint-plugin-import/CHANGELOG.md b/node_modules/eslint-plugin-import/CHANGELOG.md index cf97fff94d..b81ad61a61 100644 --- a/node_modules/eslint-plugin-import/CHANGELOG.md +++ b/node_modules/eslint-plugin-import/CHANGELOG.md @@ -6,34 +6,6 @@ This change log adheres to standards from [Keep a CHANGELOG](https://keepachange ## [Unreleased] -## [2.30.0] - 2024-09-02 - -### Added -- [`dynamic-import-chunkname`]: add `allowEmpty` option to allow empty leading comments ([#2942], thanks [@JiangWeixian]) -- [`dynamic-import-chunkname`]: Allow empty chunk name when webpackMode: 'eager' is set; add suggestions to remove name in eager mode ([#3004], thanks [@amsardesai]) -- [`no-unused-modules`]: Add `ignoreUnusedTypeExports` option ([#3011], thanks [@silverwind]) -- add support for Flat Config ([#3018], thanks [@michaelfaith]) - -### Fixed -- [`no-extraneous-dependencies`]: allow wrong path ([#3012], thanks [@chabb]) -- [`no-cycle`]: use scc algorithm to optimize ([#2998], thanks [@soryy708]) -- [`no-duplicates`]: Removing duplicates breaks in TypeScript ([#3033], thanks [@yesl-kim]) -- [`newline-after-import`]: fix considerComments option when require ([#2952], thanks [@developer-bandi]) -- [`order`]: do not compare first path segment for relative paths ([#2682]) ([#2885], thanks [@mihkeleidast]) - -### Changed -- [Docs] `no-extraneous-dependencies`: Make glob pattern description more explicit ([#2944], thanks [@mulztob]) -- [`no-unused-modules`]: add console message to help debug [#2866] -- [Refactor] `ExportMap`: make procedures static instead of monkeypatching exportmap ([#2982], thanks [@soryy708]) -- [Refactor] `ExportMap`: separate ExportMap instance from its builder logic ([#2985], thanks [@soryy708]) -- [Docs] `order`: Add a quick note on how unbound imports and --fix ([#2640], thanks [@minervabot]) -- [Tests] appveyor -> GHA (run tests on Windows in both pwsh and WSL + Ubuntu) ([#2987], thanks [@joeyguerra]) -- [actions] migrate OSX tests to GHA ([ljharb#37], thanks [@aks-]) -- [Refactor] `exportMapBuilder`: avoid hoisting ([#2989], thanks [@soryy708]) -- [Refactor] `ExportMap`: extract "builder" logic to separate files ([#2991], thanks [@soryy708]) -- [Docs] [`order`]: update the description of the `pathGroupsExcludedImportTypes` option ([#3036], thanks [@liby]) -- [readme] Clarify how to install the plugin ([#2993], thanks [@jwbth]) - ## [2.29.1] - 2023-12-14 ### Fixed @@ -1129,26 +1101,8 @@ for info on changes for earlier releases. [`memo-parser`]: ./memo-parser/README.md -[#3036]: https://github.com/import-js/eslint-plugin-import/pull/3036 -[#3033]: https://github.com/import-js/eslint-plugin-import/pull/3033 -[#3018]: https://github.com/import-js/eslint-plugin-import/pull/3018 -[#3012]: https://github.com/import-js/eslint-plugin-import/pull/3012 -[#3011]: https://github.com/import-js/eslint-plugin-import/pull/3011 -[#3004]: https://github.com/import-js/eslint-plugin-import/pull/3004 -[#2998]: https://github.com/import-js/eslint-plugin-import/pull/2998 -[#2993]: https://github.com/import-js/eslint-plugin-import/pull/2993 -[#2991]: https://github.com/import-js/eslint-plugin-import/pull/2991 -[#2989]: https://github.com/import-js/eslint-plugin-import/pull/2989 -[#2987]: https://github.com/import-js/eslint-plugin-import/pull/2987 -[#2985]: https://github.com/import-js/eslint-plugin-import/pull/2985 -[#2982]: https://github.com/import-js/eslint-plugin-import/pull/2982 -[#2952]: https://github.com/import-js/eslint-plugin-import/pull/2952 -[#2944]: https://github.com/import-js/eslint-plugin-import/pull/2944 -[#2942]: https://github.com/import-js/eslint-plugin-import/pull/2942 [#2919]: https://github.com/import-js/eslint-plugin-import/pull/2919 -[#2885]: https://github.com/import-js/eslint-plugin-import/pull/2885 [#2884]: https://github.com/import-js/eslint-plugin-import/pull/2884 -[#2866]: https://github.com/import-js/eslint-plugin-import/pull/2866 [#2854]: https://github.com/import-js/eslint-plugin-import/pull/2854 [#2851]: https://github.com/import-js/eslint-plugin-import/pull/2851 [#2850]: https://github.com/import-js/eslint-plugin-import/pull/2850 @@ -1162,7 +1116,6 @@ for info on changes for earlier releases. [#2735]: https://github.com/import-js/eslint-plugin-import/pull/2735 [#2699]: https://github.com/import-js/eslint-plugin-import/pull/2699 [#2664]: https://github.com/import-js/eslint-plugin-import/pull/2664 -[#2640]: https://github.com/import-js/eslint-plugin-import/pull/2640 [#2613]: https://github.com/import-js/eslint-plugin-import/pull/2613 [#2608]: https://github.com/import-js/eslint-plugin-import/pull/2608 [#2605]: https://github.com/import-js/eslint-plugin-import/pull/2605 @@ -1487,12 +1440,9 @@ for info on changes for earlier releases. [#164]: https://github.com/import-js/eslint-plugin-import/pull/164 [#157]: https://github.com/import-js/eslint-plugin-import/pull/157 -[ljharb#37]: https://github.com/ljharb/eslint-plugin-import/pull/37 - [#2930]: https://github.com/import-js/eslint-plugin-import/issues/2930 [#2687]: https://github.com/import-js/eslint-plugin-import/issues/2687 [#2684]: https://github.com/import-js/eslint-plugin-import/issues/2684 -[#2682]: https://github.com/import-js/eslint-plugin-import/issues/2682 [#2674]: https://github.com/import-js/eslint-plugin-import/issues/2674 [#2668]: https://github.com/import-js/eslint-plugin-import/issues/2668 [#2666]: https://github.com/import-js/eslint-plugin-import/issues/2666 @@ -1617,8 +1567,7 @@ for info on changes for earlier releases. [#119]: https://github.com/import-js/eslint-plugin-import/issues/119 [#89]: https://github.com/import-js/eslint-plugin-import/issues/89 -[Unreleased]: https://github.com/import-js/eslint-plugin-import/compare/v2.30.0...HEAD -[2.30.0]: https://github.com/import-js/eslint-plugin-import/compare/v2.29.1...v2.30.0 +[Unreleased]: https://github.com/import-js/eslint-plugin-import/compare/v2.29.1...HEAD [2.29.1]: https://github.com/import-js/eslint-plugin-import/compare/v2.29.0...v2.29.1 [2.29.0]: https://github.com/import-js/eslint-plugin-import/compare/v2.28.1...v2.29.0 [2.28.1]: https://github.com/import-js/eslint-plugin-import/compare/v2.28.0...v2.28.1 @@ -1723,11 +1672,9 @@ for info on changes for earlier releases. [@adjerbetian]: https://github.com/adjerbetian [@AdriAt360]: https://github.com/AdriAt360 [@ai]: https://github.com/ai -[@aks-]: https://github.com/aks- [@aladdin-add]: https://github.com/aladdin-add [@alex-page]: https://github.com/alex-page [@alexgorbatchev]: https://github.com/alexgorbatchev -[@amsardesai]: https://github.com/amsardesai [@andreubotella]: https://github.com/andreubotella [@AndrewLeedham]: https://github.com/AndrewLeedham [@andyogo]: https://github.com/andyogo @@ -1752,13 +1699,11 @@ for info on changes for earlier releases. [@bicstone]: https://github.com/bicstone [@Blasz]: https://github.com/Blasz [@bmish]: https://github.com/bmish -[@developer-bandi]: https://github.com/developer-bandi [@borisyankov]: https://github.com/borisyankov [@bradennapier]: https://github.com/bradennapier [@bradzacher]: https://github.com/bradzacher [@brendo]: https://github.com/brendo [@brettz9]: https://github.com/brettz9 -[@chabb]: https://github.com/chabb [@Chamion]: https://github.com/Chamion [@charlessuh]: https://github.com/charlessuh [@charpeni]: https://github.com/charpeni @@ -1825,12 +1770,10 @@ for info on changes for earlier releases. [@jeffshaver]: https://github.com/jeffshaver [@jf248]: https://github.com/jf248 [@jfmengels]: https://github.com/jfmengels -[@JiangWeixian]: https://github.com/JiangWeixian [@jimbolla]: https://github.com/jimbolla [@jkimbo]: https://github.com/jkimbo [@joaovieira]: https://github.com/joaovieira [@joe-matsec]: https://github.com/joe-matsec -[@joeyguerra]: https://github.com/joeyguerra [@johndevedu]: https://github.com/johndevedu [@johnthagen]: https://github.com/johnthagen [@jonboiser]: https://github.com/jonboiser @@ -1840,7 +1783,6 @@ for info on changes for earlier releases. [@jseminck]: https://github.com/jseminck [@julien1619]: https://github.com/julien1619 [@justinanastos]: https://github.com/justinanastos -[@jwbth]: https://github.com/jwbth [@k15a]: https://github.com/k15a [@kentcdodds]: https://github.com/kentcdodds [@kevin940726]: https://github.com/kevin940726 @@ -1888,15 +1830,11 @@ for info on changes for earlier releases. [@meowtec]: https://github.com/meowtec [@mgwalker]: https://github.com/mgwalker [@mhmadhamster]: https://github.com/MhMadHamster -[@michaelfaith]: https://github.com/michaelfaith -[@mihkeleidast]: https://github.com/mihkeleidast [@MikeyBeLike]: https://github.com/MikeyBeLike -[@minervabot]: https://github.com/minervabot [@mpint]: https://github.com/mpint [@mplewis]: https://github.com/mplewis [@mrmckeb]: https://github.com/mrmckeb [@msvab]: https://github.com/msvab -[@mulztob]: https://github.com/mulztob [@mx-bernhard]: https://github.com/mx-bernhard [@Nfinished]: https://github.com/Nfinished [@nickofthyme]: https://github.com/nickofthyme @@ -1905,9 +1843,9 @@ for info on changes for earlier releases. [@ntdb]: https://github.com/ntdb [@nwalters512]: https://github.com/nwalters512 [@ombene]: https://github.com/ombene +[@Pandemic1617]: https://github.com/Pandemic1617 [@ota-meshi]: https://github.com/ota-meshi [@OutdatedVersion]: https://github.com/OutdatedVersion -[@Pandemic1617]: https://github.com/Pandemic1617 [@panrafal]: https://github.com/panrafal [@paztis]: https://github.com/paztis [@pcorpet]: https://github.com/pcorpet @@ -1939,7 +1877,6 @@ for info on changes for earlier releases. [@sergei-startsev]: https://github.com/sergei-startsev [@sharmilajesupaul]: https://github.com/sharmilajesupaul [@sheepsteak]: https://github.com/sheepsteak -[@silverwind]: https://github.com/silverwind [@silviogutierrez]: https://github.com/silviogutierrez [@SimenB]: https://github.com/SimenB [@simmo]: https://github.com/simmo @@ -1982,7 +1919,6 @@ for info on changes for earlier releases. [@wtgtybhertgeghgtwtg]: https://github.com/wtgtybhertgeghgtwtg [@xM8WVqaG]: https://github.com/xM8WVqaG [@xpl]: https://github.com/xpl -[@yesl-kim]: https://github.com/yesl-kim [@yndajas]: https://github.com/yndajas [@yordis]: https://github.com/yordis [@Zamiell]: https://github.com/Zamiell diff --git a/node_modules/eslint-plugin-import/CONTRIBUTING.md b/node_modules/eslint-plugin-import/CONTRIBUTING.md new file mode 100644 index 0000000000..871e90ad8c --- /dev/null +++ b/node_modules/eslint-plugin-import/CONTRIBUTING.md @@ -0,0 +1,84 @@ +# Contributing + +Thanks for your interest in helping out! Here are a **few** _weird_ tricks to ~~cut your mortgage in half~~ maximize the global net efficiency of your efforts! + +## TL;DR: Checklist + +When opening an [issue](#issues): + + - [ ] search open/closed issues + - [ ] discuss bug/enhancement in new or old issue + +[PR](#prs) time: + + - [ ] write tests + - [ ] implement feature/fix bug + - [ ] update docs + - [ ] make a note in change log + +Remember, you don't need to do it all yourself; any of these are helpful! 😎 + +## How to get started + +If you are new to `eslint`, below are a few resources that will help you to familiarize yourself with the project. + + - Watch [this presentation](https://www.youtube.com/watch?v=2W9tUnALrLg) to learn the fundamental concept of Abstract Syntax Trees (AST) and the way `eslint` works under the hood. + - Familiarize yourself with the [AST explorer](https://astexplorer.net/) tool. Look into rules in `docs/rules`, create patterns in the rules, then analyze its AST. + - Explore the blog posts on how to create a custom rule. [One blog post](https://blog.yonatan.dev/writing-a-custom-eslint-rule-to-spot-undeclared-props/). [Second blog post](https://betterprogramming.pub/creating-custom-eslint-rules-cdc579694608). + - Read the official `eslint` [developer guide](https://eslint.org/docs/latest/developer-guide/architecture/). + +## Issues + +### Search open + closed issues for similar cases + + You may find an open issue that closely matches what you are thinking. You may also find a closed issue with discussion that either solves your problem or explains why we are unlikely to solve it in the near future. + + If you find a matching issue that is open, and marked `accepted` and/or `help wanted`, you might want to [open a PR](#prs). + +### Open an issue + + Let's discuss your issue. Could be as simple as unclear documentation or a wonky config file. + If you're suggesting a feature, it might exist and need better documentation, or it might be in process. Even given those, some discussion might be warranted to ensure the enhancement is clear. + + You're welcome to jump right to a PR, but without a discussion, can't make any guarantees about merging. + + That said: sometimes seeing the code makes the discussion clearer.😄 + +This is a helpful contribution all by itself. Thanks! + +## PRs + +If you would like to implement something, firstly: thanks! Community contributions are a magical thing. Like Redux or [the flux capacitor](https://youtu.be/SR5BfQ4rEqQ?t=2m25s), they make open source possible. + +**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/series/how-to-contribute-to-an-open-source-project-on-github). + +Here are some things to keep in mind when working on a PR: + +**Trying to update an inactive Pull Request?** +If a PR is open, but unfortunately the author is, for any reason, not available to apply code review fixes or rebase the source branch, then please **do not open a new PR**. +Instead, paste a link to your own branch in the PR, and the maintainers can pull in your changes and update the existing PR in-place. + +### Tests + +A PR that is just failing test cases for an existing issue is very helpful, as this can take as much time (if not more) as it takes to implement a new feature or fix a bug. + +If you only have enough time to write tests, fantastic! Submit away. This is a great jumping-off point for a core contributor or even another PR to continue what you've started. + +### Docs + +For enhancements to rules, please update the docs in `docs/rules` matching the rule filename from `src/rules` or the rule description in `meta.docs.description`. Running `npm run update:eslint-docs` will update the [README.md] and rule doc header. + +Bugfixes may not warrant docs changes, though it's worth skimming the existing docs to see if there are any relevant caveats that need to be removed. + +### Changelog + +Please add a quick blurb to the [**Unreleased**](./CHANGELOG.md#unreleased) section of the change log. Give yourself some credit, and please link back to the PR for future reference. This is especially helpful for resolver changes, as the resolvers are less frequently modified and published. + +Note also that the change log can't magically link back to Github entities (i.e. PRs, issues, users) or rules; there are a handful of footnote URL definitions at the bottom. You may need to add one or more URL if you've square-bracketed any such items. + +## Code of Conduct + +Please familiarize yourself with the [Code of Conduct](https://github.com/import-js/.github/blob/main/CODE_OF_CONDUCT.md). + +[README.md]: ./README.md diff --git a/node_modules/eslint-plugin-import/README.md b/node_modules/eslint-plugin-import/README.md index 8cc723423f..1baa0069b3 100644 --- a/node_modules/eslint-plugin-import/README.md +++ b/node_modules/eslint-plugin-import/README.md @@ -23,7 +23,7 @@ This plugin intends to support linting of ES2015+ (ES6+) import/export syntax, a ⌨️ Set in the `typescript` configuration.\ 🚸 Set in the `warnings` configuration.\ 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\ -💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).\ +💡 Manually fixable by [editor suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions).\ ❌ Deprecated. ### Helpful warnings @@ -73,7 +73,7 @@ This plugin intends to support linting of ES2015+ (ES6+) import/export syntax, a | Name                            | Description | 💼 | ⚠️ | 🚫 | 🔧 | 💡 | ❌ | | :------------------------------------------------------------------------------- | :------------------------------------------------------------------------- | :- | :---- | :- | :- | :- | :- | | [consistent-type-specifier-style](docs/rules/consistent-type-specifier-style.md) | Enforce or ban the use of inline type-only markers for named imports. | | | | 🔧 | | | -| [dynamic-import-chunkname](docs/rules/dynamic-import-chunkname.md) | Enforce a leading comment with the webpackChunkName for dynamic imports. | | | | | 💡 | | +| [dynamic-import-chunkname](docs/rules/dynamic-import-chunkname.md) | Enforce a leading comment with the webpackChunkName for dynamic imports. | | | | | | | | [exports-last](docs/rules/exports-last.md) | Ensure all exports appear after other statements. | | | | | | | | [extensions](docs/rules/extensions.md) | Ensure consistent use of file extension within the import path. | | | | | | | | [first](docs/rules/first.md) | Ensure all imports appear before other statements. | | | | 🔧 | | | @@ -106,60 +106,29 @@ The maintainers of `eslint-plugin-import` and thousands of other packages are wo npm install eslint-plugin-import --save-dev ``` -### Config - Legacy (`.eslintrc`) +All rules are off by default. However, you may configure them manually +in your `.eslintrc.(yml|json|js)`, or extend one of the canned configs: -All rules are off by default. However, you may extend one of the preset configs, or configure them manually in your `.eslintrc.(yml|json|js)`. - - - Extending a preset config: - -```jsonc -{ - "extends": [ - "eslint:recommended", - "plugin:import/recommended", - ], -} -``` - - - Configuring manually: - -```jsonc -{ - "rules": { - "import/no-unresolved": ["error", { "commonjs": true, "amd": true }] - "import/named": "error", - "import/namespace": "error", - "import/default": "error", - "import/export": "error", - // etc... - }, -}, -``` - -### Config - Flat (`eslint.config.js`) - -All rules are off by default. However, you may configure them manually in your `eslint.config.(js|cjs|mjs)`, or extend one of the preset configs: - -```js -import importPlugin from 'eslint-plugin-import'; -import js from '@eslint/js'; - -export default [ - js.configs.recommended, - importPlugin.flatConfigs.recommended, - { - files: ['**/*.{js,mjs,cjs}'], - languageOptions: { - ecmaVersion: 'latest', - sourceType: 'module', - }, - rules: { - 'no-unused-vars': 'off', - 'import/no-dynamic-require': 'warn', - 'import/no-nodejs-modules': 'warn', - }, - }, -]; +```yaml +--- +extends: + - eslint:recommended + - plugin:import/recommended + # alternatively, 'recommended' is the combination of these two rule sets: + - plugin:import/errors + - plugin:import/warnings + +# or configure manually: +plugins: + - import + +rules: + import/no-unresolved: [2, {commonjs: true, amd: true}] + import/named: 2 + import/namespace: 2 + import/default: 2 + import/export: 2 + # etc... ``` ## TypeScript @@ -168,23 +137,18 @@ You may use the following snippet or assemble your own config using the granular Make sure you have installed [`@typescript-eslint/parser`] and [`eslint-import-resolver-typescript`] which are used in the following configuration. -```jsonc -{ - "extends": [ - "eslint:recommended", - "plugin:import/recommended", -// the following lines do the trick - "plugin:import/typescript", - ], - "settings": { - "import/resolver": { - // You will also need to install and configure the TypeScript resolver - // See also https://github.com/import-js/eslint-import-resolver-typescript#configuration - "typescript": true, - "node": true, - }, - }, -} +```yaml +extends: + - eslint:recommended + - plugin:import/recommended +# the following lines do the trick + - plugin:import/typescript +settings: + import/resolver: + # You will also need to install and configure the TypeScript resolver + # See also https://github.com/import-js/eslint-import-resolver-typescript#configuration + typescript: true + node: true ``` [`@typescript-eslint/parser`]: https://github.com/typescript-eslint/typescript-eslint/tree/HEAD/packages/parser @@ -213,16 +177,6 @@ You can reference resolvers in several ways (in order of precedence): - as a conventional `eslint-import-resolver` name, like `eslint-import-resolver-foo`: - ```jsonc -// .eslintrc -{ - "settings": { - // uses 'eslint-import-resolver-foo': - "import/resolver": "foo", - }, -} -``` - ```yaml # .eslintrc.yml settings: @@ -243,15 +197,6 @@ module.exports = { - with a full npm module name, like `my-awesome-npm-module`: -```jsonc -// .eslintrc -{ - "settings": { - "import/resolver": "my-awesome-npm-module", - }, -} -``` - ```yaml # .eslintrc.yml settings: @@ -347,15 +292,11 @@ In practice, this means rules other than [`no-unresolved`](./docs/rules/no-unres `no-unresolved` has its own [`ignore`](./docs/rules/no-unresolved.md#ignore) setting. -```jsonc -{ - "settings": { - "import/ignore": [ - "\.coffee$", // fraught with parse errors - "\.(scss|less|css)$", // can't parse unprocessed CSS modules, either - ], - }, -} +```yaml +settings: + import/ignore: + - \.coffee$ # fraught with parse errors + - \.(scss|less|css)$ # can't parse unprocessed CSS modules, either ``` ### `import/core-modules` @@ -374,13 +315,10 @@ import 'electron' // without extra config, will be flagged as unresolved! that would otherwise be unresolved. To avoid this, you may provide `electron` as a core module: -```jsonc -// .eslintrc -{ - "settings": { - "import/core-modules": ["electron"], - }, -} +```yaml +# .eslintrc.yml +settings: + import/core-modules: [ electron ] ``` In Electron's specific case, there is a shared config named `electron` @@ -413,15 +351,11 @@ dependency parser will require and use the map key as the parser instead of the configured ESLint parser. This is useful if you're inter-op-ing with TypeScript directly using webpack, for example: -```jsonc -// .eslintrc -{ - "settings": { - "import/parsers": { - "@typescript-eslint/parser": [".ts", ".tsx"], - }, - }, -} +```yaml +# .eslintrc.yml +settings: + import/parsers: + "@typescript-eslint/parser": [ .ts, .tsx ] ``` In this case, [`@typescript-eslint/parser`](https://www.npmjs.com/package/@typescript-eslint/parser) @@ -451,28 +385,20 @@ For long-lasting processes, like [`eslint_d`] or [`eslint-loader`], however, it' If you never use [`eslint_d`] or [`eslint-loader`], you may set the cache lifetime to `Infinity` and everything should be fine: -```jsonc -// .eslintrc -{ - "settings": { - "import/cache": { - "lifetime": "∞", // or Infinity, in a JS config - }, - }, -} +```yaml +# .eslintrc.yml +settings: + import/cache: + lifetime: ∞ # or Infinity ``` Otherwise, set some integer, and cache entries will be evicted after that many seconds have elapsed: -```jsonc -// .eslintrc -{ - "settings": { - "import/cache": { - "lifetime": 5, // 30 is the default - }, - }, -} +```yaml +# .eslintrc.yml +settings: + import/cache: + lifetime: 5 # 30 is the default ``` [`eslint_d`]: https://www.npmjs.com/package/eslint_d @@ -486,13 +412,10 @@ By default, any package referenced from [`import/external-module-folders`](#impo For example, if your packages in a monorepo are all in `@scope`, you can configure `import/internal-regex` like this -```jsonc -// .eslintrc -{ - "settings": { - "import/internal-regex": "^@scope/", - }, -} +```yaml +# .eslintrc.yml +settings: + import/internal-regex: ^@scope/ ``` ## SublimeLinter-eslint diff --git a/node_modules/eslint-plugin-import/RELEASE.md b/node_modules/eslint-plugin-import/RELEASE.md new file mode 100644 index 0000000000..6c048dc093 --- /dev/null +++ b/node_modules/eslint-plugin-import/RELEASE.md @@ -0,0 +1,54 @@ +# Release steps + +1. create a `release-[x.y.z]` branch from tip of `main` (or whatever release commit) + + ```bash + git checkout main && git pull && git checkout -b release-2.1.0 + ``` + +2. bump `package.json` + update CHANGELOG version links for all releasing packages (i.e., root + any resolvers) + + In changelog for core plugin, normally leave [Unreleased] but update its link at the bottom + to be rooted at the new version's tag, and add a link for the new version rooted + at last version's tag. + + ```markdown + [Unreleased]: https://github.com/import-js/eslint-plugin-import/compare/v2.0.1...HEAD + [2.0.1]: https://github.com/import-js/eslint-plugin-import/compare/v2.0.0...v2.0.1 + ``` + + becomes + + ```markdown + [Unreleased]: https://github.com/import-js/eslint-plugin-import/compare/v2.1.0...HEAD + [2.1.0]: https://github.com/import-js/eslint-plugin-import/compare/v2.0.1...v2.1.0 + [2.0.1]: https://github.com/import-js/eslint-plugin-import/compare/v2.0.0...v2.0.1 + ``` + + Generally, don't use `npm version` for this because it creates a tag, which I normally + wait until signoff from contributors and actually `npm publish`-ing to snap the tag. + +3. create pull request from `release-[x.y.z]` into `release` branch + + I like this because it + - lists all commits in the release + - provides a commentary location to discuss the release + - builds in CI and provides test results + +4. iterate on feedback + - handle other issues + - merge more PRs + - fix issues in changelog/docs + +5. `npm publish` from `release-[x.y.z]` branch + - don't forget resolvers! + +6. tag commit (`v[x.y.z]`) + - again, not forgetting resolvers, if needed (`resolvers/[name]/v[t.u.v]`) + +7. merge `release-[x.y.z]` into `release` ( + - ideally fast-forward, probably with Git CLI instead of Github + +8. merge `release` into `main` + +Done! diff --git a/node_modules/eslint-plugin-import/config/flat/errors.js b/node_modules/eslint-plugin-import/config/flat/errors.js deleted file mode 100644 index 98c19f824d..0000000000 --- a/node_modules/eslint-plugin-import/config/flat/errors.js +++ /dev/null @@ -1,14 +0,0 @@ -/** - * unopinionated config. just the things that are necessarily runtime errors - * waiting to happen. - * @type {Object} - */ -module.exports = { - rules: { - 'import/no-unresolved': 2, - 'import/named': 2, - 'import/namespace': 2, - 'import/default': 2, - 'import/export': 2, - }, -}; diff --git a/node_modules/eslint-plugin-import/config/flat/react.js b/node_modules/eslint-plugin-import/config/flat/react.js deleted file mode 100644 index 0867471422..0000000000 --- a/node_modules/eslint-plugin-import/config/flat/react.js +++ /dev/null @@ -1,19 +0,0 @@ -/** - * Adds `.jsx` as an extension, and enables JSX parsing. - * - * Even if _you_ aren't using JSX (or .jsx) directly, if your dependencies - * define jsnext:main and have JSX internally, you may run into problems - * if you don't enable these settings at the top level. - */ -module.exports = { - settings: { - 'import/extensions': ['.js', '.jsx', '.mjs', '.cjs'], - }, - languageOptions: { - parserOptions: { - ecmaFeatures: { - jsx: true, - }, - }, - }, -}; diff --git a/node_modules/eslint-plugin-import/config/flat/recommended.js b/node_modules/eslint-plugin-import/config/flat/recommended.js deleted file mode 100644 index 11bc1f52a4..0000000000 --- a/node_modules/eslint-plugin-import/config/flat/recommended.js +++ /dev/null @@ -1,26 +0,0 @@ -/** - * The basics. - * @type {Object} - */ -module.exports = { - rules: { - // analysis/correctness - 'import/no-unresolved': 'error', - 'import/named': 'error', - 'import/namespace': 'error', - 'import/default': 'error', - 'import/export': 'error', - - // red flags (thus, warnings) - 'import/no-named-as-default': 'warn', - 'import/no-named-as-default-member': 'warn', - 'import/no-duplicates': 'warn', - }, - - // need all these for parsing dependencies (even if _your_ code doesn't need - // all of them) - languageOptions: { - ecmaVersion: 2018, - sourceType: 'module', - }, -}; diff --git a/node_modules/eslint-plugin-import/config/flat/warnings.js b/node_modules/eslint-plugin-import/config/flat/warnings.js deleted file mode 100644 index e788ff9cde..0000000000 --- a/node_modules/eslint-plugin-import/config/flat/warnings.js +++ /dev/null @@ -1,11 +0,0 @@ -/** - * more opinionated config. - * @type {Object} - */ -module.exports = { - rules: { - 'import/no-named-as-default': 1, - 'import/no-named-as-default-member': 1, - 'import/no-duplicates': 1, - }, -}; diff --git a/node_modules/eslint-plugin-import/config/react.js b/node_modules/eslint-plugin-import/config/react.js index 1ae8e1a51a..68555512d7 100644 --- a/node_modules/eslint-plugin-import/config/react.js +++ b/node_modules/eslint-plugin-import/config/react.js @@ -6,6 +6,7 @@ * if you don't enable these settings at the top level. */ module.exports = { + settings: { 'import/extensions': ['.js', '.jsx'], }, @@ -13,4 +14,5 @@ module.exports = { parserOptions: { ecmaFeatures: { jsx: true }, }, + }; diff --git a/node_modules/eslint-plugin-import/config/typescript.js b/node_modules/eslint-plugin-import/config/typescript.js index d5eb57a465..ff7d0795c8 100644 --- a/node_modules/eslint-plugin-import/config/typescript.js +++ b/node_modules/eslint-plugin-import/config/typescript.js @@ -9,7 +9,7 @@ // `.ts`/`.tsx`/`.js`/`.jsx` implementation. const typeScriptExtensions = ['.ts', '.cts', '.mts', '.tsx']; -const allExtensions = [...typeScriptExtensions, '.js', '.jsx', '.mjs', '.cjs']; +const allExtensions = [...typeScriptExtensions, '.js', '.jsx']; module.exports = { settings: { diff --git a/node_modules/eslint-plugin-import/docs/rules/dynamic-import-chunkname.md b/node_modules/eslint-plugin-import/docs/rules/dynamic-import-chunkname.md index de554148ee..35ae9df516 100644 --- a/node_modules/eslint-plugin-import/docs/rules/dynamic-import-chunkname.md +++ b/node_modules/eslint-plugin-import/docs/rules/dynamic-import-chunkname.md @@ -1,7 +1,5 @@ # import/dynamic-import-chunkname -💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions). - This rule reports any dynamic imports without a webpackChunkName specified in a leading block comment in the proper format. @@ -17,8 +15,7 @@ You can also configure the regex format you'd like to accept for the webpackChun { "dynamic-import-chunkname": [2, { importFunctions: ["dynamicImport"], - webpackChunknameFormat: "[a-zA-Z0-57-9-/_]+", - allowEmpty: false + webpackChunknameFormat: "[a-zA-Z0-57-9-/_]+" }] } ``` @@ -58,13 +55,6 @@ import( // webpackChunkName: "someModule" 'someModule', ); - -// chunk names are disallowed when eager mode is set -import( - /* webpackMode: "eager" */ - /* webpackChunkName: "someModule" */ - 'someModule', -) ``` ### valid @@ -97,38 +87,6 @@ The following patterns are valid: ); ``` -### `allowEmpty: true` - -If you want to allow dynamic imports without a webpackChunkName, you can set `allowEmpty: true` in the rule config. This will allow dynamic imports without a leading comment, or with a leading comment that does not contain a webpackChunkName. - -Given `{ "allowEmpty": true }`: - - -### valid - -The following patterns are valid: - -```javascript -import('someModule'); - -import( - /* webpackChunkName: "someModule" */ - 'someModule', -); -``` - -### invalid - -The following patterns are invalid: - -```javascript -// incorrectly formatted comment -import( - /*webpackChunkName:"someModule"*/ - 'someModule', -); -``` - ## When Not To Use It If you don't care that webpack will autogenerate chunk names and may blow up browser caches and bundle size reports. diff --git a/node_modules/eslint-plugin-import/docs/rules/no-empty-named-blocks.md b/node_modules/eslint-plugin-import/docs/rules/no-empty-named-blocks.md index ad83c535f8..85821d8afe 100644 --- a/node_modules/eslint-plugin-import/docs/rules/no-empty-named-blocks.md +++ b/node_modules/eslint-plugin-import/docs/rules/no-empty-named-blocks.md @@ -1,6 +1,6 @@ # import/no-empty-named-blocks -🔧💡 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix) and manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions). +🔧💡 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix) and manually fixable by [editor suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions). diff --git a/node_modules/eslint-plugin-import/docs/rules/no-extraneous-dependencies.md b/node_modules/eslint-plugin-import/docs/rules/no-extraneous-dependencies.md index 848d5bb0da..547e5c2e57 100644 --- a/node_modules/eslint-plugin-import/docs/rules/no-extraneous-dependencies.md +++ b/node_modules/eslint-plugin-import/docs/rules/no-extraneous-dependencies.md @@ -32,7 +32,7 @@ You can also use an array of globs instead of literal booleans: "import/no-extraneous-dependencies": ["error", {"devDependencies": ["**/*.test.js", "**/*.spec.js"]}] ``` -When using an array of globs, the setting will be set to `true` (no errors reported) if the name of the file being linted (i.e. not the imported file/module) matches a single glob in the array, and `false` otherwise. +When using an array of globs, the setting will be set to `true` (no errors reported) if the name of the file being linted matches a single glob in the array, and `false` otherwise. There are 2 boolean options to opt into checking extra imports that are normally ignored: `includeInternal`, which enables the checking of internal modules, and `includeTypes`, which enables checking of type imports in TypeScript. diff --git a/node_modules/eslint-plugin-import/docs/rules/no-unused-modules.md b/node_modules/eslint-plugin-import/docs/rules/no-unused-modules.md index 359c341ea0..53c2479272 100644 --- a/node_modules/eslint-plugin-import/docs/rules/no-unused-modules.md +++ b/node_modules/eslint-plugin-import/docs/rules/no-unused-modules.md @@ -29,9 +29,8 @@ This rule takes the following option: - **`missingExports`**: if `true`, files without any exports are reported (defaults to `false`) - **`unusedExports`**: if `true`, exports without any static usage within other modules are reported (defaults to `false`) - - **`ignoreUnusedTypeExports`**: if `true`, TypeScript type exports without any static usage within other modules are reported (defaults to `false` and has no effect unless `unusedExports` is `true`) - - **`src`**: an array with files/paths to be analyzed. It only applies to unused exports. Defaults to `process.cwd()`, if not provided - - **`ignoreExports`**: an array with files/paths for which unused exports will not be reported (e.g module entry points in a published package) + - `src`: an array with files/paths to be analyzed. It only applies to unused exports. Defaults to `process.cwd()`, if not provided + - `ignoreExports`: an array with files/paths for which unused exports will not be reported (e.g module entry points in a published package) ### Example for missing exports @@ -117,16 +116,6 @@ export function doAnything() { export default 5 // will not be reported ``` -### Unused exports with `ignoreUnusedTypeExports` set to `true` - -The following will not be reported: - -```ts -export type Foo = {}; // will not be reported -export interface Foo = {}; // will not be reported -export enum Foo {}; // will not be reported -``` - #### Important Note Exports from files listed as a main file (`main`, `browser`, or `bin` fields in `package.json`) will be ignored by default. This only applies if the `package.json` is not set to `private: true` diff --git a/node_modules/eslint-plugin-import/docs/rules/order.md b/node_modules/eslint-plugin-import/docs/rules/order.md index 67849bb7ed..2335699e6c 100644 --- a/node_modules/eslint-plugin-import/docs/rules/order.md +++ b/node_modules/eslint-plugin-import/docs/rules/order.md @@ -77,25 +77,6 @@ import foo from './foo'; var path = require('path'); ``` -## Limitations of `--fix` - -Unbound imports are assumed to have side effects, and will never be moved/reordered. This can cause other imports to get "stuck" around them, and the fix to fail. - -```javascript -import b from 'b' -import 'format.css'; // This will prevent --fix from working. -import a from 'a' -``` - -As a workaround, move unbound imports to be entirely above or below bound ones. - -```javascript -import 'format1.css'; // OK -import b from 'b' -import a from 'a' -import 'format2.css'; // OK -``` - ## Options This rule supports the following options: @@ -193,7 +174,7 @@ Example: ### `pathGroupsExcludedImportTypes: [array]` This defines import types that are not handled by configured pathGroups. -If you have added path groups with patterns that look like `"builtin"` or `"external"` imports, you have to remove this group (`"builtin"` and/or `"external"`) from the default exclusion list (e.g., `["builtin", "external", "object"]`, etc) to sort these path groups correctly. +This is mostly needed when you want to handle path groups that look like external imports. Example: @@ -212,7 +193,29 @@ Example: } ``` -[Import Type](https://github.com/import-js/eslint-plugin-import/blob/HEAD/src/core/importType.js#L90) is resolved as a fixed string in predefined set, it can't be a `patterns`(e.g., `react`, `react-router-dom`, etc). See [#2156] for details. +You can also use `patterns`(e.g., `react`, `react-router-dom`, etc). + +Example: + +```json +{ + "import/order": [ + "error", + { + "pathGroups": [ + { + "pattern": "react", + "group": "builtin", + "position": "before" + } + ], + "pathGroupsExcludedImportTypes": ["react"] + } + ] +} +``` + +The default value is `["builtin", "external", "object"]`. ### `newlines-between: [ignore|always|always-and-inside-groups|never]` diff --git a/node_modules/eslint-plugin-import/lib/ExportMap.js b/node_modules/eslint-plugin-import/lib/ExportMap.js new file mode 100644 index 0000000000..ad841b8593 --- /dev/null +++ b/node_modules/eslint-plugin-import/lib/ExportMap.js @@ -0,0 +1,856 @@ +'use strict';Object.defineProperty(exports, "__esModule", { value: true });var _createClass = function () {function defineProperties(target, props) {for (var i = 0; i < props.length; i++) {var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);}}return function (Constructor, protoProps, staticProps) {if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;};}();exports. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +recursivePatternCapture = recursivePatternCapture;var _fs = require('fs');var _fs2 = _interopRequireDefault(_fs);var _path = require('path');var _doctrine = require('doctrine');var _doctrine2 = _interopRequireDefault(_doctrine);var _debug = require('debug');var _debug2 = _interopRequireDefault(_debug);var _eslint = require('eslint');var _parse = require('eslint-module-utils/parse');var _parse2 = _interopRequireDefault(_parse);var _visit = require('eslint-module-utils/visit');var _visit2 = _interopRequireDefault(_visit);var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);var _ignore = require('eslint-module-utils/ignore');var _ignore2 = _interopRequireDefault(_ignore);var _hash = require('eslint-module-utils/hash');var _unambiguous = require('eslint-module-utils/unambiguous');var unambiguous = _interopRequireWildcard(_unambiguous);var _tsconfigLoader = require('tsconfig-paths/lib/tsconfig-loader');var _arrayIncludes = require('array-includes');var _arrayIncludes2 = _interopRequireDefault(_arrayIncludes);function _interopRequireWildcard(obj) {if (obj && obj.__esModule) {return obj;} else {var newObj = {};if (obj != null) {for (var key in obj) {if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];}}newObj['default'] = obj;return newObj;}}function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _classCallCheck(instance, Constructor) {if (!(instance instanceof Constructor)) {throw new TypeError("Cannot call a class as a function");}}var ts = void 0;var log = (0, _debug2['default'])('eslint-plugin-import:ExportMap');var exportCache = new Map();var tsconfigCache = new Map();var ExportMap = function () {function ExportMap(path) {_classCallCheck(this, ExportMap);this.path = path;this.namespace = new Map(); // todo: restructure to key on path, value is resolver + map of names + this.reexports = new Map(); /** + * star-exports + * @type {Set} of () => ExportMap + */this.dependencies = new Set(); /** + * dependencies of this module that are not explicitly re-exported + * @type {Map} from path = () => ExportMap + */this.imports = new Map();this.errors = []; /** + * type {'ambiguous' | 'Module' | 'Script'} + */this.parseGoal = 'ambiguous';}_createClass(ExportMap, [{ key: 'has', /** + * Note that this does not check explicitly re-exported names for existence + * in the base namespace, but it will expand all `export * from '...'` exports + * if not found in the explicit namespace. + * @param {string} name + * @return {Boolean} true if `name` is exported by this module. + */value: function () {function has(name) {if (this.namespace.has(name)) {return true;}if (this.reexports.has(name)) {return true;} // default exports must be explicitly re-exported (#328) + if (name !== 'default') {var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try {for (var _iterator = this.dependencies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var dep = _step.value;var innerMap = dep(); // todo: report as unresolved? + if (!innerMap) {continue;}if (innerMap.has(name)) {return true;}}} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}}}return false;}return has;}() /** + * ensure that imported name fully resolves. + * @param {string} name + * @return {{ found: boolean, path: ExportMap[] }} + */ }, { key: 'hasDeep', value: function () {function hasDeep(name) {if (this.namespace.has(name)) {return { found: true, path: [this] };}if (this.reexports.has(name)) {var reexports = this.reexports.get(name);var imported = reexports.getImport(); // if import is ignored, return explicit 'null' + if (imported == null) {return { found: true, path: [this] };} // safeguard against cycles, only if name matches + if (imported.path === this.path && reexports.local === name) {return { found: false, path: [this] };}var deep = imported.hasDeep(reexports.local);deep.path.unshift(this);return deep;} // default exports must be explicitly re-exported (#328) + if (name !== 'default') {var _iteratorNormalCompletion2 = true;var _didIteratorError2 = false;var _iteratorError2 = undefined;try {for (var _iterator2 = this.dependencies[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {var dep = _step2.value;var innerMap = dep();if (innerMap == null) {return { found: true, path: [this] };} // todo: report as unresolved? + if (!innerMap) {continue;} // safeguard against cycles + if (innerMap.path === this.path) {continue;}var innerValue = innerMap.hasDeep(name);if (innerValue.found) {innerValue.path.unshift(this);return innerValue;}}} catch (err) {_didIteratorError2 = true;_iteratorError2 = err;} finally {try {if (!_iteratorNormalCompletion2 && _iterator2['return']) {_iterator2['return']();}} finally {if (_didIteratorError2) {throw _iteratorError2;}}}}return { found: false, path: [this] };}return hasDeep;}() }, { key: 'get', value: function () {function get(name) {if (this.namespace.has(name)) {return this.namespace.get(name);}if (this.reexports.has(name)) {var reexports = this.reexports.get(name);var imported = reexports.getImport(); // if import is ignored, return explicit 'null' + if (imported == null) {return null;} // safeguard against cycles, only if name matches + if (imported.path === this.path && reexports.local === name) {return undefined;}return imported.get(reexports.local);} // default exports must be explicitly re-exported (#328) + if (name !== 'default') {var _iteratorNormalCompletion3 = true;var _didIteratorError3 = false;var _iteratorError3 = undefined;try {for (var _iterator3 = this.dependencies[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {var dep = _step3.value;var innerMap = dep(); // todo: report as unresolved? + if (!innerMap) {continue;} // safeguard against cycles + if (innerMap.path === this.path) {continue;}var innerValue = innerMap.get(name);if (innerValue !== undefined) {return innerValue;}}} catch (err) {_didIteratorError3 = true;_iteratorError3 = err;} finally {try {if (!_iteratorNormalCompletion3 && _iterator3['return']) {_iterator3['return']();}} finally {if (_didIteratorError3) {throw _iteratorError3;}}}}return undefined;}return get;}() }, { key: 'forEach', value: function () {function forEach(callback, thisArg) {var _this = this;this.namespace.forEach(function (v, n) {callback.call(thisArg, v, n, _this);});this.reexports.forEach(function (reexports, name) {var reexported = reexports.getImport(); // can't look up meta for ignored re-exports (#348) + callback.call(thisArg, reexported && reexported.get(reexports.local), name, _this);});this.dependencies.forEach(function (dep) {var d = dep(); // CJS / ignored dependencies won't exist (#717) + if (d == null) {return;}d.forEach(function (v, n) {if (n !== 'default') {callback.call(thisArg, v, n, _this);}});});}return forEach;}() // todo: keys, values, entries? + }, { key: 'reportErrors', value: function () {function reportErrors(context, declaration) {var msg = this.errors.map(function (e) {return String(e.message) + ' (' + String(e.lineNumber) + ':' + String(e.column) + ')';}).join(', ');context.report({ node: declaration.source, message: 'Parse errors in imported module \'' + String(declaration.source.value) + '\': ' + String(msg) });}return reportErrors;}() }, { key: 'hasDefault', get: function () {function get() {return this.get('default') != null;}return get;}() // stronger than this.has + }, { key: 'size', get: function () {function get() {var size = this.namespace.size + this.reexports.size;this.dependencies.forEach(function (dep) {var d = dep(); // CJS / ignored dependencies won't exist (#717) + if (d == null) {return;}size += d.size;});return size;}return get;}() }]);return ExportMap;}(); /** + * parse docs from the first node that has leading comments + */exports['default'] = ExportMap;function captureDoc(source, docStyleParsers) {var metadata = {}; // 'some' short-circuits on first 'true' + for (var _len = arguments.length, nodes = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {nodes[_key - 2] = arguments[_key];}nodes.some(function (n) {try {var leadingComments = void 0; // n.leadingComments is legacy `attachComments` behavior + if ('leadingComments' in n) {leadingComments = n.leadingComments;} else if (n.range) {leadingComments = source.getCommentsBefore(n);}if (!leadingComments || leadingComments.length === 0) {return false;}for (var name in docStyleParsers) {var doc = docStyleParsers[name](leadingComments);if (doc) {metadata.doc = doc;}}return true;} catch (err) {return false;}});return metadata;}var availableDocStyleParsers = { jsdoc: captureJsDoc, tomdoc: captureTomDoc }; /** + * parse JSDoc from leading comments + * @param {object[]} comments + * @return {{ doc: object }} + */function captureJsDoc(comments) {var doc = void 0; // capture XSDoc + comments.forEach(function (comment) {// skip non-block comments + if (comment.type !== 'Block') {return;}try {doc = _doctrine2['default'].parse(comment.value, { unwrap: true });} catch (err) {/* don't care, for now? maybe add to `errors?` */}});return doc;} /** + * parse TomDoc section from comments + */function captureTomDoc(comments) {// collect lines up to first paragraph break + var lines = [];for (var i = 0; i < comments.length; i++) {var comment = comments[i];if (comment.value.match(/^\s*$/)) {break;}lines.push(comment.value.trim());} // return doctrine-like object + var statusMatch = lines.join(' ').match(/^(Public|Internal|Deprecated):\s*(.+)/);if (statusMatch) {return { description: statusMatch[2], tags: [{ title: statusMatch[1].toLowerCase(), description: statusMatch[2] }] };}}var supportedImportTypes = new Set(['ImportDefaultSpecifier', 'ImportNamespaceSpecifier']);ExportMap.get = function (source, context) {var path = (0, _resolve2['default'])(source, context);if (path == null) {return null;}return ExportMap['for'](childContext(path, context));};ExportMap['for'] = function (context) {var path = context.path;var cacheKey = context.cacheKey || (0, _hash.hashObject)(context).digest('hex');var exportMap = exportCache.get(cacheKey); // return cached ignore + if (exportMap === null) {return null;}var stats = _fs2['default'].statSync(path);if (exportMap != null) {// date equality check + if (exportMap.mtime - stats.mtime === 0) {return exportMap;} // future: check content equality? + } // check valid extensions first + if (!(0, _ignore.hasValidExtension)(path, context)) {exportCache.set(cacheKey, null);return null;} // check for and cache ignore + if ((0, _ignore2['default'])(path, context)) {log('ignored path due to ignore settings:', path);exportCache.set(cacheKey, null);return null;}var content = _fs2['default'].readFileSync(path, { encoding: 'utf8' }); // check for and cache unambiguous modules + if (!unambiguous.test(content)) {log('ignored path due to unambiguous regex:', path);exportCache.set(cacheKey, null);return null;}log('cache miss', cacheKey, 'for path', path);exportMap = ExportMap.parse(path, content, context); // ambiguous modules return null + if (exportMap == null) {log('ignored path due to ambiguous parse:', path);exportCache.set(cacheKey, null);return null;}exportMap.mtime = stats.mtime;exportCache.set(cacheKey, exportMap);return exportMap;};ExportMap.parse = function (path, content, context) {var m = new ExportMap(path);var isEsModuleInteropTrue = isEsModuleInterop();var ast = void 0;var visitorKeys = void 0;try {var result = (0, _parse2['default'])(path, content, context);ast = result.ast;visitorKeys = result.visitorKeys;} catch (err) {m.errors.push(err);return m; // can't continue + }m.visitorKeys = visitorKeys;var hasDynamicImports = false;function processDynamicImport(source) {hasDynamicImports = true;if (source.type !== 'Literal') {return null;}var p = remotePath(source.value);if (p == null) {return null;}var importedSpecifiers = new Set();importedSpecifiers.add('ImportNamespaceSpecifier');var getter = thunkFor(p, context);m.imports.set(p, { getter: getter, declarations: new Set([{ source: { // capturing actual node reference holds full AST in memory! + value: source.value, loc: source.loc }, importedSpecifiers: importedSpecifiers, dynamic: true }]) });}(0, _visit2['default'])(ast, visitorKeys, { ImportExpression: function () {function ImportExpression(node) {processDynamicImport(node.source);}return ImportExpression;}(), CallExpression: function () {function CallExpression(node) {if (node.callee.type === 'Import') {processDynamicImport(node.arguments[0]);}}return CallExpression;}() });var unambiguouslyESM = unambiguous.isModule(ast);if (!unambiguouslyESM && !hasDynamicImports) {return null;}var docstyle = context.settings && context.settings['import/docstyle'] || ['jsdoc'];var docStyleParsers = {};docstyle.forEach(function (style) {docStyleParsers[style] = availableDocStyleParsers[style];}); // attempt to collect module doc + if (ast.comments) {ast.comments.some(function (c) {if (c.type !== 'Block') {return false;}try {var doc = _doctrine2['default'].parse(c.value, { unwrap: true });if (doc.tags.some(function (t) {return t.title === 'module';})) {m.doc = doc;return true;}} catch (err) {/* ignore */}return false;});}var namespaces = new Map();function remotePath(value) {return _resolve2['default'].relative(value, path, context.settings);}function resolveImport(value) {var rp = remotePath(value);if (rp == null) {return null;}return ExportMap['for'](childContext(rp, context));}function getNamespace(identifier) {if (!namespaces.has(identifier.name)) {return;}return function () {return resolveImport(namespaces.get(identifier.name));};}function addNamespace(object, identifier) {var nsfn = getNamespace(identifier);if (nsfn) {Object.defineProperty(object, 'namespace', { get: nsfn });}return object;}function processSpecifier(s, n, m) {var nsource = n.source && n.source.value;var exportMeta = {};var local = void 0;switch (s.type) {case 'ExportDefaultSpecifier':if (!nsource) {return;}local = 'default';break;case 'ExportNamespaceSpecifier':m.namespace.set(s.exported.name, Object.defineProperty(exportMeta, 'namespace', { get: function () {function get() {return resolveImport(nsource);}return get;}() }));return;case 'ExportAllDeclaration':m.namespace.set(s.exported.name || s.exported.value, addNamespace(exportMeta, s.source.value));return;case 'ExportSpecifier':if (!n.source) {m.namespace.set(s.exported.name || s.exported.value, addNamespace(exportMeta, s.local));return;} // else falls through + default:local = s.local.name;break;} // todo: JSDoc + m.reexports.set(s.exported.name, { local: local, getImport: function () {function getImport() {return resolveImport(nsource);}return getImport;}() });}function captureDependencyWithSpecifiers(n) {// import type { Foo } (TS and Flow); import typeof { Foo } (Flow) + var declarationIsType = n.importKind === 'type' || n.importKind === 'typeof'; // import './foo' or import {} from './foo' (both 0 specifiers) is a side effect and + // shouldn't be considered to be just importing types + var specifiersOnlyImportingTypes = n.specifiers.length > 0;var importedSpecifiers = new Set();n.specifiers.forEach(function (specifier) {if (specifier.type === 'ImportSpecifier') {importedSpecifiers.add(specifier.imported.name || specifier.imported.value);} else if (supportedImportTypes.has(specifier.type)) {importedSpecifiers.add(specifier.type);} // import { type Foo } (Flow); import { typeof Foo } (Flow) + specifiersOnlyImportingTypes = specifiersOnlyImportingTypes && (specifier.importKind === 'type' || specifier.importKind === 'typeof');});captureDependency(n, declarationIsType || specifiersOnlyImportingTypes, importedSpecifiers);}function captureDependency(_ref, isOnlyImportingTypes) {var source = _ref.source;var importedSpecifiers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();if (source == null) {return null;}var p = remotePath(source.value);if (p == null) {return null;}var declarationMetadata = { // capturing actual node reference holds full AST in memory! + source: { value: source.value, loc: source.loc }, isOnlyImportingTypes: isOnlyImportingTypes, importedSpecifiers: importedSpecifiers };var existing = m.imports.get(p);if (existing != null) {existing.declarations.add(declarationMetadata);return existing.getter;}var getter = thunkFor(p, context);m.imports.set(p, { getter: getter, declarations: new Set([declarationMetadata]) });return getter;}var source = makeSourceCode(content, ast);function readTsConfig(context) {var tsconfigInfo = (0, _tsconfigLoader.tsConfigLoader)({ cwd: context.parserOptions && context.parserOptions.tsconfigRootDir || process.cwd(), getEnv: function () {function getEnv(key) {return process.env[key];}return getEnv;}() });try {if (tsconfigInfo.tsConfigPath !== undefined) {// Projects not using TypeScript won't have `typescript` installed. + if (!ts) {ts = require('typescript');} // eslint-disable-line import/no-extraneous-dependencies + var configFile = ts.readConfigFile(tsconfigInfo.tsConfigPath, ts.sys.readFile);return ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, _path.dirname)(tsconfigInfo.tsConfigPath));}} catch (e) {// Catch any errors + }return null;}function isEsModuleInterop() {var cacheKey = (0, _hash.hashObject)({ tsconfigRootDir: context.parserOptions && context.parserOptions.tsconfigRootDir }).digest('hex');var tsConfig = tsconfigCache.get(cacheKey);if (typeof tsConfig === 'undefined') {tsConfig = readTsConfig(context);tsconfigCache.set(cacheKey, tsConfig);}return tsConfig && tsConfig.options ? tsConfig.options.esModuleInterop : false;}ast.body.forEach(function (n) {if (n.type === 'ExportDefaultDeclaration') {var exportMeta = captureDoc(source, docStyleParsers, n);if (n.declaration.type === 'Identifier') {addNamespace(exportMeta, n.declaration);}m.namespace.set('default', exportMeta);return;}if (n.type === 'ExportAllDeclaration') {var getter = captureDependency(n, n.exportKind === 'type');if (getter) {m.dependencies.add(getter);}if (n.exported) {processSpecifier(n, n.exported, m);}return;} // capture namespaces in case of later export + if (n.type === 'ImportDeclaration') {captureDependencyWithSpecifiers(n);var ns = n.specifiers.find(function (s) {return s.type === 'ImportNamespaceSpecifier';});if (ns) {namespaces.set(ns.local.name, n.source.value);}return;}if (n.type === 'ExportNamedDeclaration') {captureDependencyWithSpecifiers(n); // capture declaration + if (n.declaration != null) {switch (n.declaration.type) {case 'FunctionDeclaration':case 'ClassDeclaration':case 'TypeAlias': // flowtype with babel-eslint parser + case 'InterfaceDeclaration':case 'DeclareFunction':case 'TSDeclareFunction':case 'TSEnumDeclaration':case 'TSTypeAliasDeclaration':case 'TSInterfaceDeclaration':case 'TSAbstractClassDeclaration':case 'TSModuleDeclaration':m.namespace.set(n.declaration.id.name, captureDoc(source, docStyleParsers, n));break;case 'VariableDeclaration':n.declaration.declarations.forEach(function (d) {recursivePatternCapture(d.id, function (id) {return m.namespace.set(id.name, captureDoc(source, docStyleParsers, d, n));});});break;default:}}n.specifiers.forEach(function (s) {return processSpecifier(s, n, m);});}var exports = ['TSExportAssignment'];if (isEsModuleInteropTrue) {exports.push('TSNamespaceExportDeclaration');} // This doesn't declare anything, but changes what's being exported. + if ((0, _arrayIncludes2['default'])(exports, n.type)) {var exportedName = n.type === 'TSNamespaceExportDeclaration' ? (n.id || n.name).name : n.expression && n.expression.name || n.expression.id && n.expression.id.name || null;var declTypes = ['VariableDeclaration', 'ClassDeclaration', 'TSDeclareFunction', 'TSEnumDeclaration', 'TSTypeAliasDeclaration', 'TSInterfaceDeclaration', 'TSAbstractClassDeclaration', 'TSModuleDeclaration'];var exportedDecls = ast.body.filter(function (_ref2) {var type = _ref2.type,id = _ref2.id,declarations = _ref2.declarations;return (0, _arrayIncludes2['default'])(declTypes, type) && (id && id.name === exportedName || declarations && declarations.find(function (d) {return d.id.name === exportedName;}));});if (exportedDecls.length === 0) {// Export is not referencing any local declaration, must be re-exporting + m.namespace.set('default', captureDoc(source, docStyleParsers, n));return;}if (isEsModuleInteropTrue // esModuleInterop is on in tsconfig + && !m.namespace.has('default') // and default isn't added already + ) {m.namespace.set('default', {}); // add default export + }exportedDecls.forEach(function (decl) {if (decl.type === 'TSModuleDeclaration') {if (decl.body && decl.body.type === 'TSModuleDeclaration') {m.namespace.set(decl.body.id.name, captureDoc(source, docStyleParsers, decl.body));} else if (decl.body && decl.body.body) {decl.body.body.forEach(function (moduleBlockNode) {// Export-assignment exports all members in the namespace, + // explicitly exported or not. + var namespaceDecl = moduleBlockNode.type === 'ExportNamedDeclaration' ? moduleBlockNode.declaration : moduleBlockNode;if (!namespaceDecl) {// TypeScript can check this for us; we needn't + } else if (namespaceDecl.type === 'VariableDeclaration') {namespaceDecl.declarations.forEach(function (d) {return recursivePatternCapture(d.id, function (id) {return m.namespace.set(id.name, captureDoc(source, docStyleParsers, decl, namespaceDecl, moduleBlockNode));});});} else {m.namespace.set(namespaceDecl.id.name, captureDoc(source, docStyleParsers, moduleBlockNode));}});}} else {// Export as default + m.namespace.set('default', captureDoc(source, docStyleParsers, decl));}});}});if (isEsModuleInteropTrue // esModuleInterop is on in tsconfig + && m.namespace.size > 0 // anything is exported + && !m.namespace.has('default') // and default isn't added already + ) {m.namespace.set('default', {}); // add default export + }if (unambiguouslyESM) {m.parseGoal = 'Module';}return m;}; /** + * The creation of this closure is isolated from other scopes + * to avoid over-retention of unrelated variables, which has + * caused memory leaks. See #1266. + */function thunkFor(p, context) {return function () {return ExportMap['for'](childContext(p, context));};} /** + * Traverse a pattern/identifier node, calling 'callback' + * for each leaf identifier. + * @param {node} pattern + * @param {Function} callback + * @return {void} + */function recursivePatternCapture(pattern, callback) {switch (pattern.type) {case 'Identifier': // base case + callback(pattern);break;case 'ObjectPattern':pattern.properties.forEach(function (p) {if (p.type === 'ExperimentalRestProperty' || p.type === 'RestElement') {callback(p.argument);return;}recursivePatternCapture(p.value, callback);});break;case 'ArrayPattern':pattern.elements.forEach(function (element) {if (element == null) {return;}if (element.type === 'ExperimentalRestProperty' || element.type === 'RestElement') {callback(element.argument);return;}recursivePatternCapture(element, callback);});break;case 'AssignmentPattern':callback(pattern.left);break;default:}}var parserOptionsHash = '';var prevParserOptions = '';var settingsHash = '';var prevSettings = ''; /** + * don't hold full context object in memory, just grab what we need. + * also calculate a cacheKey, where parts of the cacheKey hash are memoized + */function childContext(path, context) {var settings = context.settings,parserOptions = context.parserOptions,parserPath = context.parserPath;if (JSON.stringify(settings) !== prevSettings) {settingsHash = (0, _hash.hashObject)({ settings: settings }).digest('hex');prevSettings = JSON.stringify(settings);}if (JSON.stringify(parserOptions) !== prevParserOptions) {parserOptionsHash = (0, _hash.hashObject)({ parserOptions: parserOptions }).digest('hex');prevParserOptions = JSON.stringify(parserOptions);}return { cacheKey: String(parserPath) + parserOptionsHash + settingsHash + String(path), settings: settings, parserOptions: parserOptions, parserPath: parserPath, path: path };} /** + * sometimes legacy support isn't _that_ hard... right? + */function makeSourceCode(text, ast) {if (_eslint.SourceCode.length > 1) {// ESLint 3 + return new _eslint.SourceCode(text, ast);} else {// ESLint 4, 5 + return new _eslint.SourceCode({ text: text, ast: ast });}} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ExportMap.js"],"names":["recursivePatternCapture","unambiguous","ts","log","exportCache","Map","tsconfigCache","ExportMap","path","namespace","reexports","dependencies","Set","imports","errors","parseGoal","name","has","dep","innerMap","found","get","imported","getImport","local","deep","hasDeep","unshift","innerValue","undefined","callback","thisArg","forEach","v","n","call","reexported","d","context","declaration","msg","map","e","message","lineNumber","column","join","report","node","source","value","size","captureDoc","docStyleParsers","metadata","nodes","some","leadingComments","range","getCommentsBefore","length","doc","err","availableDocStyleParsers","jsdoc","captureJsDoc","tomdoc","captureTomDoc","comments","comment","type","doctrine","parse","unwrap","lines","i","match","push","trim","statusMatch","description","tags","title","toLowerCase","supportedImportTypes","childContext","cacheKey","digest","exportMap","stats","fs","statSync","mtime","set","content","readFileSync","encoding","test","m","isEsModuleInteropTrue","isEsModuleInterop","ast","visitorKeys","result","hasDynamicImports","processDynamicImport","p","remotePath","importedSpecifiers","add","getter","thunkFor","declarations","loc","dynamic","ImportExpression","CallExpression","callee","arguments","unambiguouslyESM","isModule","docstyle","settings","style","c","t","namespaces","resolve","relative","resolveImport","rp","getNamespace","identifier","addNamespace","object","nsfn","Object","defineProperty","processSpecifier","s","nsource","exportMeta","exported","captureDependencyWithSpecifiers","declarationIsType","importKind","specifiersOnlyImportingTypes","specifiers","specifier","captureDependency","isOnlyImportingTypes","declarationMetadata","existing","makeSourceCode","readTsConfig","tsconfigInfo","cwd","parserOptions","tsconfigRootDir","process","getEnv","key","env","tsConfigPath","require","configFile","readConfigFile","sys","readFile","parseJsonConfigFileContent","config","tsConfig","options","esModuleInterop","body","exportKind","ns","find","id","exports","exportedName","expression","declTypes","exportedDecls","filter","decl","moduleBlockNode","namespaceDecl","pattern","properties","argument","elements","element","left","parserOptionsHash","prevParserOptions","settingsHash","prevSettings","parserPath","JSON","stringify","String","text","SourceCode"],"mappings":"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","file":"ExportMap.js","sourcesContent":["import fs from 'fs';\nimport { dirname } from 'path';\n\nimport doctrine from 'doctrine';\n\nimport debug from 'debug';\n\nimport { SourceCode } from 'eslint';\n\nimport parse from 'eslint-module-utils/parse';\nimport visit from 'eslint-module-utils/visit';\nimport resolve from 'eslint-module-utils/resolve';\nimport isIgnored, { hasValidExtension } from 'eslint-module-utils/ignore';\n\nimport { hashObject } from 'eslint-module-utils/hash';\nimport * as unambiguous from 'eslint-module-utils/unambiguous';\n\nimport { tsConfigLoader } from 'tsconfig-paths/lib/tsconfig-loader';\n\nimport includes from 'array-includes';\n\nlet ts;\n\nconst log = debug('eslint-plugin-import:ExportMap');\n\nconst exportCache = new Map();\nconst tsconfigCache = new Map();\n\nexport default class ExportMap {\n  constructor(path) {\n    this.path = path;\n    this.namespace = new Map();\n    // todo: restructure to key on path, value is resolver + map of names\n    this.reexports = new Map();\n    /**\n     * star-exports\n     * @type {Set} of () => ExportMap\n     */\n    this.dependencies = new Set();\n    /**\n     * dependencies of this module that are not explicitly re-exported\n     * @type {Map} from path = () => ExportMap\n     */\n    this.imports = new Map();\n    this.errors = [];\n    /**\n     * type {'ambiguous' | 'Module' | 'Script'}\n     */\n    this.parseGoal = 'ambiguous';\n  }\n\n  get hasDefault() { return this.get('default') != null; } // stronger than this.has\n\n  get size() {\n    let size = this.namespace.size + this.reexports.size;\n    this.dependencies.forEach((dep) => {\n      const d = dep();\n      // CJS / ignored dependencies won't exist (#717)\n      if (d == null) { return; }\n      size += d.size;\n    });\n    return size;\n  }\n\n  /**\n   * Note that this does not check explicitly re-exported names for existence\n   * in the base namespace, but it will expand all `export * from '...'` exports\n   * if not found in the explicit namespace.\n   * @param  {string}  name\n   * @return {Boolean} true if `name` is exported by this module.\n   */\n  has(name) {\n    if (this.namespace.has(name)) { return true; }\n    if (this.reexports.has(name)) { return true; }\n\n    // default exports must be explicitly re-exported (#328)\n    if (name !== 'default') {\n      for (const dep of this.dependencies) {\n        const innerMap = dep();\n\n        // todo: report as unresolved?\n        if (!innerMap) { continue; }\n\n        if (innerMap.has(name)) { return true; }\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * ensure that imported name fully resolves.\n   * @param  {string} name\n   * @return {{ found: boolean, path: ExportMap[] }}\n   */\n  hasDeep(name) {\n    if (this.namespace.has(name)) { return { found: true, path: [this] }; }\n\n    if (this.reexports.has(name)) {\n      const reexports = this.reexports.get(name);\n      const imported = reexports.getImport();\n\n      // if import is ignored, return explicit 'null'\n      if (imported == null) { return { found: true, path: [this] }; }\n\n      // safeguard against cycles, only if name matches\n      if (imported.path === this.path && reexports.local === name) {\n        return { found: false, path: [this] };\n      }\n\n      const deep = imported.hasDeep(reexports.local);\n      deep.path.unshift(this);\n\n      return deep;\n    }\n\n    // default exports must be explicitly re-exported (#328)\n    if (name !== 'default') {\n      for (const dep of this.dependencies) {\n        const innerMap = dep();\n        if (innerMap == null) { return { found: true, path: [this] }; }\n        // todo: report as unresolved?\n        if (!innerMap) { continue; }\n\n        // safeguard against cycles\n        if (innerMap.path === this.path) { continue; }\n\n        const innerValue = innerMap.hasDeep(name);\n        if (innerValue.found) {\n          innerValue.path.unshift(this);\n          return innerValue;\n        }\n      }\n    }\n\n    return { found: false, path: [this] };\n  }\n\n  get(name) {\n    if (this.namespace.has(name)) { return this.namespace.get(name); }\n\n    if (this.reexports.has(name)) {\n      const reexports = this.reexports.get(name);\n      const imported = reexports.getImport();\n\n      // if import is ignored, return explicit 'null'\n      if (imported == null) { return null; }\n\n      // safeguard against cycles, only if name matches\n      if (imported.path === this.path && reexports.local === name) { return undefined; }\n\n      return imported.get(reexports.local);\n    }\n\n    // default exports must be explicitly re-exported (#328)\n    if (name !== 'default') {\n      for (const dep of this.dependencies) {\n        const innerMap = dep();\n        // todo: report as unresolved?\n        if (!innerMap) { continue; }\n\n        // safeguard against cycles\n        if (innerMap.path === this.path) { continue; }\n\n        const innerValue = innerMap.get(name);\n        if (innerValue !== undefined) { return innerValue; }\n      }\n    }\n\n    return undefined;\n  }\n\n  forEach(callback, thisArg) {\n    this.namespace.forEach((v, n) => { callback.call(thisArg, v, n, this); });\n\n    this.reexports.forEach((reexports, name) => {\n      const reexported = reexports.getImport();\n      // can't look up meta for ignored re-exports (#348)\n      callback.call(thisArg, reexported && reexported.get(reexports.local), name, this);\n    });\n\n    this.dependencies.forEach((dep) => {\n      const d = dep();\n      // CJS / ignored dependencies won't exist (#717)\n      if (d == null) { return; }\n\n      d.forEach((v, n) => {\n        if (n !== 'default') {\n          callback.call(thisArg, v, n, this);\n        }\n      });\n    });\n  }\n\n  // todo: keys, values, entries?\n\n  reportErrors(context, declaration) {\n    const msg = this.errors\n      .map((e) => `${e.message} (${e.lineNumber}:${e.column})`)\n      .join(', ');\n    context.report({\n      node: declaration.source,\n      message: `Parse errors in imported module '${declaration.source.value}': ${msg}`,\n    });\n  }\n}\n\n/**\n * parse docs from the first node that has leading comments\n */\nfunction captureDoc(source, docStyleParsers, ...nodes) {\n  const metadata = {};\n\n  // 'some' short-circuits on first 'true'\n  nodes.some((n) => {\n    try {\n\n      let leadingComments;\n\n      // n.leadingComments is legacy `attachComments` behavior\n      if ('leadingComments' in n) {\n        leadingComments = n.leadingComments;\n      } else if (n.range) {\n        leadingComments = source.getCommentsBefore(n);\n      }\n\n      if (!leadingComments || leadingComments.length === 0) { return false; }\n\n      for (const name in docStyleParsers) {\n        const doc = docStyleParsers[name](leadingComments);\n        if (doc) {\n          metadata.doc = doc;\n        }\n      }\n\n      return true;\n    } catch (err) {\n      return false;\n    }\n  });\n\n  return metadata;\n}\n\nconst availableDocStyleParsers = {\n  jsdoc: captureJsDoc,\n  tomdoc: captureTomDoc,\n};\n\n/**\n * parse JSDoc from leading comments\n * @param {object[]} comments\n * @return {{ doc: object }}\n */\nfunction captureJsDoc(comments) {\n  let doc;\n\n  // capture XSDoc\n  comments.forEach((comment) => {\n    // skip non-block comments\n    if (comment.type !== 'Block') { return; }\n    try {\n      doc = doctrine.parse(comment.value, { unwrap: true });\n    } catch (err) {\n      /* don't care, for now? maybe add to `errors?` */\n    }\n  });\n\n  return doc;\n}\n\n/**\n  * parse TomDoc section from comments\n  */\nfunction captureTomDoc(comments) {\n  // collect lines up to first paragraph break\n  const lines = [];\n  for (let i = 0; i < comments.length; i++) {\n    const comment = comments[i];\n    if (comment.value.match(/^\\s*$/)) { break; }\n    lines.push(comment.value.trim());\n  }\n\n  // return doctrine-like object\n  const statusMatch = lines.join(' ').match(/^(Public|Internal|Deprecated):\\s*(.+)/);\n  if (statusMatch) {\n    return {\n      description: statusMatch[2],\n      tags: [{\n        title: statusMatch[1].toLowerCase(),\n        description: statusMatch[2],\n      }],\n    };\n  }\n}\n\nconst supportedImportTypes = new Set(['ImportDefaultSpecifier', 'ImportNamespaceSpecifier']);\n\nExportMap.get = function (source, context) {\n  const path = resolve(source, context);\n  if (path == null) { return null; }\n\n  return ExportMap.for(childContext(path, context));\n};\n\nExportMap.for = function (context) {\n  const { path } = context;\n\n  const cacheKey = context.cacheKey || hashObject(context).digest('hex');\n  let exportMap = exportCache.get(cacheKey);\n\n  // return cached ignore\n  if (exportMap === null) { return null; }\n\n  const stats = fs.statSync(path);\n  if (exportMap != null) {\n    // date equality check\n    if (exportMap.mtime - stats.mtime === 0) {\n      return exportMap;\n    }\n    // future: check content equality?\n  }\n\n  // check valid extensions first\n  if (!hasValidExtension(path, context)) {\n    exportCache.set(cacheKey, null);\n    return null;\n  }\n\n  // check for and cache ignore\n  if (isIgnored(path, context)) {\n    log('ignored path due to ignore settings:', path);\n    exportCache.set(cacheKey, null);\n    return null;\n  }\n\n  const content = fs.readFileSync(path, { encoding: 'utf8' });\n\n  // check for and cache unambiguous modules\n  if (!unambiguous.test(content)) {\n    log('ignored path due to unambiguous regex:', path);\n    exportCache.set(cacheKey, null);\n    return null;\n  }\n\n  log('cache miss', cacheKey, 'for path', path);\n  exportMap = ExportMap.parse(path, content, context);\n\n  // ambiguous modules return null\n  if (exportMap == null) {\n    log('ignored path due to ambiguous parse:', path);\n    exportCache.set(cacheKey, null);\n    return null;\n  }\n\n  exportMap.mtime = stats.mtime;\n\n  exportCache.set(cacheKey, exportMap);\n  return exportMap;\n};\n\nExportMap.parse = function (path, content, context) {\n  const m = new ExportMap(path);\n  const isEsModuleInteropTrue = isEsModuleInterop();\n\n  let ast;\n  let visitorKeys;\n  try {\n    const result = parse(path, content, context);\n    ast = result.ast;\n    visitorKeys = result.visitorKeys;\n  } catch (err) {\n    m.errors.push(err);\n    return m; // can't continue\n  }\n\n  m.visitorKeys = visitorKeys;\n\n  let hasDynamicImports = false;\n\n  function processDynamicImport(source) {\n    hasDynamicImports = true;\n    if (source.type !== 'Literal') {\n      return null;\n    }\n    const p = remotePath(source.value);\n    if (p == null) {\n      return null;\n    }\n    const importedSpecifiers = new Set();\n    importedSpecifiers.add('ImportNamespaceSpecifier');\n    const getter = thunkFor(p, context);\n    m.imports.set(p, {\n      getter,\n      declarations: new Set([{\n        source: {\n        // capturing actual node reference holds full AST in memory!\n          value: source.value,\n          loc: source.loc,\n        },\n        importedSpecifiers,\n        dynamic: true,\n      }]),\n    });\n  }\n\n  visit(ast, visitorKeys, {\n    ImportExpression(node) {\n      processDynamicImport(node.source);\n    },\n    CallExpression(node) {\n      if (node.callee.type === 'Import') {\n        processDynamicImport(node.arguments[0]);\n      }\n    },\n  });\n\n  const unambiguouslyESM = unambiguous.isModule(ast);\n  if (!unambiguouslyESM && !hasDynamicImports) { return null; }\n\n  const docstyle = context.settings && context.settings['import/docstyle'] || ['jsdoc'];\n  const docStyleParsers = {};\n  docstyle.forEach((style) => {\n    docStyleParsers[style] = availableDocStyleParsers[style];\n  });\n\n  // attempt to collect module doc\n  if (ast.comments) {\n    ast.comments.some((c) => {\n      if (c.type !== 'Block') { return false; }\n      try {\n        const doc = doctrine.parse(c.value, { unwrap: true });\n        if (doc.tags.some((t) => t.title === 'module')) {\n          m.doc = doc;\n          return true;\n        }\n      } catch (err) { /* ignore */ }\n      return false;\n    });\n  }\n\n  const namespaces = new Map();\n\n  function remotePath(value) {\n    return resolve.relative(value, path, context.settings);\n  }\n\n  function resolveImport(value) {\n    const rp = remotePath(value);\n    if (rp == null) { return null; }\n    return ExportMap.for(childContext(rp, context));\n  }\n\n  function getNamespace(identifier) {\n    if (!namespaces.has(identifier.name)) { return; }\n\n    return function () {\n      return resolveImport(namespaces.get(identifier.name));\n    };\n  }\n\n  function addNamespace(object, identifier) {\n    const nsfn = getNamespace(identifier);\n    if (nsfn) {\n      Object.defineProperty(object, 'namespace', { get: nsfn });\n    }\n\n    return object;\n  }\n\n  function processSpecifier(s, n, m) {\n    const nsource = n.source && n.source.value;\n    const exportMeta = {};\n    let local;\n\n    switch (s.type) {\n      case 'ExportDefaultSpecifier':\n        if (!nsource) { return; }\n        local = 'default';\n        break;\n      case 'ExportNamespaceSpecifier':\n        m.namespace.set(s.exported.name, Object.defineProperty(exportMeta, 'namespace', {\n          get() { return resolveImport(nsource); },\n        }));\n        return;\n      case 'ExportAllDeclaration':\n        m.namespace.set(s.exported.name || s.exported.value, addNamespace(exportMeta, s.source.value));\n        return;\n      case 'ExportSpecifier':\n        if (!n.source) {\n          m.namespace.set(s.exported.name || s.exported.value, addNamespace(exportMeta, s.local));\n          return;\n        }\n      // else falls through\n      default:\n        local = s.local.name;\n        break;\n    }\n\n    // todo: JSDoc\n    m.reexports.set(s.exported.name, { local, getImport: () => resolveImport(nsource) });\n  }\n\n  function captureDependencyWithSpecifiers(n) {\n    // import type { Foo } (TS and Flow); import typeof { Foo } (Flow)\n    const declarationIsType = n.importKind === 'type' || n.importKind === 'typeof';\n    // import './foo' or import {} from './foo' (both 0 specifiers) is a side effect and\n    // shouldn't be considered to be just importing types\n    let specifiersOnlyImportingTypes = n.specifiers.length > 0;\n    const importedSpecifiers = new Set();\n    n.specifiers.forEach((specifier) => {\n      if (specifier.type === 'ImportSpecifier') {\n        importedSpecifiers.add(specifier.imported.name || specifier.imported.value);\n      } else if (supportedImportTypes.has(specifier.type)) {\n        importedSpecifiers.add(specifier.type);\n      }\n\n      // import { type Foo } (Flow); import { typeof Foo } (Flow)\n      specifiersOnlyImportingTypes = specifiersOnlyImportingTypes\n        && (specifier.importKind === 'type' || specifier.importKind === 'typeof');\n    });\n    captureDependency(n, declarationIsType || specifiersOnlyImportingTypes, importedSpecifiers);\n  }\n\n  function captureDependency({ source }, isOnlyImportingTypes, importedSpecifiers = new Set()) {\n    if (source == null) { return null; }\n\n    const p = remotePath(source.value);\n    if (p == null) { return null; }\n\n    const declarationMetadata = {\n      // capturing actual node reference holds full AST in memory!\n      source: { value: source.value, loc: source.loc },\n      isOnlyImportingTypes,\n      importedSpecifiers,\n    };\n\n    const existing = m.imports.get(p);\n    if (existing != null) {\n      existing.declarations.add(declarationMetadata);\n      return existing.getter;\n    }\n\n    const getter = thunkFor(p, context);\n    m.imports.set(p, { getter, declarations: new Set([declarationMetadata]) });\n    return getter;\n  }\n\n  const source = makeSourceCode(content, ast);\n\n  function readTsConfig(context) {\n    const tsconfigInfo = tsConfigLoader({\n      cwd: context.parserOptions && context.parserOptions.tsconfigRootDir || process.cwd(),\n      getEnv: (key) => process.env[key],\n    });\n    try {\n      if (tsconfigInfo.tsConfigPath !== undefined) {\n        // Projects not using TypeScript won't have `typescript` installed.\n        if (!ts) { ts = require('typescript'); } // eslint-disable-line import/no-extraneous-dependencies\n\n        const configFile = ts.readConfigFile(tsconfigInfo.tsConfigPath, ts.sys.readFile);\n        return ts.parseJsonConfigFileContent(\n          configFile.config,\n          ts.sys,\n          dirname(tsconfigInfo.tsConfigPath),\n        );\n      }\n    } catch (e) {\n      // Catch any errors\n    }\n\n    return null;\n  }\n\n  function isEsModuleInterop() {\n    const cacheKey = hashObject({\n      tsconfigRootDir: context.parserOptions && context.parserOptions.tsconfigRootDir,\n    }).digest('hex');\n    let tsConfig = tsconfigCache.get(cacheKey);\n    if (typeof tsConfig === 'undefined') {\n      tsConfig = readTsConfig(context);\n      tsconfigCache.set(cacheKey, tsConfig);\n    }\n\n    return tsConfig && tsConfig.options ? tsConfig.options.esModuleInterop : false;\n  }\n\n  ast.body.forEach(function (n) {\n    if (n.type === 'ExportDefaultDeclaration') {\n      const exportMeta = captureDoc(source, docStyleParsers, n);\n      if (n.declaration.type === 'Identifier') {\n        addNamespace(exportMeta, n.declaration);\n      }\n      m.namespace.set('default', exportMeta);\n      return;\n    }\n\n    if (n.type === 'ExportAllDeclaration') {\n      const getter = captureDependency(n, n.exportKind === 'type');\n      if (getter) { m.dependencies.add(getter); }\n      if (n.exported) {\n        processSpecifier(n, n.exported, m);\n      }\n      return;\n    }\n\n    // capture namespaces in case of later export\n    if (n.type === 'ImportDeclaration') {\n      captureDependencyWithSpecifiers(n);\n\n      const ns = n.specifiers.find((s) => s.type === 'ImportNamespaceSpecifier');\n      if (ns) {\n        namespaces.set(ns.local.name, n.source.value);\n      }\n      return;\n    }\n\n    if (n.type === 'ExportNamedDeclaration') {\n      captureDependencyWithSpecifiers(n);\n\n      // capture declaration\n      if (n.declaration != null) {\n        switch (n.declaration.type) {\n          case 'FunctionDeclaration':\n          case 'ClassDeclaration':\n          case 'TypeAlias': // flowtype with babel-eslint parser\n          case 'InterfaceDeclaration':\n          case 'DeclareFunction':\n          case 'TSDeclareFunction':\n          case 'TSEnumDeclaration':\n          case 'TSTypeAliasDeclaration':\n          case 'TSInterfaceDeclaration':\n          case 'TSAbstractClassDeclaration':\n          case 'TSModuleDeclaration':\n            m.namespace.set(n.declaration.id.name, captureDoc(source, docStyleParsers, n));\n            break;\n          case 'VariableDeclaration':\n            n.declaration.declarations.forEach((d) => {\n              recursivePatternCapture(\n                d.id,\n                (id) => m.namespace.set(id.name, captureDoc(source, docStyleParsers, d, n)),\n              );\n            });\n            break;\n          default:\n        }\n      }\n\n      n.specifiers.forEach((s) => processSpecifier(s, n, m));\n    }\n\n    const exports = ['TSExportAssignment'];\n    if (isEsModuleInteropTrue) {\n      exports.push('TSNamespaceExportDeclaration');\n    }\n\n    // This doesn't declare anything, but changes what's being exported.\n    if (includes(exports, n.type)) {\n      const exportedName = n.type === 'TSNamespaceExportDeclaration'\n        ? (n.id || n.name).name\n        : n.expression && n.expression.name || n.expression.id && n.expression.id.name || null;\n      const declTypes = [\n        'VariableDeclaration',\n        'ClassDeclaration',\n        'TSDeclareFunction',\n        'TSEnumDeclaration',\n        'TSTypeAliasDeclaration',\n        'TSInterfaceDeclaration',\n        'TSAbstractClassDeclaration',\n        'TSModuleDeclaration',\n      ];\n      const exportedDecls = ast.body.filter(({ type, id, declarations }) => includes(declTypes, type) && (\n        id && id.name === exportedName || declarations && declarations.find((d) => d.id.name === exportedName)\n      ));\n      if (exportedDecls.length === 0) {\n        // Export is not referencing any local declaration, must be re-exporting\n        m.namespace.set('default', captureDoc(source, docStyleParsers, n));\n        return;\n      }\n      if (\n        isEsModuleInteropTrue // esModuleInterop is on in tsconfig\n        && !m.namespace.has('default') // and default isn't added already\n      ) {\n        m.namespace.set('default', {}); // add default export\n      }\n      exportedDecls.forEach((decl) => {\n        if (decl.type === 'TSModuleDeclaration') {\n          if (decl.body && decl.body.type === 'TSModuleDeclaration') {\n            m.namespace.set(decl.body.id.name, captureDoc(source, docStyleParsers, decl.body));\n          } else if (decl.body && decl.body.body) {\n            decl.body.body.forEach((moduleBlockNode) => {\n              // Export-assignment exports all members in the namespace,\n              // explicitly exported or not.\n              const namespaceDecl = moduleBlockNode.type === 'ExportNamedDeclaration'\n                ? moduleBlockNode.declaration\n                : moduleBlockNode;\n\n              if (!namespaceDecl) {\n                // TypeScript can check this for us; we needn't\n              } else if (namespaceDecl.type === 'VariableDeclaration') {\n                namespaceDecl.declarations.forEach((d) => recursivePatternCapture(d.id, (id) => m.namespace.set(\n                  id.name,\n                  captureDoc(source, docStyleParsers, decl, namespaceDecl, moduleBlockNode),\n                )),\n                );\n              } else {\n                m.namespace.set(\n                  namespaceDecl.id.name,\n                  captureDoc(source, docStyleParsers, moduleBlockNode));\n              }\n            });\n          }\n        } else {\n          // Export as default\n          m.namespace.set('default', captureDoc(source, docStyleParsers, decl));\n        }\n      });\n    }\n  });\n\n  if (\n    isEsModuleInteropTrue // esModuleInterop is on in tsconfig\n    && m.namespace.size > 0 // anything is exported\n    && !m.namespace.has('default') // and default isn't added already\n  ) {\n    m.namespace.set('default', {}); // add default export\n  }\n\n  if (unambiguouslyESM) {\n    m.parseGoal = 'Module';\n  }\n  return m;\n};\n\n/**\n * The creation of this closure is isolated from other scopes\n * to avoid over-retention of unrelated variables, which has\n * caused memory leaks. See #1266.\n */\nfunction thunkFor(p, context) {\n  return () => ExportMap.for(childContext(p, context));\n}\n\n/**\n * Traverse a pattern/identifier node, calling 'callback'\n * for each leaf identifier.\n * @param  {node}   pattern\n * @param  {Function} callback\n * @return {void}\n */\nexport function recursivePatternCapture(pattern, callback) {\n  switch (pattern.type) {\n    case 'Identifier': // base case\n      callback(pattern);\n      break;\n\n    case 'ObjectPattern':\n      pattern.properties.forEach((p) => {\n        if (p.type === 'ExperimentalRestProperty' || p.type === 'RestElement') {\n          callback(p.argument);\n          return;\n        }\n        recursivePatternCapture(p.value, callback);\n      });\n      break;\n\n    case 'ArrayPattern':\n      pattern.elements.forEach((element) => {\n        if (element == null) { return; }\n        if (element.type === 'ExperimentalRestProperty' || element.type === 'RestElement') {\n          callback(element.argument);\n          return;\n        }\n        recursivePatternCapture(element, callback);\n      });\n      break;\n\n    case 'AssignmentPattern':\n      callback(pattern.left);\n      break;\n    default:\n  }\n}\n\nlet parserOptionsHash = '';\nlet prevParserOptions = '';\nlet settingsHash = '';\nlet prevSettings = '';\n/**\n * don't hold full context object in memory, just grab what we need.\n * also calculate a cacheKey, where parts of the cacheKey hash are memoized\n */\nfunction childContext(path, context) {\n  const { settings, parserOptions, parserPath } = context;\n\n  if (JSON.stringify(settings) !== prevSettings) {\n    settingsHash = hashObject({ settings }).digest('hex');\n    prevSettings = JSON.stringify(settings);\n  }\n\n  if (JSON.stringify(parserOptions) !== prevParserOptions) {\n    parserOptionsHash = hashObject({ parserOptions }).digest('hex');\n    prevParserOptions = JSON.stringify(parserOptions);\n  }\n\n  return {\n    cacheKey: String(parserPath) + parserOptionsHash + settingsHash + String(path),\n    settings,\n    parserOptions,\n    parserPath,\n    path,\n  };\n}\n\n/**\n * sometimes legacy support isn't _that_ hard... right?\n */\nfunction makeSourceCode(text, ast) {\n  if (SourceCode.length > 1) {\n    // ESLint 3\n    return new SourceCode(text, ast);\n  } else {\n    // ESLint 4, 5\n    return new SourceCode({ text, ast });\n  }\n}\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/core/fsWalk.js b/node_modules/eslint-plugin-import/lib/core/fsWalk.js deleted file mode 100644 index fd3ef73eb5..0000000000 --- a/node_modules/eslint-plugin-import/lib/core/fsWalk.js +++ /dev/null @@ -1,49 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports. - - - - - - - - - - - - - - - - - - - - -walkSync = walkSync;var _path = require('path');var _path2 = _interopRequireDefault(_path);var _fs = require('fs');function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };} /** @typedef {{ name: string, path: string, dirent: import('fs').Dirent }} Entry */ /** - * Do a comprehensive walk of the provided src directory, and collect all entries. Filter out - * any directories or entries using the optional filter functions. - * @param {string} root - path to the root of the folder we're walking - * @param {{ deepFilter?: (entry: Entry) => boolean, entryFilter?: (entry: Entry) => boolean }} options - * @param {Entry} currentEntry - entry for the current directory we're working in - * @param {Entry[]} existingEntries - list of all entries so far - * @returns {Entry[]} an array of directory entries - */ /** - * This is intended to provide similar capability as the sync api from @nodelib/fs.walk, until `eslint-plugin-import` - * is willing to modernize and update their minimum node version to at least v16. I intentionally made the - * shape of the API (for the part we're using) the same as @nodelib/fs.walk so that that can be swapped in - * when the repo is ready for it. - */function walkSync(root, options, currentEntry, existingEntries) {// Extract the filter functions. Default to evaluating true, if no filter passed in. - var _options$deepFilter = options.deepFilter,deepFilter = _options$deepFilter === undefined ? function () {return true;} : _options$deepFilter,_options$entryFilter = options.entryFilter,entryFilter = _options$entryFilter === undefined ? function () {return true;} : _options$entryFilter;var entryList = existingEntries || [];var currentRelativePath = currentEntry ? currentEntry.path : '.';var fullPath = currentEntry ? _path2['default'].join(root, currentEntry.path) : root;var dirents = (0, _fs.readdirSync)(fullPath, { withFileTypes: true });dirents.forEach(function (dirent) {/** @type {Entry} */var entry = { name: dirent.name, path: _path2['default'].join(currentRelativePath, dirent.name), dirent: dirent }; - - - if (dirent.isDirectory() && deepFilter(entry)) { - entryList.push(entry); - entryList = walkSync(root, options, entry, entryList); - } else if (dirent.isFile() && entryFilter(entry)) { - entryList.push(entry); - } - }); - - return entryList; -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/core/importType.js b/node_modules/eslint-plugin-import/lib/core/importType.js index fd76a54638..749a15a39c 100644 --- a/node_modules/eslint-plugin-import/lib/core/importType.js +++ b/node_modules/eslint-plugin-import/lib/core/importType.js @@ -5,7 +5,6 @@ -isScoped = isScoped;exports. @@ -19,24 +18,26 @@ isScoped = isScoped;exports. +isAbsolute = isAbsolute;exports. -isAbsolute = isAbsolute;exports. +isBuiltIn = isBuiltIn;exports. -isBuiltIn = isBuiltIn;exports. +isExternalModule = isExternalModule;exports. +isExternalModuleMain = isExternalModuleMain;exports. @@ -54,10 +55,13 @@ isBuiltIn = isBuiltIn;exports. +isScoped = isScoped;exports. +isScopedMain = isScopedMain;exports['default'] = + @@ -103,14 +107,12 @@ isBuiltIn = isBuiltIn;exports. -isExternalModule = isExternalModule;exports. -isExternalModuleMain = isExternalModuleMain;exports. @@ -118,11 +120,10 @@ isExternalModuleMain = isExternalModuleMain;exports. -isScopedMain = isScopedMain;exports['default'] = -resolveImportType;var _path = require('path');var _isCoreModule = require('is-core-module');var _isCoreModule2 = _interopRequireDefault(_isCoreModule);var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);var _packagePath = require('./packagePath');function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}var scopedRegExp = /^@[^/]+\/?[^/]+/;function isScoped(name) {return name && scopedRegExp.test(name);}function baseModule(name) {if (isScoped(name)) {var _name$split = name.split('/'),_name$split2 = _slicedToArray(_name$split, 2),scope = _name$split2[0],_pkg = _name$split2[1];return String(scope) + '/' + String(_pkg);}var _name$split3 = name.split('/'),_name$split4 = _slicedToArray(_name$split3, 1),pkg = _name$split4[0];return pkg;}function isInternalRegexMatch(name, settings) {var internalScope = settings && settings['import/internal-regex'];return internalScope && new RegExp(internalScope).test(name);}function isAbsolute(name) {return typeof name === 'string' && (0, _path.isAbsolute)(name);} // path is defined only when a resolver resolves to a non-standard path -function isBuiltIn(name, settings, path) {if (path || !name) {return false;}var base = baseModule(name);var extras = settings && settings['import/core-modules'] || [];return (0, _isCoreModule2['default'])(base) || extras.indexOf(base) > -1;}var moduleRegExp = /^\w/;function isModule(name) {return name && moduleRegExp.test(name);}var moduleMainRegExp = /^[\w]((?!\/).)*$/;function isModuleMain(name) {return name && moduleMainRegExp.test(name);}function isRelativeToParent(name) {return (/^\.\.$|^\.\.[\\/]/.test(name));}var indexFiles = ['.', './', './index', './index.js'];function isIndex(name) {return indexFiles.indexOf(name) !== -1;}function isRelativeToSibling(name) {return (/^\.[\\/]/.test(name));}function isExternalPath(path, context) {if (!path) {return false;}var settings = context.settings;var packagePath = (0, _packagePath.getContextPackagePath)(context);if ((0, _path.relative)(packagePath, path).startsWith('..')) {return true;}var folders = settings && settings['import/external-module-folders'] || ['node_modules'];return folders.some(function (folder) {var folderPath = (0, _path.resolve)(packagePath, folder);var relativePath = (0, _path.relative)(folderPath, path);return !relativePath.startsWith('..');});}function isInternalPath(path, context) {if (!path) {return false;}var packagePath = (0, _packagePath.getContextPackagePath)(context);return !(0, _path.relative)(packagePath, path).startsWith('../');}function isExternalLookingName(name) {return isModule(name) || isScoped(name);}function typeTest(name, context, path) {var settings = context.settings;if (isInternalRegexMatch(name, settings)) {return 'internal';}if (isAbsolute(name, settings, path)) {return 'absolute';}if (isBuiltIn(name, settings, path)) {return 'builtin';}if (isRelativeToParent(name, settings, path)) {return 'parent';}if (isIndex(name, settings, path)) {return 'index';}if (isRelativeToSibling(name, settings, path)) {return 'sibling';}if (isExternalPath(path, context)) {return 'external';}if (isInternalPath(path, context)) {return 'internal';}if (isExternalLookingName(name)) {return 'external';}return 'unknown';}function isExternalModule(name, path, context) {if (arguments.length < 3) {throw new TypeError('isExternalModule: name, path, and context are all required');}return (isModule(name) || isScoped(name)) && typeTest(name, context, path) === 'external';}function isExternalModuleMain(name, path, context) {if (arguments.length < 3) {throw new TypeError('isExternalModule: name, path, and context are all required');}return isModuleMain(name) && typeTest(name, context, path) === 'external';}var scopedMainRegExp = /^@[^/]+\/?[^/]+$/;function isScopedMain(name) {return name && scopedMainRegExp.test(name);}function resolveImportType(name, context) {return typeTest(name, context, (0, _resolve2['default'])(name, context)); +resolveImportType;var _path = require('path');var _isCoreModule = require('is-core-module');var _isCoreModule2 = _interopRequireDefault(_isCoreModule);var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);var _packagePath = require('./packagePath');function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function baseModule(name) {if (isScoped(name)) {var _name$split = name.split('/'),_name$split2 = _slicedToArray(_name$split, 2),scope = _name$split2[0],_pkg = _name$split2[1];return String(scope) + '/' + String(_pkg);}var _name$split3 = name.split('/'),_name$split4 = _slicedToArray(_name$split3, 1),pkg = _name$split4[0];return pkg;}function isInternalRegexMatch(name, settings) {var internalScope = settings && settings['import/internal-regex'];return internalScope && new RegExp(internalScope).test(name);}function isAbsolute(name) {return typeof name === 'string' && (0, _path.isAbsolute)(name);} // path is defined only when a resolver resolves to a non-standard path +function isBuiltIn(name, settings, path) {if (path || !name) {return false;}var base = baseModule(name);var extras = settings && settings['import/core-modules'] || [];return (0, _isCoreModule2['default'])(base) || extras.indexOf(base) > -1;}function isExternalModule(name, path, context) {if (arguments.length < 3) {throw new TypeError('isExternalModule: name, path, and context are all required');}return (isModule(name) || isScoped(name)) && typeTest(name, context, path) === 'external';}function isExternalModuleMain(name, path, context) {if (arguments.length < 3) {throw new TypeError('isExternalModule: name, path, and context are all required');}return isModuleMain(name) && typeTest(name, context, path) === 'external';}var moduleRegExp = /^\w/;function isModule(name) {return name && moduleRegExp.test(name);}var moduleMainRegExp = /^[\w]((?!\/).)*$/;function isModuleMain(name) {return name && moduleMainRegExp.test(name);}var scopedRegExp = /^@[^/]+\/?[^/]+/;function isScoped(name) {return name && scopedRegExp.test(name);}var scopedMainRegExp = /^@[^/]+\/?[^/]+$/;function isScopedMain(name) {return name && scopedMainRegExp.test(name);}function isRelativeToParent(name) {return (/^\.\.$|^\.\.[\\/]/.test(name));}var indexFiles = ['.', './', './index', './index.js'];function isIndex(name) {return indexFiles.indexOf(name) !== -1;}function isRelativeToSibling(name) {return (/^\.[\\/]/.test(name));}function isExternalPath(path, context) {if (!path) {return false;}var settings = context.settings;var packagePath = (0, _packagePath.getContextPackagePath)(context);if ((0, _path.relative)(packagePath, path).startsWith('..')) {return true;}var folders = settings && settings['import/external-module-folders'] || ['node_modules'];return folders.some(function (folder) {var folderPath = (0, _path.resolve)(packagePath, folder);var relativePath = (0, _path.relative)(folderPath, path);return !relativePath.startsWith('..');});}function isInternalPath(path, context) {if (!path) {return false;}var packagePath = (0, _packagePath.getContextPackagePath)(context);return !(0, _path.relative)(packagePath, path).startsWith('../');}function isExternalLookingName(name) {return isModule(name) || isScoped(name);}function typeTest(name, context, path) {var settings = context.settings;if (isInternalRegexMatch(name, settings)) {return 'internal';}if (isAbsolute(name, settings, path)) {return 'absolute';}if (isBuiltIn(name, settings, path)) {return 'builtin';}if (isRelativeToParent(name, settings, path)) {return 'parent';}if (isIndex(name, settings, path)) {return 'index';}if (isRelativeToSibling(name, settings, path)) {return 'sibling';}if (isExternalPath(path, context)) {return 'external';}if (isInternalPath(path, context)) {return 'internal';}if (isExternalLookingName(name)) {return 'external';}return 'unknown';}function resolveImportType(name, context) {return typeTest(name, context, (0, _resolve2['default'])(name, context)); } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/core/importType.js"],"names":["isScoped","isAbsolute","isBuiltIn","isExternalModule","isExternalModuleMain","isScopedMain","resolveImportType","scopedRegExp","name","test","baseModule","split","scope","pkg","isInternalRegexMatch","settings","internalScope","RegExp","path","base","extras","indexOf","moduleRegExp","isModule","moduleMainRegExp","isModuleMain","isRelativeToParent","indexFiles","isIndex","isRelativeToSibling","isExternalPath","context","packagePath","startsWith","folders","some","folder","folderPath","relativePath","isInternalPath","isExternalLookingName","typeTest","arguments","length","TypeError","scopedMainRegExp"],"mappings":"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","file":"importType.js","sourcesContent":["import { isAbsolute as nodeIsAbsolute, relative, resolve as nodeResolve } from 'path';\nimport isCoreModule from 'is-core-module';\n\nimport resolve from 'eslint-module-utils/resolve';\nimport { getContextPackagePath } from './packagePath';\n\nconst scopedRegExp = /^@[^/]+\\/?[^/]+/;\nexport function isScoped(name) {\n  return name && scopedRegExp.test(name);\n}\n\nfunction baseModule(name) {\n  if (isScoped(name)) {\n    const [scope, pkg] = name.split('/');\n    return `${scope}/${pkg}`;\n  }\n  const [pkg] = name.split('/');\n  return pkg;\n}\n\nfunction isInternalRegexMatch(name, settings) {\n  const internalScope = settings && settings['import/internal-regex'];\n  return internalScope && new RegExp(internalScope).test(name);\n}\n\nexport function isAbsolute(name) {\n  return typeof name === 'string' && nodeIsAbsolute(name);\n}\n\n// path is defined only when a resolver resolves to a non-standard path\nexport function isBuiltIn(name, settings, path) {\n  if (path || !name) { return false; }\n  const base = baseModule(name);\n  const extras = settings && settings['import/core-modules'] || [];\n  return isCoreModule(base) || extras.indexOf(base) > -1;\n}\n\nconst moduleRegExp = /^\\w/;\nfunction isModule(name) {\n  return name && moduleRegExp.test(name);\n}\n\nconst moduleMainRegExp = /^[\\w]((?!\\/).)*$/;\nfunction isModuleMain(name) {\n  return name && moduleMainRegExp.test(name);\n}\n\nfunction isRelativeToParent(name) {\n  return (/^\\.\\.$|^\\.\\.[\\\\/]/).test(name);\n}\nconst indexFiles = ['.', './', './index', './index.js'];\nfunction isIndex(name) {\n  return indexFiles.indexOf(name) !== -1;\n}\n\nfunction isRelativeToSibling(name) {\n  return (/^\\.[\\\\/]/).test(name);\n}\n\nfunction isExternalPath(path, context) {\n  if (!path) {\n    return false;\n  }\n\n  const { settings } = context;\n  const packagePath = getContextPackagePath(context);\n\n  if (relative(packagePath, path).startsWith('..')) {\n    return true;\n  }\n\n  const folders = settings && settings['import/external-module-folders'] || ['node_modules'];\n  return folders.some((folder) => {\n    const folderPath = nodeResolve(packagePath, folder);\n    const relativePath = relative(folderPath, path);\n    return !relativePath.startsWith('..');\n  });\n}\n\nfunction isInternalPath(path, context) {\n  if (!path) {\n    return false;\n  }\n  const packagePath = getContextPackagePath(context);\n  return !relative(packagePath, path).startsWith('../');\n}\n\nfunction isExternalLookingName(name) {\n  return isModule(name) || isScoped(name);\n}\n\nfunction typeTest(name, context, path) {\n  const { settings } = context;\n  if (isInternalRegexMatch(name, settings)) { return 'internal'; }\n  if (isAbsolute(name, settings, path)) { return 'absolute'; }\n  if (isBuiltIn(name, settings, path)) { return 'builtin'; }\n  if (isRelativeToParent(name, settings, path)) { return 'parent'; }\n  if (isIndex(name, settings, path)) { return 'index'; }\n  if (isRelativeToSibling(name, settings, path)) { return 'sibling'; }\n  if (isExternalPath(path, context)) { return 'external'; }\n  if (isInternalPath(path, context)) { return 'internal'; }\n  if (isExternalLookingName(name)) { return 'external'; }\n  return 'unknown';\n}\n\nexport function isExternalModule(name, path, context) {\n  if (arguments.length < 3) {\n    throw new TypeError('isExternalModule: name, path, and context are all required');\n  }\n  return (isModule(name) || isScoped(name)) && typeTest(name, context, path) === 'external';\n}\n\nexport function isExternalModuleMain(name, path, context) {\n  if (arguments.length < 3) {\n    throw new TypeError('isExternalModule: name, path, and context are all required');\n  }\n  return isModuleMain(name) && typeTest(name, context, path) === 'external';\n}\n\nconst scopedMainRegExp = /^@[^/]+\\/?[^/]+$/;\nexport function isScopedMain(name) {\n  return name && scopedMainRegExp.test(name);\n}\n\nexport default function resolveImportType(name, context) {\n  return typeTest(name, context, resolve(name, context));\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/core/importType.js"],"names":["isAbsolute","isBuiltIn","isExternalModule","isExternalModuleMain","isScoped","isScopedMain","resolveImportType","baseModule","name","split","scope","pkg","isInternalRegexMatch","settings","internalScope","RegExp","test","path","base","extras","indexOf","context","arguments","length","TypeError","isModule","typeTest","isModuleMain","moduleRegExp","moduleMainRegExp","scopedRegExp","scopedMainRegExp","isRelativeToParent","indexFiles","isIndex","isRelativeToSibling","isExternalPath","packagePath","startsWith","folders","some","folder","folderPath","relativePath","isInternalPath","isExternalLookingName"],"mappings":"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","file":"importType.js","sourcesContent":["import { isAbsolute as nodeIsAbsolute, relative, resolve as nodeResolve } from 'path';\nimport isCoreModule from 'is-core-module';\n\nimport resolve from 'eslint-module-utils/resolve';\nimport { getContextPackagePath } from './packagePath';\n\nfunction baseModule(name) {\n  if (isScoped(name)) {\n    const [scope, pkg] = name.split('/');\n    return `${scope}/${pkg}`;\n  }\n  const [pkg] = name.split('/');\n  return pkg;\n}\n\nfunction isInternalRegexMatch(name, settings) {\n  const internalScope = settings && settings['import/internal-regex'];\n  return internalScope && new RegExp(internalScope).test(name);\n}\n\nexport function isAbsolute(name) {\n  return typeof name === 'string' && nodeIsAbsolute(name);\n}\n\n// path is defined only when a resolver resolves to a non-standard path\nexport function isBuiltIn(name, settings, path) {\n  if (path || !name) { return false; }\n  const base = baseModule(name);\n  const extras = settings && settings['import/core-modules'] || [];\n  return isCoreModule(base) || extras.indexOf(base) > -1;\n}\n\nexport function isExternalModule(name, path, context) {\n  if (arguments.length < 3) {\n    throw new TypeError('isExternalModule: name, path, and context are all required');\n  }\n  return (isModule(name) || isScoped(name)) && typeTest(name, context, path) === 'external';\n}\n\nexport function isExternalModuleMain(name, path, context) {\n  if (arguments.length < 3) {\n    throw new TypeError('isExternalModule: name, path, and context are all required');\n  }\n  return isModuleMain(name) && typeTest(name, context, path) === 'external';\n}\n\nconst moduleRegExp = /^\\w/;\nfunction isModule(name) {\n  return name && moduleRegExp.test(name);\n}\n\nconst moduleMainRegExp = /^[\\w]((?!\\/).)*$/;\nfunction isModuleMain(name) {\n  return name && moduleMainRegExp.test(name);\n}\n\nconst scopedRegExp = /^@[^/]+\\/?[^/]+/;\nexport function isScoped(name) {\n  return name && scopedRegExp.test(name);\n}\n\nconst scopedMainRegExp = /^@[^/]+\\/?[^/]+$/;\nexport function isScopedMain(name) {\n  return name && scopedMainRegExp.test(name);\n}\n\nfunction isRelativeToParent(name) {\n  return (/^\\.\\.$|^\\.\\.[\\\\/]/).test(name);\n}\n\nconst indexFiles = ['.', './', './index', './index.js'];\nfunction isIndex(name) {\n  return indexFiles.indexOf(name) !== -1;\n}\n\nfunction isRelativeToSibling(name) {\n  return (/^\\.[\\\\/]/).test(name);\n}\n\nfunction isExternalPath(path, context) {\n  if (!path) {\n    return false;\n  }\n\n  const { settings } = context;\n  const packagePath = getContextPackagePath(context);\n\n  if (relative(packagePath, path).startsWith('..')) {\n    return true;\n  }\n\n  const folders = settings && settings['import/external-module-folders'] || ['node_modules'];\n  return folders.some((folder) => {\n    const folderPath = nodeResolve(packagePath, folder);\n    const relativePath = relative(folderPath, path);\n    return !relativePath.startsWith('..');\n  });\n}\n\nfunction isInternalPath(path, context) {\n  if (!path) {\n    return false;\n  }\n  const packagePath = getContextPackagePath(context);\n  return !relative(packagePath, path).startsWith('../');\n}\n\nfunction isExternalLookingName(name) {\n  return isModule(name) || isScoped(name);\n}\n\nfunction typeTest(name, context, path) {\n  const { settings } = context;\n  if (isInternalRegexMatch(name, settings)) { return 'internal'; }\n  if (isAbsolute(name, settings, path)) { return 'absolute'; }\n  if (isBuiltIn(name, settings, path)) { return 'builtin'; }\n  if (isRelativeToParent(name, settings, path)) { return 'parent'; }\n  if (isIndex(name, settings, path)) { return 'index'; }\n  if (isRelativeToSibling(name, settings, path)) { return 'sibling'; }\n  if (isExternalPath(path, context)) { return 'external'; }\n  if (isInternalPath(path, context)) { return 'internal'; }\n  if (isExternalLookingName(name)) { return 'external'; }\n  return 'unknown';\n}\n\nexport default function resolveImportType(name, context) {\n  return typeTest(name, context, resolve(name, context));\n}\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/core/packagePath.js b/node_modules/eslint-plugin-import/lib/core/packagePath.js index 74bedc3172..84eb212ade 100644 --- a/node_modules/eslint-plugin-import/lib/core/packagePath.js +++ b/node_modules/eslint-plugin-import/lib/core/packagePath.js @@ -2,16 +2,16 @@ -getFilePackagePath = getFilePackagePath;exports. +getContextPackagePath = getContextPackagePath;exports. +getFilePackagePath = getFilePackagePath;exports. -getContextPackagePath = getContextPackagePath;exports. -getFilePackageName = getFilePackageName;var _path = require('path');var _pkgUp = require('eslint-module-utils/pkgUp');var _pkgUp2 = _interopRequireDefault(_pkgUp);var _readPkgUp2 = require('eslint-module-utils/readPkgUp');var _readPkgUp3 = _interopRequireDefault(_readPkgUp2);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function getFilePackagePath(filePath) {var fp = (0, _pkgUp2['default'])({ cwd: filePath });return (0, _path.dirname)(fp);}function getContextPackagePath(context) {return getFilePackagePath(context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename());}function getFilePackageName(filePath) {var _readPkgUp = +getFilePackageName = getFilePackageName;var _path = require('path');var _pkgUp = require('eslint-module-utils/pkgUp');var _pkgUp2 = _interopRequireDefault(_pkgUp);var _readPkgUp2 = require('eslint-module-utils/readPkgUp');var _readPkgUp3 = _interopRequireDefault(_readPkgUp2);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function getContextPackagePath(context) {return getFilePackagePath(context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename());}function getFilePackagePath(filePath) {var fp = (0, _pkgUp2['default'])({ cwd: filePath });return (0, _path.dirname)(fp);}function getFilePackageName(filePath) {var _readPkgUp = (0, _readPkgUp3['default'])({ cwd: filePath, normalize: false }),pkg = _readPkgUp.pkg,path = _readPkgUp.path; if (pkg) { // recursion in case of intermediate esm package.json without name found @@ -19,4 +19,4 @@ getFilePackageName = getFilePackageName;var _path = require('path');var _pkgUp = } return null; } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/builder.js b/node_modules/eslint-plugin-import/lib/exportMap/builder.js deleted file mode 100644 index f68aae2ade..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/builder.js +++ /dev/null @@ -1,206 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });var _createClass = function () {function defineProperties(target, props) {for (var i = 0; i < props.length; i++) {var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);}}return function (Constructor, protoProps, staticProps) {if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;};}();var _fs = require('fs');var _fs2 = _interopRequireDefault(_fs); - -var _doctrine = require('doctrine');var _doctrine2 = _interopRequireDefault(_doctrine); - -var _debug = require('debug');var _debug2 = _interopRequireDefault(_debug); - -var _parse2 = require('eslint-module-utils/parse');var _parse3 = _interopRequireDefault(_parse2); -var _visit = require('eslint-module-utils/visit');var _visit2 = _interopRequireDefault(_visit); -var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve); -var _ignore = require('eslint-module-utils/ignore');var _ignore2 = _interopRequireDefault(_ignore); - -var _hash = require('eslint-module-utils/hash'); -var _unambiguous = require('eslint-module-utils/unambiguous');var unambiguous = _interopRequireWildcard(_unambiguous); - -var _ = require('.');var _2 = _interopRequireDefault(_); -var _childContext = require('./childContext');var _childContext2 = _interopRequireDefault(_childContext); -var _typescript = require('./typescript'); -var _remotePath = require('./remotePath'); -var _visitor = require('./visitor');var _visitor2 = _interopRequireDefault(_visitor);function _interopRequireWildcard(obj) {if (obj && obj.__esModule) {return obj;} else {var newObj = {};if (obj != null) {for (var key in obj) {if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];}}newObj['default'] = obj;return newObj;}}function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _classCallCheck(instance, Constructor) {if (!(instance instanceof Constructor)) {throw new TypeError("Cannot call a class as a function");}} - -var log = (0, _debug2['default'])('eslint-plugin-import:ExportMap'); - -var exportCache = new Map(); - -/** - * The creation of this closure is isolated from other scopes - * to avoid over-retention of unrelated variables, which has - * caused memory leaks. See #1266. - */ -function thunkFor(p, context) { - // eslint-disable-next-line no-use-before-define - return function () {return ExportMapBuilder['for']((0, _childContext2['default'])(p, context));}; -}var - -ExportMapBuilder = function () {function ExportMapBuilder() {_classCallCheck(this, ExportMapBuilder);}_createClass(ExportMapBuilder, null, [{ key: 'get', value: function () {function get( - source, context) { - var path = (0, _resolve2['default'])(source, context); - if (path == null) {return null;} - - return ExportMapBuilder['for']((0, _childContext2['default'])(path, context)); - }return get;}() }, { key: 'for', value: function () {function _for( - - context) {var - path = context.path; - - var cacheKey = context.cacheKey || (0, _hash.hashObject)(context).digest('hex'); - var exportMap = exportCache.get(cacheKey); - - // return cached ignore - if (exportMap === null) {return null;} - - var stats = _fs2['default'].statSync(path); - if (exportMap != null) { - // date equality check - if (exportMap.mtime - stats.mtime === 0) { - return exportMap; - } - // future: check content equality? - } - - // check valid extensions first - if (!(0, _ignore.hasValidExtension)(path, context)) { - exportCache.set(cacheKey, null); - return null; - } - - // check for and cache ignore - if ((0, _ignore2['default'])(path, context)) { - log('ignored path due to ignore settings:', path); - exportCache.set(cacheKey, null); - return null; - } - - var content = _fs2['default'].readFileSync(path, { encoding: 'utf8' }); - - // check for and cache unambiguous modules - if (!unambiguous.test(content)) { - log('ignored path due to unambiguous regex:', path); - exportCache.set(cacheKey, null); - return null; - } - - log('cache miss', cacheKey, 'for path', path); - exportMap = ExportMapBuilder.parse(path, content, context); - - // ambiguous modules return null - if (exportMap == null) { - log('ignored path due to ambiguous parse:', path); - exportCache.set(cacheKey, null); - return null; - } - - exportMap.mtime = stats.mtime; - - exportCache.set(cacheKey, exportMap); - return exportMap; - }return _for;}() }, { key: 'parse', value: function () {function parse( - - path, content, context) { - var exportMap = new _2['default'](path); - var isEsModuleInteropTrue = (0, _typescript.isEsModuleInterop)(context); - - var ast = void 0; - var visitorKeys = void 0; - try { - var result = (0, _parse3['default'])(path, content, context); - ast = result.ast; - visitorKeys = result.visitorKeys; - } catch (err) { - exportMap.errors.push(err); - return exportMap; // can't continue - } - - exportMap.visitorKeys = visitorKeys; - - var hasDynamicImports = false; - - var remotePathResolver = new _remotePath.RemotePath(path, context); - - function processDynamicImport(source) { - hasDynamicImports = true; - if (source.type !== 'Literal') { - return null; - } - var p = remotePathResolver.resolve(source.value); - if (p == null) { - return null; - } - var importedSpecifiers = new Set(); - importedSpecifiers.add('ImportNamespaceSpecifier'); - var getter = thunkFor(p, context); - exportMap.imports.set(p, { - getter: getter, - declarations: new Set([{ - source: { - // capturing actual node reference holds full AST in memory! - value: source.value, - loc: source.loc }, - - importedSpecifiers: importedSpecifiers, - dynamic: true }]) }); - - - } - - (0, _visit2['default'])(ast, visitorKeys, { - ImportExpression: function () {function ImportExpression(node) { - processDynamicImport(node.source); - }return ImportExpression;}(), - CallExpression: function () {function CallExpression(node) { - if (node.callee.type === 'Import') { - processDynamicImport(node.arguments[0]); - } - }return CallExpression;}() }); - - - var unambiguouslyESM = unambiguous.isModule(ast); - if (!unambiguouslyESM && !hasDynamicImports) {return null;} - - // attempt to collect module doc - if (ast.comments) { - ast.comments.some(function (c) { - if (c.type !== 'Block') {return false;} - try { - var doc = _doctrine2['default'].parse(c.value, { unwrap: true }); - if (doc.tags.some(function (t) {return t.title === 'module';})) { - exportMap.doc = doc; - return true; - } - } catch (err) {/* ignore */} - return false; - }); - } - - var visitorBuilder = new _visitor2['default']( - path, - context, - exportMap, - ExportMapBuilder, - content, - ast, - isEsModuleInteropTrue, - thunkFor); - - ast.body.forEach(function (astNode) { - var visitor = visitorBuilder.build(astNode); - - if (visitor[astNode.type]) { - visitor[astNode.type].call(visitorBuilder); - } - }); - - if ( - isEsModuleInteropTrue // esModuleInterop is on in tsconfig - && exportMap.namespace.size > 0 // anything is exported - && !exportMap.namespace.has('default') // and default isn't added already - ) { - exportMap.namespace.set('default', {}); // add default export - } - - if (unambiguouslyESM) { - exportMap.parseGoal = 'Module'; - } - return exportMap; - }return parse;}() }]);return ExportMapBuilder;}();exports['default'] = ExportMapBuilder; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/exportMap/builder.js"],"names":["unambiguous","log","exportCache","Map","thunkFor","p","context","ExportMapBuilder","source","path","cacheKey","digest","exportMap","get","stats","fs","statSync","mtime","set","content","readFileSync","encoding","test","parse","ExportMap","isEsModuleInteropTrue","ast","visitorKeys","result","err","errors","push","hasDynamicImports","remotePathResolver","RemotePath","processDynamicImport","type","resolve","value","importedSpecifiers","Set","add","getter","imports","declarations","loc","dynamic","ImportExpression","node","CallExpression","callee","arguments","unambiguouslyESM","isModule","comments","some","c","doc","doctrine","unwrap","tags","t","title","visitorBuilder","ImportExportVisitorBuilder","body","forEach","astNode","visitor","build","call","namespace","size","has","parseGoal"],"mappings":"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","file":"builder.js","sourcesContent":["import fs from 'fs';\n\nimport doctrine from 'doctrine';\n\nimport debug from 'debug';\n\nimport parse from 'eslint-module-utils/parse';\nimport visit from 'eslint-module-utils/visit';\nimport resolve from 'eslint-module-utils/resolve';\nimport isIgnored, { hasValidExtension } from 'eslint-module-utils/ignore';\n\nimport { hashObject } from 'eslint-module-utils/hash';\nimport * as unambiguous from 'eslint-module-utils/unambiguous';\n\nimport ExportMap from '.';\nimport childContext from './childContext';\nimport { isEsModuleInterop } from './typescript';\nimport { RemotePath } from './remotePath';\nimport ImportExportVisitorBuilder from './visitor';\n\nconst log = debug('eslint-plugin-import:ExportMap');\n\nconst exportCache = new Map();\n\n/**\n * The creation of this closure is isolated from other scopes\n * to avoid over-retention of unrelated variables, which has\n * caused memory leaks. See #1266.\n */\nfunction thunkFor(p, context) {\n  // eslint-disable-next-line no-use-before-define\n  return () => ExportMapBuilder.for(childContext(p, context));\n}\n\nexport default class ExportMapBuilder {\n  static get(source, context) {\n    const path = resolve(source, context);\n    if (path == null) { return null; }\n\n    return ExportMapBuilder.for(childContext(path, context));\n  }\n\n  static for(context) {\n    const { path } = context;\n\n    const cacheKey = context.cacheKey || hashObject(context).digest('hex');\n    let exportMap = exportCache.get(cacheKey);\n\n    // return cached ignore\n    if (exportMap === null) { return null; }\n\n    const stats = fs.statSync(path);\n    if (exportMap != null) {\n      // date equality check\n      if (exportMap.mtime - stats.mtime === 0) {\n        return exportMap;\n      }\n      // future: check content equality?\n    }\n\n    // check valid extensions first\n    if (!hasValidExtension(path, context)) {\n      exportCache.set(cacheKey, null);\n      return null;\n    }\n\n    // check for and cache ignore\n    if (isIgnored(path, context)) {\n      log('ignored path due to ignore settings:', path);\n      exportCache.set(cacheKey, null);\n      return null;\n    }\n\n    const content = fs.readFileSync(path, { encoding: 'utf8' });\n\n    // check for and cache unambiguous modules\n    if (!unambiguous.test(content)) {\n      log('ignored path due to unambiguous regex:', path);\n      exportCache.set(cacheKey, null);\n      return null;\n    }\n\n    log('cache miss', cacheKey, 'for path', path);\n    exportMap = ExportMapBuilder.parse(path, content, context);\n\n    // ambiguous modules return null\n    if (exportMap == null) {\n      log('ignored path due to ambiguous parse:', path);\n      exportCache.set(cacheKey, null);\n      return null;\n    }\n\n    exportMap.mtime = stats.mtime;\n\n    exportCache.set(cacheKey, exportMap);\n    return exportMap;\n  }\n\n  static parse(path, content, context) {\n    const exportMap = new ExportMap(path);\n    const isEsModuleInteropTrue = isEsModuleInterop(context);\n\n    let ast;\n    let visitorKeys;\n    try {\n      const result = parse(path, content, context);\n      ast = result.ast;\n      visitorKeys = result.visitorKeys;\n    } catch (err) {\n      exportMap.errors.push(err);\n      return exportMap; // can't continue\n    }\n\n    exportMap.visitorKeys = visitorKeys;\n\n    let hasDynamicImports = false;\n\n    const remotePathResolver = new RemotePath(path, context);\n\n    function processDynamicImport(source) {\n      hasDynamicImports = true;\n      if (source.type !== 'Literal') {\n        return null;\n      }\n      const p = remotePathResolver.resolve(source.value);\n      if (p == null) {\n        return null;\n      }\n      const importedSpecifiers = new Set();\n      importedSpecifiers.add('ImportNamespaceSpecifier');\n      const getter = thunkFor(p, context);\n      exportMap.imports.set(p, {\n        getter,\n        declarations: new Set([{\n          source: {\n          // capturing actual node reference holds full AST in memory!\n            value: source.value,\n            loc: source.loc,\n          },\n          importedSpecifiers,\n          dynamic: true,\n        }]),\n      });\n    }\n\n    visit(ast, visitorKeys, {\n      ImportExpression(node) {\n        processDynamicImport(node.source);\n      },\n      CallExpression(node) {\n        if (node.callee.type === 'Import') {\n          processDynamicImport(node.arguments[0]);\n        }\n      },\n    });\n\n    const unambiguouslyESM = unambiguous.isModule(ast);\n    if (!unambiguouslyESM && !hasDynamicImports) { return null; }\n\n    // attempt to collect module doc\n    if (ast.comments) {\n      ast.comments.some((c) => {\n        if (c.type !== 'Block') { return false; }\n        try {\n          const doc = doctrine.parse(c.value, { unwrap: true });\n          if (doc.tags.some((t) => t.title === 'module')) {\n            exportMap.doc = doc;\n            return true;\n          }\n        } catch (err) { /* ignore */ }\n        return false;\n      });\n    }\n\n    const visitorBuilder = new ImportExportVisitorBuilder(\n      path,\n      context,\n      exportMap,\n      ExportMapBuilder,\n      content,\n      ast,\n      isEsModuleInteropTrue,\n      thunkFor,\n    );\n    ast.body.forEach(function (astNode) {\n      const visitor = visitorBuilder.build(astNode);\n\n      if (visitor[astNode.type]) {\n        visitor[astNode.type].call(visitorBuilder);\n      }\n    });\n\n    if (\n      isEsModuleInteropTrue // esModuleInterop is on in tsconfig\n      && exportMap.namespace.size > 0 // anything is exported\n      && !exportMap.namespace.has('default') // and default isn't added already\n    ) {\n      exportMap.namespace.set('default', {}); // add default export\n    }\n\n    if (unambiguouslyESM) {\n      exportMap.parseGoal = 'Module';\n    }\n    return exportMap;\n  }\n}\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/captureDependency.js b/node_modules/eslint-plugin-import/lib/exportMap/captureDependency.js deleted file mode 100644 index 5a863b60d1..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/captureDependency.js +++ /dev/null @@ -1,61 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports.captureDependency = captureDependency;exports. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -captureDependencyWithSpecifiers = captureDependencyWithSpecifiers;function captureDependency(_ref, isOnlyImportingTypes, remotePathResolver, exportMap, context, thunkFor) {var source = _ref.source;var importedSpecifiers = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new Set();if (source == null) {return null;}var p = remotePathResolver.resolve(source.value);if (p == null) {return null;}var declarationMetadata = { // capturing actual node reference holds full AST in memory! - source: { value: source.value, loc: source.loc }, isOnlyImportingTypes: isOnlyImportingTypes, importedSpecifiers: importedSpecifiers };var existing = exportMap.imports.get(p);if (existing != null) {existing.declarations.add(declarationMetadata);return existing.getter;}var getter = thunkFor(p, context);exportMap.imports.set(p, { getter: getter, declarations: new Set([declarationMetadata]) });return getter;}var supportedImportTypes = new Set(['ImportDefaultSpecifier', 'ImportNamespaceSpecifier']);function captureDependencyWithSpecifiers(n, -remotePathResolver, -exportMap, -context, -thunkFor) -{ - // import type { Foo } (TS and Flow); import typeof { Foo } (Flow) - var declarationIsType = n.importKind === 'type' || n.importKind === 'typeof'; - // import './foo' or import {} from './foo' (both 0 specifiers) is a side effect and - // shouldn't be considered to be just importing types - var specifiersOnlyImportingTypes = n.specifiers.length > 0; - var importedSpecifiers = new Set(); - n.specifiers.forEach(function (specifier) { - if (specifier.type === 'ImportSpecifier') { - importedSpecifiers.add(specifier.imported.name || specifier.imported.value); - } else if (supportedImportTypes.has(specifier.type)) { - importedSpecifiers.add(specifier.type); - } - - // import { type Foo } (Flow); import { typeof Foo } (Flow) - specifiersOnlyImportingTypes = specifiersOnlyImportingTypes && ( - specifier.importKind === 'type' || specifier.importKind === 'typeof'); - }); - captureDependency(n, declarationIsType || specifiersOnlyImportingTypes, remotePathResolver, exportMap, context, thunkFor, importedSpecifiers); -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/childContext.js b/node_modules/eslint-plugin-import/lib/exportMap/childContext.js deleted file mode 100644 index aaa31ef98f..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/childContext.js +++ /dev/null @@ -1,33 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports['default'] = - - - - - - - - - - -childContext;var _hash = require('eslint-module-utils/hash');var parserOptionsHash = '';var prevParserOptions = '';var settingsHash = '';var prevSettings = ''; /** - * don't hold full context object in memory, just grab what we need. - * also calculate a cacheKey, where parts of the cacheKey hash are memoized - */function childContext(path, context) {var settings = context.settings,parserOptions = context.parserOptions,parserPath = context.parserPath;if (JSON.stringify(settings) !== prevSettings) { - settingsHash = (0, _hash.hashObject)({ settings: settings }).digest('hex'); - prevSettings = JSON.stringify(settings); - } - - if (JSON.stringify(parserOptions) !== prevParserOptions) { - parserOptionsHash = (0, _hash.hashObject)({ parserOptions: parserOptions }).digest('hex'); - prevParserOptions = JSON.stringify(parserOptions); - } - - return { - cacheKey: String(parserPath) + parserOptionsHash + settingsHash + String(path), - settings: settings, - parserOptions: parserOptions, - parserPath: parserPath, - path: path }; - -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leHBvcnRNYXAvY2hpbGRDb250ZXh0LmpzIl0sIm5hbWVzIjpbImNoaWxkQ29udGV4dCIsInBhcnNlck9wdGlvbnNIYXNoIiwicHJldlBhcnNlck9wdGlvbnMiLCJzZXR0aW5nc0hhc2giLCJwcmV2U2V0dGluZ3MiLCJwYXRoIiwiY29udGV4dCIsInNldHRpbmdzIiwicGFyc2VyT3B0aW9ucyIsInBhcnNlclBhdGgiLCJKU09OIiwic3RyaW5naWZ5IiwiZGlnZXN0IiwiY2FjaGVLZXkiLCJTdHJpbmciXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0FBV3dCQSxZLENBWHhCLGdEQUVBLElBQUlDLG9CQUFvQixFQUF4QixDQUNBLElBQUlDLG9CQUFvQixFQUF4QixDQUNBLElBQUlDLGVBQWUsRUFBbkIsQ0FDQSxJQUFJQyxlQUFlLEVBQW5CLEMsQ0FFQTs7O21LQUllLFNBQVNKLFlBQVQsQ0FBc0JLLElBQXRCLEVBQTRCQyxPQUE1QixFQUFxQyxLQUMxQ0MsUUFEMEMsR0FDRkQsT0FERSxDQUMxQ0MsUUFEMEMsQ0FDaENDLGFBRGdDLEdBQ0ZGLE9BREUsQ0FDaENFLGFBRGdDLENBQ2pCQyxVQURpQixHQUNGSCxPQURFLENBQ2pCRyxVQURpQixDQUdsRCxJQUFJQyxLQUFLQyxTQUFMLENBQWVKLFFBQWYsTUFBNkJILFlBQWpDLEVBQStDO0FBQzdDRCxtQkFBZSxzQkFBVyxFQUFFSSxrQkFBRixFQUFYLEVBQXlCSyxNQUF6QixDQUFnQyxLQUFoQyxDQUFmO0FBQ0FSLG1CQUFlTSxLQUFLQyxTQUFMLENBQWVKLFFBQWYsQ0FBZjtBQUNEOztBQUVELE1BQUlHLEtBQUtDLFNBQUwsQ0FBZUgsYUFBZixNQUFrQ04saUJBQXRDLEVBQXlEO0FBQ3ZERCx3QkFBb0Isc0JBQVcsRUFBRU8sNEJBQUYsRUFBWCxFQUE4QkksTUFBOUIsQ0FBcUMsS0FBckMsQ0FBcEI7QUFDQVYsd0JBQW9CUSxLQUFLQyxTQUFMLENBQWVILGFBQWYsQ0FBcEI7QUFDRDs7QUFFRCxTQUFPO0FBQ0xLLGNBQVVDLE9BQU9MLFVBQVAsSUFBcUJSLGlCQUFyQixHQUF5Q0UsWUFBekMsR0FBd0RXLE9BQU9ULElBQVAsQ0FEN0Q7QUFFTEUsc0JBRks7QUFHTEMsZ0NBSEs7QUFJTEMsMEJBSks7QUFLTEosY0FMSyxFQUFQOztBQU9EIiwiZmlsZSI6ImNoaWxkQ29udGV4dC5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGhhc2hPYmplY3QgfSBmcm9tICdlc2xpbnQtbW9kdWxlLXV0aWxzL2hhc2gnO1xuXG5sZXQgcGFyc2VyT3B0aW9uc0hhc2ggPSAnJztcbmxldCBwcmV2UGFyc2VyT3B0aW9ucyA9ICcnO1xubGV0IHNldHRpbmdzSGFzaCA9ICcnO1xubGV0IHByZXZTZXR0aW5ncyA9ICcnO1xuXG4vKipcbiAqIGRvbid0IGhvbGQgZnVsbCBjb250ZXh0IG9iamVjdCBpbiBtZW1vcnksIGp1c3QgZ3JhYiB3aGF0IHdlIG5lZWQuXG4gKiBhbHNvIGNhbGN1bGF0ZSBhIGNhY2hlS2V5LCB3aGVyZSBwYXJ0cyBvZiB0aGUgY2FjaGVLZXkgaGFzaCBhcmUgbWVtb2l6ZWRcbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gY2hpbGRDb250ZXh0KHBhdGgsIGNvbnRleHQpIHtcbiAgY29uc3QgeyBzZXR0aW5ncywgcGFyc2VyT3B0aW9ucywgcGFyc2VyUGF0aCB9ID0gY29udGV4dDtcblxuICBpZiAoSlNPTi5zdHJpbmdpZnkoc2V0dGluZ3MpICE9PSBwcmV2U2V0dGluZ3MpIHtcbiAgICBzZXR0aW5nc0hhc2ggPSBoYXNoT2JqZWN0KHsgc2V0dGluZ3MgfSkuZGlnZXN0KCdoZXgnKTtcbiAgICBwcmV2U2V0dGluZ3MgPSBKU09OLnN0cmluZ2lmeShzZXR0aW5ncyk7XG4gIH1cblxuICBpZiAoSlNPTi5zdHJpbmdpZnkocGFyc2VyT3B0aW9ucykgIT09IHByZXZQYXJzZXJPcHRpb25zKSB7XG4gICAgcGFyc2VyT3B0aW9uc0hhc2ggPSBoYXNoT2JqZWN0KHsgcGFyc2VyT3B0aW9ucyB9KS5kaWdlc3QoJ2hleCcpO1xuICAgIHByZXZQYXJzZXJPcHRpb25zID0gSlNPTi5zdHJpbmdpZnkocGFyc2VyT3B0aW9ucyk7XG4gIH1cblxuICByZXR1cm4ge1xuICAgIGNhY2hlS2V5OiBTdHJpbmcocGFyc2VyUGF0aCkgKyBwYXJzZXJPcHRpb25zSGFzaCArIHNldHRpbmdzSGFzaCArIFN0cmluZyhwYXRoKSxcbiAgICBzZXR0aW5ncyxcbiAgICBwYXJzZXJPcHRpb25zLFxuICAgIHBhcnNlclBhdGgsXG4gICAgcGF0aCxcbiAgfTtcbn1cbiJdfQ== \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/doc.js b/node_modules/eslint-plugin-import/lib/exportMap/doc.js deleted file mode 100644 index e2ceaa98a6..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/doc.js +++ /dev/null @@ -1,90 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports.availableDocStyleParsers = undefined;exports. - - - - -captureDoc = captureDoc;var _doctrine = require('doctrine');var _doctrine2 = _interopRequireDefault(_doctrine);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };} /** - * parse docs from the first node that has leading comments - */function captureDoc(source, docStyleParsers) {var metadata = {}; - // 'some' short-circuits on first 'true' - for (var _len = arguments.length, nodes = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {nodes[_key - 2] = arguments[_key];}nodes.some(function (n) { - try { - - var leadingComments = void 0; - - // n.leadingComments is legacy `attachComments` behavior - if ('leadingComments' in n) { - leadingComments = n.leadingComments; - } else if (n.range) { - leadingComments = source.getCommentsBefore(n); - } - - if (!leadingComments || leadingComments.length === 0) {return false;} - - for (var name in docStyleParsers) { - var doc = docStyleParsers[name](leadingComments); - if (doc) { - metadata.doc = doc; - } - } - - return true; - } catch (err) { - return false; - } - }); - - return metadata; -} - -/** - * parse JSDoc from leading comments - * @param {object[]} comments - * @return {{ doc: object }} - */ -function captureJsDoc(comments) { - var doc = void 0; - - // capture XSDoc - comments.forEach(function (comment) { - // skip non-block comments - if (comment.type !== 'Block') {return;} - try { - doc = _doctrine2['default'].parse(comment.value, { unwrap: true }); - } catch (err) { - /* don't care, for now? maybe add to `errors?` */ - } - }); - - return doc; -} - -/** - * parse TomDoc section from comments - */ -function captureTomDoc(comments) { - // collect lines up to first paragraph break - var lines = []; - for (var i = 0; i < comments.length; i++) { - var comment = comments[i]; - if (comment.value.match(/^\s*$/)) {break;} - lines.push(comment.value.trim()); - } - - // return doctrine-like object - var statusMatch = lines.join(' ').match(/^(Public|Internal|Deprecated):\s*(.+)/); - if (statusMatch) { - return { - description: statusMatch[2], - tags: [{ - title: statusMatch[1].toLowerCase(), - description: statusMatch[2] }] }; - - - } -} - -var availableDocStyleParsers = exports.availableDocStyleParsers = { - jsdoc: captureJsDoc, - tomdoc: captureTomDoc }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leHBvcnRNYXAvZG9jLmpzIl0sIm5hbWVzIjpbImNhcHR1cmVEb2MiLCJzb3VyY2UiLCJkb2NTdHlsZVBhcnNlcnMiLCJtZXRhZGF0YSIsIm5vZGVzIiwic29tZSIsIm4iLCJsZWFkaW5nQ29tbWVudHMiLCJyYW5nZSIsImdldENvbW1lbnRzQmVmb3JlIiwibGVuZ3RoIiwibmFtZSIsImRvYyIsImVyciIsImNhcHR1cmVKc0RvYyIsImNvbW1lbnRzIiwiZm9yRWFjaCIsImNvbW1lbnQiLCJ0eXBlIiwiZG9jdHJpbmUiLCJwYXJzZSIsInZhbHVlIiwidW53cmFwIiwiY2FwdHVyZVRvbURvYyIsImxpbmVzIiwiaSIsIm1hdGNoIiwicHVzaCIsInRyaW0iLCJzdGF0dXNNYXRjaCIsImpvaW4iLCJkZXNjcmlwdGlvbiIsInRhZ3MiLCJ0aXRsZSIsInRvTG93ZXJDYXNlIiwiYXZhaWxhYmxlRG9jU3R5bGVQYXJzZXJzIiwianNkb2MiLCJ0b21kb2MiXSwibWFwcGluZ3MiOiI7Ozs7O0FBS2dCQSxVLEdBQUFBLFUsQ0FMaEIsb0MsbUpBRUE7O2tOQUdPLFNBQVNBLFVBQVQsQ0FBb0JDLE1BQXBCLEVBQTRCQyxlQUE1QixFQUF1RCxDQUM1RCxJQUFNQyxXQUFXLEVBQWpCO0FBRUE7QUFINEQsb0NBQVBDLEtBQU8sbUVBQVBBLEtBQU8sOEJBSTVEQSxNQUFNQyxJQUFOLENBQVcsVUFBQ0MsQ0FBRCxFQUFPO0FBQ2hCLFFBQUk7O0FBRUYsVUFBSUMsd0JBQUo7O0FBRUE7QUFDQSxVQUFJLHFCQUFxQkQsQ0FBekIsRUFBNEI7QUFDMUJDLDBCQUFrQkQsRUFBRUMsZUFBcEI7QUFDRCxPQUZELE1BRU8sSUFBSUQsRUFBRUUsS0FBTixFQUFhO0FBQ2xCRCwwQkFBa0JOLE9BQU9RLGlCQUFQLENBQXlCSCxDQUF6QixDQUFsQjtBQUNEOztBQUVELFVBQUksQ0FBQ0MsZUFBRCxJQUFvQkEsZ0JBQWdCRyxNQUFoQixLQUEyQixDQUFuRCxFQUFzRCxDQUFFLE9BQU8sS0FBUCxDQUFlOztBQUV2RSxXQUFLLElBQU1DLElBQVgsSUFBbUJULGVBQW5CLEVBQW9DO0FBQ2xDLFlBQU1VLE1BQU1WLGdCQUFnQlMsSUFBaEIsRUFBc0JKLGVBQXRCLENBQVo7QUFDQSxZQUFJSyxHQUFKLEVBQVM7QUFDUFQsbUJBQVNTLEdBQVQsR0FBZUEsR0FBZjtBQUNEO0FBQ0Y7O0FBRUQsYUFBTyxJQUFQO0FBQ0QsS0FyQkQsQ0FxQkUsT0FBT0MsR0FBUCxFQUFZO0FBQ1osYUFBTyxLQUFQO0FBQ0Q7QUFDRixHQXpCRDs7QUEyQkEsU0FBT1YsUUFBUDtBQUNEOztBQUVEOzs7OztBQUtBLFNBQVNXLFlBQVQsQ0FBc0JDLFFBQXRCLEVBQWdDO0FBQzlCLE1BQUlILFlBQUo7O0FBRUE7QUFDQUcsV0FBU0MsT0FBVCxDQUFpQixVQUFDQyxPQUFELEVBQWE7QUFDNUI7QUFDQSxRQUFJQSxRQUFRQyxJQUFSLEtBQWlCLE9BQXJCLEVBQThCLENBQUUsT0FBUztBQUN6QyxRQUFJO0FBQ0ZOLFlBQU1PLHNCQUFTQyxLQUFULENBQWVILFFBQVFJLEtBQXZCLEVBQThCLEVBQUVDLFFBQVEsSUFBVixFQUE5QixDQUFOO0FBQ0QsS0FGRCxDQUVFLE9BQU9ULEdBQVAsRUFBWTtBQUNaO0FBQ0Q7QUFDRixHQVJEOztBQVVBLFNBQU9ELEdBQVA7QUFDRDs7QUFFRDs7O0FBR0EsU0FBU1csYUFBVCxDQUF1QlIsUUFBdkIsRUFBaUM7QUFDL0I7QUFDQSxNQUFNUyxRQUFRLEVBQWQ7QUFDQSxPQUFLLElBQUlDLElBQUksQ0FBYixFQUFnQkEsSUFBSVYsU0FBU0wsTUFBN0IsRUFBcUNlLEdBQXJDLEVBQTBDO0FBQ3hDLFFBQU1SLFVBQVVGLFNBQVNVLENBQVQsQ0FBaEI7QUFDQSxRQUFJUixRQUFRSSxLQUFSLENBQWNLLEtBQWQsQ0FBb0IsT0FBcEIsQ0FBSixFQUFrQyxDQUFFLE1BQVE7QUFDNUNGLFVBQU1HLElBQU4sQ0FBV1YsUUFBUUksS0FBUixDQUFjTyxJQUFkLEVBQVg7QUFDRDs7QUFFRDtBQUNBLE1BQU1DLGNBQWNMLE1BQU1NLElBQU4sQ0FBVyxHQUFYLEVBQWdCSixLQUFoQixDQUFzQix1Q0FBdEIsQ0FBcEI7QUFDQSxNQUFJRyxXQUFKLEVBQWlCO0FBQ2YsV0FBTztBQUNMRSxtQkFBYUYsWUFBWSxDQUFaLENBRFI7QUFFTEcsWUFBTSxDQUFDO0FBQ0xDLGVBQU9KLFlBQVksQ0FBWixFQUFlSyxXQUFmLEVBREY7QUFFTEgscUJBQWFGLFlBQVksQ0FBWixDQUZSLEVBQUQsQ0FGRCxFQUFQOzs7QUFPRDtBQUNGOztBQUVNLElBQU1NLDhEQUEyQjtBQUN0Q0MsU0FBT3RCLFlBRCtCO0FBRXRDdUIsVUFBUWQsYUFGOEIsRUFBakMiLCJmaWxlIjoiZG9jLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGRvY3RyaW5lIGZyb20gJ2RvY3RyaW5lJztcblxuLyoqXG4gKiBwYXJzZSBkb2NzIGZyb20gdGhlIGZpcnN0IG5vZGUgdGhhdCBoYXMgbGVhZGluZyBjb21tZW50c1xuICovXG5leHBvcnQgZnVuY3Rpb24gY2FwdHVyZURvYyhzb3VyY2UsIGRvY1N0eWxlUGFyc2VycywgLi4ubm9kZXMpIHtcbiAgY29uc3QgbWV0YWRhdGEgPSB7fTtcblxuICAvLyAnc29tZScgc2hvcnQtY2lyY3VpdHMgb24gZmlyc3QgJ3RydWUnXG4gIG5vZGVzLnNvbWUoKG4pID0+IHtcbiAgICB0cnkge1xuXG4gICAgICBsZXQgbGVhZGluZ0NvbW1lbnRzO1xuXG4gICAgICAvLyBuLmxlYWRpbmdDb21tZW50cyBpcyBsZWdhY3kgYGF0dGFjaENvbW1lbnRzYCBiZWhhdmlvclxuICAgICAgaWYgKCdsZWFkaW5nQ29tbWVudHMnIGluIG4pIHtcbiAgICAgICAgbGVhZGluZ0NvbW1lbnRzID0gbi5sZWFkaW5nQ29tbWVudHM7XG4gICAgICB9IGVsc2UgaWYgKG4ucmFuZ2UpIHtcbiAgICAgICAgbGVhZGluZ0NvbW1lbnRzID0gc291cmNlLmdldENvbW1lbnRzQmVmb3JlKG4pO1xuICAgICAgfVxuXG4gICAgICBpZiAoIWxlYWRpbmdDb21tZW50cyB8fCBsZWFkaW5nQ29tbWVudHMubGVuZ3RoID09PSAwKSB7IHJldHVybiBmYWxzZTsgfVxuXG4gICAgICBmb3IgKGNvbnN0IG5hbWUgaW4gZG9jU3R5bGVQYXJzZXJzKSB7XG4gICAgICAgIGNvbnN0IGRvYyA9IGRvY1N0eWxlUGFyc2Vyc1tuYW1lXShsZWFkaW5nQ29tbWVudHMpO1xuICAgICAgICBpZiAoZG9jKSB7XG4gICAgICAgICAgbWV0YWRhdGEuZG9jID0gZG9jO1xuICAgICAgICB9XG4gICAgICB9XG5cbiAgICAgIHJldHVybiB0cnVlO1xuICAgIH0gY2F0Y2ggKGVycikge1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cbiAgfSk7XG5cbiAgcmV0dXJuIG1ldGFkYXRhO1xufVxuXG4vKipcbiAqIHBhcnNlIEpTRG9jIGZyb20gbGVhZGluZyBjb21tZW50c1xuICogQHBhcmFtIHtvYmplY3RbXX0gY29tbWVudHNcbiAqIEByZXR1cm4ge3sgZG9jOiBvYmplY3QgfX1cbiAqL1xuZnVuY3Rpb24gY2FwdHVyZUpzRG9jKGNvbW1lbnRzKSB7XG4gIGxldCBkb2M7XG5cbiAgLy8gY2FwdHVyZSBYU0RvY1xuICBjb21tZW50cy5mb3JFYWNoKChjb21tZW50KSA9PiB7XG4gICAgLy8gc2tpcCBub24tYmxvY2sgY29tbWVudHNcbiAgICBpZiAoY29tbWVudC50eXBlICE9PSAnQmxvY2snKSB7IHJldHVybjsgfVxuICAgIHRyeSB7XG4gICAgICBkb2MgPSBkb2N0cmluZS5wYXJzZShjb21tZW50LnZhbHVlLCB7IHVud3JhcDogdHJ1ZSB9KTtcbiAgICB9IGNhdGNoIChlcnIpIHtcbiAgICAgIC8qIGRvbid0IGNhcmUsIGZvciBub3c/IG1heWJlIGFkZCB0byBgZXJyb3JzP2AgKi9cbiAgICB9XG4gIH0pO1xuXG4gIHJldHVybiBkb2M7XG59XG5cbi8qKlxuICAqIHBhcnNlIFRvbURvYyBzZWN0aW9uIGZyb20gY29tbWVudHNcbiAgKi9cbmZ1bmN0aW9uIGNhcHR1cmVUb21Eb2MoY29tbWVudHMpIHtcbiAgLy8gY29sbGVjdCBsaW5lcyB1cCB0byBmaXJzdCBwYXJhZ3JhcGggYnJlYWtcbiAgY29uc3QgbGluZXMgPSBbXTtcbiAgZm9yIChsZXQgaSA9IDA7IGkgPCBjb21tZW50cy5sZW5ndGg7IGkrKykge1xuICAgIGNvbnN0IGNvbW1lbnQgPSBjb21tZW50c1tpXTtcbiAgICBpZiAoY29tbWVudC52YWx1ZS5tYXRjaCgvXlxccyokLykpIHsgYnJlYWs7IH1cbiAgICBsaW5lcy5wdXNoKGNvbW1lbnQudmFsdWUudHJpbSgpKTtcbiAgfVxuXG4gIC8vIHJldHVybiBkb2N0cmluZS1saWtlIG9iamVjdFxuICBjb25zdCBzdGF0dXNNYXRjaCA9IGxpbmVzLmpvaW4oJyAnKS5tYXRjaCgvXihQdWJsaWN8SW50ZXJuYWx8RGVwcmVjYXRlZCk6XFxzKiguKykvKTtcbiAgaWYgKHN0YXR1c01hdGNoKSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGRlc2NyaXB0aW9uOiBzdGF0dXNNYXRjaFsyXSxcbiAgICAgIHRhZ3M6IFt7XG4gICAgICAgIHRpdGxlOiBzdGF0dXNNYXRjaFsxXS50b0xvd2VyQ2FzZSgpLFxuICAgICAgICBkZXNjcmlwdGlvbjogc3RhdHVzTWF0Y2hbMl0sXG4gICAgICB9XSxcbiAgICB9O1xuICB9XG59XG5cbmV4cG9ydCBjb25zdCBhdmFpbGFibGVEb2NTdHlsZVBhcnNlcnMgPSB7XG4gIGpzZG9jOiBjYXB0dXJlSnNEb2MsXG4gIHRvbWRvYzogY2FwdHVyZVRvbURvYyxcbn07XG4iXX0= \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/index.js b/node_modules/eslint-plugin-import/lib/exportMap/index.js deleted file mode 100644 index 802da1e873..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/index.js +++ /dev/null @@ -1,180 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });var _createClass = function () {function defineProperties(target, props) {for (var i = 0; i < props.length; i++) {var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);}}return function (Constructor, protoProps, staticProps) {if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;};}();function _classCallCheck(instance, Constructor) {if (!(instance instanceof Constructor)) {throw new TypeError("Cannot call a class as a function");}}var ExportMap = function () { - function ExportMap(path) {_classCallCheck(this, ExportMap); - this.path = path; - this.namespace = new Map(); - // todo: restructure to key on path, value is resolver + map of names - this.reexports = new Map(); - /** - * star-exports - * @type {Set<() => ExportMap>} - */ - this.dependencies = new Set(); - /** - * dependencies of this module that are not explicitly re-exported - * @type {Map ExportMap>} - */ - this.imports = new Map(); - this.errors = []; - /** - * type {'ambiguous' | 'Module' | 'Script'} - */ - this.parseGoal = 'ambiguous'; - }_createClass(ExportMap, [{ key: 'has', - - - - - - - - - - - - - - - /** - * Note that this does not check explicitly re-exported names for existence - * in the base namespace, but it will expand all `export * from '...'` exports - * if not found in the explicit namespace. - * @param {string} name - * @return {boolean} true if `name` is exported by this module. - */value: function () {function has( - name) { - if (this.namespace.has(name)) {return true;} - if (this.reexports.has(name)) {return true;} - - // default exports must be explicitly re-exported (#328) - if (name !== 'default') {var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try { - for (var _iterator = this.dependencies[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var dep = _step.value; - var innerMap = dep(); - - // todo: report as unresolved? - if (!innerMap) {continue;} - - if (innerMap.has(name)) {return true;} - }} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}} - } - - return false; - }return has;}() - - /** - * ensure that imported name fully resolves. - * @param {string} name - * @return {{ found: boolean, path: ExportMap[] }} - */ }, { key: 'hasDeep', value: function () {function hasDeep( - name) { - if (this.namespace.has(name)) {return { found: true, path: [this] };} - - if (this.reexports.has(name)) { - var reexports = this.reexports.get(name); - var imported = reexports.getImport(); - - // if import is ignored, return explicit 'null' - if (imported == null) {return { found: true, path: [this] };} - - // safeguard against cycles, only if name matches - if (imported.path === this.path && reexports.local === name) { - return { found: false, path: [this] }; - } - - var deep = imported.hasDeep(reexports.local); - deep.path.unshift(this); - - return deep; - } - - // default exports must be explicitly re-exported (#328) - if (name !== 'default') {var _iteratorNormalCompletion2 = true;var _didIteratorError2 = false;var _iteratorError2 = undefined;try { - for (var _iterator2 = this.dependencies[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {var dep = _step2.value; - var innerMap = dep(); - if (innerMap == null) {return { found: true, path: [this] };} - // todo: report as unresolved? - if (!innerMap) {continue;} - - // safeguard against cycles - if (innerMap.path === this.path) {continue;} - - var innerValue = innerMap.hasDeep(name); - if (innerValue.found) { - innerValue.path.unshift(this); - return innerValue; - } - }} catch (err) {_didIteratorError2 = true;_iteratorError2 = err;} finally {try {if (!_iteratorNormalCompletion2 && _iterator2['return']) {_iterator2['return']();}} finally {if (_didIteratorError2) {throw _iteratorError2;}}} - } - - return { found: false, path: [this] }; - }return hasDeep;}() }, { key: 'get', value: function () {function get( - - name) { - if (this.namespace.has(name)) {return this.namespace.get(name);} - - if (this.reexports.has(name)) { - var reexports = this.reexports.get(name); - var imported = reexports.getImport(); - - // if import is ignored, return explicit 'null' - if (imported == null) {return null;} - - // safeguard against cycles, only if name matches - if (imported.path === this.path && reexports.local === name) {return undefined;} - - return imported.get(reexports.local); - } - - // default exports must be explicitly re-exported (#328) - if (name !== 'default') {var _iteratorNormalCompletion3 = true;var _didIteratorError3 = false;var _iteratorError3 = undefined;try { - for (var _iterator3 = this.dependencies[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {var dep = _step3.value; - var innerMap = dep(); - // todo: report as unresolved? - if (!innerMap) {continue;} - - // safeguard against cycles - if (innerMap.path === this.path) {continue;} - - var innerValue = innerMap.get(name); - if (innerValue !== undefined) {return innerValue;} - }} catch (err) {_didIteratorError3 = true;_iteratorError3 = err;} finally {try {if (!_iteratorNormalCompletion3 && _iterator3['return']) {_iterator3['return']();}} finally {if (_didIteratorError3) {throw _iteratorError3;}}} - } - - return undefined; - }return get;}() }, { key: 'forEach', value: function () {function forEach( - - callback, thisArg) {var _this = this; - this.namespace.forEach(function (v, n) {callback.call(thisArg, v, n, _this);}); - - this.reexports.forEach(function (reexports, name) { - var reexported = reexports.getImport(); - // can't look up meta for ignored re-exports (#348) - callback.call(thisArg, reexported && reexported.get(reexports.local), name, _this); - }); - - this.dependencies.forEach(function (dep) { - var d = dep(); - // CJS / ignored dependencies won't exist (#717) - if (d == null) {return;} - - d.forEach(function (v, n) { - if (n !== 'default') { - callback.call(thisArg, v, n, _this); - } - }); - }); - }return forEach;}() - - // todo: keys, values, entries? - }, { key: 'reportErrors', value: function () {function reportErrors( - context, declaration) { - var msg = this.errors. - map(function (e) {return String(e.message) + ' (' + String(e.lineNumber) + ':' + String(e.column) + ')';}). - join(', '); - context.report({ - node: declaration.source, - message: 'Parse errors in imported module \'' + String(declaration.source.value) + '\': ' + String(msg) }); - - }return reportErrors;}() }, { key: 'hasDefault', get: function () {function get() {return this.get('default') != null;}return get;}() // stronger than this.has - }, { key: 'size', get: function () {function get() {var size = this.namespace.size + this.reexports.size;this.dependencies.forEach(function (dep) {var d = dep(); // CJS / ignored dependencies won't exist (#717) - if (d == null) {return;}size += d.size;});return size;}return get;}() }]);return ExportMap;}();exports['default'] = ExportMap; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/exportMap/index.js"],"names":["ExportMap","path","namespace","Map","reexports","dependencies","Set","imports","errors","parseGoal","name","has","dep","innerMap","found","get","imported","getImport","local","deep","hasDeep","unshift","innerValue","undefined","callback","thisArg","forEach","v","n","call","reexported","d","context","declaration","msg","map","e","message","lineNumber","column","join","report","node","source","value","size"],"mappings":"ywBAAqBA,S;AACnB,qBAAYC,IAAZ,EAAkB;AAChB,SAAKA,IAAL,GAAYA,IAAZ;AACA,SAAKC,SAAL,GAAiB,IAAIC,GAAJ,EAAjB;AACA;AACA,SAAKC,SAAL,GAAiB,IAAID,GAAJ,EAAjB;AACA;;;;AAIA,SAAKE,YAAL,GAAoB,IAAIC,GAAJ,EAApB;AACA;;;;AAIA,SAAKC,OAAL,GAAe,IAAIJ,GAAJ,EAAf;AACA,SAAKK,MAAL,GAAc,EAAd;AACA;;;AAGA,SAAKC,SAAL,GAAiB,WAAjB;AACD,G;;;;;;;;;;;;;;;AAeD;;;;;;;AAOIC,U,EAAM;AACR,YAAI,KAAKR,SAAL,CAAeS,GAAf,CAAmBD,IAAnB,CAAJ,EAA8B,CAAE,OAAO,IAAP,CAAc;AAC9C,YAAI,KAAKN,SAAL,CAAeO,GAAf,CAAmBD,IAAnB,CAAJ,EAA8B,CAAE,OAAO,IAAP,CAAc;;AAE9C;AACA,YAAIA,SAAS,SAAb,EAAwB;AACtB,iCAAkB,KAAKL,YAAvB,8HAAqC,KAA1BO,GAA0B;AACnC,kBAAMC,WAAWD,KAAjB;;AAEA;AACA,kBAAI,CAACC,QAAL,EAAe,CAAE,SAAW;;AAE5B,kBAAIA,SAASF,GAAT,CAAaD,IAAb,CAAJ,EAAwB,CAAE,OAAO,IAAP,CAAc;AACzC,aARqB;AASvB;;AAED,eAAO,KAAP;AACD,O;;AAED;;;;;AAKQA,U,EAAM;AACZ,YAAI,KAAKR,SAAL,CAAeS,GAAf,CAAmBD,IAAnB,CAAJ,EAA8B,CAAE,OAAO,EAAEI,OAAO,IAAT,EAAeb,MAAM,CAAC,IAAD,CAArB,EAAP,CAAuC;;AAEvE,YAAI,KAAKG,SAAL,CAAeO,GAAf,CAAmBD,IAAnB,CAAJ,EAA8B;AAC5B,cAAMN,YAAY,KAAKA,SAAL,CAAeW,GAAf,CAAmBL,IAAnB,CAAlB;AACA,cAAMM,WAAWZ,UAAUa,SAAV,EAAjB;;AAEA;AACA,cAAID,YAAY,IAAhB,EAAsB,CAAE,OAAO,EAAEF,OAAO,IAAT,EAAeb,MAAM,CAAC,IAAD,CAArB,EAAP,CAAuC;;AAE/D;AACA,cAAIe,SAASf,IAAT,KAAkB,KAAKA,IAAvB,IAA+BG,UAAUc,KAAV,KAAoBR,IAAvD,EAA6D;AAC3D,mBAAO,EAAEI,OAAO,KAAT,EAAgBb,MAAM,CAAC,IAAD,CAAtB,EAAP;AACD;;AAED,cAAMkB,OAAOH,SAASI,OAAT,CAAiBhB,UAAUc,KAA3B,CAAb;AACAC,eAAKlB,IAAL,CAAUoB,OAAV,CAAkB,IAAlB;;AAEA,iBAAOF,IAAP;AACD;;AAED;AACA,YAAIT,SAAS,SAAb,EAAwB;AACtB,kCAAkB,KAAKL,YAAvB,mIAAqC,KAA1BO,GAA0B;AACnC,kBAAMC,WAAWD,KAAjB;AACA,kBAAIC,YAAY,IAAhB,EAAsB,CAAE,OAAO,EAAEC,OAAO,IAAT,EAAeb,MAAM,CAAC,IAAD,CAArB,EAAP,CAAuC;AAC/D;AACA,kBAAI,CAACY,QAAL,EAAe,CAAE,SAAW;;AAE5B;AACA,kBAAIA,SAASZ,IAAT,KAAkB,KAAKA,IAA3B,EAAiC,CAAE,SAAW;;AAE9C,kBAAMqB,aAAaT,SAASO,OAAT,CAAiBV,IAAjB,CAAnB;AACA,kBAAIY,WAAWR,KAAf,EAAsB;AACpBQ,2BAAWrB,IAAX,CAAgBoB,OAAhB,CAAwB,IAAxB;AACA,uBAAOC,UAAP;AACD;AACF,aAfqB;AAgBvB;;AAED,eAAO,EAAER,OAAO,KAAT,EAAgBb,MAAM,CAAC,IAAD,CAAtB,EAAP;AACD,O;;AAEGS,U,EAAM;AACR,YAAI,KAAKR,SAAL,CAAeS,GAAf,CAAmBD,IAAnB,CAAJ,EAA8B,CAAE,OAAO,KAAKR,SAAL,CAAea,GAAf,CAAmBL,IAAnB,CAAP,CAAkC;;AAElE,YAAI,KAAKN,SAAL,CAAeO,GAAf,CAAmBD,IAAnB,CAAJ,EAA8B;AAC5B,cAAMN,YAAY,KAAKA,SAAL,CAAeW,GAAf,CAAmBL,IAAnB,CAAlB;AACA,cAAMM,WAAWZ,UAAUa,SAAV,EAAjB;;AAEA;AACA,cAAID,YAAY,IAAhB,EAAsB,CAAE,OAAO,IAAP,CAAc;;AAEtC;AACA,cAAIA,SAASf,IAAT,KAAkB,KAAKA,IAAvB,IAA+BG,UAAUc,KAAV,KAAoBR,IAAvD,EAA6D,CAAE,OAAOa,SAAP,CAAmB;;AAElF,iBAAOP,SAASD,GAAT,CAAaX,UAAUc,KAAvB,CAAP;AACD;;AAED;AACA,YAAIR,SAAS,SAAb,EAAwB;AACtB,kCAAkB,KAAKL,YAAvB,mIAAqC,KAA1BO,GAA0B;AACnC,kBAAMC,WAAWD,KAAjB;AACA;AACA,kBAAI,CAACC,QAAL,EAAe,CAAE,SAAW;;AAE5B;AACA,kBAAIA,SAASZ,IAAT,KAAkB,KAAKA,IAA3B,EAAiC,CAAE,SAAW;;AAE9C,kBAAMqB,aAAaT,SAASE,GAAT,CAAaL,IAAb,CAAnB;AACA,kBAAIY,eAAeC,SAAnB,EAA8B,CAAE,OAAOD,UAAP,CAAoB;AACrD,aAXqB;AAYvB;;AAED,eAAOC,SAAP;AACD,O;;AAEOC,c,EAAUC,O,EAAS;AACzB,aAAKvB,SAAL,CAAewB,OAAf,CAAuB,UAACC,CAAD,EAAIC,CAAJ,EAAU,CAAEJ,SAASK,IAAT,CAAcJ,OAAd,EAAuBE,CAAvB,EAA0BC,CAA1B,EAA6B,KAA7B,EAAqC,CAAxE;;AAEA,aAAKxB,SAAL,CAAesB,OAAf,CAAuB,UAACtB,SAAD,EAAYM,IAAZ,EAAqB;AAC1C,cAAMoB,aAAa1B,UAAUa,SAAV,EAAnB;AACA;AACAO,mBAASK,IAAT,CAAcJ,OAAd,EAAuBK,cAAcA,WAAWf,GAAX,CAAeX,UAAUc,KAAzB,CAArC,EAAsER,IAAtE,EAA4E,KAA5E;AACD,SAJD;;AAMA,aAAKL,YAAL,CAAkBqB,OAAlB,CAA0B,UAACd,GAAD,EAAS;AACjC,cAAMmB,IAAInB,KAAV;AACA;AACA,cAAImB,KAAK,IAAT,EAAe,CAAE,OAAS;;AAE1BA,YAAEL,OAAF,CAAU,UAACC,CAAD,EAAIC,CAAJ,EAAU;AAClB,gBAAIA,MAAM,SAAV,EAAqB;AACnBJ,uBAASK,IAAT,CAAcJ,OAAd,EAAuBE,CAAvB,EAA0BC,CAA1B,EAA6B,KAA7B;AACD;AACF,WAJD;AAKD,SAVD;AAWD,O;;AAED;;AAEaI,a,EAASC,W,EAAa;AACjC,YAAMC,MAAM,KAAK1B,MAAL;AACT2B,WADS,CACL,UAACC,CAAD,iBAAUA,EAAEC,OAAZ,kBAAwBD,EAAEE,UAA1B,iBAAwCF,EAAEG,MAA1C,SADK;AAETC,YAFS,CAEJ,IAFI,CAAZ;AAGAR,gBAAQS,MAAR,CAAe;AACbC,gBAAMT,YAAYU,MADL;AAEbN,iEAA6CJ,YAAYU,MAAZ,CAAmBC,KAAhE,oBAA2EV,GAA3E,CAFa,EAAf;;AAID,O,iFAzJgB,CAAE,OAAO,KAAKnB,GAAL,CAAS,SAAT,KAAuB,IAA9B,CAAqC,C,eAAC;qDAE9C,CACT,IAAI8B,OAAO,KAAK3C,SAAL,CAAe2C,IAAf,GAAsB,KAAKzC,SAAL,CAAeyC,IAAhD,CACA,KAAKxC,YAAL,CAAkBqB,OAAlB,CAA0B,UAACd,GAAD,EAAS,CACjC,IAAMmB,IAAInB,KAAV,CADiC,CAEjC;AACA,cAAImB,KAAK,IAAT,EAAe,CAAE,OAAS,CAC1Bc,QAAQd,EAAEc,IAAV,CACD,CALD,EAMA,OAAOA,IAAP,CACD,C,6DAlCkB7C,S","file":"index.js","sourcesContent":["export default class ExportMap {\n  constructor(path) {\n    this.path = path;\n    this.namespace = new Map();\n    // todo: restructure to key on path, value is resolver + map of names\n    this.reexports = new Map();\n    /**\n     * star-exports\n     * @type {Set<() => ExportMap>}\n     */\n    this.dependencies = new Set();\n    /**\n     * dependencies of this module that are not explicitly re-exported\n     * @type {Map<string, () => ExportMap>}\n     */\n    this.imports = new Map();\n    this.errors = [];\n    /**\n     * type {'ambiguous' | 'Module' | 'Script'}\n     */\n    this.parseGoal = 'ambiguous';\n  }\n\n  get hasDefault() { return this.get('default') != null; } // stronger than this.has\n\n  get size() {\n    let size = this.namespace.size + this.reexports.size;\n    this.dependencies.forEach((dep) => {\n      const d = dep();\n      // CJS / ignored dependencies won't exist (#717)\n      if (d == null) { return; }\n      size += d.size;\n    });\n    return size;\n  }\n\n  /**\n   * Note that this does not check explicitly re-exported names for existence\n   * in the base namespace, but it will expand all `export * from '...'` exports\n   * if not found in the explicit namespace.\n   * @param  {string}  name\n   * @return {boolean} true if `name` is exported by this module.\n   */\n  has(name) {\n    if (this.namespace.has(name)) { return true; }\n    if (this.reexports.has(name)) { return true; }\n\n    // default exports must be explicitly re-exported (#328)\n    if (name !== 'default') {\n      for (const dep of this.dependencies) {\n        const innerMap = dep();\n\n        // todo: report as unresolved?\n        if (!innerMap) { continue; }\n\n        if (innerMap.has(name)) { return true; }\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * ensure that imported name fully resolves.\n   * @param  {string} name\n   * @return {{ found: boolean, path: ExportMap[] }}\n   */\n  hasDeep(name) {\n    if (this.namespace.has(name)) { return { found: true, path: [this] }; }\n\n    if (this.reexports.has(name)) {\n      const reexports = this.reexports.get(name);\n      const imported = reexports.getImport();\n\n      // if import is ignored, return explicit 'null'\n      if (imported == null) { return { found: true, path: [this] }; }\n\n      // safeguard against cycles, only if name matches\n      if (imported.path === this.path && reexports.local === name) {\n        return { found: false, path: [this] };\n      }\n\n      const deep = imported.hasDeep(reexports.local);\n      deep.path.unshift(this);\n\n      return deep;\n    }\n\n    // default exports must be explicitly re-exported (#328)\n    if (name !== 'default') {\n      for (const dep of this.dependencies) {\n        const innerMap = dep();\n        if (innerMap == null) { return { found: true, path: [this] }; }\n        // todo: report as unresolved?\n        if (!innerMap) { continue; }\n\n        // safeguard against cycles\n        if (innerMap.path === this.path) { continue; }\n\n        const innerValue = innerMap.hasDeep(name);\n        if (innerValue.found) {\n          innerValue.path.unshift(this);\n          return innerValue;\n        }\n      }\n    }\n\n    return { found: false, path: [this] };\n  }\n\n  get(name) {\n    if (this.namespace.has(name)) { return this.namespace.get(name); }\n\n    if (this.reexports.has(name)) {\n      const reexports = this.reexports.get(name);\n      const imported = reexports.getImport();\n\n      // if import is ignored, return explicit 'null'\n      if (imported == null) { return null; }\n\n      // safeguard against cycles, only if name matches\n      if (imported.path === this.path && reexports.local === name) { return undefined; }\n\n      return imported.get(reexports.local);\n    }\n\n    // default exports must be explicitly re-exported (#328)\n    if (name !== 'default') {\n      for (const dep of this.dependencies) {\n        const innerMap = dep();\n        // todo: report as unresolved?\n        if (!innerMap) { continue; }\n\n        // safeguard against cycles\n        if (innerMap.path === this.path) { continue; }\n\n        const innerValue = innerMap.get(name);\n        if (innerValue !== undefined) { return innerValue; }\n      }\n    }\n\n    return undefined;\n  }\n\n  forEach(callback, thisArg) {\n    this.namespace.forEach((v, n) => { callback.call(thisArg, v, n, this); });\n\n    this.reexports.forEach((reexports, name) => {\n      const reexported = reexports.getImport();\n      // can't look up meta for ignored re-exports (#348)\n      callback.call(thisArg, reexported && reexported.get(reexports.local), name, this);\n    });\n\n    this.dependencies.forEach((dep) => {\n      const d = dep();\n      // CJS / ignored dependencies won't exist (#717)\n      if (d == null) { return; }\n\n      d.forEach((v, n) => {\n        if (n !== 'default') {\n          callback.call(thisArg, v, n, this);\n        }\n      });\n    });\n  }\n\n  // todo: keys, values, entries?\n\n  reportErrors(context, declaration) {\n    const msg = this.errors\n      .map((e) => `${e.message} (${e.lineNumber}:${e.column})`)\n      .join(', ');\n    context.report({\n      node: declaration.source,\n      message: `Parse errors in imported module '${declaration.source.value}': ${msg}`,\n    });\n  }\n}\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/namespace.js b/node_modules/eslint-plugin-import/lib/exportMap/namespace.js deleted file mode 100644 index 0b07bdd8c1..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/namespace.js +++ /dev/null @@ -1,39 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });var _createClass = function () {function defineProperties(target, props) {for (var i = 0; i < props.length; i++) {var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);}}return function (Constructor, protoProps, staticProps) {if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;};}();var _childContext = require('./childContext');var _childContext2 = _interopRequireDefault(_childContext); -var _remotePath = require('./remotePath');function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _classCallCheck(instance, Constructor) {if (!(instance instanceof Constructor)) {throw new TypeError("Cannot call a class as a function");}}var - -Namespace = function () { - function Namespace( - path, - context, - ExportMapBuilder) - {_classCallCheck(this, Namespace); - this.remotePathResolver = new _remotePath.RemotePath(path, context); - this.context = context; - this.ExportMapBuilder = ExportMapBuilder; - this.namespaces = new Map(); - }_createClass(Namespace, [{ key: 'resolveImport', value: function () {function resolveImport( - - value) { - var rp = this.remotePathResolver.resolve(value); - if (rp == null) {return null;} - return this.ExportMapBuilder['for']((0, _childContext2['default'])(rp, this.context)); - }return resolveImport;}() }, { key: 'getNamespace', value: function () {function getNamespace( - - identifier) {var _this = this; - if (!this.namespaces.has(identifier.name)) {return;} - return function () {return _this.resolveImport(_this.namespaces.get(identifier.name));}; - }return getNamespace;}() }, { key: 'add', value: function () {function add( - - object, identifier) { - var nsfn = this.getNamespace(identifier); - if (nsfn) { - Object.defineProperty(object, 'namespace', { get: nsfn }); - } - - return object; - }return add;}() }, { key: 'rawSet', value: function () {function rawSet( - - name, value) { - this.namespaces.set(name, value); - }return rawSet;}() }]);return Namespace;}();exports['default'] = Namespace; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/patternCapture.js b/node_modules/eslint-plugin-import/lib/exportMap/patternCapture.js deleted file mode 100644 index de0888a884..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/patternCapture.js +++ /dev/null @@ -1,41 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports['default'] = - - - - - - -recursivePatternCapture; /** - * Traverse a pattern/identifier node, calling 'callback' - * for each leaf identifier. - * @param {node} pattern - * @param {Function} callback - * @return {void} - */function recursivePatternCapture(pattern, callback) {switch (pattern.type) {case 'Identifier': // base case - callback(pattern);break;case 'ObjectPattern':pattern.properties.forEach(function (p) { - if (p.type === 'ExperimentalRestProperty' || p.type === 'RestElement') { - callback(p.argument); - return; - } - recursivePatternCapture(p.value, callback); - }); - break; - - case 'ArrayPattern': - pattern.elements.forEach(function (element) { - if (element == null) {return;} - if (element.type === 'ExperimentalRestProperty' || element.type === 'RestElement') { - callback(element.argument); - return; - } - recursivePatternCapture(element, callback); - }); - break; - - case 'AssignmentPattern': - callback(pattern.left); - break; - default:} - -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/remotePath.js b/node_modules/eslint-plugin-import/lib/exportMap/remotePath.js deleted file mode 100644 index c9906d3cf4..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/remotePath.js +++ /dev/null @@ -1,12 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports.RemotePath = undefined;var _createClass = function () {function defineProperties(target, props) {for (var i = 0; i < props.length; i++) {var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);}}return function (Constructor, protoProps, staticProps) {if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;};}();var _resolve2 = require('eslint-module-utils/resolve');var _resolve3 = _interopRequireDefault(_resolve2);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _classCallCheck(instance, Constructor) {if (!(instance instanceof Constructor)) {throw new TypeError("Cannot call a class as a function");}}var - -RemotePath = exports.RemotePath = function () { - function RemotePath(path, context) {_classCallCheck(this, RemotePath); - this.path = path; - this.context = context; - }_createClass(RemotePath, [{ key: 'resolve', value: function () {function resolve( - - value) { - return _resolve3['default'].relative(value, this.path, this.context.settings); - }return resolve;}() }]);return RemotePath;}(); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leHBvcnRNYXAvcmVtb3RlUGF0aC5qcyJdLCJuYW1lcyI6WyJSZW1vdGVQYXRoIiwicGF0aCIsImNvbnRleHQiLCJ2YWx1ZSIsInJlc29sdmUiLCJyZWxhdGl2ZSIsInNldHRpbmdzIl0sIm1hcHBpbmdzIjoiK29CQUFBLHVEOztBQUVhQSxVLFdBQUFBLFU7QUFDWCxzQkFBWUMsSUFBWixFQUFrQkMsT0FBbEIsRUFBMkI7QUFDekIsU0FBS0QsSUFBTCxHQUFZQSxJQUFaO0FBQ0EsU0FBS0MsT0FBTCxHQUFlQSxPQUFmO0FBQ0QsRzs7QUFFT0MsVyxFQUFPO0FBQ2IsZUFBT0MscUJBQVFDLFFBQVIsQ0FBaUJGLEtBQWpCLEVBQXdCLEtBQUtGLElBQTdCLEVBQW1DLEtBQUtDLE9BQUwsQ0FBYUksUUFBaEQsQ0FBUDtBQUNELE8iLCJmaWxlIjoicmVtb3RlUGF0aC5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCByZXNvbHZlIGZyb20gJ2VzbGludC1tb2R1bGUtdXRpbHMvcmVzb2x2ZSc7XG5cbmV4cG9ydCBjbGFzcyBSZW1vdGVQYXRoIHtcbiAgY29uc3RydWN0b3IocGF0aCwgY29udGV4dCkge1xuICAgIHRoaXMucGF0aCA9IHBhdGg7XG4gICAgdGhpcy5jb250ZXh0ID0gY29udGV4dDtcbiAgfVxuXG4gIHJlc29sdmUodmFsdWUpIHtcbiAgICByZXR1cm4gcmVzb2x2ZS5yZWxhdGl2ZSh2YWx1ZSwgdGhpcy5wYXRoLCB0aGlzLmNvbnRleHQuc2V0dGluZ3MpO1xuICB9XG59XG4iXX0= \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/specifier.js b/node_modules/eslint-plugin-import/lib/exportMap/specifier.js deleted file mode 100644 index 7670c0cde2..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/specifier.js +++ /dev/null @@ -1,33 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports['default'] = processSpecifier;function processSpecifier(specifier, astNode, exportMap, namespace) { - var nsource = astNode.source && astNode.source.value; - var exportMeta = {}; - var local = void 0; - - switch (specifier.type) { - case 'ExportDefaultSpecifier': - if (!nsource) {return;} - local = 'default'; - break; - case 'ExportNamespaceSpecifier': - exportMap.namespace.set(specifier.exported.name, Object.defineProperty(exportMeta, 'namespace', { - get: function () {function get() {return namespace.resolveImport(nsource);}return get;}() })); - - return; - case 'ExportAllDeclaration': - exportMap.namespace.set(specifier.exported.name || specifier.exported.value, namespace.add(exportMeta, specifier.source.value)); - return; - case 'ExportSpecifier': - if (!astNode.source) { - exportMap.namespace.set(specifier.exported.name || specifier.exported.value, namespace.add(exportMeta, specifier.local)); - return; - } - // else falls through - default: - local = specifier.local.name; - break;} - - - // todo: JSDoc - exportMap.reexports.set(specifier.exported.name, { local: local, getImport: function () {function getImport() {return namespace.resolveImport(nsource);}return getImport;}() }); -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/typescript.js b/node_modules/eslint-plugin-import/lib/exportMap/typescript.js deleted file mode 100644 index 5aad0ce08b..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/typescript.js +++ /dev/null @@ -1,44 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -isEsModuleInterop = isEsModuleInterop;var _path = require('path');var _tsconfigLoader = require('tsconfig-paths/lib/tsconfig-loader');var _hash = require('eslint-module-utils/hash');var ts = void 0;var tsconfigCache = new Map();function readTsConfig(context) {var tsconfigInfo = (0, _tsconfigLoader.tsConfigLoader)({ cwd: context.parserOptions && context.parserOptions.tsconfigRootDir || process.cwd(), getEnv: function () {function getEnv(key) {return process.env[key];}return getEnv;}() });try {if (tsconfigInfo.tsConfigPath !== undefined) {// Projects not using TypeScript won't have `typescript` installed. - if (!ts) {ts = require('typescript');} // eslint-disable-line import/no-extraneous-dependencies - var configFile = ts.readConfigFile(tsconfigInfo.tsConfigPath, ts.sys.readFile);return ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, _path.dirname)(tsconfigInfo.tsConfigPath));}} catch (e) {// Catch any errors - }return null;}function isEsModuleInterop(context) {var cacheKey = (0, _hash.hashObject)({ tsconfigRootDir: context.parserOptions && context.parserOptions.tsconfigRootDir }).digest('hex'); - var tsConfig = tsconfigCache.get(cacheKey); - if (typeof tsConfig === 'undefined') { - tsConfig = readTsConfig(context); - tsconfigCache.set(cacheKey, tsConfig); - } - - return tsConfig && tsConfig.options ? tsConfig.options.esModuleInterop : false; -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9leHBvcnRNYXAvdHlwZXNjcmlwdC5qcyJdLCJuYW1lcyI6WyJpc0VzTW9kdWxlSW50ZXJvcCIsInRzIiwidHNjb25maWdDYWNoZSIsIk1hcCIsInJlYWRUc0NvbmZpZyIsImNvbnRleHQiLCJ0c2NvbmZpZ0luZm8iLCJjd2QiLCJwYXJzZXJPcHRpb25zIiwidHNjb25maWdSb290RGlyIiwicHJvY2VzcyIsImdldEVudiIsImtleSIsImVudiIsInRzQ29uZmlnUGF0aCIsInVuZGVmaW5lZCIsInJlcXVpcmUiLCJjb25maWdGaWxlIiwicmVhZENvbmZpZ0ZpbGUiLCJzeXMiLCJyZWFkRmlsZSIsInBhcnNlSnNvbkNvbmZpZ0ZpbGVDb250ZW50IiwiY29uZmlnIiwiZSIsImNhY2hlS2V5IiwiZGlnZXN0IiwidHNDb25maWciLCJnZXQiLCJzZXQiLCJvcHRpb25zIiwiZXNNb2R1bGVJbnRlcm9wIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBK0JnQkEsaUIsR0FBQUEsaUIsQ0EvQmhCLDRCQUNBLG9FQUNBLGdEQUVBLElBQUlDLFdBQUosQ0FDQSxJQUFNQyxnQkFBZ0IsSUFBSUMsR0FBSixFQUF0QixDQUVBLFNBQVNDLFlBQVQsQ0FBc0JDLE9BQXRCLEVBQStCLENBQzdCLElBQU1DLGVBQWUsb0NBQWUsRUFDbENDLEtBQUtGLFFBQVFHLGFBQVIsSUFBeUJILFFBQVFHLGFBQVIsQ0FBc0JDLGVBQS9DLElBQWtFQyxRQUFRSCxHQUFSLEVBRHJDLEVBRWxDSSxxQkFBUSxnQkFBQ0MsR0FBRCxVQUFTRixRQUFRRyxHQUFSLENBQVlELEdBQVosQ0FBVCxFQUFSLGlCQUZrQyxFQUFmLENBQXJCLENBSUEsSUFBSSxDQUNGLElBQUlOLGFBQWFRLFlBQWIsS0FBOEJDLFNBQWxDLEVBQTZDLENBQzNDO0FBQ0EsVUFBSSxDQUFDZCxFQUFMLEVBQVMsQ0FBRUEsS0FBS2UsUUFBUSxZQUFSLENBQUwsQ0FBNkIsQ0FGRyxDQUVGO0FBRXpDLFVBQU1DLGFBQWFoQixHQUFHaUIsY0FBSCxDQUFrQlosYUFBYVEsWUFBL0IsRUFBNkNiLEdBQUdrQixHQUFILENBQU9DLFFBQXBELENBQW5CLENBQ0EsT0FBT25CLEdBQUdvQiwwQkFBSCxDQUNMSixXQUFXSyxNQUROLEVBRUxyQixHQUFHa0IsR0FGRSxFQUdMLG1CQUFRYixhQUFhUSxZQUFyQixDQUhLLENBQVAsQ0FLRCxDQUNGLENBWkQsQ0FZRSxPQUFPUyxDQUFQLEVBQVUsQ0FDVjtBQUNELEdBRUQsT0FBTyxJQUFQLENBQ0QsQ0FFTSxTQUFTdkIsaUJBQVQsQ0FBMkJLLE9BQTNCLEVBQW9DLENBQ3pDLElBQU1tQixXQUFXLHNCQUFXLEVBQzFCZixpQkFBaUJKLFFBQVFHLGFBQVIsSUFBeUJILFFBQVFHLGFBQVIsQ0FBc0JDLGVBRHRDLEVBQVgsRUFFZGdCLE1BRmMsQ0FFUCxLQUZPLENBQWpCO0FBR0EsTUFBSUMsV0FBV3hCLGNBQWN5QixHQUFkLENBQWtCSCxRQUFsQixDQUFmO0FBQ0EsTUFBSSxPQUFPRSxRQUFQLEtBQW9CLFdBQXhCLEVBQXFDO0FBQ25DQSxlQUFXdEIsYUFBYUMsT0FBYixDQUFYO0FBQ0FILGtCQUFjMEIsR0FBZCxDQUFrQkosUUFBbEIsRUFBNEJFLFFBQTVCO0FBQ0Q7O0FBRUQsU0FBT0EsWUFBWUEsU0FBU0csT0FBckIsR0FBK0JILFNBQVNHLE9BQVQsQ0FBaUJDLGVBQWhELEdBQWtFLEtBQXpFO0FBQ0QiLCJmaWxlIjoidHlwZXNjcmlwdC5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRpcm5hbWUgfSBmcm9tICdwYXRoJztcbmltcG9ydCB7IHRzQ29uZmlnTG9hZGVyIH0gZnJvbSAndHNjb25maWctcGF0aHMvbGliL3RzY29uZmlnLWxvYWRlcic7XG5pbXBvcnQgeyBoYXNoT2JqZWN0IH0gZnJvbSAnZXNsaW50LW1vZHVsZS11dGlscy9oYXNoJztcblxubGV0IHRzO1xuY29uc3QgdHNjb25maWdDYWNoZSA9IG5ldyBNYXAoKTtcblxuZnVuY3Rpb24gcmVhZFRzQ29uZmlnKGNvbnRleHQpIHtcbiAgY29uc3QgdHNjb25maWdJbmZvID0gdHNDb25maWdMb2FkZXIoe1xuICAgIGN3ZDogY29udGV4dC5wYXJzZXJPcHRpb25zICYmIGNvbnRleHQucGFyc2VyT3B0aW9ucy50c2NvbmZpZ1Jvb3REaXIgfHwgcHJvY2Vzcy5jd2QoKSxcbiAgICBnZXRFbnY6IChrZXkpID0+IHByb2Nlc3MuZW52W2tleV0sXG4gIH0pO1xuICB0cnkge1xuICAgIGlmICh0c2NvbmZpZ0luZm8udHNDb25maWdQYXRoICE9PSB1bmRlZmluZWQpIHtcbiAgICAgIC8vIFByb2plY3RzIG5vdCB1c2luZyBUeXBlU2NyaXB0IHdvbid0IGhhdmUgYHR5cGVzY3JpcHRgIGluc3RhbGxlZC5cbiAgICAgIGlmICghdHMpIHsgdHMgPSByZXF1aXJlKCd0eXBlc2NyaXB0Jyk7IH0gLy8gZXNsaW50LWRpc2FibGUtbGluZSBpbXBvcnQvbm8tZXh0cmFuZW91cy1kZXBlbmRlbmNpZXNcblxuICAgICAgY29uc3QgY29uZmlnRmlsZSA9IHRzLnJlYWRDb25maWdGaWxlKHRzY29uZmlnSW5mby50c0NvbmZpZ1BhdGgsIHRzLnN5cy5yZWFkRmlsZSk7XG4gICAgICByZXR1cm4gdHMucGFyc2VKc29uQ29uZmlnRmlsZUNvbnRlbnQoXG4gICAgICAgIGNvbmZpZ0ZpbGUuY29uZmlnLFxuICAgICAgICB0cy5zeXMsXG4gICAgICAgIGRpcm5hbWUodHNjb25maWdJbmZvLnRzQ29uZmlnUGF0aCksXG4gICAgICApO1xuICAgIH1cbiAgfSBjYXRjaCAoZSkge1xuICAgIC8vIENhdGNoIGFueSBlcnJvcnNcbiAgfVxuXG4gIHJldHVybiBudWxsO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNFc01vZHVsZUludGVyb3AoY29udGV4dCkge1xuICBjb25zdCBjYWNoZUtleSA9IGhhc2hPYmplY3Qoe1xuICAgIHRzY29uZmlnUm9vdERpcjogY29udGV4dC5wYXJzZXJPcHRpb25zICYmIGNvbnRleHQucGFyc2VyT3B0aW9ucy50c2NvbmZpZ1Jvb3REaXIsXG4gIH0pLmRpZ2VzdCgnaGV4Jyk7XG4gIGxldCB0c0NvbmZpZyA9IHRzY29uZmlnQ2FjaGUuZ2V0KGNhY2hlS2V5KTtcbiAgaWYgKHR5cGVvZiB0c0NvbmZpZyA9PT0gJ3VuZGVmaW5lZCcpIHtcbiAgICB0c0NvbmZpZyA9IHJlYWRUc0NvbmZpZyhjb250ZXh0KTtcbiAgICB0c2NvbmZpZ0NhY2hlLnNldChjYWNoZUtleSwgdHNDb25maWcpO1xuICB9XG5cbiAgcmV0dXJuIHRzQ29uZmlnICYmIHRzQ29uZmlnLm9wdGlvbnMgPyB0c0NvbmZpZy5vcHRpb25zLmVzTW9kdWxlSW50ZXJvcCA6IGZhbHNlO1xufVxuIl19 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/exportMap/visitor.js b/node_modules/eslint-plugin-import/lib/exportMap/visitor.js deleted file mode 100644 index 38f51889f1..0000000000 --- a/node_modules/eslint-plugin-import/lib/exportMap/visitor.js +++ /dev/null @@ -1,171 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });var _createClass = function () {function defineProperties(target, props) {for (var i = 0; i < props.length; i++) {var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);}}return function (Constructor, protoProps, staticProps) {if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;};}();var _arrayIncludes = require('array-includes');var _arrayIncludes2 = _interopRequireDefault(_arrayIncludes); -var _eslint = require('eslint'); -var _doc = require('./doc'); -var _namespace = require('./namespace');var _namespace2 = _interopRequireDefault(_namespace); -var _specifier = require('./specifier');var _specifier2 = _interopRequireDefault(_specifier); -var _captureDependency = require('./captureDependency'); -var _patternCapture = require('./patternCapture');var _patternCapture2 = _interopRequireDefault(_patternCapture); -var _remotePath = require('./remotePath');function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _classCallCheck(instance, Constructor) {if (!(instance instanceof Constructor)) {throw new TypeError("Cannot call a class as a function");}} - -/** - * sometimes legacy support isn't _that_ hard... right? - */ -function makeSourceCode(text, ast) { - if (_eslint.SourceCode.length > 1) { - // ESLint 3 - return new _eslint.SourceCode(text, ast); - } else { - // ESLint 4, 5 - return new _eslint.SourceCode({ text: text, ast: ast }); - } -}var - -ImportExportVisitorBuilder = function () { - function ImportExportVisitorBuilder( - path, - context, - exportMap, - ExportMapBuilder, - content, - ast, - isEsModuleInteropTrue, - thunkFor) - {var _this = this;_classCallCheck(this, ImportExportVisitorBuilder); - this.context = context; - this.namespace = new _namespace2['default'](path, context, ExportMapBuilder); - this.remotePathResolver = new _remotePath.RemotePath(path, context); - this.source = makeSourceCode(content, ast); - this.exportMap = exportMap; - this.ast = ast; - this.isEsModuleInteropTrue = isEsModuleInteropTrue; - this.thunkFor = thunkFor; - var docstyle = this.context.settings && this.context.settings['import/docstyle'] || ['jsdoc']; - this.docStyleParsers = {}; - docstyle.forEach(function (style) { - _this.docStyleParsers[style] = _doc.availableDocStyleParsers[style]; - }); - }_createClass(ImportExportVisitorBuilder, [{ key: 'build', value: function () {function build( - - astNode) {var _this3 = this; - return Object.assign({ - ExportDefaultDeclaration: function () {function ExportDefaultDeclaration() { - var exportMeta = (0, _doc.captureDoc)(this.source, this.docStyleParsers, astNode); - if (astNode.declaration.type === 'Identifier') { - this.namespace.add(exportMeta, astNode.declaration); - } - this.exportMap.namespace.set('default', exportMeta); - }return ExportDefaultDeclaration;}(), - ExportAllDeclaration: function () {function ExportAllDeclaration() { - var getter = (0, _captureDependency.captureDependency)(astNode, astNode.exportKind === 'type', this.remotePathResolver, this.exportMap, this.context, this.thunkFor); - if (getter) {this.exportMap.dependencies.add(getter);} - if (astNode.exported) { - (0, _specifier2['default'])(astNode, astNode.exported, this.exportMap, this.namespace); - } - }return ExportAllDeclaration;}(), - /** capture namespaces in case of later export */ - ImportDeclaration: function () {function ImportDeclaration() { - (0, _captureDependency.captureDependencyWithSpecifiers)(astNode, this.remotePathResolver, this.exportMap, this.context, this.thunkFor); - var ns = astNode.specifiers.find(function (s) {return s.type === 'ImportNamespaceSpecifier';}); - if (ns) { - this.namespace.rawSet(ns.local.name, astNode.source.value); - } - }return ImportDeclaration;}(), - ExportNamedDeclaration: function () {function ExportNamedDeclaration() {var _this2 = this; - (0, _captureDependency.captureDependencyWithSpecifiers)(astNode, this.remotePathResolver, this.exportMap, this.context, this.thunkFor); - // capture declaration - if (astNode.declaration != null) { - switch (astNode.declaration.type) { - case 'FunctionDeclaration': - case 'ClassDeclaration': - case 'TypeAlias': // flowtype with babel-eslint parser - case 'InterfaceDeclaration': - case 'DeclareFunction': - case 'TSDeclareFunction': - case 'TSEnumDeclaration': - case 'TSTypeAliasDeclaration': - case 'TSInterfaceDeclaration': - case 'TSAbstractClassDeclaration': - case 'TSModuleDeclaration': - this.exportMap.namespace.set(astNode.declaration.id.name, (0, _doc.captureDoc)(this.source, this.docStyleParsers, astNode)); - break; - case 'VariableDeclaration': - astNode.declaration.declarations.forEach(function (d) { - (0, _patternCapture2['default'])( - d.id, - function (id) {return _this2.exportMap.namespace.set(id.name, (0, _doc.captureDoc)(_this2.source, _this2.docStyleParsers, d, astNode));}); - - }); - break; - default:} - - } - astNode.specifiers.forEach(function (s) {return (0, _specifier2['default'])(s, astNode, _this2.exportMap, _this2.namespace);}); - }return ExportNamedDeclaration;}(), - TSExportAssignment: function () {function TSExportAssignment() {return _this3.typeScriptExport(astNode);}return TSExportAssignment;}() }, - this.isEsModuleInteropTrue && { TSNamespaceExportDeclaration: function () {function TSNamespaceExportDeclaration() {return _this3.typeScriptExport(astNode);}return TSNamespaceExportDeclaration;}() }); - - }return build;}() - - // This doesn't declare anything, but changes what's being exported. - }, { key: 'typeScriptExport', value: function () {function typeScriptExport(astNode) {var _this4 = this; - var exportedName = astNode.type === 'TSNamespaceExportDeclaration' ? - (astNode.id || astNode.name).name : - astNode.expression && astNode.expression.name || astNode.expression.id && astNode.expression.id.name || null; - var declTypes = [ - 'VariableDeclaration', - 'ClassDeclaration', - 'TSDeclareFunction', - 'TSEnumDeclaration', - 'TSTypeAliasDeclaration', - 'TSInterfaceDeclaration', - 'TSAbstractClassDeclaration', - 'TSModuleDeclaration']; - - var exportedDecls = this.ast.body.filter(function (_ref) {var type = _ref.type,id = _ref.id,declarations = _ref.declarations;return (0, _arrayIncludes2['default'])(declTypes, type) && ( - id && id.name === exportedName || declarations && declarations.find(function (d) {return d.id.name === exportedName;}));}); - - if (exportedDecls.length === 0) { - // Export is not referencing any local declaration, must be re-exporting - this.exportMap.namespace.set('default', (0, _doc.captureDoc)(this.source, this.docStyleParsers, astNode)); - return; - } - if ( - this.isEsModuleInteropTrue // esModuleInterop is on in tsconfig - && !this.exportMap.namespace.has('default') // and default isn't added already - ) { - this.exportMap.namespace.set('default', {}); // add default export - } - exportedDecls.forEach(function (decl) { - if (decl.type === 'TSModuleDeclaration') { - if (decl.body && decl.body.type === 'TSModuleDeclaration') { - _this4.exportMap.namespace.set(decl.body.id.name, (0, _doc.captureDoc)(_this4.source, _this4.docStyleParsers, decl.body)); - } else if (decl.body && decl.body.body) { - decl.body.body.forEach(function (moduleBlockNode) { - // Export-assignment exports all members in the namespace, - // explicitly exported or not. - var namespaceDecl = moduleBlockNode.type === 'ExportNamedDeclaration' ? - moduleBlockNode.declaration : - moduleBlockNode; - - if (!namespaceDecl) { - // TypeScript can check this for us; we needn't - } else if (namespaceDecl.type === 'VariableDeclaration') { - namespaceDecl.declarations.forEach(function (d) {return (0, _patternCapture2['default'])(d.id, function (id) {return _this4.exportMap.namespace.set( - id.name, - (0, _doc.captureDoc)(_this4.source, _this4.docStyleParsers, decl, namespaceDecl, moduleBlockNode));});}); - - - } else { - _this4.exportMap.namespace.set( - namespaceDecl.id.name, - (0, _doc.captureDoc)(_this4.source, _this4.docStyleParsers, moduleBlockNode)); - } - }); - } - } else { - // Export as default - _this4.exportMap.namespace.set('default', (0, _doc.captureDoc)(_this4.source, _this4.docStyleParsers, decl)); - } - }); - }return typeScriptExport;}() }]);return ImportExportVisitorBuilder;}();exports['default'] = ImportExportVisitorBuilder; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/exportMap/visitor.js"],"names":["makeSourceCode","text","ast","SourceCode","length","ImportExportVisitorBuilder","path","context","exportMap","ExportMapBuilder","content","isEsModuleInteropTrue","thunkFor","namespace","Namespace","remotePathResolver","RemotePath","source","docstyle","settings","docStyleParsers","forEach","style","availableDocStyleParsers","astNode","ExportDefaultDeclaration","exportMeta","declaration","type","add","set","ExportAllDeclaration","getter","exportKind","dependencies","exported","ImportDeclaration","ns","specifiers","find","s","rawSet","local","name","value","ExportNamedDeclaration","id","declarations","d","TSExportAssignment","typeScriptExport","TSNamespaceExportDeclaration","exportedName","expression","declTypes","exportedDecls","body","filter","has","decl","moduleBlockNode","namespaceDecl"],"mappings":"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","file":"visitor.js","sourcesContent":["import includes from 'array-includes';\nimport { SourceCode } from 'eslint';\nimport { availableDocStyleParsers, captureDoc } from './doc';\nimport Namespace from './namespace';\nimport processSpecifier from './specifier';\nimport { captureDependency, captureDependencyWithSpecifiers } from './captureDependency';\nimport recursivePatternCapture from './patternCapture';\nimport { RemotePath } from './remotePath';\n\n/**\n * sometimes legacy support isn't _that_ hard... right?\n */\nfunction makeSourceCode(text, ast) {\n  if (SourceCode.length > 1) {\n    // ESLint 3\n    return new SourceCode(text, ast);\n  } else {\n    // ESLint 4, 5\n    return new SourceCode({ text, ast });\n  }\n}\n\nexport default class ImportExportVisitorBuilder {\n  constructor(\n    path,\n    context,\n    exportMap,\n    ExportMapBuilder,\n    content,\n    ast,\n    isEsModuleInteropTrue,\n    thunkFor,\n  ) {\n    this.context = context;\n    this.namespace = new Namespace(path, context, ExportMapBuilder);\n    this.remotePathResolver = new RemotePath(path, context);\n    this.source = makeSourceCode(content, ast);\n    this.exportMap = exportMap;\n    this.ast = ast;\n    this.isEsModuleInteropTrue = isEsModuleInteropTrue;\n    this.thunkFor = thunkFor;\n    const docstyle = this.context.settings && this.context.settings['import/docstyle'] || ['jsdoc'];\n    this.docStyleParsers = {};\n    docstyle.forEach((style) => {\n      this.docStyleParsers[style] = availableDocStyleParsers[style];\n    });\n  }\n\n  build(astNode) {\n    return {\n      ExportDefaultDeclaration() {\n        const exportMeta = captureDoc(this.source, this.docStyleParsers, astNode);\n        if (astNode.declaration.type === 'Identifier') {\n          this.namespace.add(exportMeta, astNode.declaration);\n        }\n        this.exportMap.namespace.set('default', exportMeta);\n      },\n      ExportAllDeclaration() {\n        const getter = captureDependency(astNode, astNode.exportKind === 'type', this.remotePathResolver, this.exportMap, this.context, this.thunkFor);\n        if (getter) { this.exportMap.dependencies.add(getter); }\n        if (astNode.exported) {\n          processSpecifier(astNode, astNode.exported, this.exportMap, this.namespace);\n        }\n      },\n      /** capture namespaces in case of later export */\n      ImportDeclaration() {\n        captureDependencyWithSpecifiers(astNode, this.remotePathResolver, this.exportMap, this.context, this.thunkFor);\n        const ns = astNode.specifiers.find((s) => s.type === 'ImportNamespaceSpecifier');\n        if (ns) {\n          this.namespace.rawSet(ns.local.name, astNode.source.value);\n        }\n      },\n      ExportNamedDeclaration() {\n        captureDependencyWithSpecifiers(astNode, this.remotePathResolver, this.exportMap, this.context, this.thunkFor);\n        // capture declaration\n        if (astNode.declaration != null) {\n          switch (astNode.declaration.type) {\n            case 'FunctionDeclaration':\n            case 'ClassDeclaration':\n            case 'TypeAlias': // flowtype with babel-eslint parser\n            case 'InterfaceDeclaration':\n            case 'DeclareFunction':\n            case 'TSDeclareFunction':\n            case 'TSEnumDeclaration':\n            case 'TSTypeAliasDeclaration':\n            case 'TSInterfaceDeclaration':\n            case 'TSAbstractClassDeclaration':\n            case 'TSModuleDeclaration':\n              this.exportMap.namespace.set(astNode.declaration.id.name, captureDoc(this.source, this.docStyleParsers, astNode));\n              break;\n            case 'VariableDeclaration':\n              astNode.declaration.declarations.forEach((d) => {\n                recursivePatternCapture(\n                  d.id,\n                  (id) => this.exportMap.namespace.set(id.name, captureDoc(this.source, this.docStyleParsers, d, astNode)),\n                );\n              });\n              break;\n            default:\n          }\n        }\n        astNode.specifiers.forEach((s) => processSpecifier(s, astNode, this.exportMap, this.namespace));\n      },\n      TSExportAssignment: () => this.typeScriptExport(astNode),\n      ...this.isEsModuleInteropTrue && { TSNamespaceExportDeclaration: () => this.typeScriptExport(astNode) },\n    };\n  }\n\n  // This doesn't declare anything, but changes what's being exported.\n  typeScriptExport(astNode) {\n    const exportedName = astNode.type === 'TSNamespaceExportDeclaration'\n      ? (astNode.id || astNode.name).name\n      : astNode.expression && astNode.expression.name || astNode.expression.id && astNode.expression.id.name || null;\n    const declTypes = [\n      'VariableDeclaration',\n      'ClassDeclaration',\n      'TSDeclareFunction',\n      'TSEnumDeclaration',\n      'TSTypeAliasDeclaration',\n      'TSInterfaceDeclaration',\n      'TSAbstractClassDeclaration',\n      'TSModuleDeclaration',\n    ];\n    const exportedDecls = this.ast.body.filter(({ type, id, declarations }) => includes(declTypes, type) && (\n      id && id.name === exportedName || declarations && declarations.find((d) => d.id.name === exportedName)\n    ));\n    if (exportedDecls.length === 0) {\n      // Export is not referencing any local declaration, must be re-exporting\n      this.exportMap.namespace.set('default', captureDoc(this.source, this.docStyleParsers, astNode));\n      return;\n    }\n    if (\n      this.isEsModuleInteropTrue // esModuleInterop is on in tsconfig\n      && !this.exportMap.namespace.has('default') // and default isn't added already\n    ) {\n      this.exportMap.namespace.set('default', {}); // add default export\n    }\n    exportedDecls.forEach((decl) => {\n      if (decl.type === 'TSModuleDeclaration') {\n        if (decl.body && decl.body.type === 'TSModuleDeclaration') {\n          this.exportMap.namespace.set(decl.body.id.name, captureDoc(this.source, this.docStyleParsers, decl.body));\n        } else if (decl.body && decl.body.body) {\n          decl.body.body.forEach((moduleBlockNode) => {\n            // Export-assignment exports all members in the namespace,\n            // explicitly exported or not.\n            const namespaceDecl = moduleBlockNode.type === 'ExportNamedDeclaration'\n              ? moduleBlockNode.declaration\n              : moduleBlockNode;\n\n            if (!namespaceDecl) {\n              // TypeScript can check this for us; we needn't\n            } else if (namespaceDecl.type === 'VariableDeclaration') {\n              namespaceDecl.declarations.forEach((d) => recursivePatternCapture(d.id, (id) => this.exportMap.namespace.set(\n                id.name,\n                captureDoc(this.source, this.docStyleParsers, decl, namespaceDecl, moduleBlockNode),\n              )),\n              );\n            } else {\n              this.exportMap.namespace.set(\n                namespaceDecl.id.name,\n                captureDoc(this.source, this.docStyleParsers, moduleBlockNode));\n            }\n          });\n        }\n      } else {\n        // Export as default\n        this.exportMap.namespace.set('default', captureDoc(this.source, this.docStyleParsers, decl));\n      }\n    });\n  }\n}\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/index.js b/node_modules/eslint-plugin-import/lib/index.js index 9f53379f91..daf8d74398 100644 --- a/node_modules/eslint-plugin-import/lib/index.js +++ b/node_modules/eslint-plugin-import/lib/index.js @@ -1,6 +1,4 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });exports.flatConfigs = exports.configs = exports.rules = undefined;var _package = require('../package.json'); - -var rules = exports.rules = { +'use strict';Object.defineProperty(exports, "__esModule", { value: true });var rules = exports.rules = { 'no-unresolved': require('./rules/no-unresolved'), named: require('./rules/named'), 'default': require('./rules/default'), @@ -70,33 +68,4 @@ var configs = exports.configs = { 'react-native': require('../config/react-native'), electron: require('../config/electron'), typescript: require('../config/typescript') }; - - -// Base Plugin Object -var importPlugin = { - meta: { name: _package.name, version: _package.version }, - rules: rules }; - - -// Create flat configs (Only ones that declare plugins and parser options need to be different from the legacy config) -var createFlatConfig = function createFlatConfig(baseConfig, configName) {return Object.assign({}, - baseConfig, { - name: 'import/' + String(configName), - plugins: { 'import': importPlugin } });}; - - -var flatConfigs = exports.flatConfigs = { - recommended: createFlatConfig( - require('../config/flat/recommended'), - 'recommended'), - - - errors: createFlatConfig(require('../config/flat/errors'), 'errors'), - warnings: createFlatConfig(require('../config/flat/warnings'), 'warnings'), - - // useful stuff for folks using various environments - react: require('../config/flat/react'), - 'react-native': configs['react-native'], - electron: configs.electron, - typescript: configs.typescript }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["rules","require","named","namespace","extensions","first","order","unambiguous","configs","recommended","errors","warnings","react","electron","typescript","importPlugin","meta","name","version","createFlatConfig","baseConfig","configName","plugins","flatConfigs"],"mappings":"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","file":"index.js","sourcesContent":["import { name, version } from '../package.json';\n\nexport const rules = {\n  'no-unresolved': require('./rules/no-unresolved'),\n  named: require('./rules/named'),\n  default: require('./rules/default'),\n  namespace: require('./rules/namespace'),\n  'no-namespace': require('./rules/no-namespace'),\n  export: require('./rules/export'),\n  'no-mutable-exports': require('./rules/no-mutable-exports'),\n  extensions: require('./rules/extensions'),\n  'no-restricted-paths': require('./rules/no-restricted-paths'),\n  'no-internal-modules': require('./rules/no-internal-modules'),\n  'group-exports': require('./rules/group-exports'),\n  'no-relative-packages': require('./rules/no-relative-packages'),\n  'no-relative-parent-imports': require('./rules/no-relative-parent-imports'),\n  'consistent-type-specifier-style': require('./rules/consistent-type-specifier-style'),\n\n  'no-self-import': require('./rules/no-self-import'),\n  'no-cycle': require('./rules/no-cycle'),\n  'no-named-default': require('./rules/no-named-default'),\n  'no-named-as-default': require('./rules/no-named-as-default'),\n  'no-named-as-default-member': require('./rules/no-named-as-default-member'),\n  'no-anonymous-default-export': require('./rules/no-anonymous-default-export'),\n  'no-unused-modules': require('./rules/no-unused-modules'),\n\n  'no-commonjs': require('./rules/no-commonjs'),\n  'no-amd': require('./rules/no-amd'),\n  'no-duplicates': require('./rules/no-duplicates'),\n  first: require('./rules/first'),\n  'max-dependencies': require('./rules/max-dependencies'),\n  'no-extraneous-dependencies': require('./rules/no-extraneous-dependencies'),\n  'no-absolute-path': require('./rules/no-absolute-path'),\n  'no-nodejs-modules': require('./rules/no-nodejs-modules'),\n  'no-webpack-loader-syntax': require('./rules/no-webpack-loader-syntax'),\n  order: require('./rules/order'),\n  'newline-after-import': require('./rules/newline-after-import'),\n  'prefer-default-export': require('./rules/prefer-default-export'),\n  'no-default-export': require('./rules/no-default-export'),\n  'no-named-export': require('./rules/no-named-export'),\n  'no-dynamic-require': require('./rules/no-dynamic-require'),\n  unambiguous: require('./rules/unambiguous'),\n  'no-unassigned-import': require('./rules/no-unassigned-import'),\n  'no-useless-path-segments': require('./rules/no-useless-path-segments'),\n  'dynamic-import-chunkname': require('./rules/dynamic-import-chunkname'),\n  'no-import-module-exports': require('./rules/no-import-module-exports'),\n  'no-empty-named-blocks': require('./rules/no-empty-named-blocks'),\n\n  // export\n  'exports-last': require('./rules/exports-last'),\n\n  // metadata-based\n  'no-deprecated': require('./rules/no-deprecated'),\n\n  // deprecated aliases to rules\n  'imports-first': require('./rules/imports-first'),\n};\n\nexport const configs = {\n  recommended: require('../config/recommended'),\n\n  errors: require('../config/errors'),\n  warnings: require('../config/warnings'),\n\n  // shhhh... work in progress \"secret\" rules\n  'stage-0': require('../config/stage-0'),\n\n  // useful stuff for folks using various environments\n  react: require('../config/react'),\n  'react-native': require('../config/react-native'),\n  electron: require('../config/electron'),\n  typescript: require('../config/typescript'),\n};\n\n// Base Plugin Object\nconst importPlugin = {\n  meta: { name, version },\n  rules,\n};\n\n// Create flat configs (Only ones that declare plugins and parser options need to be different from the legacy config)\nconst createFlatConfig = (baseConfig, configName) => ({\n  ...baseConfig,\n  name: `import/${configName}`,\n  plugins: { import: importPlugin },\n});\n\nexport const flatConfigs = {\n  recommended: createFlatConfig(\n    require('../config/flat/recommended'),\n    'recommended',\n  ),\n\n  errors: createFlatConfig(require('../config/flat/errors'), 'errors'),\n  warnings: createFlatConfig(require('../config/flat/warnings'), 'warnings'),\n\n  // useful stuff for folks using various environments\n  react: require('../config/flat/react'),\n  'react-native': configs['react-native'],\n  electron: configs.electron,\n  typescript: configs.typescript,\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/default.js b/node_modules/eslint-plugin-import/lib/rules/default.js index fbb4f6cbcb..f3e7d58d28 100644 --- a/node_modules/eslint-plugin-import/lib/rules/default.js +++ b/node_modules/eslint-plugin-import/lib/rules/default.js @@ -1,4 +1,4 @@ -'use strict';var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder); +'use strict';var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };} module.exports = { @@ -19,7 +19,7 @@ module.exports = { if (!defaultSpecifier) {return;} - var imports = _builder2['default'].get(node.source.value, context); + var imports = _ExportMap2['default'].get(node.source.value, context); if (imports == null) {return;} if (imports.errors.length) { @@ -37,4 +37,4 @@ module.exports = { ExportNamedDeclaration: checkDefault.bind(null, 'ExportDefaultSpecifier') }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/dynamic-import-chunkname.js b/node_modules/eslint-plugin-import/lib/rules/dynamic-import-chunkname.js index b05d61d648..926dcf7e26 100644 --- a/node_modules/eslint-plugin-import/lib/rules/dynamic-import-chunkname.js +++ b/node_modules/eslint-plugin-import/lib/rules/dynamic-import-chunkname.js @@ -19,28 +19,22 @@ module.exports = { type: 'string' } }, - allowEmpty: { - type: 'boolean' }, - webpackChunknameFormat: { - type: 'string' } } }], + type: 'string' } } }] }, - hasSuggestions: true }, create: function () {function create(context) { var config = context.options[0];var _ref = - config || {},_ref$importFunctions = _ref.importFunctions,importFunctions = _ref$importFunctions === undefined ? [] : _ref$importFunctions,_ref$allowEmpty = _ref.allowEmpty,allowEmpty = _ref$allowEmpty === undefined ? false : _ref$allowEmpty;var _ref2 = + config || {},_ref$importFunctions = _ref.importFunctions,importFunctions = _ref$importFunctions === undefined ? [] : _ref$importFunctions;var _ref2 = config || {},_ref2$webpackChunknam = _ref2.webpackChunknameFormat,webpackChunknameFormat = _ref2$webpackChunknam === undefined ? '([0-9a-zA-Z-_/.]|\\[(request|index)\\])+' : _ref2$webpackChunknam; var paddedCommentRegex = /^ (\S[\s\S]+\S) $/; var commentStyleRegex = /^( ((webpackChunkName: .+)|((webpackPrefetch|webpackPreload): (true|false|-?[0-9]+))|(webpackIgnore: (true|false))|((webpackInclude|webpackExclude): \/.*\/)|(webpackMode: ["'](lazy|lazy-once|eager|weak)["'])|(webpackExports: (['"]\w+['"]|\[(['"]\w+['"], *)+(['"]\w+['"]*)\]))),?)+ $/; - var chunkSubstrFormat = 'webpackChunkName: ["\']' + String(webpackChunknameFormat) + '["\'],? '; + var chunkSubstrFormat = ' webpackChunkName: ["\']' + String(webpackChunknameFormat) + '["\'],? '; var chunkSubstrRegex = new RegExp(chunkSubstrFormat); - var eagerModeFormat = 'webpackMode: ["\']eager["\'],? '; - var eagerModeRegex = new RegExp(eagerModeFormat); function run(node, arg) { var sourceCode = context.getSourceCode(); @@ -48,7 +42,7 @@ module.exports = { sourceCode.getCommentsBefore(arg) // This method is available in ESLint >= 4. : sourceCode.getComments(arg).leading; // This method is deprecated in ESLint 7. - if ((!leadingComments || leadingComments.length === 0) && !allowEmpty) { + if (!leadingComments || leadingComments.length === 0) { context.report({ node: node, message: 'dynamic imports require a leading comment with the webpack chunkname' }); @@ -56,8 +50,7 @@ module.exports = { return; } - var isChunknamePresent = false; - var isEagerModePresent = false;var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try { + var isChunknamePresent = false;var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try { for (var _iterator = leadingComments[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var comment = _step.value; if (comment.type !== 'Block') { @@ -96,55 +89,12 @@ module.exports = { return; } - if (eagerModeRegex.test(comment.value)) { - isEagerModePresent = true; - } - if (chunkSubstrRegex.test(comment.value)) { isChunknamePresent = true; } }} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}} - if (isChunknamePresent && isEagerModePresent) { - context.report({ - node: node, - message: 'dynamic imports using eager mode do not need a webpackChunkName', - suggest: [ - { - desc: 'Remove webpackChunkName', - fix: function () {function fix(fixer) {var _iteratorNormalCompletion2 = true;var _didIteratorError2 = false;var _iteratorError2 = undefined;try { - for (var _iterator2 = leadingComments[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {var _comment = _step2.value; - if (chunkSubstrRegex.test(_comment.value)) { - var replacement = _comment.value.replace(chunkSubstrRegex, '').trim().replace(/,$/, ''); - if (replacement === '') { - return fixer.remove(_comment); - } else { - return fixer.replaceText(_comment, '/* ' + String(replacement) + ' */'); - } - } - }} catch (err) {_didIteratorError2 = true;_iteratorError2 = err;} finally {try {if (!_iteratorNormalCompletion2 && _iterator2['return']) {_iterator2['return']();}} finally {if (_didIteratorError2) {throw _iteratorError2;}}} - }return fix;}() }, - - { - desc: 'Remove webpackMode', - fix: function () {function fix(fixer) {var _iteratorNormalCompletion3 = true;var _didIteratorError3 = false;var _iteratorError3 = undefined;try { - for (var _iterator3 = leadingComments[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {var _comment2 = _step3.value; - if (eagerModeRegex.test(_comment2.value)) { - var replacement = _comment2.value.replace(eagerModeRegex, '').trim().replace(/,$/, ''); - if (replacement === '') { - return fixer.remove(_comment2); - } else { - return fixer.replaceText(_comment2, '/* ' + String(replacement) + ' */'); - } - } - }} catch (err) {_didIteratorError3 = true;_iteratorError3 = err;} finally {try {if (!_iteratorNormalCompletion3 && _iterator3['return']) {_iterator3['return']();}} finally {if (_didIteratorError3) {throw _iteratorError3;}}} - }return fix;}() }] }); - - - - } - - if (!isChunknamePresent && !allowEmpty && !isEagerModePresent) { + if (!isChunknamePresent) { context.report({ node: node, message: 'dynamic imports require a leading comment in the form /*' + @@ -167,4 +117,4 @@ module.exports = { }return CallExpression;}() }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/dynamic-import-chunkname.js"],"names":["module","exports","meta","type","docs","category","description","url","schema","properties","importFunctions","uniqueItems","items","allowEmpty","webpackChunknameFormat","hasSuggestions","create","context","config","options","paddedCommentRegex","commentStyleRegex","chunkSubstrFormat","chunkSubstrRegex","RegExp","eagerModeFormat","eagerModeRegex","run","node","arg","sourceCode","getSourceCode","leadingComments","getCommentsBefore","getComments","leading","length","report","message","isChunknamePresent","isEagerModePresent","comment","test","value","vm","runInNewContext","error","suggest","desc","fix","fixer","replacement","replace","trim","remove","replaceText","ImportExpression","source","CallExpression","callee","indexOf","name","arguments"],"mappings":"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","file":"dynamic-import-chunkname.js","sourcesContent":["import vm from 'vm';\nimport docsUrl from '../docsUrl';\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Enforce a leading comment with the webpackChunkName for dynamic imports.',\n      url: docsUrl('dynamic-import-chunkname'),\n    },\n    schema: [{\n      type: 'object',\n      properties: {\n        importFunctions: {\n          type: 'array',\n          uniqueItems: true,\n          items: {\n            type: 'string',\n          },\n        },\n        allowEmpty: {\n          type: 'boolean',\n        },\n        webpackChunknameFormat: {\n          type: 'string',\n        },\n      },\n    }],\n    hasSuggestions: true,\n  },\n\n  create(context) {\n    const config = context.options[0];\n    const { importFunctions = [], allowEmpty = false } = config || {};\n    const { webpackChunknameFormat = '([0-9a-zA-Z-_/.]|\\\\[(request|index)\\\\])+' } = config || {};\n\n    const paddedCommentRegex = /^ (\\S[\\s\\S]+\\S) $/;\n    const commentStyleRegex = /^( ((webpackChunkName: .+)|((webpackPrefetch|webpackPreload): (true|false|-?[0-9]+))|(webpackIgnore: (true|false))|((webpackInclude|webpackExclude): \\/.*\\/)|(webpackMode: [\"'](lazy|lazy-once|eager|weak)[\"'])|(webpackExports: (['\"]\\w+['\"]|\\[(['\"]\\w+['\"], *)+(['\"]\\w+['\"]*)\\]))),?)+ $/;\n    const chunkSubstrFormat = `webpackChunkName: [\"']${webpackChunknameFormat}[\"'],? `;\n    const chunkSubstrRegex = new RegExp(chunkSubstrFormat);\n    const eagerModeFormat = `webpackMode: [\"']eager[\"'],? `;\n    const eagerModeRegex = new RegExp(eagerModeFormat);\n\n    function run(node, arg) {\n      const sourceCode = context.getSourceCode();\n      const leadingComments = sourceCode.getCommentsBefore\n        ? sourceCode.getCommentsBefore(arg) // This method is available in ESLint >= 4.\n        : sourceCode.getComments(arg).leading; // This method is deprecated in ESLint 7.\n\n      if ((!leadingComments || leadingComments.length === 0) && !allowEmpty) {\n        context.report({\n          node,\n          message: 'dynamic imports require a leading comment with the webpack chunkname',\n        });\n        return;\n      }\n\n      let isChunknamePresent = false;\n      let isEagerModePresent = false;\n\n      for (const comment of leadingComments) {\n        if (comment.type !== 'Block') {\n          context.report({\n            node,\n            message: 'dynamic imports require a /* foo */ style comment, not a // foo comment',\n          });\n          return;\n        }\n\n        if (!paddedCommentRegex.test(comment.value)) {\n          context.report({\n            node,\n            message: `dynamic imports require a block comment padded with spaces - /* foo */`,\n          });\n          return;\n        }\n\n        try {\n          // just like webpack itself does\n          vm.runInNewContext(`(function() {return {${comment.value}}})()`);\n        } catch (error) {\n          context.report({\n            node,\n            message: `dynamic imports require a \"webpack\" comment with valid syntax`,\n          });\n          return;\n        }\n\n        if (!commentStyleRegex.test(comment.value)) {\n          context.report({\n            node,\n            message:\n              `dynamic imports require a \"webpack\" comment with valid syntax`,\n          });\n          return;\n        }\n\n        if (eagerModeRegex.test(comment.value)) {\n          isEagerModePresent = true;\n        }\n\n        if (chunkSubstrRegex.test(comment.value)) {\n          isChunknamePresent = true;\n        }\n      }\n\n      if (isChunknamePresent && isEagerModePresent) {\n        context.report({\n          node,\n          message: 'dynamic imports using eager mode do not need a webpackChunkName',\n          suggest: [\n            {\n              desc: 'Remove webpackChunkName',\n              fix(fixer) {\n                for (const comment of leadingComments) {\n                  if (chunkSubstrRegex.test(comment.value)) {\n                    const replacement = comment.value.replace(chunkSubstrRegex, '').trim().replace(/,$/, '');\n                    if (replacement === '') {\n                      return fixer.remove(comment);\n                    } else {\n                      return fixer.replaceText(comment, `/* ${replacement} */`);\n                    }\n                  }\n                }\n              },\n            },\n            {\n              desc: 'Remove webpackMode',\n              fix(fixer) {\n                for (const comment of leadingComments) {\n                  if (eagerModeRegex.test(comment.value)) {\n                    const replacement = comment.value.replace(eagerModeRegex, '').trim().replace(/,$/, '');\n                    if (replacement === '') {\n                      return fixer.remove(comment);\n                    } else {\n                      return fixer.replaceText(comment, `/* ${replacement} */`);\n                    }\n                  }\n                }\n              },\n            },\n          ],\n        });\n      }\n\n      if (!isChunknamePresent && !allowEmpty && !isEagerModePresent) {\n        context.report({\n          node,\n          message:\n            `dynamic imports require a leading comment in the form /*${chunkSubstrFormat}*/`,\n        });\n      }\n    }\n\n    return {\n      ImportExpression(node) {\n        run(node, node.source);\n      },\n\n      CallExpression(node) {\n        if (node.callee.type !== 'Import' && importFunctions.indexOf(node.callee.name) < 0) {\n          return;\n        }\n\n        run(node, node.arguments[0]);\n      },\n    };\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/dynamic-import-chunkname.js"],"names":["module","exports","meta","type","docs","category","description","url","schema","properties","importFunctions","uniqueItems","items","webpackChunknameFormat","create","context","config","options","paddedCommentRegex","commentStyleRegex","chunkSubstrFormat","chunkSubstrRegex","RegExp","run","node","arg","sourceCode","getSourceCode","leadingComments","getCommentsBefore","getComments","leading","length","report","message","isChunknamePresent","comment","test","value","vm","runInNewContext","error","ImportExpression","source","CallExpression","callee","indexOf","name","arguments"],"mappings":"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","file":"dynamic-import-chunkname.js","sourcesContent":["import vm from 'vm';\nimport docsUrl from '../docsUrl';\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Enforce a leading comment with the webpackChunkName for dynamic imports.',\n      url: docsUrl('dynamic-import-chunkname'),\n    },\n    schema: [{\n      type: 'object',\n      properties: {\n        importFunctions: {\n          type: 'array',\n          uniqueItems: true,\n          items: {\n            type: 'string',\n          },\n        },\n        webpackChunknameFormat: {\n          type: 'string',\n        },\n      },\n    }],\n  },\n\n  create(context) {\n    const config = context.options[0];\n    const { importFunctions = [] } = config || {};\n    const { webpackChunknameFormat = '([0-9a-zA-Z-_/.]|\\\\[(request|index)\\\\])+' } = config || {};\n\n    const paddedCommentRegex = /^ (\\S[\\s\\S]+\\S) $/;\n    const commentStyleRegex = /^( ((webpackChunkName: .+)|((webpackPrefetch|webpackPreload): (true|false|-?[0-9]+))|(webpackIgnore: (true|false))|((webpackInclude|webpackExclude): \\/.*\\/)|(webpackMode: [\"'](lazy|lazy-once|eager|weak)[\"'])|(webpackExports: (['\"]\\w+['\"]|\\[(['\"]\\w+['\"], *)+(['\"]\\w+['\"]*)\\]))),?)+ $/;\n    const chunkSubstrFormat = ` webpackChunkName: [\"']${webpackChunknameFormat}[\"'],? `;\n    const chunkSubstrRegex = new RegExp(chunkSubstrFormat);\n\n    function run(node, arg) {\n      const sourceCode = context.getSourceCode();\n      const leadingComments = sourceCode.getCommentsBefore\n        ? sourceCode.getCommentsBefore(arg) // This method is available in ESLint >= 4.\n        : sourceCode.getComments(arg).leading; // This method is deprecated in ESLint 7.\n\n      if (!leadingComments || leadingComments.length === 0) {\n        context.report({\n          node,\n          message: 'dynamic imports require a leading comment with the webpack chunkname',\n        });\n        return;\n      }\n\n      let isChunknamePresent = false;\n\n      for (const comment of leadingComments) {\n        if (comment.type !== 'Block') {\n          context.report({\n            node,\n            message: 'dynamic imports require a /* foo */ style comment, not a // foo comment',\n          });\n          return;\n        }\n\n        if (!paddedCommentRegex.test(comment.value)) {\n          context.report({\n            node,\n            message: `dynamic imports require a block comment padded with spaces - /* foo */`,\n          });\n          return;\n        }\n\n        try {\n          // just like webpack itself does\n          vm.runInNewContext(`(function() {return {${comment.value}}})()`);\n        } catch (error) {\n          context.report({\n            node,\n            message: `dynamic imports require a \"webpack\" comment with valid syntax`,\n          });\n          return;\n        }\n\n        if (!commentStyleRegex.test(comment.value)) {\n          context.report({\n            node,\n            message:\n              `dynamic imports require a \"webpack\" comment with valid syntax`,\n          });\n          return;\n        }\n\n        if (chunkSubstrRegex.test(comment.value)) {\n          isChunknamePresent = true;\n        }\n      }\n\n      if (!isChunknamePresent) {\n        context.report({\n          node,\n          message:\n            `dynamic imports require a leading comment in the form /*${chunkSubstrFormat}*/`,\n        });\n      }\n    }\n\n    return {\n      ImportExpression(node) {\n        run(node, node.source);\n      },\n\n      CallExpression(node) {\n        if (node.callee.type !== 'Import' && importFunctions.indexOf(node.callee.name) < 0) {\n          return;\n        }\n\n        run(node, node.arguments[0]);\n      },\n    };\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/export.js b/node_modules/eslint-plugin-import/lib/rules/export.js index a155254c8e..97228ec5aa 100644 --- a/node_modules/eslint-plugin-import/lib/rules/export.js +++ b/node_modules/eslint-plugin-import/lib/rules/export.js @@ -1,5 +1,4 @@ -'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder); -var _patternCapture = require('../exportMap/patternCapture');var _patternCapture2 = _interopRequireDefault(_patternCapture); +'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl); var _arrayIncludes = require('array-includes');var _arrayIncludes2 = _interopRequireDefault(_arrayIncludes); var _arrayPrototype = require('array.prototype.flatmap');var _arrayPrototype2 = _interopRequireDefault(_arrayPrototype);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };} @@ -187,7 +186,7 @@ module.exports = { if (node.declaration.declarations != null) {var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try { for (var _iterator = node.declaration.declarations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var declaration = _step.value; - (0, _patternCapture2['default'])(declaration.id, function (v) {addNamed(v.name, v, parent, isTypeVariableDecl);}); + (0, _ExportMap.recursivePatternCapture)(declaration.id, function (v) {addNamed(v.name, v, parent, isTypeVariableDecl);}); }} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}} } }return ExportNamedDeclaration;}(), @@ -198,7 +197,7 @@ module.exports = { // `export * as X from 'path'` does not conflict if (node.exported && node.exported.name) {return;} - var remoteExports = _builder2['default'].get(node.source.value, context); + var remoteExports = _ExportMap2['default'].get(node.source.value, context); if (remoteExports == null) {return;} if (remoteExports.errors.length) { @@ -248,4 +247,4 @@ module.exports = { }return ProgramExit;}() }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/export.js"],"names":["rootProgram","tsTypePrefix","isTypescriptFunctionOverloads","nodes","nodesArr","Array","from","idents","node","declaration","type","id","name","Set","size","length","types","map","parent","has","isTypescriptNamespaceMerging","noNamespaceNodes","filter","shouldSkipTypescriptNamespace","module","exports","meta","docs","category","description","url","schema","create","context","namespace","Map","addNamed","isType","set","named","get","key","add","getParent","ExportDefaultDeclaration","ExportSpecifier","exported","value","ExportNamedDeclaration","isTypeVariableDecl","kind","declarations","v","ExportAllDeclaration","source","remoteExports","ExportMapBuilder","errors","reportErrors","any","forEach","report","replace"],"mappings":"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","file":"export.js","sourcesContent":["import ExportMapBuilder from '../exportMap/builder';\nimport recursivePatternCapture from '../exportMap/patternCapture';\nimport docsUrl from '../docsUrl';\nimport includes from 'array-includes';\nimport flatMap from 'array.prototype.flatmap';\n\n/*\nNotes on TypeScript namespaces aka TSModuleDeclaration:\n\nThere are two forms:\n- active namespaces: namespace Foo {} / module Foo {}\n- ambient modules; declare module \"eslint-plugin-import\" {}\n\nactive namespaces:\n- cannot contain a default export\n- cannot contain an export all\n- cannot contain a multi name export (export { a, b })\n- can have active namespaces nested within them\n\nambient namespaces:\n- can only be defined in .d.ts files\n- cannot be nested within active namespaces\n- have no other restrictions\n*/\n\nconst rootProgram = 'root';\nconst tsTypePrefix = 'type:';\n\n/**\n * Detect function overloads like:\n * ```ts\n * export function foo(a: number);\n * export function foo(a: string);\n * export function foo(a: number|string) { return a; }\n * ```\n * @param {Set<Object>} nodes\n * @returns {boolean}\n */\nfunction isTypescriptFunctionOverloads(nodes) {\n  const nodesArr = Array.from(nodes);\n\n  const idents = flatMap(\n    nodesArr,\n    (node) => node.declaration && (\n      node.declaration.type === 'TSDeclareFunction' // eslint 6+\n      || node.declaration.type === 'TSEmptyBodyFunctionDeclaration' // eslint 4-5\n    )\n      ? node.declaration.id.name\n      : [],\n  );\n  if (new Set(idents).size !== idents.length) {\n    return true;\n  }\n\n  const types = new Set(nodesArr.map((node) => node.parent.type));\n  if (!types.has('TSDeclareFunction')) {\n    return false;\n  }\n  if (types.size === 1) {\n    return true;\n  }\n  if (types.size === 2 && types.has('FunctionDeclaration')) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Detect merging Namespaces with Classes, Functions, or Enums like:\n * ```ts\n * export class Foo { }\n * export namespace Foo { }\n * ```\n * @param {Set<Object>} nodes\n * @returns {boolean}\n */\nfunction isTypescriptNamespaceMerging(nodes) {\n  const types = new Set(Array.from(nodes, (node) => node.parent.type));\n  const noNamespaceNodes = Array.from(nodes).filter((node) => node.parent.type !== 'TSModuleDeclaration');\n\n  return types.has('TSModuleDeclaration')\n    && (\n      types.size === 1\n      // Merging with functions\n      || types.size === 2 && (types.has('FunctionDeclaration') || types.has('TSDeclareFunction'))\n      || types.size === 3 && types.has('FunctionDeclaration') && types.has('TSDeclareFunction')\n      // Merging with classes or enums\n      || types.size === 2 && (types.has('ClassDeclaration') || types.has('TSEnumDeclaration')) && noNamespaceNodes.length === 1\n    );\n}\n\n/**\n * Detect if a typescript namespace node should be reported as multiple export:\n * ```ts\n * export class Foo { }\n * export function Foo();\n * export namespace Foo { }\n * ```\n * @param {Object} node\n * @param {Set<Object>} nodes\n * @returns {boolean}\n */\nfunction shouldSkipTypescriptNamespace(node, nodes) {\n  const types = new Set(Array.from(nodes, (node) => node.parent.type));\n\n  return !isTypescriptNamespaceMerging(nodes)\n    && node.parent.type === 'TSModuleDeclaration'\n    && (\n      types.has('TSEnumDeclaration')\n      || types.has('ClassDeclaration')\n      || types.has('FunctionDeclaration')\n      || types.has('TSDeclareFunction')\n    );\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid any invalid exports, i.e. re-export of the same name.',\n      url: docsUrl('export'),\n    },\n    schema: [],\n  },\n\n  create(context) {\n    const namespace = new Map([[rootProgram, new Map()]]);\n\n    function addNamed(name, node, parent, isType) {\n      if (!namespace.has(parent)) {\n        namespace.set(parent, new Map());\n      }\n      const named = namespace.get(parent);\n\n      const key = isType ? `${tsTypePrefix}${name}` : name;\n      let nodes = named.get(key);\n\n      if (nodes == null) {\n        nodes = new Set();\n        named.set(key, nodes);\n      }\n\n      nodes.add(node);\n    }\n\n    function getParent(node) {\n      if (node.parent && node.parent.type === 'TSModuleBlock') {\n        return node.parent.parent;\n      }\n\n      // just in case somehow a non-ts namespace export declaration isn't directly\n      // parented to the root Program node\n      return rootProgram;\n    }\n\n    return {\n      ExportDefaultDeclaration(node) {\n        addNamed('default', node, getParent(node));\n      },\n\n      ExportSpecifier(node) {\n        addNamed(\n          node.exported.name || node.exported.value,\n          node.exported,\n          getParent(node.parent),\n        );\n      },\n\n      ExportNamedDeclaration(node) {\n        if (node.declaration == null) { return; }\n\n        const parent = getParent(node);\n        // support for old TypeScript versions\n        const isTypeVariableDecl = node.declaration.kind === 'type';\n\n        if (node.declaration.id != null) {\n          if (includes([\n            'TSTypeAliasDeclaration',\n            'TSInterfaceDeclaration',\n          ], node.declaration.type)) {\n            addNamed(node.declaration.id.name, node.declaration.id, parent, true);\n          } else {\n            addNamed(node.declaration.id.name, node.declaration.id, parent, isTypeVariableDecl);\n          }\n        }\n\n        if (node.declaration.declarations != null) {\n          for (const declaration of node.declaration.declarations) {\n            recursivePatternCapture(declaration.id, (v) => { addNamed(v.name, v, parent, isTypeVariableDecl); });\n          }\n        }\n      },\n\n      ExportAllDeclaration(node) {\n        if (node.source == null) { return; } // not sure if this is ever true\n\n        // `export * as X from 'path'` does not conflict\n        if (node.exported && node.exported.name) { return; }\n\n        const remoteExports = ExportMapBuilder.get(node.source.value, context);\n        if (remoteExports == null) { return; }\n\n        if (remoteExports.errors.length) {\n          remoteExports.reportErrors(context, node);\n          return;\n        }\n\n        const parent = getParent(node);\n\n        let any = false;\n        remoteExports.forEach((v, name) => {\n          if (name !== 'default') {\n            any = true; // poor man's filter\n            addNamed(name, node, parent);\n          }\n        });\n\n        if (!any) {\n          context.report(\n            node.source,\n            `No named exports found in module '${node.source.value}'.`,\n          );\n        }\n      },\n\n      'Program:exit'() {\n        for (const [, named] of namespace) {\n          for (const [name, nodes] of named) {\n            if (nodes.size <= 1) { continue; }\n\n            if (isTypescriptFunctionOverloads(nodes) || isTypescriptNamespaceMerging(nodes)) { continue; }\n\n            for (const node of nodes) {\n              if (shouldSkipTypescriptNamespace(node, nodes)) { continue; }\n\n              if (name === 'default') {\n                context.report(node, 'Multiple default exports.');\n              } else {\n                context.report(\n                  node,\n                  `Multiple exports of name '${name.replace(tsTypePrefix, '')}'.`,\n                );\n              }\n            }\n          }\n        }\n      },\n    };\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/export.js"],"names":["rootProgram","tsTypePrefix","isTypescriptFunctionOverloads","nodes","nodesArr","Array","from","idents","node","declaration","type","id","name","Set","size","length","types","map","parent","has","isTypescriptNamespaceMerging","noNamespaceNodes","filter","shouldSkipTypescriptNamespace","module","exports","meta","docs","category","description","url","schema","create","context","namespace","Map","addNamed","isType","set","named","get","key","add","getParent","ExportDefaultDeclaration","ExportSpecifier","exported","value","ExportNamedDeclaration","isTypeVariableDecl","kind","declarations","v","ExportAllDeclaration","source","remoteExports","ExportMap","errors","reportErrors","any","forEach","report","replace"],"mappings":"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","file":"export.js","sourcesContent":["import ExportMap, { recursivePatternCapture } from '../ExportMap';\nimport docsUrl from '../docsUrl';\nimport includes from 'array-includes';\nimport flatMap from 'array.prototype.flatmap';\n\n/*\nNotes on TypeScript namespaces aka TSModuleDeclaration:\n\nThere are two forms:\n- active namespaces: namespace Foo {} / module Foo {}\n- ambient modules; declare module \"eslint-plugin-import\" {}\n\nactive namespaces:\n- cannot contain a default export\n- cannot contain an export all\n- cannot contain a multi name export (export { a, b })\n- can have active namespaces nested within them\n\nambient namespaces:\n- can only be defined in .d.ts files\n- cannot be nested within active namespaces\n- have no other restrictions\n*/\n\nconst rootProgram = 'root';\nconst tsTypePrefix = 'type:';\n\n/**\n * Detect function overloads like:\n * ```ts\n * export function foo(a: number);\n * export function foo(a: string);\n * export function foo(a: number|string) { return a; }\n * ```\n * @param {Set<Object>} nodes\n * @returns {boolean}\n */\nfunction isTypescriptFunctionOverloads(nodes) {\n  const nodesArr = Array.from(nodes);\n\n  const idents = flatMap(\n    nodesArr,\n    (node) => node.declaration && (\n      node.declaration.type === 'TSDeclareFunction' // eslint 6+\n      || node.declaration.type === 'TSEmptyBodyFunctionDeclaration' // eslint 4-5\n    )\n      ? node.declaration.id.name\n      : [],\n  );\n  if (new Set(idents).size !== idents.length) {\n    return true;\n  }\n\n  const types = new Set(nodesArr.map((node) => node.parent.type));\n  if (!types.has('TSDeclareFunction')) {\n    return false;\n  }\n  if (types.size === 1) {\n    return true;\n  }\n  if (types.size === 2 && types.has('FunctionDeclaration')) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Detect merging Namespaces with Classes, Functions, or Enums like:\n * ```ts\n * export class Foo { }\n * export namespace Foo { }\n * ```\n * @param {Set<Object>} nodes\n * @returns {boolean}\n */\nfunction isTypescriptNamespaceMerging(nodes) {\n  const types = new Set(Array.from(nodes, (node) => node.parent.type));\n  const noNamespaceNodes = Array.from(nodes).filter((node) => node.parent.type !== 'TSModuleDeclaration');\n\n  return types.has('TSModuleDeclaration')\n    && (\n      types.size === 1\n      // Merging with functions\n      || types.size === 2 && (types.has('FunctionDeclaration') || types.has('TSDeclareFunction'))\n      || types.size === 3 && types.has('FunctionDeclaration') && types.has('TSDeclareFunction')\n      // Merging with classes or enums\n      || types.size === 2 && (types.has('ClassDeclaration') || types.has('TSEnumDeclaration')) && noNamespaceNodes.length === 1\n    );\n}\n\n/**\n * Detect if a typescript namespace node should be reported as multiple export:\n * ```ts\n * export class Foo { }\n * export function Foo();\n * export namespace Foo { }\n * ```\n * @param {Object} node\n * @param {Set<Object>} nodes\n * @returns {boolean}\n */\nfunction shouldSkipTypescriptNamespace(node, nodes) {\n  const types = new Set(Array.from(nodes, (node) => node.parent.type));\n\n  return !isTypescriptNamespaceMerging(nodes)\n    && node.parent.type === 'TSModuleDeclaration'\n    && (\n      types.has('TSEnumDeclaration')\n      || types.has('ClassDeclaration')\n      || types.has('FunctionDeclaration')\n      || types.has('TSDeclareFunction')\n    );\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid any invalid exports, i.e. re-export of the same name.',\n      url: docsUrl('export'),\n    },\n    schema: [],\n  },\n\n  create(context) {\n    const namespace = new Map([[rootProgram, new Map()]]);\n\n    function addNamed(name, node, parent, isType) {\n      if (!namespace.has(parent)) {\n        namespace.set(parent, new Map());\n      }\n      const named = namespace.get(parent);\n\n      const key = isType ? `${tsTypePrefix}${name}` : name;\n      let nodes = named.get(key);\n\n      if (nodes == null) {\n        nodes = new Set();\n        named.set(key, nodes);\n      }\n\n      nodes.add(node);\n    }\n\n    function getParent(node) {\n      if (node.parent && node.parent.type === 'TSModuleBlock') {\n        return node.parent.parent;\n      }\n\n      // just in case somehow a non-ts namespace export declaration isn't directly\n      // parented to the root Program node\n      return rootProgram;\n    }\n\n    return {\n      ExportDefaultDeclaration(node) {\n        addNamed('default', node, getParent(node));\n      },\n\n      ExportSpecifier(node) {\n        addNamed(\n          node.exported.name || node.exported.value,\n          node.exported,\n          getParent(node.parent),\n        );\n      },\n\n      ExportNamedDeclaration(node) {\n        if (node.declaration == null) { return; }\n\n        const parent = getParent(node);\n        // support for old TypeScript versions\n        const isTypeVariableDecl = node.declaration.kind === 'type';\n\n        if (node.declaration.id != null) {\n          if (includes([\n            'TSTypeAliasDeclaration',\n            'TSInterfaceDeclaration',\n          ], node.declaration.type)) {\n            addNamed(node.declaration.id.name, node.declaration.id, parent, true);\n          } else {\n            addNamed(node.declaration.id.name, node.declaration.id, parent, isTypeVariableDecl);\n          }\n        }\n\n        if (node.declaration.declarations != null) {\n          for (const declaration of node.declaration.declarations) {\n            recursivePatternCapture(declaration.id, (v) => { addNamed(v.name, v, parent, isTypeVariableDecl); });\n          }\n        }\n      },\n\n      ExportAllDeclaration(node) {\n        if (node.source == null) { return; } // not sure if this is ever true\n\n        // `export * as X from 'path'` does not conflict\n        if (node.exported && node.exported.name) { return; }\n\n        const remoteExports = ExportMap.get(node.source.value, context);\n        if (remoteExports == null) { return; }\n\n        if (remoteExports.errors.length) {\n          remoteExports.reportErrors(context, node);\n          return;\n        }\n\n        const parent = getParent(node);\n\n        let any = false;\n        remoteExports.forEach((v, name) => {\n          if (name !== 'default') {\n            any = true; // poor man's filter\n            addNamed(name, node, parent);\n          }\n        });\n\n        if (!any) {\n          context.report(\n            node.source,\n            `No named exports found in module '${node.source.value}'.`,\n          );\n        }\n      },\n\n      'Program:exit'() {\n        for (const [, named] of namespace) {\n          for (const [name, nodes] of named) {\n            if (nodes.size <= 1) { continue; }\n\n            if (isTypescriptFunctionOverloads(nodes) || isTypescriptNamespaceMerging(nodes)) { continue; }\n\n            for (const node of nodes) {\n              if (shouldSkipTypescriptNamespace(node, nodes)) { continue; }\n\n              if (name === 'default') {\n                context.report(node, 'Multiple default exports.');\n              } else {\n                context.report(\n                  node,\n                  `Multiple exports of name '${name.replace(tsTypePrefix, '')}'.`,\n                );\n              }\n            }\n          }\n        }\n      },\n    };\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/named.js b/node_modules/eslint-plugin-import/lib/rules/named.js index f71a966db8..96d9fd8493 100644 --- a/node_modules/eslint-plugin-import/lib/rules/named.js +++ b/node_modules/eslint-plugin-import/lib/rules/named.js @@ -1,5 +1,5 @@ 'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();var _path = require('path');var path = _interopRequireWildcard(_path); -var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder); +var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _interopRequireWildcard(obj) {if (obj && obj.__esModule) {return obj;} else {var newObj = {};if (obj != null) {for (var key in obj) {if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];}}newObj['default'] = obj;return newObj;}} module.exports = { @@ -41,7 +41,7 @@ module.exports = { return; // no named imports/exports } - var imports = _builder2['default'].get(node.source.value, context); + var imports = _ExportMap2['default'].get(node.source.value, context); if (imports == null || imports.parseGoal === 'ambiguous') { return; } @@ -93,7 +93,7 @@ module.exports = { var call = node.init;var _call$arguments = _slicedToArray( call.arguments, 1),source = _call$arguments[0]; var variableImports = node.id.properties; - var variableExports = _builder2['default'].get(source.value, context); + var variableExports = _ExportMap2['default'].get(source.value, context); if ( // return if it's not a commonjs require statement @@ -140,4 +140,4 @@ module.exports = { VariableDeclarator: checkRequire }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/named.js"],"names":["path","module","exports","meta","type","docs","category","description","url","schema","properties","commonjs","additionalProperties","create","context","options","checkSpecifiers","key","node","source","importKind","exportKind","specifiers","some","im","imports","ExportMapBuilder","get","value","parseGoal","errors","length","reportErrors","forEach","name","deepLookup","hasDeep","found","deepPath","map","i","relative","dirname","getPhysicalFilename","getFilename","join","report","checkRequire","id","init","call","arguments","variableImports","variableExports","callee","ImportDeclaration","bind","ExportNamedDeclaration","VariableDeclarator"],"mappings":"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","file":"named.js","sourcesContent":["import * as path from 'path';\nimport ExportMapBuilder from '../exportMap/builder';\nimport docsUrl from '../docsUrl';\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Static analysis',\n      description: 'Ensure named imports correspond to a named export in the remote file.',\n      url: docsUrl('named'),\n    },\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          commonjs: {\n            type: 'boolean',\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create(context) {\n    const options = context.options[0] || {};\n\n    function checkSpecifiers(key, type, node) {\n      // ignore local exports and type imports/exports\n      if (\n        node.source == null\n        || node.importKind === 'type'\n        || node.importKind === 'typeof'\n        || node.exportKind === 'type'\n      ) {\n        return;\n      }\n\n      if (!node.specifiers.some((im) => im.type === type)) {\n        return; // no named imports/exports\n      }\n\n      const imports = ExportMapBuilder.get(node.source.value, context);\n      if (imports == null || imports.parseGoal === 'ambiguous') {\n        return;\n      }\n\n      if (imports.errors.length) {\n        imports.reportErrors(context, node);\n        return;\n      }\n\n      node.specifiers.forEach(function (im) {\n        if (\n          im.type !== type\n          // ignore type imports\n          || im.importKind === 'type' || im.importKind === 'typeof'\n        ) {\n          return;\n        }\n\n        const name = im[key].name || im[key].value;\n\n        const deepLookup = imports.hasDeep(name);\n\n        if (!deepLookup.found) {\n          if (deepLookup.path.length > 1) {\n            const deepPath = deepLookup.path\n              .map((i) => path.relative(path.dirname(context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename()), i.path))\n              .join(' -> ');\n\n            context.report(im[key], `${name} not found via ${deepPath}`);\n          } else {\n            context.report(im[key], `${name} not found in '${node.source.value}'`);\n          }\n        }\n      });\n    }\n\n    function checkRequire(node) {\n      if (\n        !options.commonjs\n        || node.type !== 'VariableDeclarator'\n        // return if it's not an object destructure or it's an empty object destructure\n        || !node.id || node.id.type !== 'ObjectPattern' || node.id.properties.length === 0\n        // return if there is no call expression on the right side\n        || !node.init || node.init.type !== 'CallExpression'\n      ) {\n        return;\n      }\n\n      const call = node.init;\n      const [source] = call.arguments;\n      const variableImports = node.id.properties;\n      const variableExports = ExportMapBuilder.get(source.value, context);\n\n      if (\n        // return if it's not a commonjs require statement\n        call.callee.type !== 'Identifier' || call.callee.name !== 'require' || call.arguments.length !== 1\n        // return if it's not a string source\n        || source.type !== 'Literal'\n        || variableExports == null\n        || variableExports.parseGoal === 'ambiguous'\n      ) {\n        return;\n      }\n\n      if (variableExports.errors.length) {\n        variableExports.reportErrors(context, node);\n        return;\n      }\n\n      variableImports.forEach(function (im) {\n        if (im.type !== 'Property' || !im.key || im.key.type !== 'Identifier') {\n          return;\n        }\n\n        const deepLookup = variableExports.hasDeep(im.key.name);\n\n        if (!deepLookup.found) {\n          if (deepLookup.path.length > 1) {\n            const deepPath = deepLookup.path\n              .map((i) => path.relative(path.dirname(context.getFilename()), i.path))\n              .join(' -> ');\n\n            context.report(im.key, `${im.key.name} not found via ${deepPath}`);\n          } else {\n            context.report(im.key, `${im.key.name} not found in '${source.value}'`);\n          }\n        }\n      });\n    }\n\n    return {\n      ImportDeclaration: checkSpecifiers.bind(null, 'imported', 'ImportSpecifier'),\n\n      ExportNamedDeclaration: checkSpecifiers.bind(null, 'local', 'ExportSpecifier'),\n\n      VariableDeclarator: checkRequire,\n    };\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/named.js"],"names":["path","module","exports","meta","type","docs","category","description","url","schema","properties","commonjs","additionalProperties","create","context","options","checkSpecifiers","key","node","source","importKind","exportKind","specifiers","some","im","imports","Exports","get","value","parseGoal","errors","length","reportErrors","forEach","name","deepLookup","hasDeep","found","deepPath","map","i","relative","dirname","getPhysicalFilename","getFilename","join","report","checkRequire","id","init","call","arguments","variableImports","variableExports","callee","ImportDeclaration","bind","ExportNamedDeclaration","VariableDeclarator"],"mappings":"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","file":"named.js","sourcesContent":["import * as path from 'path';\nimport Exports from '../ExportMap';\nimport docsUrl from '../docsUrl';\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Static analysis',\n      description: 'Ensure named imports correspond to a named export in the remote file.',\n      url: docsUrl('named'),\n    },\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          commonjs: {\n            type: 'boolean',\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create(context) {\n    const options = context.options[0] || {};\n\n    function checkSpecifiers(key, type, node) {\n      // ignore local exports and type imports/exports\n      if (\n        node.source == null\n        || node.importKind === 'type'\n        || node.importKind === 'typeof'\n        || node.exportKind === 'type'\n      ) {\n        return;\n      }\n\n      if (!node.specifiers.some((im) => im.type === type)) {\n        return; // no named imports/exports\n      }\n\n      const imports = Exports.get(node.source.value, context);\n      if (imports == null || imports.parseGoal === 'ambiguous') {\n        return;\n      }\n\n      if (imports.errors.length) {\n        imports.reportErrors(context, node);\n        return;\n      }\n\n      node.specifiers.forEach(function (im) {\n        if (\n          im.type !== type\n          // ignore type imports\n          || im.importKind === 'type' || im.importKind === 'typeof'\n        ) {\n          return;\n        }\n\n        const name = im[key].name || im[key].value;\n\n        const deepLookup = imports.hasDeep(name);\n\n        if (!deepLookup.found) {\n          if (deepLookup.path.length > 1) {\n            const deepPath = deepLookup.path\n              .map((i) => path.relative(path.dirname(context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename()), i.path))\n              .join(' -> ');\n\n            context.report(im[key], `${name} not found via ${deepPath}`);\n          } else {\n            context.report(im[key], `${name} not found in '${node.source.value}'`);\n          }\n        }\n      });\n    }\n\n    function checkRequire(node) {\n      if (\n        !options.commonjs\n        || node.type !== 'VariableDeclarator'\n        // return if it's not an object destructure or it's an empty object destructure\n        || !node.id || node.id.type !== 'ObjectPattern' || node.id.properties.length === 0\n        // return if there is no call expression on the right side\n        || !node.init || node.init.type !== 'CallExpression'\n      ) {\n        return;\n      }\n\n      const call = node.init;\n      const [source] = call.arguments;\n      const variableImports = node.id.properties;\n      const variableExports = Exports.get(source.value, context);\n\n      if (\n        // return if it's not a commonjs require statement\n        call.callee.type !== 'Identifier' || call.callee.name !== 'require' || call.arguments.length !== 1\n        // return if it's not a string source\n        || source.type !== 'Literal'\n        || variableExports == null\n        || variableExports.parseGoal === 'ambiguous'\n      ) {\n        return;\n      }\n\n      if (variableExports.errors.length) {\n        variableExports.reportErrors(context, node);\n        return;\n      }\n\n      variableImports.forEach(function (im) {\n        if (im.type !== 'Property' || !im.key || im.key.type !== 'Identifier') {\n          return;\n        }\n\n        const deepLookup = variableExports.hasDeep(im.key.name);\n\n        if (!deepLookup.found) {\n          if (deepLookup.path.length > 1) {\n            const deepPath = deepLookup.path\n              .map((i) => path.relative(path.dirname(context.getFilename()), i.path))\n              .join(' -> ');\n\n            context.report(im.key, `${im.key.name} not found via ${deepPath}`);\n          } else {\n            context.report(im.key, `${im.key.name} not found in '${source.value}'`);\n          }\n        }\n      });\n    }\n\n    return {\n      ImportDeclaration: checkSpecifiers.bind(null, 'imported', 'ImportSpecifier'),\n\n      ExportNamedDeclaration: checkSpecifiers.bind(null, 'local', 'ExportSpecifier'),\n\n      VariableDeclarator: checkRequire,\n    };\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/namespace.js b/node_modules/eslint-plugin-import/lib/rules/namespace.js index 56744fca80..574d89a60d 100644 --- a/node_modules/eslint-plugin-import/lib/rules/namespace.js +++ b/node_modules/eslint-plugin-import/lib/rules/namespace.js @@ -1,6 +1,5 @@ 'use strict';var _declaredScope = require('eslint-module-utils/declaredScope');var _declaredScope2 = _interopRequireDefault(_declaredScope); -var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder); -var _exportMap = require('../exportMap');var _exportMap2 = _interopRequireDefault(_exportMap); +var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap); var _importDeclaration = require('../importDeclaration');var _importDeclaration2 = _interopRequireDefault(_importDeclaration); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };} @@ -9,7 +8,7 @@ function processBodyStatement(context, namespaces, declaration) { if (declaration.specifiers.length === 0) {return;} - var imports = _builder2['default'].get(declaration.source.value, context); + var imports = _ExportMap2['default'].get(declaration.source.value, context); if (imports == null) {return null;} if (imports.errors.length > 0) { @@ -89,7 +88,7 @@ module.exports = { ExportNamespaceSpecifier: function () {function ExportNamespaceSpecifier(namespace) { var declaration = (0, _importDeclaration2['default'])(context); - var imports = _builder2['default'].get(declaration.source.value, context); + var imports = _ExportMap2['default'].get(declaration.source.value, context); if (imports == null) {return null;} if (imports.errors.length) { @@ -123,7 +122,7 @@ module.exports = { var namespace = namespaces.get(dereference.object.name); var namepath = [dereference.object.name]; // while property is namespace and parent is member expression, keep validating - while (namespace instanceof _exportMap2['default'] && dereference.type === 'MemberExpression') { + while (namespace instanceof _ExportMap2['default'] && dereference.type === 'MemberExpression') { if (dereference.computed) { if (!allowComputed) { context.report( @@ -162,7 +161,7 @@ module.exports = { // DFS traverse child namespaces function testKey(pattern, namespace) {var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [init.name]; - if (!(namespace instanceof _exportMap2['default'])) {return;} + if (!(namespace instanceof _ExportMap2['default'])) {return;} if (pattern.type !== 'ObjectPattern') {return;}var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try { @@ -216,4 +215,4 @@ module.exports = { }return JSXMemberExpression;}() }; }return namespaceRule;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/namespace.js"],"names":["processBodyStatement","context","namespaces","declaration","type","specifiers","length","imports","ExportMapBuilder","get","source","value","errors","reportErrors","forEach","specifier","size","report","set","local","name","meta","imported","namespace","module","exports","docs","category","description","url","schema","properties","allowComputed","additionalProperties","create","namespaceRule","options","Map","makeMessage","last","namepath","join","Program","body","x","ExportNamespaceSpecifier","MemberExpression","dereference","object","has","parent","left","ExportMap","computed","property","exported","push","VariableDeclarator","id","init","testKey","pattern","path","key","node","message","dependencyExportMap","pop","JSXMemberExpression"],"mappings":"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","file":"namespace.js","sourcesContent":["import declaredScope from 'eslint-module-utils/declaredScope';\nimport ExportMapBuilder from '../exportMap/builder';\nimport ExportMap from '../exportMap';\nimport importDeclaration from '../importDeclaration';\nimport docsUrl from '../docsUrl';\n\nfunction processBodyStatement(context, namespaces, declaration) {\n  if (declaration.type !== 'ImportDeclaration') { return; }\n\n  if (declaration.specifiers.length === 0) { return; }\n\n  const imports = ExportMapBuilder.get(declaration.source.value, context);\n  if (imports == null) { return null; }\n\n  if (imports.errors.length > 0) {\n    imports.reportErrors(context, declaration);\n    return;\n  }\n\n  declaration.specifiers.forEach((specifier) => {\n    switch (specifier.type) {\n      case 'ImportNamespaceSpecifier':\n        if (!imports.size) {\n          context.report(\n            specifier,\n            `No exported names found in module '${declaration.source.value}'.`,\n          );\n        }\n        namespaces.set(specifier.local.name, imports);\n        break;\n      case 'ImportDefaultSpecifier':\n      case 'ImportSpecifier': {\n        const meta = imports.get(\n        // default to 'default' for default https://i.imgur.com/nj6qAWy.jpg\n          specifier.imported ? specifier.imported.name || specifier.imported.value : 'default',\n        );\n        if (!meta || !meta.namespace) { break; }\n        namespaces.set(specifier.local.name, meta.namespace);\n        break;\n      }\n      default:\n    }\n  });\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Static analysis',\n      description: 'Ensure imported namespaces contain dereferenced properties as they are dereferenced.',\n      url: docsUrl('namespace'),\n    },\n\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          allowComputed: {\n            description: 'If `false`, will report computed (and thus, un-lintable) references to namespace members.',\n            type: 'boolean',\n            default: false,\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create: function namespaceRule(context) {\n    // read options\n    const {\n      allowComputed = false,\n    } = context.options[0] || {};\n\n    const namespaces = new Map();\n\n    function makeMessage(last, namepath) {\n      return `'${last.name}' not found in ${namepath.length > 1 ? 'deeply ' : ''}imported namespace '${namepath.join('.')}'.`;\n    }\n\n    return {\n      // pick up all imports at body entry time, to properly respect hoisting\n      Program({ body }) {\n        body.forEach((x) => { processBodyStatement(context, namespaces, x); });\n      },\n\n      // same as above, but does not add names to local map\n      ExportNamespaceSpecifier(namespace) {\n        const declaration = importDeclaration(context);\n\n        const imports = ExportMapBuilder.get(declaration.source.value, context);\n        if (imports == null) { return null; }\n\n        if (imports.errors.length) {\n          imports.reportErrors(context, declaration);\n          return;\n        }\n\n        if (!imports.size) {\n          context.report(\n            namespace,\n            `No exported names found in module '${declaration.source.value}'.`,\n          );\n        }\n      },\n\n      // todo: check for possible redefinition\n\n      MemberExpression(dereference) {\n        if (dereference.object.type !== 'Identifier') { return; }\n        if (!namespaces.has(dereference.object.name)) { return; }\n        if (declaredScope(context, dereference.object.name) !== 'module') { return; }\n\n        if (dereference.parent.type === 'AssignmentExpression' && dereference.parent.left === dereference) {\n          context.report(\n            dereference.parent,\n            `Assignment to member of namespace '${dereference.object.name}'.`,\n          );\n        }\n\n        // go deep\n        let namespace = namespaces.get(dereference.object.name);\n        const namepath = [dereference.object.name];\n        // while property is namespace and parent is member expression, keep validating\n        while (namespace instanceof ExportMap && dereference.type === 'MemberExpression') {\n          if (dereference.computed) {\n            if (!allowComputed) {\n              context.report(\n                dereference.property,\n                `Unable to validate computed reference to imported namespace '${dereference.object.name}'.`,\n              );\n            }\n            return;\n          }\n\n          if (!namespace.has(dereference.property.name)) {\n            context.report(\n              dereference.property,\n              makeMessage(dereference.property, namepath),\n            );\n            break;\n          }\n\n          const exported = namespace.get(dereference.property.name);\n          if (exported == null) { return; }\n\n          // stash and pop\n          namepath.push(dereference.property.name);\n          namespace = exported.namespace;\n          dereference = dereference.parent;\n        }\n      },\n\n      VariableDeclarator({ id, init }) {\n        if (init == null) { return; }\n        if (init.type !== 'Identifier') { return; }\n        if (!namespaces.has(init.name)) { return; }\n\n        // check for redefinition in intermediate scopes\n        if (declaredScope(context, init.name) !== 'module') { return; }\n\n        // DFS traverse child namespaces\n        function testKey(pattern, namespace, path = [init.name]) {\n          if (!(namespace instanceof ExportMap)) { return; }\n\n          if (pattern.type !== 'ObjectPattern') { return; }\n\n          for (const property of pattern.properties) {\n            if (\n              property.type === 'ExperimentalRestProperty'\n              || property.type === 'RestElement'\n              || !property.key\n            ) {\n              continue;\n            }\n\n            if (property.key.type !== 'Identifier') {\n              context.report({\n                node: property,\n                message: 'Only destructure top-level names.',\n              });\n              continue;\n            }\n\n            if (!namespace.has(property.key.name)) {\n              context.report({\n                node: property,\n                message: makeMessage(property.key, path),\n              });\n              continue;\n            }\n\n            path.push(property.key.name);\n            const dependencyExportMap = namespace.get(property.key.name);\n            // could be null when ignored or ambiguous\n            if (dependencyExportMap !== null) {\n              testKey(property.value, dependencyExportMap.namespace, path);\n            }\n            path.pop();\n          }\n        }\n\n        testKey(id, namespaces.get(init.name));\n      },\n\n      JSXMemberExpression({ object, property }) {\n        if (!namespaces.has(object.name)) { return; }\n        const namespace = namespaces.get(object.name);\n        if (!namespace.has(property.name)) {\n          context.report({\n            node: property,\n            message: makeMessage(property, [object.name]),\n          });\n        }\n      },\n    };\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/namespace.js"],"names":["processBodyStatement","context","namespaces","declaration","type","specifiers","length","imports","Exports","get","source","value","errors","reportErrors","forEach","specifier","size","report","set","local","name","meta","imported","namespace","module","exports","docs","category","description","url","schema","properties","allowComputed","additionalProperties","create","namespaceRule","options","Map","makeMessage","last","namepath","join","Program","body","x","ExportNamespaceSpecifier","MemberExpression","dereference","object","has","parent","left","computed","property","exported","push","VariableDeclarator","id","init","testKey","pattern","path","key","node","message","dependencyExportMap","pop","JSXMemberExpression"],"mappings":"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","file":"namespace.js","sourcesContent":["import declaredScope from 'eslint-module-utils/declaredScope';\nimport Exports from '../ExportMap';\nimport importDeclaration from '../importDeclaration';\nimport docsUrl from '../docsUrl';\n\nfunction processBodyStatement(context, namespaces, declaration) {\n  if (declaration.type !== 'ImportDeclaration') { return; }\n\n  if (declaration.specifiers.length === 0) { return; }\n\n  const imports = Exports.get(declaration.source.value, context);\n  if (imports == null) { return null; }\n\n  if (imports.errors.length > 0) {\n    imports.reportErrors(context, declaration);\n    return;\n  }\n\n  declaration.specifiers.forEach((specifier) => {\n    switch (specifier.type) {\n      case 'ImportNamespaceSpecifier':\n        if (!imports.size) {\n          context.report(\n            specifier,\n            `No exported names found in module '${declaration.source.value}'.`,\n          );\n        }\n        namespaces.set(specifier.local.name, imports);\n        break;\n      case 'ImportDefaultSpecifier':\n      case 'ImportSpecifier': {\n        const meta = imports.get(\n        // default to 'default' for default https://i.imgur.com/nj6qAWy.jpg\n          specifier.imported ? specifier.imported.name || specifier.imported.value : 'default',\n        );\n        if (!meta || !meta.namespace) { break; }\n        namespaces.set(specifier.local.name, meta.namespace);\n        break;\n      }\n      default:\n    }\n  });\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Static analysis',\n      description: 'Ensure imported namespaces contain dereferenced properties as they are dereferenced.',\n      url: docsUrl('namespace'),\n    },\n\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          allowComputed: {\n            description: 'If `false`, will report computed (and thus, un-lintable) references to namespace members.',\n            type: 'boolean',\n            default: false,\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create: function namespaceRule(context) {\n    // read options\n    const {\n      allowComputed = false,\n    } = context.options[0] || {};\n\n    const namespaces = new Map();\n\n    function makeMessage(last, namepath) {\n      return `'${last.name}' not found in ${namepath.length > 1 ? 'deeply ' : ''}imported namespace '${namepath.join('.')}'.`;\n    }\n\n    return {\n      // pick up all imports at body entry time, to properly respect hoisting\n      Program({ body }) {\n        body.forEach((x) => { processBodyStatement(context, namespaces, x); });\n      },\n\n      // same as above, but does not add names to local map\n      ExportNamespaceSpecifier(namespace) {\n        const declaration = importDeclaration(context);\n\n        const imports = Exports.get(declaration.source.value, context);\n        if (imports == null) { return null; }\n\n        if (imports.errors.length) {\n          imports.reportErrors(context, declaration);\n          return;\n        }\n\n        if (!imports.size) {\n          context.report(\n            namespace,\n            `No exported names found in module '${declaration.source.value}'.`,\n          );\n        }\n      },\n\n      // todo: check for possible redefinition\n\n      MemberExpression(dereference) {\n        if (dereference.object.type !== 'Identifier') { return; }\n        if (!namespaces.has(dereference.object.name)) { return; }\n        if (declaredScope(context, dereference.object.name) !== 'module') { return; }\n\n        if (dereference.parent.type === 'AssignmentExpression' && dereference.parent.left === dereference) {\n          context.report(\n            dereference.parent,\n            `Assignment to member of namespace '${dereference.object.name}'.`,\n          );\n        }\n\n        // go deep\n        let namespace = namespaces.get(dereference.object.name);\n        const namepath = [dereference.object.name];\n        // while property is namespace and parent is member expression, keep validating\n        while (namespace instanceof Exports && dereference.type === 'MemberExpression') {\n          if (dereference.computed) {\n            if (!allowComputed) {\n              context.report(\n                dereference.property,\n                `Unable to validate computed reference to imported namespace '${dereference.object.name}'.`,\n              );\n            }\n            return;\n          }\n\n          if (!namespace.has(dereference.property.name)) {\n            context.report(\n              dereference.property,\n              makeMessage(dereference.property, namepath),\n            );\n            break;\n          }\n\n          const exported = namespace.get(dereference.property.name);\n          if (exported == null) { return; }\n\n          // stash and pop\n          namepath.push(dereference.property.name);\n          namespace = exported.namespace;\n          dereference = dereference.parent;\n        }\n      },\n\n      VariableDeclarator({ id, init }) {\n        if (init == null) { return; }\n        if (init.type !== 'Identifier') { return; }\n        if (!namespaces.has(init.name)) { return; }\n\n        // check for redefinition in intermediate scopes\n        if (declaredScope(context, init.name) !== 'module') { return; }\n\n        // DFS traverse child namespaces\n        function testKey(pattern, namespace, path = [init.name]) {\n          if (!(namespace instanceof Exports)) { return; }\n\n          if (pattern.type !== 'ObjectPattern') { return; }\n\n          for (const property of pattern.properties) {\n            if (\n              property.type === 'ExperimentalRestProperty'\n              || property.type === 'RestElement'\n              || !property.key\n            ) {\n              continue;\n            }\n\n            if (property.key.type !== 'Identifier') {\n              context.report({\n                node: property,\n                message: 'Only destructure top-level names.',\n              });\n              continue;\n            }\n\n            if (!namespace.has(property.key.name)) {\n              context.report({\n                node: property,\n                message: makeMessage(property.key, path),\n              });\n              continue;\n            }\n\n            path.push(property.key.name);\n            const dependencyExportMap = namespace.get(property.key.name);\n            // could be null when ignored or ambiguous\n            if (dependencyExportMap !== null) {\n              testKey(property.value, dependencyExportMap.namespace, path);\n            }\n            path.pop();\n          }\n        }\n\n        testKey(id, namespaces.get(init.name));\n      },\n\n      JSXMemberExpression({ object, property }) {\n        if (!namespaces.has(object.name)) { return; }\n        const namespace = namespaces.get(object.name);\n        if (!namespace.has(property.name)) {\n          context.report({\n            node: property,\n            message: makeMessage(property, [object.name]),\n          });\n        }\n      },\n    };\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/newline-after-import.js b/node_modules/eslint-plugin-import/lib/rules/newline-after-import.js index f2421e17a6..6cc1568646 100644 --- a/node_modules/eslint-plugin-import/lib/rules/newline-after-import.js +++ b/node_modules/eslint-plugin-import/lib/rules/newline-after-import.js @@ -124,7 +124,7 @@ module.exports = { } } - function commentAfterImport(node, nextComment, type) { + function commentAfterImport(node, nextComment) { var lineDifference = getLineDifference(node, nextComment); var EXPECTED_LINE_DIFFERENCE = options.count + 1; @@ -140,7 +140,7 @@ module.exports = { line: node.loc.end.line, column: column }, - message: 'Expected ' + String(options.count) + ' empty line' + (options.count > 1 ? 's' : '') + ' after ' + String(type) + ' statement not followed by another ' + String(type) + '.', + message: 'Expected ' + String(options.count) + ' empty line' + (options.count > 1 ? 's' : '') + ' after import statement not followed by another import.', fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? undefined : function (fixer) {return fixer.insertTextAfter( node, '\n'.repeat(EXPECTED_LINE_DIFFERENCE - lineDifference));} }); @@ -178,7 +178,7 @@ module.exports = { } if (nextComment && typeof nextComment !== 'undefined') { - commentAfterImport(node, nextComment, 'import'); + commentAfterImport(node, nextComment); } else if (nextNode && nextNode.type !== 'ImportDeclaration' && (nextNode.type !== 'TSImportEqualsDeclaration' || nextNode.isExport)) { checkForNewLine(node, nextNode, 'import'); } @@ -215,18 +215,8 @@ module.exports = { !containsNodeOrEqual(nextStatement, nextRequireCall))) { - var nextComment = void 0; - if (typeof statementWithRequireCall.parent.comments !== 'undefined' && options.considerComments) { - var endLine = node.loc.end.line; - nextComment = statementWithRequireCall.parent.comments.find(function (o) {return o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1;}); - } - - if (nextComment && typeof nextComment !== 'undefined') { - - commentAfterImport(statementWithRequireCall, nextComment, 'require'); - } else { - checkForNewLine(statementWithRequireCall, nextStatement, 'require'); - } + + checkForNewLine(statementWithRequireCall, nextStatement, 'require'); } }); }return ProgramExit;}(), @@ -244,4 +234,4 @@ module.exports = { 'Decorator:exit': decrementLevel }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/newline-after-import.js"],"names":["log","containsNodeOrEqual","outerNode","innerNode","range","getScopeBody","scope","block","type","body","findNodeIndexInScopeBody","nodeToFind","findIndex","node","getLineDifference","nextNode","loc","start","line","end","isClassWithDecorator","decorators","length","isExportDefaultClass","declaration","isExportNameClass","module","exports","meta","docs","category","description","url","fixable","schema","properties","count","minimum","exactCount","considerComments","additionalProperties","create","context","level","requireCalls","options","checkForNewLine","classNode","lineDifference","EXPECTED_LINE_DIFFERENCE","column","report","message","fix","undefined","fixer","insertTextAfter","repeat","commentAfterImport","nextComment","incrementLevel","decrementLevel","checkImport","parent","nodePosition","indexOf","endLine","comments","find","o","isExport","ImportDeclaration","TSImportEqualsDeclaration","CallExpression","push","getPhysicalFilename","getFilename","scopeBody","getScope","forEach","index","statementWithRequireCall","nextStatement","nextRequireCall","FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","BlockStatement","ObjectExpression","Decorator"],"mappings":"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","file":"newline-after-import.js","sourcesContent":["/**\n * @fileoverview Rule to enforce new line after import not followed by another import.\n * @author Radek Benkel\n */\n\nimport isStaticRequire from '../core/staticRequire';\nimport docsUrl from '../docsUrl';\n\nimport debug from 'debug';\nconst log = debug('eslint-plugin-import:rules:newline-after-import');\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nfunction containsNodeOrEqual(outerNode, innerNode) {\n  return outerNode.range[0] <= innerNode.range[0] && outerNode.range[1] >= innerNode.range[1];\n}\n\nfunction getScopeBody(scope) {\n  if (scope.block.type === 'SwitchStatement') {\n    log('SwitchStatement scopes not supported');\n    return null;\n  }\n\n  const { body } = scope.block;\n  if (body && body.type === 'BlockStatement') {\n    return body.body;\n  }\n\n  return body;\n}\n\nfunction findNodeIndexInScopeBody(body, nodeToFind) {\n  return body.findIndex((node) => containsNodeOrEqual(node, nodeToFind));\n}\n\nfunction getLineDifference(node, nextNode) {\n  return nextNode.loc.start.line - node.loc.end.line;\n}\n\nfunction isClassWithDecorator(node) {\n  return node.type === 'ClassDeclaration' && node.decorators && node.decorators.length;\n}\n\nfunction isExportDefaultClass(node) {\n  return node.type === 'ExportDefaultDeclaration' && node.declaration.type === 'ClassDeclaration';\n}\n\nfunction isExportNameClass(node) {\n\n  return node.type === 'ExportNamedDeclaration' && node.declaration && node.declaration.type === 'ClassDeclaration';\n}\n\nmodule.exports = {\n  meta: {\n    type: 'layout',\n    docs: {\n      category: 'Style guide',\n      description: 'Enforce a newline after import statements.',\n      url: docsUrl('newline-after-import'),\n    },\n    fixable: 'whitespace',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          count: {\n            type: 'integer',\n            minimum: 1,\n          },\n          exactCount: { type: 'boolean' },\n          considerComments: { type: 'boolean' },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n  create(context) {\n    let level = 0;\n    const requireCalls = [];\n    const options = {\n      count: 1,\n      exactCount: false,\n      considerComments: false,\n      ...context.options[0],\n    };\n\n    function checkForNewLine(node, nextNode, type) {\n      if (isExportDefaultClass(nextNode) || isExportNameClass(nextNode)) {\n        const classNode = nextNode.declaration;\n\n        if (isClassWithDecorator(classNode)) {\n          nextNode = classNode.decorators[0];\n        }\n      } else if (isClassWithDecorator(nextNode)) {\n        nextNode = nextNode.decorators[0];\n      }\n\n      const lineDifference = getLineDifference(node, nextNode);\n      const EXPECTED_LINE_DIFFERENCE = options.count + 1;\n\n      if (\n        lineDifference < EXPECTED_LINE_DIFFERENCE\n        || options.exactCount && lineDifference !== EXPECTED_LINE_DIFFERENCE\n      ) {\n        let column = node.loc.start.column;\n\n        if (node.loc.start.line !== node.loc.end.line) {\n          column = 0;\n        }\n\n        context.report({\n          loc: {\n            line: node.loc.end.line,\n            column,\n          },\n          message: `Expected ${options.count} empty line${options.count > 1 ? 's' : ''} after ${type} statement not followed by another ${type}.`,\n          fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? undefined : (fixer) => fixer.insertTextAfter(\n            node,\n            '\\n'.repeat(EXPECTED_LINE_DIFFERENCE - lineDifference),\n          ),\n        });\n      }\n    }\n\n    function commentAfterImport(node, nextComment, type) {\n      const lineDifference = getLineDifference(node, nextComment);\n      const EXPECTED_LINE_DIFFERENCE = options.count + 1;\n\n      if (lineDifference < EXPECTED_LINE_DIFFERENCE) {\n        let column = node.loc.start.column;\n\n        if (node.loc.start.line !== node.loc.end.line) {\n          column = 0;\n        }\n\n        context.report({\n          loc: {\n            line: node.loc.end.line,\n            column,\n          },\n          message: `Expected ${options.count} empty line${options.count > 1 ? 's' : ''} after ${type} statement not followed by another ${type}.`,\n          fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? undefined : (fixer) => fixer.insertTextAfter(\n            node,\n            '\\n'.repeat(EXPECTED_LINE_DIFFERENCE - lineDifference),\n          ),\n        });\n      }\n    }\n\n    function incrementLevel() {\n      level++;\n    }\n    function decrementLevel() {\n      level--;\n    }\n\n    function checkImport(node) {\n      const { parent } = node;\n\n      if (!parent || !parent.body) {\n        return;\n      }\n\n      const nodePosition = parent.body.indexOf(node);\n      const nextNode = parent.body[nodePosition + 1];\n      const endLine = node.loc.end.line;\n      let nextComment;\n\n      if (typeof parent.comments !== 'undefined' && options.considerComments) {\n        nextComment = parent.comments.find((o) => o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1);\n      }\n\n      // skip \"export import\"s\n      if (node.type === 'TSImportEqualsDeclaration' && node.isExport) {\n        return;\n      }\n\n      if (nextComment && typeof nextComment !== 'undefined') {\n        commentAfterImport(node, nextComment, 'import');\n      } else if (nextNode && nextNode.type !== 'ImportDeclaration' && (nextNode.type !== 'TSImportEqualsDeclaration' || nextNode.isExport)) {\n        checkForNewLine(node, nextNode, 'import');\n      }\n    }\n\n    return {\n      ImportDeclaration: checkImport,\n      TSImportEqualsDeclaration: checkImport,\n      CallExpression(node) {\n        if (isStaticRequire(node) && level === 0) {\n          requireCalls.push(node);\n        }\n      },\n      'Program:exit'() {\n        log('exit processing for', context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename());\n        const scopeBody = getScopeBody(context.getScope());\n        log('got scope:', scopeBody);\n\n        requireCalls.forEach((node, index) => {\n          const nodePosition = findNodeIndexInScopeBody(scopeBody, node);\n          log('node position in scope:', nodePosition);\n\n          const statementWithRequireCall = scopeBody[nodePosition];\n          const nextStatement = scopeBody[nodePosition + 1];\n          const nextRequireCall = requireCalls[index + 1];\n\n          if (nextRequireCall && containsNodeOrEqual(statementWithRequireCall, nextRequireCall)) {\n            return;\n          }\n\n          if (\n            nextStatement && (\n              !nextRequireCall\n              || !containsNodeOrEqual(nextStatement, nextRequireCall)\n            )\n          ) {\n            let nextComment;\n            if (typeof statementWithRequireCall.parent.comments !== 'undefined' && options.considerComments) {\n              const endLine = node.loc.end.line;\n              nextComment = statementWithRequireCall.parent.comments.find((o) => o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1);\n            }\n\n            if (nextComment && typeof nextComment !== 'undefined') {\n\n              commentAfterImport(statementWithRequireCall, nextComment, 'require');\n            } else {\n              checkForNewLine(statementWithRequireCall, nextStatement, 'require');\n            }\n          }\n        });\n      },\n      FunctionDeclaration: incrementLevel,\n      FunctionExpression: incrementLevel,\n      ArrowFunctionExpression: incrementLevel,\n      BlockStatement: incrementLevel,\n      ObjectExpression: incrementLevel,\n      Decorator: incrementLevel,\n      'FunctionDeclaration:exit': decrementLevel,\n      'FunctionExpression:exit': decrementLevel,\n      'ArrowFunctionExpression:exit': decrementLevel,\n      'BlockStatement:exit': decrementLevel,\n      'ObjectExpression:exit': decrementLevel,\n      'Decorator:exit': decrementLevel,\n    };\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/newline-after-import.js"],"names":["log","containsNodeOrEqual","outerNode","innerNode","range","getScopeBody","scope","block","type","body","findNodeIndexInScopeBody","nodeToFind","findIndex","node","getLineDifference","nextNode","loc","start","line","end","isClassWithDecorator","decorators","length","isExportDefaultClass","declaration","isExportNameClass","module","exports","meta","docs","category","description","url","fixable","schema","properties","count","minimum","exactCount","considerComments","additionalProperties","create","context","level","requireCalls","options","checkForNewLine","classNode","lineDifference","EXPECTED_LINE_DIFFERENCE","column","report","message","fix","undefined","fixer","insertTextAfter","repeat","commentAfterImport","nextComment","incrementLevel","decrementLevel","checkImport","parent","nodePosition","indexOf","endLine","comments","find","o","isExport","ImportDeclaration","TSImportEqualsDeclaration","CallExpression","push","getPhysicalFilename","getFilename","scopeBody","getScope","forEach","index","statementWithRequireCall","nextStatement","nextRequireCall","FunctionDeclaration","FunctionExpression","ArrowFunctionExpression","BlockStatement","ObjectExpression","Decorator"],"mappings":"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","file":"newline-after-import.js","sourcesContent":["/**\n * @fileoverview Rule to enforce new line after import not followed by another import.\n * @author Radek Benkel\n */\n\nimport isStaticRequire from '../core/staticRequire';\nimport docsUrl from '../docsUrl';\n\nimport debug from 'debug';\nconst log = debug('eslint-plugin-import:rules:newline-after-import');\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nfunction containsNodeOrEqual(outerNode, innerNode) {\n  return outerNode.range[0] <= innerNode.range[0] && outerNode.range[1] >= innerNode.range[1];\n}\n\nfunction getScopeBody(scope) {\n  if (scope.block.type === 'SwitchStatement') {\n    log('SwitchStatement scopes not supported');\n    return null;\n  }\n\n  const { body } = scope.block;\n  if (body && body.type === 'BlockStatement') {\n    return body.body;\n  }\n\n  return body;\n}\n\nfunction findNodeIndexInScopeBody(body, nodeToFind) {\n  return body.findIndex((node) => containsNodeOrEqual(node, nodeToFind));\n}\n\nfunction getLineDifference(node, nextNode) {\n  return nextNode.loc.start.line - node.loc.end.line;\n}\n\nfunction isClassWithDecorator(node) {\n  return node.type === 'ClassDeclaration' && node.decorators && node.decorators.length;\n}\n\nfunction isExportDefaultClass(node) {\n  return node.type === 'ExportDefaultDeclaration' && node.declaration.type === 'ClassDeclaration';\n}\n\nfunction isExportNameClass(node) {\n\n  return node.type === 'ExportNamedDeclaration' && node.declaration && node.declaration.type === 'ClassDeclaration';\n}\n\nmodule.exports = {\n  meta: {\n    type: 'layout',\n    docs: {\n      category: 'Style guide',\n      description: 'Enforce a newline after import statements.',\n      url: docsUrl('newline-after-import'),\n    },\n    fixable: 'whitespace',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          count: {\n            type: 'integer',\n            minimum: 1,\n          },\n          exactCount: { type: 'boolean' },\n          considerComments: { type: 'boolean' },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n  create(context) {\n    let level = 0;\n    const requireCalls = [];\n    const options = {\n      count: 1,\n      exactCount: false,\n      considerComments: false,\n      ...context.options[0],\n    };\n\n    function checkForNewLine(node, nextNode, type) {\n      if (isExportDefaultClass(nextNode) || isExportNameClass(nextNode)) {\n        const classNode = nextNode.declaration;\n\n        if (isClassWithDecorator(classNode)) {\n          nextNode = classNode.decorators[0];\n        }\n      } else if (isClassWithDecorator(nextNode)) {\n        nextNode = nextNode.decorators[0];\n      }\n\n      const lineDifference = getLineDifference(node, nextNode);\n      const EXPECTED_LINE_DIFFERENCE = options.count + 1;\n\n      if (\n        lineDifference < EXPECTED_LINE_DIFFERENCE\n        || options.exactCount && lineDifference !== EXPECTED_LINE_DIFFERENCE\n      ) {\n        let column = node.loc.start.column;\n\n        if (node.loc.start.line !== node.loc.end.line) {\n          column = 0;\n        }\n\n        context.report({\n          loc: {\n            line: node.loc.end.line,\n            column,\n          },\n          message: `Expected ${options.count} empty line${options.count > 1 ? 's' : ''} after ${type} statement not followed by another ${type}.`,\n          fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? undefined : (fixer) => fixer.insertTextAfter(\n            node,\n            '\\n'.repeat(EXPECTED_LINE_DIFFERENCE - lineDifference),\n          ),\n        });\n      }\n    }\n\n    function commentAfterImport(node, nextComment) {\n      const lineDifference = getLineDifference(node, nextComment);\n      const EXPECTED_LINE_DIFFERENCE = options.count + 1;\n\n      if (lineDifference < EXPECTED_LINE_DIFFERENCE) {\n        let column = node.loc.start.column;\n\n        if (node.loc.start.line !== node.loc.end.line) {\n          column = 0;\n        }\n\n        context.report({\n          loc: {\n            line: node.loc.end.line,\n            column,\n          },\n          message: `Expected ${options.count} empty line${options.count > 1 ? 's' : ''} after import statement not followed by another import.`,\n          fix: options.exactCount && EXPECTED_LINE_DIFFERENCE < lineDifference ? undefined : (fixer) => fixer.insertTextAfter(\n            node,\n            '\\n'.repeat(EXPECTED_LINE_DIFFERENCE - lineDifference),\n          ),\n        });\n      }\n    }\n\n    function incrementLevel() {\n      level++;\n    }\n    function decrementLevel() {\n      level--;\n    }\n\n    function checkImport(node) {\n      const { parent } = node;\n\n      if (!parent || !parent.body) {\n        return;\n      }\n\n      const nodePosition = parent.body.indexOf(node);\n      const nextNode = parent.body[nodePosition + 1];\n      const endLine = node.loc.end.line;\n      let nextComment;\n\n      if (typeof parent.comments !== 'undefined' && options.considerComments) {\n        nextComment = parent.comments.find((o) => o.loc.start.line >= endLine && o.loc.start.line <= endLine + options.count + 1);\n      }\n\n      // skip \"export import\"s\n      if (node.type === 'TSImportEqualsDeclaration' && node.isExport) {\n        return;\n      }\n\n      if (nextComment && typeof nextComment !== 'undefined') {\n        commentAfterImport(node, nextComment);\n      } else if (nextNode && nextNode.type !== 'ImportDeclaration' && (nextNode.type !== 'TSImportEqualsDeclaration' || nextNode.isExport)) {\n        checkForNewLine(node, nextNode, 'import');\n      }\n    }\n\n    return {\n      ImportDeclaration: checkImport,\n      TSImportEqualsDeclaration: checkImport,\n      CallExpression(node) {\n        if (isStaticRequire(node) && level === 0) {\n          requireCalls.push(node);\n        }\n      },\n      'Program:exit'() {\n        log('exit processing for', context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename());\n        const scopeBody = getScopeBody(context.getScope());\n        log('got scope:', scopeBody);\n\n        requireCalls.forEach((node, index) => {\n          const nodePosition = findNodeIndexInScopeBody(scopeBody, node);\n          log('node position in scope:', nodePosition);\n\n          const statementWithRequireCall = scopeBody[nodePosition];\n          const nextStatement = scopeBody[nodePosition + 1];\n          const nextRequireCall = requireCalls[index + 1];\n\n          if (nextRequireCall && containsNodeOrEqual(statementWithRequireCall, nextRequireCall)) {\n            return;\n          }\n\n          if (\n            nextStatement && (\n              !nextRequireCall\n              || !containsNodeOrEqual(nextStatement, nextRequireCall)\n            )\n          ) {\n\n            checkForNewLine(statementWithRequireCall, nextStatement, 'require');\n          }\n        });\n      },\n      FunctionDeclaration: incrementLevel,\n      FunctionExpression: incrementLevel,\n      ArrowFunctionExpression: incrementLevel,\n      BlockStatement: incrementLevel,\n      ObjectExpression: incrementLevel,\n      Decorator: incrementLevel,\n      'FunctionDeclaration:exit': decrementLevel,\n      'FunctionExpression:exit': decrementLevel,\n      'ArrowFunctionExpression:exit': decrementLevel,\n      'BlockStatement:exit': decrementLevel,\n      'ObjectExpression:exit': decrementLevel,\n      'Decorator:exit': decrementLevel,\n    };\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/no-cycle.js b/node_modules/eslint-plugin-import/lib/rules/no-cycle.js index 5cc9bd7861..c728eafed7 100644 --- a/node_modules/eslint-plugin-import/lib/rules/no-cycle.js +++ b/node_modules/eslint-plugin-import/lib/rules/no-cycle.js @@ -4,18 +4,13 @@ */ var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve); -var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder); -var _scc = require('../scc');var _scc2 = _interopRequireDefault(_scc); +var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap); var _importType = require('../core/importType'); var _moduleVisitor = require('eslint-module-utils/moduleVisitor');var _moduleVisitor2 = _interopRequireDefault(_moduleVisitor); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _toConsumableArray(arr) {if (Array.isArray(arr)) {for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {arr2[i] = arr[i];}return arr2;} else {return Array.from(arr);}} var traversed = new Set(); -function routeString(route) { - return route.map(function (s) {return String(s.value) + ':' + String(s.loc.start.line);}).join('=>'); -} - module.exports = { meta: { type: 'suggestion', @@ -46,11 +41,6 @@ module.exports = { allowUnsafeDynamicCyclicDependency: { description: 'Allow cyclic dependency if there is at least one dynamic import in the chain', type: 'boolean', - 'default': false }, - - disableScc: { - description: 'When true, don\'t calculate a strongly-connected-components graph. SCC is used to reduce the time-complexity of cycle detection, but adds overhead.', - type: 'boolean', 'default': false } })] }, @@ -68,8 +58,6 @@ module.exports = { context);}return ignoreModule;}(); - var scc = options.disableScc ? {} : _scc2['default'].get(myPath, context); - function checkSourceValue(sourceNode, importer) { if (ignoreModule(sourceNode.value)) { return; // ignore external modules @@ -96,7 +84,7 @@ module.exports = { return; // ignore type imports } - var imported = _builder2['default'].get(sourceNode.value, context); + var imported = _ExportMap2['default'].get(sourceNode.value, context); if (imported == null) { return; // no-unresolved territory @@ -106,16 +94,6 @@ module.exports = { return; // no-self-import territory } - /* If we're in the same Strongly Connected Component, - * Then there exists a path from each node in the SCC to every other node in the SCC, - * Then there exists at least one path from them to us and from us to them, - * Then we have a cycle between us. - */ - var hasDependencyCycle = options.disableScc || scc[myPath] === scc[imported.path]; - if (!hasDependencyCycle) { - return; - } - var untraversed = [{ mget: function () {function mget() {return imported;}return mget;}(), route: [] }]; function detectCycle(_ref2) {var mget = _ref2.mget,route = _ref2.route; var m = mget(); @@ -124,9 +102,6 @@ module.exports = { traversed.add(m.path);var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try { for (var _iterator = m.imports[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var _ref3 = _step.value;var _ref4 = _slicedToArray(_ref3, 2);var path = _ref4[0];var _ref4$ = _ref4[1];var getter = _ref4$.getter;var declarations = _ref4$.declarations; - // If we're in different SCCs, we can't have a circular dependency - if (!options.disableScc && scc[myPath] !== scc[path]) {continue;} - if (traversed.has(path)) {continue;} var toTraverse = [].concat(_toConsumableArray(declarations)).filter(function (_ref5) {var source = _ref5.source,isOnlyImportingTypes = _ref5.isOnlyImportingTypes;return !ignoreModule(source.value) // Ignore only type imports @@ -175,4 +150,9 @@ module.exports = { }return ProgramExit;}() }); }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-cycle.js"],"names":["traversed","Set","routeString","route","map","s","value","loc","start","line","join","module","exports","meta","type","docs","category","description","url","schema","maxDepth","anyOf","minimum","ignoreExternal","allowUnsafeDynamicCyclicDependency","disableScc","create","context","myPath","getPhysicalFilename","getFilename","options","Infinity","ignoreModule","name","scc","StronglyConnectedComponentsBuilder","get","checkSourceValue","sourceNode","importer","callee","importKind","specifiers","every","imported","ExportMapBuilder","path","hasDependencyCycle","untraversed","mget","detectCycle","m","has","add","imports","getter","declarations","toTraverse","filter","source","isOnlyImportingTypes","some","d","dynamic","length","push","concat","next","shift","message","report","Object","assign","clear"],"mappings":"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","file":"no-cycle.js","sourcesContent":["/**\n * @fileOverview Ensures that no imported module imports the linted module.\n * @author Ben Mosher\n */\n\nimport resolve from 'eslint-module-utils/resolve';\nimport ExportMapBuilder from '../exportMap/builder';\nimport StronglyConnectedComponentsBuilder from '../scc';\nimport { isExternalModule } from '../core/importType';\nimport moduleVisitor, { makeOptionsSchema } from 'eslint-module-utils/moduleVisitor';\nimport docsUrl from '../docsUrl';\n\nconst traversed = new Set();\n\nfunction routeString(route) {\n  return route.map((s) => `${s.value}:${s.loc.start.line}`).join('=>');\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Static analysis',\n      description: 'Forbid a module from importing a module with a dependency path back to itself.',\n      url: docsUrl('no-cycle'),\n    },\n    schema: [makeOptionsSchema({\n      maxDepth: {\n        anyOf: [\n          {\n            description: 'maximum dependency depth to traverse',\n            type: 'integer',\n            minimum: 1,\n          },\n          {\n            enum: ['∞'],\n            type: 'string',\n          },\n        ],\n      },\n      ignoreExternal: {\n        description: 'ignore external modules',\n        type: 'boolean',\n        default: false,\n      },\n      allowUnsafeDynamicCyclicDependency: {\n        description: 'Allow cyclic dependency if there is at least one dynamic import in the chain',\n        type: 'boolean',\n        default: false,\n      },\n      disableScc: {\n        description: 'When true, don\\'t calculate a strongly-connected-components graph. SCC is used to reduce the time-complexity of cycle detection, but adds overhead.',\n        type: 'boolean',\n        default: false,\n      },\n    })],\n  },\n\n  create(context) {\n    const myPath = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n    if (myPath === '<text>') { return {}; } // can't cycle-check a non-file\n\n    const options = context.options[0] || {};\n    const maxDepth = typeof options.maxDepth === 'number' ? options.maxDepth : Infinity;\n    const ignoreModule = (name) => options.ignoreExternal && isExternalModule(\n      name,\n      resolve(name, context),\n      context,\n    );\n\n    const scc = options.disableScc ? {} : StronglyConnectedComponentsBuilder.get(myPath, context);\n\n    function checkSourceValue(sourceNode, importer) {\n      if (ignoreModule(sourceNode.value)) {\n        return; // ignore external modules\n      }\n      if (\n        options.allowUnsafeDynamicCyclicDependency && (\n          // Ignore `import()`\n          importer.type === 'ImportExpression'\n          // `require()` calls are always checked (if possible)\n          || importer.type === 'CallExpression' && importer.callee.name !== 'require'\n        )\n      ) {\n        return; // cycle via dynamic import allowed by config\n      }\n\n      if (\n        importer.type === 'ImportDeclaration' && (\n          // import type { Foo } (TS and Flow)\n          importer.importKind === 'type'\n          // import { type Foo } (Flow)\n          || importer.specifiers.every(({ importKind }) => importKind === 'type')\n        )\n      ) {\n        return; // ignore type imports\n      }\n\n      const imported = ExportMapBuilder.get(sourceNode.value, context);\n\n      if (imported == null) {\n        return;  // no-unresolved territory\n      }\n\n      if (imported.path === myPath) {\n        return;  // no-self-import territory\n      }\n\n      /* If we're in the same Strongly Connected Component,\n       * Then there exists a path from each node in the SCC to every other node in the SCC,\n       * Then there exists at least one path from them to us and from us to them,\n       * Then we have a cycle between us.\n       */\n      const hasDependencyCycle = options.disableScc || scc[myPath] === scc[imported.path];\n      if (!hasDependencyCycle) {\n        return;\n      }\n\n      const untraversed = [{ mget: () => imported, route: [] }];\n      function detectCycle({ mget, route }) {\n        const m = mget();\n        if (m == null) { return; }\n        if (traversed.has(m.path)) { return; }\n        traversed.add(m.path);\n\n        for (const [path, { getter, declarations }] of m.imports) {\n          // If we're in different SCCs, we can't have a circular dependency\n          if (!options.disableScc && scc[myPath] !== scc[path]) { continue; }\n\n          if (traversed.has(path)) { continue; }\n          const toTraverse = [...declarations].filter(({ source, isOnlyImportingTypes }) => !ignoreModule(source.value)\n            // Ignore only type imports\n            && !isOnlyImportingTypes,\n          );\n\n          /*\n          If cyclic dependency is allowed via dynamic import, skip checking if any module is imported dynamically\n          */\n          if (options.allowUnsafeDynamicCyclicDependency && toTraverse.some((d) => d.dynamic)) { return; }\n\n          /*\n          Only report as a cycle if there are any import declarations that are considered by\n          the rule. For example:\n\n          a.ts:\n          import { foo } from './b' // should not be reported as a cycle\n\n          b.ts:\n          import type { Bar } from './a'\n          */\n          if (path === myPath && toTraverse.length > 0) { return true; }\n          if (route.length + 1 < maxDepth) {\n            for (const { source } of toTraverse) {\n              untraversed.push({ mget: getter, route: route.concat(source) });\n            }\n          }\n        }\n      }\n\n      while (untraversed.length > 0) {\n        const next = untraversed.shift(); // bfs!\n        if (detectCycle(next)) {\n          const message = next.route.length > 0\n            ? `Dependency cycle via ${routeString(next.route)}`\n            : 'Dependency cycle detected.';\n          context.report(importer, message);\n          return;\n        }\n      }\n    }\n\n    return Object.assign(moduleVisitor(checkSourceValue, context.options[0]), {\n      'Program:exit'() {\n        traversed.clear();\n      },\n    });\n  },\n};\n"]} \ No newline at end of file + + +function routeString(route) { + return route.map(function (s) {return String(s.value) + ':' + String(s.loc.start.line);}).join('=>'); +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-cycle.js"],"names":["traversed","Set","module","exports","meta","type","docs","category","description","url","schema","maxDepth","anyOf","minimum","ignoreExternal","allowUnsafeDynamicCyclicDependency","create","context","myPath","getPhysicalFilename","getFilename","options","Infinity","ignoreModule","name","checkSourceValue","sourceNode","importer","value","callee","importKind","specifiers","every","imported","Exports","get","path","untraversed","mget","route","detectCycle","m","has","add","imports","getter","declarations","toTraverse","filter","source","isOnlyImportingTypes","some","d","dynamic","length","push","concat","next","shift","message","routeString","report","Object","assign","clear","map","s","loc","start","line","join"],"mappings":"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","file":"no-cycle.js","sourcesContent":["/**\n * @fileOverview Ensures that no imported module imports the linted module.\n * @author Ben Mosher\n */\n\nimport resolve from 'eslint-module-utils/resolve';\nimport Exports from '../ExportMap';\nimport { isExternalModule } from '../core/importType';\nimport moduleVisitor, { makeOptionsSchema } from 'eslint-module-utils/moduleVisitor';\nimport docsUrl from '../docsUrl';\n\nconst traversed = new Set();\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Static analysis',\n      description: 'Forbid a module from importing a module with a dependency path back to itself.',\n      url: docsUrl('no-cycle'),\n    },\n    schema: [makeOptionsSchema({\n      maxDepth: {\n        anyOf: [\n          {\n            description: 'maximum dependency depth to traverse',\n            type: 'integer',\n            minimum: 1,\n          },\n          {\n            enum: ['∞'],\n            type: 'string',\n          },\n        ],\n      },\n      ignoreExternal: {\n        description: 'ignore external modules',\n        type: 'boolean',\n        default: false,\n      },\n      allowUnsafeDynamicCyclicDependency: {\n        description: 'Allow cyclic dependency if there is at least one dynamic import in the chain',\n        type: 'boolean',\n        default: false,\n      },\n    })],\n  },\n\n  create(context) {\n    const myPath = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n    if (myPath === '<text>') { return {}; } // can't cycle-check a non-file\n\n    const options = context.options[0] || {};\n    const maxDepth = typeof options.maxDepth === 'number' ? options.maxDepth : Infinity;\n    const ignoreModule = (name) => options.ignoreExternal && isExternalModule(\n      name,\n      resolve(name, context),\n      context,\n    );\n\n    function checkSourceValue(sourceNode, importer) {\n      if (ignoreModule(sourceNode.value)) {\n        return; // ignore external modules\n      }\n      if (\n        options.allowUnsafeDynamicCyclicDependency && (\n          // Ignore `import()`\n          importer.type === 'ImportExpression'\n          // `require()` calls are always checked (if possible)\n          || importer.type === 'CallExpression' && importer.callee.name !== 'require'\n        )\n      ) {\n        return; // cycle via dynamic import allowed by config\n      }\n\n      if (\n        importer.type === 'ImportDeclaration' && (\n          // import type { Foo } (TS and Flow)\n          importer.importKind === 'type'\n          // import { type Foo } (Flow)\n          || importer.specifiers.every(({ importKind }) => importKind === 'type')\n        )\n      ) {\n        return; // ignore type imports\n      }\n\n      const imported = Exports.get(sourceNode.value, context);\n\n      if (imported == null) {\n        return;  // no-unresolved territory\n      }\n\n      if (imported.path === myPath) {\n        return;  // no-self-import territory\n      }\n\n      const untraversed = [{ mget: () => imported, route: [] }];\n      function detectCycle({ mget, route }) {\n        const m = mget();\n        if (m == null) { return; }\n        if (traversed.has(m.path)) { return; }\n        traversed.add(m.path);\n\n        for (const [path, { getter, declarations }] of m.imports) {\n          if (traversed.has(path)) { continue; }\n          const toTraverse = [...declarations].filter(({ source, isOnlyImportingTypes }) => !ignoreModule(source.value)\n            // Ignore only type imports\n            && !isOnlyImportingTypes,\n          );\n\n          /*\n          If cyclic dependency is allowed via dynamic import, skip checking if any module is imported dynamically\n          */\n          if (options.allowUnsafeDynamicCyclicDependency && toTraverse.some((d) => d.dynamic)) { return; }\n\n          /*\n          Only report as a cycle if there are any import declarations that are considered by\n          the rule. For example:\n\n          a.ts:\n          import { foo } from './b' // should not be reported as a cycle\n\n          b.ts:\n          import type { Bar } from './a'\n          */\n          if (path === myPath && toTraverse.length > 0) { return true; }\n          if (route.length + 1 < maxDepth) {\n            for (const { source } of toTraverse) {\n              untraversed.push({ mget: getter, route: route.concat(source) });\n            }\n          }\n        }\n      }\n\n      while (untraversed.length > 0) {\n        const next = untraversed.shift(); // bfs!\n        if (detectCycle(next)) {\n          const message = next.route.length > 0\n            ? `Dependency cycle via ${routeString(next.route)}`\n            : 'Dependency cycle detected.';\n          context.report(importer, message);\n          return;\n        }\n      }\n    }\n\n    return Object.assign(moduleVisitor(checkSourceValue, context.options[0]), {\n      'Program:exit'() {\n        traversed.clear();\n      },\n    });\n  },\n};\n\nfunction routeString(route) {\n  return route.map((s) => `${s.value}:${s.loc.start.line}`).join('=>');\n}\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/no-deprecated.js b/node_modules/eslint-plugin-import/lib/rules/no-deprecated.js index 27a40843fe..3aea5b5ca0 100644 --- a/node_modules/eslint-plugin-import/lib/rules/no-deprecated.js +++ b/node_modules/eslint-plugin-import/lib/rules/no-deprecated.js @@ -1,6 +1,5 @@ 'use strict';var _declaredScope = require('eslint-module-utils/declaredScope');var _declaredScope2 = _interopRequireDefault(_declaredScope); -var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder); -var _exportMap = require('../exportMap');var _exportMap2 = _interopRequireDefault(_exportMap); +var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };} function message(deprecation) { @@ -32,7 +31,7 @@ module.exports = { if (node.type !== 'ImportDeclaration') {return;} if (node.source == null) {return;} // local export, ignore - var imports = _builder2['default'].get(node.source.value, context); + var imports = _ExportMap2['default'].get(node.source.value, context); if (imports == null) {return;} var moduleDeprecation = imports.doc && imports.doc.tags.find(function (t) {return t.title === 'deprecated';}); @@ -115,7 +114,7 @@ module.exports = { var namespace = namespaces.get(dereference.object.name); var namepath = [dereference.object.name]; // while property is namespace and parent is member expression, keep validating - while (namespace instanceof _exportMap2['default'] && dereference.type === 'MemberExpression') { + while (namespace instanceof _ExportMap2['default'] && dereference.type === 'MemberExpression') { // ignore computed parts for now if (dereference.computed) {return;} @@ -136,4 +135,4 @@ module.exports = { }return MemberExpression;}() }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-deprecated.js"],"names":["message","deprecation","description","getDeprecation","metadata","doc","tags","find","t","title","module","exports","meta","type","docs","category","url","schema","create","context","deprecated","Map","namespaces","checkSpecifiers","node","source","imports","ExportMapBuilder","get","value","moduleDeprecation","report","errors","length","reportErrors","specifiers","forEach","im","imported","local","size","set","name","exported","namespace","Program","body","Identifier","parent","property","slice","has","MemberExpression","dereference","object","namepath","ExportMap","computed","push"],"mappings":"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","file":"no-deprecated.js","sourcesContent":["import declaredScope from 'eslint-module-utils/declaredScope';\nimport ExportMapBuilder from '../exportMap/builder';\nimport ExportMap from '../exportMap';\nimport docsUrl from '../docsUrl';\n\nfunction message(deprecation) {\n  return `Deprecated${deprecation.description ? `: ${deprecation.description}` : '.'}`;\n}\n\nfunction getDeprecation(metadata) {\n  if (!metadata || !metadata.doc) { return; }\n\n  return metadata.doc.tags.find((t) => t.title === 'deprecated');\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid imported names marked with `@deprecated` documentation tag.',\n      url: docsUrl('no-deprecated'),\n    },\n    schema: [],\n  },\n\n  create(context) {\n    const deprecated = new Map();\n    const namespaces = new Map();\n\n    function checkSpecifiers(node) {\n      if (node.type !== 'ImportDeclaration') { return; }\n      if (node.source == null) { return; } // local export, ignore\n\n      const imports = ExportMapBuilder.get(node.source.value, context);\n      if (imports == null) { return; }\n\n      const moduleDeprecation = imports.doc && imports.doc.tags.find((t) => t.title === 'deprecated');\n      if (moduleDeprecation) {\n        context.report({ node, message: message(moduleDeprecation) });\n      }\n\n      if (imports.errors.length) {\n        imports.reportErrors(context, node);\n        return;\n      }\n\n      node.specifiers.forEach(function (im) {\n        let imported; let local;\n        switch (im.type) {\n\n          case 'ImportNamespaceSpecifier': {\n            if (!imports.size) { return; }\n            namespaces.set(im.local.name, imports);\n            return;\n          }\n\n          case 'ImportDefaultSpecifier':\n            imported = 'default';\n            local = im.local.name;\n            break;\n\n          case 'ImportSpecifier':\n            imported = im.imported.name;\n            local = im.local.name;\n            break;\n\n          default: return; // can't handle this one\n        }\n\n        // unknown thing can't be deprecated\n        const exported = imports.get(imported);\n        if (exported == null) { return; }\n\n        // capture import of deep namespace\n        if (exported.namespace) { namespaces.set(local, exported.namespace); }\n\n        const deprecation = getDeprecation(imports.get(imported));\n        if (!deprecation) { return; }\n\n        context.report({ node: im, message: message(deprecation) });\n\n        deprecated.set(local, deprecation);\n\n      });\n    }\n\n    return {\n      Program: ({ body }) => body.forEach(checkSpecifiers),\n\n      Identifier(node) {\n        if (node.parent.type === 'MemberExpression' && node.parent.property === node) {\n          return; // handled by MemberExpression\n        }\n\n        // ignore specifier identifiers\n        if (node.parent.type.slice(0, 6) === 'Import') { return; }\n\n        if (!deprecated.has(node.name)) { return; }\n\n        if (declaredScope(context, node.name) !== 'module') { return; }\n        context.report({\n          node,\n          message: message(deprecated.get(node.name)),\n        });\n      },\n\n      MemberExpression(dereference) {\n        if (dereference.object.type !== 'Identifier') { return; }\n        if (!namespaces.has(dereference.object.name)) { return; }\n\n        if (declaredScope(context, dereference.object.name) !== 'module') { return; }\n\n        // go deep\n        let namespace = namespaces.get(dereference.object.name);\n        const namepath = [dereference.object.name];\n        // while property is namespace and parent is member expression, keep validating\n        while (namespace instanceof ExportMap && dereference.type === 'MemberExpression') {\n          // ignore computed parts for now\n          if (dereference.computed) { return; }\n\n          const metadata = namespace.get(dereference.property.name);\n\n          if (!metadata) { break; }\n          const deprecation = getDeprecation(metadata);\n\n          if (deprecation) {\n            context.report({ node: dereference.property, message: message(deprecation) });\n          }\n\n          // stash and pop\n          namepath.push(dereference.property.name);\n          namespace = metadata.namespace;\n          dereference = dereference.parent;\n        }\n      },\n    };\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-deprecated.js"],"names":["message","deprecation","description","getDeprecation","metadata","doc","tags","find","t","title","module","exports","meta","type","docs","category","url","schema","create","context","deprecated","Map","namespaces","checkSpecifiers","node","source","imports","Exports","get","value","moduleDeprecation","report","errors","length","reportErrors","specifiers","forEach","im","imported","local","size","set","name","exported","namespace","Program","body","Identifier","parent","property","slice","has","MemberExpression","dereference","object","namepath","computed","push"],"mappings":"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","file":"no-deprecated.js","sourcesContent":["import declaredScope from 'eslint-module-utils/declaredScope';\nimport Exports from '../ExportMap';\nimport docsUrl from '../docsUrl';\n\nfunction message(deprecation) {\n  return `Deprecated${deprecation.description ? `: ${deprecation.description}` : '.'}`;\n}\n\nfunction getDeprecation(metadata) {\n  if (!metadata || !metadata.doc) { return; }\n\n  return metadata.doc.tags.find((t) => t.title === 'deprecated');\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid imported names marked with `@deprecated` documentation tag.',\n      url: docsUrl('no-deprecated'),\n    },\n    schema: [],\n  },\n\n  create(context) {\n    const deprecated = new Map();\n    const namespaces = new Map();\n\n    function checkSpecifiers(node) {\n      if (node.type !== 'ImportDeclaration') { return; }\n      if (node.source == null) { return; } // local export, ignore\n\n      const imports = Exports.get(node.source.value, context);\n      if (imports == null) { return; }\n\n      const moduleDeprecation = imports.doc && imports.doc.tags.find((t) => t.title === 'deprecated');\n      if (moduleDeprecation) {\n        context.report({ node, message: message(moduleDeprecation) });\n      }\n\n      if (imports.errors.length) {\n        imports.reportErrors(context, node);\n        return;\n      }\n\n      node.specifiers.forEach(function (im) {\n        let imported; let local;\n        switch (im.type) {\n\n          case 'ImportNamespaceSpecifier': {\n            if (!imports.size) { return; }\n            namespaces.set(im.local.name, imports);\n            return;\n          }\n\n          case 'ImportDefaultSpecifier':\n            imported = 'default';\n            local = im.local.name;\n            break;\n\n          case 'ImportSpecifier':\n            imported = im.imported.name;\n            local = im.local.name;\n            break;\n\n          default: return; // can't handle this one\n        }\n\n        // unknown thing can't be deprecated\n        const exported = imports.get(imported);\n        if (exported == null) { return; }\n\n        // capture import of deep namespace\n        if (exported.namespace) { namespaces.set(local, exported.namespace); }\n\n        const deprecation = getDeprecation(imports.get(imported));\n        if (!deprecation) { return; }\n\n        context.report({ node: im, message: message(deprecation) });\n\n        deprecated.set(local, deprecation);\n\n      });\n    }\n\n    return {\n      Program: ({ body }) => body.forEach(checkSpecifiers),\n\n      Identifier(node) {\n        if (node.parent.type === 'MemberExpression' && node.parent.property === node) {\n          return; // handled by MemberExpression\n        }\n\n        // ignore specifier identifiers\n        if (node.parent.type.slice(0, 6) === 'Import') { return; }\n\n        if (!deprecated.has(node.name)) { return; }\n\n        if (declaredScope(context, node.name) !== 'module') { return; }\n        context.report({\n          node,\n          message: message(deprecated.get(node.name)),\n        });\n      },\n\n      MemberExpression(dereference) {\n        if (dereference.object.type !== 'Identifier') { return; }\n        if (!namespaces.has(dereference.object.name)) { return; }\n\n        if (declaredScope(context, dereference.object.name) !== 'module') { return; }\n\n        // go deep\n        let namespace = namespaces.get(dereference.object.name);\n        const namepath = [dereference.object.name];\n        // while property is namespace and parent is member expression, keep validating\n        while (namespace instanceof Exports && dereference.type === 'MemberExpression') {\n          // ignore computed parts for now\n          if (dereference.computed) { return; }\n\n          const metadata = namespace.get(dereference.property.name);\n\n          if (!metadata) { break; }\n          const deprecation = getDeprecation(metadata);\n\n          if (deprecation) {\n            context.report({ node: dereference.property, message: message(deprecation) });\n          }\n\n          // stash and pop\n          namepath.push(dereference.property.name);\n          namespace = metadata.namespace;\n          dereference = dereference.parent;\n        }\n      },\n    };\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/no-duplicates.js b/node_modules/eslint-plugin-import/lib/rules/no-duplicates.js index 585a17d873..8b512d083b 100644 --- a/node_modules/eslint-plugin-import/lib/rules/no-duplicates.js +++ b/node_modules/eslint-plugin-import/lib/rules/no-duplicates.js @@ -9,68 +9,28 @@ try { typescriptPkg = require('typescript/package.json'); // eslint-disable-line import/no-extraneous-dependencies } catch (e) {/**/} -function isPunctuator(node, value) { - return node.type === 'Punctuator' && node.value === value; -} - -// Get the name of the default import of `node`, if any. -function getDefaultImportName(node) { - var defaultSpecifier = node.specifiers. - find(function (specifier) {return specifier.type === 'ImportDefaultSpecifier';}); - return defaultSpecifier != null ? defaultSpecifier.local.name : undefined; -} - -// Checks whether `node` has a namespace import. -function hasNamespace(node) { - var specifiers = node.specifiers. - filter(function (specifier) {return specifier.type === 'ImportNamespaceSpecifier';}); - return specifiers.length > 0; -} - -// Checks whether `node` has any non-default specifiers. -function hasSpecifiers(node) { - var specifiers = node.specifiers. - filter(function (specifier) {return specifier.type === 'ImportSpecifier';}); - return specifiers.length > 0; -} - -// Checks whether `node` has a comment (that ends) on the previous line or on -// the same line as `node` (starts). -function hasCommentBefore(node, sourceCode) { - return sourceCode.getCommentsBefore(node). - some(function (comment) {return comment.loc.end.line >= node.loc.start.line - 1;}); -} - -// Checks whether `node` has a comment (that starts) on the same line as `node` -// (ends). -function hasCommentAfter(node, sourceCode) { - return sourceCode.getCommentsAfter(node). - some(function (comment) {return comment.loc.start.line === node.loc.end.line;}); -} +function checkImports(imported, context) {var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try { + for (var _iterator = imported.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var _ref = _step.value;var _ref2 = _slicedToArray(_ref, 2);var _module = _ref2[0];var nodes = _ref2[1]; + if (nodes.length > 1) { + var message = '\'' + String(_module) + '\' imported multiple times.';var _nodes = _toArray( + nodes),first = _nodes[0],rest = _nodes.slice(1); + var sourceCode = context.getSourceCode(); + var fix = getFix(first, rest, sourceCode, context); -// Checks whether `node` has any comments _inside,_ except inside the `{...}` -// part (if any). -function hasCommentInsideNonSpecifiers(node, sourceCode) { - var tokens = sourceCode.getTokens(node); - var openBraceIndex = tokens.findIndex(function (token) {return isPunctuator(token, '{');}); - var closeBraceIndex = tokens.findIndex(function (token) {return isPunctuator(token, '}');}); - // Slice away the first token, since we're no looking for comments _before_ - // `node` (only inside). If there's a `{...}` part, look for comments before - // the `{`, but not before the `}` (hence the `+1`s). - var someTokens = openBraceIndex >= 0 && closeBraceIndex >= 0 ? - tokens.slice(1, openBraceIndex + 1).concat(tokens.slice(closeBraceIndex + 1)) : - tokens.slice(1); - return someTokens.some(function (token) {return sourceCode.getCommentsBefore(token).length > 0;}); -} + context.report({ + node: first.source, + message: message, + fix: fix // Attach the autofix (if any) to the first import. + });var _iteratorNormalCompletion2 = true;var _didIteratorError2 = false;var _iteratorError2 = undefined;try { -// It's not obvious what the user wants to do with comments associated with -// duplicate imports, so skip imports with comments when autofixing. -function hasProblematicComments(node, sourceCode) { - return ( - hasCommentBefore(node, sourceCode) || - hasCommentAfter(node, sourceCode) || - hasCommentInsideNonSpecifiers(node, sourceCode)); + for (var _iterator2 = rest[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {var node = _step2.value; + context.report({ + node: node.source, + message: message }); + }} catch (err) {_didIteratorError2 = true;_iteratorError2 = err;} finally {try {if (!_iteratorNormalCompletion2 && _iterator2['return']) {_iterator2['return']();}} finally {if (_didIteratorError2) {throw _iteratorError2;}}} + } + }} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}} } function getFix(first, rest, sourceCode, context) { @@ -132,7 +92,6 @@ function getFix(first, rest, sourceCode, context) { var shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1; var shouldAddSpecifiers = specifiers.length > 0; var shouldRemoveUnnecessary = unnecessaryImports.length > 0; - var preferInline = context.options[0] && context.options[0]['prefer-inline']; if (!(shouldAddDefault || shouldAddSpecifiers || shouldRemoveUnnecessary)) { return undefined; @@ -155,16 +114,17 @@ function getFix(first, rest, sourceCode, context) { specifiers.reduce( - function (_ref, specifier) {var _ref2 = _slicedToArray(_ref, 3),result = _ref2[0],needsComma = _ref2[1],existingIdentifiers = _ref2[2]; + function (_ref3, specifier) {var _ref4 = _slicedToArray(_ref3, 3),result = _ref4[0],needsComma = _ref4[1],existingIdentifiers = _ref4[2]; var isTypeSpecifier = specifier.importNode.importKind === 'type'; - // a user might set prefer-inline but not have a supporting TypeScript version. Flow does not support inline types so this should fail in that case as well. + var preferInline = context.options[0] && context.options[0]['prefer-inline']; + // a user might set prefer-inline but not have a supporting TypeScript version. Flow does not support inline types so this should fail in that case as well. if (preferInline && (!typescriptPkg || !_semver2['default'].satisfies(typescriptPkg.version, '>= 4.5'))) { throw new Error('Your version of TypeScript does not support inline type imports.'); } // Add *only* the new identifiers that don't already exist, and track any new identifiers so we don't add them again in the next loop - var _specifier$identifier = specifier.identifiers.reduce(function (_ref3, cur) {var _ref4 = _slicedToArray(_ref3, 2),text = _ref4[0],set = _ref4[1]; + var _specifier$identifier = specifier.identifiers.reduce(function (_ref5, cur) {var _ref6 = _slicedToArray(_ref5, 2),text = _ref6[0],set = _ref6[1]; var trimmed = cur.trim(); // Trim whitespace before/after to compare to our set of existing identifiers var curWithType = trimmed.length > 0 && preferInline && isTypeSpecifier ? 'type ' + String(cur) : cur; if (existingIdentifiers.has(trimmed)) { @@ -186,18 +146,6 @@ function getFix(first, rest, sourceCode, context) { var fixes = []; - if (shouldAddSpecifiers && preferInline && first.importKind === 'type') { - // `import type {a} from './foo'` → `import {type a} from './foo'` - var typeIdentifierToken = tokens.find(function (token) {return token.type === 'Identifier' && token.value === 'type';}); - fixes.push(fixer.removeRange([typeIdentifierToken.range[0], typeIdentifierToken.range[1] + 1])); - - tokens. - filter(function (token) {return firstExistingIdentifiers.has(token.value);}). - forEach(function (identifier) { - fixes.push(fixer.replaceTextRange([identifier.range[0], identifier.range[1]], 'type ' + String(identifier.value))); - }); - } - if (shouldAddDefault && openBrace == null && shouldAddSpecifiers) { // `import './foo'` → `import def, {...} from './foo'` fixes.push( @@ -227,7 +175,7 @@ function getFix(first, rest, sourceCode, context) { } // Remove imports whose specifiers have been moved into the first import. - var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try {for (var _iterator = specifiers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var specifier = _step.value; + var _iteratorNormalCompletion3 = true;var _didIteratorError3 = false;var _iteratorError3 = undefined;try {for (var _iterator3 = specifiers[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {var specifier = _step3.value; var importNode = specifier.importNode; fixes.push(fixer.remove(importNode)); @@ -241,7 +189,7 @@ function getFix(first, rest, sourceCode, context) { // Remove imports whose default import has been moved to the first import, // and side-effect-only imports that are unnecessary due to the first // import. - } catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}}var _iteratorNormalCompletion2 = true;var _didIteratorError2 = false;var _iteratorError2 = undefined;try {for (var _iterator2 = unnecessaryImports[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {var node = _step2.value; + } catch (err) {_didIteratorError3 = true;_iteratorError3 = err;} finally {try {if (!_iteratorNormalCompletion3 && _iterator3['return']) {_iterator3['return']();}} finally {if (_didIteratorError3) {throw _iteratorError3;}}}var _iteratorNormalCompletion4 = true;var _didIteratorError4 = false;var _iteratorError4 = undefined;try {for (var _iterator4 = unnecessaryImports[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {var node = _step4.value; fixes.push(fixer.remove(node)); var charAfterImportRange = [node.range[1], node.range[1] + 1]; @@ -249,34 +197,74 @@ function getFix(first, rest, sourceCode, context) { if (charAfterImport === '\n') { fixes.push(fixer.removeRange(charAfterImportRange)); } - }} catch (err) {_didIteratorError2 = true;_iteratorError2 = err;} finally {try {if (!_iteratorNormalCompletion2 && _iterator2['return']) {_iterator2['return']();}} finally {if (_didIteratorError2) {throw _iteratorError2;}}} + }} catch (err) {_didIteratorError4 = true;_iteratorError4 = err;} finally {try {if (!_iteratorNormalCompletion4 && _iterator4['return']) {_iterator4['return']();}} finally {if (_didIteratorError4) {throw _iteratorError4;}}} return fixes; }; } -function checkImports(imported, context) {var _iteratorNormalCompletion3 = true;var _didIteratorError3 = false;var _iteratorError3 = undefined;try { - for (var _iterator3 = imported.entries()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {var _ref5 = _step3.value;var _ref6 = _slicedToArray(_ref5, 2);var _module = _ref6[0];var nodes = _ref6[1]; - if (nodes.length > 1) { - var message = '\'' + String(_module) + '\' imported multiple times.';var _nodes = _toArray( - nodes),first = _nodes[0],rest = _nodes.slice(1); - var sourceCode = context.getSourceCode(); - var fix = getFix(first, rest, sourceCode, context); +function isPunctuator(node, value) { + return node.type === 'Punctuator' && node.value === value; +} - context.report({ - node: first.source, - message: message, - fix: fix // Attach the autofix (if any) to the first import. - });var _iteratorNormalCompletion4 = true;var _didIteratorError4 = false;var _iteratorError4 = undefined;try { +// Get the name of the default import of `node`, if any. +function getDefaultImportName(node) { + var defaultSpecifier = node.specifiers. + find(function (specifier) {return specifier.type === 'ImportDefaultSpecifier';}); + return defaultSpecifier != null ? defaultSpecifier.local.name : undefined; +} - for (var _iterator4 = rest[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {var node = _step4.value; - context.report({ - node: node.source, - message: message }); +// Checks whether `node` has a namespace import. +function hasNamespace(node) { + var specifiers = node.specifiers. + filter(function (specifier) {return specifier.type === 'ImportNamespaceSpecifier';}); + return specifiers.length > 0; +} - }} catch (err) {_didIteratorError4 = true;_iteratorError4 = err;} finally {try {if (!_iteratorNormalCompletion4 && _iterator4['return']) {_iterator4['return']();}} finally {if (_didIteratorError4) {throw _iteratorError4;}}} - } - }} catch (err) {_didIteratorError3 = true;_iteratorError3 = err;} finally {try {if (!_iteratorNormalCompletion3 && _iterator3['return']) {_iterator3['return']();}} finally {if (_didIteratorError3) {throw _iteratorError3;}}} +// Checks whether `node` has any non-default specifiers. +function hasSpecifiers(node) { + var specifiers = node.specifiers. + filter(function (specifier) {return specifier.type === 'ImportSpecifier';}); + return specifiers.length > 0; +} + +// It's not obvious what the user wants to do with comments associated with +// duplicate imports, so skip imports with comments when autofixing. +function hasProblematicComments(node, sourceCode) { + return ( + hasCommentBefore(node, sourceCode) || + hasCommentAfter(node, sourceCode) || + hasCommentInsideNonSpecifiers(node, sourceCode)); + +} + +// Checks whether `node` has a comment (that ends) on the previous line or on +// the same line as `node` (starts). +function hasCommentBefore(node, sourceCode) { + return sourceCode.getCommentsBefore(node). + some(function (comment) {return comment.loc.end.line >= node.loc.start.line - 1;}); +} + +// Checks whether `node` has a comment (that starts) on the same line as `node` +// (ends). +function hasCommentAfter(node, sourceCode) { + return sourceCode.getCommentsAfter(node). + some(function (comment) {return comment.loc.start.line === node.loc.end.line;}); +} + +// Checks whether `node` has any comments _inside,_ except inside the `{...}` +// part (if any). +function hasCommentInsideNonSpecifiers(node, sourceCode) { + var tokens = sourceCode.getTokens(node); + var openBraceIndex = tokens.findIndex(function (token) {return isPunctuator(token, '{');}); + var closeBraceIndex = tokens.findIndex(function (token) {return isPunctuator(token, '}');}); + // Slice away the first token, since we're no looking for comments _before_ + // `node` (only inside). If there's a `{...}` part, look for comments before + // the `{`, but not before the `}` (hence the `+1`s). + var someTokens = openBraceIndex >= 0 && closeBraceIndex >= 0 ? + tokens.slice(1, openBraceIndex + 1).concat(tokens.slice(closeBraceIndex + 1)) : + tokens.slice(1); + return someTokens.some(function (token) {return sourceCode.getCommentsBefore(token).length > 0;}); } module.exports = { @@ -363,4 +351,4 @@ module.exports = { }return ProgramExit;}() }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-duplicates.js"],"names":["typescriptPkg","require","e","isPunctuator","node","value","type","getDefaultImportName","defaultSpecifier","specifiers","find","specifier","local","name","undefined","hasNamespace","filter","length","hasSpecifiers","hasCommentBefore","sourceCode","getCommentsBefore","some","comment","loc","end","line","start","hasCommentAfter","getCommentsAfter","hasCommentInsideNonSpecifiers","tokens","getTokens","openBraceIndex","findIndex","token","closeBraceIndex","someTokens","slice","concat","hasProblematicComments","getFix","first","rest","context","defaultImportNames","Set","x","size","restWithoutComments","map","openBrace","closeBrace","importNode","identifiers","text","range","split","isEmpty","Boolean","unnecessaryImports","shouldAddDefault","shouldAddSpecifiers","shouldRemoveUnnecessary","preferInline","options","fixer","firstToken","getFirstToken","defaultImportName","firstHasTrailingComma","getTokenBefore","firstIsEmpty","firstExistingIdentifiers","trim","reduce","result","needsComma","existingIdentifiers","isTypeSpecifier","importKind","semver","satisfies","version","Error","cur","set","trimmed","curWithType","has","add","specifierText","updatedExistingIdentifiers","specifiersText","fixes","typeIdentifierToken","push","removeRange","forEach","identifier","replaceTextRange","insertTextAfter","insertTextBefore","remove","charAfterImportRange","charAfterImport","substring","checkImports","imported","entries","module","nodes","message","getSourceCode","fix","report","source","exports","meta","docs","category","description","url","fixable","schema","properties","considerQueryString","additionalProperties","create","considerQueryStringOption","defaultResolver","sourcePath","resolver","parts","match","moduleMaps","Map","getImportMap","n","parent","nsImported","defaultTypesImported","namedTypesImported","get","spec","ImportDeclaration","resolvedPath","importMap","values"],"mappings":"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","file":"no-duplicates.js","sourcesContent":["import resolve from 'eslint-module-utils/resolve';\nimport semver from 'semver';\nimport flatMap from 'array.prototype.flatmap';\n\nimport docsUrl from '../docsUrl';\n\nlet typescriptPkg;\ntry {\n  typescriptPkg = require('typescript/package.json'); // eslint-disable-line import/no-extraneous-dependencies\n} catch (e) { /**/ }\n\nfunction isPunctuator(node, value) {\n  return node.type === 'Punctuator' && node.value === value;\n}\n\n// Get the name of the default import of `node`, if any.\nfunction getDefaultImportName(node) {\n  const defaultSpecifier = node.specifiers\n    .find((specifier) => specifier.type === 'ImportDefaultSpecifier');\n  return defaultSpecifier != null ? defaultSpecifier.local.name : undefined;\n}\n\n// Checks whether `node` has a namespace import.\nfunction hasNamespace(node) {\n  const specifiers = node.specifiers\n    .filter((specifier) => specifier.type === 'ImportNamespaceSpecifier');\n  return specifiers.length > 0;\n}\n\n// Checks whether `node` has any non-default specifiers.\nfunction hasSpecifiers(node) {\n  const specifiers = node.specifiers\n    .filter((specifier) => specifier.type === 'ImportSpecifier');\n  return specifiers.length > 0;\n}\n\n// Checks whether `node` has a comment (that ends) on the previous line or on\n// the same line as `node` (starts).\nfunction hasCommentBefore(node, sourceCode) {\n  return sourceCode.getCommentsBefore(node)\n    .some((comment) => comment.loc.end.line >= node.loc.start.line - 1);\n}\n\n// Checks whether `node` has a comment (that starts) on the same line as `node`\n// (ends).\nfunction hasCommentAfter(node, sourceCode) {\n  return sourceCode.getCommentsAfter(node)\n    .some((comment) => comment.loc.start.line === node.loc.end.line);\n}\n\n// Checks whether `node` has any comments _inside,_ except inside the `{...}`\n// part (if any).\nfunction hasCommentInsideNonSpecifiers(node, sourceCode) {\n  const tokens = sourceCode.getTokens(node);\n  const openBraceIndex = tokens.findIndex((token) => isPunctuator(token, '{'));\n  const closeBraceIndex = tokens.findIndex((token) => isPunctuator(token, '}'));\n  // Slice away the first token, since we're no looking for comments _before_\n  // `node` (only inside). If there's a `{...}` part, look for comments before\n  // the `{`, but not before the `}` (hence the `+1`s).\n  const someTokens = openBraceIndex >= 0 && closeBraceIndex >= 0\n    ? tokens.slice(1, openBraceIndex + 1).concat(tokens.slice(closeBraceIndex + 1))\n    : tokens.slice(1);\n  return someTokens.some((token) => sourceCode.getCommentsBefore(token).length > 0);\n}\n\n// It's not obvious what the user wants to do with comments associated with\n// duplicate imports, so skip imports with comments when autofixing.\nfunction hasProblematicComments(node, sourceCode) {\n  return (\n    hasCommentBefore(node, sourceCode)\n    || hasCommentAfter(node, sourceCode)\n    || hasCommentInsideNonSpecifiers(node, sourceCode)\n  );\n}\n\nfunction getFix(first, rest, sourceCode, context) {\n  // Sorry ESLint <= 3 users, no autofix for you. Autofixing duplicate imports\n  // requires multiple `fixer.whatever()` calls in the `fix`: We both need to\n  // update the first one, and remove the rest. Support for multiple\n  // `fixer.whatever()` in a single `fix` was added in ESLint 4.1.\n  // `sourceCode.getCommentsBefore` was added in 4.0, so that's an easy thing to\n  // check for.\n  if (typeof sourceCode.getCommentsBefore !== 'function') {\n    return undefined;\n  }\n\n  // Adjusting the first import might make it multiline, which could break\n  // `eslint-disable-next-line` comments and similar, so bail if the first\n  // import has comments. Also, if the first import is `import * as ns from\n  // './foo'` there's nothing we can do.\n  if (hasProblematicComments(first, sourceCode) || hasNamespace(first)) {\n    return undefined;\n  }\n\n  const defaultImportNames = new Set(\n    flatMap([].concat(first, rest || []), (x) => getDefaultImportName(x) || []),\n  );\n\n  // Bail if there are multiple different default import names – it's up to the\n  // user to choose which one to keep.\n  if (defaultImportNames.size > 1) {\n    return undefined;\n  }\n\n  // Leave it to the user to handle comments. Also skip `import * as ns from\n  // './foo'` imports, since they cannot be merged into another import.\n  const restWithoutComments = rest.filter((node) => !hasProblematicComments(node, sourceCode) && !hasNamespace(node));\n\n  const specifiers = restWithoutComments\n    .map((node) => {\n      const tokens = sourceCode.getTokens(node);\n      const openBrace = tokens.find((token) => isPunctuator(token, '{'));\n      const closeBrace = tokens.find((token) => isPunctuator(token, '}'));\n\n      if (openBrace == null || closeBrace == null) {\n        return undefined;\n      }\n\n      return {\n        importNode: node,\n        identifiers: sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(','), // Split the text into separate identifiers (retaining any whitespace before or after)\n        isEmpty: !hasSpecifiers(node),\n      };\n    })\n    .filter(Boolean);\n\n  const unnecessaryImports = restWithoutComments.filter((node) => !hasSpecifiers(node)\n    && !hasNamespace(node)\n    && !specifiers.some((specifier) => specifier.importNode === node),\n  );\n\n  const shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1;\n  const shouldAddSpecifiers = specifiers.length > 0;\n  const shouldRemoveUnnecessary = unnecessaryImports.length > 0;\n  const preferInline = context.options[0] && context.options[0]['prefer-inline'];\n\n  if (!(shouldAddDefault || shouldAddSpecifiers || shouldRemoveUnnecessary)) {\n    return undefined;\n  }\n\n  return (fixer) => {\n    const tokens = sourceCode.getTokens(first);\n    const openBrace = tokens.find((token) => isPunctuator(token, '{'));\n    const closeBrace = tokens.find((token) => isPunctuator(token, '}'));\n    const firstToken = sourceCode.getFirstToken(first);\n    const [defaultImportName] = defaultImportNames;\n\n    const firstHasTrailingComma = closeBrace != null && isPunctuator(sourceCode.getTokenBefore(closeBrace), ',');\n    const firstIsEmpty = !hasSpecifiers(first);\n    const firstExistingIdentifiers = firstIsEmpty\n      ? new Set()\n      : new Set(sourceCode.text.slice(openBrace.range[1], closeBrace.range[0])\n        .split(',')\n        .map((x) => x.trim()),\n      );\n\n    const [specifiersText] = specifiers.reduce(\n      ([result, needsComma, existingIdentifiers], specifier) => {\n        const isTypeSpecifier = specifier.importNode.importKind === 'type';\n\n        // a user might set prefer-inline but not have a supporting TypeScript version. Flow does not support inline types so this should fail in that case as well.\n        if (preferInline && (!typescriptPkg || !semver.satisfies(typescriptPkg.version, '>= 4.5'))) {\n          throw new Error('Your version of TypeScript does not support inline type imports.');\n        }\n\n        // Add *only* the new identifiers that don't already exist, and track any new identifiers so we don't add them again in the next loop\n        const [specifierText, updatedExistingIdentifiers] = specifier.identifiers.reduce(([text, set], cur) => {\n          const trimmed = cur.trim(); // Trim whitespace before/after to compare to our set of existing identifiers\n          const curWithType = trimmed.length > 0 && preferInline && isTypeSpecifier ? `type ${cur}` : cur;\n          if (existingIdentifiers.has(trimmed)) {\n            return [text, set];\n          }\n          return [text.length > 0 ? `${text},${curWithType}` : curWithType, set.add(trimmed)];\n        }, ['', existingIdentifiers]);\n\n        return [\n          needsComma && !specifier.isEmpty && specifierText.length > 0\n            ? `${result},${specifierText}`\n            : `${result}${specifierText}`,\n          specifier.isEmpty ? needsComma : true,\n          updatedExistingIdentifiers,\n        ];\n      },\n      ['', !firstHasTrailingComma && !firstIsEmpty, firstExistingIdentifiers],\n    );\n\n    const fixes = [];\n\n    if (shouldAddSpecifiers && preferInline && first.importKind === 'type') {\n      // `import type {a} from './foo'` → `import {type a} from './foo'`\n      const typeIdentifierToken = tokens.find((token) => token.type === 'Identifier' && token.value === 'type');\n      fixes.push(fixer.removeRange([typeIdentifierToken.range[0], typeIdentifierToken.range[1] + 1]));\n\n      tokens\n        .filter((token) => firstExistingIdentifiers.has(token.value))\n        .forEach((identifier) => {\n          fixes.push(fixer.replaceTextRange([identifier.range[0], identifier.range[1]], `type ${identifier.value}`));\n        });\n    }\n\n    if (shouldAddDefault && openBrace == null && shouldAddSpecifiers) {\n      // `import './foo'` → `import def, {...} from './foo'`\n      fixes.push(\n        fixer.insertTextAfter(firstToken, ` ${defaultImportName}, {${specifiersText}} from`),\n      );\n    } else if (shouldAddDefault && openBrace == null && !shouldAddSpecifiers) {\n      // `import './foo'` → `import def from './foo'`\n      fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName} from`));\n    } else if (shouldAddDefault && openBrace != null && closeBrace != null) {\n      // `import {...} from './foo'` → `import def, {...} from './foo'`\n      fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName},`));\n      if (shouldAddSpecifiers) {\n        // `import def, {...} from './foo'` → `import def, {..., ...} from './foo'`\n        fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));\n      }\n    } else if (!shouldAddDefault && openBrace == null && shouldAddSpecifiers) {\n      if (first.specifiers.length === 0) {\n        // `import './foo'` → `import {...} from './foo'`\n        fixes.push(fixer.insertTextAfter(firstToken, ` {${specifiersText}} from`));\n      } else {\n        // `import def from './foo'` → `import def, {...} from './foo'`\n        fixes.push(fixer.insertTextAfter(first.specifiers[0], `, {${specifiersText}}`));\n      }\n    } else if (!shouldAddDefault && openBrace != null && closeBrace != null) {\n      // `import {...} './foo'` → `import {..., ...} from './foo'`\n      fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));\n    }\n\n    // Remove imports whose specifiers have been moved into the first import.\n    for (const specifier of specifiers) {\n      const importNode = specifier.importNode;\n      fixes.push(fixer.remove(importNode));\n\n      const charAfterImportRange = [importNode.range[1], importNode.range[1] + 1];\n      const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);\n      if (charAfterImport === '\\n') {\n        fixes.push(fixer.removeRange(charAfterImportRange));\n      }\n    }\n\n    // Remove imports whose default import has been moved to the first import,\n    // and side-effect-only imports that are unnecessary due to the first\n    // import.\n    for (const node of unnecessaryImports) {\n      fixes.push(fixer.remove(node));\n\n      const charAfterImportRange = [node.range[1], node.range[1] + 1];\n      const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);\n      if (charAfterImport === '\\n') {\n        fixes.push(fixer.removeRange(charAfterImportRange));\n      }\n    }\n\n    return fixes;\n  };\n}\n\nfunction checkImports(imported, context) {\n  for (const [module, nodes] of imported.entries()) {\n    if (nodes.length > 1) {\n      const message = `'${module}' imported multiple times.`;\n      const [first, ...rest] = nodes;\n      const sourceCode = context.getSourceCode();\n      const fix = getFix(first, rest, sourceCode, context);\n\n      context.report({\n        node: first.source,\n        message,\n        fix, // Attach the autofix (if any) to the first import.\n      });\n\n      for (const node of rest) {\n        context.report({\n          node: node.source,\n          message,\n        });\n      }\n    }\n  }\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Style guide',\n      description: 'Forbid repeated import of the same module in multiple places.',\n      url: docsUrl('no-duplicates'),\n    },\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          considerQueryString: {\n            type: 'boolean',\n          },\n          'prefer-inline': {\n            type: 'boolean',\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create(context) {\n    // Prepare the resolver from options.\n    const considerQueryStringOption = context.options[0]\n      && context.options[0].considerQueryString;\n    const defaultResolver = (sourcePath) => resolve(sourcePath, context) || sourcePath;\n    const resolver = considerQueryStringOption ? (sourcePath) => {\n      const parts = sourcePath.match(/^([^?]*)\\?(.*)$/);\n      if (!parts) {\n        return defaultResolver(sourcePath);\n      }\n      return `${defaultResolver(parts[1])}?${parts[2]}`;\n    } : defaultResolver;\n\n    const moduleMaps = new Map();\n\n    function getImportMap(n) {\n      if (!moduleMaps.has(n.parent)) {\n        moduleMaps.set(n.parent, {\n          imported: new Map(),\n          nsImported: new Map(),\n          defaultTypesImported: new Map(),\n          namedTypesImported: new Map(),\n        });\n      }\n      const map = moduleMaps.get(n.parent);\n      const preferInline = context.options[0] && context.options[0]['prefer-inline'];\n      if (!preferInline && n.importKind === 'type') {\n        return n.specifiers.length > 0 && n.specifiers[0].type === 'ImportDefaultSpecifier' ? map.defaultTypesImported : map.namedTypesImported;\n      }\n      if (!preferInline && n.specifiers.some((spec) => spec.importKind === 'type')) {\n        return map.namedTypesImported;\n      }\n\n      return hasNamespace(n) ? map.nsImported : map.imported;\n    }\n\n    return {\n      ImportDeclaration(n) {\n        // resolved path will cover aliased duplicates\n        const resolvedPath = resolver(n.source.value);\n        const importMap = getImportMap(n);\n\n        if (importMap.has(resolvedPath)) {\n          importMap.get(resolvedPath).push(n);\n        } else {\n          importMap.set(resolvedPath, [n]);\n        }\n      },\n\n      'Program:exit'() {\n        for (const map of moduleMaps.values()) {\n          checkImports(map.imported, context);\n          checkImports(map.nsImported, context);\n          checkImports(map.defaultTypesImported, context);\n          checkImports(map.namedTypesImported, context);\n        }\n      },\n    };\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-duplicates.js"],"names":["typescriptPkg","require","e","checkImports","imported","context","entries","module","nodes","length","message","first","rest","sourceCode","getSourceCode","fix","getFix","report","node","source","getCommentsBefore","undefined","hasProblematicComments","hasNamespace","defaultImportNames","Set","concat","x","getDefaultImportName","size","restWithoutComments","filter","specifiers","map","tokens","getTokens","openBrace","find","token","isPunctuator","closeBrace","importNode","identifiers","text","slice","range","split","isEmpty","hasSpecifiers","Boolean","unnecessaryImports","some","specifier","shouldAddDefault","shouldAddSpecifiers","shouldRemoveUnnecessary","fixer","firstToken","getFirstToken","defaultImportName","firstHasTrailingComma","getTokenBefore","firstIsEmpty","firstExistingIdentifiers","trim","reduce","result","needsComma","existingIdentifiers","isTypeSpecifier","importKind","preferInline","options","semver","satisfies","version","Error","cur","set","trimmed","curWithType","has","add","specifierText","updatedExistingIdentifiers","specifiersText","fixes","push","insertTextAfter","insertTextBefore","remove","charAfterImportRange","charAfterImport","substring","removeRange","value","type","defaultSpecifier","local","name","hasCommentBefore","hasCommentAfter","hasCommentInsideNonSpecifiers","comment","loc","end","line","start","getCommentsAfter","openBraceIndex","findIndex","closeBraceIndex","someTokens","exports","meta","docs","category","description","url","fixable","schema","properties","considerQueryString","additionalProperties","create","considerQueryStringOption","defaultResolver","sourcePath","resolver","parts","match","moduleMaps","Map","getImportMap","n","parent","nsImported","defaultTypesImported","namedTypesImported","get","spec","ImportDeclaration","resolvedPath","importMap","values"],"mappings":"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","file":"no-duplicates.js","sourcesContent":["import resolve from 'eslint-module-utils/resolve';\nimport semver from 'semver';\nimport flatMap from 'array.prototype.flatmap';\n\nimport docsUrl from '../docsUrl';\n\nlet typescriptPkg;\ntry {\n  typescriptPkg = require('typescript/package.json'); // eslint-disable-line import/no-extraneous-dependencies\n} catch (e) { /**/ }\n\nfunction checkImports(imported, context) {\n  for (const [module, nodes] of imported.entries()) {\n    if (nodes.length > 1) {\n      const message = `'${module}' imported multiple times.`;\n      const [first, ...rest] = nodes;\n      const sourceCode = context.getSourceCode();\n      const fix = getFix(first, rest, sourceCode, context);\n\n      context.report({\n        node: first.source,\n        message,\n        fix, // Attach the autofix (if any) to the first import.\n      });\n\n      for (const node of rest) {\n        context.report({\n          node: node.source,\n          message,\n        });\n      }\n    }\n  }\n}\n\nfunction getFix(first, rest, sourceCode, context) {\n  // Sorry ESLint <= 3 users, no autofix for you. Autofixing duplicate imports\n  // requires multiple `fixer.whatever()` calls in the `fix`: We both need to\n  // update the first one, and remove the rest. Support for multiple\n  // `fixer.whatever()` in a single `fix` was added in ESLint 4.1.\n  // `sourceCode.getCommentsBefore` was added in 4.0, so that's an easy thing to\n  // check for.\n  if (typeof sourceCode.getCommentsBefore !== 'function') {\n    return undefined;\n  }\n\n  // Adjusting the first import might make it multiline, which could break\n  // `eslint-disable-next-line` comments and similar, so bail if the first\n  // import has comments. Also, if the first import is `import * as ns from\n  // './foo'` there's nothing we can do.\n  if (hasProblematicComments(first, sourceCode) || hasNamespace(first)) {\n    return undefined;\n  }\n\n  const defaultImportNames = new Set(\n    flatMap([].concat(first, rest || []), (x) => getDefaultImportName(x) || []),\n  );\n\n  // Bail if there are multiple different default import names – it's up to the\n  // user to choose which one to keep.\n  if (defaultImportNames.size > 1) {\n    return undefined;\n  }\n\n  // Leave it to the user to handle comments. Also skip `import * as ns from\n  // './foo'` imports, since they cannot be merged into another import.\n  const restWithoutComments = rest.filter((node) => !hasProblematicComments(node, sourceCode) && !hasNamespace(node));\n\n  const specifiers = restWithoutComments\n    .map((node) => {\n      const tokens = sourceCode.getTokens(node);\n      const openBrace = tokens.find((token) => isPunctuator(token, '{'));\n      const closeBrace = tokens.find((token) => isPunctuator(token, '}'));\n\n      if (openBrace == null || closeBrace == null) {\n        return undefined;\n      }\n\n      return {\n        importNode: node,\n        identifiers: sourceCode.text.slice(openBrace.range[1], closeBrace.range[0]).split(','), // Split the text into separate identifiers (retaining any whitespace before or after)\n        isEmpty: !hasSpecifiers(node),\n      };\n    })\n    .filter(Boolean);\n\n  const unnecessaryImports = restWithoutComments.filter((node) => !hasSpecifiers(node)\n    && !hasNamespace(node)\n    && !specifiers.some((specifier) => specifier.importNode === node),\n  );\n\n  const shouldAddDefault = getDefaultImportName(first) == null && defaultImportNames.size === 1;\n  const shouldAddSpecifiers = specifiers.length > 0;\n  const shouldRemoveUnnecessary = unnecessaryImports.length > 0;\n\n  if (!(shouldAddDefault || shouldAddSpecifiers || shouldRemoveUnnecessary)) {\n    return undefined;\n  }\n\n  return (fixer) => {\n    const tokens = sourceCode.getTokens(first);\n    const openBrace = tokens.find((token) => isPunctuator(token, '{'));\n    const closeBrace = tokens.find((token) => isPunctuator(token, '}'));\n    const firstToken = sourceCode.getFirstToken(first);\n    const [defaultImportName] = defaultImportNames;\n\n    const firstHasTrailingComma = closeBrace != null && isPunctuator(sourceCode.getTokenBefore(closeBrace), ',');\n    const firstIsEmpty = !hasSpecifiers(first);\n    const firstExistingIdentifiers = firstIsEmpty\n      ? new Set()\n      : new Set(sourceCode.text.slice(openBrace.range[1], closeBrace.range[0])\n        .split(',')\n        .map((x) => x.trim()),\n      );\n\n    const [specifiersText] = specifiers.reduce(\n      ([result, needsComma, existingIdentifiers], specifier) => {\n        const isTypeSpecifier = specifier.importNode.importKind === 'type';\n\n        const preferInline = context.options[0] && context.options[0]['prefer-inline'];\n        // a user might set prefer-inline but not have a supporting TypeScript version.  Flow does not support inline types so this should fail in that case as well.\n        if (preferInline && (!typescriptPkg || !semver.satisfies(typescriptPkg.version, '>= 4.5'))) {\n          throw new Error('Your version of TypeScript does not support inline type imports.');\n        }\n\n        // Add *only* the new identifiers that don't already exist, and track any new identifiers so we don't add them again in the next loop\n        const [specifierText, updatedExistingIdentifiers] = specifier.identifiers.reduce(([text, set], cur) => {\n          const trimmed = cur.trim(); // Trim whitespace before/after to compare to our set of existing identifiers\n          const curWithType = trimmed.length > 0 && preferInline && isTypeSpecifier ? `type ${cur}` : cur;\n          if (existingIdentifiers.has(trimmed)) {\n            return [text, set];\n          }\n          return [text.length > 0 ? `${text},${curWithType}` : curWithType, set.add(trimmed)];\n        }, ['', existingIdentifiers]);\n\n        return [\n          needsComma && !specifier.isEmpty && specifierText.length > 0\n            ? `${result},${specifierText}`\n            : `${result}${specifierText}`,\n          specifier.isEmpty ? needsComma : true,\n          updatedExistingIdentifiers,\n        ];\n      },\n      ['', !firstHasTrailingComma && !firstIsEmpty, firstExistingIdentifiers],\n    );\n\n    const fixes = [];\n\n    if (shouldAddDefault && openBrace == null && shouldAddSpecifiers) {\n      // `import './foo'` → `import def, {...} from './foo'`\n      fixes.push(\n        fixer.insertTextAfter(firstToken, ` ${defaultImportName}, {${specifiersText}} from`),\n      );\n    } else if (shouldAddDefault && openBrace == null && !shouldAddSpecifiers) {\n      // `import './foo'` → `import def from './foo'`\n      fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName} from`));\n    } else if (shouldAddDefault && openBrace != null && closeBrace != null) {\n      // `import {...} from './foo'` → `import def, {...} from './foo'`\n      fixes.push(fixer.insertTextAfter(firstToken, ` ${defaultImportName},`));\n      if (shouldAddSpecifiers) {\n        // `import def, {...} from './foo'` → `import def, {..., ...} from './foo'`\n        fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));\n      }\n    } else if (!shouldAddDefault && openBrace == null && shouldAddSpecifiers) {\n      if (first.specifiers.length === 0) {\n        // `import './foo'` → `import {...} from './foo'`\n        fixes.push(fixer.insertTextAfter(firstToken, ` {${specifiersText}} from`));\n      } else {\n        // `import def from './foo'` → `import def, {...} from './foo'`\n        fixes.push(fixer.insertTextAfter(first.specifiers[0], `, {${specifiersText}}`));\n      }\n    } else if (!shouldAddDefault && openBrace != null && closeBrace != null) {\n      // `import {...} './foo'` → `import {..., ...} from './foo'`\n      fixes.push(fixer.insertTextBefore(closeBrace, specifiersText));\n    }\n\n    // Remove imports whose specifiers have been moved into the first import.\n    for (const specifier of specifiers) {\n      const importNode = specifier.importNode;\n      fixes.push(fixer.remove(importNode));\n\n      const charAfterImportRange = [importNode.range[1], importNode.range[1] + 1];\n      const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);\n      if (charAfterImport === '\\n') {\n        fixes.push(fixer.removeRange(charAfterImportRange));\n      }\n    }\n\n    // Remove imports whose default import has been moved to the first import,\n    // and side-effect-only imports that are unnecessary due to the first\n    // import.\n    for (const node of unnecessaryImports) {\n      fixes.push(fixer.remove(node));\n\n      const charAfterImportRange = [node.range[1], node.range[1] + 1];\n      const charAfterImport = sourceCode.text.substring(charAfterImportRange[0], charAfterImportRange[1]);\n      if (charAfterImport === '\\n') {\n        fixes.push(fixer.removeRange(charAfterImportRange));\n      }\n    }\n\n    return fixes;\n  };\n}\n\nfunction isPunctuator(node, value) {\n  return node.type === 'Punctuator' && node.value === value;\n}\n\n// Get the name of the default import of `node`, if any.\nfunction getDefaultImportName(node) {\n  const defaultSpecifier = node.specifiers\n    .find((specifier) => specifier.type === 'ImportDefaultSpecifier');\n  return defaultSpecifier != null ? defaultSpecifier.local.name : undefined;\n}\n\n// Checks whether `node` has a namespace import.\nfunction hasNamespace(node) {\n  const specifiers = node.specifiers\n    .filter((specifier) => specifier.type === 'ImportNamespaceSpecifier');\n  return specifiers.length > 0;\n}\n\n// Checks whether `node` has any non-default specifiers.\nfunction hasSpecifiers(node) {\n  const specifiers = node.specifiers\n    .filter((specifier) => specifier.type === 'ImportSpecifier');\n  return specifiers.length > 0;\n}\n\n// It's not obvious what the user wants to do with comments associated with\n// duplicate imports, so skip imports with comments when autofixing.\nfunction hasProblematicComments(node, sourceCode) {\n  return (\n    hasCommentBefore(node, sourceCode)\n    || hasCommentAfter(node, sourceCode)\n    || hasCommentInsideNonSpecifiers(node, sourceCode)\n  );\n}\n\n// Checks whether `node` has a comment (that ends) on the previous line or on\n// the same line as `node` (starts).\nfunction hasCommentBefore(node, sourceCode) {\n  return sourceCode.getCommentsBefore(node)\n    .some((comment) => comment.loc.end.line >= node.loc.start.line - 1);\n}\n\n// Checks whether `node` has a comment (that starts) on the same line as `node`\n// (ends).\nfunction hasCommentAfter(node, sourceCode) {\n  return sourceCode.getCommentsAfter(node)\n    .some((comment) => comment.loc.start.line === node.loc.end.line);\n}\n\n// Checks whether `node` has any comments _inside,_ except inside the `{...}`\n// part (if any).\nfunction hasCommentInsideNonSpecifiers(node, sourceCode) {\n  const tokens = sourceCode.getTokens(node);\n  const openBraceIndex = tokens.findIndex((token) => isPunctuator(token, '{'));\n  const closeBraceIndex = tokens.findIndex((token) => isPunctuator(token, '}'));\n  // Slice away the first token, since we're no looking for comments _before_\n  // `node` (only inside). If there's a `{...}` part, look for comments before\n  // the `{`, but not before the `}` (hence the `+1`s).\n  const someTokens = openBraceIndex >= 0 && closeBraceIndex >= 0\n    ? tokens.slice(1, openBraceIndex + 1).concat(tokens.slice(closeBraceIndex + 1))\n    : tokens.slice(1);\n  return someTokens.some((token) => sourceCode.getCommentsBefore(token).length > 0);\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Style guide',\n      description: 'Forbid repeated import of the same module in multiple places.',\n      url: docsUrl('no-duplicates'),\n    },\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          considerQueryString: {\n            type: 'boolean',\n          },\n          'prefer-inline': {\n            type: 'boolean',\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create(context) {\n    // Prepare the resolver from options.\n    const considerQueryStringOption = context.options[0]\n      && context.options[0].considerQueryString;\n    const defaultResolver = (sourcePath) => resolve(sourcePath, context) || sourcePath;\n    const resolver = considerQueryStringOption ? (sourcePath) => {\n      const parts = sourcePath.match(/^([^?]*)\\?(.*)$/);\n      if (!parts) {\n        return defaultResolver(sourcePath);\n      }\n      return `${defaultResolver(parts[1])}?${parts[2]}`;\n    } : defaultResolver;\n\n    const moduleMaps = new Map();\n\n    function getImportMap(n) {\n      if (!moduleMaps.has(n.parent)) {\n        moduleMaps.set(n.parent, {\n          imported: new Map(),\n          nsImported: new Map(),\n          defaultTypesImported: new Map(),\n          namedTypesImported: new Map(),\n        });\n      }\n      const map = moduleMaps.get(n.parent);\n      const preferInline = context.options[0] && context.options[0]['prefer-inline'];\n      if (!preferInline && n.importKind === 'type') {\n        return n.specifiers.length > 0 && n.specifiers[0].type === 'ImportDefaultSpecifier' ? map.defaultTypesImported : map.namedTypesImported;\n      }\n      if (!preferInline && n.specifiers.some((spec) => spec.importKind === 'type')) {\n        return map.namedTypesImported;\n      }\n\n      return hasNamespace(n) ? map.nsImported : map.imported;\n    }\n\n    return {\n      ImportDeclaration(n) {\n        // resolved path will cover aliased duplicates\n        const resolvedPath = resolver(n.source.value);\n        const importMap = getImportMap(n);\n\n        if (importMap.has(resolvedPath)) {\n          importMap.get(resolvedPath).push(n);\n        } else {\n          importMap.set(resolvedPath, [n]);\n        }\n      },\n\n      'Program:exit'() {\n        for (const map of moduleMaps.values()) {\n          checkImports(map.imported, context);\n          checkImports(map.nsImported, context);\n          checkImports(map.defaultTypesImported, context);\n          checkImports(map.namedTypesImported, context);\n        }\n      },\n    };\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/no-extraneous-dependencies.js b/node_modules/eslint-plugin-import/lib/rules/no-extraneous-dependencies.js index 220e15a25a..cbe024a71f 100644 --- a/node_modules/eslint-plugin-import/lib/rules/no-extraneous-dependencies.js +++ b/node_modules/eslint-plugin-import/lib/rules/no-extraneous-dependencies.js @@ -42,11 +42,8 @@ function extractDepFields(pkg) { function getPackageDepFields(packageJsonPath, throwAtRead) { if (!depFieldCache.has(packageJsonPath)) { - var packageJson = readJSON(packageJsonPath, throwAtRead); - if (packageJson) { - var depFields = extractDepFields(packageJson); - depFieldCache.set(packageJsonPath, depFields); - } + var depFields = extractDepFields(readJSON(packageJsonPath, throwAtRead)); + depFieldCache.set(packageJsonPath, depFields); } return depFieldCache.get(packageJsonPath); @@ -75,12 +72,10 @@ function getDependencies(context, packageDir) { // use rule config to find package.json paths.forEach(function (dir) { var packageJsonPath = _path2['default'].join(dir, 'package.json'); - var _packageContent = getPackageDepFields(packageJsonPath, paths.length === 1); - if (_packageContent) { - Object.keys(packageContent).forEach(function (depsKey) { - Object.assign(packageContent[depsKey], _packageContent[depsKey]); - }); - } + var _packageContent = getPackageDepFields(packageJsonPath, true); + Object.keys(packageContent).forEach(function (depsKey) { + Object.assign(packageContent[depsKey], _packageContent[depsKey]); + }); }); } else { var packageJsonPath = (0, _pkgUp2['default'])({ @@ -303,4 +298,4 @@ module.exports = { 'Program:exit': function () {function ProgramExit() { depFieldCache.clear(); }return ProgramExit;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-extraneous-dependencies.js"],"names":["depFieldCache","Map","hasKeys","obj","Object","keys","length","arrayOrKeys","arrayOrObject","Array","isArray","readJSON","jsonPath","throwException","JSON","parse","fs","readFileSync","err","extractDepFields","pkg","dependencies","devDependencies","optionalDependencies","peerDependencies","bundledDependencies","bundleDependencies","getPackageDepFields","packageJsonPath","throwAtRead","has","packageJson","depFields","set","get","getDependencies","context","packageDir","paths","packageContent","path","resolve","map","dir","forEach","join","_packageContent","depsKey","assign","cwd","getPhysicalFilename","getFilename","normalize","some","e","code","report","message","loc","line","column","name","SyntaxError","missingErrorMessage","packageName","devDepErrorMessage","optDepErrorMessage","getModuleOriginalName","split","first","second","startsWith","getModuleRealName","resolved","checkDependencyDeclaration","deps","declarationStatus","newDeclarationStatus","isInDeps","isInDevDeps","isInOptDeps","isInPeerDeps","isInBundledDeps","packageHierarchy","packageNameParts","namePart","index","ancestor","slice","push","reduce","result","ancestorName","undefined","indexOf","reportIfMissing","depsOptions","node","verifyTypeImports","importKind","exportKind","specifiers","every","specifier","typeOfImport","verifyInternalDeps","importPackageName","allowDevDeps","allowPeerDeps","allowOptDeps","allowBundledDeps","realPackageName","testConfig","config","filename","c","process","module","exports","meta","type","docs","category","description","url","schema","properties","includeInternal","includeTypes","additionalProperties","create","options","source","value","commonjs","clear"],"mappings":"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","file":"no-extraneous-dependencies.js","sourcesContent":["import path from 'path';\nimport fs from 'fs';\nimport pkgUp from 'eslint-module-utils/pkgUp';\nimport minimatch from 'minimatch';\nimport resolve from 'eslint-module-utils/resolve';\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor';\nimport importType from '../core/importType';\nimport { getFilePackageName } from '../core/packagePath';\nimport docsUrl from '../docsUrl';\n\nconst depFieldCache = new Map();\n\nfunction hasKeys(obj = {}) {\n  return Object.keys(obj).length > 0;\n}\n\nfunction arrayOrKeys(arrayOrObject) {\n  return Array.isArray(arrayOrObject) ? arrayOrObject : Object.keys(arrayOrObject);\n}\n\nfunction readJSON(jsonPath, throwException) {\n  try {\n    return JSON.parse(fs.readFileSync(jsonPath, 'utf8'));\n  } catch (err) {\n    if (throwException) {\n      throw err;\n    }\n  }\n}\n\nfunction extractDepFields(pkg) {\n  return {\n    dependencies: pkg.dependencies || {},\n    devDependencies: pkg.devDependencies || {},\n    optionalDependencies: pkg.optionalDependencies || {},\n    peerDependencies: pkg.peerDependencies || {},\n    // BundledDeps should be in the form of an array, but object notation is also supported by\n    // `npm`, so we convert it to an array if it is an object\n    bundledDependencies: arrayOrKeys(pkg.bundleDependencies || pkg.bundledDependencies || []),\n  };\n}\n\nfunction getPackageDepFields(packageJsonPath, throwAtRead) {\n  if (!depFieldCache.has(packageJsonPath)) {\n    const packageJson = readJSON(packageJsonPath, throwAtRead);\n    if (packageJson) {\n      const depFields = extractDepFields(packageJson);\n      depFieldCache.set(packageJsonPath, depFields);\n    }\n  }\n\n  return depFieldCache.get(packageJsonPath);\n}\n\nfunction getDependencies(context, packageDir) {\n  let paths = [];\n  try {\n    const packageContent = {\n      dependencies: {},\n      devDependencies: {},\n      optionalDependencies: {},\n      peerDependencies: {},\n      bundledDependencies: [],\n    };\n\n    if (packageDir && packageDir.length > 0) {\n      if (!Array.isArray(packageDir)) {\n        paths = [path.resolve(packageDir)];\n      } else {\n        paths = packageDir.map((dir) => path.resolve(dir));\n      }\n    }\n\n    if (paths.length > 0) {\n      // use rule config to find package.json\n      paths.forEach((dir) => {\n        const packageJsonPath = path.join(dir, 'package.json');\n        const _packageContent = getPackageDepFields(packageJsonPath, paths.length === 1);\n        if (_packageContent) {\n          Object.keys(packageContent).forEach((depsKey) => {\n            Object.assign(packageContent[depsKey], _packageContent[depsKey]);\n          });\n        }\n      });\n    } else {\n      const packageJsonPath = pkgUp({\n        cwd: context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename(),\n        normalize: false,\n      });\n\n      // use closest package.json\n      Object.assign(\n        packageContent,\n        getPackageDepFields(packageJsonPath, false),\n      );\n    }\n\n    if (![\n      packageContent.dependencies,\n      packageContent.devDependencies,\n      packageContent.optionalDependencies,\n      packageContent.peerDependencies,\n      packageContent.bundledDependencies,\n    ].some(hasKeys)) {\n      return null;\n    }\n\n    return packageContent;\n  } catch (e) {\n    if (paths.length > 0 && e.code === 'ENOENT') {\n      context.report({\n        message: 'The package.json file could not be found.',\n        loc: { line: 0, column: 0 },\n      });\n    }\n    if (e.name === 'JSONError' || e instanceof SyntaxError) {\n      context.report({\n        message: `The package.json file could not be parsed: ${e.message}`,\n        loc: { line: 0, column: 0 },\n      });\n    }\n\n    return null;\n  }\n}\n\nfunction missingErrorMessage(packageName) {\n  return `'${packageName}' should be listed in the project's dependencies. Run 'npm i -S ${packageName}' to add it`;\n}\n\nfunction devDepErrorMessage(packageName) {\n  return `'${packageName}' should be listed in the project's dependencies, not devDependencies.`;\n}\n\nfunction optDepErrorMessage(packageName) {\n  return `'${packageName}' should be listed in the project's dependencies, not optionalDependencies.`;\n}\n\nfunction getModuleOriginalName(name) {\n  const [first, second] = name.split('/');\n  return first.startsWith('@') ? `${first}/${second}` : first;\n}\n\nfunction getModuleRealName(resolved) {\n  return getFilePackageName(resolved);\n}\n\nfunction checkDependencyDeclaration(deps, packageName, declarationStatus) {\n  const newDeclarationStatus = declarationStatus || {\n    isInDeps: false,\n    isInDevDeps: false,\n    isInOptDeps: false,\n    isInPeerDeps: false,\n    isInBundledDeps: false,\n  };\n\n  // in case of sub package.json inside a module\n  // check the dependencies on all hierarchy\n  const packageHierarchy = [];\n  const packageNameParts = packageName ? packageName.split('/') : [];\n  packageNameParts.forEach((namePart, index) => {\n    if (!namePart.startsWith('@')) {\n      const ancestor = packageNameParts.slice(0, index + 1).join('/');\n      packageHierarchy.push(ancestor);\n    }\n  });\n\n  return packageHierarchy.reduce((result, ancestorName) => ({\n    isInDeps: result.isInDeps || deps.dependencies[ancestorName] !== undefined,\n    isInDevDeps: result.isInDevDeps || deps.devDependencies[ancestorName] !== undefined,\n    isInOptDeps: result.isInOptDeps || deps.optionalDependencies[ancestorName] !== undefined,\n    isInPeerDeps: result.isInPeerDeps || deps.peerDependencies[ancestorName] !== undefined,\n    isInBundledDeps:\n        result.isInBundledDeps || deps.bundledDependencies.indexOf(ancestorName) !== -1,\n  }), newDeclarationStatus);\n}\n\nfunction reportIfMissing(context, deps, depsOptions, node, name) {\n  // Do not report when importing types unless option is enabled\n  if (\n    !depsOptions.verifyTypeImports\n    && (\n      node.importKind === 'type'\n      || node.importKind === 'typeof'\n      || node.exportKind === 'type'\n      || Array.isArray(node.specifiers) && node.specifiers.length && node.specifiers.every((specifier) => specifier.importKind === 'type' || specifier.importKind === 'typeof')\n    )\n  ) {\n    return;\n  }\n\n  const typeOfImport = importType(name, context);\n\n  if (\n    typeOfImport !== 'external'\n    && (typeOfImport !== 'internal' || !depsOptions.verifyInternalDeps)\n  ) {\n    return;\n  }\n\n  const resolved = resolve(name, context);\n  if (!resolved) { return; }\n\n  const importPackageName = getModuleOriginalName(name);\n  let declarationStatus = checkDependencyDeclaration(deps, importPackageName);\n\n  if (\n    declarationStatus.isInDeps\n    || depsOptions.allowDevDeps && declarationStatus.isInDevDeps\n    || depsOptions.allowPeerDeps && declarationStatus.isInPeerDeps\n    || depsOptions.allowOptDeps && declarationStatus.isInOptDeps\n    || depsOptions.allowBundledDeps && declarationStatus.isInBundledDeps\n  ) {\n    return;\n  }\n\n  // test the real name from the resolved package.json\n  // if not aliased imports (alias/react for example), importPackageName can be misinterpreted\n  const realPackageName = getModuleRealName(resolved);\n  if (realPackageName && realPackageName !== importPackageName) {\n    declarationStatus = checkDependencyDeclaration(deps, realPackageName, declarationStatus);\n\n    if (\n      declarationStatus.isInDeps\n      || depsOptions.allowDevDeps && declarationStatus.isInDevDeps\n      || depsOptions.allowPeerDeps && declarationStatus.isInPeerDeps\n      || depsOptions.allowOptDeps && declarationStatus.isInOptDeps\n      || depsOptions.allowBundledDeps && declarationStatus.isInBundledDeps\n    ) {\n      return;\n    }\n  }\n\n  if (declarationStatus.isInDevDeps && !depsOptions.allowDevDeps) {\n    context.report(node, devDepErrorMessage(realPackageName || importPackageName));\n    return;\n  }\n\n  if (declarationStatus.isInOptDeps && !depsOptions.allowOptDeps) {\n    context.report(node, optDepErrorMessage(realPackageName || importPackageName));\n    return;\n  }\n\n  context.report(node, missingErrorMessage(realPackageName || importPackageName));\n}\n\nfunction testConfig(config, filename) {\n  // Simplest configuration first, either a boolean or nothing.\n  if (typeof config === 'boolean' || typeof config === 'undefined') {\n    return config;\n  }\n  // Array of globs.\n  return config.some((c) => minimatch(filename, c)\n    || minimatch(filename, path.join(process.cwd(), c)),\n  );\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid the use of extraneous packages.',\n      url: docsUrl('no-extraneous-dependencies'),\n    },\n\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          devDependencies: { type: ['boolean', 'array'] },\n          optionalDependencies: { type: ['boolean', 'array'] },\n          peerDependencies: { type: ['boolean', 'array'] },\n          bundledDependencies: { type: ['boolean', 'array'] },\n          packageDir: { type: ['string', 'array'] },\n          includeInternal: { type: ['boolean'] },\n          includeTypes: { type: ['boolean'] },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create(context) {\n    const options = context.options[0] || {};\n    const filename = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n    const deps = getDependencies(context, options.packageDir) || extractDepFields({});\n\n    const depsOptions = {\n      allowDevDeps: testConfig(options.devDependencies, filename) !== false,\n      allowOptDeps: testConfig(options.optionalDependencies, filename) !== false,\n      allowPeerDeps: testConfig(options.peerDependencies, filename) !== false,\n      allowBundledDeps: testConfig(options.bundledDependencies, filename) !== false,\n      verifyInternalDeps: !!options.includeInternal,\n      verifyTypeImports: !!options.includeTypes,\n    };\n\n    return moduleVisitor((source, node) => {\n      reportIfMissing(context, deps, depsOptions, node, source.value);\n    }, { commonjs: true });\n  },\n\n  'Program:exit'() {\n    depFieldCache.clear();\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-extraneous-dependencies.js"],"names":["depFieldCache","Map","hasKeys","obj","Object","keys","length","arrayOrKeys","arrayOrObject","Array","isArray","readJSON","jsonPath","throwException","JSON","parse","fs","readFileSync","err","extractDepFields","pkg","dependencies","devDependencies","optionalDependencies","peerDependencies","bundledDependencies","bundleDependencies","getPackageDepFields","packageJsonPath","throwAtRead","has","depFields","set","get","getDependencies","context","packageDir","paths","packageContent","path","resolve","map","dir","forEach","join","_packageContent","depsKey","assign","cwd","getPhysicalFilename","getFilename","normalize","some","e","code","report","message","loc","line","column","name","SyntaxError","missingErrorMessage","packageName","devDepErrorMessage","optDepErrorMessage","getModuleOriginalName","split","first","second","startsWith","getModuleRealName","resolved","checkDependencyDeclaration","deps","declarationStatus","newDeclarationStatus","isInDeps","isInDevDeps","isInOptDeps","isInPeerDeps","isInBundledDeps","packageHierarchy","packageNameParts","namePart","index","ancestor","slice","push","reduce","result","ancestorName","undefined","indexOf","reportIfMissing","depsOptions","node","verifyTypeImports","importKind","exportKind","specifiers","every","specifier","typeOfImport","verifyInternalDeps","importPackageName","allowDevDeps","allowPeerDeps","allowOptDeps","allowBundledDeps","realPackageName","testConfig","config","filename","c","process","module","exports","meta","type","docs","category","description","url","schema","properties","includeInternal","includeTypes","additionalProperties","create","options","source","value","commonjs","clear"],"mappings":"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","file":"no-extraneous-dependencies.js","sourcesContent":["import path from 'path';\nimport fs from 'fs';\nimport pkgUp from 'eslint-module-utils/pkgUp';\nimport minimatch from 'minimatch';\nimport resolve from 'eslint-module-utils/resolve';\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor';\nimport importType from '../core/importType';\nimport { getFilePackageName } from '../core/packagePath';\nimport docsUrl from '../docsUrl';\n\nconst depFieldCache = new Map();\n\nfunction hasKeys(obj = {}) {\n  return Object.keys(obj).length > 0;\n}\n\nfunction arrayOrKeys(arrayOrObject) {\n  return Array.isArray(arrayOrObject) ? arrayOrObject : Object.keys(arrayOrObject);\n}\n\nfunction readJSON(jsonPath, throwException) {\n  try {\n    return JSON.parse(fs.readFileSync(jsonPath, 'utf8'));\n  } catch (err) {\n    if (throwException) {\n      throw err;\n    }\n  }\n}\n\nfunction extractDepFields(pkg) {\n  return {\n    dependencies: pkg.dependencies || {},\n    devDependencies: pkg.devDependencies || {},\n    optionalDependencies: pkg.optionalDependencies || {},\n    peerDependencies: pkg.peerDependencies || {},\n    // BundledDeps should be in the form of an array, but object notation is also supported by\n    // `npm`, so we convert it to an array if it is an object\n    bundledDependencies: arrayOrKeys(pkg.bundleDependencies || pkg.bundledDependencies || []),\n  };\n}\n\nfunction getPackageDepFields(packageJsonPath, throwAtRead) {\n  if (!depFieldCache.has(packageJsonPath)) {\n    const depFields = extractDepFields(readJSON(packageJsonPath, throwAtRead));\n    depFieldCache.set(packageJsonPath, depFields);\n  }\n\n  return depFieldCache.get(packageJsonPath);\n}\n\nfunction getDependencies(context, packageDir) {\n  let paths = [];\n  try {\n    const packageContent = {\n      dependencies: {},\n      devDependencies: {},\n      optionalDependencies: {},\n      peerDependencies: {},\n      bundledDependencies: [],\n    };\n\n    if (packageDir && packageDir.length > 0) {\n      if (!Array.isArray(packageDir)) {\n        paths = [path.resolve(packageDir)];\n      } else {\n        paths = packageDir.map((dir) => path.resolve(dir));\n      }\n    }\n\n    if (paths.length > 0) {\n      // use rule config to find package.json\n      paths.forEach((dir) => {\n        const packageJsonPath = path.join(dir, 'package.json');\n        const _packageContent = getPackageDepFields(packageJsonPath, true);\n        Object.keys(packageContent).forEach((depsKey) => {\n          Object.assign(packageContent[depsKey], _packageContent[depsKey]);\n        });\n      });\n    } else {\n      const packageJsonPath = pkgUp({\n        cwd: context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename(),\n        normalize: false,\n      });\n\n      // use closest package.json\n      Object.assign(\n        packageContent,\n        getPackageDepFields(packageJsonPath, false),\n      );\n    }\n\n    if (![\n      packageContent.dependencies,\n      packageContent.devDependencies,\n      packageContent.optionalDependencies,\n      packageContent.peerDependencies,\n      packageContent.bundledDependencies,\n    ].some(hasKeys)) {\n      return null;\n    }\n\n    return packageContent;\n  } catch (e) {\n    if (paths.length > 0 && e.code === 'ENOENT') {\n      context.report({\n        message: 'The package.json file could not be found.',\n        loc: { line: 0, column: 0 },\n      });\n    }\n    if (e.name === 'JSONError' || e instanceof SyntaxError) {\n      context.report({\n        message: `The package.json file could not be parsed: ${e.message}`,\n        loc: { line: 0, column: 0 },\n      });\n    }\n\n    return null;\n  }\n}\n\nfunction missingErrorMessage(packageName) {\n  return `'${packageName}' should be listed in the project's dependencies. Run 'npm i -S ${packageName}' to add it`;\n}\n\nfunction devDepErrorMessage(packageName) {\n  return `'${packageName}' should be listed in the project's dependencies, not devDependencies.`;\n}\n\nfunction optDepErrorMessage(packageName) {\n  return `'${packageName}' should be listed in the project's dependencies, not optionalDependencies.`;\n}\n\nfunction getModuleOriginalName(name) {\n  const [first, second] = name.split('/');\n  return first.startsWith('@') ? `${first}/${second}` : first;\n}\n\nfunction getModuleRealName(resolved) {\n  return getFilePackageName(resolved);\n}\n\nfunction checkDependencyDeclaration(deps, packageName, declarationStatus) {\n  const newDeclarationStatus = declarationStatus || {\n    isInDeps: false,\n    isInDevDeps: false,\n    isInOptDeps: false,\n    isInPeerDeps: false,\n    isInBundledDeps: false,\n  };\n\n  // in case of sub package.json inside a module\n  // check the dependencies on all hierarchy\n  const packageHierarchy = [];\n  const packageNameParts = packageName ? packageName.split('/') : [];\n  packageNameParts.forEach((namePart, index) => {\n    if (!namePart.startsWith('@')) {\n      const ancestor = packageNameParts.slice(0, index + 1).join('/');\n      packageHierarchy.push(ancestor);\n    }\n  });\n\n  return packageHierarchy.reduce((result, ancestorName) => ({\n    isInDeps: result.isInDeps || deps.dependencies[ancestorName] !== undefined,\n    isInDevDeps: result.isInDevDeps || deps.devDependencies[ancestorName] !== undefined,\n    isInOptDeps: result.isInOptDeps || deps.optionalDependencies[ancestorName] !== undefined,\n    isInPeerDeps: result.isInPeerDeps || deps.peerDependencies[ancestorName] !== undefined,\n    isInBundledDeps:\n        result.isInBundledDeps || deps.bundledDependencies.indexOf(ancestorName) !== -1,\n  }), newDeclarationStatus);\n}\n\nfunction reportIfMissing(context, deps, depsOptions, node, name) {\n  // Do not report when importing types unless option is enabled\n  if (\n    !depsOptions.verifyTypeImports\n    && (\n      node.importKind === 'type'\n      || node.importKind === 'typeof'\n      || node.exportKind === 'type'\n      || Array.isArray(node.specifiers) && node.specifiers.length && node.specifiers.every((specifier) => specifier.importKind === 'type' || specifier.importKind === 'typeof')\n    )\n  ) {\n    return;\n  }\n\n  const typeOfImport = importType(name, context);\n\n  if (\n    typeOfImport !== 'external'\n    && (typeOfImport !== 'internal' || !depsOptions.verifyInternalDeps)\n  ) {\n    return;\n  }\n\n  const resolved = resolve(name, context);\n  if (!resolved) { return; }\n\n  const importPackageName = getModuleOriginalName(name);\n  let declarationStatus = checkDependencyDeclaration(deps, importPackageName);\n\n  if (\n    declarationStatus.isInDeps\n    || depsOptions.allowDevDeps && declarationStatus.isInDevDeps\n    || depsOptions.allowPeerDeps && declarationStatus.isInPeerDeps\n    || depsOptions.allowOptDeps && declarationStatus.isInOptDeps\n    || depsOptions.allowBundledDeps && declarationStatus.isInBundledDeps\n  ) {\n    return;\n  }\n\n  // test the real name from the resolved package.json\n  // if not aliased imports (alias/react for example), importPackageName can be misinterpreted\n  const realPackageName = getModuleRealName(resolved);\n  if (realPackageName && realPackageName !== importPackageName) {\n    declarationStatus = checkDependencyDeclaration(deps, realPackageName, declarationStatus);\n\n    if (\n      declarationStatus.isInDeps\n      || depsOptions.allowDevDeps && declarationStatus.isInDevDeps\n      || depsOptions.allowPeerDeps && declarationStatus.isInPeerDeps\n      || depsOptions.allowOptDeps && declarationStatus.isInOptDeps\n      || depsOptions.allowBundledDeps && declarationStatus.isInBundledDeps\n    ) {\n      return;\n    }\n  }\n\n  if (declarationStatus.isInDevDeps && !depsOptions.allowDevDeps) {\n    context.report(node, devDepErrorMessage(realPackageName || importPackageName));\n    return;\n  }\n\n  if (declarationStatus.isInOptDeps && !depsOptions.allowOptDeps) {\n    context.report(node, optDepErrorMessage(realPackageName || importPackageName));\n    return;\n  }\n\n  context.report(node, missingErrorMessage(realPackageName || importPackageName));\n}\n\nfunction testConfig(config, filename) {\n  // Simplest configuration first, either a boolean or nothing.\n  if (typeof config === 'boolean' || typeof config === 'undefined') {\n    return config;\n  }\n  // Array of globs.\n  return config.some((c) => minimatch(filename, c)\n    || minimatch(filename, path.join(process.cwd(), c)),\n  );\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid the use of extraneous packages.',\n      url: docsUrl('no-extraneous-dependencies'),\n    },\n\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          devDependencies: { type: ['boolean', 'array'] },\n          optionalDependencies: { type: ['boolean', 'array'] },\n          peerDependencies: { type: ['boolean', 'array'] },\n          bundledDependencies: { type: ['boolean', 'array'] },\n          packageDir: { type: ['string', 'array'] },\n          includeInternal: { type: ['boolean'] },\n          includeTypes: { type: ['boolean'] },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create(context) {\n    const options = context.options[0] || {};\n    const filename = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n    const deps = getDependencies(context, options.packageDir) || extractDepFields({});\n\n    const depsOptions = {\n      allowDevDeps: testConfig(options.devDependencies, filename) !== false,\n      allowOptDeps: testConfig(options.optionalDependencies, filename) !== false,\n      allowPeerDeps: testConfig(options.peerDependencies, filename) !== false,\n      allowBundledDeps: testConfig(options.bundledDependencies, filename) !== false,\n      verifyInternalDeps: !!options.includeInternal,\n      verifyTypeImports: !!options.includeTypes,\n    };\n\n    return moduleVisitor((source, node) => {\n      reportIfMissing(context, deps, depsOptions, node, source.value);\n    }, { commonjs: true });\n  },\n\n  'Program:exit'() {\n    depFieldCache.clear();\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/no-named-as-default-member.js b/node_modules/eslint-plugin-import/lib/rules/no-named-as-default-member.js index 1f3fa1d0d8..0c15051e02 100644 --- a/node_modules/eslint-plugin-import/lib/rules/no-named-as-default-member.js +++ b/node_modules/eslint-plugin-import/lib/rules/no-named-as-default-member.js @@ -4,7 +4,7 @@ -var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder); +var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap); var _importDeclaration = require('../importDeclaration');var _importDeclaration2 = _interopRequireDefault(_importDeclaration); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };} @@ -36,7 +36,7 @@ module.exports = { return { ImportDefaultSpecifier: function () {function ImportDefaultSpecifier(node) { var declaration = (0, _importDeclaration2['default'])(context); - var exportMap = _builder2['default'].get(declaration.source.value, context); + var exportMap = _ExportMap2['default'].get(declaration.source.value, context); if (exportMap == null) {return;} if (exportMap.errors.length) { @@ -93,4 +93,4 @@ module.exports = { * @copyright 2016 Desmond Brand. All rights reserved. * See LICENSE in root directory for full license. */ -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/no-named-as-default.js b/node_modules/eslint-plugin-import/lib/rules/no-named-as-default.js index 58bbb65799..63378a33a1 100644 --- a/node_modules/eslint-plugin-import/lib/rules/no-named-as-default.js +++ b/node_modules/eslint-plugin-import/lib/rules/no-named-as-default.js @@ -1,4 +1,4 @@ -'use strict';var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder); +'use strict';var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap); var _importDeclaration = require('../importDeclaration');var _importDeclaration2 = _interopRequireDefault(_importDeclaration); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };} @@ -20,7 +20,7 @@ module.exports = { var declaration = (0, _importDeclaration2['default'])(context); - var imports = _builder2['default'].get(declaration.source.value, context); + var imports = _ExportMap2['default'].get(declaration.source.value, context); if (imports == null) {return;} if (imports.errors.length) { @@ -42,4 +42,4 @@ module.exports = { ExportDefaultSpecifier: checkDefault.bind(null, 'exported') }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydWxlcy9uby1uYW1lZC1hcy1kZWZhdWx0LmpzIl0sIm5hbWVzIjpbIm1vZHVsZSIsImV4cG9ydHMiLCJtZXRhIiwidHlwZSIsImRvY3MiLCJjYXRlZ29yeSIsImRlc2NyaXB0aW9uIiwidXJsIiwic2NoZW1hIiwiY3JlYXRlIiwiY29udGV4dCIsImNoZWNrRGVmYXVsdCIsIm5hbWVLZXkiLCJkZWZhdWx0U3BlY2lmaWVyIiwibmFtZSIsImRlY2xhcmF0aW9uIiwiaW1wb3J0cyIsIkV4cG9ydE1hcEJ1aWxkZXIiLCJnZXQiLCJzb3VyY2UiLCJ2YWx1ZSIsImVycm9ycyIsImxlbmd0aCIsInJlcG9ydEVycm9ycyIsImhhcyIsInJlcG9ydCIsIkltcG9ydERlZmF1bHRTcGVjaWZpZXIiLCJiaW5kIiwiRXhwb3J0RGVmYXVsdFNwZWNpZmllciJdLCJtYXBwaW5ncyI6ImFBQUEsK0M7QUFDQSx5RDtBQUNBLHFDOztBQUVBQSxPQUFPQyxPQUFQLEdBQWlCO0FBQ2ZDLFFBQU07QUFDSkMsVUFBTSxTQURGO0FBRUpDLFVBQU07QUFDSkMsZ0JBQVUsa0JBRE47QUFFSkMsbUJBQWEsOERBRlQ7QUFHSkMsV0FBSywwQkFBUSxxQkFBUixDQUhELEVBRkY7O0FBT0pDLFlBQVEsRUFQSixFQURTOzs7QUFXZkMsUUFYZSwrQkFXUkMsT0FYUSxFQVdDO0FBQ2QsZUFBU0MsWUFBVCxDQUFzQkMsT0FBdEIsRUFBK0JDLGdCQUEvQixFQUFpRDtBQUMvQztBQUNBLFlBQUlBLGlCQUFpQkQsT0FBakIsRUFBMEJFLElBQTFCLEtBQW1DLFNBQXZDLEVBQWtELENBQUUsT0FBUzs7QUFFN0QsWUFBTUMsY0FBYyxvQ0FBa0JMLE9BQWxCLENBQXBCOztBQUVBLFlBQU1NLFVBQVVDLHFCQUFpQkMsR0FBakIsQ0FBcUJILFlBQVlJLE1BQVosQ0FBbUJDLEtBQXhDLEVBQStDVixPQUEvQyxDQUFoQjtBQUNBLFlBQUlNLFdBQVcsSUFBZixFQUFxQixDQUFFLE9BQVM7O0FBRWhDLFlBQUlBLFFBQVFLLE1BQVIsQ0FBZUMsTUFBbkIsRUFBMkI7QUFDekJOLGtCQUFRTyxZQUFSLENBQXFCYixPQUFyQixFQUE4QkssV0FBOUI7QUFDQTtBQUNEOztBQUVELFlBQUlDLFFBQVFRLEdBQVIsQ0FBWSxTQUFaLEtBQTBCUixRQUFRUSxHQUFSLENBQVlYLGlCQUFpQkQsT0FBakIsRUFBMEJFLElBQXRDLENBQTlCLEVBQTJFOztBQUV6RUosa0JBQVFlLE1BQVI7QUFDRVosMEJBREY7QUFFMEJBLDJCQUFpQkQsT0FBakIsRUFBMEJFLElBRnBEOzs7QUFLRDtBQUNGO0FBQ0QsYUFBTztBQUNMWSxnQ0FBd0JmLGFBQWFnQixJQUFiLENBQWtCLElBQWxCLEVBQXdCLE9BQXhCLENBRG5CO0FBRUxDLGdDQUF3QmpCLGFBQWFnQixJQUFiLENBQWtCLElBQWxCLEVBQXdCLFVBQXhCLENBRm5CLEVBQVA7O0FBSUQsS0F2Q2MsbUJBQWpCIiwiZmlsZSI6Im5vLW5hbWVkLWFzLWRlZmF1bHQuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgRXhwb3J0TWFwQnVpbGRlciBmcm9tICcuLi9leHBvcnRNYXAvYnVpbGRlcic7XG5pbXBvcnQgaW1wb3J0RGVjbGFyYXRpb24gZnJvbSAnLi4vaW1wb3J0RGVjbGFyYXRpb24nO1xuaW1wb3J0IGRvY3NVcmwgZnJvbSAnLi4vZG9jc1VybCc7XG5cbm1vZHVsZS5leHBvcnRzID0ge1xuICBtZXRhOiB7XG4gICAgdHlwZTogJ3Byb2JsZW0nLFxuICAgIGRvY3M6IHtcbiAgICAgIGNhdGVnb3J5OiAnSGVscGZ1bCB3YXJuaW5ncycsXG4gICAgICBkZXNjcmlwdGlvbjogJ0ZvcmJpZCB1c2Ugb2YgZXhwb3J0ZWQgbmFtZSBhcyBpZGVudGlmaWVyIG9mIGRlZmF1bHQgZXhwb3J0LicsXG4gICAgICB1cmw6IGRvY3NVcmwoJ25vLW5hbWVkLWFzLWRlZmF1bHQnKSxcbiAgICB9LFxuICAgIHNjaGVtYTogW10sXG4gIH0sXG5cbiAgY3JlYXRlKGNvbnRleHQpIHtcbiAgICBmdW5jdGlvbiBjaGVja0RlZmF1bHQobmFtZUtleSwgZGVmYXVsdFNwZWNpZmllcikge1xuICAgICAgLy8gIzU2NjogZGVmYXVsdCBpcyBhIHZhbGlkIHNwZWNpZmllclxuICAgICAgaWYgKGRlZmF1bHRTcGVjaWZpZXJbbmFtZUtleV0ubmFtZSA9PT0gJ2RlZmF1bHQnKSB7IHJldHVybjsgfVxuXG4gICAgICBjb25zdCBkZWNsYXJhdGlvbiA9IGltcG9ydERlY2xhcmF0aW9uKGNvbnRleHQpO1xuXG4gICAgICBjb25zdCBpbXBvcnRzID0gRXhwb3J0TWFwQnVpbGRlci5nZXQoZGVjbGFyYXRpb24uc291cmNlLnZhbHVlLCBjb250ZXh0KTtcbiAgICAgIGlmIChpbXBvcnRzID09IG51bGwpIHsgcmV0dXJuOyB9XG5cbiAgICAgIGlmIChpbXBvcnRzLmVycm9ycy5sZW5ndGgpIHtcbiAgICAgICAgaW1wb3J0cy5yZXBvcnRFcnJvcnMoY29udGV4dCwgZGVjbGFyYXRpb24pO1xuICAgICAgICByZXR1cm47XG4gICAgICB9XG5cbiAgICAgIGlmIChpbXBvcnRzLmhhcygnZGVmYXVsdCcpICYmIGltcG9ydHMuaGFzKGRlZmF1bHRTcGVjaWZpZXJbbmFtZUtleV0ubmFtZSkpIHtcblxuICAgICAgICBjb250ZXh0LnJlcG9ydChcbiAgICAgICAgICBkZWZhdWx0U3BlY2lmaWVyLFxuICAgICAgICAgIGBVc2luZyBleHBvcnRlZCBuYW1lICcke2RlZmF1bHRTcGVjaWZpZXJbbmFtZUtleV0ubmFtZX0nIGFzIGlkZW50aWZpZXIgZm9yIGRlZmF1bHQgZXhwb3J0LmAsXG4gICAgICAgICk7XG5cbiAgICAgIH1cbiAgICB9XG4gICAgcmV0dXJuIHtcbiAgICAgIEltcG9ydERlZmF1bHRTcGVjaWZpZXI6IGNoZWNrRGVmYXVsdC5iaW5kKG51bGwsICdsb2NhbCcpLFxuICAgICAgRXhwb3J0RGVmYXVsdFNwZWNpZmllcjogY2hlY2tEZWZhdWx0LmJpbmQobnVsbCwgJ2V4cG9ydGVkJyksXG4gICAgfTtcbiAgfSxcbn07XG4iXX0= \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/no-namespace.js b/node_modules/eslint-plugin-import/lib/rules/no-namespace.js index 4bd4145245..2b0c783ade 100644 --- a/node_modules/eslint-plugin-import/lib/rules/no-namespace.js +++ b/node_modules/eslint-plugin-import/lib/rules/no-namespace.js @@ -6,78 +6,13 @@ var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };} +//------------------------------------------------------------------------------ +// Rule Definition +//------------------------------------------------------------------------------ /** - * @param {MemberExpression} memberExpression - * @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x` - */ /** - * @fileoverview Rule to disallow namespace import - * @author Radek Benkel - */function getMemberPropertyName(memberExpression) {return memberExpression.property.type === 'Identifier' ? memberExpression.property.name : - memberExpression.property.value; -} - -/** - * @param {ScopeManager} scopeManager - * @param {ASTNode} node - * @return {Set} - */ -function getVariableNamesInScope(scopeManager, node) { - var currentNode = node; - var scope = scopeManager.acquire(currentNode); - while (scope == null) { - currentNode = currentNode.parent; - scope = scopeManager.acquire(currentNode, true); - } - return new Set(scope.variables.concat(scope.upper.variables).map(function (variable) {return variable.name;})); -} - -/** - * - * @param {*} names - * @param {*} nameConflicts - * @param {*} namespaceName - */ -function generateLocalNames(names, nameConflicts, namespaceName) { - var localNames = {}; - names.forEach(function (name) { - var localName = void 0; - if (!nameConflicts[name].has(name)) { - localName = name; - } else if (!nameConflicts[name].has(String(namespaceName) + '_' + String(name))) { - localName = String(namespaceName) + '_' + String(name); - } else { - for (var i = 1; i < Infinity; i++) { - if (!nameConflicts[name].has(String(namespaceName) + '_' + String(name) + '_' + String(i))) { - localName = String(namespaceName) + '_' + String(name) + '_' + String(i); - break; - } - } - } - localNames[name] = localName; - }); - return localNames; -} - -/** - * @param {Identifier[]} namespaceIdentifiers - * @returns {boolean} `true` if the namespace variable is more than just a glorified constant - */ -function usesNamespaceAsObject(namespaceIdentifiers) { - return !namespaceIdentifiers.every(function (identifier) { - var parent = identifier.parent; - - // `namespace.x` or `namespace['x']` - return ( - parent && - parent.type === 'MemberExpression' && ( - parent.property.type === 'Identifier' || parent.property.type === 'Literal')); - - }); -} - -module.exports = { - meta: { - type: 'suggestion', + * @fileoverview Rule to disallow namespace import + * @author Radek Benkel + */module.exports = { meta: { type: 'suggestion', docs: { category: 'Style guide', description: 'Forbid namespace (a.k.a. "wildcard" `*`) imports.', @@ -167,4 +102,74 @@ module.exports = { }return ImportNamespaceSpecifier;}() }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-namespace.js"],"names":["getMemberPropertyName","memberExpression","property","type","name","value","getVariableNamesInScope","scopeManager","node","currentNode","scope","acquire","parent","Set","variables","concat","upper","map","variable","generateLocalNames","names","nameConflicts","namespaceName","localNames","forEach","localName","has","i","Infinity","usesNamespaceAsObject","namespaceIdentifiers","every","identifier","module","exports","meta","docs","category","description","url","fixable","schema","properties","ignore","items","uniqueItems","create","context","firstOption","options","ignoreGlobs","ImportNamespaceSpecifier","find","glob","source","matchBase","scopeVariables","getScope","namespaceVariable","defs","namespaceReferences","references","reference","canFix","length","report","message","fix","fixer","getSourceCode","fixes","importNameConflicts","importName","localConflicts","c","add","importNames","Object","keys","importLocalNames","namedImportSpecifiers","push","replaceText","join"],"mappings":"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","file":"no-namespace.js","sourcesContent":["/**\n * @fileoverview Rule to disallow namespace import\n * @author Radek Benkel\n */\n\nimport minimatch from 'minimatch';\nimport docsUrl from '../docsUrl';\n\n/**\n * @param {MemberExpression} memberExpression\n * @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x`\n */\nfunction getMemberPropertyName(memberExpression) {\n  return memberExpression.property.type === 'Identifier'\n    ? memberExpression.property.name\n    : memberExpression.property.value;\n}\n\n/**\n * @param {ScopeManager} scopeManager\n * @param {ASTNode} node\n * @return {Set<string>}\n */\nfunction getVariableNamesInScope(scopeManager, node) {\n  let currentNode = node;\n  let scope = scopeManager.acquire(currentNode);\n  while (scope == null) {\n    currentNode = currentNode.parent;\n    scope = scopeManager.acquire(currentNode, true);\n  }\n  return new Set(scope.variables.concat(scope.upper.variables).map((variable) => variable.name));\n}\n\n/**\n *\n * @param {*} names\n * @param {*} nameConflicts\n * @param {*} namespaceName\n */\nfunction generateLocalNames(names, nameConflicts, namespaceName) {\n  const localNames = {};\n  names.forEach((name) => {\n    let localName;\n    if (!nameConflicts[name].has(name)) {\n      localName = name;\n    } else if (!nameConflicts[name].has(`${namespaceName}_${name}`)) {\n      localName = `${namespaceName}_${name}`;\n    } else {\n      for (let i = 1; i < Infinity; i++) {\n        if (!nameConflicts[name].has(`${namespaceName}_${name}_${i}`)) {\n          localName = `${namespaceName}_${name}_${i}`;\n          break;\n        }\n      }\n    }\n    localNames[name] = localName;\n  });\n  return localNames;\n}\n\n/**\n * @param {Identifier[]} namespaceIdentifiers\n * @returns {boolean} `true` if the namespace variable is more than just a glorified constant\n */\nfunction usesNamespaceAsObject(namespaceIdentifiers) {\n  return !namespaceIdentifiers.every((identifier) => {\n    const parent = identifier.parent;\n\n    // `namespace.x` or `namespace['x']`\n    return (\n      parent\n      && parent.type === 'MemberExpression'\n      && (parent.property.type === 'Identifier' || parent.property.type === 'Literal')\n    );\n  });\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Forbid namespace (a.k.a. \"wildcard\" `*`) imports.',\n      url: docsUrl('no-namespace'),\n    },\n    fixable: 'code',\n    schema: [{\n      type: 'object',\n      properties: {\n        ignore: {\n          type: 'array',\n          items: {\n            type: 'string',\n          },\n          uniqueItems: true,\n        },\n      },\n    }],\n  },\n\n  create(context) {\n    const firstOption = context.options[0] || {};\n    const ignoreGlobs = firstOption.ignore;\n\n    return {\n      ImportNamespaceSpecifier(node) {\n        if (ignoreGlobs && ignoreGlobs.find((glob) => minimatch(node.parent.source.value, glob, { matchBase: true }))) {\n          return;\n        }\n\n        const scopeVariables = context.getScope().variables;\n        const namespaceVariable = scopeVariables.find((variable) => variable.defs[0].node === node);\n        const namespaceReferences = namespaceVariable.references;\n        const namespaceIdentifiers = namespaceReferences.map((reference) => reference.identifier);\n        const canFix = namespaceIdentifiers.length > 0 && !usesNamespaceAsObject(namespaceIdentifiers);\n\n        context.report({\n          node,\n          message: `Unexpected namespace import.`,\n          fix: canFix && ((fixer) => {\n            const scopeManager = context.getSourceCode().scopeManager;\n            const fixes = [];\n\n            // Pass 1: Collect variable names that are already in scope for each reference we want\n            // to transform, so that we can be sure that we choose non-conflicting import names\n            const importNameConflicts = {};\n            namespaceIdentifiers.forEach((identifier) => {\n              const parent = identifier.parent;\n              if (parent && parent.type === 'MemberExpression') {\n                const importName = getMemberPropertyName(parent);\n                const localConflicts = getVariableNamesInScope(scopeManager, parent);\n                if (!importNameConflicts[importName]) {\n                  importNameConflicts[importName] = localConflicts;\n                } else {\n                  localConflicts.forEach((c) => importNameConflicts[importName].add(c));\n                }\n              }\n            });\n\n            // Choose new names for each import\n            const importNames = Object.keys(importNameConflicts);\n            const importLocalNames = generateLocalNames(\n              importNames,\n              importNameConflicts,\n              namespaceVariable.name,\n            );\n\n            // Replace the ImportNamespaceSpecifier with a list of ImportSpecifiers\n            const namedImportSpecifiers = importNames.map((importName) => importName === importLocalNames[importName]\n              ? importName\n              : `${importName} as ${importLocalNames[importName]}`,\n            );\n            fixes.push(fixer.replaceText(node, `{ ${namedImportSpecifiers.join(', ')} }`));\n\n            // Pass 2: Replace references to the namespace with references to the named imports\n            namespaceIdentifiers.forEach((identifier) => {\n              const parent = identifier.parent;\n              if (parent && parent.type === 'MemberExpression') {\n                const importName = getMemberPropertyName(parent);\n                fixes.push(fixer.replaceText(parent, importLocalNames[importName]));\n              }\n            });\n\n            return fixes;\n          }),\n        });\n      },\n    };\n  },\n};\n"]} \ No newline at end of file + + +/** + * @param {Identifier[]} namespaceIdentifiers + * @returns {boolean} `true` if the namespace variable is more than just a glorified constant + */ +function usesNamespaceAsObject(namespaceIdentifiers) { + return !namespaceIdentifiers.every(function (identifier) { + var parent = identifier.parent; + + // `namespace.x` or `namespace['x']` + return ( + parent && + parent.type === 'MemberExpression' && ( + parent.property.type === 'Identifier' || parent.property.type === 'Literal')); + + }); +} + +/** + * @param {MemberExpression} memberExpression + * @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x` + */ +function getMemberPropertyName(memberExpression) { + return memberExpression.property.type === 'Identifier' ? + memberExpression.property.name : + memberExpression.property.value; +} + +/** + * @param {ScopeManager} scopeManager + * @param {ASTNode} node + * @return {Set} + */ +function getVariableNamesInScope(scopeManager, node) { + var currentNode = node; + var scope = scopeManager.acquire(currentNode); + while (scope == null) { + currentNode = currentNode.parent; + scope = scopeManager.acquire(currentNode, true); + } + return new Set(scope.variables.concat(scope.upper.variables).map(function (variable) {return variable.name;})); +} + +/** + * + * @param {*} names + * @param {*} nameConflicts + * @param {*} namespaceName + */ +function generateLocalNames(names, nameConflicts, namespaceName) { + var localNames = {}; + names.forEach(function (name) { + var localName = void 0; + if (!nameConflicts[name].has(name)) { + localName = name; + } else if (!nameConflicts[name].has(String(namespaceName) + '_' + String(name))) { + localName = String(namespaceName) + '_' + String(name); + } else { + for (var i = 1; i < Infinity; i++) { + if (!nameConflicts[name].has(String(namespaceName) + '_' + String(name) + '_' + String(i))) { + localName = String(namespaceName) + '_' + String(name) + '_' + String(i); + break; + } + } + } + localNames[name] = localName; + }); + return localNames; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-namespace.js"],"names":["module","exports","meta","type","docs","category","description","url","fixable","schema","properties","ignore","items","uniqueItems","create","context","firstOption","options","ignoreGlobs","ImportNamespaceSpecifier","node","find","glob","parent","source","value","matchBase","scopeVariables","getScope","variables","namespaceVariable","variable","defs","namespaceReferences","references","namespaceIdentifiers","map","reference","identifier","canFix","length","usesNamespaceAsObject","report","message","fix","fixer","scopeManager","getSourceCode","fixes","importNameConflicts","forEach","importName","getMemberPropertyName","localConflicts","getVariableNamesInScope","c","add","importNames","Object","keys","importLocalNames","generateLocalNames","name","namedImportSpecifiers","push","replaceText","join","every","property","memberExpression","currentNode","scope","acquire","Set","concat","upper","names","nameConflicts","namespaceName","localNames","localName","has","i","Infinity"],"mappings":"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","file":"no-namespace.js","sourcesContent":["/**\n * @fileoverview Rule to disallow namespace import\n * @author Radek Benkel\n */\n\nimport minimatch from 'minimatch';\nimport docsUrl from '../docsUrl';\n\n//------------------------------------------------------------------------------\n// Rule Definition\n//------------------------------------------------------------------------------\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Forbid namespace (a.k.a. \"wildcard\" `*`) imports.',\n      url: docsUrl('no-namespace'),\n    },\n    fixable: 'code',\n    schema: [{\n      type: 'object',\n      properties: {\n        ignore: {\n          type: 'array',\n          items: {\n            type: 'string',\n          },\n          uniqueItems: true,\n        },\n      },\n    }],\n  },\n\n  create(context) {\n    const firstOption = context.options[0] || {};\n    const ignoreGlobs = firstOption.ignore;\n\n    return {\n      ImportNamespaceSpecifier(node) {\n        if (ignoreGlobs && ignoreGlobs.find((glob) => minimatch(node.parent.source.value, glob, { matchBase: true }))) {\n          return;\n        }\n\n        const scopeVariables = context.getScope().variables;\n        const namespaceVariable = scopeVariables.find((variable) => variable.defs[0].node === node);\n        const namespaceReferences = namespaceVariable.references;\n        const namespaceIdentifiers = namespaceReferences.map((reference) => reference.identifier);\n        const canFix = namespaceIdentifiers.length > 0 && !usesNamespaceAsObject(namespaceIdentifiers);\n\n        context.report({\n          node,\n          message: `Unexpected namespace import.`,\n          fix: canFix && ((fixer) => {\n            const scopeManager = context.getSourceCode().scopeManager;\n            const fixes = [];\n\n            // Pass 1: Collect variable names that are already in scope for each reference we want\n            // to transform, so that we can be sure that we choose non-conflicting import names\n            const importNameConflicts = {};\n            namespaceIdentifiers.forEach((identifier) => {\n              const parent = identifier.parent;\n              if (parent && parent.type === 'MemberExpression') {\n                const importName = getMemberPropertyName(parent);\n                const localConflicts = getVariableNamesInScope(scopeManager, parent);\n                if (!importNameConflicts[importName]) {\n                  importNameConflicts[importName] = localConflicts;\n                } else {\n                  localConflicts.forEach((c) => importNameConflicts[importName].add(c));\n                }\n              }\n            });\n\n            // Choose new names for each import\n            const importNames = Object.keys(importNameConflicts);\n            const importLocalNames = generateLocalNames(\n              importNames,\n              importNameConflicts,\n              namespaceVariable.name,\n            );\n\n            // Replace the ImportNamespaceSpecifier with a list of ImportSpecifiers\n            const namedImportSpecifiers = importNames.map((importName) => importName === importLocalNames[importName]\n              ? importName\n              : `${importName} as ${importLocalNames[importName]}`,\n            );\n            fixes.push(fixer.replaceText(node, `{ ${namedImportSpecifiers.join(', ')} }`));\n\n            // Pass 2: Replace references to the namespace with references to the named imports\n            namespaceIdentifiers.forEach((identifier) => {\n              const parent = identifier.parent;\n              if (parent && parent.type === 'MemberExpression') {\n                const importName = getMemberPropertyName(parent);\n                fixes.push(fixer.replaceText(parent, importLocalNames[importName]));\n              }\n            });\n\n            return fixes;\n          }),\n        });\n      },\n    };\n  },\n};\n\n/**\n * @param {Identifier[]} namespaceIdentifiers\n * @returns {boolean} `true` if the namespace variable is more than just a glorified constant\n */\nfunction usesNamespaceAsObject(namespaceIdentifiers) {\n  return !namespaceIdentifiers.every((identifier) => {\n    const parent = identifier.parent;\n\n    // `namespace.x` or `namespace['x']`\n    return (\n      parent\n      && parent.type === 'MemberExpression'\n      && (parent.property.type === 'Identifier' || parent.property.type === 'Literal')\n    );\n  });\n}\n\n/**\n * @param {MemberExpression} memberExpression\n * @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x`\n */\nfunction getMemberPropertyName(memberExpression) {\n  return memberExpression.property.type === 'Identifier'\n    ? memberExpression.property.name\n    : memberExpression.property.value;\n}\n\n/**\n * @param {ScopeManager} scopeManager\n * @param {ASTNode} node\n * @return {Set<string>}\n */\nfunction getVariableNamesInScope(scopeManager, node) {\n  let currentNode = node;\n  let scope = scopeManager.acquire(currentNode);\n  while (scope == null) {\n    currentNode = currentNode.parent;\n    scope = scopeManager.acquire(currentNode, true);\n  }\n  return new Set(scope.variables.concat(scope.upper.variables).map((variable) => variable.name));\n}\n\n/**\n *\n * @param {*} names\n * @param {*} nameConflicts\n * @param {*} namespaceName\n */\nfunction generateLocalNames(names, nameConflicts, namespaceName) {\n  const localNames = {};\n  names.forEach((name) => {\n    let localName;\n    if (!nameConflicts[name].has(name)) {\n      localName = name;\n    } else if (!nameConflicts[name].has(`${namespaceName}_${name}`)) {\n      localName = `${namespaceName}_${name}`;\n    } else {\n      for (let i = 1; i < Infinity; i++) {\n        if (!nameConflicts[name].has(`${namespaceName}_${name}_${i}`)) {\n          localName = `${namespaceName}_${name}_${i}`;\n          break;\n        }\n      }\n    }\n    localNames[name] = localName;\n  });\n  return localNames;\n}\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/no-restricted-paths.js b/node_modules/eslint-plugin-import/lib/rules/no-restricted-paths.js index b75cff0d02..e0c9a5c894 100644 --- a/node_modules/eslint-plugin-import/lib/rules/no-restricted-paths.js +++ b/node_modules/eslint-plugin-import/lib/rules/no-restricted-paths.js @@ -12,15 +12,6 @@ var containsPath = function containsPath(filepath, target) { return relative === '' || !relative.startsWith('..'); }; -function isMatchingTargetPath(filename, targetPath) { - if ((0, _isGlob2['default'])(targetPath)) { - var mm = new _minimatch.Minimatch(targetPath); - return mm.match(filename); - } - - return containsPath(filename, targetPath); -} - module.exports = { meta: { type: 'problem', @@ -92,6 +83,15 @@ module.exports = { some(function (targetPath) {return isMatchingTargetPath(currentFilename, targetPath);});}); + function isMatchingTargetPath(filename, targetPath) { + if ((0, _isGlob2['default'])(targetPath)) { + var mm = new _minimatch.Minimatch(targetPath); + return mm.match(filename); + } + + return containsPath(filename, targetPath); + } + function isValidExceptionPath(absoluteFromPath, absoluteExceptionPath) { var relativeExceptionPath = _path2['default'].relative(absoluteFromPath, absoluteExceptionPath); @@ -242,4 +242,4 @@ module.exports = { checkForRestrictedImportPath(source.value, source); }, { commonjs: true }); }return noRestrictedPaths;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-restricted-paths.js"],"names":["containsPath","filepath","target","relative","path","startsWith","isMatchingTargetPath","filename","targetPath","mm","Minimatch","match","module","exports","meta","type","docs","category","description","url","schema","properties","zones","minItems","items","anyOf","uniqueItems","minLength","from","except","message","additionalProperties","basePath","create","noRestrictedPaths","context","options","restrictedPaths","process","cwd","currentFilename","getPhysicalFilename","getFilename","matchingZones","filter","zone","concat","map","resolve","some","isValidExceptionPath","absoluteFromPath","absoluteExceptionPath","relativeExceptionPath","areBothGlobPatternAndAbsolutePath","areGlobPatterns","isGlob","reportInvalidExceptionPath","node","report","reportInvalidExceptionMixedGlobAndNonGlob","reportInvalidExceptionGlob","computeMixedGlobAndAbsolutePathValidator","isPathRestricted","hasValidExceptions","reportInvalidException","computeGlobPatternPathValidator","absoluteFrom","zoneExcept","isPathException","absoluteImportPath","every","exceptionsMm","computeAbsolutePathValidator","absoluteExceptionPaths","exceptionPath","reportInvalidExceptions","validators","forEach","validator","reportImportsInRestrictedZone","importPath","customMessage","data","makePathValidators","zoneFrom","allZoneFrom","isGlobPattern","singleZoneFrom","checkForRestrictedImportPath","index","applicableValidatorsForImportPath","validatorsWithInvalidExceptions","applicableValidatorsForImportPathExcludingExceptions","source","value","commonjs"],"mappings":"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","file":"no-restricted-paths.js","sourcesContent":["import path from 'path';\n\nimport resolve from 'eslint-module-utils/resolve';\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor';\nimport isGlob from 'is-glob';\nimport { Minimatch } from 'minimatch';\nimport docsUrl from '../docsUrl';\nimport importType from '../core/importType';\n\nconst containsPath = (filepath, target) => {\n  const relative = path.relative(target, filepath);\n  return relative === '' || !relative.startsWith('..');\n};\n\nfunction isMatchingTargetPath(filename, targetPath) {\n  if (isGlob(targetPath)) {\n    const mm = new Minimatch(targetPath);\n    return mm.match(filename);\n  }\n\n  return containsPath(filename, targetPath);\n}\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Static analysis',\n      description: 'Enforce which files can be imported in a given folder.',\n      url: docsUrl('no-restricted-paths'),\n    },\n\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          zones: {\n            type: 'array',\n            minItems: 1,\n            items: {\n              type: 'object',\n              properties: {\n                target: {\n                  anyOf: [\n                    { type: 'string' },\n                    {\n                      type: 'array',\n                      items: { type: 'string' },\n                      uniqueItems: true,\n                      minLength: 1,\n                    },\n                  ],\n                },\n                from: {\n                  anyOf: [\n                    { type: 'string' },\n                    {\n                      type: 'array',\n                      items: { type: 'string' },\n                      uniqueItems: true,\n                      minLength: 1,\n                    },\n                  ],\n                },\n                except: {\n                  type: 'array',\n                  items: {\n                    type: 'string',\n                  },\n                  uniqueItems: true,\n                },\n                message: { type: 'string' },\n              },\n              additionalProperties: false,\n            },\n          },\n          basePath: { type: 'string' },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create: function noRestrictedPaths(context) {\n    const options = context.options[0] || {};\n    const restrictedPaths = options.zones || [];\n    const basePath = options.basePath || process.cwd();\n    const currentFilename = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n    const matchingZones = restrictedPaths.filter(\n      (zone) => [].concat(zone.target)\n        .map((target) => path.resolve(basePath, target))\n        .some((targetPath) => isMatchingTargetPath(currentFilename, targetPath)),\n    );\n\n    function isValidExceptionPath(absoluteFromPath, absoluteExceptionPath) {\n      const relativeExceptionPath = path.relative(absoluteFromPath, absoluteExceptionPath);\n\n      return importType(relativeExceptionPath, context) !== 'parent';\n    }\n\n    function areBothGlobPatternAndAbsolutePath(areGlobPatterns) {\n      return areGlobPatterns.some((isGlob) => isGlob) && areGlobPatterns.some((isGlob) => !isGlob);\n    }\n\n    function reportInvalidExceptionPath(node) {\n      context.report({\n        node,\n        message: 'Restricted path exceptions must be descendants of the configured `from` path for that zone.',\n      });\n    }\n\n    function reportInvalidExceptionMixedGlobAndNonGlob(node) {\n      context.report({\n        node,\n        message: 'Restricted path `from` must contain either only glob patterns or none',\n      });\n    }\n\n    function reportInvalidExceptionGlob(node) {\n      context.report({\n        node,\n        message: 'Restricted path exceptions must be glob patterns when `from` contains glob patterns',\n      });\n    }\n\n    function computeMixedGlobAndAbsolutePathValidator() {\n      return {\n        isPathRestricted: () => true,\n        hasValidExceptions: false,\n        reportInvalidException: reportInvalidExceptionMixedGlobAndNonGlob,\n      };\n    }\n\n    function computeGlobPatternPathValidator(absoluteFrom, zoneExcept) {\n      let isPathException;\n\n      const mm = new Minimatch(absoluteFrom);\n      const isPathRestricted = (absoluteImportPath) => mm.match(absoluteImportPath);\n      const hasValidExceptions = zoneExcept.every(isGlob);\n\n      if (hasValidExceptions) {\n        const exceptionsMm = zoneExcept.map((except) => new Minimatch(except));\n        isPathException = (absoluteImportPath) => exceptionsMm.some((mm) => mm.match(absoluteImportPath));\n      }\n\n      const reportInvalidException = reportInvalidExceptionGlob;\n\n      return {\n        isPathRestricted,\n        hasValidExceptions,\n        isPathException,\n        reportInvalidException,\n      };\n    }\n\n    function computeAbsolutePathValidator(absoluteFrom, zoneExcept) {\n      let isPathException;\n\n      const isPathRestricted = (absoluteImportPath) => containsPath(absoluteImportPath, absoluteFrom);\n\n      const absoluteExceptionPaths = zoneExcept\n        .map((exceptionPath) => path.resolve(absoluteFrom, exceptionPath));\n      const hasValidExceptions = absoluteExceptionPaths\n        .every((absoluteExceptionPath) => isValidExceptionPath(absoluteFrom, absoluteExceptionPath));\n\n      if (hasValidExceptions) {\n        isPathException = (absoluteImportPath) => absoluteExceptionPaths.some(\n          (absoluteExceptionPath) => containsPath(absoluteImportPath, absoluteExceptionPath),\n        );\n      }\n\n      const reportInvalidException = reportInvalidExceptionPath;\n\n      return {\n        isPathRestricted,\n        hasValidExceptions,\n        isPathException,\n        reportInvalidException,\n      };\n    }\n\n    function reportInvalidExceptions(validators, node) {\n      validators.forEach((validator) => validator.reportInvalidException(node));\n    }\n\n    function reportImportsInRestrictedZone(validators, node, importPath, customMessage) {\n      validators.forEach(() => {\n        context.report({\n          node,\n          message: `Unexpected path \"{{importPath}}\" imported in restricted zone.${customMessage ? ` ${customMessage}` : ''}`,\n          data: { importPath },\n        });\n      });\n    }\n\n    const makePathValidators = (zoneFrom, zoneExcept = []) => {\n      const allZoneFrom = [].concat(zoneFrom);\n      const areGlobPatterns = allZoneFrom.map(isGlob);\n\n      if (areBothGlobPatternAndAbsolutePath(areGlobPatterns)) {\n        return [computeMixedGlobAndAbsolutePathValidator()];\n      }\n\n      const isGlobPattern = areGlobPatterns.every((isGlob) => isGlob);\n\n      return allZoneFrom.map((singleZoneFrom) => {\n        const absoluteFrom = path.resolve(basePath, singleZoneFrom);\n\n        if (isGlobPattern) {\n          return computeGlobPatternPathValidator(absoluteFrom, zoneExcept);\n        }\n        return computeAbsolutePathValidator(absoluteFrom, zoneExcept);\n      });\n    };\n\n    const validators = [];\n\n    function checkForRestrictedImportPath(importPath, node) {\n      const absoluteImportPath = resolve(importPath, context);\n\n      if (!absoluteImportPath) {\n        return;\n      }\n\n      matchingZones.forEach((zone, index) => {\n        if (!validators[index]) {\n          validators[index] = makePathValidators(zone.from, zone.except);\n        }\n\n        const applicableValidatorsForImportPath = validators[index].filter((validator) => validator.isPathRestricted(absoluteImportPath));\n\n        const validatorsWithInvalidExceptions = applicableValidatorsForImportPath.filter((validator) => !validator.hasValidExceptions);\n        reportInvalidExceptions(validatorsWithInvalidExceptions, node);\n\n        const applicableValidatorsForImportPathExcludingExceptions = applicableValidatorsForImportPath\n          .filter((validator) => validator.hasValidExceptions && !validator.isPathException(absoluteImportPath));\n        reportImportsInRestrictedZone(applicableValidatorsForImportPathExcludingExceptions, node, importPath, zone.message);\n      });\n    }\n\n    return moduleVisitor((source) => {\n      checkForRestrictedImportPath(source.value, source);\n    }, { commonjs: true });\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-restricted-paths.js"],"names":["containsPath","filepath","target","relative","path","startsWith","module","exports","meta","type","docs","category","description","url","schema","properties","zones","minItems","items","anyOf","uniqueItems","minLength","from","except","message","additionalProperties","basePath","create","noRestrictedPaths","context","options","restrictedPaths","process","cwd","currentFilename","getPhysicalFilename","getFilename","matchingZones","filter","zone","concat","map","resolve","some","targetPath","isMatchingTargetPath","filename","mm","Minimatch","match","isValidExceptionPath","absoluteFromPath","absoluteExceptionPath","relativeExceptionPath","areBothGlobPatternAndAbsolutePath","areGlobPatterns","isGlob","reportInvalidExceptionPath","node","report","reportInvalidExceptionMixedGlobAndNonGlob","reportInvalidExceptionGlob","computeMixedGlobAndAbsolutePathValidator","isPathRestricted","hasValidExceptions","reportInvalidException","computeGlobPatternPathValidator","absoluteFrom","zoneExcept","isPathException","absoluteImportPath","every","exceptionsMm","computeAbsolutePathValidator","absoluteExceptionPaths","exceptionPath","reportInvalidExceptions","validators","forEach","validator","reportImportsInRestrictedZone","importPath","customMessage","data","makePathValidators","zoneFrom","allZoneFrom","isGlobPattern","singleZoneFrom","checkForRestrictedImportPath","index","applicableValidatorsForImportPath","validatorsWithInvalidExceptions","applicableValidatorsForImportPathExcludingExceptions","source","value","commonjs"],"mappings":"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","file":"no-restricted-paths.js","sourcesContent":["import path from 'path';\n\nimport resolve from 'eslint-module-utils/resolve';\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor';\nimport isGlob from 'is-glob';\nimport { Minimatch } from 'minimatch';\nimport docsUrl from '../docsUrl';\nimport importType from '../core/importType';\n\nconst containsPath = (filepath, target) => {\n  const relative = path.relative(target, filepath);\n  return relative === '' || !relative.startsWith('..');\n};\n\nmodule.exports = {\n  meta: {\n    type: 'problem',\n    docs: {\n      category: 'Static analysis',\n      description: 'Enforce which files can be imported in a given folder.',\n      url: docsUrl('no-restricted-paths'),\n    },\n\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          zones: {\n            type: 'array',\n            minItems: 1,\n            items: {\n              type: 'object',\n              properties: {\n                target: {\n                  anyOf: [\n                    { type: 'string' },\n                    {\n                      type: 'array',\n                      items: { type: 'string' },\n                      uniqueItems: true,\n                      minLength: 1,\n                    },\n                  ],\n                },\n                from: {\n                  anyOf: [\n                    { type: 'string' },\n                    {\n                      type: 'array',\n                      items: { type: 'string' },\n                      uniqueItems: true,\n                      minLength: 1,\n                    },\n                  ],\n                },\n                except: {\n                  type: 'array',\n                  items: {\n                    type: 'string',\n                  },\n                  uniqueItems: true,\n                },\n                message: { type: 'string' },\n              },\n              additionalProperties: false,\n            },\n          },\n          basePath: { type: 'string' },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create: function noRestrictedPaths(context) {\n    const options = context.options[0] || {};\n    const restrictedPaths = options.zones || [];\n    const basePath = options.basePath || process.cwd();\n    const currentFilename = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n    const matchingZones = restrictedPaths.filter(\n      (zone) => [].concat(zone.target)\n        .map((target) => path.resolve(basePath, target))\n        .some((targetPath) => isMatchingTargetPath(currentFilename, targetPath)),\n    );\n\n    function isMatchingTargetPath(filename, targetPath) {\n      if (isGlob(targetPath)) {\n        const mm = new Minimatch(targetPath);\n        return mm.match(filename);\n      }\n\n      return containsPath(filename, targetPath);\n    }\n\n    function isValidExceptionPath(absoluteFromPath, absoluteExceptionPath) {\n      const relativeExceptionPath = path.relative(absoluteFromPath, absoluteExceptionPath);\n\n      return importType(relativeExceptionPath, context) !== 'parent';\n    }\n\n    function areBothGlobPatternAndAbsolutePath(areGlobPatterns) {\n      return areGlobPatterns.some((isGlob) => isGlob) && areGlobPatterns.some((isGlob) => !isGlob);\n    }\n\n    function reportInvalidExceptionPath(node) {\n      context.report({\n        node,\n        message: 'Restricted path exceptions must be descendants of the configured `from` path for that zone.',\n      });\n    }\n\n    function reportInvalidExceptionMixedGlobAndNonGlob(node) {\n      context.report({\n        node,\n        message: 'Restricted path `from` must contain either only glob patterns or none',\n      });\n    }\n\n    function reportInvalidExceptionGlob(node) {\n      context.report({\n        node,\n        message: 'Restricted path exceptions must be glob patterns when `from` contains glob patterns',\n      });\n    }\n\n    function computeMixedGlobAndAbsolutePathValidator() {\n      return {\n        isPathRestricted: () => true,\n        hasValidExceptions: false,\n        reportInvalidException: reportInvalidExceptionMixedGlobAndNonGlob,\n      };\n    }\n\n    function computeGlobPatternPathValidator(absoluteFrom, zoneExcept) {\n      let isPathException;\n\n      const mm = new Minimatch(absoluteFrom);\n      const isPathRestricted = (absoluteImportPath) => mm.match(absoluteImportPath);\n      const hasValidExceptions = zoneExcept.every(isGlob);\n\n      if (hasValidExceptions) {\n        const exceptionsMm = zoneExcept.map((except) => new Minimatch(except));\n        isPathException = (absoluteImportPath) => exceptionsMm.some((mm) => mm.match(absoluteImportPath));\n      }\n\n      const reportInvalidException = reportInvalidExceptionGlob;\n\n      return {\n        isPathRestricted,\n        hasValidExceptions,\n        isPathException,\n        reportInvalidException,\n      };\n    }\n\n    function computeAbsolutePathValidator(absoluteFrom, zoneExcept) {\n      let isPathException;\n\n      const isPathRestricted = (absoluteImportPath) => containsPath(absoluteImportPath, absoluteFrom);\n\n      const absoluteExceptionPaths = zoneExcept\n        .map((exceptionPath) => path.resolve(absoluteFrom, exceptionPath));\n      const hasValidExceptions = absoluteExceptionPaths\n        .every((absoluteExceptionPath) => isValidExceptionPath(absoluteFrom, absoluteExceptionPath));\n\n      if (hasValidExceptions) {\n        isPathException = (absoluteImportPath) => absoluteExceptionPaths.some(\n          (absoluteExceptionPath) => containsPath(absoluteImportPath, absoluteExceptionPath),\n        );\n      }\n\n      const reportInvalidException = reportInvalidExceptionPath;\n\n      return {\n        isPathRestricted,\n        hasValidExceptions,\n        isPathException,\n        reportInvalidException,\n      };\n    }\n\n    function reportInvalidExceptions(validators, node) {\n      validators.forEach((validator) => validator.reportInvalidException(node));\n    }\n\n    function reportImportsInRestrictedZone(validators, node, importPath, customMessage) {\n      validators.forEach(() => {\n        context.report({\n          node,\n          message: `Unexpected path \"{{importPath}}\" imported in restricted zone.${customMessage ? ` ${customMessage}` : ''}`,\n          data: { importPath },\n        });\n      });\n    }\n\n    const makePathValidators = (zoneFrom, zoneExcept = []) => {\n      const allZoneFrom = [].concat(zoneFrom);\n      const areGlobPatterns = allZoneFrom.map(isGlob);\n\n      if (areBothGlobPatternAndAbsolutePath(areGlobPatterns)) {\n        return [computeMixedGlobAndAbsolutePathValidator()];\n      }\n\n      const isGlobPattern = areGlobPatterns.every((isGlob) => isGlob);\n\n      return allZoneFrom.map((singleZoneFrom) => {\n        const absoluteFrom = path.resolve(basePath, singleZoneFrom);\n\n        if (isGlobPattern) {\n          return computeGlobPatternPathValidator(absoluteFrom, zoneExcept);\n        }\n        return computeAbsolutePathValidator(absoluteFrom, zoneExcept);\n      });\n    };\n\n    const validators = [];\n\n    function checkForRestrictedImportPath(importPath, node) {\n      const absoluteImportPath = resolve(importPath, context);\n\n      if (!absoluteImportPath) {\n        return;\n      }\n\n      matchingZones.forEach((zone, index) => {\n        if (!validators[index]) {\n          validators[index] = makePathValidators(zone.from, zone.except);\n        }\n\n        const applicableValidatorsForImportPath = validators[index].filter((validator) => validator.isPathRestricted(absoluteImportPath));\n\n        const validatorsWithInvalidExceptions = applicableValidatorsForImportPath.filter((validator) => !validator.hasValidExceptions);\n        reportInvalidExceptions(validatorsWithInvalidExceptions, node);\n\n        const applicableValidatorsForImportPathExcludingExceptions = applicableValidatorsForImportPath\n          .filter((validator) => validator.hasValidExceptions && !validator.isPathException(absoluteImportPath));\n        reportImportsInRestrictedZone(applicableValidatorsForImportPathExcludingExceptions, node, importPath, zone.message);\n      });\n    }\n\n    return moduleVisitor((source) => {\n      checkForRestrictedImportPath(source.value, source);\n    }, { commonjs: true });\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/no-unused-modules.js b/node_modules/eslint-plugin-import/lib/rules/no-unused-modules.js index 4347b2c4a0..f6f6348b16 100644 --- a/node_modules/eslint-plugin-import/lib/rules/no-unused-modules.js +++ b/node_modules/eslint-plugin-import/lib/rules/no-unused-modules.js @@ -13,171 +13,54 @@ var _object = require('object.values');var _object2 = _interopRequireDefault(_ob var _arrayIncludes = require('array-includes');var _arrayIncludes2 = _interopRequireDefault(_arrayIncludes); var _arrayPrototype = require('array.prototype.flatmap');var _arrayPrototype2 = _interopRequireDefault(_arrayPrototype); -var _fsWalk = require('../core/fsWalk'); -var _builder = require('../exportMap/builder');var _builder2 = _interopRequireDefault(_builder); -var _patternCapture = require('../exportMap/patternCapture');var _patternCapture2 = _interopRequireDefault(_patternCapture); +var _ExportMap = require('../ExportMap');var _ExportMap2 = _interopRequireDefault(_ExportMap); var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _toConsumableArray(arr) {if (Array.isArray(arr)) {for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {arr2[i] = arr[i];}return arr2;} else {return Array.from(arr);}} /** * @fileOverview Ensures that modules contain exports and/or all * modules are consumed within other modules. * @author René Fermann - */ /** - * Attempt to load the internal `FileEnumerator` class, which has existed in a couple - * of different places, depending on the version of `eslint`. Try requiring it from both - * locations. - * @returns Returns the `FileEnumerator` class if its requirable, otherwise `undefined`. - */function requireFileEnumerator() {var FileEnumerator = void 0; - - // Try getting it from the eslint private / deprecated api - try {var _require = - require('eslint/use-at-your-own-risk');FileEnumerator = _require.FileEnumerator; - } catch (e) { - // Absorb this if it's MODULE_NOT_FOUND - if (e.code !== 'MODULE_NOT_FOUND') { - throw e; - } - - // If not there, then try getting it from eslint/lib/cli-engine/file-enumerator (moved there in v6) - try {var _require2 = - require('eslint/lib/cli-engine/file-enumerator');FileEnumerator = _require2.FileEnumerator; - } catch (e) { - // Absorb this if it's MODULE_NOT_FOUND - if (e.code !== 'MODULE_NOT_FOUND') { - throw e; - } + */var FileEnumerator = void 0;var listFilesToProcess = void 0; +try {var _require = + require('eslint/use-at-your-own-risk');FileEnumerator = _require.FileEnumerator; +} catch (e) { + try {var _require2 = + + require('eslint/lib/cli-engine/file-enumerator'); // has been moved to eslint/lib/cli-engine/file-enumerator in version 6 + FileEnumerator = _require2.FileEnumerator;} catch (e) { + try { + // eslint/lib/util/glob-util has been moved to eslint/lib/util/glob-utils with version 5.3 + var _require3 = require('eslint/lib/util/glob-utils'),originalListFilesToProcess = _require3.listFilesToProcess; + + // Prevent passing invalid options (extensions array) to old versions of the function. + // https://github.com/eslint/eslint/blob/v5.16.0/lib/util/glob-utils.js#L178-L280 + // https://github.com/eslint/eslint/blob/v5.2.0/lib/util/glob-util.js#L174-L269 + listFilesToProcess = function listFilesToProcess(src, extensions) { + return originalListFilesToProcess(src, { + extensions: extensions }); + + }; + } catch (e) {var _require4 = + require('eslint/lib/util/glob-util'),_originalListFilesToProcess = _require4.listFilesToProcess; + + listFilesToProcess = function listFilesToProcess(src, extensions) { + var patterns = src.concat((0, _arrayPrototype2['default'])(src, function (pattern) {return extensions.map(function (extension) {return (/\*\*|\*\./.test(pattern) ? pattern : String(pattern) + '/**/*' + String(extension));});})); + + return _originalListFilesToProcess(patterns); + }; } } - return FileEnumerator; } -/** - * - * @param FileEnumerator the `FileEnumerator` class from `eslint`'s internal api - * @param {string} src path to the src root - * @param {string[]} extensions list of supported extensions - * @returns {{ filename: string, ignored: boolean }[]} list of files to operate on - */ -function listFilesUsingFileEnumerator(FileEnumerator, src, extensions) { - var e = new FileEnumerator({ - extensions: extensions }); - - - return Array.from( - e.iterateFiles(src), - function (_ref) {var filePath = _ref.filePath,ignored = _ref.ignored;return { filename: filePath, ignored: ignored };}); - -} - -/** - * Attempt to require old versions of the file enumeration capability from v6 `eslint` and earlier, and use - * those functions to provide the list of files to operate on - * @param {string} src path to the src root - * @param {string[]} extensions list of supported extensions - * @returns {string[]} list of files to operate on - */ -function listFilesWithLegacyFunctions(src, extensions) { - try { - // eslint/lib/util/glob-util has been moved to eslint/lib/util/glob-utils with version 5.3 - var _require3 = require('eslint/lib/util/glob-utils'),originalListFilesToProcess = _require3.listFilesToProcess; - // Prevent passing invalid options (extensions array) to old versions of the function. - // https://github.com/eslint/eslint/blob/v5.16.0/lib/util/glob-utils.js#L178-L280 - // https://github.com/eslint/eslint/blob/v5.2.0/lib/util/glob-util.js#L174-L269 - - return originalListFilesToProcess(src, { +if (FileEnumerator) { + listFilesToProcess = function listFilesToProcess(src, extensions) { + var e = new FileEnumerator({ extensions: extensions }); - } catch (e) { - // Absorb this if it's MODULE_NOT_FOUND - if (e.code !== 'MODULE_NOT_FOUND') { - throw e; - } - - // Last place to try (pre v5.3) - var _require4 = - - require('eslint/lib/util/glob-util'),_originalListFilesToProcess = _require4.listFilesToProcess; - var patterns = src.concat( - (0, _arrayPrototype2['default'])( - src, - function (pattern) {return extensions.map(function (extension) {return (/\*\*|\*\./.test(pattern) ? pattern : String(pattern) + '/**/*' + String(extension));});})); - - - - return _originalListFilesToProcess(patterns); - } -} - -/** - * Given a source root and list of supported extensions, use fsWalk and the - * new `eslint` `context.session` api to build the list of files we want to operate on - * @param {string[]} srcPaths array of source paths (for flat config this should just be a singular root (e.g. cwd)) - * @param {string[]} extensions list of supported extensions - * @param {{ isDirectoryIgnored: (path: string) => boolean, isFileIgnored: (path: string) => boolean }} session eslint context session object - * @returns {string[]} list of files to operate on - */ -function listFilesWithModernApi(srcPaths, extensions, session) { - /** @type {string[]} */ - var files = [];var _loop = function _loop( - - i) { - var src = srcPaths[i]; - // Use walkSync along with the new session api to gather the list of files - var entries = (0, _fsWalk.walkSync)(src, { - deepFilter: function () {function deepFilter(entry) { - var fullEntryPath = (0, _path.resolve)(src, entry.path); - - // Include the directory if it's not marked as ignore by eslint - return !session.isDirectoryIgnored(fullEntryPath); - }return deepFilter;}(), - entryFilter: function () {function entryFilter(entry) { - var fullEntryPath = (0, _path.resolve)(src, entry.path); - - // Include the file if it's not marked as ignore by eslint and its extension is included in our list - return ( - !session.isFileIgnored(fullEntryPath) && - extensions.find(function (extension) {return entry.path.endsWith(extension);})); - - }return entryFilter;}() }); - - // Filter out directories and map entries to their paths - files.push.apply(files, _toConsumableArray( - entries. - filter(function (entry) {return !entry.dirent.isDirectory();}). - map(function (entry) {return entry.path;})));};for (var i = 0; i < srcPaths.length; i++) {_loop(i); + return Array.from(e.iterateFiles(src), function (_ref) {var filePath = _ref.filePath,ignored = _ref.ignored;return { + ignored: ignored, + filename: filePath };}); - } - return files; -} - -/** - * Given a src pattern and list of supported extensions, return a list of files to process - * with this rule. - * @param {string} src - file, directory, or glob pattern of files to act on - * @param {string[]} extensions - list of supported file extensions - * @param {import('eslint').Rule.RuleContext} context - the eslint context object - * @returns {string[] | { filename: string, ignored: boolean }[]} the list of files that this rule will evaluate. - */ -function listFilesToProcess(src, extensions, context) { - // If the context object has the new session functions, then prefer those - // Otherwise, fallback to using the deprecated `FileEnumerator` for legacy support. - // https://github.com/eslint/eslint/issues/18087 - if ( - context.session && - context.session.isFileIgnored && - context.session.isDirectoryIgnored) - { - return listFilesWithModernApi(src, extensions, context.session); - } - - // Fallback to og FileEnumerator - var FileEnumerator = requireFileEnumerator(); - - // If we got the FileEnumerator, then let's go with that - if (FileEnumerator) { - return listFilesUsingFileEnumerator(FileEnumerator, src, extensions); - } - // If not, then we can try even older versions of this capability (listFilesToProcess) - return listFilesWithLegacyFunctions(src, extensions); + }; } var EXPORT_DEFAULT_DECLARATION = 'ExportDefaultDeclaration'; @@ -199,30 +82,28 @@ var DEFAULT = 'default'; function forEachDeclarationIdentifier(declaration, cb) { if (declaration) { - var isTypeDeclaration = declaration.type === TS_INTERFACE_DECLARATION || - declaration.type === TS_TYPE_ALIAS_DECLARATION || - declaration.type === TS_ENUM_DECLARATION; - if ( declaration.type === FUNCTION_DECLARATION || declaration.type === CLASS_DECLARATION || - isTypeDeclaration) + declaration.type === TS_INTERFACE_DECLARATION || + declaration.type === TS_TYPE_ALIAS_DECLARATION || + declaration.type === TS_ENUM_DECLARATION) { - cb(declaration.id.name, isTypeDeclaration); + cb(declaration.id.name); } else if (declaration.type === VARIABLE_DECLARATION) { declaration.declarations.forEach(function (_ref2) {var id = _ref2.id; if (id.type === OBJECT_PATTERN) { - (0, _patternCapture2['default'])(id, function (pattern) { + (0, _ExportMap.recursivePatternCapture)(id, function (pattern) { if (pattern.type === IDENTIFIER) { - cb(pattern.name, false); + cb(pattern.name); } }); } else if (id.type === ARRAY_PATTERN) { id.elements.forEach(function (_ref3) {var name = _ref3.name; - cb(name, false); + cb(name); }); } else { - cb(id.name, false); + cb(id.name); } }); } @@ -279,7 +160,6 @@ var exportList = new Map(); var visitorKeyMap = new Map(); -/** @type {Set} */ var ignoredFiles = new Set(); var filesOutsideSrc = new Set(); @@ -289,40 +169,32 @@ var isNodeModule = function isNodeModule(path) {return (/\/(node_modules)\//.tes * read all files matching the patterns in src and ignoreExports * * return all files matching src pattern, which are not matching the ignoreExports pattern - * @type {(src: string, ignoreExports: string, context: import('eslint').Rule.RuleContext) => Set} */ -function resolveFiles(src, ignoreExports, context) { +var resolveFiles = function resolveFiles(src, ignoreExports, context) { var extensions = Array.from((0, _ignore.getFileExtensions)(context.settings)); - var srcFileList = listFilesToProcess(src, extensions, context); + var srcFileList = listFilesToProcess(src, extensions); // prepare list of ignored files - var ignoredFilesList = listFilesToProcess(ignoreExports, extensions, context); - - // The modern api will return a list of file paths, rather than an object - if (ignoredFilesList.length && typeof ignoredFilesList[0] === 'string') { - ignoredFilesList.forEach(function (filename) {return ignoredFiles.add(filename);}); - } else { - ignoredFilesList.forEach(function (_ref4) {var filename = _ref4.filename;return ignoredFiles.add(filename);}); - } + var ignoredFilesList = listFilesToProcess(ignoreExports, extensions); + ignoredFilesList.forEach(function (_ref4) {var filename = _ref4.filename;return ignoredFiles.add(filename);}); // prepare list of source files, don't consider files from node_modules - var resolvedFiles = srcFileList.length && typeof srcFileList[0] === 'string' ? - srcFileList.filter(function (filePath) {return !isNodeModule(filePath);}) : - (0, _arrayPrototype2['default'])(srcFileList, function (_ref5) {var filename = _ref5.filename;return isNodeModule(filename) ? [] : filename;}); - return new Set(resolvedFiles); -} + return new Set( + (0, _arrayPrototype2['default'])(srcFileList, function (_ref5) {var filename = _ref5.filename;return isNodeModule(filename) ? [] : filename;})); + +}; /** - * parse all source files and build up 2 maps containing the existing imports and exports - */ + * parse all source files and build up 2 maps containing the existing imports and exports + */ var prepareImportsAndExports = function prepareImportsAndExports(srcFiles, context) { var exportAll = new Map(); srcFiles.forEach(function (file) { var exports = new Map(); var imports = new Map(); - var currentExports = _builder2['default'].get(file, context); + var currentExports = _ExportMap2['default'].get(file, context); if (currentExports) {var dependencies = @@ -454,7 +326,6 @@ var getSrc = function getSrc(src) { * prepare the lists of existing imports and exports - should only be executed once at * the start of a new eslint run */ -/** @type {Set} */ var srcFiles = void 0; var lastPrepareKey = void 0; var doPreparation = function doPreparation(src, ignoreExports, context) { @@ -569,10 +440,6 @@ module.exports = { unusedExports: { description: 'report exports without any usage', - type: 'boolean' }, - - ignoreUnusedTypeExports: { - description: 'ignore type exports without any usage', type: 'boolean' } }, @@ -602,8 +469,7 @@ module.exports = { - - context.options[0] || {},src = _ref9.src,_ref9$ignoreExports = _ref9.ignoreExports,ignoreExports = _ref9$ignoreExports === undefined ? [] : _ref9$ignoreExports,missingExports = _ref9.missingExports,unusedExports = _ref9.unusedExports,ignoreUnusedTypeExports = _ref9.ignoreUnusedTypeExports; + context.options[0] || {},src = _ref9.src,_ref9$ignoreExports = _ref9.ignoreExports,ignoreExports = _ref9$ignoreExports === undefined ? [] : _ref9$ignoreExports,missingExports = _ref9.missingExports,unusedExports = _ref9.unusedExports; if (unusedExports) { doPreparation(src, ignoreExports, context); @@ -635,15 +501,11 @@ module.exports = { exportCount.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports); }return checkExportPresence;}(); - var checkUsage = function () {function checkUsage(node, exportedValue, isTypeExport) { + var checkUsage = function () {function checkUsage(node, exportedValue) { if (!unusedExports) { return; } - if (isTypeExport && ignoreUnusedTypeExports) { - return; - } - if (ignoredFiles.has(file)) { return; } @@ -667,10 +529,6 @@ module.exports = { exports = exportList.get(file); - if (!exports) { - console.error('file `' + String(file) + '` has no exports. Please update to the latest, and if it still happens, report this on https://github.com/import-js/eslint-plugin-import/issues/2866!'); - } - // special case: export * from var exportAll = exports.get(EXPORT_ALL_DECLARATION); if (typeof exportAll !== 'undefined' && exportedValue !== IMPORT_DEFAULT_SPECIFIER) { @@ -1072,16 +930,16 @@ module.exports = { checkExportPresence(node); }return ProgramExit;}(), ExportDefaultDeclaration: function () {function ExportDefaultDeclaration(node) { - checkUsage(node, IMPORT_DEFAULT_SPECIFIER, false); + checkUsage(node, IMPORT_DEFAULT_SPECIFIER); }return ExportDefaultDeclaration;}(), ExportNamedDeclaration: function () {function ExportNamedDeclaration(node) { node.specifiers.forEach(function (specifier) { - checkUsage(specifier, specifier.exported.name || specifier.exported.value, false); + checkUsage(specifier, specifier.exported.name || specifier.exported.value); }); - forEachDeclarationIdentifier(node.declaration, function (name, isTypeExport) { - checkUsage(node, name, isTypeExport); + forEachDeclarationIdentifier(node.declaration, function (name) { + checkUsage(node, name); }); }return ExportNamedDeclaration;}() }; }return create;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-unused-modules.js"],"names":["requireFileEnumerator","FileEnumerator","require","e","code","listFilesUsingFileEnumerator","src","extensions","Array","from","iterateFiles","filePath","ignored","filename","listFilesWithLegacyFunctions","originalListFilesToProcess","listFilesToProcess","patterns","concat","pattern","map","extension","test","listFilesWithModernApi","srcPaths","session","files","i","entries","deepFilter","entry","fullEntryPath","path","isDirectoryIgnored","entryFilter","isFileIgnored","find","endsWith","push","filter","dirent","isDirectory","length","context","EXPORT_DEFAULT_DECLARATION","EXPORT_NAMED_DECLARATION","EXPORT_ALL_DECLARATION","IMPORT_DECLARATION","IMPORT_NAMESPACE_SPECIFIER","IMPORT_DEFAULT_SPECIFIER","VARIABLE_DECLARATION","FUNCTION_DECLARATION","CLASS_DECLARATION","IDENTIFIER","OBJECT_PATTERN","ARRAY_PATTERN","TS_INTERFACE_DECLARATION","TS_TYPE_ALIAS_DECLARATION","TS_ENUM_DECLARATION","DEFAULT","forEachDeclarationIdentifier","declaration","cb","isTypeDeclaration","type","id","name","declarations","forEach","elements","importList","Map","exportList","visitorKeyMap","ignoredFiles","Set","filesOutsideSrc","isNodeModule","resolveFiles","ignoreExports","settings","srcFileList","ignoredFilesList","add","resolvedFiles","prepareImportsAndExports","srcFiles","exportAll","file","exports","imports","currentExports","ExportMapBuilder","get","dependencies","reexports","localImportList","namespace","visitorKeys","set","currentExportAll","getDependency","dependency","value","key","whereUsed","reexport","getImport","localImport","currentValue","local","importedSpecifiers","specifier","has","val","currentExport","determineUsage","listValue","listKey","currentImport","exportStatement","getSrc","process","cwd","lastPrepareKey","doPreparation","prepareKey","JSON","stringify","sort","clear","newNamespaceImportExists","specifiers","some","newDefaultImportExists","fileIsInPkg","pkg","basePath","checkPkgFieldString","pkgField","checkPkgFieldObject","pkgFieldFiles","checkPkgField","bin","browser","main","module","meta","docs","category","description","url","schema","properties","uniqueItems","items","minLength","missingExports","unusedExports","ignoreUnusedTypeExports","anyOf","minItems","required","create","options","getPhysicalFilename","getFilename","checkExportPresence","node","exportCount","namespaceImports","size","report","body","checkUsage","exportedValue","isTypeExport","console","error","exportsKey","updateExportUsage","newExports","newExportIdentifiers","exported","updateImportUsage","oldImportPaths","oldNamespaceImports","newNamespaceImports","oldExportAll","newExportAll","oldDefaultImports","newDefaultImports","oldImports","newImports","processDynamicImport","source","p","ImportExpression","child","CallExpression","callee","arguments","astNode","resolvedPath","raw","replace","imported","ExportDefaultDeclaration","ExportNamedDeclaration"],"mappings":"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","file":"no-unused-modules.js","sourcesContent":["/**\n * @fileOverview Ensures that modules contain exports and/or all\n * modules are consumed within other modules.\n * @author René Fermann\n */\n\nimport { getFileExtensions } from 'eslint-module-utils/ignore';\nimport resolve from 'eslint-module-utils/resolve';\nimport visit from 'eslint-module-utils/visit';\nimport { dirname, join, resolve as resolvePath } from 'path';\nimport readPkgUp from 'eslint-module-utils/readPkgUp';\nimport values from 'object.values';\nimport includes from 'array-includes';\nimport flatMap from 'array.prototype.flatmap';\n\nimport { walkSync } from '../core/fsWalk';\nimport ExportMapBuilder from '../exportMap/builder';\nimport recursivePatternCapture from '../exportMap/patternCapture';\nimport docsUrl from '../docsUrl';\n\n/**\n * Attempt to load the internal `FileEnumerator` class, which has existed in a couple\n * of different places, depending on the version of `eslint`.  Try requiring it from both\n * locations.\n * @returns Returns the `FileEnumerator` class if its requirable, otherwise `undefined`.\n */\nfunction requireFileEnumerator() {\n  let FileEnumerator;\n\n  // Try getting it from the eslint private / deprecated api\n  try {\n    ({ FileEnumerator } = require('eslint/use-at-your-own-risk'));\n  } catch (e) {\n    // Absorb this if it's MODULE_NOT_FOUND\n    if (e.code !== 'MODULE_NOT_FOUND') {\n      throw e;\n    }\n\n    // If not there, then try getting it from eslint/lib/cli-engine/file-enumerator (moved there in v6)\n    try {\n      ({ FileEnumerator } = require('eslint/lib/cli-engine/file-enumerator'));\n    } catch (e) {\n      // Absorb this if it's MODULE_NOT_FOUND\n      if (e.code !== 'MODULE_NOT_FOUND') {\n        throw e;\n      }\n    }\n  }\n  return FileEnumerator;\n}\n\n/**\n *\n * @param FileEnumerator the `FileEnumerator` class from `eslint`'s internal api\n * @param {string} src path to the src root\n * @param {string[]} extensions list of supported extensions\n * @returns {{ filename: string, ignored: boolean }[]} list of files to operate on\n */\nfunction listFilesUsingFileEnumerator(FileEnumerator, src, extensions) {\n  const e = new FileEnumerator({\n    extensions,\n  });\n\n  return Array.from(\n    e.iterateFiles(src),\n    ({ filePath, ignored }) => ({ filename: filePath, ignored }),\n  );\n}\n\n/**\n * Attempt to require old versions of the file enumeration capability from v6 `eslint` and earlier, and use\n * those functions to provide the list of files to operate on\n * @param {string} src path to the src root\n * @param {string[]} extensions list of supported extensions\n * @returns {string[]} list of files to operate on\n */\nfunction listFilesWithLegacyFunctions(src, extensions) {\n  try {\n    // eslint/lib/util/glob-util has been moved to eslint/lib/util/glob-utils with version 5.3\n    const { listFilesToProcess: originalListFilesToProcess } = require('eslint/lib/util/glob-utils');\n    // Prevent passing invalid options (extensions array) to old versions of the function.\n    // https://github.com/eslint/eslint/blob/v5.16.0/lib/util/glob-utils.js#L178-L280\n    // https://github.com/eslint/eslint/blob/v5.2.0/lib/util/glob-util.js#L174-L269\n\n    return originalListFilesToProcess(src, {\n      extensions,\n    });\n  } catch (e) {\n    // Absorb this if it's MODULE_NOT_FOUND\n    if (e.code !== 'MODULE_NOT_FOUND') {\n      throw e;\n    }\n\n    // Last place to try (pre v5.3)\n    const {\n      listFilesToProcess: originalListFilesToProcess,\n    } = require('eslint/lib/util/glob-util');\n    const patterns = src.concat(\n      flatMap(\n        src,\n        (pattern) => extensions.map((extension) => (/\\*\\*|\\*\\./).test(pattern) ? pattern : `${pattern}/**/*${extension}`),\n      ),\n    );\n\n    return originalListFilesToProcess(patterns);\n  }\n}\n\n/**\n * Given a source root and list of supported extensions, use fsWalk and the\n * new `eslint` `context.session` api to build the list of files we want to operate on\n * @param {string[]} srcPaths array of source paths (for flat config this should just be a singular root (e.g. cwd))\n * @param {string[]} extensions list of supported extensions\n * @param {{ isDirectoryIgnored: (path: string) => boolean, isFileIgnored: (path: string) => boolean }} session eslint context session object\n * @returns {string[]} list of files to operate on\n */\nfunction listFilesWithModernApi(srcPaths, extensions, session) {\n  /** @type {string[]} */\n  const files = [];\n\n  for (let i = 0; i < srcPaths.length; i++) {\n    const src = srcPaths[i];\n    // Use walkSync along with the new session api to gather the list of files\n    const entries = walkSync(src, {\n      deepFilter(entry) {\n        const fullEntryPath = resolvePath(src, entry.path);\n\n        // Include the directory if it's not marked as ignore by eslint\n        return !session.isDirectoryIgnored(fullEntryPath);\n      },\n      entryFilter(entry) {\n        const fullEntryPath = resolvePath(src, entry.path);\n\n        // Include the file if it's not marked as ignore by eslint and its extension is included in our list\n        return (\n          !session.isFileIgnored(fullEntryPath)\n          && extensions.find((extension) => entry.path.endsWith(extension))\n        );\n      },\n    });\n\n    // Filter out directories and map entries to their paths\n    files.push(\n      ...entries\n        .filter((entry) => !entry.dirent.isDirectory())\n        .map((entry) => entry.path),\n    );\n  }\n  return files;\n}\n\n/**\n * Given a src pattern and list of supported extensions, return a list of files to process\n * with this rule.\n * @param {string} src - file, directory, or glob pattern of files to act on\n * @param {string[]} extensions - list of supported file extensions\n * @param {import('eslint').Rule.RuleContext} context - the eslint context object\n * @returns {string[] | { filename: string, ignored: boolean }[]} the list of files that this rule will evaluate.\n */\nfunction listFilesToProcess(src, extensions, context) {\n  // If the context object has the new session functions, then prefer those\n  // Otherwise, fallback to using the deprecated `FileEnumerator` for legacy support.\n  // https://github.com/eslint/eslint/issues/18087\n  if (\n    context.session\n    && context.session.isFileIgnored\n    && context.session.isDirectoryIgnored\n  ) {\n    return listFilesWithModernApi(src, extensions, context.session);\n  }\n\n  // Fallback to og FileEnumerator\n  const FileEnumerator = requireFileEnumerator();\n\n  // If we got the FileEnumerator, then let's go with that\n  if (FileEnumerator) {\n    return listFilesUsingFileEnumerator(FileEnumerator, src, extensions);\n  }\n  // If not, then we can try even older versions of this capability (listFilesToProcess)\n  return listFilesWithLegacyFunctions(src, extensions);\n}\n\nconst EXPORT_DEFAULT_DECLARATION = 'ExportDefaultDeclaration';\nconst EXPORT_NAMED_DECLARATION = 'ExportNamedDeclaration';\nconst EXPORT_ALL_DECLARATION = 'ExportAllDeclaration';\nconst IMPORT_DECLARATION = 'ImportDeclaration';\nconst IMPORT_NAMESPACE_SPECIFIER = 'ImportNamespaceSpecifier';\nconst IMPORT_DEFAULT_SPECIFIER = 'ImportDefaultSpecifier';\nconst VARIABLE_DECLARATION = 'VariableDeclaration';\nconst FUNCTION_DECLARATION = 'FunctionDeclaration';\nconst CLASS_DECLARATION = 'ClassDeclaration';\nconst IDENTIFIER = 'Identifier';\nconst OBJECT_PATTERN = 'ObjectPattern';\nconst ARRAY_PATTERN = 'ArrayPattern';\nconst TS_INTERFACE_DECLARATION = 'TSInterfaceDeclaration';\nconst TS_TYPE_ALIAS_DECLARATION = 'TSTypeAliasDeclaration';\nconst TS_ENUM_DECLARATION = 'TSEnumDeclaration';\nconst DEFAULT = 'default';\n\nfunction forEachDeclarationIdentifier(declaration, cb) {\n  if (declaration) {\n    const isTypeDeclaration = declaration.type === TS_INTERFACE_DECLARATION\n      || declaration.type === TS_TYPE_ALIAS_DECLARATION\n      || declaration.type === TS_ENUM_DECLARATION;\n\n    if (\n      declaration.type === FUNCTION_DECLARATION\n      || declaration.type === CLASS_DECLARATION\n      || isTypeDeclaration\n    ) {\n      cb(declaration.id.name, isTypeDeclaration);\n    } else if (declaration.type === VARIABLE_DECLARATION) {\n      declaration.declarations.forEach(({ id }) => {\n        if (id.type === OBJECT_PATTERN) {\n          recursivePatternCapture(id, (pattern) => {\n            if (pattern.type === IDENTIFIER) {\n              cb(pattern.name, false);\n            }\n          });\n        } else if (id.type === ARRAY_PATTERN) {\n          id.elements.forEach(({ name }) => {\n            cb(name, false);\n          });\n        } else {\n          cb(id.name, false);\n        }\n      });\n    }\n  }\n}\n\n/**\n * List of imports per file.\n *\n * Represented by a two-level Map to a Set of identifiers. The upper-level Map\n * keys are the paths to the modules containing the imports, while the\n * lower-level Map keys are the paths to the files which are being imported\n * from. Lastly, the Set of identifiers contains either names being imported\n * or a special AST node name listed above (e.g ImportDefaultSpecifier).\n *\n * For example, if we have a file named foo.js containing:\n *\n *   import { o2 } from './bar.js';\n *\n * Then we will have a structure that looks like:\n *\n *   Map { 'foo.js' => Map { 'bar.js' => Set { 'o2' } } }\n *\n * @type {Map<string, Map<string, Set<string>>>}\n */\nconst importList = new Map();\n\n/**\n * List of exports per file.\n *\n * Represented by a two-level Map to an object of metadata. The upper-level Map\n * keys are the paths to the modules containing the exports, while the\n * lower-level Map keys are the specific identifiers or special AST node names\n * being exported. The leaf-level metadata object at the moment only contains a\n * `whereUsed` property, which contains a Set of paths to modules that import\n * the name.\n *\n * For example, if we have a file named bar.js containing the following exports:\n *\n *   const o2 = 'bar';\n *   export { o2 };\n *\n * And a file named foo.js containing the following import:\n *\n *   import { o2 } from './bar.js';\n *\n * Then we will have a structure that looks like:\n *\n *   Map { 'bar.js' => Map { 'o2' => { whereUsed: Set { 'foo.js' } } } }\n *\n * @type {Map<string, Map<string, object>>}\n */\nconst exportList = new Map();\n\nconst visitorKeyMap = new Map();\n\n/** @type {Set<string>} */\nconst ignoredFiles = new Set();\nconst filesOutsideSrc = new Set();\n\nconst isNodeModule = (path) => (/\\/(node_modules)\\//).test(path);\n\n/**\n * read all files matching the patterns in src and ignoreExports\n *\n * return all files matching src pattern, which are not matching the ignoreExports pattern\n * @type {(src: string, ignoreExports: string, context: import('eslint').Rule.RuleContext) => Set<string>}\n */\nfunction resolveFiles(src, ignoreExports, context) {\n  const extensions = Array.from(getFileExtensions(context.settings));\n\n  const srcFileList = listFilesToProcess(src, extensions, context);\n\n  // prepare list of ignored files\n  const ignoredFilesList = listFilesToProcess(ignoreExports, extensions, context);\n\n  // The modern api will return a list of file paths, rather than an object\n  if (ignoredFilesList.length && typeof ignoredFilesList[0] === 'string') {\n    ignoredFilesList.forEach((filename) => ignoredFiles.add(filename));\n  } else {\n    ignoredFilesList.forEach(({ filename }) => ignoredFiles.add(filename));\n  }\n\n  // prepare list of source files, don't consider files from node_modules\n  const resolvedFiles = srcFileList.length && typeof srcFileList[0] === 'string'\n    ? srcFileList.filter((filePath) => !isNodeModule(filePath))\n    : flatMap(srcFileList, ({ filename }) => isNodeModule(filename) ? [] : filename);\n\n  return new Set(resolvedFiles);\n}\n\n/**\n * parse all source files and build up 2 maps containing the existing imports and exports\n */\nconst prepareImportsAndExports = (srcFiles, context) => {\n  const exportAll = new Map();\n  srcFiles.forEach((file) => {\n    const exports = new Map();\n    const imports = new Map();\n    const currentExports = ExportMapBuilder.get(file, context);\n    if (currentExports) {\n      const {\n        dependencies,\n        reexports,\n        imports: localImportList,\n        namespace,\n        visitorKeys,\n      } = currentExports;\n\n      visitorKeyMap.set(file, visitorKeys);\n      // dependencies === export * from\n      const currentExportAll = new Set();\n      dependencies.forEach((getDependency) => {\n        const dependency = getDependency();\n        if (dependency === null) {\n          return;\n        }\n\n        currentExportAll.add(dependency.path);\n      });\n      exportAll.set(file, currentExportAll);\n\n      reexports.forEach((value, key) => {\n        if (key === DEFAULT) {\n          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() });\n        } else {\n          exports.set(key, { whereUsed: new Set() });\n        }\n        const reexport = value.getImport();\n        if (!reexport) {\n          return;\n        }\n        let localImport = imports.get(reexport.path);\n        let currentValue;\n        if (value.local === DEFAULT) {\n          currentValue = IMPORT_DEFAULT_SPECIFIER;\n        } else {\n          currentValue = value.local;\n        }\n        if (typeof localImport !== 'undefined') {\n          localImport = new Set([...localImport, currentValue]);\n        } else {\n          localImport = new Set([currentValue]);\n        }\n        imports.set(reexport.path, localImport);\n      });\n\n      localImportList.forEach((value, key) => {\n        if (isNodeModule(key)) {\n          return;\n        }\n        const localImport = imports.get(key) || new Set();\n        value.declarations.forEach(({ importedSpecifiers }) => {\n          importedSpecifiers.forEach((specifier) => {\n            localImport.add(specifier);\n          });\n        });\n        imports.set(key, localImport);\n      });\n      importList.set(file, imports);\n\n      // build up export list only, if file is not ignored\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n      namespace.forEach((value, key) => {\n        if (key === DEFAULT) {\n          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() });\n        } else {\n          exports.set(key, { whereUsed: new Set() });\n        }\n      });\n    }\n    exports.set(EXPORT_ALL_DECLARATION, { whereUsed: new Set() });\n    exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed: new Set() });\n    exportList.set(file, exports);\n  });\n  exportAll.forEach((value, key) => {\n    value.forEach((val) => {\n      const currentExports = exportList.get(val);\n      if (currentExports) {\n        const currentExport = currentExports.get(EXPORT_ALL_DECLARATION);\n        currentExport.whereUsed.add(key);\n      }\n    });\n  });\n};\n\n/**\n * traverse through all imports and add the respective path to the whereUsed-list\n * of the corresponding export\n */\nconst determineUsage = () => {\n  importList.forEach((listValue, listKey) => {\n    listValue.forEach((value, key) => {\n      const exports = exportList.get(key);\n      if (typeof exports !== 'undefined') {\n        value.forEach((currentImport) => {\n          let specifier;\n          if (currentImport === IMPORT_NAMESPACE_SPECIFIER) {\n            specifier = IMPORT_NAMESPACE_SPECIFIER;\n          } else if (currentImport === IMPORT_DEFAULT_SPECIFIER) {\n            specifier = IMPORT_DEFAULT_SPECIFIER;\n          } else {\n            specifier = currentImport;\n          }\n          if (typeof specifier !== 'undefined') {\n            const exportStatement = exports.get(specifier);\n            if (typeof exportStatement !== 'undefined') {\n              const { whereUsed } = exportStatement;\n              whereUsed.add(listKey);\n              exports.set(specifier, { whereUsed });\n            }\n          }\n        });\n      }\n    });\n  });\n};\n\nconst getSrc = (src) => {\n  if (src) {\n    return src;\n  }\n  return [process.cwd()];\n};\n\n/**\n * prepare the lists of existing imports and exports - should only be executed once at\n * the start of a new eslint run\n */\n/** @type {Set<string>} */\nlet srcFiles;\nlet lastPrepareKey;\nconst doPreparation = (src, ignoreExports, context) => {\n  const prepareKey = JSON.stringify({\n    src: (src || []).sort(),\n    ignoreExports: (ignoreExports || []).sort(),\n    extensions: Array.from(getFileExtensions(context.settings)).sort(),\n  });\n  if (prepareKey === lastPrepareKey) {\n    return;\n  }\n\n  importList.clear();\n  exportList.clear();\n  ignoredFiles.clear();\n  filesOutsideSrc.clear();\n\n  srcFiles = resolveFiles(getSrc(src), ignoreExports, context);\n  prepareImportsAndExports(srcFiles, context);\n  determineUsage();\n  lastPrepareKey = prepareKey;\n};\n\nconst newNamespaceImportExists = (specifiers) => specifiers.some(({ type }) => type === IMPORT_NAMESPACE_SPECIFIER);\n\nconst newDefaultImportExists = (specifiers) => specifiers.some(({ type }) => type === IMPORT_DEFAULT_SPECIFIER);\n\nconst fileIsInPkg = (file) => {\n  const { path, pkg } = readPkgUp({ cwd: file });\n  const basePath = dirname(path);\n\n  const checkPkgFieldString = (pkgField) => {\n    if (join(basePath, pkgField) === file) {\n      return true;\n    }\n  };\n\n  const checkPkgFieldObject = (pkgField) => {\n    const pkgFieldFiles = flatMap(values(pkgField), (value) => typeof value === 'boolean' ? [] : join(basePath, value));\n\n    if (includes(pkgFieldFiles, file)) {\n      return true;\n    }\n  };\n\n  const checkPkgField = (pkgField) => {\n    if (typeof pkgField === 'string') {\n      return checkPkgFieldString(pkgField);\n    }\n\n    if (typeof pkgField === 'object') {\n      return checkPkgFieldObject(pkgField);\n    }\n  };\n\n  if (pkg.private === true) {\n    return false;\n  }\n\n  if (pkg.bin) {\n    if (checkPkgField(pkg.bin)) {\n      return true;\n    }\n  }\n\n  if (pkg.browser) {\n    if (checkPkgField(pkg.browser)) {\n      return true;\n    }\n  }\n\n  if (pkg.main) {\n    if (checkPkgFieldString(pkg.main)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid modules without exports, or exports without matching import in another module.',\n      url: docsUrl('no-unused-modules'),\n    },\n    schema: [{\n      properties: {\n        src: {\n          description: 'files/paths to be analyzed (only for unused exports)',\n          type: 'array',\n          uniqueItems: true,\n          items: {\n            type: 'string',\n            minLength: 1,\n          },\n        },\n        ignoreExports: {\n          description: 'files/paths for which unused exports will not be reported (e.g module entry points)',\n          type: 'array',\n          uniqueItems: true,\n          items: {\n            type: 'string',\n            minLength: 1,\n          },\n        },\n        missingExports: {\n          description: 'report modules without any exports',\n          type: 'boolean',\n        },\n        unusedExports: {\n          description: 'report exports without any usage',\n          type: 'boolean',\n        },\n        ignoreUnusedTypeExports: {\n          description: 'ignore type exports without any usage',\n          type: 'boolean',\n        },\n      },\n      anyOf: [\n        {\n          properties: {\n            unusedExports: { enum: [true] },\n            src: {\n              minItems: 1,\n            },\n          },\n          required: ['unusedExports'],\n        },\n        {\n          properties: {\n            missingExports: { enum: [true] },\n          },\n          required: ['missingExports'],\n        },\n      ],\n    }],\n  },\n\n  create(context) {\n    const {\n      src,\n      ignoreExports = [],\n      missingExports,\n      unusedExports,\n      ignoreUnusedTypeExports,\n    } = context.options[0] || {};\n\n    if (unusedExports) {\n      doPreparation(src, ignoreExports, context);\n    }\n\n    const file = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n\n    const checkExportPresence = (node) => {\n      if (!missingExports) {\n        return;\n      }\n\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n\n      const exportCount = exportList.get(file);\n      const exportAll = exportCount.get(EXPORT_ALL_DECLARATION);\n      const namespaceImports = exportCount.get(IMPORT_NAMESPACE_SPECIFIER);\n\n      exportCount.delete(EXPORT_ALL_DECLARATION);\n      exportCount.delete(IMPORT_NAMESPACE_SPECIFIER);\n      if (exportCount.size < 1) {\n        // node.body[0] === 'undefined' only happens, if everything is commented out in the file\n        // being linted\n        context.report(node.body[0] ? node.body[0] : node, 'No exports found');\n      }\n      exportCount.set(EXPORT_ALL_DECLARATION, exportAll);\n      exportCount.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports);\n    };\n\n    const checkUsage = (node, exportedValue, isTypeExport) => {\n      if (!unusedExports) {\n        return;\n      }\n\n      if (isTypeExport && ignoreUnusedTypeExports) {\n        return;\n      }\n\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n\n      if (fileIsInPkg(file)) {\n        return;\n      }\n\n      if (filesOutsideSrc.has(file)) {\n        return;\n      }\n\n      // make sure file to be linted is included in source files\n      if (!srcFiles.has(file)) {\n        srcFiles = resolveFiles(getSrc(src), ignoreExports, context);\n        if (!srcFiles.has(file)) {\n          filesOutsideSrc.add(file);\n          return;\n        }\n      }\n\n      exports = exportList.get(file);\n\n      if (!exports) {\n        console.error(`file \\`${file}\\` has no exports. Please update to the latest, and if it still happens, report this on https://github.com/import-js/eslint-plugin-import/issues/2866!`);\n      }\n\n      // special case: export * from\n      const exportAll = exports.get(EXPORT_ALL_DECLARATION);\n      if (typeof exportAll !== 'undefined' && exportedValue !== IMPORT_DEFAULT_SPECIFIER) {\n        if (exportAll.whereUsed.size > 0) {\n          return;\n        }\n      }\n\n      // special case: namespace import\n      const namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n      if (typeof namespaceImports !== 'undefined') {\n        if (namespaceImports.whereUsed.size > 0) {\n          return;\n        }\n      }\n\n      // exportsList will always map any imported value of 'default' to 'ImportDefaultSpecifier'\n      const exportsKey = exportedValue === DEFAULT ? IMPORT_DEFAULT_SPECIFIER : exportedValue;\n\n      const exportStatement = exports.get(exportsKey);\n\n      const value = exportsKey === IMPORT_DEFAULT_SPECIFIER ? DEFAULT : exportsKey;\n\n      if (typeof exportStatement !== 'undefined') {\n        if (exportStatement.whereUsed.size < 1) {\n          context.report(\n            node,\n            `exported declaration '${value}' not used within other modules`,\n          );\n        }\n      } else {\n        context.report(\n          node,\n          `exported declaration '${value}' not used within other modules`,\n        );\n      }\n    };\n\n    /**\n     * only useful for tools like vscode-eslint\n     *\n     * update lists of existing exports during runtime\n     */\n    const updateExportUsage = (node) => {\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n\n      let exports = exportList.get(file);\n\n      // new module has been created during runtime\n      // include it in further processing\n      if (typeof exports === 'undefined') {\n        exports = new Map();\n      }\n\n      const newExports = new Map();\n      const newExportIdentifiers = new Set();\n\n      node.body.forEach(({ type, declaration, specifiers }) => {\n        if (type === EXPORT_DEFAULT_DECLARATION) {\n          newExportIdentifiers.add(IMPORT_DEFAULT_SPECIFIER);\n        }\n        if (type === EXPORT_NAMED_DECLARATION) {\n          if (specifiers.length > 0) {\n            specifiers.forEach((specifier) => {\n              if (specifier.exported) {\n                newExportIdentifiers.add(specifier.exported.name || specifier.exported.value);\n              }\n            });\n          }\n          forEachDeclarationIdentifier(declaration, (name) => {\n            newExportIdentifiers.add(name);\n          });\n        }\n      });\n\n      // old exports exist within list of new exports identifiers: add to map of new exports\n      exports.forEach((value, key) => {\n        if (newExportIdentifiers.has(key)) {\n          newExports.set(key, value);\n        }\n      });\n\n      // new export identifiers added: add to map of new exports\n      newExportIdentifiers.forEach((key) => {\n        if (!exports.has(key)) {\n          newExports.set(key, { whereUsed: new Set() });\n        }\n      });\n\n      // preserve information about namespace imports\n      const exportAll = exports.get(EXPORT_ALL_DECLARATION);\n      let namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n\n      if (typeof namespaceImports === 'undefined') {\n        namespaceImports = { whereUsed: new Set() };\n      }\n\n      newExports.set(EXPORT_ALL_DECLARATION, exportAll);\n      newExports.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports);\n      exportList.set(file, newExports);\n    };\n\n    /**\n     * only useful for tools like vscode-eslint\n     *\n     * update lists of existing imports during runtime\n     */\n    const updateImportUsage = (node) => {\n      if (!unusedExports) {\n        return;\n      }\n\n      let oldImportPaths = importList.get(file);\n      if (typeof oldImportPaths === 'undefined') {\n        oldImportPaths = new Map();\n      }\n\n      const oldNamespaceImports = new Set();\n      const newNamespaceImports = new Set();\n\n      const oldExportAll = new Set();\n      const newExportAll = new Set();\n\n      const oldDefaultImports = new Set();\n      const newDefaultImports = new Set();\n\n      const oldImports = new Map();\n      const newImports = new Map();\n      oldImportPaths.forEach((value, key) => {\n        if (value.has(EXPORT_ALL_DECLARATION)) {\n          oldExportAll.add(key);\n        }\n        if (value.has(IMPORT_NAMESPACE_SPECIFIER)) {\n          oldNamespaceImports.add(key);\n        }\n        if (value.has(IMPORT_DEFAULT_SPECIFIER)) {\n          oldDefaultImports.add(key);\n        }\n        value.forEach((val) => {\n          if (\n            val !== IMPORT_NAMESPACE_SPECIFIER\n            && val !== IMPORT_DEFAULT_SPECIFIER\n          ) {\n            oldImports.set(val, key);\n          }\n        });\n      });\n\n      function processDynamicImport(source) {\n        if (source.type !== 'Literal') {\n          return null;\n        }\n        const p = resolve(source.value, context);\n        if (p == null) {\n          return null;\n        }\n        newNamespaceImports.add(p);\n      }\n\n      visit(node, visitorKeyMap.get(file), {\n        ImportExpression(child) {\n          processDynamicImport(child.source);\n        },\n        CallExpression(child) {\n          if (child.callee.type === 'Import') {\n            processDynamicImport(child.arguments[0]);\n          }\n        },\n      });\n\n      node.body.forEach((astNode) => {\n        let resolvedPath;\n\n        // support for export { value } from 'module'\n        if (astNode.type === EXPORT_NAMED_DECLARATION) {\n          if (astNode.source) {\n            resolvedPath = resolve(astNode.source.raw.replace(/('|\")/g, ''), context);\n            astNode.specifiers.forEach((specifier) => {\n              const name = specifier.local.name || specifier.local.value;\n              if (name === DEFAULT) {\n                newDefaultImports.add(resolvedPath);\n              } else {\n                newImports.set(name, resolvedPath);\n              }\n            });\n          }\n        }\n\n        if (astNode.type === EXPORT_ALL_DECLARATION) {\n          resolvedPath = resolve(astNode.source.raw.replace(/('|\")/g, ''), context);\n          newExportAll.add(resolvedPath);\n        }\n\n        if (astNode.type === IMPORT_DECLARATION) {\n          resolvedPath = resolve(astNode.source.raw.replace(/('|\")/g, ''), context);\n          if (!resolvedPath) {\n            return;\n          }\n\n          if (isNodeModule(resolvedPath)) {\n            return;\n          }\n\n          if (newNamespaceImportExists(astNode.specifiers)) {\n            newNamespaceImports.add(resolvedPath);\n          }\n\n          if (newDefaultImportExists(astNode.specifiers)) {\n            newDefaultImports.add(resolvedPath);\n          }\n\n          astNode.specifiers\n            .filter((specifier) => specifier.type !== IMPORT_DEFAULT_SPECIFIER && specifier.type !== IMPORT_NAMESPACE_SPECIFIER)\n            .forEach((specifier) => {\n              newImports.set(specifier.imported.name || specifier.imported.value, resolvedPath);\n            });\n        }\n      });\n\n      newExportAll.forEach((value) => {\n        if (!oldExportAll.has(value)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(EXPORT_ALL_DECLARATION);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(EXPORT_ALL_DECLARATION);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(EXPORT_ALL_DECLARATION, { whereUsed });\n          }\n        }\n      });\n\n      oldExportAll.forEach((value) => {\n        if (!newExportAll.has(value)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(EXPORT_ALL_DECLARATION);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(EXPORT_ALL_DECLARATION);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n\n      newDefaultImports.forEach((value) => {\n        if (!oldDefaultImports.has(value)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(IMPORT_DEFAULT_SPECIFIER);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed });\n          }\n        }\n      });\n\n      oldDefaultImports.forEach((value) => {\n        if (!newDefaultImports.has(value)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(IMPORT_DEFAULT_SPECIFIER);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n\n      newNamespaceImports.forEach((value) => {\n        if (!oldNamespaceImports.has(value)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(IMPORT_NAMESPACE_SPECIFIER);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed });\n          }\n        }\n      });\n\n      oldNamespaceImports.forEach((value) => {\n        if (!newNamespaceImports.has(value)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(IMPORT_NAMESPACE_SPECIFIER);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n\n      newImports.forEach((value, key) => {\n        if (!oldImports.has(key)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(key);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(key);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(key, { whereUsed });\n          }\n        }\n      });\n\n      oldImports.forEach((value, key) => {\n        if (!newImports.has(key)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(key);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(key);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n    };\n\n    return {\n      'Program:exit'(node) {\n        updateExportUsage(node);\n        updateImportUsage(node);\n        checkExportPresence(node);\n      },\n      ExportDefaultDeclaration(node) {\n        checkUsage(node, IMPORT_DEFAULT_SPECIFIER, false);\n      },\n      ExportNamedDeclaration(node) {\n        node.specifiers.forEach((specifier) => {\n          checkUsage(specifier, specifier.exported.name || specifier.exported.value, false);\n        });\n        forEachDeclarationIdentifier(node.declaration, (name, isTypeExport) => {\n          checkUsage(node, name, isTypeExport);\n        });\n      },\n    };\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-unused-modules.js"],"names":["FileEnumerator","listFilesToProcess","require","e","originalListFilesToProcess","src","extensions","patterns","concat","pattern","map","extension","test","Array","from","iterateFiles","filePath","ignored","filename","EXPORT_DEFAULT_DECLARATION","EXPORT_NAMED_DECLARATION","EXPORT_ALL_DECLARATION","IMPORT_DECLARATION","IMPORT_NAMESPACE_SPECIFIER","IMPORT_DEFAULT_SPECIFIER","VARIABLE_DECLARATION","FUNCTION_DECLARATION","CLASS_DECLARATION","IDENTIFIER","OBJECT_PATTERN","ARRAY_PATTERN","TS_INTERFACE_DECLARATION","TS_TYPE_ALIAS_DECLARATION","TS_ENUM_DECLARATION","DEFAULT","forEachDeclarationIdentifier","declaration","cb","type","id","name","declarations","forEach","elements","importList","Map","exportList","visitorKeyMap","ignoredFiles","Set","filesOutsideSrc","isNodeModule","path","resolveFiles","ignoreExports","context","settings","srcFileList","ignoredFilesList","add","prepareImportsAndExports","srcFiles","exportAll","file","exports","imports","currentExports","Exports","get","dependencies","reexports","localImportList","namespace","visitorKeys","set","currentExportAll","getDependency","dependency","value","key","whereUsed","reexport","getImport","localImport","currentValue","local","importedSpecifiers","specifier","has","val","currentExport","determineUsage","listValue","listKey","currentImport","exportStatement","getSrc","process","cwd","lastPrepareKey","doPreparation","prepareKey","JSON","stringify","sort","clear","newNamespaceImportExists","specifiers","some","newDefaultImportExists","fileIsInPkg","pkg","basePath","checkPkgFieldString","pkgField","checkPkgFieldObject","pkgFieldFiles","checkPkgField","bin","browser","main","module","meta","docs","category","description","url","schema","properties","uniqueItems","items","minLength","missingExports","unusedExports","anyOf","minItems","required","create","options","getPhysicalFilename","getFilename","checkExportPresence","node","exportCount","namespaceImports","size","report","body","checkUsage","exportedValue","exportsKey","updateExportUsage","newExports","newExportIdentifiers","length","exported","updateImportUsage","oldImportPaths","oldNamespaceImports","newNamespaceImports","oldExportAll","newExportAll","oldDefaultImports","newDefaultImports","oldImports","newImports","processDynamicImport","source","p","ImportExpression","child","CallExpression","callee","arguments","astNode","resolvedPath","raw","replace","filter","imported","ExportDefaultDeclaration","ExportNamedDeclaration"],"mappings":"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","file":"no-unused-modules.js","sourcesContent":["/**\n * @fileOverview Ensures that modules contain exports and/or all\n * modules are consumed within other modules.\n * @author René Fermann\n */\n\nimport { getFileExtensions } from 'eslint-module-utils/ignore';\nimport resolve from 'eslint-module-utils/resolve';\nimport visit from 'eslint-module-utils/visit';\nimport { dirname, join } from 'path';\nimport readPkgUp from 'eslint-module-utils/readPkgUp';\nimport values from 'object.values';\nimport includes from 'array-includes';\nimport flatMap from 'array.prototype.flatmap';\n\nimport Exports, { recursivePatternCapture } from '../ExportMap';\nimport docsUrl from '../docsUrl';\n\nlet FileEnumerator;\nlet listFilesToProcess;\n\ntry {\n  ({ FileEnumerator } = require('eslint/use-at-your-own-risk'));\n} catch (e) {\n  try {\n    // has been moved to eslint/lib/cli-engine/file-enumerator in version 6\n    ({ FileEnumerator } = require('eslint/lib/cli-engine/file-enumerator'));\n  } catch (e) {\n    try {\n      // eslint/lib/util/glob-util has been moved to eslint/lib/util/glob-utils with version 5.3\n      const { listFilesToProcess: originalListFilesToProcess } = require('eslint/lib/util/glob-utils');\n\n      // Prevent passing invalid options (extensions array) to old versions of the function.\n      // https://github.com/eslint/eslint/blob/v5.16.0/lib/util/glob-utils.js#L178-L280\n      // https://github.com/eslint/eslint/blob/v5.2.0/lib/util/glob-util.js#L174-L269\n      listFilesToProcess = function (src, extensions) {\n        return originalListFilesToProcess(src, {\n          extensions,\n        });\n      };\n    } catch (e) {\n      const { listFilesToProcess: originalListFilesToProcess } = require('eslint/lib/util/glob-util');\n\n      listFilesToProcess = function (src, extensions) {\n        const patterns = src.concat(flatMap(src, (pattern) => extensions.map((extension) => (/\\*\\*|\\*\\./).test(pattern) ? pattern : `${pattern}/**/*${extension}`)));\n\n        return originalListFilesToProcess(patterns);\n      };\n    }\n  }\n}\n\nif (FileEnumerator) {\n  listFilesToProcess = function (src, extensions) {\n    const e = new FileEnumerator({\n      extensions,\n    });\n\n    return Array.from(e.iterateFiles(src), ({ filePath, ignored }) => ({\n      ignored,\n      filename: filePath,\n    }));\n  };\n}\n\nconst EXPORT_DEFAULT_DECLARATION = 'ExportDefaultDeclaration';\nconst EXPORT_NAMED_DECLARATION = 'ExportNamedDeclaration';\nconst EXPORT_ALL_DECLARATION = 'ExportAllDeclaration';\nconst IMPORT_DECLARATION = 'ImportDeclaration';\nconst IMPORT_NAMESPACE_SPECIFIER = 'ImportNamespaceSpecifier';\nconst IMPORT_DEFAULT_SPECIFIER = 'ImportDefaultSpecifier';\nconst VARIABLE_DECLARATION = 'VariableDeclaration';\nconst FUNCTION_DECLARATION = 'FunctionDeclaration';\nconst CLASS_DECLARATION = 'ClassDeclaration';\nconst IDENTIFIER = 'Identifier';\nconst OBJECT_PATTERN = 'ObjectPattern';\nconst ARRAY_PATTERN = 'ArrayPattern';\nconst TS_INTERFACE_DECLARATION = 'TSInterfaceDeclaration';\nconst TS_TYPE_ALIAS_DECLARATION = 'TSTypeAliasDeclaration';\nconst TS_ENUM_DECLARATION = 'TSEnumDeclaration';\nconst DEFAULT = 'default';\n\nfunction forEachDeclarationIdentifier(declaration, cb) {\n  if (declaration) {\n    if (\n      declaration.type === FUNCTION_DECLARATION\n      || declaration.type === CLASS_DECLARATION\n      || declaration.type === TS_INTERFACE_DECLARATION\n      || declaration.type === TS_TYPE_ALIAS_DECLARATION\n      || declaration.type === TS_ENUM_DECLARATION\n    ) {\n      cb(declaration.id.name);\n    } else if (declaration.type === VARIABLE_DECLARATION) {\n      declaration.declarations.forEach(({ id }) => {\n        if (id.type === OBJECT_PATTERN) {\n          recursivePatternCapture(id, (pattern) => {\n            if (pattern.type === IDENTIFIER) {\n              cb(pattern.name);\n            }\n          });\n        } else if (id.type === ARRAY_PATTERN) {\n          id.elements.forEach(({ name }) => {\n            cb(name);\n          });\n        } else {\n          cb(id.name);\n        }\n      });\n    }\n  }\n}\n\n/**\n * List of imports per file.\n *\n * Represented by a two-level Map to a Set of identifiers. The upper-level Map\n * keys are the paths to the modules containing the imports, while the\n * lower-level Map keys are the paths to the files which are being imported\n * from. Lastly, the Set of identifiers contains either names being imported\n * or a special AST node name listed above (e.g ImportDefaultSpecifier).\n *\n * For example, if we have a file named foo.js containing:\n *\n *   import { o2 } from './bar.js';\n *\n * Then we will have a structure that looks like:\n *\n *   Map { 'foo.js' => Map { 'bar.js' => Set { 'o2' } } }\n *\n * @type {Map<string, Map<string, Set<string>>>}\n */\nconst importList = new Map();\n\n/**\n * List of exports per file.\n *\n * Represented by a two-level Map to an object of metadata. The upper-level Map\n * keys are the paths to the modules containing the exports, while the\n * lower-level Map keys are the specific identifiers or special AST node names\n * being exported. The leaf-level metadata object at the moment only contains a\n * `whereUsed` property, which contains a Set of paths to modules that import\n * the name.\n *\n * For example, if we have a file named bar.js containing the following exports:\n *\n *   const o2 = 'bar';\n *   export { o2 };\n *\n * And a file named foo.js containing the following import:\n *\n *   import { o2 } from './bar.js';\n *\n * Then we will have a structure that looks like:\n *\n *   Map { 'bar.js' => Map { 'o2' => { whereUsed: Set { 'foo.js' } } } }\n *\n * @type {Map<string, Map<string, object>>}\n */\nconst exportList = new Map();\n\nconst visitorKeyMap = new Map();\n\nconst ignoredFiles = new Set();\nconst filesOutsideSrc = new Set();\n\nconst isNodeModule = (path) => (/\\/(node_modules)\\//).test(path);\n\n/**\n * read all files matching the patterns in src and ignoreExports\n *\n * return all files matching src pattern, which are not matching the ignoreExports pattern\n */\nconst resolveFiles = (src, ignoreExports, context) => {\n  const extensions = Array.from(getFileExtensions(context.settings));\n\n  const srcFileList = listFilesToProcess(src, extensions);\n\n  // prepare list of ignored files\n  const ignoredFilesList = listFilesToProcess(ignoreExports, extensions);\n  ignoredFilesList.forEach(({ filename }) => ignoredFiles.add(filename));\n\n  // prepare list of source files, don't consider files from node_modules\n\n  return new Set(\n    flatMap(srcFileList, ({ filename }) => isNodeModule(filename) ? [] : filename),\n  );\n};\n\n/**\n * parse all source files and build up 2 maps containing the existing imports and exports\n */\nconst prepareImportsAndExports = (srcFiles, context) => {\n  const exportAll = new Map();\n  srcFiles.forEach((file) => {\n    const exports = new Map();\n    const imports = new Map();\n    const currentExports = Exports.get(file, context);\n    if (currentExports) {\n      const {\n        dependencies,\n        reexports,\n        imports: localImportList,\n        namespace,\n        visitorKeys,\n      } = currentExports;\n\n      visitorKeyMap.set(file, visitorKeys);\n      // dependencies === export * from\n      const currentExportAll = new Set();\n      dependencies.forEach((getDependency) => {\n        const dependency = getDependency();\n        if (dependency === null) {\n          return;\n        }\n\n        currentExportAll.add(dependency.path);\n      });\n      exportAll.set(file, currentExportAll);\n\n      reexports.forEach((value, key) => {\n        if (key === DEFAULT) {\n          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() });\n        } else {\n          exports.set(key, { whereUsed: new Set() });\n        }\n        const reexport =  value.getImport();\n        if (!reexport) {\n          return;\n        }\n        let localImport = imports.get(reexport.path);\n        let currentValue;\n        if (value.local === DEFAULT) {\n          currentValue = IMPORT_DEFAULT_SPECIFIER;\n        } else {\n          currentValue = value.local;\n        }\n        if (typeof localImport !== 'undefined') {\n          localImport = new Set([...localImport, currentValue]);\n        } else {\n          localImport = new Set([currentValue]);\n        }\n        imports.set(reexport.path, localImport);\n      });\n\n      localImportList.forEach((value, key) => {\n        if (isNodeModule(key)) {\n          return;\n        }\n        const localImport = imports.get(key) || new Set();\n        value.declarations.forEach(({ importedSpecifiers }) => {\n          importedSpecifiers.forEach((specifier) => {\n            localImport.add(specifier);\n          });\n        });\n        imports.set(key, localImport);\n      });\n      importList.set(file, imports);\n\n      // build up export list only, if file is not ignored\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n      namespace.forEach((value, key) => {\n        if (key === DEFAULT) {\n          exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed: new Set() });\n        } else {\n          exports.set(key, { whereUsed: new Set() });\n        }\n      });\n    }\n    exports.set(EXPORT_ALL_DECLARATION, { whereUsed: new Set() });\n    exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed: new Set() });\n    exportList.set(file, exports);\n  });\n  exportAll.forEach((value, key) => {\n    value.forEach((val) => {\n      const currentExports = exportList.get(val);\n      if (currentExports) {\n        const currentExport = currentExports.get(EXPORT_ALL_DECLARATION);\n        currentExport.whereUsed.add(key);\n      }\n    });\n  });\n};\n\n/**\n * traverse through all imports and add the respective path to the whereUsed-list\n * of the corresponding export\n */\nconst determineUsage = () => {\n  importList.forEach((listValue, listKey) => {\n    listValue.forEach((value, key) => {\n      const exports = exportList.get(key);\n      if (typeof exports !== 'undefined') {\n        value.forEach((currentImport) => {\n          let specifier;\n          if (currentImport === IMPORT_NAMESPACE_SPECIFIER) {\n            specifier = IMPORT_NAMESPACE_SPECIFIER;\n          } else if (currentImport === IMPORT_DEFAULT_SPECIFIER) {\n            specifier = IMPORT_DEFAULT_SPECIFIER;\n          } else {\n            specifier = currentImport;\n          }\n          if (typeof specifier !== 'undefined') {\n            const exportStatement = exports.get(specifier);\n            if (typeof exportStatement !== 'undefined') {\n              const { whereUsed } = exportStatement;\n              whereUsed.add(listKey);\n              exports.set(specifier, { whereUsed });\n            }\n          }\n        });\n      }\n    });\n  });\n};\n\nconst getSrc = (src) => {\n  if (src) {\n    return src;\n  }\n  return [process.cwd()];\n};\n\n/**\n * prepare the lists of existing imports and exports - should only be executed once at\n * the start of a new eslint run\n */\nlet srcFiles;\nlet lastPrepareKey;\nconst doPreparation = (src, ignoreExports, context) => {\n  const prepareKey = JSON.stringify({\n    src: (src || []).sort(),\n    ignoreExports: (ignoreExports || []).sort(),\n    extensions: Array.from(getFileExtensions(context.settings)).sort(),\n  });\n  if (prepareKey === lastPrepareKey) {\n    return;\n  }\n\n  importList.clear();\n  exportList.clear();\n  ignoredFiles.clear();\n  filesOutsideSrc.clear();\n\n  srcFiles = resolveFiles(getSrc(src), ignoreExports, context);\n  prepareImportsAndExports(srcFiles, context);\n  determineUsage();\n  lastPrepareKey = prepareKey;\n};\n\nconst newNamespaceImportExists = (specifiers) => specifiers.some(({ type }) => type === IMPORT_NAMESPACE_SPECIFIER);\n\nconst newDefaultImportExists = (specifiers) => specifiers.some(({ type }) => type === IMPORT_DEFAULT_SPECIFIER);\n\nconst fileIsInPkg = (file) => {\n  const { path, pkg } = readPkgUp({ cwd: file });\n  const basePath = dirname(path);\n\n  const checkPkgFieldString = (pkgField) => {\n    if (join(basePath, pkgField) === file) {\n      return true;\n    }\n  };\n\n  const checkPkgFieldObject = (pkgField) => {\n    const pkgFieldFiles = flatMap(values(pkgField), (value) => typeof value === 'boolean' ? [] : join(basePath, value));\n\n    if (includes(pkgFieldFiles, file)) {\n      return true;\n    }\n  };\n\n  const checkPkgField = (pkgField) => {\n    if (typeof pkgField === 'string') {\n      return checkPkgFieldString(pkgField);\n    }\n\n    if (typeof pkgField === 'object') {\n      return checkPkgFieldObject(pkgField);\n    }\n  };\n\n  if (pkg.private === true) {\n    return false;\n  }\n\n  if (pkg.bin) {\n    if (checkPkgField(pkg.bin)) {\n      return true;\n    }\n  }\n\n  if (pkg.browser) {\n    if (checkPkgField(pkg.browser)) {\n      return true;\n    }\n  }\n\n  if (pkg.main) {\n    if (checkPkgFieldString(pkg.main)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Helpful warnings',\n      description: 'Forbid modules without exports, or exports without matching import in another module.',\n      url: docsUrl('no-unused-modules'),\n    },\n    schema: [{\n      properties: {\n        src: {\n          description: 'files/paths to be analyzed (only for unused exports)',\n          type: 'array',\n          uniqueItems: true,\n          items: {\n            type: 'string',\n            minLength: 1,\n          },\n        },\n        ignoreExports: {\n          description: 'files/paths for which unused exports will not be reported (e.g module entry points)',\n          type: 'array',\n          uniqueItems: true,\n          items: {\n            type: 'string',\n            minLength: 1,\n          },\n        },\n        missingExports: {\n          description: 'report modules without any exports',\n          type: 'boolean',\n        },\n        unusedExports: {\n          description: 'report exports without any usage',\n          type: 'boolean',\n        },\n      },\n      anyOf: [\n        {\n          properties: {\n            unusedExports: { enum: [true] },\n            src: {\n              minItems: 1,\n            },\n          },\n          required: ['unusedExports'],\n        },\n        {\n          properties: {\n            missingExports: { enum: [true] },\n          },\n          required: ['missingExports'],\n        },\n      ],\n    }],\n  },\n\n  create(context) {\n    const {\n      src,\n      ignoreExports = [],\n      missingExports,\n      unusedExports,\n    } = context.options[0] || {};\n\n    if (unusedExports) {\n      doPreparation(src, ignoreExports, context);\n    }\n\n    const file = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();\n\n    const checkExportPresence = (node) => {\n      if (!missingExports) {\n        return;\n      }\n\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n\n      const exportCount = exportList.get(file);\n      const exportAll = exportCount.get(EXPORT_ALL_DECLARATION);\n      const namespaceImports = exportCount.get(IMPORT_NAMESPACE_SPECIFIER);\n\n      exportCount.delete(EXPORT_ALL_DECLARATION);\n      exportCount.delete(IMPORT_NAMESPACE_SPECIFIER);\n      if (exportCount.size < 1) {\n        // node.body[0] === 'undefined' only happens, if everything is commented out in the file\n        // being linted\n        context.report(node.body[0] ? node.body[0] : node, 'No exports found');\n      }\n      exportCount.set(EXPORT_ALL_DECLARATION, exportAll);\n      exportCount.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports);\n    };\n\n    const checkUsage = (node, exportedValue) => {\n      if (!unusedExports) {\n        return;\n      }\n\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n\n      if (fileIsInPkg(file)) {\n        return;\n      }\n\n      if (filesOutsideSrc.has(file)) {\n        return;\n      }\n\n      // make sure file to be linted is included in source files\n      if (!srcFiles.has(file)) {\n        srcFiles = resolveFiles(getSrc(src), ignoreExports, context);\n        if (!srcFiles.has(file)) {\n          filesOutsideSrc.add(file);\n          return;\n        }\n      }\n\n      exports = exportList.get(file);\n\n      // special case: export * from\n      const exportAll = exports.get(EXPORT_ALL_DECLARATION);\n      if (typeof exportAll !== 'undefined' && exportedValue !== IMPORT_DEFAULT_SPECIFIER) {\n        if (exportAll.whereUsed.size > 0) {\n          return;\n        }\n      }\n\n      // special case: namespace import\n      const namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n      if (typeof namespaceImports !== 'undefined') {\n        if (namespaceImports.whereUsed.size > 0) {\n          return;\n        }\n      }\n\n      // exportsList will always map any imported value of 'default' to 'ImportDefaultSpecifier'\n      const exportsKey = exportedValue === DEFAULT ? IMPORT_DEFAULT_SPECIFIER : exportedValue;\n\n      const exportStatement = exports.get(exportsKey);\n\n      const value = exportsKey === IMPORT_DEFAULT_SPECIFIER ? DEFAULT : exportsKey;\n\n      if (typeof exportStatement !== 'undefined') {\n        if (exportStatement.whereUsed.size < 1) {\n          context.report(\n            node,\n            `exported declaration '${value}' not used within other modules`,\n          );\n        }\n      } else {\n        context.report(\n          node,\n          `exported declaration '${value}' not used within other modules`,\n        );\n      }\n    };\n\n    /**\n     * only useful for tools like vscode-eslint\n     *\n     * update lists of existing exports during runtime\n     */\n    const updateExportUsage = (node) => {\n      if (ignoredFiles.has(file)) {\n        return;\n      }\n\n      let exports = exportList.get(file);\n\n      // new module has been created during runtime\n      // include it in further processing\n      if (typeof exports === 'undefined') {\n        exports = new Map();\n      }\n\n      const newExports = new Map();\n      const newExportIdentifiers = new Set();\n\n      node.body.forEach(({ type, declaration, specifiers }) => {\n        if (type === EXPORT_DEFAULT_DECLARATION) {\n          newExportIdentifiers.add(IMPORT_DEFAULT_SPECIFIER);\n        }\n        if (type === EXPORT_NAMED_DECLARATION) {\n          if (specifiers.length > 0) {\n            specifiers.forEach((specifier) => {\n              if (specifier.exported) {\n                newExportIdentifiers.add(specifier.exported.name || specifier.exported.value);\n              }\n            });\n          }\n          forEachDeclarationIdentifier(declaration, (name) => {\n            newExportIdentifiers.add(name);\n          });\n        }\n      });\n\n      // old exports exist within list of new exports identifiers: add to map of new exports\n      exports.forEach((value, key) => {\n        if (newExportIdentifiers.has(key)) {\n          newExports.set(key, value);\n        }\n      });\n\n      // new export identifiers added: add to map of new exports\n      newExportIdentifiers.forEach((key) => {\n        if (!exports.has(key)) {\n          newExports.set(key, { whereUsed: new Set() });\n        }\n      });\n\n      // preserve information about namespace imports\n      const exportAll = exports.get(EXPORT_ALL_DECLARATION);\n      let namespaceImports = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n\n      if (typeof namespaceImports === 'undefined') {\n        namespaceImports = { whereUsed: new Set() };\n      }\n\n      newExports.set(EXPORT_ALL_DECLARATION, exportAll);\n      newExports.set(IMPORT_NAMESPACE_SPECIFIER, namespaceImports);\n      exportList.set(file, newExports);\n    };\n\n    /**\n     * only useful for tools like vscode-eslint\n     *\n     * update lists of existing imports during runtime\n     */\n    const updateImportUsage = (node) => {\n      if (!unusedExports) {\n        return;\n      }\n\n      let oldImportPaths = importList.get(file);\n      if (typeof oldImportPaths === 'undefined') {\n        oldImportPaths = new Map();\n      }\n\n      const oldNamespaceImports = new Set();\n      const newNamespaceImports = new Set();\n\n      const oldExportAll = new Set();\n      const newExportAll = new Set();\n\n      const oldDefaultImports = new Set();\n      const newDefaultImports = new Set();\n\n      const oldImports = new Map();\n      const newImports = new Map();\n      oldImportPaths.forEach((value, key) => {\n        if (value.has(EXPORT_ALL_DECLARATION)) {\n          oldExportAll.add(key);\n        }\n        if (value.has(IMPORT_NAMESPACE_SPECIFIER)) {\n          oldNamespaceImports.add(key);\n        }\n        if (value.has(IMPORT_DEFAULT_SPECIFIER)) {\n          oldDefaultImports.add(key);\n        }\n        value.forEach((val) => {\n          if (\n            val !== IMPORT_NAMESPACE_SPECIFIER\n            && val !== IMPORT_DEFAULT_SPECIFIER\n          ) {\n            oldImports.set(val, key);\n          }\n        });\n      });\n\n      function processDynamicImport(source) {\n        if (source.type !== 'Literal') {\n          return null;\n        }\n        const p = resolve(source.value, context);\n        if (p == null) {\n          return null;\n        }\n        newNamespaceImports.add(p);\n      }\n\n      visit(node, visitorKeyMap.get(file), {\n        ImportExpression(child) {\n          processDynamicImport(child.source);\n        },\n        CallExpression(child) {\n          if (child.callee.type === 'Import') {\n            processDynamicImport(child.arguments[0]);\n          }\n        },\n      });\n\n      node.body.forEach((astNode) => {\n        let resolvedPath;\n\n        // support for export { value } from 'module'\n        if (astNode.type === EXPORT_NAMED_DECLARATION) {\n          if (astNode.source) {\n            resolvedPath = resolve(astNode.source.raw.replace(/('|\")/g, ''), context);\n            astNode.specifiers.forEach((specifier) => {\n              const name = specifier.local.name || specifier.local.value;\n              if (name === DEFAULT) {\n                newDefaultImports.add(resolvedPath);\n              } else {\n                newImports.set(name, resolvedPath);\n              }\n            });\n          }\n        }\n\n        if (astNode.type === EXPORT_ALL_DECLARATION) {\n          resolvedPath = resolve(astNode.source.raw.replace(/('|\")/g, ''), context);\n          newExportAll.add(resolvedPath);\n        }\n\n        if (astNode.type === IMPORT_DECLARATION) {\n          resolvedPath = resolve(astNode.source.raw.replace(/('|\")/g, ''), context);\n          if (!resolvedPath) {\n            return;\n          }\n\n          if (isNodeModule(resolvedPath)) {\n            return;\n          }\n\n          if (newNamespaceImportExists(astNode.specifiers)) {\n            newNamespaceImports.add(resolvedPath);\n          }\n\n          if (newDefaultImportExists(astNode.specifiers)) {\n            newDefaultImports.add(resolvedPath);\n          }\n\n          astNode.specifiers\n            .filter((specifier) => specifier.type !== IMPORT_DEFAULT_SPECIFIER && specifier.type !== IMPORT_NAMESPACE_SPECIFIER)\n            .forEach((specifier) => {\n              newImports.set(specifier.imported.name || specifier.imported.value, resolvedPath);\n            });\n        }\n      });\n\n      newExportAll.forEach((value) => {\n        if (!oldExportAll.has(value)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(EXPORT_ALL_DECLARATION);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(EXPORT_ALL_DECLARATION);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(EXPORT_ALL_DECLARATION, { whereUsed });\n          }\n        }\n      });\n\n      oldExportAll.forEach((value) => {\n        if (!newExportAll.has(value)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(EXPORT_ALL_DECLARATION);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(EXPORT_ALL_DECLARATION);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n\n      newDefaultImports.forEach((value) => {\n        if (!oldDefaultImports.has(value)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(IMPORT_DEFAULT_SPECIFIER);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(IMPORT_DEFAULT_SPECIFIER, { whereUsed });\n          }\n        }\n      });\n\n      oldDefaultImports.forEach((value) => {\n        if (!newDefaultImports.has(value)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(IMPORT_DEFAULT_SPECIFIER);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(IMPORT_DEFAULT_SPECIFIER);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n\n      newNamespaceImports.forEach((value) => {\n        if (!oldNamespaceImports.has(value)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(IMPORT_NAMESPACE_SPECIFIER);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(IMPORT_NAMESPACE_SPECIFIER, { whereUsed });\n          }\n        }\n      });\n\n      oldNamespaceImports.forEach((value) => {\n        if (!newNamespaceImports.has(value)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(IMPORT_NAMESPACE_SPECIFIER);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(IMPORT_NAMESPACE_SPECIFIER);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n\n      newImports.forEach((value, key) => {\n        if (!oldImports.has(key)) {\n          let imports = oldImportPaths.get(value);\n          if (typeof imports === 'undefined') {\n            imports = new Set();\n          }\n          imports.add(key);\n          oldImportPaths.set(value, imports);\n\n          let exports = exportList.get(value);\n          let currentExport;\n          if (typeof exports !== 'undefined') {\n            currentExport = exports.get(key);\n          } else {\n            exports = new Map();\n            exportList.set(value, exports);\n          }\n\n          if (typeof currentExport !== 'undefined') {\n            currentExport.whereUsed.add(file);\n          } else {\n            const whereUsed = new Set();\n            whereUsed.add(file);\n            exports.set(key, { whereUsed });\n          }\n        }\n      });\n\n      oldImports.forEach((value, key) => {\n        if (!newImports.has(key)) {\n          const imports = oldImportPaths.get(value);\n          imports.delete(key);\n\n          const exports = exportList.get(value);\n          if (typeof exports !== 'undefined') {\n            const currentExport = exports.get(key);\n            if (typeof currentExport !== 'undefined') {\n              currentExport.whereUsed.delete(file);\n            }\n          }\n        }\n      });\n    };\n\n    return {\n      'Program:exit'(node) {\n        updateExportUsage(node);\n        updateImportUsage(node);\n        checkExportPresence(node);\n      },\n      ExportDefaultDeclaration(node) {\n        checkUsage(node, IMPORT_DEFAULT_SPECIFIER);\n      },\n      ExportNamedDeclaration(node) {\n        node.specifiers.forEach((specifier) => {\n          checkUsage(specifier, specifier.exported.name || specifier.exported.value);\n        });\n        forEachDeclarationIdentifier(node.declaration, (name) => {\n          checkUsage(node, name);\n        });\n      },\n    };\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/rules/order.js b/node_modules/eslint-plugin-import/lib/rules/order.js index 364f3e06aa..4b735ae4b4 100644 --- a/node_modules/eslint-plugin-import/lib/rules/order.js +++ b/node_modules/eslint-plugin-import/lib/rules/order.js @@ -92,12 +92,6 @@ function findRootNode(node) { return parent; } -function commentOnSameLineAs(node) { - return function (token) {return (token.type === 'Block' || token.type === 'Line') && - token.loc.start.line === token.loc.end.line && - token.loc.end.line === node.loc.end.line;}; -} - function findEndOfLineWithComments(sourceCode, node) { var tokensToEndOfLine = takeTokensAfterWhile(sourceCode, node, commentOnSameLineAs(node)); var endOfTokens = tokensToEndOfLine.length > 0 ? @@ -117,6 +111,12 @@ function findEndOfLineWithComments(sourceCode, node) { return result; } +function commentOnSameLineAs(node) { + return function (token) {return (token.type === 'Block' || token.type === 'Line') && + token.loc.start.line === token.loc.end.line && + token.loc.end.line === node.loc.end.line;}; +} + function findStartOfLineWithComments(sourceCode, node) { var tokensToEndOfLine = takeTokensBeforeWhile(sourceCode, node, commentOnSameLineAs(node)); var startOfTokens = tokensToEndOfLine.length > 0 ? tokensToEndOfLine[0].range[0] : node.range[0]; @@ -302,12 +302,6 @@ function getSorter(alphabetizeOptions) { var b = B.length; for (var i = 0; i < Math.min(a, b); i++) { - // Skip comparing the first path segment, if they are relative segments for both imports - if (i === 0 && (A[i] === '.' || A[i] === '..') && (B[i] === '.' || B[i] === '..')) { - // If one is sibling and the other parent import, no need to compare at all, since the paths belong in different groups - if (A[i] !== B[i]) {break;} - continue; - } result = compareString(A[i], B[i]); if (result) {break;} } @@ -788,4 +782,4 @@ module.exports = { }return reportAndReset;}() }; }return importOrderRule;}() }; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/order.js"],"names":["defaultGroups","reverse","array","map","v","rank","getTokensOrCommentsAfter","sourceCode","node","count","currentNodeOrToken","result","i","getTokenOrCommentAfter","push","getTokensOrCommentsBefore","getTokenOrCommentBefore","takeTokensAfterWhile","condition","tokens","length","takeTokensBeforeWhile","findOutOfOrder","imported","maxSeenRankNode","filter","importedModule","res","findRootNode","parent","body","commentOnSameLineAs","token","type","loc","start","line","end","findEndOfLineWithComments","tokensToEndOfLine","endOfTokens","range","text","findStartOfLineWithComments","startOfTokens","isRequireExpression","expr","callee","name","arguments","isSupportedRequireModule","declarations","decl","isPlainRequire","id","init","isRequireWithMemberExpression","object","isPlainImportModule","specifiers","isPlainImportEquals","moduleReference","expression","canCrossNodeWhileReorder","canReorderItems","firstNode","secondNode","indexOf","sort","firstIndex","secondIndex","nodesBetween","slice","nodeBetween","makeImportDescription","importKind","fixOutOfOrder","context","order","getSourceCode","firstRoot","firstRootStart","firstRootEnd","secondRoot","secondRootStart","secondRootEnd","canFix","newCode","substring","firstImport","displayName","secondImport","message","report","fix","fixer","replaceTextRange","reportOutOfOrder","outOfOrder","forEach","imp","found","find","hasHigherRank","importedItem","makeOutOfOrderReport","reversedImported","reversedOrder","compareString","a","b","DEAFULT_IMPORT_KIND","getNormalizedValue","toLowerCase","value","String","getSorter","alphabetizeOptions","multiplier","orderImportKind","multiplierImportKind","importsSorter","nodeA","nodeB","importA","caseInsensitive","importB","A","split","B","Math","min","mutateRanksToAlphabetize","groupedByRanks","item","sorterFn","groupRanks","Object","keys","groupRank","newRank","alphabetizedRanks","reduce","acc","parseInt","computePathRank","ranks","pathGroups","path","maxPosition","l","pattern","patternOptions","group","position","nocomment","computeRank","importEntry","excludedImportTypes","impType","omittedTypes","has","groups","startsWith","registerNode","getRequireBlock","n","types","convertGroupsToRanks","rankObject","index","concat","groupItem","Error","JSON","stringify","undefined","convertPathGroupsForRanks","after","before","transformed","pathGroup","positionString","groupLength","groupIndex","max","key","groupNextPosition","pow","ceil","log10","fixNewLineAfterImport","previousImport","prevRoot","endOfLine","insertTextAfterRange","removeNewLineAfterImport","currentImport","currRoot","rangeToRemove","test","removeRange","makeNewlinesBetweenReport","newlinesBetweenImports","distinctGroup","getNumberOfEmptyLinesBetween","linesBetweenImports","lines","trim","getIsStartOfDistinctGroup","emptyLinesBetween","isStartOfDistinctGroup","getAlphabetizeConfig","options","alphabetize","defaultDistinctGroup","module","exports","meta","docs","category","description","url","fixable","schema","properties","pathGroupsExcludedImportTypes","items","additionalProperties","required","warnOnUnassignedImports","create","importOrderRule","Set","error","Program","importMap","Map","getBlockImports","set","get","ImportDeclaration","handleImports","source","TSImportEqualsDeclaration","isExport","getText","CallExpression","handleRequires","block","reportAndReset","clear"],"mappings":"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","file":"order.js","sourcesContent":["'use strict';\n\nimport minimatch from 'minimatch';\nimport includes from 'array-includes';\nimport groupBy from 'object.groupby';\n\nimport importType from '../core/importType';\nimport isStaticRequire from '../core/staticRequire';\nimport docsUrl from '../docsUrl';\n\nconst defaultGroups = ['builtin', 'external', 'parent', 'sibling', 'index'];\n\n// REPORTING AND FIXING\n\nfunction reverse(array) {\n  return array.map(function (v) {\n    return { ...v, rank: -v.rank };\n  }).reverse();\n}\n\nfunction getTokensOrCommentsAfter(sourceCode, node, count) {\n  let currentNodeOrToken = node;\n  const result = [];\n  for (let i = 0; i < count; i++) {\n    currentNodeOrToken = sourceCode.getTokenOrCommentAfter(currentNodeOrToken);\n    if (currentNodeOrToken == null) {\n      break;\n    }\n    result.push(currentNodeOrToken);\n  }\n  return result;\n}\n\nfunction getTokensOrCommentsBefore(sourceCode, node, count) {\n  let currentNodeOrToken = node;\n  const result = [];\n  for (let i = 0; i < count; i++) {\n    currentNodeOrToken = sourceCode.getTokenOrCommentBefore(currentNodeOrToken);\n    if (currentNodeOrToken == null) {\n      break;\n    }\n    result.push(currentNodeOrToken);\n  }\n  return result.reverse();\n}\n\nfunction takeTokensAfterWhile(sourceCode, node, condition) {\n  const tokens = getTokensOrCommentsAfter(sourceCode, node, 100);\n  const result = [];\n  for (let i = 0; i < tokens.length; i++) {\n    if (condition(tokens[i])) {\n      result.push(tokens[i]);\n    } else {\n      break;\n    }\n  }\n  return result;\n}\n\nfunction takeTokensBeforeWhile(sourceCode, node, condition) {\n  const tokens = getTokensOrCommentsBefore(sourceCode, node, 100);\n  const result = [];\n  for (let i = tokens.length - 1; i >= 0; i--) {\n    if (condition(tokens[i])) {\n      result.push(tokens[i]);\n    } else {\n      break;\n    }\n  }\n  return result.reverse();\n}\n\nfunction findOutOfOrder(imported) {\n  if (imported.length === 0) {\n    return [];\n  }\n  let maxSeenRankNode = imported[0];\n  return imported.filter(function (importedModule) {\n    const res = importedModule.rank < maxSeenRankNode.rank;\n    if (maxSeenRankNode.rank < importedModule.rank) {\n      maxSeenRankNode = importedModule;\n    }\n    return res;\n  });\n}\n\nfunction findRootNode(node) {\n  let parent = node;\n  while (parent.parent != null && parent.parent.body == null) {\n    parent = parent.parent;\n  }\n  return parent;\n}\n\nfunction commentOnSameLineAs(node) {\n  return (token) => (token.type === 'Block' ||  token.type === 'Line')\n      && token.loc.start.line === token.loc.end.line\n      && token.loc.end.line === node.loc.end.line;\n}\n\nfunction findEndOfLineWithComments(sourceCode, node) {\n  const tokensToEndOfLine = takeTokensAfterWhile(sourceCode, node, commentOnSameLineAs(node));\n  const endOfTokens = tokensToEndOfLine.length > 0\n    ? tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1]\n    : node.range[1];\n  let result = endOfTokens;\n  for (let i = endOfTokens; i < sourceCode.text.length; i++) {\n    if (sourceCode.text[i] === '\\n') {\n      result = i + 1;\n      break;\n    }\n    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\\t' && sourceCode.text[i] !== '\\r') {\n      break;\n    }\n    result = i + 1;\n  }\n  return result;\n}\n\nfunction findStartOfLineWithComments(sourceCode, node) {\n  const tokensToEndOfLine = takeTokensBeforeWhile(sourceCode, node, commentOnSameLineAs(node));\n  const startOfTokens = tokensToEndOfLine.length > 0 ? tokensToEndOfLine[0].range[0] : node.range[0];\n  let result = startOfTokens;\n  for (let i = startOfTokens - 1; i > 0; i--) {\n    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\\t') {\n      break;\n    }\n    result = i;\n  }\n  return result;\n}\n\nfunction isRequireExpression(expr) {\n  return expr != null\n    && expr.type === 'CallExpression'\n    && expr.callee != null\n    && expr.callee.name === 'require'\n    && expr.arguments != null\n    && expr.arguments.length === 1\n    && expr.arguments[0].type === 'Literal';\n}\n\nfunction isSupportedRequireModule(node) {\n  if (node.type !== 'VariableDeclaration') {\n    return false;\n  }\n  if (node.declarations.length !== 1) {\n    return false;\n  }\n  const decl = node.declarations[0];\n  const isPlainRequire = decl.id\n    && (decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern')\n    && isRequireExpression(decl.init);\n  const isRequireWithMemberExpression = decl.id\n    && (decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern')\n    && decl.init != null\n    && decl.init.type === 'CallExpression'\n    && decl.init.callee != null\n    && decl.init.callee.type === 'MemberExpression'\n    && isRequireExpression(decl.init.callee.object);\n  return isPlainRequire || isRequireWithMemberExpression;\n}\n\nfunction isPlainImportModule(node) {\n  return node.type === 'ImportDeclaration' && node.specifiers != null && node.specifiers.length > 0;\n}\n\nfunction isPlainImportEquals(node) {\n  return node.type === 'TSImportEqualsDeclaration' && node.moduleReference.expression;\n}\n\nfunction canCrossNodeWhileReorder(node) {\n  return isSupportedRequireModule(node) || isPlainImportModule(node) || isPlainImportEquals(node);\n}\n\nfunction canReorderItems(firstNode, secondNode) {\n  const parent = firstNode.parent;\n  const [firstIndex, secondIndex] = [\n    parent.body.indexOf(firstNode),\n    parent.body.indexOf(secondNode),\n  ].sort();\n  const nodesBetween = parent.body.slice(firstIndex, secondIndex + 1);\n  for (const nodeBetween of nodesBetween) {\n    if (!canCrossNodeWhileReorder(nodeBetween)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction makeImportDescription(node) {\n  if (node.node.importKind === 'type') {\n    return 'type import';\n  }\n  if (node.node.importKind === 'typeof') {\n    return 'typeof import';\n  }\n  return 'import';\n}\n\nfunction fixOutOfOrder(context, firstNode, secondNode, order) {\n  const sourceCode = context.getSourceCode();\n\n  const firstRoot = findRootNode(firstNode.node);\n  const firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot);\n  const firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot);\n\n  const secondRoot = findRootNode(secondNode.node);\n  const secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot);\n  const secondRootEnd = findEndOfLineWithComments(sourceCode, secondRoot);\n  const canFix = canReorderItems(firstRoot, secondRoot);\n\n  let newCode = sourceCode.text.substring(secondRootStart, secondRootEnd);\n  if (newCode[newCode.length - 1] !== '\\n') {\n    newCode = `${newCode}\\n`;\n  }\n\n  const firstImport = `${makeImportDescription(firstNode)} of \\`${firstNode.displayName}\\``;\n  const secondImport = `\\`${secondNode.displayName}\\` ${makeImportDescription(secondNode)}`;\n  const message = `${secondImport} should occur ${order} ${firstImport}`;\n\n  if (order === 'before') {\n    context.report({\n      node: secondNode.node,\n      message,\n      fix: canFix && ((fixer) => fixer.replaceTextRange(\n        [firstRootStart, secondRootEnd],\n        newCode + sourceCode.text.substring(firstRootStart, secondRootStart),\n      )),\n    });\n  } else if (order === 'after') {\n    context.report({\n      node: secondNode.node,\n      message,\n      fix: canFix && ((fixer) => fixer.replaceTextRange(\n        [secondRootStart, firstRootEnd],\n        sourceCode.text.substring(secondRootEnd, firstRootEnd) + newCode,\n      )),\n    });\n  }\n}\n\nfunction reportOutOfOrder(context, imported, outOfOrder, order) {\n  outOfOrder.forEach(function (imp) {\n    const found = imported.find(function hasHigherRank(importedItem) {\n      return importedItem.rank > imp.rank;\n    });\n    fixOutOfOrder(context, found, imp, order);\n  });\n}\n\nfunction makeOutOfOrderReport(context, imported) {\n  const outOfOrder = findOutOfOrder(imported);\n  if (!outOfOrder.length) {\n    return;\n  }\n\n  // There are things to report. Try to minimize the number of reported errors.\n  const reversedImported = reverse(imported);\n  const reversedOrder = findOutOfOrder(reversedImported);\n  if (reversedOrder.length < outOfOrder.length) {\n    reportOutOfOrder(context, reversedImported, reversedOrder, 'after');\n    return;\n  }\n  reportOutOfOrder(context, imported, outOfOrder, 'before');\n}\n\nconst compareString = (a, b) => {\n  if (a < b) {\n    return -1;\n  }\n  if (a > b) {\n    return 1;\n  }\n  return 0;\n};\n\n/** Some parsers (languages without types) don't provide ImportKind */\nconst DEAFULT_IMPORT_KIND = 'value';\nconst getNormalizedValue = (node, toLowerCase) => {\n  const value = node.value;\n  return toLowerCase ? String(value).toLowerCase() : value;\n};\n\nfunction getSorter(alphabetizeOptions) {\n  const multiplier = alphabetizeOptions.order === 'asc' ? 1 : -1;\n  const orderImportKind = alphabetizeOptions.orderImportKind;\n  const multiplierImportKind = orderImportKind !== 'ignore'\n    && (alphabetizeOptions.orderImportKind === 'asc' ? 1 : -1);\n\n  return function importsSorter(nodeA, nodeB) {\n    const importA = getNormalizedValue(nodeA, alphabetizeOptions.caseInsensitive);\n    const importB = getNormalizedValue(nodeB, alphabetizeOptions.caseInsensitive);\n    let result = 0;\n\n    if (!includes(importA, '/') && !includes(importB, '/')) {\n      result = compareString(importA, importB);\n    } else {\n      const A = importA.split('/');\n      const B = importB.split('/');\n      const a = A.length;\n      const b = B.length;\n\n      for (let i = 0; i < Math.min(a, b); i++) {\n        // Skip comparing the first path segment, if they are relative segments for both imports\n        if (i === 0 && ((A[i] === '.' || A[i] === '..') && (B[i] === '.' || B[i] === '..'))) {\n          // If one is sibling and the other parent import, no need to compare at all, since the paths belong in different groups\n          if (A[i] !== B[i]) { break; }\n          continue;\n        }\n        result = compareString(A[i], B[i]);\n        if (result) { break; }\n      }\n\n      if (!result && a !== b) {\n        result = a < b ? -1 : 1;\n      }\n    }\n\n    result = result * multiplier;\n\n    // In case the paths are equal (result === 0), sort them by importKind\n    if (!result && multiplierImportKind) {\n      result = multiplierImportKind * compareString(\n        nodeA.node.importKind || DEAFULT_IMPORT_KIND,\n        nodeB.node.importKind || DEAFULT_IMPORT_KIND,\n      );\n    }\n\n    return result;\n  };\n}\n\nfunction mutateRanksToAlphabetize(imported, alphabetizeOptions) {\n  const groupedByRanks = groupBy(imported, (item) => item.rank);\n\n  const sorterFn = getSorter(alphabetizeOptions);\n\n  // sort group keys so that they can be iterated on in order\n  const groupRanks = Object.keys(groupedByRanks).sort(function (a, b) {\n    return a - b;\n  });\n\n  // sort imports locally within their group\n  groupRanks.forEach(function (groupRank) {\n    groupedByRanks[groupRank].sort(sorterFn);\n  });\n\n  // assign globally unique rank to each import\n  let newRank = 0;\n  const alphabetizedRanks = groupRanks.reduce(function (acc, groupRank) {\n    groupedByRanks[groupRank].forEach(function (importedItem) {\n      acc[`${importedItem.value}|${importedItem.node.importKind}`] = parseInt(groupRank, 10) + newRank;\n      newRank += 1;\n    });\n    return acc;\n  }, {});\n\n  // mutate the original group-rank with alphabetized-rank\n  imported.forEach(function (importedItem) {\n    importedItem.rank = alphabetizedRanks[`${importedItem.value}|${importedItem.node.importKind}`];\n  });\n}\n\n// DETECTING\n\nfunction computePathRank(ranks, pathGroups, path, maxPosition) {\n  for (let i = 0, l = pathGroups.length; i < l; i++) {\n    const { pattern, patternOptions, group, position = 1 } = pathGroups[i];\n    if (minimatch(path, pattern, patternOptions || { nocomment: true })) {\n      return ranks[group] + position / maxPosition;\n    }\n  }\n}\n\nfunction computeRank(context, ranks, importEntry, excludedImportTypes) {\n  let impType;\n  let rank;\n  if (importEntry.type === 'import:object') {\n    impType = 'object';\n  } else if (importEntry.node.importKind === 'type' && ranks.omittedTypes.indexOf('type') === -1) {\n    impType = 'type';\n  } else {\n    impType = importType(importEntry.value, context);\n  }\n  if (!excludedImportTypes.has(impType)) {\n    rank = computePathRank(ranks.groups, ranks.pathGroups, importEntry.value, ranks.maxPosition);\n  }\n  if (typeof rank === 'undefined') {\n    rank = ranks.groups[impType];\n  }\n  if (importEntry.type !== 'import' && !importEntry.type.startsWith('import:')) {\n    rank += 100;\n  }\n\n  return rank;\n}\n\nfunction registerNode(context, importEntry, ranks, imported, excludedImportTypes) {\n  const rank = computeRank(context, ranks, importEntry, excludedImportTypes);\n  if (rank !== -1) {\n    imported.push({ ...importEntry, rank });\n  }\n}\n\nfunction getRequireBlock(node) {\n  let n = node;\n  // Handle cases like `const baz = require('foo').bar.baz`\n  // and `const foo = require('foo')()`\n  while (\n    n.parent.type === 'MemberExpression' && n.parent.object === n\n    || n.parent.type === 'CallExpression' && n.parent.callee === n\n  ) {\n    n = n.parent;\n  }\n  if (\n    n.parent.type === 'VariableDeclarator'\n    && n.parent.parent.type === 'VariableDeclaration'\n    && n.parent.parent.parent.type === 'Program'\n  ) {\n    return n.parent.parent.parent;\n  }\n}\n\nconst types = ['builtin', 'external', 'internal', 'unknown', 'parent', 'sibling', 'index', 'object', 'type'];\n\n// Creates an object with type-rank pairs.\n// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }\n// Will throw an error if it contains a type that does not exist, or has a duplicate\nfunction convertGroupsToRanks(groups) {\n  const rankObject = groups.reduce(function (res, group, index) {\n    [].concat(group).forEach(function (groupItem) {\n      if (types.indexOf(groupItem) === -1) {\n        throw new Error(`Incorrect configuration of the rule: Unknown type \\`${JSON.stringify(groupItem)}\\``);\n      }\n      if (res[groupItem] !== undefined) {\n        throw new Error(`Incorrect configuration of the rule: \\`${groupItem}\\` is duplicated`);\n      }\n      res[groupItem] = index * 2;\n    });\n    return res;\n  }, {});\n\n  const omittedTypes = types.filter(function (type) {\n    return typeof rankObject[type] === 'undefined';\n  });\n\n  const ranks = omittedTypes.reduce(function (res, type) {\n    res[type] = groups.length * 2;\n    return res;\n  }, rankObject);\n\n  return { groups: ranks, omittedTypes };\n}\n\nfunction convertPathGroupsForRanks(pathGroups) {\n  const after = {};\n  const before = {};\n\n  const transformed = pathGroups.map((pathGroup, index) => {\n    const { group, position: positionString } = pathGroup;\n    let position = 0;\n    if (positionString === 'after') {\n      if (!after[group]) {\n        after[group] = 1;\n      }\n      position = after[group]++;\n    } else if (positionString === 'before') {\n      if (!before[group]) {\n        before[group] = [];\n      }\n      before[group].push(index);\n    }\n\n    return { ...pathGroup, position };\n  });\n\n  let maxPosition = 1;\n\n  Object.keys(before).forEach((group) => {\n    const groupLength = before[group].length;\n    before[group].forEach((groupIndex, index) => {\n      transformed[groupIndex].position = -1 * (groupLength - index);\n    });\n    maxPosition = Math.max(maxPosition, groupLength);\n  });\n\n  Object.keys(after).forEach((key) => {\n    const groupNextPosition = after[key];\n    maxPosition = Math.max(maxPosition, groupNextPosition - 1);\n  });\n\n  return {\n    pathGroups: transformed,\n    maxPosition: maxPosition > 10 ? Math.pow(10, Math.ceil(Math.log10(maxPosition))) : 10,\n  };\n}\n\nfunction fixNewLineAfterImport(context, previousImport) {\n  const prevRoot = findRootNode(previousImport.node);\n  const tokensToEndOfLine = takeTokensAfterWhile(\n    context.getSourceCode(), prevRoot, commentOnSameLineAs(prevRoot));\n\n  let endOfLine = prevRoot.range[1];\n  if (tokensToEndOfLine.length > 0) {\n    endOfLine = tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1];\n  }\n  return (fixer) => fixer.insertTextAfterRange([prevRoot.range[0], endOfLine], '\\n');\n}\n\nfunction removeNewLineAfterImport(context, currentImport, previousImport) {\n  const sourceCode = context.getSourceCode();\n  const prevRoot = findRootNode(previousImport.node);\n  const currRoot = findRootNode(currentImport.node);\n  const rangeToRemove = [\n    findEndOfLineWithComments(sourceCode, prevRoot),\n    findStartOfLineWithComments(sourceCode, currRoot),\n  ];\n  if ((/^\\s*$/).test(sourceCode.text.substring(rangeToRemove[0], rangeToRemove[1]))) {\n    return (fixer) => fixer.removeRange(rangeToRemove);\n  }\n  return undefined;\n}\n\nfunction makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup) {\n  const getNumberOfEmptyLinesBetween = (currentImport, previousImport) => {\n    const linesBetweenImports = context.getSourceCode().lines.slice(\n      previousImport.node.loc.end.line,\n      currentImport.node.loc.start.line - 1,\n    );\n\n    return linesBetweenImports.filter((line) => !line.trim().length).length;\n  };\n  const getIsStartOfDistinctGroup = (currentImport, previousImport) => currentImport.rank - 1 >= previousImport.rank;\n  let previousImport = imported[0];\n\n  imported.slice(1).forEach(function (currentImport) {\n    const emptyLinesBetween = getNumberOfEmptyLinesBetween(currentImport, previousImport);\n    const isStartOfDistinctGroup = getIsStartOfDistinctGroup(currentImport, previousImport);\n\n    if (newlinesBetweenImports === 'always'\n        || newlinesBetweenImports === 'always-and-inside-groups') {\n      if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {\n        if (distinctGroup || !distinctGroup && isStartOfDistinctGroup) {\n          context.report({\n            node: previousImport.node,\n            message: 'There should be at least one empty line between import groups',\n            fix: fixNewLineAfterImport(context, previousImport),\n          });\n        }\n      } else if (emptyLinesBetween > 0\n        && newlinesBetweenImports !== 'always-and-inside-groups') {\n        if (distinctGroup && currentImport.rank === previousImport.rank || !distinctGroup && !isStartOfDistinctGroup) {\n          context.report({\n            node: previousImport.node,\n            message: 'There should be no empty line within import group',\n            fix: removeNewLineAfterImport(context, currentImport, previousImport),\n          });\n        }\n      }\n    } else if (emptyLinesBetween > 0) {\n      context.report({\n        node: previousImport.node,\n        message: 'There should be no empty line between import groups',\n        fix: removeNewLineAfterImport(context, currentImport, previousImport),\n      });\n    }\n\n    previousImport = currentImport;\n  });\n}\n\nfunction getAlphabetizeConfig(options) {\n  const alphabetize = options.alphabetize || {};\n  const order = alphabetize.order || 'ignore';\n  const orderImportKind = alphabetize.orderImportKind || 'ignore';\n  const caseInsensitive = alphabetize.caseInsensitive || false;\n\n  return { order, orderImportKind, caseInsensitive };\n}\n\n// TODO, semver-major: Change the default of \"distinctGroup\" from true to false\nconst defaultDistinctGroup = true;\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Enforce a convention in module import order.',\n      url: docsUrl('order'),\n    },\n\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          groups: {\n            type: 'array',\n          },\n          pathGroupsExcludedImportTypes: {\n            type: 'array',\n          },\n          distinctGroup: {\n            type: 'boolean',\n            default: defaultDistinctGroup,\n          },\n          pathGroups: {\n            type: 'array',\n            items: {\n              type: 'object',\n              properties: {\n                pattern: {\n                  type: 'string',\n                },\n                patternOptions: {\n                  type: 'object',\n                },\n                group: {\n                  type: 'string',\n                  enum: types,\n                },\n                position: {\n                  type: 'string',\n                  enum: ['after', 'before'],\n                },\n              },\n              additionalProperties: false,\n              required: ['pattern', 'group'],\n            },\n          },\n          'newlines-between': {\n            enum: [\n              'ignore',\n              'always',\n              'always-and-inside-groups',\n              'never',\n            ],\n          },\n          alphabetize: {\n            type: 'object',\n            properties: {\n              caseInsensitive: {\n                type: 'boolean',\n                default: false,\n              },\n              order: {\n                enum: ['ignore', 'asc', 'desc'],\n                default: 'ignore',\n              },\n              orderImportKind: {\n                enum: ['ignore', 'asc', 'desc'],\n                default: 'ignore',\n              },\n            },\n            additionalProperties: false,\n          },\n          warnOnUnassignedImports: {\n            type: 'boolean',\n            default: false,\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create: function importOrderRule(context) {\n    const options = context.options[0] || {};\n    const newlinesBetweenImports = options['newlines-between'] || 'ignore';\n    const pathGroupsExcludedImportTypes = new Set(options.pathGroupsExcludedImportTypes || ['builtin', 'external', 'object']);\n    const alphabetize = getAlphabetizeConfig(options);\n    const distinctGroup = options.distinctGroup == null ? defaultDistinctGroup : !!options.distinctGroup;\n    let ranks;\n\n    try {\n      const { pathGroups, maxPosition } = convertPathGroupsForRanks(options.pathGroups || []);\n      const { groups, omittedTypes } = convertGroupsToRanks(options.groups || defaultGroups);\n      ranks = {\n        groups,\n        omittedTypes,\n        pathGroups,\n        maxPosition,\n      };\n    } catch (error) {\n      // Malformed configuration\n      return {\n        Program(node) {\n          context.report(node, error.message);\n        },\n      };\n    }\n    const importMap = new Map();\n\n    function getBlockImports(node) {\n      if (!importMap.has(node)) {\n        importMap.set(node, []);\n      }\n      return importMap.get(node);\n    }\n\n    return {\n      ImportDeclaration: function handleImports(node) {\n        // Ignoring unassigned imports unless warnOnUnassignedImports is set\n        if (node.specifiers.length || options.warnOnUnassignedImports) {\n          const name = node.source.value;\n          registerNode(\n            context,\n            {\n              node,\n              value: name,\n              displayName: name,\n              type: 'import',\n            },\n            ranks,\n            getBlockImports(node.parent),\n            pathGroupsExcludedImportTypes,\n          );\n        }\n      },\n      TSImportEqualsDeclaration: function handleImports(node) {\n        let displayName;\n        let value;\n        let type;\n        // skip \"export import\"s\n        if (node.isExport) {\n          return;\n        }\n        if (node.moduleReference.type === 'TSExternalModuleReference') {\n          value = node.moduleReference.expression.value;\n          displayName = value;\n          type = 'import';\n        } else {\n          value = '';\n          displayName = context.getSourceCode().getText(node.moduleReference);\n          type = 'import:object';\n        }\n        registerNode(\n          context,\n          {\n            node,\n            value,\n            displayName,\n            type,\n          },\n          ranks,\n          getBlockImports(node.parent),\n          pathGroupsExcludedImportTypes,\n        );\n      },\n      CallExpression: function handleRequires(node) {\n        if (!isStaticRequire(node)) {\n          return;\n        }\n        const block = getRequireBlock(node);\n        if (!block) {\n          return;\n        }\n        const name = node.arguments[0].value;\n        registerNode(\n          context,\n          {\n            node,\n            value: name,\n            displayName: name,\n            type: 'require',\n          },\n          ranks,\n          getBlockImports(block),\n          pathGroupsExcludedImportTypes,\n        );\n      },\n      'Program:exit': function reportAndReset() {\n        importMap.forEach((imported) => {\n          if (newlinesBetweenImports !== 'ignore') {\n            makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup);\n          }\n\n          if (alphabetize.order !== 'ignore') {\n            mutateRanksToAlphabetize(imported, alphabetize);\n          }\n\n          makeOutOfOrderReport(context, imported);\n        });\n\n        importMap.clear();\n      },\n    };\n  },\n};\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/order.js"],"names":["defaultGroups","reverse","array","map","v","rank","getTokensOrCommentsAfter","sourceCode","node","count","currentNodeOrToken","result","i","getTokenOrCommentAfter","push","getTokensOrCommentsBefore","getTokenOrCommentBefore","takeTokensAfterWhile","condition","tokens","length","takeTokensBeforeWhile","findOutOfOrder","imported","maxSeenRankNode","filter","importedModule","res","findRootNode","parent","body","findEndOfLineWithComments","tokensToEndOfLine","commentOnSameLineAs","endOfTokens","range","text","token","type","loc","start","line","end","findStartOfLineWithComments","startOfTokens","isRequireExpression","expr","callee","name","arguments","isSupportedRequireModule","declarations","decl","isPlainRequire","id","init","isRequireWithMemberExpression","object","isPlainImportModule","specifiers","isPlainImportEquals","moduleReference","expression","canCrossNodeWhileReorder","canReorderItems","firstNode","secondNode","indexOf","sort","firstIndex","secondIndex","nodesBetween","slice","nodeBetween","makeImportDescription","importKind","fixOutOfOrder","context","order","getSourceCode","firstRoot","firstRootStart","firstRootEnd","secondRoot","secondRootStart","secondRootEnd","canFix","newCode","substring","firstImport","displayName","secondImport","message","report","fix","fixer","replaceTextRange","reportOutOfOrder","outOfOrder","forEach","imp","found","find","hasHigherRank","importedItem","makeOutOfOrderReport","reversedImported","reversedOrder","compareString","a","b","DEAFULT_IMPORT_KIND","getNormalizedValue","toLowerCase","value","String","getSorter","alphabetizeOptions","multiplier","orderImportKind","multiplierImportKind","importsSorter","nodeA","nodeB","importA","caseInsensitive","importB","A","split","B","Math","min","mutateRanksToAlphabetize","groupedByRanks","item","sorterFn","groupRanks","Object","keys","groupRank","newRank","alphabetizedRanks","reduce","acc","parseInt","computePathRank","ranks","pathGroups","path","maxPosition","l","pattern","patternOptions","group","position","nocomment","computeRank","importEntry","excludedImportTypes","impType","omittedTypes","has","groups","startsWith","registerNode","getRequireBlock","n","types","convertGroupsToRanks","rankObject","index","concat","groupItem","Error","JSON","stringify","undefined","convertPathGroupsForRanks","after","before","transformed","pathGroup","positionString","groupLength","groupIndex","max","key","groupNextPosition","pow","ceil","log10","fixNewLineAfterImport","previousImport","prevRoot","endOfLine","insertTextAfterRange","removeNewLineAfterImport","currentImport","currRoot","rangeToRemove","test","removeRange","makeNewlinesBetweenReport","newlinesBetweenImports","distinctGroup","getNumberOfEmptyLinesBetween","linesBetweenImports","lines","trim","getIsStartOfDistinctGroup","emptyLinesBetween","isStartOfDistinctGroup","getAlphabetizeConfig","options","alphabetize","defaultDistinctGroup","module","exports","meta","docs","category","description","url","fixable","schema","properties","pathGroupsExcludedImportTypes","items","additionalProperties","required","warnOnUnassignedImports","create","importOrderRule","Set","error","Program","importMap","Map","getBlockImports","set","get","ImportDeclaration","handleImports","source","TSImportEqualsDeclaration","isExport","getText","CallExpression","handleRequires","block","reportAndReset","clear"],"mappings":"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","file":"order.js","sourcesContent":["'use strict';\n\nimport minimatch from 'minimatch';\nimport includes from 'array-includes';\nimport groupBy from 'object.groupby';\n\nimport importType from '../core/importType';\nimport isStaticRequire from '../core/staticRequire';\nimport docsUrl from '../docsUrl';\n\nconst defaultGroups = ['builtin', 'external', 'parent', 'sibling', 'index'];\n\n// REPORTING AND FIXING\n\nfunction reverse(array) {\n  return array.map(function (v) {\n    return { ...v, rank: -v.rank };\n  }).reverse();\n}\n\nfunction getTokensOrCommentsAfter(sourceCode, node, count) {\n  let currentNodeOrToken = node;\n  const result = [];\n  for (let i = 0; i < count; i++) {\n    currentNodeOrToken = sourceCode.getTokenOrCommentAfter(currentNodeOrToken);\n    if (currentNodeOrToken == null) {\n      break;\n    }\n    result.push(currentNodeOrToken);\n  }\n  return result;\n}\n\nfunction getTokensOrCommentsBefore(sourceCode, node, count) {\n  let currentNodeOrToken = node;\n  const result = [];\n  for (let i = 0; i < count; i++) {\n    currentNodeOrToken = sourceCode.getTokenOrCommentBefore(currentNodeOrToken);\n    if (currentNodeOrToken == null) {\n      break;\n    }\n    result.push(currentNodeOrToken);\n  }\n  return result.reverse();\n}\n\nfunction takeTokensAfterWhile(sourceCode, node, condition) {\n  const tokens = getTokensOrCommentsAfter(sourceCode, node, 100);\n  const result = [];\n  for (let i = 0; i < tokens.length; i++) {\n    if (condition(tokens[i])) {\n      result.push(tokens[i]);\n    } else {\n      break;\n    }\n  }\n  return result;\n}\n\nfunction takeTokensBeforeWhile(sourceCode, node, condition) {\n  const tokens = getTokensOrCommentsBefore(sourceCode, node, 100);\n  const result = [];\n  for (let i = tokens.length - 1; i >= 0; i--) {\n    if (condition(tokens[i])) {\n      result.push(tokens[i]);\n    } else {\n      break;\n    }\n  }\n  return result.reverse();\n}\n\nfunction findOutOfOrder(imported) {\n  if (imported.length === 0) {\n    return [];\n  }\n  let maxSeenRankNode = imported[0];\n  return imported.filter(function (importedModule) {\n    const res = importedModule.rank < maxSeenRankNode.rank;\n    if (maxSeenRankNode.rank < importedModule.rank) {\n      maxSeenRankNode = importedModule;\n    }\n    return res;\n  });\n}\n\nfunction findRootNode(node) {\n  let parent = node;\n  while (parent.parent != null && parent.parent.body == null) {\n    parent = parent.parent;\n  }\n  return parent;\n}\n\nfunction findEndOfLineWithComments(sourceCode, node) {\n  const tokensToEndOfLine = takeTokensAfterWhile(sourceCode, node, commentOnSameLineAs(node));\n  const endOfTokens = tokensToEndOfLine.length > 0\n    ? tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1]\n    : node.range[1];\n  let result = endOfTokens;\n  for (let i = endOfTokens; i < sourceCode.text.length; i++) {\n    if (sourceCode.text[i] === '\\n') {\n      result = i + 1;\n      break;\n    }\n    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\\t' && sourceCode.text[i] !== '\\r') {\n      break;\n    }\n    result = i + 1;\n  }\n  return result;\n}\n\nfunction commentOnSameLineAs(node) {\n  return (token) => (token.type === 'Block' ||  token.type === 'Line')\n      && token.loc.start.line === token.loc.end.line\n      && token.loc.end.line === node.loc.end.line;\n}\n\nfunction findStartOfLineWithComments(sourceCode, node) {\n  const tokensToEndOfLine = takeTokensBeforeWhile(sourceCode, node, commentOnSameLineAs(node));\n  const startOfTokens = tokensToEndOfLine.length > 0 ? tokensToEndOfLine[0].range[0] : node.range[0];\n  let result = startOfTokens;\n  for (let i = startOfTokens - 1; i > 0; i--) {\n    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\\t') {\n      break;\n    }\n    result = i;\n  }\n  return result;\n}\n\nfunction isRequireExpression(expr) {\n  return expr != null\n    && expr.type === 'CallExpression'\n    && expr.callee != null\n    && expr.callee.name === 'require'\n    && expr.arguments != null\n    && expr.arguments.length === 1\n    && expr.arguments[0].type === 'Literal';\n}\n\nfunction isSupportedRequireModule(node) {\n  if (node.type !== 'VariableDeclaration') {\n    return false;\n  }\n  if (node.declarations.length !== 1) {\n    return false;\n  }\n  const decl = node.declarations[0];\n  const isPlainRequire = decl.id\n    && (decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern')\n    && isRequireExpression(decl.init);\n  const isRequireWithMemberExpression = decl.id\n    && (decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern')\n    && decl.init != null\n    && decl.init.type === 'CallExpression'\n    && decl.init.callee != null\n    && decl.init.callee.type === 'MemberExpression'\n    && isRequireExpression(decl.init.callee.object);\n  return isPlainRequire || isRequireWithMemberExpression;\n}\n\nfunction isPlainImportModule(node) {\n  return node.type === 'ImportDeclaration' && node.specifiers != null && node.specifiers.length > 0;\n}\n\nfunction isPlainImportEquals(node) {\n  return node.type === 'TSImportEqualsDeclaration' && node.moduleReference.expression;\n}\n\nfunction canCrossNodeWhileReorder(node) {\n  return isSupportedRequireModule(node) || isPlainImportModule(node) || isPlainImportEquals(node);\n}\n\nfunction canReorderItems(firstNode, secondNode) {\n  const parent = firstNode.parent;\n  const [firstIndex, secondIndex] = [\n    parent.body.indexOf(firstNode),\n    parent.body.indexOf(secondNode),\n  ].sort();\n  const nodesBetween = parent.body.slice(firstIndex, secondIndex + 1);\n  for (const nodeBetween of nodesBetween) {\n    if (!canCrossNodeWhileReorder(nodeBetween)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction makeImportDescription(node) {\n  if (node.node.importKind === 'type') {\n    return 'type import';\n  }\n  if (node.node.importKind === 'typeof') {\n    return 'typeof import';\n  }\n  return 'import';\n}\n\nfunction fixOutOfOrder(context, firstNode, secondNode, order) {\n  const sourceCode = context.getSourceCode();\n\n  const firstRoot = findRootNode(firstNode.node);\n  const firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot);\n  const firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot);\n\n  const secondRoot = findRootNode(secondNode.node);\n  const secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot);\n  const secondRootEnd = findEndOfLineWithComments(sourceCode, secondRoot);\n  const canFix = canReorderItems(firstRoot, secondRoot);\n\n  let newCode = sourceCode.text.substring(secondRootStart, secondRootEnd);\n  if (newCode[newCode.length - 1] !== '\\n') {\n    newCode = `${newCode}\\n`;\n  }\n\n  const firstImport = `${makeImportDescription(firstNode)} of \\`${firstNode.displayName}\\``;\n  const secondImport = `\\`${secondNode.displayName}\\` ${makeImportDescription(secondNode)}`;\n  const message = `${secondImport} should occur ${order} ${firstImport}`;\n\n  if (order === 'before') {\n    context.report({\n      node: secondNode.node,\n      message,\n      fix: canFix && ((fixer) => fixer.replaceTextRange(\n        [firstRootStart, secondRootEnd],\n        newCode + sourceCode.text.substring(firstRootStart, secondRootStart),\n      )),\n    });\n  } else if (order === 'after') {\n    context.report({\n      node: secondNode.node,\n      message,\n      fix: canFix && ((fixer) => fixer.replaceTextRange(\n        [secondRootStart, firstRootEnd],\n        sourceCode.text.substring(secondRootEnd, firstRootEnd) + newCode,\n      )),\n    });\n  }\n}\n\nfunction reportOutOfOrder(context, imported, outOfOrder, order) {\n  outOfOrder.forEach(function (imp) {\n    const found = imported.find(function hasHigherRank(importedItem) {\n      return importedItem.rank > imp.rank;\n    });\n    fixOutOfOrder(context, found, imp, order);\n  });\n}\n\nfunction makeOutOfOrderReport(context, imported) {\n  const outOfOrder = findOutOfOrder(imported);\n  if (!outOfOrder.length) {\n    return;\n  }\n\n  // There are things to report. Try to minimize the number of reported errors.\n  const reversedImported = reverse(imported);\n  const reversedOrder = findOutOfOrder(reversedImported);\n  if (reversedOrder.length < outOfOrder.length) {\n    reportOutOfOrder(context, reversedImported, reversedOrder, 'after');\n    return;\n  }\n  reportOutOfOrder(context, imported, outOfOrder, 'before');\n}\n\nconst compareString = (a, b) => {\n  if (a < b) {\n    return -1;\n  }\n  if (a > b) {\n    return 1;\n  }\n  return 0;\n};\n\n/** Some parsers (languages without types) don't provide ImportKind */\nconst DEAFULT_IMPORT_KIND = 'value';\nconst getNormalizedValue = (node, toLowerCase) => {\n  const value = node.value;\n  return toLowerCase ? String(value).toLowerCase() : value;\n};\n\nfunction getSorter(alphabetizeOptions) {\n  const multiplier = alphabetizeOptions.order === 'asc' ? 1 : -1;\n  const orderImportKind = alphabetizeOptions.orderImportKind;\n  const multiplierImportKind = orderImportKind !== 'ignore'\n    && (alphabetizeOptions.orderImportKind === 'asc' ? 1 : -1);\n\n  return function importsSorter(nodeA, nodeB) {\n    const importA = getNormalizedValue(nodeA, alphabetizeOptions.caseInsensitive);\n    const importB = getNormalizedValue(nodeB, alphabetizeOptions.caseInsensitive);\n    let result = 0;\n\n    if (!includes(importA, '/') && !includes(importB, '/')) {\n      result = compareString(importA, importB);\n    } else {\n      const A = importA.split('/');\n      const B = importB.split('/');\n      const a = A.length;\n      const b = B.length;\n\n      for (let i = 0; i < Math.min(a, b); i++) {\n        result = compareString(A[i], B[i]);\n        if (result) { break; }\n      }\n\n      if (!result && a !== b) {\n        result = a < b ? -1 : 1;\n      }\n    }\n\n    result = result * multiplier;\n\n    // In case the paths are equal (result === 0), sort them by importKind\n    if (!result && multiplierImportKind) {\n      result = multiplierImportKind * compareString(\n        nodeA.node.importKind || DEAFULT_IMPORT_KIND,\n        nodeB.node.importKind || DEAFULT_IMPORT_KIND,\n      );\n    }\n\n    return result;\n  };\n}\n\nfunction mutateRanksToAlphabetize(imported, alphabetizeOptions) {\n  const groupedByRanks = groupBy(imported, (item) => item.rank);\n\n  const sorterFn = getSorter(alphabetizeOptions);\n\n  // sort group keys so that they can be iterated on in order\n  const groupRanks = Object.keys(groupedByRanks).sort(function (a, b) {\n    return a - b;\n  });\n\n  // sort imports locally within their group\n  groupRanks.forEach(function (groupRank) {\n    groupedByRanks[groupRank].sort(sorterFn);\n  });\n\n  // assign globally unique rank to each import\n  let newRank = 0;\n  const alphabetizedRanks = groupRanks.reduce(function (acc, groupRank) {\n    groupedByRanks[groupRank].forEach(function (importedItem) {\n      acc[`${importedItem.value}|${importedItem.node.importKind}`] = parseInt(groupRank, 10) + newRank;\n      newRank += 1;\n    });\n    return acc;\n  }, {});\n\n  // mutate the original group-rank with alphabetized-rank\n  imported.forEach(function (importedItem) {\n    importedItem.rank = alphabetizedRanks[`${importedItem.value}|${importedItem.node.importKind}`];\n  });\n}\n\n// DETECTING\n\nfunction computePathRank(ranks, pathGroups, path, maxPosition) {\n  for (let i = 0, l = pathGroups.length; i < l; i++) {\n    const { pattern, patternOptions, group, position = 1 } = pathGroups[i];\n    if (minimatch(path, pattern, patternOptions || { nocomment: true })) {\n      return ranks[group] + position / maxPosition;\n    }\n  }\n}\n\nfunction computeRank(context, ranks, importEntry, excludedImportTypes) {\n  let impType;\n  let rank;\n  if (importEntry.type === 'import:object') {\n    impType = 'object';\n  } else if (importEntry.node.importKind === 'type' && ranks.omittedTypes.indexOf('type') === -1) {\n    impType = 'type';\n  } else {\n    impType = importType(importEntry.value, context);\n  }\n  if (!excludedImportTypes.has(impType)) {\n    rank = computePathRank(ranks.groups, ranks.pathGroups, importEntry.value, ranks.maxPosition);\n  }\n  if (typeof rank === 'undefined') {\n    rank = ranks.groups[impType];\n  }\n  if (importEntry.type !== 'import' && !importEntry.type.startsWith('import:')) {\n    rank += 100;\n  }\n\n  return rank;\n}\n\nfunction registerNode(context, importEntry, ranks, imported, excludedImportTypes) {\n  const rank = computeRank(context, ranks, importEntry, excludedImportTypes);\n  if (rank !== -1) {\n    imported.push({ ...importEntry, rank });\n  }\n}\n\nfunction getRequireBlock(node) {\n  let n = node;\n  // Handle cases like `const baz = require('foo').bar.baz`\n  // and `const foo = require('foo')()`\n  while (\n    n.parent.type === 'MemberExpression' && n.parent.object === n\n    || n.parent.type === 'CallExpression' && n.parent.callee === n\n  ) {\n    n = n.parent;\n  }\n  if (\n    n.parent.type === 'VariableDeclarator'\n    && n.parent.parent.type === 'VariableDeclaration'\n    && n.parent.parent.parent.type === 'Program'\n  ) {\n    return n.parent.parent.parent;\n  }\n}\n\nconst types = ['builtin', 'external', 'internal', 'unknown', 'parent', 'sibling', 'index', 'object', 'type'];\n\n// Creates an object with type-rank pairs.\n// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }\n// Will throw an error if it contains a type that does not exist, or has a duplicate\nfunction convertGroupsToRanks(groups) {\n  const rankObject = groups.reduce(function (res, group, index) {\n    [].concat(group).forEach(function (groupItem) {\n      if (types.indexOf(groupItem) === -1) {\n        throw new Error(`Incorrect configuration of the rule: Unknown type \\`${JSON.stringify(groupItem)}\\``);\n      }\n      if (res[groupItem] !== undefined) {\n        throw new Error(`Incorrect configuration of the rule: \\`${groupItem}\\` is duplicated`);\n      }\n      res[groupItem] = index * 2;\n    });\n    return res;\n  }, {});\n\n  const omittedTypes = types.filter(function (type) {\n    return typeof rankObject[type] === 'undefined';\n  });\n\n  const ranks = omittedTypes.reduce(function (res, type) {\n    res[type] = groups.length * 2;\n    return res;\n  }, rankObject);\n\n  return { groups: ranks, omittedTypes };\n}\n\nfunction convertPathGroupsForRanks(pathGroups) {\n  const after = {};\n  const before = {};\n\n  const transformed = pathGroups.map((pathGroup, index) => {\n    const { group, position: positionString } = pathGroup;\n    let position = 0;\n    if (positionString === 'after') {\n      if (!after[group]) {\n        after[group] = 1;\n      }\n      position = after[group]++;\n    } else if (positionString === 'before') {\n      if (!before[group]) {\n        before[group] = [];\n      }\n      before[group].push(index);\n    }\n\n    return { ...pathGroup, position };\n  });\n\n  let maxPosition = 1;\n\n  Object.keys(before).forEach((group) => {\n    const groupLength = before[group].length;\n    before[group].forEach((groupIndex, index) => {\n      transformed[groupIndex].position = -1 * (groupLength - index);\n    });\n    maxPosition = Math.max(maxPosition, groupLength);\n  });\n\n  Object.keys(after).forEach((key) => {\n    const groupNextPosition = after[key];\n    maxPosition = Math.max(maxPosition, groupNextPosition - 1);\n  });\n\n  return {\n    pathGroups: transformed,\n    maxPosition: maxPosition > 10 ? Math.pow(10, Math.ceil(Math.log10(maxPosition))) : 10,\n  };\n}\n\nfunction fixNewLineAfterImport(context, previousImport) {\n  const prevRoot = findRootNode(previousImport.node);\n  const tokensToEndOfLine = takeTokensAfterWhile(\n    context.getSourceCode(), prevRoot, commentOnSameLineAs(prevRoot));\n\n  let endOfLine = prevRoot.range[1];\n  if (tokensToEndOfLine.length > 0) {\n    endOfLine = tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1];\n  }\n  return (fixer) => fixer.insertTextAfterRange([prevRoot.range[0], endOfLine], '\\n');\n}\n\nfunction removeNewLineAfterImport(context, currentImport, previousImport) {\n  const sourceCode = context.getSourceCode();\n  const prevRoot = findRootNode(previousImport.node);\n  const currRoot = findRootNode(currentImport.node);\n  const rangeToRemove = [\n    findEndOfLineWithComments(sourceCode, prevRoot),\n    findStartOfLineWithComments(sourceCode, currRoot),\n  ];\n  if ((/^\\s*$/).test(sourceCode.text.substring(rangeToRemove[0], rangeToRemove[1]))) {\n    return (fixer) => fixer.removeRange(rangeToRemove);\n  }\n  return undefined;\n}\n\nfunction makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup) {\n  const getNumberOfEmptyLinesBetween = (currentImport, previousImport) => {\n    const linesBetweenImports = context.getSourceCode().lines.slice(\n      previousImport.node.loc.end.line,\n      currentImport.node.loc.start.line - 1,\n    );\n\n    return linesBetweenImports.filter((line) => !line.trim().length).length;\n  };\n  const getIsStartOfDistinctGroup = (currentImport, previousImport) => currentImport.rank - 1 >= previousImport.rank;\n  let previousImport = imported[0];\n\n  imported.slice(1).forEach(function (currentImport) {\n    const emptyLinesBetween = getNumberOfEmptyLinesBetween(currentImport, previousImport);\n    const isStartOfDistinctGroup = getIsStartOfDistinctGroup(currentImport, previousImport);\n\n    if (newlinesBetweenImports === 'always'\n        || newlinesBetweenImports === 'always-and-inside-groups') {\n      if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {\n        if (distinctGroup || !distinctGroup && isStartOfDistinctGroup) {\n          context.report({\n            node: previousImport.node,\n            message: 'There should be at least one empty line between import groups',\n            fix: fixNewLineAfterImport(context, previousImport),\n          });\n        }\n      } else if (emptyLinesBetween > 0\n        && newlinesBetweenImports !== 'always-and-inside-groups') {\n        if (distinctGroup && currentImport.rank === previousImport.rank || !distinctGroup && !isStartOfDistinctGroup) {\n          context.report({\n            node: previousImport.node,\n            message: 'There should be no empty line within import group',\n            fix: removeNewLineAfterImport(context, currentImport, previousImport),\n          });\n        }\n      }\n    } else if (emptyLinesBetween > 0) {\n      context.report({\n        node: previousImport.node,\n        message: 'There should be no empty line between import groups',\n        fix: removeNewLineAfterImport(context, currentImport, previousImport),\n      });\n    }\n\n    previousImport = currentImport;\n  });\n}\n\nfunction getAlphabetizeConfig(options) {\n  const alphabetize = options.alphabetize || {};\n  const order = alphabetize.order || 'ignore';\n  const orderImportKind = alphabetize.orderImportKind || 'ignore';\n  const caseInsensitive = alphabetize.caseInsensitive || false;\n\n  return { order, orderImportKind, caseInsensitive };\n}\n\n// TODO, semver-major: Change the default of \"distinctGroup\" from true to false\nconst defaultDistinctGroup = true;\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Enforce a convention in module import order.',\n      url: docsUrl('order'),\n    },\n\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          groups: {\n            type: 'array',\n          },\n          pathGroupsExcludedImportTypes: {\n            type: 'array',\n          },\n          distinctGroup: {\n            type: 'boolean',\n            default: defaultDistinctGroup,\n          },\n          pathGroups: {\n            type: 'array',\n            items: {\n              type: 'object',\n              properties: {\n                pattern: {\n                  type: 'string',\n                },\n                patternOptions: {\n                  type: 'object',\n                },\n                group: {\n                  type: 'string',\n                  enum: types,\n                },\n                position: {\n                  type: 'string',\n                  enum: ['after', 'before'],\n                },\n              },\n              additionalProperties: false,\n              required: ['pattern', 'group'],\n            },\n          },\n          'newlines-between': {\n            enum: [\n              'ignore',\n              'always',\n              'always-and-inside-groups',\n              'never',\n            ],\n          },\n          alphabetize: {\n            type: 'object',\n            properties: {\n              caseInsensitive: {\n                type: 'boolean',\n                default: false,\n              },\n              order: {\n                enum: ['ignore', 'asc', 'desc'],\n                default: 'ignore',\n              },\n              orderImportKind: {\n                enum: ['ignore', 'asc', 'desc'],\n                default: 'ignore',\n              },\n            },\n            additionalProperties: false,\n          },\n          warnOnUnassignedImports: {\n            type: 'boolean',\n            default: false,\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create: function importOrderRule(context) {\n    const options = context.options[0] || {};\n    const newlinesBetweenImports = options['newlines-between'] || 'ignore';\n    const pathGroupsExcludedImportTypes = new Set(options.pathGroupsExcludedImportTypes || ['builtin', 'external', 'object']);\n    const alphabetize = getAlphabetizeConfig(options);\n    const distinctGroup = options.distinctGroup == null ? defaultDistinctGroup : !!options.distinctGroup;\n    let ranks;\n\n    try {\n      const { pathGroups, maxPosition } = convertPathGroupsForRanks(options.pathGroups || []);\n      const { groups, omittedTypes } = convertGroupsToRanks(options.groups || defaultGroups);\n      ranks = {\n        groups,\n        omittedTypes,\n        pathGroups,\n        maxPosition,\n      };\n    } catch (error) {\n      // Malformed configuration\n      return {\n        Program(node) {\n          context.report(node, error.message);\n        },\n      };\n    }\n    const importMap = new Map();\n\n    function getBlockImports(node) {\n      if (!importMap.has(node)) {\n        importMap.set(node, []);\n      }\n      return importMap.get(node);\n    }\n\n    return {\n      ImportDeclaration: function handleImports(node) {\n        // Ignoring unassigned imports unless warnOnUnassignedImports is set\n        if (node.specifiers.length || options.warnOnUnassignedImports) {\n          const name = node.source.value;\n          registerNode(\n            context,\n            {\n              node,\n              value: name,\n              displayName: name,\n              type: 'import',\n            },\n            ranks,\n            getBlockImports(node.parent),\n            pathGroupsExcludedImportTypes,\n          );\n        }\n      },\n      TSImportEqualsDeclaration: function handleImports(node) {\n        let displayName;\n        let value;\n        let type;\n        // skip \"export import\"s\n        if (node.isExport) {\n          return;\n        }\n        if (node.moduleReference.type === 'TSExternalModuleReference') {\n          value = node.moduleReference.expression.value;\n          displayName = value;\n          type = 'import';\n        } else {\n          value = '';\n          displayName = context.getSourceCode().getText(node.moduleReference);\n          type = 'import:object';\n        }\n        registerNode(\n          context,\n          {\n            node,\n            value,\n            displayName,\n            type,\n          },\n          ranks,\n          getBlockImports(node.parent),\n          pathGroupsExcludedImportTypes,\n        );\n      },\n      CallExpression: function handleRequires(node) {\n        if (!isStaticRequire(node)) {\n          return;\n        }\n        const block = getRequireBlock(node);\n        if (!block) {\n          return;\n        }\n        const name = node.arguments[0].value;\n        registerNode(\n          context,\n          {\n            node,\n            value: name,\n            displayName: name,\n            type: 'require',\n          },\n          ranks,\n          getBlockImports(block),\n          pathGroupsExcludedImportTypes,\n        );\n      },\n      'Program:exit': function reportAndReset() {\n        importMap.forEach((imported) => {\n          if (newlinesBetweenImports !== 'ignore') {\n            makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup);\n          }\n\n          if (alphabetize.order !== 'ignore') {\n            mutateRanksToAlphabetize(imported, alphabetize);\n          }\n\n          makeOutOfOrderReport(context, imported);\n        });\n\n        importMap.clear();\n      },\n    };\n  },\n};\n"]} \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/lib/scc.js b/node_modules/eslint-plugin-import/lib/scc.js deleted file mode 100644 index 82eff7196d..0000000000 --- a/node_modules/eslint-plugin-import/lib/scc.js +++ /dev/null @@ -1,86 +0,0 @@ -'use strict';Object.defineProperty(exports, "__esModule", { value: true });var _createClass = function () {function defineProperties(target, props) {for (var i = 0; i < props.length; i++) {var descriptor = props[i];descriptor.enumerable = descriptor.enumerable || false;descriptor.configurable = true;if ("value" in descriptor) descriptor.writable = true;Object.defineProperty(target, descriptor.key, descriptor);}}return function (Constructor, protoProps, staticProps) {if (protoProps) defineProperties(Constructor.prototype, protoProps);if (staticProps) defineProperties(Constructor, staticProps);return Constructor;};}();var _scc = require('@rtsao/scc');var _scc2 = _interopRequireDefault(_scc); -var _hash = require('eslint-module-utils/hash'); -var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve); -var _builder = require('./exportMap/builder');var _builder2 = _interopRequireDefault(_builder); -var _childContext = require('./exportMap/childContext');var _childContext2 = _interopRequireDefault(_childContext);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}function _toConsumableArray(arr) {if (Array.isArray(arr)) {for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {arr2[i] = arr[i];}return arr2;} else {return Array.from(arr);}}function _classCallCheck(instance, Constructor) {if (!(instance instanceof Constructor)) {throw new TypeError("Cannot call a class as a function");}} - -var cache = new Map();var - -StronglyConnectedComponentsBuilder = function () {function StronglyConnectedComponentsBuilder() {_classCallCheck(this, StronglyConnectedComponentsBuilder);}_createClass(StronglyConnectedComponentsBuilder, null, [{ key: 'clearCache', value: function () {function clearCache() - { - cache = new Map(); - }return clearCache;}() }, { key: 'get', value: function () {function get( - - source, context) { - var path = (0, _resolve2['default'])(source, context); - if (path == null) {return null;} - return StronglyConnectedComponentsBuilder['for']((0, _childContext2['default'])(path, context)); - }return get;}() }, { key: 'for', value: function () {function _for( - - context) { - var cacheKey = context.cacheKey || (0, _hash.hashObject)(context).digest('hex'); - if (cache.has(cacheKey)) { - return cache.get(cacheKey); - } - var scc = StronglyConnectedComponentsBuilder.calculate(context); - cache.set(cacheKey, scc); - return scc; - }return _for;}() }, { key: 'calculate', value: function () {function calculate( - - context) { - var exportMap = _builder2['default']['for'](context); - var adjacencyList = this.exportMapToAdjacencyList(exportMap); - var calculatedScc = (0, _scc2['default'])(adjacencyList); - return StronglyConnectedComponentsBuilder.calculatedSccToPlainObject(calculatedScc); - }return calculate;}() - - /** @returns {Map>} for each dep, what are its direct deps */ }, { key: 'exportMapToAdjacencyList', value: function () {function exportMapToAdjacencyList( - initialExportMap) { - var adjacencyList = new Map(); - // BFS - function visitNode(exportMap) { - if (!exportMap) { - return; - } - exportMap.imports.forEach(function (v, importedPath) { - var from = exportMap.path; - var to = importedPath; - - // Ignore type-only imports, because we care only about SCCs of value imports - var toTraverse = [].concat(_toConsumableArray(v.declarations)).filter(function (_ref) {var isOnlyImportingTypes = _ref.isOnlyImportingTypes;return !isOnlyImportingTypes;}); - if (toTraverse.length === 0) {return;} - - if (!adjacencyList.has(from)) { - adjacencyList.set(from, new Set()); - } - - if (adjacencyList.get(from).has(to)) { - return; // prevent endless loop - } - adjacencyList.get(from).add(to); - visitNode(v.getter()); - }); - } - visitNode(initialExportMap); - // Fill gaps - adjacencyList.forEach(function (values) { - values.forEach(function (value) { - if (!adjacencyList.has(value)) { - adjacencyList.set(value, new Set()); - } - }); - }); - return adjacencyList; - }return exportMapToAdjacencyList;}() - - /** @returns {Record} for each key, its SCC's index */ }, { key: 'calculatedSccToPlainObject', value: function () {function calculatedSccToPlainObject( - sccs) { - var obj = {}; - sccs.forEach(function (scc, index) { - scc.forEach(function (node) { - obj[node] = index; - }); - }); - return obj; - }return calculatedSccToPlainObject;}() }]);return StronglyConnectedComponentsBuilder;}();exports['default'] = StronglyConnectedComponentsBuilder; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/node_modules/eslint-plugin-import/package.json b/node_modules/eslint-plugin-import/package.json index be150064d6..5c0af48543 100644 --- a/node_modules/eslint-plugin-import/package.json +++ b/node_modules/eslint-plugin-import/package.json @@ -1,6 +1,6 @@ { "name": "eslint-plugin-import", - "version": "2.30.0", + "version": "2.29.1", "description": "Import with sanity.", "engines": { "node": ">=4" @@ -11,7 +11,6 @@ }, "files": [ "*.md", - "!{CONTRIBUTING,RELEASE}.md", "LICENSE", "docs", "lib", @@ -31,9 +30,6 @@ "test": "npm run tests-only", "test-compiled": "npm run prepublish && BABEL_ENV=testCompiled mocha --compilers js:babel-register tests/src", "test-all": "node --require babel-register ./scripts/testAll", - "test-examples": "npm run build && npm run test-example:legacy && npm run test-example:flat", - "test-example:legacy": "cd examples/legacy && npm install && npm run lint", - "test-example:flat": "cd examples/flat && npm install && npm run lint", "prepublishOnly": "safe-publish-latest && npm run build", "prepublish": "not-in-publish || npm run prepublishOnly", "preupdate:eslint-docs": "npm run build", @@ -86,15 +82,13 @@ "eslint-plugin-eslint-plugin": "^2.3.0", "eslint-plugin-import": "2.x", "eslint-plugin-json": "^2.1.2", - "find-babel-config": "=1.2.0", "fs-copy-file-sync": "^1.1.1", "glob": "^7.2.3", "in-publish": "^2.0.1", "jackspeak": "=2.1.1", - "jsonc-parser": "=3.2.0", "linklocal": "^2.8.2", "lodash.isarray": "^4.0.0", - "markdownlint-cli": "~0.35", + "markdownlint-cli": "^0.38.0", "mocha": "^3.5.3", "npm-which": "^3.0.1", "nyc": "^11.9.0", @@ -109,22 +103,21 @@ "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8" }, "dependencies": { - "@rtsao/scc": "^1.1.0", - "array-includes": "^3.1.8", - "array.prototype.findlastindex": "^1.2.5", + "array-includes": "^3.1.7", + "array.prototype.findlastindex": "^1.2.3", "array.prototype.flat": "^1.3.2", "array.prototype.flatmap": "^1.3.2", "debug": "^3.2.7", "doctrine": "^2.1.0", "eslint-import-resolver-node": "^0.3.9", - "eslint-module-utils": "^2.9.0", - "hasown": "^2.0.2", - "is-core-module": "^2.15.1", + "eslint-module-utils": "^2.8.0", + "hasown": "^2.0.0", + "is-core-module": "^2.13.1", "is-glob": "^4.0.3", "minimatch": "^3.1.2", - "object.fromentries": "^2.0.8", - "object.groupby": "^1.0.3", - "object.values": "^1.2.0", + "object.fromentries": "^2.0.7", + "object.groupby": "^1.0.1", + "object.values": "^1.1.7", "semver": "^6.3.1", "tsconfig-paths": "^3.15.0" } diff --git a/package-lock.json b/package-lock.json index 0f079b13d9..141269a745 100644 --- a/package-lock.json +++ b/package-lock.json @@ -59,7 +59,7 @@ "eslint-import-resolver-typescript": "^3.6.3", "eslint-plugin-filenames": "^1.3.2", "eslint-plugin-github": "^5.0.2", - "eslint-plugin-import": "~2.30.0", + "eslint-plugin-import": "^2.29.1", "eslint-plugin-no-async-foreach": "^0.1.1", "micromatch": "4.0.8", "nock": "^13.5.5", @@ -867,12 +867,6 @@ "dev": true, "license": "0BSD" }, - "node_modules/@rtsao/scc": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz", - "integrity": "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==", - "dev": true - }, "node_modules/@schemastore/package": { "version": "0.0.10", "license": "MIT" @@ -2836,27 +2830,26 @@ } }, "node_modules/eslint-plugin-import": { - "version": "2.30.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.30.0.tgz", - "integrity": "sha512-/mHNE9jINJfiD2EKkg1BKyPyUk4zdnT54YgbOgfjSakWT5oyX/qQLVNTkehyfpcMxZXMy1zyonZ2v7hZTX43Yw==", + "version": "2.29.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.29.1.tgz", + "integrity": "sha512-BbPC0cuExzhiMo4Ff1BTVwHpjjv28C5R+btTOGaCRC7UEz801up0JadwkeSk5Ued6TG34uaczuVuH6qyy5YUxw==", "dev": true, "dependencies": { - "@rtsao/scc": "^1.1.0", - "array-includes": "^3.1.8", - "array.prototype.findlastindex": "^1.2.5", + "array-includes": "^3.1.7", + "array.prototype.findlastindex": "^1.2.3", "array.prototype.flat": "^1.3.2", "array.prototype.flatmap": "^1.3.2", "debug": "^3.2.7", "doctrine": "^2.1.0", "eslint-import-resolver-node": "^0.3.9", - "eslint-module-utils": "^2.9.0", - "hasown": "^2.0.2", - "is-core-module": "^2.15.1", + "eslint-module-utils": "^2.8.0", + "hasown": "^2.0.0", + "is-core-module": "^2.13.1", "is-glob": "^4.0.3", "minimatch": "^3.1.2", - "object.fromentries": "^2.0.8", - "object.groupby": "^1.0.3", - "object.values": "^1.2.0", + "object.fromentries": "^2.0.7", + "object.groupby": "^1.0.1", + "object.values": "^1.1.7", "semver": "^6.3.1", "tsconfig-paths": "^3.15.0" }, diff --git a/package.json b/package.json index 95b53f21a7..811a86c780 100644 --- a/package.json +++ b/package.json @@ -75,7 +75,7 @@ "eslint-import-resolver-typescript": "^3.6.3", "eslint-plugin-filenames": "^1.3.2", "eslint-plugin-github": "^5.0.2", - "eslint-plugin-import": "~2.30.0", + "eslint-plugin-import": "^2.29.1", "eslint-plugin-no-async-foreach": "^0.1.1", "micromatch": "4.0.8", "nock": "^13.5.5",