eslint-plugin-stratified-design 0.9.2 → 0.11.0

package/.github/workflows/release.yml

@@ -9,12 +9,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Set up Node.js
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
-          node-version: 16
+          node-version: 20
           registry-url: https://registry.npmjs.org/
 
       - name: Update package version

package/docs/rules/lower-level-imports.md

@@ -40,6 +40,23 @@ To designate a layer as an abstract barrier, set `barrier` to `true`:
 }
 ```
 
+A language layer can 'pass' any abstract barrier:
+
+```json
+{
+  "stratified-design/lower-level-imports": [
+    "error",
+    {
+      "structure": [
+        "layer1",
+        { "name": "layer2", "barrier": true },
+        { "name": "layer3", "language": true }
+      ]
+    }
+  ]
+}
+```
+
 For the 'abstract barrier,' refer to "[Grokking Simplicity](https://grokkingsimplicity.com)."
 
 To locate a node module in the structure, set `nodeModule` to `true`:
@@ -148,10 +165,11 @@ src/
  ┃ ┣ file.js
  ┃ ┣ otherFile.js
  ┃ ┗ subFolder/
- ┗ layer3/
-   ┣ entry.js
-   ┣ 1 layer.js
-   ┗ 2 layer.js
+ ┃ layer3/
+ ┃ ┣ entry.js
+ ┃ ┣ 1 layer.js
+ ┃ ┗ 2 layer.js
+ ┗ layer4.js
 ```
 
 Examples of **incorrect** code for this rule:
@@ -242,3 +260,11 @@ import { func } from "../layer3/entry";
 // ./src/layer2/index.js
 import { func } from "./file";
 ```
+
+```js
+/* "lower-level-imports": ["error", {
+  "structure": ["layer1", { name: "layer2", barrier: true }, "layer3", { name: "layer4", language: true }]
+}] */
+// ./src/layer1.js
+import { func } from "./layer4";
+```

package/docs/rules/no-disallowed-imports.md

@@ -57,7 +57,7 @@ Examples of **incorrect** code for this rule:
 //   {
 //     "imports": [
 //       {
-//         "import": { "member": ["foo"], "from": "src/fileA" },
+//         "import": { "member": ["foo", "default", "*"], "from": "src/fileA" },
 //         "allow": ["src/**/fileB.js"],
 //         "disallow": ["src/**/fileC.*"]
 //       }
@@ -69,6 +69,42 @@ Examples of **incorrect** code for this rule:
 import { foo } from "./fileA";
 ```
 
+```js
+// "stratified-design/no-disallowed-imports": [
+//   "error",
+//   {
+//     "imports": [
+//       {
+//         "import": { "member": ["foo", "default", "*"], "from": "src/fileA" },
+//         "allow": ["src/**/fileB.js"],
+//         "disallow": ["src/**/fileC.*"]
+//       }
+//     ]
+//   }
+// ]
+
+// ./src/fileC.js
+import foo from "./fileA";
+```
+
+```js
+// "stratified-design/no-disallowed-imports": [
+//   "error",
+//   {
+//     "imports": [
+//       {
+//         "import": { "member": ["foo", "default", "*"], "from": "src/fileA" },
+//         "allow": ["src/**/fileB.js"],
+//         "disallow": ["src/**/fileC.*"]
+//       }
+//     ]
+//   }
+// ]
+
+// ./src/fileC.js
+import * as foo from "./fileA";
+```
+
 Examples of **correct** code for this rule:
 
 ```js
@@ -77,7 +113,7 @@ Examples of **correct** code for this rule:
 //   {
 //     "imports": [
 //       {
-//         "import": { "member": ["foo"], "from": "src/fileA" },
+//         "import": { "member": ["foo", "default", "*"], "from": "src/fileA" },
 //         "allow": ["src/**/fileB.js"],
 //         "disallow": ["src/**/fileC.*"]
 //       }

package/docs/rules/stratified-imports.md

@@ -10,6 +10,7 @@ This rule enforces the requirement for importing lower-level modules. The hierar
   [{ "name": "layerB", "barrier": true }],
   [{ "name": "nodeModuleC", "nodeModule": true }],
   ["layerD", "layerE"]
+  [{ "name": "layerF", "language": true }]
 ]
 ```
 
@@ -24,6 +25,7 @@ And consider that the folder structure is as follows:
  ┃ ┣ entry
  ┃ ┣ layerEA
  ┃ ┗ .stratified.json
+ ┣ layerF
  ┗ .stratified.json
 ```
 
@@ -33,6 +35,7 @@ The above JSON file indicates the following:
 - The `layerB` file/folder is a lower-level layer than `layerA` and serves as an abstract barrier. (For the concept of 'abstract barrier,' refer to '[Grokking Simplicity](https://grokkingsimplicity.com).')
 - `nodeModuleC` is an **installed module** (node module) and is at a lower level than `layerB`. (Unregistered node modules are considered to be the lowest layers.)
 - The `layerD` file/folder and the `layerE` file/folder are at the same level and represent the lowest level layers.
+- The `layerF` file/folder is a language layer and 'pass' any abstract barrier.
 
 Consider that the `.stratified.json` in the `layerE` folder is as follows:
 
@@ -109,6 +112,7 @@ src/
  ┃ ┣ entry
  ┃ ┣ layerEA.js
  ┃ ┗ .stratified.json
+ ┣ layerF
  ┗ .stratified.json
 ```
 
@@ -119,7 +123,8 @@ and the `.stratified.json` in `src/` is as follows:
   ["layerA"],
   [{ "name": "layerB", "barrier": true }],
   [{ "name": "nodeModuleC", "nodeModule": true }],
-  ["layerD", "layerE"]
+  ["layerD", "layerE"],
+  [{ "name": "layerF", "language": true }]
 ]
 ```
 
@@ -187,3 +192,8 @@ import { func } from "./layerE";
 // ./layerB.js
 import { func } from "./layerE/entry";
 ```
+
+```js
+// ./layerA.js
+import { func } from "./layerF";
+```

package/lib/helpers/lowerLevelImports/1 layer.js

@@ -236,7 +236,7 @@ const reportHasProperLevel = (
       return FINISHED;
     }
 
-    if (hasBarrier(moduleLevel)) {
+    if (hasBarrier(modulePath, moduleLevel)) {
       report("barrier");
       return FINISHED;
     }

package/lib/helpers/lowerLevelImports/3 layer.js

@@ -24,6 +24,7 @@ const {
  * @typedef {{
  *  name: string;
  *  barrier?: boolean | undefined;
+ *  language?: boolean | undefined;
  *  interface?: boolean | undefined;
  *  nodeModule?: boolean | undefined;
  *  isNodeModule?: boolean | undefined;
@@ -107,7 +108,22 @@ const findLevel = (structure) => {
 };
 
 /**
- * Check if there is an interface between file layer and module layer
+ * Check if a layer is language layer
+ * @param {Structure} structure
+ */
+const isLanguage = (structure) => {
+  /**
+   * @param {string} path
+   */
+  return (path) => {
+    return Boolean(
+      structure.find((layer) => layer.name === path && layer.language === true)
+    );
+  };
+};
+
+/**
+ * Check if there is an barrier between file layer and module layer
  * @param {Structure} structure
  * @param {number} fileLevel
  */
@@ -115,7 +131,8 @@ const hasBarrier = (structure, fileLevel) => {
   /**
    * @param {number} moduleLevel
    */
-  return (moduleLevel) => {
+  return (modulePath, moduleLevel) => {
+    if (isLanguage(structure)(modulePath)) return false;
     const layerBarrier = structure
       .slice(fileLevel + 1, moduleLevel)
       .find((layer) => layer.barrier || layer.interface);

package/lib/helpers/stratifiedImports/1 layer.js

@@ -106,7 +106,9 @@ const findLevelInCurrent = (structure, fileLevel) => {
   return (modulePath) => {
     const level = findLevel(structure)(modulePath);
     if (level === null) return null;
-    return hasBarrier(structure, fileLevel)(level) ? BARRIER : level;
+    return hasBarrier(structure, fileLevel)(modulePath, level)
+      ? BARRIER
+      : level;
   };
 };
 
@@ -173,7 +175,7 @@ const findLevelInParent = (cwd, fileDir, fileLevel) => {
 
       if (moduleLevel === null) {
         return result(null);
-      } else if (hasBarrier(structure, fileLevel)(moduleLevel)) {
+      } else if (hasBarrier(structure, fileLevel)(modulePath, moduleLevel)) {
         return result(BARRIER);
       } else {
         return result(originalFileLevel + moduleLevel - fileLevel);

package/lib/helpers/stratifiedImports/2 layer.js

@@ -14,6 +14,7 @@ const {
  *  name: string;
  *  barrier?: boolean;
  *  nodeModule?: boolean;
+ *  language?: boolean;
  * }} Layer
  */
 
@@ -29,6 +30,24 @@ const {
  * @typedef {RawLayer[][]} RawStructure
  */
 
+// @level 3
+/**
+ * @param {Structure} structure
+ * @returns
+ */
+const isLanguage = (structure) => {
+  /**
+   * @param {string} path
+   */
+  return (path) => {
+    return Boolean(
+      structure.find((layers) =>
+        layers.find((layer) => layer.name === path && layer.language === true)
+      )
+    );
+  };
+};
+
 // @level 2
 /**
  * @param {string} fileDir
@@ -64,6 +83,8 @@ const validateRawStructure = (rawStructure) => {
         if (typeof value !== "boolean") return false;
       } else if (key === "barrier") {
         if (typeof value !== "boolean") return false;
+      } else if (key === "language") {
+        if (typeof value !== "boolean") return false;
       } else {
         return false;
       }
@@ -148,9 +169,11 @@ const findLayerWithReducedPath = (structure) => {
  */
 const hasBarrier = (structure, fileLevel) => {
   /**
+   * @param {string} modulePath
    * @param {number} moduleLevel
    */
-  return (moduleLevel) => {
+  return (modulePath, moduleLevel) => {
+    if (isLanguage(structure)(modulePath)) return false;
     const layerBarrier = structure
       .slice(fileLevel + 1, moduleLevel)
       .find((layers) => layers.find((layer) => layer.barrier));

package/lib/rules/lower-level-imports.js

@@ -40,9 +40,10 @@ const layerSchema = {
           pattern: layerNamePattern,
         },
         barrier: { type: "boolean" },
-        interface: { type: "boolean" },
+        language: { type: "boolean" },
+        interface: { type: "boolean" }, // deprecated
         nodeModule: { type: "boolean" },
-        isNodeModule: { type: "boolean" },
+        isNodeModule: { type: "boolean" }, // deprecated
       },
       required: ["name"],
       additionalProperties: false,
@@ -166,6 +167,8 @@ module.exports = {
     const isFileIndex = isFileIndexOfModule(options, fileDir, filePath);
 
     const report = (node) => {
+      if (node.importKind === "type") return;
+
       if (isExcludedFile) return;
 
       const { modulePath, isModuleExcluded } = createModulePath(

package/lib/rules/stratified-imports.js

@@ -124,6 +124,8 @@ module.exports = {
      * @returns
      */
     const report = (node) => {
+      if (node.importKind === "type") return;
+
       if (!isStructureValid) {
         reportError(node, "invalid-json");
         return;

package/mocked/stratified-imports/.stratified.json

@@ -8,5 +8,6 @@
   ["layerG", "layerH"],
   ["layerI"],
   ["layerJ"],
-  ["layerK"]
+  ["layerK"],
+  [{ "name": "layerL", "language": true }]
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-stratified-design",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "description": "ESlint rules for stratified design",
   "keywords": [
     "eslint",
@@ -12,7 +12,7 @@
   "author": "Hodoug Joung",
   "repository": {
     "type": "git",
-    "url": "https://github.com/anisotropy/eslint-plugin-stratified-design"
+    "url": "git+https://github.com/anisotropy/eslint-plugin-stratified-design.git"
   },
   "homepage": "https://github.com/anisotropy/eslint-plugin-stratified-design",
   "main": "./lib/index.js",
@@ -27,6 +27,7 @@
     "requireindex": "^1.2.0"
   },
   "devDependencies": {
+    "@typescript-eslint/parser": "^7.1.0",
     "eslint": "^8.19.0",
     "eslint-plugin-eslint-plugin": "^5.0.0",
     "eslint-plugin-node": "^11.1.0",

package/tests/lib/rules/lower-level-imports.js

@@ -9,7 +9,8 @@
 //------------------------------------------------------------------------------
 
 const rule = require("../../../lib/rules/lower-level-imports"),
-  RuleTester = require("eslint").RuleTester;
+  RuleTester = require("eslint").RuleTester,
+  path = require("path");
 
 //------------------------------------------------------------------------------
 // Tests
@@ -24,10 +25,14 @@ const structure = [
   "layer3/subLayer1",
   "layer3/subLayer2",
   "layer3/subLayer3",
+  { name: "layer4", language: true },
 ];
 
 const ruleTester = new RuleTester({
-  parserOptions: { ecmaVersion: 2022, sourceType: "module" },
+  parser: path.resolve(
+    "./node_modules/@typescript-eslint/parser/dist/parser.js"
+  ),
+  parserOptions: { ecmaVersion: "latest", sourceType: "module" },
 });
 
 ruleTester.run("lower-level-imports", rule, {
@@ -226,6 +231,16 @@ ruleTester.run("lower-level-imports", rule, {
         },
       ],
     },
+    {
+      code: "import { func } from '@/layer4'",
+      filename: "./src/layer1/subLayer2.js",
+      options: [{ structure, root: "./src", aliases: { "@/": "./src/" } }],
+    },
+    {
+      code: "import type { SomeType } from '@/layer2/subLayer2'",
+      filename: "./src/layer1/subLayer2.js",
+      options: [{ structure, root: "./src", aliases: { "@/": "./src/" } }],
+    },
   ],
   invalid: [
     {

package/tests/lib/rules/stratified-imports.js

@@ -10,6 +10,7 @@
 
 const rule = require("../../../lib/rules/stratified-imports");
 const RuleTester = require("eslint").RuleTester;
+const path = require("path");
 
 //------------------------------------------------------------------------------
 // Tests
@@ -27,7 +28,8 @@ const RuleTester = require("eslint").RuleTester;
   ["layerG", "layerH"],
   ["layerI"],
   ["layerJ"],
-  ["layerK"]
+  ["layerK"],
+  [{ "name": "layerL", "language": true }]
 ]
 
 // layerB/.stratified.json
@@ -56,7 +58,10 @@ const RuleTester = require("eslint").RuleTester;
 */
 
 const ruleTester = new RuleTester({
-  parserOptions: { ecmaVersion: 2022, sourceType: "module" },
+  parser: path.resolve(
+    "./node_modules/@typescript-eslint/parser/dist/parser.js"
+  ),
+  parserOptions: { ecmaVersion: "latest", sourceType: "module" },
 });
 
 ruleTester.run("stratified-imports", rule, {
@@ -156,6 +161,16 @@ ruleTester.run("stratified-imports", rule, {
       filename: "./mocked/stratified-imports/layerD/layerDB/layerDBA.js",
       options: [{ aliases: { "@/": "./mocked/stratified-imports/" } }],
     },
+    {
+      code: "import { func } from '@/layerL'",
+      filename: "./mocked/stratified-imports/layerA.js",
+      options: [{ aliases: { "@/": "./mocked/stratified-imports/" } }],
+    },
+    {
+      code: "import type { SomeType } from './layerA'",
+      filename: "./mocked/stratified-imports/layerB.js",
+      options: [],
+    },
   ],
   invalid: [
     {