@nextcloud/eslint-config 9.0.0-rc.0 → 9.0.0-rc.2

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

@@ -0,0 +1,61 @@
+import * as vueUtils from 'eslint-plugin-vue/lib/utils/index.js';
+export default {
+    meta: {
+        docs: {
+            description: 'Deprecated `@nextcloud/vue` properties',
+        },
+        type: 'problem',
+        fixable: 'code',
+        messages: {
+            useTypeInstead: 'Using `native-type` for button variant is deprecated - use `type` instead.',
+            useVariantInstead: 'Using `type` for button variant is deprecated - use `variant` instead.',
+        },
+    },
+    create(context) {
+        const legacyTypes = ['primary', 'error', 'warning', 'success', 'secondary', 'tertiary', 'tertiary-no-background'];
+        return vueUtils.defineTemplateBodyVisitor(context, {
+            'VElement[name="ncbutton"] VAttribute:has(VIdentifier[name="type"])': function (node) {
+                const hasNativeType = node.parent.attributes.find((attr) => (attr.key.name === 'native-type'
+                    || (attr.key.type === 'VDirectiveKey' && attr.key.argument && attr.key.argument.name === 'native-type')));
+                const isLiteral = node.value.type === 'VLiteral' && legacyTypes.includes(node.value.value);
+                const isExpression = node.value.type === 'VExpressionContainer'
+                    && node.value.expression.type === 'ConditionalExpression'
+                    && (legacyTypes.includes(node.value.expression.consequent.value)
+                        || legacyTypes.includes(node.value.expression.alternate.value));
+                /**
+                 * if it is a literal with a deprecated value -> we migrate
+                 * if it is an expression with a defined deprecated value -> we migrate
+                 * if it is unknown value (e.g. computed), but there is also the `native-type` we assume it is legacy and we migrate
+                 */
+                if (isLiteral || isExpression || hasNativeType) {
+                    context.report({
+                        node,
+                        messageId: 'useVariantInstead',
+                        fix: (fixer) => {
+                            if (node.key.type === 'VIdentifier') {
+                                return fixer.replaceTextRange(node.key.range, 'variant');
+                            }
+                            else if (node.key.type === 'VDirectiveKey') {
+                                return fixer.replaceTextRange(node.key.argument.range, 'variant');
+                            }
+                        },
+                    });
+                }
+            },
+            'VElement[name="ncbutton"] VAttribute:has(VIdentifier[name="native-type"])': function (node) {
+                context.report({
+                    node,
+                    messageId: 'useTypeInstead',
+                    fix: (fixer) => {
+                        if (node.key.type === 'VIdentifier') {
+                            return fixer.replaceTextRange(node.key.range, 'type');
+                        }
+                        else if (node.key.type === 'VDirectiveKey') {
+                            return fixer.replaceTextRange(node.key.argument.range, 'type');
+                        }
+                    },
+                });
+            },
+        });
+    },
+};

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

@@ -0,0 +1,33 @@
+/**
+ * Check if a given path exists and is a file
+ *
+ * @param filePath The path
+ */
+export declare function isFile(filePath: string): boolean;
+/**
+ * Find the path of nearest `package.json` relative to given path
+ *
+ * @param currentPath Path to lookup
+ * @return Either the full path where `package.json` is located or `undefined` if no found
+ */
+export declare function findPackageJsonDir(currentPath: string): string | undefined;
+/**
+ * Make sure that versions like '25' can be handled by semver
+ *
+ * @param version The pure version string
+ * @return Sanitized version string
+ */
+export declare function sanitizeTargetVersion(version: string): string;
+/**
+ * Create a callback that takes a version number and checks if the version
+ * is valid compared to configured version / detected version.
+ *
+ * @param options Options
+ * @param options.cwd The current working directory
+ * @param options.physicalFilename The real filename where ESLint is linting currently
+ * @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;
+}): ((version: string) => boolean);

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

@@ -0,0 +1,94 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { lstatSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
+import { gte, minVersion, valid } from 'semver';
+/**
+ * Cached map of paths: Reco <path_to_package.json, validator>
+ */
+const cachedMap = {};
+/**
+ * Check if a given path exists and is a file
+ *
+ * @param filePath The path
+ */
+export function isFile(filePath) {
+    const stats = lstatSync(filePath, { throwIfNoEntry: false });
+    return stats !== undefined && stats.isFile();
+}
+/**
+ * Find the path of nearest `package.json` relative to given path
+ *
+ * @param currentPath Path to lookup
+ * @return Either the full path where `package.json` is located or `undefined` if no found
+ */
+export function findPackageJsonDir(currentPath) {
+    for (const cachedDirPath of Object.keys(cachedMap)) {
+        if (currentPath.startsWith(cachedDirPath)) {
+            return cachedDirPath;
+        }
+    }
+    while (currentPath && currentPath !== sep) {
+        if (isFile(join(currentPath, 'package.json'))) {
+            return currentPath;
+        }
+        currentPath = resolve(currentPath, '..');
+    }
+    return undefined;
+}
+/**
+ * Make sure that versions like '25' can be handled by semver
+ *
+ * @param version The pure version string
+ * @return Sanitized version string
+ */
+export function sanitizeTargetVersion(version) {
+    const sanitizedVersion = minVersion(version)?.version;
+    // now version should look like '23.0.0'
+    if (!valid(sanitizedVersion)) {
+        throw Error(`[@nextcloud/eslint-plugin] Invalid target version ${version} found`);
+    }
+    return sanitizedVersion;
+}
+/**
+ * Create a callback that takes a version number and checks if the version
+ * is valid compared to configured version / detected version.
+ *
+ * @param options Options
+ * @param options.cwd The current working directory
+ * @param options.physicalFilename The real filename where ESLint is linting currently
+ * @return Function validator, return a boolean whether current version satisfies minimal required for the rule
+ */
+export function createLibVersionValidator({ cwd, physicalFilename }) {
+    // Try to find package.json and parse the supported version
+    // Current working directory, either the filename (can be empty) or the cwd property
+    const currentDirectory = isAbsolute(physicalFilename)
+        ? resolve(dirname(physicalFilename))
+        : dirname(resolve(cwd, physicalFilename));
+    // The nearest package.json
+    const packageJsonDir = findPackageJsonDir(currentDirectory);
+    if (!packageJsonDir) {
+        // Skip the rule
+        return () => false;
+    }
+    else if (cachedMap[packageJsonDir]) {
+        return cachedMap[packageJsonDir];
+    }
+    const json = JSON.parse(readFileSync(join(packageJsonDir, 'package.json'), 'utf-8'));
+    const libVersions = [
+        json?.dependencies?.['@nextcloud/vue'],
+        json?.devDependencies?.['@nextcloud/vue'],
+        json?.peerDependencies?.['@nextcloud/vue'],
+    ]
+        .filter((version) => typeof version === 'string' && !!version)
+        .map(sanitizeTargetVersion)
+        .sort((a, b) => gte(a, b) ? 1 : -1);
+    if (!libVersions.length) {
+        // Skip the rule
+        return () => false;
+    }
+    // Return, whether given version satisfies minimal version from dependencies
+    return (version) => gte(libVersions[0], version);
+}

package/dist/plugins/packageJson.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import type { ESLint } from 'eslint';
+/**
+ * ESLint plugin to sort package.json files in a consistent way.
+ */
+declare const Plugin: ESLint.Plugin;
+export default Plugin;

package/dist/plugins/packageJson.js

@@ -0,0 +1,66 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import path from 'node:path';
+import sortPackageJson from 'sort-package-json';
+import { packageVersion } from "../version.js";
+const SortPackageJsonRule = {
+    meta: {
+        fixable: 'code',
+        docs: {
+            recommended: true,
+            description: 'Sort package json in consistent order',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    sortOrder: {
+                        type: 'array',
+                        minItems: 0,
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        if (path.basename(context.filename) !== 'package.json') {
+            return {};
+        }
+        const options = context.options ? context.options[0] : undefined;
+        return {
+            Document({ body }) {
+                const sourceCode = context.sourceCode.text;
+                const packageJsonText = sourceCode.slice(...body.range);
+                const sortedPackageJsonText = sortPackageJson(packageJsonText, options);
+                if (packageJsonText !== sortedPackageJsonText) {
+                    context.report({
+                        node: body,
+                        message: 'package.json is not sorted correctly',
+                        fix(fixer) {
+                            return fixer.replaceText(body, sortedPackageJsonText);
+                        },
+                    });
+                }
+            },
+        };
+    },
+};
+/**
+ * ESLint plugin to sort package.json files in a consistent way.
+ */
+const Plugin = {
+    meta: {
+        name: '@nextcloud/package-json',
+        version: packageVersion,
+    },
+    rules: {
+        'sort-package-json': SortPackageJsonRule,
+    },
+};
+export default Plugin;

package/dist/utils.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import type { Linter } from 'eslint';
+/**
+ * Restrict a set of configurations to a given glob pattern
+ *
+ * @param configs The configs to restrict
+ * @param files The glob pattern to assign
+ */
+export declare function restrictConfigFiles(configs: Linter.Config[], files: string[]): {
+    files: (string | string[])[];
+    name?: string;
+    ignores?: string[];
+    language?: string;
+    languageOptions?: Linter.LanguageOptions;
+    linterOptions?: Linter.LinterOptions;
+    processor?: string | Linter.Processor;
+    plugins?: Record<string, import("eslint").ESLint.Plugin>;
+    rules?: Partial<Linter.RulesRecord>;
+    settings?: Record<string, unknown>;
+}[];

package/dist/utils.js

@@ -0,0 +1,19 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+/**
+ * Restrict a set of configurations to a given glob pattern
+ *
+ * @param configs The configs to restrict
+ * @param files The glob pattern to assign
+ */
+export function restrictConfigFiles(configs, files) {
+    return configs.map((config) => ({
+        ...config,
+        files: [
+            ...(config.files ?? []),
+            ...files,
+        ],
+    }));
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const packageVersion: string;

package/dist/version.js

@@ -0,0 +1,6 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import packageJson from '../package.json' with { type: 'json' };
+export const packageVersion = packageJson.version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextcloud/eslint-config",
-  "version": "9.0.0-rc.0",
+  "version": "9.0.0-rc.2",
   "description": "Eslint shared config for nextcloud apps and libraries",
   "keywords": [
     "eslint",
@@ -22,7 +22,7 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "default": "./dist/index.mjs"
+      "default": "./dist/index.js"
     }
   },
   "main": "dist/index.mjs",
@@ -34,35 +34,39 @@
     "dist"
   ],
   "scripts": {
-    "build": "vite --mode production build",
-    "lint": "npm run build && eslint",
-    "lint:fix": "eslint --fix",
+    "build": "npm run build:cleanup && npm run build:source",
+    "build:cleanup": "tsc --build --clean",
+    "build:source": "tsc",
+    "lint": "npx --node-options='--experimental-strip-types' eslint --flag unstable_native_nodejs_ts_config",
+    "lint:fix": "npx --node-options='--experimental-strip-types' eslint --flag unstable_native_nodejs_ts_config --fix",
+    "prerelease:format-changelog": "node build/format-changelog.mjs",
     "test": "vitest run"
   },
   "dependencies": {
-    "@eslint/json": "^0.11.0",
-    "@stylistic/eslint-plugin": "^4.2.0",
-    "eslint-plugin-jsdoc": "^50.6.9",
-    "eslint-plugin-vue": "^10.0.0",
-    "fast-xml-parser": "^5.0.9",
-    "globals": "^16.0.0",
-    "semver": "^7.7.1",
-    "sort-package-json": "^3.0.0",
-    "typescript-eslint": "^8.28.0"
+    "@eslint/json": "^0.12.0",
+    "@stylistic/eslint-plugin": "^4.4.1",
+    "eslint-plugin-antfu": "^3.1.1",
+    "eslint-plugin-jsdoc": "^50.7.1",
+    "eslint-plugin-perfectionist": "^4.14.0",
+    "eslint-plugin-vue": "^10.1.0",
+    "fast-xml-parser": "^5.2.3",
+    "globals": "^16.2.0",
+    "semver": "^7.7.2",
+    "sort-package-json": "^3.2.1",
+    "typescript-eslint": "^8.33.1"
   },
   "devDependencies": {
-    "@nextcloud/vite-config": "^2.3.2",
-    "@types/node": "^22.13.13",
-    "eslint": "^9.23.0",
-    "memfs": "^4.17.0",
-    "vite": "^6.2.3",
-    "vitest": "^3.0.9"
+    "@types/node": "^22.15.29",
+    "@types/semver": "^7.7.0",
+    "eslint": "^9.28.0",
+    "memfs": "^4.17.2",
+    "vitest": "^3.2.1"
   },
   "peerDependencies": {
     "eslint": ">=9"
   },
   "engines": {
-    "node": "^20.9 || ^22"
+    "node": "^20.19 || ^22 || ^24"
   },
   "devEngines": {
     "packageManager": {
@@ -71,7 +75,7 @@
     },
     "runtime": {
       "name": "node",
-      "version": "^22"
+      "version": "^22.10"
     }
   }
 }