feat: add control for executing rules based on Svelte/SvelteKit context

.changeset/blue-swans-give.md

@@ -0,0 +1,5 @@
+---
+'eslint-plugin-svelte': minor
+---
+
+feat: Implement util to conditionally run lint based on Svelte version and SvelteKit routes etc

packages/eslint-plugin-svelte/src/rules/no-export-load-in-svelte-module-in-kit-pages.ts

@@ -1,6 +1,5 @@
 import type { TSESTree } from '@typescript-eslint/types';
 import { createRule } from '../utils/index.js';
-import { isKitPageComponent } from '../utils/svelte-kit.js';
 
 export default createRule('no-export-load-in-svelte-module-in-kit-pages', {
 	meta: {
@@ -8,7 +7,7 @@
 			description:
 				'disallow exporting load functions in `*.svelte` module in SvelteKit page components.',
 			category: 'Possible Errors',
 			// TODO Switch to recommended in the major version.
 			recommended: false
 		},
 		schema: [],
@@ -16,12 +15,14 @@
 			unexpected:
 				'disallow exporting load functions in `*.svelte` module in SvelteKit page components.'
 		},
-		type: 'problem'
+		type: 'problem',
+		conditions: [
+			{
+				svelteKitFileTypes: ['+page.svelte', '+error.svelte', '+layout.svelte']
+			}
+		]
 	},
 	create(context) {
-		if (!isKitPageComponent(context)) {
-			return {};
-		}
 		let isModule = false;
 		return {
 			// <script context="module">

packages/eslint-plugin-svelte/src/rules/valid-prop-names-in-kit-pages.ts

@@ -1,7 +1,6 @@
 import type { AST } from 'svelte-eslint-parser';
 import type { TSESTree } from '@typescript-eslint/types';
 import { createRule } from '../utils/index.js';
-import { isKitPageComponent } from '../utils/svelte-kit.js';
 import type { RuleContext } from '../types.js';
 
 const EXPECTED_PROP_NAMES = ['data', 'errors', 'form', 'snapshot'];
@@ -35,10 +34,14 @@ export default createRule('valid-prop-names-in-kit-pages', {
 		messages: {
 			unexpected: 'disallow props other than data or errors in SvelteKit page components.'
 		},
-		type: 'problem'
+		type: 'problem',
+		conditions: [
+			{
+				svelteKitFileTypes: ['+page.svelte', '+error.svelte', '+layout.svelte']
+			}
+		]
 	},
 	create(context) {
-		if (!isKitPageComponent(context)) return {};
 		let isScript = false;
 		return {
 			// <script>

packages/eslint-plugin-svelte/src/types.ts

@@ -8,6 +8,7 @@ import type { Root as SelectorRoot, Node as SelectorNode } from 'postcss-selecto
 import type { ASTNode, ASTNodeWithParent, ASTNodeListener } from './types-for-node.js';
 import type * as TS from 'typescript';
 import type { SourceLocation } from 'svelte-eslint-parser/lib/ast/common.js';
+import type { SvelteContext } from './utils/svelte-context.js';
 
 export type { ASTNode, ASTNodeWithParent, ASTNodeListener };
 export interface RuleListener extends ASTNodeListener {
@@ -108,6 +109,18 @@ export interface PartialRuleMetaData {
 	deprecated?: boolean;
 	replacedBy?: string[] | { note: string };
 	type: 'problem' | 'suggestion' | 'layout';
+	/**
+	 * Conditions to determine whether this rule should be applied.
+	 * Multiple conditions can be specified as array, and the rule will be applied if any one of them matches (logical OR).
+	 * If not specified, the rule will be applied to all files.
+	 */
+	conditions?: {
+		svelteVersions?: SvelteContext['svelteVersion'][];
+		fileTypes?: SvelteContext['fileType'][];
+		runes?: SvelteContext['runes'][];
+		svelteKitVersions?: SvelteContext['svelteKitVersion'][];
+		svelteKitFileTypes?: SvelteContext['svelteKitFileType'][];
+	}[];
 }
 
 export type RuleContext = {

packages/eslint-plugin-svelte/src/utils/index.ts

@@ -1,4 +1,50 @@
-import type { RuleModule, PartialRuleModule } from '../types.js';
+import type { RuleModule, PartialRuleModule, PartialRuleMetaData, RuleContext } from '../types.js';
+import { getSvelteContext, type SvelteContext } from '../utils/svelte-context.js';
+
+function isNotSatisfies<T>(actual: T, expected?: T[]): boolean {
+	if (expected == null || expected.length === 0) {
+		return false;
+	}
+
+	return !expected.includes(actual);
+}
+
+function satisfiesCondition(
+	condition: NonNullable<PartialRuleMetaData['conditions']>[number],
+	svelteContext: SvelteContext
+): boolean {
+	if (
+		isNotSatisfies(svelteContext.svelteVersion, condition.svelteVersions) ||
+		isNotSatisfies(svelteContext.fileType, condition.fileTypes) ||
+		isNotSatisfies(svelteContext.runes, condition.runes) ||
+		isNotSatisfies(svelteContext.svelteKitVersion, condition.svelteKitVersions) ||
+		isNotSatisfies(svelteContext.svelteKitFileType, condition.svelteKitFileTypes)
+	) {
+		return false;
+	}
+
+	return true;
+}
+
+// export for testing
+export function shouldRun(
+	svelteContext: SvelteContext | null,
+	conditions: PartialRuleMetaData['conditions']
+): boolean {
+	// If svelteContext is null, it means the rule might be executed based on the analysis result of a different parser.
+	// In this case, always execute the rule.
+	if (svelteContext == null || conditions == null || conditions.length === 0) {
+		return true;
+	}
+
+	for (const condition of conditions) {
+		if (satisfiesCondition(condition, svelteContext)) {
+			return true;
+		}
+	}
+
+	return false;
+}
 
 /**
  * Define the rule.
@@ -16,6 +62,14 @@ export function createRule(ruleName: string, rule: PartialRuleModule): RuleModul
 				ruleName
 			}
 		},
-		create: rule.create as never
+		create(context: RuleContext) {
+			const { conditions } = rule.meta;
+			const svelteContext = getSvelteContext(context);
+			if (!shouldRun(svelteContext, conditions)) {
+				return {};
+			}
+
+			return rule.create(context);
+		}
 	};
 }

packages/eslint-plugin-svelte/src/utils/svelte-context.ts

@@ -0,0 +1,201 @@
+import type { RuleContext } from '../types.js';
+import fs from 'fs';
+import path from 'path';
+import { getPackageJson } from './get-package-json.js';
+import { getFilename, getSourceCode } from './compat.js';
+
+const isRunInBrowser = !fs.readFileSync;
+
+export type SvelteContext = {
+	svelteVersion: '3/4' | '5';
+	fileType: '.svelte' | '.svelte.[js|ts]';
+	runes: boolean;
+	svelteKitVersion: '1-next' | '1' | '2' | null;
+	svelteKitFileType:
+		| '+page.svelte'
+		| '+page.js'
+		| '+page.server.js'
+		| '+error.svelte'
+		| '+layout.svelte'
+		| '+layout.js'
+		| '+layout.server.js'
+		| '+server.js'
+		| null;
+};
+
+function getFileType(filePath: string): SvelteContext['fileType'] | null {
+	if (filePath.endsWith('.svelte')) {
+		return '.svelte';
+	}
+
+	if (filePath.endsWith('.svelte.js') || filePath.endsWith('.svelte.ts')) {
+		return '.svelte.[js|ts]';
+	}
+
+	return null;
+}
+
+function getSvelteKitFileTypeFromFilePath(filePath: string): SvelteContext['svelteKitFileType'] {
+	const fileName = filePath.split('/').pop();
+	switch (fileName) {
+		case '+page.svelte': {
+			return '+page.svelte';
+		}
+		case '+page.js':
+		case '+page.ts': {
+			return '+page.js';
+		}
+		case '+page.server.js':
+		case '+page.server.ts': {
+			return '+page.server.js';
+		}
+		case '+error.svelte': {
+			return '+error.svelte';
+		}
+		case '+layout.svelte': {
+			return '+layout.svelte';
+		}
+		case '+layout.js':
+		case '+layout.ts': {
+			return '+layout.js';
+		}
+		case '+layout.server.js':
+		case '+layout.server.ts': {
+			return '+layout.server.js';
+		}
+		case '+server.js':
+		case '+server.ts': {
+			return '+server.js';
+		}
+		default: {
+			return null;
+		}
+	}
+}
+
+function getSvelteKitContext(
+	context: RuleContext
+): Pick<SvelteContext, 'svelteKitFileType' | 'svelteKitVersion'> {
+	const filePath = getFilename(context);
+	const svelteKitVersion = getSvelteKitVersion(filePath);
+	if (svelteKitVersion == null) {
+		return {
+			svelteKitFileType: null,
+			svelteKitVersion: null
+		};
+	}
+	if (isRunInBrowser) {
+		return {
+			svelteKitVersion,
+			// Judge by only file path if it runs in browser.
+			svelteKitFileType: getSvelteKitFileTypeFromFilePath(filePath)
+		};
+	}
+
+	const routes =
+		(
+			context.settings?.svelte?.kit?.files?.routes ??
+			getSourceCode(context).parserServices.svelteParseContext?.svelteConfig?.kit?.files?.routes
+		)?.replace(/^\//, '') ?? 'src/routes';
+	const projectRootDir = getProjectRootDir(getFilename(context)) ?? '';
+
+	if (!filePath.startsWith(path.join(projectRootDir, routes))) {
+		return {
+			svelteKitVersion,
+			svelteKitFileType: null
+		};
+	}
+
+	return {
+		svelteKitVersion,
+		svelteKitFileType: getSvelteKitFileTypeFromFilePath(filePath)
+	};
+}
+
+/**
+ * Check givin file is under SvelteKit project.
+ *
+ * If it runs on browser, it always returns true.
+ *
+ * @param filePath A file path.
+ * @returns
+ */
+function getSvelteKitVersion(filePath: string): SvelteContext['svelteKitVersion'] {
+	// Hack: if it runs in browser, it regards as SvelteKit project.
+	if (isRunInBrowser) return '2';
+	try {
+		const packageJson = getPackageJson(filePath);
+		if (!packageJson) return null;
+		if (packageJson.name === 'eslint-plugin-svelte')
+			// Hack: CI removes `@sveltejs/kit` and it returns false and test failed.
+			// So always it returns true if it runs on the package.
+			return '2';
+
+		const version =
+			packageJson.dependencies?.['@sveltejs/kit'] ?? packageJson.devDependencies?.['@sveltejs/kit'];
+		if (typeof version !== 'string') {
+			return null;
+		}
+		if (version.startsWith('1.0.0-next.')) {
+			return '1-next';
+		} else if (version.startsWith('1.')) {
+			return '1';
+		} else if (version.startsWith('2.')) {
+			return '2';
+		}
+		// If unknown version, it recognize as v2.
+		return '2';
+	} catch {
+		return null;
+	}
+}
+
+function getSvelteVersion(compilerVersion: string): SvelteContext['svelteVersion'] {
+	const version = parseInt(compilerVersion.split('.')[0], 10);
+	if (version === 3 || version === 4) {
+		return '3/4';
+	}
+	return '5';
+}
+
+/**
+ * Gets a  project root folder path.
+ * @param filePath A file path to lookup.
+ * @returns A found project root folder path or null.
+ */
+function getProjectRootDir(filePath: string): string | null {
+	if (isRunInBrowser) return null;
+	const packageJsonFilePath = getPackageJson(filePath)?.filePath;
+	if (!packageJsonFilePath) return null;
+	return path.dirname(path.resolve(packageJsonFilePath));
+}
+
+export function getSvelteContext(context: RuleContext): SvelteContext | null {
+	const { parserServices } = getSourceCode(context);
+	const { svelteParseContext } = parserServices;
+	if (svelteParseContext === undefined) {
+		return null;
+	}
+
+	const { compilerVersion } = svelteParseContext;
+	if (compilerVersion === undefined) {
+		return null;
+	}
+
+	const filePath = getFilename(context);
+	const svelteKitContext = getSvelteKitContext(context);
+
+	const runes = svelteParseContext.runes === true;
+	const fileType = getFileType(filePath);
+	if (fileType === null) {
+		return null;
+	}
+
+	return {
+		svelteVersion: getSvelteVersion(compilerVersion),
+		runes,
+		fileType,
+		svelteKitVersion: svelteKitContext.svelteKitVersion,
+		svelteKitFileType: svelteKitContext.svelteKitFileType
+	};
+}