@o3r/eslint-plugin 10.0.0-next.9 → 11.0.0-next.0

package/src/rules/{template-async-number-limitation → template/template-async-number-limitation}/template-async-number-limitation.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.name = void 0;
-const template_utils_1 = require("../template-utils");
 const utils_1 = require("../utils");
+const utils_2 = require("../../utils");
 /** Rule Name */
 exports.name = 'template-async-number-limitation';
 const defaultOptions = [{
         maximumAsyncOnTag: 5
     }];
-exports.default = (0, utils_1.createRule)({
+exports.default = (0, utils_2.createRule)({
     name: exports.name,
     meta: {
         type: 'problem',
@@ -35,9 +35,8 @@ exports.default = (0, utils_1.createRule)({
         fixable: undefined
     },
     defaultOptions,
-    create: (context) => {
-        const parserServices = (0, template_utils_1.getTemplateParserServices)(context);
-        const options = context.options[0] || defaultOptions[0];
+    create: (context, [options]) => {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
         const asyncRegExp = /\| *async\b/g;
         return {
             // eslint-disable-next-line @typescript-eslint/naming-convention

package/src/rules/template/utils.d.ts

@@ -0,0 +1,38 @@
+import { ParserServices, TSESLint } from '@typescript-eslint/experimental-utils';
+/** Position in source code */
+interface SourceSpan {
+    /** starting position */
+    start: {
+        line: number;
+        col: any;
+    };
+    /** ending position */
+    end: {
+        line: number;
+        col: any;
+    };
+}
+/** Basic interface for the Parser Services object provided by @angular-eslint/template-parser */
+interface TemplateParserServices extends ParserServices {
+    /** Set body visitor rule runner */
+    convertElementSourceSpanToLoc: (listenerObj: any) => any;
+    /** Determine the linter notification position based on the node */
+    convertNodeSourceSpanToLoc: (sourceSpan: SourceSpan) => any;
+}
+/**
+ * Determine if @angular-eslint/template-parser is used
+ * @param parserServices Parser services object
+ */
+export declare function isTemplateParserServices(parserServices: any): parserServices is TemplateParserServices;
+/**
+ * Retrieve the template parser services object or throw if the invalid parser is used
+ * @param context Rule context
+ */
+export declare function getTemplateParserServices(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>): TemplateParserServices;
+/**
+ * Utility for rule authors to ensure that their rule is correctly being used with @angular-eslint/template-parser
+ * If @angular-eslint/template-parser is not the configured parser when the function is invoked it will throw
+ * @param context
+ */
+export declare function ensureTemplateParser(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>): void;
+export {};

package/src/rules/{template-utils.js → template/utils.js}

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureTemplateParser = exports.getTemplateParserServices = exports.isTemplateParserServices = void 0;
 /**
  * Determine if @angular-eslint/template-parser is used
- *
  * @param parserServices Parser services object
  */
 function isTemplateParserServices(parserServices) {
@@ -13,7 +12,6 @@ function isTemplateParserServices(parserServices) {
 exports.isTemplateParserServices = isTemplateParserServices;
 /**
  * Retrieve the template parser services object or throw if the invalid parser is used
- *
  * @param context Rule context
  */
 function getTemplateParserServices(context) {
@@ -31,7 +29,6 @@ exports.getTemplateParserServices = getTemplateParserServices;
 /**
  * Utility for rule authors to ensure that their rule is correctly being used with @angular-eslint/template-parser
  * If @angular-eslint/template-parser is not the configured parser when the function is invoked it will throw
- *
  * @param context
  */
 function ensureTemplateParser(context) {

package/src/rules/typescript/matching-configuration-name/matching-configuration-name.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"suggestion" | "error", never[], {
+    CallExpression: (node: TSESTree.CallExpression) => void;
+}>;
+export default _default;

package/src/rules/typescript/matching-configuration-name/matching-configuration-name.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const utils_1 = require("../../utils");
+const nameDeterminingFunctionNames = ['computeItemIdentifier', 'computeConfigurationName'];
+exports.default = (0, utils_1.createRule)({
+    name: 'matching-configuration-name',
+    meta: {
+        hasSuggestions: true,
+        fixable: 'code',
+        type: 'problem',
+        docs: {
+            // eslint-disable-next-line max-len
+            description: 'Ensures that the configuration interface name matches the first parameter of `computeItemIdentifier` (or `computeConfigurationName`) used beside the configuration interface to expose its ID (as generated by the configuration module).',
+            recommended: 'error'
+        },
+        schema: [],
+        messages: {
+            error: '{{currentValue}} does not match: {{possibleValues}}',
+            suggestion: 'Replace {{currentValue}} by {{recommendedValue}}'
+        }
+    },
+    defaultOptions: [],
+    create: (context) => {
+        return {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            CallExpression: (node) => {
+                if (node.callee.type !== experimental_utils_1.TSESTree.AST_NODE_TYPES.Identifier
+                    || !nameDeterminingFunctionNames.includes(node.callee.name)
+                    || !node.arguments.length
+                    || node.arguments[0].type !== experimental_utils_1.TSESTree.AST_NODE_TYPES.Literal
+                    || typeof node.arguments[0].value !== 'string') {
+                    return;
+                }
+                const sourceCode = context.getSourceCode();
+                const interfaceNames = sourceCode.ast.body
+                    .filter((statement) => statement.type === experimental_utils_1.TSESTree.AST_NODE_TYPES.ExportNamedDeclaration
+                    && statement.declaration?.type === experimental_utils_1.TSESTree.AST_NODE_TYPES.TSInterfaceDeclaration
+                    && (statement.declaration.extends || []).some((heritageClause) => heritageClause.expression.type === experimental_utils_1.TSESTree.AST_NODE_TYPES.Identifier
+                        && heritageClause.expression.name === 'Configuration'))
+                    .map((statement) => statement.declaration.id.name);
+                const fnArgInterfaceName = node.arguments[0].value;
+                if (interfaceNames.length && !interfaceNames.includes(fnArgInterfaceName)) {
+                    return context.report({
+                        node: node.arguments[0],
+                        loc: node.arguments[0].loc,
+                        messageId: 'error',
+                        data: {
+                            currentValue: fnArgInterfaceName,
+                            possibleValues: interfaceNames.join(', ')
+                        },
+                        fix: (fixer) => {
+                            return fixer.replaceText(node.arguments[0], `'${interfaceNames[0]}'`);
+                        },
+                        suggest: interfaceNames.map((interfaceName) => ({
+                            messageId: 'suggestion',
+                            data: {
+                                currentValue: fnArgInterfaceName,
+                                recommendedValue: interfaceName
+                            },
+                            fix: (fixer) => {
+                                return fixer.replaceText(node.arguments[0], `'${interfaceName}'`);
+                            }
+                        }))
+                    });
+                }
+            }
+        };
+    }
+});

package/src/rules/typescript/no-folder-import-for-module/no-folder-import-for-module.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"error" | "indexFile", never[], {
+    ImportDeclaration: (node: import("@typescript-eslint/types/dist/generated/ast-spec").ImportDeclaration) => void;
+}>;
+export default _default;

package/src/rules/{no-folder-import-for-module → typescript/no-folder-import-for-module}/no-folder-import-for-module.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require("node:fs");
 const path = require("node:path");
-const utils_1 = require("../utils");
+const utils_1 = require("../../utils");
 exports.default = (0, utils_1.createRule)({
     name: 'no-folder-import-for-module',
     meta: {

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-categories-tags/o3r-categories-tags.d.ts

@@ -0,0 +1,7 @@
+export interface O3rCategoriesTagsRuleOption {
+    supportedInterfaceNames?: string[];
+    globalConfigCategories?: string[];
+}
+type Messages = 'alreadyDefined' | 'undefinedCategory' | 'onlyOneCategoryAllowed' | 'notInConfigurationInterface' | 'suggestReplaceO3rCategory';
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<Messages, [O3rCategoriesTagsRuleOption, ...any[]], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default _default;

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+exports.default = (0, utils_1.createRule)({
+    name: 'o3r-categories-tags',
+    meta: {
+        hasSuggestions: true,
+        fixable: 'code',
+        type: 'problem',
+        docs: {
+            description: 'Ensures that @o3rCategories and @o3rCategory are used with correct value',
+            recommended: 'error'
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    supportedInterfaceNames: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        default: utils_1.defaultSupportedInterfaceNames
+                    },
+                    globalConfigCategories: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        default: []
+                    }
+                }
+            }
+        ],
+        messages: {
+            alreadyDefined: '{{ currentCategory }} is already defined globally.',
+            undefinedCategory: '{{ currentCategory }} is not supported. Supported @o3rCategory: {{ supportedCategories }}.',
+            onlyOneCategoryAllowed: '@o3rCategory must be defined only once.',
+            notInConfigurationInterface: '@o3rCategory and @o3rCategories can only be used in `Configuration` interface.',
+            suggestReplaceO3rCategory: 'Replace {{ currentCategory }} by {{ suggestedCategory }}.'
+        }
+    },
+    defaultOptions: [{
+            supportedInterfaceNames: utils_1.defaultSupportedInterfaceNames,
+            globalConfigCategories: []
+        }],
+    create: (context, [options]) => {
+        const globalConfigCategories = new Set(options.globalConfigCategories);
+        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 categories = Array.from(docText.matchAll(/@o3rCategory (\w+)/g)).map((match) => match[1]);
+                if (categories.length < 1) {
+                    return;
+                }
+                else if (categories.length > 1) {
+                    return context.report({
+                        messageId: 'onlyOneCategoryAllowed',
+                        node,
+                        loc
+                    });
+                }
+                const category = categories[0];
+                const interfaceDeclNode = node.parent?.parent;
+                if (!(0, utils_1.isExtendingConfiguration)(interfaceDeclNode, options.supportedInterfaceNames)) {
+                    return context.report({
+                        messageId: 'notInConfigurationInterface',
+                        node,
+                        loc
+                    });
+                }
+                const interfaceComment = (0, utils_1.getNodeComment)(interfaceDeclNode, sourceCode);
+                const supportedO3rCategories = new Set(options.globalConfigCategories);
+                Array.from(interfaceComment?.value.matchAll(/@o3rCategories (\w+)/g) || []).forEach((match) => supportedO3rCategories.add(match[1]));
+                if (!supportedO3rCategories.has(category)) {
+                    return context.report({
+                        messageId: 'undefinedCategory',
+                        node,
+                        loc,
+                        data: {
+                            currentCategory: category,
+                            supportedCategories: Array.from(supportedO3rCategories).join(', ')
+                        },
+                        suggest: Array.from(supportedO3rCategories).map((suggestedCategory) => ({
+                            messageId: 'suggestReplaceO3rCategory',
+                            data: {
+                                currentCategory: category,
+                                suggestedCategory: suggestedCategory
+                            },
+                            fix: (fixer) => {
+                                return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(`@o3rCategory ${category}`, `@o3rCategory ${suggestedCategory}`)));
+                            }
+                        }))
+                    });
+                }
+            },
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            TSInterfaceDeclaration: (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 categories = Array.from(docText.matchAll(/@o3rCategories (\w+)/g)).map((match) => match[1]);
+                if (categories.length < 1) {
+                    return;
+                }
+                if (!(0, utils_1.isExtendingConfiguration)(node, options.supportedInterfaceNames)) {
+                    return context.report({
+                        messageId: 'notInConfigurationInterface',
+                        node,
+                        loc
+                    });
+                }
+                const alreadyDefined = categories.find((category) => globalConfigCategories.has(category));
+                if (alreadyDefined) {
+                    return context.report({
+                        messageId: 'alreadyDefined',
+                        fix: (fixer) => fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(new RegExp(`.*@o3rCategories ${alreadyDefined}.*\n`), ''))),
+                        data: {
+                            currentCategory: alreadyDefined
+                        },
+                        node,
+                        loc
+                    });
+                }
+            }
+        };
+    }
+});

package/src/rules/typescript/o3r-widget-tags/o3r-widget-tags.d.ts

@@ -0,0 +1,16 @@
+import { TSESLint } from '@typescript-eslint/experimental-utils';
+type O3rWidgetParamType = 'string' | 'number' | 'boolean' | 'string[]' | 'number[]' | 'boolean[]';
+export interface O3rWidgetTagsRuleOption {
+    supportedInterfaceNames?: string[];
+    widgets: {
+        [widgetName: string]: {
+            [paramName: string]: {
+                type: O3rWidgetParamType;
+                required?: boolean;
+            };
+        };
+    };
+}
+type O3rWidgetRuleErrorId = 'notInConfigurationInterface' | 'notSupportedType' | 'notSupportedParamForType' | 'invalidParamValueType' | 'noParamWithoutWidget' | 'onlyOneWidgetAllowed' | 'duplicatedParam' | 'requiredParamMissing' | 'suggestParamMissing' | 'suggestRemoveDuplicatedO3rWidget' | 'suggestRemoveDuplicatedO3rWidgetParam' | 'suggestAddO3rWidgetTag' | 'suggestReplaceO3rWidgetType';
+declare const _default: TSESLint.RuleModule<O3rWidgetRuleErrorId, [Required<O3rWidgetTagsRuleOption>, ...any[]], TSESLint.RuleListener>;
+export default _default;