@sjcrh/proteinpaint-client 2.182.0 → 2.183.0

package/dist/chunk-L4QG7XZE.js

@@ -0,0 +1,46 @@
+// ../shared/utils/src/roundValue.js
+function roundValue(value, digits) {
+  const v = Number(value);
+  if (Number.isInteger(v)) return v;
+  if (Math.abs(v) < 1) return Number(v.toPrecision(digits));
+  return Number(v.toFixed(digits));
+}
+function roundValueAuto(value, format = false, defaultDigits = 2) {
+  if (!value && value != 0) return value;
+  const dp = decimalPlacesUntilFirstNonZero(value);
+  const digits = Math.abs(value) > 1 ? defaultDigits : dp > 0 ? dp + 1 : defaultDigits;
+  if (format) return formatValue(value, digits);
+  return roundValue(value, digits);
+}
+function decimalPlacesUntilFirstNonZero(number) {
+  const numberStr = number.toString();
+  const decimalIndex = numberStr.indexOf(".");
+  if (decimalIndex === -1 || decimalIndex === numberStr.length - 1) {
+    return 0;
+  }
+  let decimalPlaces = 0;
+  for (let i = decimalIndex + 1; i < numberStr.length; i++) {
+    if (numberStr[i] === "0") {
+      decimalPlaces++;
+    } else if (numberStr[i] >= "1" && numberStr[i] <= "9") {
+      break;
+    }
+  }
+  return decimalPlaces;
+}
+function formatValue(value, digits) {
+  const v = Number(value);
+  if (Number.isInteger(v)) return v;
+  const abs = Math.abs(v);
+  if (abs < 1 || abs > 9999) {
+    return abs > 9999 ? v.toPrecision(digits) : Number(v.toPrecision(digits));
+  }
+  return Number(v.toFixed(digits));
+}
+
+export {
+  roundValue,
+  roundValueAuto,
+  decimalPlacesUntilFirstNonZero
+};
+//# sourceMappingURL=chunk-L4QG7XZE.js.map

package/dist/chunk-L4QG7XZE.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../shared/utils/src/roundValue.js"],
+  "sourcesContent": ["/*\nround a value to specified digits\n    - if value is integer, value is returned\n    - if value is a fractional float, round to precision\n    - if value is not a fractional float, round to decimal point\n    - TODO: handle scientific notation\nvalue: given value\ndigits: number of digits to round to\n*/\n\nexport function roundValue(value, digits) {\n\tconst v = Number(value)\n\tif (Number.isInteger(v)) return v\n\tif (Math.abs(v) < 1) return Number(v.toPrecision(digits))\n\treturn Number(v.toFixed(digits))\n}\n\n/** Rounds numbers to the appropriate decimal point\n * if format is true, returns either a number or string in\n * scientific notation.\n *\n * TODO: Review digit logic.\n */\n\nexport function roundValueAuto(value, format = false, defaultDigits = 2) {\n\tif (!value && value != 0) return value\n\tconst dp = decimalPlacesUntilFirstNonZero(value)\n\tconst digits =\n\t\tMath.abs(value) > 1 ? defaultDigits : dp > 0 ? dp + 1 : defaultDigits\n\tif (format) return formatValue(value, digits)\n\treturn roundValue(value, digits)\n}\n\nexport function decimalPlacesUntilFirstNonZero(number) {\n\t// Convert number to string\n\tconst numberStr = number.toString()\n\n\t// Find the position of the decimal point\n\tconst decimalIndex = numberStr.indexOf(\".\")\n\n\t// If decimal point is not found or number is an integer, return 0\n\tif (decimalIndex === -1 || decimalIndex === numberStr.length - 1) {\n\t\treturn 0\n\t}\n\n\t// Iterate through characters after the decimal point\n\tlet decimalPlaces = 0\n\tfor (let i = decimalIndex + 1; i < numberStr.length; i++) {\n\t\t// Increment the count of decimal places until a non-zero digit is found\n\t\tif (numberStr[i] === \"0\") {\n\t\t\tdecimalPlaces++\n\t\t} else if (numberStr[i] >= \"1\" && numberStr[i] <= \"9\") {\n\t\t\tbreak\n\t\t}\n\t}\n\n\treturn decimalPlaces\n}\n\n/* \nsimple logic to return a number close to original while rounding up decimals.\nsupplements roundValueAuto which rounds 12345 to 1.2e4 which is only suitable for human quick glance but not subsequent computing\n\nTODO:\n10000 and 10001 to 1e4\n0.00001 to 1e-5\n1.00001 to 1\n*/\nexport function roundValue2(value) {\n\tif (!Number.isFinite(value)) return value // not a number\n\tif (Number.isInteger(value)) return value // is integer, do not convert\n\tconst abs = Math.abs(value)\n\tif (abs > 100) return Math.round(value) // 12345.1234 to 12345 (compared to 1.2e4 from roundValueAuto)\n\tif (abs > 10) return Number(value.toFixed(1)) // 99.1234 to 99.1\n\tif (abs > 1) return Number(value.toFixed(2)) // 9.1234 to 9.12\n\tif (abs > 0.1) return Number(value.toFixed(3)) // 0.12345 to 0.123\n\tif (abs > 0.01) return Number(value.toFixed(4)) // 0.012345 to 0.0123\n\treturn value // as is\n}\n\n/** Use to return displayed values in scientific notation\n * Do not use for values intended for calculation later.\n */\nexport function formatValue(value, digits) {\n\tconst v = Number(value)\n\tif (Number.isInteger(v)) return v\n\tconst abs = Math.abs(v)\n\tif (abs < 1 || abs > 9999) {\n\t\t//Number() reverts positive values less than 10^21 to a whole number\n\t\t//To return the value in scientific notation, use toPrecision without Number()\n\t\treturn abs > 9999 ? v.toPrecision(digits) : Number(v.toPrecision(digits))\n\t}\n\treturn Number(v.toFixed(digits))\n}\n"],
+  "mappings": ";AAUO,SAAS,WAAW,OAAO,QAAQ;AACzC,QAAM,IAAI,OAAO,KAAK;AACtB,MAAI,OAAO,UAAU,CAAC,EAAG,QAAO;AAChC,MAAI,KAAK,IAAI,CAAC,IAAI,EAAG,QAAO,OAAO,EAAE,YAAY,MAAM,CAAC;AACxD,SAAO,OAAO,EAAE,QAAQ,MAAM,CAAC;AAChC;AASO,SAAS,eAAe,OAAO,SAAS,OAAO,gBAAgB,GAAG;AACxE,MAAI,CAAC,SAAS,SAAS,EAAG,QAAO;AACjC,QAAM,KAAK,+BAA+B,KAAK;AAC/C,QAAM,SACL,KAAK,IAAI,KAAK,IAAI,IAAI,gBAAgB,KAAK,IAAI,KAAK,IAAI;AACzD,MAAI,OAAQ,QAAO,YAAY,OAAO,MAAM;AAC5C,SAAO,WAAW,OAAO,MAAM;AAChC;AAEO,SAAS,+BAA+B,QAAQ;AAEtD,QAAM,YAAY,OAAO,SAAS;AAGlC,QAAM,eAAe,UAAU,QAAQ,GAAG;AAG1C,MAAI,iBAAiB,MAAM,iBAAiB,UAAU,SAAS,GAAG;AACjE,WAAO;AAAA,EACR;AAGA,MAAI,gBAAgB;AACpB,WAAS,IAAI,eAAe,GAAG,IAAI,UAAU,QAAQ,KAAK;AAEzD,QAAI,UAAU,CAAC,MAAM,KAAK;AACzB;AAAA,IACD,WAAW,UAAU,CAAC,KAAK,OAAO,UAAU,CAAC,KAAK,KAAK;AACtD;AAAA,IACD;AAAA,EACD;AAEA,SAAO;AACR;AA0BO,SAAS,YAAY,OAAO,QAAQ;AAC1C,QAAM,IAAI,OAAO,KAAK;AACtB,MAAI,OAAO,UAAU,CAAC,EAAG,QAAO;AAChC,QAAM,MAAM,KAAK,IAAI,CAAC;AACtB,MAAI,MAAM,KAAK,MAAM,MAAM;AAG1B,WAAO,MAAM,OAAO,EAAE,YAAY,MAAM,IAAI,OAAO,EAAE,YAAY,MAAM,CAAC;AAAA,EACzE;AACA,SAAO,OAAO,EAAE,QAAQ,MAAM,CAAC;AAChC;",
+  "names": []
+}

package/dist/chunk-L4YGMXLX.js

@@ -0,0 +1,37 @@
+import {
+  addGeneSearchbox,
+  getGEunit
+} from "./chunk-OXJ2TWDO.js";
+import {
+  Menu
+} from "./chunk-A6TQGNDQ.js";
+import {
+  TermTypes
+} from "./chunk-6ITDJ5UR.js";
+
+// termdb/handlers/geneExpression.ts
+var SearchHandler = class {
+  init(opts) {
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: opts.genomeObj,
+      row: holder,
+      searchOnly: "gene",
+      callback: () => this.selectGene(geneSearch.geneSymbol)
+    });
+  }
+  async selectGene(gene) {
+    const unit = getGEunit(this.app.vocabApi);
+    const name = `${gene} ${unit}`;
+    if (!gene) throw new Error("No gene selected");
+    this.callback({ gene, name, type: TermTypes.GENE_EXPRESSION });
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-L4YGMXLX.js.map

package/dist/chunk-L4YGMXLX.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../termdb/handlers/geneExpression.ts"],
+  "sourcesContent": ["import { Menu, addGeneSearchbox } from '#dom'\nimport { TermTypes } from '#shared/terms.js'\nimport { getGEunit } from '#tw/geneExpression'\n\nexport class SearchHandler {\n\tcallback: any\n\tapp: any\n\tinit(opts) {\n\t\tthis.callback = opts.callback\n\t\tthis.app = opts.app\n\t\tconst holder = opts.holder.append('div').style('padding', '10px 0px')\n\t\tconst geneSearch = addGeneSearchbox({\n\t\t\ttip: new Menu({ padding: '0px' }),\n\t\t\tgenome: opts.genomeObj,\n\t\t\trow: holder,\n\t\t\tsearchOnly: 'gene',\n\t\t\tcallback: () => this.selectGene(geneSearch.geneSymbol)\n\t\t})\n\t}\n\n\tasync selectGene(gene) {\n\t\tconst unit = getGEunit(this.app.vocabApi)\n\t\tconst name = `${gene} ${unit}`\n\t\tif (!gene) throw new Error('No gene selected')\n\t\tthis.callback({ gene, name, type: TermTypes.GENE_EXPRESSION })\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;;;AAIO,IAAM,gBAAN,MAAoB;AAAA,EAG1B,KAAK,MAAM;AACV,SAAK,WAAW,KAAK;AACrB,SAAK,MAAM,KAAK;AAChB,UAAM,SAAS,KAAK,OAAO,OAAO,KAAK,EAAE,MAAM,WAAW,UAAU;AACpE,UAAM,aAAa,iBAAiB;AAAA,MACnC,KAAK,IAAI,KAAK,EAAE,SAAS,MAAM,CAAC;AAAA,MAChC,QAAQ,KAAK;AAAA,MACb,KAAK;AAAA,MACL,YAAY;AAAA,MACZ,UAAU,MAAM,KAAK,WAAW,WAAW,UAAU;AAAA,IACtD,CAAC;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,MAAM;AACtB,UAAM,OAAO,UAAU,KAAK,IAAI,QAAQ;AACxC,UAAM,OAAO,GAAG,IAAI,IAAI,IAAI;AAC5B,QAAI,CAAC,KAAM,OAAM,IAAI,MAAM,kBAAkB;AAC7C,SAAK,SAAS,EAAE,MAAM,MAAM,MAAM,UAAU,gBAAgB,CAAC;AAAA,EAC9D;AACD;",
+  "names": []
+}

package/dist/chunk-LI7FE335.js

@@ -0,0 +1,371 @@
+import {
+  addBrushes,
+  addNewBrush
+} from "./chunk-FVWCYGJL.js";
+import {
+  NumericRangeInput,
+  niceNumLabels,
+  violinRenderer
+} from "./chunk-SEQLC4AD.js";
+import {
+  convertUnits
+} from "./chunk-TV74I3Y5.js";
+import {
+  select_default
+} from "./chunk-NDWTN4U5.js";
+
+// filter/tvs.numeric.js
+var handler = {
+  type: "numeric",
+  term_name_gen,
+  get_pill_label,
+  getSelectRemovePos,
+  fillMenu,
+  setTvsDefaults
+};
+function term_name_gen(d) {
+  const name = d.term.name;
+  return name.length < 26 ? name : '<label title="' + name + '">' + name.substring(0, 24) + "...</label>";
+}
+function get_pill_label(tvs) {
+  if (tvs.ranges.length == 1) {
+    const v = tvs.ranges[0];
+    if ("value" in v) {
+      if (v.label) return { txt: v.label };
+      if (tvs.term.values && tvs.term.values[v.value] && tvs.term.values[v.value].label)
+        return { txt: tvs.term.values[v.value].label };
+      console.error(`key "${v.value}" not found in values{} of ${tvs.term.name}`);
+      return { txt: v.value };
+    }
+    return { txt: format_val_text(v, tvs.term) };
+  }
+  return { txt: tvs.ranges.length + " intervals" };
+}
+function format_val_text(range, term) {
+  const x = '<span style="font-family:Times;font-style:italic;font-size:1em; vertical-align:top">x</span>';
+  if (range.startunbounded && range.stopunbounded) {
+    const inf = (sign = "") => `<span style='vertical-align: middle; font-size:1.1em; line-height: 0.9em'>${sign}\u221E</span>`;
+    const lt = `<span style='vertical-align: top; font-size: 0.9em'>&lt;</span>`;
+    return `<span>${inf("\uFE63")} ${lt} ${x} ${lt} ${inf("\uFE62")}</span>`;
+  }
+  const vc = term.valueConversion;
+  if (range.startunbounded)
+    return `${x} ${range.stopinclusive ? "&le;" : "&lt;"} ${vc ? convertUnits(range.stop, vc.fromUnit, vc.toUnit, vc.scaleFactor) : range.stop}`;
+  if (range.stopunbounded)
+    return `${x} ${range.startinclusive ? "&ge;" : "&gt;"} ${vc ? convertUnits(range.start, vc.fromUnit, vc.toUnit, vc.scaleFactor) : range.start}`;
+  let startName, stopName;
+  if (vc) {
+    startName = convertUnits(range.start, vc.fromUnit, vc.toUnit, vc.scaleFactor);
+    stopName = convertUnits(range.stop, vc.fromUnit, vc.toUnit, vc.scaleFactor);
+  } else {
+    ;
+    [startName, stopName] = niceNumLabels([range.start, range.stop]);
+  }
+  return `${startName} 
+			${range.startinclusive ? "&le;" : "&lt;"}
+			${x}
+			${range.stopinclusive ? "&le;" : "&lt;"}
+			${stopName}`;
+}
+function getSelectRemovePos(j, tvs) {
+  return j - tvs.ranges.slice(0, j).filter((a) => a.start || a.stop).length;
+}
+async function fillMenu(self, div, tvs) {
+  const num_parent_div = div.append("div");
+  self.num_obj = {};
+  self.num_obj.num_div = num_parent_div.append("div").attr("class", "num_div").style("padding", "5px").style("color", "#000");
+  self.num_obj.plot_size = {
+    width: 450,
+    height: 100,
+    xpad: 10,
+    ypad: 20,
+    radius: 8
+  };
+  if (typeof self.opts.vocabApi.getViolinBox == "function") {
+    try {
+      const data = await self.opts.vocabApi.getViolinBox(
+        {
+          plotType: "violin",
+          tw: { term: tvs.term, q: { mode: "continuous" } },
+          // must supply this filter and override state filter in function, so the density plot will not be limited to range defined by current numeric tvs but will show whole range
+          filter: self.filter,
+          svgw: self.num_obj.plot_size.width,
+          radius: self.num_obj.plot_size.radius
+        },
+        self.opts.getCategoriesArguments
+      );
+      if (data.error) throw data.error;
+      if (data.max === null && data.min === null) {
+        throw `No data available under current filter conditions.`;
+      }
+      self.num_obj.density_data = data;
+    } catch (err) {
+      throw err;
+    }
+  } else {
+    self.num_obj.density_data = {};
+  }
+  if (self.num_obj.density_data.error) throw self.num_obj.density_data.error;
+  if (!self.num_obj.density_data.charts?.[""]?.plots?.[0]?.density?.bins) {
+    addRangeTableNoDensity(self, tvs);
+    return;
+  }
+  self.vr = new violinRenderer({
+    holder: self.num_obj.num_div,
+    rd: self.num_obj.density_data,
+    width: self.num_obj.plot_size.width,
+    radius: self.num_obj.plot_size.radius,
+    height: self.num_obj.plot_size.height
+  });
+  self.vr.render();
+  self.num_obj.svg = self.vr.svg;
+  self.num_obj.range_table = self.num_obj.num_div.append("table").style("table-layout", "fixed").style("border-collapse", "collapse");
+  const ranges = [];
+  for (const [index, range] of tvs.ranges.entries()) {
+    range.index = index;
+    ranges.push(range);
+  }
+  self.num_obj.brush_g = self.vr.brushG.attr("class", "brush_g");
+  self.num_obj.xscale = self.vr.axisScale;
+  self.num_obj.ranges = ranges;
+  self.num_obj.brushes = [];
+  addBrushes(self);
+  addRangeTable(self);
+  if (!ranges.length) {
+    const callback = () => addRangeTable(self);
+    addNewBrush(self, "center", callback);
+  }
+  self.num_obj.brushes.forEach((brush) => brush.init());
+  await showCheckList_numeric(self, tvs, div);
+}
+function setTvsDefaults(tvs) {
+  if (!tvs.ranges) tvs.ranges = [];
+}
+function addRangeTableNoDensity(self, tvs) {
+  const termrange = tvs.term.range || {};
+  const range = tvs.ranges && tvs.ranges[0] ? tvs.ranges[0] : termrange;
+  range.min = "min" in tvs.term ? tvs.term.min : null;
+  range.max = "max" in tvs.term ? tvs.term.max : null;
+  const num_div = self.num_obj.num_div;
+  num_div.selectAll("*").remove();
+  const brush = {};
+  const table = num_div.append("table").style("padding-left", "5px");
+  const rangeTr = table.append("tr");
+  const rangeLabelTd = rangeTr.append("td");
+  brush.equation_td = rangeTr.append("td");
+  brush.rangeInput = new NumericRangeInput(brush.equation_td, range, () => {
+  }, { width: "125px" });
+  if (self.opts.isMafFilter) {
+    rangeLabelTd.text("MAF Range (0-1)");
+    const depthTr = table.append("tr");
+    depthTr.append("td").text("Minimum Total Depth");
+    brush.depthInput = depthTr.append("td").append("input").attr("type", "number").attr("min", 1).attr("step", 1).style("width", "125px").property("value", tvs.minAllelicDepth);
+    const applyTr = table.append("tr");
+    brush.apply_btn = applyTr.append("td").attr("class", "sja_filter_tag_btn sjpp_apply_btn").style("border-radius", "13px").style("margin-top", "10px").style("font-size", ".8em").style("text-transform", "uppercase").text("apply").on("click", clickApply);
+  } else {
+    rangeLabelTd.text("Range");
+    brush.apply_btn = rangeTr.append("td").attr("class", "sja_filter_tag_btn sjpp_apply_btn").style("border-radius", "13px").style("margin", "5px").style("margin-left", "10px").style("text-align", "center").style("font-size", ".8em").style("text-transform", "uppercase").text("apply").on("click", clickApply);
+  }
+  function clickApply() {
+    const r = brush.rangeInput.getRange();
+    if (!Number.isFinite(r.start) && !Number.isFinite(r.stop)) {
+      window.alert("Invalid range.");
+      return;
+    }
+    const new_tvs = { term: tvs.term, ranges: [r] };
+    if (brush.depthInput) {
+      const minAllelicDepth = Number(brush.depthInput.property("value"));
+      if (!Number.isFinite(minAllelicDepth)) {
+        window.alert("Minimum allelic depth must be a numeric value.");
+        return;
+      }
+      new_tvs.minAllelicDepth = Math.max(minAllelicDepth, 1);
+    }
+    self.dom.tip.hide();
+    self.opts.callback(new_tvs);
+  }
+}
+function addRangeTable(self) {
+  const brushes = self.num_obj.brushes;
+  const range_divs = self.num_obj.range_table.selectAll(".range_div").data(brushes);
+  range_divs.exit().each(function() {
+    select_default(this).style("opacity", 1).transition().duration(100).style("opacity", 0).remove();
+  });
+  range_divs.enter().append("tr").attr("class", "range_div").style("white-space", "nowrap").style("padding", "2px").transition().duration(200).each(function(brush, i) {
+    enterRange(self, this, brush, i);
+  });
+}
+function enterRange(self, tr, brush, i) {
+  if (!brush.range_tr) brush.range_tr = select_default(tr);
+  const range_tr = brush.range_tr;
+  const xscale = self.num_obj.xscale;
+  range_tr.append("td").append("td").style("display", "inline-block").style("margin-left", "10px").style("padding", "3px 10px").style("font-size", ".9em").text("Range " + (i + 1) + ": ");
+  brush.equation_td = range_tr.append("td").style("width", "150px");
+  brush.rangeInput = new NumericRangeInput(brush.equation_td, brush.range, apply);
+  makeRangeButtons(self, brush);
+  if (i == 0) {
+    self.num_obj.range_table.append("tr").attr("class", "note_tr").append("td").attr("colspan", "3").append("div").style("font-size", ".8em").style("margin-left", "20px").style("font-style", "italic").style("color", "#888").html("Option 1: Drag the rectangle to select a range. Overlapping ranges will be merged.");
+  }
+  if (i == 0) {
+    self.num_obj.range_table.append("tr").attr("class", "note_tr").append("td").attr("colspan", "3").append("div").style("font-size", ".8em").style("margin-left", "20px").style("font-style", "italic").style("color", "#888").html(
+      `Option 2: Type in values to select a range.${self.tvs.term.valueConversion ? ` Values are in the unit of ${self.tvs.term.valueConversion.fromUnit}.` : ""}`
+    );
+  }
+  async function apply(new_range) {
+    try {
+      brush.range = new_range;
+      const minvalue = self.num_obj.density_data.min;
+      const maxvalue = self.num_obj.density_data.max;
+      const start = new_range.value != void 0 ? new_range.value : new_range.start != void 0 ? new_range.start : minvalue;
+      const stop = new_range.value != void 0 ? new_range.value : new_range.stop != void 0 ? new_range.stop : maxvalue;
+      brush.elem.call(brush.d3brush).call(brush.d3brush.move, [start, stop].map(xscale));
+    } catch (e) {
+      window.alert(e);
+    }
+  }
+  function makeRangeButtons(self2, brush2) {
+    const buttons_td = brush2.range_tr.append("td");
+    const range = brush2.range;
+    brush2.apply_btn = buttons_td.append("td").attr("class", "sja_filter_tag_btn sjpp_apply_btn").style("border-radius", "13px").style("margin", "5px").style("margin-left", "10px").style("text-align", "center").style("font-size", ".8em").style("text-transform", "uppercase").text("apply").on("click", async () => {
+      self2.dom.tip.hide();
+      const new_range = brush2.rangeInput.parseRange();
+      const new_tvs = JSON.parse(JSON.stringify(self2.tvs));
+      delete new_tvs.groupset_label;
+      if (self2.num_obj.ranges.length > 1) new_tvs.ranges = mergeOverlapRanges(self2, new_range);
+      else new_tvs.ranges[range.index] = new_range;
+      try {
+        validateNumericTvs(new_tvs);
+        self2.opts.callback(new_tvs);
+      } catch (ex) {
+        alert(ex);
+      }
+    });
+    buttons_td.append("td").attr("class", "sja_filter_tag_btn sjpp_delete_btn").style("border-radius", "13px").style("display", self2.num_obj.ranges.length > 1 ? "inline-block" : "none").style("margin", "5px").style("margin-left", "10px").style("text-align", "center").style("font-size", ".8em").style("text-transform", "uppercase").text("Delete").on("click", async () => {
+      const new_tvs = JSON.parse(JSON.stringify(self2.tvs));
+      new_tvs.ranges.splice(range.index, 1);
+      self2.num_obj.ranges.pop();
+      self2.num_obj.brushes.pop();
+      self2.num_obj.num_div.select(".note_tr").remove();
+      addBrushes(self2);
+      addRangeTable(self2);
+      if (new_tvs.ranges.length) self2.opts.callback(new_tvs);
+    });
+  }
+}
+function mergeOverlapRanges(self, new_range) {
+  let ranges = JSON.parse(JSON.stringify(self.tvs.ranges));
+  let merged_flag = false;
+  for (const [i, range] of ranges.entries()) {
+    if (!range.value && new_range.index != i) {
+      if (new_range.start <= range.start && new_range.stop >= range.stop) {
+        range.start = new_range.start;
+        range.stop = new_range.stop;
+        merged_flag = true;
+      } else if (new_range.start <= range.stop && new_range.stop >= range.stop) {
+        range.stop = new_range.stop;
+        merged_flag = true;
+      } else if (new_range.stop >= range.start && new_range.start <= range.start) {
+        range.start = new_range.start;
+        merged_flag = true;
+      } else if (new_range.start >= range.start && new_range.stop <= range.stop) {
+        merged_flag = true;
+      } else if (new_range.startunbounded) {
+        if (new_range.stop > range.stop) {
+          range.stop = new_range.stop;
+        }
+        delete range.start;
+        range.startunbounded = true;
+        merged_flag = true;
+      } else if (new_range.stopunbounded) {
+        if (new_range.start < range.start) {
+          range.start = new_range.start;
+        }
+        delete range.stop;
+        range.stopunbounded = true;
+        merged_flag = true;
+      }
+    }
+  }
+  if (merged_flag) {
+    if (new_range.index <= ranges.length - 1) ranges.splice(new_range.index, 1);
+  } else {
+    ranges = JSON.parse(JSON.stringify(self.tvs.ranges));
+    if (new_range.index) ranges[new_range.index] = new_range;
+    else ranges.push(new_range);
+  }
+  return ranges;
+}
+async function showCheckList_numeric(self, tvs, div) {
+  if (!tvs.term.values) {
+    return;
+  }
+  const values = await self.opts.vocabApi.getNumericUncomputableCategories(tvs.term, self.filter);
+  const unannotated_cats = [];
+  const lst = values?.lst || values;
+  for (const cat of lst) {
+    const key = "key" in cat ? cat.key : cat.value;
+    if (!("key" in cat)) cat.key = key;
+    if (!("value" in cat)) cat.value = key;
+    if (key in tvs.term.values) {
+      cat.label = tvs.term.values[key].label;
+      unannotated_cats.push(cat);
+    }
+  }
+  const sortedVals = unannotated_cats.sort((a, b) => {
+    return b.samplecount - a.samplecount;
+  });
+  const unanno_div = div.append("div").style("padding", "5px").style("color", "#000");
+  const callback = (indexes) => {
+    try {
+      const new_tvs = JSON.parse(JSON.stringify(tvs));
+      delete new_tvs.groupset_label;
+      new_tvs.ranges = [
+        ...new_tvs.ranges.filter((r) => !("value" in r)),
+        ...indexes.map((i) => ({ value: sortedVals[i].value, label: sortedVals[i].label }))
+      ];
+      self.dom.tip.hide();
+      if (new_tvs.ranges.length == 0) throw "select at least one range or category";
+      if (JSON.parse(JSON.stringify(tvs) != new_tvs)) {
+        try {
+          validateNumericTvs(new_tvs);
+        } catch (e) {
+          window.alert(e);
+          return;
+        }
+        self.opts.callback(new_tvs);
+      }
+    } catch (e) {
+      window.alert(e);
+    }
+  };
+  const values_table = self.makeValueTable(unanno_div, tvs, sortedVals, callback).node();
+}
+function validateNumericTvs(tvs) {
+  if (!tvs.term) throw "tvs.term is not defined";
+  if (!tvs.ranges) throw `.values[] missing for a term ${tvs.term.name}`;
+  if (!Array.isArray(tvs.ranges)) throw `.values[] is not an array for a term ${tvs.term.name}`;
+  if (!tvs.ranges.length) throw `no categories selected for ${tvs.term.name}`;
+  for (const range of tvs.ranges) {
+    if (range.value != void 0) {
+      if (!range.label) throw `.label missing for special category for a term ${tvs.term.name}`;
+    } else {
+      if (range.startunbounded) {
+        if (range.stopunbounded) throw `both start & stop are unbounded for a term ${tvs.term.name}`;
+        if (!Number.isFinite(range.stop)) throw `.stop undefined when start is unbounded for a term ${tvs.term.name}`;
+      } else if (range.stopunbounded) {
+        if (!Number.isFinite(range.start)) throw `.start undefined when stop is unbounded for a term ${tvs.term.name}`;
+      } else {
+        if (!Number.isFinite(range.start))
+          throw `.start undefined when start is not unbounded for a term ${tvs.term.name}`;
+        if (!Number.isFinite(range.stop)) throw `.stop undefined when stop is not unbounded for a term ${tvs.term.name}`;
+        if (range.start >= range.stop) throw `.start is not lower than stop for a term ${tvs.term.name}`;
+      }
+    }
+  }
+}
+
+export {
+  handler,
+  format_val_text
+};
+//# sourceMappingURL=chunk-LI7FE335.js.map