lint-rules-alvin 1.1.3 → 1.2.0

package/eslint/configs/custom.js

@@ -1,7 +1,6 @@
 import { newlineBetweenImportsRule } from '../custom_rules/newline-between-imports.js';
 import { unnamedImportsLastRule } from '../custom_rules/unnamed-imports-last.js';
 import { jsxMultilinePropNewlineRule } from '../custom_rules/jsx-multiline-prop-newline.js';
-import { jsxNoSingleObjectCurlyNewlineRule } from '../custom_rules/jsx-no-single-object-curly-newline.js';
 import { maxChainPerLineRule } from '../custom_rules/max-chain-per-line.js';
 import { multilineParenNewlineRule } from '../custom_rules/multiline-paren-newline.js';
 import { multilineArrayAccessorNewlineRule } from '../custom_rules/multiline-array-accessor-newline.js';
@@ -19,7 +18,6 @@ export const custom = {
 				'newline-between-imports': newlineBetweenImportsRule,
 				'unnamed-imports-last': unnamedImportsLastRule,
 				'jsx-multiline-prop-newline': jsxMultilinePropNewlineRule,
-				'jsx-no-single-object-curly-newline': jsxNoSingleObjectCurlyNewlineRule,
 				'max-chain-per-line': maxChainPerLineRule,
 				'multiline-paren-newline': multilineParenNewlineRule,
 				'multiline-array-accessor-newline': multilineArrayAccessorNewlineRule,
@@ -33,8 +31,13 @@ export const custom = {
 			{ minItems: 2 }
 		],
 		'custom/unnamed-imports-last': 'error',
-		'custom/jsx-multiline-prop-newline': 'error',
-		'custom/jsx-no-single-object-curly-newline': 'error',
+		'custom/jsx-multiline-prop-newline': [
+			'error',
+			{
+				enforceSingleLine: true,
+				allowSingleExpression: true
+			}
+		],
 		'custom/max-chain-per-line': [
 			'error',
 			{

package/eslint/configs/index.d.ts

@@ -9,4 +9,5 @@ export declare const json: Linter.Config[];
 export declare const markdown: Linter.Config;
 export declare const reactHooks: Linter.Config;
 export declare const stylistic: Linter.Config;
+export declare const sveltekit: Linter.Config[];
 export declare const typescript: Linter.Config;

package/eslint/configs/index.js

@@ -7,4 +7,5 @@ export { json } from './json.js';
 export { markdown } from './markdown.js';
 export { reactHooks } from './reactHooks.js';
 export { stylistic } from './stylistic.js';
+export { sveltekit } from './sveltekit.js';
 export { typescript } from './typescript.js';

package/eslint/configs/sveltekit.js

@@ -0,0 +1,209 @@
+import eslintPluginSvelte from 'eslint-plugin-svelte';
+
+/**
+ * The ESLint `stylistic` config. Extends `configs.recommended` and overrides all rules.
+ *
+ * @type {import('eslint').Linter.Config[]}
+ */
+export const sveltekit = [
+	...eslintPluginSvelte.configs['flat/base'],
+	{
+		files: [
+			'**/*.svelte',
+			'**/*.svelte.ts',
+			'**/*.svelte.js'
+		],
+		rules: {
+
+			// Svelte-specific
+			'svelte/infinite-reactive-loop': 'warn',
+			'svelte/no-dom-manupulating': 'warn',
+			'svelte/no-dupe-else-if-blocks': 'error',
+			'svelte/no-dupe-else-on-directives': 'error',
+			'svelte/no-dupe-style-properties': 'error',
+			'svelte/no-dupe-use-directives': 'error',
+			'svelte/no-not-function-handler': 'error',
+			'svelte/no-object-in-text-mustaches': 'error',
+			'svelte/no-raw-special-elements': 'error',
+			'svelte/no-reactive-reassign': 'error',
+			'svelte/no-shorthand-style-property-overrides': 'warn',
+			'svelte/no-store-async': 'error',
+			'svelte/no-top-level-browser-globals': 'error',
+			'svelte/no-unknown-style-directive-property': 'error',
+			'svelte/prefer-svelte-reactivity': 'error',
+			'svelte/require-store-callbacks-use-set-param': 'error',
+			'svelte/require-store-reactive-access': 'error',
+			'svelte/valid-compile': 'off',
+			'svelte/valid-style-parse': 'error',
+
+			// Security
+			'svelte/no-at-html-tags': 'warn',
+			'svelte/no-target-blank': 'error',
+
+			// Best practices
+			'svelte/block-lang': [
+				'error',
+				{
+					enforceScriptPresent: false,
+					enforceStylePresent: false,
+					script: [
+						'ts',
+						'js'
+					]
+				}
+			],
+			'svelte/button-has-type': 'off',
+			'svelte/no-add-event-listener': 'error',
+			'svelte/no-at-debug-tags': 'warn',
+			'svelte/no-ignored-unsubscribe': 'warn',
+			'svelte/no-immutable-reactive-statements': 'error',
+			'svelte/no-inline-styles': 'error',
+			'svelte/no-inspect': 'warn',
+			'svelte/no-reactive-functions': 'error',
+			'svelte/no-reactive-literals': 'error',
+			'svelte/no-svelte-internal': 'error',
+			'svelte/no-unnecessary-state-wrap': 'error',
+			'svelte/no-unused-class-name': 'error',
+			'svelte/no-unused-props': 'error',
+			'svelte/no-unused-svelte-ignore': 'error',
+			'svelte/no-useless-children-snippet': 'error',
+			'svelte/no-useless-mustaches': 'error',
+			'prefer-const': 'off',
+			'svelte/prefer-const': 'error',
+			'svelte/prefer-destructed-store-props': 'error',
+			'svelte/prefer-writable-derived': 'error',
+			'svelte/require-each-key': 'error',
+			'svelte/require-event-dispatcher-types': 'error',
+			'svelte/require-optimized-style-attribute': 'error',
+			'svelte/require-store-init': 'error',
+			'svelte/valid-each-key': 'error',
+
+			// Stylistic
+			'svelte/consistent-selector-style': 'off',
+			'svelte/derived-has-same-inputs-outputs': 'error',
+			'svelte/first-attribute-linebreak': [
+				'error',
+				{
+					singleline: 'beside',
+					multiline: 'below'
+				}
+			],
+			'svelte/html-closing-bracket-new-line': [
+				'error',
+				{
+					singleline: 'never',
+					multiline: 'always',
+					selfClosingTag: {
+						singleline: 'never',
+						multiline: 'always'
+					}
+				}
+			],
+			'svelte/html-closing-bracket-spacing': [
+				'error',
+				{
+					startTag: 'never',
+					endTag: 'never',
+					selfClosingTag: 'always'
+				}
+			],
+			'svelte/html-quotes': [
+				'error',
+				{
+					prefer: 'double',
+					dynamic: {
+						quoted: false,
+						avoidInvalidUnquotedInHTML: false
+					}
+				}
+			],
+			'svelte/html-self-closing': [
+				'error',
+				'default'
+			],
+			'indent': 'off', // eslint-disable-line @stylistic/quote-props
+			'@stylistic/indent': 'off',
+			'svelte/indent': [
+				'error',
+				{
+					indent: 'tab',
+					switchCase: 1,
+					alignAttributesVertically: false
+				}
+			],
+			'svelte/max-attributes-per-line': [
+				'error',
+				{
+					singleline: 1,
+					multiline: 1
+				}
+			],
+			'svelte/mustache-spacing': [
+				'error',
+				{
+					textExpressions: 'never',
+					attributesAndProps: 'never',
+					directiveExpressions: 'never',
+					tags: {
+						openingBrace: 'never',
+						closingBrace: 'never'
+					}
+				}
+			],
+			'svelte/no-extra-reactive-curlies': 'error',
+			'svelte/no-restricted-html-elements': 'off', // Allow the user to override
+			'svelte/no-spaces-around-equal-signs-in-attribute': 'error',
+			'svelte/prefer-class-directive': 'error',
+			'svelte/prefer-style-directive': 'error',
+			'svelte/require-event-prefix': 'off',
+			'svelte/shorthand-attribute': [
+				'error',
+				{ prefer: 'always' }
+			],
+			'svelte/shorthand-directive': [
+				'off',
+				{ prefer: 'never' }
+			],
+			'svelte/sort-attributes': 'error',
+			'svelte/spaced-html-comment': [
+				'error',
+				'always'
+			],
+
+			// Extensions
+			'svelte/no-inner-declarations': [
+				'error',
+				'functions',
+				{ blockScopedFunctions: 'allow' }
+			],
+			'no-trailing-spaces': 'off',
+			'svelte/no-trailing-spaces': [
+				'error',
+				{
+					skipBlankLines: false,
+					ignoreComments: false
+				}
+			],
+
+			// SvelteKit
+			'svelte/no-export-load-in-svelte-module-in-kit-pages': 'error',
+			'svelte/no-navigation-without-resolve': [
+				'error',
+				{
+					ignoreGoto: false,
+					ignoreLinks: false,
+					ignorePushState: false,
+					ignoreReplaceState: false
+				}
+			],
+			'svelte/valid-prop-names-in-kit-pages': 'error',
+
+			// System
+			'svelte/comment-directive': [
+				'error',
+				{ reportUnusedDisableDirectives: true }
+			],
+			'svelte/system': 'error' // Keep this on!
+		}
+	}
+];

package/eslint/custom_rules/jsx-multiline-prop-newline.js

@@ -5,108 +5,199 @@ export const jsxMultilinePropNewlineRule = {
 	meta: {
 		type: 'layout',
 		docs: {
-			description: 'Enforces a new line for the first prop if any prop\'s value is multiline.',
+			description: 'Enforces newline consistency for JSX properties.',
 			category: 'Stylistic Issues',
 			recommended: false
 		},
 		fixable: 'code',
-		schema: [],
-		messages: { error: 'The first property should be on a new line if any property\'s value is multiline.' }
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					enforceSingleLine: {
+						type: 'boolean',
+						default: false
+					},
+					allowSingleExpression: {
+						type: 'boolean',
+						default: true
+					}
+				},
+				additionalProperties: false
+			}
+		],
+		messages: {
+			collapse: 'This expression should not be surrounded by newlines.',
+			expand: 'This multiline expression should be surrounded by newlines.'
+		}
 	},
-
 	create(context) {
 
+		const {
+			allowSingleExpression = true,
+			enforceSingleLine = false
+		} = context.options[0] || {};
 		const sourceCode = context.sourceCode;
 
-		function isMultiline(node) {
-
-			return node && node.loc && node
-				.loc
-				.start
-				.line < node
-				.loc
-				.end
-				.line;
-
-		}
-
 		return {
-			JSXOpeningElement(node) {
+			JSXExpressionContainer(node) {
 
-				if (node.attributes.length === 0) {
+				if (node.parent.type !== 'JSXAttribute' || node.expression.type === 'JSXEmptyExpression') {
 
 					return;
 
 				}
 
-				const hasMultilineProp = node.attributes.some(
-					(attr) => {
+				const openingBrace = sourceCode.getFirstToken(node);
+				const closingBrace = sourceCode.getLastToken(node);
+				const expression = node.expression;
+
+				const expressionIsMultiline = expression
+					.loc
+					.start
+					.line !== expression
+					.loc
+					.end
+					.line;
+
+				const hasNewlineAfter = openingBrace
+					.loc
+					.end
+					.line !== expression
+					.loc
+					.start
+					.line;
+				const hasNewlineBefore = expression
+					.loc
+					.end
+					.line !== closingBrace
+					.loc
+					.start
+					.line;
+
+				if (expressionIsMultiline) {
+
+					const isSingleObjectOrArray = expression.type === 'ObjectExpression' || expression.type === 'ArrayExpression';
+
+					if (allowSingleExpression && isSingleObjectOrArray) {
+
+						// Collapse newlines for single multiline Object/Array
+						if (hasNewlineAfter || hasNewlineBefore) {
+
+							context.report({
+								node,
+								messageId: 'collapse',
+								fix(fixer) {
+
+									const fixes = [];
+									if (hasNewlineAfter) {
+
+										fixes.push(
+											fixer.removeRange([
+												openingBrace.range[1],
+												expression.range[0]
+											])
+										);
+
+									}
+									if (hasNewlineBefore) {
+
+										fixes.push(
+											fixer.removeRange([
+												expression.range[1],
+												closingBrace.range[0]
+											])
+										);
+
+									}
+									return fixes;
+
+								}
+							});
 
-						// Check for JSXAttribute (e.g., href={...})
-						if (attr.type === 'JSXAttribute') {
+						}
 
-							return isMultiline(attr.value);
+					} else {
 
-						}
+						// Enforce newlines for other multiline expressions
+						if (!hasNewlineAfter || !hasNewlineBefore) {
+
+							context.report({
+								node,
+								messageId: 'expand',
+								fix(fixer) {
+
+									const fixes = [];
+									if (!hasNewlineAfter) {
+
+										fixes.push(
+											fixer.insertTextAfter(
+												openingBrace,
+												'\n'
+											)
+										);
 
-						// Check for JSXSpreadAttribute (e.g., {...props})
-						if (attr.type === 'JSXSpreadAttribute') {
+									}
+									if (!hasNewlineBefore) {
 
-							return isMultiline(attr);
+										fixes.push(
+											fixer.insertTextBefore(
+												closingBrace,
+												'\n'
+											)
+										);
+
+									}
+									return fixes;
+
+								}
+							});
 
 						}
-						return false;
 
 					}
-				);
 
-				if (!hasMultilineProp) {
+				} else { // Single-line expression
 
-					return;
+					if (enforceSingleLine) {
 
-				}
+						// Collapse newlines
+						if (hasNewlineAfter || hasNewlineBefore) {
+
+							context.report({
+								node,
+								messageId: 'collapse',
+								fix(fixer) {
+
+									const fixes = [];
+									if (hasNewlineAfter) {
 
-				const firstProp = node.attributes[0];
-
-				// Check if the tag name and the first prop are on the same line.
-				if (
-					node
-						.name
-						.loc
-						.end
-						.line === firstProp
-						.loc
-						.start
-						.line
-				) {
-
-					context.report({
-						node: firstProp,
-						messageId: 'error',
-						fix(fixer) {
-
-							// Get indentation of the line with the opening tag.
-							const line = sourceCode.getLines()[
-								node
-									.loc
-									.start
-									.line - 1
-							];
-							const baseIndentMatch = line.match(/^\s*/);
-							const baseIndent = baseIndentMatch
-								? baseIndentMatch[0]
-								: '';
-
-							// Assume an indent of 2 spaces, a common practice.
-							const indent = baseIndent + '  ';
-
-							return fixer.insertTextBefore(
-								firstProp,
-								`\n${indent}`
-							);
+										fixes.push(
+											fixer.removeRange([
+												openingBrace.range[1],
+												expression.range[0]
+											])
+										);
+
+									}
+									if (hasNewlineBefore) {
+
+										fixes.push(
+											fixer.removeRange([
+												expression.range[1],
+												closingBrace.range[0]
+											])
+										);
+
+									}
+									return fixes;
+
+								}
+							});
 
 						}
-					});
+
+					}
 
 				}
 

package/eslint/presets/index.d.ts

@@ -1,14 +1,11 @@
 import type { Linter } from 'eslint';
 
 /**
- * ESLint preset for Astro/React with JavaScript.
- *
- * This package uses ESLint's flat config format, so the preset is an array
- * of flat-config items.
+ * ESLint preset for Astro/React with TypeScript.
  */
-export declare const astroReact: readonly Linter.Config[];
+export declare const astroReactTs: readonly Linter.Config[];
 
 /**
- * ESLint preset for Astro/React with TypeScript.
+ * ESLint preset for SvelteKit with TypeScript.
  */
-export declare const astroReactTs: readonly Linter.Config[];
+export declare const sveltekitTs: readonly Linter.Config[];

package/eslint/presets/index.js

@@ -1,2 +1,2 @@
-export { astroReact } from './astroReact';
-export { astroReactTs } from './astroReactTs';
+export { astroReactTs } from './astroReactTs.js';
+export { sveltekitTs } from './sveltekitTs.js';

package/eslint/presets/sveltekitTs.js

@@ -0,0 +1,25 @@
+import { defineConfig } from 'eslint/config';
+import { importX as eslintPluginImportX } from 'eslint-plugin-import-x';
+import {
+	base,
+	importX,
+	sveltekit,
+	stylistic,
+	custom,
+	typescript
+} from '../configs/index.js';
+
+/**
+ * The `ESLint` PocketBase/SvelteKit config with typescript.
+ */
+export const sveltekitTs = defineConfig(
+	base,
+	sveltekit,
+	typescript,
+	{
+		...eslintPluginImportX.configs['flat/typescript'],
+		...importX
+	},
+	stylistic,
+	custom
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lint-rules-alvin",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "My own personal linting ruleset for a bunch of different plugins. Includes a few custom rules. Used in a few of my repos.",
   "keywords": [
     "eslint"
@@ -43,7 +43,9 @@
     "eslint-plugin-jsonc": "^2.21.0",
     "eslint-plugin-markdown": "^5.1.0",
     "eslint-plugin-react-hooks": "^7.0.0",
+    "eslint-plugin-svelte": "^3.12.4",
     "globals": "^16.4.0",
+    "svelte": "^5.40.2",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.46.1"
   },
@@ -59,6 +61,9 @@
     "eslint-plugin-jsonc": "^2.21.0",
     "eslint-plugin-markdown": "^5.1.0",
     "eslint-plugin-react-hooks": "^7.0.0",
+    "eslint-plugin-svelte": "^3.12.4",
+    "globals": "^16.4.0",
+    "svelte": "^5.40.2",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.46.0"
   },
@@ -96,6 +101,15 @@
     "eslint-plugin-react-hooks": {
       "optional": true
     },
+    "eslint-plugin-svelte": {
+      "optional": true
+    },
+    "globals": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
     "typescript": {
       "optional": true
     },

package/eslint/custom_rules/jsx-no-single-object-curly-newline.js

@@ -1,120 +0,0 @@
-/**
- * @type {import('eslint').Rule.RuleModule}
- */
-export const jsxNoSingleObjectCurlyNewlineRule = {
-	meta: {
-		type: 'layout',
-		docs: {
-			description: 'Disallows newlines inside curly braces for single object or array expressions in JSX.',
-			category: 'Stylistic Issues',
-			recommended: false
-		},
-		fixable: 'code',
-		schema: [],
-		messages: { error: 'Newlines around single object or array expressions in JSX curly braces are not allowed.' }
-	},
-
-	create(context) {
-
-		const sourceCode = context.sourceCode;
-
-		return {
-			JSXExpressionContainer(node) {
-
-				const expression = node.expression;
-
-				// This rule applies only to single ArrayExpressions or ObjectExpressions.
-				if (expression.type !== 'ArrayExpression' && expression.type !== 'ObjectExpression') {
-
-					return;
-
-				}
-
-				// If the expression itself isn't multiline, there are no newlines to collapse.
-				if (
-					expression
-						.loc
-						.start
-						.line === expression
-						.loc
-						.end
-						.line
-				) {
-
-					return;
-
-				}
-
-				const openingBrace = sourceCode.getFirstToken(node); // `{`
-				const closingBrace = sourceCode.getLastToken(node); // `}`
-				const firstTokenInExpression = sourceCode.getFirstToken(expression);
-				const lastTokenInExpression = sourceCode.getLastToken(expression);
-
-				const hasNewlineBefore = openingBrace
-					.loc
-					.end
-					.line < firstTokenInExpression
-					.loc
-					.start
-					.line;
-				const hasNewlineAfter = lastTokenInExpression
-					.loc
-					.end
-					.line < closingBrace
-					.loc
-					.start
-					.line;
-
-				if (hasNewlineBefore || hasNewlineAfter) {
-
-					context.report({
-						node,
-						messageId: 'error',
-						fix(fixer) {
-
-							const fixes = [];
-
-							if (hasNewlineBefore) {
-
-								// Range from the end of `{` to the start of the expression's first token.
-								const range = [
-									openingBrace.range[1],
-									firstTokenInExpression.range[0]
-								];
-								fixes.push(
-									fixer.replaceTextRange(
-										range,
-										''
-									)
-								);
-
-							}
-
-							if (hasNewlineAfter) {
-
-								// Range from the end of the expression's last token to the start of `}`.
-								const range = [
-									lastTokenInExpression.range[1],
-									closingBrace.range[0]
-								];
-								fixes.push(
-									fixer.replaceTextRange(
-										range,
-										''
-									)
-								);
-
-							}
-
-							return fixes;
-
-						}
-					});
-
-				}
-
-			}
-		};
-
-	}
-};

package/eslint/presets/astroReact.js

@@ -1,34 +0,0 @@
-import { defineConfig } from 'eslint/config';
-import { importX as eslintPluginImportX } from 'eslint-plugin-import-x';
-import {
-	base,
-	astro,
-	importX,
-	reactHooks,
-	stylistic,
-	custom
-} from '../configs/index.js';
-
-/**
- * The `ESLint` Astro/React config with typescript.
- */
-export const astroReact = defineConfig(
-	base,
-	astro,
-	{
-		...eslintPluginImportX.configs['flat/react'],
-		...importX
-	},
-	reactHooks,
-	stylistic,
-	custom,
-	{
-		name: 'eslint-plugin-astro-stylistic-override',
-		files: [ '**/*.astro' ],
-		rules: {
-			'@stylistic/jsx-one-expression-per-line': 'off',
-			'@stylistic/jsx-curly-brace-presence': 'off',
-			'import-x/unambiguous': 'off'
-		}
-	}
-);