├── .github
    └── workflows
    │   └── ci.yml
├── .gitignore
├── CHANGELOG.md
├── INTEGRATIONS.md
├── LICENSE
├── OTHER_PLUGINS.md
├── README.md
├── package.json
├── rollup.config.js
├── src
    ├── block.js
    ├── index.js
    ├── mapping.js
    ├── postprocess.js
    ├── preprocess.js
    ├── processor_options.js
    ├── state.js
    └── utils.js
└── test
    ├── index.js
    ├── node_modules
        └── eslint-plugin-svelte3
        │   └── index.js
    └── samples
        ├── .eslintrc.js
        ├── block-filenames
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── compiler-error
            ├── Input.svelte
            └── expected.json
        ├── const-tag
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── ignore-styles
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── indentation
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── labels
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── line-endings
            ├── .eslintrc.js
            ├── Input.svelte
            ├── expected.json
            └── preserve_line_endings
        ├── module-context
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── multiline-fixes
            ├── .eslintrc.js
            ├── Fixed.svelte
            ├── Input.svelte
            └── expected.json
        ├── scope
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── script-reference
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── self-assignment
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── template-quotes
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-$$globals
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-bind-reference
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-block-filenames
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-imports
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-indentation
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-inline-type-import
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-lazy
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-multiline-fixes
            ├── .eslintrc.js
            ├── Fixed.svelte
            ├── Input.svelte
            └── expected.json
        ├── typescript-peer-dependency
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-special-types
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-template-quotes
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        ├── typescript-type-aware-rules
            ├── .eslintrc.js
            ├── Input.svelte
            ├── expected.json
            ├── store.ts
            └── tsconfig.json
        ├── typescript-unsafe-member-access
            ├── .eslintrc.js
            ├── Input.svelte
            ├── expected.json
            ├── external-file.ts
            └── tsconfig.json
        ├── typescript
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json
        └── unused-write-only-store
            ├── .eslintrc.js
            ├── Input.svelte
            └── expected.json


/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | on: [push, pull_request]
 3 | jobs:
 4 |   Tests:
 5 |     runs-on: ${{ matrix.os }}
 6 |     strategy:
 7 |       matrix:
 8 |         node-version: [14, 16, 18]
 9 |         os: [ubuntu-latest, windows-latest, macOS-latest]
10 |     steps:
11 |     - run: git config --global core.autocrlf false
12 |     - uses: actions/checkout@v1
13 |     - uses: actions/setup-node@v1
14 |       with:
15 |         node-version: ${{ matrix.node-version }}
16 |     - run: npm install
17 |     - run: npm test
18 |       env:
19 |         CI: true
20 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /index.js
2 | /node_modules
3 | /package-lock.json
4 | /pnpm-lock.yaml
5 | /test/samples/*/actual.json
6 | /yarn.lock
7 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # 4.0.0
  2 | 
  3 | - Breaking change: ESLint 8+ is now required
  4 | 
  5 | # 3.4.1
  6 | 
  7 | - Support destructuring in `{@const}` tag
  8 | 
  9 | # 3.4.0
 10 | 
 11 | - Support `{@const}` tag
 12 | 
 13 | # 3.3.0
 14 | 
 15 | - Add injected globals when there's no instance script when using TypeScript
 16 | - Allow `$$Props`, `$$Slots`, `$$Events` interface/type usage
 17 | - Improve type inference for autosubscribed stores
 18 | - Silence false positives for `<svelte:fragment let:x>`
 19 | - Use TS 4.5 `preserveValueImports` if it's available
 20 | - Improve default setting for `svelte3/ignore-styles`: Now ignores styles if its tag has a `lang` or `type` attribute
 21 | - Improve fix range handling
 22 | 
 23 | # 3.2.1
 24 | 
 25 | - Filter `no-undef` messages about `$$Generic`
 26 | 
 27 | # 3.2.0
 28 | 
 29 | - Support lazy-loading TypeScript compiler
 30 | - Support non-CommonJS format of ESLint configuration file when using TypeScript by specifying `true` in configuration
 31 | - Improve logic for finding the correct `Linter` instance in a workspace with multiple directories
 32 | - Improve filtering of `@typescript-eslint/indent` and `@typescript-eslint/quotes` messages like what already happens with `indent` and `quotes`
 33 | - Fix erroneous messages when a component only writes to a store
 34 | 
 35 | # 3.1.2
 36 | 
 37 | - Silence some incorrect `unsafe-member-access` errors - see README for current limitations
 38 | 
 39 | # 3.1.1
 40 | 
 41 | - Fix erroneous errors from two-way binding in TypeScript components
 42 | - Fix erroneous warnings from the removal of `import`s in TypeScript components
 43 | 
 44 | # 3.1.0
 45 | 
 46 | - Add TypeScript support
 47 | 
 48 | # 3.0.0
 49 | 
 50 | - Breaking change: Node 10+ is now required
 51 |   - There are no specific changes yet that will not work on Node 8, but tests will no longer be run on Node 8, and there are no guarantees about it
 52 | - Fix erroneous `no-unused-vars` for variables that are assigned to in the template, but are only used in the script
 53 | 
 54 | # 2.7.3
 55 | 
 56 | - Fix mishandling of blocks whose last line consists of only the expected indentation
 57 | 
 58 | # 2.7.2
 59 | 
 60 | - Fix regression when using `linebreak-style` with Windows line endings
 61 | 
 62 | # 2.7.1
 63 | 
 64 | - Named code blocks were in fact a breaking change, sorry!
 65 | - They're now disabled by default, but can be enabled with `svelte3/named-blocks`
 66 | 
 67 | # 2.7.0
 68 | 
 69 | - Expose the parts of each linted component as separate named code blocks `module.js`, `instance.js`, and `template.js`
 70 | 
 71 | # 2.6.0
 72 | 
 73 | - Add `svelte3/compiler` setting to allow overriding which instance of the Svelte compiler is used
 74 | 
 75 | # 2.5.0
 76 | 
 77 | - Fix `let:` handling on regular elements as well
 78 | - Separate `then` and `catch` scopes in `{#await}`
 79 | 
 80 | # 2.4.2
 81 | 
 82 | - Fix handling of the scope created by `let:` directives
 83 | 
 84 | # 2.4.1
 85 | 
 86 | - Fix attribute parsing edge case in `svelte3/ignore-styles` callback
 87 | 
 88 | # 2.4.0
 89 | 
 90 | - Respect `no-self-assign` rule unless self-assignment is to a top-level variable known to the compiler
 91 | - Better handling of identifiers containing unicode characters
 92 | 
 93 | # 2.3.0
 94 | 
 95 | - Respect `quotes` rule unless inside a template expression which is inside an attribute or directive enclosed in quotes
 96 | - Respect `no-unused-expressions` rule again (which is now safe thanks to a previous refactor)
 97 | 
 98 | # 2.2.2
 99 | 
100 | - Stop using inline configuration comments internally, to avoid issues with `--no-inline-config` and `--report-unused-disable-directives`
101 | 
102 | # 2.2.1
103 | 
104 | - Handle `then` and `catch` scope in `{#await}`
105 | 
106 | # 2.2.0
107 | 
108 | - Enforce semicolon rules in template expressions
109 | - Fix parsing of template expressions that are object literals
110 | - Don't produce multiple messages for template expressions wrapped in parentheses
111 | 
112 | # 2.1.0
113 | 
114 | - Preserve linting messages about labels other than `$`
115 | 
116 | # 2.0.2
117 | 
118 | - Actually fix ignoring of rules in the template
119 | 
120 | # 2.0.1
121 | 
122 | - Disregard `eol-last` rule
123 | - Disregard `no-unused-expressions` rule in the template
124 | - Fix bug where rules intended to only be ignored in the template were being ignored in the entire file
125 | 
126 | # v2.0.0
127 | 
128 | - Require Svelte v3.2+ and ESLint 6+
129 | - Reworked configuration:
130 |   - `svelte3/enabled` has been removed in favor of registering a `svelte3/svelte3` processor that you need to enable on files
131 |   - `svelte3/ignore-warnings` now only takes a callback which is passed the warning object
132 |   - `svelte3/compiler-options` now only takes a compiler options object
133 |   - `svelte3/ignore-styles` now only takes a preprocessor-style callback
134 |   - `svelte3/lint-template` has been removed, and template linting is now always enabled
135 | 
136 | # v1.2.3
137 | 
138 | - Fix a weird edge case where fixes to problems could be lost in certain cases
139 | 
140 | # v1.2.2
141 | 
142 | - Internal improvements to AST walk
143 | 
144 | # v1.2.1
145 | 
146 | - Avoid mutating the AST while linting, which can have adverse effects
147 | 
148 | # v1.2.0
149 | 
150 | - Pass a second argument to the `svelte3/ignore-warnings` function that contains the entire warning object
151 | - Disregard `no-labels` rule and `no-restricted-syntax` rule in places where it disallows labels
152 | 
153 | # v1.1.0
154 | 
155 | - Experimental support for linting expressions in the template, behind the `svelte3/lint-template` setting. This feature requires Svelte 3.2.0
156 | 
157 | # v1.0.0
158 | 
159 | - Svelte v3 release party!
160 | 
161 | # v0.4.7
162 | 
163 | - Fix regression with specifying an array of warnings to ignore
164 | 
165 | # v0.4.6
166 | 
167 | - Add `svelte3/compiler-options` setting to control how the compiler is called during linting
168 | 
169 | # v0.4.5
170 | 
171 | - Proper fix for not wiping tag names that begin with `<style`
172 | 
173 | # v0.4.4
174 | 
175 | - With `svelte3/ignore-warnings`, don't wipe elements whose tag names merely begin with `<style`
176 | - The plugin is now published to npm
177 | 
178 | # v0.4.3
179 | 
180 | - Better handling for files linted in Windows/CRLF `linebreak-style`
181 | 
182 | # v0.4.2
183 | 
184 | - Work around issues caused by ESLint issues with fixes that replace more of the file than necessary
185 | 
186 | # v0.4.1
187 | 
188 | - Make sure fixes for issues at the beginning and end of the scripts do not change text outside of the scripts
189 | 
190 | # v0.4.0
191 | 
192 | - Reworked configuration to be more flexible:
193 |   - `svelte3/ignore` has been renamed to `svelte3/ignore-warnings`
194 |   - `svelte3/extensions` has been removed and `svelte3/enabled` has been added (which works differently but is more powerful)
195 | - `svelte3/ignore-styles` has been added as an immediate solution for components with styles written in something other than normal CSS
196 | 
197 | # v0.3.0
198 | 
199 | - Support and require at least beta 4
200 | 
201 | # v0.2.3
202 | 
203 | - Add `svelte3/ignore` setting for ignoring specific compiler warnings
204 | 
205 | # v0.2.2
206 | 
207 | - Include the position of the end of a compiler error message, when available
208 | 
209 | # v0.2.1
210 | 
211 | - Don't warn about `export let`s with default values and no other reassignments when using `prefer-const`
212 | 
213 | # v0.2.0
214 | 
215 | - Add handling of store auto-subscriptions and other injected variables
216 | - Require alpha 21
217 | 
218 | # v0.1.0
219 | 
220 | - Initial release
221 | 


--------------------------------------------------------------------------------
/INTEGRATIONS.md:
--------------------------------------------------------------------------------
 1 | # Visual Studio Code
 2 | 
 3 | You'll need the [ESLint](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint) extension installed.
 4 | 
 5 | Then, you'll need to tell the ESLint extension to also lint files with language `svelte`. If you haven't adjusted the `eslint.validate` setting, it defaults to `[ "javascript", "javascriptreact" ]`, so put this in your `settings.json`:
 6 | 
 7 | ```json
 8 | {
 9 |   "eslint.validate": [
10 |     "javascript",
11 |     "javascriptreact",
12 |     "svelte"
13 |   ]
14 | }
15 | ```
16 | 
17 | Reload VS Code and give it a go!
18 | 
19 | # Atom
20 | 
21 | You'll need the [linter](https://atom.io/packages/linter) and [linter-eslint](https://atom.io/packages/linter-eslint) packages installed.
22 | 
23 | Unless you're using `.html` for your Svelte components, you'll need to configure `*`.`core`.`customFileTypes` to associate the appropriate file extension with the `text.html.basic` language. For example, to associate `.svelte`, put this in your `config.cson`:
24 | 
25 | ```cson
26 | "*":
27 |   core:
28 |     customFileTypes:
29 |       "text.html.basic": [
30 |         "svelte"
31 |       ]
32 | ```
33 | 
34 | Then, you'll need to tell linter-eslint to also lint HTML files: add `source.html` to the list of scopes to run ESLint on in the linter-eslint settings.
35 | 
36 | Reload Atom and give it a go!
37 | 
38 | # Sublime Text
39 | 
40 | You'll need the [SublimeLinter](https://github.com/SublimeLinter/SublimeLinter) and [SublimeLinter-eslint](https://github.com/SublimeLinter/SublimeLinter-eslint) packages installed.
41 | 
42 | Unless you're using `.html` for your Svelte components, you'll need to configure Sublime to associate the appropriate file extension with the `text.html` syntax. Open any Svelte component, and go to **View > Syntax > Open all with current extension as... > HTML**.
43 | 
44 | Then, you'll need to tell SublimeLinter-eslint to lint entire files with the `text.html` syntax, and not just the contents of their `<script>` tags (which is the default). In your SublimeLinter configuration, you'll need to add `text.html` to `linters`.`eslint`.`selector`. If you're starting with the default values, this would mean:
45 | 
46 | ```json
47 | {
48 |   "linters": {
49 |     "eslint": {
50 |       "selector": "source.js - meta.attribute-with-value, text.html"
51 |     }
52 |   }
53 | }
54 | ```
55 | 
56 | Reload Sublime and give it a go!
57 | 
58 | # Vim
59 | 
60 | You'll need the [ALE (Asynchronous Lint Engine)](https://github.com/w0rp/ale) plugin installed.
61 | 
62 | Unless you're using `.html` for your Svelte components, you'll need to configure Vim to associate the appropriate file extension with the `html` syntax. For example, to associate `.svelte`, put this in your `.vimrc`:
63 | 
64 | ```vim
65 | au BufNewFile,BufRead,BufReadPost *.svelte set syntax=html
66 | ```
67 | 
68 | Then you'll need to tell ALE to lint and fix `.svelte` files using ESLint, so put this in your `.vimrc`:
69 | 
70 | ```vim
71 | let g:ale_linter_aliases = {
72 | \   'svelte': ['javascript']
73 | \}
74 | let g:ale_linters = {
75 | \   'svelte': ['eslint']
76 | \}
77 | let g:ale_fixers = {
78 | \   'svelte': ['eslint']
79 | \}
80 | ```
81 | 
82 | Reload Vim and give it a go!
83 | 
84 | # Other integrations?
85 | 
86 | If you've gotten this plugin to work with other editors, please let us know!
87 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Conduitry
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/OTHER_PLUGINS.md:
--------------------------------------------------------------------------------
 1 | # Interactions with other plugins
 2 | 
 3 | ## `eslint-plugin-html`
 4 | 
 5 | Don't enable this at all on the files you're running `eslint-plugin-svelte3` on. Everything will almost certainly break.
 6 | 
 7 | ## `eslint-plugin-prettier`
 8 | 
 9 | Don't enable this either on Svelte components. If you want to use Prettier, just use it directly, along with appropriate plugins.
10 | 
11 | ## `eslint-plugin-import`
12 | 
13 | These rules are known to not work correctly together with this plugin:
14 | 
15 | - `import/first`
16 | - `import/no-duplicates`
17 | - `import/no-mutable-exports`
18 | - `import/no-unresolved` when using `svelte3/named-blocks`, pending [this issue](https://github.com/benmosher/eslint-plugin-import/issues/1415)
19 | - `import/prefer-default-export`
20 | 
21 | If you're using them on other linted files, consider [adding `overrides` for them for Svelte components](https://eslint.org/docs/user-guide/configuring/configuration-files#how-do-overrides-work).
22 | 
23 | ## `eslint-config-standard`
24 | 
25 | This uses `eslint-plugin-import` by default, so the above applies.
26 | 
27 | ## Others?
28 | 
29 | If you've found another mainstream ESLint plugin that doesn't play nicely with this one, or has certain rules that don't work properly, please let us know!
30 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # ⚠️ Please use [`eslint-plugin-svelte`](https://github.com/sveltejs/eslint-plugin-svelte) instead
  2 | 
  3 | This ESLint plugin is deprecated.<br>
  4 | [`eslint-plugin-svelte`](https://github.com/sveltejs/eslint-plugin-svelte) is the new official ESLint plugin for Svelte.
  5 | 
  6 | This plugin has supported Svelte's development for a long time. However, it does not handle the AST of the template well, which results in false positives/negatives and makes it very difficult to create custom ESLint rules.
  7 | To solve this issue, [ota-meshi](https://github.com/ota-meshi) developed [svelte-eslint-parser](https://github.com/sveltejs/svelte-eslint-parser) and [`eslint-plugin-svelte`](https://github.com/sveltejs/eslint-plugin-svelte) which has proven to be more reliable and successful. The Svelte team therefore decided to switch the official plugin to [`eslint-plugin-svelte`](https://github.com/sveltejs/eslint-plugin-svelte).
  8 | 
  9 | # eslint-plugin-svelte3
 10 | 
 11 | An ESLint plugin for Svelte v3 components.
 12 | 
 13 | ## Features
 14 | 
 15 | - Compiler errors and warnings are displayed through ESLint
 16 | - Script blocks and template expression tags are linted with existing ESLint rules
 17 | - Svelte scope and stores are respected by unused variable and undefined variable rules
 18 | - Idioms like self-assignment and `$:` labels are always allowed, regardless of configuration
 19 | 
 20 | ## Requirements
 21 | 
 22 | - Svelte 3.2+
 23 | - ESLint 8+
 24 | 
 25 | ## Installation
 26 | 
 27 | Install the plugin package:
 28 | 
 29 | ```
 30 | npm install --save-dev eslint-plugin-svelte3
 31 | ```
 32 | 
 33 | Then add `svelte3` to the `plugins` array in your `.eslintrc.*`, and set `svelte3/svelte3` as the `processor` for your Svelte components.
 34 | 
 35 | For example:
 36 | 
 37 | ```javascript
 38 | module.exports = {
 39 |   parserOptions: {
 40 |     ecmaVersion: 2019,
 41 |     sourceType: 'module'
 42 |   },
 43 |   env: {
 44 |     es6: true,
 45 |     browser: true
 46 |   },
 47 |   plugins: [
 48 |     'svelte3'
 49 |   ],
 50 |   overrides: [
 51 |     {
 52 |       files: ['*.svelte'],
 53 |       processor: 'svelte3/svelte3'
 54 |     }
 55 |   ],
 56 |   rules: {
 57 |     // ...
 58 |   },
 59 |   settings: {
 60 |     // ...
 61 |   }
 62 | };
 63 | ```
 64 | 
 65 | By default, this plugin needs to be able to `require('svelte/compiler')`. If ESLint, this plugin, and Svelte are all installed locally in your project, this should not be a problem.
 66 | 
 67 | ### Installation with TypeScript
 68 | 
 69 | If you want to use TypeScript, you'll need a different ESLint configuration. In addition to the Svelte plugin, you also need the ESLint TypeScript parser and plugin. Install `typescript`, `@typescript-eslint/parser` and `@typescript-eslint/eslint-plugin` from npm and then adjust your config like this:
 70 | 
 71 | ```javascript
 72 | module.exports = {
 73 |   parser: '@typescript-eslint/parser', // add the TypeScript parser
 74 |   plugins: [
 75 |     'svelte3',
 76 |     '@typescript-eslint' // add the TypeScript plugin
 77 |   ],
 78 |   overrides: [ // this stays the same
 79 |     {
 80 |       files: ['*.svelte'],
 81 |       processor: 'svelte3/svelte3'
 82 |     }
 83 |   ],
 84 |   rules: {
 85 |     // ...
 86 |   },
 87 |   settings: {
 88 |     'svelte3/typescript': () => require('typescript'), // pass the TypeScript package to the Svelte plugin
 89 |     // OR
 90 |     'svelte3/typescript': true, // load TypeScript as peer dependency
 91 |     // ...
 92 |   }
 93 | };
 94 | ```
 95 | 
 96 | If you also want to be able to use type-aware linting rules (which will result in slower linting, because the whole program needs to be compiled and type-checked), then you also need to add some `parserOptions` configuration. The values below assume that your ESLint config is at the root of your project next to your `tsconfig.json`. For more information, see [here](https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/TYPED_LINTING.md).
 97 | 
 98 | ```javascript
 99 | module.exports = {
100 |   // ...
101 |   parserOptions: { // add these parser options
102 |     tsconfigRootDir: __dirname,
103 |     project: ['./tsconfig.json'],
104 |     extraFileExtensions: ['.svelte'],
105 |   },
106 |   extends: [ // then, enable whichever type-aware rules you want to use
107 |     'eslint:recommended',
108 |     'plugin:@typescript-eslint/recommended',
109 |     'plugin:@typescript-eslint/recommended-requiring-type-checking'
110 |   ],
111 |   // ...
112 | };
113 | ```
114 | 
115 | There are some limitations to these type-aware rules currently. Specifically, checks in the context of reactive assignments and store subscriptions will report false positives or false negatives, depending on the rule. In the case of reactive assignments, you can work around this by explicitly typing the reactive variable. An example with the `no-unsafe-member-access` rule:
116 | 
117 | ```svelte
118 | <script lang="ts">
119 |   import { writable } from 'svelte/store';
120 | 
121 |   const store = writable([]);
122 |   $store.length; // incorrect no-unsafe-member-access error
123 | 
124 |   $: assignment = [];
125 |   assignment.length; // incorrect no-unsafe-member-access error
126 |   // You can work around this by doing
127 |   let another_assignment: string[];
128 |   $: another_assignment = [];
129 |   another_assignment.length; // OK
130 | </script>
131 | ```
132 | 
133 | ## Interactions with other plugins
134 | 
135 | Care needs to be taken when using this plugin alongside others. Take a look at [this list of things you need to watch out for](OTHER_PLUGINS.md).
136 | 
137 | ## Configuration
138 | 
139 | There are a few settings you can use to adjust this plugin's behavior. These go in the `settings` object in your ESLint configuration.
140 | 
141 | Passing a function as a value for a setting (which some of the settings below require) is only possible when using a CommonJS `.eslintrc.js` file, and not a JSON or YAML configuration file.
142 | 
143 | ### `svelte3/ignore-warnings`
144 | 
145 | This setting can be given a function that indicates whether to ignore a warning in the linting. The function will be passed a warning object and should return a boolean. Only warnings from the Svelte compiler itself can be filtered out through this function. Regular ESLint rules are configured/disabled through the corresponding ESLint settings.
146 | 
147 | The default is to not ignore any warnings.
148 | 
149 | ### `svelte3/compiler-options`
150 | 
151 | Most compiler options do not affect the validity of compiled components, but a couple of them can. If you are compiling to custom elements, or for some other reason need to control how the plugin compiles the components it's linting, you can use this setting.
152 | 
153 | This setting can be given an object of compiler options.
154 | 
155 | The default is to compile with `{ generate: false }`.
156 | 
157 | ### `svelte3/ignore-styles`
158 | 
159 | If you're using some sort of preprocessor on the component styles, then it's likely that when this plugin calls the Svelte compiler on your component, it will throw an exception. In a perfect world, this plugin would be able to apply the preprocessor to the component and then use source maps to translate any warnings back to the original source. In the current reality, however, you can instead simply disregard styles written in anything other than standard CSS. You won't get warnings about the styles from the linter, but your application will still use them (of course) and compiler warnings will still appear in your build logs.
160 | 
161 | This setting can be given a function that accepts an object of attributes on a `<style>` tag (like that passed to a Svelte preprocessor) and returns whether to ignore the style block for the purposes of linting.
162 | 
163 | The default is to ignore styles when the `<style>` tag has a `lang=` or `type=` attribute.
164 | 
165 | ### `svelte3/named-blocks`
166 | 
167 | When an [ESLint processor](https://eslint.org/docs/user-guide/configuring/plugins#specifying-processor) processes a file, it is able to output named code blocks, which can each have their own linting configuration. When this setting is enabled, the code extracted from `<script context='module'>` tag, the `<script>` tag, and the template are respectively given the block names `module.js`, `instance.js`, and `template.js`.
168 | 
169 | This means that to override linting rules in Svelte components, you'd instead have to target `**/*.svelte/*.js`. But it also means that you can define an override targeting `**/*.svelte/*_template.js` for example, and that configuration will only apply to linting done on the templates in Svelte components.
170 | 
171 | The default is to not use named code blocks.
172 | 
173 | ### `svelte3/typescript`
174 | 
175 | If you use TypeScript inside your Svelte components and want ESLint support, you need to set this option. It expects a function returning an instance of the TypeScript package. This probably means doing `'svelte3/typescript': () => require('typescript')`.
176 | 
177 | To support ESLint configuration files that are not written in CommonJS, this can also be set to `true`, which behaves the same as `() => require('typescript')`.
178 | 
179 | For backwards compatibility, it also supports being passed the TypeScript package directly, but this is not generally recommended as it unnecessarily loads the package in some situations.
180 | 
181 | The default is to not enable TypeScript support.
182 | 
183 | ### `svelte3/compiler`
184 | 
185 | In some esoteric setups, this plugin might not be able to find the correct instance of the Svelte compiler to use.
186 | 
187 | This setting can be given the result of `require('.../path/to/svelte/compiler')` to indicate which instance should be used in linting the components.
188 | 
189 | The default is `require('svelte/compiler')` from wherever the plugin is installed to.
190 | 
191 | ## Using the CLI
192 | 
193 | It's probably a good idea to make sure you can lint from the command line before proceeding with configuring your editor.
194 | 
195 | Using this with the command line `eslint` tool shouldn't require any special actions. Just remember that if you are running `eslint` on a directory, you need to pass it the `--ext` flag to tell it which nonstandard file extensions you want to lint.
196 | 
197 | ## Integrations
198 | 
199 | See [INTEGRATIONS.md](INTEGRATIONS.md) for how to use this plugin with your text editor.
200 | 
201 | ## License
202 | 
203 | [MIT](LICENSE)
204 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "eslint-plugin-svelte3",
 3 | 	"version": "4.0.0",
 4 | 	"description": "An ESLint plugin for Svelte v3 components.",
 5 | 	"keywords": [
 6 | 		"eslint",
 7 | 		"eslintplugin",
 8 | 		"svelte",
 9 | 		"sveltejs"
10 | 	],
11 | 	"files": [
12 | 		"index.js"
13 | 	],
14 | 	"main": "index.js",
15 | 	"repository": {
16 | 		"type": "git",
17 | 		"url": "https://github.com/sveltejs/eslint-plugin-svelte3.git"
18 | 	},
19 | 	"author": "Conduitry",
20 | 	"license": "MIT",
21 | 	"bugs": {
22 | 		"url": "https://github.com/sveltejs/eslint-plugin-svelte3/issues"
23 | 	},
24 | 	"peerDependencies": {
25 | 		"eslint": ">=8.0.0",
26 | 		"svelte": "^3.2.0"
27 | 	},
28 | 	"scripts": {
29 | 		"build": "rollup -c",
30 | 		"dev": "rollup -cw",
31 | 		"test": "npm run build && node test"
32 | 	},
33 | 	"devDependencies": {
34 | 		"@rollup/plugin-node-resolve": "^13.1.3",
35 | 		"@typescript-eslint/eslint-plugin": "^5.18.0",
36 | 		"@typescript-eslint/parser": "^5.18.0",
37 | 		"eslint": ">=8.0.0",
38 | 		"rollup": "^2",
39 | 		"sourcemap-codec": "1.4.8",
40 | 		"svelte": "^3.2.0",
41 | 		"typescript": "^4.6.3"
42 | 	}
43 | }
44 | 


--------------------------------------------------------------------------------
/rollup.config.js:
--------------------------------------------------------------------------------
1 | import node_resolve from '@rollup/plugin-node-resolve';
2 | 
3 | export default {
4 | 	input: 'src/index.js',
5 | 	output: { file: 'index.js', format: 'cjs' },
6 | 	plugins: [ node_resolve() ],
7 | };
8 | 


--------------------------------------------------------------------------------
/src/block.js:
--------------------------------------------------------------------------------
 1 | import { get_offsets, dedent_code } from './utils.js';
 2 | 
 3 | // create a new block to add code transformations to
 4 | export const new_block = () => ({ transformed_code: '', line_offsets: null, translations: new Map() });
 5 | 
 6 | // get translation info and include the processed scripts in this block's transformed_code
 7 | // each translation consists of info about the original text range (range),
 8 | // the difference after dedenting (dedent), line/length info about the text itself (offsets),
 9 | // line/length info about the transformed code prior to adding the text (unoffsets) and the new
10 | // line count of the transformed code after adding the text (end). This information can be used
11 | // to map code back to its original position.
12 | export const get_translation = (text, block, node, options = {}) => {
13 | 	block.transformed_code += '\n';
14 | 	const translation = { options, unoffsets: get_offsets(block.transformed_code) };
15 | 	translation.range = [node.start, node.end];
16 | 	const { dedented, offsets, indentation } = dedent_code(text.slice(node.start, node.end));
17 | 	block.transformed_code += dedented;
18 | 	translation.offsets = get_offsets(text.slice(0, node.start));
19 | 	translation.dedent = offsets;
20 | 	translation.indentation = indentation;
21 | 	translation.end = get_offsets(block.transformed_code).lines;
22 | 	for (let i = translation.unoffsets.lines; i <= translation.end; i++) {
23 | 		block.translations.set(i, translation);
24 | 	}
25 | 	block.transformed_code += '\n';
26 | };
27 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
1 | import { preprocess } from './preprocess.js';
2 | import { postprocess } from './postprocess.js';
3 | 
4 | export default { processors: { svelte3: { preprocess, postprocess, supportsAutofix: true } } };
5 | 


--------------------------------------------------------------------------------
/src/mapping.js:
--------------------------------------------------------------------------------
  1 | import { decode } from 'sourcemap-codec';
  2 | 
  3 | class GeneratedFragmentMapper {
  4 | 	constructor(generated_code, diff) {
  5 | 		this.generated_code = generated_code;
  6 | 		this.diff = diff;
  7 | 	}
  8 | 
  9 | 	get_position_relative_to_fragment(position_relative_to_file) {
 10 | 		const fragment_offset = this.offset_in_fragment(offset_at(position_relative_to_file, this.generated_code));
 11 | 		return position_at(fragment_offset, this.diff.generated_content);
 12 | 	}
 13 | 
 14 | 	offset_in_fragment(offset) {
 15 | 		return offset - this.diff.generated_start;
 16 | 	}
 17 | }
 18 | 
 19 | class OriginalFragmentMapper {
 20 | 	constructor(original_code, diff) {
 21 | 		this.original_code = original_code;
 22 | 		this.diff = diff;
 23 | 	}
 24 | 
 25 | 	get_position_relative_to_file(position_relative_to_fragment) {
 26 | 		const parent_offset = this.offset_in_parent(offset_at(position_relative_to_fragment, this.diff.original_content));
 27 | 		return position_at(parent_offset, this.original_code);
 28 | 	}
 29 | 
 30 | 	offset_in_parent(offset) {
 31 | 		return this.diff.original_start + offset;
 32 | 	}
 33 | }
 34 | 
 35 | class SourceMapper {
 36 | 	constructor(raw_source_map) {
 37 | 		this.raw_source_map = raw_source_map;
 38 | 	}
 39 | 
 40 | 	get_original_position(generated_position) {
 41 | 		if (generated_position.line < 0) {
 42 | 			return { line: -1, column: -1 };
 43 | 		}
 44 | 
 45 | 		// Lazy-load
 46 | 		if (!this.decoded) {
 47 | 			this.decoded = decode(JSON.parse(this.raw_source_map).mappings);
 48 | 		}
 49 | 
 50 | 		let line = generated_position.line;
 51 | 		let column = generated_position.column;
 52 | 
 53 | 		let line_match = this.decoded[line];
 54 | 		while (line >= 0 && (!line_match || !line_match.length)) {
 55 | 			line -= 1;
 56 | 			line_match = this.decoded[line];
 57 | 			if (line_match && line_match.length) {
 58 | 				return {
 59 | 					line: line_match[line_match.length - 1][2],
 60 | 					column: line_match[line_match.length - 1][3]
 61 | 				};
 62 | 			}
 63 | 		}
 64 | 
 65 | 		if (line < 0) {
 66 | 			return { line: -1, column: -1 };
 67 | 		}
 68 | 
 69 | 		const column_match = line_match.find((col, idx) =>
 70 | 			idx + 1 === line_match.length ||
 71 | 			(col[0] <= column && line_match[idx + 1][0] > column)
 72 | 		);
 73 | 
 74 | 		return {
 75 | 			line: column_match[2],
 76 | 			column: column_match[3],
 77 | 		};
 78 | 	}
 79 | }
 80 | 
 81 | export class DocumentMapper {
 82 | 	constructor(original_code, generated_code, diffs) {
 83 | 		this.original_code = original_code;
 84 | 		this.generated_code = generated_code;
 85 | 		this.diffs = diffs;
 86 | 		this.mappers = diffs.map(diff => {
 87 | 			return {
 88 | 				start: diff.generated_start,
 89 | 				end: diff.generated_end,
 90 | 				diff: diff.diff,
 91 | 				generated_fragment_mapper: new GeneratedFragmentMapper(generated_code, diff),
 92 | 				source_mapper: new SourceMapper(diff.map),
 93 | 				original_fragment_mapper: new OriginalFragmentMapper(original_code, diff)
 94 | 			};
 95 | 		});
 96 | 	}
 97 | 
 98 | 	get_original_position(generated_position) {
 99 | 		generated_position = { line: generated_position.line - 1, column: generated_position.column };
100 | 		const offset = offset_at(generated_position, this.generated_code);
101 | 		let original_offset = offset;
102 | 		for (const mapper of this.mappers) {
103 | 			if (offset >= mapper.start && offset <= mapper.end) {
104 | 				return this.map(mapper, generated_position);
105 | 			}
106 | 			if (offset > mapper.end) {
107 | 				original_offset -= mapper.diff;
108 | 			}
109 | 		}
110 | 		const original_position = position_at(original_offset, this.original_code);
111 | 		return this.to_ESLint_position(original_position);
112 | 	}
113 | 
114 | 	map(mapper, generated_position) {
115 | 		// Map the position to be relative to the transpiled fragment
116 | 		const position_in_transpiled_fragment = mapper.generated_fragment_mapper.get_position_relative_to_fragment(
117 | 			generated_position
118 | 		);
119 | 		// Map the position, using the sourcemap, to the original position in the source fragment
120 | 		const position_in_original_fragment = mapper.source_mapper.get_original_position(
121 | 			position_in_transpiled_fragment
122 | 		);
123 | 		// Map the position to be in the original fragment's parent
124 | 		const original_position = mapper.original_fragment_mapper.get_position_relative_to_file(position_in_original_fragment);
125 | 		return this.to_ESLint_position(original_position);
126 | 	}
127 | 
128 | 	to_ESLint_position(position) {
129 | 		// ESLint line/column is 1-based
130 | 		return { line: position.line + 1, column: position.column + 1 };
131 | 	}
132 | 
133 | }
134 | 
135 | /**
136 |  * Get the offset of the line and character position
137 |  * @param position Line and character position
138 |  * @param text The text for which the offset should be retrieved
139 |  */
140 | export function offset_at(position, text) {
141 | 	const line_offsets = get_line_offsets(text);
142 | 
143 | 	if (position.line >= line_offsets.length) {
144 | 		return text.length;
145 | 	} else if (position.line < 0) {
146 | 		return 0;
147 | 	}
148 | 
149 | 	const line_offset = line_offsets[position.line];
150 | 	const next_line_offset =
151 | 		position.line + 1 < line_offsets.length ? line_offsets[position.line + 1] : text.length;
152 | 
153 | 	return clamp(next_line_offset, line_offset, line_offset + position.column);
154 | }
155 | 
156 | /**
157 |  * Get the line and character position of an offset
158 |  * @param offset Idx of the offset
159 |  * @param text The text for which the position should be retrieved
160 |  */
161 | export function position_at(offset, text) {
162 | 	offset = clamp(offset, 0, text.length);
163 | 
164 | 	const line_offsets = get_line_offsets(text);
165 | 	let low = 0;
166 | 	let high = line_offsets.length;
167 | 	if (high === 0) {
168 | 		return { line: 0, column: offset };
169 | 	}
170 | 
171 | 	while (low < high) {
172 | 		const mid = Math.floor((low + high) / 2);
173 | 		if (line_offsets[mid] > offset) {
174 | 			high = mid;
175 | 		} else {
176 | 			low = mid + 1;
177 | 		}
178 | 	}
179 | 
180 | 	// low is the least x for which the line offset is larger than the current offset
181 | 	// or array.length if no line offset is larger than the current offset
182 | 	const line = low - 1;
183 | 	return { line, column: offset - line_offsets[line] };
184 | }
185 | 
186 | function get_line_offsets(text) {
187 | 	const line_offsets = [];
188 | 	let is_line_start = true;
189 | 
190 | 	for (let i = 0; i < text.length; i++) {
191 | 		if (is_line_start) {
192 | 			line_offsets.push(i);
193 | 			is_line_start = false;
194 | 		}
195 | 		const ch = text.charAt(i);
196 | 		is_line_start = ch === '\r' || ch === '\n';
197 | 		if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {
198 | 			i++;
199 | 		}
200 | 	}
201 | 
202 | 	if (is_line_start && text.length > 0) {
203 | 		line_offsets.push(text.length);
204 | 	}
205 | 
206 | 	return line_offsets;
207 | }
208 | 
209 | function clamp(num, min, max) {
210 | 	return Math.max(min, Math.min(max, num));
211 | }
212 | 


--------------------------------------------------------------------------------
/src/postprocess.js:
--------------------------------------------------------------------------------
  1 | import { position_at } from './mapping.js';
  2 | import { state, reset } from './state.js';
  3 | import { get_line_offsets } from './utils.js';
  4 | 
  5 | // transform a linting message according to the module/instance script info we've gathered
  6 | const transform_message = ({ transformed_code }, { unoffsets, dedent, indentation, offsets, range }, message) => {
  7 | 	let fix_pos_start;
  8 | 	let fix_pos_end;
  9 | 	if (message.fix) {
 10 | 		// strip out the start and end of the fix if they are not actually changes
 11 | 		while (message.fix.range[0] < message.fix.range[1] && transformed_code[message.fix.range[0]] === message.fix.text[0]) {
 12 | 			message.fix.range[0]++;
 13 | 			message.fix.text = message.fix.text.slice(1);
 14 | 		}
 15 | 		while (message.fix.range[0] < message.fix.range[1] && transformed_code[message.fix.range[1] - 1] === message.fix.text[message.fix.text.length - 1]) {
 16 | 			message.fix.range[1]--;
 17 | 			message.fix.text = message.fix.text.slice(0, -1);
 18 | 		}
 19 | 		// If the fix spans multiple lines, add the indentation to each one
 20 | 		message.fix.text = message.fix.text.split('\n').join(`\n${indentation}`);
 21 | 		// The fix can span multiple lines and doesn't need to be on the same line
 22 | 		// as the lint message, so we can't just add total_offsets at message.line to it
 23 | 		// (see dedent-step below)
 24 | 		fix_pos_start = position_at(message.fix.range[0], transformed_code);
 25 | 		fix_pos_end = position_at(message.fix.range[1], transformed_code);
 26 | 	}
 27 | 
 28 | 	// shift position reference backward according to unoffsets
 29 | 	// (aka: throw out the generated code lines prior to the original code)
 30 | 	{
 31 | 		const { length, lines, last } = unoffsets;
 32 | 		if (message.line === lines) {
 33 | 			message.column -= last;
 34 | 		}
 35 | 		if (message.endColumn && message.endLine === lines) {
 36 | 			message.endColumn -= last;
 37 | 		}
 38 | 		message.line -= lines - 1;
 39 | 		if (message.endLine) {
 40 | 			message.endLine -= lines - 1;
 41 | 		}
 42 | 		if (message.fix) {
 43 | 			message.fix.range[0] -= length;
 44 | 			message.fix.range[1] -= length;
 45 | 		}
 46 | 	}
 47 | 
 48 | 	// adjust position reference according to the previous dedenting
 49 | 	// (aka: re-add the stripped indentation)
 50 | 	{
 51 | 		const { offsets, total_offsets } = dedent;
 52 | 		message.column += offsets[message.line - 1];
 53 | 		if (message.endColumn) {
 54 | 			message.endColumn += offsets[message.endLine - 1];
 55 | 		}
 56 | 		if (message.fix) {
 57 | 			// We need the offset at the line relative to dedent's total_offsets. The dedents
 58 | 			// start at the point in the total transformed code where a subset of the code was transformed.
 59 | 			// Therefore substract (unoffsets.lines + 1) which marks the start of that transformation.
 60 | 			// Add +1 afterwards because total_offsets are 1-index-based.
 61 | 			message.fix.range[0] += total_offsets[fix_pos_start.line - unoffsets.lines + 2];
 62 | 			message.fix.range[1] += total_offsets[fix_pos_end.line - unoffsets.lines + 2];
 63 | 		}
 64 | 	}
 65 | 
 66 | 	// shift position reference forward according to offsets
 67 | 	// (aka: re-add the code that is originally prior to the code)
 68 | 	{
 69 | 		const { length, lines, last } = offsets;
 70 | 		if (message.line === 1) {
 71 | 			message.column += last;
 72 | 		}
 73 | 		if (message.endColumn && message.endLine === 1) {
 74 | 			message.endColumn += last;
 75 | 		}
 76 | 		message.line += lines - 1;
 77 | 		if (message.endLine) {
 78 | 			message.endLine += lines - 1;
 79 | 		}
 80 | 		if (message.fix) {
 81 | 			message.fix.range[0] += length;
 82 | 			message.fix.range[1] += length;
 83 | 		}
 84 | 	}
 85 | 
 86 | 	// make sure the fix doesn't include anything outside the range of the script
 87 | 	if (message.fix) {
 88 | 		if (message.fix.range[0] < range[0]) {
 89 | 			message.fix.text = message.fix.text.slice(range[0] - message.fix.range[0]);
 90 | 			message.fix.range[0] = range[0];
 91 | 		}
 92 | 		if (message.fix.range[1] > range[1]) {
 93 | 			message.fix.text = message.fix.text.slice(0, range[1] - message.fix.range[1]);
 94 | 			message.fix.range[1] = range[1];
 95 | 		}
 96 | 	}
 97 | };
 98 | 
 99 | // extract the string referenced by a message
100 | const get_referenced_string = (block, message) => {
101 | 	if (message.line && message.column && message.endLine && message.endColumn) {
102 | 		if (!block.line_offsets) {
103 | 			block.line_offsets = get_line_offsets(block.transformed_code);
104 | 		}
105 | 		return block.transformed_code.slice(block.line_offsets[message.line - 1] + message.column, block.line_offsets[message.endLine - 1] + message.endColumn);
106 | 	}
107 | };
108 | 
109 | // extract something that looks like an identifier (not supporting unicode escape stuff) from the beginning of a string
110 | const get_identifier = str => (str && str.match(/^[^\s!"#%&\\'()*+,\-./:;<=>?@[\\\]^`{|}~]+/) || [])[0];
111 | 
112 | // determine whether this message from ESLint is something we care about
113 | const is_valid_message = (block, message, translation) => {
114 | 	switch (message.ruleId) {
115 | 		case 'eol-last': return false;
116 | 		case '@typescript-eslint/indent':
117 | 		case 'indent': return !translation.options.template;
118 | 		case 'linebreak-style': return message.line !== translation.end;
119 | 		case 'no-labels': return get_identifier(get_referenced_string(block, message)) !== '$';
120 | 		case 'no-restricted-syntax': return message.nodeType !== 'LabeledStatement' || get_identifier(get_referenced_string(block, message)) !== '$';
121 | 		case 'no-self-assign': return !state.var_names.has(get_identifier(get_referenced_string(block, message)));
122 | 		case 'no-undef': return get_referenced_string(block, message) !== '$$Generic';
123 | 		case 'no-unused-labels': return get_referenced_string(block, message) !== '$';
124 | 		case '@typescript-eslint/no-unused-vars':
125 | 		case 'no-unused-vars': return !['$$Props', '$$Slots', '$$Events'].includes(get_referenced_string(block, message));
126 | 		case '@typescript-eslint/quotes':
127 | 		case 'quotes': return !translation.options.in_quoted_attribute;
128 | 	}
129 | 	return true;
130 | };
131 | 
132 | // transform linting messages and combine with compiler warnings
133 | export const postprocess = blocks_messages => {
134 | 	// filter messages and fix their offsets
135 | 	const blocks_array = [...state.blocks.values()];
136 | 	for (let i = 0; i < blocks_messages.length; i++) {
137 | 		const block = blocks_array[i];
138 | 		for (let j = 0; j < blocks_messages[i].length; j++) {
139 | 			const message = blocks_messages[i][j];
140 | 			const translation = block.translations.get(message.line);
141 | 			if (translation && is_valid_message(block, message, translation)) {
142 | 				transform_message(block, translation, message);
143 | 				state.messages.push(message);
144 | 			}
145 | 		}
146 | 	}
147 | 
148 | 	// sort messages and return
149 | 	const sorted_messages = state.messages.sort((a, b) => a.line - b.line || a.column - b.column);
150 | 	reset();
151 | 	return sorted_messages;
152 | };
153 | 


--------------------------------------------------------------------------------
/src/preprocess.js:
--------------------------------------------------------------------------------
  1 | import { new_block, get_translation } from './block.js';
  2 | import { processor_options } from './processor_options.js';
  3 | import { state } from './state.js';
  4 | import { DocumentMapper } from './mapping.js';
  5 | 
  6 | let default_compiler;
  7 | 
  8 | // find the contextual name or names described by a particular node in the AST
  9 | const contextual_names = [];
 10 | const find_contextual_names = (compiler, node) => {
 11 | 	if (node) {
 12 | 		if (typeof node === 'string') {
 13 | 			contextual_names.push(node);
 14 | 		} else if (typeof node === 'object') {
 15 | 			compiler.walk(node, {
 16 | 				enter(node, parent, prop) {
 17 | 					if (node.name && prop !== 'key') {
 18 | 						contextual_names.push(node.name);
 19 | 					}
 20 | 				},
 21 | 			});
 22 | 		}
 23 | 	}
 24 | };
 25 | // let-declaration that (when using TypeScript) is able to infer the type value of a autosubscribed store
 26 | const make_let = (name, is_typescript) =>
 27 | 	is_typescript && name[0] === '$' ?
 28 | 	// Disable eslint on that line because it may result in a "used before defined" error
 29 | 	`declare let ${name}:Parameters<Parameters<typeof ${name.slice(1)}.subscribe>[0]>[0]; // eslint-disable-line\n` :
 30 | 	`let ${name};`;
 31 | 
 32 | 	// ignore_styles when a `lang=` or `type=` attribute is present on the <style> tag
 33 | const ignore_styles_fallback = ({ type, lang }) => !!type || !!lang;
 34 | 
 35 | // extract scripts to lint from component definition
 36 | export const preprocess = text => {
 37 | 	const compiler = processor_options.custom_compiler || default_compiler || (default_compiler = require('svelte/compiler'));
 38 | 	const ignore_styles = processor_options.ignore_styles ? processor_options.ignore_styles : ignore_styles_fallback;
 39 | 	if (ignore_styles) {
 40 | 		// wipe the appropriate <style> tags in the file
 41 | 		text = text.replace(/<style(\s[^]*?)?>[^]*?<\/style>/gi, (match, attributes = '') => {
 42 | 			const attrs = {};
 43 | 			attributes.split(/\s+/).filter(Boolean).forEach(attr => {
 44 | 				const p = attr.indexOf('=');
 45 | 				if (p === -1) {
 46 | 					attrs[attr] = true;
 47 | 				} else {
 48 | 					attrs[attr.slice(0, p)] = '\'"'.includes(attr[p + 1]) ? attr.slice(p + 2, -1) : attr.slice(p + 1);
 49 | 				}
 50 | 			});
 51 | 			return ignore_styles(attrs) ? match.replace(/\S/g, ' ') : match;
 52 | 		});
 53 | 	}
 54 | 
 55 | 	// get information about the component
 56 | 	let result;
 57 | 	try {
 58 | 		result = compile_code(text, compiler, processor_options);
 59 | 	} catch ({ name, message, start, end }) {
 60 | 		// convert the error to a linting message, store it, and return
 61 | 		state.messages = [
 62 | 			{
 63 | 				ruleId: name,
 64 | 				severity: 2,
 65 | 				message,
 66 | 				line: start && start.line,
 67 | 				column: start && start.column + 1,
 68 | 				endLine: end && end.line,
 69 | 				endColumn: end && end.column + 1,
 70 | 			},
 71 | 		];
 72 | 		return [];
 73 | 	}
 74 | 	const { ast, warnings, vars, mapper } = result;
 75 | 
 76 | 	const references_and_reassignments = `{${vars.filter(v => v.referenced || v.name[0] === '$').map(v => v.name)};${vars.filter(v => v.reassigned || v.export_name).map(v => v.name + '=0')}}`;
 77 | 	state.var_names = new Set(vars.map(v => v.name));
 78 | 
 79 | 	// convert warnings to linting messages
 80 | 	const filtered_warnings = processor_options.ignore_warnings ? warnings.filter(warning => !processor_options.ignore_warnings(warning)) : warnings;
 81 | 	state.messages = filtered_warnings.map(({ code, message, start, end }) => {
 82 | 		const start_pos = processor_options.typescript && start ?
 83 | 			mapper.get_original_position(start) :
 84 | 			start && { line: start.line, column: start.column + 1 };
 85 | 		const end_pos = processor_options.typescript && end ?
 86 | 			mapper.get_original_position(end) :
 87 | 			end && { line: end.line, column: end.column + 1 };
 88 | 		return {
 89 | 			ruleId: code,
 90 | 			severity: 1,
 91 | 			message,
 92 | 			line: start_pos && start_pos.line,
 93 | 			column: start_pos && start_pos.column,
 94 | 			endLine: end_pos && end_pos.line,
 95 | 			endColumn: end_pos && end_pos.column,
 96 | 		};
 97 | 	});
 98 | 
 99 | 	// build strings that we can send along to ESLint to get the remaining messages
100 | 
101 | 	// Things to think about:
102 | 	// - not all Svelte files may be typescript -> do we need a distinction on a file basis by analyzing the attribute + a config option to tell "treat all as TS"?
103 | 	const with_file_ending = (filename) => `${filename}${processor_options.typescript ? '.ts' : '.js'}`;
104 | 
105 | 	if (ast.module) {
106 | 		// block for <script context='module'>
107 | 		const block = new_block();
108 | 		state.blocks.set(with_file_ending('module'), block);
109 | 
110 | 		get_translation(text, block, ast.module.content);
111 | 
112 | 		if (ast.instance) {
113 | 			block.transformed_code += text.slice(ast.instance.content.start, ast.instance.content.end);
114 | 		}
115 | 
116 | 		block.transformed_code += references_and_reassignments;
117 | 	}
118 | 
119 | 	if (ast.instance) {
120 | 		// block for <script context='instance'>
121 | 		const block = new_block();
122 | 		state.blocks.set(with_file_ending('instance'), block);
123 | 
124 | 		block.transformed_code = vars.filter(v => v.injected || !processor_options.typescript && v.module).map(v => make_let(v.name, processor_options.typescript)).join('');
125 | 		if (ast.module && processor_options.typescript) {
126 | 			block.transformed_code += text.slice(ast.module.content.start, ast.module.content.end);
127 | 		}
128 | 
129 | 		get_translation(text, block, ast.instance.content);
130 | 
131 | 		block.transformed_code += references_and_reassignments;
132 | 	}
133 | 
134 | 	if (ast.html) {
135 | 		// block for template
136 | 		const block = new_block();
137 | 		state.blocks.set(with_file_ending('template'), block);
138 | 
139 | 		if (processor_options.typescript) {
140 | 			block.transformed_code = '';
141 | 			if (ast.module) {
142 | 				block.transformed_code += text.slice(ast.module.content.start, ast.module.content.end);
143 | 			}
144 | 			if (ast.instance || vars.length) {
145 | 				block.transformed_code += '\n';
146 | 			}
147 | 			block.transformed_code += vars.filter(v => v.injected).map(v => make_let(v.name, true)).join('');
148 | 			if (ast.instance) {
149 | 				block.transformed_code += text.slice(ast.instance.content.start, ast.instance.content.end);
150 | 			}
151 | 		} else {
152 | 			block.transformed_code = vars.map(v => `let ${v.name};`).join('');
153 | 		}
154 | 
155 | 		const nodes_with_contextual_scope = new WeakSet();
156 | 		let in_quoted_attribute = false;
157 | 		compiler.walk(ast.html, {
158 | 			enter(node, parent, prop) {
159 | 				if (prop === 'expression') {
160 | 					return this.skip();
161 | 				} else if (prop === 'attributes' && '\'"'.includes(text[node.end - 1])) {
162 | 					in_quoted_attribute = true;
163 | 				}
164 | 				contextual_names.length = 0;
165 | 				find_contextual_names(compiler, node.context);
166 | 				if (node.type === 'EachBlock') {
167 | 					find_contextual_names(compiler, node.index);
168 | 				} else if (node.type === 'ThenBlock') {
169 | 					find_contextual_names(compiler, parent.value);
170 | 				} else if (node.type === 'CatchBlock') {
171 | 					find_contextual_names(compiler, parent.error);
172 | 				} else if (node.type === 'Element' || node.type === 'InlineComponent' || node.type === 'SlotTemplate') {
173 | 					node.attributes.forEach(node => node.type === 'Let' && find_contextual_names(compiler, node.expression || node.name));
174 | 				}
175 | 				if (Array.isArray(node.children)) {
176 | 					node.children.forEach(node => node.type === 'ConstTag' && find_contextual_names(compiler, node.expression.left.name || node.expression.left));
177 | 				}
178 | 				if (contextual_names.length) {
179 | 					nodes_with_contextual_scope.add(node);
180 | 					block.transformed_code += `{let ${contextual_names.map(name => `${name}=0`).join(',')};`;
181 | 				}
182 | 				if (node.expression && typeof node.expression === 'object') {
183 | 					// add the expression in question to the constructed string
184 | 					block.transformed_code += '(';
185 | 					get_translation(text, block, node.expression, { template: true, in_quoted_attribute });
186 | 					block.transformed_code += ');';
187 | 				}
188 | 			},
189 | 			leave(node, parent, prop) {
190 | 				if (prop === 'attributes') {
191 | 					in_quoted_attribute = false;
192 | 				}
193 | 				// close contextual scope
194 | 				if (nodes_with_contextual_scope.has(node)) {
195 | 					block.transformed_code += '}';
196 | 				}
197 | 			},
198 | 		});
199 | 
200 | 		block.transformed_code += `{${vars.filter(v => v.referenced_from_script || v.name[0] === '$').map(v => v.name)}}`;
201 | 	}
202 | 
203 | 	// return processed string
204 | 	return [...state.blocks].map(([filename, { transformed_code: text }]) => processor_options.named_blocks ? { text, filename } : text);
205 | };
206 | 
207 | // https://github.com/sveltejs/svelte-preprocess/blob/main/src/transformers/typescript.ts
208 | // TypeScript transformer for preserving imports correctly when preprocessing TypeScript files
209 | // Only needed if TS < 4.5
210 | const ts_import_transformer = (context) => {
211 | 	const ts = processor_options.typescript;
212 | 	const visit = (node) => {
213 | 		if (ts.isImportDeclaration(node)) {
214 | 			if (node.importClause && node.importClause.isTypeOnly) {
215 | 				return ts.createEmptyStatement();
216 | 			}
217 | 
218 | 			return ts.createImportDeclaration(
219 | 				node.decorators,
220 | 				node.modifiers,
221 | 				node.importClause,
222 | 				node.moduleSpecifier,
223 | 			);
224 | 		}
225 | 
226 | 		return ts.visitEachChild(node, (child) => visit(child), context);
227 | 	};
228 | 
229 | 	return (node) => ts.visitNode(node, visit);
230 | };
231 | 
232 | // How it works for JS:
233 | // 1. compile code
234 | // 2. return ast/vars/warnings
235 | // How it works for TS:
236 | // 1. transpile script contents from TS to JS
237 | // 2. compile result to get Svelte compiler warnings and variables
238 | // 3. provide a mapper to map those warnings back to its original positions
239 | // 4. blank script contents
240 | // 5. parse the source to get the AST
241 | // 6. return AST of step 5, warnings and vars of step 2
242 | function compile_code(text, compiler, processor_options) {
243 | 	const ts = processor_options.typescript;
244 | 	if (!ts) {
245 | 		return compiler.compile(text, { generate: false, ...processor_options.compiler_options });
246 | 	} else {
247 | 		const ts_options = {
248 | 			reportDiagnostics: false,
249 | 			compilerOptions: {
250 | 				target: ts.ScriptTarget.ESNext,
251 | 				importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Preserve,
252 | 				sourceMap: true
253 | 			},
254 | 			transformers: {
255 | 				before: [ts_import_transformer]
256 | 			}
257 | 		};
258 | 
259 | 		// See if we can use `preserveValueImports` instead of the transformer (TS >= 4.5)
260 | 		const ts_version = ts.version.split('.').map(str => parseInt(str, 10));
261 | 		if (ts_version[0] > 4 || (ts_version[0] === 4 && ts_version[1] >= 5)) {
262 | 			ts_options.compilerOptions.preserveValueImports = true;
263 | 			ts_options.transformers = {};
264 | 		}
265 | 
266 | 		const diffs = [];
267 | 		let accumulated_diff = 0;
268 | 		const transpiled = text.replace(/<script(\s[^]*?)?>([^]*?)<\/script>/gi, (match, attributes = '', content) => {
269 | 			const output = ts.transpileModule(content, ts_options);
270 | 			const original_start = text.indexOf(content);
271 | 			const generated_start = accumulated_diff + original_start;
272 | 			accumulated_diff += output.outputText.length - content.length;
273 | 			diffs.push({
274 | 				original_start: original_start,
275 | 				generated_start: generated_start,
276 | 				generated_end: generated_start + output.outputText.length,
277 | 				diff: output.outputText.length - content.length,
278 | 				original_content: content,
279 | 				generated_content: output.outputText,
280 | 				map: output.sourceMapText
281 | 			});
282 | 			return `<script${attributes}>${output.outputText}</script>`;
283 | 		});
284 | 		const mapper = new DocumentMapper(text, transpiled, diffs);
285 | 
286 | 		let ts_result;
287 | 		try {
288 | 			ts_result = compiler.compile(transpiled, { generate: false, ...processor_options.compiler_options });
289 | 		} catch (err) {
290 | 			// remap the error to be in the correct spot and rethrow it
291 | 			err.start = mapper.get_original_position(err.start);
292 | 			err.end = mapper.get_original_position(err.end);
293 | 			throw err;
294 | 		}
295 | 
296 | 		text = text.replace(/<script(\s[^]*?)?>([^]*?)<\/script>/gi, (match, attributes = '', content) => {
297 | 			return `<script${attributes}>${content
298 | 				// blank out the content
299 | 				.replace(/[^\n]/g, ' ')
300 | 				// excess blank space can make the svelte parser very slow (sec->min). break it up with comments (works in style/script)
301 | 				.replace(/[^\n][^\n][^\n][^\n]\n/g, '/**/\n')
302 | 			}</script>`;
303 | 		});
304 | 		// if we do a full recompile Svelte can fail due to the blank script tag not declaring anything
305 | 		// so instead we just parse for the AST (which is likely faster, anyways)
306 | 		const ast = compiler.parse(text, { ...processor_options.compiler_options });
307 | 		const { warnings, vars } = ts_result;
308 | 		return { ast, warnings, vars, mapper };
309 | 	}
310 | }
311 | 


--------------------------------------------------------------------------------
/src/processor_options.js:
--------------------------------------------------------------------------------
 1 | export const processor_options = {};
 2 | 
 3 | // find Linter instance
 4 | const linter_paths = Object.keys(require.cache).filter(path => path.endsWith('/eslint/lib/linter/linter.js') || path.endsWith('\\eslint\\lib\\linter\\linter.js'));
 5 | if (!linter_paths.length) {
 6 | 	throw new Error('Could not find ESLint Linter in require cache');
 7 | }
 8 | // There may be more than one instance of the linter when we're in a workspace with multiple directories.
 9 | // We first try to find the one that's inside the same node_modules directory as this plugin.
10 | // If that can't be found for some reason, we assume the one we want is the last one in the array.
11 | const current_node_modules_path = __dirname.replace(/(?<=[/\\]node_modules[/\\]).*$/, '');
12 | const linter_path = linter_paths.find(path => path.startsWith(current_node_modules_path)) || linter_paths.pop();
13 | const { Linter } = require(linter_path);
14 | 
15 | // patch Linter#verify
16 | const { verify } = Linter.prototype;
17 | Linter.prototype.verify = function(code, config, options) {
18 | 	// fetch settings
19 | 	const settings = config && (typeof config.extractConfig === 'function' ? config.extractConfig(options.filename) : config).settings || {};
20 | 	processor_options.custom_compiler = settings['svelte3/compiler'];
21 | 	processor_options.ignore_warnings = settings['svelte3/ignore-warnings'];
22 | 	processor_options.ignore_styles = settings['svelte3/ignore-styles'];
23 | 	processor_options.compiler_options = settings['svelte3/compiler-options'];
24 | 	processor_options.named_blocks = settings['svelte3/named-blocks'];
25 | 	processor_options.typescript =
26 | 		settings['svelte3/typescript'] === true
27 | 			? require('typescript')
28 | 			: typeof settings['svelte3/typescript'] === 'function'
29 | 				? settings['svelte3/typescript']()
30 | 				: settings['svelte3/typescript'];
31 | 	// call original Linter#verify
32 | 	return verify.call(this, code, config, options);
33 | };
34 | 


--------------------------------------------------------------------------------
/src/state.js:
--------------------------------------------------------------------------------
 1 | export let state;
 2 | export const reset = () => {
 3 | 	state = {
 4 | 		messages: null,
 5 | 		var_names: null,
 6 | 		blocks: new Map(),
 7 | 	};
 8 | };
 9 | reset();
10 | 


--------------------------------------------------------------------------------
/src/utils.js:
--------------------------------------------------------------------------------
 1 | // get the total length, number of lines, and length of the last line of a string
 2 | export const get_offsets = str => {
 3 | 	const { length } = str;
 4 | 	let lines = 1;
 5 | 	let last = 0;
 6 | 	for (let i = 0; i < length; i++) {
 7 | 		if (str[i] === '\n') {
 8 | 			lines++;
 9 | 			last = 0;
10 | 		} else {
11 | 			last++;
12 | 		}
13 | 	}
14 | 	return { length, lines, last };
15 | };
16 | 
17 | // dedent a script block, and get offsets necessary to later adjust linting messages about the block
18 | export const dedent_code = str => {
19 | 	let indentation = '';
20 | 	for (let i = 0; i < str.length; i++) {
21 | 		const char = str[i];
22 | 		if (char === '\n' || char === '\r') {
23 | 			indentation = '';
24 | 		} else if (char === ' ' || char === '\t') {
25 | 			indentation += str[i];
26 | 		} else {
27 | 			break;
28 | 		}
29 | 	}
30 | 	const { length } = indentation;
31 | 	let dedented = '';
32 | 	const offsets = [];
33 | 	const total_offsets = [0];
34 | 	for (let i = 0; i < str.length; i++) {
35 | 		if (i === 0 || str[i - 1] === '\n') {
36 | 			if (str.slice(i, i + length) === indentation) {
37 | 				i += length;
38 | 				offsets.push(length);
39 | 			} else {
40 | 				offsets.push(0);
41 | 			}
42 | 			total_offsets.push(total_offsets[total_offsets.length - 1] + offsets[offsets.length - 1]);
43 | 			if (i >= str.length) {
44 | 				break;
45 | 			}
46 | 		}
47 | 		dedented += str[i];
48 | 	}
49 | 	return { dedented, offsets: { offsets, total_offsets }, indentation };
50 | };
51 | 
52 | // get character offsets of each line in a string
53 | export const get_line_offsets = str => {
54 | 	const offsets = [-1];
55 | 	for (let i = 0; i < str.length; i++) {
56 | 		if (str[i] === '\n') {
57 | 			offsets.push(i);
58 | 		}
59 | 	}
60 | 	return offsets;
61 | };
62 | 


--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | process.chdir(__dirname);
 4 | 
 5 | const { ESLint } = require('eslint');
 6 | const path = require('path');
 7 | const { SourceCodeFixer } = require(path.join(require.resolve('eslint/package.json'), '../lib/linter'));
 8 | const assert = require('assert');
 9 | const fs = require('fs');
10 | 
11 | const linter = new ESLint({ reportUnusedDisableDirectives: 'error' });
12 | 
13 | async function run() {
14 | 	const tests = fs.readdirSync('samples').filter(name => name[0] !== '.');
15 | 
16 | 	for (const name of tests) {
17 | 		console.log(name);
18 | 
19 | 		const path_input = `samples/${name}/Input.svelte`;
20 | 		const path_fixed = `samples/${name}/Fixed.svelte`;
21 | 		const path_ple = `samples/${name}/preserve_line_endings`;
22 | 		const path_expected = `samples/${name}/expected.json`;
23 | 		const path_actual = `samples/${name}/actual.json`;
24 | 
25 | 		if (process.platform === 'win32' && !exists(path_ple)) {
26 | 			const file = fs.readFileSync(path_input, 'utf-8');
27 | 			fs.writeFileSync(path_input, file.replace(/\r/g, ''));
28 | 		}
29 | 
30 | 		const result = await linter.lintFiles(path_input);
31 | 
32 | 		const actual = result[0] ? result[0].messages : [];
33 | 		const expected = JSON.parse(fs.readFileSync(path_expected, 'utf-8'));
34 | 
35 | 		fs.writeFileSync(path_actual, JSON.stringify(actual, null, '\t'));
36 | 
37 | 		assert.equal(actual.length, expected.length);
38 | 		assert.deepStrictEqual(actual, actual.map((msg, i) => ({ ...msg, ...expected[i] })));
39 | 
40 | 		if (fs.existsSync(path_fixed)) {
41 | 			const fixed = SourceCodeFixer.applyFixes(fs.readFileSync(path_input, 'utf-8'), actual).output;
42 | 			assert.deepStrictEqual(fixed, fs.readFileSync(path_fixed, 'utf-8'))
43 | 		}
44 | 
45 | 		console.log('passed!\n');
46 | 	}
47 | }
48 | 
49 | function exists(path) {
50 | 	try {
51 | 		fs.accessSync(path);
52 | 		return true;
53 | 	} catch (err) {
54 | 		return false;
55 | 	}
56 | }
57 | 
58 | run();
59 | 


--------------------------------------------------------------------------------
/test/node_modules/eslint-plugin-svelte3/index.js:
--------------------------------------------------------------------------------
1 | module.exports = require('../../..');
2 | 


--------------------------------------------------------------------------------
/test/samples/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	root: true,
 3 | 	parserOptions: {
 4 | 		ecmaVersion: 2019,
 5 | 		sourceType: 'module',
 6 | 	},
 7 | 	env: {
 8 | 		es6: true,
 9 | 		browser: true,
10 | 	},
11 | 	plugins: ['svelte3'],
12 | 	overrides: [
13 | 		{
14 | 			files: ['**/*.svelte'],
15 | 			processor: 'svelte3/svelte3',
16 | 		},
17 | 	],
18 | };
19 | 


--------------------------------------------------------------------------------
/test/samples/block-filenames/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	rules: {
 3 | 		curly: 'error',
 4 | 		'no-undef': 'error',
 5 | 	},
 6 | 	settings: {
 7 | 		'svelte3/named-blocks': true
 8 | 	},
 9 | 	overrides: [
10 | 		{
11 | 			files: ['**/*.svelte/*_template.js'],
12 | 			rules: {
13 | 				curly: 'off',
14 | 			},
15 | 		},
16 | 		{
17 | 			files: ['**/*.svelte/*_module.js'],
18 | 			rules: {
19 | 				'no-undef': 'off',
20 | 			},
21 | 		},
22 | 	],
23 | };
24 | 


--------------------------------------------------------------------------------
/test/samples/block-filenames/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script context='module'>
 2 | 	if (blah) blah;
 3 | </script>
 4 | 
 5 | <script>
 6 | 	let foo, bar;
 7 | 	if (foo) bar;
 8 | </script>
 9 | 
10 | <div on:click={() => { if (foo) bar; }} on:keyup={() => { if (foo) bar; }}>blah</div>
11 | 


--------------------------------------------------------------------------------
/test/samples/block-filenames/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "curly",
 4 | 		"line": 2,
 5 | 		"column": 12
 6 | 	},
 7 | 	{
 8 | 		"ruleId": "curly",
 9 | 		"line": 7,
10 | 		"column": 11
11 | 	}
12 | ]
13 | 


--------------------------------------------------------------------------------
/test/samples/compiler-error/Input.svelte:
--------------------------------------------------------------------------------
1 | <script>
2 | 


--------------------------------------------------------------------------------
/test/samples/compiler-error/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "ParseError",
 4 | 		"line": 1,
 5 | 		"column": 9,
 6 | 		"endLine": 1,
 7 | 		"endColumn": 9
 8 | 	}
 9 | ]
10 | 


--------------------------------------------------------------------------------
/test/samples/const-tag/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		'no-undef': 'error',
4 | 	},
5 | 	settings: {
6 | 		'svelte3/ignore-warnings': ({ code }) => code === 'missing-declaration',
7 | 	},
8 | };
9 | 


--------------------------------------------------------------------------------
/test/samples/const-tag/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script>
 2 | 	export let boxes;
 3 | 	let p;
 4 | 	let dimensions = [{ width: 100, height: 20 }];
 5 | </script>
 6 | 
 7 | {#each boxes as box}
 8 | 	{@const area = box.width * box.height}
 9 | 	{box.width} * {box.height} = {area}
10 | {/each}
11 | 
12 | {area} <!-- undef -->
13 | 
14 | {#each dimensions as dimension}
15 | 	{@const { width, height } = dimension}
16 | 	{width}
17 | 	{height}
18 | 	{unknown} <!-- undef -->
19 | {/each}
20 | 
21 | {#await p}
22 | 	wait
23 | {:then}
24 | 	{@const box = boxes[0]}
25 | 	{box.width}
26 | {/await}
27 | 
28 | {#await p then}
29 | 	then
30 | {:catch}
31 | 	{@const box = boxes[0]}
32 | 	{box.width}
33 | {/await}
34 | 
35 | <Component>
36 | 	{@const box = boxes[0]}
37 | 	{box.width}
38 | </Component>
39 | 
40 | <Component>
41 | 	<svelte:fragment slot="foo">
42 | 		{@const box = boxes[0]}
43 | 		{box.width}
44 | 	</svelte:fragment>
45 | </Component>
46 | 


--------------------------------------------------------------------------------
/test/samples/const-tag/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "no-undef",
 4 | 		"line": 12,
 5 | 		"column": 2,
 6 | 		"endLine": 12,
 7 | 		"endColumn": 6
 8 | 	},
 9 | 	{
10 | 		"ruleId": "no-undef",
11 | 		"line": 18,
12 | 		"column": 3,
13 | 		"endLine": 18,
14 | 		"endColumn": 10
15 | 	}
16 | ]
17 | 


--------------------------------------------------------------------------------
/test/samples/ignore-styles/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	settings: {
3 | 		'svelte3/ignore-styles': attributes => attributes.foo && attributes.foo.includes('bar'),
4 | 	},
5 | };
6 | 


--------------------------------------------------------------------------------
/test/samples/ignore-styles/Input.svelte:
--------------------------------------------------------------------------------
1 | <style foo='blah=bar'>
2 | 	{
3 | </style>
4 | 


--------------------------------------------------------------------------------
/test/samples/ignore-styles/expected.json:
--------------------------------------------------------------------------------
1 | []
2 | 


--------------------------------------------------------------------------------
/test/samples/indentation/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		indent: ['error', 'tab'],
4 | 		semi: 'error',
5 | 	},
6 | };
7 | 


--------------------------------------------------------------------------------
/test/samples/indentation/Input.svelte:
--------------------------------------------------------------------------------
1 | <script>
2 | 	foo
3 | 		bar
4 | 	</script>
5 | 


--------------------------------------------------------------------------------
/test/samples/indentation/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "semi",
 4 | 		"line": 2,
 5 | 		"column": 5,
 6 | 		"fix": {
 7 | 			"range": [13, 13],
 8 | 			"text": ";"
 9 | 		}
10 | 	},
11 | 	{
12 | 		"ruleId": "indent",
13 | 		"line": 3,
14 | 		"column": 2,
15 | 		"endLine": 3,
16 | 		"endColumn": 3,
17 | 		"fix": {
18 | 			"range": [15, 16],
19 | 			"text": ""
20 | 		}
21 | 	},
22 | 	{
23 | 		"ruleId": "semi",
24 | 		"line": 3,
25 | 		"column": 6,
26 | 		"fix": {
27 | 			"range": [19, 19],
28 | 			"text": ";"
29 | 		}
30 | 	}
31 | ]
32 | 


--------------------------------------------------------------------------------
/test/samples/labels/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		'no-labels': 'error',
4 | 		'no-restricted-syntax': ['error', 'LabeledStatement'],
5 | 		'no-unused-labels': 'error',
6 | 	},
7 | };
8 | 


--------------------------------------------------------------------------------
/test/samples/labels/Input.svelte:
--------------------------------------------------------------------------------
1 | <script>
2 | 	foo: bar;
3 | 	$: bar;
4 | 	$baz: blah;
5 | </script>
6 | 


--------------------------------------------------------------------------------
/test/samples/labels/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "no-restricted-syntax",
 4 | 		"line": 2,
 5 | 		"column": 2,
 6 | 		"endLine": 2,
 7 | 		"endColumn": 11
 8 | 	},
 9 | 	{
10 | 		"ruleId": "no-labels",
11 | 		"line": 2,
12 | 		"column": 2,
13 | 		"endLine": 2,
14 | 		"endColumn": 11
15 | 	},
16 | 	{
17 | 		"ruleId": "no-unused-labels",
18 | 		"line": 2,
19 | 		"column": 2,
20 | 		"endLine": 2,
21 | 		"endColumn": 5,
22 | 		"fix": {
23 | 			"range": [10, 15],
24 | 			"text": ""
25 | 		}
26 | 	},
27 | 	{
28 | 		"ruleId": "no-restricted-syntax",
29 | 		"line": 4,
30 | 		"column": 2,
31 | 		"endLine": 4,
32 | 		"endColumn": 13
33 | 	},
34 | 	{
35 | 		"ruleId": "no-labels",
36 | 		"line": 4,
37 | 		"column": 2,
38 | 		"endLine": 4,
39 | 		"endColumn": 13
40 | 	},
41 | 	{
42 | 		"ruleId": "no-unused-labels",
43 | 		"line": 4,
44 | 		"column": 2,
45 | 		"endLine": 4,
46 | 		"endColumn": 6,
47 | 		"fix": {
48 | 			"range": [30, 36],
49 | 			"text": ""
50 | 		}
51 | 	}
52 | ]
53 | 


--------------------------------------------------------------------------------
/test/samples/line-endings/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		'linebreak-style': ['error', 'windows'],
4 | 	},
5 | };
6 | 


--------------------------------------------------------------------------------
/test/samples/line-endings/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script context='module'>
 2 | 	console.log('Hello');
 3 | </script>
 4 | 
 5 | <script>
 6 | 	console.log('Hello');
 7 | </script>
 8 | 
 9 | {foo}
10 | 


--------------------------------------------------------------------------------
/test/samples/line-endings/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "missing-declaration",
 4 | 		"line": 9,
 5 | 		"column": 2,
 6 | 		"endLine": 9,
 7 | 		"endColumn": 5
 8 | 	}
 9 | ]
10 | 


--------------------------------------------------------------------------------
/test/samples/line-endings/preserve_line_endings:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sveltejs/eslint-plugin-svelte3/92671bee83b1d38979e1b0f2897a987cbd61b808/test/samples/line-endings/preserve_line_endings


--------------------------------------------------------------------------------
/test/samples/module-context/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		'no-undef': 'error',
4 | 		'no-unused-vars': 'error',
5 | 		'prefer-const': 'error',
6 | 	},
7 | };
8 | 


--------------------------------------------------------------------------------
/test/samples/module-context/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script context='module'>
 2 | 	const foo = {}, bar = {};
 3 | 	let baz1 = null, baz2 = null;
 4 | </script>
 5 | 
 6 | <script>
 7 | 	console.log(foo, $foo);
 8 | 	console.log(baz1, baz2);
 9 | 	console.log($blah);
10 | 	baz2 = 0;
11 | </script>
12 | 


--------------------------------------------------------------------------------
/test/samples/module-context/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "no-unused-vars",
 4 | 		"line": 2,
 5 | 		"column": 18,
 6 | 		"endLine": 2,
 7 | 		"endColumn": 21
 8 | 	},
 9 | 	{
10 | 		"ruleId": "prefer-const",
11 | 		"line": 3,
12 | 		"column": 6,
13 | 		"endLine": 3,
14 | 		"endColumn": 10
15 | 	},
16 | 	{
17 | 		"ruleId": "missing-declaration",
18 | 		"line": 9,
19 | 		"column": 14,
20 | 		"endLine": 9,
21 | 		"endColumn": 19
22 | 	}
23 | ]
24 | 


--------------------------------------------------------------------------------
/test/samples/multiline-fixes/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		curly: 'error',
4 | 		'no-else-return': 'error',
5 | 		'no-lonely-if': 'error',
6 | 	},
7 | };
8 | 


--------------------------------------------------------------------------------
/test/samples/multiline-fixes/Fixed.svelte:
--------------------------------------------------------------------------------
 1 | <script>
 2 |     if (window.foo)
 3 |         {window.foo =
 4 |             window.bar
 5 |                 .toLowerCase()
 6 |                 .replace('something', 'else')
 7 |                 .trim();}
 8 | 
 9 |     function noElseReturn() {
10 |         if (window) {
11 |             return 'foo';
12 |         } 
13 |             return 'bar';
14 |         
15 |     }
16 | 
17 |     function noLonelyIf() {
18 |         if (window) {
19 |             doX();
20 |         } else if (!window) {
21 |                 doY();
22 |             }
23 |     }
24 | </script>
25 | 


--------------------------------------------------------------------------------
/test/samples/multiline-fixes/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script>
 2 |     if (window.foo)
 3 |         window.foo =
 4 |             window.bar
 5 |                 .toLowerCase()
 6 |                 .replace('something', 'else')
 7 |                 .trim();
 8 | 
 9 |     function noElseReturn() {
10 |         if (window) {
11 |             return 'foo';
12 |         } else {
13 |             return 'bar';
14 |         }
15 |     }
16 | 
17 |     function noLonelyIf() {
18 |         if (window) {
19 |             doX();
20 |         } else {
21 |             if (!window) {
22 |                 doY();
23 |             }
24 |         }
25 |     }
26 | </script>
27 | 


--------------------------------------------------------------------------------
/test/samples/multiline-fixes/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "curly",
 4 | 		"severity": 2,
 5 | 		"message": "Expected { after 'if' condition.",
 6 | 		"line": 3,
 7 | 		"column": 9,
 8 | 		"nodeType": "IfStatement",
 9 | 		"messageId": "missingCurlyAfterCondition",
10 | 		"endLine": 7,
11 | 		"endColumn": 25,
12 | 		"fix": {
13 | 			"range": [
14 | 				37,
15 | 				174
16 | 			],
17 | 			"text": "{window.foo =\n            window.bar\n                .toLowerCase()\n                .replace('something', 'else')\n                .trim();}"
18 | 		}
19 | 	},
20 | 	{
21 | 		"ruleId": "no-else-return",
22 | 		"severity": 2,
23 | 		"message": "Unnecessary 'else' after 'return'.",
24 | 		"line": 12,
25 | 		"column": 16,
26 | 		"nodeType": "BlockStatement",
27 | 		"messageId": "unexpected",
28 | 		"endLine": 14,
29 | 		"endColumn": 10,
30 | 		"fix": {
31 | 			"range": [
32 | 				264,
33 | 				306
34 | 			],
35 | 			"text": "\n            return 'bar';\n        "
36 | 		}
37 | 	},
38 | 	{
39 | 		"ruleId": "no-lonely-if",
40 | 		"severity": 2,
41 | 		"message": "Unexpected if as the only statement in an else block.",
42 | 		"line": 21,
43 | 		"column": 13,
44 | 		"nodeType": "IfStatement",
45 | 		"messageId": "unexpectedLonelyIf",
46 | 		"endLine": 23,
47 | 		"endColumn": 14,
48 | 		"fix": {
49 | 			"range": [
50 | 				398,
51 | 				468
52 | 			],
53 | 			"text": "if (!window) {\n                doY();\n        "
54 | 		}
55 | 	}
56 | ]


--------------------------------------------------------------------------------
/test/samples/scope/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		'no-undef': 'error',
4 | 	},
5 | 	settings: {
6 | 		'svelte3/ignore-warnings': ({ code }) => code === 'missing-declaration',
7 | 	},
8 | };
9 | 


--------------------------------------------------------------------------------
/test/samples/scope/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script>
 2 | 	let foo;
 3 | </script>
 4 | 
 5 | {#each foo as bar}
 6 | 	{bar}
 7 | {/each}
 8 | 
 9 | {bar}
10 | 
11 | {#each foo as [bar1, { bar2 }]}
12 | 	{bar1}
13 | 	{bar2}
14 | 	{bar3}
15 | {/each}
16 | 
17 | <Component let:baz>
18 | 	{baz}
19 | </Component>
20 | 
21 | <Component let:baz={{ baz1, baz2 }}>
22 | 	{baz1}
23 | 	{baz2}
24 | 	{baz3}
25 | </Component>
26 | 
27 | <Component2>
28 | 	<div slot='foo' let:blah={blah2}>
29 | 		{blah1}
30 | 		{blah2}
31 | 	</div>
32 | </Component2>
33 | 
34 | <Component2>
35 | 	<svelte:fragment slot='foo' let:blah={blah2}>
36 | 		{blah1}
37 | 		{blah2}
38 | 	</svelte:fragment>
39 | </Component2>
40 | 
41 | {#await foo}
42 | 	xxx
43 | {:then blah1}
44 | 	{blah1}
45 | 	{blah2}
46 | {:catch blah2}
47 | 	{blah1}
48 | 	{blah2}
49 | {/await}
50 | 
51 | {#await foo then bar}
52 | 	{bar}
53 | {/await}
54 | 


--------------------------------------------------------------------------------
/test/samples/scope/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "no-undef",
 4 | 		"line": 9,
 5 | 		"column": 2,
 6 | 		"endLine": 9,
 7 | 		"endColumn": 5
 8 | 	},
 9 | 	{
10 | 		"ruleId": "no-undef",
11 | 		"line": 14,
12 | 		"column": 3,
13 | 		"endLine": 14,
14 | 		"endColumn": 7
15 | 	},
16 | 	{
17 | 		"ruleId": "no-undef",
18 | 		"line": 24,
19 | 		"column": 3,
20 | 		"endLine": 24,
21 | 		"endColumn": 7
22 | 	},
23 | 	{
24 | 		"ruleId": "no-undef",
25 | 		"line": 29,
26 | 		"column": 4,
27 | 		"endLine": 29,
28 | 		"endColumn": 9
29 | 	},
30 | 	{
31 | 		"ruleId": "no-undef",
32 | 		"line": 36,
33 | 		"column": 4,
34 | 		"endLine": 36,
35 | 		"endColumn": 9
36 | 	},
37 | 	{
38 | 		"ruleId": "no-undef",
39 | 		"line": 45,
40 | 		"column": 3,
41 | 		"endLine": 45,
42 | 		"endColumn": 8
43 | 	},
44 | 	{
45 | 		"ruleId": "no-undef",
46 | 		"line": 47,
47 | 		"column": 3,
48 | 		"endLine": 47,
49 | 		"endColumn": 8
50 | 	}
51 | ]
52 | 


--------------------------------------------------------------------------------
/test/samples/script-reference/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		'no-unused-vars': 'error',
4 | 	},
5 | };
6 | 


--------------------------------------------------------------------------------
/test/samples/script-reference/Input.svelte:
--------------------------------------------------------------------------------
1 | <script>
2 | 	let foo = false;
3 | 	setInterval(() => {
4 | 		console.log(foo);
5 | 	}, 1000);
6 | </script>
7 | 
8 | <div on:click={() => foo = true} on:keyup={() => foo = true}>foo</div>
9 | 


--------------------------------------------------------------------------------
/test/samples/script-reference/expected.json:
--------------------------------------------------------------------------------
1 | []
2 | 


--------------------------------------------------------------------------------
/test/samples/self-assignment/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		'no-self-assign': 'error',
4 | 	},
5 | };
6 | 


--------------------------------------------------------------------------------
/test/samples/self-assignment/Input.svelte:
--------------------------------------------------------------------------------
1 | <script>
2 | 	let foo;
3 | 	foo = foo;
4 | 	function bar() {
5 | 		let baz;
6 | 		baz = baz;
7 | 	}
8 | </script>
9 | 


--------------------------------------------------------------------------------
/test/samples/self-assignment/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "no-self-assign",
 4 | 		"line": 6,
 5 | 		"column": 9,
 6 | 		"endLine": 6,
 7 | 		"endColumn": 12
 8 | 	}
 9 | ]
10 | 


--------------------------------------------------------------------------------
/test/samples/template-quotes/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		quotes: ['error', 'single'],
4 | 	},
5 | };
6 | 


--------------------------------------------------------------------------------
/test/samples/template-quotes/Input.svelte:
--------------------------------------------------------------------------------
1 | {'foo'}
2 | {"bar"}
3 | <div class={"baz1"}></div>
4 | <div class='{"baz2"}'></div>
5 | 


--------------------------------------------------------------------------------
/test/samples/template-quotes/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "quotes",
 4 | 		"line": 2,
 5 | 		"column": 2,
 6 | 		"endLine": 2,
 7 | 		"endColumn": 7,
 8 | 		"fix": {
 9 | 			"range": [9, 14],
10 | 			"text": "'bar'"
11 | 		}
12 | 	},
13 | 	{
14 | 		"ruleId": "quotes",
15 | 		"line": 3,
16 | 		"column": 13,
17 | 		"endLine": 3,
18 | 		"endColumn": 19,
19 | 		"fix": {
20 | 			"range": [28, 34],
21 | 			"text": "'baz1'"
22 | 		}
23 | 	}
24 | ]
25 | 


--------------------------------------------------------------------------------
/test/samples/typescript-$$globals/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	parser: '@typescript-eslint/parser',
3 | 	extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
4 | 	plugins: ['@typescript-eslint'],
5 | 	settings: {
6 | 		'svelte3/typescript': require('typescript'),
7 | 	},
8 | };
9 | 


--------------------------------------------------------------------------------
/test/samples/typescript-$$globals/Input.svelte:
--------------------------------------------------------------------------------
1 | {$$slots.foo}
2 | {$$props.bar}
3 | {$$restProps.baz}
4 | 


--------------------------------------------------------------------------------
/test/samples/typescript-$$globals/expected.json:
--------------------------------------------------------------------------------
1 | []
2 | 


--------------------------------------------------------------------------------
/test/samples/typescript-bind-reference/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	parser: '@typescript-eslint/parser',
3 | 	extends: ['plugin:@typescript-eslint/recommended'],
4 | 	plugins: ['@typescript-eslint'],
5 | 	settings: {
6 | 		'svelte3/typescript': require('typescript'),
7 | 	},
8 | };
9 | 


--------------------------------------------------------------------------------
/test/samples/typescript-bind-reference/Input.svelte:
--------------------------------------------------------------------------------
1 | <script>
2 | 	let value = '';
3 | 	let foo = '';
4 | </script>
5 | 
6 | <input bind:value />
7 | <input bind:value={foo} />
8 | 


--------------------------------------------------------------------------------
/test/samples/typescript-bind-reference/expected.json:
--------------------------------------------------------------------------------
1 | []
2 | 


--------------------------------------------------------------------------------
/test/samples/typescript-block-filenames/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	extends: ['plugin:@typescript-eslint/recommended'],
 4 | 	plugins: ['@typescript-eslint'],
 5 | 	overrides: [
 6 | 		{
 7 | 			files: ['**/*.svelte/*_template.ts'],
 8 | 			rules: {
 9 | 				curly: 'off',
10 | 			},
11 | 		},
12 | 		{
13 | 			files: ['**/*.svelte/*_module.ts'],
14 | 			rules: {
15 | 				'no-undef': 'off',
16 | 			},
17 | 		},
18 | 	],
19 | 	settings: {
20 | 		'svelte3/typescript': require('typescript'),
21 | 		'svelte3/named-blocks': true,
22 | 	},
23 | 	rules: {
24 | 		curly: 'error',
25 | 		'no-undef': 'error',
26 | 	},
27 | };
28 | 


--------------------------------------------------------------------------------
/test/samples/typescript-block-filenames/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script context='module'>
 2 | 	if (blah) blah;
 3 | </script>
 4 | 
 5 | <script>
 6 | 	let foo, bar;
 7 | 	if (foo) bar;
 8 | </script>
 9 | 
10 | <div on:click={() => { if (foo) bar; }} on:keyup={() => { if (foo) bar; }}>blah</div>
11 | 


--------------------------------------------------------------------------------
/test/samples/typescript-block-filenames/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "curly",
 4 | 		"line": 2,
 5 | 		"column": 12
 6 | 	},
 7 | 	{
 8 | 		"ruleId": "curly",
 9 | 		"line": 7,
10 | 		"column": 11
11 | 	}
12 | ]
13 | 


--------------------------------------------------------------------------------
/test/samples/typescript-imports/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	plugins: ['@typescript-eslint'],
 4 | 	settings: {
 5 | 		'svelte3/typescript': require('typescript'),
 6 | 	},
 7 | 	rules: {
 8 | 		'no-unused-vars': 'error',
 9 | 	},
10 | };
11 | 


--------------------------------------------------------------------------------
/test/samples/typescript-imports/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script lang='ts'>
 2 | 	import type { Type, UnusedType } from './types';
 3 | 	import Component from './Component.svelte';
 4 | 	import UnusedComponent from './UnusedComponent.svelte';
 5 | 	import { Thing1, Thing2, UnusedThing } from './things';
 6 | 	const a: Type = new Thing1();
 7 | 	a;
 8 | </script>
 9 | 
10 | <div on:click={() => new Thing2()} on:keyup={() => new Thing2()}></div>
11 | <Component />
12 | 


--------------------------------------------------------------------------------
/test/samples/typescript-imports/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "no-unused-vars",
 4 | 		"severity": 2,
 5 | 		"line": 2,
 6 | 		"column": 22,
 7 | 		"endLine": 2,
 8 | 		"endColumn": 32
 9 | 	},
10 | 	{
11 | 		"ruleId": "no-unused-vars",
12 | 		"severity": 2,
13 | 		"line": 4,
14 | 		"column": 9,
15 | 		"endLine": 4,
16 | 		"endColumn": 24
17 | 	},
18 | 	{
19 | 		"ruleId": "no-unused-vars",
20 | 		"severity": 2,
21 | 		"line": 5,
22 | 		"column": 27,
23 | 		"endLine": 5,
24 | 		"endColumn": 38
25 | 	}
26 | ]
27 | 


--------------------------------------------------------------------------------
/test/samples/typescript-indentation/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	plugins: [
 4 | 		'@typescript-eslint',
 5 | 	],
 6 | 	rules: {
 7 | 		indent: 'off',
 8 | 		'@typescript-eslint/indent': ['error', 'tab'],
 9 | 		semi: 'error',
10 | 	},
11 | };
12 | 


--------------------------------------------------------------------------------
/test/samples/typescript-indentation/Input.svelte:
--------------------------------------------------------------------------------
1 | <script lang='ts'>
2 | 	let foo
3 | 		let bar
4 | 	</script>
5 | 
6 | <div>{foo}</div>
7 | 


--------------------------------------------------------------------------------
/test/samples/typescript-indentation/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "semi",
 4 | 		"line": 2,
 5 | 		"column": 9,
 6 | 		"fix": {
 7 | 			"range": [27, 27],
 8 | 			"text": ";"
 9 | 		}
10 | 	},
11 | 	{
12 | 		"ruleId": "@typescript-eslint/indent",
13 | 		"line": 3,
14 | 		"column": 2,
15 | 		"endLine": 3,
16 | 		"endColumn": 3,
17 | 		"fix": {
18 | 			"range": [29, 30],
19 | 			"text": ""
20 | 		}
21 | 	},
22 | 	{
23 | 		"ruleId": "semi",
24 | 		"line": 3,
25 | 		"column": 10,
26 | 		"fix": {
27 | 			"range": [37, 37],
28 | 			"text": ";"
29 | 		}
30 | 	}
31 | ]
32 | 


--------------------------------------------------------------------------------
/test/samples/typescript-inline-type-import/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	plugins: ['@typescript-eslint'],
 4 | 	settings: {
 5 | 		'svelte3/typescript': require('typescript'),
 6 | 	},
 7 | 	rules: {
 8 | 		'no-unused-vars': 'error',
 9 | 	},
10 | };
11 | 


--------------------------------------------------------------------------------
/test/samples/typescript-inline-type-import/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script lang='ts'>
 2 | 	import Component from './Component.svelte';
 3 | 	import UnusedComponent from './UnusedComponent.svelte';
 4 | 	import { Thing1, Thing2, UnusedThing, type Type, type UnusedType } from './things';
 5 | 	const a: Type = new Thing1();
 6 | 	a;
 7 | </script>
 8 | 
 9 | <div on:click={() => new Thing2()} on:keyup={() => new Thing2()}></div>
10 | <Component />
11 | 


--------------------------------------------------------------------------------
/test/samples/typescript-inline-type-import/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "no-unused-vars",
 4 | 		"severity": 2,
 5 | 		"message": "'UnusedComponent' is defined but never used.",
 6 | 		"line": 3,
 7 | 		"column": 9,
 8 | 		"nodeType": "Identifier",
 9 | 		"messageId": "unusedVar",
10 | 		"endLine": 3,
11 | 		"endColumn": 24
12 | 	},
13 | 	{
14 | 		"ruleId": "no-unused-vars",
15 | 		"severity": 2,
16 | 		"message": "'UnusedThing' is defined but never used.",
17 | 		"line": 4,
18 | 		"column": 27,
19 | 		"nodeType": "Identifier",
20 | 		"messageId": "unusedVar",
21 | 		"endLine": 4,
22 | 		"endColumn": 38
23 | 	},
24 | 	{
25 | 		"ruleId": "no-unused-vars",
26 | 		"severity": 2,
27 | 		"message": "'UnusedType' is defined but never used.",
28 | 		"line": 4,
29 | 		"column": 56,
30 | 		"nodeType": "Identifier",
31 | 		"messageId": "unusedVar",
32 | 		"endLine": 4,
33 | 		"endColumn": 66
34 | 	}
35 | ]
36 | 


--------------------------------------------------------------------------------
/test/samples/typescript-lazy/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
 4 | 	plugins: ['@typescript-eslint'],
 5 | 	settings: {
 6 | 		'svelte3/typescript': () => require('typescript'),
 7 | 	},
 8 | 	rules: {
 9 | 		indent: ['error', 'tab'],
10 | 		semi: 'error',
11 | 	},
12 | };
13 | 


--------------------------------------------------------------------------------
/test/samples/typescript-lazy/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script context="module">
 2 | 	export const z = '';
 3 | 	$: z2 = z;
 4 | </script>
 5 | 
 6 | <script lang="ts">
 7 | 	export let a: any;
 8 | 
 9 | 		export let b: any
10 | 	export let d: number;
11 | 
12 | 	const asd = d.asd();
13 | 
14 | 	interface A {}
15 | 
16 | 	function c(x) {}
17 | 	c(1);
18 | 
19 | 	$: z1 = z;
20 | </script>
21 | 
22 | <o>{b}</o>
23 | <p>{x}</p>
24 | 


--------------------------------------------------------------------------------
/test/samples/typescript-lazy/expected.json:
--------------------------------------------------------------------------------
  1 | [
  2 | 	{
  3 | 		"ruleId": "module-script-reactive-declaration",
  4 | 		"severity": 1,
  5 | 		"line": 3,
  6 | 		"column": 2,
  7 | 		"endLine": 3,
  8 | 		"endColumn": 12
  9 | 	},
 10 | 	{
 11 | 		"ruleId": "no-undef",
 12 | 		"severity": 2,
 13 | 		"line": 3,
 14 | 		"column": 5,
 15 | 		"endLine": 3,
 16 | 		"endColumn": 7
 17 | 	},
 18 | 	{
 19 | 		"ruleId": "unused-export-let",
 20 | 		"severity": 1,
 21 | 		"line": 7,
 22 | 		"column": 13,
 23 | 		"endLine": 7,
 24 | 		"endColumn": 19
 25 | 	},
 26 | 	{
 27 | 		"ruleId": "@typescript-eslint/no-explicit-any",
 28 | 		"severity": 1,
 29 | 		"line": 7,
 30 | 		"column": 16,
 31 | 		"endLine": 7,
 32 | 		"endColumn": 19,
 33 | 		"suggestions": [
 34 | 			{
 35 | 				"messageId": "suggestUnknown",
 36 | 				"fix": {
 37 | 					"range": [
 38 | 						58,
 39 | 						61
 40 | 					],
 41 | 					"text": "unknown"
 42 | 				},
 43 | 				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
 44 | 			},
 45 | 			{
 46 | 				"messageId": "suggestNever",
 47 | 				"fix": {
 48 | 					"range": [
 49 | 						58,
 50 | 						61
 51 | 					],
 52 | 					"text": "never"
 53 | 				},
 54 | 				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
 55 | 			}
 56 | 		]
 57 | 	},
 58 | 	{
 59 | 		"ruleId": "indent",
 60 | 		"severity": 2,
 61 | 		"line": 9,
 62 | 		"column": 2,
 63 | 		"endLine": 9,
 64 | 		"endColumn": 3,
 65 | 		"fix": {
 66 | 			"range": [
 67 | 				112,
 68 | 				113
 69 | 			],
 70 | 			"text": ""
 71 | 		}
 72 | 	},
 73 | 	{
 74 | 		"ruleId": "@typescript-eslint/no-explicit-any",
 75 | 		"severity": 1,
 76 | 		"line": 9,
 77 | 		"column": 17,
 78 | 		"endLine": 9,
 79 | 		"endColumn": 20,
 80 | 		"suggestions": [
 81 | 			{
 82 | 				"messageId": "suggestUnknown",
 83 | 				"fix": {
 84 | 					"range": [
 85 | 						79,
 86 | 						82
 87 | 					],
 88 | 					"text": "unknown"
 89 | 				},
 90 | 				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
 91 | 			},
 92 | 			{
 93 | 				"messageId": "suggestNever",
 94 | 				"fix": {
 95 | 					"range": [
 96 | 						79,
 97 | 						82
 98 | 					],
 99 | 					"text": "never"
100 | 				},
101 | 				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
102 | 			}
103 | 		]
104 | 	},
105 | 	{
106 | 		"ruleId": "semi",
107 | 		"severity": 2,
108 | 		"line": 9,
109 | 		"column": 20,
110 | 		"endLine": 10,
111 | 		"endColumn": 2,
112 | 		"fix": {
113 | 			"range": [
114 | 				130,
115 | 				130
116 | 			],
117 | 			"text": ";"
118 | 		}
119 | 	},
120 | 	{
121 | 		"ruleId": "@typescript-eslint/no-unused-vars",
122 | 		"severity": 1,
123 | 		"line": 12,
124 | 		"column": 8,
125 | 		"endLine": 12,
126 | 		"endColumn": 11
127 | 	},
128 | 	{
129 | 		"ruleId": "@typescript-eslint/no-empty-interface",
130 | 		"severity": 2,
131 | 		"line": 14,
132 | 		"column": 12,
133 | 		"endLine": 14,
134 | 		"endColumn": 13
135 | 	},
136 | 	{
137 | 		"ruleId": "@typescript-eslint/no-unused-vars",
138 | 		"severity": 1,
139 | 		"line": 14,
140 | 		"column": 12,
141 | 		"endLine": 14,
142 | 		"endColumn": 13
143 | 	},
144 | 	{
145 | 		"ruleId": "@typescript-eslint/no-unused-vars",
146 | 		"severity": 1,
147 | 		"line": 16,
148 | 		"column": 13,
149 | 		"endLine": 16,
150 | 		"endColumn": 14
151 | 	},
152 | 	{
153 | 		"ruleId": "@typescript-eslint/no-empty-function",
154 | 		"severity": 2,
155 | 		"line": 16,
156 | 		"column": 16,
157 | 		"endLine": 16,
158 | 		"endColumn": 18
159 | 	},
160 | 	{
161 | 		"ruleId": "missing-declaration",
162 | 		"severity": 1,
163 | 		"line": 23,
164 | 		"column": 5,
165 | 		"endLine": 23,
166 | 		"endColumn": 6
167 | 	},
168 | 	{
169 | 		"ruleId": "no-undef",
170 | 		"severity": 2,
171 | 		"line": 23,
172 | 		"column": 5,
173 | 		"endLine": 23,
174 | 		"endColumn": 6
175 | 	}
176 | ]
177 | 


--------------------------------------------------------------------------------
/test/samples/typescript-multiline-fixes/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	plugins: ['@typescript-eslint'],
 4 | 	settings: {
 5 | 		'svelte3/typescript': require('typescript'),
 6 | 	},
 7 | 	rules: {
 8 | 		curly: 'error',
 9 | 		'no-else-return': 'error',
10 | 		'no-lonely-if': 'error',
11 | 	},
12 | };
13 | 


--------------------------------------------------------------------------------
/test/samples/typescript-multiline-fixes/Fixed.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 |     interface Foo {}
 3 | 
 4 |     if (window.foo)
 5 |         {window.foo =
 6 |             window.bar
 7 |                 .toLowerCase()
 8 |                 .replace('something' as string, 'else')
 9 |                 .trim();}
10 | 
11 |     function noElseReturn(): string {
12 |         if (window) {
13 |             return 'foo';
14 |         } 
15 |             return 'bar' as string;
16 |         
17 |     }
18 | 
19 |     function noLonelyIf(): void {
20 |         if (window) {
21 |             doX();
22 |         } else if (!window) {
23 |                 (doY as any)();
24 |             }
25 |     }
26 | </script>
27 | 


--------------------------------------------------------------------------------
/test/samples/typescript-multiline-fixes/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 |     interface Foo {}
 3 | 
 4 |     if (window.foo)
 5 |         window.foo =
 6 |             window.bar
 7 |                 .toLowerCase()
 8 |                 .replace('something' as string, 'else')
 9 |                 .trim();
10 | 
11 |     function noElseReturn(): string {
12 |         if (window) {
13 |             return 'foo';
14 |         } else {
15 |             return 'bar' as string;
16 |         }
17 |     }
18 | 
19 |     function noLonelyIf(): void {
20 |         if (window) {
21 |             doX();
22 |         } else {
23 |             if (!window) {
24 |                 (doY as any)();
25 |             }
26 |         }
27 |     }
28 | </script>
29 | 


--------------------------------------------------------------------------------
/test/samples/typescript-multiline-fixes/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "curly",
 4 | 		"severity": 2,
 5 | 		"message": "Expected { after 'if' condition.",
 6 | 		"line": 5,
 7 | 		"column": 9,
 8 | 		"nodeType": "IfStatement",
 9 | 		"messageId": "missingCurlyAfterCondition",
10 | 		"endLine": 9,
11 | 		"endColumn": 25,
12 | 		"fix": {
13 | 			"range": [
14 | 				69,
15 | 				216
16 | 			],
17 | 			"text": "{window.foo =\n            window.bar\n                .toLowerCase()\n                .replace('something' as string, 'else')\n                .trim();}"
18 | 		}
19 | 	},
20 | 	{
21 | 		"ruleId": "no-else-return",
22 | 		"severity": 2,
23 | 		"message": "Unnecessary 'else' after 'return'.",
24 | 		"line": 14,
25 | 		"column": 16,
26 | 		"nodeType": "BlockStatement",
27 | 		"messageId": "unexpected",
28 | 		"endLine": 16,
29 | 		"endColumn": 10,
30 | 		"fix": {
31 | 			"range": [
32 | 				314,
33 | 				366
34 | 			],
35 | 			"text": "\n            return 'bar' as string;\n        "
36 | 		}
37 | 	},
38 | 	{
39 | 		"ruleId": "no-lonely-if",
40 | 		"severity": 2,
41 | 		"message": "Unexpected if as the only statement in an else block.",
42 | 		"line": 23,
43 | 		"column": 13,
44 | 		"nodeType": "IfStatement",
45 | 		"messageId": "unexpectedLonelyIf",
46 | 		"endLine": 25,
47 | 		"endColumn": 14,
48 | 		"fix": {
49 | 			"range": [
50 | 				464,
51 | 				543
52 | 			],
53 | 			"text": "if (!window) {\n                (doY as any)();\n        "
54 | 		}
55 | 	}
56 | ]


--------------------------------------------------------------------------------
/test/samples/typescript-peer-dependency/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
 4 | 	plugins: ['@typescript-eslint'],
 5 | 	settings: {
 6 | 		'svelte3/typescript': true,
 7 | 	},
 8 | 	rules: {
 9 | 		indent: ['error', 'tab'],
10 | 		semi: 'error',
11 | 	},
12 | };
13 | 


--------------------------------------------------------------------------------
/test/samples/typescript-peer-dependency/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script context="module">
 2 | 	export const z = '';
 3 | 	$: z2 = z;
 4 | </script>
 5 | 
 6 | <script lang="ts">
 7 | 	export let a: any;
 8 | 
 9 | 		export let b: any
10 | 	export let d: number;
11 | 
12 | 	const asd = d.asd();
13 | 
14 | 	interface A {}
15 | 
16 | 	function c(x) {}
17 | 	c(1);
18 | 
19 | 	$: z1 = z;
20 | </script>
21 | 
22 | <o>{b}</o>
23 | <p>{x}</p>
24 | 


--------------------------------------------------------------------------------
/test/samples/typescript-peer-dependency/expected.json:
--------------------------------------------------------------------------------
  1 | [
  2 | 	{
  3 | 		"ruleId": "module-script-reactive-declaration",
  4 | 		"severity": 1,
  5 | 		"line": 3,
  6 | 		"column": 2,
  7 | 		"endLine": 3,
  8 | 		"endColumn": 12
  9 | 	},
 10 | 	{
 11 | 		"ruleId": "no-undef",
 12 | 		"severity": 2,
 13 | 		"line": 3,
 14 | 		"column": 5,
 15 | 		"endLine": 3,
 16 | 		"endColumn": 7
 17 | 	},
 18 | 	{
 19 | 		"ruleId": "unused-export-let",
 20 | 		"severity": 1,
 21 | 		"line": 7,
 22 | 		"column": 13,
 23 | 		"endLine": 7,
 24 | 		"endColumn": 19
 25 | 	},
 26 | 	{
 27 | 		"ruleId": "@typescript-eslint/no-explicit-any",
 28 | 		"severity": 1,
 29 | 		"line": 7,
 30 | 		"column": 16,
 31 | 		"endLine": 7,
 32 | 		"endColumn": 19,
 33 | 		"suggestions": [
 34 | 			{
 35 | 				"messageId": "suggestUnknown",
 36 | 				"fix": {
 37 | 					"range": [
 38 | 						58,
 39 | 						61
 40 | 					],
 41 | 					"text": "unknown"
 42 | 				},
 43 | 				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
 44 | 			},
 45 | 			{
 46 | 				"messageId": "suggestNever",
 47 | 				"fix": {
 48 | 					"range": [
 49 | 						58,
 50 | 						61
 51 | 					],
 52 | 					"text": "never"
 53 | 				},
 54 | 				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
 55 | 			}
 56 | 		]
 57 | 	},
 58 | 	{
 59 | 		"ruleId": "indent",
 60 | 		"severity": 2,
 61 | 		"line": 9,
 62 | 		"column": 2,
 63 | 		"endLine": 9,
 64 | 		"endColumn": 3,
 65 | 		"fix": {
 66 | 			"range": [
 67 | 				112,
 68 | 				113
 69 | 			],
 70 | 			"text": ""
 71 | 		}
 72 | 	},
 73 | 	{
 74 | 		"ruleId": "@typescript-eslint/no-explicit-any",
 75 | 		"severity": 1,
 76 | 		"line": 9,
 77 | 		"column": 17,
 78 | 		"endLine": 9,
 79 | 		"endColumn": 20,
 80 | 		"suggestions": [
 81 | 			{
 82 | 				"messageId": "suggestUnknown",
 83 | 				"fix": {
 84 | 					"range": [
 85 | 						79,
 86 | 						82
 87 | 					],
 88 | 					"text": "unknown"
 89 | 				},
 90 | 				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
 91 | 			},
 92 | 			{
 93 | 				"messageId": "suggestNever",
 94 | 				"fix": {
 95 | 					"range": [
 96 | 						79,
 97 | 						82
 98 | 					],
 99 | 					"text": "never"
100 | 				},
101 | 				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
102 | 			}
103 | 		]
104 | 	},
105 | 	{
106 | 		"ruleId": "semi",
107 | 		"severity": 2,
108 | 		"line": 9,
109 | 		"column": 20,
110 | 		"endLine": 10,
111 | 		"endColumn": 2,
112 | 		"fix": {
113 | 			"range": [
114 | 				130,
115 | 				130
116 | 			],
117 | 			"text": ";"
118 | 		}
119 | 	},
120 | 	{
121 | 		"ruleId": "@typescript-eslint/no-unused-vars",
122 | 		"severity": 1,
123 | 		"line": 12,
124 | 		"column": 8,
125 | 		"endLine": 12,
126 | 		"endColumn": 11
127 | 	},
128 | 	{
129 | 		"ruleId": "@typescript-eslint/no-empty-interface",
130 | 		"severity": 2,
131 | 		"line": 14,
132 | 		"column": 12,
133 | 		"endLine": 14,
134 | 		"endColumn": 13
135 | 	},
136 | 	{
137 | 		"ruleId": "@typescript-eslint/no-unused-vars",
138 | 		"severity": 1,
139 | 		"line": 14,
140 | 		"column": 12,
141 | 		"endLine": 14,
142 | 		"endColumn": 13
143 | 	},
144 | 	{
145 | 		"ruleId": "@typescript-eslint/no-unused-vars",
146 | 		"severity": 1,
147 | 		"line": 16,
148 | 		"column": 13,
149 | 		"endLine": 16,
150 | 		"endColumn": 14
151 | 	},
152 | 	{
153 | 		"ruleId": "@typescript-eslint/no-empty-function",
154 | 		"severity": 2,
155 | 		"line": 16,
156 | 		"column": 16,
157 | 		"endLine": 16,
158 | 		"endColumn": 18
159 | 	},
160 | 	{
161 | 		"ruleId": "missing-declaration",
162 | 		"severity": 1,
163 | 		"line": 23,
164 | 		"column": 5,
165 | 		"endLine": 23,
166 | 		"endColumn": 6
167 | 	},
168 | 	{
169 | 		"ruleId": "no-undef",
170 | 		"severity": 2,
171 | 		"line": 23,
172 | 		"column": 5,
173 | 		"endLine": 23,
174 | 		"endColumn": 6
175 | 	}
176 | ]
177 | 


--------------------------------------------------------------------------------
/test/samples/typescript-special-types/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	extends: ['plugin:@typescript-eslint/recommended'],
 4 | 	plugins: ['@typescript-eslint'],
 5 | 	settings: {
 6 | 		'svelte3/typescript': require('typescript'),
 7 | 	},
 8 | 	rules: {
 9 | 		'no-undef': 'error',
10 | 	},
11 | };
12 | 


--------------------------------------------------------------------------------
/test/samples/typescript-special-types/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script lang='ts'>
 2 | 	type T = $$Generic;
 3 | 	type U = $$Generic<string>;
 4 | 
 5 | 	interface $$Slots {
 6 | 		default: {
 7 | 			foo: string;
 8 | 		}
 9 | 	}
10 | 
11 | 	type $$Props = {
12 | 		items: T;
13 | 		message: U;
14 | 	}
15 | 
16 | 	interface $$Events {
17 | 		click: string;
18 | 	}
19 | 
20 | 	export let items: T[];
21 | 	export let message: U;
22 | </script>
23 | 
24 | {#each items as item}
25 | 	<slot {item} />
26 | {/each}
27 | 
28 | {#if message}
29 | 	{message}
30 | {/if}
31 | 


--------------------------------------------------------------------------------
/test/samples/typescript-special-types/expected.json:
--------------------------------------------------------------------------------
1 | []
2 | 


--------------------------------------------------------------------------------
/test/samples/typescript-template-quotes/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	plugins: [
 4 | 		'@typescript-eslint',
 5 | 	],
 6 | 	rules: {
 7 | 		quotes: 'off',
 8 | 		'@typescript-eslint/quotes': ['error', 'single']
 9 | 	},
10 | };
11 | 


--------------------------------------------------------------------------------
/test/samples/typescript-template-quotes/Input.svelte:
--------------------------------------------------------------------------------
1 | {'foo'}
2 | {"bar"}
3 | <div class={"baz1"}></div>
4 | <div class='{"baz2"}'></div>
5 | 


--------------------------------------------------------------------------------
/test/samples/typescript-template-quotes/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "@typescript-eslint/quotes",
 4 | 		"line": 2,
 5 | 		"column": 2,
 6 | 		"endLine": 2,
 7 | 		"endColumn": 7,
 8 | 		"fix": {
 9 | 			"range": [9, 14],
10 | 			"text": "'bar'"
11 | 		}
12 | 	},
13 | 	{
14 | 		"ruleId": "@typescript-eslint/quotes",
15 | 		"line": 3,
16 | 		"column": 13,
17 | 		"endLine": 3,
18 | 		"endColumn": 19,
19 | 		"fix": {
20 | 			"range": [28, 34],
21 | 			"text": "'baz1'"
22 | 		}
23 | 	}
24 | ]
25 | 


--------------------------------------------------------------------------------
/test/samples/typescript-type-aware-rules/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	extends: [
 4 | 		'eslint:recommended',
 5 | 		'plugin:@typescript-eslint/recommended',
 6 |     	'plugin:@typescript-eslint/recommended-requiring-type-checking',],
 7 | 	plugins: ['@typescript-eslint'],
 8 | 	parserOptions: {
 9 | 	  tsconfigRootDir: __dirname,
10 | 	  project: ['./tsconfig.json'],
11 | 	  extraFileExtensions: ['.svelte'],
12 | 	},
13 | 	ignorePatterns: ['.eslintrc.js'],
14 | 	settings: {
15 | 		'svelte3/typescript': require('typescript'),
16 | 	}
17 | };
18 | 


--------------------------------------------------------------------------------
/test/samples/typescript-type-aware-rules/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts">
 2 | 	import { f, g } from './store';
 3 | 	for (const a in []) {
 4 | 		a;
 5 | 	}
 6 | 
 7 | 	function foo() {
 8 | 		return 1 as any;
 9 | 	}
10 | 
11 | 	foo().hello();
12 | 	$f();
13 | </script>
14 | 
15 | {$g().slice(2)}
16 | 


--------------------------------------------------------------------------------
/test/samples/typescript-type-aware-rules/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "@typescript-eslint/no-for-in-array",
 4 | 		"severity": 2,
 5 | 		"line": 3,
 6 | 		"column": 2,
 7 | 		"endLine": 5,
 8 | 		"endColumn": 3
 9 | 	},
10 | 	{
11 | 		"ruleId": "@typescript-eslint/no-unsafe-return",
12 | 		"severity": 2,
13 | 		"line": 8,
14 | 		"column": 3,
15 | 		"endLine": 8,
16 | 		"endColumn": 19
17 | 	},
18 | 	{
19 | 		"ruleId": "@typescript-eslint/no-explicit-any",
20 | 		"severity": 1,
21 | 		"line": 8,
22 | 		"column": 15,
23 | 		"endLine": 8,
24 | 		"endColumn": 18,
25 | 		"suggestions": [
26 | 			{
27 | 				"messageId": "suggestUnknown",
28 | 				"fix": {
29 | 					"range": [
30 | 						269,
31 | 						272
32 | 					],
33 | 					"text": "unknown"
34 | 				},
35 | 				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
36 | 			},
37 | 			{
38 | 				"messageId": "suggestNever",
39 | 				"fix": {
40 | 					"range": [
41 | 						269,
42 | 						272
43 | 					],
44 | 					"text": "never"
45 | 				},
46 | 				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
47 | 			}
48 | 		]
49 | 	},
50 | 	{
51 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
52 | 		"severity": 2,
53 | 		"line": 11,
54 | 		"column": 2,
55 | 		"endLine": 11,
56 | 		"endColumn": 13
57 | 	},
58 | 	{
59 | 		"ruleId": "@typescript-eslint/no-unsafe-call",
60 | 		"severity": 2,
61 | 		"line": 11,
62 | 		"column": 2,
63 | 		"endLine": 11,
64 | 		"endColumn": 13
65 | 	},
66 | 	{
67 | 		"ruleId": "@typescript-eslint/no-floating-promises",
68 | 		"severity": 2,
69 | 		"line": 12,
70 | 		"column": 2,
71 | 		"endLine": 12,
72 | 		"endColumn": 7
73 | 	}
74 | ]
75 | 


--------------------------------------------------------------------------------
/test/samples/typescript-type-aware-rules/store.ts:
--------------------------------------------------------------------------------
1 | import { readable, writable } from 'svelte/store';
2 | 
3 | export const f = readable(async () => "hello");
4 | export const g = writable(() => "world");
5 | 


--------------------------------------------------------------------------------
/test/samples/typescript-type-aware-rules/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |     "include": ["**/*"]
3 | }
4 | 


--------------------------------------------------------------------------------
/test/samples/typescript-unsafe-member-access/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: "@typescript-eslint/parser",
 3 | 	plugins: [
 4 | 	  "@typescript-eslint",
 5 | 	],
 6 | 	parserOptions: {
 7 | 	  project: ["./tsconfig.json"],
 8 | 	  tsconfigRootDir: __dirname,
 9 | 	  extraFileExtensions: [".svelte"],
10 | 	},
11 | 	settings: {
12 | 	  "svelte3/typescript": require("typescript"),
13 | 	},
14 | 	rules: {
15 | 	  "@typescript-eslint/no-unsafe-member-access": "error",
16 | 	},
17 | };
18 | 


--------------------------------------------------------------------------------
/test/samples/typescript-unsafe-member-access/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script lang="ts" context="module">
 2 | 	const context_safe = [];
 3 | 	const context_unsafe: any = null;
 4 | 
 5 | 	console.log(context_safe.length);
 6 | 	console.log(context_unsafe.length);
 7 | </script>
 8 | 
 9 | <script lang="ts">
10 | 	import { writable } from 'svelte/store';
11 | 	import { external_safe, external_unsafe } from './external-file';
12 | 	const instance_safe = [];
13 | 	const instance_unsafe: any = null;
14 | 	$: reactive_safe = instance_safe;
15 | 	$: reactive_unsafe = instance_unsafe;
16 | 	const writable_safe = writable([]);
17 | 	const writable_unsafe = writable(null as any);
18 | 
19 | 	console.log(context_safe.length);
20 | 	console.log(context_unsafe.length);
21 | 	console.log(external_safe.length);
22 | 	console.log(external_unsafe.length);
23 | 	console.log(instance_safe.length);
24 | 	console.log(instance_unsafe.length);
25 | 	// console.log(reactive_safe.length);  TODO, current limitation
26 | 	console.log(reactive_unsafe.length);
27 | 	// console.log($writable_safe.length);  TODO, current limitation
28 | 	console.log($writable_unsafe.length);
29 | </script>
30 | 
31 | {context_safe.length}
32 | {context_unsafe.length}
33 | {external_safe.length}
34 | {external_unsafe.length}
35 | {instance_safe.length}
36 | {instance_unsafe.length}
37 | <!-- {reactive_safe.length} TODO, current limitation -->
38 | {reactive_unsafe.length}
39 | <!-- {$writable_safe.length} TODO, current limitation -->
40 | {$writable_unsafe.length}
41 | 


--------------------------------------------------------------------------------
/test/samples/typescript-unsafe-member-access/expected.json:
--------------------------------------------------------------------------------
 1 | [
 2 | 	{
 3 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
 4 | 		"severity": 2,
 5 | 		"line": 6,
 6 | 		"column": 14,
 7 | 		"endLine": 6,
 8 | 		"endColumn": 35
 9 | 	},
10 | 	{
11 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
12 | 		"severity": 2,
13 | 		"line": 20,
14 | 		"column": 14,
15 | 		"endLine": 20,
16 | 		"endColumn": 35
17 | 	},
18 | 	{
19 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
20 | 		"severity": 2,
21 | 		"line": 22,
22 | 		"column": 14,
23 | 		"endLine": 22,
24 | 		"endColumn": 36
25 | 	},
26 | 	{
27 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
28 | 		"severity": 2,
29 | 		"line": 24,
30 | 		"column": 14,
31 | 		"endLine": 24,
32 | 		"endColumn": 36
33 | 	},
34 | 	{
35 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
36 | 		"severity": 2,
37 | 		"line": 26,
38 | 		"column": 14,
39 | 		"endLine": 26,
40 | 		"endColumn": 36
41 | 	},
42 | 	{
43 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
44 | 		"severity": 2,
45 | 		"line": 28,
46 | 		"column": 14,
47 | 		"endLine": 28,
48 | 		"endColumn": 37
49 | 	},
50 | 	{
51 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
52 | 		"severity": 2,
53 | 		"line": 32,
54 | 		"column": 2,
55 | 		"endLine": 32,
56 | 		"endColumn": 23
57 | 	},
58 | 	{
59 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
60 | 		"severity": 2,
61 | 		"line": 34,
62 | 		"column": 2,
63 | 		"endLine": 34,
64 | 		"endColumn": 24
65 | 	},
66 | 	{
67 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
68 | 		"severity": 2,
69 | 		"line": 36,
70 | 		"column": 2,
71 | 		"endLine": 36,
72 | 		"endColumn": 24
73 | 	},
74 | 	{
75 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
76 | 		"severity": 2,
77 | 		"line": 38,
78 | 		"column": 2,
79 | 		"endLine": 38,
80 | 		"endColumn": 24
81 | 	},
82 | 	{
83 | 		"ruleId": "@typescript-eslint/no-unsafe-member-access",
84 | 		"severity": 2,
85 | 		"line": 40,
86 | 		"column": 2,
87 | 		"endLine": 40,
88 | 		"endColumn": 25
89 | 	}
90 | ]


--------------------------------------------------------------------------------
/test/samples/typescript-unsafe-member-access/external-file.ts:
--------------------------------------------------------------------------------
1 | export const external_safe = ['hi'];
2 | export const external_unsafe: any = null;
3 | 


--------------------------------------------------------------------------------
/test/samples/typescript-unsafe-member-access/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |     "include": ["**/*"]
3 | }
4 | 


--------------------------------------------------------------------------------
/test/samples/typescript/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 | 	parser: '@typescript-eslint/parser',
 3 | 	extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
 4 | 	plugins: ['@typescript-eslint'],
 5 | 	settings: {
 6 | 		'svelte3/typescript': require('typescript'),
 7 | 	},
 8 | 	rules: {
 9 | 		indent: ['error', 'tab'],
10 | 		semi: 'error',
11 | 	},
12 | };
13 | 


--------------------------------------------------------------------------------
/test/samples/typescript/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script context="module">
 2 | 	export const z = '';
 3 | 	$: z2 = z;
 4 | </script>
 5 | 
 6 | <script lang="ts">
 7 | 	export let a: any;
 8 | 
 9 | 		export let b: any
10 | 	export let d: number;
11 | 
12 | 	const asd = d.asd();
13 | 
14 | 	interface A {}
15 | 
16 | 	function c(x) {}
17 | 	c(1);
18 | 
19 | 	$: z1 = z;
20 | </script>
21 | 
22 | <o>{b}</o>
23 | <p>{x}</p>
24 | 


--------------------------------------------------------------------------------
/test/samples/typescript/expected.json:
--------------------------------------------------------------------------------
  1 | [
  2 | 	{
  3 | 		"ruleId": "module-script-reactive-declaration",
  4 | 		"severity": 1,
  5 | 		"line": 3,
  6 | 		"column": 2,
  7 | 		"endLine": 3,
  8 | 		"endColumn": 12
  9 | 	},
 10 | 	{
 11 | 		"ruleId": "no-undef",
 12 | 		"severity": 2,
 13 | 		"line": 3,
 14 | 		"column": 5,
 15 | 		"endLine": 3,
 16 | 		"endColumn": 7
 17 | 	},
 18 | 	{
 19 | 		"ruleId": "unused-export-let",
 20 | 		"severity": 1,
 21 | 		"line": 7,
 22 | 		"column": 13,
 23 | 		"endLine": 7,
 24 | 		"endColumn": 19
 25 | 	},
 26 | 	{
 27 | 		"ruleId": "@typescript-eslint/no-explicit-any",
 28 | 		"severity": 1,
 29 | 		"line": 7,
 30 | 		"column": 16,
 31 | 		"endLine": 7,
 32 | 		"endColumn": 19,
 33 | 		"suggestions": [
 34 | 			{
 35 | 				"messageId": "suggestUnknown",
 36 | 				"fix": {
 37 | 					"range": [
 38 | 						58,
 39 | 						61
 40 | 					],
 41 | 					"text": "unknown"
 42 | 				},
 43 | 				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
 44 | 			},
 45 | 			{
 46 | 				"messageId": "suggestNever",
 47 | 				"fix": {
 48 | 					"range": [
 49 | 						58,
 50 | 						61
 51 | 					],
 52 | 					"text": "never"
 53 | 				},
 54 | 				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
 55 | 			}
 56 | 		]
 57 | 	},
 58 | 	{
 59 | 		"ruleId": "indent",
 60 | 		"severity": 2,
 61 | 		"line": 9,
 62 | 		"column": 2,
 63 | 		"endLine": 9,
 64 | 		"endColumn": 3,
 65 | 		"fix": {
 66 | 			"range": [
 67 | 				112,
 68 | 				113
 69 | 			],
 70 | 			"text": ""
 71 | 		}
 72 | 	},
 73 | 	{
 74 | 		"ruleId": "@typescript-eslint/no-explicit-any",
 75 | 		"severity": 1,
 76 | 		"line": 9,
 77 | 		"column": 17,
 78 | 		"endLine": 9,
 79 | 		"endColumn": 20,
 80 | 		"suggestions": [
 81 | 			{
 82 | 				"messageId": "suggestUnknown",
 83 | 				"fix": {
 84 | 					"range": [
 85 | 						79,
 86 | 						82
 87 | 					],
 88 | 					"text": "unknown"
 89 | 				},
 90 | 				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
 91 | 			},
 92 | 			{
 93 | 				"messageId": "suggestNever",
 94 | 				"fix": {
 95 | 					"range": [
 96 | 						79,
 97 | 						82
 98 | 					],
 99 | 					"text": "never"
100 | 				},
101 | 				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
102 | 			}
103 | 		]
104 | 	},
105 | 	{
106 | 		"ruleId": "semi",
107 | 		"severity": 2,
108 | 		"line": 9,
109 | 		"column": 20,
110 | 		"endLine": 10,
111 | 		"endColumn": 2,
112 | 		"fix": {
113 | 			"range": [
114 | 				130,
115 | 				130
116 | 			],
117 | 			"text": ";"
118 | 		}
119 | 	},
120 | 	{
121 | 		"ruleId": "@typescript-eslint/no-unused-vars",
122 | 		"severity": 1,
123 | 		"line": 12,
124 | 		"column": 8,
125 | 		"endLine": 12,
126 | 		"endColumn": 11
127 | 	},
128 | 	{
129 | 		"ruleId": "@typescript-eslint/no-empty-interface",
130 | 		"severity": 2,
131 | 		"line": 14,
132 | 		"column": 12,
133 | 		"endLine": 14,
134 | 		"endColumn": 13
135 | 	},
136 | 	{
137 | 		"ruleId": "@typescript-eslint/no-unused-vars",
138 | 		"severity": 1,
139 | 		"line": 14,
140 | 		"column": 12,
141 | 		"endLine": 14,
142 | 		"endColumn": 13
143 | 	},
144 | 	{
145 | 		"ruleId": "@typescript-eslint/no-unused-vars",
146 | 		"severity": 1,
147 | 		"line": 16,
148 | 		"column": 13,
149 | 		"endLine": 16,
150 | 		"endColumn": 14
151 | 	},
152 | 	{
153 | 		"ruleId": "@typescript-eslint/no-empty-function",
154 | 		"severity": 2,
155 | 		"line": 16,
156 | 		"column": 16,
157 | 		"endLine": 16,
158 | 		"endColumn": 18
159 | 	},
160 | 	{
161 | 		"ruleId": "missing-declaration",
162 | 		"severity": 1,
163 | 		"line": 23,
164 | 		"column": 5,
165 | 		"endLine": 23,
166 | 		"endColumn": 6
167 | 	},
168 | 	{
169 | 		"ruleId": "no-undef",
170 | 		"severity": 2,
171 | 		"line": 23,
172 | 		"column": 5,
173 | 		"endLine": 23,
174 | 		"endColumn": 6
175 | 	}
176 | ]
177 | 


--------------------------------------------------------------------------------
/test/samples/unused-write-only-store/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | 	rules: {
3 | 		"no-unused-vars": "error",
4 | 	},
5 | };
6 | 


--------------------------------------------------------------------------------
/test/samples/unused-write-only-store/Input.svelte:
--------------------------------------------------------------------------------
 1 | <script>
 2 | 	import { imported, createStore } from './store.js';
 3 | 
 4 | 	const writeOnly = createStore();
 5 | 	$writeOnly = 99;
 6 | 
 7 | 	const readOnly = createStore();
 8 | 	$readOnly;
 9 | 
10 | 	$imported = 'some value';
11 | </script>
12 | <div on:click={() => $imported = 'clicked' } on:keyup={() => $imported = 'clicked' } />
13 | 


--------------------------------------------------------------------------------
/test/samples/unused-write-only-store/expected.json:
--------------------------------------------------------------------------------
1 | []
2 | 


--------------------------------------------------------------------------------