@sjcrh/proteinpaint-client 2.222.0 → 2.224.0

package/dist/chunk-4XFL2PXO.js

@@ -0,0 +1,257 @@
+import {
+  make_table_2col
+} from "./chunk-U45YALDI.js";
+
+// src/block.mds.expressionstat.js
+var color_noinfo = "#858585";
+function init_config(cfg) {
+  if (!cfg.datatype) cfg.datatype = "FPKM";
+  if (!cfg.itemcolor) cfg.itemcolor = "green";
+  if (!cfg.ase) cfg.ase = {};
+  if (cfg.ase.qvalue == void 0) cfg.ase.qvalue = 0.05;
+  if (cfg.ase.meandelta_monoallelic == void 0) cfg.ase.meandelta_monoallelic = 0.3;
+  if (cfg.ase.asemarkernumber_biallelic == void 0) cfg.ase.asemarkernumber_biallelic = 0;
+  if (!cfg.ase.color_noinfo) cfg.ase.color_noinfo = color_noinfo;
+  if (!cfg.ase.color_uncertain) cfg.ase.color_uncertain = "#A8E0B5";
+  if (!cfg.ase.color_biallelic) cfg.ase.color_biallelic = "#40859C";
+  if (!cfg.ase.color_monoallelic) cfg.ase.color_monoallelic = "#d95f02";
+  if (!cfg.outlier) cfg.outlier = {};
+  if (cfg.outlier.pvalue_cutoff == void 0) cfg.outlier.pvalue_cutoff = 0.05;
+  if (cfg.outlier.rank_asehigh_cutoff == void 0) cfg.outlier.rank_asehigh_cutoff = 0.1;
+  if (!cfg.outlier.color_outlier) cfg.outlier.color_outlier = "#FF8875";
+  if (!cfg.outlier.color_outlier_asehigh) cfg.outlier.color_outlier_asehigh = "blue";
+}
+function measure(v, cfg) {
+  if (!cfg) return;
+  v.estat = {};
+  if (v.ase && cfg.ase) {
+    const qvalue = v.ase.qvalue || v.ase.geometricmean;
+    if (qvalue == void 0) {
+      v.estat.ase_noinfo = true;
+    } else if (qvalue <= cfg.ase.qvalue) {
+      if (v.ase.mean_delta >= cfg.ase.meandelta_monoallelic) {
+        v.estat.ase_monoallelic = true;
+      } else {
+        v.estat.ase_uncertain = true;
+      }
+    } else {
+      if (v.ase.ase_markers == cfg.ase.asemarkernumber_biallelic) {
+        v.estat.ase_biallelic = true;
+      } else {
+        v.estat.ase_uncertain = true;
+      }
+    }
+  } else {
+    v.estat.ase_noinfo = true;
+  }
+  if (v.outlier && cfg.outlier) {
+    if (v.outlier.test_whitelist) {
+      if (v.outlier.test_whitelist.pvalue <= cfg.outlier.pvalue_cutoff) {
+        v.estat.outlier = true;
+      } else {
+        if (v.estat.ase_monoallelic) {
+          if (Number.isInteger(v.outlier.test_whitelist.rank) && Number.isInteger(v.outlier.test_whitelist.size) && v.outlier.test_whitelist.rank / v.outlier.test_whitelist.size <= cfg.outlier.rank_asehigh_cutoff) {
+            v.estat.outlier_asehigh = true;
+            v.outlier.test_whitelist.asehigh = true;
+          }
+        }
+      }
+    } else if (v.outlier.test_biallelic) {
+      if (v.outlier.test_biallelic.pvalue <= cfg.outlier.pvalue_cutoff) {
+        v.estat.outlier = true;
+      } else {
+        if (v.estat.ase_monoallelic) {
+          if (Number.isInteger(v.outlier.test_biallelic.rank) && Number.isInteger(v.outlier.test_biallelic.size) && v.outlier.test_biallelic.rank / v.outlier.test_biallelic.size <= cfg.outlier.rank_asehigh_cutoff) {
+            v.estat.outlier_asehigh = true;
+            v.outlier.test_biallelic.asehigh = true;
+          }
+        }
+      }
+    } else if (v.outlier.test_entirecohort) {
+      if (v.outlier.test_entirecohort.pvalue <= cfg.outlier.pvalue_cutoff) {
+        v.estat.outlier = true;
+      } else {
+        if (v.estat.ase_monoallelic) {
+          if (Number.isInteger(v.outlier.test_entirecohort.rank) && Number.isInteger(v.outlier.test_entirecohort.size) && v.outlier.test_entirecohort.rank / v.outlier.test_entirecohort.size <= cfg.outlier.rank_asehigh_cutoff) {
+            v.estat.outlier_asehigh = true;
+            v.outlier.test_entirecohort.asehigh = true;
+          }
+        }
+      }
+    }
+  }
+}
+function showsingleitem_table(v, cfg, table) {
+  if (!v.estat) return;
+  if (cfg.no_ase) return;
+  if (v.ase) {
+    const tr = table.append("tr");
+    tr.append("td").attr("colspan", 2).style("background", ase_color(v, cfg)).style("color", "white").html(
+      (v.estat.ase_monoallelic ? "Mono-allelic" : v.estat.ase_biallelic ? "Bi-allelic" : "ASE uncertain") + "<br>(allele-specific expression)"
+    );
+    const lst = [
+      {
+        k: "#SNPs heterozygous in DNA",
+        v: v.ase.markers
+      },
+      {
+        k: "#SNPs showing ASE in RNA",
+        v: v.ase.ase_markers
+      },
+      {
+        k: "Mean delta of ASE SNPs",
+        v: v.ase.mean_delta
+      }
+    ];
+    if (v.ase.qvalue) {
+      lst.push({
+        k: "Q-value",
+        v: v.ase.qvalue
+      });
+    } else if (v.ase.geometricmean) {
+      lst.push({
+        k: "Geometric mean of binomial P-values of ASE SNPs",
+        v: v.ase.geometricmean
+      });
+    }
+    const td = tr.append("td");
+    make_table_2col(td, lst);
+  } else {
+    const tr = table.append("tr");
+    tr.append("td").attr("colspan", 3).style("background", cfg.ase.color_noinfo).style("color", "white").text("No info on allele-specific expression");
+  }
+  if (v.outlier) {
+    if (v.outlier.test_whitelist) {
+      const tr = table.append("tr");
+      tr.append("td").attr("colspan", 2).text("Outlier (white list)");
+      const lst = [];
+      for (const k in v.outlier.test_whitelist) {
+        lst.push({ k, v: v.outlier.test_whitelist[k] });
+      }
+      const td = tr.append("td");
+      make_table_2col(td, lst);
+      if (v.outlier.test_whitelist.asehigh) {
+        td.append("div").style("background", cfg.outlier.color_outlier_asehigh).style("padding", "2px 10px").style("color", "white").text("ASE high");
+      }
+    }
+    if (v.outlier.test_biallelic) {
+      const tr = table.append("tr");
+      tr.append("td").attr("colspan", 2).text("Outlier (biallelic)");
+      const lst = [];
+      for (const k in v.outlier.test_biallelic) {
+        lst.push({ k, v: v.outlier.test_biallelic[k] });
+      }
+      const td = tr.append("td");
+      make_table_2col(td, lst);
+      if (v.outlier.test_biallelic.asehigh) {
+        td.append("div").style("background", cfg.outlier.color_outlier_asehigh).style("padding", "2px 10px").style("color", "white").text("ASE high");
+      }
+    }
+    if (v.outlier.test_entirecohort) {
+      const tr = table.append("tr");
+      tr.append("td").attr("colspan", 2).text("Outlier (all samples)");
+      const lst = [];
+      for (const k in v.outlier.test_entirecohort) {
+        lst.push({ k, v: v.outlier.test_entirecohort[k] });
+      }
+      const td = tr.append("td");
+      make_table_2col(td, lst);
+      if (v.outlier.test_entirecohort.asehigh) {
+        td.append("div").style("background", cfg.outlier.color_outlier_asehigh).style("padding", "2px 10px").style("color", "white").text("ASE high");
+      }
+    }
+  }
+}
+function ase_color(v, cfg) {
+  if (cfg.no_ase) return color_noinfo;
+  if (!cfg.ase) return color_noinfo;
+  if (!v.estat) return cfg.ase.color_noinfo;
+  if (v.estat.ase_monoallelic) return cfg.ase.color_monoallelic;
+  if (v.estat.ase_biallelic) return cfg.ase.color_biallelic;
+  if (v.estat.ase_uncertain) return cfg.ase.color_uncertain;
+  return cfg.ase.color_noinfo;
+}
+function ui_config(holder, cfg, tk, call) {
+  const indent = 30;
+  {
+    const row = holder.append("div").style("margin-bottom", "5px");
+    row.append("span").html("If Q-VALUE &le;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", cfg.ase.qvalue).on("keyup", (event) => {
+      if (event.code != "Enter" && event.code != "NumpadEnter") return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0) {
+        return;
+      }
+      if (cfg.ase.qvalue == v) {
+        return;
+      }
+      cfg.ase.qvalue = v;
+      call();
+    });
+    row.append("span").html("&nbsp;:");
+  }
+  {
+    const row = holder.append("div").style("margin", "0px 5px 5px " + indent + "px");
+    row.append("span").html("If MEAN_DELTA &ge;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", cfg.ase.meandelta_monoallelic).on("keyup", (event) => {
+      if (event.code != "Enter" && event.code != "NumpadEnter") return;
+      let v = Number.parseFloat(event.target.value);
+      if (!v || v <= 0) {
+        return;
+      }
+      if (cfg.ase.meandelta_monoallelic == v) {
+        return;
+      }
+      cfg.ase.meandelta_monoallelic = v;
+      call();
+    });
+    row.append("span").html("&nbsp;:&nbsp;");
+  }
+  holder.append("div").style("margin", "0px 5px 5px " + indent * 2 + "px").html(
+    'Is <span style="background:' + cfg.ase.color_monoallelic + ';padding:1px 5px;color:white;">mono-allelic expression</span>'
+  );
+  holder.append("div").style("margin", "0px 5px 5px " + indent + "px").html("Else:");
+  holder.append("div").style("margin", "0px 5px 5px " + indent * 2 + "px").html(
+    'Is <span style="background:' + cfg.ase.color_uncertain + ';padding:1px 5px;color:white;">ASE uncertain</span>'
+  );
+  holder.append("div").style("margin", "0px 5px 5px 0px").html("Else:");
+  {
+    const row = holder.append("div").style("margin", "0px 5px 5px " + indent + "px");
+    row.append("span").html("If number of ASE markers &le;&nbsp;");
+    row.append("input").attr("type", "number").style("width", "50px").property("value", cfg.ase.asemarkernumber_biallelic).on("keyup", (event) => {
+      if (event.code != "Enter" && event.code != "NumpadEnter") return;
+      let v = Number.parseInt(event.target.value);
+      if (v < 0) {
+        return;
+      }
+      if (cfg.ase.asemarkernumber_biallelic == v) {
+        return;
+      }
+      cfg.ase.asemarkernumber_biallelic = v;
+      call();
+    });
+    row.append("span").html("&nbsp;:&nbsp;");
+  }
+  holder.append("div").style("margin", "0px 5px 5px " + indent * 2 + "px").html(
+    'Is <span style="background:' + cfg.ase.color_biallelic + ';padding:1px 5px;color:white;">bi-allelic expression</span>'
+  );
+  holder.append("div").style("margin", "0px 5px 5px " + indent + "px").html("Else:");
+  holder.append("div").style("margin", "0px 5px 5px " + indent * 2 + "px").html(
+    'Is <span style="background:' + cfg.ase.color_uncertain + ';padding:1px 5px;color:white;">ASE uncertain</span>'
+  );
+  holder.append("div").style("margin", "10px").append("button").text("Default ASE parameters").on("click", () => {
+    cfg.ase.qvalue = 0.05;
+    cfg.ase.meandelta_monoallelic = 0.3;
+    cfg.ase.asemarkernumber_biallelic = 0;
+    call();
+  });
+}
+
+export {
+  init_config,
+  measure,
+  showsingleitem_table,
+  ase_color,
+  ui_config
+};
+//# sourceMappingURL=chunk-4XFL2PXO.js.map

package/dist/chunk-5MBKRZWI.js

@@ -0,0 +1,96 @@
+import {
+  keyupEnter,
+  require_debounce
+} from "./chunk-U45YALDI.js";
+import {
+  Menu
+} from "./chunk-CNFTQSNE.js";
+import {
+  dofetch,
+  dofetch3
+} from "./chunk-KBTFT76L.js";
+import {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// src/gene.js
+var import_debounce = __toESM(require_debounce(), 1);
+var tip;
+function gene_searchbox(p) {
+  if (!tip) {
+    tip = new Menu({ padding: "" });
+    tip.d.style("z-index", 1e3);
+  }
+  const input = p.div.append("input").attr("placeholder", "Search gene").style("width", p.width || "100px");
+  const printdiv = p.resultdiv || (p.tip ? p.tip.d : tip.d);
+  function fold() {
+    if (p.resultdiv) {
+      p.resultdiv.selectAll("*").remove();
+    } else if (p.tip) {
+      p.tip.hide();
+    } else {
+      tip.hide();
+    }
+  }
+  input.on("keyup", (event) => {
+    const str = event.target.value;
+    if (str.length <= 1) {
+      fold();
+      return;
+    }
+    if (keyupEnter(event)) {
+      const hitgene = printdiv.select(".sja_menuoption");
+      if (hitgene.size() > 0) {
+        p.callback(hitgene.text());
+        fold();
+      }
+      return;
+    }
+    debouncer();
+  });
+  input.node().focus();
+  function genesearch() {
+    dofetch("genelookup", { genome: p.genome, input: input.property("value") }).then((data) => {
+      if (data.error) throw data.error;
+      if (!data.hits) throw ".hits[] missing";
+      if (p.resultdiv) {
+        p.resultdiv.selectAll("*").remove();
+      } else if (p.tip) {
+        p.tip.clear().showunder(input.node());
+      } else {
+        tip.clear().showunder(input.node());
+      }
+      for (const name of data.hits) {
+        printdiv.append("div").attr("class", "sja_menuoption").text(name).on("click", () => {
+          p.callback(name);
+          fold();
+        });
+      }
+    }).catch((err) => {
+      printdiv.append("div").text(err.message || err);
+      if (err.stack) console.log(err.stack);
+    });
+  }
+  const debouncer = (0, import_debounce.debounce)(genesearch, 300);
+}
+function findgenemodel_bysymbol(genome, str) {
+  return dofetch3("genelookup", {
+    body: {
+      deep: 1,
+      input: str,
+      genome
+    }
+  }).then((data) => {
+    if (data.error) throw data.error;
+    if (!data.gmlst || data.gmlst.length == 0) return null;
+    return data.gmlst;
+  }).catch((e) => {
+    throw e;
+  });
+}
+
+export {
+  gene_searchbox,
+  findgenemodel_bysymbol
+};
+//# sourceMappingURL=chunk-5MBKRZWI.js.map

package/dist/chunk-5NQXKUJ3.js

@@ -0,0 +1,243 @@
+import {
+  keyupEnter
+} from "./chunk-U45YALDI.js";
+import {
+  get_bin_label,
+  get_bin_range_equation
+} from "./chunk-KBTFT76L.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-5NQXKUJ3.js.map