@allurereport/web-awesome 3.0.0-beta.3

package/src/utils/treeFilters.ts

@@ -0,0 +1,150 @@
+import type { DefaultTreeData } from "@allurereport/core-api";
+import type { ReportContentContextValue } from "@/components/app/ReportBody/context";
+
+const statusOrder = {
+  failed: 1,
+  broken: 2,
+  passed: 3,
+  skipped: 4,
+  unknown: 5,
+};
+
+const filterByQuery = ({
+  leaves,
+  leavesById,
+  query,
+}: {
+  leaves: string[];
+  leavesById: DefaultTreeData["leavesById"];
+  query: string;
+}) =>
+  leaves.filter((leafId) => {
+    const lowerCaseQuery = query.toLocaleLowerCase();
+    const foundById = leavesById[leafId].nodeId.toLowerCase().includes(lowerCaseQuery);
+    const foundByName = leavesById[leafId].name.toLowerCase().includes(lowerCaseQuery);
+
+    return foundById || foundByName;
+  });
+
+const sortedLeaves = ({
+  leavesFiltered,
+  leavesById,
+  filterOptions,
+}: {
+  leavesFiltered: string[];
+  leavesById: DefaultTreeData["leavesById"];
+  filterOptions: ReportContentContextValue;
+}) => {
+  leavesFiltered.sort((a, b) => {
+    const leafA = leavesById[a];
+    const leafB = leavesById[b];
+    const filterDirection = filterOptions.direction === "asc";
+
+    switch (filterOptions.sortBy) {
+      case "duration":
+        return filterDirection
+          ? (leafA.duration || 0) - (leafB.duration || 0)
+          : (leafB.duration || 0) - (leafA.duration || 0);
+      case "alphabet":
+        return filterDirection ? leafA.name.localeCompare(leafB.name) : leafB.name.localeCompare(leafA.name);
+      case "status": {
+        const statusA = statusOrder[leafA.status] || statusOrder.unknown;
+        const statusB = statusOrder[leafB.status] || statusOrder.unknown;
+        return filterDirection ? statusA - statusB : statusB - statusA;
+      }
+      default:
+        return 0;
+    }
+  });
+
+  if (filterOptions.direction === "desc" && ["order"].includes(filterOptions.sortBy as string)) {
+    leavesFiltered.reverse();
+  }
+
+  return leavesFiltered;
+};
+
+const filterByTestType = ({
+  leaves,
+  leavesById,
+  filterTypes,
+}: {
+  leaves: string[];
+  leavesById: DefaultTreeData["leavesById"];
+  filterTypes: ReportContentContextValue["filter"];
+}) => {
+  return leaves.filter((leafId) => {
+    const leaf = leavesById[leafId];
+    return (!filterTypes.flaky || leaf.flaky) && (!filterTypes.retry || leaf.retry) && (!filterTypes.new || leaf.new);
+  });
+};
+
+export const filterLeaves = (
+  leaves: string[],
+  leavesById: DefaultTreeData["leavesById"],
+  statusFilter?: string,
+  filterOptions?: ReportContentContextValue,
+): string[] => {
+  let leavesFiltered =
+    statusFilter === "total" || !statusFilter
+      ? filterByQuery({
+          leaves,
+          leavesById,
+          query: filterOptions.query,
+        })
+      : leaves.filter((leafId) => leavesById[leafId].status === statusFilter);
+
+  leavesFiltered = filterByQuery({
+    leaves: leavesFiltered,
+    leavesById,
+    query: filterOptions.query,
+  });
+
+  leavesFiltered = filterByTestType({ leaves: leavesFiltered, leavesById, filterTypes: filterOptions.filter });
+
+  leavesFiltered = sortedLeaves({ leavesFiltered, leavesById, filterOptions });
+
+  return leavesFiltered;
+};
+
+export const filterGroups = (
+  groups: string[],
+  groupsById: DefaultTreeData["groupsById"],
+  leavesById: DefaultTreeData["leavesById"],
+  statusFilter?: string,
+  filterOptions?: ReportContentContextValue,
+): string[] => {
+  const gro = groups.filter((groupId) => {
+    const group = groupsById?.[groupId];
+    const groupLeaves = filterLeaves((group?.leaves as string[]) || [], leavesById, statusFilter, filterOptions);
+    const filteredSubGroups = group?.groups?.filter((subGroupId: number) => {
+      const subGroup = groupsById?.[subGroupId] as { leaves: string[]; groups: string[] };
+      return (
+        filterLeaves(subGroup?.leaves || [], leavesById, statusFilter, filterOptions).length > 0 ||
+        filterGroups(subGroup?.groups || [], groupsById, leavesById, statusFilter, filterOptions).length > 0
+      );
+    });
+
+    return groupLeaves.length > 0 || (filteredSubGroups && filteredSubGroups.length > 0);
+  });
+
+  const sortedGroups = gro.sort((a, b) => {
+    const leafA = groupsById[a];
+    const leafB = groupsById[b];
+    const filterDirection = filterOptions.direction === "asc";
+
+    switch (filterOptions.sortBy) {
+      case "alphabet": {
+        return filterDirection ? leafA.name.localeCompare(leafB.name) : leafB.name.localeCompare(leafA.name);
+      }
+      default:
+        return 0;
+    }
+  });
+
+  if (filterOptions.direction === "desc" && ["order"].includes(filterOptions.sortBy as string)) {
+    sortedGroups.reverse();
+  }
+
+  return sortedGroups;
+};

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["src/*"],
+    },
+    "jsx": "preserve",
+    "jsxFactory": "h",
+    "jsxFragmentFactory": "Fragment",
+    "jsxImportSource": "preact",
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "useUnknownInCatchVariables": false,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "lib": ["ES2019", "dom"],
+    // node types should not be used in web-commons
+    "types": []
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}

package/types.d.ts

@@ -0,0 +1,53 @@
+import type {
+  AttachmentLink, AttachmentTestStepResult,
+  DefaultTreeGroup,
+  DefaultTreeLeaf,
+  HistoryTestResult,
+  TestFixtureResult,
+  TestResult,
+  TestStepResult,
+  TreeData,
+} from "@allurereport/core-api";
+
+export type AllureAwesomeReportOptions = {
+  reportName?: string;
+  logo?: string;
+  theme?: "light" | "dark";
+  reportLanguage?: "en" | "ru";
+  createdAt: number;
+  reportUuid: string;
+};
+
+export type AllureAwesomeFixtureResult = Omit<
+  TestFixtureResult,
+  "testResultIds" | "start" | "stop" | "sourceMetadata" | "steps"
+> & {
+  steps: AllureAwesomeTestStepResult[];
+};
+
+export type AllureAwesomeTestStepResult = TestStepResult;
+
+type AllureAwesomeBreadcrumbItem = string[] | string[][];
+
+export type AllureAwesomeTestResult = Omit<
+  TestResult,
+  | "runSelector"
+  | "sourceMetadata"
+  | "expectedResult"
+  | "expectedResultHtml"
+  | "precondition"
+  | "preconditionHtml"
+  | "start"
+  | "steps"
+> & {
+  setup: AllureAwesomeFixtureResult[];
+  teardown: AllureAwesomeFixtureResult[];
+  steps: AllureAwesomeTestStepResult[];
+  history: HistoryTestResult[];
+  retries?: TestResult[];
+  groupedLabels: Record<string, string[]>;
+  attachments?: AttachmentTestStepResult[];
+  breadcrumbs: AllureAwesomeBreadcrumbItem[];
+};
+
+export type AllureAwesomeTree = TreeData<DefaultTreeLeaf, DefaultTreeGroup>;

package/webpack.config.js

@@ -0,0 +1,108 @@
+import HtmlWebpackPlugin from "html-webpack-plugin";
+import MiniCssExtractPlugin from "mini-css-extract-plugin";
+import { dirname, join } from "node:path";
+import { env } from "node:process";
+import { fileURLToPath } from "node:url";
+import SpriteLoaderPlugin from "svg-sprite-loader/plugin.js";
+import webpack from "webpack";
+import { WebpackManifestPlugin } from "webpack-manifest-plugin";
+
+const { SINGLE_FILE_MODE } = env;
+const baseDir = dirname(fileURLToPath(import.meta.url));
+
+export default (env, argv) => {
+  const devMode = argv?.mode === "development";
+  const config = {
+    entry: "./src/index.tsx",
+    output: {
+      path: join(baseDir, SINGLE_FILE_MODE ? "dist/single" : "dist/multi"),
+      filename: devMode ? "app.js" : "app-[hash:8].js",
+      assetModuleFilename: devMode ? `[name].[ext]` : `[name]-[hash:8].[ext]`,
+    },
+    devtool: devMode ? "inline-source-map" : false,
+    module: {
+      rules: [
+        {
+          test: /\.tsx?$/,
+          use: "babel-loader",
+          exclude: /node_modules/,
+        },
+        {
+          test: /\.css$/,
+          use: [SINGLE_FILE_MODE ? "style-loader" : MiniCssExtractPlugin.loader, "css-loader"],
+        },
+        {
+          test: /\.scss$/,
+          use: [
+            SINGLE_FILE_MODE ? "style-loader" : MiniCssExtractPlugin.loader,
+            {
+              loader: "css-loader",
+              options: {
+                modules: {
+                  localIdentName: devMode ? "[path][name]__[local]" : "[hash:base64:8]",
+                },
+              },
+            },
+            "sass-loader",
+          ],
+        },
+        {
+          test: /\.svg$/,
+          loader: "svg-sprite-loader",
+        },
+        {
+          test: /\.(png|jpe?g|gif|woff2?|otf|ttf)$/i,
+          type: SINGLE_FILE_MODE ? "asset/inline" : "asset/resource",
+        },
+      ],
+    },
+    devServer: {
+      hot: true,
+      static: "./out/dev",
+      historyApiFallback: true,
+      watchFiles: ["./src"],
+      devMiddleware: {
+        index: true,
+        mimeTypes: { phtml: "text/html" },
+        serverSideRender: false,
+      },
+    },
+    plugins: [
+      new webpack.DefinePlugin({
+        DEVELOPMENT: devMode,
+      }),
+      new MiniCssExtractPlugin({
+        filename: devMode ? "styles.css" : "styles-[hash:8].css",
+      }),
+      new SpriteLoaderPlugin(),
+      new WebpackManifestPlugin({
+        publicPath: "",
+      }),
+    ],
+    resolve: {
+      modules: ["node_modules"],
+      extensions: [".js", ".ts", ".tsx"],
+      alias: {
+        "@": join(baseDir, "src"),
+      },
+    },
+  };
+
+  if (SINGLE_FILE_MODE) {
+    config.plugins.push(
+      new webpack.optimize.LimitChunkCountPlugin({
+        maxChunks: 1,
+      }),
+    );
+  }
+
+  if (devMode) {
+    config.plugins.push(
+      new HtmlWebpackPlugin({
+        template: "src/index.html",
+      }),
+    );
+  }
+
+  return config;
+};