@sjcrh/proteinpaint-client 2.220.0 → 2.221.0

package/dist/geneExpClustering-SIAC7CMA.js

@@ -0,0 +1,240 @@
+import {
+  appInit
+} from "./chunk-MWARRQT4.js";
+import "./chunk-5ZYANHGX.js";
+import "./chunk-4E2F26CC.js";
+import "./chunk-FE5TCBIT.js";
+import {
+  fillTermWrapper,
+  vocabInit
+} from "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-WXSMUSU7.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import {
+  TermTypes
+} from "./chunk-WJLRU5OF.js";
+import {
+  copyMerge
+} from "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// gdc/geneExpClustering.js
+async function init(arg, holder, genomes) {
+  try {
+    const useGenome = arg.genome || "hg38";
+    const useDslabel = arg.dslabel || "GDC";
+    const genome = genomes[useGenome];
+    if (!genome) throw useGenome + " missing";
+    const settings = arg.settings || {};
+    if (typeof settings != "object") throw "arg.settings{} not object";
+    if (!settings.hierCluster) settings.hierCluster = {};
+    if (typeof settings.hierCluster != "object") throw "arg.settings.hierCluster{} not object";
+    if (!Number.isInteger(settings.hierCluster.maxGenes)) settings.hierCluster.maxGenes = 1e3;
+    if (arg.filter0 && typeof arg.filter0 != "object") throw "arg.filter0 not object";
+    const vocabApi = await vocabInit({
+      state: { vocab: { genome: useGenome, dslabel: useDslabel } }
+    });
+    vocabApi.getTermdbConfig();
+    const plotAppApi = await appInit({
+      debug: arg.debug,
+      holder: select_default(arg.holder).select(".sja_root_holder"),
+      genome,
+      state: {
+        genome: useGenome,
+        dslabel: useDslabel,
+        termfilter: { filter0: arg.filter0 },
+        plots: [
+          // Initialize with a geneset component, in case the genes lst is empty.
+          // This will be replaced with the actual matrix/hierCluster app once
+          // a valid geneset is selected.
+          {
+            chartType: "geneset",
+            toolName: "Gene Expression Clustering",
+            settings: {
+              maxGenes: settings.hierCluster.maxGenes
+            }
+          }
+        ]
+      },
+      app: arg.opts?.app || {},
+      hierCluster: copyMerge(
+        {
+          reactsTo(action) {
+            if (action.type.startsWith("plot_")) return action.id === this.id;
+            if (action.type.startsWith("filter")) return true;
+            if (action.type == "app_refresh") return true;
+          },
+          callbacks: {
+            "firstRender.gdcHierCluster": async (hierClusterApi2) => {
+              hierClusterApi2.on("firstRender.gdcHierCluster", null);
+              if (!genesetCompApi) return;
+              plotAppApi.dispatch({
+                type: "plot_delete",
+                id: genesetCompApi.id
+              });
+              genesetCompApi = void 0;
+            }
+          }
+        },
+        arg.opts?.hierCluster || {}
+      ),
+      matrix: arg.opts?.matrix || {},
+      geneset: {
+        mode: "geneExpression",
+        // consistent with GeneSetEdit
+        genome,
+        genes: arg.genes,
+        showEditUI: arg.opts?.geneset?.showEditUI,
+        reactsTo(action) {
+          if (action.type.startsWith("plot_")) return action.id === this.id;
+          if (action.type.startsWith("filter")) return true;
+          if (action.type == "app_refresh") return true;
+        },
+        showWaitMessage(div) {
+          div.style("margin", "20px");
+          div.append("div").text("Loading genes that are top variably expressed in current cohort...");
+          div.append("div").style("font-size", ".8em").html(`
+						Only up to 1000 cases with gene expression data will be used to select genes.<br>
+						Genes are selected from all protein-coding genes, may take over 1 minute.
+					`);
+        },
+        async callback(_genesetCompApi, twlst) {
+          if (!_genesetCompApi) return;
+          genesetCompApi = _genesetCompApi;
+          if (!hierClusterApi) {
+            const plotConfig = plotAppApi.getState().plots.find((p) => p.chartType == "hierCluster");
+            if (plotConfig) hierClusterApi = plotAppApi.getComponents(`plots.${plotConfig.id}`);
+          }
+          const termgroups = [
+            {
+              name: "Gene Expression",
+              type: "hierCluster",
+              lst: twlst
+            },
+            ...arg.termgroups || []
+          ];
+          if (hierClusterApi) {
+            plotAppApi.dispatch({
+              type: "plot_edit",
+              id: hierClusterApi.id,
+              config: { termgroups }
+            });
+          } else {
+            plotAppApi.dispatch({
+              type: "plot_create",
+              config: {
+                chartType: "hierCluster",
+                // avoid making a dictionary request when there is no gene data;
+                // if there is gene data, then the arg.termgroups can be submitted and rehydrated on app/store.init()
+                termgroups,
+                divideBy: arg.divideBy || void 0,
+                // moved default settings to gdc.hg38.js termdb[chartType].settings
+                // but can still override in the runpp() argument
+                settings,
+                dataType: TermTypes.GENE_EXPRESSION
+              }
+            });
+          }
+        }
+      },
+      recover: {
+        undoHtml: "Undo",
+        redoHtml: "Redo",
+        resetHtml: "Restore",
+        hide(state) {
+          return state.plots[0]?.chartType != "hierCluster";
+        },
+        adjustTrackedState: (state) => {
+          const s = structuredClone(state);
+          delete s.termfilter.filter0;
+          if (s.plots) {
+            for (const plot of s.plots) {
+              if (!plot.termgroups) continue;
+              for (const grp of plot.termgroups) {
+                if (!grp.lst) continue;
+                for (const tw of grp.lst) {
+                  if (!tw?.term) continue;
+                  delete tw.term.category2samplecount;
+                  delete tw.term.values;
+                }
+              }
+            }
+          }
+          return s;
+        }
+      }
+    });
+    let hierClusterApi, genesetCompApi;
+    const api = {
+      type: "hierCluster",
+      update: async (_arg) => {
+        const plotConfig = plotAppApi.getState().plots.find((p) => p.chartType == "hierCluster");
+        if (!hierClusterApi) {
+          if (plotConfig) hierClusterApi = plotAppApi.getComponents(`plots.${plotConfig.id}`);
+        }
+        if (_arg.genes) {
+          const t0 = plotConfig.termgroups.find((g) => g.type == "hierCluster");
+          plotAppApi.dispatch({
+            type: "plot_edit",
+            id: hierClusterApi.id,
+            config: {
+              termgroups: [
+                {
+                  name: t0.name,
+                  type: "hierCluster",
+                  lst: await Promise.all(
+                    _arg.genes.map(async (g) => {
+                      return await fillTermWrapper(
+                        {
+                          term: { gene: g.gene, type: "geneExpression", name: g.gene }
+                        },
+                        vocabApi
+                      );
+                    })
+                  )
+                }
+              ]
+            }
+          });
+        } else if ("filter0" in _arg) {
+          plotAppApi.dispatch({
+            type: "filter_replace",
+            filter0: _arg.filter0
+          });
+        } else if (hierClusterApi) {
+          plotAppApi.dispatch({
+            type: "plot_edit",
+            id: hierClusterApi.id,
+            config: _arg
+          });
+        }
+      },
+      triggerAbort: (_) => plotAppApi.triggerAbort(_)
+    };
+    return api;
+  } catch (e) {
+    throw e;
+  }
+}
+export {
+  init
+};
+//# sourceMappingURL=geneExpClustering-SIAC7CMA.js.map

package/dist/geneExpression-P2TTZXN2.js

@@ -0,0 +1,29 @@
+import {
+  SearchHandler
+} from "./chunk-QNCE6EOK.js";
+import "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-WXSMUSU7.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import "./chunk-WJLRU5OF.js";
+import "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+export {
+  SearchHandler
+};
+//# sourceMappingURL=geneExpression-P2TTZXN2.js.map

package/dist/geneExpression.unit.spec-Q5D6XHUF.js

@@ -0,0 +1,151 @@
+import {
+  SearchHandler
+} from "./chunk-QNCE6EOK.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-WXSMUSU7.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import {
+  TermTypes
+} from "./chunk-WJLRU5OF.js";
+import "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// termdb/handlers/test/geneExpression.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+(0, import_tape.default)("\n", function(test) {
+  test.comment("-***- termdb/handlers/geneExpression -***-");
+  test.end();
+});
+(0, import_tape.default)("selectGene() should throw when no gene is selected", async (test) => {
+  const handler = new SearchHandler();
+  handler.app = { vocabApi: { termdbConfig: { queries: { geneExpression: {} } } } };
+  handler.callback = () => {
+  };
+  try {
+    await handler.selectGene(void 0);
+    test.fail("Should throw when no gene is selected");
+  } catch (e) {
+    test.match(String(e), /No gene selected/, "Should throw expected message when gene is missing");
+  }
+  test.end();
+});
+(0, import_tape.default)("selectGene() should call callback with configured unit from termdbConfig", async (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {
+          geneExpression: { unit: "log2 TPM" }
+        }
+      }
+    }
+  };
+  handler.sampleTypeSelect = [
+    { property: (key) => key == "checked" ? true : 1 },
+    { property: (key) => key == "checked" ? false : 2 }
+  ];
+  await handler.selectGene({ geneSymbol: "TP53" });
+  test.deepEqual(selected?.sampleTypes, [1], "Should pass selected sampleTypes as array");
+  test.equal(selected?.gene, "TP53", "Should pass selected gene");
+  test.equal(selected?.name, "TP53 log2 TPM", "Should include configured unit in name");
+  test.equal(selected?.type, TermTypes.GENE_EXPRESSION, "Should set type to geneExpression");
+  test.end();
+});
+(0, import_tape.default)("selectGene() should label a selected sample-type subset", async (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: { geneExpression: { sampleTypes: [1, 2] } },
+        sampleTypes: {
+          1: { plural_name: "Primary tumors" },
+          2: { plural_name: "Relapses" }
+        }
+      }
+    }
+  };
+  handler.querySampleTypes = [1, 2];
+  handler.sampleTypeSelect = [
+    { property: (key) => key == "checked" ? false : 1 },
+    { property: (key) => key == "checked" ? true : 2 }
+  ];
+  await handler.selectGene({ geneSymbol: "TP53" });
+  test.equal(selected?.sampleTypeLabel, "Relapses", "Should label the selected sample-type subset");
+  test.equal(selected?.name, "TP53 Gene Expression", "Should preserve the gene expression term name");
+  test.end();
+});
+(0, import_tape.default)("selectGene() should use default unit when not configured", async (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {}
+      }
+    }
+  };
+  await handler.selectGene({ geneSymbol: "BRCA1" });
+  test.equal(selected?.sampleTypes, void 0, "Should include sampleTypes key with undefined value when not provided");
+  test.equal(selected?.gene, "BRCA1", "Should pass selected gene");
+  test.equal(selected?.name, "BRCA1 Gene Expression", "Should use default unit when config unit is not provided");
+  test.equal(selected?.type, TermTypes.GENE_EXPRESSION, "Should set type to geneExpression");
+  test.end();
+});
+(0, import_tape.default)("selectGene() should require at least one sample type when selector is rendered", async (test) => {
+  const handler = new SearchHandler();
+  let called = false;
+  let alertMsg = "";
+  const oldAlert = window.alert;
+  handler.callback = () => {
+    called = true;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {}
+      }
+    }
+  };
+  handler.sampleTypeSelect = [{ property: (key) => key == "checked" ? false : 1 }];
+  window.alert = (msg) => {
+    alertMsg = msg;
+  };
+  await handler.selectGene({ geneSymbol: "BRCA1" });
+  window.alert = oldAlert;
+  test.equal(called, false, "Should not call callback when no sample type is selected");
+  test.equal(alertMsg, "Please select at least one sample type.", "Should notify user to select sample type");
+  test.end();
+});
+//# sourceMappingURL=geneExpression.unit.spec-Q5D6XHUF.js.map

package/dist/geneORA-PKUIJKTL.js

@@ -0,0 +1,269 @@
+import {
+  controlsInit,
+  downloadTable,
+  newSandboxDiv,
+  renderTable,
+  table2col
+} from "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-WXSMUSU7.js";
+import {
+  Menu
+} from "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import {
+  dofetch3
+} from "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import "./chunk-WJLRU5OF.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import {
+  roundValueAuto
+} from "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/geneORA.js
+var tip = new Menu();
+var geneORA = class _geneORA {
+  static type = "geneORA";
+  constructor() {
+    this.type = _geneORA.type;
+  }
+  async init(opts) {
+    if (!this.opts.holder || !this.opts.header) {
+      const sandBox = newSandboxDiv(select_default(this.opts.holder.node().parentNode));
+      this.opts.header = sandBox.header;
+      this.opts.holder = sandBox.body;
+    }
+    const controlsDiv = this.opts.holder.append("div").style("display", "inline-block");
+    const mainDiv = this.opts.holder.append("div").style("display", "inline-block").style("margin-left", "50px");
+    const holder = mainDiv.append("div").style("display", "inline-block");
+    const detailsDiv = mainDiv.append("div").style("display", "inline-block").style("vertical-align", "top").style("margin-top", "50px");
+    const tableDiv = this.opts.holder.append("div").style("margin-left", "50px");
+    this.dom = {
+      holder,
+      header: this.opts.header,
+      controlsDiv,
+      detailsDiv,
+      tableDiv
+    };
+  }
+  async setControls() {
+    this.dom.controlsDiv.selectAll("*").remove();
+    const inputs = [
+      {
+        label: "P-value Filter Cutoff (Linear Scale)",
+        type: "number",
+        chartType: "geneORA",
+        settingsKey: "pvalue",
+        title: "P-value significance",
+        min: 0,
+        max: 1
+      },
+      {
+        label: "P-value Filter Type",
+        type: "radio",
+        chartType: "geneORA",
+        settingsKey: "adjusted_original_pvalue",
+        title: "Toggle between original and adjusted pvalues for volcano plot",
+        options: [
+          { label: "Adjusted", value: "adjusted" },
+          { label: "Original", value: "original" }
+        ]
+      },
+      {
+        label: "Gene Set Size Filter Cutoff",
+        type: "number",
+        chartType: "geneORA",
+        settingsKey: "gene_set_size_cutoff",
+        title: "Gene set size cutoff. Helps in filtering out large gene sets",
+        min: 0,
+        max: 2e4
+      },
+      {
+        label: "Filter Non-coding Genes",
+        type: "checkbox",
+        chartType: "geneORA",
+        settingsKey: "filter_non_coding_genes",
+        title: "Filter non-coding genes",
+        boxLabel: ""
+      }
+    ];
+    const geneSet = {
+      label: "Gene Set Group",
+      type: "dropdown",
+      chartType: "geneORA",
+      settingsKey: "pathway",
+      title: "Display table showing original and adjusted pvalues corresponding to each significant pathway",
+      boxLabel: ""
+    };
+    geneSet.options = this.app.opts.genome.termdbs.msigdb.analysisGenesetGroups;
+    if (!this.settings.pathway) {
+      this.settings.pathway = "-";
+    }
+    inputs.push(geneSet);
+    this.components = {
+      controls: await controlsInit({
+        app: this.app,
+        id: this.id,
+        holder: this.dom.controlsDiv,
+        inputs
+      })
+    };
+    this.components.controls.on("downloadClick.geneORA", () => {
+      downloadTable(this.gene_ora_table_rows, this.gene_ora_table_cols);
+    });
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) throw `No plot with id='${this.id}' found`;
+    return {
+      config
+    };
+  }
+  async main() {
+    this.config = JSON.parse(JSON.stringify(this.state.config));
+    this.settings = this.config.settings.geneORA;
+    await this.setControls();
+    this.dom.header.html(
+      this.config.geneORAparams.sample_genes.split(",").length + ' genes <span style="font-size:.8em;opacity:.7">GENE SET OVERREPRESENTATION ANALYSIS</span>'
+    );
+    render_geneORA(this);
+  }
+};
+async function render_geneORA(self) {
+  if (self.settings.pathway != "-") {
+    self.dom.detailsDiv.selectAll("*").remove();
+    self.dom.tableDiv.selectAll("*").remove();
+    self.config.geneORAparams.geneSetGroup = self.settings.pathway;
+    self.config.geneORAparams.filter_non_coding_genes = self.settings.filter_non_coding_genes;
+    const wait = self.dom.detailsDiv.append("div").text("Loading...");
+    let output;
+    try {
+      output = await rungeneORA(self.config.geneORAparams);
+      wait.remove();
+      if (output.error) {
+        throw output.error;
+      }
+    } catch (e) {
+      alert("Error: " + e);
+      return;
+    }
+    const table_stats = table2col({ holder: self.dom.detailsDiv });
+    const [t1, t2] = table_stats.addRow();
+    t2.style("text-align", "center").style("font-size", "0.8em").style("opacity", "0.8").text("COUNT");
+    const addStats = [
+      //{
+      //	label: 'Sample genes',
+      //	values: self.config.geneORAparams.sample_genes.split(',').length
+      //},
+      {
+        label: "Gene sets analyzed",
+        values: output.num_pathways
+      }
+    ];
+    if (self.config.geneORAparams.background_genes) {
+      addStats.push({
+        label: "Background genes",
+        values: self.config.geneORAparams.background_genes.split(",").length
+      });
+    }
+    for (const dataRow of addStats) {
+      const [td1, td2] = table_stats.addRow();
+      td1.text(dataRow.label);
+      td2.style("text-align", "end").text(dataRow.values);
+    }
+    self.gene_ora_table_cols = [
+      { label: "Gene set group" },
+      { label: "Original p-value (linear scale)" },
+      { label: "Adjusted p-value (linear scale)" },
+      { label: "Gene set size" },
+      { label: "Gene set hits" }
+    ];
+    self.gene_ora_table_rows = [];
+    for (const pathway of output.pathways) {
+      if (self.settings.adjusted_original_pvalue == "adjusted" && self.settings.pvalue >= pathway.p_value_adjusted && self.settings.gene_set_size_cutoff > pathway.gene_set_size) {
+        self.gene_ora_table_rows.push([
+          { value: pathway.pathway_name },
+          { value: roundValueAuto(pathway.p_value_original) },
+          { value: roundValueAuto(pathway.p_value_adjusted) },
+          { value: pathway.gene_set_size },
+          { value: pathway.gene_set_hits }
+        ]);
+      } else if (self.settings.adjusted_original_pvalue == "original" && self.settings.pvalue >= pathway.p_value_original && self.settings.gene_set_size_cutoff > pathway.gene_set_size) {
+        self.gene_ora_table_rows.push([
+          { value: pathway.pathway_name },
+          { value: roundValueAuto(pathway.p_value_original) },
+          { value: roundValueAuto(pathway.p_value_adjusted) },
+          { value: pathway.gene_set_size },
+          { value: pathway.gene_set_hits }
+        ]);
+      }
+    }
+    const d_ora = self.dom.tableDiv.append("div");
+    renderTable({
+      columns: self.gene_ora_table_cols,
+      rows: self.gene_ora_table_rows,
+      div: d_ora,
+      showLines: true,
+      maxHeight: "30vh",
+      resize: true
+    });
+  }
+}
+async function getPlotConfig(opts, app) {
+  try {
+    const config = {
+      //idea for fixing nav button
+      //samplelst: { groups: app.opts.state.groups}
+      settings: {
+        geneORA: {
+          pvalue: 0.05,
+          adjusted_original_pvalue: "adjusted",
+          pathway: void 0,
+          gene_set_size_cutoff: 2e3,
+          filter_non_coding_genes: true
+        },
+        controls: { isOpen: true }
+      }
+    };
+    return copyMerge(config, opts);
+  } catch (e) {
+    throw `${e} [geneORA getPlotConfig()]`;
+  }
+}
+var geneORAInit = getCompInit(geneORA);
+var componentInit = geneORAInit;
+function makeChartBtnMenu(holder, chartsInstance) {
+  chartsInstance.prepPlot({
+    config: {
+      chartType: "geneORA"
+    }
+  });
+}
+async function rungeneORA(body) {
+  return await dofetch3("genesetOverrepresentation", { body });
+}
+export {
+  componentInit,
+  geneORAInit,
+  getPlotConfig,
+  makeChartBtnMenu
+};
+//# sourceMappingURL=geneORA-PKUIJKTL.js.map