@o3r/eslint-plugin 11.6.0-prerelease.6 → 11.6.0-prerelease.8

package/src/rules/typescript/o3r-widget-tags/o3r-widget-tags.js

@@ -72,184 +72,184 @@ exports.default = (0, utils_1.createRule)({
     defaultOptions,
     create: (context, [options]) => {
         const supportedO3rWidgets = new Set(Object.keys(options.widgets));
-        return {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            TSPropertySignature: (node) => {
-                const sourceCode = context.getSourceCode();
-                const comment = (0, utils_1.getNodeComment)(node, sourceCode);
-                if (!comment || !comment.value.length) {
-                    return;
-                }
-                const { loc, value: docText } = comment;
-                const widgetTypes = Array.from(docText.matchAll(/@o3rWidget (.*)/g));
-                if (widgetTypes.length > 1) {
+        const rule = (node) => {
+            const { sourceCode } = context;
+            const comment = (0, utils_1.getNodeComment)(node, sourceCode);
+            if (!comment || comment.value.length === 0) {
+                return;
+            }
+            const { loc, value: docText } = comment;
+            const widgetTypes = Array.from(docText.matchAll(/@o3rWidget (.*)/g));
+            if (widgetTypes.length > 1) {
+                const fix = (fixer) => {
+                    return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(/(.*(@o3rWidget ).*(\n.*)*)(\n.*)\2.*/, '$1')));
+                };
+                return context.report({
+                    messageId: 'onlyOneWidgetAllowed',
+                    node,
+                    loc,
+                    fix,
+                    suggest: [{
+                            messageId: 'suggestRemoveDuplicatedO3rWidget',
+                            fix
+                        }]
+                });
+            }
+            const widgetType = widgetTypes[0]?.[1].trim();
+            const widgetParameterTexts = Array.from(docText.matchAll(/@o3rWidgetParam (.*)/g))
+                .map((match) => match[1].trim());
+            if (!widgetType) {
+                if (widgetParameterTexts.length > 0) {
                     const fix = (fixer) => {
-                        return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(/(.*(@o3rWidget ).*(\n.*)*)(\n.*)\2.*/, '$1')));
+                        return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(/((.*)@o3rWidgetParam .*)/, '$2@o3rWidget widgetType\n$1')));
                     };
                     return context.report({
-                        messageId: 'onlyOneWidgetAllowed',
+                        messageId: 'noParamWithoutWidget',
                         node,
                         loc,
                         fix,
                         suggest: [{
-                                messageId: 'suggestRemoveDuplicatedO3rWidget',
+                                messageId: 'suggestAddO3rWidgetTag',
                                 fix
                             }]
                     });
                 }
-                const widgetType = widgetTypes[0]?.[1].trim();
-                const widgetParameterTexts = Array.from(docText.matchAll(/@o3rWidgetParam (.*)/g))
-                    .map((match) => match[1].trim());
-                if (!widgetType) {
-                    if (widgetParameterTexts.length) {
-                        const fix = (fixer) => {
-                            return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(/((.*)@o3rWidgetParam .*)/, '$2@o3rWidget widgetType\n$1')));
-                        };
-                        return context.report({
-                            messageId: 'noParamWithoutWidget',
-                            node,
-                            loc,
-                            fix,
-                            suggest: [{
-                                    messageId: 'suggestAddO3rWidgetTag',
-                                    fix
-                                }]
-                        });
-                    }
-                    return;
-                }
-                const interfaceDeclNode = node.parent?.parent;
-                if (!(0, utils_1.isExtendingConfiguration)(interfaceDeclNode, options.supportedInterfaceNames)) {
+                return;
+            }
+            const interfaceDeclNode = node.parent?.parent;
+            if (!(0, utils_1.isExtendingConfiguration)(interfaceDeclNode, options.supportedInterfaceNames)) {
+                return context.report({
+                    messageId: 'notInConfigurationInterface',
+                    node,
+                    loc
+                });
+            }
+            if (!supportedO3rWidgets.has(widgetType)) {
+                return context.report({
+                    messageId: 'notSupportedType',
+                    node,
+                    loc,
+                    data: {
+                        o3rWidgetType: widgetType,
+                        supportedO3rWidgets: Array.from(supportedO3rWidgets).join(', ')
+                    },
+                    suggest: Array.from(supportedO3rWidgets).map((suggestedWidget) => ({
+                        messageId: 'suggestReplaceO3rWidgetType',
+                        data: {
+                            currentType: widgetType,
+                            suggestedType: suggestedWidget
+                        },
+                        fix: (fixer) => {
+                            return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(`@o3rWidget ${widgetType}`, `@o3rWidget ${suggestedWidget}`)));
+                        }
+                    }))
+                });
+            }
+            const widgetParameters = widgetParameterTexts.map((text) => {
+                const [name, ...values] = text.split(' ');
+                return {
+                    name,
+                    textValue: values.join(' ')
+                };
+            });
+            const widgetParameterNames = widgetParameters.map(({ name }) => name);
+            const supportedO3rWidgetParam = new Set(Object.keys(options.widgets[widgetType]));
+            const checkedParam = new Set();
+            for (const widgetParameterName of widgetParameterNames) {
+                if (checkedParam.has(widgetParameterName)) {
+                    const fix = (fixer) => {
+                        return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(/(.*(@o3rWidgetParam ).*(\n.*)*)(\n.*)\2.*/m, '$1')));
+                    };
                     return context.report({
-                        messageId: 'notInConfigurationInterface',
+                        messageId: 'duplicatedParam',
                         node,
-                        loc
+                        loc,
+                        data: {
+                            o3rWidgetParam: widgetParameterName
+                        },
+                        fix,
+                        suggest: [{
+                                messageId: 'suggestRemoveDuplicatedO3rWidgetParam',
+                                fix
+                            }]
                     });
                 }
-                if (!supportedO3rWidgets.has(widgetType)) {
+                if (!supportedO3rWidgetParam.has(widgetParameterName)) {
                     return context.report({
-                        messageId: 'notSupportedType',
+                        messageId: 'notSupportedParamForType',
                         node,
                         loc,
                         data: {
+                            o3rWidgetParam: widgetParameterName,
                             o3rWidgetType: widgetType,
-                            supportedO3rWidgets: Array.from(supportedO3rWidgets).join(', ')
+                            supportedO3rWidgetParam: Array.from(supportedO3rWidgetParam).join(', ')
                         },
-                        suggest: Array.from(supportedO3rWidgets).map((suggestedWidget) => ({
+                        suggest: Array.from(supportedO3rWidgetParam).map((suggestedParam) => ({
                             messageId: 'suggestReplaceO3rWidgetType',
                             data: {
-                                currentType: widgetType,
-                                suggestedType: suggestedWidget
+                                currentType: widgetParameterName,
+                                suggestedType: suggestedParam
                             },
                             fix: (fixer) => {
-                                return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(`@o3rWidget ${widgetType}`, `@o3rWidget ${suggestedWidget}`)));
+                                return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(`@o3rWidgetParam ${widgetParameterName}`, `@o3rWidgetParam ${suggestedParam}`)));
                             }
                         }))
                     });
                 }
-                const widgetParameters = widgetParameterTexts.map((text) => {
-                    const [name, ...values] = text.split(' ');
-                    return {
-                        name,
-                        textValue: values.join(' ')
-                    };
-                });
-                const widgetParameterNames = widgetParameters.map(({ name }) => name);
-                const supportedO3rWidgetParam = new Set(Object.keys(options.widgets[widgetType]));
-                const checkedParam = new Set();
-                for (const widgetParameterName of widgetParameterNames) {
-                    if (checkedParam.has(widgetParameterName)) {
-                        const fix = (fixer) => {
-                            return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(/(.*(@o3rWidgetParam ).*(\n.*)*)(\n.*)\2.*/m, '$1')));
-                        };
-                        return context.report({
-                            messageId: 'duplicatedParam',
-                            node,
-                            loc,
-                            data: {
-                                o3rWidgetParam: widgetParameterName
-                            },
-                            fix,
-                            suggest: [{
-                                    messageId: 'suggestRemoveDuplicatedO3rWidget',
-                                    fix
-                                }]
-                        });
-                    }
-                    if (!supportedO3rWidgetParam.has(widgetParameterName)) {
-                        return context.report({
-                            messageId: 'notSupportedParamForType',
-                            node,
-                            loc,
+                checkedParam.add(widgetParameterName);
+            }
+            const firstRequiredParam = Object.entries(options.widgets[widgetType]).find(([param, { required }]) => required && !checkedParam.has(param));
+            if (firstRequiredParam) {
+                const [firstRequiredParamName] = firstRequiredParam;
+                const fix = (fixer) => {
+                    return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(/((.*)@o3rWidget (.*))/, `$1\n$2@o3rWidgetParam ${firstRequiredParamName} value`)));
+                };
+                return context.report({
+                    messageId: 'requiredParamMissing',
+                    node,
+                    loc,
+                    data: {
+                        o3rWidgetParam: firstRequiredParamName,
+                        o3rWidgetType: widgetType
+                    },
+                    fix,
+                    suggest: [{
+                            messageId: 'suggestParamMissing',
                             data: {
-                                o3rWidgetParam: widgetParameterName,
-                                o3rWidgetType: widgetType,
-                                supportedO3rWidgetParam: Array.from(supportedO3rWidgetParam).join(', ')
+                                o3rWidgetParam: firstRequiredParamName
                             },
-                            suggest: Array.from(supportedO3rWidgetParam).map((suggestedParam) => ({
-                                messageId: 'suggestReplaceO3rWidgetType',
-                                data: {
-                                    currentType: widgetType,
-                                    suggestedType: suggestedParam
-                                },
-                                fix: (fixer) => {
-                                    return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(`@o3rWidgetParam ${widgetType}`, `@o3rWidgetParam ${suggestedParam}`)));
-                                }
-                            }))
-                        });
-                    }
-                    checkedParam.add(widgetParameterName);
-                }
-                const firstRequiredParam = Object.entries(options.widgets[widgetType]).find(([param, { required }]) => required && !checkedParam.has(param));
-                if (firstRequiredParam) {
-                    const [firstRequiredParamName] = firstRequiredParam;
-                    const fix = (fixer) => {
-                        return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(/((.*)@o3rWidget (.*))/, `$1\n$2@o3rWidgetParam ${firstRequiredParamName} value`)));
-                    };
-                    return context.report({
-                        messageId: 'requiredParamMissing',
-                        node,
-                        loc,
-                        data: {
-                            o3rWidgetParam: firstRequiredParamName,
-                            o3rWidgetType: widgetType
-                        },
-                        fix,
-                        suggest: [{
-                                messageId: 'suggestParamMissing',
-                                data: {
-                                    o3rWidgetParam: firstRequiredParamName
-                                },
-                                fix
-                            }]
-                    });
-                }
-                for (const widgetParameter of widgetParameters) {
-                    const { name, textValue } = widgetParameter;
-                    const supportedTypeForParam = options.widgets[widgetType][name];
-                    try {
-                        const value = JSON.parse(textValue);
-                        if (supportedTypeForParam.type.endsWith('[]')) {
-                            if (Array.isArray(value) && value.every((element) => typeof element === supportedTypeForParam.type.substring(0, -2))) {
-                                continue;
-                            }
-                        }
-                        else if (typeof value === supportedTypeForParam.type) {
+                            fix
+                        }]
+                });
+            }
+            for (const widgetParameter of widgetParameters) {
+                const { name, textValue } = widgetParameter;
+                const supportedTypeForParam = options.widgets[widgetType][name];
+                try {
+                    const value = JSON.parse(textValue);
+                    if (supportedTypeForParam.type.endsWith('[]')) {
+                        if (Array.isArray(value) && value.every((element) => typeof element === supportedTypeForParam.type.substring(0, -2))) {
                             continue;
                         }
                     }
-                    catch { }
-                    return context.report({
-                        messageId: 'invalidParamValueType',
-                        node,
-                        loc,
-                        data: {
-                            o3rWidgetParam: name,
-                            o3rWidgetParamType: supportedTypeForParam.type
-                        }
-                    });
+                    else if (typeof value === supportedTypeForParam.type) {
+                        continue;
+                    }
                 }
+                catch { }
+                return context.report({
+                    messageId: 'invalidParamValueType',
+                    node,
+                    loc,
+                    data: {
+                        o3rWidgetParam: name,
+                        o3rWidgetParamType: supportedTypeForParam.type
+                    }
+                });
             }
         };
+        return {
+            TSPropertySignature: rule
+        };
     }
 });

package/src/rules/utils.d.ts

@@ -1,6 +1,6 @@
 import { ESLintUtils, TSESLint, TSESTree } from '@typescript-eslint/utils';
 /** ESLint rule generator */
-export declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds>>) => ESLintUtils.RuleModule<MessageIds, Options>;
+export declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener>;
 /** Default supported interface names */
 export declare const defaultSupportedInterfaceNames: string[];
 /**

package/src/rules/utils.js

@@ -1,18 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCommentString = exports.getNodeComment = exports.isExtendingConfiguration = exports.defaultSupportedInterfaceNames = exports.createRule = void 0;
-const utils_1 = require("@typescript-eslint/utils");
 const node_fs_1 = require("node:fs");
 const path = require("node:path");
+const utils_1 = require("@typescript-eslint/utils");
 /** Current package version (format: <major>.<minor>)*/
-const version = JSON.parse((0, node_fs_1.readFileSync)(path.resolve(__dirname, '..', '..', 'package.json'), { encoding: 'utf-8' })).version?.split('.').slice(0, 2).join('.') || '0.0';
+const version = JSON.parse((0, node_fs_1.readFileSync)(path.resolve(__dirname, '..', '..', 'package.json'), { encoding: 'utf8' })).version?.split('.').slice(0, 2).join('.') || '0.0';
 /** ESLint rule generator */
-// eslint-disable-next-line new-cap
+// eslint-disable-next-line new-cap -- naming convention imposed by typescript-eslint
 exports.createRule = utils_1.ESLintUtils.RuleCreator((name) => {
-    if (version === '0.0') {
-        return 'file:' + path.resolve(__dirname, '..', '..', '..', '..', '..', 'docs', 'linter', 'eslint-plugin', 'rules', `${name}.md`);
-    }
-    return `https://github.com/AmadeusITGroup/otter/tree/release/${version}/docs/linter/eslint-plugin/rules/${name}.md`;
+    return `https://github.com/AmadeusITGroup/otter/tree/release/${version === '0.0' ? 'main' : version}/docs/linter/eslint-plugin/rules/${name}.md`;
 });
 /** Default supported interface names */
 exports.defaultSupportedInterfaceNames = ['Configuration', 'NestedConfiguration'];

package/src/rules/yaml/utils.js

@@ -15,7 +15,7 @@ function isYamlParserServices(parserServices) {
  * @param context Rule context
  */
 function getYamlParserServices(context) {
-    const parserService = context.parserServices;
+    const parserService = context.sourceCode.parserServices;
     if (!isYamlParserServices(parserService)) {
         /*
          * The user needs to have configured "parser" in their eslint config and set it
@@ -31,7 +31,7 @@ function getYamlParserServices(context) {
  * @param context
  */
 function ensureJsoncParser(context) {
-    if (!(context.parserServices)) {
+    if (!(context.sourceCode.parserServices)) {
         /*
          * The user needs to have configured "parser" in their eslint config and set it
          * to yaml-eslint-parser

package/src/rules/yaml/yarnrc-package-extensions-harmonize/yarnrc-package-extensions-harmonize.d.ts

@@ -1,4 +1,4 @@
-interface Options {
+export interface YarnrcPackageExtensionsHarmonizeOptions {
     /** List of package.json to ignore when determining the dependencies versions */
     excludePackages: string[];
     /** List of dependency types in package.json to parse */
@@ -8,5 +8,5 @@ interface Options {
     /** List of dependency types to validate in .yarnrc.yml */
     yarnrcDependencyTypes: string[];
 }
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"error" | "versionUpdate", [Options, ...any[]], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"error" | "versionUpdate", [YarnrcPackageExtensionsHarmonizeOptions, ...any[]], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
 export default _default;

package/src/rules/yaml/yarnrc-package-extensions-harmonize/yarnrc-package-extensions-harmonize.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("node:path");
 const semver = require("semver");
-const utils_1 = require("../../utils");
-const utils_2 = require("../utils");
 const yaml_eslint_parser_1 = require("yaml-eslint-parser");
 const version_harmonize_1 = require("../../json/json-dependency-versions-harmonize/version-harmonize");
+const utils_1 = require("../../utils");
+const utils_2 = require("../utils");
 const defaultOptions = [{
         ignoredDependencies: [],
         excludePackages: [],
@@ -67,55 +67,55 @@ exports.default = (0, utils_1.createRule)({
     defaultOptions,
     create: (context, [options]) => {
         const parserServices = (0, utils_2.getYamlParserServices)(context);
-        const dirname = path.dirname(context.getFilename());
+        const dirname = path.dirname(context.filename);
         const workspace = (0, version_harmonize_1.findWorkspacePackageJsons)(dirname);
-        const bestRanges = workspace ?
-            (0, version_harmonize_1.getBestRanges)(options.dependencyTypesInPackages, workspace.packages.filter(({ content }) => !content.name || !options.excludePackages.includes(content.name))) :
-            {};
-        const ignoredDependencies = options.ignoredDependencies.map((dep) => new RegExp(dep.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')));
+        const bestRanges = workspace
+            ? (0, version_harmonize_1.getBestRanges)(options.dependencyTypesInPackages, workspace.packages.filter(({ content }) => !content.name || !options.excludePackages.includes(content.name)))
+            : {};
+        const ignoredDependencies = options.ignoredDependencies.map((dep) => new RegExp(dep.replace(/[$()+.?[\\\]^{|}]/g, '\\$&').replace(/\*/g, '.*')));
         if (parserServices.isYAML) {
-            return {
-                // eslint-disable-next-line @typescript-eslint/naming-convention
-                'YAMLPair': (node) => {
-                    if (node.value) {
-                        const range = (0, yaml_eslint_parser_1.getStaticYAMLValue)(node.value)?.toString();
-                        const parent = node.parent.parent && node.parent.parent.type === 'YAMLPair' && (0, yaml_eslint_parser_1.getStaticYAMLValue)(node.parent.parent.key)?.toString();
-                        const baseNode = node.parent.parent.parent.parent?.parent?.parent;
-                        const isCorrectNode = baseNode && baseNode.type === 'YAMLPair' && (0, yaml_eslint_parser_1.getStaticYAMLValue)(baseNode.key)?.toString() === 'packageExtensions';
-                        if (isCorrectNode && semver.validRange(range) && parent && options.yarnrcDependencyTypes.some((t) => t === parent)) {
-                            const depName = node.key && (0, yaml_eslint_parser_1.getStaticYAMLValue)(node.key)?.toString();
-                            if (!depName || !bestRanges[depName] || ignoredDependencies.some((ignore) => ignore.test(depName))) {
-                                return;
-                            }
-                            const minYarnrcVersion = semver.minVersion(range);
-                            const minBestRangeVersion = semver.minVersion(bestRanges[depName].range);
-                            if (minYarnrcVersion && minBestRangeVersion && semver.lt(minYarnrcVersion, minBestRangeVersion)) {
-                                const version = bestRanges[depName].range;
-                                const packageJsonFile = bestRanges[depName].path;
-                                context.report({
-                                    loc: node.value.loc,
-                                    messageId: 'error',
-                                    data: {
-                                        depName,
-                                        version,
-                                        packageJsonFile
-                                    },
-                                    fix: (fixer) => fixer.replaceTextRange(node.value.range, `${version}`),
-                                    suggest: [
-                                        {
-                                            messageId: 'versionUpdate',
-                                            data: {
-                                                version
-                                            },
-                                            fix: (fixer) => fixer.replaceTextRange(node.value.range, `${version}`)
-                                        }
-                                    ]
-                                });
-                            }
+            const rule = (node) => {
+                if (node.value) {
+                    const range = (0, yaml_eslint_parser_1.getStaticYAMLValue)(node.value)?.toString();
+                    const parent = node.parent.parent && node.parent.parent.type === 'YAMLPair' && (0, yaml_eslint_parser_1.getStaticYAMLValue)(node.parent.parent.key)?.toString();
+                    const baseNode = node.parent.parent.parent.parent?.parent?.parent;
+                    const isCorrectNode = baseNode && baseNode.type === 'YAMLPair' && (0, yaml_eslint_parser_1.getStaticYAMLValue)(baseNode.key)?.toString() === 'packageExtensions';
+                    if (isCorrectNode && semver.validRange(range) && parent && options.yarnrcDependencyTypes.includes(parent)) {
+                        const depName = node.key && (0, yaml_eslint_parser_1.getStaticYAMLValue)(node.key)?.toString();
+                        if (!depName || !bestRanges[depName] || ignoredDependencies.some((ignore) => ignore.test(depName))) {
+                            return;
+                        }
+                        const minYarnrcVersion = semver.minVersion(range);
+                        const minBestRangeVersion = semver.minVersion(bestRanges[depName].range);
+                        if (minYarnrcVersion && minBestRangeVersion && semver.lt(minYarnrcVersion, minBestRangeVersion)) {
+                            const version = bestRanges[depName].range;
+                            const packageJsonFile = bestRanges[depName].path;
+                            context.report({
+                                loc: node.value.loc,
+                                messageId: 'error',
+                                data: {
+                                    depName,
+                                    version,
+                                    packageJsonFile
+                                },
+                                fix: (fixer) => fixer.replaceTextRange(node.value.range, `${version}`),
+                                suggest: [
+                                    {
+                                        messageId: 'versionUpdate',
+                                        data: {
+                                            version
+                                        },
+                                        fix: (fixer) => fixer.replaceTextRange(node.value.range, `${version}`)
+                                    }
+                                ]
+                            });
                         }
                     }
                 }
             };
+            return {
+                YAMLPair: rule
+            };
         }
         return {};
     }