@backstage-community/plugin-code-coverage 0.2.28

package/dist/index.esm.js

@@ -0,0 +1,622 @@
+import React, { useState, useEffect, Fragment } from 'react';
+import { useEntity, humanizeEntityRef, MissingAnnotationEmptyState } from '@backstage/plugin-catalog-react';
+import Box from '@material-ui/core/Box';
+import Card from '@material-ui/core/Card';
+import CardContent from '@material-ui/core/CardContent';
+import CardHeader from '@material-ui/core/CardHeader';
+import Typography from '@material-ui/core/Typography';
+import { makeStyles } from '@material-ui/core/styles';
+import TrendingDownIcon from '@material-ui/icons/TrendingDown';
+import TrendingFlatIcon from '@material-ui/icons/TrendingFlat';
+import TrendingUpIcon from '@material-ui/icons/TrendingUp';
+import Alert from '@material-ui/lab/Alert';
+import useAsync from 'react-use/esm/useAsync';
+import { ResponsiveContainer, LineChart, CartesianGrid, XAxis, YAxis, Tooltip, Legend, Line } from 'recharts';
+import { stringifyEntityRef } from '@backstage/catalog-model';
+import { ResponseError } from '@backstage/errors';
+import { createApiRef, useApi, createRouteRef, createPlugin, createApiFactory, discoveryApiRef, fetchApiRef, createRoutableExtension } from '@backstage/core-plugin-api';
+import { Progress, ResponseErrorPanel, Table, Page, Content, ContentHeader } from '@backstage/core-components';
+import { DateTime } from 'luxon';
+import Modal from '@material-ui/core/Modal';
+import FolderIcon from '@material-ui/icons/Folder';
+import FileOutlinedIcon from '@material-ui/icons/InsertDriveFileOutlined';
+import Paper from '@material-ui/core/Paper';
+import 'highlight.js/styles/mono-blue.css';
+import { highlight } from 'highlight.js';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const codeCoverageApiRef = createApiRef({
+  id: "plugin.code-coverage.service"
+});
+class CodeCoverageRestApi {
+  constructor(options) {
+    __publicField(this, "discoveryApi");
+    __publicField(this, "fetchApi");
+    this.discoveryApi = options.discoveryApi;
+    this.fetchApi = options.fetchApi;
+  }
+  async fetch(path) {
+    var _a;
+    const url = await this.discoveryApi.getBaseUrl("code-coverage");
+    const resp = await this.fetchApi.fetch(`${url}${path}`);
+    if (!resp.ok) {
+      throw await ResponseError.fromResponse(resp);
+    }
+    if ((_a = resp.headers.get("content-type")) == null ? void 0 : _a.includes("application/json")) {
+      return await resp.json();
+    }
+    return await resp.text();
+  }
+  async getCoverageForEntity(entityName) {
+    const entity = encodeURIComponent(stringifyEntityRef(entityName));
+    return await this.fetch(
+      `/report?entity=${entity}`
+    );
+  }
+  async getFileContentFromEntity(entityName, filePath) {
+    const entity = encodeURIComponent(stringifyEntityRef(entityName));
+    return await this.fetch(
+      `/file-content?entity=${entity}&path=${encodeURI(filePath)}`
+    );
+  }
+  async getCoverageHistoryForEntity(entityName, limit) {
+    const entity = encodeURIComponent(stringifyEntityRef(entityName));
+    const hasValidLimit = limit && limit > 0;
+    return await this.fetch(
+      `/history?entity=${entity}${hasValidLimit ? `&limit=${encodeURIComponent(String(limit))}` : ""}`
+    );
+  }
+}
+
+const useStyles$3 = makeStyles((theme) => ({
+  trendDown: {
+    color: theme.palette.status.warning
+  },
+  trendUp: {
+    color: theme.palette.status.ok
+  }
+}));
+const getTrendIcon = (trend, classes) => {
+  switch (true) {
+    case trend > 0:
+      return /* @__PURE__ */ React.createElement(TrendingUpIcon, { className: classes.trendUp });
+    case trend < 0:
+      return /* @__PURE__ */ React.createElement(TrendingDownIcon, { className: classes.trendDown });
+    case trend === 0:
+    default:
+      return /* @__PURE__ */ React.createElement(TrendingFlatIcon, null);
+  }
+};
+function formatDateToHuman(timeStamp) {
+  return DateTime.fromMillis(Number(timeStamp)).toLocaleString(
+    DateTime.DATETIME_MED
+  );
+}
+const CoverageHistoryChart = () => {
+  const { entity } = useEntity();
+  const codeCoverageApi = useApi(codeCoverageApiRef);
+  const {
+    loading: loadingHistory,
+    error: errorHistory,
+    value: valueHistory
+  } = useAsync(
+    async () => await codeCoverageApi.getCoverageHistoryForEntity({
+      kind: entity.kind,
+      namespace: entity.metadata.namespace || "default",
+      name: entity.metadata.name
+    })
+  );
+  const classes = useStyles$3();
+  if (loadingHistory) {
+    return /* @__PURE__ */ React.createElement(Progress, null);
+  }
+  if (errorHistory) {
+    return /* @__PURE__ */ React.createElement(ResponseErrorPanel, { error: errorHistory });
+  } else if (!valueHistory) {
+    return /* @__PURE__ */ React.createElement(Alert, { severity: "warning" }, "No history found.");
+  }
+  if (!valueHistory.history.length) {
+    return /* @__PURE__ */ React.createElement(Card, null, /* @__PURE__ */ React.createElement(CardHeader, { title: "History" }), /* @__PURE__ */ React.createElement(CardContent, null, "No coverage history found"));
+  }
+  const [oldestCoverage] = valueHistory.history.slice(-1);
+  const latestCoverage = valueHistory.history[0];
+  const getTrendForCoverage = (type) => {
+    if (!oldestCoverage[type].percentage) {
+      return 0;
+    }
+    return (latestCoverage[type].percentage - oldestCoverage[type].percentage) / oldestCoverage[type].percentage * 100;
+  };
+  const lineTrend = getTrendForCoverage("line");
+  const branchTrend = getTrendForCoverage("branch");
+  return /* @__PURE__ */ React.createElement(Card, null, /* @__PURE__ */ React.createElement(CardHeader, { title: "History" }), /* @__PURE__ */ React.createElement(CardContent, null, /* @__PURE__ */ React.createElement(Box, { px: 6, display: "flex" }, /* @__PURE__ */ React.createElement(Box, { display: "flex", mr: 4 }, getTrendIcon(lineTrend, classes), /* @__PURE__ */ React.createElement(Typography, null, "Current line: ", latestCoverage.line.percentage, "%", /* @__PURE__ */ React.createElement("br", null), "(", Math.floor(lineTrend), "% change over ", valueHistory.history.length, " ", "builds)")), /* @__PURE__ */ React.createElement(Box, { display: "flex" }, getTrendIcon(branchTrend, classes), /* @__PURE__ */ React.createElement(Typography, null, "Current branch: ", latestCoverage.branch.percentage, "%", /* @__PURE__ */ React.createElement("br", null), "(", Math.floor(branchTrend), "% change over", " ", valueHistory.history.length, " builds)"))), /* @__PURE__ */ React.createElement(ResponsiveContainer, { width: "100%", height: 300 }, /* @__PURE__ */ React.createElement(
+    LineChart,
+    {
+      data: valueHistory.history,
+      margin: { right: 48, top: 32 }
+    },
+    /* @__PURE__ */ React.createElement(CartesianGrid, { strokeDasharray: "3 3" }),
+    /* @__PURE__ */ React.createElement(
+      XAxis,
+      {
+        dataKey: "timestamp",
+        tickFormatter: formatDateToHuman,
+        reversed: true
+      }
+    ),
+    /* @__PURE__ */ React.createElement(YAxis, { dataKey: "line.percentage" }),
+    /* @__PURE__ */ React.createElement(YAxis, { dataKey: "branch.percentage" }),
+    /* @__PURE__ */ React.createElement(Tooltip, { labelFormatter: formatDateToHuman }),
+    /* @__PURE__ */ React.createElement(Legend, null),
+    /* @__PURE__ */ React.createElement(
+      Line,
+      {
+        type: "monotone",
+        dataKey: "branch.percentage",
+        stroke: "#8884d8"
+      }
+    ),
+    /* @__PURE__ */ React.createElement(Line, { type: "monotone", dataKey: "line.percentage", stroke: "#82ca9d" })
+  ))));
+};
+
+const useStyles$2 = makeStyles((theme) => ({
+  lineNumberCell: {
+    color: `${theme.palette.grey[500]}`,
+    fontSize: "90%",
+    borderRight: `1px solid ${theme.palette.grey[500]}`,
+    paddingRight: theme.spacing(1),
+    textAlign: "right"
+  },
+  hitCountCell: {
+    width: "50px",
+    borderRight: `1px solid ${theme.palette.grey[500]}`,
+    textAlign: "center",
+    color: theme.palette.common.white,
+    // need to enforce this color since it needs to stand out against colored background
+    paddingLeft: theme.spacing(1),
+    paddingRight: theme.spacing(1)
+  },
+  countRoundedRectangle: {
+    borderRadius: "45px",
+    fontSize: "90%",
+    padding: "1px 3px 1px 3px",
+    width: "50px"
+  },
+  hitCountRoundedRectangle: {
+    backgroundColor: `${theme.palette.success.main}`,
+    color: `${theme.palette.success.contrastText}`
+  },
+  notHitCountRoundedRectangle: {
+    backgroundColor: `${theme.palette.error.main}`,
+    color: `${theme.palette.error.contrastText}`
+  },
+  codeLine: {
+    paddingLeft: `${theme.spacing(1)}`,
+    whiteSpace: "pre",
+    fontSize: "90%"
+  },
+  hitCodeLine: {
+    backgroundColor: `${theme.palette.success.main}`,
+    color: `${theme.palette.success.contrastText}`
+  },
+  notHitCodeLine: {
+    backgroundColor: `${theme.palette.error.main}`,
+    color: `${theme.palette.error.contrastText}`
+  }
+}));
+const CodeRow = ({
+  lineNumber,
+  lineContent,
+  lineHits = null
+}) => {
+  const classes = useStyles$2();
+  const hitCountRoundedRectangleClass = [classes.countRoundedRectangle];
+  const lineContentClass = [classes.codeLine];
+  let hitRoundedRectangle = null;
+  if (lineHits !== null) {
+    if (lineHits > 0) {
+      hitCountRoundedRectangleClass.push(classes.hitCountRoundedRectangle);
+      lineContentClass.push(classes.hitCodeLine);
+    } else {
+      hitCountRoundedRectangleClass.push(classes.notHitCountRoundedRectangle);
+      lineContentClass.push(classes.notHitCodeLine);
+    }
+    hitRoundedRectangle = /* @__PURE__ */ React.createElement("div", { className: hitCountRoundedRectangleClass.join(" ") }, lineHits);
+  }
+  return /* @__PURE__ */ React.createElement("tr", null, /* @__PURE__ */ React.createElement("td", { className: classes.lineNumberCell }, lineNumber), /* @__PURE__ */ React.createElement("td", { className: classes.hitCountCell }, hitRoundedRectangle), /* @__PURE__ */ React.createElement(
+    "td",
+    {
+      className: lineContentClass.join(" "),
+      dangerouslySetInnerHTML: { __html: lineContent }
+    }
+  ));
+};
+
+const highlightLines = (fileExtension, lines) => {
+  const formattedLines = [];
+  let fileformat = fileExtension;
+  if (fileExtension === "m") {
+    fileformat = "objectivec";
+  }
+  if (fileExtension === "tsx") {
+    fileformat = "typescript";
+  }
+  if (fileExtension === "jsx") {
+    fileformat = "javascript";
+  }
+  if (fileExtension === "kt") {
+    fileformat = "kotlin";
+  }
+  lines.forEach((line) => {
+    const result = highlight(line, {
+      language: fileformat,
+      ignoreIllegals: true
+    });
+    formattedLines.push(result.value);
+  });
+  return formattedLines;
+};
+
+const useStyles$1 = makeStyles((theme) => ({
+  paper: {
+    margin: "auto",
+    top: "2em",
+    width: "80%",
+    border: `2px solid ${theme.palette.common.black}`,
+    boxShadow: theme.shadows[5],
+    padding: theme.spacing(2, 4, 3),
+    overflow: "scroll"
+  },
+  coverageFileViewTable: {
+    borderSpacing: "0px",
+    width: "80%",
+    marginTop: theme.spacing(2)
+  }
+}));
+const FormattedLines = ({
+  highlightedLines,
+  lineHits
+}) => {
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, highlightedLines.map((lineContent, idx) => {
+    const line = idx + 1;
+    return /* @__PURE__ */ React.createElement(
+      CodeRow,
+      {
+        key: line,
+        lineNumber: line,
+        lineContent,
+        lineHits: lineHits[line]
+      }
+    );
+  }));
+};
+const FileContent = ({ filename, coverage }) => {
+  const { entity } = useEntity();
+  const codeCoverageApi = useApi(codeCoverageApiRef);
+  const { loading, error, value } = useAsync(
+    async () => await codeCoverageApi.getFileContentFromEntity(
+      {
+        kind: entity.kind,
+        namespace: entity.metadata.namespace || "default",
+        name: entity.metadata.name
+      },
+      filename
+    ),
+    [entity]
+  );
+  const classes = useStyles$1();
+  if (loading) {
+    return /* @__PURE__ */ React.createElement(Progress, null);
+  }
+  if (error) {
+    return /* @__PURE__ */ React.createElement(ResponseErrorPanel, { error });
+  }
+  if (!value) {
+    return /* @__PURE__ */ React.createElement(Alert, { severity: "warning" }, "Unable to retrieve file content for ", filename);
+  }
+  const [language] = filename.split(".").slice(-1);
+  const highlightedLines = highlightLines(language, value.split("\n"));
+  const lineHits = Object.entries(coverage.lineHits).reduce(
+    (acc, next) => {
+      acc[next[0]] = next[1];
+      return acc;
+    },
+    {}
+  );
+  return /* @__PURE__ */ React.createElement(Paper, { variant: "outlined", className: classes.paper }, /* @__PURE__ */ React.createElement("table", { className: classes.coverageFileViewTable }, /* @__PURE__ */ React.createElement("tbody", null, /* @__PURE__ */ React.createElement(
+    FormattedLines,
+    {
+      highlightedLines,
+      lineHits
+    }
+  ))));
+};
+
+const useStyles = makeStyles((theme) => ({
+  container: {
+    marginTop: theme.spacing(2)
+  },
+  icon: {
+    marginRight: theme.spacing(1)
+  },
+  link: {
+    color: theme.palette.primary.main,
+    cursor: "pointer"
+  }
+}));
+const groupByPath = (files) => {
+  const acc = {};
+  files.forEach((file) => {
+    const filename = file.filename;
+    if (!file.filename)
+      return;
+    const pathArray = filename == null ? void 0 : filename.split("/").filter((el) => el !== "");
+    if (pathArray) {
+      if (!acc.hasOwnProperty(pathArray[0])) {
+        acc[pathArray[0]] = [];
+      }
+      acc[pathArray[0]].push(file);
+    }
+  });
+  return acc;
+};
+const removeVisitedPathGroup = (files, pathGroup) => {
+  return files.map((file) => {
+    var _a;
+    return {
+      ...file,
+      filename: file.filename ? file.filename.substring(
+        ((_a = file.filename) == null ? void 0 : _a.indexOf(pathGroup)) + pathGroup.length + 1
+      ) : file.filename
+    };
+  });
+};
+const buildFileStructure = (row) => {
+  const dataGroupedByPath = groupByPath(row.files);
+  row.files = Object.keys(dataGroupedByPath).map((pathGroup) => {
+    return buildFileStructure({
+      path: pathGroup,
+      files: dataGroupedByPath.hasOwnProperty("files") ? removeVisitedPathGroup(dataGroupedByPath.files, pathGroup) : removeVisitedPathGroup(dataGroupedByPath[pathGroup], pathGroup),
+      coverage: dataGroupedByPath[pathGroup].reduce(
+        (acc, cur) => acc + cur.coverage,
+        0
+      ) / dataGroupedByPath[pathGroup].length,
+      missing: dataGroupedByPath[pathGroup].reduce(
+        (acc, cur) => acc + cur.missing,
+        0
+      ),
+      tracked: dataGroupedByPath[pathGroup].reduce(
+        (acc, cur) => acc + cur.tracked,
+        0
+      )
+    });
+  });
+  return row;
+};
+const formatInitialData = (value) => {
+  return buildFileStructure({
+    path: "",
+    coverage: value.aggregate.line.percentage,
+    missing: value.aggregate.line.missed,
+    tracked: value.aggregate.line.available,
+    files: value.files.map((fc) => {
+      return {
+        path: "",
+        filename: fc.filename,
+        coverage: Math.floor(
+          Object.values(fc.lineHits).filter((hits) => hits > 0).length / Object.values(fc.lineHits).length * 100
+        ),
+        missing: Object.values(fc.lineHits).filter((hits) => !hits).length,
+        tracked: Object.values(fc.lineHits).length
+      };
+    })
+  });
+};
+const getObjectsAtPath = (curData, path) => {
+  var _a;
+  let data = curData == null ? void 0 : curData.files;
+  for (const fragment of path) {
+    data = (_a = data == null ? void 0 : data.find((d) => d.path === fragment)) == null ? void 0 : _a.files;
+  }
+  return data;
+};
+const FileExplorer = () => {
+  const styles = useStyles();
+  const { entity } = useEntity();
+  const [curData, setCurData] = useState();
+  const [tableData, setTableData] = useState();
+  const [curPath, setCurPath] = useState("");
+  const [modalOpen, setModalOpen] = useState(false);
+  const [curFile, setCurFile] = useState("");
+  const codeCoverageApi = useApi(codeCoverageApiRef);
+  const { loading, error, value } = useAsync(
+    async () => await codeCoverageApi.getCoverageForEntity({
+      kind: entity.kind,
+      namespace: entity.metadata.namespace || "default",
+      name: entity.metadata.name
+    })
+  );
+  useEffect(() => {
+    if (!value)
+      return;
+    const data = formatInitialData(value);
+    setCurData(data);
+    if (data.files)
+      setTableData(data.files);
+  }, [value]);
+  if (loading) {
+    return /* @__PURE__ */ React.createElement(Progress, null);
+  } else if (error) {
+    return /* @__PURE__ */ React.createElement(ResponseErrorPanel, { error });
+  }
+  if (!value) {
+    return /* @__PURE__ */ React.createElement(Alert, { severity: "warning" }, "No code coverage found for ", humanizeEntityRef(entity));
+  }
+  const moveDownIntoPath = (path) => {
+    const nextPathData = tableData.find(
+      (d) => d.path === path
+    );
+    if (nextPathData && nextPathData.files) {
+      setTableData(nextPathData.files);
+    }
+  };
+  const moveUpIntoPath = (idx) => {
+    const path = curPath.split("/").slice(0, idx + 1);
+    setCurFile("");
+    setCurPath(path.join("/"));
+    setTableData(getObjectsAtPath(curData, path.slice(1)));
+  };
+  const columns = [
+    {
+      title: "Path",
+      type: "string",
+      field: "path",
+      render: (row) => {
+        var _a, _b;
+        return /* @__PURE__ */ React.createElement(
+          Box,
+          {
+            display: "flex",
+            alignItems: "center",
+            role: "button",
+            tabIndex: row.tableData.id,
+            className: styles.link,
+            onClick: () => {
+              var _a2;
+              if ((_a2 = row.files) == null ? void 0 : _a2.length) {
+                setCurPath(`${curPath}/${row.path}`);
+                moveDownIntoPath(row.path);
+              } else {
+                setCurFile(`${curPath.slice(1)}/${row.path}`);
+                setModalOpen(true);
+              }
+            }
+          },
+          ((_a = row.files) == null ? void 0 : _a.length) > 0 && /* @__PURE__ */ React.createElement(FolderIcon, { fontSize: "small", className: styles.icon }),
+          ((_b = row.files) == null ? void 0 : _b.length) === 0 && /* @__PURE__ */ React.createElement(FileOutlinedIcon, { fontSize: "small", className: styles.icon }),
+          row.path
+        );
+      }
+    },
+    {
+      title: "Coverage",
+      type: "numeric",
+      field: "coverage",
+      render: (row) => `${row.coverage.toFixed(2)}%`
+    },
+    {
+      title: "Missing lines",
+      type: "numeric",
+      field: "missing"
+    },
+    {
+      title: "Tracked lines",
+      type: "numeric",
+      field: "tracked"
+    }
+  ];
+  const pathArray = curPath.split("/");
+  const lastPathElementIndex = pathArray.length - 1;
+  const fileCoverage = value.files.find(
+    (f) => f.filename.endsWith(curFile)
+  );
+  if (!fileCoverage) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(Box, { className: styles.container }, /* @__PURE__ */ React.createElement(
+    Table,
+    {
+      emptyContent: /* @__PURE__ */ React.createElement(React.Fragment, null, "No files found"),
+      data: tableData || [],
+      columns,
+      title: /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Box, null, "Explore Files"), /* @__PURE__ */ React.createElement(
+        Box,
+        {
+          mt: 1,
+          style: {
+            fontSize: "0.875rem",
+            fontWeight: "normal",
+            display: "flex"
+          }
+        },
+        pathArray.map((pathElement, idx) => /* @__PURE__ */ React.createElement(Fragment, { key: pathElement || "root" }, /* @__PURE__ */ React.createElement(
+          "div",
+          {
+            role: "button",
+            tabIndex: idx,
+            className: idx !== lastPathElementIndex ? styles.link : void 0,
+            onKeyDown: () => moveUpIntoPath(idx),
+            onClick: () => moveUpIntoPath(idx)
+          },
+          pathElement || "root"
+        ), idx !== lastPathElementIndex && /* @__PURE__ */ React.createElement("div", null, "\xA0/\xA0")))
+      ))
+    }
+  ), /* @__PURE__ */ React.createElement(
+    Modal,
+    {
+      open: modalOpen,
+      onClick: (event) => event.stopPropagation(),
+      onClose: () => setModalOpen(false),
+      style: { overflow: "scroll" }
+    },
+    /* @__PURE__ */ React.createElement(FileContent, { filename: curFile, coverage: fileCoverage })
+  ));
+};
+
+const CodeCoveragePage = () => {
+  return /* @__PURE__ */ React.createElement(Page, { themeId: "tool" }, /* @__PURE__ */ React.createElement(Content, null, /* @__PURE__ */ React.createElement(ContentHeader, { title: "Code coverage" }), /* @__PURE__ */ React.createElement(CoverageHistoryChart, null), /* @__PURE__ */ React.createElement(FileExplorer, null)));
+};
+
+function isCodeCoverageAvailable(entity) {
+  var _a;
+  return Boolean((_a = entity.metadata.annotations) == null ? void 0 : _a["backstage.io/code-coverage"]);
+}
+const Router = () => {
+  const { entity } = useEntity();
+  if (!isCodeCoverageAvailable(entity)) {
+    return /* @__PURE__ */ React.createElement(MissingAnnotationEmptyState, { annotation: "backstage.io/code-coverage" });
+  }
+  return /* @__PURE__ */ React.createElement(CodeCoveragePage, null);
+};
+
+var Router$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  Router: Router,
+  isCodeCoverageAvailable: isCodeCoverageAvailable
+});
+
+const rootRouteRef = createRouteRef({
+  id: "code-coverage"
+});
+
+const codeCoveragePlugin = createPlugin({
+  id: "code-coverage",
+  routes: {
+    root: rootRouteRef
+  },
+  apis: [
+    createApiFactory({
+      api: codeCoverageApiRef,
+      deps: { discoveryApi: discoveryApiRef, fetchApi: fetchApiRef },
+      factory: ({ discoveryApi, fetchApi }) => new CodeCoverageRestApi({ discoveryApi, fetchApi })
+    })
+  ]
+});
+const EntityCodeCoverageContent = codeCoveragePlugin.provide(
+  createRoutableExtension({
+    name: "EntityCodeCoverageContent",
+    component: () => Promise.resolve().then(function () { return Router$1; }).then((m) => m.Router),
+    mountPoint: rootRouteRef
+  })
+);
+
+const isPluginApplicableToEntity = isCodeCoverageAvailable;
+
+export { EntityCodeCoverageContent, codeCoveragePlugin, isCodeCoverageAvailable, isPluginApplicableToEntity };
+//# sourceMappingURL=index.esm.js.map