@sjcrh/proteinpaint-client 2.224.1 → 2.224.2

package/dist/chunk-5FD6NRGE.js

@@ -0,0 +1,472 @@
+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,
+  SINGLECELL_NUMERIC_VALUE,
+  SNP,
+  SNP_LIST,
+  SNP_LOCUS,
+  SSGSEA,
+  SURVIVAL,
+  TERM_COLLECTION,
+  TermTypeGroups,
+  dtTerms,
+  dtdnamethylation,
+  dtgeneexpression,
+  dtmetaboliteintensity,
+  dtproteomeabundance,
+  dtssgsea
+} from "./chunk-R2H22S4J.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,
+  [SINGLECELL_NUMERIC_VALUE]: TermTypeGroups.SINGLECELL_NUMERIC_VALUE,
+  [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,
+  SINGLECELL_NUMERIC_VALUE,
+  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,
+  SINGLECELL_NUMERIC_VALUE,
+  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,
+  SINGLECELL_NUMERIC_VALUE
+  /*PSEUDOBULK*/
+]);
+function isSingleCellTerm(term) {
+  if (!term) return false;
+  if (typeof term !== "object") throw new Error("Term is not an object. Did you provide the type instead?");
+  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 hasLegacyGroupsetOrigins(groupset) {
+  let found = false;
+  walkTvs(groupset, (tvs) => {
+    if (tvs.term?.origin) found = true;
+  });
+  return found;
+}
+function migrateLegacyTvsOrigins(tvs) {
+  if (!tvs?.term) return tvs;
+  if (tvs.term.origin && !tvs.origins?.length) tvs.origins = [tvs.term.origin];
+  delete tvs.term.origin;
+  delete tvs.term.name_noOrigin;
+  return tvs;
+}
+function migrateLegacyGroupsetOrigins(groupset) {
+  walkTvs(groupset, migrateLegacyTvsOrigins);
+  return groupset;
+}
+function getOriginLabel(origins, byOrigin) {
+  if (!origins?.length || !byOrigin) return "";
+  if (origins.length == Object.keys(byOrigin).length) return "";
+  return origins.map((origin) => byOrigin[origin]?.label || origin).join(", ");
+}
+function getGvLabelSuffix(q, term) {
+  const labels = [q?.originLabel, term?.sampleTypeLabel].filter(Boolean);
+  return labels.length ? ` (${labels.join(", ")})` : "";
+}
+function setGroupsetOrigins(groupset, byDt, seed) {
+  walkTvs(groupset, (tvs) => {
+    const origins = resolveDtOrigins(byDt, tvs.term?.dt, seed);
+    if (origins) tvs.origins = origins;
+    else delete tvs.origins;
+  });
+  return groupset;
+}
+function resolveDtOrigins(byDt, dt, seed) {
+  const byOrigin = byDt?.[dt]?.byOrigin;
+  if (!byOrigin) return;
+  const seeded = seed?.filter((origin) => origin in byOrigin);
+  return seeded?.length ? seeded : Object.keys(byOrigin);
+}
+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;
+}
+function getQuerySampleTypesByTerms(sampleTypesByTerms, querySampleTypes) {
+  if (!sampleTypesByTerms) return;
+  const querySampleTypesByTerms = {};
+  for (const [term, values] of Object.entries(sampleTypesByTerms)) {
+    const queryValues = {};
+    for (const [value, sampleTypes] of Object.entries(values)) {
+      const filteredSampleTypes = sampleTypes.filter((sampleType) => querySampleTypes.includes(sampleType));
+      if (filteredSampleTypes.length) queryValues[value] = filteredSampleTypes;
+    }
+    if (Object.keys(queryValues).length) querySampleTypesByTerms[term] = queryValues;
+  }
+  if (!Object.keys(querySampleTypesByTerms).length) return;
+  return querySampleTypesByTerms;
+}
+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",
+  singleCellNumericValue: "Single Cell, Numeric Value",
+  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,
+  hasLegacyGroupsetOrigins,
+  migrateLegacyTvsOrigins,
+  migrateLegacyGroupsetOrigins,
+  getOriginLabel,
+  getGvLabelSuffix,
+  setGroupsetOrigins,
+  walkTvs,
+  getDtsFromGroups,
+  clearDtTermMnames,
+  getQuerySampleTypesByTerms,
+  termItemType,
+  termType2label,
+  getDateFromNumber,
+  getDateStrFromNumber
+};
+//# sourceMappingURL=chunk-5FD6NRGE.js.map

package/dist/chunk-5JBOGNSG.js

@@ -0,0 +1,159 @@
+import {
+  NumericDensity
+} from "./chunk-2GP3LH7J.js";
+import {
+  HandlerBase,
+  Tabs
+} from "./chunk-ZIMAIUZD.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-U4R6HPDM.js");
+          this.handlerByMode.continuous = new NumContEditor(this.opts, this);
+          break;
+        }
+        case "discrete": {
+          const { NumDiscreteEditor } = await import("./NumDiscreteEditor-LNK4KHSL.js");
+          this.handlerByMode.discrete = new NumDiscreteEditor(this.opts, this);
+          break;
+        }
+        case "binary": {
+          const { NumBinaryEditor } = await import("./NumBinaryEditor-4WUDJRSU.js");
+          this.handlerByMode.binary = new NumBinaryEditor(this.opts, this);
+          break;
+        }
+        case "spline": {
+          const { NumSplineEditor } = await import("./NumSplineEditor-YSQTKBFA.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-5JBOGNSG.js.map