@sjcrh/proteinpaint-client 2.204.0 → 2.206.0

package/dist/chunk-5ILEFNXJ.js

@@ -0,0 +1,402 @@
+import {
+  CATEGORICAL,
+  COHORT,
+  CONDITION,
+  DATE,
+  DNA_METHYLATION,
+  FLOAT,
+  GENE_EXPRESSION,
+  GENE_VARIANT,
+  INTEGER,
+  ISOFORM_EXPRESSION,
+  JUNCTION,
+  METABOLITE_INTENSITY,
+  MULTIVALUE,
+  PROTEOME_ABUNDANCE,
+  PSEUDOBULK,
+  SAMPLELST,
+  SINGLECELL_CELLTYPE,
+  SINGLECELL_GENE_EXPRESSION,
+  SNP,
+  SNP_LIST,
+  SNP_LOCUS,
+  SSGSEA,
+  SURVIVAL,
+  TERM_COLLECTION,
+  TermTypeGroups,
+  dtTerms,
+  dtdnamethylation,
+  dtgeneexpression,
+  dtmetaboliteintensity,
+  dtproteomeabundance,
+  dtssgsea
+} from "./chunk-IZUYLFOX.js";
+
+// ../shared/utils/dist/src/terms.js
+var ROOT_SAMPLE_TYPE = 1;
+var DEFAULT_SAMPLE_TYPE = 2;
+var NumericModes = {
+  continuous: "continuous",
+  discrete: "discrete"
+};
+var dtTermTypes = new Set(dtTerms.map((t) => t.type));
+var TermTypes2Dt = {
+  [GENE_EXPRESSION]: dtgeneexpression,
+  [SSGSEA]: dtssgsea,
+  [DNA_METHYLATION]: dtdnamethylation,
+  [METABOLITE_INTENSITY]: dtmetaboliteintensity,
+  [PROTEOME_ABUNDANCE]: dtproteomeabundance
+};
+var typeGroup = {
+  [CATEGORICAL]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [CONDITION]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [FLOAT]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [INTEGER]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [SAMPLELST]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [SURVIVAL]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [DATE]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [MULTIVALUE]: TermTypeGroups.DICTIONARY_VARIABLES,
+  [GENE_VARIANT]: TermTypeGroups.MUTATION_CNV_FUSION,
+  [SNP]: TermTypeGroups.SNP,
+  [SNP_LIST]: TermTypeGroups.SNP_LIST,
+  [SNP_LOCUS]: TermTypeGroups.SNP_LOCUS,
+  [GENE_EXPRESSION]: TermTypeGroups.GENE_EXPRESSION,
+  [ISOFORM_EXPRESSION]: TermTypeGroups.ISOFORM_EXPRESSION,
+  [JUNCTION]: TermTypeGroups.SPLICE_JUNCTION,
+  [SSGSEA]: TermTypeGroups.SSGSEA,
+  [DNA_METHYLATION]: TermTypeGroups.DNA_METHYLATION,
+  [METABOLITE_INTENSITY]: TermTypeGroups.METABOLITE_INTENSITY,
+  [PROTEOME_ABUNDANCE]: TermTypeGroups.PROTEOME_ABUNDANCE,
+  [PSEUDOBULK]: TermTypeGroups.PSEUDOBULK,
+  [TERM_COLLECTION]: TermTypeGroups.TERM_COLLECTION,
+  [SINGLECELL_CELLTYPE]: TermTypeGroups.SINGLECELL_CELLTYPE,
+  [SINGLECELL_GENE_EXPRESSION]: TermTypeGroups.SINGLECELL_GENE_EXPRESSION,
+  [COHORT]: TermTypeGroups.COHORT
+};
+var nonDictTypes = /* @__PURE__ */ new Set([
+  SNP,
+  SNP_LIST,
+  SNP_LOCUS,
+  GENE_EXPRESSION,
+  ISOFORM_EXPRESSION,
+  JUNCTION,
+  SSGSEA,
+  DNA_METHYLATION,
+  GENE_VARIANT,
+  METABOLITE_INTENSITY,
+  PROTEOME_ABUNDANCE,
+  PSEUDOBULK,
+  SINGLECELL_CELLTYPE,
+  SINGLECELL_GENE_EXPRESSION,
+  COHORT
+]);
+for (const dtTermType of dtTermTypes) {
+  nonDictTypes.add(dtTermType);
+}
+var numericTypes = /* @__PURE__ */ new Set([
+  INTEGER,
+  FLOAT,
+  GENE_EXPRESSION,
+  ISOFORM_EXPRESSION,
+  JUNCTION,
+  SSGSEA,
+  DNA_METHYLATION,
+  METABOLITE_INTENSITY,
+  PROTEOME_ABUNDANCE,
+  SINGLECELL_GENE_EXPRESSION,
+  DATE,
+  PSEUDOBULK
+]);
+var dictionaryNumericTypes = /* @__PURE__ */ new Set([INTEGER, FLOAT, DATE]);
+var categoricalTypes = /* @__PURE__ */ new Set([CATEGORICAL, SNP]);
+var singleCellTerms = /* @__PURE__ */ new Set([
+  SINGLECELL_CELLTYPE,
+  SINGLECELL_GENE_EXPRESSION
+  /*PSEUDOBULK*/
+]);
+function isSingleCellTerm(term) {
+  if (!term) return false;
+  return singleCellTerms.has(term.type);
+}
+function isNumericTerm(term) {
+  if (!term) return false;
+  return numericTypes.has(term.type);
+}
+function isNumericTw(tw) {
+  if (!tw?.term) return false;
+  return isNumericTerm(tw.term) || tw.term.type === TERM_COLLECTION && tw.term.memberType === "numeric" && tw.type === "TermCollectionTWFraction";
+}
+function isCategoricalTerm(term) {
+  if (!term) return false;
+  return categoricalTypes.has(term.type);
+}
+function isDictionaryType(type) {
+  return !isNonDictionaryType(type);
+}
+function isNonDictionaryType(type) {
+  if (!type) throw new Error("Type is not defined");
+  return nonDictTypes.has(type);
+}
+function isNumTermCollection(term) {
+  if (!term || !term.type) throw new Error("Term or term type is not defined");
+  return term.type === TERM_COLLECTION;
+}
+function equals(t1, t2) {
+  if (!t1) throw new Error("First term is not defined ");
+  if (!t2) throw new Error("Second term is not defined ");
+  if (t1.type !== t2.type) return false;
+  if (isDictionaryType(t1.type) && isDictionaryType(t2.type) && t1.type != SAMPLELST) return t1.id === t2.id;
+  switch (t1.type) {
+    case GENE_EXPRESSION:
+      return t1.gene == t2.gene;
+    case ISOFORM_EXPRESSION:
+      return t1.isoform == t2.isoform;
+    case JUNCTION:
+      return t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop && t1.strand == t2.strand;
+    case SSGSEA:
+      return t1.id == t2.id;
+    case DNA_METHYLATION:
+      return t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop;
+    case METABOLITE_INTENSITY:
+    case PROTEOME_ABUNDANCE:
+      return t1.name == t2.name;
+    case GENE_VARIANT:
+      return t1.gene == t2.gene || t1.chr == t2.chr && t1.start == t2.start && t1.stop == t2.stop;
+    // TO DO: Add more cases
+    // case SNP_LIST:
+    // case SNP_LOCUS:
+    // case SAMPLELST:
+    default:
+      return false;
+  }
+}
+function trimGvTermCopy(term, q) {
+  if (term?.type != GENE_VARIANT) return term;
+  delete term.childTerms;
+  if (q?.customset) clearGroupsetParentTerms(q.customset);
+  const lst = term.groupsetting?.lst;
+  if (!lst?.length) return term;
+  if (q?.type == "predefined-groupset") {
+    const idx = q.predefined_groupset_idx;
+    term.groupsetting.lst = lst.map((groupset, i) => i === idx ? groupset : null);
+    clearDtTermMnames(term.groupsetting.lst[idx]);
+    clearGroupsetParentTerms(term.groupsetting.lst[idx]);
+  } else {
+    delete term.groupsetting.lst;
+  }
+  return term;
+}
+function forEachGvTw(obj, callback) {
+  if (!obj || typeof obj != "object") return;
+  if (obj.q && obj.term?.type == GENE_VARIANT) callback(obj);
+  for (const value of Object.values(obj)) forEachGvTw(value, callback);
+}
+function trimGvTermsForSave(obj) {
+  forEachGvTw(obj, (tw) => {
+    delete tw.term.childTerms;
+    delete tw.term.groupsetting;
+    if (tw.q.customset) clearGroupsetParentTerms(tw.q.customset);
+  });
+  return obj;
+}
+function getGvGeneKey(term) {
+  const genes = term?.genes?.length ? term.genes : term ? [term] : [];
+  const keys = genes.map((gene) => {
+    if (getGvGeneKind(gene) == "coord") {
+      const region = getGvQueryRegion(gene);
+      return region ? `${region.chr}:${region.start + 1}-${region.stop}` : void 0;
+    }
+    return gene.gene || gene.name;
+  }).filter((key) => typeof key == "string" && key);
+  if (!keys.length || keys.length != genes.length) return "";
+  return keys.sort().join(",");
+}
+var gvQCacheKeyPrefix = "gv:";
+function getGvQCacheKey(term) {
+  const key = getGvGeneKey(term);
+  return key ? gvQCacheKeyPrefix + key : "";
+}
+function getGvGeneKind(gene) {
+  if (gene?.kind) return gene.kind;
+  if (gene?.gene || gene?.name && !gene.chr) return "gene";
+  if (gene?.chr) return "coord";
+  return void 0;
+}
+function trimGvQForCache(q) {
+  const copy = structuredClone(q);
+  delete copy.isAtomic;
+  delete copy.hiddenValues;
+  delete copy.dtLst;
+  if (copy.customset) {
+    clearDtTermMnames(copy.customset);
+    clearGroupsetParentTerms(copy.customset);
+  }
+  return copy;
+}
+function getGvQueryRegion(gene) {
+  if (!gene?.chr || !Number.isInteger(gene.start) || !Number.isInteger(gene.stop)) return;
+  return { chr: gene.chr, start: gene.start, stop: gene.stop };
+}
+function restoreGvQueryEntry(v, queries) {
+  if (!queries || v?.$q === void 0) return false;
+  Object.assign(v, queries[v.$q]);
+  delete v.$q;
+  return true;
+}
+function matchesGvQueryEntry(entry, v) {
+  if (entry.gene) return entry.gene == v.gene;
+  const r = entry.region;
+  if (r) return !!v.region && r.chr == v.region.chr && r.start == v.region.start && r.stop == v.region.stop;
+  return true;
+}
+function setGroupsetParentTerms(groupset, term) {
+  if (term?.type != GENE_VARIANT) throw "parent of a groupset tvs must be a geneVariant term";
+  const parentTerm = structuredClone(term);
+  delete parentTerm.childTerms;
+  delete parentTerm.groupsetting;
+  walkTvs(groupset, (tvs) => {
+    if (!dtTermTypes.has(tvs.term?.type)) throw `groupset tvs term is not a dt term`;
+    tvs.term.parentTerm = parentTerm;
+  });
+  return groupset;
+}
+function clearGroupsetParentTerms(groupset) {
+  walkTvs(groupset, (tvs) => {
+    if (tvs.term) delete tvs.term.parentTerm;
+  });
+  return groupset;
+}
+function walkTvs(obj, fn) {
+  if (!obj || typeof obj != "object") return;
+  if (obj.type == "tvs" && obj.tvs) {
+    fn(obj.tvs);
+    return;
+  }
+  for (const k in obj) walkTvs(obj[k], fn);
+}
+function getDtsFromGroups(groups) {
+  const dts = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    for (const dt of getDtsFromFilter(group.filter)) dts.add(dt);
+  }
+  return [...dts];
+}
+function getDtsFromFilter(filter) {
+  const dts = /* @__PURE__ */ new Set();
+  for (const item of filter.lst) {
+    if (item.type == "tvslst") {
+      for (const dt of getDtsFromFilter(item)) dts.add(dt);
+    } else {
+      dts.add(item.tvs.term.dt);
+    }
+  }
+  return dts;
+}
+function clearDtTermMnames(obj) {
+  walkTvs(obj, (tvs) => {
+    if (tvs.term) delete tvs.term.mnames;
+  });
+  return obj;
+}
+var typeMap = {
+  categorical: "Categorical",
+  condition: "Condition",
+  float: "Numerical",
+  integer: "Numerical",
+  date: "Date",
+  geneExpression: "Gene Expression",
+  isoformExpression: "Isoform Expression",
+  [JUNCTION]: "Splice junction",
+  ssGSEA: "Geneset Expression",
+  dnaMethylation: "DNA Methylation",
+  geneVariant: "Gene Variant",
+  metaboliteIntensity: "Metabolite Intensity",
+  proteomeAbundance: "Proteome Abundance",
+  proteomeDAP: "Proteome DAP",
+  multivalue: "Multi Value",
+  singleCellGeneExpression: "Single Cell, Gene Expression",
+  singleCellCellType: "Single Cell, Cell Type",
+  snplocus: "SNP Locus",
+  snp: "SNP",
+  snplst: "SNP List",
+  termCollection: "Term Collection"
+};
+function termItemType(t) {
+  switch (t.type) {
+    case JUNCTION:
+      return "Splice junction";
+    case GENE_EXPRESSION:
+    case SINGLECELL_GENE_EXPRESSION:
+      return "Gene";
+    case ISOFORM_EXPRESSION:
+      return "Isoform";
+    case SSGSEA:
+      return "Gene set";
+    case METABOLITE_INTENSITY:
+      return "Metabolite";
+    // keep adding here
+    default:
+      return "Variable";
+  }
+}
+function termType2label(type) {
+  const s = typeMap[type];
+  if (s) return s;
+  throw new Error("termType2label(): unknown value");
+}
+function getDateFromNumber(value) {
+  const year = Math.floor(value);
+  const january1st = new Date(year, 0, 1);
+  const totalDays = getDaysInYear(year);
+  const time = Math.round((value - year) * totalDays) * oneDayTime;
+  const date = new Date(january1st.getTime() + time);
+  return date;
+}
+var oneDayTime = 24 * 60 * 60 * 1e3;
+function getDateStrFromNumber(value) {
+  const date = getDateFromNumber(value);
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long"
+  });
+}
+function getDaysInYear(year) {
+  const isLeap = new Date(year, 1, 29).getMonth() === 1;
+  const days = isLeap ? 366 : 365;
+  return days;
+}
+
+export {
+  ROOT_SAMPLE_TYPE,
+  DEFAULT_SAMPLE_TYPE,
+  NumericModes,
+  dtTermTypes,
+  TermTypes2Dt,
+  typeGroup,
+  numericTypes,
+  dictionaryNumericTypes,
+  isSingleCellTerm,
+  isNumericTerm,
+  isNumericTw,
+  isCategoricalTerm,
+  isDictionaryType,
+  isNonDictionaryType,
+  isNumTermCollection,
+  equals,
+  trimGvTermCopy,
+  forEachGvTw,
+  trimGvTermsForSave,
+  gvQCacheKeyPrefix,
+  getGvQCacheKey,
+  trimGvQForCache,
+  restoreGvQueryEntry,
+  matchesGvQueryEntry,
+  setGroupsetParentTerms,
+  getDtsFromGroups,
+  clearDtTermMnames,
+  termItemType,
+  termType2label,
+  getDateFromNumber,
+  getDateStrFromNumber
+};
+//# sourceMappingURL=chunk-5ILEFNXJ.js.map

package/dist/chunk-5UO7MKCO.js

@@ -0,0 +1,59 @@
+import {
+  plotColor
+} from "./chunk-IZUYLFOX.js";
+
+// plots/scatter/settings/defaults.ts
+function getDefaultScatterSettings(opts = {}) {
+  const overrides = opts?.overrides || {};
+  const defaults = {
+    size: 0.8,
+    minShapeSize: 0.5,
+    maxShapeSize: 4,
+    scaleDotOrder: "Ascending",
+    refSize: 0.8,
+    svgw: 600,
+    svgh: 600,
+    svgd: 600,
+    axisTitleFontSize: 16,
+    showAxes: true,
+    showRef: true,
+    opacity: 0.6,
+    defaultColor: plotColor,
+    regression: "None",
+    fov: 50,
+    threeSize: 5e-3,
+    threeFOV: 70,
+    //ColorScale settings
+    colorScaleMode: "auto",
+    colorScalePercentile: 95,
+    colorScaleMinFixed: null,
+    colorScaleMaxFixed: null,
+    //3D Plot settings
+    showContour: false,
+    colorContours: false,
+    contourBandwidth: 30,
+    contourThresholds: 10,
+    duration: 500,
+    useGlobalMinMax: true,
+    saveZoomTransform: false,
+    // Axis scale settings
+    minXScale: null,
+    maxXScale: null,
+    minYScale: null,
+    maxYScale: null,
+    itemLabel: opts?.singleCellPlot ? "Cell" : "Sample",
+    maxTooltipRows: 5
+  };
+  return Object.assign(defaults, overrides);
+}
+var maxSvgSamplesCutoff = 2e4;
+var noExpColor = "#F5F5F5";
+var expColor = "#ff000d";
+
+export {
+  getDefaultScatterSettings,
+  maxSvgSamplesCutoff,
+  noExpColor,
+  expColor
+};
+//# sourceMappingURL=chunk-5UO7MKCO.js.map

package/dist/chunk-7R7P6VMT.js

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