@nextcloud/eslint-config 9.0.0-rc.0 → 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/index.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import type { ESLint } from 'eslint';
+declare const _default: ESLint.Plugin;
+export default _default;

package/dist/plugins/nextcloud/index.js

@@ -0,0 +1,9 @@
+import { packageVersion } from "../../version.js";
+import { rules } from "./rules/index.js";
+export default {
+    rules,
+    meta: {
+        name: '@nextcloud/eslint-plugin',
+        version: packageVersion,
+    },
+};

package/dist/plugins/nextcloud/rules/index.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import type { Rule } from 'eslint';
+export declare const rules: Record<string, Rule.RuleModule>;

package/dist/plugins/nextcloud/rules/index.js

@@ -0,0 +1,18 @@
+/*!
+ * 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 = {
+    '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.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import type { Rule } from 'eslint';
+declare const _default: Rule.RuleModule;
+export default _default;

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/nextcloud/rules/l10n-non-breaking-space.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import type { Rule } from 'eslint';
+declare const _default: Rule.RuleModule;
+export default _default;

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

@@ -0,0 +1,39 @@
+/*!
+ * 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 non-breaking spaces before ellipsis',
+        },
+        messages: {
+            precedeWithNonbreakingSpace: 'Ellipsis must be preceded by non-breaking spaces',
+        },
+    },
+    create(context) {
+        const visitor = {
+            Literal(node) {
+                if (typeof node.value !== 'string') {
+                    return;
+                }
+                const matches = node.value.match(/(\s+)…/);
+                if (matches && matches[1] !== ' ') {
+                    context.report({
+                        node,
+                        messageId: 'precedeWithNonbreakingSpace',
+                        fix(fixer) {
+                            return fixer.replaceText(node, node.raw.replaceAll(/\s+…/g, ' …'));
+                        },
+                    });
+                }
+            },
+        };
+        return defineTemplateBodyVisitor(context, visitor, visitor);
+    },
+});

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

@@ -0,0 +1,7 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;