@nextcloud/eslint-config 9.0.0-rc.9 → 9.0.1

package/CHANGELOG.md

@@ -4,8 +4,15 @@
 -->	
 # Changelog
 
-## [v9.0.0](https://github.com/nextcloud-libraries/eslint-config/tree/v9.0.0) (unreleased)
+## [v9.0.1](https://github.com/nextcloud-libraries/eslint-config/tree/v9.0.1) (2026-07-07)
+### Fixed
+* fix(vue): error on `vue/attributes-order` and `vue/order-in-components` instead of warn [\#1445](https://github.com/nextcloud-libraries/eslint-config/pull/1445) \([susnux](https://github.com/susnux)\)
+* fix: `no-deprecated-library-*` rules incorrectly behave for `nextcloud/vue` syntax [\#1452](https://github.com/nextcloud-libraries/eslint-config/pull/1452) \([Antreesy](https://github.com/Antreesy)\)
+* fix(no-deprecated-library-props): support win32 filesystem and different `@nextcloud/vue` directory structures [\#1454](https://github.com/nextcloud-libraries/eslint-config/pull/1454) \([ShGKme](https://github.com/ShGKme)\)
+* fix(no-deprecated-library-props): support camelCase attributes [\#1453](https://github.com/nextcloud-libraries/eslint-config/pull/1453) \([Antreesy](https://github.com/Antreesy)\)
+* fix: increase min. Node version to 22.14 [\#1455](https://github.com/nextcloud-libraries/eslint-config/pull/1455) \([susnux](https://github.com/susnux)\)
 
+## [v9.0.0](https://github.com/nextcloud-libraries/eslint-config/tree/v9.0.0) (2026-06-26)
 ### Breaking
 This package now is using ESLint v10 and requires ESLint flat configurations.
 Please refer to the README on how to adjust your configuration for flat config.
@@ -44,6 +51,7 @@ either using the sledge hammer method (remove the lock file and run `npm i`) or
 * feat(vue3): force camelCase for events in `<template>` [\#1263](https://github.com/nextcloud-libraries/eslint-config/pull/1263) \([ShGKme](https://github.com/ShGKme)\)
 * feat(vue3): force camelCase for slot names [\#1264](https://github.com/nextcloud-libraries/eslint-config/pull/1264) \([ShGKme](https://github.com/ShGKme)\)
 * feat(vue3): force camelCase for props in template [\#1266](https://github.com/nextcloud-libraries/eslint-config/pull/1266) \([ShGKme](https://github.com/ShGKme)\)
+* feat(import): enforce consistent types imports and ban usage of inline type specifiers [\#1382](https://github.com/nextcloud-libraries/eslint-config/pull/1382) \([susnux](https://github.com/susnux)\)
 
 ### Fixed
 * fix(codestyle): do not require splitting chains [\#951](https://github.com/nextcloud-libraries/eslint-config/pull/951)
@@ -81,6 +89,7 @@ either using the sledge hammer method (remove the lock file and run `npm i`) or
 * fix: switch to `@stylistic/exp-list-style` to resolve array edge-cases [\#1203](https://github.com/nextcloud-libraries/eslint-config/pull/1203) \([susnux](https://github.com/susnux)\)
 * fix(nextcloud-plugin): add more removed API in Nextcloud 33 [\#1269](https://github.com/nextcloud-libraries/eslint-config/pull/1269) \([susnux](https://github.com/susnux)\)
 * fix: use vue-eslint-parser directly [\#1277](https://github.com/nextcloud-libraries/eslint-config/pull/1277) \([susnux](https://github.com/susnux)\)
+* fix(imports): no newline inside import statements [\#1379](https://github.com/nextcloud-libraries/eslint-config/pull/1379) \([max-nextcloud](https://github.com/max-nextcloud)\)
 
 ### Changed
 * Add SPDX header [#802](https://github.com/nextcloud-libraries/eslint-config/pull/802)
@@ -89,6 +98,7 @@ either using the sledge hammer method (remove the lock file and run `npm i`) or
 * refactor: use camelCase for internal variables [#971](https://github.com/nextcloud-libraries/eslint-config/pull/971) ([susnux](https://github.com/susnux))
 * chore: do not bundle config but just use Typescript [#967](https://github.com/nextcloud-libraries/eslint-config/pull/967)
 * chore: require node ^20.19 [\#982](https://github.com/nextcloud-libraries/eslint-config/pull/982)
+* chore: remove EOL Node version and add new future LTS [\#1381](https://github.com/nextcloud-libraries/eslint-config/pull/1381) \([susnux](https://github.com/susnux)\)
 * chore: allow to run `npm lint` without compile step [#975](https://github.com/nextcloud-libraries/eslint-config/pull/975) ([susnux](https://github.com/susnux))
 * chore: prepare v9.0.0-rc.1 [#1010](https://github.com/nextcloud-libraries/eslint-config/pull/1010) ([susnux](https://github.com/susnux))
 * docs: consistent badge style with the reuse one [#1060](https://github.com/nextcloud-libraries/eslint-config/pull/1060) ([susnux](https://github.com/susnux))
@@ -103,18 +113,18 @@ either using the sledge hammer method (remove the lock file and run `npm i`) or
 * chore(gitignore): ignore IDE configs [\#1265](https://github.com/nextcloud-libraries/eslint-config/pull/1265) \([ShGKme](https://github.com/ShGKme)\)
 * test(vue3): add some formatting tests [\#1267](https://github.com/nextcloud-libraries/eslint-config/pull/1267) \([ShGKme](https://github.com/ShGKme)\)
 * refactor: merge Nextcloud specific rules into the `@nextcloud` plugin [\#1278](https://github.com/nextcloud-libraries/eslint-config/pull/1278) \([susnux](https://github.com/susnux)\)
-* Updated `@eslint/json` to 0.14.0
+* Updated `@eslint/json` to 2.0.0
 * Updated `@stylistic/eslint-plugin` to 5.7.0
 * Updated `eslint-config-flat-gitignore` to 2.1.0
-* Updated `eslint-plugin-antfu` to 3.1.3
-* Updated `eslint-plugin-jsdoc` to 62.0.0
-* Updated `eslint-plugin-perfectionist` to 5.3.1
-* Updated `eslint-plugin-vue` to 10.6.2
-* Updated `fast-xml-parser` to 5.3.3
-* Updated `globals` to 17.0.0
-* Updated `semver` to 7.7.3
-* Updated `sort-package-json` to 3.6.0
-* Updated `typescript-eslint` to 8.53.0
+* Updated `eslint-plugin-antfu` to 3.2.3
+* Updated `eslint-plugin-jsdoc` to 63.0.4
+* Updated `eslint-plugin-perfectionist` to 5.9.1
+* Updated `eslint-plugin-vue` to 10.9.2
+* Updated `fast-xml-parser` to 5.9.0
+* Updated `globals` to 17.7.0
+* Updated `semver` to 7.8.4
+* Updated `sort-package-json` to 4.0.0
+* Updated `typescript-eslint` to 8.62.0
 
 ## [v8.4.2](https://github.com/nextcloud-libraries/eslint-config/tree/v8.4.2) (2025-02-16)
 ### Fixed

package/dist/configs/imports.js

@@ -30,6 +30,8 @@ export function imports(options) {
             rules: {
                 // Require file extensions
                 'import-extensions/extensions': 'error',
+                // enforce explicit type imports (no inline types)
+                'import-extensions/ban-inline-type-imports': 'error',
                 // Sorting of imports
                 'sort-imports': 'off',
                 'perfectionist/sort-imports': [
@@ -96,7 +98,7 @@ export function imports(options) {
 function createSortingConfig(type) {
     return {
         type: 'natural',
-        newlinesBetween: 1,
+        newlinesBetween: 0,
         partitionByNewLine: false,
         groups: [
             `type-${type}`,

package/dist/configs/vue.js

@@ -123,7 +123,11 @@ export function vue(options) {
                 'vue/padding-line-between-blocks': 'error',
                 // Prefer separated static and dynamic class attributes
                 'vue/prefer-separate-static-class': 'error',
+                // For consistent layout of the template
+                'vue/attributes-order': 'error',
                 // For consistent layout of components
+                'vue/order-in-components': 'error',
+                // For consistent layout of script-setup components
                 'vue/define-macros-order': [
                     'error',
                     {

package/dist/plugins/import-extensions/index.d.ts

@@ -4,6 +4,7 @@
  */
 declare const _default: {
     rules: {
+        'ban-inline-type-imports': import("eslint").Rule.RuleModule;
         extensions: import("eslint").Rule.RuleModule;
     };
     meta: {

package/dist/plugins/import-extensions/rules/ban-inline-type-imports.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2015 Ben Mosher
+ * SPDX-License-Identifier: MIT
+ */
+import type { Rule } from 'eslint';
+export declare const rule: Rule.RuleModule;

package/dist/plugins/import-extensions/rules/ban-inline-type-imports.js

@@ -0,0 +1,176 @@
+/*!
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2015 Ben Mosher
+ * SPDX-License-Identifier: MIT
+ */
+export const rule = {
+    meta: {
+        fixable: 'code',
+        type: 'suggestion',
+        docs: {
+            dialects: ['typescript'],
+            description: 'Ban the use of inline type-only markers for named imports.',
+        },
+        messages: {
+            preferTopLevel: 'Prefer using a top-level type-only import instead of inline type specifiers.',
+        },
+    },
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                if (!('importKind' in node)
+                    || node.importKind === 'type'
+                    // no specifiers (import {} from '') cannot have inline - so is valid
+                    || node.specifiers.length === 0
+                    || (node.specifiers.length === 1
+                        // default imports are both "inline" and "top-level"
+                        && (node.specifiers[0].type === 'ImportDefaultSpecifier'
+                            // namespace imports are both "inline" and "top-level"
+                            || node.specifiers[0].type === 'ImportNamespaceSpecifier'))) {
+                    return;
+                }
+                const typeSpecifiers = [];
+                const valueSpecifiers = [];
+                let defaultSpecifier;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === 'ImportDefaultSpecifier') {
+                        defaultSpecifier = specifier;
+                        continue;
+                    }
+                    if (!('importKind' in specifier) || !specifier.importKind) {
+                        valueSpecifiers.push(specifier);
+                        continue;
+                    }
+                    if (specifier.importKind === 'type') {
+                        typeSpecifiers.push(specifier);
+                    }
+                    else if (specifier.importKind === 'value') {
+                        valueSpecifiers.push(specifier);
+                    }
+                }
+                const typeImport = getImportText(node, context.sourceCode, typeSpecifiers);
+                const newImports = typeImport.trim();
+                if (typeSpecifiers.length === node.specifiers.length) {
+                    // all specifiers have inline specifiers - so we replace the entire import
+                    context.report({
+                        node,
+                        messageId: 'preferTopLevel',
+                        fix(fixer) {
+                            return fixer.replaceText(node, newImports);
+                        },
+                    });
+                }
+                else {
+                    // remove specific specifiers and insert new imports for them
+                    for (const specifier of typeSpecifiers) {
+                        context.report({
+                            node: specifier,
+                            messageId: 'preferTopLevel',
+                            fix(fixer) {
+                                const fixes = [];
+                                // if there are no value specifiers, then the other report fixer will be called, not this one
+                                if (valueSpecifiers.length > 0) {
+                                    // import { Value, type Type } from 'mod';
+                                    // we can just remove the type specifiers
+                                    removeSpecifiers(fixes, fixer, context.sourceCode, typeSpecifiers);
+                                    // make the import nicely formatted by also removing the trailing comma after the last value import
+                                    // eg
+                                    // import { Value, type Type } from 'mod';
+                                    // to
+                                    // import { Value  } from 'mod';
+                                    // not
+                                    // import { Value,  } from 'mod';
+                                    removeCommaAfterNode(fixes, fixer, context.sourceCode, valueSpecifiers[valueSpecifiers.length - 1]);
+                                }
+                                else if (defaultSpecifier) {
+                                    // import Default, { type Type } from 'mod';
+                                    // remove the entire curly block so we don't leave an empty one behind
+                                    // NOTE - the default specifier *must* be the first specifier always!
+                                    //        so a comma exists that we also have to clean up or else it's bad syntax
+                                    const comma = context.sourceCode.getTokenAfter(defaultSpecifier, isComma);
+                                    const closingBrace = context.sourceCode.getTokenAfter(node.specifiers[node.specifiers.length - 1], (token) => token.type === 'Punctuator' && token.value === '}');
+                                    if (comma && closingBrace) {
+                                        fixes.push(fixer.removeRange([
+                                            comma.range[0],
+                                            closingBrace.range[1],
+                                        ]));
+                                    }
+                                }
+                                // insert the new imports after the old declaration
+                                return fixes.concat(fixer.insertTextAfter(node, `\n${newImports}`));
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+/**
+ * Check if the given token is a comma
+ *
+ * @param token - The token to check
+ */
+function isComma(token) {
+    return token.type === 'Punctuator' && token.value === ',';
+}
+/**
+ * Remove the given specifiers from the import declaration, along with any trailing commas if necessary.
+ *
+ * @param fixes - The array to which the generated fixes will be added
+ * @param fixer - The fixer object used to create the fixes
+ * @param sourceCode - The source code object used to analyze the code and find tokens
+ * @param specifiers - The specifiers to remove from the import declaration
+ */
+function removeSpecifiers(fixes, fixer, sourceCode, specifiers) {
+    for (const specifier of specifiers) {
+        removeCommaAfterNode(fixes, fixer, sourceCode, specifier);
+        fixes.push(fixer.remove(specifier));
+    }
+}
+/**
+ * Remove the trailing comma
+ *
+ * @param fixes - The array to which the generated fixes will be added
+ * @param fixer - The fixer object used to create the fixes
+ * @param sourceCode - The source code object used to analyze the code and find tokens
+ * @param node - The node after which to check for a comma and remove it if exists
+ */
+function removeCommaAfterNode(fixes, fixer, sourceCode, node) {
+    const token = sourceCode.getTokenAfter(node);
+    if (token && isComma(token)) {
+        const nextToken = sourceCode.getTokenAfter(token);
+        // get the empty space to remove double whitespace after removing the comma
+        const emptySpace = sourceCode.text
+            .slice(token.range[1], nextToken?.range[0] ?? token.range[1])
+            .match(/^[ \t]*[\n\r]*/)?.[0] ?? '';
+        if (emptySpace) {
+            fixes.push(fixer.removeRange([token.range[0], token.range[1] + emptySpace.length]));
+        }
+        else {
+            fixes.push(fixer.remove(token));
+        }
+    }
+}
+/**
+ * Get the text for a new top-level type-only import based on the given inline type specifiers.
+ *
+ * @param node - The original import declaration node containing the inline type specifiers
+ * @param sourceCode - The source code object used to analyze the code and find tokens
+ * @param specifiers - The inline type specifiers for which to generate the new import text
+ */
+function getImportText(node, sourceCode, specifiers) {
+    const sourceString = sourceCode.getText(node.source);
+    if (specifiers.length === 0) {
+        return '';
+    }
+    const names = specifiers.map((s) => {
+        const name = 'name' in s.imported ? s.imported.name : s.imported.value;
+        if (name === s.local.name) {
+            return name;
+        }
+        return `${name} as ${s.local.name}`;
+    });
+    // insert a fresh top-level import
+    return `import type {${names.join(', ')}} from ${sourceString};`;
+}

package/dist/plugins/import-extensions/rules/index.d.ts

@@ -3,5 +3,6 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 export declare const rules: {
+    'ban-inline-type-imports': import("eslint").Rule.RuleModule;
     extensions: import("eslint").Rule.RuleModule;
 };

package/dist/plugins/import-extensions/rules/index.js

@@ -2,7 +2,9 @@
  * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
+import { rule as banInlineTypeImports } from "./ban-inline-type-imports.js";
 import { rule as extensions } from "./extensions.js";
 export const rules = {
+    'ban-inline-type-imports': banInlineTypeImports,
     extensions,
 };

package/dist/plugins/nextcloud/rules/no-deprecated-library-exports.js

@@ -26,7 +26,11 @@ const rule = {
         const versionSatisfies = createLibVersionValidator(context);
         const isVersionValidForDist = versionSatisfies('8.23.0');
         const oldPattern = '@nextcloud/vue/dist/([^/]+)/([^/.]+)';
-        const mixinPattern = '@nextcloud/vue/mixins/([^/.]+)';
+        // Matches both the legacy `dist/Mixins/*` path and a bare `mixins/*` path.
+        // There is no clean `@nextcloud/vue/mixins/*` subpath export (only components,
+        // composables, directives and functions), so mixins must be migrated to
+        // composables rather than have their import path rewritten.
+        const mixinPattern = '@nextcloud/vue/(?:dist/)?mixins/([^/.]+)';
         const isVersionValidForTooltip = versionSatisfies('8.25.0');
         const tooltipPattern = '@nextcloud/vue/directives/Tooltip';
         const isVersionValidForNcSettingsInputText = versionSatisfies('8.31.0');
@@ -73,6 +77,10 @@ const rule = {
                         context.report({ node, messageId: 'outdatedVueLibrary' });
                         return;
                     }
+                    // Mixins removed in v9 and already reported as `deprecatedMixin`
+                    if (match[1].toLowerCase() === 'mixins') {
+                        return;
+                    }
                     const newImportPath = `'@nextcloud/vue/${match[1].toLowerCase()}/${match[2]}'`;
                     context.report({
                         node,

package/dist/plugins/nextcloud/rules/no-deprecated-library-props.js

@@ -4,6 +4,37 @@
  */
 import { createLibVersionValidator } from "../utils/lib-version-parser.js";
 import { defineTemplateBodyVisitor } from "../utils/vue-template-visitor.js";
+/*
+ * Deprecated props can be authored in either kebab-case or camelCase:
+ * - camelCase is forced by `vue/attribute-hyphenation: never` shipped rule;
+ * - kebab-case might come from legacy code and other presets.
+ * A single `VAttribute` visitor normalizes the raw attribute name with `toCamelCase()`
+ * and dispatches to the handler registered under the canonical camelCase name.
+ */
+/**
+ * Convert an attribute name to camelCase, matching Vue's own prop normalization,
+ * so a template attribute written in either casing maps to a single canonical name.
+ *
+ * @param name - the raw attribute name as written in the template
+ */
+const toCamelCase = (name) => name.replace(/-(\w)/g, (_, char) => char.toUpperCase());
+/**
+ * Resolve the raw (case-preserving) name of a template attribute: the argument
+ * for a directive binding (`:foo` / `v-model:foo`), or the key otherwise.
+ * Returns `undefined` when there is no static name (e.g. a dynamic argument).
+ *
+ * Must use `rawName`, not `name`: Vue lowercases `name` in the AST (`focusTrap`
+ * becomes `focustrap`), which `toCamelCase()` cannot restore, so it would no
+ * longer match the camelCase handler key. `rawName` keeps the original casing.
+ *
+ * @param node - the attribute or directive node
+ */
+function getRawName(node) {
+    if (node.key.type === 'VDirectiveKey') {
+        return node.key.argument?.type === 'VIdentifier' ? node.key.argument.rawName : undefined;
+    }
+    return node.key.rawName;
+}
 export default {
     meta: {
         docs: {
@@ -28,7 +59,7 @@ export default {
             useNoFocusTrapInstead: 'Using `focus-trap` is deprecated - use `no-focus-trap` instead',
             useKeepOpenInstead: 'Using `close-on-select` is deprecated - use `keep-open` instead',
             useNcSelectUsersInstead: 'Using `user-select` is deprecated - use `NcSelectUsers` component instead',
-            useArrowEndInstead: 'Using `arrow-right` is deprecated - use `arrow-end` instead',
+            useArrowEndInstead: 'Using `arrowRight` as `trailing-button-icon` value is deprecated - use `arrowEnd` instead',
             removeAriaHidden: 'Using `aria-hidden` is deprecated - remove prop from components, otherwise root element will inherit incorrect attribute.',
             removeLimitWidth: 'Using `limit-width` is deprecated - remove prop from components, otherwise root element will inherit incorrect attribute.',
             removeExact: 'Using `exact` is deprecated - consult Vue Router documentation for alternatives.',
@@ -48,7 +79,7 @@ export default {
         const isDateTimePickerFormatValid = versionSatisfies('8.25.0'); // #6738
         const isNcSelectKeepOpenValid = versionSatisfies('8.25.0'); // #6791
         const isNcPopoverNoFocusTrapValid = versionSatisfies('8.26.0'); // #6808
-        const isNcSelectUsersValid = versionSatisfies('8.27.1'); // #7032
+        const isNcSelectUsersValid = versionSatisfies('8.25.0'); // #6791
         const isNcTextFieldArrowEndValid = versionSatisfies('8.28.0'); // #7002
         const isCloseButtonOutsideValid = versionSatisfies('8.32.0'); // #7553
         const legacyTypes = [
@@ -60,8 +91,13 @@ export default {
             'tertiary',
             'tertiary-no-background',
         ];
-        return defineTemplateBodyVisitor(context, {
-            'VElement VAttribute:has(VIdentifier[name="type"])': function (node) {
+        /*
+         * Deprecated prop handlers keyed by their canonical camelCase name. Each
+         * handler receives the matched attribute node and verifies the owning
+         * component and installed library version itself.
+         */
+        const handlers = {
+            type: function (node) {
                 if (![
                     'ncactions',
                     'ncappnavigationnew',
@@ -75,8 +111,10 @@ export default {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
                 }
-                const hasNativeType = node.parent.attributes.find((attr) => (attr.key.name === 'native-type'
-                    || (attr.key.type === 'VDirectiveKey' && attr.key.argument && attr.key.argument.type === 'VIdentifier' && attr.key.argument.name === 'native-type')));
+                const hasNativeType = node.parent.attributes.some((attr) => {
+                    const rawName = getRawName(attr);
+                    return rawName !== undefined && toCamelCase(rawName) === 'nativeType';
+                });
                 const isLiteral = node.value.type === 'VLiteral' && legacyTypes.includes(node.value.value);
                 const isExpression = node.value.type === 'VExpressionContainer'
                     && node.value.expression.type === 'ConditionalExpression'
@@ -102,7 +140,7 @@ export default {
                     });
                 }
             },
-            'VElement VAttribute:has(VIdentifier[name="native-type"])': function (node) {
+            nativeType: function (node) {
                 if (![
                     'ncbutton',
                     'ncdialogbutton',
@@ -126,7 +164,7 @@ export default {
                     },
                 });
             },
-            'VElement VAttribute:has(VIdentifier[name="aria-hidden"])': function (node) {
+            ariaHidden: function (node) {
                 if (node.parent.parent.name.startsWith('ncaction')
                     || node.parent.parent.name === 'ncbutton') {
                     if (!isAriaHiddenValid) {
@@ -139,7 +177,10 @@ export default {
                     });
                 }
             },
-            'VElement[name="ncappcontent"] VAttribute:has(VIdentifier[name="allow-swipe-navigation"])': function (node) {
+            allowSwipeNavigation: function (node) {
+                if (node.parent.parent.name !== 'ncappcontent') {
+                    return;
+                }
                 if (!isDisableSwipeValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -149,7 +190,10 @@ export default {
                     messageId: 'useDisableSwipeForNavInstead',
                 });
             },
-            'VElement[name="ncavatar"] VAttribute:has(VIdentifier[name="show-user-status"])': function (node) {
+            showUserStatus: function (node) {
+                if (node.parent.parent.name !== 'ncavatar') {
+                    return;
+                }
                 if (!isDefaultBooleanFalseValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -159,7 +203,10 @@ export default {
                     messageId: 'useHideStatusInstead',
                 });
             },
-            'VElement[name="ncavatar"] VAttribute:has(VIdentifier[name="show-user-status-compact"])': function (node) {
+            showUserStatusCompact: function (node) {
+                if (node.parent.parent.name !== 'ncavatar') {
+                    return;
+                }
                 if (!isDefaultBooleanFalseValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -169,7 +216,10 @@ export default {
                     messageId: 'useVerboseStatusInstead',
                 });
             },
-            'VElement[name="ncavatar"] VAttribute:has(VIdentifier[name="allow-placeholder"])': function (node) {
+            allowPlaceholder: function (node) {
+                if (node.parent.parent.name !== 'ncavatar') {
+                    return;
+                }
                 if (!isDefaultBooleanFalseValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -179,7 +229,10 @@ export default {
                     messageId: 'useNoPlaceholderInstead',
                 });
             },
-            'VElement[name="ncdatetimepicker"] VAttribute:has(VIdentifier[name="formatter"])': function (node) {
+            formatter: function (node) {
+                if (node.parent.parent.name !== 'ncdatetimepicker') {
+                    return;
+                }
                 if (!isDateTimePickerFormatValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -189,7 +242,10 @@ export default {
                     messageId: 'useFormatInstead',
                 });
             },
-            'VElement[name="ncdatetimepicker"] VAttribute:has(VIdentifier[name="lang"])': function (node) {
+            lang: function (node) {
+                if (node.parent.parent.name !== 'ncdatetimepicker') {
+                    return;
+                }
                 if (!isVue3Valid) {
                     // Do not throw for v8.X.X
                     return;
@@ -199,7 +255,10 @@ export default {
                     messageId: 'useLocaleInstead',
                 });
             },
-            'VElement[name="ncdatetimepicker"] VAttribute:has(VIdentifier[name="range"])': function (node) {
+            range: function (node) {
+                if (node.parent.parent.name !== 'ncdatetimepicker') {
+                    return;
+                }
                 if (!isDateTimePickerFormatValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -209,7 +268,7 @@ export default {
                     messageId: 'useTypeDateRangeInstead',
                 });
             },
-            'VElement VAttribute:has(VIdentifier[name="can-close"])': function (node) {
+            canClose: function (node) {
                 if (![
                     'ncdialog',
                     'ncmodal',
@@ -225,7 +284,10 @@ export default {
                     messageId: 'useNoCloseInstead',
                 });
             },
-            'VElement[name="ncpopover"] VAttribute:has(VIdentifier[name="close-on-click-outside"])': function (node) {
+            closeOnClickOutside: function (node) {
+                if (node.parent.parent.name !== 'ncpopover') {
+                    return;
+                }
                 if (!isVue3Valid) {
                     // Do not throw for v8.X.X
                     return;
@@ -235,7 +297,10 @@ export default {
                     messageId: 'useNoCloseOnClickOutsideInstead',
                 });
             },
-            'VElement[name="ncmodal"] VAttribute:has(VIdentifier[name="enable-swipe"])': function (node) {
+            enableSwipe: function (node) {
+                if (node.parent.parent.name !== 'ncmodal') {
+                    return;
+                }
                 if (!isDisableSwipeValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -245,7 +310,10 @@ export default {
                     messageId: 'useDisableSwipeForModalInstead',
                 });
             },
-            'VElement[name="ncmodal"] VAttribute:has(VIdentifier[name="close-button-contained"])': function (node) {
+            closeButtonContained: function (node) {
+                if (node.parent.parent.name !== 'ncmodal') {
+                    return;
+                }
                 if (!isCloseButtonOutsideValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -255,7 +323,10 @@ export default {
                     messageId: 'useCloseButtonOutsideInstead',
                 });
             },
-            'VElement[name="ncpopover"] VAttribute:has(VIdentifier[name="focus-trap"])': function (node) {
+            focusTrap: function (node) {
+                if (node.parent.parent.name !== 'ncpopover') {
+                    return;
+                }
                 if (!isNcPopoverNoFocusTrapValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -265,7 +336,10 @@ export default {
                     messageId: 'useNoFocusTrapInstead',
                 });
             },
-            'VElement[name="ncselect"] VAttribute:has(VIdentifier[name="close-on-select"])': function (node) {
+            closeOnSelect: function (node) {
+                if (node.parent.parent.name !== 'ncselect') {
+                    return;
+                }
                 if (!isNcSelectKeepOpenValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -275,7 +349,10 @@ export default {
                     messageId: 'useKeepOpenInstead',
                 });
             },
-            'VElement[name="ncselect"] VAttribute:has(VIdentifier[name="user-select"])': function (node) {
+            userSelect: function (node) {
+                if (node.parent.parent.name !== 'ncselect') {
+                    return;
+                }
                 if (!isNcSelectUsersValid) {
                     context.report({ node, messageId: 'outdatedVueLibrary' });
                     return;
@@ -285,7 +362,7 @@ export default {
                     messageId: 'useNcSelectUsersInstead',
                 });
             },
-            'VElement VAttribute:has(VIdentifier[name="trailing-button-icon"])': function (node) {
+            trailingButtonIcon: function (node) {
                 if (node.parent.parent.name !== 'nctextfield') {
                     return;
                 }
@@ -320,14 +397,17 @@ export default {
                     });
                 }
             },
-            'VElement[name="ncsettingssection"] VAttribute:has(VIdentifier[name="limit-width"])': function (node) {
-                // This was deprecated in 8.13.0 (Nextcloud 30+), before first supported version by plugin
+            limitWidth: function (node) {
+                if (node.parent.parent.name !== 'ncsettingssection') {
+                    return;
+                }
+                // This was deprecated in 8.12.0 (Nextcloud 30+), before first supported version by plugin
                 context.report({
                     node,
                     messageId: 'removeLimitWidth',
                 });
             },
-            'VElement VAttribute:has(VIdentifier[name="exact"])': function (node) {
+            exact: function (node) {
                 if (![
                     'ncactionrouter',
                     'ncappnavigationitem',
@@ -346,7 +426,7 @@ export default {
                     messageId: 'removeExact',
                 });
             },
-            'VElement VAttribute:has(VIdentifier[name="checked"])': function (node) {
+            checked: function (node) {
                 if (![
                     'ncactioncheckbox',
                     'ncactionradio',
@@ -379,7 +459,7 @@ export default {
                     },
                 });
             },
-            'VElement VAttribute:has(VIdentifier[name="value"])': function (node) {
+            value: function (node) {
                 if (![
                     'ncactioninput',
                     'ncactiontexteditable',
@@ -424,6 +504,15 @@ export default {
                     },
                 });
             },
+        };
+        return defineTemplateBodyVisitor(context, {
+            VAttribute(node) {
+                const rawName = getRawName(node);
+                if (rawName === undefined) {
+                    return;
+                }
+                handlers[toCamelCase(rawName)]?.(node);
+            },
         });
     },
 };

package/dist/plugins/nextcloud/utils/lib-version-parser.d.ts

@@ -5,13 +5,12 @@
  * @param options Options
  * @param options.cwd The current working directory
  * @param options.physicalFilename The real filename where ESLint is linting currently
- * @param importResolve Optional custom import resolver function (for testing purposes)
  * @return Function validator, return a boolean whether current version satisfies minimal required for the rule
  */
 export declare function createLibVersionValidator({ cwd, physicalFilename }: {
-    cwd: any;
-    physicalFilename: any;
-}, importResolve?: (specifier: string, parent?: string | import("node:url").URL) => string): ((version: string) => boolean);
+    cwd: string;
+    physicalFilename: string;
+}): ((version: string) => boolean);
 /**
  * Clear the module cache
  */

package/dist/plugins/nextcloud/utils/lib-version-parser.js

@@ -3,8 +3,9 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { readFileSync } from 'node:fs';
-import { isAbsolute, join, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { findPackageJSON } from 'node:module';
+import { isAbsolute, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { gte } from 'semver';
 /**
  * Cached map of paths: Reco <path_to_package.json, validator>
@@ -17,29 +18,29 @@ const cachedMap = new Map();
  * @param options Options
  * @param options.cwd The current working directory
  * @param options.physicalFilename The real filename where ESLint is linting currently
- * @param importResolve Optional custom import resolver function (for testing purposes)
  * @return Function validator, return a boolean whether current version satisfies minimal required for the rule
  */
-export function createLibVersionValidator({ cwd, physicalFilename }, importResolve = import.meta.resolve) {
+export function createLibVersionValidator({ cwd, physicalFilename }) {
     // Try to find package.json of the nextcloud-vue package
     const sourceFile = isAbsolute(physicalFilename)
         ? resolve(physicalFilename)
         : resolve(cwd, physicalFilename);
-    let packageJsonDir;
+    let packageJsonPath;
     try {
-        const modulePath = fileURLToPath(importResolve('@nextcloud/vue', pathToFileURL(sourceFile)));
-        const idx = modulePath.lastIndexOf('/dist/');
-        packageJsonDir = modulePath.substring(0, idx);
+        packageJsonPath = findPackageJSON('@nextcloud/vue', pathToFileURL(sourceFile));
     }
     catch {
+        packageJsonPath = undefined;
+    }
+    if (!packageJsonPath) {
         return () => false;
     }
-    if (!cachedMap[packageJsonDir]) {
-        const json = JSON.parse(readFileSync(join(packageJsonDir, 'package.json'), 'utf-8'));
+    if (!cachedMap.has(packageJsonPath)) {
+        const json = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
         const libVersion = json.version;
-        cachedMap[packageJsonDir] = (version) => gte(libVersion, version);
+        cachedMap.set(packageJsonPath, (version) => gte(libVersion, version));
     }
-    return cachedMap[packageJsonDir];
+    return cachedMap.get(packageJsonPath);
 }
 /**
  * Clear the module cache

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextcloud/eslint-config",
-  "version": "9.0.0-rc.9",
+  "version": "9.0.1",
   "description": "Eslint shared config for nextcloud apps and libraries",
   "keywords": [
     "eslint",
@@ -44,31 +44,31 @@
   },
   "dependencies": {
     "@eslint/js": "^10.0.1",
-    "@eslint/json": "^1.2.0",
+    "@eslint/json": "^2.0.0",
     "@stylistic/eslint-plugin": "^5.10.0",
     "eslint-config-flat-gitignore": "^2.3.0",
-    "eslint-plugin-antfu": "^3.2.2",
-    "eslint-plugin-jsdoc": "^62.9.0",
-    "eslint-plugin-perfectionist": "^5.8.0",
-    "eslint-plugin-vue": "^10.8.0",
-    "fast-xml-parser": "^5.5.10",
-    "globals": "^17.4.0",
-    "semver": "^7.7.4",
-    "sort-package-json": "^3.6.1",
-    "typescript-eslint": "^8.58.0"
+    "eslint-plugin-antfu": "^3.2.3",
+    "eslint-plugin-jsdoc": "^63.0.10",
+    "eslint-plugin-perfectionist": "^5.9.1",
+    "eslint-plugin-vue": "^10.9.2",
+    "fast-xml-parser": "^5.9.3",
+    "globals": "^17.7.0",
+    "semver": "^7.8.5",
+    "sort-package-json": "^4.0.0",
+    "typescript-eslint": "^8.62.1"
   },
   "devDependencies": {
-    "@types/node": "^25.5.2",
+    "@types/node": "^26.0.1",
     "@types/semver": "^7.7.1",
-    "eslint": "^10.2.0",
-    "memfs": "^4.57.1",
-    "vitest": "^4.1.3"
+    "eslint": "^10.6.0",
+    "memfs": "^4.57.8",
+    "vitest": "^4.1.9"
   },
   "peerDependencies": {
     "eslint": ">=10"
   },
   "engines": {
-    "node": "^20.19 || ^22.13 || ^24"
+    "node": "^22.14 || ^24 || >=26"
   },
   "devEngines": {
     "packageManager": [