eslint-plugin-fsd-paths-check 0.0.13 → 0.0.15

package/lib/constants/constants.js

@@ -0,0 +1,5 @@
+const allFsdLayers = ['shared', 'entities', 'features', 'widgets', 'pages', 'app'];
+
+module.exports = {
+    allFsdLayers
+}

package/lib/helpers/getNormalizedProjectPath.js

@@ -0,0 +1,12 @@
+const {toNamespacedPath} = require("path");
+
+function getNormalizedProjectPath(fullPath) {
+    const fromNamespaced = toNamespacedPath(fullPath);
+    const fromNormalized = fromNamespaced.split(`\\`).join(`/`);
+
+    return fromNormalized.split(`src/`)[1];
+}
+
+module.exports = {
+    getNormalizedProjectPath
+};

package/lib/helpers/isSameModuleImport.js

@@ -1,5 +1,6 @@
 const { isPathRelative } = require("./isPathRelative");
 const path = require("path");
+const { getNormalizedProjectPath } = require("./getNormalizedProjectPath");
 
 function isSameModuleImport(from, to, fsdLayers, noSlicesLayers) {
     if(isPathRelative(to)) {
@@ -15,8 +16,7 @@ function isSameModuleImport(from, to, fsdLayers, noSlicesLayers) {
         return false;
     }
 
-    const fromNormalized = path.toNamespacedPath(from);
-    const fromProject = fromNormalized.split(`src/`)[1];
+    const fromProject = getNormalizedProjectPath(from)
 
     if(!fromProject) {
         return false;

package/lib/helpers/pathContainsFsdLayer.js

@@ -0,0 +1,23 @@
+const { allFsdLayers } = require("../constants/constants");
+
+const getFsdLayerFromPath = (filePath) => {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const segments = normalizedPath.split('/');
+
+    for (const segment of segments) {
+        if (allFsdLayers.includes(segment)) {
+            return segment;
+        }
+    }
+
+    return null;
+};
+
+const hasFsdLayerInPath = (filePath) => {
+    return getFsdLayerFromPath(filePath) !== null;
+};
+
+module.exports = {
+    getFsdLayerFromPath,
+    hasFsdLayerInPath,
+};

package/lib/rules/enforce-public-api-imports.js

@@ -1,8 +1,9 @@
 "use strict";
 
-const { isPathRelative } = require("../helpers/isPathRelative");
-const path = require("path");
+const {isPathRelative} = require("../helpers/isPathRelative");
 const {isSameModuleImport} = require("../helpers/isSameModuleImport");
+const {getFsdLayerFromPath} = require("../helpers/pathContainsFsdLayer");
+const {allFsdLayers} = require("../constants/constants");
 
 const fsdLayers = {
   'entities': 'entities',
@@ -31,6 +32,7 @@ module.exports = {
     messages: {
       useOthersModulesPublicApi: `When importing from other modules, public api should be used`,
       doNotUseAbsolutePathInSameModuleImport: `When importing from the same module, absolute path should not be used`,
+      doNotUseRelativePathsBetweenLayers: `When importing from other modules, absolute path should be used`,
     },
   },
 
@@ -42,36 +44,62 @@ module.exports = {
         const pathTo = alias ? value.replace(`${alias}`, ``) : value;
         const currentFile = context.getFilename();
 
-        if(isPathRelative(pathTo)) {
+        const pathToLayer = getFsdLayerFromPath(pathTo)
+        const segments = pathTo.split("/");
+
+        console.warn(value)
+        console.warn(pathTo)
+        console.warn(segments)
+
+
+        if(isPathRelative(pathTo) && !pathToLayer) {
           return;
+        } else if(isPathRelative(pathTo)) {
+          context.report({
+            node,
+            messageId: `doNotUseRelativePathsBetweenLayers`,
+            fix(fixer) {
+              const layerIndex = segments.findIndex(segment => allFsdLayers.includes(segment));
+              if (layerIndex === -1) return undefined;
+
+              const absolutePath = `${alias}${segments.slice(layerIndex).join(`/`)}`;
+
+              return fixer.replaceText(node.source, `'${absolutePath}'`);
+            }
+          })
         }
 
-        const segments = pathTo.split("/");
         const layer = segments[0];
-
         if(!fsdLayers[layer]) {
           return;
         }
+        console.warn(layer)
 
         const isImportNotFromPublicApi = segments.length > 2;
         const isSameModule = isSameModuleImport(currentFile, pathTo, fsdLayers);
 
+        console.warn(isImportNotFromPublicApi);
+        console.warn(isSameModule);
+
         if (isImportNotFromPublicApi && !isSameModule) {
-          context.report({
+          return context.report({
             node,
             messageId: `useOthersModulesPublicApi`,
             fix(fixer) {
               const index = value.indexOf(segments[1]);
+              console.warn(index)
               if (index === -1) return undefined;
 
               const publicPathImport = value.substring(0, index + segments[1].length);
 
+              console.warn(publicPathImport)
+
               return fixer.replaceText(node.source, `'${publicPathImport}'`);
             }
           })
         }
         else if (isSameModule) {
-          context.report({
+          return context.report({
             node,
             messageId: `doNotUseAbsolutePathInSameModuleImport`
           })

package/lib/rules/enforce-relative-path-within-slice.js

@@ -2,6 +2,7 @@
 
 const path = require("path");
 const { isSameModuleImport } = require("../helpers/isSameModuleImport");
+const { getNormalizedProjectPath } = require("../helpers/getNormalizedProjectPath");
 
 const fsdLayers = {
   'shared': 'shared',
@@ -62,7 +63,7 @@ const importExportDeclaration = (context) => (node) => {
       node,
       messageId: `useRelativePathWithinSlice`,
       fix(fixer) {
-        const projectFromPath = getProjectPath(currentFile);
+        const projectFromPath = getNormalizedProjectPath(currentFile);
         const currentDir = path.dirname(projectFromPath);
         const relativePath = path.relative(currentDir, pathTo);
         const finalRelativePath = relativePath.startsWith(`.`) ? relativePath : `./${relativePath}`;
@@ -73,8 +74,4 @@ const importExportDeclaration = (context) => (node) => {
   }
 }
 
-function getProjectPath(fullPath) {
-  const fromNormalized = path.toNamespacedPath(fullPath);
 
-  return fromNormalized.split(`src/`)[1];
-}

package/lib/rules/forbid-imports-from-upper-slices.js

@@ -3,6 +3,7 @@
 const path = require("path");
 const {isPathRelative} = require("../helpers/isPathRelative");
 const micromatch = require("micromatch");
+const {getNormalizedProjectPath} = require("../helpers/getNormalizedProjectPath");
 
 const fsdLayers = {
   'shared': 'shared',
@@ -61,11 +62,10 @@ const importExportDeclaration = (context) => (node) => {
   const { alias = '', ignoreImportPatterns = [] } = context.options[0] ?? {};
 
   const getCurrentFileLayer = (currentFilePath) => {
-    const normalizedPath = path.toNamespacedPath(currentFilePath);
-    const projectPath = normalizedPath?.split('src')[1];
+    const projectPath = getNormalizedProjectPath(currentFilePath)
     const segments = projectPath?.split('/');
 
-    return segments?.[1];
+    return segments?.[0];
   }
 
   const getImportLayer = (value) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-fsd-paths-check",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Plugin to check feature sliced design paths correctness",
   "keywords": [
     "eslint",