@sjcrh/proteinpaint-client 2.196.0 → 2.198.0

package/dist/bubbleHeatmap-ERWNEKZB.js

@@ -0,0 +1,383 @@
+import {
+  LegendCircleReference,
+  PlotBase,
+  addGeneSearchbox
+} from "./chunk-5VOPABBA.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-LSEFWW72.js";
+import "./chunk-Z5U6HOE4.js";
+import {
+  Menu
+} from "./chunk-HYOEWQ5P.js";
+import "./chunk-HBW42TDT.js";
+import "./chunk-FN5XPUPH.js";
+import "./chunk-5ABGFJSP.js";
+import "./chunk-IIT367QZ.js";
+import "./chunk-RZGEKL77.js";
+import "./chunk-XPY6AWXO.js";
+import "./chunk-NELOT3NJ.js";
+import {
+  dofetch3
+} from "./chunk-M6EF3WVV.js";
+import "./chunk-7IYJZZQI.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-M3J4MINX.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-LFCYMSVA.js";
+import "./chunk-I6WR4CG7.js";
+import "./chunk-2X6W4E3W.js";
+import "./chunk-NYRZNRG5.js";
+import "./chunk-JNITUVXP.js";
+import "./chunk-3XVVN66M.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-VQZ2Z5YU.js";
+import {
+  linear,
+  sqrt
+} from "./chunk-NSTL4MY2.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-KYBIQBXE.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-OMR2DT66.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HFNDKYVF.js";
+
+// plots/bubbleHeatmap.ts
+var defaultConfig = { chartType: "bubbleHeatmap" };
+var CELL_W = 92;
+var CELL_H = 64;
+var ROW_LABEL_W = 170;
+var COL_LABEL_H = 92;
+var SITE_DOT_R = 5;
+var SITE_DOT_SP = 13;
+var CELL_PAD = 8;
+var MIN_DOT_R = 8;
+var MAX_DOT_R = 20;
+var NEG_LOG_P_CAP = 10;
+var BubbleHeatmap = class _BubbleHeatmap extends PlotBase {
+  constructor(opts, api) {
+    super(opts, api);
+    this.currentIsoform = "";
+    this.useAdjusted = false;
+    this.type = _BubbleHeatmap.type;
+    this.components = {};
+  }
+  static {
+    this.type = "bubbleHeatmap";
+  }
+  async init() {
+    const holder = this.opts.holder.append("div").style("padding", "10px");
+    this.dom = {
+      holder,
+      body: holder.append("div"),
+      tip: new Menu({ padding: "" }),
+      header: this.opts.header
+    };
+    if (this.dom.header) this.dom.header.html("Bubble Heatmap");
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) throw `No plot with id='${this.id}' found`;
+    return { config };
+  }
+  async main() {
+    const gene = this.state.config?.gene;
+    if (!gene) throw new Error("bubbleHeatmap: gene is missing");
+    if (this.dom.header) this.dom.header.text(`Bubble Heatmap: ${gene}`);
+    const body = {
+      genome: this.app.opts.state.vocab.genome,
+      dslabel: this.app.opts.state.vocab.dslabel,
+      gene
+    };
+    const data = await dofetch3("termdb/bubbleHeatmap", { body });
+    if (data.error) throw data.error;
+    this.data = data;
+    this.dom.body.selectAll("*").remove();
+    const isoformIds = Object.keys(data.isoforms);
+    if (isoformIds.length === 0) {
+      this.dom.body.append("div").style("padding", "20px").style("color", "#666").text(`No data found for gene "${gene}" in any (assay, cohort) DAPfile.`);
+      return;
+    }
+    this.useAdjusted = !!data.proteinReferenceAssay;
+    this.currentIsoform = isoformIds[0];
+    const isoBlock = this.dom.body.append("div").style("margin-bottom", "12px");
+    isoBlock.append("span").style("font-weight", "bold").text("Isoform: ");
+    if (isoformIds.length > 1) {
+      const sel = isoBlock.append("select").style("margin-left", "5px").style("padding", "3px 6px").on("change", () => {
+        this.currentIsoform = sel.node().value;
+        this.renderGrid();
+      });
+      sel.selectAll("option").data(isoformIds).enter().append("option").attr("value", (d) => d).text((d) => `${data.isoforms[d].gene_name} \u2014 ${d}`);
+    } else {
+      isoBlock.append("span").style("margin-left", "5px").text(`${data.isoforms[this.currentIsoform].gene_name} \u2014 ${this.currentIsoform}`);
+    }
+    this.gridHolder = this.dom.body.append("div");
+    this.renderGrid();
+  }
+  renderGrid() {
+    const data = this.data;
+    const selectedIsoform = this.currentIsoform;
+    const useAdjusted = this.useAdjusted;
+    const refAssay = data.proteinReferenceAssay;
+    const threshold = data.pValueThreshold;
+    this.gridHolder.selectAll("*").remove();
+    const container = this.gridHolder.append("div").style("display", "flex").style("gap", "24px").style("align-items", "flex-start").style("flex-wrap", "wrap");
+    const isoformData = data.isoforms[selectedIsoform];
+    if (!isoformData) return;
+    const assays = data.assays;
+    const cohorts = data.cohorts;
+    const nRows = assays.length;
+    const nCols = cohorts.length;
+    const ptmAssays = new Set(data.ptmAssays || []);
+    const isPTMassay = (assay) => ptmAssays.has(assay);
+    const valueOf = (s) => this.valueFor(s, useAdjusted);
+    const negLogP = (p) => p > 0 ? Math.min(-Math.log10(p), NEG_LOG_P_CAP) : NEG_LOG_P_CAP;
+    const slotIndex = /* @__PURE__ */ new Map();
+    const assaySlotCount = /* @__PURE__ */ new Map();
+    let maxAbs = 0;
+    const thresholdNegLog = negLogP(threshold);
+    let maxNegLog = thresholdNegLog;
+    for (const assay of assays) {
+      const ptm = isPTMassay(assay);
+      const rawSum = /* @__PURE__ */ new Map();
+      const rawN = /* @__PURE__ */ new Map();
+      const significantSomewhere = /* @__PURE__ */ new Set();
+      for (const cohort of cohorts) {
+        const cell = isoformData.data[assay]?.[cohort];
+        if (!cell) continue;
+        if (ptm) {
+          for (const s of cell.sites) {
+            if (s.significant) {
+              const v = Math.abs(valueOf(s));
+              if (v > maxAbs) maxAbs = v;
+            }
+            rawSum.set(s.id, (rawSum.get(s.id) ?? 0) + s.log2FC);
+            rawN.set(s.id, (rawN.get(s.id) ?? 0) + 1);
+            if (s.significant) significantSomewhere.add(s.id);
+          }
+        } else {
+          const s = cell.sites[0];
+          if (!s) continue;
+          const v = Math.abs(valueOf(s));
+          if (v > maxAbs) maxAbs = v;
+          const nl = negLogP(s.p_value);
+          if (nl > maxNegLog) maxNegLog = nl;
+        }
+      }
+      if (ptm) {
+        const meanRaw = (id) => rawSum.get(id) / rawN.get(id);
+        const ordered = [...significantSomewhere].sort((a, b) => meanRaw(b) - meanRaw(a));
+        ordered.forEach((id, i) => slotIndex.set(`${assay}|${id}`, i));
+        assaySlotCount.set(assay, ordered.length);
+      } else {
+        assaySlotCount.set(assay, 1);
+      }
+    }
+    if (maxAbs === 0) maxAbs = 1;
+    if (maxNegLog <= thresholdNegLog) maxNegLog = thresholdNegLog + 1;
+    const colorScale = linear().domain([-maxAbs, 0, maxAbs]).range(["#2166ac", "#f7f7f7", "#b2182b"]).clamp(true);
+    const sizeScale = sqrt().domain([thresholdNegLog, maxNegLog]).range([MIN_DOT_R, MAX_DOT_R]).clamp(true);
+    const layout = assays.map((assay) => {
+      const m = assaySlotCount.get(assay);
+      const subCols = Math.max(1, Math.min(m, Math.floor((CELL_W - 2 * CELL_PAD) / SITE_DOT_SP)));
+      const rows = Math.ceil(m / subCols);
+      return { subCols, rows, height: Math.max(CELL_H, rows * SITE_DOT_SP + 2 * CELL_PAD) };
+    });
+    const rowY = [];
+    let yAcc = COL_LABEL_H;
+    for (let r = 0; r < nRows; r++) {
+      rowY[r] = yAcc;
+      yAcc += layout[r].height;
+    }
+    const gridW = ROW_LABEL_W + nCols * CELL_W + 20;
+    const gridH = yAcc + 20;
+    const svg = container.append("svg").attr("width", gridW).attr("height", gridH).style("flex", "0 0 auto");
+    const grid = svg.append("g");
+    for (let c = 0; c < nCols; c++) {
+      const cx = ROW_LABEL_W + c * CELL_W + CELL_W / 2;
+      grid.append("text").attr("x", cx).attr("y", COL_LABEL_H - 10).attr("text-anchor", "start").attr("font-size", "12px").attr("font-weight", "bold").attr("transform", `rotate(-35 ${cx} ${COL_LABEL_H - 10})`).text(cohorts[c]);
+    }
+    for (let r = 0; r < nRows; r++) {
+      const cy = rowY[r] + layout[r].height / 2;
+      const m = assaySlotCount.get(assays[r]);
+      const lbl = grid.append("text").attr("x", ROW_LABEL_W - 10).attr("y", cy).attr("text-anchor", "end").attr("dominant-baseline", "central").attr("font-size", "12px").attr("font-weight", "bold");
+      lbl.append("tspan").text(assays[r]);
+      lbl.append("tspan").attr("x", ROW_LABEL_W - 10).attr("dy", "1.3em").attr("font-weight", "normal").attr("font-size", "10px").attr("fill", "#888").text(m > 1 ? `${m} sites` : "");
+    }
+    for (let r = 0; r < nRows; r++) {
+      const assay = assays[r];
+      const ptm = isPTMassay(assay);
+      const { subCols, height } = layout[r];
+      for (let c = 0; c < nCols; c++) {
+        const x0 = ROW_LABEL_W + c * CELL_W;
+        const y0 = rowY[r];
+        grid.append("rect").attr("x", x0).attr("y", y0).attr("width", CELL_W).attr("height", height).attr("fill", "none").attr("stroke", "#eee").attr("stroke-width", 1);
+        const cell = isoformData.data[assay]?.[cohorts[c]];
+        if (!cell || !cell.sites.length) continue;
+        const addDot = (s, cx, cy, radius) => {
+          return grid.append("circle").attr("cx", cx).attr("cy", cy).attr("r", radius).attr("fill", colorScale(valueOf(s))).attr("stroke", "#888").attr("stroke-width", 0.8).style("opacity", s.significant ? 1 : 0.35).on(
+            "mouseover",
+            (event) => this.showSiteTip(
+              event,
+              isoformData.gene_name,
+              selectedIsoform,
+              assay,
+              cohorts[c],
+              s,
+              useAdjusted,
+              refAssay
+            )
+          ).on("mouseout", () => this.dom.tip.hide());
+        };
+        if (!ptm) {
+          const s = cell.sites[0];
+          const cx = x0 + CELL_W / 2;
+          const cy = y0 + height / 2;
+          addDot(s, cx, cy, sizeScale(negLogP(s.p_value)));
+          continue;
+        }
+        const blockW = subCols * SITE_DOT_SP;
+        const blockH = layout[r].rows * SITE_DOT_SP;
+        const startX = x0 + (CELL_W - blockW) / 2 + SITE_DOT_SP / 2;
+        const startY = y0 + (height - blockH) / 2 + SITE_DOT_SP / 2;
+        for (const s of cell.sites) {
+          if (!s.significant) continue;
+          const slot = slotIndex.get(`${assay}|${s.id}`);
+          const cx = startX + slot % subCols * SITE_DOT_SP;
+          const cy = startY + Math.floor(slot / subCols) * SITE_DOT_SP;
+          addDot(s, cx, cy, SITE_DOT_R);
+        }
+      }
+    }
+    this.renderLegend(container, colorScale, maxAbs, threshold, useAdjusted, refAssay, maxNegLog);
+  }
+  fmtP(v) {
+    return v >= 1e-4 ? v.toFixed(4) : v.toExponential(2);
+  }
+  /** true when the protein-adjusted value should be shown instead of raw log2FC */
+  showsAdjusted(s, useAdjusted) {
+    return !!(useAdjusted && s.adjustedAvailable && s.adjustedLog2FC != null);
+  }
+  /** value encoded by color: protein-adjusted when requested & available, else raw */
+  valueFor(s, useAdjusted) {
+    return this.showsAdjusted(s, useAdjusted) ? s.adjustedLog2FC : s.log2FC;
+  }
+  showSiteTip(event, geneName, isoform, assay, cohort, s, useAdjusted, refAssay) {
+    this.dom.tip.clear().show(event.clientX, event.clientY);
+    const t = this.dom.tip.d.append("div").style("padding", "8px").style("font-size", "13px");
+    t.append("div").style("font-weight", "bold").style("margin-bottom", "4px").text(`${geneName} \u2014 ${isoform}`);
+    t.append("div").text(`Assay: ${assay}`);
+    t.append("div").text(`Sample set: ${cohort}`);
+    const isPTM = (this.data.ptmAssays || []).includes(assay);
+    t.append("div").text(`${isPTM ? "Site" : "Protein"}: ${s.id}`);
+    t.append("div").text(`raw log\u2082FC: ${s.log2FC.toFixed(3)}`);
+    if (s.adjustedAvailable) {
+      t.append("div").text(`protein log\u2082FC: ${s.proteinLog2FC.toFixed(3)}`);
+      t.append("div").text(`adjusted log\u2082FC: ${s.adjustedLog2FC.toFixed(3)}`);
+    } else if (refAssay && isPTM) {
+      t.append("div").style("color", "#999").text("adjusted: n/a (protein not measured)");
+    }
+    t.append("div").text(`p-value: ${this.fmtP(s.p_value)}`);
+    const shown = this.showsAdjusted(s, useAdjusted) ? "adjusted" : "raw";
+    t.append("div").style("color", "#666").style("margin-top", "4px").text(`Color = ${shown} log\u2082FC.`);
+  }
+  renderLegend(container, colorScale, maxAbs, threshold, useAdjusted, refAssay, maxNegLog) {
+    const legend = container.append("div").style("display", "flex").style("flex-direction", "column").style("gap", "16px").style("padding", "8px 0").style("min-width", "180px").style("max-width", "260px");
+    const colorBlock = legend.append("div");
+    colorBlock.append("div").style("font-weight", "bold").style("font-size", "13px").style("margin-bottom", "6px").text(useAdjusted && refAssay ? "log\u2082FC (PTM-adjusted)" : "log\u2082FC");
+    const cW = 22;
+    const cH = 130;
+    const cSvg = colorBlock.append("svg").attr("width", cW + 60).attr("height", cH + 16);
+    const gid = `bh-grad-${this.id}`;
+    const grad = cSvg.append("defs").append("linearGradient").attr("id", gid).attr("x1", "0").attr("y1", "0").attr("x2", "0").attr("y2", "1");
+    const steps = 10;
+    for (let i = 0; i <= steps; i++) {
+      const t = i / steps;
+      grad.append("stop").attr("offset", `${t * 100}%`).attr("stop-color", colorScale(maxAbs * (1 - 2 * t)));
+    }
+    cSvg.append("rect").attr("x", 0).attr("y", 8).attr("width", cW).attr("height", cH).style("fill", `url(#${gid})`).attr("stroke", "#999");
+    const cScale = linear().domain([maxAbs, -maxAbs]).range([8, cH + 8]);
+    for (const tick of [maxAbs, maxAbs / 2, 0, -maxAbs / 2, -maxAbs]) {
+      const y = cScale(tick);
+      cSvg.append("line").attr("x1", cW).attr("y1", y).attr("x2", cW + 5).attr("y2", y).attr("stroke", "#666");
+      cSvg.append("text").attr("x", cW + 8).attr("y", y).attr("dominant-baseline", "central").attr("font-size", "10px").text(tick.toFixed(2));
+    }
+    const sizeBlock = legend.append("div");
+    sizeBlock.append("div").style("font-weight", "bold").style("font-size", "13px").style("margin-bottom", "6px").text("Non-PTM dot size: significance (\u2212log\u2081\u2080 p)");
+    const sSvg = sizeBlock.append("svg");
+    const sG = sSvg.append("g");
+    new LegendCircleReference({
+      g: sG,
+      inputMin: 0,
+      inputMax: MAX_DOT_R * 2,
+      minRadius: MIN_DOT_R,
+      maxRadius: MAX_DOT_R,
+      // capped to match the size scale's domain min (thresholdNegLog in renderGrid)
+      minLabel: Number(Math.min(-Math.log10(threshold), NEG_LOG_P_CAP).toFixed(1)),
+      maxLabel: Number(maxNegLog.toFixed(1))
+    });
+    const sPad = 4;
+    const sBox = sG.node().getBBox();
+    sG.attr("transform", `translate(${sPad - sBox.x}, ${sPad - sBox.y})`);
+    sSvg.attr("width", Math.ceil(sBox.width + 2 * sPad)).attr("height", Math.ceil(sBox.height + 2 * sPad));
+    if (refAssay) {
+      const adjLabel = legend.append("div").append("label").style("display", "flex").style("align-items", "center").style("gap", "6px").style("cursor", "pointer").style("font-size", "13px").style("font-weight", "bold").attr(
+        "title",
+        `When checked, the PTM assays have the ${refAssay} log\u2082FC subtracted; other assays are shown unchanged.`
+      );
+      const adjCb = adjLabel.append("input").attr("type", "checkbox").property("checked", this.useAdjusted).on("change", () => {
+        this.useAdjusted = adjCb.property("checked");
+        this.renderGrid();
+      });
+      adjLabel.append("span").style("font-weight", "normal").text("Adjust PTM for total protein abundance");
+    }
+    const notes = legend.append("div").style("font-size", "11px").style("color", "#666").style("line-height", "1.5").style("max-width", "240px").style("overflow-wrap", "break-word");
+    notes.append("div").text(
+      `Color = log\u2082FC. Dot size = significance, \u2212log\u2081\u2080 p (non-PTM rows); the smallest size marks the p < ${threshold} cutoff. Non-significant dots are faded.`
+    );
+    notes.append("div").style("margin-top", "4px").text(
+      "PTM rows: one fixed-size dot per site significant in that cohort, positions stable across cohorts; non-significant sites are not shown."
+    );
+    notes.append("div").style("margin-top", "4px").text(
+      "A slot stays empty where the site is not significant in that cohort, the assay was not performed, or the protein was not detected."
+    );
+    if (refAssay) {
+      notes.append("div").style("margin-top", "4px").text(`Adjusted log\u2082FC = a PTM site's log\u2082FC \u2212 ${refAssay} log\u2082FC (PTM assays only).`);
+    }
+  }
+};
+var componentInit = getCompInit(BubbleHeatmap);
+async function getPlotConfig(opts) {
+  const config = structuredClone(defaultConfig);
+  if (!opts.gene) throw new Error("bubbleHeatmap requires opts.gene");
+  return copyMerge(config, opts);
+}
+function makeChartBtnMenu(holder, chartsInstance) {
+  const row = holder.append("div").style("padding", "5px");
+  row.append("span").style("font-weight", "bold").text("Enter a gene name:");
+  const geneSearch = addGeneSearchbox({
+    row,
+    genome: chartsInstance.app.opts.genome,
+    tip: new Menu({ padding: "0px" }),
+    searchOnly: "gene",
+    callback: async () => {
+      if (!geneSearch.geneSymbol) throw new Error("A valid gene selection is required");
+      chartsInstance.dom.tip.hide();
+      chartsInstance.app.dispatch({
+        type: "plot_create",
+        config: {
+          chartType: "bubbleHeatmap",
+          gene: geneSearch.geneSymbol
+        }
+      });
+    }
+  });
+}
+export {
+  componentInit,
+  getPlotConfig,
+  makeChartBtnMenu
+};
+//# sourceMappingURL=bubbleHeatmap-ERWNEKZB.js.map

package/dist/chunk-2GYWFQML.js

@@ -0,0 +1,299 @@
+import {
+  first_genetrack_tolist,
+  gmmode,
+  sayerror
+} from "./chunk-5VOPABBA.js";
+import {
+  dofetch3
+} from "./chunk-M6EF3WVV.js";
+import {
+  codon_stop,
+  nt2aa,
+  proteinDomainColorScale
+} from "./chunk-2X6W4E3W.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+
+// common/snp.js
+async function string2snp(genome, str) {
+  const data = await dofetch3("snp", {
+    method: "POST",
+    body: JSON.stringify({ byName: true, genome: genome.name, lst: [str] })
+  });
+  if (data.error) throw data.error;
+  if (!data.results || data.results.length == 0) throw str + ": not a SNP";
+  for (const i of data.results) {
+    const chr = genome.chrlookup[i.chrom.toUpperCase()];
+    if (chr && chr.major) {
+      return {
+        chr: i.chrom,
+        start: i.chromStart,
+        stop: i.chromEnd
+      };
+    }
+  }
+  const r = data.results[0];
+  return {
+    chr: r.chrom,
+    start: r.chromStart,
+    stop: r.chromEnd
+  };
+}
+
+// src/block.init.js
+async function block_init_default(arg) {
+  if (!arg.holder) throw "No holder for block.init";
+  if (!arg.genome) throw "no genome";
+  if (arg.holder instanceof Element) arg.holder = select_default(arg.holder);
+  if (!arg.tklst) arg.tklst = [];
+  if (arg.query) {
+    await step1_findgm(arg);
+    return;
+  }
+  if (arg.model && arg.allmodels) {
+    await step2_getseq(arg);
+    return;
+  }
+}
+async function step1_findgm(arg) {
+  const wait = arg.holder.append("p").style("font-size", "2em").style("color", "#858585").text("Searching for " + arg.query + " ...");
+  const data = await dofetch3("genelookup", {
+    body: { deep: 1, input: arg.query, genome: arg.genome.name }
+  });
+  if (!data) throw "querying genes: server error";
+  if (data.error) throw "error querying genes: " + data.error;
+  if (!data.gmlst || data.gmlst.length == 0) {
+    if (arg.genome.hasSNP) {
+      try {
+        const r = await string2snp(arg.genome, arg.query);
+        wait.remove();
+        const par = {
+          genome: arg.genome,
+          holder: arg.holder,
+          chr: r.chr,
+          start: Math.max(0, r.start - 300),
+          stop: r.start + 300,
+          nobox: true,
+          tklst: arg.tklst,
+          debugmode: arg.debugmode
+        };
+        first_genetrack_tolist(arg.genome, par.tklst);
+        const b = await import("./block-NBTCOT3H.js");
+        const block = new b.Block(par);
+        block.addhlregion(r.chr, r.start, r.stop - 1);
+      } catch (e) {
+        wait.text("Not a gene or SNP: " + arg.query);
+      }
+    } else {
+      wait.text("No match to gene: " + arg.query);
+    }
+    return;
+  }
+  wait.remove();
+  arg.allmodels = data.gmlst;
+  for (const m of arg.allmodels) {
+    if (m.isoform.toUpperCase() == (data.found_isoform ? data.found_isoform.toUpperCase() : arg.query.toUpperCase())) {
+      arg.model = m;
+      await step2_getseq(arg);
+      return;
+    }
+  }
+  const defaultisoforms = [];
+  for (const m of arg.allmodels) {
+    if (!m.isoform) throw "isoform missing from one gene model: " + JSON.stringify(m);
+    const n = m.isoform.toUpperCase();
+    if (arg.genome.isoformcache.has(n)) {
+      let nothas = true;
+      for (const m2 of arg.genome.isoformcache.get(n)) {
+        if (m2.chr == m.chr && m2.start == m.start && m2.stop == m.stop && m2.strand == m.strand) {
+          nothas = false;
+          break;
+        }
+      }
+      if (nothas) {
+        arg.genome.isoformcache.get(n).push(m);
+      }
+    } else {
+      arg.genome.isoformcache.set(n, [m]);
+    }
+    if (m.isoform.toUpperCase() == arg.query.toUpperCase()) {
+      defaultisoforms.push(m);
+      break;
+    }
+    if (m.isdefault) {
+      defaultisoforms.push(m);
+    }
+  }
+  if (defaultisoforms.length == 1) {
+    arg.model = defaultisoforms[0];
+  } else if (defaultisoforms.length > 1) {
+    for (const m of defaultisoforms) {
+      if (m.chr == "chrY") {
+        continue;
+      }
+      const chr = arg.genome.chrlookup[m.chr.toUpperCase()];
+      if (!chr) {
+        continue;
+      }
+      if (!chr.major) {
+        continue;
+      }
+      arg.model = m;
+      break;
+    }
+    if (!arg.model) {
+      arg.model = defaultisoforms[0];
+    }
+  }
+  if (!arg.model) {
+    arg.model = arg.allmodels[0];
+  }
+  await step2_getseq(arg);
+}
+async function step2_getseq(arg) {
+  if (arg.model.genomicseq) {
+    checker();
+    step2_getpdomain(arg);
+    return;
+  }
+  const par = {
+    genome: arg.genome.name,
+    coord: arg.model.chr + ":" + (arg.model.start + 1) + "-" + arg.model.stop
+  };
+  const data = await dofetch3("ntseq", { method: "POST", body: JSON.stringify(par) });
+  if (!data) throw "getting sequence: server error";
+  if (data.error) throw "getting sequence: " + data.error;
+  if (!data.seq) throw "no nt seq???";
+  arg.model.genomicseq = data.seq.toUpperCase();
+  arg.model.aaseq = nt2aa(arg.model);
+  checker();
+  await step2_getpdomain(arg);
+  function checker() {
+    if (arg.model.aaseq) {
+      const stop = arg.model.aaseq.indexOf(codon_stop);
+      const cdslen = arg.model.cdslen - (arg.model.startCodonFrame ? 3 - arg.model.startCodonFrame : 0);
+      if (stop != -1 && stop < cdslen / 3 - 1) {
+        sayerror(arg.holder, "Translating " + arg.model.isoform + " ends at " + stop + " AA, expecting " + cdslen / 3);
+      }
+    }
+  }
+}
+async function step2_getpdomain(arg) {
+  const isoform2gm = /* @__PURE__ */ new Map();
+  for (const m of arg.allmodels) {
+    if (!m.pdomains) {
+      m.pdomains = [];
+      m.domain_hidden = {};
+      if (!isoform2gm.has(m.isoform)) isoform2gm.set(m.isoform, []);
+      isoform2gm.get(m.isoform).push(m);
+    }
+  }
+  if (isoform2gm.size == 0) {
+    await step3(arg);
+    return;
+  }
+  const data = await dofetch3("pdomain", {
+    method: "POST",
+    body: JSON.stringify({ genome: arg.genome.name, isoforms: [...isoform2gm.keys()] })
+  });
+  if (data.error) throw "error getting protein domain: " + data.error;
+  if (!Array.isArray(data.lst)) throw ".lst[] not array";
+  for (const a of data.lst) {
+    for (const m of isoform2gm.get(a.name)) {
+      m.pdomains = a.pdomains;
+      if (arg.hidePdomain) {
+        for (const i of a.pdomains) {
+          m.domain_hidden[i.name + i.description] = 1;
+        }
+      }
+    }
+  }
+  if (arg.geneDomains) {
+    if (typeof arg.geneDomains != "object") throw "geneDomains not object";
+    for (const isoform in arg.geneDomains) {
+      const lst = isoform2gm.get(isoform);
+      if (!lst) throw `unknown isoform ${isoform} from geneDomains{}`;
+      for (const g of lst) {
+        if (!g.pdomains) g.pdomains = [];
+        if (!Array.isArray(arg.geneDomains[isoform])) throw `geneDomains[${isoform}] not array`;
+        for (const b of arg.geneDomains[isoform]) {
+          if (typeof b != "object") throw "element from geneDomains[] not object";
+          if (!Number.isInteger(b.start)) throw "start not integer from geneDomains[]";
+          if (!Number.isInteger(b.stop)) throw "stop not integer from geneDomains[]";
+          if (b.start > b.stop) throw "start>stop from geneDomains[]";
+          if (!b.name) b.name = "Custom domain";
+          if (!g.pdomains.find((a) => a.start == b.start && a.stop == b.stop && a.name == b.name)) g.pdomains.push(b);
+        }
+      }
+    }
+  }
+  const s = proteinDomainColorScale();
+  for (const lst of isoform2gm.values()) {
+    for (const g of lst) {
+      for (const d of g.pdomains || []) {
+        if (!d.color) d.color = s(d.name + d.description);
+      }
+    }
+  }
+  await step3(arg);
+}
+async function step3(arg) {
+  let mode = arg.gmmode;
+  if (!mode) {
+    if (arg.model.cdslen) {
+      mode = gmmode.protein;
+    } else {
+      mode = gmmode.exononly;
+    }
+  }
+  if (arg.dataset) {
+    if (!Array.isArray(arg.dataset)) throw "dataset is not array";
+    for (const dsname of arg.dataset) {
+      if (arg.genome.datasets[dsname] && !arg.genome.datasets[dsname].legacyDsIsUninitiated) continue;
+      const d = await dofetch3(`getDataset?genome=${arg.genome.name}&dsname=${dsname}`);
+      if (d.error) throw `invalid name from dataset[]: ${d.error}`;
+      if (!d.ds) throw ".ds missing";
+      const ds = arg.genome.datasets[d.ds.label];
+      Object.assign(ds, d.ds);
+      const _ = await import("./legacyDataset-VLD7ZYWI.js");
+      _.validate_oldds(ds);
+      delete ds.legacyDsIsUninitiated;
+    }
+  }
+  const b = await import("./block-NBTCOT3H.js");
+  arg.__blockInstance = new b.Block({
+    genome: arg.genome,
+    holder: arg.holder,
+    nobox: true,
+    usegm: arg.model,
+    gmstackheight: 37,
+    allgm: arg.allmodels,
+    datasetlst: arg.dataset,
+    legacyDsFilter: arg.legacyDsFilter,
+    mset: arg.mset,
+    hlaachange: arg.hlaachange,
+    hlvariants: arg.hlvariants,
+    hlregions: arg.hlregions,
+    aarange: arg.aarange,
+    gmmode: mode,
+    hidedatasetexpression: arg.hidedatasetexpression,
+    hidegenecontrol: arg.hidegenecontrol,
+    hidegenelegend: arg.hidegenelegend,
+    variantPageCall_snv: arg.variantPageCall_snv,
+    datasetqueries: arg.datasetqueries,
+    samplecart: arg.samplecart,
+    debugmode: arg.debugmode,
+    tklst: arg.tklst,
+    mclassOverride: arg.mclassOverride,
+    hide_dsHandles: arg.hide_dsHandles,
+    onloadalltk_always: arg.onloadalltk_always,
+    onAddRemoveTk: arg.onAddRemoveTk
+  });
+}
+
+export {
+  string2snp,
+  block_init_default
+};
+//# sourceMappingURL=chunk-2GYWFQML.js.map