@open-xchange/linter-presets 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.1.7] - 2024-07-23
+
+- changed: [ESLint] reverted option `modules` for `env.project` (introduced in 0.1.6)
+- changed: [ESLint] `env.project`: renamed option `packages` to `hierarchy`
+- chore: [ESLint] split rule `env-project/no-invalid-modules` (added `env-project/no-invalid-hierarchy`)
+
+## [0.1.6] - 2024-07-23
+
+- changed: [ESLint] moved rule options for `env.project` into own `modules` option
+- chore: [ESLint] unit test for `env.project`
+
 ## [0.1.5] - 2024-07-23
 
 - chore: bump dependencies
@@ -26,7 +37,7 @@
 
 ## [0.0.6] - 2024-07-10
 
-- fixed: [ESLint] type error in `env-project/no-invalid-modules`
+- fixed: [ESLint] type error in rule `env-project/no-invalid-modules`
 
 ## [0.0.5] - 2024-07-10
 

package/dist/eslint/env/browser.d.ts

@@ -13,10 +13,10 @@ export interface EnvBrowserOptions extends EnvRestrictedOptions {
  * - `globals`
  * - `confusing-browser-globals`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function browser(options: EnvBrowserOptions): TSESLint.FlatConfig.ConfigArray;
+export default function browser(envOptions: EnvBrowserOptions): TSESLint.FlatConfig.ConfigArray;

package/dist/eslint/env/browser.js

@@ -84,26 +84,26 @@ const RESTRICTED_GLOBALS = AMBIGUOUS_BROWSER_TYPES.map(name => {
  * - `globals`
  * - `confusing-browser-globals`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function browser(options) {
+export default function browser(envOptions) {
     return concatConfigs(
     // register global symbols used in browser scripts
-    createConfig(options, {
+    createConfig(envOptions, {
         languageOptions: {
             globals: BROWSER_GLOBALS,
         },
     }), 
     // generate the "no-restricted-?" rules according to passed configuration
-    restrictedRules(options, {
+    restrictedRules(envOptions, {
         globals: RESTRICTED_GLOBALS,
         properties: RESTRICTED_PROPERTIES,
         syntax: RESTRICTED_SYNTAX,
     }), 
     // custom rules
-    customRules(options));
+    customRules(envOptions));
 }

package/dist/eslint/env/codecept.d.ts

@@ -13,10 +13,10 @@ export interface EnvCodeceptOptions extends EnvBaseOptions {
  * - `eslint-plugin-codeceptjs`
  * - `eslint-plugin-chai-expect`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function codecept(options: EnvCodeceptOptions): TSESLint.FlatConfig.ConfigArray;
+export default function codecept(envOptions: EnvCodeceptOptions): TSESLint.FlatConfig.ConfigArray;

package/dist/eslint/env/codecept.js

@@ -16,16 +16,16 @@ import { concatConfigs, createConfig, customRules } from "../shared/env-utils.js
  * - `eslint-plugin-codeceptjs`
  * - `eslint-plugin-chai-expect`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function codecept(options) {
+export default function codecept(envOptions) {
     return concatConfigs(
     // "codecept" plugin
-    createConfig(options, {
+    createConfig(envOptions, {
         // register rule implementations of the plugins
         plugins: {
             codeceptjs: codeceptPlugin,
@@ -38,9 +38,9 @@ export default function codecept(options) {
         rules: codeceptPlugin.configs.recommended.rules,
     }), 
     // "chai-expect" plugin
-    createConfig(options, chaiExpectPlugin.configs["recommended-flat"]), 
+    createConfig(envOptions, chaiExpectPlugin.configs["recommended-flat"]), 
     // custom rules
-    customRules(options, {
+    customRules(envOptions, {
         "new-cap": ["error", {
                 capIsNewExceptions: ["After", "AfterSuite", "Before", "BeforeSuite", "Feature", "Scenario"],
             }],

package/dist/eslint/env/eslint.d.ts

@@ -11,10 +11,10 @@ export interface EnvEslintOptions extends EnvBaseOptions {
  * Wraps the following packages:
  * - `eslint-plugin-eslint-plugin`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function eslint(options: EnvEslintOptions): TSESLint.FlatConfig.ConfigArray;
+export default function eslint(envOptions: EnvEslintOptions): TSESLint.FlatConfig.ConfigArray;

package/dist/eslint/env/eslint.js

@@ -7,16 +7,16 @@ import { concatConfigs, createConfig, customRules } from "../shared/env-utils.js
  * Wraps the following packages:
  * - `eslint-plugin-eslint-plugin`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function eslint(options) {
+export default function eslint(envOptions) {
     return concatConfigs(
     // register rule implementations and recommended rules
-    createConfig(options, eslintPlugin.configs["flat/rules-recommended"]), 
+    createConfig(envOptions, eslintPlugin.configs["flat/rules-recommended"]), 
     // custom rules
-    customRules(options));
+    customRules(envOptions));
 }

package/dist/eslint/env/jest.d.ts

@@ -12,10 +12,10 @@ export interface EnvJestOptions extends EnvBaseOptions {
  * Wraps the following packages:
  * - `eslint-plugin-jest`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function jest(options: EnvJestOptions): TSESLint.FlatConfig.ConfigArray;
+export default function jest(envOptions: EnvJestOptions): TSESLint.FlatConfig.ConfigArray;

package/dist/eslint/env/jest.js

@@ -8,22 +8,22 @@ import { concatConfigs, createConfig, customRules } from "../shared/env-utils.js
  * Wraps the following packages:
  * - `eslint-plugin-jest`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function jest(options) {
+export default function jest(envOptions) {
     return concatConfigs(
     // register rule implementations, globals, and recommended rules
-    createConfig(options, jestPlugin.configs["flat/recommended"]), 
+    createConfig(envOptions, jestPlugin.configs["flat/recommended"]), 
     // add recommended stylistic rules
-    createConfig(options, {
+    createConfig(envOptions, {
         rules: jestPlugin.configs["flat/style"].rules,
     }), 
     // custom rules
-    customRules(options, {
+    customRules(envOptions, {
         "jest/consistent-test-it": ["error", { fn: "it" }],
         "jest/no-commented-out-tests": "error",
         "jest/no-conditional-expect": "off",

package/dist/eslint/env/node.d.ts

@@ -16,10 +16,10 @@ export interface EnvNodeOptions extends EnvRestrictedOptions {
  * Wraps the following packages:
  * - `eslint-plugin-n`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function node(options: EnvNodeOptions): TSESLint.FlatConfig.ConfigArray;
+export default function node(envOptions: EnvNodeOptions): TSESLint.FlatConfig.ConfigArray;

package/dist/eslint/env/node.js

@@ -8,18 +8,18 @@ import { concatConfigs, createConfig, restrictedRules, customRules } from "../sh
  * Wraps the following packages:
  * - `eslint-plugin-n`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function node(options) {
+export default function node(envOptions) {
     // the plugin configuration key, according to source module type
-    const configKey = (options.sourceType === "commonjs") ? "flat/recommended-script" : "flat/recommended-module";
+    const configKey = (envOptions.sourceType === "commonjs") ? "flat/recommended-script" : "flat/recommended-module";
     return concatConfigs(
     // register rule implementations
-    createConfig(options, {
+    createConfig(envOptions, {
         ...nodePlugin.configs[configKey],
         settings: {
             node: {
@@ -28,9 +28,9 @@ export default function node(options) {
         },
     }), 
     // generate the "no-restricted-?" rules according to passed configuration
-    restrictedRules(options), 
+    restrictedRules(envOptions), 
     // custom rules
-    customRules(options, {
+    customRules(envOptions, {
         "n/no-unsupported-features/node-builtins": ["error", { allowExperimental: true }],
         "n/prefer-node-protocol": "error",
     }));

package/dist/eslint/env/project.d.ts

@@ -1,18 +1,32 @@
 import type { TSESLint } from "@typescript-eslint/utils";
 import type { EnvBaseOptions } from "../shared/env-utils.js";
+import type { SharedRuleSettings } from "../shared/rule-utils.js";
 import { type RuleNoInvalidModulesOptions } from "../rules/no-invalid-modules.js";
+import { type RuleNoInvalidHierarchyOptions } from "../rules/no-invalid-hierarchy.js";
 /**
  * Configuration options for the environment preset "env.project".
  */
-export interface EnvProjectOptions extends EnvBaseOptions, RuleNoInvalidModulesOptions {
+export interface EnvProjectOptions extends EnvBaseOptions {
+    /**
+     * Maps all alias prefixes to actual paths in the project.
+     */
+    alias?: SharedRuleSettings["alias"];
+    /**
+     * Options to be passed to the rule "env-project/no-invalid-modules".
+     */
+    external?: RuleNoInvalidModulesOptions["external"];
+    /**
+     * Options to be passed to the rule "env-project/no-invalid-hierarchy".
+     */
+    hierarchy?: RuleNoInvalidHierarchyOptions;
 }
 /**
  * Adds custom linter rules for checking project setup and module hierarchy.
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function project(options: EnvProjectOptions): TSESLint.FlatConfig.ConfigArray;
+export default function project(envOptions: EnvProjectOptions): TSESLint.FlatConfig.ConfigArray;

package/dist/eslint/env/project.js

@@ -1,32 +1,40 @@
 import { concatConfigs, createConfig, customRules } from "../shared/env-utils.js";
 import noAmdModuleDirective from "../rules/no-amd-module-directive.js";
 import noInvalidModules from "../rules/no-invalid-modules.js";
+import noInvalidHierarchy from "../rules/no-invalid-hierarchy.js";
 // exports ====================================================================
 /**
  * Adds custom linter rules for checking project setup and module hierarchy.
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function project(options) {
+export default function project(envOptions) {
     return concatConfigs(
     // register rule implementations
-    createConfig(options, {
+    createConfig(envOptions, {
         plugins: {
             "env-project": {
                 rules: {
                     "no-amd-module-directive": noAmdModuleDirective,
                     "no-invalid-modules": noInvalidModules,
+                    "no-invalid-hierarchy": noInvalidHierarchy,
                 },
             },
         },
+        settings: {
+            "env-project": {
+                alias: envOptions.alias,
+            },
+        },
     }), 
     // custom rules
-    customRules(options, {
+    customRules(envOptions, {
         "env-project/no-amd-module-directive": "error",
-        "env-project/no-invalid-modules": ["error", options],
+        "env-project/no-invalid-modules": ["error", { external: envOptions.external }],
+        "env-project/no-invalid-hierarchy": envOptions.hierarchy ? ["error", envOptions.hierarchy] : "off",
     }));
 }

package/dist/eslint/env/react.d.ts

@@ -20,10 +20,10 @@ export interface EnvReactOptions extends EnvBaseOptions {
  * - `eslint-plugin-jsx-expressions`
  * - `eslint-plugin-jsx-a11y`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function react(options: EnvReactOptions): TSESLint.FlatConfig.ConfigArray;
+export default function react(envOptions: EnvReactOptions): TSESLint.FlatConfig.ConfigArray;

package/dist/eslint/env/react.js

@@ -18,16 +18,16 @@ import { concatConfigs, createConfig, customRules } from "../shared/env-utils.js
  * - `eslint-plugin-jsx-expressions`
  * - `eslint-plugin-jsx-a11y`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function react(options) {
+export default function react(envOptions) {
     return concatConfigs(
     // configure "react" plugin for all source files (JSX and TSX)
-    createConfig(options, {
+    createConfig(envOptions, {
         // auto-detect installed React version
         settings: {
             react: {
@@ -43,7 +43,7 @@ export default function react(options) {
         },
     }), 
     // configure other plugins and rules for all source files (JSX and TSX)
-    createConfig(options, {
+    createConfig(envOptions, {
         // register rule implementations of the plugins
         plugins: {
             "react-hooks": reactHooksPlugin,
@@ -58,17 +58,17 @@ export default function react(options) {
         },
     }), 
     // "react-hooks-static-deps" plugin
-    options.staticHooks && createConfig(options, {
+    envOptions.staticHooks && createConfig(envOptions, {
         plugins: {
             "react-hooks-static-deps": fixupPluginRules(reactHooksStaticDepsPlugin), // https://github.com/stoikio/eslint-plugin-react-hooks-static-deps/issues/1
         },
         rules: {
             "react-hooks/exhaustive-deps": "off",
-            "react-hooks-static-deps/exhaustive-deps": ["error", { staticHooks: options.staticHooks }],
+            "react-hooks-static-deps/exhaustive-deps": ["error", { staticHooks: envOptions.staticHooks }],
         },
     }), 
     // additional rules for TSX only
-    createConfig(options, {
+    createConfig(envOptions, {
         ignores: ["**/*.{js,jsx}"],
         rules: {
             // replace "react/jsx-no-leaked-render" rule with advanced alternative
@@ -76,7 +76,7 @@ export default function react(options) {
         },
     }), 
     // custom rules
-    customRules(options, {
+    customRules(envOptions, {
         // "react" plugin
         "react/hook-use-state": "error",
         "react/iframe-missing-sandbox": "error",

package/dist/eslint/env/tsconfig.d.ts

@@ -12,10 +12,10 @@ export interface EnvTSConfigOptions extends EnvBaseOptions {
 /**
  * Creates configuration objects for TypeScript projects.
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function tsconfig(options: EnvTSConfigOptions): TSESLint.FlatConfig.ConfigArray;
+export default function tsconfig(envOptions: EnvTSConfigOptions): TSESLint.FlatConfig.ConfigArray;

package/dist/eslint/env/tsconfig.js

@@ -3,22 +3,22 @@ import { concatConfigs, createConfig, customRules } from "../shared/env-utils.js
 /**
  * Creates configuration objects for TypeScript projects.
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function tsconfig(options) {
+export default function tsconfig(envOptions) {
     return concatConfigs(
     // path to project configuration file
-    createConfig(options, {
+    createConfig(envOptions, {
         languageOptions: {
             parserOptions: {
-                project: options.project,
+                project: envOptions.project,
             },
         },
     }), 
     // custom rules
-    customRules(options));
+    customRules(envOptions));
 }

package/dist/eslint/env/vitest.d.ts

@@ -14,10 +14,10 @@ export interface EnvVitestOptions extends EnvBaseOptions {
  * - `eslint-plugin-jest-dom`
  * - `eslint-plugin-testing-library`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function vitest(options: EnvVitestOptions): TSESLint.FlatConfig.ConfigArray;
+export default function vitest(envOptions: EnvVitestOptions): TSESLint.FlatConfig.ConfigArray;

package/dist/eslint/env/vitest.js

@@ -13,16 +13,16 @@ import { concatConfigs, createConfig, customRules } from "../shared/env-utils.js
  * - `eslint-plugin-jest-dom`
  * - `eslint-plugin-testing-library`
  *
- * @param options
+ * @param envOptions
  *  Configuration options for the environment.
  *
  * @returns
  *  An array of configuration objects to be added to the flat configuration.
  */
-export default function vitest(options) {
+export default function vitest(envOptions) {
     return concatConfigs(
     // "vitest" plugin
-    createConfig(options, {
+    createConfig(envOptions, {
         // register rule implementations of the plugins
         plugins: {
             vitest: vitestPlugin,
@@ -35,9 +35,9 @@ export default function vitest(options) {
         rules: vitestPlugin.configs.recommended.rules,
     }), 
     // "jest-dom" plugin
-    createConfig(options, jestDomPlugin.configs["flat/recommended"]), 
+    createConfig(envOptions, jestDomPlugin.configs["flat/recommended"]), 
     // "testing-library" plugin
-    createConfig(options, {
+    createConfig(envOptions, {
         // register rule implementations of the plugins
         plugins: {
             "testing-library": fixupPluginRules(testingLibraryPlugin), // https://github.com/testing-library/eslint-plugin-testing-library/issues/899
@@ -46,7 +46,7 @@ export default function vitest(options) {
         rules: testingLibraryPlugin.configs.react.rules,
     }), 
     // custom rules
-    customRules(options, {
+    customRules(envOptions, {
         // "vitest" plugin
         "vitest/consistent-test-it": "error",
         "vitest/no-alias-methods": "error",

package/dist/eslint/rules/no-invalid-hierarchy.d.ts

@@ -0,0 +1,25 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export interface RuleNoInvalidHierarchyPackage {
+    /**
+     * Glob patterns selecting all source files that are part of the package.
+     */
+    files: string[];
+    /**
+     * Specifies the names of all packages (keys of the `packages` dictionary)
+     * this package depends on.
+     */
+    extends?: string | string[];
+    /**
+     * Set to `true` to mark an optional package that may be missing in an
+     * installation. Such a package cannot be imported statically (with
+     * `import` statement) from a non-optional package, but can only be loaded
+     * dynamically at runtime (by calling `import()`). The rule will mark all
+     * static imports of optional code as an error. Default value is `false`.
+     */
+    optional?: boolean;
+}
+export type RuleNoInvalidHierarchyOptions = Record<string, RuleNoInvalidHierarchyPackage>;
+type RuleOptions = [RuleNoInvalidHierarchyOptions];
+type RuleMessageIds = "UNEXPECTED_OPTIONAL_STATIC" | "INVALID_PACKAGE_HIERARCHY";
+declare const _default: ESLintUtils.RuleModule<RuleMessageIds, RuleOptions, ESLintUtils.RuleListener>;
+export default _default;

package/dist/eslint/rules/no-invalid-hierarchy.js

@@ -0,0 +1,85 @@
+import { AST_NODE_TYPES as NodeType, ESLintUtils } from "@typescript-eslint/utils";
+import { Schema, makeArray, ProjectContext } from "../shared/rule-utils.js";
+// exports ====================================================================
+export default ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: "problem",
+        schema: [
+            // single options object
+            Schema.dictionary(Schema.options({
+                files: Schema.maybeArray(Schema.stringNE()),
+                extends: Schema.maybeArray(Schema.stringNE()),
+                optional: Schema.boolean(),
+            }, ["files"])),
+        ],
+        messages: {
+            UNEXPECTED_OPTIONAL_STATIC: "Unexpected static import of optional package.",
+            INVALID_PACKAGE_HIERARCHY: "Low-level package cannot import modules from higher-level package.",
+        },
+        fixable: "code",
+    },
+    defaultOptions: [{}],
+    create(context, [options]) {
+        // create the project context with aliases, root path, own module name, etc.
+        const projectContext = new ProjectContext(context);
+        const hierarchyMap = new Map();
+        for (const [key, settings] of Object.entries(options)) {
+            hierarchyMap.set(key, {
+                ...settings,
+                extends: makeArray(settings.extends),
+            });
+        }
+        // collect all globs for package members
+        const packagesGlobs = Array.from(hierarchyMap.values(), settings => settings.files).flat();
+        return {
+            "ImportDeclaration, TSExternalModuleReference, ImportExpression, ExportAllDeclaration, ExportNamedDeclaration"(node) {
+                // import/export statement must contain string literal
+                const importWrapper = projectContext.resolveImportNode(node);
+                if (!importWrapper) {
+                    return;
+                }
+                // check dependencies if the imported module is covered in the configuration
+                if (!importWrapper.matchModuleName(packagesGlobs)) {
+                    return;
+                }
+                // check package dependencies
+                // whether an invalid static import has been found
+                let invalidStatic = false;
+                // recursively checks the imported module for dependency violations
+                const checkDependencies = (settings, root) => {
+                    // only allow static imports from specified package, if it is not optional
+                    if (importWrapper.matchModuleName(settings.files)) {
+                        if (!root && (node.type !== NodeType.ImportExpression) && settings.optional) {
+                            invalidStatic = true;
+                        }
+                        return true;
+                    }
+                    // do not traverse into dependencies of optional modules
+                    if (!settings.extends.length || (!root && settings.optional)) {
+                        return false;
+                    }
+                    // allow imports from any of the dependent packages
+                    return settings.extends.some(key => {
+                        const package2 = hierarchyMap.get(key);
+                        return !!package2 && checkDependencies(package2, false);
+                    });
+                };
+                // check dependencies of all configured packages (not for anonymous modules)
+                let invalidDeps = false;
+                for (const settings of hierarchyMap.values()) {
+                    if (projectContext.matchModuleName(settings.files) && !checkDependencies(settings, true)) {
+                        invalidDeps = true;
+                        break;
+                    }
+                }
+                // report package hierarchy errors
+                if (invalidStatic) {
+                    context.report({ messageId: "UNEXPECTED_OPTIONAL_STATIC", node: importWrapper.sourceNode });
+                }
+                else if (invalidDeps) {
+                    context.report({ messageId: "INVALID_PACKAGE_HIERARCHY", node: importWrapper.sourceNode });
+                }
+            },
+        };
+    },
+});

package/dist/eslint/rules/no-invalid-modules.d.ts

@@ -1,38 +1,10 @@
 import { ESLintUtils } from "@typescript-eslint/utils";
-export interface RuleNoInvalidModulesPackage {
-    /**
-     * Glob patterns selecting all source files that are part of the package.
-     */
-    src: string | string[];
-    /**
-     * Specifies the names of all packages (keys of the `packages` dictionary)
-     * this package depends on.
-     */
-    extends?: string | string[];
-    /**
-     * Set to `true` to mark an optional package that may be missing in an
-     * installation. Such a package cannot be imported statically (with
-     * `import` statement) from a non-optional package, but can only be loaded
-     * dynamically at runtime (by calling `import()`). The rule will mark all
-     * static imports of optional code as an error. Default value is `false`.
-     */
-    optional?: boolean;
-}
 export interface RuleNoInvalidModulesOptions {
-    /**
-     * Maps all alias prefixes to actual paths in the project.
-     */
-    alias?: Record<string, string>;
     /**
      * Specifies glob patterns for external modules.
      */
-    external?: string | string[];
-    /**
-     * Allows to separate the source files into virtual packages.
-     */
-    packages?: Record<string, RuleNoInvalidModulesPackage>;
+    external?: string[];
 }
 type RuleOptions = [Required<RuleNoInvalidModulesOptions>];
-type RuleMessageIds = "SOURCE_FILE_NOT_FOUND" | "UNEXPECTED_OPTIONAL_STATIC" | "INVALID_PACKAGE_HIERARCHY";
-declare const _default: ESLintUtils.RuleModule<RuleMessageIds, RuleOptions, ESLintUtils.RuleListener>;
+declare const _default: ESLintUtils.RuleModule<"SOURCE_FILE_NOT_FOUND", RuleOptions, ESLintUtils.RuleListener>;
 export default _default;