@nextcloud/eslint-config 9.0.0-rc.1 → 9.0.0-rc.10

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/extensions.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import type { Rule } from 'eslint';
+/**
+ * helper for unit tests
+ */
+export declare function clearCache(): void;
+export declare const rule: Rule.RuleModule;
+export default rule;

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

@@ -0,0 +1,143 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { existsSync, opendirSync, statSync } from 'fs';
+import { basename, dirname, extname, join, resolve } from 'path';
+// we use this module scope map to cache results for resolving the file extensions
+// in larger projects its likely the same files are imported so we cache "absolute resolved import without extension" -> array of possible extensions
+const fsCache = new Map();
+/**
+ * helper for unit tests
+ */
+export function clearCache() {
+    fsCache.clear();
+}
+export const rule = {
+    meta: {
+        type: 'suggestion',
+        hasSuggestions: true,
+        docs: {
+            description: 'Ensure all relative imports and exports have a file extension',
+        },
+        messages: {
+            missingExtension: 'This relative {{ type }} should have a file extension.',
+            recommendedMissingExtension: 'The relative {{ type }} should probably have the file extension "{{ extension }}".',
+            applySuggestedExtension: 'Add the "{{ extension }}" to the {{ type }}.',
+        },
+    },
+    create(context) {
+        /**
+         * @param node - The ESTree node representing the source
+         * @param isImport - is this an import or export
+         */
+        function handleImportExport(node, isImport = true) {
+            const value = String(node.value);
+            if (!value.includes('/')) {
+                return;
+            }
+            // get rid of query like ?raw
+            const [text] = value.split('?', 2);
+            if (text.match(/\.[a-z0-9]+$/i)) {
+                return;
+            }
+            const type = isImport ? 'import' : 'export';
+            // check custom paths - we cannot fix though
+            if (text.startsWith('~/')) {
+                context.report({
+                    node,
+                    messageId: 'missingExtension',
+                    data: { type },
+                });
+            }
+            if (!text.match(/^\.\.?\//)) {
+                return;
+            }
+            const contextPath = dirname(context.physicalFilename);
+            const relativePath = resolve(contextPath, text);
+            const absolutePath = resolve(context.cwd, relativePath);
+            if (!fsCache.has(absolutePath)) {
+                let resolvedPath = relativePath;
+                if (existsSync(resolvedPath)) {
+                    if (statSync(resolvedPath).isDirectory) {
+                        resolvedPath = join(resolvedPath, 'index');
+                    }
+                    else {
+                        // weird extensionless file
+                        return;
+                    }
+                }
+                const resolvedDirectoryPath = dirname(resolvedPath);
+                if (existsSync(resolvedDirectoryPath)) {
+                    const filename = basename(resolvedPath);
+                    const resolvedDir = opendirSync(resolvedDirectoryPath);
+                    const extensions = [];
+                    try {
+                        let entry;
+                        while ((entry = resolvedDir.readSync()) !== null) {
+                            const extension = extname(entry.name);
+                            if (extension && `${filename}${extension}` === entry.name) {
+                                extensions.push(extension);
+                            }
+                        }
+                    }
+                    finally {
+                        resolvedDir.close();
+                    }
+                    fsCache.set(absolutePath, extensions);
+                }
+            }
+            if (fsCache.get(absolutePath)?.length) {
+                return context.report({
+                    node,
+                    messageId: fsCache.get(absolutePath).length === 1
+                        ? 'recommendedMissingExtension'
+                        : 'missingExtension',
+                    data: {
+                        extension: fsCache.get(absolutePath)[0],
+                        type,
+                    },
+                    suggest: fsCache.get(absolutePath).map((extension) => ({
+                        messageId: 'applySuggestedExtension',
+                        data: {
+                            extension,
+                            type,
+                        },
+                        fix(fixer) {
+                            const range = [node.range[0], node.range[0] + 1 + text.length];
+                            return fixer.insertTextAfterRange(range, extension);
+                        },
+                    })),
+                });
+            }
+            // no way to fix it
+            context.report({
+                node,
+                messageId: 'missingExtension',
+                data: {
+                    type,
+                },
+            });
+        }
+        return {
+            ExportAllDeclaration(node) {
+                handleImportExport(node.source, false);
+            },
+            ExportNamedDeclaration(node) {
+                if (node.source) {
+                    handleImportExport(node.source, false);
+                }
+            },
+            ImportDeclaration(node) {
+                handleImportExport(node.source);
+            },
+            ImportExpression(node) {
+                if (node.source.type === 'Literal') {
+                    handleImportExport(node.source);
+                }
+                // we cannot handle dynamic imports here
+            },
+        };
+    },
+};
+export default rule;

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

@@ -0,0 +1,8 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * 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

@@ -0,0 +1,10 @@
+/*!
+ * 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/index.js

@@ -1,6 +1,18 @@
-import noDeprecations from "./no-deprecations.js";
-import noRemovedApis from "./no-removed-apis.js";
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import l10nEnforceEllipsis from "./l10n-enforce-ellipsis.js";
+import l10nNonBreakingSpace from "./l10n-non-breaking-space.js";
+import noDeprecatedGlobals from "./no-deprecated-globals.js";
+import noDeprecatedLibraryExports from "./no-deprecated-library-exports.js";
+import noDeprecatedLibraryProps from "./no-deprecated-library-props.js";
+import noRemovedGlobals from "./no-removed-globals.js";
 export const rules = {
-    'no-deprecations': noDeprecations,
-    'no-removed-apis': noRemovedApis,
+    'l10n-enforce-ellipsis': l10nEnforceEllipsis,
+    'l10n-non-breaking-space': l10nNonBreakingSpace,
+    'no-deprecated-globals': noDeprecatedGlobals,
+    'no-removed-globals': noRemovedGlobals,
+    'no-deprecated-library-exports': noDeprecatedLibraryExports,
+    'no-deprecated-library-props': noDeprecatedLibraryProps,
 };

package/dist/plugins/nextcloud/rules/l10n-enforce-ellipsis.js

@@ -0,0 +1,44 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { defineTemplateBodyVisitor } from "../utils/vue-template-visitor.js";
+const defineRule = (r) => r;
+export default defineRule({
+    meta: {
+        fixable: 'code',
+        type: 'suggestion',
+        schema: [],
+        docs: {
+            description: 'Enforce consistent usageof ellipsis instead of tripple dots',
+        },
+        messages: {
+            shoudUseEllipsis: 'Translated strings should use ellipsis character instead of triple dots',
+        },
+    },
+    create(context) {
+        const visitor = {
+            CallExpression(node) {
+                if (node.callee.type !== 'Identifier'
+                    || (node.callee.name !== 't' && node.callee.name !== 'n')) {
+                    return;
+                }
+                for (const argument of node.arguments) {
+                    if (argument.type !== 'Literal') {
+                        continue;
+                    }
+                    if (argument.raw?.match(/(?<=[^.])\.\.\.(?!\.)/)) {
+                        context.report({
+                            node,
+                            messageId: 'shoudUseEllipsis',
+                            fix(fixer) {
+                                return fixer.replaceText(argument, argument.raw.replaceAll(/(?<=[^.])\.\.\.(?!\.)/g, '…'));
+                            },
+                        });
+                    }
+                }
+            },
+        };
+        return defineTemplateBodyVisitor(context, visitor, visitor);
+    },
+});

package/dist/plugins/{l10n/rules/non-breaking-space.js → nextcloud/rules/l10n-non-breaking-space.js}

@@ -1,3 +1,8 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { defineTemplateBodyVisitor } from "../utils/vue-template-visitor.js";
 const defineRule = (r) => r;
 export default defineRule({
     meta: {
@@ -7,9 +12,12 @@ export default defineRule({
         docs: {
             description: 'Enforce non-breaking spaces before ellipsis',
         },
+        messages: {
+            precedeWithNonbreakingSpace: 'Ellipsis must be preceded by non-breaking spaces',
+        },
     },
     create(context) {
-        return {
+        const visitor = {
             Literal(node) {
                 if (typeof node.value !== 'string') {
                     return;
@@ -18,7 +26,7 @@ export default defineRule({
                 if (matches && matches[1] !== ' ') {
                     context.report({
                         node,
-                        message: 'Ellipsis must be preceded by non-breaking spaces',
+                        messageId: 'precedeWithNonbreakingSpace',
                         fix(fixer) {
                             return fixer.replaceText(node, node.raw.replaceAll(/\s+…/g, ' …'));
                         },
@@ -26,5 +34,6 @@ export default defineRule({
                 }
             },
         };
+        return defineTemplateBodyVisitor(context, visitor, visitor);
     },
 });

package/dist/plugins/nextcloud/rules/{no-deprecations.js → no-deprecated-globals.js}

@@ -1,4 +1,8 @@
-import { createVersionValidator } from "../utils/version-parser.js";
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createVersionValidator } from "../utils/app-version-parser.js";
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -31,15 +35,18 @@ const global = {
     relative_modified_date: '16.0.0',
 };
 const oc = {
+    AppConfig: '16.0.0',
     L10n: '26.0.0',
+    SystemTags: '32.0.0',
     _capabilities: '17.0.0',
     addTranslations: '17.0.0',
     basename: '18.0.0',
     coreApps: '17.0.0',
     currentUser: '19.0.0',
+    dialogs: '30.0.0',
     dirname: '18.0.0',
     encodePath: '18.0.0',
-    fileIsBlacklisted: '17.0.0',
+    fileIsBlacklisted: '18.0.0',
     filePath: '19.0.0',
     generateUrl: '19.0.0',
     get: '19.0.0',
@@ -71,12 +78,18 @@ const ocNested = {
         humanFileSize: '20.0.0',
         relativeModifiedDate: '20.0.0',
     },
+    dialogs: {
+        fileexists: '29.0.0',
+    },
+    config: {
+        blacklist_files_regex: '30.0.0',
+        forbidden_filename_characters: '30.0.0',
+    },
 };
 const rule = {
     meta: {
         docs: {
             description: 'Deprecated Nextcloud APIs',
-            category: 'Nextcloud',
             recommended: true,
         },
         // fixable: null or "code" or "whitespace"

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

@@ -0,0 +1,89 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createLibVersionValidator } from "../utils/lib-version-parser.js";
+/*
+ Introduced in @nextcloud/vue v8.23.0
+ https://github.com/nextcloud-libraries/nextcloud-vue/pull/6385
+ */
+const rule = {
+    meta: {
+        docs: {
+            description: 'Deprecated @nextcloud/vue import syntax',
+            recommended: true,
+        },
+        fixable: 'code',
+        messages: {
+            outdatedVueLibrary: 'Installed @nextcloud/vue library is outdated and does not support all reported errors. Install latest compatible version',
+            deprecatedDist: 'Import from "@nextcloud/vue/dist" is deprecated',
+            deprecatedMixin: 'Mixins are no longer recommended by Vue. Consider using available alternatives',
+            deprecatedNcSettingsInputText: 'NcSettingsInputText is deprecated. Consider using available alternatives',
+            deprecatedTooltip: 'Tooltip directive is deprecated. use native title attribute or NcPopover instead',
+        },
+    },
+    create(context) {
+        const versionSatisfies = createLibVersionValidator(context);
+        const isVersionValidForDist = versionSatisfies('8.23.0');
+        const oldPattern = '@nextcloud/vue/dist/([^/]+)/([^/.]+)';
+        const mixinPattern = '@nextcloud/vue/mixins/([^/.]+)';
+        const isVersionValidForTooltip = versionSatisfies('8.25.0');
+        const tooltipPattern = '@nextcloud/vue/directives/Tooltip';
+        const isVersionValidForNcSettingsInputText = versionSatisfies('8.31.0');
+        const patternForNcSettingsInputText = '@nextcloud/vue/components/NcSettingsInputText';
+        return {
+            ImportDeclaration: function (node) {
+                const importPath = node.source.value;
+                const matchForNcSettingsInputText = importPath.match(new RegExp(patternForNcSettingsInputText));
+                if (matchForNcSettingsInputText) {
+                    if (!isVersionValidForNcSettingsInputText) {
+                        context.report({ node, messageId: 'outdatedVueLibrary' });
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'deprecatedNcSettingsInputText',
+                    });
+                }
+                const mixinMatch = importPath.match(new RegExp(mixinPattern, 'i'));
+                if (mixinMatch) {
+                    if (!isVersionValidForDist) {
+                        context.report({ node, messageId: 'outdatedVueLibrary' });
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'deprecatedMixin',
+                    });
+                }
+                const tooltipMatch = importPath.match(new RegExp(tooltipPattern));
+                if (tooltipMatch) {
+                    if (!isVersionValidForTooltip) {
+                        context.report({ node, messageId: 'outdatedVueLibrary' });
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'deprecatedTooltip',
+                    });
+                }
+                const match = importPath.match(new RegExp(oldPattern));
+                if (match) {
+                    if (!isVersionValidForDist) {
+                        context.report({ node, messageId: 'outdatedVueLibrary' });
+                        return;
+                    }
+                    const newImportPath = `'@nextcloud/vue/${match[1].toLowerCase()}/${match[2]}'`;
+                    context.report({
+                        node,
+                        messageId: 'deprecatedDist',
+                        fix(fixer) {
+                            return fixer.replaceText(node.source, newImportPath);
+                        },
+                    });
+                }
+            },
+        };
+    },
+};
+export default rule;

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

@@ -0,0 +1,41 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import type { Rule } from 'eslint';
+declare const _default: {
+    meta: {
+        docs: {
+            description: string;
+        };
+        type: "problem";
+        fixable: "code";
+        messages: {
+            outdatedVueLibrary: string;
+            useTypeInstead: string;
+            useVariantInstead: string;
+            useDisableSwipeForNavInstead: string;
+            useHideStatusInstead: string;
+            useVerboseStatusInstead: string;
+            useNoPlaceholderInstead: string;
+            useFormatInstead: string;
+            useLocaleInstead: string;
+            useTypeDateRangeInstead: string;
+            useNoCloseInstead: string;
+            useNoCloseOnClickOutsideInstead: string;
+            useDisableSwipeForModalInstead: string;
+            useNoFocusTrapInstead: string;
+            useKeepOpenInstead: string;
+            useNcSelectUsersInstead: string;
+            useArrowEndInstead: string;
+            removeAriaHidden: string;
+            removeLimitWidth: string;
+            removeExact: string;
+            useCloseButtonOutsideInstead: string;
+            useModelValueInsteadChecked: string;
+            useModelValueInsteadValue: string;
+        };
+    };
+    create(context: Rule.RuleContext): Rule.RuleListener;
+};
+export default _default;