@o3r/eslint-plugin 9.6.0-alpha.3 → 9.6.0-alpha.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o3r/eslint-plugin",
-  "version": "9.6.0-alpha.3",
+  "version": "9.6.0-alpha.30",
   "description": "The module provides in-house eslint plugins to use in your own eslint configuration.",
   "main": "./src/public_api.js",
   "keywords": [
@@ -35,8 +35,8 @@
     }
   },
   "peerDependencies": {
-    "@angular-eslint/template-parser": "~16.2.0",
-    "@angular-eslint/utils": "~16.2.0",
+    "@angular-eslint/template-parser": "~16.3.0",
+    "@angular-eslint/utils": "~16.3.0",
     "@angular/compiler": "~16.2.0",
     "@typescript-eslint/eslint-plugin": "^5.60.1",
     "@typescript-eslint/parser": "^5.60.1",
@@ -46,16 +46,16 @@
   "devDependencies": {
     "@angular-devkit/core": "~16.2.0",
     "@angular-devkit/schematics": "~16.2.0",
-    "@angular-eslint/eslint-plugin": "~16.2.0",
-    "@angular-eslint/template-parser": "~16.2.0",
-    "@angular-eslint/utils": "~16.2.0",
+    "@angular-eslint/eslint-plugin": "~16.3.0",
+    "@angular-eslint/template-parser": "~16.3.0",
+    "@angular-eslint/utils": "~16.3.0",
     "@angular/compiler": "~16.2.0",
     "@babel/core": "~7.23.0",
     "@babel/preset-typescript": "~7.23.0",
     "@compodoc/compodoc": "^1.1.19",
     "@nx/eslint-plugin": "~16.10.0",
     "@nx/jest": "~16.10.0",
-    "@o3r/build-helpers": "^9.6.0-alpha.3",
+    "@o3r/build-helpers": "^9.6.0-alpha.30",
     "@types/jest": "~29.5.2",
     "@types/node": "^18.0.0",
     "@types/semver": "^7.3.13",

package/src/index.js

@@ -3,25 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/naming-convention */
 const no_folder_import_for_module_1 = require("./rules/typescript/no-folder-import-for-module/no-folder-import-for-module");
 const o3r_widget_tags_1 = require("./rules/typescript/o3r-widget-tags/o3r-widget-tags");
+const no_inner_html_1 = require("./rules/template/no-inner-html/no-inner-html");
 const template_async_number_limitation_1 = require("./rules/template/template-async-number-limitation/template-async-number-limitation");
 const json_dependency_versions_harmonize_1 = require("./rules/json/json-dependency-versions-harmonize/json-dependency-versions-harmonize");
 const matching_configuration_name_1 = require("./rules/typescript/matching-configuration-name/matching-configuration-name");
+const no_multiple_type_configuration_property_1 = require("./rules/typescript/no-multiple-type-configuration-property/no-multiple-type-configuration-property");
 module.exports = {
     rules: {
         'no-folder-import-for-module': no_folder_import_for_module_1.default,
+        'no-inner-html': no_inner_html_1.default,
         'template-async-number-limitation': template_async_number_limitation_1.default,
         'o3r-widget-tags': o3r_widget_tags_1.default,
         'json-dependency-versions-harmonize': json_dependency_versions_harmonize_1.default,
-        'matching-configuration-name': matching_configuration_name_1.default
+        'matching-configuration-name': matching_configuration_name_1.default,
+        'no-multiple-type-configuration-property': no_multiple_type_configuration_property_1.default
     },
     configs: {
         '@o3r/no-folder-import-for-module': 'error',
         '@o3r/json-dependency-versions-harmonize': 'error',
+        '@o3r/no-multiple-type-configuration-property': 'error',
         '@o3r/template-async-number-limitation': 'warn',
         '@o3r/matching-configuration-name': 'warn',
         recommended: {
             rules: {
                 '@o3r/matching-configuration-name': 'error',
+                '@o3r/no-multiple-type-configuration-property': 'error',
                 '@o3r/no-folder-import-for-module': 'error',
                 '@o3r/template-async-number-limitation': 'off'
             }

package/src/rules/template/no-inner-html/no-inner-html.d.ts

@@ -0,0 +1,5 @@
+/** Rule Name */
+export declare const name = "no-inner-html";
+type Messages = 'error' | 'fix';
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<Messages, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default _default;

package/src/rules/template/no-inner-html/no-inner-html.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.name = void 0;
+const utils_1 = require("../utils");
+const utils_2 = require("../../utils");
+/** Rule Name */
+exports.name = 'no-inner-html';
+exports.default = (0, utils_2.createRule)({
+    name: exports.name,
+    defaultOptions: [],
+    meta: {
+        type: 'problem',
+        hasSuggestions: true,
+        docs: {
+            description: 'Ensures that your template does not use innerHTML',
+            recommended: 'warn'
+        },
+        schema: [],
+        messages: {
+            error: 'Unexpected use of innerHTML',
+            fix: 'Replace innerHTML by innerText'
+        },
+        fixable: 'code'
+    },
+    create: (context) => {
+        // To throw error if use without @angular-eslint/template-parser
+        (0, utils_1.getTemplateParserServices)(context);
+        return {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'Element$1': (node) => {
+                const innerHTMLAttribute = node.attributes.find((a) => /innerHTML/i.test(a.name));
+                if (innerHTMLAttribute && innerHTMLAttribute.keySpan) {
+                    context.report({
+                        messageId: 'error',
+                        loc: {
+                            column: innerHTMLAttribute.keySpan.start.col,
+                            line: innerHTMLAttribute.keySpan.start.line,
+                            end: {
+                                column: innerHTMLAttribute.keySpan.end.col,
+                                line: innerHTMLAttribute.keySpan.end.line
+                            },
+                            start: {
+                                column: innerHTMLAttribute.keySpan.start.col,
+                                line: innerHTMLAttribute.keySpan.start.line
+                            }
+                        },
+                        fix: (fixer) => fixer.replaceTextRange([innerHTMLAttribute.keySpan.start.offset, innerHTMLAttribute.keySpan.end.offset], 'innerText'),
+                        suggest: [{
+                                messageId: 'fix',
+                                fix: (fixer) => fixer.replaceTextRange([innerHTMLAttribute.keySpan.start.offset, innerHTMLAttribute.keySpan.end.offset], 'innerText')
+                            }]
+                    });
+                }
+            }
+        };
+    }
+});

package/src/rules/typescript/no-multiple-type-configuration-property/no-multiple-type-configuration-property.d.ts

@@ -0,0 +1,5 @@
+export interface NoMultipleTypeConfigurationPropertyOption {
+    supportedInterfaceNames?: string[];
+}
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"suggestion" | "error", NoMultipleTypeConfigurationPropertyOption[], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default _default;

package/src/rules/typescript/no-multiple-type-configuration-property/no-multiple-type-configuration-property.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const utils_1 = require("../../utils");
+const separatorRegExp = /\s*[|&]\s*/;
+exports.default = (0, utils_1.createRule)({
+    name: 'no-multiple-type-configuration-property',
+    meta: {
+        hasSuggestions: true,
+        type: 'problem',
+        docs: {
+            description: 'Ensures that the configuration property does not accept multiple types.',
+            recommended: 'error'
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    supportedInterfaceNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        default: utils_1.defaultSupportedInterfaceNames
+                    }
+                }
+            }
+        ],
+        messages: {
+            error: 'Configuration cannot be the union of multiple type',
+            suggestion: 'Replace {{currentValue}} by {{recommendedValue}}'
+        }
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const supportedInterfaceNames = context.options.reduce((acc, option) => acc.concat(option.supportedInterfaceNames || []), []);
+        const sourceCode = context.getSourceCode();
+        const rule = (node) => {
+            const interfaceDeclNode = node.parent?.parent?.parent?.parent;
+            if (!(0, utils_1.isExtendingConfiguration)(interfaceDeclNode, supportedInterfaceNames)) {
+                return; // Not in a configuration interface
+            }
+            if (node.types.every((type) => type.type === experimental_utils_1.TSESTree.AST_NODE_TYPES.TSLiteralType && type.literal.type === experimental_utils_1.TSESTree.AST_NODE_TYPES.Literal)
+                && [...(new Set(node.types.map((literalType) => typeof literalType.literal.value)))].length === 1) {
+                return; // Only the same literal type
+            }
+            const text = sourceCode.getText(node);
+            context.report({
+                messageId: 'error',
+                node,
+                loc: node.loc,
+                suggest: text.split(separatorRegExp).map((type) => ({
+                    messageId: 'suggestion',
+                    data: {
+                        currentValue: text,
+                        recommendedValue: type
+                    },
+                    fix: (fixer) => fixer.replaceTextRange(node.range, type)
+                }))
+            });
+        };
+        return {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            TSUnionType: rule,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            TSIntersectionType: rule
+        };
+    }
+});

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

@@ -1,6 +1,5 @@
 "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[]'];
@@ -24,7 +23,8 @@ exports.default = (0, utils_1.createRule)({
                         type: 'array',
                         items: {
                             type: 'string'
-                        }
+                        },
+                        default: utils_1.defaultSupportedInterfaceNames
                     },
                     widgets: {
                         additionalProperties: {
@@ -76,7 +76,7 @@ exports.default = (0, utils_1.createRule)({
                 ...option.widgets
             };
             return acc;
-        }, { widgets: {}, supportedInterfaceNames: ['Configuration', 'NestedConfiguration'] });
+        }, { widgets: {}, supportedInterfaceNames: [] });
         const supportedO3rWidgets = new Set(Object.keys(options.widgets));
         return {
             // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -125,10 +125,7 @@ exports.default = (0, utils_1.createRule)({
                     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))) {
+                if (!(0, utils_1.isExtendingConfiguration)(interfaceDeclNode, options.supportedInterfaceNames)) {
                     return context.report({
                         messageId: 'notInConfigurationInterface',
                         node,

package/src/rules/utils.d.ts

@@ -1,3 +1,11 @@
-import { ESLintUtils } from '@typescript-eslint/experimental-utils';
+import { ESLintUtils, TSESTree } from '@typescript-eslint/experimental-utils';
 /** ESLint rule generator */
 export declare const createRule: <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener = import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<TOptions, TMessageIds, TRuleListener>>) => import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<TMessageIds, TOptions, TRuleListener>;
+/** Default supported interface names */
+export declare const defaultSupportedInterfaceNames: string[];
+/**
+ * Returns true if the node extends one of the `supportedInterfaceNames`
+ * @param interfaceDeclNode
+ * @param supportedInterfaceNames
+ */
+export declare const isExtendingConfiguration: (interfaceDeclNode: TSESTree.Node | undefined, supportedInterfaceNames?: string[]) => boolean | undefined;

package/src/rules/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRule = void 0;
+exports.isExtendingConfiguration = exports.defaultSupportedInterfaceNames = exports.createRule = void 0;
 const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
 const path = require("node:path");
 /** Current package version (format: <major>.<minor>)*/
@@ -13,3 +13,18 @@ exports.createRule = experimental_utils_1.ESLintUtils.RuleCreator((name) => {
     }
     return `https://github.com/AmadeusITGroup/otter/tree/release/${version}/docs/linter/eslint-plugin/rules/${name}.md`;
 });
+/** Default supported interface names */
+exports.defaultSupportedInterfaceNames = ['Configuration', 'NestedConfiguration'];
+/**
+ * Returns true if the node extends one of the `supportedInterfaceNames`
+ * @param interfaceDeclNode
+ * @param supportedInterfaceNames
+ */
+const isExtendingConfiguration = (interfaceDeclNode, supportedInterfaceNames = []) => {
+    const supportedInterfaceNamesSet = new Set(supportedInterfaceNames.length > 0 ? supportedInterfaceNames : exports.defaultSupportedInterfaceNames);
+    return 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
+            && supportedInterfaceNamesSet.has(ext.expression.name));
+};
+exports.isExtendingConfiguration = isExtendingConfiguration;