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

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

@@ -0,0 +1,429 @@
+/*!
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createLibVersionValidator } from "../utils/lib-version-parser.js";
+import { defineTemplateBodyVisitor } from "../utils/vue-template-visitor.js";
+export default {
+    meta: {
+        docs: {
+            description: 'Deprecated `@nextcloud/vue` properties',
+        },
+        type: 'problem',
+        fixable: 'code',
+        messages: {
+            outdatedVueLibrary: 'Installed @nextcloud/vue library is outdated and does not support all reported errors. Install latest compatible version',
+            useTypeInstead: 'Using `native-type` for button variant is deprecated - use `type` instead.',
+            useVariantInstead: 'Using `type` for button variant is deprecated - use `variant` instead.',
+            useDisableSwipeForNavInstead: 'Using `allow-swipe-navigation` is deprecated - use `disable-swipe` instead',
+            useHideStatusInstead: 'Using `show-user-status` is deprecated - use `hide-status` instead',
+            useVerboseStatusInstead: 'Using `show-user-status-compact` is deprecated - use `verbose-status` instead',
+            useNoPlaceholderInstead: 'Using `allow-placeholder` is deprecated - use `no-placeholder` instead',
+            useFormatInstead: 'Using `formatter` is deprecated - use `format` instead',
+            useLocaleInstead: 'Using `lang` is deprecated - use `locale` instead',
+            useTypeDateRangeInstead: 'Using `range` is deprecated - use `type` with `date-range` or `datetime-range` instead',
+            useNoCloseInstead: 'Using `can-close` is deprecated - use `no-close` instead',
+            useNoCloseOnClickOutsideInstead: 'Using `close-on-click-outside` is deprecated - use `no-close-on-click-outside` instead',
+            useDisableSwipeForModalInstead: 'Using `enable-swipe` is deprecated - use `disable-swipe` instead',
+            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',
+            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.',
+            useCloseButtonOutsideInstead: 'Using `close-button-contained` is deprecated - use `close-button-outside` instead',
+            useModelValueInsteadChecked: 'Using `checked` is deprecated - use `model-value` or `v-model` instead',
+            useModelValueInsteadValue: 'Using `value` is deprecated - use `model-value` or `v-model` instead',
+        },
+    },
+    create(context) {
+        const versionSatisfies = createLibVersionValidator(context);
+        const isVue3Valid = versionSatisfies('9.0.0'); // #6651
+        const isAriaHiddenValid = versionSatisfies('8.2.0'); // #4835
+        const isModelValueValid = versionSatisfies('8.20.0'); // #6172
+        const isDisableSwipeValid = versionSatisfies('8.23.0'); // #6452
+        const isVariantTypeValid = versionSatisfies('8.24.0'); // #6472
+        const isDefaultBooleanFalseValid = versionSatisfies('8.24.0'); // #6656
+        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 isNcTextFieldArrowEndValid = versionSatisfies('8.28.0'); // #7002
+        const isCloseButtonOutsideValid = versionSatisfies('8.32.0'); // #7553
+        const legacyTypes = [
+            'primary',
+            'error',
+            'warning',
+            'success',
+            'secondary',
+            'tertiary',
+            'tertiary-no-background',
+        ];
+        return defineTemplateBodyVisitor(context, {
+            'VElement VAttribute:has(VIdentifier[name="type"])': function (node) {
+                if (![
+                    'ncactions',
+                    'ncappnavigationnew',
+                    'ncbutton',
+                    'ncchip',
+                    'ncdialogbutton',
+                ].includes(node.parent.parent.name)) {
+                    return;
+                }
+                if (!isVariantTypeValid) {
+                    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 isLiteral = node.value.type === 'VLiteral' && legacyTypes.includes(node.value.value);
+                const isExpression = node.value.type === 'VExpressionContainer'
+                    && node.value.expression.type === 'ConditionalExpression'
+                    && (('value' in node.value.expression.consequent && legacyTypes.includes(node.value.expression.consequent.value.toString()))
+                        || ('value' in node.value.expression.alternate && legacyTypes.includes(node.value.expression.alternate.value.toString())));
+                /**
+                 * 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 VAttribute:has(VIdentifier[name="native-type"])': function (node) {
+                if (![
+                    'ncbutton',
+                    'ncdialogbutton',
+                ].includes(node.parent.parent.name)) {
+                    return;
+                }
+                if (!isVariantTypeValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                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');
+                        }
+                    },
+                });
+            },
+            'VElement VAttribute:has(VIdentifier[name="aria-hidden"])': function (node) {
+                if (node.parent.parent.name.startsWith('ncaction')
+                    || node.parent.parent.name === 'ncbutton') {
+                    if (!isAriaHiddenValid) {
+                        context.report({ node, messageId: 'outdatedVueLibrary' });
+                        return;
+                    }
+                    context.report({
+                        node,
+                        messageId: 'removeAriaHidden',
+                    });
+                }
+            },
+            'VElement[name="ncappcontent"] VAttribute:has(VIdentifier[name="allow-swipe-navigation"])': function (node) {
+                if (!isDisableSwipeValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useDisableSwipeForNavInstead',
+                });
+            },
+            'VElement[name="ncavatar"] VAttribute:has(VIdentifier[name="show-user-status"])': function (node) {
+                if (!isDefaultBooleanFalseValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useHideStatusInstead',
+                });
+            },
+            'VElement[name="ncavatar"] VAttribute:has(VIdentifier[name="show-user-status-compact"])': function (node) {
+                if (!isDefaultBooleanFalseValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useVerboseStatusInstead',
+                });
+            },
+            'VElement[name="ncavatar"] VAttribute:has(VIdentifier[name="allow-placeholder"])': function (node) {
+                if (!isDefaultBooleanFalseValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useNoPlaceholderInstead',
+                });
+            },
+            'VElement[name="ncdatetimepicker"] VAttribute:has(VIdentifier[name="formatter"])': function (node) {
+                if (!isDateTimePickerFormatValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useFormatInstead',
+                });
+            },
+            'VElement[name="ncdatetimepicker"] VAttribute:has(VIdentifier[name="lang"])': function (node) {
+                if (!isVue3Valid) {
+                    // Do not throw for v8.X.X
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useLocaleInstead',
+                });
+            },
+            'VElement[name="ncdatetimepicker"] VAttribute:has(VIdentifier[name="range"])': function (node) {
+                if (!isDateTimePickerFormatValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useTypeDateRangeInstead',
+                });
+            },
+            'VElement VAttribute:has(VIdentifier[name="can-close"])': function (node) {
+                if (![
+                    'ncdialog',
+                    'ncmodal',
+                ].includes(node.parent.parent.name)) {
+                    return;
+                }
+                if (!isDefaultBooleanFalseValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useNoCloseInstead',
+                });
+            },
+            'VElement[name="ncpopover"] VAttribute:has(VIdentifier[name="close-on-click-outside"])': function (node) {
+                if (!isVue3Valid) {
+                    // Do not throw for v8.X.X
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useNoCloseOnClickOutsideInstead',
+                });
+            },
+            'VElement[name="ncmodal"] VAttribute:has(VIdentifier[name="enable-swipe"])': function (node) {
+                if (!isDisableSwipeValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useDisableSwipeForModalInstead',
+                });
+            },
+            'VElement[name="ncmodal"] VAttribute:has(VIdentifier[name="close-button-contained"])': function (node) {
+                if (!isCloseButtonOutsideValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useCloseButtonOutsideInstead',
+                });
+            },
+            'VElement[name="ncpopover"] VAttribute:has(VIdentifier[name="focus-trap"])': function (node) {
+                if (!isNcPopoverNoFocusTrapValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useNoFocusTrapInstead',
+                });
+            },
+            'VElement[name="ncselect"] VAttribute:has(VIdentifier[name="close-on-select"])': function (node) {
+                if (!isNcSelectKeepOpenValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useKeepOpenInstead',
+                });
+            },
+            'VElement[name="ncselect"] VAttribute:has(VIdentifier[name="user-select"])': function (node) {
+                if (!isNcSelectUsersValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useNcSelectUsersInstead',
+                });
+            },
+            'VElement VAttribute:has(VIdentifier[name="trailing-button-icon"])': function (node) {
+                if (node.parent.parent.name !== 'nctextfield') {
+                    return;
+                }
+                if (!isNcTextFieldArrowEndValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                const isLiteral = node.value.type === 'VLiteral' && node.value.value === 'arrowRight';
+                const isExpression = node.value.type === 'VExpressionContainer'
+                    && node.value.expression?.type === 'ConditionalExpression'
+                    && (('value' in node.value.expression.consequent && node.value.expression.consequent.value === 'arrowRight')
+                        || ('value' in node.value.expression.alternate && node.value.expression.alternate.value === 'arrowRight'));
+                /**
+                 * if it is a literal with a deprecated value -> we migrate
+                 * if it is an expression with a defined deprecated value -> we migrate
+                 */
+                if (isLiteral || isExpression) {
+                    context.report({
+                        node,
+                        messageId: 'useArrowEndInstead',
+                        fix: (fixer) => {
+                            if (node.key.type === 'VIdentifier') {
+                                return fixer.replaceTextRange(node.value.range, '"arrowEnd"');
+                            }
+                            else if (node.key.type === 'VDirectiveKey') {
+                                const expression = node.value.expression;
+                                return expression.consequent.value === 'arrowRight'
+                                    ? fixer.replaceTextRange(expression.consequent.range, '\'arrowEnd\'')
+                                    : fixer.replaceTextRange(expression.alternate.range, '\'arrowEnd\'');
+                            }
+                        },
+                    });
+                }
+            },
+            '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
+                context.report({
+                    node,
+                    messageId: 'removeLimitWidth',
+                });
+            },
+            'VElement VAttribute:has(VIdentifier[name="exact"])': function (node) {
+                if (![
+                    'ncactionrouter',
+                    'ncappnavigationitem',
+                    'ncbreadcrumb',
+                    'ncbutton',
+                    'nclistitem',
+                ].includes(node.parent.parent.name)) {
+                    return;
+                }
+                if (!isVue3Valid) {
+                    // Do not throw for v8.X.X
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'removeExact',
+                });
+            },
+            'VElement VAttribute:has(VIdentifier[name="checked"])': function (node) {
+                if (![
+                    'ncactioncheckbox',
+                    'ncactionradio',
+                    'nccheckboxradioswitch',
+                ].includes(node.parent.parent.name)) {
+                    return;
+                }
+                if (!isModelValueValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useModelValueInsteadChecked',
+                    fix: (fixer) => {
+                        if (node.key.type === 'VIdentifier') {
+                            return fixer.replaceTextRange(node.key.range, 'model-value');
+                        }
+                        else if (node.key.type === 'VDirectiveKey') {
+                            if (node.key.name.name === 'model') {
+                                return fixer.replaceTextRange(node.key.range, 'v-model');
+                            }
+                            else if (node.key.modifiers.some((m) => m.name === 'sync')) {
+                                return fixer.replaceTextRange(node.key.range, 'v-model');
+                            }
+                            else {
+                                return fixer.replaceTextRange(node.key.argument.range, 'model-value');
+                            }
+                        }
+                    },
+                });
+            },
+            'VElement VAttribute:has(VIdentifier[name="value"])': function (node) {
+                if (![
+                    'ncactioninput',
+                    'ncactiontexteditable',
+                    'nccolorpicker',
+                    'ncdatetimepicker',
+                    'ncdatetimepickernative',
+                    'ncinputfield',
+                    'nctextfield',
+                    'ncpasswordfield',
+                    'ncrichcontenteditable',
+                    'ncselecttags',
+                    'ncselect',
+                    'ncsettingsinputtext',
+                    'ncsettingsselectgroup',
+                    'nctextarea',
+                    'nctimezonepicker',
+                ].includes(node.parent.parent.name)) {
+                    return;
+                }
+                if (!isModelValueValid) {
+                    context.report({ node, messageId: 'outdatedVueLibrary' });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'useModelValueInsteadValue',
+                    fix: (fixer) => {
+                        if (node.key.type === 'VIdentifier') {
+                            return fixer.replaceTextRange(node.key.range, 'model-value');
+                        }
+                        else if (node.key.type === 'VDirectiveKey') {
+                            if (node.key.name.name === 'model') {
+                                return fixer.replaceTextRange(node.key.range, 'v-model');
+                            }
+                            else if (node.key.modifiers.some((m) => m.name === 'sync')) {
+                                return fixer.replaceTextRange(node.key.range, 'v-model');
+                            }
+                            else {
+                                return fixer.replaceTextRange(node.key.argument.range, 'model-value');
+                            }
+                        }
+                    },
+                });
+            },
+        });
+    },
+};

package/dist/plugins/nextcloud/rules/no-removed-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;

package/dist/plugins/nextcloud/rules/no-removed-globals.js

@@ -0,0 +1,203 @@
+/*!
+ * 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
+// ------------------------------------------------------------------------------
+const global = {
+    autosize: '29.0.0',
+    escapeHTML: '20.0.0',
+    fileDownloadPath: '15.0.0',
+    formatDate: '19.0.0',
+    getScrollBarWidth: '15.0.0',
+    getURLParameter: '19.0.0',
+    humanFileSize: '19.0.0',
+    marked: '19.0.0',
+    md5: '32.0.0',
+    relative_modified_date: '19.0.0',
+};
+const oc = {
+    AppConfig: '33.0.0',
+    SystemTags: '33.0.0',
+    getScrollBarWidth: '15.0.0',
+    addTranslations: '26.0.0',
+    appSettings: '28.0.0',
+    fileIsBlacklisted: '33.0.0',
+    get: '33.0.0',
+    getHost: '33.0.0',
+    getHostName: '33.0.0',
+    getPort: '33.0.0',
+    getProtocol: '33.0.0',
+    loadScript: '28.0.0',
+    loadStyle: '28.0.0',
+    redirect: '33.0.0',
+    reload: '33.0.0',
+    set: '33.0.0',
+};
+const ocNested = {
+    AppConfig: {
+        hasKey: '15.0.0',
+        deleteApp: '15.0.0',
+    },
+    Util: {
+        hasSVGSupport: '15.0.0',
+        replaceSVGIcon: '15.0.0',
+        replaceSVG: '15.0.0',
+        scaleFixForIE8: '15.0.0',
+        isIE8: '15.0.0',
+    },
+    Settings: {
+        UserSettings: '33.0.0',
+    },
+};
+const oca = {
+    // ref: https://github.com/nextcloud/server/commit/6eced42b7a40f5b0ea0489244583219d0ee2e7af
+    Search: '20.0.0',
+    FilesSharingDrop: '31.0.0',
+};
+const ocaNested = {
+    Core: {
+        ProfileSections: '33.0.0',
+    },
+    Files: {
+        Sidebar: '33.0.0',
+    },
+    Sharing: {
+        ExternalLinkActions: '33.0.0',
+    },
+};
+// TODO: handle OC.x.y.z like OC.Share.ShareConfigModel.areAvatarsEnabled()
+//       ref https://github.com/nextcloud/server/issues/11045
+const rule = {
+    meta: {
+        docs: {
+            description: 'Removed Nextcloud APIs',
+            recommended: true,
+        },
+        // fixable: "code" or "whitespace"
+        schema: [
+            {
+                // We accept one option which is an object
+                type: 'object',
+                properties: {
+                    // if we should try to find an appinfo and only handle APIs removed before the max-version
+                    parseAppInfo: {
+                        type: 'boolean',
+                    },
+                    // Set a Nextcloud target version, only APIs removed before that versions are checked
+                    targetVersion: {
+                        type: 'string',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            removedGlobal: 'The global property or function {{name}} was removed in Nextcloud {{version}}',
+        },
+    },
+    create(context) {
+        const checkTargetVersion = createVersionValidator(context);
+        return {
+            MemberExpression(node) {
+                // OCA.x
+                if ('name' in node.object
+                    && 'name' in node.property
+                    && node.object.name === 'OCA'
+                    && oca[node.property.name]
+                    && checkTargetVersion(oca[node.property.name])) {
+                    context.report({
+                        node,
+                        message: `The property or function OCA.${node.property.name} was removed in Nextcloud ${oca[node.property.name]}`,
+                    });
+                }
+                // OCA.x.y
+                if (node.object.type === 'MemberExpression'
+                    && 'name' in node.object.object
+                    && node.object.object.name === 'OCA'
+                    && 'name' in node.object.property
+                    && ocaNested[node.object.property.name]
+                    && 'name' in node.property
+                    && ocaNested[node.object.property.name][node.property.name]) {
+                    const version = ocaNested[node.object.property.name][node.property.name];
+                    if (checkTargetVersion(version)) {
+                        const prop = [
+                            'OC',
+                            node.object.property.name,
+                            node.property.name,
+                        ].join('.');
+                        context.report({
+                            node,
+                            message: `The property or function ${prop} was removed in Nextcloud ${version}`,
+                        });
+                    }
+                }
+                // OC.x
+                if ('name' in node.object
+                    && 'name' in node.property
+                    && node.object.name === 'OC'
+                    && Object.hasOwn(oc, node.property.name)
+                    && checkTargetVersion(oc[node.property.name])) {
+                    context.report({
+                        node,
+                        message: `The property or function OC.${node.property.name} was removed in Nextcloud ${oc[node.property.name]}`,
+                    });
+                }
+                // OC.x.y
+                if (node.object.type === 'MemberExpression'
+                    && 'name' in node.object.object
+                    && node.object.object.name === 'OC'
+                    && 'name' in node.object.property
+                    && ocNested[node.object.property.name]
+                    && 'name' in node.property
+                    && ocNested[node.object.property.name][node.property.name]) {
+                    const version = ocNested[node.object.property.name][node.property.name];
+                    if (checkTargetVersion(version)) {
+                        const prop = [
+                            'OC',
+                            node.object.property.name,
+                            node.property.name,
+                        ].join('.');
+                        context.report({
+                            node,
+                            message: `The property or function ${prop} was removed in Nextcloud ${version}`,
+                        });
+                    }
+                }
+            },
+            Program(node) {
+                // Logic adapted from https://github.com/eslint/eslint/blob/master/lib/rules/no-restricted-globals.js
+                const scope = context.sourceCode.getScope(node);
+                const report = (ref) => {
+                    const { identifier } = ref;
+                    if (global[identifier.name] && checkTargetVersion(global[identifier.name])) {
+                        context.report({
+                            node,
+                            messageId: 'removedGlobal',
+                            data: {
+                                name: identifier.name,
+                                version: global[identifier.name],
+                            },
+                        });
+                    }
+                };
+                // Report variables declared elsewhere (ex: variables defined as "global" by eslint)
+                scope.variables.forEach((variable) => {
+                    if (!variable.defs.length
+                        && Object.hasOwn(global, variable.name)) {
+                        variable.references.forEach(report);
+                    }
+                });
+                // Report variables not declared at all
+                scope.through.forEach((reference) => {
+                    if (Object.hasOwn(global, reference.identifier.name)) {
+                        report(reference);
+                    }
+                });
+            },
+        };
+    },
+};
+export default rule;

package/dist/plugins/nextcloud/utils/app-version-parser.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';
+/**
+ * Check if a given path exists and is a directory
+ *
+ * @param filePath The path
+ */
+export declare function isDirectory(filePath: string): boolean;
+/**
+ * Check if a given path exists and is a directory
+ *
+ * @param filePath The path
+ */
+export declare function isFile(filePath: string): boolean;
+/**
+ * Find the path of nearest `appinfo/info.xml` relative to given path
+ *
+ * @param currentPath Path to lookup
+ * @return Either the full path including the `info.xml` part or `undefined` if no found
+ */
+export declare function findAppinfo(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 an 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
+ * @param options.options The plugin options
+ */
+export declare function createVersionValidator({ cwd, physicalFilename, options }: Rule.RuleContext): ((version: string) => boolean);