@sjcrh/proteinpaint-client 2.191.4 → 2.193.0

package/dist/chunk-CLN7ANNL.js

@@ -0,0 +1,216 @@
+import {
+  make_radios
+} from "./chunk-L7VDSIM7.js";
+import {
+  initBinConfig
+} from "./chunk-6G4YOMWW.js";
+import {
+  format
+} from "./chunk-SOTB4FRE.js";
+
+// termsetting/handlers/NumRegularBinEditor.ts
+var NumRegularBinEditor = class {
+  constructor(editHandler) {
+    this.dom = {};
+    this.editHandler = editHandler;
+    this.opts = editHandler.opts;
+    this.tw = editHandler.tw;
+    this.termsetting = editHandler.termsetting;
+  }
+  render(div) {
+    this.tw = this.editHandler.tw;
+    this.q = this.getDefaultQ();
+    this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+    if (this.dom.binsTable) {
+      if (this.editHandler.dom.binsDiv?.node().contains(this.dom.binsTable.node())) return;
+      else {
+        this.dom.binsTable.remove();
+        delete this.dom.binsTable;
+      }
+    }
+    const binsTable = div.append("table");
+    this.dom.binsTable = binsTable;
+    this.renderBinSizeInput(binsTable.append("tr"));
+    this.renderFirstBinInput(binsTable.append("tr"));
+    this.renderLastBinInputs(binsTable.append("tr"));
+  }
+  getDefaultQ() {
+    if (this.tw.q.type == "regular-bin") return JSON.parse(JSON.stringify(this.tw.q));
+    const t = this.tw.term;
+    const defaultQ = this.termsetting.opts.use_bins_less && t.bins?.less || t.bins?.default;
+    if (defaultQ) return JSON.parse(JSON.stringify(defaultQ));
+    const binConfig = initBinConfig(this.editHandler.handler.density_data);
+    return typeof binConfig == "string" ? JSON.parse(binConfig) : binConfig;
+  }
+  renderBinSizeInput(tr) {
+    const handler = this.editHandler.handler;
+    tr.append("td").style("margin", "5px").style("opacity", 0.5).text("Bin Size");
+    const { min, max } = handler.density_data;
+    const q = this.q;
+    const origBinSize = q.bin_size;
+    this.dom.bin_size_input = tr.append("td").append("input").attr("type", "number").attr("value", "rounding" in q ? format(q.rounding || ".0f")(q.bin_size) : q.bin_size).attr("data-testid", "sjpp-num-reg-bin-editor-size").style("margin-left", "15px").style("width", "100px").style("color", () => q.bin_size > Math.abs(max - min) ? "red" : "").on("change", (event) => {
+      const newValue = Number(event.target.value);
+      if (newValue <= 0) {
+        window.alert("Please enter non-negative bin size.");
+        event.target.value = origBinSize;
+        return;
+      }
+      if ((max - min) / newValue > 100) {
+        window.alert("Bin size too small. Try setting a bigger value.");
+        event.target.value = origBinSize;
+        return;
+      }
+      q.bin_size = newValue;
+      this.dom.bin_size_input.style("color", q.bin_size > max - min ? "red" : newValue != origBinSize ? "green" : "");
+      handler.density.setBinLines(this.getBoundaryOpts());
+    });
+  }
+  renderFirstBinInput(tr) {
+    const handler = this.editHandler.handler;
+    const q = this.q;
+    if (!q.first_bin) throw "missing q.first_bin";
+    tr.append("td").style("margin", "5px").style("opacity", 0.5).text("First Bin Stop");
+    const { min, max } = handler.density_data;
+    const origValue = q.first_bin.stop;
+    this.dom.first_stop_input = tr.append("td").append("input").attr("type", "number").property("value", origValue).style("width", "100px").style("margin-left", "15px").on("change", (event) => {
+      const newValue = Number(event.target.value);
+      if (newValue < min || newValue > max) {
+        window.alert("First bin stop value out of bound.");
+        event.target.value = origValue;
+        return;
+      }
+      this.q.first_bin.stop = newValue;
+      handler.density.setBinLines(this.getBoundaryOpts());
+    });
+    tr.append("td").append("div").style("font-size", ".6em").style("opacity", 0.5).style("display", handler.density.no_density_data ? "none" : "block").text("Indicated by left-most red line. Drag to change.");
+  }
+  renderLastBinInputs(tr) {
+    const handler = this.editHandler.handler;
+    const q = this.q;
+    const isAuto = !q.last_bin || !Number.isFinite(q.last_bin.start);
+    tr.append("td").style("padding-top", "4px").style("opacity", 0.5).style("vertical-align", "top").text("Last Bin Start");
+    const td1 = tr.append("td").style("padding-left", "15px").style("vertical-align", "top");
+    const radio_div = td1.append("div");
+    const radios = make_radios({
+      holder: radio_div,
+      options: [
+        { label: "Automatic", value: "auto", checked: isAuto },
+        { label: "Fixed", value: "fixed", checked: !isAuto }
+      ],
+      callback: (v) => {
+        if (v == "auto") {
+          delete q.last_bin;
+          edit_div.style("display", "none");
+          handler.density.setBinLines(this.getBoundaryOpts());
+          return;
+        }
+        edit_div.style("display", "inline-block");
+        if (this.dom.last_start_input.property("value") == "") {
+          this.dom.last_start_input.property("value", this.tw.q.last_bin?.start || handler.density_data.max);
+        }
+        this.setLastBinStart();
+      }
+    });
+    this.dom.fixed_radio = radios.inputs.filter((_, i) => i === 1);
+    const edit_div = tr.append("td").append("div").style("display", isAuto ? "none" : "inline-block");
+    this.dom.last_start_input = edit_div.append("input").attr("type", "number").property("value", q.last_bin?.start || "").style("width", "100px").on("change", () => this.setLastBinStart());
+    edit_div.append("div").style("font-size", ".6em").style("opacity", 0.5).style("display", handler.density.no_density_data ? "none" : "block").text("Indicated by right-most red line. Drag to change.");
+  }
+  setLastBinStart() {
+    const q = this.q;
+    const { max } = this.editHandler.handler.density_data;
+    const strInput = this.dom.last_start_input.property("value");
+    if (strInput === "") return;
+    const inputValue = Number(strInput);
+    if (q.first_bin && inputValue <= q.first_bin.stop) {
+      window.alert("Last bin start cannot be smaller than first bin stop.");
+      this.dom.last_start_input.property("value", max);
+      return;
+    }
+    if (inputValue > max) {
+      window.alert("Last bin start value out of bound.");
+      this.dom.last_start_input.property("value", max);
+      return;
+    }
+    if (q.last_bin) q.last_bin.start = inputValue;
+    else
+      q.last_bin = {
+        start: inputValue,
+        stopunbounded: true,
+        stopinclusive: false
+      };
+    this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+  }
+  getBoundaryOpts() {
+    const { min, max } = this.editHandler.handler.density_data;
+    const binLinesStop = this.q.last_bin?.start ?? max + Math.abs(this.q.first_bin.stop) - Math.min(min, 0);
+    const boundaryValues = [];
+    for (let i = this.q.first_bin.stop; i <= binLinesStop; i = i + this.q.bin_size) {
+      if (this.q.last_bin?.start === i) break;
+      if (i > binLinesStop) boundaryValues[boundaryValues.length - 1].isLastVisibleLine = true;
+      const isDraggable = i === this.q.first_bin.stop || i === this.q.bin_size - 1;
+      boundaryValues.push({ x: i, isDraggable, movesWithLineIndex: !isDraggable ? 0 : -1 });
+    }
+    if (this.q.last_bin) {
+      boundaryValues.push({
+        x: this.q.last_bin.start,
+        isDraggable: true,
+        isLastVisibleLine: true,
+        movesWithLineIndex: -1
+      });
+    }
+    return {
+      values: boundaryValues,
+      callback: (d, value) => {
+        if (d.index === 0) {
+          this.dom.first_stop_input.property("value", value);
+          this.q.first_bin.stop = value;
+        } else {
+          this.editHandler.handler.dom.last_start_input.property("value", value);
+          if (this.q.last_bin) this.q.last_bin.start = value;
+        }
+      }
+    };
+  }
+  getEditedQ(destroyDom = true) {
+    const bin_size = this.dom.bin_size_input.property("value");
+    const config = {
+      mode: "discrete",
+      type: "regular-bin",
+      startinclusive: this.editHandler.boundaryInclusion == "startinclusive",
+      stopinclusive: this.editHandler.boundaryInclusion == "stopinclusive",
+      bin_size: Number(bin_size),
+      first_bin: {
+        startunbounded: true,
+        stop: Number(this.dom.first_stop_input.property("value"))
+      },
+      rounding: bin_size.includes(".") && !bin_size.endsWith(".") ? `.${bin_size.split(".")[1].length}f` : ".0f"
+    };
+    if (this.dom.fixed_radio.property("checked")) {
+      config.last_bin = {
+        start: Number(this.dom.last_start_input.property("value")),
+        stopunbounded: true
+      };
+    }
+    if (destroyDom) {
+      for (const name of Object.keys(this.dom)) {
+        this.dom[name].remove();
+        delete this.dom[name];
+      }
+    }
+    return config;
+  }
+  undoEdits() {
+    this.q = this.getDefaultQ();
+    this.dom.binsTable.selectAll("*").remove();
+    this.renderBinSizeInput(this.dom.binsTable.append("tr"));
+    this.renderFirstBinInput(this.dom.binsTable.append("tr"));
+    this.renderLastBinInputs(this.dom.binsTable.append("tr"));
+    this.editHandler.handler.density.setBinLines(this.getBoundaryOpts());
+  }
+};
+
+export {
+  NumRegularBinEditor
+};
+//# sourceMappingURL=chunk-CLN7ANNL.js.map

package/dist/chunk-CLNSNNQU.js

@@ -0,0 +1,302 @@
+import {
+  appear2 as appear,
+  axisstyle,
+  bwSetting,
+  disappear2 as disappear,
+  makeNumericAxisConfig,
+  rgb2hex
+} from "./chunk-L7VDSIM7.js";
+import {
+  dofetch3
+} from "./chunk-6G4YOMWW.js";
+import {
+  axisLeft
+} from "./chunk-LOZEKOES.js";
+import {
+  format,
+  linear
+} from "./chunk-SOTB4FRE.js";
+
+// src/block.tk.bigwig.js
+function bigwigfromtemplate(tk, template) {
+  tk.scale = {};
+  if (template.scale) {
+    for (const k in template.scale) {
+      tk.scale[k] = template.scale[k];
+    }
+  } else {
+    tk.scale.auto = 1;
+  }
+  if (tk.normalize) {
+  } else {
+    tk.normalize = {
+      dividefactor: 1,
+      disable: 1
+    };
+  }
+  tk.barheight = template.height || 50;
+  tk.height_main = tk.toppad + tk.barheight + tk.bottompad;
+  if (!tk.ncolor) tk.ncolor = "#BD005E";
+  if (!tk.ncolor2) tk.ncolor2 = "#5E00BD";
+  if (!tk.pcolor) tk.pcolor = "#005EBD";
+  if (!tk.pcolor2) tk.pcolor2 = "#FA7D00";
+}
+function bigwigmaketk(tk, block) {
+  tk.img = tk.glider.append("image");
+  tk.tklabel.attr("y", tk.barheight / 2);
+  tk.leftaxis = tk.gleft.append("g");
+  tk.config_handle = block.maketkconfighandle(tk).on("click", () => {
+    tk.tkconfigtip.clear().showunder(tk.config_handle.node());
+    bigwigconfigpanel(tk, block, tk.tkconfigtip.d, () => bigwigload(tk, block));
+  });
+}
+async function bigwigload(tk, block) {
+  block.tkcloakon(tk);
+  const par = block.tkarg_q(tk);
+  if (tk.dotplotfactor) par.dotplotfactor = tk.dotplotfactor;
+  if (tk.bgcolor) par.bgcolor = tk.bgcolor;
+  tk.height_main = tk.toppad + tk.barheight + tk.bottompad;
+  tk.img.attr("width", block.width).attr("height", tk.barheight);
+  let errtext;
+  try {
+    let data;
+    if (tk.imgData) {
+      data = tk.imgData;
+    } else {
+      data = await dofetch3("tkbigwig", { method: "POST", body: JSON.stringify(par) });
+    }
+    if (data.error) throw data.error;
+    if (!data.src) throw "data.src missing";
+    tk.tklabel.transition().attr("y", tk.barheight / 2);
+    tk.img.attr("xlink:href", data.src);
+    if (data.minv != void 0) {
+      tk.scale.min = data.minv;
+    }
+    if (data.maxv != void 0) {
+      tk.scale.max = data.maxv;
+    }
+    tk.leftaxis.selectAll("*").remove();
+    if (data.nodata) {
+      throw "No data in view range";
+    }
+    const scale = linear().domain([tk.scale.min, tk.scale.max]).range([tk.barheight, 0]);
+    const axis = axisLeft().scale(scale).tickValues([tk.scale.min, tk.scale.max]);
+    if (tk.integer4axis) {
+      axis.tickFormat(format("d"));
+    }
+    axisstyle({
+      axis: tk.leftaxis.call(axis),
+      color: "black",
+      showline: true
+    });
+  } catch (err) {
+    tk.img.attr("width", 0).attr("height", 0);
+    if (err.stack) {
+      console.log(err.stack);
+    }
+    errtext = typeof err == "string" ? err : err.message;
+  } finally {
+    block.tkcloakoff(tk, { error: errtext });
+    block.block_setheight();
+    for (const panel of tk.subpanels) {
+      bigwigloadsubpanel(tk, block, panel);
+    }
+  }
+}
+async function bigwigloadsubpanel(tk, block, panel) {
+  block.tkcloakon_subpanel(panel);
+  const par = block.tkarg_q(tk);
+  if (tk.dotplotfactor) {
+    par.dotplotfactor = tk.dotplotfactor;
+  }
+  par.width = panel.width;
+  par.rglst = [
+    {
+      chr: panel.chr,
+      start: panel.start,
+      stop: panel.stop,
+      width: panel.width
+    }
+  ];
+  delete par.percentile;
+  delete par.autoscale;
+  panel.img.attr("width", panel.width).attr("height", tk.barheight);
+  let errtext;
+  try {
+    if (tk.imgData) throw "subpanel not supported by imgData yet";
+    const data = await dofetch3("tkbigwig", { method: "POST", body: JSON.stringify(par) });
+    if (data.error) throw data.error;
+    panel.img.attr("xlink:href", data.src);
+  } catch (err) {
+    panel.img.attr("width", 0).attr("height", 0);
+    if (err.stack) {
+      console.log(err.stack);
+    }
+    errtext = typeof err == "string" ? err : err.message;
+  } finally {
+    block.tkcloakoff_subpanel(panel, { error: errtext });
+  }
+}
+function bigwigconfigpanel(tk, block, holder, loader) {
+  const config = {
+    pcolor: {},
+    ncolor: {},
+    pcolor2: {},
+    ncolor2: {},
+    // .row
+    // .lab
+    dotplot: {},
+    // .row
+    dividefactor: {}
+  };
+  {
+    const row = holder.append("div").style("margin-bottom", "15px");
+    row.append("span").html("Height  ");
+    row.append("input").attr("size", 5).property("value", tk.barheight).on("keyup", (event) => {
+      if (event.code != "Enter") return;
+      const s = event.target.value;
+      if (s == "") return;
+      const v = Number.parseInt(s);
+      if (Number.isNaN(v) || v <= 1) {
+        alert("track height must be positive integer");
+        return;
+      }
+      tk.barheight = v;
+      loader(bwSetting.height);
+    });
+  }
+  config.pcolor.row = holder.append("div").style("margin-bottom", "15px");
+  config.pcolor.lab = config.pcolor.row.append("span").text("Positive value color").style("padding-right", "10px");
+  config.pcolor.row.append("input").attr("type", "color").property("value", rgb2hex(tk.pcolor)).on("change", (event) => {
+    tk.pcolor = event.target.value;
+    loader(bwSetting.pcolor);
+  });
+  config.ncolor.row = holder.append("div").style("margin-bottom", "15px");
+  config.ncolor.lab = config.ncolor.row.append("span").text("Negative value color").style("padding-right", "10px");
+  config.ncolor.row.append("input").attr("type", "color").property("value", rgb2hex(tk.ncolor)).on("change", (event) => {
+    tk.ncolor = event.target.value;
+    loader(bwSetting.ncolor);
+  });
+  if (!tk.scale.auto) {
+    config.pcolor2.row = holder.append("div").style("margin-bottom", "15px");
+    config.pcolor2.lab = config.pcolor2.row.append("span").html("&ge;Max color").style("padding-right", "10px");
+    config.pcolor2.row.append("input").attr("type", "color").property("value", rgb2hex(tk.pcolor2)).on("change", (event) => {
+      tk.pcolor2 = event.target.value;
+      loader(bwSetting.pcolor2);
+    });
+    config.ncolor2.row = holder.append("div").style("margin-bottom", "15px");
+    config.ncolor2.lab = config.ncolor2.row.append("span").html("&le;Min color").style("padding-right", "10px");
+    config.ncolor2.row.append("input").attr("type", "color").property("value", rgb2hex(tk.ncolor2)).on("change", (event) => {
+      tk.ncolor2 = event.target.value;
+      loader(bwSetting.ncolor2);
+    });
+  }
+  {
+    const setting = {};
+    if (tk.scale.auto) {
+      setting.auto = 1;
+    } else if (tk.scale.percentile) {
+      setting.percentile = tk.scale.percentile;
+    } else {
+      setting.fixed = { min: tk.scale.min, max: tk.scale.max };
+    }
+    makeNumericAxisConfig({
+      holder: holder.append("div").style("margin-bottom", "15px"),
+      setting,
+      callback: (s) => {
+        if (s.auto) {
+          tk.scale.auto = 1;
+          loader(bwSetting.autoscale);
+          return;
+        }
+        if (s.fixed) {
+          delete tk.scale.auto;
+          delete tk.scale.percentile;
+          tk.scale.max = s.fixed.max;
+          tk.scale.min = s.fixed.min;
+          loader(bwSetting.fixedscale);
+          return;
+        }
+        delete tk.scale.auto;
+        tk.scale.percentile = s.percentile;
+        loader(bwSetting.percentilescale);
+      }
+    });
+  }
+  {
+    config.dotplot.row = holder.append("div").style("margin-bottom", "15px");
+    config.dotplot.row.append("span").html("Dot plot&nbsp;&nbsp;");
+    const s = config.dotplot.row.append("select").on("change", (event) => {
+      const i = event.target.selectedIndex;
+      if (i == 0) {
+        delete tk.dotplotfactor;
+      } else {
+        tk.dotplotfactor = Number.parseInt(event.target.options[i].innerHTML);
+      }
+      loader(i == 0 ? bwSetting.nodotplot : bwSetting.usedotplot);
+    });
+    let o = s.append("option").text("no");
+    if (!tk.dotplotfactor) {
+      o.property("selected", 1);
+    }
+    o = s.append("option").text("5");
+    if (tk.dotplotfactor == 5) {
+      o.property("selected", 1);
+    }
+    o = s.append("option").text("10");
+    if (tk.dotplotfactor == 10) {
+      o.property("selected", 1);
+    }
+    o = s.append("option").text("15");
+    if (tk.dotplotfactor == 15) {
+      o.property("selected", 1);
+    }
+    o = s.append("option").text("20");
+    if (tk.dotplotfactor == 20) {
+      o.property("selected", 1);
+    }
+  }
+  config.dividefactor.row = holder.append("div");
+  {
+    const id = Math.random().toString();
+    const input = config.dividefactor.row.append("input").attr("type", "checkbox").attr("id", id);
+    if (!tk.normalize.disable) {
+      input.property("checked", 1);
+    }
+    config.dividefactor.row.append("label").html("&nbsp;Apply normalization").attr("for", id);
+    const folder = config.dividefactor.row.append("div").style("margin", "5px 10px 0px 20px").style("display", tk.normalize.disable ? "none" : "block");
+    folder.append("span").html("Divide raw value by&nbsp;");
+    const factorinput = folder.append("input").attr("type", "number").style("width", "60px").property("value", tk.normalize.dividefactor).on("keyup", (event) => {
+      if (event.code != "Enter" && event.code != "NumpadEnter") return;
+      const v = event.target.value;
+      if (v <= 0) {
+        return;
+      }
+      tk.normalize.dividefactor = v;
+      loader(bwSetting.usedividefactor);
+    });
+    folder.append("div").text("Enter a value above zero").style("font-size", ".7em").style("color", "#858585");
+    input.on("change", (event) => {
+      if (event.target.checked) {
+        appear(folder);
+        delete tk.normalize.disable;
+        factorinput.property("value", tk.normalize.dividefactor);
+        loader(bwSetting.usedividefactor);
+        return;
+      }
+      disappear(folder);
+      tk.normalize.disable = 1;
+      loader(bwSetting.nodividefactor);
+    });
+  }
+  return config;
+}
+
+export {
+  bigwigfromtemplate,
+  bigwigmaketk,
+  bigwigload,
+  bigwigloadsubpanel,
+  bigwigconfigpanel
+};
+//# sourceMappingURL=chunk-CLNSNNQU.js.map

package/dist/chunk-COYULNJF.js

@@ -0,0 +1,119 @@
+import {
+  GENE_EXPRESSION,
+  METABOLITE_INTENSITY,
+  PROTEOME_ABUNDANCE,
+  SINGLECELL_GENE_EXPRESSION
+} from "./chunk-IVXCWCKS.js";
+
+// common/termutils.js
+function sample_match_termvaluesetting(row, filter, geneVariant$ids) {
+  const lst = !filter ? [] : filter.type == "tvslst" ? filter.lst : [filter];
+  let numberofmatchedterms = 0;
+  for (const item of lst) {
+    if (item.type == "tvslst") {
+      if (sample_match_termvaluesetting(row, item)) {
+        numberofmatchedterms++;
+      }
+    } else {
+      const t = item.tvs;
+      let samplevalue;
+      if (t.term.type == "geneVariant") {
+        samplevalue = geneVariant$ids.map((g) => row[g]).filter((s) => s);
+      } else if (t.term.type == "integer" || t.term.type == "float" || t.term.type == GENE_EXPRESSION || t.term.type == METABOLITE_INTENSITY || t.term.type == PROTEOME_ABUNDANCE) {
+        samplevalue = row[t.term.id] || row[t.term.$id]?.key;
+      } else if (t.term.type == "survival") {
+        samplevalue = row[t.term.$id]?.key;
+      } else {
+        samplevalue = row[t.term.id] || row[t.term.$id]?.value;
+      }
+      let thistermmatch;
+      if (t.term.type == "categorical") {
+        if (samplevalue === void 0) {
+          if (t.isnot) thistermmatch = !thistermmatch;
+          if (thistermmatch) numberofmatchedterms++;
+          continue;
+        }
+        const valueset = t.valueset ? t.valueset : new Set(t.values.map((i) => i.key));
+        thistermmatch = valueset.has(samplevalue);
+      } else if (t.term.type == "integer" || t.term.type == "float" || t.term.type == GENE_EXPRESSION || t.term.type == METABOLITE_INTENSITY || t.term.type == PROTEOME_ABUNDANCE) {
+        if (samplevalue === void 0) {
+          if (t.isnot) thistermmatch = !thistermmatch;
+          if (thistermmatch) numberofmatchedterms++;
+          continue;
+        }
+        for (const range of t.ranges) {
+          if ("value" in range) {
+            thistermmatch = samplevalue === range.value;
+            if (thistermmatch) break;
+          } else if (samplevalue == range.name) {
+            thistermmatch = true;
+            break;
+          } else {
+            if (t.term.values) {
+              const v = t.term.values[samplevalue.toString()];
+              if (v && v.uncomputable) {
+                continue;
+              }
+            }
+            let left, right;
+            if (range.startunbounded) {
+              left = true;
+            } else if ("start" in range) {
+              if (range.startinclusive) {
+                left = samplevalue >= range.start;
+              } else {
+                left = samplevalue > range.start;
+              }
+            }
+            if (range.stopunbounded) {
+              right = true;
+            } else if ("stop" in range) {
+              if (range.stopinclusive) {
+                right = samplevalue <= range.stop;
+              } else {
+                right = samplevalue < range.stop;
+              }
+            }
+            thistermmatch = left && right;
+          }
+          if (thistermmatch) break;
+        }
+      } else if (t.term.type == "condition") {
+        const key = getPrecomputedKey(t);
+        const anno = samplevalue && samplevalue[key];
+        if (anno) {
+          thistermmatch = Array.isArray(anno) ? t.values.find((d) => anno.includes(d.key)) : t.values.find((d) => d.key == anno);
+        }
+      } else if (t.term.type == "survival") {
+        if (samplevalue === void 0) {
+          if (t.isnot) thistermmatch = !thistermmatch;
+          if (thistermmatch) numberofmatchedterms++;
+          continue;
+        }
+        const valueset = t.valueset ? t.valueset : new Set(t.values.map((i) => i.key));
+        thistermmatch = valueset.has(samplevalue);
+      } else if (t.term.type == "geneVariant" && t.legendFilterType == "geneVariant_hard") {
+        const f = t.values[0];
+        thistermmatch = samplevalue.find((s) => {
+          for (const v of s.values) {
+            if (v.dt == f.dt && (!v.origin || v.origin == f.origin) && f.mclasslst.includes(v.class)) return true;
+          }
+        }) && true;
+      } else if (t.term.type == SINGLECELL_GENE_EXPRESSION) {
+      } else {
+        throw "unknown term type";
+      }
+      if (t.isnot) {
+        thistermmatch = !thistermmatch;
+      }
+      if (thistermmatch) numberofmatchedterms++;
+    }
+    if (filter.join == "or" && numberofmatchedterms) return true;
+  }
+  if (numberofmatchedterms == lst.length) return true;
+}
+
+export {
+  sample_match_termvaluesetting
+};
+//# sourceMappingURL=chunk-COYULNJF.js.map