@o3r/eslint-plugin 9.4.0-alpha.2 → 9.4.0-alpha.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o3r/eslint-plugin",
-  "version": "9.4.0-alpha.2",
+  "version": "9.4.0-alpha.20",
   "description": "The module provides in-house eslint plugins to use in your own eslint configuration.",
   "main": "./src/public_api.js",
   "keywords": [
@@ -47,10 +47,10 @@
     "@babel/core": "~7.23.0",
     "@babel/preset-typescript": "~7.23.0",
     "@compodoc/compodoc": "^1.1.19",
-    "@nx/eslint-plugin": "~16.8.0",
-    "@nx/jest": "~16.8.0",
-    "@o3r/build-helpers": "^9.4.0-alpha.2",
-    "@o3r/eslint-plugin": "^9.4.0-alpha.2",
+    "@nx/eslint-plugin": "~16.10.0",
+    "@nx/jest": "~16.10.0",
+    "@o3r/build-helpers": "^9.4.0-alpha.20",
+    "@o3r/eslint-plugin": "^9.4.0-alpha.20",
     "@types/jest": "~29.5.2",
     "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^5.60.1",
@@ -64,7 +64,7 @@
     "jest": "~29.7.0",
     "jest-junit": "~16.0.0",
     "jsonc-eslint-parser": "~2.3.0",
-    "nx": "~16.8.0",
+    "nx": "~16.10.0",
     "rimraf": "^5.0.1",
     "ts-jest": "~29.1.1",
     "typescript": "~5.1.6"

package/src/index.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/naming-convention */
 const no_folder_import_for_module_1 = require("./rules/no-folder-import-for-module/no-folder-import-for-module");
 const template_async_number_limitation_1 = require("./rules/template-async-number-limitation/template-async-number-limitation");
+const o3r_widget_tags_1 = require("./rules/o3r-widget-tags/o3r-widget-tags");
 module.exports = {
     rules: {
         'no-folder-import-for-module': no_folder_import_for_module_1.default,
-        'template-async-number-limitation': template_async_number_limitation_1.default
+        'template-async-number-limitation': template_async_number_limitation_1.default,
+        'o3r-widget-tags': o3r_widget_tags_1.default
     },
     configs: {
         '@o3r/no-folder-import-for-module': 'error',

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const utils_1 = require("../utils");
+const o3rWidgetParameterPattern = '^[a-zA-Z0-9-_:.]+$';
+const o3rWidgetParamTypes = ['string', 'number', 'boolean', 'string[]', 'number[]', 'boolean[]'];
+const createCommentString = (comment) => `/*${comment}*/`;
+exports.default = (0, utils_1.createRule)({
+    name: 'o3r-widget-tags',
+    meta: {
+        hasSuggestions: true,
+        fixable: 'code',
+        type: 'problem',
+        docs: {
+            description: 'Ensures that @o3rWidget and @o3rWidgetParam are used with correct value',
+            recommended: 'error'
+        },
+        schema: [
+            {
+                type: 'object',
+                required: ['widgets'],
+                properties: {
+                    supportedInterfaceNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    widgets: {
+                        additionalProperties: {
+                            type: 'object',
+                            additionalProperties: false,
+                            patternProperties: {
+                                [o3rWidgetParameterPattern]: {
+                                    type: 'object',
+                                    required: ['type'],
+                                    properties: {
+                                        required: {
+                                            type: 'boolean'
+                                        },
+                                        type: {
+                                            type: 'string',
+                                            enum: o3rWidgetParamTypes
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        ],
+        messages: {
+            notSupportedType: '{{ o3rWidgetType }} is not supported. Supported o3rWidget types: {{ supportedO3rWidgets }}.',
+            notSupportedParamForType: '{{ o3rWidgetParam }} is not supported for {{ o3rWidgetType }}. Supported o3rWidgetParam for {{ o3rWidgetType }}: {{ supportedO3rWidgetParam }}.',
+            invalidParamValueType: '{{ o3rWidgetParam }} supports only {{ o3rWidgetParamType }}.',
+            noParamWithoutWidget: '@o3rWidgetParam cannot be used without @o3rWidget',
+            duplicatedParam: '@o3rWidgetParam {{ o3rWidgetParam }} must be defined only once.',
+            onlyOneWidgetAllowed: '@o3rWidget must be defined only once.',
+            notInConfigurationInterface: '@o3rWidget can only be used in `Configuration` interface.',
+            requiredParamMissing: '@o3rWidgetParam {{ o3rWidgetParam }} is mandatory when using @o3rWidget {{ o3rWidgetType }}.',
+            suggestParamMissing: 'Add @o3rWidgetParam {{ o3rWidgetParam }}.',
+            suggestRemoveDuplicatedO3rWidget: 'Remove the 2nd @o3rWidget.',
+            suggestRemoveDuplicatedO3rWidgetParam: 'Remove the 2nd @o3rWidgetParam.',
+            suggestAddO3rWidgetTag: 'Add @o3rWidget tag.',
+            suggestReplaceO3rWidgetType: 'Replace {{ currentType }} by {{ suggestedType }}.'
+        }
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const options = context.options
+            .reduce((acc, option) => {
+            acc.supportedInterfaceNames = (acc.supportedInterfaceNames || []).concat(option.supportedInterfaceNames || []);
+            acc.widgets = {
+                ...acc.widgets,
+                ...option.widgets
+            };
+            return acc;
+        }, { widgets: {}, supportedInterfaceNames: ['Configuration', 'NestedConfiguration'] });
+        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] = sourceCode.getCommentsBefore(node);
+                if (!comment || !comment.value.length) {
+                    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, 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) {
+                        const fix = (fixer) => {
+                            return fixer.replaceTextRange(comment.range, 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 (interfaceDeclNode?.type !== experimental_utils_1.TSESTree.AST_NODE_TYPES.TSInterfaceDeclaration
+                    || !interfaceDeclNode.extends?.some((ext) => ext.type === experimental_utils_1.TSESTree.AST_NODE_TYPES.TSInterfaceHeritage
+                        && ext.expression.type === experimental_utils_1.TSESTree.AST_NODE_TYPES.Identifier
+                        && options.supportedInterfaceNames.includes(ext.expression.name))) {
+                    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, 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, 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,
+                            data: {
+                                o3rWidgetParam: widgetParameterName,
+                                o3rWidgetType: widgetType,
+                                supportedO3rWidgetParam: Array.from(supportedO3rWidgetParam).join(', ')
+                            },
+                            suggest: Array.from(supportedO3rWidgetParam).map((suggestedParam) => ({
+                                messageId: 'suggestReplaceO3rWidgetType',
+                                data: {
+                                    currentType: widgetType,
+                                    suggestedType: suggestedParam
+                                },
+                                fix: (fixer) => {
+                                    return fixer.replaceTextRange(comment.range, 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, 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) {
+                            continue;
+                        }
+                    }
+                    catch { }
+                    return context.report({
+                        messageId: 'invalidParamValueType',
+                        node,
+                        loc,
+                        data: {
+                            o3rWidgetParam: name,
+                            o3rWidgetParamType: supportedTypeForParam.type
+                        }
+                    });
+                }
+            }
+        };
+    }
+});