@sjcrh/proteinpaint-client 2.208.0 → 2.210.0

package/dist/chunk-5UB5H7A3.js

@@ -0,0 +1,123 @@
+import {
+  pickCollectionFraction,
+  renderTable
+} from "./chunk-55FABQU2.js";
+
+// termdb/handlers/termCollection.ts
+var SearchHandler = class {
+  async init(opts) {
+    this.callback = opts.callback;
+    this.app = opts.app;
+    opts.holder.style("display", "");
+    const termlst = opts.details.termlst ?? [];
+    const memberType = opts.details.memberType || opts.details.type;
+    if (opts.termCollectionSelectionMode === "fraction" && memberType === "numeric") {
+      pickCollectionFraction({
+        holder: opts.holder,
+        term: makeTerm(opts.details, termlst, opts.usecase),
+        callback: (tw) => opts.callback(tw)
+      });
+      return;
+    }
+    const tableDiv = opts.holder.append("div");
+    renderTable({
+      columns: [{ label: "VARIABLES" }],
+      rows: termlst.map((t) => {
+        return [{ value: t.name }];
+      }),
+      div: tableDiv,
+      maxWidth: "30vw",
+      maxHeight: "40vh",
+      // the button is disabled while the selection cannot be submitted
+      noButtonCallback: () => updateSelectBtn(),
+      striped: false,
+      showHeader: true,
+      //false,
+      selectAll: true,
+      columnButtons: void 0,
+      //Leave until table.js is typed
+      buttons: void 0
+    });
+    let categoryTable;
+    let ckSource = [];
+    if (opts.details.categoryKeys) {
+      ckSource = opts.details.categoryKeys;
+      const categoryDiv = opts.holder.append("div").style("margin-top", "15px");
+      const values = opts.details.termlst[0].values || {};
+      categoryTable = categoryDiv.append("div");
+      renderTable({
+        columns: [{ label: "CATEGORIES" }],
+        rows: ckSource.map((ck) => {
+          return [{ value: values[ck.key]?.label ?? ck.key, checked: ck.shown }];
+        }),
+        div: categoryTable,
+        maxWidth: "30vw",
+        maxHeight: "40vh",
+        noButtonCallback: () => updateSelectBtn(),
+        striped: false,
+        showHeader: true,
+        //false,
+        selectAll: true,
+        columnButtons: void 0,
+        //Leave until table.js is typed
+        buttons: void 0
+      });
+    }
+    function getRowChecks(div) {
+      const trs = div.select("table").select("tbody").node().querySelectorAll("tr");
+      return [...trs].map((tr) => tr.querySelectorAll("td")[1]?.querySelector("input")?.checked === true);
+    }
+    function getSelectedTermlst() {
+      const checked = getRowChecks(tableDiv);
+      return termlst.filter((term, i) => checked[i]);
+    }
+    function getCategoryKeys() {
+      if (!categoryTable) return void 0;
+      const checked = getRowChecks(categoryTable);
+      return ckSource.map((ck, i) => ({ key: ck.key, shown: checked[i] }));
+    }
+    function getSelectionError() {
+      if (getSelectedTermlst().length < 2) return "Select at least two variables.";
+      if (getCategoryKeys()?.every((ck) => !ck.shown)) return "Select at least one category.";
+      return void 0;
+    }
+    function updateSelectBtn() {
+      if (!selectBtn) return;
+      const error = getSelectionError();
+      selectBtn.property("disabled", Boolean(error)).attr("title", error || null);
+    }
+    const selectBtn = opts.holder.append("div").style("float", "right").style("padding", "6px 20px").append("button").attr("data-testid", "sjpp-term-collection-select").text("Select").on("click", () => {
+      opts.callback({
+        // makeTerm() extracts propsByTermId (color, etc) for the selected terms
+        ...makeTerm(opts.details, getSelectedTermlst(), opts.usecase),
+        categoryKeys: getCategoryKeys()
+      });
+    });
+    updateSelectBtn();
+  }
+};
+function makeTerm(details, termlst, usecase) {
+  const propsByTermId = {};
+  if (details.propsByTermId) {
+    for (const term of termlst) {
+      if (details.propsByTermId[term.id]) propsByTermId[term.id] = details.propsByTermId[term.id];
+    }
+  }
+  return {
+    type: "termCollection",
+    termIds: termlst.map((term) => term.id),
+    termlst,
+    name: details.name,
+    valueTransform: details.valueTransformByPlots?.[usecase?.target],
+    // memberType = ds.cohort.termdb.termCollections[].type for client code
+    memberType: details.memberType || details.type,
+    categoryKeys: details.categoryKeys,
+    isleaf: true,
+    propsByTermId
+  };
+}
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-5UB5H7A3.js.map

package/dist/chunk-6FYQYTV6.js

@@ -0,0 +1,141 @@
+import {
+  skipPrevActionAbort,
+  storeInit
+} from "./chunk-S2ICJ3RZ.js";
+import {
+  recoverInit
+} from "./chunk-X46YA4CB.js";
+import {
+  AppBase,
+  sayerror,
+  vocabInit
+} from "./chunk-55FABQU2.js";
+import {
+  importPlot
+} from "./chunk-UXD6G6G4.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import {
+  AppApi
+} from "./chunk-WINIL2KN.js";
+
+// plots/plot.app.ts
+var PlotApp = class _PlotApp extends AppBase {
+  constructor(opts, api) {
+    super(opts);
+    this.components = {};
+    this.wasDestroyed = false;
+    this.api = api;
+    this.type = _PlotApp.type;
+    this.dom = this.getDom(opts);
+  }
+  static {
+    this.type = "app";
+  }
+  getDom(opts) {
+    const dom = {
+      holder: opts.holder,
+      errdiv: opts.holder.append("div"),
+      plotDiv: opts.holder.append("div")
+    };
+    const controls = opts.violin?.mode == "minimal" ? null : opts.holder.append("div").style("white-space", "nowrap");
+    if (controls) {
+      dom.plotControls = controls.append("div").style("display", "inline-block");
+      dom.recoverControls = controls.append("div").style("display", "inline-block");
+    }
+    return dom;
+  }
+  async preApiFreeze(api) {
+    try {
+      api.tip = new Menu({ padding: "5px" });
+      api.printError = (e) => this.printError(e);
+      const vocab = this.opts.state.vocab;
+      api.vocabApi = this.opts.vocabApi ? this.opts.vocabApi : await vocabInit({
+        app: api,
+        state: {
+          vocab: {
+            // either (genome + dslabel) XOR (terms) can be undefined
+            genome: vocab?.genome || this.opts.state.genome,
+            dslabel: vocab?.dslabel || this.opts.state.dslabel,
+            terms: vocab?.terms
+          }
+        },
+        fetchOpts: this.opts.fetchOpts
+      });
+      this.opts.state.vocab = api.vocabApi.vocab;
+    } catch (e) {
+      console.log(`preApiFreeze error`, e);
+      throw e;
+    }
+  }
+  async init() {
+    try {
+      this.opts.state.nav = { header_mode: "hidden" };
+      this.store = await storeInit({ app: this.api, state: this.opts.state });
+      this.state = await this.store.copyState();
+      this.components = {
+        plots: {}
+      };
+      if (this.opts.app?.features?.includes("recover"))
+        this.components.recover = await recoverInit({
+          app: this.api,
+          holder: this.dom.recoverControls,
+          // TODO: ???? may limit the tracked state to only the filter, activeCohort ???
+          getState: (appState) => appState,
+          //reactsTo: action => true, //action.type != 'plot_edit' || action.type == 'app_refresh',
+          maxHistoryLen: 10
+        });
+      if (this.opts.app?.doNotAwaitInitRender) {
+        this.api.dispatch();
+      } else {
+        await this.api.dispatch();
+      }
+    } catch (e) {
+      this.printError(e);
+      throw e;
+    }
+  }
+  async main() {
+    this.api.vocabApi.main();
+    for (const id in this.components.plots) {
+      const plot = this.components.plots[id];
+      if (!this.state.plots.find((p) => p.id === plot.id)) {
+        plot.destroy();
+        delete this.components.plots[id];
+      }
+    }
+    for (const plot of this.state.plots.values()) {
+      if (plot.parentId) continue;
+      if (!this.components.plots[plot.id]) {
+        const holder = this.opts?.app?.getPlotHolder ? this.opts.app.getPlotHolder(plot, this.dom.holder) : this.dom.holder.append("div");
+        if (!this.dom.plotDiv) this.dom.plotDiv = holder;
+        const { componentInit } = await importPlot(plot.chartType);
+        const plotApi = await componentInit({
+          id: plot.id,
+          app: this.api,
+          holder,
+          controls: this.dom.plotControls
+        });
+        this.components.plots[plot.id] = plotApi;
+      }
+    }
+  }
+  printError(e) {
+    sayerror(this.dom.errdiv, "Error: " + (e.message || e));
+    if (e.stack) console.log(e.stack);
+    this.bus.emit("error");
+  }
+  skipPrevActionAbort(action) {
+    return skipPrevActionAbort(action);
+  }
+  destroy() {
+    if (this.dom?.holder) this.dom.holder.selectAll("*").remove();
+  }
+};
+var appInit = AppApi.getInitFxn(PlotApp);
+
+export {
+  appInit
+};
+//# sourceMappingURL=chunk-6FYQYTV6.js.map

package/dist/chunk-6RP6CR4Q.js

@@ -0,0 +1,182 @@
+import {
+  Tabs,
+  addGeneSearchbox,
+  make_one_checkbox,
+  make_radios
+} from "./chunk-55FABQU2.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import {
+  termType2label
+} from "./chunk-KIAMLQ7S.js";
+import {
+  TermTypeGroups
+} from "./chunk-SB36AUG7.js";
+
+// termdb/handlers/pseudobulk.ts
+var SearchHandler = class {
+  async init(opts) {
+    const pseudobulkTerms = this.validateOpts(opts);
+    this.callback = opts.callback;
+    this.app = opts.app;
+    this.genome = opts.genomeObj;
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    this.multiSelect = opts?.usecase?.target == "aggregateMatrix";
+    this.selectedTerm = void 0;
+    this.map = this.buildRenderingDataMap(pseudobulkTerms);
+    this.renderPseudobulkSearch(holder);
+  }
+  validateOpts(opts) {
+    if (!opts) throw new Error("opts is required");
+    if (!opts.app) throw new Error("opts.app is required");
+    if (!opts.holder) throw new Error("opts.holder is required");
+    if (opts.genomeObj == null || typeof opts.genomeObj !== "object") throw new Error("genomeObj is required");
+    if (!opts.callback) throw new Error("opts.callback is required");
+    const pseudobulkTerms = opts.app.vocabApi.termdbConfig?.termType2terms?.[TermTypeGroups.PSEUDOBULK];
+    if (!pseudobulkTerms?.length) {
+      throw new Error(
+        `termType2terms[${TermTypeGroups.PSEUDOBULK}]:[] is required in termdbConfig for pseudobulk handler`
+      );
+    }
+    return pseudobulkTerms;
+  }
+  /** Builds a map from assay to memberId to terms */
+  buildRenderingDataMap(pseudobulkTerms) {
+    const map = /* @__PURE__ */ new Map();
+    for (const term of pseudobulkTerms) {
+      const { assay, memberId } = term;
+      if (!map.has(assay)) map.set(assay, /* @__PURE__ */ new Map());
+      const assayMap = map.get(assay);
+      if (!assayMap.has(memberId)) assayMap.set(memberId, []);
+      assayMap.get(memberId).push(term);
+    }
+    return map;
+  }
+  /** If more than one assay, render tabs for each assay. Member IDs within
+   * an assay are rendered as tabs when there is more than one. */
+  renderPseudobulkSearch(holder) {
+    if (!this.map || this.map.size < 1) throw new Error("map is not initialized");
+    if (this.map.size === 1) {
+      const label = termType2label(this.map.keys().next().value);
+      holder.append("div").style("padding-bottom", "10px").text("Single-cell pseudobulk " + label);
+      this.renderMemberIdsByAssay(holder.append("div"), this.map);
+      return;
+    }
+    const tabs = this.buildTabsOpts(this.map);
+    new Tabs({ holder, tabs, tabsPosition: "vertical" }).main();
+  }
+  buildTabsOpts(map) {
+    const tabs = [];
+    for (const [key, valuesMap] of map.entries()) {
+      const label = termType2label(key);
+      tabs.push({
+        label,
+        active: false,
+        callback: (_, tab) => {
+          this.renderMemberIdsByAssay(tab.contentHolder, /* @__PURE__ */ new Map([[key, valuesMap]]));
+        }
+      });
+    }
+    return tabs;
+  }
+  renderMemberIdsByAssay(holder, map) {
+    const memberIdMap = map.values().next().value;
+    holder.selectAll("*").remove();
+    this.renderTermdByMemberId(holder, memberIdMap);
+  }
+  renderTermdByMemberId(holder, memberIdMap) {
+    const layout = holder.append("div").style("display", "flex").style("align-items", "flex-start").style("gap", "30px");
+    const pseudoTermsWrapper = layout.append("div").attr("data-testid", "sjpp-pseudobulk-terms-wrapper");
+    const geneSearchWrapper = layout.append("div").attr("data-testid", "sjpp-pseudobulk-gene-search-wrapper");
+    this.renderPseudobulkTerms(pseudoTermsWrapper, memberIdMap, geneSearchWrapper);
+  }
+  renderPseudobulkTerms(holder, memberIdMap, geneSearchHolder) {
+    if (memberIdMap.size === 1) {
+      const [memberId, terms] = memberIdMap.entries().next().value;
+      if (this.multiSelect) {
+        this.renderCategoriesAsTerms(holder, terms);
+      } else this.renderCategoryRadios(holder, memberId, terms, geneSearchHolder);
+      return;
+    }
+    const memberEntries = Array.from(memberIdMap.entries());
+    const tabs = memberEntries.map(([memberId, terms]) => ({
+      label: memberId,
+      active: false,
+      testid: `sjpp-pseudobulk-member-${memberId}`,
+      callback: (_, tab) => {
+        geneSearchHolder.selectAll("*").remove();
+        tab.contentHolder.selectAll("*").remove();
+        if (this.multiSelect) this.renderCategoriesAsTerms(tab.contentHolder, terms);
+        else this.renderCategoryRadios(tab.contentHolder, memberId, terms, geneSearchHolder);
+      }
+    }));
+    new Tabs({ holder, tabs, tabsPosition: "vertical" }).main();
+  }
+  renderCategoryRadios(holder, memberId, terms, geneSearchHolder) {
+    if (!terms || terms.length < 1) throw new Error("No terms found for memberId");
+    const options = terms.map((term) => ({
+      label: term.name,
+      value: term.id,
+      checked: false,
+      testid: `sjpp-pseudobulk-category-${term.id}`
+    }));
+    make_radios({
+      holder,
+      inputName: `sjpp-pseudobulk-category-radios-${memberId}`,
+      options,
+      styles: { display: "block", padding: "3px 5px" },
+      callback: (value) => {
+        const term = terms.find((term2) => term2.id == value);
+        if (!term) throw new Error(`No pseudobulk term found for category ${value}`);
+        this.selectedTerm = term;
+        this.renderGeneSelection(geneSearchHolder);
+      }
+    });
+  }
+  renderGeneSelection(holder) {
+    holder.selectAll("*").remove();
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: this.genome,
+      row: holder,
+      searchOnly: "gene",
+      callback: () => {
+        if (!geneSearch.geneSymbol) throw new Error("No gene selected");
+        if (!this.selectedTerm) throw new Error("No pseudobulk cell type selected");
+        this.callback(createPseudobulkTerm(this.selectedTerm, geneSearch.geneSymbol));
+      }
+    });
+  }
+  /** Mimics the style and functionality of pills created in tree.js.
+   * Returns the term object(s) from termdbConfig.termType2terms.[TermTypeGroups.PSEUDOBULK]
+   * without the gene. */
+  renderCategoriesAsTerms(holder, terms) {
+    holder.style("padding", "0px 10px");
+    make_one_checkbox({
+      holder,
+      labeltext: "Select all",
+      divstyle: { opacity: "0.7" },
+      callback: () => this.callback(terms)
+    });
+    const wrapper = holder.append("div").style("display", "block").style("padding", "10px 15px 0px");
+    wrapper.selectAll(".pseudobulk-term").data(terms, (term) => term.id).join((enter) => {
+      const row = enter.append("div").attr("class", "pseudobulk-term");
+      row.append("div").attr("class", "termlabel sja_filter_tag_btn sja_tree_click_term ts_pill").style("padding", "5px 8px").style("margin", "1px 0px").style("border-radius", "6px").text((term) => term.name).on("click", async (_, term) => {
+        await this.callback(term);
+      });
+      return row;
+    });
+  }
+};
+function createPseudobulkTerm(selectedTerm, gene) {
+  const category = selectedTerm.category || selectedTerm.id;
+  const name = `${selectedTerm.assay} ${category} ${gene}`;
+  return { ...selectedTerm, id: name, category, gene, name };
+}
+
+export {
+  SearchHandler,
+  createPseudobulkTerm
+};
+//# sourceMappingURL=chunk-6RP6CR4Q.js.map

package/dist/chunk-A5D37SIL.js

@@ -0,0 +1,103 @@
+import {
+  SearchHandler,
+  fillTermWrapper,
+  table2col,
+  termsettingInit
+} from "./chunk-55FABQU2.js";
+
+// plots/summarizeMutationDiagnosis.ts
+async function makeChartBtnMenu(holder, chartsInstance) {
+  let dictTw;
+  {
+    const t = chartsInstance.app.vocabApi.termdbConfig.defaultTw4correlationPlot?.disease;
+    if (!t) throw "defaultTw4correlationPlot missing";
+    dictTw = structuredClone(t);
+    await fillTermWrapper(dictTw, chartsInstance.app.vocabApi);
+  }
+  const table = table2col({
+    holder: holder.append("div"),
+    margin: "0px 10px 10px 10px",
+    cellPadding: "10px"
+  });
+  {
+    const [td1, td2] = table.addRow();
+    td1.text("Mutation Variable");
+    const searchDiv = td2.append("div");
+    const geneSearchInst = new SearchHandler();
+    geneSearchInst.init({
+      holder: searchDiv,
+      app: chartsInstance.app,
+      // required to supply "opts.app.vocabApi" for the search ui
+      genomeObj: chartsInstance.app.opts.genome,
+      msg: "Hit ENTER to launch plot.",
+      /* the geneTw below is used as it comes, so a grouping the user built for this gene
+      elsewhere can be offered here, see keepsQ in client/termdb/TermTypeSearch.ts */
+      keepsQ: true,
+      callback: async (geneTw) => {
+        await fillTermWrapper(geneTw, chartsInstance.app.vocabApi);
+        launchPlot({
+          tw1: dictTw,
+          tw2: geneTw,
+          chartsInstance,
+          holder
+        });
+      }
+    });
+    searchDiv.style("padding", "0px 0px 5px 0px");
+  }
+  {
+    const [td1, td2] = table.addRow();
+    td1.text("Compare Mutations Against");
+    const pillDiv = td2.append("div"), waitDiv = td2.append("div").style("font-size", ".7em").text("LOADING ...");
+    const pill = await termsettingInit({
+      menuOptions: "{edit,replace}",
+      /** presumably this usecase let it restrict to dictionary term ui, and hide genomic queries
+      target="filter" works for gdc since in gdc ds it is overriding filter to dict
+      but is not a general fix for non-gdc ds, which Replace menu will launch genomic+dict options
+      maybe this is okay for non-gdc ds as the default dictTw is meaningful
+      */
+      usecase: { target: "filter" },
+      vocabApi: chartsInstance.app.vocabApi,
+      holder: pillDiv,
+      callback: async (tw) => {
+        waitDiv.text("LOADING ...");
+        try {
+          await pill.main(tw);
+          dictTw = tw;
+          waitDiv.text("Click to edit/replace the variable before searching gene.");
+        } catch (e) {
+          waitDiv.text("Error: " + (e.message || e));
+        }
+      }
+    });
+    try {
+      await fillTermWrapper(dictTw, chartsInstance.app.vocabApi);
+      await pill.main(dictTw);
+      waitDiv.text("Click to edit/replace the variable before searching gene.");
+    } catch (e) {
+      waitDiv.text("Error: " + (e.message || e));
+    }
+  }
+}
+function launchPlot({ tw1, tw2, chartsInstance, holder }) {
+  const chart = {
+    config: {
+      chartType: tw1?.term?.type == "survival" ? "survival" : "summary",
+      // TODO define sandbox header with gene+term name
+      term: tw1,
+      term2: tw2
+    }
+  };
+  chartsInstance.plotCreate(chart);
+  holder.selectAll("*").remove();
+  holder.append("div").style("margin", "20px").text("LOADING CHART ...");
+  setTimeout(() => {
+    holder.style("display", "none");
+  }, 1e3);
+}
+
+export {
+  makeChartBtnMenu,
+  launchPlot
+};
+//# sourceMappingURL=chunk-A5D37SIL.js.map

package/dist/chunk-ADRFQ5AL.js

@@ -0,0 +1,102 @@
+import {
+  addGeneSearchbox,
+  first_genetrack_tolist,
+  getDNAMethUnit,
+  sayerror
+} from "./chunk-55FABQU2.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import {
+  DNA_METHYLATION
+} from "./chunk-SB36AUG7.js";
+
+// termdb/handlers/dnaMethylation.ts
+var SearchHandler = class {
+  init(opts) {
+    this.opts = opts;
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const holder = opts.holder.append("div").style("margin", "10px 0px");
+    this.dom = {};
+    this.dom.errDiv = holder.append("div").style("margin", "5px 0px").style("display", "none");
+    this.dom.geneSearchDiv = holder.append("div");
+    this.dom.blockDiv = holder.append("div").style("display", "none").style("margin", "15px 4px");
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: opts.genomeObj,
+      row: this.dom.geneSearchDiv,
+      callback: async () => {
+        try {
+          this.dom.errDiv.style("display", "none");
+          await this.handleGeneSearch(geneSearch);
+        } catch (e) {
+          this.dom.errDiv.style("display", "block");
+          sayerror(this.dom.errDiv, "Error: " + (e.message || e));
+          if (e.stack) console.log(e.stack);
+        }
+      }
+    });
+  }
+  async handleGeneSearch(geneSearch) {
+    if (geneSearch.geneSymbol) {
+      const { chr, start, stop } = geneSearch;
+      if (!chr || !Number.isInteger(start) || !Number.isInteger(stop))
+        throw new Error("unable to retrieve gene coordinate");
+      this.dom.blockDiv.selectAll("*").remove();
+      this.dom.blockDiv.style("display", "block");
+      this.dom.blockDiv.append("div").style("opacity", 0.6).text("Navigate genome browser to desired region");
+      const arg = {
+        holder: this.dom.blockDiv,
+        genome: this.opts.genomeObj,
+        // genome obj
+        chr,
+        start,
+        stop,
+        tklst: [],
+        nobox: true,
+        width: 500,
+        hidegenelegend: true,
+        debugmode: this.opts.debug
+      };
+      first_genetrack_tolist(this.opts.genomeObj, arg.tklst);
+      const _ = await import("./block-43KNTXZ5.js");
+      this.blockInstance = new _.Block(arg);
+      this.dom.submitBtn = this.dom.blockDiv.append("div").attr("data-testid", "sjpp-dnaMethylation-submitDiv").style("margin", "10px 0px").append("button").style("border", "none").style("border-radius", "20px").style("padding", "10px 15px").text("Submit Region").on("click", async () => {
+        const { chr: chr2, start: start2, stop: stop2 } = this.blockInstance.rglst[0];
+        const term = this.makeTerm({ chr: chr2, start: start2, stop: stop2 });
+        await this.callback(term);
+      });
+    } else if (geneSearch.chr && Number.isInteger(geneSearch.start) && Number.isInteger(geneSearch.stop)) {
+      const { chr } = geneSearch;
+      let { start, stop } = geneSearch;
+      if (geneSearch.actualposition?.len <= 1) {
+        start = geneSearch.actualposition.position;
+        stop = start + 1;
+      }
+      const term = this.makeTerm({ chr, start, stop });
+      await this.callback(term);
+    } else {
+      throw new Error("invalid gene search input");
+    }
+  }
+  makeTerm(opts) {
+    const { chr, start, stop } = opts;
+    if (!chr || !Number.isInteger(start) || !Number.isInteger(stop)) throw new Error("invalid coordinate");
+    const unit = getDNAMethUnit("region", this.app.vocabApi);
+    const term = {
+      chr,
+      start,
+      stop,
+      type: DNA_METHYLATION,
+      unit,
+      genomicFeatureType: "region"
+    };
+    return term;
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-ADRFQ5AL.js.map