@conarti/eslint-plugin-feature-sliced 1.0.3

package/dist/configs/import-order/recommended.js

@@ -0,0 +1,28 @@
+"use strict";
+const config_1 = require("../../config");
+const LAYERS_REVERSED = [...config_1.layers].reverse();
+module.exports = {
+    plugins: [
+        'import',
+    ],
+    rules: {
+        'import/order': [
+            2,
+            {
+                alphabetize: {
+                    order: 'asc',
+                    caseInsensitive: true,
+                },
+                'newlines-between': 'never',
+                pathGroups: LAYERS_REVERSED.map((layer) => ({
+                    pattern: `**/?(*)${layer}{,/**}`,
+                    group: 'internal',
+                    position: 'after',
+                })),
+                distinctGroup: false,
+                pathGroupsExcludedImportTypes: ['builtin'],
+                groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
+            },
+        ],
+    },
+};

package/dist/configs/import-order/with-newlines-and-type-group.js

@@ -0,0 +1,28 @@
+"use strict";
+const config_1 = require("../../config");
+const LAYERS_REVERSED = [...config_1.layers].reverse();
+module.exports = {
+    plugins: [
+        'import',
+    ],
+    rules: {
+        'import/order': [
+            2,
+            {
+                alphabetize: {
+                    order: 'asc',
+                    caseInsensitive: true,
+                },
+                'newlines-between': 'always',
+                pathGroups: LAYERS_REVERSED.map((layer) => ({
+                    pattern: `**/?(*)${layer}{,/**}`,
+                    group: 'internal',
+                    position: 'after',
+                })),
+                distinctGroup: false,
+                pathGroupsExcludedImportTypes: ['builtin', 'type'],
+                groups: ['builtin', 'external', 'internal', 'type', 'parent', 'sibling', 'index'],
+            },
+        ],
+    },
+};

package/dist/configs/import-order/with-newlines.js

@@ -0,0 +1,28 @@
+"use strict";
+const config_1 = require("../../config");
+const LAYERS_REVERSED = [...config_1.layers].reverse();
+module.exports = {
+    plugins: [
+        'import',
+    ],
+    rules: {
+        'import/order': [
+            2,
+            {
+                alphabetize: {
+                    order: 'asc',
+                    caseInsensitive: true,
+                },
+                'newlines-between': 'always',
+                pathGroups: LAYERS_REVERSED.map((layer) => ({
+                    pattern: `**/?(*)${layer}{,/**}`,
+                    group: 'internal',
+                    position: 'after',
+                })),
+                distinctGroup: false,
+                pathGroupsExcludedImportTypes: ['builtin'],
+                groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index'],
+            },
+        ],
+    },
+};

package/dist/configs/import-order/with-type-group.js

@@ -0,0 +1,28 @@
+"use strict";
+const config_1 = require("../../config");
+const LAYERS_REVERSED = [...config_1.layers].reverse();
+module.exports = {
+    plugins: [
+        'import',
+    ],
+    rules: {
+        'import/order': [
+            2,
+            {
+                alphabetize: {
+                    order: 'asc',
+                    caseInsensitive: true,
+                },
+                'newlines-between': 'never',
+                pathGroups: LAYERS_REVERSED.map((layer) => ({
+                    pattern: `**/?(*)${layer}{,/**}`,
+                    group: 'internal',
+                    position: 'after',
+                })),
+                distinctGroup: false,
+                pathGroupsExcludedImportTypes: ['builtin', 'type'],
+                groups: ['builtin', 'external', 'internal', 'type', 'parent', 'sibling', 'index'],
+            },
+        ],
+    },
+};

package/dist/configs/recommended.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const path_1 = __importDefault(require("path"));
+module.exports = {
+    extends: [
+        path_1.default.resolve(__dirname, './rules'),
+        path_1.default.resolve(__dirname, './import-order/recommended'),
+    ],
+};

package/dist/configs/rules.js

@@ -0,0 +1,11 @@
+"use strict";
+module.exports = {
+    plugins: [
+        '@conarti/feature-sliced',
+    ],
+    rules: {
+        '@conarti/feature-sliced/layers-slices': 'error',
+        '@conarti/feature-sliced/absolute-relative': 'error',
+        '@conarti/feature-sliced/public-api': 'error',
+    },
+};

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const recommended_1 = __importDefault(require("./configs/recommended"));
+const rules_1 = __importDefault(require("./configs/rules"));
+const absolute_relative_1 = __importDefault(require("./rules/absolute-relative"));
+const layers_slices_1 = __importDefault(require("./rules/layers-slices"));
+const public_api_1 = __importDefault(require("./rules/public-api"));
+module.exports = {
+    parserOptions: {
+        ecmaVersion: '2015',
+        sourceType: 'module',
+    },
+    rules: {
+        'absolute-relative': absolute_relative_1.default,
+        'layers-slices': layers_slices_1.default,
+        'public-api': public_api_1.default,
+    },
+    configs: {
+        recommended: recommended_1.default,
+        rules: rules_1.default,
+    },
+};

package/dist/lib/fsd-lib/extract-feature-sliced-parts.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFeatureSlicedParts = void 0;
+const extract_layer_1 = require("./extract-layer");
+const extract_segment_1 = require("./extract-segment");
+const extract_slice_1 = require("./extract-slice");
+function extractFeatureSlicedParts(targetPath, cwd) {
+    const layer = (0, extract_layer_1.extractLayer)(targetPath, cwd);
+    const slice = (0, extract_slice_1.extractSlice)(targetPath);
+    const [segment, segmentFiles] = (0, extract_segment_1.extractSegment)(targetPath);
+    return {
+        layer,
+        slice,
+        segment,
+        segmentFiles,
+    };
+}
+exports.extractFeatureSlicedParts = extractFeatureSlicedParts;

package/dist/lib/fsd-lib/extract-layer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLayer = void 0;
+const config_1 = require("../../config");
+const shared_1 = require("../shared");
+function prepareToExtract(targetPath, cwd) {
+    const lowerCasedTargetPath = targetPath.toLowerCase();
+    if (cwd === undefined) {
+        return lowerCasedTargetPath;
+    }
+    const lowerCasedCwd = cwd.toLowerCase();
+    const pathWithoutCwd = lowerCasedTargetPath.replace(lowerCasedCwd, '');
+    return pathWithoutCwd;
+}
+function extractLayer(targetPath, cwd) {
+    const layersRegExpPattern = `(${config_1.layers.join('|')})(?![\\w\\.-])`;
+    const layersRegExp = new RegExp(layersRegExpPattern, 'ig');
+    const pathForExtract = prepareToExtract(targetPath, cwd);
+    return (0, shared_1.getByRegExp)(pathForExtract, layersRegExp);
+}
+exports.extractLayer = extractLayer;

package/dist/lib/fsd-lib/extract-paths-info.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPathsInfo = void 0;
+const extract_feature_sliced_parts_1 = require("./extract-feature-sliced-parts");
+const extract_paths_1 = require("./extract-paths");
+const validate_extracted_feature_sliced_parts_1 = require("./validate-extracted-feature-sliced-parts");
+function compareFeatureSlicedParts(fsPartsToCompare) {
+    const { target, currentFile, } = fsPartsToCompare;
+    const hasUnknownLayers = target.validatedFeatureSlicedParts.hasNotLayer || currentFile.validatedFeatureSlicedParts.hasNotLayer;
+    const isSameLayer = target.validatedFeatureSlicedParts.hasLayer
+        && currentFile.validatedFeatureSlicedParts.hasLayer
+        && target.fsdParts.layer === currentFile.fsdParts.layer;
+    const isSameSlice = target.validatedFeatureSlicedParts.hasSlice && currentFile.validatedFeatureSlicedParts.hasSlice
+        && target.fsdParts.slice === currentFile.fsdParts.slice;
+    const isSameSegment = target.fsdParts.segment === currentFile.fsdParts.segment;
+    const isSameLayerWithoutSlices = isSameLayer
+        && !target.validatedFeatureSlicedParts.canLayerContainSlices
+        && !currentFile.validatedFeatureSlicedParts.canLayerContainSlices;
+    return {
+        hasUnknownLayers,
+        isSameLayer,
+        isSameSlice,
+        isSameSegment,
+        isSameLayerWithoutSlices,
+    };
+}
+function extractPathsInfo(node, context) {
+    const { targetPath, normalizedTargetPath, normalizedCurrentFilePath, absoluteTargetPath, normalizedCwd, } = (0, extract_paths_1.extractPaths)(node, context);
+    const fsdPartsOfTarget = (0, extract_feature_sliced_parts_1.extractFeatureSlicedParts)(absoluteTargetPath, normalizedCwd);
+    const fsdPartsOfCurrentFile = (0, extract_feature_sliced_parts_1.extractFeatureSlicedParts)(normalizedCurrentFilePath, normalizedCwd);
+    const validatedFeatureSlicedPartsOfTarget = (0, validate_extracted_feature_sliced_parts_1.validateExtractedFeatureSlicedParts)(fsdPartsOfTarget);
+    const validatedFeatureSlicedPartsOfCurrentFile = (0, validate_extracted_feature_sliced_parts_1.validateExtractedFeatureSlicedParts)(fsdPartsOfCurrentFile);
+    const { hasUnknownLayers, isSameLayer, isSameSlice, isSameSegment, isSameLayerWithoutSlices, } = compareFeatureSlicedParts({
+        target: {
+            validatedFeatureSlicedParts: validatedFeatureSlicedPartsOfTarget,
+            fsdParts: fsdPartsOfTarget,
+        },
+        currentFile: {
+            validatedFeatureSlicedParts: validatedFeatureSlicedPartsOfCurrentFile,
+            fsdParts: fsdPartsOfCurrentFile,
+        },
+    });
+    return {
+        targetPath,
+        normalizedTargetPath,
+        normalizedCurrentFilePath,
+        absoluteTargetPath,
+        fsdPartsOfTarget,
+        fsdPartsOfCurrentFile,
+        isSameLayer,
+        isSameSlice,
+        isSameSegment,
+        isSameLayerWithoutSlices,
+        hasUnknownLayers,
+        validatedFeatureSlicedPartsOfTarget,
+        validatedFeatureSlicedPartsOfCurrentFile,
+    };
+}
+exports.extractPathsInfo = extractPathsInfo;

package/dist/lib/fsd-lib/extract-paths.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPaths = void 0;
+const path_lib_1 = require("../path-lib");
+const rule_lib_1 = require("../rule-lib");
+function extractPaths(node, context) {
+    const normalizedCurrentFilePath = (0, rule_lib_1.extractCurrentFilePath)(context);
+    const { targetPath, normalizedTargetPath, } = (0, rule_lib_1.extractNodePath)(node);
+    const absoluteTargetPath = (0, path_lib_1.convertToAbsolute)(normalizedCurrentFilePath, normalizedTargetPath);
+    const cwd = (0, rule_lib_1.extractCwd)(context);
+    return {
+        targetPath,
+        normalizedTargetPath,
+        normalizedCurrentFilePath,
+        absoluteTargetPath,
+        normalizedCwd: cwd,
+    };
+}
+exports.extractPaths = extractPaths;

package/dist/lib/fsd-lib/extract-segment.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSegment = void 0;
+const config_1 = require("../../config");
+const layersUnion = config_1.layersWithSlices.join('|');
+const segmentsUnion = config_1.segments.join('|');
+const fsdPartsRegExp = new RegExp(`(?<=(?<layer>${layersUnion}))\\/(?<slice>([\\w-]*\\/)+?)(?<segment>(${segmentsUnion})(\\.\\w+)?)(\\/(?<segmentFiles>.*))?`);
+function extractSegment(targetPath) {
+    const fsdParts = targetPath.match(fsdPartsRegExp);
+    if (fsdParts === null) {
+        return [null, null];
+    }
+    const { segment = null, segmentFiles = null, } = fsdParts.groups || {};
+    const fileExtensionRegExp = /\.[^/.]+$/;
+    const segmentWithoutFileExtension = segment?.replace(fileExtensionRegExp, '') || null;
+    return [segmentWithoutFileExtension, segmentFiles];
+}
+exports.extractSegment = extractSegment;

package/dist/lib/fsd-lib/extract-slice.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSlice = void 0;
+const config_1 = require("../../config");
+const shared_1 = require("../shared");
+function extractSlice(targetPath) {
+    const targetPathWithoutCurrentFileName = targetPath.replace(/\/\w+\.\w+$/, '');
+    return (0, shared_1.getByRegExp)(targetPathWithoutCurrentFileName, new RegExp(`(?<=(${config_1.layersWithSlices.join('|')})\\/)(\\w|-)+`, 'ig'), true);
+}
+exports.extractSlice = extractSlice;

package/dist/lib/fsd-lib/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLayer = exports.isLayer = exports.getLayerWeight = exports.extractPathsInfo = void 0;
+var extract_paths_info_1 = require("./extract-paths-info");
+Object.defineProperty(exports, "extractPathsInfo", { enumerable: true, get: function () { return extract_paths_info_1.extractPathsInfo; } });
+var layers_1 = require("./layers");
+Object.defineProperty(exports, "getLayerWeight", { enumerable: true, get: function () { return layers_1.getLayerWeight; } });
+Object.defineProperty(exports, "isLayer", { enumerable: true, get: function () { return layers_1.isLayer; } });
+var extract_layer_1 = require("./extract-layer");
+Object.defineProperty(exports, "extractLayer", { enumerable: true, get: function () { return extract_layer_1.extractLayer; } });

package/dist/lib/fsd-lib/layers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canLayerContainSlices = exports.getLayerWeight = exports.isLayer = void 0;
+const config_1 = require("../../config");
+function isLayer(layer) {
+    return config_1.layers.some((fsdLayer) => fsdLayer === layer);
+}
+exports.isLayer = isLayer;
+function getLayerWeight(layer) {
+    return config_1.layers.indexOf(layer);
+}
+exports.getLayerWeight = getLayerWeight;
+function canLayerContainSlices(layer) {
+    return !config_1.layersWithoutSlices.includes(layer);
+}
+exports.canLayerContainSlices = canLayerContainSlices;

package/dist/lib/fsd-lib/validate-extracted-feature-sliced-parts.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExtractedFeatureSlicedParts = void 0;
+const shared_1 = require("../shared");
+const layers_1 = require("./layers");
+function validateExtractedFeatureSlicedParts(extractedFeatureSlicedParts) {
+    const { layer, slice, segment, segmentFiles, } = extractedFeatureSlicedParts;
+    const hasLayer = (0, layers_1.isLayer)(layer);
+    const hasNotLayer = !hasLayer;
+    const hasSlice = !(0, shared_1.isNull)(slice);
+    const hasNotSlice = !hasSlice;
+    const hasSegment = !(0, shared_1.isNull)(segment);
+    const hasNotSegment = !hasSegment;
+    const hasSegmentFiles = !(0, shared_1.isNull)(segmentFiles);
+    const hasNotSegmentFiles = !hasSegmentFiles;
+    const canContainSlices = hasLayer && (0, layers_1.canLayerContainSlices)(layer);
+    return {
+        hasLayer,
+        hasNotLayer,
+        hasSlice,
+        hasNotSlice,
+        hasSegment,
+        hasNotSegment,
+        hasSegmentFiles,
+        hasNotSegmentFiles,
+        canLayerContainSlices: canContainSlices,
+    };
+}
+exports.validateExtractedFeatureSlicedParts = validateExtractedFeatureSlicedParts;

package/dist/lib/path-lib/convert-to-absolute.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToAbsolute = void 0;
+const is_path_relative_1 = require("./is-path-relative");
+const join_path_1 = require("./join-path");
+function convertToAbsolute(base, target) {
+    if (target === '') {
+        return base;
+    }
+    if (base === '') {
+        return target;
+    }
+    if (!(0, is_path_relative_1.isPathRelative)(target)) {
+        return target;
+    }
+    return (0, join_path_1.joinPath)(base, `../${target}`);
+}
+exports.convertToAbsolute = convertToAbsolute;

package/dist/lib/path-lib/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathRelative = exports.convertToAbsolute = exports.normalizePath = void 0;
+var normalize_path_1 = require("./normalize-path");
+Object.defineProperty(exports, "normalizePath", { enumerable: true, get: function () { return normalize_path_1.normalizePath; } });
+var convert_to_absolute_1 = require("./convert-to-absolute");
+Object.defineProperty(exports, "convertToAbsolute", { enumerable: true, get: function () { return convert_to_absolute_1.convertToAbsolute; } });
+var is_path_relative_1 = require("./is-path-relative");
+Object.defineProperty(exports, "isPathRelative", { enumerable: true, get: function () { return is_path_relative_1.isPathRelative; } });

package/dist/lib/path-lib/is-path-relative.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathRelative = void 0;
+function isPathRelative(path) {
+    return path.startsWith('.');
+}
+exports.isPathRelative = isPathRelative;

package/dist/lib/path-lib/join-path.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinPath = void 0;
+const path_1 = __importDefault(require("path"));
+const normalize_path_1 = require("./normalize-path");
+function joinPath(from, to) {
+    return (0, normalize_path_1.normalizePath)(path_1.default.join((0, normalize_path_1.normalizePath)(from), (0, normalize_path_1.normalizePath)(to)));
+}
+exports.joinPath = joinPath;

package/dist/lib/path-lib/normalize-path.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = void 0;
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../../config");
+function normalizePath(targetPath) {
+    const winSepRegExp = /\\/g;
+    const withNormalizedSeparators = path_1.default
+        .normalize(targetPath)
+        .replace(winSepRegExp, config_1.pathSeparator);
+    if (targetPath.startsWith('./')) {
+        return `./${withNormalizedSeparators}`;
+    }
+    return withNormalizedSeparators;
+}
+exports.normalizePath = normalizePath;

package/dist/lib/rule-lib/can-validate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canValidate = void 0;
+const shared_1 = require("../shared");
+function canValidate(node) {
+    if ((0, shared_1.isObject)(node) && 'source' in node) {
+        return node.source !== null;
+    }
+    return false;
+}
+exports.canValidate = canValidate;

package/dist/lib/rule-lib/create-rule.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRule = void 0;
+const url_1 = require("url");
+const utils_1 = require("@typescript-eslint/utils");
+const config_1 = require("../../config");
+exports.createRule = utils_1.ESLintUtils.RuleCreator((name) => new url_1.URL(name, config_1.RULE_DOCS_URL).toString());

package/dist/lib/rule-lib/extract-current-file-path.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCurrentFilePath = void 0;
+const path_lib_1 = require("../path-lib");
+function extractCurrentFilePath(context) {
+    const currentFilePath = context.getPhysicalFilename
+        ? context.getPhysicalFilename()
+        : context.getFilename();
+    return (0, path_lib_1.normalizePath)(currentFilePath);
+}
+exports.extractCurrentFilePath = extractCurrentFilePath;

package/dist/lib/rule-lib/extract-cwd.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCwd = void 0;
+const path_lib_1 = require("../path-lib");
+const shared_1 = require("../shared");
+function extractCwd(context) {
+    const cwd = context.getCwd?.();
+    if ((0, shared_1.isUndefined)(cwd)) {
+        return undefined;
+    }
+    return (0, path_lib_1.normalizePath)(cwd);
+}
+exports.extractCwd = extractCwd;

package/dist/lib/rule-lib/extract-node-path.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractNodePath = void 0;
+const path_lib_1 = require("../path-lib");
+function extractNodePath(node) {
+    const targetPath = node.source.value;
+    const normalizedTargetPath = (0, path_lib_1.normalizePath)(targetPath);
+    return {
+        targetPath,
+        normalizedTargetPath,
+    };
+}
+exports.extractNodePath = extractNodePath;

package/dist/lib/rule-lib/extract-rule-options.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRuleOptions = void 0;
+function extractRuleOptions(optionsWithDefault) {
+    return optionsWithDefault[0];
+}
+exports.extractRuleOptions = extractRuleOptions;

package/dist/lib/rule-lib/get-source-range-without-quotes.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceRangeWithoutQuotes = void 0;
+function getSourceRangeWithoutQuotes([rangeStart, rangeEnd]) {
+    return [rangeStart + 1, rangeEnd - 1];
+}
+exports.getSourceRangeWithoutQuotes = getSourceRangeWithoutQuotes;

package/dist/lib/rule-lib/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIgnoredCurrentFile = exports.extractCwd = exports.extractCurrentFilePath = exports.extractNodePath = exports.isNodeType = exports.createRule = exports.isIgnored = exports.getSourceRangeWithoutQuotes = exports.canValidate = exports.extractRuleOptions = void 0;
+var extract_rule_options_1 = require("./extract-rule-options");
+Object.defineProperty(exports, "extractRuleOptions", { enumerable: true, get: function () { return extract_rule_options_1.extractRuleOptions; } });
+var can_validate_1 = require("./can-validate");
+Object.defineProperty(exports, "canValidate", { enumerable: true, get: function () { return can_validate_1.canValidate; } });
+var get_source_range_without_quotes_1 = require("./get-source-range-without-quotes");
+Object.defineProperty(exports, "getSourceRangeWithoutQuotes", { enumerable: true, get: function () { return get_source_range_without_quotes_1.getSourceRangeWithoutQuotes; } });
+var is_ignored_1 = require("./is-ignored");
+Object.defineProperty(exports, "isIgnored", { enumerable: true, get: function () { return is_ignored_1.isIgnored; } });
+var create_rule_1 = require("./create-rule");
+Object.defineProperty(exports, "createRule", { enumerable: true, get: function () { return create_rule_1.createRule; } });
+var is_node_type_1 = require("./is-node-type");
+Object.defineProperty(exports, "isNodeType", { enumerable: true, get: function () { return is_node_type_1.isNodeType; } });
+var extract_node_path_1 = require("./extract-node-path");
+Object.defineProperty(exports, "extractNodePath", { enumerable: true, get: function () { return extract_node_path_1.extractNodePath; } });
+var extract_current_file_path_1 = require("./extract-current-file-path");
+Object.defineProperty(exports, "extractCurrentFilePath", { enumerable: true, get: function () { return extract_current_file_path_1.extractCurrentFilePath; } });
+var extract_cwd_1 = require("./extract-cwd");
+Object.defineProperty(exports, "extractCwd", { enumerable: true, get: function () { return extract_cwd_1.extractCwd; } });
+var is_ignored_current_file_1 = require("./is-ignored-current-file");
+Object.defineProperty(exports, "isIgnoredCurrentFile", { enumerable: true, get: function () { return is_ignored_current_file_1.isIgnoredCurrentFile; } });

package/dist/lib/rule-lib/is-ignored-current-file.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIgnoredCurrentFile = void 0;
+const extract_current_file_path_1 = require("./extract-current-file-path");
+const extract_rule_options_1 = require("./extract-rule-options");
+const is_ignored_1 = require("./is-ignored");
+function isIgnoredCurrentFile(context, optionsWithDefault) {
+    const ruleOptions = (0, extract_rule_options_1.extractRuleOptions)(optionsWithDefault);
+    const normalizedCurrentFilePath = (0, extract_current_file_path_1.extractCurrentFilePath)(context);
+    return (0, is_ignored_1.isIgnored)(normalizedCurrentFilePath, ruleOptions.ignoreInFilesPatterns);
+}
+exports.isIgnoredCurrentFile = isIgnoredCurrentFile;

package/dist/lib/rule-lib/is-ignored.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIgnored = void 0;
+const picomatch_1 = __importDefault(require("picomatch"));
+function isIgnored(path, patterns) {
+    const match = (0, picomatch_1.default)(patterns);
+    return match(path);
+}
+exports.isIgnored = isIgnored;

package/dist/lib/rule-lib/is-node-type.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNodeType = void 0;
+const types_1 = require("@typescript-eslint/types");
+function isNodeType(node) {
+    const isImport = node.type === types_1.AST_NODE_TYPES.ImportDeclaration;
+    const isExport = node.type === types_1.AST_NODE_TYPES.ExportAllDeclaration
+        || node.type === types_1.AST_NODE_TYPES.ExportNamedDeclaration;
+    if (isImport) {
+        return node.importKind === 'type';
+    }
+    if (isExport) {
+        return node.exportKind === 'type';
+    }
+    return false;
+}
+exports.isNodeType = isNodeType;

package/dist/lib/rule-lib/models.js

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

package/dist/lib/shared/get-by-reg-exp.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getByRegExp = void 0;
+function getByRegExp(target, regExp, fromEnd = false) {
+    const results = target.match(regExp) || [];
+    if (fromEnd) {
+        const lastResult = results[results.length - 1];
+        return lastResult || null;
+    }
+    return results[0] || null;
+}
+exports.getByRegExp = getByRegExp;

package/dist/lib/shared/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUndefined = exports.isNull = exports.isObject = exports.getByRegExp = void 0;
+var get_by_reg_exp_1 = require("./get-by-reg-exp");
+Object.defineProperty(exports, "getByRegExp", { enumerable: true, get: function () { return get_by_reg_exp_1.getByRegExp; } });
+var is_object_1 = require("./is-object");
+Object.defineProperty(exports, "isObject", { enumerable: true, get: function () { return is_object_1.isObject; } });
+var is_null_1 = require("./is-null");
+Object.defineProperty(exports, "isNull", { enumerable: true, get: function () { return is_null_1.isNull; } });
+var is_undefined_1 = require("./is-undefined");
+Object.defineProperty(exports, "isUndefined", { enumerable: true, get: function () { return is_undefined_1.isUndefined; } });

package/dist/lib/shared/is-null.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNull = void 0;
+function isNull(target) {
+    return target === null;
+}
+exports.isNull = isNull;