eslint-plugin-svelte 3.0.3 → 3.2.0

package/README.md

@@ -302,7 +302,9 @@ These rules relate to better ways of doing things to help you avoid problems:
 | [svelte/no-reactive-functions](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-reactive-functions/) | it's not necessary to define functions in reactive statements | :star::bulb: |
 | [svelte/no-reactive-literals](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-reactive-literals/) | don't assign literal values in reactive statements | :star::bulb: |
 | [svelte/no-svelte-internal](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-svelte-internal/) | svelte/internal will be removed in Svelte 6. | :star: |
+| [svelte/no-unnecessary-state-wrap](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-unnecessary-state-wrap/) | Disallow unnecessary $state wrapping of reactive classes | :star::bulb: |
 | [svelte/no-unused-class-name](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-unused-class-name/) | disallow the use of a class in the template without a corresponding style |  |
+| [svelte/no-unused-props](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-unused-props/) | Warns about defined Props properties that are unused | :star: |
 | [svelte/no-unused-svelte-ignore](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-unused-svelte-ignore/) | disallow unused svelte-ignore comments | :star: |
 | [svelte/no-useless-children-snippet](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-useless-children-snippet/) | disallow explicit children snippet where it's not needed | :star: |
 | [svelte/no-useless-mustaches](https://sveltejs.github.io/eslint-plugin-svelte/rules/no-useless-mustaches/) | disallow unnecessary mustache interpolations | :star::wrench: |

package/lib/configs/flat/recommended.js

@@ -28,6 +28,8 @@ const config = [
             'svelte/no-store-async': 'error',
             'svelte/no-svelte-internal': 'error',
             'svelte/no-unknown-style-directive-property': 'error',
+            'svelte/no-unnecessary-state-wrap': 'error',
+            'svelte/no-unused-props': 'error',
             'svelte/no-unused-svelte-ignore': 'error',
             'svelte/no-useless-children-snippet': 'error',
             'svelte/no-useless-mustaches': 'error',

package/lib/main.d.ts

@@ -14,7 +14,7 @@ export declare const configs: {
 export declare const rules: Record<string, Rule.RuleModule>;
 export declare const meta: {
     name: "eslint-plugin-svelte";
-    version: "3.0.3";
+    version: "3.2.0";
 };
 export declare const processors: {
     '.svelte': typeof processor;

package/lib/meta.d.ts

@@ -1,2 +1,2 @@
 export declare const name = "eslint-plugin-svelte";
-export declare const version = "3.0.3";
+export declare const version = "3.2.0";

package/lib/meta.js

@@ -2,4 +2,4 @@
 // This file has been automatically generated,
 // in order to update its content execute "pnpm run update"
 export const name = 'eslint-plugin-svelte';
-export const version = '3.0.3';
+export const version = '3.2.0';

package/lib/rule-types.d.ts

@@ -249,11 +249,21 @@ export interface RuleOptions {
      * @see https://sveltejs.github.io/eslint-plugin-svelte/rules/no-unknown-style-directive-property/
      */
     'svelte/no-unknown-style-directive-property'?: Linter.RuleEntry<SvelteNoUnknownStyleDirectiveProperty>;
+    /**
+     * Disallow unnecessary $state wrapping of reactive classes
+     * @see https://sveltejs.github.io/eslint-plugin-svelte/rules/no-unnecessary-state-wrap/
+     */
+    'svelte/no-unnecessary-state-wrap'?: Linter.RuleEntry<SvelteNoUnnecessaryStateWrap>;
     /**
      * disallow the use of a class in the template without a corresponding style
      * @see https://sveltejs.github.io/eslint-plugin-svelte/rules/no-unused-class-name/
      */
     'svelte/no-unused-class-name'?: Linter.RuleEntry<SvelteNoUnusedClassName>;
+    /**
+     * Warns about defined Props properties that are unused
+     * @see https://sveltejs.github.io/eslint-plugin-svelte/rules/no-unused-props/
+     */
+    'svelte/no-unused-props'?: Linter.RuleEntry<SvelteNoUnusedProps>;
     /**
      * disallow unused svelte-ignore comments
      * @see https://sveltejs.github.io/eslint-plugin-svelte/rules/no-unused-svelte-ignore/
@@ -521,11 +531,23 @@ type SvelteNoUnknownStyleDirectiveProperty = [] | [
         ignorePrefixed?: boolean;
     }
 ];
+type SvelteNoUnnecessaryStateWrap = [] | [
+    {
+        additionalReactiveClasses?: string[];
+        allowReassign?: boolean;
+    }
+];
 type SvelteNoUnusedClassName = [] | [
     {
         allowedClassNames?: string[];
     }
 ];
+type SvelteNoUnusedProps = [] | [
+    {
+        checkImportedTypes?: boolean;
+        ignorePatterns?: string[];
+    }
+];
 type SvelteNoUselessMustaches = [] | [
     {
         ignoreIncludesComment?: boolean;
@@ -541,6 +563,7 @@ type SveltePreferConst = [] | [
     {
         destructuring?: ("any" | "all");
         ignoreReadBeforeAssign?: boolean;
+        excludedRunes?: string[];
     }
 ];
 type SvelteShorthandAttribute = [] | [

package/lib/rules/consistent-selector-style.js

@@ -49,6 +49,7 @@ export default createRule('consistent-selector-style', {
         const styleSelectorNodeLoc = sourceCode.parserServices.styleSelectorNodeLoc;
         const checkGlobal = context.options[0]?.checkGlobal ?? false;
         const style = context.options[0]?.style ?? ['type', 'id', 'class'];
+        const whitelistedClasses = [];
         const classSelections = new Map();
         const idSelections = new Map();
         const typeSelections = new Map();
@@ -89,6 +90,9 @@ export default createRule('consistent-selector-style', {
          * Checks a class selector
          */
         function checkClassSelector(node) {
+            if (whitelistedClasses.includes(node.value)) {
+                return;
+            }
             const selection = classSelections.get(node.value) ?? [];
             for (const styleValue of style) {
                 if (styleValue === 'class') {
@@ -171,6 +175,9 @@ export default createRule('consistent-selector-style', {
                     addToArrayMap(classSelections, className, node);
                 }
                 for (const attribute of node.startTag.attributes) {
+                    if (attribute.type === 'SvelteDirective' && attribute.kind === 'Class') {
+                        whitelistedClasses.push(attribute.key.name.name);
+                    }
                     if (attribute.type !== 'SvelteAttribute' || attribute.key.name !== 'id') {
                         continue;
                     }

package/lib/rules/no-navigation-without-base.js

@@ -71,13 +71,14 @@ export default createRule('no-navigation-without-base', {
                 }
                 const hrefValue = node.value[0];
                 if (hrefValue.type === 'SvelteLiteral') {
-                    if (!expressionIsAbsolute(hrefValue)) {
+                    if (!expressionIsAbsolute(hrefValue) && !expressionIsFragment(hrefValue)) {
                         context.report({ loc: hrefValue.loc, messageId: 'linkNotPrefixed' });
                     }
                     return;
                 }
                 if (!expressionStartsWithBase(context, hrefValue.expression, basePathNames) &&
-                    !expressionIsAbsolute(hrefValue.expression)) {
+                    !expressionIsAbsolute(hrefValue.expression) &&
+                    !expressionIsFragment(hrefValue.expression)) {
                     context.report({ loc: hrefValue.loc, messageId: 'linkNotPrefixed' });
                 }
             }
@@ -247,3 +248,27 @@ function templateLiteralIsAbsolute(url) {
 function urlValueIsAbsolute(url) {
     return url.includes('://');
 }
+function expressionIsFragment(url) {
+    switch (url.type) {
+        case 'BinaryExpression':
+            return binaryExpressionIsFragment(url);
+        case 'Literal':
+            return typeof url.value === 'string' && urlValueIsFragment(url.value);
+        case 'SvelteLiteral':
+            return urlValueIsFragment(url.value);
+        case 'TemplateLiteral':
+            return templateLiteralIsFragment(url);
+        default:
+            return false;
+    }
+}
+function binaryExpressionIsFragment(url) {
+    return url.left.type !== 'PrivateIdentifier' && expressionIsFragment(url.left);
+}
+function templateLiteralIsFragment(url) {
+    return ((url.expressions.length >= 1 && expressionIsFragment(url.expressions[0])) ||
+        (url.quasis.length >= 1 && urlValueIsFragment(url.quasis[0].value.raw)));
+}
+function urlValueIsFragment(url) {
+    return url.startsWith('#');
+}

package/lib/rules/no-unnecessary-state-wrap.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types.js").RuleModule;
+export default _default;

package/lib/rules/no-unnecessary-state-wrap.js

@@ -0,0 +1,133 @@
+import { createRule } from '../utils/index.js';
+import { getSourceCode } from '../utils/compat.js';
+import { ReferenceTracker } from '@eslint-community/eslint-utils';
+const REACTIVE_CLASSES = [
+    'SvelteSet',
+    'SvelteMap',
+    'SvelteURL',
+    'SvelteURLSearchParams',
+    'SvelteDate',
+    'MediaQuery'
+];
+export default createRule('no-unnecessary-state-wrap', {
+    meta: {
+        docs: {
+            description: 'Disallow unnecessary $state wrapping of reactive classes',
+            category: 'Best Practices',
+            recommended: true
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    additionalReactiveClasses: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        uniqueItems: true
+                    },
+                    allowReassign: {
+                        type: 'boolean'
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        messages: {
+            unnecessaryStateWrap: '{{className}} is already reactive, $state wrapping is unnecessary.',
+            suggestRemoveStateWrap: 'Remove unnecessary $state wrapping'
+        },
+        type: 'suggestion',
+        hasSuggestions: true,
+        conditions: [
+            {
+                svelteVersions: ['5'],
+                runes: [true, 'undetermined']
+            }
+        ]
+    },
+    create(context) {
+        const options = context.options[0] ?? {};
+        const additionalReactiveClasses = options.additionalReactiveClasses ?? [];
+        const allowReassign = options.allowReassign ?? false;
+        const referenceTracker = new ReferenceTracker(getSourceCode(context).scopeManager.globalScope);
+        const traceMap = {};
+        for (const reactiveClass of REACTIVE_CLASSES) {
+            traceMap[reactiveClass] = {
+                [ReferenceTracker.CALL]: true,
+                [ReferenceTracker.CONSTRUCT]: true
+            };
+        }
+        // Track all reactive class imports and their aliases
+        const references = referenceTracker.iterateEsmReferences({
+            'svelte/reactivity': {
+                [ReferenceTracker.ESM]: true,
+                ...traceMap
+            }
+        });
+        const referenceNodeAndNames = Array.from(references).map(({ node, path }) => {
+            return {
+                node,
+                name: path[path.length - 1]
+            };
+        });
+        function isReassigned(identifier) {
+            const variable = getSourceCode(context).scopeManager.getDeclaredVariables(identifier.parent)[0];
+            return variable.references.some((ref) => {
+                return ref.isWrite() && ref.identifier !== identifier;
+            });
+        }
+        function reportUnnecessaryStateWrap(stateNode, targetNode, className, identifier) {
+            if (allowReassign && identifier && isReassigned(identifier)) {
+                return;
+            }
+            context.report({
+                node: targetNode,
+                messageId: 'unnecessaryStateWrap',
+                data: {
+                    className
+                },
+                suggest: [
+                    {
+                        messageId: 'suggestRemoveStateWrap',
+                        fix(fixer) {
+                            return fixer.replaceText(stateNode, getSourceCode(context).getText(targetNode));
+                        }
+                    }
+                ]
+            });
+        }
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== 'Identifier' || node.callee.name !== '$state') {
+                    return;
+                }
+                for (const arg of node.arguments) {
+                    if ((arg.type === 'NewExpression' || arg.type === 'CallExpression') &&
+                        arg.callee.type === 'Identifier') {
+                        const name = arg.callee.name;
+                        if (additionalReactiveClasses.includes(name)) {
+                            const parent = node.parent;
+                            if (parent?.type === 'VariableDeclarator' && parent.id.type === 'Identifier') {
+                                reportUnnecessaryStateWrap(node, arg, name, parent.id);
+                            }
+                        }
+                    }
+                }
+            },
+            'Program:exit': () => {
+                for (const { node, name } of referenceNodeAndNames) {
+                    if (node.parent?.type === 'CallExpression' &&
+                        node.parent.callee.type === 'Identifier' &&
+                        node.parent.callee.name === '$state') {
+                        const parent = node.parent.parent;
+                        if (parent?.type === 'VariableDeclarator' && parent.id.type === 'Identifier') {
+                            reportUnnecessaryStateWrap(node.parent, node, name, parent.id);
+                        }
+                    }
+                }
+            }
+        };
+    }
+});

package/lib/rules/no-unused-props.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types.js").RuleModule;
+export default _default;

package/lib/rules/no-unused-props.js

@@ -0,0 +1,280 @@
+import { createRule } from '../utils/index.js';
+import { getTypeScriptTools } from '../utils/ts-utils/index.js';
+import { findVariable } from '../utils/ast-utils.js';
+import { toRegExp } from '../utils/regexp.js';
+import { getFilename } from '../utils/compat.js';
+export default createRule('no-unused-props', {
+    meta: {
+        docs: {
+            description: 'Warns about defined Props properties that are unused',
+            category: 'Best Practices',
+            recommended: true
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    checkImportedTypes: {
+                        type: 'boolean',
+                        default: false
+                    },
+                    ignorePatterns: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        default: []
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        messages: {
+            unusedProp: "'{{name}}' is an unused Props property.",
+            unusedNestedProp: "'{{name}}' in '{{parent}}' is an unused property.",
+            unusedIndexSignature: 'Index signature is unused. Consider using rest operator (...) to capture remaining properties.'
+        },
+        type: 'suggestion',
+        conditions: [
+            {
+                svelteVersions: ['5'],
+                runes: [true, 'undetermined']
+            }
+        ]
+    },
+    create(context) {
+        const fileName = getFilename(context);
+        const tools = getTypeScriptTools(context);
+        if (!tools) {
+            return {};
+        }
+        const typeChecker = tools.service.program.getTypeChecker();
+        if (!typeChecker) {
+            return {};
+        }
+        const options = context.options[0] ?? {};
+        const checkImportedTypes = options.checkImportedTypes ?? false;
+        const ignorePatterns = (options.ignorePatterns ?? []).map((p) => {
+            if (typeof p === 'string') {
+                return toRegExp(p);
+            }
+            return p;
+        });
+        function shouldIgnore(name) {
+            return ignorePatterns.some((pattern) => pattern.test(name));
+        }
+        function shouldIgnoreType(type) {
+            const typeStr = typeChecker.typeToString(type);
+            const symbol = type.getSymbol();
+            const symbolName = symbol?.getName();
+            return shouldIgnore(typeStr) || (symbolName ? shouldIgnore(symbolName) : false);
+        }
+        function isExternalType(type) {
+            const symbol = type.getSymbol();
+            if (!symbol)
+                return false;
+            const declarations = symbol.getDeclarations();
+            if (!declarations || declarations.length === 0)
+                return false;
+            const sourceFile = declarations[0].getSourceFile();
+            return sourceFile.fileName !== fileName;
+        }
+        /**
+         * Extracts property paths from member expressions.
+         */
+        function getPropertyPath(node) {
+            const paths = [];
+            let currentNode = node;
+            let parentNode = currentNode.parent ?? null;
+            while (parentNode) {
+                if (parentNode.type === 'MemberExpression' && parentNode.object === currentNode) {
+                    const property = parentNode.property;
+                    if (property.type === 'Identifier') {
+                        paths.push(property.name);
+                    }
+                    else if (property.type === 'Literal' && typeof property.value === 'string') {
+                        paths.push(property.value);
+                    }
+                    else {
+                        break;
+                    }
+                }
+                currentNode = parentNode;
+                parentNode = currentNode.parent ?? null;
+            }
+            return paths;
+        }
+        /**
+         * Finds all property access paths for a given variable.
+         */
+        function getUsedNestedPropertyNames(node) {
+            const variable = findVariable(context, node);
+            if (!variable)
+                return [];
+            const paths = [];
+            for (const reference of variable.references) {
+                if ('identifier' in reference && reference.identifier.type === 'Identifier') {
+                    const referencePath = getPropertyPath(reference.identifier);
+                    paths.push(referencePath);
+                }
+            }
+            return paths;
+        }
+        /**
+         * Checks if a property is from TypeScript's built-in type definitions.
+         * These properties should be ignored as they are not user-defined props.
+         */
+        function isBuiltInProperty(prop) {
+            const declarations = prop.getDeclarations();
+            if (!declarations || declarations.length === 0)
+                return false;
+            const declaration = declarations[0];
+            const sourceFile = declaration.getSourceFile();
+            if (!sourceFile)
+                return false;
+            return sourceFile.fileName.includes('node_modules/typescript/lib/');
+        }
+        function getUsedPropertiesFromPattern(pattern) {
+            const usedProps = new Set();
+            for (const prop of pattern.properties) {
+                if (prop.type === 'Property' && prop.key.type === 'Identifier') {
+                    usedProps.add(prop.key.name);
+                }
+                else if (prop.type === 'RestElement') {
+                    // If there's a rest element, all properties are potentially used
+                    return new Set();
+                }
+            }
+            return usedProps;
+        }
+        /**
+         * Check if the type is a class type (has constructor or prototype)
+         */
+        function isClassType(type) {
+            if (!type)
+                return false;
+            // Check if it's a class instance type
+            if (type.isClass())
+                return true;
+            // Check for constructor signatures
+            const constructorType = type.getConstructSignatures();
+            if (constructorType.length > 0)
+                return true;
+            // Check if it has a prototype property
+            const symbol = type.getSymbol();
+            if (symbol?.members?.has('prototype'))
+                return true;
+            return false;
+        }
+        /**
+         * Recursively checks for unused properties in a type.
+         */
+        function checkUnusedProperties(type, usedPaths, usedProps, reportNode, parentPath, checkedTypes, reportedProps) {
+            // Skip checking if the type itself is a class
+            if (isClassType(type))
+                return;
+            const typeStr = typeChecker.typeToString(type);
+            if (checkedTypes.has(typeStr))
+                return;
+            checkedTypes.add(typeStr);
+            if (shouldIgnoreType(type))
+                return;
+            if (!checkImportedTypes && isExternalType(type))
+                return;
+            const properties = typeChecker.getPropertiesOfType(type);
+            const baseTypes = type.getBaseTypes();
+            if (!properties.length && (!baseTypes || baseTypes.length === 0)) {
+                return;
+            }
+            if (baseTypes) {
+                for (const baseType of baseTypes) {
+                    checkUnusedProperties(baseType, usedPaths, usedProps, reportNode, parentPath, checkedTypes, reportedProps);
+                }
+            }
+            for (const prop of properties) {
+                if (isBuiltInProperty(prop))
+                    continue;
+                const propName = prop.getName();
+                const currentPath = [...parentPath, propName];
+                const currentPathStr = [...parentPath, propName].join('.');
+                if (reportedProps.has(currentPathStr))
+                    continue;
+                const propType = typeChecker.getTypeOfSymbol(prop);
+                const isUsedInPath = usedPaths.some((path) => {
+                    const usedPath = path.join('.');
+                    return usedPath === currentPathStr || usedPath.startsWith(`${currentPathStr}.`);
+                });
+                const isUsedInProps = usedProps.has(propName);
+                if (!isUsedInPath && !isUsedInProps) {
+                    reportedProps.add(currentPathStr);
+                    context.report({
+                        node: reportNode,
+                        messageId: parentPath.length ? 'unusedNestedProp' : 'unusedProp',
+                        data: {
+                            name: propName,
+                            parent: parentPath.join('.')
+                        }
+                    });
+                }
+                const isUsedNested = usedPaths.some((path) => {
+                    return path.join('.').startsWith(`${currentPathStr}.`);
+                });
+                if (isUsedNested || isUsedInProps) {
+                    checkUnusedProperties(propType, usedPaths, usedProps, reportNode, currentPath, checkedTypes, reportedProps);
+                }
+            }
+            // Check for unused index signatures only at the root level
+            if (parentPath.length === 0) {
+                const indexType = type.getStringIndexType();
+                const numberIndexType = type.getNumberIndexType();
+                const hasIndexSignature = Boolean(indexType) || Boolean(numberIndexType);
+                if (hasIndexSignature && !hasRestElement(usedProps)) {
+                    context.report({
+                        node: reportNode,
+                        messageId: 'unusedIndexSignature'
+                    });
+                }
+            }
+        }
+        /**
+         * Returns true if the destructuring pattern includes a rest element,
+         * which means all remaining properties are potentially used.
+         */
+        function hasRestElement(usedProps) {
+            return usedProps.size === 0;
+        }
+        return {
+            'VariableDeclaration > VariableDeclarator': (node) => {
+                // Only check $props declarations
+                if (node.init?.type !== 'CallExpression' ||
+                    node.init.callee.type !== 'Identifier' ||
+                    node.init.callee.name !== '$props') {
+                    return;
+                }
+                const tsNode = tools.service.esTreeNodeToTSNodeMap.get(node);
+                if (!tsNode || !tsNode.type)
+                    return;
+                const propType = typeChecker.getTypeFromTypeNode(tsNode.type);
+                let usedPaths = [];
+                let usedProps = new Set();
+                if (node.id.type === 'ObjectPattern') {
+                    usedProps = getUsedPropertiesFromPattern(node.id);
+                    if (usedProps.size === 0)
+                        return;
+                    const identifiers = node.id.properties
+                        .filter((p) => p.type === 'Property')
+                        .map((p) => p.value)
+                        .filter((v) => v.type === 'Identifier');
+                    for (const identifier of identifiers) {
+                        const paths = getUsedNestedPropertyNames(identifier);
+                        usedPaths.push(...paths);
+                    }
+                }
+                else if (node.id.type === 'Identifier') {
+                    usedPaths = getUsedNestedPropertyNames(node.id);
+                }
+                checkUnusedProperties(propType, usedPaths, usedProps, node.id, [], new Set(), new Set());
+            }
+        };
+    }
+});

package/lib/rules/prefer-const.js

@@ -15,7 +15,7 @@ function findDeclarationCallee(node) {
  * Determines if a declaration should be skipped in the const preference analysis.
  * Specifically checks for Svelte's state management utilities ($props, $derived).
  */
-function shouldSkipDeclaration(declaration) {
+function shouldSkipDeclaration(declaration, excludedRunes) {
     if (!declaration) {
         return false;
     }
@@ -23,15 +23,13 @@ function shouldSkipDeclaration(declaration) {
     if (!callee) {
         return false;
     }
-    if (callee.type === 'Identifier' && ['$props', '$derived'].includes(callee.name)) {
+    if (callee.type === 'Identifier' && excludedRunes.includes(callee.name)) {
         return true;
     }
     if (callee.type !== 'MemberExpression' || callee.object.type !== 'Identifier') {
         return false;
     }
-    if (callee.object.name === '$derived' &&
-        callee.property.type === 'Identifier' &&
-        callee.property.name === 'by') {
+    if (excludedRunes.includes(callee.object.name)) {
         return true;
     }
     return false;
@@ -44,16 +42,34 @@ export default createRule('prefer-const', {
             category: 'Best Practices',
             recommended: false,
             extensionRule: 'prefer-const'
-        }
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    destructuring: { enum: ['any', 'all'] },
+                    ignoreReadBeforeAssign: { type: 'boolean' },
+                    excludedRunes: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
     },
     create(context) {
+        const config = context.options[0] ?? {};
+        const excludedRunes = config.excludedRunes ?? ['$props', '$derived'];
         return defineWrapperListener(coreRule, context, {
             createListenerProxy(coreListener) {
                 return {
                     ...coreListener,
                     VariableDeclaration(node) {
                         for (const decl of node.declarations) {
-                            if (shouldSkipDeclaration(decl.init)) {
+                            if (shouldSkipDeclaration(decl.init, excludedRunes)) {
                                 return;
                             }
                         }

package/lib/rules/valid-prop-names-in-kit-pages.js

@@ -7,11 +7,11 @@ function checkProp(node, context, expectedPropNames) {
         return;
     for (const p of node.id.properties) {
         if (p.type === 'Property' &&
-            p.value.type === 'Identifier' &&
-            !expectedPropNames.includes(p.value.name)) {
+            p.key.type === 'Identifier' &&
+            !expectedPropNames.includes(p.key.name)) {
             context.report({
-                node: p.value,
-                loc: p.value.loc,
+                node: p.key,
+                loc: p.key.loc,
                 messageId: 'unexpected'
             });
         }

package/lib/utils/rules.js

@@ -46,7 +46,9 @@ import noSvelteInternal from '../rules/no-svelte-internal.js';
 import noTargetBlank from '../rules/no-target-blank.js';
 import noTrailingSpaces from '../rules/no-trailing-spaces.js';
 import noUnknownStyleDirectiveProperty from '../rules/no-unknown-style-directive-property.js';
+import noUnnecessaryStateWrap from '../rules/no-unnecessary-state-wrap.js';
 import noUnusedClassName from '../rules/no-unused-class-name.js';
+import noUnusedProps from '../rules/no-unused-props.js';
 import noUnusedSvelteIgnore from '../rules/no-unused-svelte-ignore.js';
 import noUselessChildrenSnippet from '../rules/no-useless-children-snippet.js';
 import noUselessMustaches from '../rules/no-useless-mustaches.js';
@@ -118,7 +120,9 @@ export const rules = [
     noTargetBlank,
     noTrailingSpaces,
     noUnknownStyleDirectiveProperty,
+    noUnnecessaryStateWrap,
     noUnusedClassName,
+    noUnusedProps,
     noUnusedSvelteIgnore,
     noUselessChildrenSnippet,
     noUselessMustaches,

package/lib/utils/svelte-context.js

@@ -16,7 +16,7 @@ function getSvelteFileType(filePath) {
     return null;
 }
 function getSvelteKitFileTypeFromFilePath(filePath) {
-    const fileName = filePath.split('/').pop();
+    const fileName = filePath.split(/[/\\]/).pop();
     switch (fileName) {
         case '+page.svelte': {
             return '+page.svelte';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "3.0.3",
+  "version": "3.2.0",
   "description": "ESLint plugin for Svelte using AST",
   "repository": "git+https://github.com/sveltejs/eslint-plugin-svelte.git",
   "homepage": "https://sveltejs.github.io/eslint-plugin-svelte",