@o3r/eslint-plugin 9.6.0-alpha.4 → 9.6.0-alpha.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o3r/eslint-plugin",
-  "version": "9.6.0-alpha.4",
+  "version": "9.6.0-alpha.41",
   "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.4",
+    "@o3r/build-helpers": "^9.6.0-alpha.41",
     "@types/jest": "~29.5.2",
     "@types/node": "^18.0.0",
     "@types/semver": "^7.3.13",

package/schematics/ng-add/index.d.ts

@@ -0,0 +1,6 @@
+import type { Rule } from '@angular-devkit/schematics';
+/**
+ * Add Otter eslint-plugin to an Angular Project
+ */
+export declare function ngAdd(): Rule;
+//# sourceMappingURL=index.d.ts.map

package/schematics/ng-add/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../schematics/ng-add/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAEvD;;GAEG;AACH,wBAAgB,KAAK,IAAI,IAAI,CAG5B"}

package/schematics/ng-add/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngAdd = void 0;
+const schematics_1 = require("@angular-devkit/schematics");
+/**
+ * Add Otter eslint-plugin to an Angular Project
+ */
+function ngAdd() {
+    /* ng add rules */
+    return (0, schematics_1.noop)();
+}
+exports.ngAdd = ngAdd;
+//# sourceMappingURL=index.js.map

package/schematics/ng-add/schema.d.ts

@@ -0,0 +1,5 @@
+export interface NgAddSchematicsSchema {
+    /** Project name */
+    projectName?: string | undefined;
+}
+//# sourceMappingURL=schema.d.ts.map

package/schematics/ng-add/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../schematics/ng-add/schema.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,mBAAmB;IACnB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC"}

package/schematics/ng-add/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schema.js.map

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/template/template-async-number-limitation/template-async-number-limitation.js

@@ -35,9 +35,8 @@ exports.default = (0, utils_2.createRule)({
         fixable: undefined
     },
     defaultOptions,
-    create: (context) => {
+    create: (context, [options]) => {
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
-        const options = context.options[0] || defaultOptions[0];
         const asyncRegExp = /\| *async\b/g;
         return {
             // eslint-disable-next-line @typescript-eslint/naming-convention

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", [Required<NoMultipleTypeConfigurationPropertyOption>, ...any[]], 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,71 @@
+"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: [{
+            supportedInterfaceNames: utils_1.defaultSupportedInterfaceNames
+        }],
+    create: (context, [options]) => {
+        const supportedInterfaceNames = options.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.d.ts

@@ -12,5 +12,5 @@ export interface O3rWidgetTagsRuleOption {
     };
 }
 type O3rWidgetRuleErrorId = 'notInConfigurationInterface' | 'notSupportedType' | 'notSupportedParamForType' | 'invalidParamValueType' | 'noParamWithoutWidget' | 'onlyOneWidgetAllowed' | 'duplicatedParam' | 'requiredParamMissing' | 'suggestParamMissing' | 'suggestRemoveDuplicatedO3rWidget' | 'suggestRemoveDuplicatedO3rWidgetParam' | 'suggestAddO3rWidgetTag' | 'suggestReplaceO3rWidgetType';
-declare const _default: TSESLint.RuleModule<O3rWidgetRuleErrorId, O3rWidgetTagsRuleOption[], TSESLint.RuleListener>;
+declare const _default: TSESLint.RuleModule<O3rWidgetRuleErrorId, [Required<O3rWidgetTagsRuleOption>, ...any[]], TSESLint.RuleListener>;
 export default _default;

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

@@ -1,10 +1,13 @@
 "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}*/`;
+const defaultOptions = [{
+        supportedInterfaceNames: utils_1.defaultSupportedInterfaceNames,
+        widgets: {}
+    }];
 exports.default = (0, utils_1.createRule)({
     name: 'o3r-widget-tags',
     meta: {
@@ -24,7 +27,8 @@ exports.default = (0, utils_1.createRule)({
                         type: 'array',
                         items: {
                             type: 'string'
-                        }
+                        },
+                        default: utils_1.defaultSupportedInterfaceNames
                     },
                     widgets: {
                         additionalProperties: {
@@ -66,17 +70,8 @@ exports.default = (0, utils_1.createRule)({
             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'] });
+    defaultOptions,
+    create: (context, [options]) => {
         const supportedO3rWidgets = new Set(Object.keys(options.widgets));
         return {
             // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -125,10 +120,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;