@allurereport/web-classic 3.7.0 → 3.8.0

package/dist/single/manifest.json

@@ -1,3 +1,3 @@
 {
-  "main.js": "app-7d3875e449b0b8749a3e.js"
+  "main.js": "app-e92ac44c4ec92cf8d329.js"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/web-classic",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "description": "The static files for Allure Classic Report",
   "keywords": [
     "allure",
@@ -27,10 +27,10 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/charts-api": "3.7.0",
-    "@allurereport/core-api": "3.7.0",
-    "@allurereport/web-commons": "3.7.0",
-    "@allurereport/web-components": "3.7.0",
+    "@allurereport/charts-api": "3.8.0",
+    "@allurereport/core-api": "3.8.0",
+    "@allurereport/web-commons": "3.8.0",
+    "@allurereport/web-components": "3.8.0",
     "@preact/signals": "^2.6.1",
     "clsx": "^2.1.1",
     "d3-shape": "^3.2.0",

package/src/utils/treeFilters.ts

@@ -54,18 +54,31 @@ const groupComparatorByTreeSortBy = (sortBy: TreeSortBy): Comparator<DefaultTree
   }
 };
 
+const withDirection = <T extends { name: string }>(
+  cmp: Comparator<T>,
+  filterOptions: TreeFiltersState,
+): Comparator<T> => {
+  const isStatusSort = filterOptions.sortBy === "status";
+  const isDescending = filterOptions.direction === "desc";
+  const nameComparator = compareBy<T>("name", alphabetically());
+
+  // Status sort always prioritizes severity. Direction only affects name-based tie-breaking.
+  return andThen([
+    isDescending && !isStatusSort ? reverse(cmp) : cmp,
+    isDescending && isStatusSort ? reverse(nameComparator) : nameComparator,
+  ]);
+};
+
 export const leafComparator = (filterOptions: TreeFiltersState): Comparator<TreeLeaf<ClassicTreeLeaf>> => {
   const cmp = leafComparatorByTreeSortBy(filterOptions.sortBy);
-  const directional = filterOptions.direction === "asc" ? cmp : reverse(cmp);
-  // apply fallback sorting by name
-  return andThen([directional, compareBy("name", alphabetically())]);
+
+  return withDirection(cmp, filterOptions);
 };
 
 export const groupComparator = (filterOptions: TreeFiltersState): Comparator<DefaultTreeGroup> => {
   const cmp = groupComparatorByTreeSortBy(filterOptions.sortBy);
-  const directional = filterOptions.direction === "asc" ? cmp : reverse(cmp);
-  // apply fallback sorting by name
-  return andThen([directional, compareBy("name", alphabetically())]);
+
+  return withDirection(cmp, filterOptions);
 };
 
 export const filterLeaves = (

package/test/utils/treeFilters.test.ts

@@ -285,7 +285,7 @@ describe("utils > treeFilters", () => {
     });
 
     it("sorts leaves by status in descending order", () => {
-      const leaves = ["a1", "b2", "c3", "d4", "e5"];
+      const leaves = ["a1", "b2", "c3", "d4", "e5", "f6", "z9"];
       const leavesById = {
         a1: {
           name: "a1",
@@ -307,6 +307,14 @@ describe("utils > treeFilters", () => {
           name: "e5",
           status: "skipped",
         } as ClassicTestResult,
+        f6: {
+          name: "f6",
+          status: "failed",
+        } as ClassicTestResult,
+        z9: {
+          name: "z9",
+          status: "passed",
+        } as ClassicTestResult,
       };
       const result = filterLeaves(leaves, leavesById, {
         direction: "desc",
@@ -314,11 +322,13 @@ describe("utils > treeFilters", () => {
       });
 
       expect(result).toEqual([
-        expect.objectContaining({ name: "d4" }),
-        expect.objectContaining({ name: "e5" }),
-        expect.objectContaining({ name: "a1" }),
-        expect.objectContaining({ name: "c3" }),
+        expect.objectContaining({ name: "f6" }),
         expect.objectContaining({ name: "b2" }),
+        expect.objectContaining({ name: "c3" }),
+        expect.objectContaining({ name: "z9" }),
+        expect.objectContaining({ name: "a1" }),
+        expect.objectContaining({ name: "e5" }),
+        expect.objectContaining({ name: "d4" }),
       ]);
     });
 
@@ -445,5 +455,83 @@ describe("utils > treeFilters", () => {
         }),
       );
     });
+
+    it("keeps problem-heavy groups first when sorting by status in descending order", () => {
+      const group = {
+        leaves: [],
+        groups: ["passedHeavy", "failedAlpha", "brokenGroup", "failedZulu"],
+      };
+      const leavesById = {
+        failedAlphaTest: {
+          name: "failedAlphaTest",
+          status: "failed",
+        } as ClassicTestResult,
+        failedZuluTest: {
+          name: "failedZuluTest",
+          status: "failed",
+        } as ClassicTestResult,
+        brokenTest1: {
+          name: "brokenTest1",
+          status: "broken",
+        } as ClassicTestResult,
+        brokenTest2: {
+          name: "brokenTest2",
+          status: "broken",
+        } as ClassicTestResult,
+        passedTest1: {
+          name: "passedTest1",
+          status: "passed",
+        } as ClassicTestResult,
+        passedTest2: {
+          name: "passedTest2",
+          status: "passed",
+        } as ClassicTestResult,
+      };
+      const groupsById = {
+        passedHeavy: {
+          name: "passedHeavy",
+          leaves: ["passedTest1", "passedTest2"],
+          groups: [],
+        },
+        brokenGroup: {
+          name: "brokenGroup",
+          leaves: ["brokenTest1", "brokenTest2"],
+          groups: [],
+        },
+        failedAlpha: {
+          name: "failedAlpha",
+          leaves: ["failedAlphaTest"],
+          groups: [],
+        },
+        failedZulu: {
+          name: "failedZulu",
+          leaves: ["failedZuluTest"],
+          groups: [],
+        },
+      };
+      const result = createRecursiveTree({
+        group,
+        leavesById,
+        groupsById,
+        filterOptions: {
+          query: "",
+          status: "total",
+          filter: {
+            flaky: false,
+            retry: false,
+            new: false,
+          },
+          sortBy: "status",
+          direction: "desc",
+        },
+      });
+
+      expect(result.trees).toEqual([
+        expect.objectContaining({ name: "failedZulu" }),
+        expect.objectContaining({ name: "failedAlpha" }),
+        expect.objectContaining({ name: "brokenGroup" }),
+        expect.objectContaining({ name: "passedHeavy" }),
+      ]);
+    });
   });
 });