eslint-plugin-traceability 1.1.9 → 1.1.10

package/lib/src/rules/require-story-annotation.d.ts

@@ -5,6 +5,8 @@
  * @req REQ-OPTIONS-SCOPE - Support configuring which function types to enforce via options
  * @req REQ-EXPORT-PRIORITY - Add exportPriority option to target exported or non-exported
  * @req REQ-UNIFIED-CHECK - Implement unified checkNode for all supported node types
+ * @req REQ-FUNCTION-DETECTION - Detect function declarations, expressions, arrow functions, and methods
+ * @req REQ-TYPESCRIPT-SUPPORT - Support TypeScript-specific function syntax
  */
 declare const _default: any;
 export default _default;

package/lib/src/rules/require-story-annotation.js

@@ -6,6 +6,8 @@
  * @req REQ-OPTIONS-SCOPE - Support configuring which function types to enforce via options
  * @req REQ-EXPORT-PRIORITY - Add exportPriority option to target exported or non-exported
  * @req REQ-UNIFIED-CHECK - Implement unified checkNode for all supported node types
+ * @req REQ-FUNCTION-DETECTION - Detect function declarations, expressions, arrow functions, and methods
+ * @req REQ-TYPESCRIPT-SUPPORT - Support TypeScript-specific function syntax
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
@@ -96,6 +98,12 @@ function resolveTargetNode(sourceCode, node) {
             }
         }
     }
+    else if (node.type === "TSMethodSignature") {
+        const exp = findAncestorNode(node, ["TSInterfaceDeclaration"]);
+        if (exp) {
+            target = exp;
+        }
+    }
     else if (node.type === "MethodDefinition") {
         target = node;
     }
@@ -124,6 +132,30 @@ function checkStoryAnnotation(sourceCode, context, node, scope, exportPriority)
     if (!shouldCheckNode(node, scope, exportPriority)) {
         return;
     }
+    // Special handling for TSMethodSignature: allow annotation on the method itself
+    if (node.type === "TSMethodSignature") {
+        // If annotated on the method signature, skip
+        if (hasStoryAnnotation(sourceCode, node)) {
+            return;
+        }
+        // Otherwise, check on interface declaration
+        const intf = resolveTargetNode(sourceCode, node);
+        if (hasStoryAnnotation(sourceCode, intf)) {
+            return;
+        }
+        // Missing annotation: report on the interface declaration
+        context.report({
+            node: intf,
+            messageId: "missingStory",
+            fix(fixer) {
+                const indentLevel = intf.loc.start.column;
+                const indent = " ".repeat(indentLevel);
+                const insertPos = intf.range[0] - indentLevel;
+                return fixer.insertTextBeforeRange([insertPos, insertPos], `${indent}/** @story <story-file>.story.md */\n`);
+            },
+        });
+        return;
+    }
     const target = resolveTargetNode(sourceCode, node);
     if (hasStoryAnnotation(sourceCode, target)) {
         return;
@@ -162,6 +194,8 @@ exports.default = {
                                 "FunctionExpression",
                                 "ArrowFunctionExpression",
                                 "MethodDefinition",
+                                "TSDeclareFunction",
+                                "TSMethodSignature",
                             ],
                         },
                         uniqueItems: true,
@@ -182,6 +216,8 @@ exports.default = {
             "FunctionExpression",
             "ArrowFunctionExpression",
             "MethodDefinition",
+            "TSDeclareFunction",
+            "TSMethodSignature",
         ];
         const exportPriority = options.exportPriority || "all";
         return {
@@ -197,6 +233,16 @@ exports.default = {
             MethodDefinition(node) {
                 checkStoryAnnotation(sourceCode, context, node, scope, exportPriority);
             },
+            // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+            // @req REQ-FUNCTION-DETECTION - Detect TS-specific function syntax
+            TSDeclareFunction(node) {
+                checkStoryAnnotation(sourceCode, context, node, scope, exportPriority);
+            },
+            // @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md
+            // @req REQ-FUNCTION-DETECTION - Detect TS-specific function syntax
+            TSMethodSignature(node) {
+                checkStoryAnnotation(sourceCode, context, node, scope, exportPriority);
+            },
         };
     },
 };

package/lib/tests/rules/require-story-annotation.test.js

@@ -40,6 +40,26 @@ const arrowFn = () => {};`,
                 name: "[REQ-ANNOTATION-REQUIRED] valid on class method with annotation",
                 code: `class A {\n  /** @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md */\n  method() {}\n}`,
             },
+            {
+                name: "[REQ-FUNCTION-DETECTION] valid with annotation on TS declare function",
+                code: `/** @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md */
+declare function tsDecl(): void;`,
+                languageOptions: {
+                    parser: require("@typescript-eslint/parser"),
+                    parserOptions: { ecmaVersion: 2020, sourceType: "module" },
+                },
+            },
+            {
+                name: "[REQ-FUNCTION-DETECTION] valid with annotation on TS method signature",
+                code: `interface C {
+  /** @story docs/stories/003.0-DEV-FUNCTION-ANNOTATIONS.story.md */
+  method(): void;
+}`,
+                languageOptions: {
+                    parser: require("@typescript-eslint/parser"),
+                    parserOptions: { ecmaVersion: 2020, sourceType: "module" },
+                },
+            },
         ],
         invalid: [
             {
@@ -66,6 +86,32 @@ const arrowFn = () => {};`,
                 output: `class C {\n  /** @story <story-file>.story.md */\n  method() {}\n}`,
                 errors: [{ messageId: "missingStory" }],
             },
+            {
+                name: "[REQ-ANNOTATION-REQUIRED] missing @story on TS declare function",
+                code: `declare function tsDecl(): void;`,
+                output: `/** @story <story-file>.story.md */
+declare function tsDecl(): void;`,
+                languageOptions: {
+                    parser: require("@typescript-eslint/parser"),
+                    parserOptions: { ecmaVersion: 2020, sourceType: "module" },
+                },
+                errors: [{ messageId: "missingStory" }],
+            },
+            {
+                name: "[REQ-ANNOTATION-REQUIRED] missing @story on TS method signature",
+                code: `interface D {
+  method(): void;
+}`,
+                output: `/** @story <story-file>.story.md */
+interface D {
+  method(): void;
+}`,
+                languageOptions: {
+                    parser: require("@typescript-eslint/parser"),
+                    parserOptions: { ecmaVersion: 2020, sourceType: "module" },
+                },
+                errors: [{ messageId: "missingStory" }],
+            },
         ],
     });
     ruleTester.run("require-story-annotation with exportPriority option", require_story_annotation_1.default, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-traceability",
-  "version": "1.1.9",
+  "version": "1.1.10",
   "description": "A customizable ESLint plugin that enforces traceability annotations in your code, ensuring each implementation is linked to its requirement or test case.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -75,6 +75,11 @@
     "node": ">=14"
   },
   "overrides": {
-    "glob": ">=11.0.4"
+    "glob": "12.0.0",
+    "http-cache-semantics": ">=4.1.1",
+    "ip": ">=2.0.2",
+    "semver": ">=7.5.2",
+    "socks": ">=2.7.2",
+    "tar": ">=6.1.12"
   }
 }