@boundaries/eslint-plugin 5.2.0-beta.1

package/dist/Rules/NoIgnored.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Settings_1 = require("../Settings");
+const Support_1 = require("./Support");
+const { RULE_NO_IGNORED } = Settings_1.SETTINGS;
+exports.default = (0, Support_1.dependencyRule)({
+    schema: [],
+    ruleName: RULE_NO_IGNORED,
+    description: `Prevent importing ignored files from recognized elements`,
+}, function ({ dependency, node, context }) {
+    if (dependency.to.isIgnored) {
+        context.report({
+            message: `Importing ignored files is not allowed`,
+            node: node,
+        });
+    }
+}, {
+    validate: false,
+});

package/dist/Rules/NoPrivate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/Rules/NoPrivate.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const elements_1 = require("@boundaries/elements");
+const Messages_1 = require("../Messages");
+const Settings_1 = require("../Settings");
+const Support_1 = require("./Support");
+const { RULE_NO_PRIVATE } = Settings_1.SETTINGS;
+function errorMessage(dependency, options) {
+    if (options?.message) {
+        return (0, Messages_1.customErrorMessage)(options.message, dependency);
+    }
+    // @ts-expect-error could not be defined. TODO: I have to decide whether to unify properties in all elements, or to use type guards
+    return `Dependency is private of element ${(0, Messages_1.elementMessage)(dependency.to.parents?.[0])}`;
+}
+exports.default = (0, Support_1.dependencyRule)({
+    ruleName: RULE_NO_PRIVATE,
+    description: `Prevent importing private elements of another element`,
+    schema: [
+        {
+            type: "object",
+            properties: {
+                allowUncles: {
+                    type: "boolean",
+                },
+                message: {
+                    type: "string",
+                },
+            },
+            additionalProperties: false,
+        },
+    ],
+}, function ({ dependency, node, context, options }) {
+    if (!dependency.to.isIgnored &&
+        (0, elements_1.isLocalDependencyElement)(dependency.to) &&
+        dependency.to.type &&
+        dependency.to.parents.length &&
+        dependency.dependency.relationship.to !==
+            elements_1.DEPENDENCY_RELATIONSHIPS_MAP.INTERNAL &&
+        dependency.dependency.relationship.to !==
+            elements_1.DEPENDENCY_RELATIONSHIPS_MAP.CHILD &&
+        dependency.dependency.relationship.to !==
+            elements_1.DEPENDENCY_RELATIONSHIPS_MAP.SIBLING &&
+        (!options?.allowUncles ||
+            dependency.dependency.relationship.to !==
+                elements_1.DEPENDENCY_RELATIONSHIPS_MAP.UNCLE)) {
+        context.report({
+            message: errorMessage(dependency, options),
+            node: node,
+        });
+    }
+}, {
+    validate: false,
+});

package/dist/Rules/NoUnknown.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;

package/dist/Rules/NoUnknown.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const elements_1 = require("@boundaries/elements");
+const Settings_1 = require("../Settings");
+const Support_1 = require("./Support");
+const { RULE_NO_UNKNOWN } = Settings_1.SETTINGS;
+exports.default = (0, Support_1.dependencyRule)({
+    schema: [],
+    ruleName: RULE_NO_UNKNOWN,
+    description: `Prevent importing unknown elements from the known ones`,
+}, function ({ dependency, node, context }) {
+    if (!dependency.to.isIgnored &&
+        (0, elements_1.isLocalDependencyElement)(dependency.to) &&
+        dependency.to.isUnknown) {
+        context.report({
+            message: `Importing unknown elements is not allowed`,
+            node: node,
+        });
+    }
+}, {
+    validate: false,
+});

package/dist/Rules/NoUnknownFiles.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "eslint";
+declare const noUnknownFilesRule: Rule.RuleModule;
+export default noUnknownFilesRule;

package/dist/Rules/NoUnknownFiles.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Elements_1 = require("../Elements");
+const Settings_1 = require("../Settings");
+const Support_1 = require("./Support");
+const { RULE_NO_UNKNOWN_FILES } = Settings_1.SETTINGS;
+const noUnknownFilesRule = {
+    ...(0, Support_1.meta)({
+        ruleName: RULE_NO_UNKNOWN_FILES,
+        schema: [],
+        description: `Prevent creating files not recognized as any of the element types`,
+    }),
+    create: function (context) {
+        const settings = (0, Settings_1.getSettings)(context);
+        const file = (0, Elements_1.elementDescription)(context.filename, settings);
+        if (file.isIgnored || !file.isUnknown) {
+            return {};
+        }
+        return {
+            Program: (node) => {
+                context.report({
+                    message: `File is not of any known element type`,
+                    node: node,
+                });
+            },
+        };
+    },
+};
+exports.default = noUnknownFilesRule;

package/dist/Rules/Support/DependencyRule.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+import type { RuleOptionsWithRules, RuleMetaDefinition } from "../../Settings";
+import type { DependencyRuleRunner, DependencyRuleOptions } from "./DependencyRule.types";
+export declare function dependencyRule<Options extends RuleOptionsWithRules>(ruleMeta: RuleMetaDefinition, rule: DependencyRuleRunner<Options>, ruleOptions?: DependencyRuleOptions): Rule.RuleModule;

package/dist/Rules/Support/DependencyRule.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyRule = dependencyRule;
+const Elements_1 = require("../../Elements");
+const Settings_1 = require("../../Settings");
+const Support_1 = require("../../Support");
+const Helpers_1 = require("./Helpers");
+const { ADDITIONAL_DEPENDENCY_NODES } = Settings_1.SETTINGS;
+function optionsHaveRules(options) {
+    if (!options) {
+        return false;
+    }
+    return Boolean(options.rules);
+}
+function dependencyRule(ruleMeta, rule, ruleOptions = {}) {
+    return {
+        ...(0, Helpers_1.meta)(ruleMeta),
+        create: function (context) {
+            const options = context.options[0];
+            const settings = (0, Settings_1.getSettings)(context);
+            const file = (0, Elements_1.elementDescription)(context.filename, settings);
+            if (ruleOptions.validate !== false && !options) {
+                return {};
+            }
+            if (ruleOptions.validate !== false && optionsHaveRules(options)) {
+                (0, Settings_1.validateRules)(settings, options.rules, ruleOptions.validateRules);
+            }
+            // TODO: Remove this check when allowing to select by any other property
+            if (file.isIgnored || !file.type) {
+                return {};
+            }
+            return settings.dependencyNodes.reduce((visitors, { selector, kind, name }) => {
+                visitors[selector] = (node) => {
+                    if (!(0, Support_1.isString)(node.value)) {
+                        (0, Support_1.warnOnce)(`Dependency node is not a Literal, skipping node. Please check your ${ADDITIONAL_DEPENDENCY_NODES} setting.`);
+                        return;
+                    }
+                    const dependency = (0, Elements_1.dependencyDescription)({
+                        node,
+                        kind,
+                        nodeKind: name,
+                    }, context.filename, settings, context);
+                    rule({ dependency, options, node, context, settings });
+                };
+                return visitors;
+            }, {});
+        },
+    };
+}

package/dist/Rules/Support/DependencyRule.types.d.ts

@@ -0,0 +1,17 @@
+import type { DependencyDescription } from "@boundaries/elements";
+import type { Rule } from "eslint";
+import type { EslintLiteralNode } from "../../Elements";
+import type { ValidateRulesOptions, SettingsNormalized } from "../../Settings";
+export type DependencyRuleRunner<Options> = (options: {
+    dependency: DependencyDescription;
+    options?: Options;
+    node: EslintLiteralNode;
+    context: Rule.RuleContext;
+    settings: SettingsNormalized;
+}) => void;
+export type DependencyRuleOptions = {
+    /** Whether to validate the presence of options */
+    validate?: boolean;
+    /** Whether to validate the rules */
+    validateRules?: ValidateRulesOptions;
+};

package/dist/Rules/Support/DependencyRule.types.js

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

package/dist/Rules/Support/Helpers.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from "eslint";
+import type { RuleMetaDefinition } from "../../Settings";
+/**
+ * Returns the meta object for an ESLint rule.
+ * @param param0 The rule metadata definition.
+ * @returns The meta object for the ESLint rule.
+ */
+export declare function meta({ description, schema, ruleName, type, }: RuleMetaDefinition): Pick<Rule.RuleModule, "meta">;

package/dist/Rules/Support/Helpers.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meta = meta;
+const Settings_1 = require("../../Settings");
+/**
+ * Removes the plugin namespace from a rule name.
+ * @param ruleName The name of the rule.
+ * @returns The rule name without the plugin namespace.
+ */
+function removePluginNamespace(ruleName) {
+    return ruleName.replace(`${Settings_1.PLUGIN_NAME}/`, "");
+}
+/**
+ * Returns the documentation URL for an ESLint rule.
+ * @param ruleName The name of the rule.
+ * @returns The documentation URL for the ESLint rule.
+ */
+function docsUrl(ruleName) {
+    return `${Settings_1.REPO_URL}/blob/master/docs/rules/${removePluginNamespace(ruleName)}.md`;
+}
+/**
+ * Returns the meta object for an ESLint rule.
+ * @param param0 The rule metadata definition.
+ * @returns The meta object for the ESLint rule.
+ */
+function meta({ description, schema = [], ruleName, type, }) {
+    return {
+        meta: {
+            // TODO: Consider changing default to "suggestion" in a future major release, because most rules are not fixing code issues, but only suggesting best practices.
+            type: type || "problem",
+            docs: {
+                url: docsUrl(ruleName),
+                description,
+                category: "dependencies",
+            },
+            schema,
+        },
+    };
+}

package/dist/Rules/Support/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DependencyRule.types";
+export * from "./DependencyRule";
+export * from "./Helpers";

package/dist/Rules/Support/index.js

@@ -0,0 +1,19 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DependencyRule.types"), exports);
+__exportStar(require("./DependencyRule"), exports);
+__exportStar(require("./Helpers"), exports);

package/dist/Settings/Helpers.d.ts

@@ -0,0 +1,41 @@
+import type { DependencyKind } from "@boundaries/elements";
+import type { DependencyNodeKey, SettingsKey, RulePolicy, RuleShortName, RuleName, RuleMainKey } from "./Settings.types";
+/**
+ * Type guard to check if a value is a valid DependencyKind.
+ * @param value The value to check.
+ * @returns True if the value is a valid DependencyKind, false otherwise.
+ * @deprecated Use isDependencyKind instead.
+ */
+export declare function isImportKind(value: unknown): value is DependencyKind;
+/**
+ * Type guard to check if a value is a valid DependencyNodeKey.
+ * @param value The value to check.
+ * @returns True if the value is a valid DependencyNodeKey, false otherwise.
+ */
+export declare function isDependencyNodeKey(value: unknown): value is DependencyNodeKey;
+/**
+ * Type guard to check if a value is a valid key for the plugin settings.
+ * @param value - The value to check.
+ * @returns True if the value is a valid settings key, false otherwise.
+ */
+export declare function isSettingsKey(value: unknown): value is SettingsKey;
+/**
+ * Type guard to check if a value is a valid RulePolicy.
+ * @param value - The value to check.
+ * @returns True if the value is a valid RulePolicy, false otherwise.
+ */
+export declare function isRulePolicy(value: unknown): value is RulePolicy;
+/**
+ * Type guard to check if a value is a valid rule name including the default plugin prefix.
+ * @param value - The value to check.
+ * @returns True if the value is a valid rule name with the default plugin prefix, false otherwise.
+ */
+export declare function isRuleName(value: unknown): value is RuleName;
+/**
+ * Type guard to check if a value is a valid rule short name.
+ * @param value - The value to check.
+ * @returns True if the value is a valid rule short name, false otherwise.
+ */
+export declare function isRuleShortName(value: unknown): value is RuleShortName;
+export declare function isLegacyType(type: unknown): type is string;
+export declare function rulesMainKey(key?: RuleMainKey): RuleMainKey;

package/dist/Settings/Helpers.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImportKind = isImportKind;
+exports.isDependencyNodeKey = isDependencyNodeKey;
+exports.isSettingsKey = isSettingsKey;
+exports.isRulePolicy = isRulePolicy;
+exports.isRuleName = isRuleName;
+exports.isRuleShortName = isRuleShortName;
+exports.isLegacyType = isLegacyType;
+exports.rulesMainKey = rulesMainKey;
+const elements_1 = require("@boundaries/elements");
+const Support_1 = require("../Support");
+const Settings_types_1 = require("./Settings.types");
+/**
+ * Type guard to check if a value is a valid DependencyKind.
+ * @param value The value to check.
+ * @returns True if the value is a valid DependencyKind, false otherwise.
+ * @deprecated Use isDependencyKind instead.
+ */
+function isImportKind(value) {
+    return ((0, Support_1.isString)(value) &&
+        Object.values(elements_1.DEPENDENCY_KINDS_MAP).includes(value));
+}
+/**
+ * Type guard to check if a value is a valid DependencyNodeKey.
+ * @param value The value to check.
+ * @returns True if the value is a valid DependencyNodeKey, false otherwise.
+ */
+function isDependencyNodeKey(value) {
+    return ((0, Support_1.isString)(value) &&
+        Object.values(Settings_types_1.DEPENDENCY_NODE_KEYS_MAP).includes(value));
+}
+/**
+ * Type guard to check if a value is a valid key for the plugin settings.
+ * @param value - The value to check.
+ * @returns True if the value is a valid settings key, false otherwise.
+ */
+function isSettingsKey(value) {
+    return ((0, Support_1.isString)(value) &&
+        Object.values(Settings_types_1.SETTINGS_KEYS_MAP).includes(value));
+}
+/**
+ * Type guard to check if a value is a valid RulePolicy.
+ * @param value - The value to check.
+ * @returns True if the value is a valid RulePolicy, false otherwise.
+ */
+function isRulePolicy(value) {
+    return ((0, Support_1.isString)(value) &&
+        (value === Settings_types_1.RULE_POLICY_ALLOW || value === Settings_types_1.RULE_POLICY_DISALLOW));
+}
+/**
+ * Type guard to check if a value is a valid rule name including the default plugin prefix.
+ * @param value - The value to check.
+ * @returns True if the value is a valid rule name with the default plugin prefix, false otherwise.
+ */
+function isRuleName(value) {
+    return Settings_types_1.RULE_NAMES.includes(value);
+}
+/**
+ * Type guard to check if a value is a valid rule short name.
+ * @param value - The value to check.
+ * @returns True if the value is a valid rule short name, false otherwise.
+ */
+function isRuleShortName(value) {
+    return Settings_types_1.RULE_SHORT_NAMES.includes(value);
+}
+function isLegacyType(type) {
+    return (0, Support_1.isString)(type);
+}
+function rulesMainKey(key = Settings_types_1.FROM) {
+    return key;
+}

package/dist/Settings/Settings.d.ts

@@ -0,0 +1,6 @@
+import type { ElementDescriptors } from "@boundaries/elements";
+import type { Settings } from "./Settings.types";
+export declare function transformLegacyTypes(typesFromSettings?: string[] | ElementDescriptors): ElementDescriptors;
+export declare function getElementsTypeNames(descriptors: ElementDescriptors): string[];
+export declare function getRootPath(settings: Settings): string;
+export declare function isDebugModeEnabled(): string | undefined;

package/dist/Settings/Settings.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLegacyTypes = transformLegacyTypes;
+exports.getElementsTypeNames = getElementsTypeNames;
+exports.getRootPath = getRootPath;
+exports.isDebugModeEnabled = isDebugModeEnabled;
+const node_path_1 = require("node:path");
+const Support_1 = require("../Support");
+const Helpers_1 = require("./Helpers");
+const Settings_types_1 = require("./Settings.types");
+const { VALID_MODES, ROOT_PATH, ENV_ROOT_PATH, DEBUG } = Settings_types_1.SETTINGS;
+// TODO, remove in next major version
+function transformLegacyTypes(typesFromSettings) {
+    const types = typesFromSettings || [];
+    if (!(0, Support_1.isArray)(types)) {
+        return [];
+    }
+    return types.map((type) => {
+        // backward compatibility with v1
+        if ((0, Helpers_1.isLegacyType)(type)) {
+            return {
+                type: type,
+                match: VALID_MODES[0],
+                pattern: `${type}/*`,
+                capture: ["elementName"],
+            };
+        }
+        // default options
+        return {
+            match: VALID_MODES[0],
+            ...type,
+        };
+    });
+}
+function getElementsTypeNames(descriptors) {
+    return descriptors.map((element) => element.type).filter(Boolean);
+}
+function getRootPath(settings) {
+    const rootPathUserSetting = process.env[ENV_ROOT_PATH] || settings[ROOT_PATH];
+    if (rootPathUserSetting) {
+        return (0, node_path_1.isAbsolute)(rootPathUserSetting)
+            ? rootPathUserSetting
+            : (0, node_path_1.resolve)(process.cwd(), rootPathUserSetting);
+    }
+    return process.cwd();
+}
+function isDebugModeEnabled() {
+    return process.env[DEBUG];
+}