eslint-plugin-boundaries 5.0.2 → 5.1.0

package/README.md

@@ -1,4 +1,4 @@
-[![Build status][build-image]][build-url] [![Coverage Status][coveralls-image]][coveralls-url] [![Quality Gate][quality-gate-image]][quality-gate-url]
+[![Build status][build-image]][build-url] [![Coverage Status][coveralls-image]][coveralls-url] <!-- [![Quality Gate][quality-gate-image]][quality-gate-url] -->
 
 [![Renovate](https://img.shields.io/badge/renovate-enabled-brightgreen.svg)](https://renovatebot.com) [![Last commit][last-commit-image]][last-commit-url] [![Last release][release-image]][release-url]
 
@@ -28,13 +28,15 @@ By default, __the plugin works by checking `import` statements, but it is also a
 - [Configuration](#configuration)
   * [Global settings](#global-settings)
   * [Predefined configurations](#predefined-configurations)
+  * [createConfig helper](#createconfig-helper)
   * [Rules configuration](#rules-configuration)
     * [Main format of rules options](#main-format-of-rules-options)
-    * [Elements matchers](#elements-matchers)
+    * [Elements selectors](#elements-selectors)
     * [Error messages](#error-messages)
     * [Advanced example](#advanced-example)
 - [Resolvers](#resolvers)
-- [Usage with TypeScript](#usage-with-typescript)
+- [TypeScript Support](#typescript-support)
+    * [Exported Types](#exported-types)
 - [Migration guides](#migration-guides)
 - [Debug mode](#debug-mode)
 - [Acknowledgements](#acknowledgements)
@@ -70,7 +72,7 @@ export default [
 ];
 ```
 
-> [!NOTE]  
+> [!NOTE]
 > From version `5.0.0`, this plugin is compatible with eslint v9 and above. It may be also compatible with previous eslint versions, but you might read the [documentation of the `4.2.2` version](https://github.com/javierbrea/eslint-plugin-boundaries/tree/v4.2.2) to know how to configure it properly using the legacy configuration format.
 
 ## Overview
@@ -173,7 +175,7 @@ Read the [docs of the `boundaries/entry-point` rule](docs/rules/entry-point.md)
 
 #### __`boundaries/elements`__
 
-Define patterns to recognize each file in the project as one of this element types. All rules need this setting to be configured properly to work. The plugin tries to identify each file being analyzed or `import` statement in rules as one of the defined element types. The assigned element type will be that with the first matching pattern, in the same order that elements are defined in the array, so you __should sort them from the most accurate patterns to the less ones__. Properties of each `element`:
+Define element descriptors to recognize each file in the project as one of this element types. All rules need this setting to be configured properly to work. The plugin tries to identify each file being analyzed or `import` statement in rules as one of the defined element types. The assigned element type will be that with the first matching pattern, in the same order that elements are defined in the array, so you __should sort them from the most accurate patterns to the less ones__. Properties of each `element`:
 
 * __`type`__: `<string>` Element type to be assigned to files or imports matching the `pattern`. This type will be used afterwards in the rules configuration.
 * __`pattern`__: `<string>|<array>` [`micromatch` pattern](https://github.com/micromatch/micromatch). __By default the plugin will try to match this pattern progressively starting from the right side of each file path.__ This means that you don't have to define patterns matching from the base project path, but only the last part of the path that you want to be matched. This is made because the plugin supports elements being children of other elements, and otherwise it could wrongly recognize children elements as a part of the parent one. <br/>For example, given a path `src/helpers/awesome-helper/index.js`, it will try to assign the element to a pattern matching `index.js`, then `awesome-helper/index.js`, then `helpers/awesome-helper/index.js`, etc. Once a pattern matches, it assign the correspondent element type, and continues searching for parents elements with the same logic until the full path has been analyzed. __This behavior can be disabled setting the `mode` option to `full`__, then the provided pattern will try to match the full path.
@@ -328,26 +330,107 @@ We recommend to use this setting if you are applying the plugin to an already ex
 
 ```js
 import boundaries from "eslint-plugin-boundaries";
+import { recommended } from "eslint-plugin-boundaries/config";
 
 export default [{
+  plugins: {
+    boundaries,
+  },
+  settings: {
+    ...recommended.settings,
+    // Define your own element descriptors here
+    "boundaries/elements": [
+      {
+        type: "helpers",
+        pattern: "helpers/*"
+      },
+    ]
+  },
   rules: {
-    ...boundaries.configs.recommended.rules,
+    ...recommended.rules,
+    "boundaries/element-types": [2, {
+      // Define your own options here
+    }],
   }
 }]
 ```
 
 #### Strict
 
-All rules are enabled, so all elements in the project will be compliant with your architecture boundaries. 😃
+All rules are enabled by default, so all elements in the project will be compliant with your architecture boundaries. 😃
+
+Follow the same example as in "recommended" configuration, but importing `strict` instead of `recommended`.
 
 ```js
-import boundaries from "eslint-plugin-boundaries";
+import { strict } from "eslint-plugin-boundaries/config";
+```
 
-export default [{
+### createConfig helper
+
+A `createConfig` helper is also available for making configurations easier.
+
+It enforces valid types for settings and rules and automatically:
+
+* Adds the plugin to the plugins property
+* Includes JavaScript and TypeScript file patterns in the files property
+* Validates that all provided settings and rules belong to the plugin
+
+```js
+import { createConfig, recommended } from "eslint-plugin-boundaries/config";
+
+const config = createConfig({
+  settings: {
+    ...recommended.settings,
+    "boundaries/elements": [],
+    "boundaries/ignore": ["**/ignored/**/*.js"],
+  },
   rules: {
-    ...boundaries.configs.strict.rules,
+    ...recommended.rules,
+    "boundaries/element-types": ["error", { default: "disallow" }],
   }
-}]
+});
+
+export default [config];
+```
+
+You can also rename the plugin by passing a second argument. The helper will rename all rules from `boundaries/` prefix to the provided one, so recommended or strict configs can be used as a base without issues.
+
+```js
+import { createConfig, recommended } from "eslint-plugin-boundaries/config";
+
+const config = createConfig({
+  settings: {
+    ...recommended.settings,
+    "boundaries/elements": [], // Note the original prefix here
+  },
+  rules: {
+    ...recommended.rules,
+    "custom-boundaries/element-types": ["error", { default: "disallow" }], // Note the renamed prefix here
+    "boundaries/entry-point": 0, // The original prefix still works too
+    // @ts-expect-error Any other prefix raises an error
+    "foo/entry-point": 2, // This rule does not match the new plugin name nor the original one
+  }
+}, "custom-boundaries");
+
+export default [config];
+```
+
+> [!WARNING]
+> Note that the settings still must use the `boundaries/` prefix — ESLint doesn’t namespace settings by plugin name.
+
+The plugin also exports constants and type guard methods for settings keys, rule names, and other configuration-related values. You can use them when defining your configuration. For example:
+
+```ts
+import {
+  RULE_NAMES_MAP,
+  isRuleName,
+  SETTINGS_KEYS_MAP,
+  isSettingsKey,
+  ELEMENT_DESCRIPTOR_MODES_MAP,
+  isElementDescriptorMode,
+  RULE_POLICIES_MAP,
+  isRulePolicy,
+} from "eslint-plugin-boundaries/config";
 ```
 
 ### Rules configuration
@@ -397,26 +480,26 @@ Remember that:
 
 ##### Rules options properties
 
-* __`from/target`__: `<element matchers>` Depending of the rule to which the options are for, the rule will be applied only if the file being analyzed matches with this element matcher (`from`), or the dependency being imported matches with this element matcher (`target`).
-* __`disallow/allow`__: `<value matchers>` If the plugin rule target matches with this, then the result of the rule will be "disallow/allow". Each rule will require a type of value here depending of what it is checking. In the case of the `element-types` rule, for example, another `<element matcher>` has to be provided in order to check the type of the local dependency.
+* __`from/target`__: `<element selectors>` Depending of the rule to which the options are for, the rule will be applied only if the file being analyzed matches with this element selector (`from`), or the dependency being imported matches with this element selector (`target`).
+* __`disallow/allow`__: `<selectors>` If the plugin rule target matches with this, then the result of the rule will be "disallow/allow". Each rule will require a type of value here depending of what it is checking. In the case of the `element-types` rule, for example, another `<element selector>` has to be provided in order to check the type of the local dependency.
 * __`importKind`__: `<string>` _Optional_. It is useful only when using TypeScript, because it allows to define if the rule applies when the dependency is being imported as a value or as a type. It can be also defined as an array of strings, or a micromatch pattern. Note that possible values to match with are `"value"`, `"type"` or `"typeof"`. For example, you could define that "components" can import "helpers" as a value, but not as a type. So, `import { helper } from "helpers/helper-a"` would be allowed, but `import type { Helper } from "helpers/helper-a"` would be disallowed.
 * __`message`__: `<string>` Optional. If the rule results in an error, the plugin will return this message instead of the default one. Read [error messages](#error-messages) for further info.
 
-> Tip: Properties `from/target` and `disallow/allow` can receive a single matcher, or an array of matchers.
+> Tip: Properties `from/target` and `disallow/allow` can receive a single selector, or an array of selectors.
 
-##### Elements matchers
+##### Elements selectors
 
-Elements matchers used in the rules options can have the next formats:
+Elements selectors used in the rules options can have the next formats:
 
 * __`<string>`__: Will return `true` when the element type matches with this [`micromatch` pattern](https://github.com/micromatch/micromatch). It [supports templating](#templating) for using values from captured values.
-* __`[<string>, <capturedValuesObject>]`__: Will return `true` whe when the element type matches with the first element in the array, and all of the captured values also match. <br/>The `<capturedValuesObject>` has to be an object containing `capture` keys from the [`boundaries/element-types` setting](#boundarieselement-types) of the element as keys, and [`micromatch` patterns](https://github.com/micromatch/micromatch) as values. (values also support [templating](#templating)) <br/>For example, for an element of type "helpers" with settings as `{ type: "helpers", pattern": "helpers/*/*.js", "capture": ["category", "elementName"]}`, you could write element matchers as:
+* __`[<string>, <capturedValuesObject>]`__: Will return `true` whe when the element type matches with the first element in the array, and all of the captured values also match. <br/>The `<capturedValuesObject>` has to be an object containing `capture` keys from the [`boundaries/element-types` setting](#boundarieselement-types) of the element as keys, and [`micromatch` patterns](https://github.com/micromatch/micromatch) as values. (values also support [templating](#templating)) <br/>For example, for an element of type "helpers" with settings as `{ type: "helpers", pattern": "helpers/*/*.js", "capture": ["category", "elementName"]}`, you could write element selectors as:
   * `["helpers", { category: "data", elementName: "parsers"}]`: Will only match with helpers with category "data" and elementName "parsers" (`helpers/data/parsers.js`).
   * `["helpers", { category: "data" }]`: Will match with all helpers with category "data" (`helpers/data/*.js`)
   * `["data-${from.elementName}", { category: "${from.category}" }]`: Will only match with helpers with the type equals to the `elementName` of the file importing plus a `data-` prefix, and the category being equal to the `category` of the file importing the dependency.
 
 ##### Templating
 
-When defining [__Element matchers__](#elements-matchers), the values captured both from the element importing ("from") and from the imported element ("target") are available to be replaced. They are replaced both in the main string and in the `<capturedValuesObject>`.
+When defining [__Element selectors__](#elements-selectors), the values captured both from the element importing ("from") and from the imported element ("target") are available to be replaced. They are replaced both in the main string and in the `<capturedValuesObject>`.
 
 Templates must be defined with the format `${from.CAPTURED_PROPERTY}` or `${target.CAPTURED_PROPERTY}`.
 
@@ -541,7 +624,7 @@ export default [{
 }]
 ```
 
-## Usage with TypeScript
+## TypeScript Support
 
 This plugin can be used also in [TypeScript](https://www.typescriptlang.org/) projects using `@typescript-eslint/eslint-plugin`. Follow next steps to configure it:
 
@@ -580,6 +663,88 @@ export default [{
 
 In case you face any issue configuring it, you can also [use this repository as a guide](https://github.com/javierbrea/epb-ts-example). It contains a fully working and tested example.
 
+### Exported Types
+
+The main type exported by the plugin is `Config`, which represents a fully typed [Flat Config](https://eslint.org/docs/latest/use/core-concepts/glossary#flat-config).
+
+```ts
+import type { Config } from "eslint-plugin-boundaries";
+
+const config: Config = {
+  plugins: {
+    boundaries,
+  },
+  settings: {
+    "boundaries/elements": [],
+    "boundaries/ignore": ["**/ignored/**/*.js"],
+  },
+  rules: {
+    "boundaries/element-types": [
+      "error",
+      { default: "disallow", rules: [] },
+    ],
+  },
+};
+```
+
+Types also support renaming the plugin when loading it in the `plugins` property, so rules and must be defined using the new name:
+
+```ts
+import type { Config } from "eslint-plugin-boundaries";
+
+const config: Config<"custom-boundaries"> = {
+  plugins: {
+    "custom-boundaries": boundaries, // NOTE the renamed prefix here
+  },
+  settings: {
+    "boundaries/elements": [],
+    "boundaries/ignore": ["**/ignored/**/*.js"],
+  },
+  rules: {
+    "custom-boundaries/element-types": 2, // NOTE the renamed prefix here
+  },
+};
+```
+
+> [!WARNING]
+> Note that the settings still use the `boundaries/` prefix — ESLint doesn’t namespace settings by plugin name.
+
+In addition, individual subtypes are available for each part of the configuration, such as:
+
+* `Settings`, `Rules`, `ElementDescriptor`, `ElementTypesRule`, `ElementTypesRuleOptions`, `ElementSelector`, `IgnoreSetting`, etc.
+
+This allows you to import only what you need and get full autocompletion and type safety.
+
+```ts
+import type {
+  Config,
+  Settings,
+  Rules,
+  ElementDescriptor,
+  ElementTypesRuleOptions,
+} from "eslint-plugin-boundaries";
+
+const moduleDescriptor: ElementDescriptor = {
+  type: "module",
+  pattern: "src/modules/*",
+  capture: ["module"],
+};
+
+const settings: Settings = {
+  "boundaries/elements": [moduleDescriptor],
+};
+
+const rules: Rules = {
+  "boundaries/element-types": ["error", { default: "disallow", rules: [] }],
+};
+
+const config: Config = {
+  files: ["**/*.js", "**/*.ts"],
+  settings,
+  rules,
+};
+```
+
 ## Migration guides
 
 ### Migrating from v4.x

package/dist/configs/Config.types.d.ts

@@ -0,0 +1,41 @@
+import type { ESLint, Linter, Rule } from "eslint";
+import type { ElementTypesRuleOptions, EntryPointRuleOptions, ExternalRuleOptions, NoPrivateOptions } from "../constants/Options.types";
+import type { PLUGIN_NAME } from "../constants/plugin";
+import type { RuleShortName, ELEMENT_TYPES, ENTRY_POINT, EXTERNAL, NO_IGNORED, NO_PRIVATE, NO_UNKNOWN, NO_UNKNOWN_FILES } from "../constants/rules";
+import type { Settings } from "../constants/settings";
+/**
+ * Eslint boundaries plugin rules.
+ * By default, rule names are prefixed with "boundaries/", but it can be customized via the `PluginName` generic parameter.
+ *
+ * @template PluginName - The name of the plugin, defaults to "boundaries". It defines the prefix for the rule names.
+ */
+export type Rules<PluginName extends string = typeof PLUGIN_NAME> = {
+    [K in `${PluginName}/${typeof ELEMENT_TYPES | typeof ENTRY_POINT | typeof EXTERNAL | typeof NO_IGNORED | typeof NO_PRIVATE | typeof NO_UNKNOWN_FILES | typeof NO_UNKNOWN}`]?: K extends `${PluginName}/${typeof ELEMENT_TYPES}` ? Linter.RuleEntry<ElementTypesRuleOptions[]> : K extends `${PluginName}/${typeof ENTRY_POINT}` ? Linter.RuleEntry<EntryPointRuleOptions[]> : K extends `${PluginName}/${typeof EXTERNAL}` ? Linter.RuleEntry<ExternalRuleOptions[]> : K extends `${PluginName}/${typeof NO_PRIVATE}` ? Linter.RuleEntry<NoPrivateOptions[]> : Linter.RuleEntry<never>;
+};
+/**
+ * ESLint configuration with optional settings and rules specific to the boundaries plugin.
+ */
+export interface Config<PluginName extends string = typeof PLUGIN_NAME> extends Linter.Config {
+    /**
+     * Optional settings specific to the boundaries plugin.
+     */
+    settings?: Settings;
+    /**
+     * Optional rules specific to the boundaries plugin.
+     */
+    rules?: Rules<PluginName>;
+}
+/**
+ * ESLint plugin interface for the boundaries plugin, including metadata, rules, and configurations.
+ */
+export interface PluginBoundaries extends ESLint.Plugin {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: Record<RuleShortName, Rule.RuleModule>;
+    configs: {
+        recommended: Config;
+        strict: Config;
+    };
+}

package/dist/configs/Config.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/configs/config.d.ts

@@ -0,0 +1,40 @@
+import type { Linter } from "eslint";
+import { PLUGIN_NAME } from "../constants/plugin";
+import type { PluginBoundaries, Config } from "./Config.types";
+export * from "../types";
+type PluginFullConfig<PluginName extends string = typeof PLUGIN_NAME> = {
+    plugins: Record<PluginName, PluginBoundaries>;
+    files: Linter.Config["files"];
+} & Omit<Config<PluginName>, "plugins">;
+/**
+ * Returns an ESLint config object with the boundaries plugin registered, providing default JS and TS file patterns
+ * and enforcing valid types for settings and rules. Supports renaming the plugin. Rules can be prefixed with either
+ * the original plugin name or the provided plugin name.
+ *
+ * @param config - ESLint config object without the plugins field.
+ * @param name - The name of the plugin to register. Defaults to "boundaries".
+ * @returns {Linter.Config} The ESLint config object with the boundaries plugin registered and the provided config merged in.
+ * @throws {Error} If settings or rules are not from eslint-plugin-boundaries.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, recommended } from "eslint-plugin-boundaries/config";
+ *
+ * const config = createConfig({
+ *   settings: {
+ *     ...recommended.settings,
+ *     "boundaries/elements": [],
+ *     "boundaries/ignore": ["ignored/*.js"],
+ *   },
+ *   rules: {
+ *     ...recommended.rules,
+ *     "boundaries/element-types": ["error", { default: "disallow" }],
+ *   }
+ * });
+ *
+ * export default [config];
+ * ```
+ */
+export declare function createConfig<PluginName extends string = typeof PLUGIN_NAME>(config: Omit<Config<PluginName> | Config, "plugins">, name?: PluginName): PluginFullConfig<PluginName>;
+export declare const recommended: Config<"boundaries">;
+export declare const strict: Config<"boundaries">;

package/dist/configs/config.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strict = exports.recommended = void 0;
+exports.createConfig = createConfig;
+const plugin_1 = require("../constants/plugin");
+const rules_1 = require("../constants/rules");
+const settings_1 = require("../constants/settings");
+const index_1 = __importDefault(require("../index"));
+const recommended_1 = __importDefault(require("./recommended"));
+const strict_1 = __importDefault(require("./strict"));
+__exportStar(require("../types"), exports);
+function renamePluginRules(rules, pluginName = plugin_1.PLUGIN_NAME) {
+    if (!rules) {
+        return {};
+    }
+    const allowedPrefixes = [plugin_1.PLUGIN_NAME, pluginName];
+    // Return the same rules objects, but converting plugin default rule keys with provided plugin name
+    return Object.entries(rules).reduce((acc, [key, value]) => {
+        if (!key.includes("/")) {
+            throw new Error(`Invalid rule key "${key}". When using createConfig, all rules must belong to eslint-plugin-boundaries. You can prefix them with the original plugin name "${plugin_1.PLUGIN_NAME}/", or with the provided plugin name "${pluginName}/".`);
+        }
+        const splittedRuleKey = key.split("/");
+        const rulePrefix = splittedRuleKey[0];
+        const ruleName = splittedRuleKey[1];
+        if (!allowedPrefixes.includes(rulePrefix)) {
+            throw new Error(`Invalid rule key "${key}". When using createConfig, all rules must belong to eslint-plugin-boundaries. You can prefix them with the original plugin name "${plugin_1.PLUGIN_NAME}/", or with the provided plugin name "${pluginName}/".`);
+        }
+        if (!(0, rules_1.isRuleShortName)(ruleName)) {
+            throw new Error(`Invalid rule name "${ruleName}". When using createConfig, all rules must belong to eslint-plugin-boundaries.`);
+        }
+        const newKey = rulePrefix === plugin_1.PLUGIN_NAME
+            ? `${pluginName}/${key.slice(`${plugin_1.PLUGIN_NAME}/`.length)}`
+            : key;
+        acc[newKey] = value;
+        return acc;
+    }, {});
+}
+/**
+ * Returns an ESLint config object with the boundaries plugin registered, providing default JS and TS file patterns
+ * and enforcing valid types for settings and rules. Supports renaming the plugin. Rules can be prefixed with either
+ * the original plugin name or the provided plugin name.
+ *
+ * @param config - ESLint config object without the plugins field.
+ * @param name - The name of the plugin to register. Defaults to "boundaries".
+ * @returns {Linter.Config} The ESLint config object with the boundaries plugin registered and the provided config merged in.
+ * @throws {Error} If settings or rules are not from eslint-plugin-boundaries.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, recommended } from "eslint-plugin-boundaries/config";
+ *
+ * const config = createConfig({
+ *   settings: {
+ *     ...recommended.settings,
+ *     "boundaries/elements": [],
+ *     "boundaries/ignore": ["ignored/*.js"],
+ *   },
+ *   rules: {
+ *     ...recommended.rules,
+ *     "boundaries/element-types": ["error", { default: "disallow" }],
+ *   }
+ * });
+ *
+ * export default [config];
+ * ```
+ */
+function createConfig(config, name = plugin_1.PLUGIN_NAME) {
+    const pluginsRegistration = {
+        [name]: index_1.default,
+    };
+    if (Object.prototype.hasOwnProperty.call(config, "plugins")) {
+        throw new Error("The 'plugins' field is managed by createConfig and should not be provided in the config argument.");
+    }
+    if (Object.prototype.hasOwnProperty.call(config, "settings")) {
+        const settings = config.settings;
+        if (settings) {
+            for (const key of Object.keys(settings)) {
+                if (!(0, settings_1.isSettingsKey)(key)) {
+                    throw new Error(`Invalid settings key "${key}". When using createConfig, all settings keys must belong to eslint-plugin-boundaries.`);
+                }
+            }
+        }
+    }
+    return {
+        files: [
+            "**/*.js",
+            "**/*.jsx",
+            "**/*.ts",
+            "**/*.tsx",
+            "**/*.mjs",
+            "**/*.cjs",
+        ],
+        ...config,
+        plugins: pluginsRegistration,
+        rules: renamePluginRules(config.rules, name),
+    };
+}
+exports.recommended = recommended_1.default;
+exports.strict = strict_1.default;

package/dist/configs/recommended.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from "./Config.types";
+/**
+ * Recommended configuration for eslint-plugin-boundaries.
+ *
+ * It is recommended for applying the plugin to an already existing project.
+ * Rules `boundaries/no-unknown`, `boundaries/no-unknown-files` and `boundaries/no-ignored` are disabled,
+ * so it allows to have parts of the project non-compliant with defined rules, allowing to refactor the code progressively.
+ */
+declare const config: Config;
+export default config;

package/dist/configs/recommended.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const settings_1 = require("../constants/settings");
+const { ELEMENTS, 
+// rules
+RULE_ELEMENT_TYPES, RULE_ENTRY_POINT, RULE_EXTERNAL, RULE_NO_IGNORED, RULE_NO_PRIVATE, RULE_NO_UNKNOWN_FILES, RULE_NO_UNKNOWN, } = settings_1.SETTINGS;
+// TODO In next major version: Export also files, plugin, etc.
+/**
+ * Recommended configuration for eslint-plugin-boundaries.
+ *
+ * It is recommended for applying the plugin to an already existing project.
+ * Rules `boundaries/no-unknown`, `boundaries/no-unknown-files` and `boundaries/no-ignored` are disabled,
+ * so it allows to have parts of the project non-compliant with defined rules, allowing to refactor the code progressively.
+ */
+const config = {
+    rules: {
+        [RULE_ELEMENT_TYPES]: [2],
+        [RULE_ENTRY_POINT]: [2],
+        [RULE_EXTERNAL]: [2],
+        [RULE_NO_IGNORED]: 0,
+        [RULE_NO_PRIVATE]: [
+            2,
+            {
+                allowUncles: true,
+            },
+        ],
+        [RULE_NO_UNKNOWN_FILES]: 0,
+        [RULE_NO_UNKNOWN]: 0,
+    },
+    settings: {
+        [ELEMENTS]: [],
+    },
+};
+exports.default = config;
+// For CommonJS compatibility
+module.exports = config;

package/dist/configs/strict.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from "./Config.types";
+/**
+ * Strict configuration for eslint-plugin-boundaries.
+ *
+ * It enables all rules, enforcing full compliance with defined boundaries. Unknown files and importing ignored files are not allowed.
+ */
+declare const config: Config;
+export default config;

package/dist/configs/strict.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const settings_1 = require("../constants/settings");
+const recommended_1 = __importDefault(require("./recommended"));
+const { RULE_NO_IGNORED, RULE_NO_UNKNOWN_FILES, RULE_NO_UNKNOWN } = settings_1.SETTINGS;
+// TODO In next major version: Export also files, plugin, etc.
+/**
+ * Strict configuration for eslint-plugin-boundaries.
+ *
+ * It enables all rules, enforcing full compliance with defined boundaries. Unknown files and importing ignored files are not allowed.
+ */
+const config = {
+    ...recommended_1.default,
+    rules: {
+        ...recommended_1.default.rules,
+        [RULE_NO_IGNORED]: 2,
+        [RULE_NO_UNKNOWN_FILES]: 2,
+        [RULE_NO_UNKNOWN]: 2,
+    },
+};
+exports.default = config;
+// For CommonJS compatibility
+module.exports = config;

package/dist/constants/DependencyInfo.types.d.ts

@@ -0,0 +1,9 @@
+import type { ImportInfo } from "./ElementsInfo.types";
+import type { ImportKind } from "./settings";
+export type ElementsRelationship = "internal" | "child" | "descendant" | "brother" | "parent" | "uncle" | "ancestor" | null;
+export type DependencyInfo = ImportInfo & {
+    importKind: ImportKind;
+    relationship: ElementsRelationship;
+    isInternal: boolean;
+    baseModule: string | null;
+};

package/dist/constants/DependencyInfo.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/constants/ElementsInfo.types.d.ts

@@ -0,0 +1,24 @@
+import type { CapturedValues } from "./Options.types";
+export type PathCapturedValues = string[];
+export type ElementInfo = {
+    elementPath: string;
+    type: string | null;
+    parents: Pick<ElementInfo, "elementPath" | "type" | "capture" | "capturedValues">[];
+    capture: string[] | null;
+    capturedValues: CapturedValues;
+    internalPath: string | null;
+};
+export type ImportInfo = {
+    source: string;
+    path: string;
+    isIgnored: boolean;
+    isLocal: boolean;
+    isBuiltIn: boolean;
+    isExternal: boolean;
+    baseModule: string | null;
+    specifiers?: string[];
+} & ElementInfo;
+export type FileInfo = ElementInfo & {
+    path: string;
+    isIgnored: boolean;
+};

package/dist/constants/ElementsInfo.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });