@sjcrh/proteinpaint-client 2.190.2 → 2.191.0

package/dist/chunk-CW2Q5EA7.js

@@ -0,0 +1,283 @@
+import {
+  NUMERIC_DICTIONARY_TERM,
+  TermTypes
+} from "./chunk-TVADJLMF.js";
+import {
+  __export
+} from "./chunk-HFNDKYVF.js";
+
+// plots/matrix/hierCluster.renderers.js
+var hierCluster_renderers_exports = {};
+__export(hierCluster_renderers_exports, {
+  maySetSandboxHeader: () => maySetSandboxHeader,
+  plotDendrogramHclust: () => plotDendrogramHclust,
+  renderImage: () => renderImage
+});
+function maySetSandboxHeader(appState) {
+  if (!this.dom.header) return;
+  switch (this.config.dataType) {
+    case TermTypes.GENE_EXPRESSION:
+      const headerText = this.config?.headerText ? `${this.config.headerText} ` : "";
+      this.dom.header.text(`${headerText}Gene Expression Clustering`);
+      break;
+    case TermTypes.METABOLITE_INTENSITY:
+      this.dom.header.text("Metabolite Intensity Clustering");
+      break;
+    case TermTypes.SSGSEA:
+      this.dom.header.text("ssGSEA Clustering");
+      break;
+    case NUMERIC_DICTIONARY_TERM:
+      this.dom.header.text(
+        this.config.preBuiltPlotTitle ? this.config.preBuiltPlotTitle : appState.termdbConfig.numericDictTermCluster?.appName ? appState.termdbConfig.numericDictTermCluster.appName + " Clustering" : "Numeric Dictionary Term Clustering"
+      );
+      break;
+    case TermTypes.PROTEOME_ABUNDANCE:
+      this.dom.header.text(
+        this.config.assayCohortTitle ? `Protein Abundance Clustering (${this.config.assayCohortTitle})` : "Protein Abundance Clustering"
+      );
+      break;
+    default:
+      throw `dataType '${this.config.dataType}' not recognized`;
+  }
+}
+function plotDendrogramHclust(plotOnly) {
+  const d = this.dimensions;
+  const s = this.config.settings.matrix;
+  const xOffset = d.seriesXoffset;
+  const pxr = window.devicePixelRatio <= 1 ? 1 : window.devicePixelRatio;
+  const obj = this.hierClusterData.clustering;
+  const row = obj.row;
+  const col = obj.col;
+  const rowHeight = this.settings.matrix.clusterRowh, { xDendrogramHeight, yDendrogramHeight } = this.settings.hierCluster, colWidth = this.dimensions.dx;
+  if (plotOnly !== "left") {
+    if (!this.settings.hierCluster.clusterSamples) {
+      this.dom.topDendrogram.selectAll("*").remove();
+    } else {
+      const height2px = getHclustHeightScalefactor(col.height, yDendrogramHeight);
+      const height = yDendrogramHeight + 1e-7;
+      const width = Math.min(colWidth * col.inputOrder.length, s.imgWMax);
+      if (width <= 0 || height <= 0) {
+        console.warn(
+          "Skipping top dendrogram render: invalid dimensions.",
+          "This may indicate a zoom feedback loop issue.",
+          {
+            width,
+            height,
+            colWidth,
+            sampleCount: col.inputOrder.length,
+            yDendrogramHeight
+          }
+        );
+        this.dom.topDendrogram.selectAll("*").remove();
+        return;
+      }
+      const canvas = new OffscreenCanvas(width * pxr, height * pxr);
+      const ctx = canvas.getContext("2d");
+      ctx.scale(pxr, pxr);
+      ctx.translate(-d.xMin, 0);
+      ctx.imageSmoothingEnabled = false;
+      ctx.imageSmoothingQuality = "high";
+      ctx.strokeStyle = "black";
+      const mergedClusters = /* @__PURE__ */ new Map();
+      for (const [clusterid0, pair] of col.merge.entries()) {
+        const clusterid = clusterid0 + 1;
+        const children = [];
+        const childrenClusters = [];
+        let x1, x2, y1, y2;
+        if (pair.n1 < 0) {
+          const [name, columnNumber] = getLeafNumber(pair.n1, col.inputOrder, col.order);
+          x1 = colWidth * (columnNumber + 0.5);
+          y1 = yDendrogramHeight;
+          children.push({ name });
+        } else {
+          if (!mergedClusters.has(pair.n1)) throw "pair.n1 is positive but not seen before";
+          const c = mergedClusters.get(pair.n1);
+          x1 = c.x;
+          y1 = c.y;
+          children.push(...c.children);
+          childrenClusters.push(pair.n1);
+        }
+        if (pair.n2 < 0) {
+          const [name, columnNumber] = getLeafNumber(pair.n2, col.inputOrder, col.order);
+          x2 = colWidth * (columnNumber + 0.5);
+          y2 = yDendrogramHeight;
+          children.push({ name });
+        } else {
+          if (!mergedClusters.has(pair.n2)) throw "pair.n1 is positive but not seen before";
+          const c = mergedClusters.get(pair.n2);
+          x2 = c.x;
+          y2 = c.y;
+          children.push(...c.children);
+          childrenClusters.push(pair.n2);
+        }
+        const clusterY = yDendrogramHeight - col.height[clusterid0].height * height2px;
+        const highlight = this.clickedClusterIds?.includes(clusterid);
+        ctx.strokeStyle = highlight ? "red" : "black";
+        ctx.beginPath();
+        ctx.moveTo(x1, y1);
+        ctx.lineTo(x1, clusterY);
+        ctx.lineTo(x2, clusterY);
+        ctx.lineTo(x2, y2);
+        ctx.stroke();
+        ctx.closePath();
+        mergedClusters.set(clusterid, {
+          x: (x1 + x2) / 2,
+          y: clusterY,
+          children,
+          childrenClusters,
+          clusterPosition: {
+            x1,
+            x2,
+            y1,
+            y2,
+            clusterY
+          }
+        });
+      }
+      this.renderImage(
+        this.api,
+        this.dom.topDendrogram,
+        canvas,
+        width,
+        height,
+        xDendrogramHeight + 0.5 * colWidth + d.xMin,
+        s.margin.top + s.scrollHeight
+      );
+      col.mergedClusters = mergedClusters;
+    }
+  }
+  if (plotOnly !== "top") {
+    if (!this.settings.hierCluster.clusterRows) {
+      this.dom.leftDendrogram.selectAll("*").remove();
+    } else {
+      const height2px = getHclustHeightScalefactor(row.height, xDendrogramHeight);
+      const width = xDendrogramHeight + 1e-7;
+      const height = rowHeight * row.inputOrder.length;
+      const canvasWidthPx = Number.isFinite(width) && Number.isFinite(pxr) ? Math.max(0, Math.floor(width * pxr)) : 0;
+      const canvasHeightPx = Number.isFinite(height) && Number.isFinite(pxr) ? Math.max(0, Math.floor(height * pxr)) : 0;
+      if (!Number.isFinite(width) || !Number.isFinite(height) || !Number.isFinite(pxr) || width <= 0 || height <= 0 || pxr <= 0 || canvasWidthPx < 1 || canvasHeightPx < 1) {
+        console.warn(
+          "Skipping left dendrogram render: invalid dimensions.",
+          "This may indicate a zoom feedback loop issue.",
+          {
+            width,
+            height,
+            pxr,
+            canvasWidthPx,
+            canvasHeightPx,
+            rowHeight,
+            termCount: row.inputOrder.length,
+            xDendrogramHeight
+          }
+        );
+        this.dom.leftDendrogram.selectAll("*").remove();
+        return;
+      }
+      const canvas = new OffscreenCanvas(canvasWidthPx, canvasHeightPx);
+      const ctx = canvas.getContext("2d");
+      ctx.scale(pxr, pxr);
+      ctx.imageSmoothingEnabled = false;
+      ctx.imageSmoothingQuality = "high";
+      ctx.strokeStyle = "black";
+      const mergedClusters = /* @__PURE__ */ new Map();
+      for (const [clusterid0, pair] of row.merge.entries()) {
+        const clusterid = clusterid0 + 1;
+        const children = [];
+        const childrenClusters = [];
+        let x1, x2, y1, y2;
+        if (pair.n1 < 0) {
+          const [name, rowNumber] = getLeafNumber(pair.n1, row.inputOrder, row.order);
+          y1 = rowHeight * (rowNumber + 0.5);
+          x1 = xDendrogramHeight;
+          children.push({ name });
+        } else {
+          if (!mergedClusters.has(pair.n1)) throw "pair.n1 is positive but not seen before";
+          const c = mergedClusters.get(pair.n1);
+          x1 = c.x;
+          y1 = c.y;
+          children.push(...c.children);
+          childrenClusters.push(pair.n1);
+        }
+        if (pair.n2 < 0) {
+          const [name, rowNumber] = getLeafNumber(pair.n2, row.inputOrder, row.order);
+          y2 = rowHeight * (rowNumber + 0.5);
+          x2 = xDendrogramHeight;
+          children.push({ name });
+        } else {
+          if (!mergedClusters.has(pair.n2)) throw "pair.n1 is positive but not seen before";
+          const c = mergedClusters.get(pair.n2);
+          x2 = c.x;
+          y2 = c.y;
+          children.push(...c.children);
+          childrenClusters.push(pair.n2);
+        }
+        const clusterX = xDendrogramHeight - row.height[clusterid0].height * height2px;
+        const highlight = this.clickedLeftClusterIds?.includes(clusterid);
+        ctx.strokeStyle = highlight ? "red" : "black";
+        ctx.beginPath();
+        ctx.moveTo(x1, y1);
+        ctx.lineTo(clusterX, y1);
+        ctx.lineTo(clusterX, y2);
+        ctx.lineTo(x2, y2);
+        ctx.stroke();
+        ctx.closePath();
+        mergedClusters.set(clusterid, {
+          x: clusterX,
+          y: (y1 + y2) / 2,
+          children,
+          childrenClusters,
+          clusterPosition: {
+            x1,
+            x2,
+            y1,
+            y2,
+            clusterX
+          }
+        });
+      }
+      const t = this.termOrder.find((t2) => t2.grp.type == "hierCluster" || t2.grp.name == this.hcTermGroup.name);
+      const y = (
+        // t.labelOffset is commented out because it is already handled in adjustSvgDimensions
+        t.grpIndex * s.rowgspace + t.prevGrpTotalIndex * s.rowh + t.totalHtAdjustments + s.margin.top + s.scrollHeight + // left dendrogram image must be lower than the top dendrogram image height
+        yDendrogramHeight
+      );
+      this.renderImage(this.api, this.dom.leftDendrogram, canvas, width, height, 0, y);
+      row.mergedClusters = mergedClusters;
+    }
+  }
+}
+async function renderImage(componentApi, g, canvas, width, height, x, y) {
+  const sequenceId = componentApi.getSequenceId();
+  const reader = new FileReader();
+  reader.addEventListener(
+    "load",
+    () => {
+      if (componentApi.isStaleSequenceId(sequenceId)) return;
+      g.selectAll("*").remove();
+      g.append("image").attr("x", x + 0.033).attr("y", y + 0.033).attr("xlink:href", reader.result).attr("width", width).attr("height", height);
+    },
+    false
+  );
+  const blob = await canvas.convertToBlob({ quality: 1 });
+  reader.readAsDataURL(blob);
+}
+function getHclustHeightScalefactor(lst, ph) {
+  let max = lst[0].height;
+  for (const h of lst) max = Math.max(max, h.height);
+  return ph / max;
+}
+function getLeafNumber(minus, inputOrder, order) {
+  const name = inputOrder[-minus - 1];
+  if (!name) throw "minus not in inputOrder";
+  const i = order.findIndex((j) => j.name == name);
+  if (i == -1) throw "name not found in hc$order";
+  return [name, i];
+}
+
+export {
+  maySetSandboxHeader,
+  plotDendrogramHclust,
+  renderImage,
+  hierCluster_renderers_exports
+};
+//# sourceMappingURL=chunk-CW2Q5EA7.js.map

package/dist/chunk-E7UJR2YK.js

@@ -0,0 +1,158 @@
+import {
+  appInit
+} from "./chunk-5WKIMNGG.js";
+import {
+  showErrorsWithCounter
+} from "./chunk-6FF5VLGO.js";
+import {
+  mclass
+} from "./chunk-EBKERML3.js";
+
+// plots/disco/launch.adhoc.ts
+async function launch(arg, genomeObj, holder) {
+  const [mlst, errors] = await getMlst(arg);
+  if (errors?.length) {
+    return showErrorsWithCounter(errors, holder);
+  }
+  const opts = {
+    holder,
+    vocabApi: {
+      // api is required by plot.app.js, so create a mock one for the adhoc data
+      vocab: { terms: [] },
+      main: () => {
+        return;
+      },
+      getTermdbConfig: () => {
+        return {};
+      }
+    },
+    state: {
+      args: {
+        data: mlst,
+        genome: genomeObj
+      },
+      plots: [
+        {
+          chartType: "Disco",
+          subfolder: "disco",
+          extension: "ts",
+          /** NOTE: Users should only override the settings in the default
+           * settings.Disco:{}, not the entire settings:{} object.*/
+          overrides: { Disco: arg?.settings || {} }
+        }
+      ]
+    }
+  };
+  const plotAppApi = await appInit(opts);
+  return plotAppApi;
+}
+async function getMlst(arg) {
+  if (Array.isArray(arg.mlst)) {
+    return [arg.mlst, null];
+  }
+  const mlst = [];
+  const errors = [];
+  if (arg.snvText) parseSnvText(arg.snvText, mlst, errors);
+  if (arg.svText) parseSvText(arg.svText, mlst, errors);
+  if (arg.cnvText) parseCnvText(arg.cnvText, mlst, errors);
+  return [mlst, errors];
+}
+function parseSnvText(text, mlst, errors) {
+  for (const line of text.trim().split("\n")) {
+    const l = line.trim().split("	");
+    if (l.length != 5) {
+      errors.push("snv input not equal to 5 columns");
+      continue;
+    }
+    let m;
+    try {
+      m = {
+        dt: 1,
+        chr: l[0],
+        position: Number(l[1]),
+        gene: l[2],
+        mname: l[3],
+        class: validateMutation(l[4], errors)
+      };
+    } catch (e) {
+      errors.push(e);
+      continue;
+    }
+    mlst.push(m);
+  }
+}
+function parseSvText(text, mlst, errors) {
+  for (const line of text.trim().split("\n")) {
+    const l = line.trim().split("	");
+    if (l.length < 4 || l.length > 6) {
+      errors.push("sv input not equal to 4 or 6 columns");
+      continue;
+    }
+    let m;
+    try {
+      const length = l.length;
+      if (length == 4) {
+        m = {
+          dt: 2,
+          chrA: l[0],
+          posA: Number(l[1]),
+          chrB: l[2],
+          posB: Number(l[3])
+        };
+      } else {
+        m = {
+          dt: 2,
+          chrA: l[0],
+          posA: Number(l[1]),
+          geneA: l[2],
+          chrB: l[3],
+          posB: Number(l[4]),
+          geneB: l[5]
+        };
+      }
+    } catch (e) {
+      errors.push(e);
+      continue;
+    }
+    mlst.push(m);
+  }
+}
+function parseCnvText(text, mlst, errors) {
+  for (const line of text.trim().split("\n")) {
+    const l = line.trim().split("	");
+    if (l.length != 4) {
+      errors.push("cnv input not equal to 4 columns");
+      continue;
+    }
+    let m;
+    try {
+      m = {
+        dt: 4,
+        chr: l[0],
+        start: Number(l[1]),
+        stop: Number(l[2]),
+        value: Number(l[3])
+      };
+    } catch (e) {
+      errors.push(e);
+      continue;
+    }
+    mlst.push(m);
+  }
+}
+function validateMutation(mutation, errors) {
+  const mut2check = mutation.toLowerCase();
+  const foundMutation = Object.values(mclass).find(
+    (m) => m.key.toLowerCase() === mut2check || m.label.toLowerCase() === mut2check
+  );
+  if (foundMutation) {
+    return foundMutation.key;
+  } else {
+    errors.push(`Invalid mutation class: ${mutation}`);
+  }
+}
+
+export {
+  launch
+};
+//# sourceMappingURL=chunk-E7UJR2YK.js.map

package/dist/chunk-ENZZUMVY.js

@@ -0,0 +1,215 @@
+import {
+  make_radios
+} from "./chunk-6FF5VLGO.js";
+import {
+  initBinConfig
+} from "./chunk-H5BIGL3W.js";
+import {
+  format
+} from "./chunk-OAWQ6LOO.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) {
+    if (this.q?.type != "regular-bin") 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-ENZZUMVY.js.map