@o3r/eslint-plugin 9.4.0-alpha.32 → 9.4.0-alpha.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o3r/eslint-plugin",
-  "version": "9.4.0-alpha.32",
+  "version": "9.4.0-alpha.33",
   "description": "The module provides in-house eslint plugins to use in your own eslint configuration.",
   "main": "./src/public_api.js",
   "keywords": [
@@ -22,11 +22,16 @@
   },
   "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
     }
   },
   "peerDependencies": {
@@ -35,7 +40,8 @@
     "@angular/compiler": "~16.2.0",
     "@typescript-eslint/eslint-plugin": "^5.60.1",
     "@typescript-eslint/parser": "^5.60.1",
-    "eslint": "^8.22.0"
+    "eslint": "^8.22.0",
+    "jsonc-eslint-parser": "~2.3.0"
   },
   "devDependencies": {
     "@angular-devkit/core": "~16.2.0",
@@ -49,10 +55,10 @@
     "@compodoc/compodoc": "^1.1.19",
     "@nx/eslint-plugin": "~16.10.0",
     "@nx/jest": "~16.10.0",
-    "@o3r/build-helpers": "^9.4.0-alpha.32",
-    "@o3r/eslint-plugin": "^9.4.0-alpha.32",
+    "@o3r/build-helpers": "^9.4.0-alpha.33",
     "@types/jest": "~29.5.2",
     "@types/node": "^18.0.0",
+    "@types/semver": "^7.3.13",
     "@typescript-eslint/eslint-plugin": "^5.60.1",
     "@typescript-eslint/parser": "^5.60.1",
     "cpy-cli": "^4.2.0",
@@ -67,6 +73,7 @@
     "nx": "~16.10.0",
     "rimraf": "^5.0.1",
     "ts-jest": "~29.1.1",
+    "type-fest": "^3.12.0",
     "typescript": "~5.1.6"
   },
   "schematics": "./collection.json",

package/src/index.d.ts

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

package/src/index.js

@@ -1,17 +1,20 @@
 "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 o3r_widget_tags_1 = require("./rules/o3r-widget-tags/o3r-widget-tags");
+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 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");
 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,
-        'o3r-widget-tags': o3r_widget_tags_1.default
+        'o3r-widget-tags': o3r_widget_tags_1.default,
+        'json-dependency-versions-harmonize': json_dependency_versions_harmonize_1.default
     },
     configs: {
         '@o3r/no-folder-import-for-module': 'error',
+        '@o3r/json-dependency-versions-harmonize': 'error',
         '@o3r/template-async-number-limitation': 'warn',
         recommended: {
             rules: {
@@ -24,6 +27,11 @@ module.exports = {
                 '@o3r/no-folder-import-for-module': 'error',
                 '@o3r/template-async-number-limitation': 'warn'
             }
+        },
+        'json-recommended': {
+            rules: {
+                '@o3r/json-dependency-versions-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,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 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',
+                        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;
+}
+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/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;

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',
@@ -36,7 +36,7 @@ exports.default = (0, utils_1.createRule)({
     },
     defaultOptions,
     create: (context) => {
-        const parserServices = (0, template_utils_1.getTemplateParserServices)(context);
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
         const options = context.options[0] || defaultOptions[0];
         const asyncRegExp = /\| *async\b/g;
         return {

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

@@ -0,0 +1,41 @@
+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/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/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, O3rWidgetTagsRuleOption[], TSESLint.RuleListener>;
+export default _default;

package/src/rules/{o3r-widget-tags → typescript/o3r-widget-tags}/o3r-widget-tags.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
-const utils_1 = require("../utils");
+const utils_1 = require("../../utils");
 const o3rWidgetParameterPattern = '^[a-zA-Z0-9-_:.]+$';
 const o3rWidgetParamTypes = ['string', 'number', 'boolean', 'string[]', 'number[]', 'boolean[]'];
 const createCommentString = (comment) => `/*${comment}*/`;

package/src/rules/utils.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/experimental-utils';
+/** ESLint rule generator */
+export declare const createRule: <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener = import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<TOptions, TMessageIds, TRuleListener>>) => import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<TMessageIds, TOptions, TRuleListener>;

package/tsconfig.tsbuildinfo

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

package/collection.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/angular/angular-cli/main/packages/angular_devkit/schematics/collection-schema.json",
-  "schematics": {
-    "ng-add": {
-      "description": "Add Otter eslint-plugin to the project.",
-      "factory": "./schematics/ng-add/index#ngAdd",
-      "schema": "./schematics/ng-add/schema.json",
-      "aliases": ["install", "i"]
-    }
-  }
-}

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": [
-  ]
-}