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

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

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const o3rWidgetParameterPattern = '^[a-zA-Z0-9-_:.]+$';
+const o3rWidgetParamTypes = ['string', 'number', 'boolean', 'string[]', 'number[]', 'boolean[]'];
+const defaultOptions = [{
+        supportedInterfaceNames: utils_1.defaultSupportedInterfaceNames,
+        widgets: {}
+    }];
+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'
+                        },
+                        default: utils_1.defaultSupportedInterfaceNames
+                    },
+                    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, [options]) => {
+        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 = (0, utils_1.getNodeComment)(node, sourceCode);
+                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, (0, utils_1.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, (0, utils_1.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 (!(0, utils_1.isExtendingConfiguration)(interfaceDeclNode, options.supportedInterfaceNames)) {
+                    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, (0, utils_1.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, (0, utils_1.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, (0, utils_1.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, (0, utils_1.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
+                        }
+                    });
+                }
+            }
+        };
+    }
+});

package/src/rules/utils.d.ts

@@ -0,0 +1,22 @@
+import { ESLintUtils, TSESLint, TSESTree } from '@typescript-eslint/experimental-utils';
+/** ESLint rule generator */
+export declare const createRule: <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends TSESLint.RuleListener = TSESLint.RuleListener>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<TOptions, TMessageIds, TRuleListener>>) => TSESLint.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[]) => interfaceDeclNode is TSESTree.Node;
+/**
+ * Returns the comment above the node
+ * @param node
+ * @param sourceCode
+ */
+export declare const getNodeComment: (node: TSESTree.Node, sourceCode: TSESLint.SourceCode) => TSESTree.Comment | undefined;
+/**
+ * Wraps `commentValue` into a comment
+ * @param commentValue
+ */
+export declare const createCommentString: (commentValue: string) => string;

package/src/rules/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRule = void 0;
+exports.createCommentString = exports.getNodeComment = 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,36 @@ 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;
+/**
+ * Returns the comment above the node
+ * @param node
+ * @param sourceCode
+ */
+const getNodeComment = (node, sourceCode) => {
+    const [comment] = node.parent?.type === experimental_utils_1.TSESTree.AST_NODE_TYPES.ExportNamedDeclaration
+        ? sourceCode.getCommentsBefore(node.parent)
+        : sourceCode.getCommentsBefore(node);
+    return comment;
+};
+exports.getNodeComment = getNodeComment;
+/**
+ * Wraps `commentValue` into a comment
+ * @param commentValue
+ */
+const createCommentString = (commentValue) => `/*${commentValue.replace(/\*\//g, '*\\/')}*/`;
+exports.createCommentString = createCommentString;

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

@@ -0,0 +1,22 @@
+import { ParserServices, TSESLint } from '@typescript-eslint/experimental-utils';
+/** Basic interface for the Parser Services object provided by yaml-eslint-parser */
+interface YamlParserServices extends ParserServices {
+    isYAML: boolean;
+}
+/**
+ * Determine if yaml-eslint-parser is used
+ * @param parserServices Parser services object
+ */
+export declare function isYamlParserServices(parserServices: any): parserServices is YamlParserServices;
+/**
+ * Retrieve the yaml parser services object or throw if the invalid parser is used
+ * @param context Rule context
+ */
+export declare function getYamlParserServices(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>): YamlParserServices;
+/**
+ * Utility for rule authors to ensure that their rule is correctly being used with yaml-eslint-parser
+ * If yaml-eslint-parser is not the configured parser when the function is invoked it will throw
+ * @param context
+ */
+export declare function ensureJsoncParser(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>): void;
+export {};

package/src/rules/yaml/utils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureJsoncParser = exports.getYamlParserServices = exports.isYamlParserServices = void 0;
+/**
+ * Determine if yaml-eslint-parser is used
+ * @param parserServices Parser services object
+ */
+function isYamlParserServices(parserServices) {
+    return !!parserServices && parserServices.isYAML;
+}
+exports.isYamlParserServices = isYamlParserServices;
+/**
+ * Retrieve the yaml parser services object or throw if the invalid parser is used
+ * @param context Rule context
+ */
+function getYamlParserServices(context) {
+    const parserService = context.parserServices;
+    if (!isYamlParserServices(parserService)) {
+        /*
+         * The user needs to have configured "parser" in their eslint config and set it
+         * to yaml-eslint-parser
+         */
+        throw new Error('You have used a rule which requires \'yaml-eslint-parser\' to be used as the \'parser\' in your ESLint config.');
+    }
+    return parserService;
+}
+exports.getYamlParserServices = getYamlParserServices;
+/**
+ * Utility for rule authors to ensure that their rule is correctly being used with yaml-eslint-parser
+ * If yaml-eslint-parser is not the configured parser when the function is invoked it will throw
+ * @param context
+ */
+function ensureJsoncParser(context) {
+    if (!(context.parserServices)) {
+        /*
+         * The user needs to have configured "parser" in their eslint config and set it
+         * to yaml-eslint-parser
+         */
+        throw new Error('You have used a rule which requires \'yaml-eslint-parser\' to be used as the \'parser\' in your ESLint config.');
+    }
+}
+exports.ensureJsoncParser = ensureJsoncParser;

package/src/rules/yaml/yarnrc-package-extensions-harmonize/yarnrc-package-extensions-harmonize.d.ts

@@ -0,0 +1,12 @@
+interface Options {
+    /** List of package.json to ignore when determining the dependencies versions */
+    excludePackages: string[];
+    /** List of dependency types in package.json to parse */
+    dependencyTypesInPackages: string[];
+    /** List of dependencies to ignore */
+    ignoredDependencies: string[];
+    /** List of dependency types to validate in .yarnrc.yml */
+    yarnrcDependencyTypes: string[];
+}
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"error" | "versionUpdate", [Options, ...any[]], any>;
+export default _default;

package/src/rules/yaml/yarnrc-package-extensions-harmonize/yarnrc-package-extensions-harmonize.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("node:path");
+const semver = require("semver");
+const utils_1 = require("../../utils");
+const utils_2 = require("../utils");
+const yaml_eslint_parser_1 = require("yaml-eslint-parser");
+const version_harmonize_1 = require("../../json/json-dependency-versions-harmonize/version-harmonize");
+const defaultOptions = [{
+        ignoredDependencies: [],
+        excludePackages: [],
+        yarnrcDependencyTypes: ['peerDependencies', 'dependencies'],
+        dependencyTypesInPackages: ['optionalDependencies', 'dependencies', 'devDependencies', 'peerDependencies', 'generatorDependencies']
+    }];
+exports.default = (0, utils_1.createRule)({
+    name: 'yarnrc-package-extensions-harmonize',
+    meta: {
+        hasSuggestions: true,
+        type: 'problem',
+        docs: {
+            description: 'Ensure that the package extension versions are aligned with range defined in packages.',
+            recommended: 'error'
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    excludePackages: {
+                        type: 'array',
+                        description: 'List of package.json to ignore when determining the dependencies versions',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    yarnrcDependencyTypes: {
+                        type: 'array',
+                        description: 'List of dependency types to validate in .yarnrc.yml',
+                        default: defaultOptions[0].yarnrcDependencyTypes,
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    dependencyTypesInPackages: {
+                        type: 'array',
+                        description: 'List of dependency types in package.json to parse',
+                        default: defaultOptions[0].dependencyTypesInPackages,
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    ignoredDependencies: {
+                        type: 'array',
+                        description: 'List of dependencies to ignore',
+                        items: {
+                            type: 'string'
+                        }
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        messages: {
+            versionUpdate: 'Set version {{version}}',
+            error: '{{depName}} should be updated to version {{version}} (from: {{packageJsonFile}})'
+        },
+        fixable: 'code'
+    },
+    defaultOptions,
+    create: (context, [options]) => {
+        const parserServices = (0, utils_2.getYamlParserServices)(context);
+        const dirname = path.dirname(context.getFilename());
+        const workspace = (0, version_harmonize_1.findWorkspacePackageJsons)(dirname);
+        const bestRanges = workspace ?
+            (0, version_harmonize_1.getBestRanges)(options.dependencyTypesInPackages, workspace.packages.filter(({ content }) => !content.name || !options.excludePackages.includes(content.name))) :
+            {};
+        const ignoredDependencies = options.ignoredDependencies.map((dep) => new RegExp(dep.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')));
+        if (parserServices.isYAML) {
+            return {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'YAMLPair': (node) => {
+                    if (node.value) {
+                        const range = (0, yaml_eslint_parser_1.getStaticYAMLValue)(node.value)?.toString();
+                        const parent = node.parent.parent && node.parent.parent.type === 'YAMLPair' && (0, yaml_eslint_parser_1.getStaticYAMLValue)(node.parent.parent.key)?.toString();
+                        const baseNode = node.parent.parent.parent.parent?.parent?.parent;
+                        const isCorrectNode = baseNode && baseNode.type === 'YAMLPair' && (0, yaml_eslint_parser_1.getStaticYAMLValue)(baseNode.key)?.toString() === 'packageExtensions';
+                        if (isCorrectNode && semver.validRange(range) && parent && options.yarnrcDependencyTypes.some((t) => t === parent)) {
+                            const depName = node.key && (0, yaml_eslint_parser_1.getStaticYAMLValue)(node.key)?.toString();
+                            if (!depName || !bestRanges[depName] || ignoredDependencies.some((ignore) => ignore.test(depName))) {
+                                return;
+                            }
+                            const minYarnrcVersion = semver.minVersion(range);
+                            const minBestRangeVersion = semver.minVersion(bestRanges[depName].range);
+                            if (minYarnrcVersion && minBestRangeVersion && semver.lt(minYarnrcVersion, minBestRangeVersion)) {
+                                const version = bestRanges[depName].range;
+                                const packageJsonFile = bestRanges[depName].path;
+                                context.report({
+                                    loc: node.value.loc,
+                                    messageId: 'error',
+                                    data: {
+                                        depName,
+                                        version,
+                                        packageJsonFile
+                                    },
+                                    fix: (fixer) => fixer.replaceTextRange(node.value.range, `${version}`),
+                                    suggest: [
+                                        {
+                                            messageId: 'versionUpdate',
+                                            data: {
+                                                version
+                                            },
+                                            fix: (fixer) => fixer.replaceTextRange(node.value.range, `${version}`)
+                                        }
+                                    ]
+                                });
+                            }
+                        }
+                    }
+                }
+            };
+        }
+    }
+});

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.2.2"}

package/schematics/ng-add/schema.json

@@ -1,18 +0,0 @@
-{
-  "$schema": "http://json-schema.org/schema",
-  "$id": "ngAddSchematicsSchema",
-  "title": "Add Otter eslint-plugin ",
-  "description": "ngAdd Otter eslint-plugin ",
-  "properties": {
-    "projectName": {
-      "type": "string",
-      "description": "Project name",
-      "$default": {
-        "$source": "projectName"
-      }
-    }
-  },
-  "additionalProperties": false,
-  "required": [
-  ]
-}