@sjcrh/proteinpaint-client 2.207.0 → 2.207.1

package/dist/chunk-HPAW7XDM.js

@@ -0,0 +1,178 @@
+import {
+  __glob
+} from "./chunk-HS5PO5ZQ.js";
+
+// import("../plots/**/*.js") in plots/importPlot.js
+var globImport_plots_js = __glob({
+  "../plots/controls.btns.js": () => import("./controls.btns-BYM4DON4.js"),
+  "../plots/controls.config.js": () => import("./controls.config-KF7PHZSG.js"),
+  "../plots/controls.js": () => import("./controls-DWDKFDXY.js"),
+  "../plots/dictionary.js": () => import("./dictionary-ERJQMALC.js"),
+  "../plots/gb/test/genomeBrowser.spec.js": () => import("./genomeBrowser.spec-JTCVUTO5.js"),
+  "../plots/geneExpression.js": () => import("./geneExpression-AWWMOUAR.js"),
+  "../plots/geneORA.js": () => import("./geneORA-NGZTMFSJ.js"),
+  "../plots/geneset.js": () => import("./geneset-APCO4BRX.js"),
+  "../plots/hierCluster.js": () => import("./hierCluster-SFRQK3PS.js"),
+  "../plots/importPlot.js": () => import("./importPlot-7V456QK7.js"),
+  "../plots/matrix.js": () => import("./matrix-DLCX6GOO.js"),
+  "../plots/matrix/hierCluster.config.js": () => import("./hierCluster.config-G2TFGBYF.js"),
+  "../plots/matrix/hierCluster.interactivity.js": () => import("./hierCluster.interactivity-LQA6J56H.js"),
+  "../plots/matrix/hierCluster.js": () => import("./hierCluster-4DRHXD6W.js"),
+  "../plots/matrix/hierCluster.renderers.js": () => import("./hierCluster.renderers-TZZJEVFO.js"),
+  "../plots/matrix/matrix.cells.js": () => import("./matrix.cells-J3QZ7C6U.js"),
+  "../plots/matrix/matrix.cluster.js": () => import("./matrix.cluster-RH4BOM5F.js"),
+  "../plots/matrix/matrix.config.js": () => import("./matrix.config-VNMS6B7J.js"),
+  "../plots/matrix/matrix.data.js": () => import("./matrix.data-PIE3TLKD.js"),
+  "../plots/matrix/matrix.dom.js": () => import("./matrix.dom-2SA43BPT.js"),
+  "../plots/matrix/matrix.groups.js": () => import("./matrix.groups-URBU775S.js"),
+  "../plots/matrix/matrix.interactivity.js": () => import("./matrix.interactivity-W5AFOAQN.js"),
+  "../plots/matrix/matrix.js": () => import("./matrix-TIV42IQB.js"),
+  "../plots/matrix/matrix.layout.js": () => import("./matrix.layout-LU3NIJAL.js"),
+  "../plots/matrix/matrix.legend.js": () => import("./matrix.legend-LTP6ETZO.js"),
+  "../plots/matrix/matrix.renderers.js": () => import("./matrix.renderers-762XI65L.js"),
+  "../plots/matrix/matrix.serieses.js": () => import("./matrix.serieses-FHDBRPZA.js"),
+  "../plots/matrix/matrix.sort.js": () => import("./matrix.sort-Q6A6UWMY.js"),
+  "../plots/matrix/matrix.sorterUi.js": () => import("./matrix.sorterUi-4M5AU5EL.js"),
+  "../plots/matrix/test/hierCluster.integration.spec.js": () => import("./hierCluster.integration.spec-ZUZKCG6A.js"),
+  "../plots/matrix/test/matrix.integration.spec.js": () => import("./matrix.integration.spec-LC6YMEKP.js"),
+  "../plots/matrix/test/matrix.sort.unit.spec.js": () => import("./matrix.sort.unit.spec-CTCOPKVS.js"),
+  "../plots/matrix/test/matrix.sorterUi.unit.spec.js": () => import("./matrix.sorterUi.unit.spec-Y7GC3PM5.js"),
+  "../plots/matrix/test/matrix.unit.spec.js": () => import("./matrix.unit.spec-DROPHFTM.js"),
+  "../plots/matrix/test/oncomatrix.spec.js": () => import("./oncomatrix.spec-UWMSLOHW.js"),
+  "../plots/plot.brainImaging.js": () => import("./plot.brainImaging-3MTTCZHI.js"),
+  "../plots/plot.disco.js": () => import("./plot.disco-HODBY7SO.js"),
+  "../plots/plot.ssgq.js": () => import("./plot.ssgq-4URQE673.js"),
+  "../plots/singleCellPlot.js": () => import("./singleCellPlot-XG3HZS7I.js"),
+  "../plots/stattable.js": () => import("./stattable-NDYUCLVZ.js"),
+  "../plots/survival/test/survival.integration.spec.js": () => import("./survival.integration.spec-WWZELTKZ.js"),
+  "../plots/table.js": () => import("./table-IAQ6J4DO.js"),
+  "../plots/test/expclust.gdc.spec.js": () => import("./expclust.gdc.spec-P77T6JR2.js"),
+  "../plots/test/summary.integration.spec.js": () => import("./summary.integration.spec-4GTCG6HY.js"),
+  "../plots/volcano/test/testData.js": () => import("./testData-DRM5HWQB.js")
+});
+
+// plots/importPlot.js
+async function importPlot(chartType, notFoundMessage = "") {
+  switch (chartType) {
+    case "aggregateMatrix":
+      return await import("./AggregateMatrix-TPXNNWVD.js");
+    case "aggMatrixInput":
+      return await import("./AggMatrixInput-RDFMGV47.js");
+    case "animatedBubbleChart":
+      return await import("./animatedBubbleChart-OQOZ3WFK.js");
+    case "brainImaging":
+      return await import("./brainImaging-35LPNBDR.js");
+    case "brainRegions":
+      return await import("./brainRegions-JMTQT4X3.js");
+    case "barchart":
+      return await import("./barchart-ESY6FOS4.js");
+    case "boxplot":
+      return await import("./BoxPlot-LOAO2MDO.js");
+    case "bubbleHeatmap":
+      return await import("./bubbleHeatmap-FMBKMDUL.js");
+    case "cellTypeBubbleHeatmap":
+      return await import("./cellTypeBubbleHeatmap-ZPTAGEWW.js");
+    case "correlationVolcano":
+      return await import("./CorrelationVolcano-AU6ZAFPG.js");
+    case "cuminc":
+      return await import("./Cuminc-O533BXFY.js");
+    case "dataDownload":
+      return await import("./dataDownload-G7TGPFGL.js");
+    case "DEinput":
+      return await import("./DEinput-TF2VYTIJ.js");
+    case "dictionary":
+      return await import("./dictionary-ERJQMALC.js");
+    case "differentialAnalysis":
+      return await import("./DifferentialAnalysis-H5NBPR3P.js");
+    case "Disco":
+      return await import("./Disco-FGFHIKUR.js");
+    case "dmr":
+      return await import("./DmrPlot-EQFXMAW5.js");
+    case "facet":
+      return await import("./facet-LJTSTASE.js");
+    case "GeneExpInput":
+      return await import("./GeneExpInput-ZY6SHXTX.js");
+    case "geneRanking":
+      return await import("./geneRanking-AYNBGFKU.js");
+    case "genomeBrowser":
+      return await import("./GB-244UT5VU.js");
+    case "geomap":
+      return await import("./Geomap-6ZV4AM23.js");
+    case "grin2":
+      return await import("./grin2-LF46UKFY.js");
+    case "gsea":
+      return await import("./GSEA-KXQBR3HH.js");
+    case "imagePlot":
+      return await import("./imagePlot-OUHFWYKT.js");
+    case "numericDictTermCluster":
+      return await import("./numericDictTermCluster-C2MYJYPZ.js");
+    case "profileBarchart2":
+      return await import("./barchart2-XEJZGCES.js");
+    case "profileForms":
+      return await import("./profileForms-Z22CJXI4.js");
+    case "profilePlot":
+      return await import("./profilePlot-IVQZBSID.js");
+    case "profilePolar2":
+      return await import("./polar2-GVFQNSLK.js");
+    case "profileRadar2":
+      return await import("./radar2-CEE6SNBS.js");
+    case "profileRadarFacility2":
+      return await import("./radarFacility2-OSKDYIK7.js");
+    case "proteinView":
+      return await import("./proteinView-AUK634AU.js");
+    case "proteomeAbundance":
+      return await import("./proteomeAbundance-NH3Y4YC7.js");
+    case "proteomeCohortCompare":
+      return await import("./proteomeCohortCompare-7G2F35H5.js");
+    case "ProteomeInput":
+      return await import("./ProteomeInput-HIS4GYWH.js");
+    case "regression":
+      return await import("./Regression-C5GZYLEN.js");
+    case "report":
+      return await import("./report-6JXJVSEB.js");
+    case "runChart2":
+    //See frequencyChart
+    case "frequencyChart":
+      return await import("./RunChart2-X5WKYLPQ.js");
+    case "sampleView":
+      return await import("./sampleView-SG3QYZKQ.js");
+    case "sampleScatter":
+      return await import("./scatter-RHUVER53.js");
+    case "sc":
+      return await import("./SC-3Y5J65DT.js");
+    case "studyCatalog":
+      return await import("./studyCatalog-TAXRF5NS.js");
+    case "summarizeCnvGeneexp":
+      return await import("./summarizeCnvGeneexp-3QLHU6N7.js");
+    case "summarizeGeneexpSurvival":
+      return await import("./summarizeGeneexpSurvival-ARI4MPFX.js");
+    case "summarizeMutationDiagnosis":
+      return await import("./summarizeMutationDiagnosis-GCL4SRON.js");
+    case "summarizeMutationSurvival":
+      return await import("./summarizeMutationSurvival-6TTMSRRX.js");
+    case "summarizeMutationCnv":
+      return await import("./summarizeMutationCnv-W7V7CKPI.js");
+    case "summaryInput":
+      return await import("./summaryInput-UK3TLC7M.js");
+    case "summary":
+      return await import("./summary-OUYDWLBF.js");
+    case "survival":
+      return await import("./survival-TL6UZ6FQ.js");
+    case "table":
+      return await import("./table-IAQ6J4DO.js");
+    case "violin":
+      return await import("./Violin-F3QS2EMJ.js");
+    case "volcano":
+      return await import("./Volcano-ZNYDKP2O.js");
+    case "wsi":
+      return await import("./Wsi-B6EIGTI2.js");
+    default:
+      if (notFoundMessage) throw notFoundMessage;
+      return await globImport_plots_js(`../plots/${chartType}.js`);
+  }
+}
+
+export {
+  importPlot
+};
+//# sourceMappingURL=chunk-HPAW7XDM.js.map

package/dist/chunk-IV57XNTG.js

@@ -0,0 +1,123 @@
+import {
+  pickCollectionFraction,
+  renderTable
+} from "./chunk-PC4MFDHP.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-IV57XNTG.js.map

package/dist/chunk-JMAFJKGG.js

@@ -0,0 +1,243 @@
+import {
+  keyupEnter
+} from "./chunk-PC4MFDHP.js";
+import {
+  get_bin_label,
+  get_bin_range_equation
+} from "./chunk-52QHIKH2.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-JMAFJKGG.js.map