@sjcrh/proteinpaint-client 2.211.0 → 2.212.0

package/dist/chunk-XL4N3H32.js

@@ -0,0 +1,276 @@
+import {
+  parsesample
+} from "./chunk-RMUK3TLD.js";
+import {
+  dtfusionrna,
+  dtsv,
+  mclassfusionrna,
+  mclasssv
+} from "./chunk-57Z4VYLM.js";
+
+// ../shared/utils/dist/src/bulk.sv.js
+function parseheader(line, flag, issv) {
+  const header = line.toLowerCase().split("	");
+  if (header.length <= 1) return "invalid file header for fusions";
+  const htry = (...lst) => {
+    for (const a of lst) {
+      const j = header.indexOf(a);
+      if (j != -1) return j;
+    }
+    return -1;
+  };
+  let i = htry("gene_a", "gene1", "genea");
+  if (i == -1) return "gene_a missing from header";
+  header[i] = "gene1";
+  i = htry("gene_b", "gene2", "geneb");
+  if (i == -1) return "gene_b missing from header";
+  header[i] = "gene2";
+  i = htry("chr_a", "chr1", "chra");
+  if (i == -1) return "chr_a missing from header";
+  header[i] = "chr1";
+  i = htry("chr_b", "chr2", "chrb");
+  if (i == -1) return "chr_b missing from header";
+  header[i] = "chr2";
+  i = htry("pos_a", "position_a", "position1", "posa");
+  if (i == -1) return "pos_a missing from header";
+  header[i] = "position1";
+  i = htry("pos_b", "position_b", "position2", "posb");
+  if (i == -1) return "pos_b missing from header";
+  header[i] = "position2";
+  i = htry("isoform_a", "refseq_a", "refseq1", "isoform1", "sv_refseqa");
+  if (i == -1) return "isoform_a missing from header";
+  header[i] = "isoform1";
+  i = htry("isoform_b", "refseq_b", "refseq2", "isoform2", "sv_refseqb");
+  if (i == -1) return "isoform_b missing from header";
+  header[i] = "isoform2";
+  i = htry("strand_a", "orta");
+  if (i == -1) return "strand_a missing from header";
+  header[i] = "strand1";
+  i = htry("strand_b", "ortb");
+  if (i == -1) return "strand_b missing from header";
+  header[i] = "strand2";
+  i = htry("sample", "sample_name", "tumor_sample_barcode");
+  if (i != -1) header[i] = "sample";
+  i = htry("patient", "donor", "target_case_id");
+  if (i != -1) header[i] = "patient";
+  i = htry("sampletype", "sample type", "sample_type");
+  if (i != -1) header[i] = "sampletype";
+  i = htry("disease");
+  if (i != -1) header[i] = "disease";
+  i = htry("origin");
+  if (i != -1) header[i] = "origin";
+  if (issv) {
+    flag.sv.loaded = true;
+    flag.sv.header = header;
+  } else {
+    flag.fusion.loaded = true;
+    flag.fusion.header = header;
+  }
+  return false;
+}
+function parseline(i, line, flag, issv) {
+  if (line == "" || line[0] == "#") return;
+  const lst = line.split("	");
+  const m = {};
+  const header = issv ? flag.sv.header : flag.fusion.header;
+  const badlines = issv ? flag.sv.badlines : flag.fusion.badlines;
+  for (let j = 0; j < header.length; j++) {
+    m[header[j]] = lst[j];
+  }
+  if (!m.chr1) {
+    badlines.push([i, "missing chr1", lst]);
+    return;
+  }
+  if (m.chr1.toLowerCase().indexOf("chr") != 0) {
+    m.chr1 = "chr" + m.chr1;
+  }
+  if (!m.chr2) {
+    badlines.push([i, "missing chr2", lst]);
+    return;
+  }
+  if (m.chr2.toLowerCase().indexOf("chr") != 0) {
+    m.chr2 = "chr" + m.chr2;
+  }
+  let v = m.position1;
+  if (!v) {
+    badlines.push([i, "missing position1", lst]);
+    return;
+  }
+  let v2 = Number.parseInt(v);
+  if (Number.isNaN(v2) || v2 <= 0) {
+    badlines.push([i, "invalid value for position1", lst]);
+    return;
+  }
+  m.position1 = v2;
+  v = m.position2;
+  if (!v) {
+    badlines.push([i, "missing position2", lst]);
+    return;
+  }
+  v2 = Number.parseInt(v);
+  if (Number.isNaN(v2) || v2 <= 0) {
+    badlines.push([i, "invalid value for position2", lst]);
+    return;
+  }
+  m.position2 = v2;
+  if (parsesample(m, flag, i, lst)) {
+    return;
+  }
+  if (m.isoform1 && m.isoform1.indexOf(",") != -1) {
+    const lst2 = m.isoform1.split(",");
+    m.isoform1 = void 0;
+    for (const t of lst2) {
+      if (t != "") m.isoform1 = t;
+    }
+  }
+  if (m.isoform2 && m.isoform2.indexOf(",") != -1) {
+    const lst2 = m.isoform2.split(",");
+    m.isoform2 = void 0;
+    for (const t of lst2) {
+      if (t != "") m.isoform2 = t;
+    }
+  }
+  if (!m.gene1) {
+    m.isoform1 = void 0;
+  }
+  if (!m.gene2) {
+    m.isoform2 = void 0;
+  }
+  if (m.gene1) {
+    flag.good++;
+    const m2 = {
+      dt: issv ? dtsv : dtfusionrna,
+      class: issv ? mclasssv : mclassfusionrna,
+      isoform: m.isoform1,
+      mname: m.gene2 || m.chr2,
+      sample: m.sample,
+      patient: m.patient,
+      sampletype: m.sampletype,
+      origin: m.origin,
+      disease: m.disease,
+      pairlst: [
+        {
+          a: {
+            name: m.gene1,
+            isoform: m.isoform1,
+            strand: m.strand1,
+            chr: m.chr1,
+            position: m.position1
+          },
+          b: {
+            name: m.gene2,
+            isoform: m.isoform2,
+            strand: m.strand2,
+            chr: m.chr2,
+            position: m.position2
+          }
+        }
+      ]
+    };
+    const n = flag.geneToUpper ? m.gene1.toUpperCase() : m.gene1;
+    if (!flag.data[n]) {
+      flag.data[n] = [];
+    }
+    flag.data[n].push(m2);
+  }
+  if (m.gene2 && m.gene2 != m.gene1) {
+    flag.good++;
+    const m2 = {
+      dt: issv ? dtsv : dtfusionrna,
+      class: issv ? mclasssv : mclassfusionrna,
+      isoform: m.isoform2,
+      mname: m.gene1 || m.chr1,
+      sample: m.sample,
+      patient: m.patient,
+      sampletype: m.sampletype,
+      origin: m.origin,
+      disease: m.disease,
+      pairlst: [
+        {
+          a: {
+            name: m.gene1,
+            isoform: m.isoform1,
+            strand: m.strand1,
+            chr: m.chr1,
+            position: m.position1
+          },
+          b: {
+            name: m.gene2,
+            isoform: m.isoform2,
+            strand: m.strand2,
+            chr: m.chr2,
+            position: m.position2
+          }
+        }
+      ]
+    };
+    const n = flag.geneToUpper ? m.gene2.toUpperCase() : m.gene2;
+    if (!flag.data[n]) {
+      flag.data[n] = [];
+    }
+    flag.data[n].push(m2);
+  }
+}
+function duplicate(m) {
+  const n = {};
+  for (const k in m) {
+    if (k == "pairlst") continue;
+    const v = m[k];
+    const type = typeof v;
+    if (type == "object") {
+      continue;
+    }
+    n[k] = v;
+  }
+  if (m.pairlst) {
+    n.pairlst = [];
+    for (const pair of m.pairlst) {
+      const p = {};
+      for (const k in pair) {
+        if (k == "a" || k == "b" || k == "interstitial") {
+          continue;
+        }
+        p[k] = pair[k];
+      }
+      if (pair.a) {
+        p.a = {};
+        for (const k in pair.a) {
+          const v = pair.a[k];
+          if (typeof v == "object") {
+            continue;
+          }
+          p.a[k] = v;
+        }
+      }
+      if (pair.b) {
+        p.b = {};
+        for (const k in pair.b) {
+          const v = pair.b[k];
+          if (typeof v == "object") {
+            continue;
+          }
+          p.b[k] = v;
+        }
+      }
+      if (pair.interstitial) {
+        p.interstitial = {};
+        for (const k in pair.interstitial) {
+          const v = pair.interstitial[k];
+          if (typeof v == "object") {
+            continue;
+          }
+          p.interstitial[k] = v;
+        }
+      }
+      n.pairlst.push(p);
+    }
+  }
+  return n;
+}
+
+export {
+  parseheader,
+  parseline,
+  duplicate
+};
+//# sourceMappingURL=chunk-XL4N3H32.js.map

package/dist/chunk-XNKLJMGF.js

@@ -0,0 +1,123 @@
+import {
+  pickCollectionFraction,
+  renderTable
+} from "./chunk-VHDYIOWU.js";
+
+// termdb/handlers/termCollection.ts
+var SearchHandler = class {
+  async init(opts) {
+    this.callback = opts.callback;
+    this.app = opts.app;
+    opts.holder.style("display", "");
+    const termlst = opts.details.termlst ?? [];
+    const memberType = opts.details.memberType || opts.details.type;
+    if (opts.termCollectionSelectionMode === "fraction" && memberType === "numeric") {
+      pickCollectionFraction({
+        holder: opts.holder,
+        term: makeTerm(opts.details, termlst, opts.usecase),
+        callback: (tw) => opts.callback(tw)
+      });
+      return;
+    }
+    const tableDiv = opts.holder.append("div");
+    renderTable({
+      columns: [{ label: "VARIABLES" }],
+      rows: termlst.map((t) => {
+        return [{ value: t.name }];
+      }),
+      div: tableDiv,
+      maxWidth: "30vw",
+      maxHeight: "40vh",
+      // the button is disabled while the selection cannot be submitted
+      noButtonCallback: () => updateSelectBtn(),
+      striped: false,
+      showHeader: true,
+      //false,
+      selectAll: true,
+      columnButtons: void 0,
+      //Leave until table.js is typed
+      buttons: void 0
+    });
+    let categoryTable;
+    let ckSource = [];
+    if (opts.details.categoryKeys) {
+      ckSource = opts.details.categoryKeys;
+      const categoryDiv = opts.holder.append("div").style("margin-top", "15px");
+      const values = opts.details.termlst[0].values || {};
+      categoryTable = categoryDiv.append("div");
+      renderTable({
+        columns: [{ label: "CATEGORIES" }],
+        rows: ckSource.map((ck) => {
+          return [{ value: values[ck.key]?.label ?? ck.key, checked: ck.shown }];
+        }),
+        div: categoryTable,
+        maxWidth: "30vw",
+        maxHeight: "40vh",
+        noButtonCallback: () => updateSelectBtn(),
+        striped: false,
+        showHeader: true,
+        //false,
+        selectAll: true,
+        columnButtons: void 0,
+        //Leave until table.js is typed
+        buttons: void 0
+      });
+    }
+    function getRowChecks(div) {
+      const trs = div.select("table").select("tbody").node().querySelectorAll("tr");
+      return [...trs].map((tr) => tr.querySelectorAll("td")[1]?.querySelector("input")?.checked === true);
+    }
+    function getSelectedTermlst() {
+      const checked = getRowChecks(tableDiv);
+      return termlst.filter((term, i) => checked[i]);
+    }
+    function getCategoryKeys() {
+      if (!categoryTable) return void 0;
+      const checked = getRowChecks(categoryTable);
+      return ckSource.map((ck, i) => ({ key: ck.key, shown: checked[i] }));
+    }
+    function getSelectionError() {
+      if (getSelectedTermlst().length < 2) return "Select at least two variables.";
+      if (getCategoryKeys()?.every((ck) => !ck.shown)) return "Select at least one category.";
+      return void 0;
+    }
+    function updateSelectBtn() {
+      if (!selectBtn) return;
+      const error = getSelectionError();
+      selectBtn.property("disabled", Boolean(error)).attr("title", error || null);
+    }
+    const selectBtn = opts.holder.append("div").style("float", "right").style("padding", "6px 20px").append("button").attr("data-testid", "sjpp-term-collection-select").text("Select").on("click", () => {
+      opts.callback({
+        // makeTerm() extracts propsByTermId (color, etc) for the selected terms
+        ...makeTerm(opts.details, getSelectedTermlst(), opts.usecase),
+        categoryKeys: getCategoryKeys()
+      });
+    });
+    updateSelectBtn();
+  }
+};
+function makeTerm(details, termlst, usecase) {
+  const propsByTermId = {};
+  if (details.propsByTermId) {
+    for (const term of termlst) {
+      if (details.propsByTermId[term.id]) propsByTermId[term.id] = details.propsByTermId[term.id];
+    }
+  }
+  return {
+    type: "termCollection",
+    termIds: termlst.map((term) => term.id),
+    termlst,
+    name: details.name,
+    valueTransform: details.valueTransformByPlots?.[usecase?.target],
+    // memberType = ds.cohort.termdb.termCollections[].type for client code
+    memberType: details.memberType || details.type,
+    categoryKeys: details.categoryKeys,
+    isleaf: true,
+    propsByTermId
+  };
+}
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-XNKLJMGF.js.map

package/dist/chunk-XZCRYWVL.js

@@ -0,0 +1,243 @@
+import {
+  keyupEnter
+} from "./chunk-VHDYIOWU.js";
+import {
+  get_bin_label,
+  get_bin_range_equation
+} from "./chunk-RMUK3TLD.js";
+import {
+  toStoredUnit,
+  toUserUnit
+} from "./chunk-W5J3LTYS.js";
+
+// termsetting/handlers/NumCustomBinEditor.ts
+var NumCustomBinEditor = class {
+  constructor(editHandler) {
+    this.dom = {};
+    this.editHandler = editHandler;
+    this.opts = editHandler.opts;
+    this.tw = editHandler.tw;
+    this.termsetting = editHandler.termsetting;
+  }
+  /* bin boundaries are stored in the term's own unit but entered and shown in its user-facing one.
+  both are identity functions unless the term declares valueConversion{} */
+  toDisplay(v) {
+    return toUserUnit(v, this.tw.term);
+  }
+  toStored(v) {
+    return toStoredUnit(v, this.tw.term);
+  }
+  async render(div) {
+    this.tw = this.editHandler.tw;
+    const isRemounting = !!this.dom.inputsDiv && this.editHandler.dom.binsDiv?.node().contains(this.dom.inputsDiv.node());
+    if (!isRemounting) this.q = this.getDefaultQ();
+    await this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+    if (isRemounting) return;
+    if (this.dom.inputsDiv) {
+      this.dom.inputsDiv.remove();
+      delete this.dom.inputsDiv;
+    }
+    this.dom.inputsDiv = div.append("div").style("display", "flex").style("width", "100%");
+    this.renderCustomBinInputs();
+  }
+  getBoundaryOpts() {
+    return {
+      values: this.q.lst.slice(1).map((bin) => ({ x: this.toDisplay(bin.startunbounded ? bin.stop : bin.start), isDraggable: true })),
+      // the dragged value arrives in display units, matching what the textarea holds
+      callback: (d, value) => {
+        const boundaryValues = this.q.lst.slice(1).map((d2) => "start" in d2 ? this.toDisplay(d2.start) : "");
+        boundaryValues[d.index] = value;
+        this.dom.customBinBoundaryInput.property("value", boundaryValues.join("\n"));
+        this.handleInputChange("drag");
+        return 0;
+      }
+    };
+  }
+  getDefaultQ() {
+    if (this.tw.q.mode == "discrete" && this.tw.q.type == "custom-bin") {
+      const copy = JSON.parse(JSON.stringify(this.tw.q));
+      copy.lst.forEach((bin) => {
+        if (!bin.label) bin.label = get_bin_label(bin, this.tw.q, this.tw.term.valueConversion);
+        bin.range = get_bin_range_equation(bin, this.tw.q, this.tw.term.valueConversion);
+      });
+      return copy;
+    }
+    const { min, max } = this.editHandler.handler.density_data;
+    const defaultCustomBoundary = (
+      /* when no sample is annotated by this term,
+      minvalue and maxvalue are both null
+      setting defaultCustomBoundary to arbitrary "0" will allow existing UI to work
+      but remains to be evaluated if is really okay to use 0
+      */
+      !Number.isFinite(min) || !Number.isFinite(max) ? 0 : (
+        // minvalue and maxvalue is valid number
+        max != min ? min + (max - min) / 2 : max
+      )
+    );
+    const firstBin = {
+      startunbounded: true,
+      startinclusive: false,
+      stopinclusive: false,
+      stop: +defaultCustomBoundary.toFixed(this.tw.term.type == "integer" ? 0 : 2)
+    };
+    const lastBin = {
+      stopunbounded: true,
+      startinclusive: true,
+      stopinclusive: false,
+      start: +defaultCustomBoundary.toFixed(this.tw.term.type == "integer" ? 0 : 2)
+    };
+    return {
+      mode: "discrete",
+      type: "custom-bin",
+      lst: [
+        // Type '{ label: any; range: any; startunbounded: boolean; startinclusive: boolean; stopinclusive: boolean; stop: number; }' is not assignable to type 'StartUnboundedBin | FullyBoundedBin'.
+        // Property 'start' is missing in type '{ label: any; range: any; startunbounded: boolean; startinclusive: boolean; stopinclusive: boolean; stop: number; }' but required in type 'FullyBoundedBin'.
+        {
+          ...firstBin,
+          label: get_bin_label(firstBin, this.tw.q, this.tw.term.valueConversion),
+          range: get_bin_range_equation(firstBin, this.tw.q, this.tw.term.valueConversion)
+        },
+        {
+          ...lastBin,
+          label: get_bin_label(lastBin, this.tw.q, this.tw.term.valueConversion),
+          range: get_bin_range_equation(lastBin, this.tw.q, this.tw.term.valueConversion)
+        }
+        //satisfies StopUnboundedBin
+      ]
+    };
+  }
+  /******************* Functions for Numerical Custom size bins *******************/
+  renderCustomBinInputs() {
+    const q = this.q;
+    const boundaryDiv = this.dom.inputsDiv.append("div").style("margin-right", "20px");
+    this.dom.rangeAndLabelDiv = this.dom.inputsDiv.append("div");
+    boundaryDiv.append("div").style("margin-bottom", "5px").style("color", "rgb(136, 136, 136)").text("Bin boundaries");
+    this.dom.customBinBoundaryInput = boundaryDiv.append("textarea").style("width", "100px").style("height", "70px").text(
+      q.lst.slice(1).map((d) => "start" in d ? this.toDisplay(d.start) : "").join("\n")
+    ).on("change", () => this.handleInputChange()).on("keyup", async (event) => {
+      if (!keyupEnter(event) && event.key != 8 && event.key != "Enter") return;
+      if (!this.dom.inputsDiv.selectAll("input").node().value) return;
+      this.handleInputChange();
+    });
+    boundaryDiv.append("div").style("font-size", ".6em").style("margin-left", "1px").style("color", "#858585").html("Enter numeric values </br>seperated by ENTER");
+    this.renderBoundaryInputDivs();
+  }
+  renderBoundaryInputDivs() {
+    const data = this.q.lst;
+    const holder = this.dom.rangeAndLabelDiv;
+    holder.selectAll("*").remove();
+    const grid = holder.append("div").style("display", "grid").style("grid-template-columns", "auto auto").style("column-gap", "20px").style("align-items", "center");
+    grid.append("div").style("margin-bottom", "3px").style("color", "rgb(136, 136, 136)").text("Range");
+    grid.append("div").style("margin-bottom", "3px").style("color", "rgb(136, 136, 136)").text("Bin label");
+    for (const d of data) {
+      grid.append("div").attr("name", "range").html(d.range);
+      grid.append("div").append("input").attr("type", "text").style("margin", "2px 0px").property("value", d.label).on("change", function() {
+        d.label = this.value;
+      });
+    }
+    this.dom.customBinRanges = this.dom.inputsDiv.selectAll('div[name="range"]').data(data);
+    this.dom.customBinLabelInput = this.dom.inputsDiv.selectAll("input").data(data);
+  }
+  handleInputChange(eventType = "") {
+    const self = this.tw;
+    const inputs = this.dom.inputsDiv.selectAll("input");
+    inputs.property("value", "");
+    const data = this.processCustomBinInputs();
+    if (data == void 0) {
+      return;
+    }
+    if (self.q.hiddenValues) this.tw.q.hiddenValues = self.q.hiddenValues;
+    if (this.binsChanged(data, this.q.lst)) {
+      this.q.lst = data;
+    }
+    this.renderBoundaryInputDivs();
+    if (eventType != "drag") this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+  }
+  binsChanged(data, qlst) {
+    if (data.length != qlst.length) return true;
+    if (Object.keys(data[0]).length !== Object.keys(qlst[0]).length) return true;
+    for (const [i, bin] of qlst.entries()) {
+      for (const k of Object.keys(bin)) {
+        if (bin[k] && bin[k] !== data[i][k]) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  processCustomBinInputs() {
+    const self = this.termsetting;
+    const startinclusive = this.editHandler.boundaryInclusion == "startinclusive";
+    const stopinclusive = this.editHandler.boundaryInclusion == "stopinclusive";
+    const inputs = this.dom.inputsDiv.node().querySelectorAll("input");
+    const inputData = this.dom.customBinBoundaryInput.property("value").split("\n").filter((d) => d != "" && !isNaN(d));
+    const trackBins = new Set(inputData);
+    if (!trackBins.size) return this.tw.q.lst;
+    const sortedBins = Array.from(trackBins).map((v) => this.toStored(Number(v))).sort((a, b) => a - b);
+    const data = [
+      // first bin: StartUnbounded type
+      {
+        startunbounded: true,
+        stop: sortedBins[0],
+        startinclusive: false,
+        stopinclusive,
+        label: inputs[0].value
+      }
+    ];
+    if (!data[0].label) data[0].label = get_bin_label(data[0], self.q, self.term.valueConversion);
+    if (!data[0].range) data[0].range = get_bin_range_equation(data[0], self.q, self.term.valueConversion);
+    for (const [i, d] of sortedBins.entries()) {
+      let bin;
+      const label = inputs[i + 1]?.value || "";
+      if (i !== trackBins.size - 1) {
+        bin = {
+          start: +d,
+          startinclusive,
+          stopinclusive,
+          stop: sortedBins[i + 1],
+          label
+          //range: ''
+        };
+      } else {
+        bin = {
+          start: +d,
+          startinclusive,
+          stopinclusive: false,
+          stopunbounded: true,
+          label
+          //range: ''
+        };
+      }
+      if (bin.label === "" || bin.label === void 0) bin.label = get_bin_label(bin, self.q, self.term.valueConversion);
+      if (bin.range === "" || bin.range === void 0)
+        bin.range = get_bin_range_equation(bin, self.q, self.term.valueConversion);
+      data.push(bin);
+    }
+    return data;
+  }
+  getEditedQ(destroyDom = true) {
+    const lst = this.processCustomBinInputs();
+    if (destroyDom) {
+      for (const name of Object.keys(this.dom)) {
+        this.dom[name].remove();
+        delete this.dom[name];
+      }
+    }
+    return {
+      mode: "discrete",
+      type: "custom-bin",
+      lst
+    };
+  }
+  undoEdits() {
+    this.q = this.getDefaultQ();
+    this.dom.inputsDiv.selectAll("*").remove();
+    this.renderCustomBinInputs();
+    this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+  }
+};
+
+export {
+  NumCustomBinEditor
+};
+//# sourceMappingURL=chunk-XZCRYWVL.js.map

package/dist/chunk-Y4MV62JA.js

@@ -0,0 +1,56 @@
+import {
+  sayerror
+} from "./chunk-VHDYIOWU.js";
+import {
+  TermTypeGroups
+} from "./chunk-57Z4VYLM.js";
+
+// termdb/handlers/singleCellNumericValue.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 scnvTerms = opts.app.vocabApi.termdbConfig?.termType2terms?.[TermTypeGroups.SINGLECELL_NUMERIC_VALUE];
+    if (!scnvTerms?.length) {
+      sayerror(
+        holder,
+        `termType2terms[${TermTypeGroups.SINGLECELL_NUMERIC_VALUE}]:[] is required in termdbConfig for singleCellNumericValue handler`
+      );
+      return;
+    }
+    const usecaseConfig = opts.usecase?.specialCase?.config;
+    const plots = usecaseConfig?.sample?.plots;
+    const isMeta = usecaseConfig?.sample?.isMetaResult;
+    const filtered = plots ? scnvTerms.filter((t) => plots.includes(t.plot)) : usecaseConfig?.name ? scnvTerms.filter((t) => t.plot === usecaseConfig.name) : scnvTerms;
+    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 singleCellNumericValue handler");
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-Y4MV62JA.js.map