@sjcrh/proteinpaint-client 2.221.0 → 2.222.0

package/dist/chunk-VIFY62YA.js

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

package/dist/chunk-VZ2JWFSX.js

@@ -0,0 +1,296 @@
+import {
+  getSortOptions
+} from "./chunk-5DI4UNH5.js";
+import {
+  defaultUiLabels,
+  fillTermWrapper
+} from "./chunk-4ASBDE27.js";
+import {
+  isDictionaryType
+} from "./chunk-JHLF2ZC2.js";
+import {
+  CNVClasses,
+  dtcnv,
+  mclass,
+  mutationClasses,
+  proteinChangingMutations,
+  synonymousMutations,
+  truncatingMutations
+} from "./chunk-WJLRU5OF.js";
+import {
+  copyMerge
+} from "./chunk-HBNB5TRH.js";
+
+// plots/matrix/matrix.config.js
+async function getPlotConfig(opts = {}, app) {
+  const controlLabels = structuredClone(defaultUiLabels);
+  const devicePixelRatio = opts.devicePixelRatio || window.devicePixelRatio;
+  const config = {
+    // data configuration
+    termgroups: [],
+    samplegroups: [],
+    divideBy: null,
+    legendValueFilter: {
+      isAtomic: true,
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: []
+    },
+    legendGrpFilter: {
+      isAtomic: true,
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: []
+    },
+    filter: {
+      isAtomic: true,
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: []
+    },
+    // cnvCutoffs: {},
+    // rendering options
+    settings: {
+      matrix: {
+        svgCanvasSwitch: 1e3,
+        // the number of samples to trigger switching between svg and canvas
+        useMinPixelWidth: true,
+        // canvas may be hazy if false, but more accurately reflects column density
+        cellEncoding: "",
+        // can be "oncoprint" | "stacked" | "single"
+        margin: {
+          top: 10,
+          right: 5,
+          bottom: 20,
+          left: 50
+        },
+        // set any dataset-defined sample limits and sort priority, otherwise undefined
+        // put in settings, so that later may be overridden by a user
+        maxGenes: opts.settings?.maxGenes || 50,
+        maxSample: opts.settings?.maxSample || 1e3,
+        sampleNameFilter: "",
+        sortSamplesBy: "a",
+        sortPriority: void 0,
+        // will be filled-in
+        sortBySampleAncestry: app.vocabApi.termdbConfig.hasSampleAncestry ? "last" : false,
+        // indicates sorting priority by sample ancestry
+        mapChildren2Root: false,
+        // for a dataset with sample ancestry, show one column per root sample (e.g. patient)
+        // sortByMutation: 'consequence', computed
+        // sortByCNV: true, computed
+        //sortOptions: getSortOptions(app.vocabApi.termdbConfig, controlLabels),
+        sortSampleGrpsBy: "name",
+        // 'hits' | 'name' | 'sampleCount'
+        sortSamplesTieBreakers: [{
+          $id: "sample",
+          sortSamples: {}
+          /*split: {char: '', index: 0}*/
+        }],
+        sortTermsBy: "sampleCount",
+        // or 'as listed'
+        // do not show number of samples at hiercluster gene row labels
+        samplecount4gene: opts.chartType == "hierCluster" ? "" : "abs",
+        //true, // 'abs' (default, previously true), 'pct', ''  (previously false)
+        geneVariantCountSamplesSkipMclass: [],
+        cellbg: "#ececec",
+        showGrid: "",
+        // false | 'pattern' | 'rect'
+        // whether to show these controls buttons
+        addMutationCNVButtons: false,
+        truncatingMutations,
+        proteinChangingMutations,
+        synonymousMutations,
+        mutationClasses,
+        CNVClasses,
+        gridStroke: "#fff",
+        outlineStroke: "#ccc",
+        beamStroke: "#f00",
+        colw: 0,
+        colwMin: 0.1 / devicePixelRatio,
+        colwMax: 16,
+        colspace: 1,
+        colgspace: 8,
+        colglabelpos: true,
+        collabelpos: "bottom",
+        collabelvisible: true,
+        collabelgap: 5,
+        collabelpad: 1,
+        collabelmaxchars: 32,
+        rowh: 18,
+        //use 0 to auto-compute row height, previous default=18,
+        rowhMin: 1,
+        rowhMax: 20,
+        rowspace: 1,
+        rowgspace: 8,
+        rowlabelpos: "left",
+        // | 'right'
+        rowlabelgap: 5,
+        rowlabelvisible: true,
+        rowlabelpad: 1,
+        rowlabelmaxchars: 32,
+        legendGrpLabelMaxChars: 26,
+        grpLabelFontSize: 12,
+        minLabelFontSize: 6,
+        maxLabelFontSize: 14,
+        transpose: false,
+        // 'auto' shows column labels only when columns are wide enough (colw >= minLabelFontSize);
+        sampleLabelsToggle: "auto",
+        // 'auto' | 'hide'
+        sampleLabelOffset: 120,
+        sampleGrpLabelOffset: 120,
+        sampleGrpLabelMaxChars: 32,
+        termLabelOffset: 80,
+        termGrpLabelOffset: 80,
+        termGrpLabelMaxChars: 32,
+        duration: 0,
+        zoomLevel: 1,
+        zoomCenterPct: 0,
+        zoomIndex: 0,
+        zoomGrpIndex: 0,
+        zoomMin: 0.5,
+        zoomIncrement: 0.1,
+        zoomStep: 1,
+        // renderedWMax should not be exposed as a user-input
+        // 60000 pixels is based on laptop and external monitor tests,
+        // when a canvas dataURL image in a zoomed-in matrix svg stops rendering
+        imgWMax: 6e4 / devicePixelRatio,
+        scrollHeight: 12,
+        controlLabels,
+        cnvUnit: "log2ratio",
+        ignoreCnvValues: false,
+        //will ignore numeric CNV values if true
+        barh: 32,
+        // default bar height for continuous terms,
+        // possible string entries:
+        // - "genesetEdit", for gene-centric embedders only like GDC OncoMatrix
+        // - may add other optional hints later
+        showHints: [],
+        genesetEditUiVersion: "",
+        // '' | 'withTabs'
+        // settings for a specific tw
+        twSpecificSettings: {},
+        oncoPrintSNVindelCellBorder: false,
+        // whether to show white cell border for SNVindel in oncoPrint mode
+        cnvValues: {
+          //Properties match the args for the ColorScales
+          //numericInput arg
+          cutoffMode: "percentile",
+          defaultPercentile: 99,
+          min: null,
+          max: null,
+          percentile: 99
+        }
+      }
+    }
+  };
+  const s = config.settings;
+  const fontsize = Math.max(s.matrix.rowh + s.matrix.rowspace - 3 * s.matrix.rowlabelpad, 12);
+  s.legend = {
+    ontop: false,
+    lineh: 25,
+    padx: 5,
+    padleft: 0,
+    //150,
+    padright: 20,
+    padbtm: 30,
+    fontsize,
+    iconh: fontsize - 2,
+    iconw: fontsize - 2,
+    hangleft: 1,
+    linesep: false
+  };
+  const overrides = app.vocabApi.termdbConfig.matrix || {};
+  copyMerge(config.settings.matrix, overrides.settings);
+  if (overrides.legendGrpFilter) config.legendGrpFilter = overrides.legendGrpFilter;
+  if (overrides.legendValueFilter) config.legendValueFilter = overrides.legendValueFilter;
+  if (overrides.filter) config.filter = overrides.filter;
+  if (opts.name) {
+    const data = await app.vocabApi.getMatrixByName(opts.name);
+    if (!data) throw "error from getMatrixByName()";
+    if (data.error) throw data.error;
+    copyMerge(config, data);
+  }
+  const os = opts?.settings?.matrix;
+  if (os) {
+    if ((os.sortSamplesBy == "custom" || os.sortSamplesBy == "asListed") && os.sortOptions?.custom.label == "against alteration type") {
+      os.sortSamplesBy = "a";
+    }
+    if (os.sortOptions) {
+      delete os.sortOptions.custom;
+      delete os.sortOptions.asListed;
+    }
+  }
+  copyMerge(config, opts);
+  const m = config.settings.matrix;
+  m.sortOptions = getSortOptions(app.vocabApi.termdbConfig, controlLabels, m);
+  m.duration = 0;
+  m.colw = 0;
+  if (m.sortSamplesBy != "asListed" && !m.sortOptions?.[m.sortSamplesBy]) m.sortSamplesBy = "a";
+  else if (["selectedTerms", "class", "dt", "hits"].includes(m.sortSamplesBy)) m.sortSamplesBy = "a";
+  if (m.samplecount4gene === true || m.samplecount4gene === 1) m.samplecount4gene = "abs";
+  if (window.location.hostname == "localhost") {
+    if (window.location.hash == "#canvas") m.svgCanvasSwitch = 0;
+  }
+  for (const grp of config.termgroups) {
+    const promises = [];
+    for (const tw of grp.lst) {
+      if (!tw.term?.type || isDictionaryType(tw.term.type)) {
+        if (!tw.id && tw.term.type != "samplelst" && tw.term.type != "termCollection") {
+          if (!tw.term.id) throw `missing tw.id and tw.term.id`;
+          tw.id = tw.term.id;
+        }
+        if (tw.term?.type != "samplelst" && tw.term?.type != "termCollection") delete tw.term;
+      }
+      promises.push(fillTermWrapper(tw, app.vocabApi));
+    }
+    grp.lst = await Promise.all(promises);
+  }
+  if (config.divideBy) config.divideBy = await fillTermWrapper(config.divideBy, app.vocabApi);
+  return config;
+}
+function setComputedConfig(config) {
+  const s = config.settings.matrix;
+  const allClasses = [...s.mutationClasses, ...s.CNVClasses];
+  s.filterByClass = { isAtomic: true };
+  for (const f of config.legendGrpFilter.lst) {
+    if (!f.dt) continue;
+    allClasses.filter((m) => f.dt.includes(mclass[m].dt)).forEach((key2) => {
+      s.filterByClass[key2] = "value";
+    });
+  }
+  for (const f of config.legendValueFilter.lst) {
+    if (!f.legendGrpName || f.tvs?.term?.type !== "geneVariant") continue;
+    if (f.tvs.values?.[0].mclasslst)
+      f.tvs.values[0].mclasslst.forEach((key2) => {
+        s.filterByClass[key2] = f.legendFilterType?.endsWith("_hard") ? "case" : "value";
+      });
+    else if (f.tvs.values)
+      f.tvs.values.forEach((v) => {
+        s.filterByClass[key] = "value";
+      });
+    else throw `unhandled tvs from legendValueFilter`;
+  }
+  s.hiddenVariants = Object.keys(s.filterByClass).filter((c) => c !== "isAtomic");
+  const hiddenCNVs = new Set(s.hiddenVariants.filter((key2) => mclass[key2]?.dt === dtcnv));
+  s.hiddenCNVs = [...hiddenCNVs];
+  s.showMatrixCNV = !hiddenCNVs.size ? "all" : hiddenCNVs.size == s.CNVClasses.length ? "none" : "bySelection";
+  s.allMatrixCNVHidden = hiddenCNVs.size == s.CNVClasses.length;
+  const hiddenMutations = new Set(s.hiddenVariants.filter((key2) => s.mutationClasses.find((k) => k === key2)));
+  s.hiddenMutations = [...hiddenMutations];
+  const PCset = new Set(s.proteinChangingMutations);
+  const TMset = new Set(s.truncatingMutations);
+  s.showMatrixMutation = !hiddenMutations.size ? "all" : hiddenMutations.size == s.mutationClasses.length ? "none" : hiddenMutations.size === s.mutationClasses.length - PCset.size && [...hiddenMutations].every((m) => !PCset.has(m)) ? "onlyPC" : hiddenMutations.size === s.mutationClasses.length - TMset.size && [...hiddenMutations].every((m) => !TMset.has(m)) ? "onlyTruncating" : "bySelection";
+  s.allMatrixMutationHidden = hiddenMutations.size == s.mutationClasses.length;
+  const tiebreakers = s.sortOptions.a?.sortPriority.find((sp) => sp.types.length == 1 && sp.types[0] == "geneVariant")?.tiebreakers || [];
+  s.sortByMutation = tiebreakers.find((tb) => tb.filter?.values[0]?.dt === 1)?.isOrdered ? "consequence" : "presence";
+  s.sortByCNV = tiebreakers.find((tb) => tb.filter?.values[0]?.dt === 4)?.disabled !== true;
+}
+
+export {
+  getPlotConfig,
+  setComputedConfig
+};
+//# sourceMappingURL=chunk-VZ2JWFSX.js.map

package/dist/chunk-W5GR42L2.js

@@ -0,0 +1,159 @@
+import {
+  NumericDensity
+} from "./chunk-V2D7DA2M.js";
+import {
+  HandlerBase,
+  Tabs
+} from "./chunk-4ASBDE27.js";
+
+// termsetting/handlers/NumericHandler.ts
+var NumericHandler = class extends HandlerBase {
+  constructor(opts) {
+    super(opts);
+    this.tabs = [];
+    this.handlerByMode = {};
+    this.dom = {};
+    this.opts = opts;
+    this.termsetting = opts.termsetting;
+    this.tw = opts.termsetting.tw;
+    this.tabs = this.setTabData();
+    this.density = new NumericDensity(opts);
+  }
+  getPillStatus() {
+    this.tw = this.termsetting.tw;
+    const status = this.tw.getStatus(this.termsetting.usecase, this.termsetting.data);
+    if (this.tw.term.type == "geneExpression" && this.tw.term.sampleTypeLabel)
+      status.text += ` (${this.tw.term.sampleTypeLabel})`;
+    return status;
+  }
+  setTabData() {
+    const self = this.termsetting;
+    const tabs = [];
+    const callback = async (event, tabData) => {
+      if (event) event.stopPropagation();
+      try {
+        await this.setEditHandler(tabData);
+        await this.editHandler.showEditMenu(tabData.contentHolder);
+      } catch (e) {
+        this.dom.errdiv.style("display", "").text(e);
+      }
+    };
+    const numTabs = self.opts.numericEditMenuVersion.length;
+    if (self.opts.numericEditMenuVersion.includes("continuous")) {
+      tabs.push({
+        mode: "continuous",
+        label: self.term.type == "survival" ? "Time to Event" : "Continuous",
+        callback,
+        active: this.tw.q.mode === "continuous" || numTabs === 1
+      });
+    }
+    if (self.opts.numericEditMenuVersion.includes("discrete")) {
+      tabs.push({
+        mode: "discrete",
+        label: self.term.type == "survival" ? "Exit code" : "Discrete",
+        callback,
+        active: this.tw.q.mode === "discrete" || numTabs === 1
+      });
+    }
+    if (self.opts.numericEditMenuVersion.includes("spline")) {
+      tabs.push({
+        mode: "spline",
+        label: "Cubic spline",
+        callback,
+        active: this.tw.q.mode === "spline" || numTabs === 1
+      });
+    }
+    if (self.opts.numericEditMenuVersion.includes("binary")) {
+      tabs.push({
+        mode: "binary",
+        label: "Binary",
+        callback,
+        active: this.tw.q.mode === "binary" || numTabs === 1
+      });
+    }
+    return tabs;
+  }
+  async setEditHandler(tabData) {
+    if (!this.handlerByMode[tabData.mode]) {
+      switch (tabData.mode) {
+        case "continuous": {
+          const { NumContEditor } = await import("./NumContEditor-VMCE5LUM.js");
+          this.handlerByMode.continuous = new NumContEditor(this.opts, this);
+          break;
+        }
+        case "discrete": {
+          const { NumDiscreteEditor } = await import("./NumDiscreteEditor-YZ3Q4J4M.js");
+          this.handlerByMode.discrete = new NumDiscreteEditor(this.opts, this);
+          break;
+        }
+        case "binary": {
+          const { NumBinaryEditor } = await import("./NumBinaryEditor-45I5YNHI.js");
+          this.handlerByMode.binary = new NumBinaryEditor(this.opts, this);
+          break;
+        }
+        case "spline": {
+          const { NumSplineEditor } = await import("./NumSplineEditor-OMJUFDSC.js");
+          this.handlerByMode.spline = new NumSplineEditor(this.opts, this);
+          break;
+        }
+        default:
+          throw `unexpected numeric tabData.mode='${tabData.mode}'`;
+          break;
+      }
+    }
+    this.editHandler = this.handlerByMode[tabData.mode];
+  }
+  async showEditMenu(div) {
+    try {
+      this.showLoading(div);
+      this.dom.errdiv = div.append("div").attr("class", "sja_errorbar").style("display", "none");
+      this.tw = this.termsetting.tw;
+      const self = this.tw;
+      for (const t of this.tabs) {
+        t.active = this.tabs.length === 1 || self.q.mode == t.mode || t.mode == "continuous" && !self.q.mode;
+      }
+      this.density_data = await this.density.setData();
+      await this.setEditHandler(this.tabs.find((t) => t.active));
+      this.dom.editDiv = div.append("div").attr("data-testid", "sjpp-num-ts-edit-div");
+      this.dom.btnDiv = div.append("div").style("margin", "0px 0px 5px 5px");
+      this.renderButtons(this.dom.btnDiv);
+      if (this.tabs.length > 1) {
+        this.dom.topBar = this.dom.editDiv.append("div").attr("data-testid", "sja-ts-numeric-edit-top-bar").style("padding", "10px");
+        this.dom.topBar.append("span").html("Use as ");
+        new Tabs({
+          holder: this.dom.topBar.append("div").style("display", "inline-block"),
+          contentHolder: this.dom.editDiv.append("div"),
+          noTopContentStyle: true,
+          tabs: this.tabs
+        }).main();
+      } else {
+        await this.editHandler.showEditMenu(this.dom.editDiv);
+      }
+      this.dom.loadingDiv.style("display", "none");
+    } catch (e) {
+      this.hideLoading();
+      this.dom.errdiv.style("display", "").text(typeof e == "object" ? e.message || e.error || e : e);
+    }
+  }
+  renderButtons(btnDiv) {
+    btnDiv.append("button").style("margin", "5px").attr("data-testId", "sjpp_numeric_edit_apply").html("Apply").on("click", () => {
+      this.termsetting.q = this.editHandler.getEditedQ();
+      this.termsetting.dom.tip.hide();
+      this.termsetting.api.runCallback();
+    });
+    btnDiv.append("button").style("margin", "5px").attr("data-testId", "sjpp_numeric_edit_reset").html("Reset").on("click", () => {
+      this.editHandler.undoEdits();
+    });
+  }
+  destroy() {
+    for (const s of Object.values(this.dom)) {
+      if (typeof s.remove == "function") s.remove();
+    }
+    this.density.destroy();
+  }
+};
+
+export {
+  NumericHandler
+};
+//# sourceMappingURL=chunk-W5GR42L2.js.map