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

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

@@ -1,2 +1,2 @@
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"error" | "indexFile", [], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"error" | "indexFile", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
 export default _default;

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

@@ -20,30 +20,31 @@ exports.default = (0, utils_1.createRule)({
     },
     defaultOptions: [],
     create: (context) => {
-        return {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            ImportDeclaration: (node) => {
-                const importedModules = node.specifiers.filter((specifier) => specifier.local.name.endsWith('Module'));
-                const importPath = node.source.value?.toString();
-                if (importedModules.length && importPath && importPath.startsWith('.') && !importPath.endsWith('.module') && !importPath.endsWith('index')) {
-                    const dirname = path.dirname(context.getFilename());
-                    const importTarget = path.resolve(dirname, importPath);
-                    if (!fs.existsSync(importTarget) || !fs.statSync(importTarget).isDirectory()) {
-                        return;
-                    }
-                    const indexPath = path.resolve(importTarget, 'index.ts');
-                    const indexFileExist = fs.existsSync(indexPath);
-                    const newIndexFilePath = path.join(importPath, 'index')
-                        .replace(/[\\/]/g, '/')
-                        .replace(/^([^.])/, './$1');
-                    context.report({
-                        node,
-                        messageId: 'error',
-                        fix: !indexFileExist ? undefined : (fixer) => {
+        const rule = (node) => {
+            const importedModules = node.specifiers.filter((specifier) => specifier.local.name.endsWith('Module'));
+            const importPath = node.source.value?.toString();
+            if (importedModules.length > 0 && importPath && importPath.startsWith('.') && !importPath.endsWith('.module') && !importPath.endsWith('index')) {
+                const dirname = path.dirname(context.filename);
+                const importTarget = path.resolve(dirname, importPath);
+                if (!fs.existsSync(importTarget) || !fs.statSync(importTarget).isDirectory()) {
+                    return;
+                }
+                const indexPath = path.resolve(importTarget, 'index.ts');
+                const indexFileExist = fs.existsSync(indexPath);
+                const newIndexFilePath = path.join(importPath, 'index')
+                    .replace(/[/\\]/g, '/')
+                    .replace(/^([^.])/, './$1');
+                context.report({
+                    node,
+                    messageId: 'error',
+                    fix: indexFileExist
+                        ? (fixer) => {
                             return fixer.replaceText(node.source, node.source.raw
                                 .replace(importPath, newIndexFilePath));
-                        },
-                        suggest: !indexFileExist ? undefined : [
+                        }
+                        : undefined,
+                    suggest: indexFileExist
+                        ? [
                             {
                                 messageId: 'indexFile',
                                 fix: (fixer) => {
@@ -55,9 +56,12 @@ exports.default = (0, utils_1.createRule)({
                                 }
                             }
                         ]
-                    });
-                }
+                        : undefined
+                });
             }
         };
+        return {
+            ImportDeclaration: rule
+        };
     }
 });

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

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

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@typescript-eslint/utils");
 const utils_2 = require("../../utils");
-const separatorRegExp = /\s*[|&]\s*/;
+const separatorRegExp = /\s*[&|]\s*/;
 exports.default = (0, utils_2.createRule)({
     name: 'no-multiple-type-configuration-property',
     meta: {
@@ -35,14 +35,14 @@ exports.default = (0, utils_2.createRule)({
         }],
     create: (context, [options]) => {
         const supportedInterfaceNames = options.supportedInterfaceNames;
-        const sourceCode = context.getSourceCode();
+        const { sourceCode } = context;
         const rule = (node) => {
             const interfaceDeclNode = node.parent?.parent?.parent?.parent;
             if (!(0, utils_2.isExtendingConfiguration)(interfaceDeclNode, supportedInterfaceNames)) {
                 return; // Not in a configuration interface
             }
             if (node.types.every((type) => type.type === utils_1.TSESTree.AST_NODE_TYPES.TSLiteralType && type.literal.type === utils_1.TSESTree.AST_NODE_TYPES.Literal)
-                && [...(new Set(node.types.map((literalType) => typeof literalType.literal.value)))].length === 1) {
+                && new Set(node.types.map((literalType) => typeof literalType.literal.value)).size === 1) {
                 return; // Only the same literal type
             }
             const text = sourceCode.getText(node);
@@ -61,9 +61,7 @@ exports.default = (0, utils_2.createRule)({
             });
         };
         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

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

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

@@ -45,92 +45,92 @@ exports.default = (0, utils_1.createRule)({
         }],
     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,
+        const ruleForProperties = (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 categories = Array.from(docText.matchAll(/@o3rCategory (\w+)/g)).map((match) => match[1]);
+            if (categories.length === 0) {
+                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,
-                            supportedCategories: Array.from(supportedO3rCategories).join(', ')
+                            suggestedCategory
                         },
-                        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
-                    });
-                }
+                        fix: (fixer) => {
+                            return fixer.replaceTextRange(comment.range, (0, utils_1.createCommentString)(comment.value.replace(`@o3rCategory ${category}`, `@o3rCategory ${suggestedCategory}`)));
+                        }
+                    }))
+                });
+            }
+        };
+        const ruleForInterface = (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 categories = Array.from(docText.matchAll(/@o3rCategories (\w+)/g)).map((match) => match[1]);
+            if (categories.length === 0) {
+                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
+                });
+            }
+        };
+        return {
+            TSPropertySignature: ruleForProperties,
+            TSInterfaceDeclaration: ruleForInterface
         };
     }
 });

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, [Readonly<O3rWidgetTagsRuleOption>, ...any[]], TSESLint.RuleListener>;
+declare const _default: TSESLint.RuleModule<O3rWidgetRuleErrorId, [Readonly<O3rWidgetTagsRuleOption>, ...any[]], unknown, TSESLint.RuleListener>;
 export default _default;