@boundaries/eslint-plugin 5.2.0-beta.1

package/dist/Settings/Validations.d.ts

@@ -0,0 +1,137 @@
+import type { ElementsSelector, ExternalLibrariesSelector, ElementDescriptor } from "@boundaries/elements";
+import type { Rule } from "eslint";
+import type { Settings, RuleMainKey, ValidateRulesOptions, RuleOptionsRules, SettingsNormalized } from "./Settings.types";
+export declare function elementsMatcherSchema(matcherOptions?: Record<string, unknown>): {
+    oneOf: ({
+        type: string;
+        items?: undefined;
+    } | {
+        type: string;
+        items: {
+            oneOf: ({
+                type: string;
+                items?: undefined;
+            } | {
+                type: string;
+                items: Record<string, unknown>[];
+            })[];
+        };
+    })[];
+};
+export declare function rulesOptionsSchema(options?: {
+    rulesMainKey?: RuleMainKey;
+    targetMatcherOptions?: Record<string, unknown>;
+}): {
+    type: string;
+    properties: {
+        message: {
+            type: string;
+        };
+        default: {
+            type: string;
+            enum: string[];
+        };
+        rules: {
+            type: string;
+            items: {
+                type: string;
+                properties: {
+                    [x: string]: {
+                        oneOf: ({
+                            type: string;
+                            items?: undefined;
+                        } | {
+                            type: string;
+                            items: {
+                                oneOf: ({
+                                    type: string;
+                                    items?: undefined;
+                                } | {
+                                    type: string;
+                                    items: Record<string, unknown>[];
+                                })[];
+                            };
+                        })[];
+                    } | {
+                        oneOf: ({
+                            type: string;
+                            items?: undefined;
+                        } | {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        })[];
+                        type?: undefined;
+                    } | {
+                        type: string;
+                        oneOf?: undefined;
+                    };
+                    allow: {
+                        oneOf: ({
+                            type: string;
+                            items?: undefined;
+                        } | {
+                            type: string;
+                            items: {
+                                oneOf: ({
+                                    type: string;
+                                    items?: undefined;
+                                } | {
+                                    type: string;
+                                    items: Record<string, unknown>[];
+                                })[];
+                            };
+                        })[];
+                    };
+                    disallow: {
+                        oneOf: ({
+                            type: string;
+                            items?: undefined;
+                        } | {
+                            type: string;
+                            items: {
+                                oneOf: ({
+                                    type: string;
+                                    items?: undefined;
+                                } | {
+                                    type: string;
+                                    items: Record<string, unknown>[];
+                                })[];
+                            };
+                        })[];
+                    };
+                    importKind: {
+                        oneOf: ({
+                            type: string;
+                            items?: undefined;
+                        } | {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                        })[];
+                    };
+                    message: {
+                        type: string;
+                    };
+                };
+                additionalProperties: boolean;
+                anyOf: {
+                    required: string[];
+                }[];
+            };
+        };
+    };
+    additionalProperties: boolean;
+}[];
+export declare function validateElementTypesMatcher(elementsMatcher: ElementsSelector | ExternalLibrariesSelector, settings: SettingsNormalized): void;
+export declare function validateSettings(settings: Rule.RuleContext["settings"]): Settings;
+/**
+ * Returns the normalized settings from the ESLint rule context
+ * @param context The ESLint rule context
+ * @returns The normalized settings
+ */
+export declare function getSettings(context: Rule.RuleContext): SettingsNormalized;
+export declare function validateRules(settings: SettingsNormalized, rules?: RuleOptionsRules[], options?: ValidateRulesOptions): void;
+export declare function isValidElementAssigner(element: unknown): element is ElementDescriptor;

package/dist/Settings/Validations.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.elementsMatcherSchema = elementsMatcherSchema;
+exports.rulesOptionsSchema = rulesOptionsSchema;
+exports.validateElementTypesMatcher = validateElementTypesMatcher;
+exports.validateSettings = validateSettings;
+exports.getSettings = getSettings;
+exports.validateRules = validateRules;
+exports.isValidElementAssigner = isValidElementAssigner;
+const elements_1 = require("@boundaries/elements");
+const micromatch_1 = __importDefault(require("micromatch"));
+const Common_1 = require("../Support/Common");
+const Debug_1 = require("../Support/Debug");
+const Helpers_1 = require("./Helpers");
+const Settings_1 = require("./Settings");
+const Settings_types_1 = require("./Settings.types");
+const { TYPES, ALIAS, ELEMENTS, DEPENDENCY_NODES, ADDITIONAL_DEPENDENCY_NODES, VALID_DEPENDENCY_NODE_KINDS, DEFAULT_DEPENDENCY_NODES, VALID_MODES, } = Settings_types_1.SETTINGS;
+const settingsCache = new elements_1.CacheManager();
+const invalidMatchers = [];
+const DEFAULT_MATCHER_OPTIONS = {
+    type: "object",
+};
+function elementsMatcherSchema(matcherOptions = DEFAULT_MATCHER_OPTIONS) {
+    return {
+        oneOf: [
+            {
+                type: "string", // single matcher
+            },
+            {
+                type: "array", // multiple matchers
+                items: {
+                    oneOf: [
+                        {
+                            type: "string", // matcher with options
+                        },
+                        {
+                            type: "array",
+                            items: [
+                                {
+                                    type: "string", // matcher
+                                },
+                                matcherOptions, // options
+                            ],
+                        },
+                    ],
+                },
+            },
+        ],
+    };
+}
+function rulesOptionsSchema(options = {}) {
+    const mainKey = (0, Helpers_1.rulesMainKey)(options.rulesMainKey);
+    return [
+        {
+            type: "object",
+            properties: {
+                message: {
+                    type: "string",
+                },
+                default: {
+                    type: "string",
+                    enum: ["allow", "disallow"],
+                },
+                rules: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            [mainKey]: elementsMatcherSchema(),
+                            allow: elementsMatcherSchema(options.targetMatcherOptions),
+                            disallow: elementsMatcherSchema(options.targetMatcherOptions),
+                            importKind: {
+                                oneOf: [
+                                    {
+                                        type: "string",
+                                    },
+                                    {
+                                        type: "array",
+                                        items: {
+                                            type: "string",
+                                        },
+                                    },
+                                ],
+                            },
+                            message: {
+                                type: "string",
+                            },
+                        },
+                        additionalProperties: false,
+                        anyOf: [
+                            {
+                                required: [mainKey, "allow", "disallow"],
+                            },
+                            {
+                                required: [mainKey, "allow"],
+                            },
+                            {
+                                required: [mainKey, "disallow"],
+                            },
+                        ],
+                    },
+                },
+            },
+            additionalProperties: false,
+        },
+    ];
+}
+function isValidElementTypesMatcher(matcher, settings) {
+    const matcherToCheck = (0, Common_1.isArray)(matcher) ? matcher[0] : matcher;
+    const typeMatcherToCheck = (0, Common_1.isString)(matcherToCheck)
+        ? matcherToCheck
+        : matcherToCheck.type;
+    return (!matcher ||
+        (typeMatcherToCheck &&
+            micromatch_1.default.some(settings.elementTypeNames, typeMatcherToCheck)));
+}
+// TODO: Remove this validation. Selectors should not be limited to element types defined in settings when using selector objects
+function validateElementTypesMatcher(elementsMatcher, settings) {
+    const [matcher] = (0, Common_1.isArray)(elementsMatcher)
+        ? elementsMatcher
+        : [elementsMatcher];
+    if (!invalidMatchers.includes(matcher) &&
+        !isValidElementTypesMatcher(matcher, settings)) {
+        invalidMatchers.push(matcher);
+        (0, Debug_1.warnOnce)(`Option '${matcher}' does not match any element type from '${ELEMENTS}' setting`);
+    }
+}
+function validateElements(elements) {
+    if (!elements || !(0, Common_1.isArray)(elements) || !elements.length) {
+        (0, Debug_1.warnOnce)(`Please provide element types using the '${ELEMENTS}' setting`);
+        return;
+    }
+    return elements.filter(isValidElementAssigner);
+}
+function validateDependencyNodes(dependencyNodes) {
+    if (!dependencyNodes) {
+        return;
+    }
+    const defaultNodesNames = Object.keys(DEFAULT_DEPENDENCY_NODES);
+    const invalidFormatMessage = [
+        `Please provide a valid value in ${DEPENDENCY_NODES} setting.`,
+        `The value should be an array of the following strings:`,
+        ` "${defaultNodesNames.join('", "')}".`,
+    ].join(" ");
+    if (!(0, Common_1.isArray)(dependencyNodes)) {
+        (0, Debug_1.warnOnce)(invalidFormatMessage);
+        return;
+    }
+    for (const dependencyNode of dependencyNodes) {
+        if (!(0, Helpers_1.isDependencyNodeKey)(dependencyNode)) {
+            (0, Debug_1.warnOnce)(invalidFormatMessage);
+        }
+    }
+    return dependencyNodes.filter(Helpers_1.isDependencyNodeKey);
+}
+/**
+ * Validates the legacyTemplates setting.
+ * @param legacyTemplates The legacyTemplates setting value
+ * @returns The validated legacyTemplates value or undefined
+ */
+function validateLegacyTemplates(
+/** The legacyTemplates setting value */
+legacyTemplates) {
+    if (legacyTemplates === undefined) {
+        return;
+    }
+    if ((0, Common_1.isBoolean)(legacyTemplates)) {
+        return legacyTemplates;
+    }
+    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.LEGACY_TEMPLATES}' setting. The value should be a boolean.`);
+    // Value is invalid, return undefined
+    return;
+}
+function isValidDependencyNodeSelector(selector) {
+    const isValidObject = (0, Common_1.isObject)(selector) &&
+        (0, Common_1.isString)(selector.selector) &&
+        (!selector.kind ||
+            ((0, Common_1.isString)(selector.kind) &&
+                VALID_DEPENDENCY_NODE_KINDS.includes(selector.kind)));
+    if (!isValidObject) {
+        (0, Debug_1.warnOnce)(`Please provide a valid object in ${ADDITIONAL_DEPENDENCY_NODES} setting. The object should be composed of the following properties: { selector: "<esquery selector>", kind: "value" | "type" }. The invalid object will be ignored.`);
+    }
+    return isValidObject;
+}
+function validateAdditionalDependencyNodes(additionalDependencyNodes) {
+    if (!additionalDependencyNodes) {
+        return;
+    }
+    const invalidFormatMessage = [
+        `Please provide a valid value in ${ADDITIONAL_DEPENDENCY_NODES} setting.`,
+        "The value should be an array composed of the following objects:",
+        '{ selector: "<esquery selector>", kind: "value" | "type" }.',
+    ].join(" ");
+    if (!(0, Common_1.isArray)(additionalDependencyNodes)) {
+        (0, Debug_1.warnOnce)(invalidFormatMessage);
+        return;
+    }
+    return additionalDependencyNodes.filter(isValidDependencyNodeSelector);
+}
+function deprecateAlias(aliases) {
+    if (aliases) {
+        (0, Debug_1.warnOnce)(`Defining aliases in '${ALIAS}' setting is deprecated. Please use 'import/resolver' setting`);
+    }
+}
+function deprecateTypes(types) {
+    if (types) {
+        (0, Debug_1.warnOnce)(`'${TYPES}' setting is deprecated. Please use '${ELEMENTS}' instead`);
+    }
+}
+function validateIgnore(ignore) {
+    if (!ignore) {
+        return;
+    }
+    if ((0, Common_1.isString)(ignore) || ((0, Common_1.isArray)(ignore) && ignore.every(Common_1.isString))) {
+        return ignore;
+    }
+    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.IGNORE}' setting. The value should be a string or an array of strings.`);
+}
+function validateInclude(include) {
+    if (!include) {
+        return;
+    }
+    if ((0, Common_1.isString)(include) || ((0, Common_1.isArray)(include) && include.every(Common_1.isString))) {
+        return include;
+    }
+    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.INCLUDE}' setting. The value should be a string or an array of strings.`);
+}
+function validateRootPath(rootPath) {
+    if (!rootPath) {
+        return;
+    }
+    if ((0, Common_1.isString)(rootPath)) {
+        return rootPath;
+    }
+    (0, Debug_1.warnOnce)(`Please provide a valid value in '${Settings_types_1.SETTINGS_KEYS_MAP.ROOT_PATH}' setting. The value should be a string.`);
+}
+function validateSettings(settings) {
+    deprecateTypes(settings[TYPES]);
+    deprecateAlias(settings[ALIAS]);
+    return {
+        [Settings_types_1.SETTINGS_KEYS_MAP.ELEMENTS]: validateElements(settings[ELEMENTS] || settings[TYPES]),
+        [Settings_types_1.SETTINGS_KEYS_MAP.IGNORE]: validateIgnore(settings[Settings_types_1.SETTINGS_KEYS_MAP.IGNORE]),
+        [Settings_types_1.SETTINGS_KEYS_MAP.INCLUDE]: validateInclude(settings[Settings_types_1.SETTINGS_KEYS_MAP.INCLUDE]),
+        [Settings_types_1.SETTINGS_KEYS_MAP.ROOT_PATH]: validateRootPath(settings[Settings_types_1.SETTINGS_KEYS_MAP.ROOT_PATH]),
+        [Settings_types_1.SETTINGS_KEYS_MAP.DEPENDENCY_NODES]: validateDependencyNodes(settings[DEPENDENCY_NODES]),
+        [Settings_types_1.SETTINGS_KEYS_MAP.LEGACY_TEMPLATES]: validateLegacyTemplates(settings[Settings_types_1.SETTINGS_KEYS_MAP.LEGACY_TEMPLATES]),
+        [Settings_types_1.SETTINGS_KEYS_MAP.ADDITIONAL_DEPENDENCY_NODES]: validateAdditionalDependencyNodes(settings[ADDITIONAL_DEPENDENCY_NODES]),
+    };
+}
+/**
+ * Returns the normalized settings from the ESLint rule context
+ * @param context The ESLint rule context
+ * @returns The normalized settings
+ */
+function getSettings(context) {
+    if (settingsCache.has(context.settings)) {
+        return settingsCache.get(context.settings);
+    }
+    const validatedSettings = validateSettings(context.settings);
+    const dependencyNodesSetting = (0, Common_1.getArrayOrNull)(validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.DEPENDENCY_NODES]);
+    const additionalDependencyNodesSetting = (0, Common_1.getArrayOrNull)(validatedSettings[ADDITIONAL_DEPENDENCY_NODES]);
+    const dependencyNodes = 
+    // TODO In next major version, make this default to all types of nodes!!!
+    (dependencyNodesSetting || [Settings_types_1.DEPENDENCY_NODE_KEYS_MAP.IMPORT])
+        .flatMap((dependencyNode) => [
+        ...DEFAULT_DEPENDENCY_NODES[dependencyNode],
+    ])
+        .filter(Boolean);
+    const additionalDependencyNodes = additionalDependencyNodesSetting || [];
+    const ignoreSetting = validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.IGNORE];
+    const ignorePaths = (0, Common_1.isString)(ignoreSetting) ? [ignoreSetting] : ignoreSetting;
+    const includeSetting = validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.INCLUDE];
+    const includePaths = (0, Common_1.isString)(includeSetting)
+        ? [includeSetting]
+        : includeSetting;
+    const descriptors = (0, Settings_1.transformLegacyTypes)(validatedSettings[ELEMENTS]);
+    // NOTE: Filter valid descriptors only to avoid a breaking change for the moment
+    const validDescriptors = descriptors.filter(elements_1.isElementDescriptor);
+    const invalidDescriptors = descriptors.filter((desc) => !(0, elements_1.isElementDescriptor)(desc));
+    if (invalidDescriptors.length > 0) {
+        /*
+         * TODO: Report invalid descriptors in ESLint context as a warning in a separate rule:
+         * context.report({
+         * message: `Some element descriptors are invalid and will be ignored: ${JSON.stringify(
+         *   invalidDescriptors,
+         * )}`,
+         * loc: { line: 1, column: 0 },
+         * });
+         */
+        (0, Debug_1.warnOnce)(`Some element descriptors are invalid and will be ignored: ${JSON.stringify(invalidDescriptors)}`);
+    }
+    const result = {
+        elementDescriptors: validDescriptors,
+        elementTypeNames: (0, Settings_1.getElementsTypeNames)(validDescriptors),
+        ignorePaths,
+        includePaths,
+        rootPath: (0, Settings_1.getRootPath)(validatedSettings),
+        dependencyNodes: [...dependencyNodes, ...additionalDependencyNodes],
+        legacyTemplates: validatedSettings[Settings_types_1.SETTINGS_KEYS_MAP.LEGACY_TEMPLATES] ??
+            Settings_types_1.LEGACY_TEMPLATES_DEFAULT,
+    };
+    settingsCache.set(context.settings, result);
+    return result;
+}
+function validateRules(settings, rules = [], options = {}) {
+    const mainKey = (0, Helpers_1.rulesMainKey)(options.mainKey);
+    for (const rule of rules) {
+        //@ts-expect-error TODO: Add a different schema validation for each rule type, so keys are properly validated
+        validateElementTypesMatcher([rule[mainKey]], settings);
+        if (!options.onlyMainKey) {
+            if (rule.allow) {
+                validateElementTypesMatcher(rule.allow, settings);
+            }
+            if (rule.disallow) {
+                validateElementTypesMatcher(rule.disallow, settings);
+            }
+        }
+    }
+}
+function isValidElementAssigner(element) {
+    if (!element) {
+        (0, Debug_1.warnOnce)(`Please provide a valid object to define element types in '${ELEMENTS}' setting`);
+        return false;
+    }
+    if ((0, Helpers_1.isLegacyType)(element)) {
+        (0, Debug_1.warnOnce)(`Defining elements as strings in settings is deprecated. Will be automatically converted, but this feature will be removed in next major versions`);
+        return true;
+    }
+    else {
+        const isObjectElement = (0, Common_1.isObject)(element);
+        if (!isObjectElement) {
+            (0, Debug_1.warnOnce)(`Please provide a valid object to define element types in '${ELEMENTS}' setting`);
+            return false;
+        }
+        if (!element.type || !(0, Common_1.isString)(element.type)) {
+            (0, Debug_1.warnOnce)(`Please provide type in '${ELEMENTS}' setting`);
+            return false;
+        }
+        if (element.mode &&
+            (0, Common_1.isString)(element.mode) &&
+            !VALID_MODES.includes(element.mode)) {
+            (0, Debug_1.warnOnce)(`Invalid mode property of type ${element.type} in '${ELEMENTS}' setting. Should be one of ${VALID_MODES.join(",")}. Default value "${VALID_MODES[0]}" will be used instead`);
+            return false;
+        }
+        if (!element.pattern ||
+            !((0, Common_1.isString)(element.pattern) || (0, Common_1.isArray)(element.pattern))) {
+            (0, Debug_1.warnOnce)(`Please provide a valid pattern to type ${element.type} in '${ELEMENTS}' setting`);
+            return false;
+        }
+        if (element.capture && !(0, Common_1.isArray)(element.capture)) {
+            (0, Debug_1.warnOnce)(`Invalid capture property of type ${element.type} in '${ELEMENTS}' setting`);
+            return false;
+        }
+        return true;
+    }
+}

package/dist/Settings/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Settings";
+export * from "./Validations";
+export * from "./Settings.types";
+export * from "./Helpers";

package/dist/Settings/index.js

@@ -0,0 +1,20 @@
+"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("./Settings"), exports);
+__exportStar(require("./Validations"), exports);
+__exportStar(require("./Settings.types"), exports);
+__exportStar(require("./Helpers"), exports);

package/dist/Support/Common.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Determines if the provided object is an array.
+ * @param object The object to check.
+ * @returns True if the object is an array, false otherwise.
+ */
+export declare function isArray(object: unknown): object is unknown[];
+/**
+ * Determines if the provided object is a string.
+ * @param object The object to check.
+ * @returns True if the object is a string, false otherwise.
+ */
+export declare function isString(object: unknown): object is string;
+/**
+ * Determines if the provided object is a boolean.
+ * @param object The object to check.
+ * @returns True if the object is a boolean, false otherwise.
+ */
+export declare function isBoolean(object: unknown): object is boolean;
+/**
+ * Determines if the provided object is a non-null object (but not an array).
+ * @param object The object to check.
+ * @returns True if the object is a non-null object, false otherwise.
+ */
+export declare function isObject(object: unknown): object is Record<string, unknown>;
+/**
+ * Returns the value as an array if it is an array, or null otherwise.
+ * @param value The value to check.
+ * @returns The value as an array or null.
+ */
+export declare function getArrayOrNull<T>(value: unknown): T[] | null;

package/dist/Support/Common.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArray = isArray;
+exports.isString = isString;
+exports.isBoolean = isBoolean;
+exports.isObject = isObject;
+exports.getArrayOrNull = getArrayOrNull;
+/**
+ * Determines if the provided object is an array.
+ * @param object The object to check.
+ * @returns True if the object is an array, false otherwise.
+ */
+function isArray(object) {
+    return Array.isArray(object);
+}
+/**
+ * Determines if the provided object is a string.
+ * @param object The object to check.
+ * @returns True if the object is a string, false otherwise.
+ */
+function isString(object) {
+    return typeof object === "string";
+}
+/**
+ * Determines if the provided object is a boolean.
+ * @param object The object to check.
+ * @returns True if the object is a boolean, false otherwise.
+ */
+function isBoolean(object) {
+    return typeof object === "boolean";
+}
+/**
+ * Determines if the provided object is a non-null object (but not an array).
+ * @param object The object to check.
+ * @returns True if the object is a non-null object, false otherwise.
+ */
+function isObject(object) {
+    return typeof object === "object" && object !== null && !isArray(object);
+}
+/**
+ * Returns the value as an array if it is an array, or null otherwise.
+ * @param value The value to check.
+ * @returns The value as an array or null.
+ */
+function getArrayOrNull(value) {
+    return isArray(value) ? value : null;
+}

package/dist/Support/Debug.d.ts

@@ -0,0 +1,5 @@
+import type { DependencyDescription, ElementDescription } from "@boundaries/elements";
+export declare function warn(message: string): void;
+export declare function success(message: string): void;
+export declare function warnOnce(message: string): void;
+export declare function debugDescription(elementDescription: ElementDescription | DependencyDescription): void;

package/dist/Support/Debug.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warn = warn;
+exports.success = success;
+exports.warnOnce = warnOnce;
+exports.debugDescription = debugDescription;
+const elements_1 = require("@boundaries/elements");
+const chalk_1 = __importDefault(require("chalk"));
+const Settings_1 = require("../Settings");
+const warns = [];
+const debuggedFiles = [];
+const COLORS_MAP = {
+    gray: "gray",
+    green: "green",
+    yellow: "yellow",
+};
+function trace(message, color) {
+    // eslint-disable-next-line no-console
+    console.log(chalk_1.default[COLORS_MAP[color]](`[${Settings_1.PLUGIN_NAME}]: ${message}`));
+}
+function warn(message) {
+    trace(message, COLORS_MAP.yellow);
+}
+function success(message) {
+    trace(message, COLORS_MAP.green);
+}
+function warnOnce(message) {
+    if (!warns.includes(message)) {
+        warns.push(message);
+        warn(message);
+    }
+}
+function debugDescription(elementDescription) {
+    const isDependency = (0, elements_1.isDependencyDescription)(elementDescription);
+    const key = isDependency
+        ? elementDescription.to.source
+        : elementDescription.path || "";
+    const type = isDependency
+        ? elementDescription.to.type
+        : elementDescription.type;
+    if ((0, Settings_1.isDebugModeEnabled)() && !debuggedFiles.includes(key)) {
+        debuggedFiles.push(key);
+        if (type) {
+            success(`'${key}' is of type '${type}'`);
+        }
+        else {
+            warn(`'${key}' is of unknown type`);
+        }
+        trace(`\n${JSON.stringify(elementDescription, null, 2)}`, COLORS_MAP.gray);
+    }
+}

package/dist/Support/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Common";
+export * from "./Debug";

package/dist/Support/index.js

@@ -0,0 +1,18 @@
+"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("./Common"), exports);
+__exportStar(require("./Debug"), exports);