@sjcrh/proteinpaint-client 2.224.2 → 2.226.0

package/dist/chunk-LMONIWPI.js

@@ -0,0 +1,30 @@
+import {
+  dtTermTypes,
+  migrateLegacyTvsOrigins
+} from "./chunk-T2W4JHWJ.js";
+
+// filter/rehydrateFilter.js
+function rehydrateFilter(filter, vocabApi, proms = []) {
+  if (Object.isFrozen(filter)) throw "filter obj is frozen, unable to rehydrate and modify";
+  if (filter.type == "tvslst") {
+    for (const f of filter.lst) rehydrateFilter(f, vocabApi, proms);
+  } else if (filter.type == "tvs") {
+    if (typeof filter.tvs?.term != "object") throw "a tvs lacks structure of .tvs.term{}";
+    if (dtTermTypes.has(filter.tvs.term.type)) migrateLegacyTvsOrigins(filter.tvs);
+    if (filter.tvs.term.id && !filter.tvs.term.name) {
+      proms.push(
+        vocabApi.getterm(filter.tvs.term.id).then((term) => {
+          filter.tvs.term = term;
+        })
+      );
+    }
+  } else {
+    throw `cannot rehydrate filter.type='${filter.type}'`;
+  }
+  return proms;
+}
+
+export {
+  rehydrateFilter
+};
+//# sourceMappingURL=chunk-LMONIWPI.js.map

package/dist/chunk-LTY7WOAT.js

@@ -0,0 +1,281 @@
+import {
+  getMclassSorter,
+  getSampleGroupSorter,
+  getSampleSorter,
+  getTermSorter
+} from "./chunk-ECCXTB5S.js";
+import {
+  setRelatedSamples
+} from "./chunk-C2MCQZWH.js";
+import {
+  filterVariantValues,
+  sample_match_termvaluesetting
+} from "./chunk-KUOXZIH4.js";
+import {
+  dtcnv,
+  dtfusionrna,
+  dtgeneexpression,
+  dtsnvindel
+} from "./chunk-2N345NXD.js";
+import {
+  __export
+} from "./chunk-HS5PO5ZQ.js";
+
+// plots/matrix/matrix.groups.js
+var matrix_groups_exports = {};
+__export(matrix_groups_exports, {
+  classifyValues: () => classifyValues,
+  getSampleGroups: () => getSampleGroups,
+  getSampleOrder: () => getSampleOrder,
+  getTermOrder: () => getTermOrder,
+  stackSiblingCellsByClass: () => stackSiblingCellsByClass
+});
+function getTermOrder(data) {
+  const s = this.settings.matrix;
+  this.termSorter = getTermSorter(this, s);
+  const termOrder = [];
+  let totalIndex = 0, visibleGrpIndex = 0, numClusterTerms = 0;
+  this.mclassSorter = getMclassSorter(this);
+  this.samplesByAncestorId = /* @__PURE__ */ new Map();
+  const seenAncestorSamples = /* @__PURE__ */ new Set();
+  for (const sd of data.lst) {
+    if (seenAncestorSamples.has(sd.sample)) continue;
+    seenAncestorSamples.add(sd.sample);
+    if (!sd._ref_?.ancestors) continue;
+    for (const a of sd._ref_.ancestors) {
+      const id = a.ancestor_id;
+      if (id === void 0) continue;
+      if (!this.samplesByAncestorId.has(id)) this.samplesByAncestorId.set(id, /* @__PURE__ */ new Set());
+      this.samplesByAncestorId.get(id).add(sd);
+    }
+  }
+  for (const [grpIndex, grp] of this.termGroups.entries()) {
+    const lst = [];
+    for (const [index, tw] of grp.lst.entries()) {
+      const counts = { samples: 0, hits: 0 };
+      const countedSamples = /* @__PURE__ */ new Set();
+      for (const sd of data.lst) {
+        if (countedSamples.has(sd.sample)) continue;
+        countedSamples.add(sd.sample);
+        const anno = sd[tw.$id];
+        if (anno) {
+          const { filteredValues, countedValues, renderedValues } = this.classifyValues(anno, tw, grp, s, sd);
+          anno.filteredValues = filteredValues;
+          anno.countedValues = countedValues;
+          anno.renderedValues = renderedValues;
+          if (anno.countedValues?.length) {
+            const v = tw.term.values?.[anno.value];
+            if (v?.uncountable) continue;
+            counts.samples += 1;
+            counts.hits += anno.countedValues.length;
+            if (tw.q?.mode == "continuous") {
+              const v2 = anno.value;
+              if (!("minval" in counts) || counts.minval > v2) counts.minval = v2;
+              if (!("maxval" in counts) || counts.maxval < v2) counts.maxval = v2;
+            }
+          }
+        }
+      }
+      if (grp.type != "hierCluster" || counts.samples) lst.push({ tw, counts, index });
+      if (grp.type == "hierCluster") numClusterTerms++;
+    }
+    const termSorter = grp.sortTermsBy || grp.type == "hierCluster" ? getTermSorter(this, s, grp) : this.termSorter;
+    const processedLst = lst.filter((t) => {
+      if ("minNumSamples" in t.tw) return t.tw.minNumSamples <= t.counts.samples;
+      if (!grp.settings) return true;
+      return !("minNumSamples" in grp.settings) || t.counts.samples >= grp.settings.minNumSamples;
+    }).sort(termSorter);
+    if (!processedLst.length) continue;
+    for (const [index, t] of processedLst.entries()) {
+      const { tw, counts } = t;
+      const ref = data.refs.byTermId[t.tw.$id] || {};
+      termOrder.push({
+        grp,
+        grpIndex,
+        visibleGrpIndex,
+        tw,
+        index,
+        // rendered index
+        lstIndex: t.index,
+        // as-listed index, before applying term filters
+        processedLst,
+        prevGrpTotalIndex: totalIndex,
+        totalIndex: totalIndex + index,
+        ref,
+        allCounts: counts
+        // note: term label will be assigned after sample counts are known
+        // label: t.tw.label || t.tw.term.name,
+      });
+    }
+    totalIndex += processedLst.length;
+    visibleGrpIndex += 1;
+  }
+  for (const [ancestor_id, samples] of this.samplesByAncestorId.entries()) {
+    if (samples.size < 2) this.samplesByAncestorId.delete(ancestor_id);
+  }
+  this.numTerms = termOrder.length;
+  this.numClusterTerms = numClusterTerms;
+  return termOrder;
+}
+function getSampleGroups(data) {
+  const s = this.settings.matrix;
+  const defaultSampleGrp = {
+    id: this.config.divideBy?.$id,
+    name: this.config.divideBy ? "Not annotated" : "",
+    lst: []
+  };
+  const sampleGroups = /* @__PURE__ */ new Map();
+  const term = this.config.divideBy?.term || {};
+  const $id = this.config.divideBy?.$id || "-";
+  const exclude = this.config.divideBy?.exclude || [];
+  const values = term.values || {};
+  const ref = data.refs.byTermId[$id] || {};
+  for (const row of data.lst) {
+    if ($id in row) {
+      const cell = row[$id];
+      const keys = term.type == "multivalue" && Array.isArray(cell.values) ? cell.values.map((v) => v.key) : [cell.key];
+      for (const key of keys) {
+        const name = key in values && values[key].label ? values[key].label : key;
+        if (!sampleGroups.has(key)) {
+          const grp = {
+            name: `${name}`,
+            // convert to a string
+            id: key,
+            lst: [],
+            tw: this.config.divideBy,
+            legendGroups: {},
+            isExcluded: exclude.includes(key)
+          };
+          if (ref.bins && s.sortSampleGrpsBy == "name") grp.order = ref.bins.findIndex((bin) => bin.name == key);
+          else delete grp.order;
+          sampleGroups.set(key, grp);
+        }
+        sampleGroups.get(key).lst.push(row);
+      }
+    } else {
+      defaultSampleGrp.lst.push(row);
+    }
+  }
+  const sampleGrpsArr = [...sampleGroups.values()];
+  const n = sampleGroups.size;
+  if (n > 100 && sampleGrpsArr.filter((sg) => sg.lst.length < 3).length > 0.8 * n) {
+    const l = s.controlLabels;
+    throw `Did not group ${l.samples} by "${term.name}": too many ${l.sample} groups (${n}), with the majority of groups having <= 2 ${l.samples} per group.`;
+  }
+  if (defaultSampleGrp.lst.length && !sampleGroups.size) {
+    sampleGroups.set(void 0, defaultSampleGrp);
+    sampleGrpsArr.push(...sampleGroups.values());
+  }
+  this.asListedSampleOrder = [];
+  for (const grp of sampleGrpsArr) {
+    this.asListedSampleOrder.push(...grp.lst.map((s2) => s2.sample));
+  }
+  const selectedDictTerms = this.termOrder.filter((t) => t.tw.sortSamples && t.tw.term.type != "geneVariant");
+  const noGrpSampleSorter = getSampleSorter(this, s, data.lst, {
+    skipSorter: (p, tw) => !p.types?.includes("geneVariant") && selectedDictTerms.find((t) => t.tw.$id === tw.$id)
+  });
+  const noGrpSampleOrder = data.lst.sort(noGrpSampleSorter);
+  const allowedSamples = noGrpSampleOrder.slice(0, s.maxSample);
+  const dataFilter = (d) => allowedSamples.includes(d);
+  const hitsPerSample = (t, c) => t + (typeof c == "object" && c.countedValues?.length ? 1 : 0);
+  const countHits = (total, d) => total + (Object.values(d).reduce(hitsPerSample, 0) ? 1 : 0);
+  const grpLstSampleSorter = getSampleSorter(this, s, data.lst);
+  for (const grp of sampleGrpsArr) {
+    grp.lst = grp.lst.filter(dataFilter);
+    grp.totalCountedValues = grp.lst.reduce(countHits, 0);
+    grp.lst.sort(grpLstSampleSorter);
+    if (this.config.chartType == "matrix" && s.sortBySampleAncestry) setRelatedSamples(grp);
+  }
+  const sampleGrpSorter = getSampleGroupSorter(this);
+  return sampleGrpsArr.sort(sampleGrpSorter);
+}
+function getSampleOrder(data) {
+  const s = this.settings.matrix;
+  this.visibleSampleGrps = /* @__PURE__ */ new Set();
+  const sampleOrder = [];
+  let total = 0, numHiddenGrps = 0;
+  for (const [grpIndex, grp] of this.sampleGroups.entries()) {
+    if (!grp.lst.length) continue;
+    if (grp.isExcluded) numHiddenGrps++;
+    let processedLst = grp.lst;
+    for (const [index, row] of processedLst.entries()) {
+      sampleOrder.push({
+        grp,
+        grpIndex: grpIndex - numHiddenGrps,
+        // : this.sampleGroups.length,
+        row,
+        index,
+        prevGrpTotalIndex: total,
+        totalIndex: total + index,
+        totalHtAdjustments: 0,
+        // may be required when transposed???
+        grpTotals: { htAdjustment: 0 },
+        // may be required when transposed???
+        processedLst
+      });
+    }
+    if (!grp.isExcluded) total += processedLst.length;
+    this.visibleSampleGrps.add(grp);
+  }
+  this.unfilteredSampleOrder = sampleOrder;
+  return sampleOrder.filter((so) => !so.grp.isExcluded);
+}
+function classifyValues(anno, tw, grp, s, sample) {
+  let values = "value" in anno ? [anno.value] : anno.values;
+  if (!values) return { filteredValues: null, countedValues: null, renderedValues: null };
+  if (tw.term.type == "geneVariant" && tw.q?.type == "values" && tw.q.variantFilter) {
+    values = filterVariantValues(values, tw.q.variantFilter);
+  }
+  const isSpecific = [tw.valueFilter || grp.valueFilter].filter((v) => v && true);
+  if (isSpecific.length && isSpecific[0].type !== "tvs" && isSpecific[0].type !== "tvslst")
+    throw `unknown matrix value filter type='${isSpecific.type}'`;
+  let filteredValues = !isSpecific.length ? values : values.filter((v) => sample_match_termvaluesetting(v, isSpecific[0], tw.term, sample));
+  const renderedValues = [];
+  if (tw.term.type == "geneVariant" && tw.q?.type == "values") {
+    filteredValues.sort(this.mclassSorter);
+    if (s.cellEncoding == "") renderedValues.push(...filteredValues);
+    else {
+      const sortedFilteredValues = [];
+      for (const dt of [dtcnv, dtsnvindel, dtfusionrna, dtgeneexpression]) {
+        const v = dt == dtgeneexpression ? filteredValues.find((v2) => v2.dt === dt) : filteredValues.find((v2) => v2.dt === dt && v2.class !== "WT" && v2.class !== "Blank");
+        if (v) renderedValues.push(v);
+        const oneDtV = filteredValues.filter((v2) => v2.dt === dt);
+        sortedFilteredValues.push(...oneDtV);
+      }
+      filteredValues = sortedFilteredValues;
+    }
+  } else {
+    renderedValues.push(...filteredValues);
+  }
+  return {
+    filteredValues,
+    countedValues: filteredValues.filter((v) => {
+      if (tw.term.type == "geneVariant") {
+        if (tw.q?.type == "predefined-groupset" || tw.q?.type == "custom-groupset") {
+          const groupset = tw.q.type == "predefined-groupset" ? tw.term.groupsetting.lst[tw.q.predefined_groupset_idx] : tw.q.customset;
+          if (!groupset) throw "groupset not found";
+          const group = groupset.groups[0];
+          if (v != group.name) return false;
+        } else {
+          if (v.class == "WT" || v.class == "Blank" || s.geneVariantCountSamplesSkipMclass.includes(v.class))
+            return false;
+        }
+      }
+      return true;
+    }),
+    renderedValues
+  };
+}
+function stackSiblingCellsByClass(a, b) {
+  return a.class === b.class ? 0 : a.class === "Blank" ? 1 : b.class == "Blank" ? -1 : a.class < b.class ? -1 : 1;
+}
+
+export {
+  getTermOrder,
+  getSampleGroups,
+  getSampleOrder,
+  classifyValues,
+  stackSiblingCellsByClass,
+  matrix_groups_exports
+};
+//# sourceMappingURL=chunk-LTY7WOAT.js.map

package/dist/chunk-LVFWXUUX.js

@@ -0,0 +1,34 @@
+// dom/eventImages.ts
+function renderEventImages(holder, images) {
+  holder.text("");
+  const buttons = holder.append("div").style("margin-bottom", "4px");
+  const preview = holder.append("div").attr("data-testid", "sjpp-event-image-preview").style("display", "none").style("margin-top", "5px");
+  let active = null;
+  const setActive = (button) => {
+    if (active)
+      active.attr("aria-pressed", "false").style("font-weight", "").style("background-color", "").style("color", "");
+    active = button;
+    if (button)
+      button.attr("aria-pressed", "true").style("font-weight", "bold").style("background-color", "#255398").style("color", "white");
+  };
+  for (const image of images) {
+    const button = buttons.append("button").attr("type", "button").attr("aria-pressed", "false").style("margin", "3px").text(image.label);
+    button.on("click", () => {
+      preview.selectAll("*").remove();
+      if (active == button) {
+        setActive(null);
+        preview.style("display", "none");
+        return;
+      }
+      setActive(button);
+      preview.style("display", "");
+      const div = preview.append("div").style("width", "min(800px, 75vw)").style("max-height", "70vh").style("overflow", "auto").style("border", "1px solid #ccc");
+      div.append("img").attr("alt", image.label).style("display", "block").style("width", "100%").on("error", () => div.text("Error: Could not display image")).attr("src", image.src);
+    });
+  }
+}
+
+export {
+  renderEventImages
+};
+//# sourceMappingURL=chunk-LVFWXUUX.js.map

package/dist/chunk-LVFWXUUX.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../dom/eventImages.ts"],
+  "sourcesContent": ["import type { EventImage } from '#types'\nimport type { Button, Elem } from '../types/d3'\n\n/*\nrenders the images of an event as buttons, clicking one shows the image as an inline preview below the buttons\n\nholder: d3 element, contents are replaced\nimages[]: {label, src}, from the termdb/mds3/eventImage route\n*/\nexport function renderEventImages(holder: Elem, images: EventImage[]) {\n\tholder.text('')\n\tconst buttons = holder.append('div').style('margin-bottom', '4px')\n\tconst preview = holder\n\t\t.append('div')\n\t\t.attr('data-testid', 'sjpp-event-image-preview')\n\t\t.style('display', 'none')\n\t\t.style('margin-top', '5px')\n\tlet active: Button | null = null\n\tconst setActive = (button: Button | null) => {\n\t\tif (active)\n\t\t\tactive.attr('aria-pressed', 'false').style('font-weight', '').style('background-color', '').style('color', '')\n\t\tactive = button\n\t\tif (button)\n\t\t\tbutton\n\t\t\t\t.attr('aria-pressed', 'true')\n\t\t\t\t.style('font-weight', 'bold')\n\t\t\t\t.style('background-color', '#255398')\n\t\t\t\t.style('color', 'white')\n\t}\n\tfor (const image of images) {\n\t\tconst button = buttons\n\t\t\t.append('button')\n\t\t\t.attr('type', 'button')\n\t\t\t.attr('aria-pressed', 'false')\n\t\t\t.style('margin', '3px')\n\t\t\t.text(image.label)\n\t\tbutton.on('click', () => {\n\t\t\tpreview.selectAll('*').remove()\n\t\t\tif (active == button) {\n\t\t\t\tsetActive(null)\n\t\t\t\tpreview.style('display', 'none')\n\t\t\t\treturn\n\t\t\t}\n\t\t\tsetActive(button)\n\t\t\tpreview.style('display', '')\n\t\t\tconst div = preview\n\t\t\t\t.append('div')\n\t\t\t\t.style('width', 'min(800px, 75vw)')\n\t\t\t\t.style('max-height', '70vh')\n\t\t\t\t.style('overflow', 'auto')\n\t\t\t\t.style('border', '1px solid #ccc')\n\t\t\tdiv\n\t\t\t\t.append('img')\n\t\t\t\t.attr('alt', image.label)\n\t\t\t\t.style('display', 'block')\n\t\t\t\t.style('width', '100%')\n\t\t\t\t.on('error', () => div.text('Error: Could not display image'))\n\t\t\t\t.attr('src', image.src)\n\t\t})\n\t}\n}\n"],
+  "mappings": ";AASO,SAAS,kBAAkB,QAAc,QAAsB;AACrE,SAAO,KAAK,EAAE;AACd,QAAM,UAAU,OAAO,OAAO,KAAK,EAAE,MAAM,iBAAiB,KAAK;AACjE,QAAM,UAAU,OACd,OAAO,KAAK,EACZ,KAAK,eAAe,0BAA0B,EAC9C,MAAM,WAAW,MAAM,EACvB,MAAM,cAAc,KAAK;AAC3B,MAAI,SAAwB;AAC5B,QAAM,YAAY,CAAC,WAA0B;AAC5C,QAAI;AACH,aAAO,KAAK,gBAAgB,OAAO,EAAE,MAAM,eAAe,EAAE,EAAE,MAAM,oBAAoB,EAAE,EAAE,MAAM,SAAS,EAAE;AAC9G,aAAS;AACT,QAAI;AACH,aACE,KAAK,gBAAgB,MAAM,EAC3B,MAAM,eAAe,MAAM,EAC3B,MAAM,oBAAoB,SAAS,EACnC,MAAM,SAAS,OAAO;AAAA,EAC1B;AACA,aAAW,SAAS,QAAQ;AAC3B,UAAM,SAAS,QACb,OAAO,QAAQ,EACf,KAAK,QAAQ,QAAQ,EACrB,KAAK,gBAAgB,OAAO,EAC5B,MAAM,UAAU,KAAK,EACrB,KAAK,MAAM,KAAK;AAClB,WAAO,GAAG,SAAS,MAAM;AACxB,cAAQ,UAAU,GAAG,EAAE,OAAO;AAC9B,UAAI,UAAU,QAAQ;AACrB,kBAAU,IAAI;AACd,gBAAQ,MAAM,WAAW,MAAM;AAC/B;AAAA,MACD;AACA,gBAAU,MAAM;AAChB,cAAQ,MAAM,WAAW,EAAE;AAC3B,YAAM,MAAM,QACV,OAAO,KAAK,EACZ,MAAM,SAAS,kBAAkB,EACjC,MAAM,cAAc,MAAM,EAC1B,MAAM,YAAY,MAAM,EACxB,MAAM,UAAU,gBAAgB;AAClC,UACE,OAAO,KAAK,EACZ,KAAK,OAAO,MAAM,KAAK,EACvB,MAAM,WAAW,OAAO,EACxB,MAAM,SAAS,MAAM,EACrB,GAAG,SAAS,MAAM,IAAI,KAAK,gCAAgC,CAAC,EAC5D,KAAK,OAAO,MAAM,GAAG;AAAA,IACxB,CAAC;AAAA,EACF;AACD;",
+  "names": []
+}

package/dist/chunk-LYDN734A.js

@@ -0,0 +1,194 @@
+import {
+  violinRenderer
+} from "./chunk-DPWSIN62.js";
+import {
+  getValueConversionFactor
+} from "./chunk-W5J3LTYS.js";
+import {
+  linear
+} from "./chunk-4OLM3KSB.js";
+import {
+  drag_default
+} from "./chunk-5R63Q5KH.js";
+import {
+  pointer_default,
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+
+// termsetting/handlers/NumericDensity.ts
+var NumericDensity = class {
+  constructor(opts) {
+    this.dom = {};
+    // WeakMap allows deletion of value when the object/DOM key is deleted,
+    // so better for avoiding memory leak
+    this.vrByDiv = /* @__PURE__ */ new WeakMap();
+    this.ranges = [];
+    this.no_density_data = false;
+    this.brushes = [];
+    this.plot_size = {
+      width: 500,
+      height: 100,
+      xpad: 10,
+      ypad: 20,
+      radius: 8
+    };
+    this.opts = opts;
+    this.termsetting = opts.termsetting;
+    this.tw = opts.termsetting.tw;
+  }
+  /* the boundary values exchanged with the bin/knot editors, and the domain of this.xscale, are in
+  	the term's user-facing unit; density_data is in the unit the values are stored in. only the two
+  	getters below cross that line, to put the plot's endpoints in the same unit as those values.
+  
+  	they multiply instead of calling toUserUnit(), which rounds: rounding is right for a number shown
+  	in an input, but a rounded domain endpoint distorts every scaled x by up to half of the last shown
+  	digit, and collapses the domain outright when the converted range is smaller than that (a stored
+  	range of under 2 days at scaleFactor=1/365.25). it would also disagree with violinRenderer, whose
+  	axis this plot's lines overlay and which scales its own domain unrounded */
+  get scaleFactor() {
+    return getValueConversionFactor(this.tw.term);
+  }
+  get displayMin() {
+    return this.density_data.min * this.scaleFactor;
+  }
+  get displayMax() {
+    return this.density_data.max * this.scaleFactor;
+  }
+  async setData() {
+    const self = this.termsetting;
+    const d = await self.vocabApi.getViolinBox(
+      {
+        plotType: "violin",
+        tw: { type: self.tw.type, term: self.term, q: self.q },
+        svgw: this.plot_size.width,
+        radius: this.plot_size.radius,
+        filter: self.filter
+      },
+      self.opts.getBodyParams?.()
+    );
+    if (d.error) throw d;
+    this.density_data = d;
+    return this.density_data;
+  }
+  async showViolin(div, boundaryOpts) {
+    await this.setData();
+    if (!this.vrByDiv.has(div)) {
+      div.style("padding", "5px").selectAll("*").remove();
+      const loadingDiv = div.append("div").style("padding", "10px").style("text-align", "center").html("Getting distribution data ...<br/>");
+      const densityDiv = div.append("div");
+      loadingDiv.remove();
+      const vr = new violinRenderer({
+        holder: densityDiv,
+        rd: this.density_data,
+        width: this.plot_size.width,
+        height: this.plot_size.height,
+        radius: this.plot_size.radius,
+        // axis ticks are labeled in the term's user-facing unit, e.g. years and not days
+        scaleFactor: this.scaleFactor
+      });
+      this.vrByDiv.set(div, vr);
+    }
+    this.vr = this.vrByDiv.get(div);
+    this.dom.svg = this.vr.svg;
+    this.vr.render();
+    if (boundaryOpts) await this.setBinLines(boundaryOpts);
+    return this.density_data;
+  }
+  async setBinLines(boundaryOpts) {
+    if (this.density_data.max == this.density_data.min) {
+      this.handleNoDensity();
+    } else {
+      if (this.dom.binsize_g) this.dom.binsize_g.selectAll("*").remove();
+      this.dom.binsize_g = this.dom.svg.append("g").attr("transform", `translate(${this.plot_size.xpad}, ${this.plot_size.ypad})`).attr("class", "binsize_g");
+      const maxvalue = this.displayMax;
+      const minvalue = this.displayMin;
+      this.xscale = linear().domain([minvalue, maxvalue]).range([this.plot_size.xpad, this.plot_size.width + this.plot_size.xpad]);
+      this.ranges = [];
+      this.brushes = [];
+      this.renderBinLines(boundaryOpts);
+    }
+  }
+  handleNoDensity() {
+    this.no_density_data = true;
+    this.ranges = [];
+    this.brushes = [];
+  }
+  renderBinLines(boundaryOpts) {
+    const { plot_size, tw, xscale, scaleFactor } = this;
+    if (!this.density_data) throw `Missing .density_data [density.ts, renderBinLines()]`;
+    const scaledMinX = Math.round(this.xscale(this.displayMin));
+    const scaledMaxX = Math.round(this.xscale(this.displayMax));
+    const lines = [];
+    for (const [index, v] of boundaryOpts.values.entries()) {
+      lines.push({ ...v, index, scaledX: Math.round(this.xscale(v.x)) });
+    }
+    const lastVisibleLine = lines.find((l) => l.isLastVisibleLine);
+    const lastVisibleScaledX = lastVisibleLine ? lastVisibleLine.scaledX : scaledMaxX;
+    const dragger = drag_default().on("drag", onDrag).on("end", onDrag);
+    this.dom.binsize_g.selectAll("line").remove();
+    this.dom.binsize_g.selectAll("line").data(lines).enter().append("line").style("stroke", (d) => d.isDraggable ? "#cc0000" : "#555").style("stroke-width", 1).attr("x1", (d) => d.scaledX).attr("y1", 0).attr("x2", (d) => d.scaledX).attr("y2", plot_size.height).style("cursor", (d) => d.isDraggable ? "ew-resize" : "").attr("display", (d) => !d.isDraggable && d.scaledX > lastVisibleScaledX ? "none" : "").on("mouseover", function(_, d) {
+      if (d.isDraggable) select_default(this).style("stroke-width", 3);
+    }).on("mouseout", function() {
+      select_default(this).style("stroke-width", 1);
+    }).each(function(d) {
+      if (d.isDraggable) select_default(this).call(dragger);
+    });
+    const lineElems = this.dom.binsize_g.node().querySelectorAll("line");
+    function toBoundaryValue(x) {
+      const inverted = xscale.invert(x);
+      return Number(
+        scaleFactor != 1 ? inverted.toFixed(2) : tw.term.type == "integer" ? Math.round(inverted) : inverted.toFixed(3)
+      );
+    }
+    function toLineValue(line) {
+      return line.draggedX === void 0 ? line.x : toBoundaryValue(line.draggedX);
+    }
+    function getNeighbors(d) {
+      const x = d.draggedX ?? d.scaledX;
+      let lower, upper;
+      for (const line of lines) {
+        if (line.index === d.index || !line.isDraggable) continue;
+        const lineX = line.draggedX ?? line.scaledX;
+        if (lineX <= x) {
+          if (!lower || lineX > (lower.draggedX ?? lower.scaledX)) lower = line;
+        } else if (!upper || lineX < (upper.draggedX ?? upper.scaledX)) upper = line;
+      }
+      return [lower, upper];
+    }
+    function onDrag(event, _d) {
+      const d = _d;
+      const [lower, upper] = getNeighbors(d);
+      const lowerX = Math.max(scaledMinX, lower ? lower.draggedX ?? lower.scaledX : scaledMinX);
+      const upperX = Math.min(scaledMaxX, upper ? upper.draggedX ?? upper.scaledX : scaledMaxX);
+      if (upperX - lowerX < 2) return;
+      const draggedX = Math.min(Math.max(pointer_default(event, this)[0], lowerX + 1), upperX - 1);
+      const value = toBoundaryValue(draggedX);
+      if (lower && value === toLineValue(lower)) return;
+      if (upper && value === toLineValue(upper)) return;
+      d.draggedX = draggedX;
+      select_default(this).attr("x1", d.draggedX).attr("y1", 0).attr("x2", d.draggedX).attr("y2", plot_size.height);
+      const lastVisibleScaledX2 = lastVisibleLine?.draggedX ?? lastVisibleLine?.scaledX ?? scaledMaxX;
+      const xOffset = d.draggedX - d.scaledX;
+      if (xOffset) {
+        for (const elem of lineElems) {
+          const c = elem.__data__;
+          if (c.movesWithLineIndex !== d.index) continue;
+          c.draggedX = c.scaledX + xOffset;
+          select_default(elem).attr("x1", c.draggedX).attr("x2", c.draggedX).style("display", c.draggedX >= lastVisibleScaledX2 ? "none" : "");
+        }
+        boundaryOpts.callback(d, value);
+      }
+    }
+  }
+  destroy() {
+    for (const [k, v] of Object.entries(this.dom)) {
+      delete this.dom[k];
+      if (typeof v.remove == "function") v.remove();
+    }
+  }
+};
+
+export {
+  NumericDensity
+};
+//# sourceMappingURL=chunk-LYDN734A.js.map