@elisra-devops/docgen-data-provider 1.86.0 → 1.87.0

package/bin/modules/ResultDataProvider.d.ts

@@ -142,6 +142,7 @@ export default class ResultDataProvider {
     private isExcludedL3L4BySapWbs;
     private normalizeMewpRequirementCode;
     private normalizeMewpRequirementCodeWithSuffix;
+    private formatRequirementCodesGroupedByFamily;
     private toMewpComparableText;
     private fetchTestPlanName;
     /**

package/bin/modules/ResultDataProvider.js

@@ -581,17 +581,34 @@ class ResultDataProvider {
                 const missingFamilyMembers = new Set();
                 for (const [baseKey, mentionedCodes] of mentionedCodesByBase.entries()) {
                     const familyCodes = requirementFamilies.get(baseKey);
+                    const mentionedCodesList = [...mentionedCodes];
+                    const hasBaseMention = mentionedCodesList.some((code) => !/-\d+$/.test(code));
+                    const mentionedSpecificMembers = mentionedCodesList.filter((code) => /-\d+$/.test(code));
                     if (familyCodes === null || familyCodes === void 0 ? void 0 : familyCodes.size) {
-                        const missingInFamily = [...familyCodes].filter((code) => !linkedFullCodes.has(code));
-                        if (missingInFamily.length === 0)
+                        // Base mention ("SR0054") validates against child coverage when children exist.
+                        // If no child variants exist, fallback to the single standalone requirement code.
+                        if (hasBaseMention) {
+                            const familyCodesList = [...familyCodes];
+                            const childFamilyCodes = familyCodesList.filter((code) => /-\d+$/.test(code));
+                            const targetFamilyCodes = childFamilyCodes.length > 0 ? childFamilyCodes : familyCodesList;
+                            const missingInTargetFamily = targetFamilyCodes.filter((code) => !linkedFullCodes.has(code));
+                            if (missingInTargetFamily.length > 0) {
+                                const hasAnyLinkedInFamily = familyCodesList.some((code) => linkedFullCodes.has(code));
+                                if (!hasAnyLinkedInFamily) {
+                                    missingBaseWhenFamilyUncovered.add(baseKey);
+                                }
+                                else {
+                                    for (const code of missingInTargetFamily) {
+                                        missingFamilyMembers.add(code);
+                                    }
+                                }
+                            }
                             continue;
-                        const linkedInFamilyCount = familyCodes.size - missingInFamily.length;
-                        if (linkedInFamilyCount === 0) {
-                            missingBaseWhenFamilyUncovered.add(baseKey);
                         }
-                        else {
-                            for (const code of missingInFamily) {
-                                missingFamilyMembers.add(code);
+                        // Specific mention ("SR0054-1") validates as exact-match only.
+                        for (const code of mentionedSpecificMembers) {
+                            if (!linkedFullCodes.has(code)) {
+                                missingSpecificMentionedNoFamily.add(code);
                             }
                         }
                         continue;
@@ -661,11 +678,11 @@ class ResultDataProvider {
                     return String(a[0]).localeCompare(String(b[0]));
                 })
                     .map(([stepRef, requirementIds]) => {
-                    const requirementList = [...requirementIds].sort((a, b) => a.localeCompare(b));
-                    return `${stepRef}: ${requirementList.join(', ')}`;
+                    const groupedRequirementList = this.formatRequirementCodesGroupedByFamily(requirementIds);
+                    return `${stepRef}: ${groupedRequirementList}`;
                 })
                     .join('; ');
-                const linkedButNotMentioned = sortedExtraLinked.join('; ');
+                const linkedButNotMentioned = this.formatRequirementCodesGroupedByFamily(sortedExtraLinked);
                 const validationStatus = mentionedButNotLinked || linkedButNotMentioned ? 'Fail' : 'Pass';
                 if (validationStatus === 'Fail')
                     diagnostics.failingRows += 1;
@@ -2254,6 +2271,29 @@ class ResultDataProvider {
             return `SR${match[1]}-${match[2]}`;
         return `SR${match[1]}`;
     }
+    formatRequirementCodesGroupedByFamily(codes) {
+        const byBaseKey = new Map();
+        for (const rawCode of codes || []) {
+            const normalizedCode = this.normalizeMewpRequirementCodeWithSuffix(String(rawCode || ''));
+            if (!normalizedCode)
+                continue;
+            const baseKey = this.toRequirementKey(normalizedCode) || normalizedCode;
+            if (!byBaseKey.has(baseKey))
+                byBaseKey.set(baseKey, new Set());
+            byBaseKey.get(baseKey).add(normalizedCode);
+        }
+        if (byBaseKey.size === 0)
+            return '';
+        return [...byBaseKey.entries()]
+            .sort((a, b) => a[0].localeCompare(b[0]))
+            .map(([baseKey, members]) => {
+            const sortedMembers = [...members].sort((a, b) => a.localeCompare(b));
+            if (sortedMembers.length <= 1)
+                return sortedMembers[0];
+            return `${baseKey}: ${sortedMembers.join(', ')}`;
+        })
+            .join('; ');
+    }
     toMewpComparableText(value) {
         if (value === null || value === undefined)
             return '';