@sjcrh/proteinpaint-client 2.207.0 → 2.207.1

package/dist/chunk-OIJ6GRVS.js

@@ -0,0 +1,134 @@
+import {
+  addGeneSearchbox,
+  isoformSelect,
+  pickCollectionFraction,
+  sayerror
+} from "./chunk-PC4MFDHP.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import {
+  dofetch3
+} from "./chunk-52QHIKH2.js";
+import {
+  ISOFORM_EXPRESSION,
+  getColors
+} from "./chunk-RUBZCKIX.js";
+
+// termdb/handlers/isoformExpression.ts
+var SearchHandler = class {
+  constructor() {
+    this.currentGene = null;
+  }
+  init(opts) {
+    this.callback = opts.callback;
+    this.app = opts.app;
+    this.termCollectionSelectionMode = opts.termCollectionSelectionMode;
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    this.dom = {
+      errDiv: holder.append("div").style("margin", "5px 0px").style("display", "none")
+    };
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: opts.genomeObj,
+      row: holder,
+      searchOnly: "gene",
+      callback: async () => {
+        try {
+          this.dom.errDiv.style("display", "none");
+          if (!geneSearch.geneSymbol) throw new Error("No gene selected");
+          if (geneSearch.geneSymbol === this.currentGene) return;
+          this.currentGene = geneSearch.geneSymbol;
+          if (this.dom.isoformDiv) this.dom.isoformDiv.remove();
+          this.dom.isoformDiv = holder.append("div");
+          await this.showIsoforms(geneSearch.geneSymbol, opts.genomeObj);
+        } catch (e) {
+          this.dom.errDiv.style("display", "block");
+          sayerror(this.dom.errDiv, "Error: " + (e instanceof Error ? e.message : String(e)));
+        }
+      }
+    });
+  }
+  async showIsoforms(gene, genomeObj) {
+    if (!gene) throw new Error("No gene selected");
+    const data = await dofetch3("genelookup", { body: { genome: genomeObj.name, input: gene, deep: 1 } });
+    if (!data.gmlst?.length) throw new Error(`No isoforms found for ${gene}`);
+    const enstCandidates = data.gmlst.filter((gm) => gm.isoform?.startsWith("ENST"));
+    if (enstCandidates.length === 0) throw new Error(`No Ensembl transcript isoforms found for ${gene}`);
+    const { available } = await dofetch3("termdb/isoformAvailability", {
+      body: {
+        genome: genomeObj.name,
+        dslabel: this.app.vocabApi.vocab.dslabel,
+        isoforms: enstCandidates.map((gm) => gm.isoform)
+      }
+    });
+    const availableSet = new Set(available || []);
+    const enstModels = enstCandidates.filter((gm) => availableSet.has(gm.isoform));
+    if (enstModels.length === 0) throw new Error(`No isoforms with data found for ${gene}`);
+    if (gene !== this.currentGene) return;
+    const div = this.dom.isoformDiv;
+    div.append("div").style("margin-bottom", "8px").style("opacity", 0.65).text(`${gene} \u2014 select isoform(s):`);
+    isoformSelect({
+      holder: div,
+      allgm: enstModels,
+      multiSelect: true,
+      // a single checked isoform yields an individual term, 2+ yield a collection
+      getSubmitLabel: (selectedCount) => selectedCount === 1 ? "Select One Isoform" : `Create Collection (${selectedCount})`,
+      onMultiSelect: (selected) => {
+        if (selected.length === 1) {
+          this.selectIsoform(selected[0].isoform, gene);
+        } else {
+          this.selectCollection(selected, gene);
+        }
+      }
+    });
+  }
+  getUnit() {
+    return this.app.vocabApi.termdbConfig.queries.isoformExpression?.unit || "TPM";
+  }
+  selectIsoform(isoform, gene) {
+    const name = `${isoform} ${this.getUnit()}`;
+    this.callback({ isoform, gene, name, type: ISOFORM_EXPRESSION });
+  }
+  selectCollection(gms, gene) {
+    const unit = this.getUnit();
+    const termlst = gms.map((gm) => ({
+      id: gm.isoform,
+      name: gm.isoform,
+      type: ISOFORM_EXPRESSION,
+      isoform: gm.isoform
+    }));
+    const colorScale = getColors(termlst.length);
+    const term = {
+      type: "termCollection",
+      isCustom: true,
+      memberType: "numeric",
+      name: `${gene} Isoforms (${unit})`,
+      termlst,
+      propsByTermId: Object.fromEntries(termlst.map((term2) => [term2.id, { color: colorScale(term2.id) }])),
+      isleaf: true
+    };
+    if (this.termCollectionSelectionMode === "fraction") {
+      if (!this.dom?.isoformDiv) throw new Error("isoform result holder is missing");
+      this.dom.fractionDiv?.remove();
+      this.dom.fractionDiv = this.dom.isoformDiv.append("div").style("margin-top", "10px");
+      pickCollectionFraction({
+        holder: this.dom.fractionDiv,
+        term,
+        callback: (tw) => this.callback(tw)
+      });
+      return;
+    }
+    this.callback(term);
+  }
+};
+function filterIsoforms(gmlst, availableItems) {
+  const itemSet = new Set(availableItems);
+  return gmlst.filter((gm) => gm.isoform?.startsWith("ENST") && (itemSet.size === 0 || itemSet.has(gm.isoform)));
+}
+
+export {
+  SearchHandler,
+  filterIsoforms
+};
+//# sourceMappingURL=chunk-OIJ6GRVS.js.map

package/dist/chunk-ONVIVITY.js

@@ -0,0 +1,203 @@
+import {
+  tkt
+} from "./chunk-PC4MFDHP.js";
+import {
+  stratinput
+} from "./chunk-PF4DSFDR.js";
+import {
+  stratify_default
+} from "./chunk-4OLM3KSB.js";
+
+// src/vcf.tkconvert.js
+function vcf2dstk(arg) {
+  const ds = {
+    id2vcf: {},
+    label: arg.name || "Unnamed VCF file"
+  };
+  let vcfobj;
+  if (arg.file) {
+    const id = Math.random().toString();
+    vcfobj = {
+      file: arg.file,
+      indexURL: arg.indexURL,
+      vcfid: id
+    };
+    ds.id2vcf[id] = vcfobj;
+  } else if (arg.url) {
+    const id = Math.random().toString();
+    vcfobj = {
+      url: arg.url,
+      indexURL: arg.indexURL,
+      vcfid: id
+    };
+    ds.id2vcf[id] = vcfobj;
+  } else {
+    return ["no .file or .url"];
+  }
+  vcfobj.headernotloaded = true;
+  if (arg.samplenamemap) {
+    vcfobj.samplenamemap = arg.samplenamemap;
+  }
+  if (arg.variant2img) {
+    if (!arg.variant2img.path) return [".path missing from .variant2img{}"];
+  }
+  const tk = {
+    type: tkt.ds,
+    // to be loaded by loadvcftk() as a custom track, rather than "/dsdata" for official ds
+    isvcf: true,
+    name: ds.label,
+    ds,
+    populationfrequencyfilter: arg.populationfrequencyfilter,
+    vcfinfofilter: arg.vcfinfofilter,
+    itemlabelname: arg.itemlabelname,
+    viewrangeupperlimit: arg.viewrangeupperlimit,
+    variant2img: arg.variant2img,
+    axisheight: arg.axisheight
+  };
+  if (arg.url4variant) {
+    const err = check_url4variant(arg.url4variant);
+    if (err) return [".url4variant error: " + err];
+    tk.url4variant = arg.url4variant;
+  }
+  if (arg.button4variant) {
+    const err = check_button4variant(arg.button4variant);
+    if (err) return [".button4variant error: " + err];
+    tk.button4variant = arg.button4variant;
+  }
+  if (arg.sampleannotation) {
+    const sn = arg.sampleannotation;
+    if (!sn.annotation) return [".annotation{} missing from .sampleannotation"];
+    if (sn.levels) {
+      if (!Array.isArray(sn.levels)) return [".sampleannotation.levels should be array"];
+      const lst = [];
+      for (const sample in sn.annotation) {
+        const o = { sample_name: sample };
+        for (const k in sn.annotation[sample]) {
+          o[k] = sn.annotation[sample][k];
+        }
+        lst.push(o);
+      }
+      const nodes = stratinput(lst, sn.levels);
+      sn.root = stratify_default()(nodes);
+      sn.root.sum((i) => i.value);
+    }
+    if (sn.variantsunburst) {
+      if (!sn.levels) return [".levels missing when .variantsunburst is on from .sampleannotation"];
+    }
+    tk.ds.cohort = sn;
+  }
+  if (arg.vcfcohorttrack) {
+    if (!arg.vcfcohorttrack.file && !arg.vcfcohorttrack.url) return ["no .file or .url provided from .vcfcohorttrack"];
+    tk.ds.vcfcohorttrack = arg.vcfcohorttrack;
+  }
+  if (arg.germline2dvafplot) {
+    if (!arg.germline2dvafplot.individualkey) return [".individualkey missing from germline2dvafplot"];
+    if (!arg.germline2dvafplot.sampletypekey) return [".sampletypekey missing from germline2dvafplot"];
+    if (!arg.germline2dvafplot.xsampletype) return [".xsampletype missing from germline2dvafplot"];
+    if (!arg.germline2dvafplot.yleftsampletype) return [".yleftsampletype missing from germline2dvafplot"];
+    if (arg.germline2dvafplot.yrightsampletype) {
+      if (arg.germline2dvafplot.yrightsampletype == arg.germline2dvafplot.yleftsampletype)
+        return [".yrightsampletype should not be same as yleftsampletype"];
+    }
+    tk.ds.germline2dvafplot = arg.germline2dvafplot;
+  }
+  if (arg.vaf2coverageplot) {
+    if (arg.vaf2coverageplot.categorykey) {
+      if (!arg.vaf2coverageplot.categories)
+        return [".categories missing when .categorykey is in use for .vaf2coverageplot"];
+    }
+    tk.ds.vaf2coverageplot = arg.vaf2coverageplot;
+  }
+  if (arg.genotype2boxplot) {
+    if (arg.genotype2boxplot.boxplotvaluekey) {
+    } else if (arg.genotype2boxplot.sampleannotationkey) {
+      if (!tk.ds.cohort) return ["sampleannotation missing when using genotype2boxplot.sampleannotationkey"];
+      if (!tk.ds.cohort.annotation)
+        return ["sampleannotation.annotation missing when using genotype2boxplot.sampleannotationkey"];
+      let found = false;
+      for (const k in tk.ds.cohort.annotation) {
+        if (arg.genotype2boxplot.sampleannotationkey in tk.ds.cohort.annotation[k]) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return [arg.genotype2boxplot.sampleannotationkey + " not found in any sample annotation"];
+    } else {
+      return ["incomplete instruction for genotype2boxplot"];
+    }
+    tk.ds.genotype2boxplot = arg.genotype2boxplot;
+  }
+  if (arg.discardsymbolicallele) {
+    tk.ds.discardsymbolicallele = true;
+  }
+  if (arg.samplebynumericvalue) {
+    if (!arg.samplebynumericvalue.attrkey) return ["attrkey missing from samplebynumericvalue"];
+    if (!tk.ds.cohort) return ["sampleannotation missing when using samplebynumericvalue"];
+    if (!tk.ds.cohort.annotation) return ["sampleannotation.annotation missing when using samplebynumericvalue"];
+    let found = false;
+    for (const k in tk.ds.cohort.annotation) {
+      if (Number.isFinite(tk.ds.cohort.annotation[k][arg.samplebynumericvalue.attrkey])) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) return ["samplebynumericvalue.attrkey not found in any sample annotation"];
+    tk.ds.samplebynumericvalue = arg.samplebynumericvalue;
+  }
+  {
+    const g = arg.genotypebynumericvalue;
+    if (g) {
+      if (!g.refref) return [tk.name + ": refref missing from genotypebynumericvalue"];
+      if (!g.refalt) return [tk.name + ": refalt missing from genotypebynumericvalue"];
+      if (!g.altalt) return [tk.name + ": altalt missing from genotypebynumericvalue"];
+      if (!g.refref.infokey) return [tk.name + ": refref.infokey missing from genotypebynumericvalue"];
+      if (!g.refalt.infokey) return [tk.name + ": refalt.infokey missing from genotypebynumericvalue"];
+      if (!g.altalt.infokey) return [tk.name + ": altalt.infokey missing from genotypebynumericvalue"];
+      if (g.refref.genotypeCountInfokey || g.refalt.genotypeCountInfokey || g.altalt.genotypeCountInfokey) {
+        if (!g.refref.genotypeCountInfokey)
+          return [tk.name + ": genotypeCountInfokey missing from genotypebynumericvalue.refref{}"];
+        if (!g.refalt.genotypeCountInfokey)
+          return [tk.name + ": genotypeCountInfokey missing from genotypebynumericvalue.refalt{}"];
+        if (!g.altalt.genotypeCountInfokey)
+          return [tk.name + ": genotypeCountInfokey missing from genotypebynumericvalue.altalt{}"];
+      }
+      tk.ds.genotypebynumericvalue = g;
+    }
+  }
+  if (arg.pointdown) {
+    tk.aboveprotein = false;
+  }
+  if (arg.dstk_novcferror) {
+    tk.dstk_novcferror = true;
+  }
+  return [null, tk];
+}
+function check_url4variant(lst) {
+  if (!Array.isArray(lst)) return "value is not an array";
+  for (const item of lst) {
+    if (!item.makeurl) {
+      return ".makeurl missing";
+    }
+    if (typeof item.makeurl != "function") {
+      return ".makeurl must be a function";
+    }
+  }
+  return false;
+}
+function check_button4variant(lst) {
+  if (!Array.isArray(lst)) return "value is not an array";
+  for (const item of lst) {
+    if (!item.makebutton) {
+      return ".makebutton missing";
+    }
+    if (typeof item.makebutton != "function") {
+      return ".makebutton must be a function";
+    }
+  }
+  return false;
+}
+
+export {
+  vcf2dstk
+};
+//# sourceMappingURL=chunk-ONVIVITY.js.map

package/dist/chunk-OQX3HO46.js

@@ -0,0 +1,56 @@
+import {
+  sayerror
+} from "./chunk-PC4MFDHP.js";
+import {
+  TermTypeGroups
+} from "./chunk-RUBZCKIX.js";
+
+// termdb/handlers/singleCellCellType.ts
+var SearchHandler = class {
+  async init(opts) {
+    this.validateOpts(opts);
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    const scctTerms = opts.app.vocabApi.termdbConfig?.termType2terms?.[TermTypeGroups.SINGLECELL_CELLTYPE];
+    if (!scctTerms) {
+      sayerror(
+        holder,
+        `termType2terms[${TermTypeGroups.SINGLECELL_CELLTYPE}]:[] is required in termdbConfig for singleCellCellType handler`
+      );
+      return;
+    }
+    const usecaseConfig = opts.usecase?.specialCase?.config;
+    const plots = usecaseConfig?.sample?.plots;
+    const isMeta = usecaseConfig?.sample?.isMetaResult;
+    const filtered = plots ? scctTerms.filter((t) => plots.includes(t.plot)) : usecaseConfig?.name ? scctTerms.filter((t) => t.plot === usecaseConfig.name) : scctTerms;
+    const getLabel = (t) => isMeta || plots?.length == 1 ? t.name : `${t.name} (${t.plot})`;
+    const filteredTerms = new Set(
+      plots || !usecaseConfig?.name ? filtered.map((t) => ({ ...t, label: getLabel(t) })) : filtered
+    );
+    for (const t of Array.from(filteredTerms)) {
+      holder.append("div").classed("termdiv", true).style("padding", "0px 5px").append("div").classed("termlabel sja_filter_tag_btn sja_tree_click_term ts_pill", true).style("display", "inline-block").style("padding", "5px 8px").style("margin", "1px 0px").style("border-radius", "6px").text(t.label || t.name).on("click", () => {
+        const term = this.makeTerm(t, usecaseConfig);
+        this.callback(term);
+      });
+    }
+  }
+  makeTerm(_term, usecaseConfig) {
+    const term = { ..._term };
+    if (!term.sample && usecaseConfig?.sample) term.sample = usecaseConfig.sample;
+    return term;
+  }
+  validateOpts(opts) {
+    if (opts.callback == null) throw new Error("callback is required");
+    if (opts.app == null) throw new Error("app is required");
+    if (opts.holder == null) throw new Error("holder is required");
+    if (opts.usecase == null) throw new Error("usecase is required");
+    if (!opts.app.vocabApi.termdbConfig?.termType2terms)
+      throw new Error("termType2terms is required in termdbConfig for singleCellCellType handler");
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-OQX3HO46.js.map

package/dist/chunk-OYLGAFFY.js

@@ -0,0 +1,31 @@
+import {
+  IN_frame,
+  OUT_frame
+} from "./chunk-RUBZCKIX.js";
+
+// src/spliceevent.exonskip.getdefault.js
+function spliceevent_exonskip_getdefault_default(events) {
+  let evt2showidx = 0;
+  for (let i = 1; i < events.length; i++) {
+    const e = events[i];
+    const e2show = events[evt2showidx];
+    if (e.isskipexon && e2show.isaltexon) {
+      evt2showidx = i;
+      continue;
+    }
+    if (e.frame == OUT_frame && e2show.framenocheck) {
+      evt2showidx = i;
+      continue;
+    }
+    if (e.frame == IN_frame && e2show.frame != IN_frame) {
+      evt2showidx = i;
+      continue;
+    }
+  }
+  return evt2showidx;
+}
+
+export {
+  spliceevent_exonskip_getdefault_default
+};
+//# sourceMappingURL=chunk-OYLGAFFY.js.map

package/dist/chunk-P7DIIYCX.js

@@ -0,0 +1,197 @@
+import {
+  DATermTypes
+} from "./chunk-PC4MFDHP.js";
+import {
+  dofetch3
+} from "./chunk-52QHIKH2.js";
+import {
+  rgb
+} from "./chunk-Q5RDQNIT.js";
+
+// plots/volcano/colors.ts
+function getGroupColors(config) {
+  const groups = config?.samplelst?.groups;
+  const termValues = config?.tw?.term?.values;
+  const rawDown = termValues?.[groups?.[0]?.name]?.color || "red";
+  const rawUp = termValues?.[groups?.[1]?.name]?.color || "blue";
+  return {
+    controlColor: toHex(rawDown, "red"),
+    caseColor: toHex(rawUp, "blue")
+  };
+}
+function toHex(color, fallback) {
+  const c = rgb(color || fallback);
+  return c.displayable() ? c.formatHex() : rgb(fallback).formatHex();
+}
+
+// plots/volcano/model/VolcanoModel.ts
+var VolcanoModel = class {
+  /** TODO: This model is used in both the volcano and gsea.
+   * In the future, create base model in DA and use specific
+   * classes for the volcano and gsea. */
+  constructor(plot, termType) {
+    this.plot = plot;
+    this.app = plot.app;
+    this.termType = termType;
+  }
+  /** May use mapper instead as more termTypes are added */
+  async getData(config, settings) {
+    this.config = config;
+    this.settings = settings;
+    if (this.termType === DATermTypes.GENE_EXPRESSION) {
+      const body = await this.getGERequestBody();
+      const response = await dofetch3("termdb/DE", { body, signal: this.plot.api?.getAbortSignal() });
+      if (response && !response.error) response.daRequest = body;
+      return response;
+    }
+    if (this.termType === DATermTypes.DNA_METHYLATION) {
+      const body = await this.getDMRequestBody();
+      const response = await dofetch3("termdb/diffMeth", { body, signal: this.plot.api?.getAbortSignal() });
+      if (response && !response.error) response.daRequest = body;
+      return response;
+    }
+    if (this.termType === DATermTypes.SINGLECELL_CELLTYPE) {
+      const body = await this.getSCCTRequestBody();
+      return await dofetch3("termdb/singlecellDEgenes", { body, signal: this.plot.api?.getAbortSignal() });
+    }
+    if (this.termType === DATermTypes.PROTEOME_DAP) {
+      const body = this.getDapRequestBody();
+      return await dofetch3("termdb/dapVolcano", { body, signal: this.plot.api?.getAbortSignal() });
+    }
+    if (this.termType === DATermTypes.SINGLECELL_GENE_EXPRESSION) {
+    }
+    throw new Error(`Volcano plot does not support route for termType='${this.termType}'`);
+  }
+  //Gene expression
+  async getGERequestBody() {
+    await this.getOtherSamples(this.config.samplelst);
+    const state = this.app.getState();
+    const body = {
+      kind: "DE",
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      method: this.settings.method,
+      min_count: this.settings.minCount,
+      min_total_count: this.settings.minTotalCount,
+      samplelst: this.config.samplelst,
+      filter: state.termfilter.filter,
+      filter0: state.termfilter.filter0,
+      cpm_cutoff: this.settings.cpmCutoff,
+      volcanoRender: this.getVolcanoRender()
+    };
+    const pseudobulk = this.config.tw?.pseudobulk;
+    if (pseudobulk) body.pseudobulk = pseudobulk;
+    this.addConfounderTw(body);
+    return body;
+  }
+  //DNA methylation
+  async getDMRequestBody() {
+    await this.getOtherSamples(this.config.samplelst);
+    const state = this.app.getState();
+    const body = {
+      kind: "DM",
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      samplelst: this.config.samplelst,
+      filter: state.termfilter.filter,
+      filter0: state.termfilter.filter0,
+      min_samples_per_group: this.settings.minSamplesPerGroup,
+      exclude_sex_chr: this.settings.excludeSexChr,
+      /* Omitted rather than sent as 'promoter' when it is the default, so a request
+      from a promoter-only dataset is byte-identical to what this client sent before
+      the element picker existed. The server resolves an absent element_type to
+      'promoter'. This does NOT preserve cache keys -- the key object gained the
+      field server-side, so every pre-existing dm/ entry is orphaned on deploy
+      regardless of what the client sends. */
+      ...this.settings.elementType && this.settings.elementType != "promoter" ? { element_type: this.settings.elementType } : {},
+      volcanoRender: this.getVolcanoRender()
+    };
+    this.addConfounderTw(body);
+    return body;
+  }
+  /** Parameters telling the server to run the `volcano` Rust renderer and return a
+   * volcano PNG + top-significant rows instead of the full dot list. */
+  getVolcanoRender() {
+    const dotRadius = Math.max(this.settings.width, this.settings.height) / 80;
+    const { caseColor, controlColor } = getGroupColors(this.config);
+    const useDeltaBeta = this.termType === DATermTypes.DNA_METHYLATION && this.settings.xAxis == "delta_beta";
+    return {
+      significanceThresholds: {
+        pValueCutoff: this.settings.pValue,
+        pValueType: this.settings.pValueType,
+        foldChangeCutoff: useDeltaBeta ? this.settings.deltaBetaCutoff : this.settings.foldChangeCutoff
+      },
+      ...useDeltaBeta ? { xField: "delta_beta" } : {},
+      pixelWidth: this.settings.width,
+      pixelHeight: this.settings.height,
+      colorSignificant: toHex(this.settings.defaultSignColor, "red"),
+      colorSignificantUp: caseColor,
+      colorSignificantDown: controlColor,
+      colorNonsignificant: toHex(this.settings.defaultNonSignColor, "black"),
+      dotRadius,
+      maxInteractiveDots: this.settings.maxInteractiveDots,
+      // Render the PNG at device-pixel resolution so it stays sharp on
+      // retina screens. The server reports the plot extent in CSS-space,
+      // so SVG overlay coords are unaffected.
+      //
+      // Oversample by 2× so the PNG also stays sharp when the user
+      // *zooms in after* the initial render (the captured DPR is frozen
+      // at fetch time — bigger headroom = more tolerable post-render
+      // zoom before pixelation appears). The server clamp keeps the
+      // bitmap memory bounded.
+      devicePixelRatio: (typeof window !== "undefined" ? window.devicePixelRatio : 1) * 2
+    };
+  }
+  //This is a workaround until the server can accept an arr of confounder tws
+  addConfounderTw(body) {
+    const confounders = this.config?.confounderTws;
+    if (confounders?.length) {
+      body.tw = this.config.confounderTws[0];
+      if (confounders.length > 1) body.tw2 = this.config.confounderTws[1];
+    }
+  }
+  //Single cell cell type
+  getSCCTRequestBody() {
+    const body = {
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      sample: this.config.sample,
+      termId: this.config.termId,
+      categoryName: this.config.categoryName,
+      volcanoRender: this.getVolcanoRender()
+    };
+    return body;
+  }
+  getDapRequestBody() {
+    const { organism, assay, cohort } = this.config.proteomeDetails;
+    return {
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      organism,
+      assay,
+      cohort,
+      volcanoRender: this.getVolcanoRender()
+    };
+  }
+  /** retrieve the sampleId/sampleName for samples in
+   * the "others" group instead of using {in: false} */
+  async getOtherSamples(samplelst) {
+    const othersSamplesGroup = samplelst.groups.find((g) => !g.in);
+    if (!othersSamplesGroup) return;
+    const state = this.app.getState();
+    const samplesGroup = samplelst.groups.find((g) => g.in);
+    othersSamplesGroup.values = [];
+    for (const s of await this.plot.vocabApi.getFilteredSampleList(state.termfilter.filter)) {
+      if (!samplesGroup.values.some((i) => i.sampleId == s.id)) {
+        othersSamplesGroup.values.push({ sampleId: s.id, sample: s.name });
+      }
+    }
+    othersSamplesGroup.in = true;
+  }
+};
+
+export {
+  getGroupColors,
+  VolcanoModel
+};
+//# sourceMappingURL=chunk-P7DIIYCX.js.map