@sjcrh/proteinpaint-client 2.207.0 → 2.207.1

package/dist/GSEA-KXQBR3HH.js

@@ -0,0 +1,851 @@
+import {
+  VolcanoModel
+} from "./chunk-P7DIIYCX.js";
+import {
+  getDefaultGseaSettings
+} from "./chunk-KTKZSYIH.js";
+import {
+  PlotBase,
+  axisstyle,
+  controlsInit,
+  getCombinedTermFilter,
+  getDefaultVolcanoSettings,
+  renderTable,
+  sayerror,
+  table2col
+} from "./chunk-PC4MFDHP.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-HPAW7XDM.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-BZN2O76M.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import {
+  dofetch3
+} from "./chunk-52QHIKH2.js";
+import "./chunk-A2ORIMUJ.js";
+import "./chunk-PPSWNLMG.js";
+import {
+  PROTEOME_DAP,
+  SINGLECELL_CELLTYPE
+} from "./chunk-RUBZCKIX.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import {
+  axisBottom,
+  axisLeft
+} from "./chunk-Z2ZITHT4.js";
+import {
+  linear
+} from "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import {
+  roundValueAuto
+} from "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/gsea/model/GseaParams.ts
+function isValidGseaParams(value) {
+  return isProteomeDAPGseaParams(value) || isScctGseaParams(value) || isOtherTermTypesGseaParams(value);
+}
+function isProteomeDAPGseaParams(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  const d = p.dapParams;
+  return typeof p.genome === "string" && typeof p.dslabel === "string" && d && typeof d.organism === "string" && typeof d.assay === "string" && typeof d.cohort === "string";
+}
+function isScctGseaParams(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  return typeof p.genome === "string" && Array.isArray(p.genes) && p.genes.every((g) => typeof g === "string") && Array.isArray(p.fold_change) && p.fold_change.every((fc) => typeof fc === "number") && typeof p.genes_length === "number";
+}
+function isOtherTermTypesGseaParams(value) {
+  if (!value || typeof value !== "object") return false;
+  const p = value;
+  return typeof p.genome === "string" && typeof p.cacheId === "string" && "daRequest" in p && typeof p.genes_length === "number" && typeof p.dslabel === "string";
+}
+
+// plots/gsea/model/GSEAModel.ts
+var GSEAModel = class {
+  constructor(gsea) {
+    this.gsea = gsea;
+    this.app = gsea.app;
+  }
+  async getGseaParams(_params, state, config) {
+    if (!this.termType) this.termType = config.termType;
+    const params = structuredClone(_params);
+    if (!params.genome) params.genome = state.genome;
+    if (!params.dslabel) params.dslabel = state.dslabel;
+    if (this.termType === PROTEOME_DAP) this.getProteomeDAPParams(params);
+    else if (this.termType === SINGLECELL_CELLTYPE) await this.getScctParams(params, state, config);
+    else await this.getOtherTermTypesParams(params, config);
+    return params;
+  }
+  getProteomeDAPParams(params) {
+    if (isProteomeDAPGseaParams(params)) return;
+    if (!params.dapParams) params.dapParams = this.gsea.state.config.proteomeDetails;
+  }
+  async getScctParams(params, state, config) {
+    if (isScctGseaParams(params)) return;
+    let response;
+    try {
+      response = await this.getDEGenes(state, config);
+      if (response.error) throw new Error(response.error);
+      if (!Array.isArray(response.data) || response.data.length === 0) {
+        throw new Error("No DE genes returned for this cluster");
+      }
+    } catch (e) {
+      if (e instanceof Error) console.error(e.message || e);
+      else if (e.stack) console.log(e.stack);
+      throw new Error(e.message || e);
+    }
+    const genes = [];
+    const fold_change = [];
+    for (const g of response.data) {
+      genes.push(g.gene_name);
+      fold_change.push(g.fold_change);
+    }
+    params.genes = genes;
+    params.fold_change = fold_change;
+    params.genes_length = genes.length;
+  }
+  async getDEGenes(state, config) {
+    const body = {
+      genome: state.genome,
+      dslabel: state.dslabel,
+      sample: config.sample,
+      termId: config.termId,
+      categoryName: config.categoryName
+    };
+    return await dofetch3("termdb/singlecellDEgenes", { body });
+  }
+  async getOtherTermTypesParams(params, config) {
+    if (isOtherTermTypesGseaParams(params)) return;
+    let response;
+    try {
+      response = await this.getCachedResponse(config);
+      if (!response?.data?.cacheId || response.error) {
+        throw new Error(response.error || "No DE cacheId returned from volcano model");
+      }
+    } catch (e) {
+      if (e instanceof Error) console.error(e.message || e);
+      else if (e.stack) console.log(e.stack);
+      throw new Error(e.message || e);
+    }
+    params.cacheId = response.data.cacheId;
+    params.daRequest = response.daRequest;
+    params.genes_length = response.data.totalRows;
+  }
+  async getCachedResponse(config) {
+    const volcanoSettings = config.settings?.volcano || getDefaultVolcanoSettings({}, { termType: config.termType });
+    const model = new VolcanoModel(this.gsea, config.termType);
+    return await model.getData(config, volcanoSettings);
+  }
+  async runEnrichment(body) {
+    this.toggleLoading(true);
+    try {
+      return await dofetch3("genesetEnrichment", { body });
+    } finally {
+      this.toggleLoading(false);
+    }
+  }
+  toggleLoading(isLoading) {
+    this.gsea.dom.actionsDiv.style("display", isLoading ? "none" : "block");
+    this.gsea.dom.loadingDiv.style("display", isLoading ? "block" : "none");
+  }
+};
+
+// plots/gsea/view/GSEAControls.ts
+async function setControls(controlsDiv, gsea) {
+  const inputs = [
+    {
+      label: "Minimum Gene Set Size Filter Cutoff",
+      type: "number",
+      chartType: "gsea",
+      settingsKey: "min_gene_set_size_cutoff",
+      title: "Minimum Gene set size cutoff. Helps in filtering out small gene sets",
+      min: 0
+    },
+    {
+      label: "Maximum Gene Set Size Filter Cutoff",
+      type: "number",
+      chartType: "gsea",
+      settingsKey: "max_gene_set_size_cutoff",
+      title: "Maximum Gene set size cutoff. Helps in filtering out large gene sets",
+      max: 25e3
+    },
+    {
+      label: "Filter Non-coding Genes",
+      type: "checkbox",
+      chartType: "gsea",
+      settingsKey: "filter_non_coding_genes",
+      title: "Filter non-coding genes",
+      boxLabel: ""
+    },
+    {
+      label: "FDR or Top Gene Sets",
+      type: "radio",
+      chartType: "gsea",
+      settingsKey: "fdr_or_top",
+      title: "Toggle between FDR cutoff and top gene sets in ascending order of FDR",
+      options: [
+        { label: "FDR", value: "fdr" },
+        { label: "Top Gene Sets", value: "top" }
+      ]
+    },
+    {
+      label: "GSEA method",
+      type: "radio",
+      chartType: "gsea",
+      settingsKey: "gsea_method",
+      title: "Toggle between blitzgsea and CERNO method",
+      options: [
+        { label: "blitzgsea", value: "blitzgsea" },
+        { label: "CERNO", value: "cerno" }
+      ],
+      getDisplayStyle: () => {
+        return gsea.testEnabled ? "" : "none";
+      }
+    },
+    {
+      label: "Number of Permutations",
+      type: "number",
+      chartType: "gsea",
+      settingsKey: "num_permutations",
+      title: "Number of permutations to be used for GSEA. Higher number increases accuracy but also compute time.",
+      min: 0,
+      max: 4e4,
+      // Setting it to pretty lenient limit for testing
+      getDisplayStyle: (plot) => {
+        const settings = plot.settings.gsea;
+        return settings.gsea_method === "blitzgsea" ? "" : "none";
+      }
+    },
+    {
+      label: "FDR Filter Cutoff (Linear Scale)",
+      type: "number",
+      chartType: "gsea",
+      settingsKey: "fdr_cutoff",
+      title: "P-value significance",
+      min: 0,
+      max: 1,
+      getDisplayStyle: (plot) => {
+        const settings = plot.settings.gsea;
+        return settings.fdr_or_top == "fdr" ? "" : "none";
+      }
+    },
+    {
+      label: "Number of top Gene Sets by FDR",
+      type: "number",
+      chartType: "gsea",
+      settingsKey: "top_genesets",
+      title: "Number of top gene sets to be displayed in ascending order of FDR",
+      min: 0,
+      max: 5e3,
+      getDisplayStyle: (plot) => {
+        const settings = plot.settings.gsea;
+        return settings.fdr_or_top == "top" ? "" : "none";
+      }
+    }
+  ];
+  gsea.components.controls = await controlsInit({
+    app: gsea.app,
+    id: gsea.id,
+    holder: controlsDiv,
+    inputs
+  });
+  gsea.components.controls.on("downloadClick.gsea", () => {
+    if (!gsea.imageUrl) return alert("No image to download");
+    const dataUrl = gsea.imageUrl;
+    const downloadImgName = `${gsea.state.config.gsea_params.geneset_name || ""}_GSEA_IMG`;
+    const a = document.createElement("a");
+    document.body.appendChild(a);
+    a.addEventListener(
+      "click",
+      () => {
+        a.download = downloadImgName + ".png";
+        a.href = dataUrl;
+        document.body.removeChild(a);
+      },
+      false
+    );
+    a.click();
+  });
+}
+
+// plots/gsea/viewModel/GSEAViewModel.ts
+function formatStat(v) {
+  if (v == null) return v;
+  if (v === "Infinity") return "\u221E";
+  if (v === "-Infinity") return "\u2212\u221E";
+  return typeof v == "number" ? roundValueAuto(v) : v;
+}
+var GSEAViewModel = class {
+  constructor(gsea) {
+    this.rankedDE = null;
+    this.rankedDEKey = "";
+    this.gsea = gsea;
+    this.initPathwayOpts = structuredClone(gsea.app.opts.genome.termdbs.msigdb.analysisGenesetGroups);
+  }
+  async processData() {
+    const settings = this.gsea.state.config.settings.gsea;
+    const viewData = {
+      pathwayOpts: this.getPathwayOpts(settings)
+    };
+    if (!settings.pathway || settings.pathway == "-") {
+      this.viewData = viewData;
+      return;
+    }
+    let outputMap;
+    try {
+      const output = await this.gsea.model.runEnrichment(this.getRequestBody(settings));
+      if (output?.error) throw Object.assign(new Error(output.error), { code: output.code });
+      outputMap = this.getOutputMap(output, settings.gsea_method);
+    } catch (e) {
+      const msg = String(e?.message || e);
+      if (e?.code === "CACHE_BUSY") {
+        if (window.confirm(msg)) {
+          await this.processData();
+          return;
+        }
+        this.viewData = viewData;
+        return;
+      }
+      viewData.error = /daCacheMissing|ENOENT|no such file/i.test(msg) ? "The differential-analysis cache for this GSEA is no longer available. Reopen the volcano plot to regenerate it." : msg;
+      this.viewData = viewData;
+      return;
+    }
+    viewData.statsData = this.getStatsData(outputMap);
+    viewData.tableData = this.getTableData(outputMap, settings);
+    viewData.selectedRows = this.getSelectedRows(viewData.tableData.rowItems);
+    viewData.showHighlightButton = this.gsea.state.config.chartType == "differentialAnalysis" && this.gsea.state.config.gsea_params?.geneset_name != null;
+    const selectedGeneset = this.gsea.state.config.gsea_params?.geneset_name;
+    if (selectedGeneset) {
+      if (settings.gsea_method == "blitzgsea") {
+        try {
+          viewData.detailImage = await this.getDetailImage(settings, selectedGeneset);
+        } catch (e) {
+          const msg = String(e?.message || e);
+          if (e?.code === "CACHE_BUSY") {
+            if (window.confirm(msg)) {
+              await this.processData();
+              return;
+            }
+          } else {
+            viewData.detailError = /daCacheMissing|ENOENT|no such file/i.test(msg) ? "The differential-analysis cache for this GSEA is no longer available. Reopen the volcano plot to regenerate it." : msg;
+          }
+        }
+      } else {
+        viewData.cernoPlotData = await this.getCernoPlotData(outputMap, selectedGeneset);
+      }
+    }
+    this.viewData = viewData;
+  }
+  getPathwayOpts(settings) {
+    const pathwayOpts = structuredClone(this.initPathwayOpts);
+    if (this.gsea.testEnabled && settings.gsea_method == "blitzgsea") {
+      pathwayOpts.push(
+        { label: "REACTOME (blitzgsea)", value: "REACTOME--blitzgsea" },
+        { label: "KEGG (blitzgsea)", value: "KEGG--blitzgsea" },
+        { label: "WikiPathways (blitzgsea)", value: "WikiPathways--blitzgsea" }
+      );
+    }
+    if (settings.pathway) {
+      pathwayOpts.shift();
+      const opt = pathwayOpts.find((opt2) => opt2.value == settings.pathway);
+      if (!opt) console.warn(`Selected pathway ${settings.pathway} not found in pathway options.`);
+      else opt.selected = true;
+    }
+    return pathwayOpts;
+  }
+  getRequestBody(settings, geneset_name) {
+    const p = this.gsea.gsea_params;
+    const body = {
+      genome: p.genome,
+      geneSetGroup: settings.pathway,
+      filter_non_coding_genes: settings.filter_non_coding_genes,
+      method: settings.gsea_method
+    };
+    if (p.cacheId) {
+      body.cacheId = p.cacheId;
+      if (p.daRequest) body.daRequest = p.daRequest;
+      if (p.dslabel) body.dslabel = p.dslabel;
+    } else if (p.dapParams) {
+      body.dapParams = p.dapParams;
+      body.dslabel = p.dslabel;
+    } else {
+      body.genes = p.genes;
+      body.fold_change = p.fold_change;
+    }
+    if (settings.gsea_method == "blitzgsea") {
+      body.num_permutations = settings.num_permutations;
+    }
+    if (geneset_name) body.geneset_name = geneset_name;
+    return body;
+  }
+  getOutputMap(output, method) {
+    if (method == "blitzgsea") {
+      if (!output?.data || typeof output.data != "object") throw new Error("Invalid blitzgsea response");
+      return output.data;
+    }
+    if (output?.data && !Array.isArray(output.data) && !output.data.genes && !output.data.fold_change) {
+      return output.data;
+    }
+    if (output && typeof output == "object" && !Array.isArray(output)) return output;
+    throw new Error("Invalid cerno response");
+  }
+  getStatsData(outputMap) {
+    return [{ label: "Gene sets analyzed", value: Object.keys(outputMap).length }];
+  }
+  getTableData(outputMap, settings) {
+    const entries = Object.entries(outputMap).map(([genesetName, result]) => ({ genesetName, result }));
+    const rowItems = [];
+    if (settings.fdr_or_top == "top") {
+      entries.sort((a, b) => Number(a.result.fdr ?? Infinity) - Number(b.result.fdr ?? Infinity));
+      for (let index = 0; index < Math.min(settings.top_genesets, entries.length); index++) {
+        const item = entries[index];
+        if (this.withinSizeCutoff(item.result, settings)) rowItems.push(this.makeRowItem(item, settings.gsea_method));
+      }
+    } else {
+      for (const item of entries) {
+        if (!this.withinSizeCutoff(item.result, settings)) continue;
+        if (Number(item.result.fdr ?? Infinity) > settings.fdr_cutoff) continue;
+        rowItems.push(this.makeRowItem(item, settings.gsea_method));
+      }
+    }
+    return {
+      columns: this.getTableColumns(settings.gsea_method),
+      rows: rowItems.map((item) => item.row),
+      rowItems
+    };
+  }
+  withinSizeCutoff(result, settings) {
+    return settings.max_gene_set_size_cutoff >= result.geneset_size && settings.min_gene_set_size_cutoff <= result.geneset_size;
+  }
+  makeRowItem(item, method) {
+    const pvalue = formatStat(item.result.pval);
+    const fdr = formatStat(item.result.fdr);
+    const leadingEdge = item.result.leading_edge;
+    const genes = leadingEdge ? leadingEdge.split(",").map((gene) => gene.trim()).filter(Boolean) : [];
+    if (method == "blitzgsea") {
+      const nes = formatStat(item.result.nes);
+      return {
+        genesetName: item.genesetName,
+        genes,
+        row: [
+          { value: item.genesetName },
+          { value: nes },
+          { value: item.result.geneset_size },
+          { value: pvalue },
+          { value: fdr },
+          { value: leadingEdge }
+        ]
+      };
+    }
+    const auc = formatStat(item.result.auc);
+    const es = formatStat(item.result.es);
+    return {
+      genesetName: item.genesetName,
+      genes,
+      row: [
+        { value: item.genesetName },
+        { value: auc },
+        { value: es },
+        { value: item.result.geneset_size },
+        { value: pvalue },
+        { value: fdr },
+        { value: leadingEdge }
+      ]
+    };
+  }
+  getTableColumns(method) {
+    if (method == "blitzgsea") {
+      return [
+        { label: "Gene Set", sortable: true },
+        {
+          label: "Normalized Enrichment Score",
+          barplot: { axisWidth: 200 },
+          sortable: true,
+          tooltip: "Normal quantile of the permutation p-value. \xB1\u221E means the p-value underflowed the permutation model, so the enrichment is beyond what the null distribution can score \u2014 the P value column reads 0 for the same reason. Rank these by enrichment score, not by how far off the scale they are."
+        },
+        { label: "Gene Set Size", sortable: true },
+        { label: "P value", sortable: true },
+        { label: "FDR", sortable: true },
+        { label: "Leading Edge" }
+      ];
+    }
+    return [
+      { label: "Gene Set", sortable: true },
+      { label: "Area Under Curve", barplot: { axisWidth: 200 }, sortable: true },
+      { label: "Enrichment Score", barplot: { axisWidth: 200 }, sortable: true },
+      { label: "Total Gene Set Size", sortable: true },
+      { label: "P value", sortable: true },
+      { label: "FDR", sortable: true },
+      { label: "Gene Set Hits" }
+    ];
+  }
+  getSelectedRows(rowItems) {
+    const selectedGeneset = this.gsea.state.config.gsea_params?.geneset_name;
+    const selectedIndex = rowItems.findIndex((item) => item.genesetName == selectedGeneset);
+    return selectedIndex > -1 ? [selectedIndex] : [];
+  }
+  async getDetailImage(settings, genesetName) {
+    const image = await this.gsea.model.runEnrichment(this.getRequestBody(settings, genesetName));
+    if (image?.error) throw Object.assign(new Error(image.error), { code: image.code });
+    if (this.gsea.imageUrl) URL.revokeObjectURL(this.gsea.imageUrl);
+    this.gsea.imageUrl = URL.createObjectURL(image);
+    return {
+      src: this.gsea.imageUrl,
+      width: 600,
+      height: 400
+    };
+  }
+  async getCernoPlotData(outputMap, genesetName) {
+    const selected = outputMap[genesetName];
+    if (!selected) throw new Error(`${genesetName} not found`);
+    const rankedDE = await this.getRankedDE();
+    const rankedGenes = rankedDE.genes.map((gene, index) => ({ gene, fold_change: rankedDE.fold_change[index] }));
+    rankedGenes.sort((a, b) => b.fold_change - a.fold_change);
+    return {
+      auc: selected.auc,
+      genesetName,
+      leadingEdgeGenes: selected.leading_edge.split(",").map((gene) => gene.trim()).filter(Boolean),
+      rankedGenes
+    };
+  }
+  async getRankedDE() {
+    const cacheKey = this.getRankedDECacheKey();
+    if (this.rankedDE && this.rankedDEKey == cacheKey) return this.rankedDE;
+    if (!this.gsea.gsea_params.cacheId && !this.gsea.gsea_params.dapParams) {
+      const rankedDE2 = {
+        genes: this.gsea.gsea_params.genes,
+        fold_change: this.gsea.gsea_params.fold_change
+      };
+      this.rankedDE = rankedDE2;
+      this.rankedDEKey = cacheKey;
+      return rankedDE2;
+    }
+    const response = await this.gsea.model.runEnrichment({
+      genome: this.gsea.gsea_params.genome,
+      dslabel: this.gsea.gsea_params.dslabel,
+      fetchDE: true,
+      geneSetGroup: "-",
+      filter_non_coding_genes: false,
+      method: "cerno",
+      ...this.gsea.gsea_params.cacheId ? {
+        cacheId: this.gsea.gsea_params.cacheId,
+        daRequest: this.gsea.gsea_params.daRequest
+      } : { dapParams: this.gsea.gsea_params.dapParams }
+    });
+    if (response?.error) throw Object.assign(new Error(response.error), { code: response.code });
+    const rankedDE = response.data;
+    this.rankedDE = rankedDE;
+    this.rankedDEKey = cacheKey;
+    return rankedDE;
+  }
+  getRankedDECacheKey() {
+    if (this.gsea.gsea_params.cacheId) return `cache:${this.gsea.gsea_params.cacheId}`;
+    if (this.gsea.gsea_params.dapParams) return `dap:${JSON.stringify(this.gsea.gsea_params.dapParams)}`;
+    const genes = this.gsea.gsea_params.genes || [];
+    return `inline:${genes.length}:${genes[0] || ""}:${genes[genes.length - 1] || ""}`;
+  }
+};
+
+// plots/gsea/view/GSEAView.ts
+var GSEAView = class {
+  constructor(gsea) {
+    this.gsea = gsea;
+    this.dom = gsea.dom;
+  }
+  initRender() {
+    this.renderActions();
+  }
+  renderActions() {
+    this.dom.actionsDiv.append("span").attr("data-testid", "sjpp-gsea-pathway").style("margin-right", "10px").style("display", "inline-block").text("Select a gene set group:");
+    this.pathwayDropDown = this.dom.actionsDiv.append("select").style("display", "inline-block").on("change", async () => {
+      const value = this.pathwayDropDown.node().value;
+      const settings = structuredClone(this.gsea.state.config.settings.gsea);
+      settings.pathway = value;
+      await this.gsea.app.dispatch({
+        type: "plot_edit",
+        id: this.gsea.id,
+        config: {
+          //Need to clear the gsea_params completely
+          gsea_params: {
+            geneset_name: null,
+            pathway: value
+          },
+          highlightGenes: [],
+          settings: {
+            gsea: settings
+          }
+        }
+      });
+    });
+  }
+  update() {
+    const viewData = this.gsea.viewModel.viewData;
+    this.renderPathwayOptions(viewData.pathwayOpts);
+    this.dom.detailsDiv.selectAll("*").remove();
+    this.dom.holder.selectAll("*").remove();
+    this.dom.tableDiv.selectAll("*").remove();
+    if (viewData.error) {
+      sayerror(this.dom.holder, viewData.error);
+      return;
+    }
+    if (!viewData.tableData) return;
+    this.renderStats(viewData.statsData);
+    if (viewData.detailImage) this.renderImage(viewData.detailImage);
+    if (viewData.cernoPlotData) this.renderCernoPlot(viewData.cernoPlotData);
+    if (viewData.detailError) sayerror(this.dom.holder, viewData.detailError);
+    if (viewData.showHighlightButton) this.renderHighlightButton();
+    this.renderResultsTable(viewData);
+  }
+  renderPathwayOptions(pathwayOpts) {
+    this.pathwayDropDown.selectAll("option").remove();
+    this.pathwayDropDown.selectAll("option").data(pathwayOpts).enter().append("option").text((d) => d.label).property("value", (d) => d.value).property("selected", (d) => d.selected);
+  }
+  renderStats(statsData) {
+    const tableStats = table2col({ holder: this.dom.detailsDiv.attr("data-testid", "sjpp-gsea-stats") });
+    const [, countHeader] = tableStats.addRow();
+    countHeader.style("text-align", "center").style("font-size", "0.8em").style("opacity", "0.8").text("COUNT");
+    for (const row of statsData) {
+      const [labelCell, valueCell] = tableStats.addRow();
+      labelCell.text(row.label);
+      valueCell.style("text-align", "end").text(row.value);
+    }
+  }
+  renderImage(detailImage) {
+    this.dom.holder.append("img").attr("width", detailImage.width).attr("height", detailImage.height).attr("src", detailImage.src);
+  }
+  renderHighlightButton() {
+    this.dom.detailsDiv.append("button").style("margin-left", "10px").style("display", "block").attr("aria-label", "Highlight genes in the volcano plot").text("Highlight genes").on("click", () => {
+      this.gsea.app.dispatch({
+        type: "plot_edit",
+        id: this.gsea.id,
+        config: {
+          childType: "volcano",
+          highlightedData: this.gsea.state.config.highlightGenes
+        }
+      });
+    });
+  }
+  renderResultsTable(viewData) {
+    const tableDiv = this.dom.tableDiv.append("div");
+    renderTable({
+      download: {
+        fileName: this.gsea.state.config.downloadFilename || ""
+      },
+      columns: viewData.tableData.columns,
+      rows: viewData.tableData.rows,
+      div: tableDiv,
+      showLines: true,
+      maxHeight: "30vh",
+      singleMode: true,
+      resize: true,
+      header: { allowSort: true },
+      selectedRows: viewData.selectedRows,
+      noButtonCallback: async (index) => {
+        const rowItem = viewData.tableData.rowItems[index];
+        const config = {
+          gsea_params: {
+            geneset_name: rowItem.genesetName
+          }
+        };
+        if (this.gsea.state.config.chartType == "differentialAnalysis" && rowItem.genes.length) {
+          config.highlightGenes = rowItem.genes;
+        }
+        await this.gsea.app.dispatch({
+          type: "plot_edit",
+          id: this.gsea.id,
+          config
+        });
+      }
+    });
+  }
+  renderCernoPlot(cernoPlotData) {
+    const holder = this.dom.holder;
+    const svgWidth = 400;
+    const svgHeight = 400;
+    const svg = holder.append("svg").attr("width", svgWidth).attr("height", svgHeight);
+    const topPad = 20;
+    const rightPad = 5;
+    const xPad = 50;
+    const yPad = 100;
+    const yAxis = svg.append("g");
+    const xAxis = svg.append("g");
+    const xScale = linear().domain([0, cernoPlotData.rankedGenes.length]).range([xPad, svgWidth - rightPad]);
+    const yScale = linear().domain([100, 0]).range([topPad, svgHeight - yPad]);
+    yAxis.attr("transform", `translate(${xPad},0)`);
+    xAxis.attr("transform", `translate(0,${svgHeight - yPad})`);
+    svg.append("text").text("Gene list").attr("fill", "black").attr("text-anchor", "start").attr("transform", `translate(${xScale(cernoPlotData.rankedGenes.length / 3)},${svgHeight - yPad + 2 * topPad})`);
+    svg.append("text").text("Percentage of gene set").attr("fill", "black").attr("text-anchor", "middle").attr("y", xPad / 2).attr("x", -svgWidth / 2.5).attr("transform", "rotate(-90)");
+    let fontSize = 30;
+    const title = svg.append("text").text(cernoPlotData.genesetName).attr("fill", "black").attr("text-anchor", "start").attr("font-size", `${fontSize}px`).attr("transform", `translate(${xPad},${topPad / 2})`);
+    let titleBox = title.node().getBBox();
+    while (titleBox.width > svgWidth - xPad || titleBox.height > topPad * 3.5 / 5) {
+      fontSize -= 1;
+      title.node().setAttribute("font-size", `${fontSize}px`);
+      titleBox = title.node().getBBox();
+    }
+    if (typeof cernoPlotData.auc === "number") {
+      const aucPos = cernoPlotData.auc >= 0.5 ? `${xScale(cernoPlotData.rankedGenes.length * 3 / 3.5)},${svgHeight - yPad * 1.5}` : `${xScale(cernoPlotData.rankedGenes.length * 0.8 / 4.5)},${svgHeight - yPad * 3}`;
+      svg.append("text").text(`AUC=${roundValueAuto(cernoPlotData.auc)}`).attr("fill", "black").attr("text-anchor", "middle").attr("transform", `translate(${aucPos})`);
+    }
+    axisstyle({
+      axis: yAxis.call(axisLeft(yScale)),
+      color: "black",
+      showline: true,
+      fontsize: "10"
+    });
+    axisstyle({
+      axis: xAxis.call(axisBottom(xScale)),
+      color: "black",
+      showline: true,
+      fontsize: "10"
+    });
+    const hitGenes = new Set(cernoPlotData.leadingEdgeGenes);
+    const yIncrement = 100 / Math.max(hitGenes.size, 1);
+    const lines = svg.append("g");
+    let yIter = 100;
+    for (let index = 0; index < cernoPlotData.rankedGenes.length; index++) {
+      const rankedGene = cernoPlotData.rankedGenes[index];
+      const yOld = yIter;
+      if (hitGenes.has(rankedGene.gene)) {
+        yIter -= yIncrement;
+        lines.append("line").style("stroke", "red").attr("x1", xScale(index)).attr("y1", svgHeight).attr("x2", xScale(index)).attr("y2", svgHeight - yPad + 2.5 * topPad);
+      }
+      lines.append("line").style("stroke", "red").attr("x1", xScale(index)).attr("y1", yScale(100 - yOld)).attr("x2", xScale(index + 1)).attr("y2", yScale(100 - yIter));
+    }
+  }
+};
+
+// plots/gsea/GSEA.ts
+var GSEA = class _GSEA extends PlotBase {
+  static {
+    this.type = "gsea";
+  }
+  constructor(opts, api) {
+    super(opts, api);
+    this.type = _GSEA.type;
+    this.components = {
+      controls: {}
+    };
+    const controlsDiv = typeof opts.controls == "object" ? opts.controls : opts.holder.append("div").style("display", "inline-block");
+    const main = opts.holder.append("div").style("display", "inline-block");
+    const actionsDiv = main.append("div").attr("data-testid", "sjpp-gsea-actions").style("margin", "10px").style("text-align", "left");
+    const loadingDiv = main.append("div").attr("data-testid", "sjpp-gsea-loading").style("text-align", "center").style("display", "none").style("margin", "10px").style("text-align", "left").text("Loading...");
+    const holder = main.append("div").style("margin-left", "50px").style("display", "inline-block").attr("data-testid", "sjpp-gsea-holder");
+    const detailsDiv = main.append("div").attr("data-testid", "sjpp-gsea-details").style("display", "inline-block").style("vertical-align", "top").style("margin-top", "50px");
+    const tableDiv = main.append("div").style("margin", "10px").attr("data-testid", "sjpp-gsea-results-table");
+    this.dom = {
+      holder,
+      header: opts.header,
+      actionsDiv,
+      loadingDiv,
+      controlsDiv,
+      detailsDiv,
+      tableDiv
+    };
+    this.testEnabled = JSON.parse(sessionStorage.getItem("optionalFeatures") || "{}")?.gsea_test;
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) throw new Error(`No plot with id='${this.id}' found`);
+    const parentConfig = appState.plots.find((p) => p.id === this.parentId);
+    const termfilter = getCombinedTermFilter(appState, config.filter || parentConfig?.filter);
+    return {
+      config,
+      termfilter,
+      genome: appState.vocab.genome,
+      dslabel: appState.vocab.dslabel
+    };
+  }
+  async init(appState) {
+    const state = this.getState(appState);
+    const config = structuredClone(state.config);
+    this.model = new GSEAModel(this);
+    validateConfigByTermType(config);
+    if (!isValidGseaParams(config.gsea_params)) {
+      this.gsea_params = await this.model.getGseaParams(config.gsea_params, state, config);
+    } else {
+      this.gsea_params = config.gsea_params;
+    }
+    await setControls(this.dom.controlsDiv, this);
+    this.viewModel = new GSEAViewModel(this);
+    this.view = new GSEAView(this);
+    this.view.initRender();
+  }
+  async main() {
+    const state = structuredClone(this.state);
+    if (state.config.chartType != this.type && state.config.childType != this.type) return;
+    if (this.dom.header) {
+      const geneCount = this.gsea_params.genes_length ?? this.gsea_params.genes?.length ?? 0;
+      this.dom.header.html(
+        geneCount + ' genes <span style="font-size:.8em;opacity:.7">GENE SET ENRICHMENT ANALYSIS</span>'
+      );
+    }
+    if (this.imageUrl) URL.revokeObjectURL(this.imageUrl);
+    this.imageUrl = null;
+    await this.viewModel.processData();
+    this.view.update();
+  }
+};
+var gseaInit = getCompInit(GSEA);
+var componentInit = gseaInit;
+async function getPlotConfig(opts, app) {
+  if (!opts.termType) throw new Error("No termType provided [gsea getPlotConfig()]");
+  try {
+    const config = {
+      gsea_params: {
+        genome: app.opts.state.vocab.genome
+      },
+      //idea for fixing nav button
+      //samplelst: { groups: app.opts.state.groups}
+      settings: {
+        gsea: getDefaultGseaSettings(opts.overrides, opts)
+      }
+    };
+    copyMerge(config, opts);
+    validateConfigByTermType(config);
+    return config;
+  } catch (e) {
+    throw `${e} [gsea getPlotConfig()]`;
+  }
+}
+function validateConfigByTermType(config) {
+  if (!config.gsea_params) config.gsea_params = {};
+  if (config.termType === PROTEOME_DAP) {
+    if (!config.proteomeDetails) throw new Error("No proteomeDetails provided for DAP GSEA");
+    config.gsea_params.dapParams = config.proteomeDetails;
+  } else if (config.termType === SINGLECELL_CELLTYPE) {
+    if (!config.sample || !config.termId || !config.categoryName)
+      throw new Error("Missing sample, termId, or categoryName for single cell cluster GSEA");
+  }
+}
+function makeChartBtnMenu(holder, chartsInstance) {
+  chartsInstance.prepPlot({
+    config: {
+      chartType: "gsea"
+    }
+  });
+}
+export {
+  GSEA,
+  componentInit,
+  getPlotConfig,
+  gseaInit,
+  makeChartBtnMenu
+};
+//# sourceMappingURL=GSEA-KXQBR3HH.js.map