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

package/README.md

@@ -1,6 +1,6 @@
 <h1 align="center">Otter eslint plugin</h1>
 <p align="center">
-  <img src="https://raw.githubusercontent.com/AmadeusITGroup/otter/main/.attachments/otter.png" alt="Super cute Otter!" width="40%"/>
+  <img src="https://raw.githubusercontent.com/AmadeusITGroup/otter/main/assets/logo/otter.png" alt="Super cute Otter!" width="40%"/>
 </p>
 
 This package is an [Otter Framework Module](https://github.com/AmadeusITGroup/otter/tree/main/docs/core/MODULE.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o3r/eslint-plugin",
-  "version": "10.0.0-next.9",
+  "version": "11.0.0-next.0",
   "description": "The module provides in-house eslint plugins to use in your own eslint configuration.",
   "main": "./src/public_api.js",
   "keywords": [
@@ -17,55 +17,69 @@
     "build": "yarn nx build eslint-plugin",
     "postbuild": "patch-package-json-main",
     "prepare:publish": "prepare-publish ./dist",
-    "prepare:build:builders": "yarn cpy 'schematics/**/*.json' dist/schematics && yarn cpy 'collection.json' dist",
+    "prepare:build:builders": "yarn cpy './collection.json' dist",
     "build:builders": "tsc -b tsconfig.builders.json --pretty && yarn generate-cjs-manifest"
   },
   "dependencies": {
     "@typescript-eslint/experimental-utils": "^5.3.0",
+    "globby": "^11.1.0",
+    "semver": "^7.5.2",
     "tslib": "^2.5.3"
   },
   "peerDependenciesMeta": {
     "@angular-eslint/template-parser": {
       "optional": true
+    },
+    "jsonc-eslint-parser": {
+      "optional": true
+    },
+    "yaml-eslint-parser": {
+      "optional": true
     }
   },
   "peerDependencies": {
-    "@angular-eslint/template-parser": "~16.1.0",
-    "@angular-eslint/utils": "~16.1.0",
-    "@angular/compiler": "~16.2.0",
-    "@typescript-eslint/eslint-plugin": "^5.9.0",
-    "@typescript-eslint/parser": "^5.9.0",
-    "eslint": "^8.22.0"
+    "@angular-eslint/template-parser": "~17.1.0",
+    "@angular-eslint/utils": "~17.1.0",
+    "@angular/compiler": "~17.0.2",
+    "@typescript-eslint/eslint-plugin": "^6.11.0",
+    "@typescript-eslint/parser": "^6.11.0",
+    "eslint": "^8.22.0",
+    "jsonc-eslint-parser": "~2.4.0",
+    "yaml-eslint-parser": "^1.2.2"
   },
   "devDependencies": {
-    "@angular-devkit/core": "~16.2.0",
-    "@angular-devkit/schematics": "~16.2.0",
-    "@angular-eslint/eslint-plugin": "~16.1.0",
-    "@angular-eslint/template-parser": "~16.1.0",
-    "@angular-eslint/utils": "~16.1.0",
-    "@angular/compiler": "~16.2.0",
-    "@babel/core": "~7.22.0",
-    "@babel/preset-typescript": "~7.22.0",
+    "@angular-devkit/core": "~17.0.3",
+    "@angular-devkit/schematics": "~17.0.3",
+    "@angular-eslint/eslint-plugin": "~17.1.0",
+    "@angular-eslint/template-parser": "~17.1.0",
+    "@angular-eslint/utils": "~17.1.0",
+    "@angular/compiler": "~17.0.4",
+    "@babel/core": "~7.23.0",
+    "@babel/preset-typescript": "~7.23.0",
     "@compodoc/compodoc": "^1.1.19",
-    "@nx/jest": "~16.8.0",
-    "@o3r/build-helpers": "^10.0.0-next.9",
-    "@o3r/eslint-plugin": "^10.0.0-next.9",
+    "@nx/eslint-plugin": "~17.1.1",
+    "@nx/jest": "~17.1.1",
+    "@o3r/build-helpers": "^11.0.0-next.0",
     "@types/jest": "~29.5.2",
-    "@types/node": "^18.0.0",
-    "@typescript-eslint/eslint-plugin": "^5.59.9",
-    "@typescript-eslint/parser": "^5.59.9",
-    "cpy-cli": "^4.2.0",
+    "@types/node": "^20.0.0",
+    "@types/semver": "^7.3.13",
+    "@typescript-eslint/eslint-plugin": "6.11.0",
+    "@typescript-eslint/parser": "^6.11.0",
+    "cpy-cli": "^5.0.0",
     "eslint": "^8.42.0",
-    "eslint-plugin-jest": "~27.2.3",
-    "eslint-plugin-jsdoc": "~46.8.0",
+    "eslint-plugin-jest": "~27.6.0",
+    "eslint-plugin-jsdoc": "~48.0.0",
     "eslint-plugin-prefer-arrow": "~1.2.3",
-    "eslint-plugin-unicorn": "^47.0.0",
+    "eslint-plugin-unicorn": "^50.0.0",
     "jest": "~29.7.0",
     "jest-junit": "~16.0.0",
-    "nx": "~16.8.0",
+    "jsonc-eslint-parser": "~2.4.0",
+    "nx": "~17.1.1",
     "rimraf": "^5.0.1",
     "ts-jest": "~29.1.1",
-    "typescript": "~5.1.6"
+    "type-fest": "^4.3.1",
+    "typescript": "~5.2.2",
+    "yaml-eslint-parser": "^1.2.2"
   },
   "schematics": "./collection.json",
   "type": "commonjs",
@@ -132,5 +146,6 @@
   ],
   "bugs": "https://github.com/AmadeusITGroup/otter/issues",
   "repository": "https://github.com/AmadeusITGroup/otter",
-  "license": "BSD-3-Clause"
+  "license": "BSD-3-Clause",
+  "homepage": "https://amadeusitgroup.github.io/otter/"
 }

package/src/index.d.ts

@@ -0,0 +1 @@
+export {};

package/src/index.js

@@ -1,19 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/naming-convention */
-const no_folder_import_for_module_1 = require("./rules/no-folder-import-for-module/no-folder-import-for-module");
-const template_async_number_limitation_1 = require("./rules/template-async-number-limitation/template-async-number-limitation");
+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 yarnrc_package_extensions_harmonize_1 = require("./rules/yaml/yarnrc-package-extensions-harmonize/yarnrc-package-extensions-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");
+const o3r_categories_tags_1 = require("./rules/typescript/o3r-categories-tags/o3r-categories-tags");
 module.exports = {
     rules: {
         'no-folder-import-for-module': no_folder_import_for_module_1.default,
-        'template-async-number-limitation': template_async_number_limitation_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,
+        'yarnrc-package-extensions-harmonize': yarnrc_package_extensions_harmonize_1.default,
+        'no-multiple-type-configuration-property': no_multiple_type_configuration_property_1.default,
+        'o3r-categories-tags': o3r_categories_tags_1.default
     },
     configs: {
         '@o3r/no-folder-import-for-module': 'error',
+        '@o3r/o3r-categories-tags': '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/o3r-categories-tags': 'error',
                 '@o3r/template-async-number-limitation': 'off'
             }
         },
@@ -22,6 +43,16 @@ module.exports = {
                 '@o3r/no-folder-import-for-module': 'error',
                 '@o3r/template-async-number-limitation': 'warn'
             }
+        },
+        'json-recommended': {
+            rules: {
+                '@o3r/json-dependency-versions-harmonize': 'error'
+            }
+        },
+        'yarn-recommended': {
+            rules: {
+                '@o3r/yarnrc-package-extensions-harmonize': 'error'
+            }
         }
     }
 };

package/src/public_api.d.ts

@@ -0,0 +1 @@
+export * from './index';

package/src/rules/json/json-dependency-versions-harmonize/json-dependency-versions-harmonize.d.ts

@@ -0,0 +1,15 @@
+interface Options {
+    /** List of package name to ignore when determining the dependencies versions */
+    ignoredPackages: string[];
+    /** List of dependencies to ignore */
+    ignoredDependencies: string[];
+    /** List of dependency types to update */
+    dependencyTypes: string[];
+    /**
+     * Enforce to align the version of the dependencies with the latest range.
+     * If not set, the version will be aligned with the latest range if the latest range is not intersected with the current range.
+     */
+    alignPeerDependencies: boolean;
+}
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"error" | "versionUpdate", [Options, ...any[]], any>;
+export default _default;

package/src/rules/json/json-dependency-versions-harmonize/json-dependency-versions-harmonize.js

@@ -0,0 +1,123 @@
+"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 version_harmonize_1 = require("./version-harmonize");
+const defaultOptions = [{
+        ignoredDependencies: [],
+        dependencyTypes: ['optionalDependencies', 'dependencies', 'devDependencies', 'peerDependencies', 'generatorDependencies'],
+        alignPeerDependencies: false,
+        ignoredPackages: []
+    }];
+exports.default = (0, utils_1.createRule)({
+    name: 'json-dependency-versions-harmonize',
+    meta: {
+        hasSuggestions: true,
+        type: 'problem',
+        docs: {
+            description: 'Ensure that the package dependency versions are aligned with the other package of the workspace.',
+            recommended: 'error'
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    alignPeerDependencies: {
+                        type: 'boolean',
+                        description: 'Enforce to align the version of the dependencies with the latest range.'
+                    },
+                    dependencyTypes: {
+                        type: 'array',
+                        description: 'List of dependency types to update',
+                        default: defaultOptions[0].dependencyTypes,
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    ignoredDependencies: {
+                        type: 'array',
+                        description: 'List of dependencies to ignore',
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    ignoredPackages: {
+                        type: 'array',
+                        description: 'List of package name to ignore when determining the dependencies versions',
+                        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.getJsoncParserServices)(context);
+        const dirname = path.dirname(context.getFilename());
+        const workspace = (0, version_harmonize_1.findWorkspacePackageJsons)(dirname);
+        const bestRanges = workspace && (0, version_harmonize_1.getBestRanges)(options.dependencyTypes, workspace.packages.filter(({ content }) => !content.name || !options.ignoredPackages.includes(content.name)));
+        const ignoredDependencies = options.ignoredDependencies.map((dep) => new RegExp(dep.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')));
+        if (parserServices.isJSON) {
+            return {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'JSONExpressionStatement': (node) => {
+                    if (node.expression.type === 'JSONObjectExpression') {
+                        const deps = node.expression.properties
+                            .filter(({ key }) => options.dependencyTypes.includes(key.type === 'JSONLiteral' ? key.value.toString() : key.name));
+                        if (deps.length > 0 && bestRanges) {
+                            deps
+                                .map((depGroup) => depGroup.value)
+                                .filter((depGroup) => depGroup.type === 'JSONObjectExpression')
+                                .forEach((depGroup) => {
+                                depGroup.properties.forEach((dep) => {
+                                    const name = dep.key.type === 'JSONLiteral' ? dep.key.value.toString() : dep.key.name;
+                                    if (ignoredDependencies.some((ignore) => ignore.test(name))) {
+                                        return;
+                                    }
+                                    const range = dep.value.type === 'JSONLiteral' ? dep.value.value : (dep.value.type === 'JSONIdentifier' ? dep.value.name : undefined);
+                                    const bestRange = (0, version_harmonize_1.getBestRange)(range, bestRanges[name]?.range);
+                                    if (bestRange && bestRange !== range) {
+                                        if (!options.alignPeerDependencies && depGroup.parent.type === 'JSONProperty' && range &&
+                                            (depGroup.parent.key.type === 'JSONLiteral' ? depGroup.parent.key.value.toString() : depGroup.parent.key.name) === 'peerDependencies' &&
+                                            semver.subset(bestRange, range)) {
+                                            return;
+                                        }
+                                        context.report({
+                                            loc: dep.value.loc,
+                                            messageId: 'error',
+                                            data: {
+                                                depName: name,
+                                                version: bestRange,
+                                                packageJsonFile: bestRanges[name].path
+                                            },
+                                            fix: (fixer) => fixer.replaceTextRange(dep.value.range, `"${bestRange}"`),
+                                            suggest: [
+                                                {
+                                                    messageId: 'versionUpdate',
+                                                    data: {
+                                                        version: bestRange
+                                                    },
+                                                    fix: (fixer) => fixer.replaceTextRange(dep.value.range, `"${bestRange}"`)
+                                                }
+                                            ]
+                                        });
+                                    }
+                                });
+                            });
+                        }
+                    }
+                }
+            };
+        }
+    }
+});

package/src/rules/json/json-dependency-versions-harmonize/version-harmonize.d.ts

@@ -0,0 +1,40 @@
+import type { PackageJson } from 'type-fest';
+/** List of packages information resulting of a package.json discovery */
+export interface PackageProperty {
+    /** List of package.json file information */
+    packages: {
+        /** Parsed package.json content */
+        content: PackageJson;
+        /** Path to the file */
+        path: string;
+        /** Determine if the package.json has a workspace information */
+        isWorkspace?: boolean;
+    }[];
+    /** Determine if the package.json collection is the result of a default strategy (in the case no matching workspace has been found) */
+    hasDefaulted?: boolean;
+}
+/** Range discovered for a given dependency */
+export interface RangeInformation {
+    /** Range as specified in the package.json dependencies */
+    range: string;
+    /** Path to the original package.json */
+    path: string;
+}
+/**
+ * Find the closest package.json file containing workspace definition in the parent directories
+ * @param directory Current directory to search for
+ * @param rootDir First directory of the recursion
+ */
+export declare const findWorkspacePackageJsons: (directory: string, rootDir?: string) => PackageProperty | undefined;
+/**
+ * Compare and return the best range in the both given onces
+ * @param currentRange Current range in the memory stack
+ * @param range Range to compare the current one to
+ */
+export declare const getBestRange: (currentRange?: string, range?: string) => string | undefined;
+/**
+ * Retrieve the best ranges for each dependencies in the given package.json files
+ * @param dependencyTypes Type of dependency files to analyze
+ * @param packages List of the package.json files
+ */
+export declare const getBestRanges: (dependencyTypes: string[], packages: PackageProperty['packages']) => Record<string, RangeInformation>;

package/src/rules/json/json-dependency-versions-harmonize/version-harmonize.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBestRanges = exports.getBestRange = exports.findWorkspacePackageJsons = void 0;
+const semver = require("semver");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const globby_1 = require("globby");
+/**
+ * Find the closest package.json file containing workspace definition in the parent directories
+ * @param directory Current directory to search for
+ * @param rootDir First directory of the recursion
+ */
+const findWorkspacePackageJsons = (directory, rootDir) => {
+    const parentFolder = (0, node_path_1.dirname)(directory);
+    rootDir ||= directory;
+    if (parentFolder === directory) {
+        return undefined;
+    }
+    const packageJsonPath = (0, node_path_1.resolve)(directory, 'package.json');
+    const content = (0, node_fs_1.existsSync)(packageJsonPath) && JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, { encoding: 'utf-8' }));
+    if (!content || !content.workspaces) {
+        return (0, exports.findWorkspacePackageJsons)(parentFolder, rootDir);
+    }
+    const packagePaths = (0, globby_1.sync)((Array.isArray(content.workspaces) ? content.workspaces : content.workspaces.packages || []).map((f) => node_path_1.posix.join(f, 'package.json')), { cwd: directory, onlyFiles: false, absolute: true });
+    const isPackageWorkspace = packagePaths.some((workspacePath) => (0, node_path_1.normalize)(workspacePath) === rootDir);
+    const getPackages = () => ([
+        { content, path: packageJsonPath, isWorkspace: true },
+        ...packagePaths.map((subPackageJsonPath) => ({ content: JSON.parse((0, node_fs_1.readFileSync)(subPackageJsonPath, { encoding: 'utf-8' })), path: subPackageJsonPath }))
+    ]);
+    if (isPackageWorkspace) {
+        return {
+            packages: getPackages()
+        };
+    }
+    else { // In case we discover a workspace for which the package is not part of
+        const parent = (0, exports.findWorkspacePackageJsons)(parentFolder, rootDir);
+        if (!parent || parent.hasDefaulted) {
+            return {
+                hasDefaulted: true,
+                packages: getPackages()
+            };
+        }
+    }
+};
+exports.findWorkspacePackageJsons = findWorkspacePackageJsons;
+/**
+ * Compare and return the best range in the both given onces
+ * @param currentRange Current range in the memory stack
+ * @param range Range to compare the current one to
+ */
+const getBestRange = (currentRange, range) => {
+    if (!range || !semver.validRange(range)) {
+        return currentRange && semver.validRange(currentRange) ? currentRange : undefined;
+    }
+    if (!currentRange || !semver.validRange(currentRange)) {
+        return range;
+    }
+    if (currentRange !== range) {
+        const minVersion = semver.minVersion(range);
+        const currentMinVersion = semver.minVersion(currentRange);
+        if (semver.gt(minVersion, currentMinVersion)) {
+            return range;
+        }
+        else if (semver.eq(minVersion, currentMinVersion) && semver.subset(range, currentRange)) {
+            return range;
+        }
+    }
+    return currentRange;
+};
+exports.getBestRange = getBestRange;
+/**
+ * Retrieve the best ranges for each dependencies in the given package.json files
+ * @param dependencyTypes Type of dependency files to analyze
+ * @param packages List of the package.json files
+ */
+const getBestRanges = (dependencyTypes, packages) => {
+    return packages.reduce((acc, pck) => {
+        dependencyTypes.forEach((depType) => {
+            const dependencies = pck.content[depType];
+            if (dependencies) {
+                Object.entries(dependencies).forEach(([depName, range]) => {
+                    if (!acc[depName]) {
+                        if (range) {
+                            acc[depName] = { range, path: (0, node_path_1.normalize)(pck.path) };
+                        }
+                    }
+                    else if ((0, exports.getBestRange)(acc[depName].range, range) !== acc[depName].range) {
+                        acc[depName] = { range: range, path: (0, node_path_1.normalize)(pck.path) };
+                    }
+                });
+            }
+        });
+        return acc;
+    }, {});
+};
+exports.getBestRanges = getBestRanges;

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

@@ -0,0 +1,39 @@
+import { ParserServices, TSESLint } from '@typescript-eslint/experimental-utils';
+import type { AST } from 'jsonc-eslint-parser';
+/** Basic interface for the Parser Services object provided by jsonc-eslint-parser */
+interface JsoncParserServices extends ParserServices {
+    isJSON: boolean;
+}
+/**
+ * Determine if jsonc-eslint-parser is used
+ * @param parserServices Parser services object
+ */
+export declare function isJsoncParserServices(parserServices: any): parserServices is JsoncParserServices;
+/**
+ *
+ * @param node
+ * @param node.type
+ */
+export declare function isProperty(node?: {
+    type: string;
+}): node is AST.JSONProperty;
+/**
+ *
+ * @param node
+ * @param node.type
+ */
+export declare function isObjectExpression(node?: {
+    type: string;
+}): node is AST.JSONObjectExpression;
+/**
+ * Retrieve the json parser services object or throw if the invalid parser is used
+ * @param context Rule context
+ */
+export declare function getJsoncParserServices(context: Readonly<TSESLint.RuleContext<string, readonly unknown[]>>): JsoncParserServices;
+/**
+ * Utility for rule authors to ensure that their rule is correctly being used with jsonc-eslint-parser
+ * If jsonc-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/json/utils.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureJsoncParser = exports.getJsoncParserServices = exports.isObjectExpression = exports.isProperty = exports.isJsoncParserServices = void 0;
+/**
+ * Determine if jsonc-eslint-parser is used
+ * @param parserServices Parser services object
+ */
+function isJsoncParserServices(parserServices) {
+    return !!parserServices && typeof parserServices.isJSON !== undefined;
+}
+exports.isJsoncParserServices = isJsoncParserServices;
+/**
+ *
+ * @param node
+ * @param node.type
+ */
+function isProperty(node) {
+    return !!node && node.type !== 'JSONProperty';
+}
+exports.isProperty = isProperty;
+/**
+ *
+ * @param node
+ * @param node.type
+ */
+function isObjectExpression(node) {
+    return !!node && node.type !== 'JSONObjectExpression';
+}
+exports.isObjectExpression = isObjectExpression;
+/**
+ * Retrieve the json parser services object or throw if the invalid parser is used
+ * @param context Rule context
+ */
+function getJsoncParserServices(context) {
+    const parserService = context.parserServices;
+    if (!isJsoncParserServices(parserService)) {
+        /*
+         * The user needs to have configured "parser" in their eslint config and set it
+         * to jsonc-eslint-parser
+         */
+        throw new Error('You have used a rule which requires \'jsonc-eslint-parser\' to be used as the \'parser\' in your ESLint config.');
+    }
+    return parserService;
+}
+exports.getJsoncParserServices = getJsoncParserServices;
+/**
+ * Utility for rule authors to ensure that their rule is correctly being used with jsonc-eslint-parser
+ * If jsonc-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 jsonc-eslint-parser
+         */
+        throw new Error('You have used a rule which requires \'jsonc-eslint-parser\' to be used as the \'parser\' in your ESLint config.');
+    }
+}
+exports.ensureJsoncParser = ensureJsoncParser;

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.d.ts

@@ -0,0 +1,7 @@
+interface Options {
+    maximumAsyncOnTag: number;
+}
+/** Rule Name */
+export declare const name = "template-async-number-limitation";
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"tooManyAsyncOnTag", [Options, ...any[]], any>;
+export default _default;