eslint-plugin-gapone-plugin 0.0.14 → 0.3.14

package/lib/rules/layer-imports.js

@@ -0,0 +1,104 @@
+const path = require('path');
+const { isPathRelative } = require('../helpers');
+const micromatch = require('micromatch');
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+    meta: {
+        type: 'problem', // `problem`, `suggestion`, or `layout`
+        docs: {
+            description: 'desc',
+            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',
+                    },
+                },
+            },
+        ], // Add a schema if the rule has options
+        messages: {
+            invalidLayerImport:
+                'Слой может импортировать в себя только нижележащие слои(pages, widgets, features, shared, entities)',
+        }, // Add messageId and message
+    },
+
+    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 avalibaleLayers = {
+            app: 'app',
+            pages: 'pages',
+            widgets: 'widgets',
+            features: 'features',
+            entities: 'entities',
+            shared: 'shared',
+        };
+
+        const { alias = '', ignoreImportPatterns = [] } =
+            context.options[0] ?? {};
+
+        const getCurrentFileLayer = () => {
+            const currentFilePath = context.filename;
+
+            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 (
+                    !avalibaleLayers[importLayer] ||
+                    !avalibaleLayers[currentFileLayer]
+                ) {
+                    return;
+                }
+
+                const isIgnored = ignoreImportPatterns.some((pattern) => {
+                    return micromatch.isMatch(importPath, pattern);
+                });
+
+                if (isIgnored) {
+                    return;
+                }
+
+                if (!layers[currentFileLayer]?.includes(importLayer)) {
+                    context.report({ node, messageId: 'invalidLayerImport' });
+                }
+            },
+        };
+    },
+};

package/lib/rules/path-cheker.js

@@ -75,7 +75,6 @@ function shouldBeRelation(from, to) {
     const normalizedPath = path.toNamespacedPath(from);
     const projectFrom = normalizedPath.split('src')[1];
     const fromArray = projectFrom.split('\\');
-    console.log(fromArray);
 
     const fromLayer = fromArray[1];
     const fromSlice = fromArray[2];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-gapone-plugin",
-    "version": "0.0.14",
+    "version": "0.3.14",
     "description": "plugin for production project",
     "keywords": [
         "eslint",