@conarti/eslint-plugin-feature-sliced 1.0.5 → 2.0.0-rc.2

package/dist/index.cjs

@@ -0,0 +1,1004 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var PLUGIN_NAME = "@conarti/feature-sliced";
+var RULE_NAMES = {
+  LAYERS_SLICES: `${PLUGIN_NAME}/layers-slices`,
+  ABSOLUTE_RELATIVE: `${PLUGIN_NAME}/absolute-relative`,
+  PUBLIC_API: `${PLUGIN_NAME}/public-api`,
+  IMPORT_ORDER: `${PLUGIN_NAME}/import-order`
+};
+var layers = [
+  "shared",
+  "entities",
+  "features",
+  "widgets",
+  "pages",
+  "processes",
+  "app"
+];
+var layersWithoutSlices = [
+  "shared",
+  "app"
+];
+var layersWithSlices = layers.filter((layer) => !layersWithoutSlices.includes(layer));
+var segments = [
+  "ui",
+  "model",
+  "lib",
+  "api",
+  "config",
+  "assets"
+];
+var pathSeparator = "/";
+
+// package.json
+var version = "2.0.0-rc.1";
+
+// src/rules/index.ts
+var import_eslint_plugin_import_x = __toESM(require("eslint-plugin-import-x"), 1);
+
+// src/lib/rule/create-rule.ts
+var import_eslint_utils = require("@typescript-eslint/utils/eslint-utils");
+var blobUrl = "https://github.com/conarti/eslint-plugin-feature-sliced/blob/master/src/rules";
+var createEslintRule = (0, import_eslint_utils.RuleCreator)(
+  (ruleName) => `${blobUrl}/${ruleName}/index.test.ts`
+);
+
+// src/lib/path/is-path-relative.ts
+function isPathRelative(path3) {
+  return path3.startsWith(".");
+}
+
+// src/lib/path/join-path.ts
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/lib/path/normalize-path.ts
+var import_node_path = __toESM(require("path"), 1);
+function normalizePath(targetPath) {
+  const winSepRegExp = /\\/g;
+  const withNormalizedSeparators = import_node_path.default.normalize(targetPath).replace(winSepRegExp, pathSeparator);
+  if (targetPath.startsWith("./")) {
+    return `./${withNormalizedSeparators}`;
+  }
+  return withNormalizedSeparators;
+}
+
+// src/lib/path/join-path.ts
+function joinPath(from, to) {
+  return normalizePath(import_node_path2.default.join(normalizePath(from), normalizePath(to)));
+}
+
+// src/lib/path/convert-to-absolute.ts
+function convertToAbsolute(base, target) {
+  if (target === "") {
+    return base;
+  }
+  if (base === "") {
+    return target;
+  }
+  if (!isPathRelative(target)) {
+    return target;
+  }
+  return joinPath(base, `../${target}`);
+}
+
+// src/lib/rule/extract-current-file-path.ts
+function extractCurrentFilePath(context) {
+  const currentFilePath = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();
+  return normalizePath(currentFilePath);
+}
+
+// src/lib/shared/get-by-reg-exp.ts
+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;
+}
+
+// src/lib/shared/is-null.ts
+function isNull(target) {
+  return target === null;
+}
+
+// src/lib/shared/is-object.ts
+function isObject(target) {
+  return (typeof target === "object" || typeof target === "function") && target !== null;
+}
+
+// src/lib/shared/is-undefined.ts
+function isUndefined(target) {
+  return target === void 0;
+}
+
+// src/lib/rule/extract-cwd.ts
+function extractCwd(context) {
+  const cwd = context.getCwd?.();
+  if (isUndefined(cwd)) {
+    return void 0;
+  }
+  return normalizePath(cwd);
+}
+
+// src/lib/rule/extract-node-path.ts
+function extractNodePath(node) {
+  const targetPath = node.source.value;
+  const normalizedTargetPath = normalizePath(targetPath);
+  return {
+    targetPath,
+    normalizedTargetPath
+  };
+}
+
+// src/lib/rule/extract-paths.ts
+function extractPaths(node, context) {
+  const normalizedCurrentFilePath = extractCurrentFilePath(context);
+  const {
+    targetPath,
+    normalizedTargetPath
+  } = extractNodePath(node);
+  const absoluteTargetPath = convertToAbsolute(normalizedCurrentFilePath, normalizedTargetPath);
+  const cwd = extractCwd(context);
+  return {
+    targetPath,
+    normalizedTargetPath,
+    normalizedCurrentFilePath,
+    absoluteTargetPath,
+    normalizedCwd: cwd
+  };
+}
+
+// src/lib/rule/extract-rule-options.ts
+function extractRuleOptions(optionsWithDefault) {
+  return optionsWithDefault[0];
+}
+
+// src/lib/rule/get-source-range-without-quotes.ts
+function getSourceRangeWithoutQuotes([rangeStart, rangeEnd]) {
+  return [rangeStart + 1, rangeEnd - 1];
+}
+
+// src/lib/rule/has-path.ts
+function hasPath(node) {
+  if (isObject(node) && "source" in node) {
+    return node.source !== null;
+  }
+  return false;
+}
+
+// src/lib/rule/is-ignored.ts
+var import_picomatch = __toESM(require("picomatch"), 1);
+function isIgnored(path3, patterns) {
+  const match = (0, import_picomatch.default)(patterns);
+  return match(path3);
+}
+
+// src/lib/rule/is-ignored-current-file.ts
+function isIgnoredCurrentFile(context, optionsWithDefault) {
+  const ruleOptions = extractRuleOptions(optionsWithDefault);
+  const normalizedCurrentFilePath = extractCurrentFilePath(context);
+  return isIgnored(normalizedCurrentFilePath, ruleOptions.ignoreInFilesPatterns);
+}
+
+// src/lib/rule/is-ignored-target.ts
+function isIgnoredTarget(node, optionsWithDefault) {
+  const { targetPath } = extractNodePath(node);
+  const userDefinedRuleOptions = extractRuleOptions(optionsWithDefault);
+  return isIgnored(targetPath, userDefinedRuleOptions.ignorePatterns);
+}
+
+// src/lib/rule/is-node-type.ts
+var import_utils = require("@typescript-eslint/utils");
+function isNodeType(node) {
+  const isImport = import_utils.ASTUtils.isNodeOfTypes([import_utils.AST_NODE_TYPES.ImportSpecifier, import_utils.AST_NODE_TYPES.ImportDeclaration])(node);
+  const isExport = import_utils.ASTUtils.isNodeOfTypes([import_utils.AST_NODE_TYPES.ExportAllDeclaration, import_utils.AST_NODE_TYPES.ExportNamedDeclaration])(node);
+  if (isImport) {
+    return node.importKind === "type";
+  }
+  if (isExport) {
+    return node.exportKind === "type";
+  }
+  return false;
+}
+
+// src/lib/feature-sliced/extract-layer.ts
+function prepareToExtract(targetPath, cwd) {
+  const lowerCasedTargetPath = targetPath.toLowerCase();
+  if (cwd === void 0) {
+    return lowerCasedTargetPath;
+  }
+  const lowerCasedCwd = cwd.toLowerCase();
+  const pathWithoutCwd = lowerCasedTargetPath.replace(lowerCasedCwd, "");
+  return pathWithoutCwd;
+}
+function extractLayer(targetPath, cwd) {
+  const layersRegExpPattern = `(${layers.join("|")})(?![\\w\\.-])`;
+  const layersRegExp = new RegExp(layersRegExpPattern, "gi");
+  const pathForExtract = prepareToExtract(targetPath, cwd);
+  return getByRegExp(pathForExtract, layersRegExp);
+}
+
+// src/lib/feature-sliced/extract-segment.ts
+var layersUnion = layersWithSlices.join("|");
+var segmentsUnion = segments.join("|");
+var 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];
+}
+
+// src/lib/feature-sliced/extract-slice.ts
+function extractSlice(targetPath) {
+  const targetPathWithoutCurrentFileName = targetPath.replace(/\/\w+\.\w+$/, "");
+  return getByRegExp(targetPathWithoutCurrentFileName, new RegExp(`(?<=(${layersWithSlices.join("|")})\\/)(\\w|-)+`, "gi"));
+}
+
+// src/lib/feature-sliced/extract-feature-sliced-parts.ts
+function extractFeatureSlicedParts(targetPath, cwd) {
+  const layer = extractLayer(targetPath, cwd);
+  const slice = extractSlice(targetPath);
+  const [segment, segmentFiles] = extractSegment(targetPath);
+  return {
+    layer,
+    slice,
+    segment,
+    segmentFiles
+  };
+}
+
+// src/lib/feature-sliced/layers.ts
+function isLayer(layer) {
+  return typeof layer === "string" && layers.includes(layer);
+}
+function getLayerWeight(layer) {
+  return layers.indexOf(layer);
+}
+function canLayerContainSlices(layer) {
+  return !layersWithoutSlices.includes(layer);
+}
+
+// src/lib/feature-sliced/validate-extracted-feature-sliced-parts.ts
+function validateExtractedFeatureSlicedParts(extractedFeatureSlicedParts) {
+  const {
+    layer,
+    slice,
+    segment,
+    segmentFiles
+  } = extractedFeatureSlicedParts;
+  const hasLayer = isLayer(layer);
+  const hasNotLayer = !hasLayer;
+  const hasSlice = !isNull(slice);
+  const hasNotSlice = !hasSlice;
+  const hasSegment = !isNull(segment);
+  const hasNotSegment = !hasSegment;
+  const hasSegmentFiles = !isNull(segmentFiles);
+  const hasNotSegmentFiles = !hasSegmentFiles;
+  const canContainSlices = hasLayer && canLayerContainSlices(layer);
+  return {
+    hasLayer,
+    hasNotLayer,
+    hasSlice,
+    hasNotSlice,
+    hasSegment,
+    hasNotSegment,
+    hasSegmentFiles,
+    hasNotSegmentFiles,
+    canLayerContainSlices: canContainSlices
+  };
+}
+
+// src/lib/feature-sliced/extract-paths-info.ts
+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
+  } = extractPaths(node, context);
+  const fsdPartsOfTarget = extractFeatureSlicedParts(absoluteTargetPath, normalizedCwd);
+  const fsdPartsOfCurrentFile = extractFeatureSlicedParts(normalizedCurrentFilePath, normalizedCwd);
+  const validatedFeatureSlicedPartsOfTarget = validateExtractedFeatureSlicedParts(fsdPartsOfTarget);
+  const validatedFeatureSlicedPartsOfCurrentFile = 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
+  };
+}
+
+// src/rules/absolute-relative/model/errors.ts
+function reportShouldBeRelative(node, context) {
+  context.report({
+    node: node.source,
+    messageId: "must-be-relative-path" /* MUST_BE_RELATIVE_PATH */
+  });
+}
+function reportShouldBeAbsolute(node, context) {
+  context.report({
+    node: node.source,
+    messageId: "must-be-absolute-path" /* MUST_BE_ABSOLUTE_PATH */
+  });
+}
+
+// src/rules/absolute-relative/model/should-be-absolute.ts
+function shouldBeAbsolute(pathsInfo) {
+  const {
+    normalizedTargetPath,
+    fsdPartsOfTarget,
+    fsdPartsOfCurrentFile,
+    hasUnknownLayers
+  } = pathsInfo;
+  const isAbsolute = !isPathRelative(normalizedTargetPath);
+  if (isAbsolute) {
+    return false;
+  }
+  if (hasUnknownLayers) {
+    return false;
+  }
+  return fsdPartsOfCurrentFile.layer !== fsdPartsOfTarget.layer;
+}
+
+// src/rules/absolute-relative/model/should-be-relative.ts
+function shouldBeRelative(pathsInfo) {
+  const {
+    validatedFeatureSlicedPartsOfCurrentFile,
+    normalizedTargetPath,
+    isSameLayerWithoutSlices,
+    isSameLayer,
+    isSameSlice
+  } = pathsInfo;
+  const isRelative = isPathRelative(normalizedTargetPath);
+  if (isRelative) {
+    return false;
+  }
+  const isImportToLayerPublicApi = validatedFeatureSlicedPartsOfCurrentFile.hasNotSlice && isSameLayer;
+  if (isImportToLayerPublicApi) {
+    return true;
+  }
+  if (isSameLayerWithoutSlices) {
+    return true;
+  }
+  const isSameLayerAndSlice = isSameLayer && isSameSlice;
+  return isSameLayerAndSlice;
+}
+
+// src/rules/absolute-relative/model/validate-and-report.ts
+function validateAndReport(node, context, optionsWithDefault, options = { needCheckForAbsolute: true }) {
+  if (!hasPath(node)) {
+    return;
+  }
+  if (isIgnoredCurrentFile(context, optionsWithDefault)) {
+    return;
+  }
+  const pathsInfo = extractPathsInfo(node, context);
+  if (shouldBeRelative(pathsInfo)) {
+    reportShouldBeRelative(node, context);
+  }
+  if (options.needCheckForAbsolute && shouldBeAbsolute(pathsInfo)) {
+    reportShouldBeAbsolute(node, context);
+  }
+}
+
+// src/rules/absolute-relative/index.ts
+var absolute_relative_default = createEslintRule({
+  name: "absolute-relative",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Checks for absolute and relative paths"
+    },
+    messages: {
+      ["must-be-relative-path" /* MUST_BE_RELATIVE_PATH */]: "There must be relative paths",
+      ["must-be-absolute-path" /* MUST_BE_ABSOLUTE_PATH */]: "There must be absolute paths"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignoreInFilesPatterns: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        }
+      }
+    ]
+  },
+  defaultOptions: [
+    {
+      ignoreInFilesPatterns: []
+    }
+  ],
+  create(context, optionsWithDefault) {
+    return {
+      ImportDeclaration(node) {
+        validateAndReport(node, context, optionsWithDefault);
+      },
+      ImportExpression(node) {
+        validateAndReport(node, context, optionsWithDefault);
+      },
+      ExportAllDeclaration(node) {
+        validateAndReport(node, context, optionsWithDefault, { needCheckForAbsolute: false });
+      },
+      ExportNamedDeclaration(node) {
+        validateAndReport(node, context, optionsWithDefault, { needCheckForAbsolute: false });
+      }
+    };
+  }
+});
+
+// src/rules/layers-slices/model/validate-and-report.ts
+var import_utils4 = require("@typescript-eslint/utils");
+
+// src/rules/layers-slices/model/errors.ts
+var import_utils2 = require("@typescript-eslint/utils");
+function reportCanNotImportLayer(context, node, pathsInfo) {
+  function getReportPosition(validatedNode) {
+    const isSpecifier = validatedNode.type === import_utils2.AST_NODE_TYPES.ImportSpecifier;
+    if (isSpecifier) {
+      return validatedNode;
+    }
+    return validatedNode.source;
+  }
+  context.report({
+    node: getReportPosition(node),
+    messageId: "can-not-import" /* CAN_NOT_IMPORT */,
+    data: {
+      importLayer: pathsInfo.fsdPartsOfTarget.layer,
+      currentFileLayer: pathsInfo.fsdPartsOfCurrentFile.layer
+    }
+  });
+}
+
+// src/rules/layers-slices/model/is-not-suitable-for-validation.ts
+function isNotSuitableForValidation(pathsInfo) {
+  const {
+    isSameSlice,
+    isSameLayerWithoutSlices,
+    hasUnknownLayers
+  } = pathsInfo;
+  if (hasUnknownLayers) {
+    return true;
+  }
+  if (isSameSlice) {
+    return true;
+  }
+  if (isSameLayerWithoutSlices) {
+    return true;
+  }
+  return false;
+}
+
+// src/rules/layers-slices/model/specifiers/has-errors-at-all-specifiers.ts
+function hasErrorsAtAllSpecifiers(specifiers, invalidSpecifiers) {
+  const allSpecifiersCount = specifiers.length;
+  const invalidSpecifiersCount = invalidSpecifiers.length;
+  return invalidSpecifiersCount === allSpecifiersCount;
+}
+
+// src/rules/layers-slices/model/validate-node/valid-by-type-import.ts
+function validByTypeImport(node, allowTypeImports) {
+  const isType = isNodeType(node);
+  return allowTypeImports && isType;
+}
+
+// src/rules/layers-slices/model/specifiers/validate-specifiers.ts
+function validateSpecifiers(specifiers, allowTypeImports) {
+  return specifiers.filter((specifier) => !validByTypeImport(specifier, allowTypeImports));
+}
+
+// src/rules/layers-slices/model/specifiers/extract-import-specifiers.ts
+var import_utils3 = require("@typescript-eslint/utils");
+function extractImportSpecifiers(node) {
+  return node.specifiers.filter((specifier) => specifier.type === import_utils3.AST_NODE_TYPES.ImportSpecifier);
+}
+
+// src/rules/layers-slices/model/validate-node/valid-by-layer-order.ts
+function validByLayerOrder(fsdPartsOfTarget, fsdPartsOfCurrentFile) {
+  const importLayerOrder = getLayerWeight(
+    fsdPartsOfTarget.layer
+    /* ts doesn't understand that the check was done on hasUnknownLayers */
+  );
+  const currentFileLayerOrder = getLayerWeight(
+    fsdPartsOfCurrentFile.layer
+    /* ts doesn't understand that the check was done on hasUnknownLayers */
+  );
+  return currentFileLayerOrder > importLayerOrder;
+}
+
+// src/rules/layers-slices/model/validate-node/index.ts
+function validateNode(node, pathsInfo, allowTypeImports) {
+  const {
+    fsdPartsOfTarget,
+    fsdPartsOfCurrentFile
+  } = pathsInfo;
+  if (validByTypeImport(node, allowTypeImports)) {
+    return true;
+  }
+  if (validByLayerOrder(fsdPartsOfTarget, fsdPartsOfCurrentFile)) {
+    return true;
+  }
+  return false;
+}
+
+// src/rules/layers-slices/model/validate-and-report.ts
+function validate(node, pathsInfo, allowTypeImports) {
+  if (validateNode(node, pathsInfo, allowTypeImports)) {
+    return [];
+  }
+  const isImportExpression = import_utils4.ASTUtils.isNodeOfType(import_utils4.AST_NODE_TYPES.ImportExpression)(node);
+  if (isImportExpression) {
+    return [node];
+  }
+  const specifiers = extractImportSpecifiers(node);
+  const invalidSpecifiers = validateSpecifiers(specifiers, allowTypeImports);
+  if (hasErrorsAtAllSpecifiers(specifiers, invalidSpecifiers)) {
+    return [node];
+  }
+  return invalidSpecifiers;
+}
+function reportValidationErrors(nodes, context, pathsInfo) {
+  nodes.forEach((node) => reportCanNotImportLayer(context, node, pathsInfo));
+}
+function validateAndReport2(node, context, optionsWithDefault) {
+  if (!hasPath(node)) {
+    return;
+  }
+  const isIgnoredForValidation = isIgnoredTarget(node, optionsWithDefault) || isIgnoredCurrentFile(context, optionsWithDefault);
+  if (isIgnoredForValidation) {
+    return;
+  }
+  const pathsInfo = extractPathsInfo(node, context);
+  if (isNotSuitableForValidation(pathsInfo)) {
+    return;
+  }
+  const { allowTypeImports } = extractRuleOptions(optionsWithDefault);
+  const nodesToReport = validate(node, pathsInfo, allowTypeImports);
+  reportValidationErrors(nodesToReport, context, pathsInfo);
+}
+
+// src/rules/layers-slices/index.ts
+var layers_slices_default = createEslintRule({
+  name: "layers-slices",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Checks layer imports"
+    },
+    messages: {
+      ["can-not-import" /* CAN_NOT_IMPORT */]: 'You cannot import layer "{{ importLayer }}" into "{{ currentFileLayer }}" (shared -> entities -> features -> widgets -> pages -> processes -> app)'
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowTypeImports: {
+            type: "boolean"
+          },
+          ignorePatterns: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          },
+          ignoreInFilesPatterns: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        }
+      }
+    ]
+  },
+  defaultOptions: [
+    {
+      allowTypeImports: true,
+      ignorePatterns: [],
+      ignoreInFilesPatterns: []
+    }
+  ],
+  create(context, optionsWithDefault) {
+    return {
+      ImportDeclaration(node) {
+        validateAndReport2(node, context, optionsWithDefault);
+      },
+      ImportExpression(node) {
+        validateAndReport2(node, context, optionsWithDefault);
+      }
+    };
+  }
+});
+
+// src/rules/public-api/model/convert-to-public-api.ts
+function addSlashToStart(targetPath) {
+  if (isNull(targetPath)) {
+    return "";
+  }
+  return `/${targetPath}`;
+}
+function extractValueToRemove(pathsInfo) {
+  const {
+    isSameSlice,
+    fsdPartsOfTarget
+  } = pathsInfo;
+  if (isSameSlice) {
+    return fsdPartsOfTarget.segmentFiles;
+  }
+  return `${fsdPartsOfTarget.segment}${addSlashToStart(fsdPartsOfTarget.segmentFiles)}`;
+}
+function convertToPublicApi(pathsInfo) {
+  const { normalizedTargetPath } = pathsInfo;
+  const valueToRemove = extractValueToRemove(pathsInfo);
+  const publicApiPath = normalizedTargetPath.replace(`/${valueToRemove}`, "");
+  return [publicApiPath, valueToRemove];
+}
+
+// src/rules/public-api/model/errors.ts
+function reportShouldBeFromPublicApi(node, context) {
+  const pathsInfo = extractPathsInfo(node, context);
+  const [fixedPath, valueToRemove] = convertToPublicApi(pathsInfo);
+  context.report({
+    node: node.source,
+    messageId: "should-be-from-public-api" /* SHOULD_BE_FROM_PUBLIC_API */,
+    data: {
+      fixedPath
+    },
+    suggest: [
+      {
+        messageId: "remove-suggestion" /* REMOVE_SUGGESTION */,
+        data: {
+          valueToRemove
+        },
+        fix: (fixer) => fixer.replaceTextRange(getSourceRangeWithoutQuotes(node.source.range), fixedPath)
+      }
+    ]
+  });
+}
+function reportLayersPublicApiNotAllowed(node, context) {
+  context.report({
+    node,
+    messageId: "layers-public-api-not-allowed" /* LAYERS_PUBLIC_API_NOT_ALLOWED */
+  });
+}
+
+// src/rules/public-api/model/is-index-file.ts
+function isIndexFile(segmentFiles) {
+  return /^index\.\w+/i.test(segmentFiles);
+}
+
+// src/rules/public-api/model/is-segments-public-api.ts
+function isSegmentsPublicApi(pathsInfo) {
+  const {
+    fsdPartsOfTarget,
+    validatedFeatureSlicedPartsOfTarget,
+    isSameSegment
+  } = pathsInfo;
+  const isSegmentPublicApi = validatedFeatureSlicedPartsOfTarget.hasNotSegmentFiles || isIndexFile(
+    fsdPartsOfTarget.segmentFiles
+    /* 'hasNotSegmentFiles' is already validate it, ts doesn't understand */
+  );
+  return isSameSegment || isSegmentPublicApi;
+}
+
+// src/rules/public-api/model/is-slice-public-api.ts
+function isSlicePublicApi(pathsInfo) {
+  return pathsInfo.validatedFeatureSlicedPartsOfTarget.hasNotSegment;
+}
+
+// src/rules/public-api/model/should-be-from-public-api.ts
+function shouldBeFromSlicePublicApi(pathsInfo) {
+  const isFromAnotherSlice = !pathsInfo.isSameSlice;
+  return isFromAnotherSlice && !isSlicePublicApi(pathsInfo);
+}
+function shouldBeFromSegmentsPublicApi(pathsInfo, validateOptions) {
+  const needValidateSegments = validateOptions.level === "segments" /* SEGMENTS */;
+  return needValidateSegments && !isSegmentsPublicApi(pathsInfo);
+}
+function shouldBeFromPublicApi(node, context, optionsWithDefault) {
+  const pathsInfo = extractPathsInfo(node, context);
+  const ruleOptions = extractRuleOptions(optionsWithDefault);
+  return shouldBeFromSlicePublicApi(pathsInfo) || shouldBeFromSegmentsPublicApi(pathsInfo, ruleOptions);
+}
+
+// src/rules/public-api/model/validate-and-report.ts
+function validateAndReport3(node, context, optionsWithDefault) {
+  if (!hasPath(node)) {
+    return;
+  }
+  if (isIgnoredCurrentFile(context, optionsWithDefault)) {
+    return;
+  }
+  if (shouldBeFromPublicApi(node, context, optionsWithDefault)) {
+    reportShouldBeFromPublicApi(node, context);
+  }
+}
+
+// src/rules/public-api/model/is-layer-public-api.ts
+var import_picomatch2 = __toESM(require("picomatch"), 1);
+function isLayerPublicApi(context) {
+  const normalizedCurrentFilePath = extractCurrentFilePath(context);
+  const cwd = extractCwd(context);
+  const layer = extractLayer(normalizedCurrentFilePath, cwd);
+  if (isNull(layer)) {
+    return false;
+  }
+  const matcher = (0, import_picomatch2.default)([
+    `**/${layer}/index.*`
+  ]);
+  return matcher(normalizedCurrentFilePath);
+}
+
+// src/rules/public-api/model/validate-and-report-program.ts
+function validateAndReportProgram(node, context, optionsWithDefault) {
+  if (isIgnoredCurrentFile(context, optionsWithDefault)) {
+    return;
+  }
+  if (isLayerPublicApi(context)) {
+    reportLayersPublicApiNotAllowed(node, context);
+  }
+}
+
+// src/rules/public-api/index.ts
+var public_api_default = createEslintRule({
+  name: "public-api",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Check for module imports from public api"
+    },
+    hasSuggestions: true,
+    messages: {
+      ["should-be-from-public-api" /* SHOULD_BE_FROM_PUBLIC_API */]: 'Absolute imports are only allowed from public api ("{{ fixedPath }}")',
+      ["remove-suggestion" /* REMOVE_SUGGESTION */]: 'Remove the "{{ valueToRemove }}"',
+      ["layers-public-api-not-allowed" /* LAYERS_PUBLIC_API_NOT_ALLOWED */]: "The layer public API is not allowed. It harms both architecturally and practically (code splitting)"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          level: {
+            type: "string",
+            enum: [
+              "segments" /* SEGMENTS */,
+              "slices" /* SLICES */
+            ]
+          },
+          ignoreInFilesPatterns: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        }
+      }
+    ]
+  },
+  defaultOptions: [
+    {
+      level: "slices" /* SLICES */,
+      ignoreInFilesPatterns: []
+    }
+  ],
+  create(context, optionsWithDefault) {
+    return {
+      ImportDeclaration(node) {
+        validateAndReport3(node, context, optionsWithDefault);
+      },
+      ImportExpression(node) {
+        validateAndReport3(node, context, optionsWithDefault);
+      },
+      ExportAllDeclaration(node) {
+        validateAndReport3(node, context, optionsWithDefault);
+      },
+      ExportNamedDeclaration(node) {
+        validateAndReport3(node, context, optionsWithDefault);
+      },
+      Program(node) {
+        validateAndReportProgram(node, context, optionsWithDefault);
+      }
+    };
+  }
+});
+
+// src/rules/index.ts
+var rules = {
+  "absolute-relative": absolute_relative_default,
+  "import-order": import_eslint_plugin_import_x.default.rules.order,
+  "layers-slices": layers_slices_default,
+  "public-api": public_api_default
+};
+var rules_default = rules;
+
+// src/plugin.ts
+var plugin = {
+  meta: {
+    name: PLUGIN_NAME,
+    version
+  },
+  rules: rules_default
+};
+
+// src/rules/import-order/configs.ts
+var LAYERS_REVERSED = [...layers].reverse();
+var baseConfig = {
+  alphabetize: {
+    order: "asc",
+    caseInsensitive: true
+  },
+  pathGroups: LAYERS_REVERSED.map((layer) => ({
+    pattern: `**/?(*)${layer}{,/**}`,
+    group: "internal",
+    position: "after"
+  })),
+  distinctGroup: false,
+  pathGroupsExcludedImportTypes: ["builtin"],
+  groups: ["builtin", "external", "internal", "parent", "sibling", "index"]
+};
+var importOrderRuleConfigs = {
+  "recommended": [
+    "error",
+    {
+      ...baseConfig,
+      "newlines-between": "never"
+    }
+  ],
+  "with-newlines": [
+    "error",
+    {
+      ...baseConfig,
+      "newlines-between": "always"
+    }
+  ],
+  "with-type-group": [
+    "error",
+    {
+      ...baseConfig,
+      "newlines-between": "never",
+      "pathGroupsExcludedImportTypes": ["builtin", "type"],
+      "groups": ["builtin", "external", "internal", "type", "parent", "sibling", "index"]
+    }
+  ],
+  "with-newlines-and-type-group": [
+    "error",
+    {
+      ...baseConfig,
+      "newlines-between": "always",
+      "pathGroupsExcludedImportTypes": ["builtin", "type"],
+      "groups": ["builtin", "external", "internal", "type", "parent", "sibling", "index"]
+    }
+  ]
+};
+
+// src/create-plugin.ts
+function createPlugin(options = {}) {
+  const {
+    sortImports = "recommended",
+    absoluteRelative,
+    layersSlices,
+    publicApi
+  } = options;
+  const rules2 = defineRules({ absoluteRelative, layersSlices, publicApi, sortImports });
+  return {
+    name: PLUGIN_NAME,
+    plugins: {
+      [PLUGIN_NAME]: plugin
+    },
+    rules: rules2
+  };
+}
+function defineRules(options) {
+  const {
+    absoluteRelative = {},
+    layersSlices = {},
+    publicApi = {},
+    sortImports = "recommended"
+  } = options;
+  const createRuleEntry = (ruleOptions) => ruleOptions ? ["error", ruleOptions] : ["off"];
+  const rules2 = {
+    [RULE_NAMES.LAYERS_SLICES]: createRuleEntry(layersSlices),
+    [RULE_NAMES.ABSOLUTE_RELATIVE]: createRuleEntry(absoluteRelative),
+    [RULE_NAMES.PUBLIC_API]: createRuleEntry(publicApi)
+  };
+  if (sortImports) {
+    rules2[RULE_NAMES.IMPORT_ORDER] = importOrderRuleConfigs[sortImports];
+  }
+  return rules2;
+}
+
+// src/index.ts
+var src_default = createPlugin;