From 192bf8253bcabd5e26fc75371c0224ad9e261a5f Mon Sep 17 00:00:00 2001
From: Simon H <5968653+dummdidumm@users.noreply.github.com>
Date: Tue, 16 Feb 2021 00:22:03 +0100
Subject: [PATCH] add TypeScript support (#83)

Co-authored-by: Conduitry <git@chor.date>
---
 CHANGELOG.md                                  |   4 +
 README.md                                     |  54 ++++-
 package.json                                  |   7 +-
 rollup.config.js                              |   3 +
 src/mapping.js                                | 206 ++++++++++++++++++
 src/preprocess.js                             | 108 +++++++--
 src/processor_options.js                      |   1 +
 .../typescript-block-filenames/.eslintrc.js   |  27 +++
 .../typescript-block-filenames/Input.svelte   |  10 +
 .../typescript-block-filenames/expected.json  |  12 +
 .../typescript-type-aware-rules/.eslintrc.js  |  17 ++
 .../typescript-type-aware-rules/Input.svelte  |  11 +
 .../typescript-type-aware-rules/expected.json |  66 ++++++
 .../typescript-type-aware-rules/tsconfig.json |   3 +
 test/samples/typescript/.eslintrc.js          |  12 +
 test/samples/typescript/Input.svelte          |  23 ++
 test/samples/typescript/expected.json         | 184 ++++++++++++++++
 17 files changed, 732 insertions(+), 16 deletions(-)
 create mode 100644 src/mapping.js
 create mode 100644 test/samples/typescript-block-filenames/.eslintrc.js
 create mode 100644 test/samples/typescript-block-filenames/Input.svelte
 create mode 100644 test/samples/typescript-block-filenames/expected.json
 create mode 100644 test/samples/typescript-type-aware-rules/.eslintrc.js
 create mode 100644 test/samples/typescript-type-aware-rules/Input.svelte
 create mode 100644 test/samples/typescript-type-aware-rules/expected.json
 create mode 100644 test/samples/typescript-type-aware-rules/tsconfig.json
 create mode 100644 test/samples/typescript/.eslintrc.js
 create mode 100644 test/samples/typescript/Input.svelte
 create mode 100644 test/samples/typescript/expected.json

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 49f0af6..787c2e7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 3.1.0 (Unreleased)
+
+- Add TypeScript support
+
 # 3.0.0
 
 - Breaking change: Node 10+ is now required
diff --git a/README.md b/README.md
index d609238..ae77479 100644
--- a/README.md
+++ b/README.md
@@ -56,6 +56,52 @@ module.exports = {
 
 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.
 
+### Installation with TypeScript
+
+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:
+
+```javascript
+module.exports = {
+  parser: '@typescript-eslint/parser', // add the TypeScript parser
+  plugins: [
+    'svelte3',
+    '@typescript-eslint' // add the TypeScript plugin
+  ],
+  overrides: [ // this stays the same
+    {
+      files: ['*.svelte'],
+      processor: 'svelte3/svelte3'
+    }
+  ],
+  rules: {
+    // ...
+  },
+  settings: {
+    'svelte3/typescript': require('typescript'), // pass the TypeScript package to the Svelte plugin
+    // ...
+  }
+};
+```
+
+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).
+
+```javascript
+module.exports = {
+  // ...
+  parserOptions: { // add these parser options
+    tsconfigRootDir: __dirname,
+    project: ['./tsconfig.json'],
+    extraFileExtensions: ['.svelte'],
+  },
+  extends: [ // then, enable whichever type-aware rules you want to use
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:@typescript-eslint/recommended-requiring-type-checking'
+  ],
+  // ...
+};
+```
+
 ## Interactions with other plugins
 
 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).
@@ -90,12 +136,18 @@ The default is to not ignore any styles.
 
 ### `svelte3/named-blocks`
 
-When an [ESLint processor](https://eslint.org/docs/user-guide/configuring#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`.
+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`.
 
 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.
 
 The default is to not use named code blocks.
 
+### `svelte3/typescript`
+
+If you use TypeScript inside your Svelte components and want ESLint support, you need to set this option. It expects an instance of the TypeScript package. This probably means doing `'svelte3/typescript': require('typescript')`.
+
+The default is to not enable TypeScript support.
+
 ### `svelte3/compiler`
 
 In some esoteric setups, this plugin might not be able to find the correct instance of the Svelte compiler to use.
diff --git a/package.json b/package.json
index e6ecfb4..f4b9bec 100644
--- a/package.json
+++ b/package.json
@@ -34,8 +34,13 @@
 		"test": "npm run build && node test"
 	},
 	"devDependencies": {
+		"@rollup/plugin-node-resolve": "^11.2.0",
+		"@typescript-eslint/eslint-plugin": "^4.14.2",
+		"@typescript-eslint/parser": "^4.14.2",
 		"eslint": ">=6.0.0",
 		"rollup": "^2",
-		"svelte": "^3.2.0"
+		"sourcemap-codec": "1.4.8",
+		"svelte": "^3.2.0",
+		"typescript": "^4.0.0"
 	}
 }
diff --git a/rollup.config.js b/rollup.config.js
index 78de19d..ee052fd 100644
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -1,4 +1,7 @@
+import node_resolve from '@rollup/plugin-node-resolve';
+
 export default {
 	input: 'src/index.js',
 	output: { file: 'index.js', format: 'cjs' },
+	plugins: [ node_resolve() ],
 };
diff --git a/src/mapping.js b/src/mapping.js
new file mode 100644
index 0000000..f8bf778
--- /dev/null
+++ b/src/mapping.js
@@ -0,0 +1,206 @@
+import { decode } from 'sourcemap-codec';
+
+class GeneratedFragmentMapper {
+	constructor(generated_code, diff) {
+		this.generated_code = generated_code;
+		this.diff = diff;
+	}
+
+	get_position_relative_to_fragment(position_relative_to_file) {
+		const fragment_offset = this.offset_in_fragment(offset_at(position_relative_to_file, this.generated_code));
+		return position_at(fragment_offset, this.diff.generated_content);
+	}
+
+	offset_in_fragment(offset) {
+		return offset - this.diff.generated_start
+	}
+}
+
+class OriginalFragmentMapper {
+	constructor(original_code, diff) {
+		this.original_code = original_code;
+		this.diff = diff;
+	}
+
+	get_position_relative_to_file(position_relative_to_fragment) {
+		const parent_offset = this.offset_in_parent(offset_at(position_relative_to_fragment, this.diff.original_content));
+		return position_at(parent_offset, this.original_code);
+	}
+
+	offset_in_parent(offset) {
+		return this.diff.original_start + offset;
+	}
+}
+
+class SourceMapper {
+	constructor(raw_source_map) {
+		this.raw_source_map = raw_source_map;
+	}
+
+	get_original_position(generated_position) {
+		if (generated_position.line < 0) {
+			return { line: -1, column: -1 };
+		}
+
+		// Lazy-load
+		if (!this.decoded) {
+			this.decoded = decode(JSON.parse(this.raw_source_map).mappings);
+		}
+
+		let line = generated_position.line;
+		let column = generated_position.column;
+
+		let line_match = this.decoded[line];
+		while (line >= 0 && (!line_match || !line_match.length)) {
+			line -= 1;
+			line_match = this.decoded[line];
+			if (line_match && line_match.length) {
+				return {
+					line: line_match[line_match.length - 1][2],
+					column: line_match[line_match.length - 1][3]
+				};
+			}
+		}
+
+		if (line < 0) {
+			return { line: -1, column: -1 };
+		}
+
+		const column_match = line_match.find((col, idx) =>
+			idx + 1 === line_match.length ||
+			(col[0] <= column && line_match[idx + 1][0] > column)
+		);
+
+		return {
+			line: column_match[2],
+			column: column_match[3],
+		};
+	}
+}
+
+export class DocumentMapper {
+	constructor(original_code, generated_code, diffs) {
+		this.original_code = original_code;
+		this.generated_code = generated_code;
+		this.diffs = diffs;
+		this.mappers = diffs.map(diff => {
+			return {
+				start: diff.generated_start,
+				end: diff.generated_end,
+				diff: diff.diff,
+				generated_fragment_mapper: new GeneratedFragmentMapper(generated_code, diff),
+				source_mapper: new SourceMapper(diff.map),
+				original_fragment_mapper: new OriginalFragmentMapper(original_code, diff)
+			}
+		});
+	}
+
+	get_original_position(generated_position) {
+		generated_position = { line: generated_position.line - 1, column: generated_position.column };
+		const offset = offset_at(generated_position, this.generated_code);
+		let original_offset = offset;
+		for (const mapper of this.mappers) {
+			if (offset >= mapper.start && offset <= mapper.end) {
+				return this.map(mapper, generated_position);
+			}
+			if (offset > mapper.end) {
+				original_offset -= mapper.diff;
+			}
+		}
+		const original_position = position_at(original_offset, this.original_code);
+		return this.to_ESLint_position(original_position);
+	}
+
+	map(mapper, generated_position) {
+		// Map the position to be relative to the transpiled fragment
+		const position_in_transpiled_fragment = mapper.generated_fragment_mapper.get_position_relative_to_fragment(
+			generated_position
+		);
+		// Map the position, using the sourcemap, to the original position in the source fragment
+		const position_in_original_fragment = mapper.source_mapper.get_original_position(
+			position_in_transpiled_fragment
+		);
+		// Map the position to be in the original fragment's parent
+		const original_position = mapper.original_fragment_mapper.get_position_relative_to_file(position_in_original_fragment);
+		return this.to_ESLint_position(original_position);
+	}
+
+	to_ESLint_position(position) {
+		// ESLint line/column is 1-based
+		return { line: position.line + 1, column: position.column + 1 };
+	}
+
+}
+
+/**
+ * Get the offset of the line and character position
+ * @param position Line and character position
+ * @param text The text for which the offset should be retrieved
+ */
+function offset_at(position, text) {
+	const line_offsets = get_line_offsets(text);
+
+	if (position.line >= line_offsets.length) {
+		return text.length;
+	} else if (position.line < 0) {
+		return 0;
+	}
+
+	const line_offset = line_offsets[position.line];
+	const next_line_offset =
+		position.line + 1 < line_offsets.length ? line_offsets[position.line + 1] : text.length;
+
+	return clamp(next_line_offset, line_offset, line_offset + position.column);
+}
+
+function position_at(offset, text) {
+	offset = clamp(offset, 0, text.length);
+
+	const line_offsets = get_line_offsets(text);
+	let low = 0;
+	let high = line_offsets.length;
+	if (high === 0) {
+		return { line: 0, column: offset };
+	}
+
+	while (low < high) {
+		const mid = Math.floor((low + high) / 2);
+		if (line_offsets[mid] > offset) {
+			high = mid;
+		} else {
+			low = mid + 1;
+		}
+	}
+
+	// low is the least x for which the line offset is larger than the current offset
+	// or array.length if no line offset is larger than the current offset
+	const line = low - 1;
+	return { line, column: offset - line_offsets[line] };
+}
+
+function get_line_offsets(text) {
+	const line_offsets = [];
+	let is_line_start = true;
+
+	for (let i = 0; i < text.length; i++) {
+		if (is_line_start) {
+			line_offsets.push(i);
+			is_line_start = false;
+		}
+		const ch = text.charAt(i);
+		is_line_start = ch === '\r' || ch === '\n';
+		if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {
+			i++;
+		}
+	}
+
+	if (is_line_start && text.length > 0) {
+		line_offsets.push(text.length);
+	}
+
+	return line_offsets;
+}
+
+function clamp(num, min, max) {
+	return Math.max(min, Math.min(max, num));
+}
diff --git a/src/preprocess.js b/src/preprocess.js
index 77aa11c..bd2c933 100644
--- a/src/preprocess.js
+++ b/src/preprocess.js
@@ -1,6 +1,7 @@
 import { new_block, get_translation } from './block.js';
 import { processor_options } from './processor_options.js';
 import { state } from './state.js';
+import { DocumentMapper } from './mapping.js';
 
 let default_compiler;
 
@@ -40,10 +41,11 @@ export const preprocess = text => {
 			return processor_options.ignore_styles(attrs) ? match.replace(/\S/g, ' ') : match;
 		});
 	}
+
 	// get information about the component
 	let result;
 	try {
-		result = compiler.compile(text, { generate: false, ...processor_options.compiler_options });
+		result = compile_code(text, compiler, processor_options);
 	} catch ({ name, message, start, end }) {
 		// convert the error to a linting message, store it, and return
 		state.messages = [
@@ -59,27 +61,41 @@ export const preprocess = text => {
 		];
 		return [];
 	}
-	const { ast, warnings, vars } = result;
+	const { ast, warnings, vars, mapper } = result;
+
 	const references_and_reassignments = `{${vars.filter(v => v.referenced).map(v => v.name)};${vars.filter(v => v.reassigned || v.export_name).map(v => v.name + '=0')}}`;
 	state.var_names = new Set(vars.map(v => v.name));
 
 	// convert warnings to linting messages
-	state.messages = (processor_options.ignore_warnings ? warnings.filter(warning => !processor_options.ignore_warnings(warning)) : warnings).map(({ code, message, start, end }) => ({
-		ruleId: code,
-		severity: 1,
-		message,
-		line: start && start.line,
-		column: start && start.column + 1,
-		endLine: end && end.line,
-		endColumn: end && end.column + 1,
-	}));
+	const filtered_warnings = processor_options.ignore_warnings ? warnings.filter(warning => !processor_options.ignore_warnings(warning)) : warnings;
+	state.messages = filtered_warnings.map(({ code, message, start, end }) => {
+		const start_pos = processor_options.typescript && start ?
+			mapper.get_original_position(start) :
+			start && { line: start.line, column: start.column + 1 };
+		const end_pos = processor_options.typescript && end ?
+			mapper.get_original_position(end) :
+			end && { line: end.line, column: end.column + 1 };
+		return {
+			ruleId: code,
+			severity: 1,
+			message,
+			line: start_pos && start_pos.line,
+			column: start_pos && start_pos.column,
+			endLine: end_pos && end_pos.line,
+			endColumn: end_pos && end_pos.column,
+		};
+	});
 
 	// build strings that we can send along to ESLint to get the remaining messages
 
+	// Things to think about:
+	// - 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"?
+	const with_file_ending = (filename) => `${filename}${processor_options.typescript ? '.ts' : '.js'}`;
+
 	if (ast.module) {
 		// block for <script context='module'>
 		const block = new_block();
-		state.blocks.set('module.js', block);
+		state.blocks.set(with_file_ending('module'), block);
 
 		get_translation(text, block, ast.module.content);
 
@@ -93,7 +109,7 @@ export const preprocess = text => {
 	if (ast.instance) {
 		// block for <script context='instance'>
 		const block = new_block();
-		state.blocks.set('instance.js', block);
+		state.blocks.set(with_file_ending('instance'), block);
 
 		block.transformed_code = vars.filter(v => v.injected || v.module).map(v => `let ${v.name};`).join('');
 
@@ -105,7 +121,7 @@ export const preprocess = text => {
 	if (ast.html) {
 		// block for template
 		const block = new_block();
-		state.blocks.set('template.js', block);
+		state.blocks.set(with_file_ending('template'), block);
 
 		block.transformed_code = vars.map(v => `let ${v.name};`).join('');
 
@@ -157,3 +173,67 @@ export const preprocess = text => {
 	// return processed string
 	return [...state.blocks].map(([filename, { transformed_code: text }]) => processor_options.named_blocks ? { text, filename } : text);
 };
+
+// How it works for JS:
+// 1. compile code
+// 2. return ast/vars/warnings
+// How it works for TS:
+// 1. transpile script contents from TS to JS
+// 2. compile result to get Svelte compiler warnings
+// 3. provide a mapper to map those warnings back to its original positions
+// 4. blank script contents
+// 5. compile again to get the AST with original positions in the markdown part
+// 6. use AST and warnings of step 5, vars of step 2
+function compile_code(text, compiler, processor_options) {
+	let ast;
+	let warnings;
+	let vars;
+
+	let mapper;
+	let ts_result;
+	if (processor_options.typescript) {
+		const diffs = [];
+		let accumulated_diff = 0;
+		const transpiled = text.replace(/<script(\s[^]*?)?>([^]*?)<\/script>/gi, (match, attributes = '', content) => {
+			const output = processor_options.typescript.transpileModule(
+				content,
+				{ reportDiagnostics: false, compilerOptions: { target: processor_options.typescript.ScriptTarget.ESNext, sourceMap: true } }
+			);
+			const original_start = text.indexOf(content);
+			const generated_start = accumulated_diff + original_start;
+			accumulated_diff += output.outputText.length - content.length;
+			diffs.push({
+				original_start: original_start,
+				generated_start: generated_start,
+				generated_end: generated_start + output.outputText.length,
+				diff: output.outputText.length - content.length,
+				original_content: content,
+				generated_content: output.outputText,
+				map: output.sourceMapText
+			});
+			return `<script${attributes}>${output.outputText}</script>`;
+		});
+		mapper = new DocumentMapper(text, transpiled, diffs);
+		ts_result = compiler.compile(transpiled, { generate: false, ...processor_options.compiler_options });
+
+		text = text.replace(/<script(\s[^]*?)?>([^]*?)<\/script>/gi, (match, attributes = '', content) => {
+			return `<script${attributes}>${content
+				// blank out the content
+				.replace(/[^\n]/g, ' ')
+				// excess blank space can make the svelte parser very slow (sec->min). break it up with comments (works in style/script)
+				.replace(/[^\n][^\n][^\n][^\n]\n/g, '/**/\n')
+			}</script>`;
+		});
+	}
+
+	const result = compiler.compile(text, { generate: false, ...processor_options.compiler_options });
+
+	if (!processor_options.typescript) {
+		({ ast, warnings, vars } = result);
+	} else {
+		ast = result.ast;
+		({ warnings, vars } = ts_result);
+	}
+
+	return { ast, warnings, vars, mapper };
+}
diff --git a/src/processor_options.js b/src/processor_options.js
index 83d59a1..c9f6c3d 100644
--- a/src/processor_options.js
+++ b/src/processor_options.js
@@ -17,6 +17,7 @@ Linter.prototype.verify = function(code, config, options) {
 	processor_options.ignore_styles = settings['svelte3/ignore-styles'];
 	processor_options.compiler_options = settings['svelte3/compiler-options'];
 	processor_options.named_blocks = settings['svelte3/named-blocks'];
+	processor_options.typescript = settings['svelte3/typescript'];
 	// call original Linter#verify
 	return verify.call(this, code, config, options);
 };
diff --git a/test/samples/typescript-block-filenames/.eslintrc.js b/test/samples/typescript-block-filenames/.eslintrc.js
new file mode 100644
index 0000000..b283cbe
--- /dev/null
+++ b/test/samples/typescript-block-filenames/.eslintrc.js
@@ -0,0 +1,27 @@
+module.exports = {
+	parser: '@typescript-eslint/parser',
+	extends: ['plugin:@typescript-eslint/recommended'],
+	plugins: ['@typescript-eslint'],
+	overrides: [
+		{
+			files: ['**/*.svelte/*_template.ts'],
+			rules: {
+				curly: 'off',
+			},
+		},
+		{
+			files: ['**/*.svelte/*_module.ts'],
+			rules: {
+				'no-undef': 'off',
+			},
+		},
+	],
+	settings: {
+		'svelte3/typescript': require('typescript'),
+		'svelte3/named-blocks': true,
+	},
+	rules: {
+		curly: 'error',
+		'no-undef': 'error',
+	},
+};
diff --git a/test/samples/typescript-block-filenames/Input.svelte b/test/samples/typescript-block-filenames/Input.svelte
new file mode 100644
index 0000000..f6b0362
--- /dev/null
+++ b/test/samples/typescript-block-filenames/Input.svelte
@@ -0,0 +1,10 @@
+<script context='module'>
+	if (blah) blah;
+</script>
+
+<script>
+	let foo, bar;
+	if (foo) bar;
+</script>
+
+<div on:click={() => { if (foo) bar; }}>blah</div>
diff --git a/test/samples/typescript-block-filenames/expected.json b/test/samples/typescript-block-filenames/expected.json
new file mode 100644
index 0000000..f40aa65
--- /dev/null
+++ b/test/samples/typescript-block-filenames/expected.json
@@ -0,0 +1,12 @@
+[
+	{
+		"ruleId": "curly",
+		"line": 2,
+		"column": 2
+	},
+	{
+		"ruleId": "curly",
+		"line": 7,
+		"column": 2
+	}
+]
diff --git a/test/samples/typescript-type-aware-rules/.eslintrc.js b/test/samples/typescript-type-aware-rules/.eslintrc.js
new file mode 100644
index 0000000..d66ccce
--- /dev/null
+++ b/test/samples/typescript-type-aware-rules/.eslintrc.js
@@ -0,0 +1,17 @@
+module.exports = {
+	parser: '@typescript-eslint/parser',
+	extends: [
+		'eslint:recommended',
+		'plugin:@typescript-eslint/recommended',
+    	'plugin:@typescript-eslint/recommended-requiring-type-checking',],
+	plugins: ['@typescript-eslint'],
+	parserOptions: {
+	  tsconfigRootDir: __dirname,
+	  project: ['./tsconfig.json'],
+	  extraFileExtensions: ['.svelte'],
+	},
+	ignorePatterns: ['.eslintrc.js'],
+	settings: {
+		'svelte3/typescript': require('typescript'),
+	}
+};
diff --git a/test/samples/typescript-type-aware-rules/Input.svelte b/test/samples/typescript-type-aware-rules/Input.svelte
new file mode 100644
index 0000000..6021a0f
--- /dev/null
+++ b/test/samples/typescript-type-aware-rules/Input.svelte
@@ -0,0 +1,11 @@
+<script lang="ts">
+	for (const a in []) {
+		a;
+	}
+
+	function foo() {
+		return 1 as any;
+	}
+
+	foo().hello();
+</script>
diff --git a/test/samples/typescript-type-aware-rules/expected.json b/test/samples/typescript-type-aware-rules/expected.json
new file mode 100644
index 0000000..0ce8f94
--- /dev/null
+++ b/test/samples/typescript-type-aware-rules/expected.json
@@ -0,0 +1,66 @@
+[
+	{
+		"ruleId": "@typescript-eslint/no-for-in-array",
+		"severity": 2,
+		"line": 2,
+		"column": 2,
+		"endLine": 4,
+		"endColumn": 3
+	},
+	{
+		"ruleId": "@typescript-eslint/no-unsafe-return",
+		"severity": 2,
+		"line": 7,
+		"column": 3,
+		"endLine": 7,
+		"endColumn": 19
+	},
+	{
+		"ruleId": "@typescript-eslint/no-explicit-any",
+		"severity": 1,
+		"line": 7,
+		"column": 15,
+		"endLine": 7,
+		"endColumn": 18,
+		"suggestions": [
+			{
+				"messageId": "suggestUnknown",
+				"fix": {
+					"range": [
+						61,
+						64
+					],
+					"text": "unknown"
+				},
+				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
+			},
+			{
+				"messageId": "suggestNever",
+				"fix": {
+					"range": [
+						61,
+						64
+					],
+					"text": "never"
+				},
+				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
+			}
+		]
+	},
+	{
+		"ruleId": "@typescript-eslint/no-unsafe-member-access",
+		"severity": 2,
+		"line": 10,
+		"column": 2,
+		"endLine": 10,
+		"endColumn": 13
+	},
+	{
+		"ruleId": "@typescript-eslint/no-unsafe-call",
+		"severity": 2,
+		"line": 10,
+		"column": 2,
+		"endLine": 10,
+		"endColumn": 13
+	}
+]
\ No newline at end of file
diff --git a/test/samples/typescript-type-aware-rules/tsconfig.json b/test/samples/typescript-type-aware-rules/tsconfig.json
new file mode 100644
index 0000000..9aadfdc
--- /dev/null
+++ b/test/samples/typescript-type-aware-rules/tsconfig.json
@@ -0,0 +1,3 @@
+{
+    "include": ["**/*"]
+}
diff --git a/test/samples/typescript/.eslintrc.js b/test/samples/typescript/.eslintrc.js
new file mode 100644
index 0000000..8215883
--- /dev/null
+++ b/test/samples/typescript/.eslintrc.js
@@ -0,0 +1,12 @@
+module.exports = {
+	parser: '@typescript-eslint/parser',
+	extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+	plugins: ['@typescript-eslint'],
+	settings: {
+		'svelte3/typescript': require('typescript'),
+	},
+	rules: {
+		indent: ['error', 'tab'],
+		semi: 'error',
+	},
+};
diff --git a/test/samples/typescript/Input.svelte b/test/samples/typescript/Input.svelte
new file mode 100644
index 0000000..4ed1764
--- /dev/null
+++ b/test/samples/typescript/Input.svelte
@@ -0,0 +1,23 @@
+<script context="module">
+	export const z = '';
+	$: z2 = z;
+</script>
+
+<script lang="ts">
+	export let a: any;
+
+		export let b: any
+	export let d: number;
+
+	const asd = d.asd();
+
+	interface A {}
+
+	function c(x) {}
+	c(1);
+
+	$: z1 = z;
+</script>
+
+<o>{b}</o>
+<p>{x}</p>
diff --git a/test/samples/typescript/expected.json b/test/samples/typescript/expected.json
new file mode 100644
index 0000000..8c05a26
--- /dev/null
+++ b/test/samples/typescript/expected.json
@@ -0,0 +1,184 @@
+[
+	{
+		"ruleId": "module-script-reactive-declaration",
+		"severity": 1,
+		"line": 3,
+		"column": 2,
+		"endLine": 3,
+		"endColumn": 12
+	},
+	{
+		"ruleId": "no-undef",
+		"severity": 2,
+		"line": 3,
+		"column": 5,
+		"endLine": 3,
+		"endColumn": 7
+	},
+	{
+		"ruleId": "unused-export-let",
+		"severity": 1,
+		"line": 7,
+		"column": 13,
+		"endLine": 7,
+		"endColumn": 19
+	},
+	{
+		"ruleId": "@typescript-eslint/no-explicit-any",
+		"severity": 1,
+		"line": 7,
+		"column": 16,
+		"endLine": 7,
+		"endColumn": 19,
+		"suggestions": [
+			{
+				"messageId": "suggestUnknown",
+				"fix": {
+					"range": [
+						29,
+						32
+					],
+					"text": "unknown"
+				},
+				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
+			},
+			{
+				"messageId": "suggestNever",
+				"fix": {
+					"range": [
+						29,
+						32
+					],
+					"text": "never"
+				},
+				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
+			}
+		]
+	},
+	{
+		"ruleId": "indent",
+		"severity": 2,
+		"line": 9,
+		"column": 2,
+		"endLine": 9,
+		"endColumn": 3,
+		"fix": {
+			"range": [
+				112,
+				113
+			],
+			"text": ""
+		}
+	},
+	{
+		"ruleId": "@typescript-eslint/no-explicit-any",
+		"severity": 1,
+		"line": 9,
+		"column": 17,
+		"endLine": 9,
+		"endColumn": 20,
+		"suggestions": [
+			{
+				"messageId": "suggestUnknown",
+				"fix": {
+					"range": [
+						50,
+						53
+					],
+					"text": "unknown"
+				},
+				"desc": "Use `unknown` instead, this will force you to explicitly, and safely assert the type is correct."
+			},
+			{
+				"messageId": "suggestNever",
+				"fix": {
+					"range": [
+						50,
+						53
+					],
+					"text": "never"
+				},
+				"desc": "Use `never` instead, this is useful when instantiating generic type parameters that you don't need to know the type of."
+			}
+		]
+	},
+	{
+		"ruleId": "semi",
+		"severity": 2,
+		"line": 9,
+		"column": 20,
+		"endLine": 10,
+		"endColumn": 2,
+		"fix": {
+			"range": [
+				130,
+				130
+			],
+			"text": ";"
+		}
+	},
+	{
+		"ruleId": "@typescript-eslint/no-unused-vars",
+		"severity": 1,
+		"line": 12,
+		"column": 8,
+		"endLine": 12,
+		"endColumn": 11
+	},
+	{
+		"ruleId": "@typescript-eslint/no-empty-interface",
+		"severity": 2,
+		"line": 14,
+		"column": 12,
+		"endLine": 14,
+		"endColumn": 13
+	},
+	{
+		"ruleId": "@typescript-eslint/no-unused-vars",
+		"severity": 1,
+		"line": 14,
+		"column": 12,
+		"endLine": 14,
+		"endColumn": 13
+	},
+	{
+		"ruleId": "@typescript-eslint/no-unused-vars",
+		"severity": 1,
+		"line": 16,
+		"column": 13,
+		"endLine": 16,
+		"endColumn": 14
+	},
+	{
+		"ruleId": "@typescript-eslint/no-empty-function",
+		"severity": 2,
+		"line": 16,
+		"column": 16,
+		"endLine": 16,
+		"endColumn": 18
+	},
+	{
+		"ruleId": "module-script-reactive-declaration",
+		"severity": 1,
+		"line": 19,
+		"column": 10,
+		"endLine": 19,
+		"endColumn": 11
+	},
+	{
+		"ruleId": "missing-declaration",
+		"severity": 1,
+		"line": 23,
+		"column": 5,
+		"endLine": 23,
+		"endColumn": 6
+	},
+	{
+		"ruleId": "no-undef",
+		"severity": 2,
+		"line": 23,
+		"column": 5,
+		"endLine": 23,
+		"endColumn": 6
+	}
+]
\ No newline at end of file