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

package/CHANGELOG.md

@@ -4,7 +4,7 @@
 -->	
 # Changelog
 
-## [v9.0.0](https://github.com/nextcloud-libraries/eslint-config/tree/v9.0.0) (unreleased)
+## [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.
@@ -44,6 +44,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 +82,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 +91,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 +106,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextcloud/eslint-config",
-  "version": "9.0.0-rc.9",
+  "version": "9.0.0",
   "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.7",
+    "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.0"
   },
   "devDependencies": {
-    "@types/node": "^25.5.2",
+    "@types/node": "^26.0.0",
     "@types/semver": "^7.7.1",
-    "eslint": "^10.2.0",
-    "memfs": "^4.57.1",
-    "vitest": "^4.1.3"
+    "eslint": "^10.5.0",
+    "memfs": "^4.57.8",
+    "vitest": "^4.1.9"
   },
   "peerDependencies": {
     "eslint": ">=10"
   },
   "engines": {
-    "node": "^20.19 || ^22.13 || ^24"
+    "node": "^22.13 || ^24 || >=26"
   },
   "devEngines": {
     "packageManager": [