@sjcrh/proteinpaint-client 2.210.0 → 2.210.1

package/dist/junction.unit.spec-4MWU36MR.js

@@ -0,0 +1,182 @@
+import {
+  SearchHandler
+} from "./chunk-PUSSP76H.js";
+import {
+  makeJunctionCustomTerm
+} from "./chunk-Q3PAXUCU.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import "./chunk-UYKJOBRO.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// termdb/handlers/test/junction.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+function makeJunction(id) {
+  return {
+    type: "junction",
+    id,
+    name: `Name ${id}`,
+    chr: "chr1",
+    start: 100,
+    stop: 200,
+    strand: "+",
+    info: {}
+  };
+}
+function getOpts(holder, dslabel, customTerms = [], callback = (_term) => {
+}, termCollectionSelectionMode) {
+  const state = { customTerms };
+  return {
+    holder,
+    callback,
+    termCollectionSelectionMode,
+    genomeObj: { name: "hg38" },
+    app: {
+      vocabApi: {
+        vocab: { dslabel },
+        state,
+        async deleteCustomTermById(id) {
+          const index = state.customTerms.findIndex((term) => term.id === id);
+          if (index !== -1) state.customTerms.splice(index, 1);
+        }
+      }
+    }
+  };
+}
+(0, import_tape.default)("\n", (test) => {
+  test.comment("-***- termdb/handlers/junction -***-");
+  test.end();
+});
+(0, import_tape.default)("init() shows the empty-state message", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  await handler.init(getOpts(holder, "junction-handler-empty"));
+  test.ok(holder.text().includes("Junctions selected from genome browser"), "shows the empty-state instructions");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("ungrouped junctions render as selectable pills and can be deleted", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  let selected;
+  const dslabel = "junction-handler-ungrouped";
+  const customTerms = [makeJunctionCustomTerm([makeJunction("junction-1")])];
+  await handler.init(
+    getOpts(holder, dslabel, customTerms, (term) => {
+      selected = term;
+    })
+  );
+  const pill = holder.select(".ts_pill");
+  test.equal(pill.text(), "Name junction-1", "renders the junction name in a pill");
+  pill.node().click();
+  test.equal(selected?.id, "junction-1", "selects the individual junction");
+  holder.select('[data-testid="sjpp-junction-delete"]').node().click();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  test.equal(holder.selectAll(".ts_pill").size(), 0, "removes the deleted junction pill");
+  test.ok(holder.text().includes("Junctions selected from genome browser"), "restores the empty state");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("event junctions render as one pill that selects and deletes the term collection", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  let selected;
+  const dslabel = "junction-handler-event";
+  const customTerms = [makeJunctionCustomTerm([makeJunction("junction-1"), makeJunction("junction-2")], "Event A")];
+  await handler.init(
+    getOpts(holder, dslabel, customTerms, (term) => {
+      selected = term;
+    })
+  );
+  const pills = holder.selectAll(".ts_pill");
+  test.equal(pills.size(), 1, "renders one pill for the event and no member junction pills");
+  test.equal(pills.text(), "Event A", "uses the event label as the pill text");
+  test.ok(holder.text().includes("junction-1"), "lists the first junction ID");
+  test.ok(holder.text().includes("junction-2"), "lists the second junction ID");
+  pills.node().click();
+  test.equal(selected?.type, "termCollection", "selects a term collection");
+  test.equal(selected?.memberType, "numeric", "creates a numeric collection");
+  test.equal(selected?.name, "Event A", "uses the event label as the collection name");
+  test.deepEqual(selected?.termIds, ["junction-1", "junction-2"], "includes all event junction IDs");
+  test.ok(selected?.propsByTermId["junction-1"].color, "assigns the first junction a color");
+  test.ok(selected?.propsByTermId["junction-2"].color, "assigns the second junction a color");
+  test.notEqual(
+    selected?.propsByTermId["junction-1"].color,
+    selected?.propsByTermId["junction-2"].color,
+    "assigns distinct member colors"
+  );
+  holder.select('[data-testid="sjpp-junction-delete"]').node().click();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  test.equal(holder.selectAll(".ts_pill").size(), 0, "removes the complete event choice");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init() only shows state-backed junction custom terms", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  const customTerms = [
+    makeJunctionCustomTerm([makeJunction("active-junction")]),
+    { id: "other-custom-term", name: "Other", tw: { term: { type: "float", id: "other", name: "Other" } } }
+  ];
+  await handler.init(getOpts(holder, "active", customTerms));
+  test.equal(holder.selectAll(".ts_pill").size(), 1, "renders only one matching junction term");
+  test.equal(holder.select(".ts_pill").text(), "Name active-junction", "renders the state-backed junction");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("event junction renders fraction choices when requested", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  let selected;
+  const customTerms = [makeJunctionCustomTerm([makeJunction("junction-1"), makeJunction("junction-2")], "Event A")];
+  await handler.init(
+    getOpts(
+      holder,
+      "junction-handler-fraction",
+      customTerms,
+      (term) => {
+        selected = term;
+      },
+      "fraction"
+    )
+  );
+  holder.select(".ts_pill").node().click();
+  test.ok(holder.text().includes("Denominator"), "renders denominator choices for the event collection");
+  holder.select('[data-testid="sjpp-term-collection-fraction-select"]').node().click();
+  test.equal(selected?.type, "TermCollectionTWFraction", "returns a fraction wrapper");
+  test.deepEqual(selected?.q.denominators, ["junction-1", "junction-2"], "defaults both junctions as denominators");
+  test.deepEqual(selected?.q.numerators, ["junction-1"], "defaults only the first junction as numerator");
+  test.equal(selected?.term.termlst.length, 2, "retains both junction members");
+  holder.remove();
+  test.end();
+});
+//# sourceMappingURL=junction.unit.spec-4MWU36MR.js.map

package/dist/launch.adhoc-3B34GV4S.js

@@ -0,0 +1,37 @@
+import {
+  launch
+} from "./chunk-3CGAABHZ.js";
+import "./chunk-DH74ZT37.js";
+import "./chunk-BSWPONNA.js";
+import "./chunk-X46YA4CB.js";
+import "./chunk-SKMFMGCD.js";
+import "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import "./chunk-UYKJOBRO.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+export {
+  launch
+};
+//# sourceMappingURL=launch.adhoc-3B34GV4S.js.map

package/dist/leftlabel.sample-6OM5H67E.js

@@ -0,0 +1,258 @@
+import {
+  displaySampleTable,
+  getFilterName,
+  makelabel
+} from "./chunk-CW35X5ZL.js";
+import "./chunk-SKMFMGCD.js";
+import "./chunk-YPHFEKWI.js";
+import "./chunk-5XE3WSUX.js";
+import "./chunk-V2OJLJSK.js";
+import "./chunk-4FTH4L3A.js";
+import "./chunk-XDLKYVYU.js";
+import {
+  Tabs,
+  fillbar,
+  filterInit,
+  getNormalRoot,
+  renderTable
+} from "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import "./chunk-UYKJOBRO.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import {
+  violinRenderer
+} from "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// mds3/leftlabel.sample.js
+function makeSampleLabel(data, tk, block, laby) {
+  if (!tk.leftlabels.doms.samples) {
+    tk.leftlabels.doms.samples = makelabel(tk, block, laby);
+  }
+  if (data.sampleTotalNumber) {
+    tk.leftlabels.doms.samples.attr("class", "sja_clbtext2").style("opacity", 1).text(`${data.sampleTotalNumber} sample${data.sampleTotalNumber > 1 ? "s" : ""}`).attr("data-testid", "sjpp_mds3tk_samples_label").on("click", async (event) => {
+      tk.menutip.clear().showunder(event.target);
+      await mayShowSummary(tk, block);
+      const buttonrow = tk.menutip.d.append("div").style("margin", "10px");
+      menu_listSamples(buttonrow, data, tk, block);
+    });
+  } else {
+    tk.leftlabels.doms.samples.text("No samples").attr("class", "").style("opacity", 0.5).on("click", null);
+  }
+}
+function makeSampleFilterLabel(data, tk, block, laby) {
+  if (!tk.leftlabels.doms.filterObj) {
+    tk.leftlabels.doms.filterObj = makelabel(tk, block, laby);
+    tk.leftlabels.doms.filterObj.attr("data-testid", "sjpp_mds3tk_leftlabel_samplefilter");
+  }
+  tk.leftlabels.doms.filterObj.text(getFilterName(tk.filterObj)).on("click", async (event) => {
+    tk.menutip.clear().showunder(event.target);
+    const arg = {
+      holder: tk.menutip.d.append("div").style("margin", "10px"),
+      vocabApi: tk.mds.termdb.vocabApi,
+      callback: (f) => {
+        tk.filterObj = f;
+        tk.load();
+      }
+    };
+    mayAddGetCategoryArgs(arg, block);
+    filterInit(arg).main(tk.filterObj);
+  });
+}
+function mayAddGetCategoryArgs(arg, block) {
+  if (block.usegm) {
+    arg.getCategoriesArguments = { currentGeneNames: [block.usegm.name] };
+  } else {
+    arg.getCategoriesArguments = { rglst: structuredClone(block.rglst) };
+  }
+}
+async function mayShowSummary(tk, block) {
+  if (!tk.mds.variant2samples.twLst) {
+    return;
+  }
+  const div = tk.menutip.d.append("div").style("margin", "10px");
+  const wait = div.append("div").text("Loading...");
+  try {
+    const { summary } = await tk.mds.getSamples({ isSummary: true });
+    tk.leftlabels.__samples_data = summary;
+    wait.remove();
+    await showSummary4terms(summary, div.append("div").attr("data-testid", "sja_mds3samplesummarydiv"), tk, block);
+  } catch (e) {
+    wait.text(`Error: ${e.message || e}`);
+    if (e.stack) console.log(e.stack);
+  }
+}
+async function showSummary4terms(data, div, tk, block) {
+  const tabs = [];
+  for (const { termid, numbycategory } of data) {
+    tabs.push({
+      label: tk.mds.variant2samples.twLst.find((i) => i.term.id == termid).term.name + (numbycategory ? `<span style="font-size:.8em;float:right;margin-left: 5px;">n=${numbycategory.length}</span>` : ""),
+      keydownCallback: function(event) {
+        setTimeout(() => {
+          const tr = this.contentHolder.select("tbody").select("tr").node();
+          if (!tr) return;
+          tr.focus();
+        }, 100);
+      }
+    });
+  }
+  new Tabs({
+    holder: div,
+    tabsPosition: "vertical",
+    linePosition: "right",
+    tabs
+  }).main();
+  for (const [i, d] of data.entries()) {
+    const holder = tabs[i].contentHolder.style("padding-left", "20px");
+    if (d.numbycategory) {
+      holder.append("div").text("Click a category to create new track.").style("margin-bottom", "10px").style("font-size", ".8em").style("opacity", 0.5);
+      showSummary4oneTerm(d.termid, holder, d.numbycategory, tk, block);
+      continue;
+    }
+    if (d.density_data) {
+      if (!Number.isFinite(d.density_data.min) || !Number.isFinite(d.density_data.max)) {
+        holder.append("div").text("No data");
+        continue;
+      }
+      holder.append("div").text("Select a range to create new track.").style("margin-bottom", "10px").style("font-size", ".8em").style("opacity", 0.5);
+      showDensity4oneTerm(d.termid, holder, d, tk, block);
+      continue;
+    }
+    throw "unknown summary data";
+  }
+}
+function showSummary4oneTerm(termid, div, numbycategory, tk, block) {
+  const tw = tk.mds.variant2samples.twLst.find((i) => i.term.id == termid);
+  if (!tw) throw "showSummary4oneTerm(): tw not found from variant2samples.twLst";
+  const rows = [];
+  for (const [category_key, count, total] of numbycategory) {
+    const sk = category_key.replace(/\s/g, "-");
+    const row = [
+      { value: tw.term.values?.[category_key]?.label || category_key },
+      { html: total == void 0 ? "" : fillbar(null, { f: count / total, v1: count, v2: total }) },
+      {
+        html: `<span data-testid=sjpp-mds3tk-samsumcatmutcount-${sk}>${count}</span>
+			${total ? ` <span style="font-size:.8em">/ <span data-testid=sjpp-mds3tk-samsumcattotalcount-${sk}>` + total + "</span></span>" : ""}`
+      }
+    ];
+    rows.push(row);
+  }
+  renderTable({
+    div,
+    rows,
+    columns: [
+      {
+        nowrap: true
+        // to force all category values to show in one line without wrap. otherwise they wrap and column width appears fixed
+      },
+      {},
+      {}
+    ],
+    showHeader: false,
+    singleMode: true,
+    noRadioBtn: true,
+    noButtonCallback: (i) => {
+      clickCategory(numbycategory[i][0]);
+    }
+  });
+  async function clickCategory(category) {
+    tk.menutip.clear();
+    const term = await tk.mds.termdb.vocabApi.getterm(termid);
+    if (!term.values || Object.keys(term.values).length == 0) {
+      term.values = {};
+      for (const c of numbycategory) {
+        term.values[c[0]] = { label: c[0], samplecount: c[1] };
+      }
+    }
+    const tvs = {
+      type: "tvs",
+      tvs: { term, values: [{ key: category }] }
+    };
+    createSubTk(tk, block, tvs);
+  }
+}
+function getNewFilter(tk, tvs) {
+  if (tk.filterObj) {
+    return getNormalRoot({
+      type: "tvslst",
+      join: "and",
+      in: true,
+      lst: [tk.filterObj, tvs]
+    });
+  }
+  return {
+    type: "tvslst",
+    in: true,
+    join: "",
+    lst: [tvs]
+  };
+}
+async function showDensity4oneTerm(termid, div, data, tk, block) {
+  const term = await tk.mds.termdb.vocabApi.getterm(termid);
+  const callback = async (range) => {
+    tk.menutip.clear();
+    const tvs = {
+      type: "tvs",
+      tvs: { term, ranges: [{ start: range.range_start, stop: range.range_end }] }
+    };
+    createSubTk(tk, block, tvs);
+  };
+  const vr = new violinRenderer({
+    holder: div,
+    rd: data.density_data,
+    width: 400,
+    height: 100,
+    radius: 8,
+    callback,
+    scaleFactor: term.valueConversion ? term.valueConversion.scaleFactor : 1
+  });
+  vr.render();
+}
+function createSubTk(tk, block, tvs) {
+  const tk2 = block.block_addtk_template(tk.duplicateTk(getNewFilter(tk, tvs)));
+  tk2.subtk = true;
+  block.tk_load(tk2);
+}
+function menu_listSamples(buttonrow, data, tk, block) {
+  buttonrow.append("div").text(`List ${data.sampleTotalNumber} sample${data.sampleTotalNumber > 1 ? "s" : ""}`).attr("class", "sja_menuoption sja_mds3_slb_sampletablebtn").attr("data-testid", "sjpp-mds3-list-samples-option").on("click", async () => {
+    tk.menutip.clear();
+    const wait = tk.menutip.d.append("div").text("Loading...").style("margin", "15px");
+    try {
+      const { samples } = await tk.mds.getSamples();
+      await displaySampleTable(samples, {
+        div: tk.menutip.d,
+        tk,
+        block
+      });
+      wait.remove();
+    } catch (e) {
+      wait.text(e.message || e);
+      console.log(e);
+    }
+  });
+}
+export {
+  makeSampleFilterLabel,
+  makeSampleLabel
+};
+//# sourceMappingURL=leftlabel.sample-6OM5H67E.js.map

package/dist/lollipop-SL2F5G6K.js

@@ -0,0 +1,166 @@
+import {
+  block_init_default
+} from "./chunk-BX3P73XH.js";
+import {
+  addGeneSearchbox,
+  first_genetrack_tolist
+} from "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import {
+  dofetch3
+} from "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import "./chunk-UYKJOBRO.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// gdc/lollipop.js
+var tip = new Menu({ padding: "" });
+async function init(arg, holder, genomes) {
+  const useGenome = arg.genome || "hg38";
+  const useDslabel = arg.dslabel || "GDC";
+  const genome = genomes[useGenome];
+  if (!genome) throw useGenome + " missing";
+  if (arg.geneSearch4GDCmds3.onloadalltk_always && typeof arg.geneSearch4GDCmds3.onloadalltk_always != "function")
+    throw "arg.geneSearch4GDCmds3.onloadalltk_always not function";
+  if (arg.geneSearch4GDCmds3.postRender && typeof arg.geneSearch4GDCmds3.postRender != "function")
+    throw "arg.geneSearch4GDCmds3.postRender not function";
+  holder.selectAll(".sja_lollipop_holder").remove();
+  const mainDiv = holder.append("div").attr("class", "sja_lollipop_holder");
+  const geneInputDiv = mainDiv.append("div").style("margin-left", "20px");
+  geneInputDiv.append("div").text(
+    arg.geneSearch4GDCmds3.hardcodeCnvOnly ? `To view ${useDslabel} CNV segments over a gene or region, enter genomic position (chr11:108195437-108267444), dbSNP accesion, or gene name (MYC).` : `To view ${useDslabel} mutations on a gene, enter one of gene symbol (MYC), alias (c-Myc), GENCODE accession (ENSG00000136997, ENST00000621592), or RefSeq accession (NM_002467).`
+  );
+  const graphDiv = mainDiv.append("div").attr("class", "sja_geneSearch4GDCmds3_blockdiv");
+  const searchOpt = {
+    genome,
+    tip,
+    row: geneInputDiv,
+    callback: launchView,
+    geneSymbol: arg.geneSymbol,
+    triggerSearch: arg.geneSymbol && arg.geneSearch4GDCmds3?.hardcodeCnvOnly == true,
+    hideInputBeforeCallback: arg.geneSearch4GDCmds3?.hardcodeCnvOnly == true
+  };
+  if (!arg.geneSearch4GDCmds3.hardcodeCnvOnly) {
+    searchOpt.searchOnly = "gene";
+  }
+  const coordInput = addGeneSearchbox(searchOpt);
+  let userSelection;
+  await arg.geneSearch4GDCmds3.postRender?.({ tip });
+  if (arg.state) {
+    if (arg.state.userSelection) launchView(false, arg.state.userSelection);
+    delete arg.state;
+  }
+  async function launchView(triggeredByInput = true, userSelection2) {
+    const pa = {
+      // param for instantiating block
+      genome,
+      holder: graphDiv,
+      gmmode: "exon only",
+      nobox: 1,
+      hide_dsHandles: arg.hide_dsHandles,
+      onloadalltk_always: arg.geneSearch4GDCmds3.onloadalltk_always
+    };
+    if (arg.tracks) {
+      pa.tklst = arg.tracks;
+    } else {
+      const tk = {
+        type: "mds3",
+        dslabel: useDslabel,
+        allow2selectSamples: arg.allow2selectSamples,
+        filter0: arg.filter0
+      };
+      pa.tklst = [tk];
+      if (arg.geneSearch4GDCmds3.hardcodeCnvOnly) {
+        tk.hardcodeCnvOnly = 1;
+        delete pa.gmmode;
+        first_genetrack_tolist(pa.genome, pa.tklst);
+      }
+      if (arg.geneSearch4GDCmds3.snvIndelOnly) {
+        tk.snvIndelOnly = 1;
+      }
+    }
+    if (userSelection2) {
+      if (arg.geneSearch4GDCmds3.hardcodeCnvOnly) {
+        if (typeof userSelection2 != "object") throw "userSelection not object when pa.block is true";
+        pa.chr = userSelection2.chr;
+        pa.start = userSelection2.start;
+        pa.stop = userSelection2.stop;
+        if (!pa.chr || !Number.isInteger(pa.start) || !Number.isInteger(pa.stop))
+          throw "userSelection not {chr,start,stop}";
+      } else {
+        if (typeof userSelection2 != "string") throw "userSelection should be string when pa.block is not true";
+        pa.query = userSelection2;
+      }
+    } else {
+      if (arg.geneSearch4GDCmds3.hardcodeCnvOnly) {
+        if (!coordInput.chr || !Number.isInteger(coordInput.start) || !Number.isInteger(coordInput.stop)) {
+          if (triggeredByInput) throw "coordInput.chr/start/stop missing";
+        }
+        pa.chr = coordInput.chr;
+        pa.start = coordInput.start;
+        pa.stop = coordInput.stop;
+      } else {
+        if (!coordInput.geneSymbol) {
+          if (triggeredByInput) throw "coordInput.geneSymbol missing";
+        }
+        const gmlst = (await dofetch3(`genelookup?deep=1&input=${coordInput.geneSymbol}&genome=${useGenome}`)).gmlst;
+        if (!Array.isArray(gmlst) || gmlst.length == 0) throw "gmlst is not non-empty array";
+        pa.query = getSelectedIsoform(coordInput, gmlst);
+        if (gmlst.some((i) => i.coding)) pa.gmmode = "protein";
+      }
+    }
+    graphDiv.selectAll("*").remove();
+    if (!arg.geneSearch4GDCmds3.hardcodeCnvOnly) return await block_init_default(pa);
+    const _ = await import("./block-GEG4UUOU.js");
+    return new _.Block(pa);
+  }
+  const api = {
+    update: (_arg) => {
+      Object.assign(arg, _arg);
+      launchView(false);
+    },
+    getState: () => ({ userSelection })
+  };
+  return api;
+}
+function getSelectedIsoform(coordInput, gmlst) {
+  if (coordInput.fromWhat) {
+    if (gmlst.some((i) => i.isoform.toUpperCase() == coordInput.fromWhat.toUpperCase())) {
+      return coordInput.fromWhat;
+    }
+    if (coordInput.fromWhat.toUpperCase().startsWith("ENSG")) {
+      for (const i of gmlst) {
+        if (i.isdefault && i.isoform.startsWith("ENST")) return i.isoform;
+      }
+    }
+  }
+  const defaultIsoform = gmlst.find((i) => i.isdefault);
+  if (defaultIsoform) return defaultIsoform.isoform;
+  return gmlst[0].isoform;
+}
+export {
+  init
+};
+//# sourceMappingURL=lollipop-SL2F5G6K.js.map