eslint-plugin-big-react-app-plugin 0.2.4 → 0.2.6

package/lib/rules/path-checker.js

@@ -37,7 +37,17 @@ module.exports = {
         // example C:\Users\tim\Desktop\javascript\production_project\src\entities\Article
         const fromFilename = context.getFilename();
         if(shouldBeRelative(fromFilename, importTo)) {
-          context.report({node: node, message: 'В рамках одного слайса все пути должны быть относительными'});
+          context.report({node:
+             node, 
+             message: 'В рамках одного слайса все пути должны быть относительными'});
+             fix:(fixer)=>{
+              const normalizedPath = getNormalizedFilePath(fromFilename).split('/').slice(0, -1).join('/')//enteties/Article/Artcile.tsx файл в который делаем импорт  и также убираем концовку
+              let relativePath = path.relative(normalizedPath, `/${importTo}`).split('\\').join('/')
+              if(!relativePath.startsWith('.')){
+                relativePath = './' + relativePath
+              }
+              return fixer.replaceText(node.source, `'${relativePath}'`)
+             }
         }
       }
     };
@@ -51,7 +61,12 @@ const layers = {
   "shared":"shared",
   "widgets":"widgets",
 }
-const shouldBeRelative = (from, to)=>{
+function getNormalizedFilePath  (){
+    const normalizationPath = path.toNamespacedPath(from);
+    const projFrom = normalizationPath.split('src')[1]
+    return projFrom.split('\\').join('/')
+}
+function shouldBeRelative  (from, to){
   if(isPathRelative(to)){
     return false
   }
@@ -64,8 +79,7 @@ const shouldBeRelative = (from, to)=>{
     return false
   }
   //нормализуем путь 
-  const normalizationPath = path.toNamespacedPath(from);
-  const projFrom = normalizationPath.split('src')[1]
+  const projFrom = getNormalizedFilePath(from)
   const fromArray = projFrom.split('\\')
   
   const fromLayer = fromArray[1];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-big-react-app-plugin",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "plugin for prod proj",
   "keywords": [
     "eslint",

package/.history/lib/rules/layer-imports_20251101143845.js

@@ -1,44 +0,0 @@
-/**
- * @fileoverview The rule ensures that the layers above are not used in the layers below.
- * @author vasilii
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * @type {import('eslint').Rule.RuleModule}
- */
-module.exports = {
-  meta: {
-    type: null, // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: "The rule ensures that the layers above are not used in the layers below.",
-      category: "Fill me in",
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: [], // Add a schema if the rule has options
-  },
-
-  create(context) {
-    // variables should be defined here
-
-    //----------------------------------------------------------------------
-    // Helpers
-    //----------------------------------------------------------------------
-
-    // any helper functions should go here or else delete this section
-
-    //----------------------------------------------------------------------
-    // Public
-    //----------------------------------------------------------------------
-
-    return {
-      // visitor functions for different types of nodes
-    };
-  },
-};

package/.history/lib/rules/layer-imports_20251101144032.js

@@ -1,106 +0,0 @@
-/**
- * @fileoverview The rule ensures that the layers above are not used in the layers below.
- * @author vasilii
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * @type {import('eslint').Rule.RuleModule}
- */
-module.exports = {
-  meta: {
-    type: null, // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: "saf",
-      category: "Fill me in",
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          alias: {
-            type: 'string',
-          },
-          ignoreImportPatterns: {
-            type: 'array',
-          }
-        },
-      }
-    ],
-  },
-
-  create(context) {
-    const layers = {
-      'app': ['pages', 'widgets', 'features', 'shared', 'entities'],
-      'pages': ['widgets', 'features', 'shared', 'entities'],
-      'widgets': ['features', 'shared', 'entities'],
-      'features': ['shared', 'entities'],
-      'entities': ['shared', 'entities'],
-      'shared': ['shared'],
-    }
-
-    const availableLayers = {
-      'app': 'app',
-      'entities': 'entities',
-      'features': 'features',
-      'shared': 'shared',
-      'pages': 'pages',
-      'widgets': 'widgets',
-    }
-
-
-    const {alias = '', ignoreImportPatterns = []} = context.options[0] ?? {};
-
-    const getCurrentFileLayer = () => {
-      const currentFilePath = context.getFilename();
-
-      const normalizedPath = path.toNamespacedPath(currentFilePath);
-      const projectPath = normalizedPath?.split('src')[1];
-      const segments = projectPath?.split('\\')
-
-      return segments?.[1];
-    }
-
-    const getImportLayer = (value) => {
-      const importPath = alias ? value.replace(`${alias}/`, '') : value;
-      const segments = importPath?.split('/')
-
-      return segments?.[0]
-    }
-
-    return {
-      ImportDeclaration(node) {
-        const importPath = node.source.value
-        const currentFileLayer = getCurrentFileLayer()
-        const importLayer = getImportLayer(importPath)
-
-        if(isPathRelative(importPath)) {
-          return;
-        }
-
-        if(!availableLayers[importLayer] || !availableLayers[currentFileLayer]) {
-          return;
-        }
-
-        const isIgnored = ignoreImportPatterns.some(pattern => {
-          return micromatch.isMatch(importPath, pattern)
-        });
-
-        if(isIgnored) {
-          return;
-        }
-
-        if(!layers[currentFileLayer]?.includes(importLayer)) {
-          context.report(node, 'Слой может импортировать в себя только нижележащие слои (shared, entities, features, widgets, pages, app)');
-        }
-      }
-    };
-  },
-};

package/.history/lib/rules/layer-imports_20251101144044.js

@@ -1,106 +0,0 @@
-/**
- * @fileoverview The rule ensures that the layers above are not used in the layers below.
- * @author vasilii
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * @type {import('eslint').Rule.RuleModule}
- */
-module.exports = {
-  meta: {
-    type: null, // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: "saf",
-      category: "Fill me in",
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          alias: {
-            type: 'string',
-          },
-          ignoreImportPatterns: {
-            type: 'array',
-          }
-        },
-      }
-    ],
-  },
-
-  create(context) {
-    const layers = {
-      'app': ['pages', 'widgets', 'features', 'shared', 'entities'],
-      'pages': ['widgets', 'features', 'shared', 'entities'],
-      'widgets': ['features', 'shared', 'entities'],
-      'features': ['shared', 'entities'],
-      'entities': ['shared', 'entities'],
-      'shared': ['shared'],
-    }
-
-    const availableLayers = {
-      'app': 'app',
-      'entities': 'entities',
-      'features': 'features',
-      'shared': 'shared',
-      'pages': 'pages',
-      'widgets': 'widgets',
-    }
-
-
-    const {alias = '', ignoreImportPatterns = []} = context.options[0] ?? {};
-
-    const getCurrentFileLayer = () => {
-      const currentFilePath = context.getFilename();
-
-      const normalizedPath = path.toNamespacedPath(currentFilePath);
-      const projectPath = normalizedPath?.split('src')[1];
-      const segments = projectPath?.split('\\')
-
-      return segments?.[1];
-    }
-
-    const getImportLayer = (value) => {
-      const importPath = alias ? value.replace(`${alias}/`, '') : value;
-      const segments = importPath?.split('/')
-
-      return segments?.[0]
-    }
-
-    return {
-      ImportDeclaration(node) {
-        const importPath = node.source.value
-        const currentFileLayer = getCurrentFileLayer()
-        const importLayer = getImportLayer(importPath)
-
-        if(isPathRelative(importPath)) {
-          return;
-        }
-
-        if(!availableLayers[importLayer] || !availableLayers[currentFileLayer]) {
-          return;
-        }
-
-        const isIgnored = ignoreImportPatterns.some(pattern => {
-          return micromatch.isMatch(importPath, pattern)
-        });
-
-        if(isIgnored) {
-          return;
-        }
-
-        if(!layers[currentFileLayer]?.includes(importLayer)) {
-          context.report(node, 'Слой может импортировать в себя только нижележащие слои (shared, entities, features, widgets, pages, app)');
-        }
-      }
-    };
-  },
-};

package/.history/lib/rules/layer-imports_20251101144137.js

@@ -1,106 +0,0 @@
-/**
- * @fileoverview The rule ensures that the layers above are not used in the layers below.
- * @author vasilii
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * @type {import('eslint').Rule.RuleModule}
- */
-module.exports = {
-  meta: {
-    type: null, // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: "saf",
-      category: "Fill me in",
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          alias: {
-            type: 'string',
-          },
-          ignoreImportPatterns: {
-            type: 'array',
-          }
-        },
-      }
-    ],
-  },
-
-  create(context) {
-    const layers = {
-      'app': ['pages', 'widgets', 'features', 'shared', 'entities'],
-      'pages': ['widgets', 'features', 'shared', 'entities'],
-      'widgets': ['features', 'shared', 'entities'],
-      'features': ['shared', 'entities'],
-      'entities': ['shared', 'entities'],
-      'shared': ['shared'],
-    }
-
-    const availableLayers = {
-      'app': 'app',
-      'entities': 'entities',
-      'features': 'features',
-      'shared': 'shared',
-      'pages': 'pages',
-      'widgets': 'widgets',
-    }
-
-
-    const {alias = '', ignoreImportPatterns = []} = context.options[0] ?? {};
-
-    const getCurrentFileLayer = () => {
-      const currentFilePath = context.getFilename();
-
-      const normalizedPath = path.toNamespacedPath(currentFilePath);
-      const projectPath = normalizedPath?.split('src')[1];
-      const segments = projectPath?.split('\\')
-
-      return segments?.[1];
-    }
-
-    const getImportLayer = (value) => {
-      const importPath = alias ? value.replace(`${alias}/`, '') : value;
-      const segments = importPath?.split('/')
-
-      return segments?.[0]
-    }
-
-    return {
-      ImportDeclaration(node) {
-        const importPath = node.source.value
-        const currentFileLayer = getCurrentFileLayer()
-        const importLayer = getImportLayer(importPath)
-
-        if(isPathRelative(importPath)) {
-          return;
-        }
-
-        if(!availableLayers[importLayer] || !availableLayers[currentFileLayer]) {
-          return;
-        }
-
-        const isIgnored = ignoreImportPatterns.some(pattern => {
-          return micromatch.isMatch(importPath, pattern)
-        });
-
-        if(isIgnored) {
-          return;
-        }
-
-        if(!layers[currentFileLayer]?.includes(importLayer)) {
-          context.report(node, 'Слой может импортировать в себя только нижележащие слои (shared, entities, features, widgets, pages, app)');
-        }
-      }
-    };
-  },
-};

package/.history/lib/rules/layer-imports_20251101144214.js

@@ -1,110 +0,0 @@
-/**
- * @fileoverview The rule ensures that the layers above are not used in the layers below.
- * @author vasilii
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * @type {import('eslint').Rule.RuleModule}
- */
-
-const path = require('path');
-const {isPathRelative} = require('../helpers');
-const micromatch = require('micromatch');
-module.exports = {
-  meta: {
-    type: null, // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: "saf",
-      category: "Fill me in",
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          alias: {
-            type: 'string',
-          },
-          ignoreImportPatterns: {
-            type: 'array',
-          }
-        },
-      }
-    ],
-  },
-
-  create(context) {
-    const layers = {
-      'app': ['pages', 'widgets', 'features', 'shared', 'entities'],
-      'pages': ['widgets', 'features', 'shared', 'entities'],
-      'widgets': ['features', 'shared', 'entities'],
-      'features': ['shared', 'entities'],
-      'entities': ['shared', 'entities'],
-      'shared': ['shared'],
-    }
-
-    const availableLayers = {
-      'app': 'app',
-      'entities': 'entities',
-      'features': 'features',
-      'shared': 'shared',
-      'pages': 'pages',
-      'widgets': 'widgets',
-    }
-
-
-    const {alias = '', ignoreImportPatterns = []} = context.options[0] ?? {};
-
-    const getCurrentFileLayer = () => {
-      const currentFilePath = context.getFilename();
-
-      const normalizedPath = path.toNamespacedPath(currentFilePath);
-      const projectPath = normalizedPath?.split('src')[1];
-      const segments = projectPath?.split('\\')
-
-      return segments?.[1];
-    }
-
-    const getImportLayer = (value) => {
-      const importPath = alias ? value.replace(`${alias}/`, '') : value;
-      const segments = importPath?.split('/')
-
-      return segments?.[0]
-    }
-
-    return {
-      ImportDeclaration(node) {
-        const importPath = node.source.value
-        const currentFileLayer = getCurrentFileLayer()
-        const importLayer = getImportLayer(importPath)
-
-        if(isPathRelative(importPath)) {
-          return;
-        }
-
-        if(!availableLayers[importLayer] || !availableLayers[currentFileLayer]) {
-          return;
-        }
-
-        const isIgnored = ignoreImportPatterns.some(pattern => {
-          return micromatch.isMatch(importPath, pattern)
-        });
-
-        if(isIgnored) {
-          return;
-        }
-
-        if(!layers[currentFileLayer]?.includes(importLayer)) {
-          context.report(node, 'Слой может импортировать в себя только нижележащие слои (shared, entities, features, widgets, pages, app)');
-        }
-      }
-    };
-  },
-};

package/.history/lib/rules/public-api-imports_20251028164625.js

@@ -1,76 +0,0 @@
-"use strict";
-const micromatch = require("micromatch");
-const {isPathRelative} = require("../helpers")
-const path = require("path");
-module.exports = {
-  meta: {
-    type: null, 
-    docs: {
-      description: "description",
-      category: "Fill me in",
-      recommended: false,
-      url: null, 
-    },
-    fixable: null, 
-    schema: [
-         {
-        type: 'object',
-        properties: {
-          alias: {
-            type: 'string'
-          },
-          testFilesPatterns: {
-            type: 'array'
-          }
-        }
-      }
-    ], 
-  },
-
-  
-  create(context) {
-    const checkingLayers = {
-      "entities":"entities",
-      "features":"features",
-      "pages":"pages",
-      "widgets":"widgets",
-    }
-    const {alias='', testFilesPatterns=[]} = context.options[0] ?? {};
-    return {
-      ImportDeclaration(node) {
-        // example app/entities/Article
-        const value = node.source.value;
-        const importTo = alias ? value.replace(`${alias}/`, "")  : value;
-        //если путь относительный то выходим
-        if(isPathRelative(importTo)){
-          return; 
-        }
-        //[enteties, article, ... далее еще что-то может быть]
-        const segments = importTo.split('/')
-        const layer = segments[0]//получаем слой
-        // проверяем что есть слой из массива
-
-        //[enteties, article, testing]
-        const isTestingPublicApi = segments[2] === 'testing' && segments.length < 4;
-
-        if(!checkingLayers[layer]){
-          return;
-        }
-        const isImportNotFromPublicApi = segments.length > 2;
-
-        if(isImportNotFromPublicApi && !isTestingPublicApi ) {
-          context.report({node: node, message: 'Абсолютный импорт разрешен только из Public API (index.ts)'});
-        }
-
-        if(isTestingPublicApi){
-          const currentFilePath = context.getFilename();
-          const normalizedPath = path.toNamespacedPath(currentFilePath);
-          const isCurrentFileTesting = testFilesPatterns.some(pattern=>micromatch.isMatch(normalizedPath, pattern))
-          if(!isCurrentFileTesting){
-              context.report({node: node, message: 'Тестовые данные необходимо импортировать из publicApi/testing.ts'});
-          }
-        }
-      }
-    };
-  },
-};

package/.history/lib/rules/public-api-imports_20251028165757.js

@@ -1,75 +0,0 @@
-"use strict";
-const micromatch = require("micromatch");
-const {isPathRelative} = require("../helpers")
-const path = require("path");
-module.exports = {
-  meta: {
-    type: null, 
-    docs: {
-      description: "description",
-      category: "Fill me in",
-      recommended: false,
-      url: null, 
-    },
-    fixable: null, 
-    schema: [
-         {
-        type: 'object',
-        properties: {
-          alias: {
-            type: 'string'
-          },
-          testFilesPatterns: {
-            type: 'array'
-          }
-        }
-      }
-    ], 
-  },
-
-  
-  create(context) {
-    const checkingLayers = {
-      "entities":"entities",
-      "features":"features",
-      "pages":"pages",
-      "widgets":"widgets",
-    }
-    const {alias='', testFilesPatterns=[]} = context.options[0] ?? {};
-    return {
-      ImportDeclaration(node) {
-        // example app/entities/Article
-        const value = node.source.value;
-        const importTo = alias ? value.replace(`${alias}/`, "")  : value;
-        //если путь относительный то выходим
-        if(isPathRelative(importTo)){
-          return; 
-        }
-        //[enteties, article, ... далее еще что-то может быть]
-        const segments = importTo.split('/')
-        const layer = segments[0]//получаем слой
-        // проверяем что есть слой из массива
-
-        //[enteties, article, testing]
-        const isTestingPublicApi = segments[2] === 'testing' && segments.length < 4;
-
-        if(!checkingLayers[layer]){
-          return;
-        }
-        const isImportNotFromPublicApi = segments.length > 2;
-
-        if(isImportNotFromPublicApi && !isTestingPublicApi ) {
-          context.report({node: node, message: 'Абсолютный импорт разрешен только из Public API (index.ts)'});
-        }
-
-        if(isTestingPublicApi){
-          const currentFilePath = context.getFilename();
-          const isCurrentFileTesting = testFilesPatterns.some(pattern=>micromatch.isMatch(normalizedPath, pattern))
-          if(!isCurrentFileTesting){
-              context.report({node: node, message: 'Тестовые данные необходимо импортировать из publicApi/testing.ts'});
-          }
-        }
-      }
-    };
-  },
-};