@sjcrh/proteinpaint-client 2.190.2 → 2.191.2

package/dist/plot.brainImaging-HG6I3GJW.js

@@ -0,0 +1,51 @@
+import "./chunk-HFNDKYVF.js";
+
+// plots/plot.brainImaging.js
+async function plot_brainImaging_default(termdbConfig, dslabel, queryKey, sample, holder, genomeObj, _overrides = {}) {
+  const overrides = computeOverrides(_overrides);
+  const loadingDiv = holder.append("div").style("margin", "20px").text("Loading...");
+  try {
+    if (typeof termdbConfig?.queries?.NIdata != "object") throw "termdbConfig.queries.NIdata{} not object";
+    const q = termdbConfig.queries.NIdata[queryKey];
+    if (!q) throw "invalid queryKey";
+    if (typeof sample != "object") throw "sample{} not object";
+    if (typeof genomeObj != "object") throw "genomeObj{} not object";
+    const brainImaging_arg = {
+      sampleName: sample.sample_id,
+      genome: genomeObj,
+      queryKey
+    };
+    const opts = {
+      holder,
+      state: {
+        genome: genomeObj.name,
+        dslabel,
+        plots: [
+          {
+            chartType: "brainImaging",
+            selectedSampleFileNames: [sample.sample_id + ".nii"],
+            queryKey,
+            overrides
+          }
+        ]
+      }
+    };
+    const plot = await import("./plot.app-T7CQMBRV.js");
+    const plotAppApi = await plot.appInit(opts);
+    loadingDiv.remove();
+  } catch (e) {
+    loadingDiv.text("Error: " + (e.message || e));
+  }
+}
+function computeOverrides(o) {
+  const overrides = structuredClone(o);
+  if (!overrides.brainImaging) overrides.brainImaging = {};
+  if (!overrides.downloadImgName) {
+    overrides.downloadImgName = "brainImaging";
+  }
+  return overrides;
+}
+export {
+  plot_brainImaging_default as default
+};
+//# sourceMappingURL=plot.brainImaging-HG6I3GJW.js.map

package/dist/plot.disco-LPH7F6YW.js

@@ -0,0 +1,102 @@
+import {
+  dofetch3
+} from "./chunk-6VKTEMFV.js";
+import "./chunk-7IYJZZQI.js";
+import "./chunk-M3J4MINX.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-S4JLRRKK.js";
+import "./chunk-TVADJLMF.js";
+import {
+  dt2label
+} from "./chunk-EBKERML3.js";
+import "./chunk-JNITUVXP.js";
+import "./chunk-KSGA62R2.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-TOU7EVFQ.js";
+import "./chunk-OAWQ6LOO.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-KYBIQBXE.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-OMR2DT66.js";
+import "./chunk-HFNDKYVF.js";
+
+// plots/plot.disco.js
+async function plot_disco_default(termdbConfig, dslabel, sample, holder, genomeObj, _overrides = {}, showError = true) {
+  const loadingDiv = holder.append("div").style("margin", "20px").text("Loading...");
+  try {
+    if (typeof termdbConfig?.queries?.singleSampleMutation != "object")
+      throw "termdbConfig.queries.singleSampleMutation{} not object";
+    if (typeof sample != "object") throw "sample{} not object";
+    if (typeof genomeObj != "object") throw "genomeObj{} not object";
+    const body = {
+      genome: genomeObj.name,
+      dslabel,
+      sample: sample[termdbConfig.queries.singleSampleMutation.sample_id_key]
+    };
+    const data = await dofetch3("termdb/singleSampleMutation", { body });
+    if (data.error) throw data.error;
+    if (!Array.isArray(data.mlst)) throw "data.mlst is not array";
+    if (data.dt2total?.length) {
+      for (const o of data.dt2total) {
+        holder.append("div").attr("data-testid", "sjpp-disco-maxReached-" + dt2label[o.dt]).style("margin", "20px 20px 0px 40px").text(`(Displaying ${data.mlst.filter((i) => i.dt == o.dt).length} out of total ${o.total} ${dt2label[o.dt]})`);
+      }
+    }
+    const mlst = data.mlst;
+    for (const i of mlst) i.position = i.pos;
+    const disco_arg = {
+      sampleName: sample[termdbConfig.queries.singleSampleMutation.sample_id_key],
+      data: mlst,
+      genome: genomeObj
+    };
+    if (data.alternativeDataByDt) {
+      disco_arg.alternativeDataByDt = data.alternativeDataByDt;
+    }
+    if (termdbConfig.queries.singleSampleMutation.discoPlot?.skipChrM) {
+      disco_arg.chromosomes = {};
+      for (const k in genomeObj.majorchr) {
+        if (k.toLowerCase() == "chrm") continue;
+        disco_arg.chromosomes[k] = genomeObj.majorchr[k];
+      }
+    }
+    const opts = {
+      holder,
+      state: {
+        genome: genomeObj.name,
+        dslabel,
+        args: disco_arg,
+        plots: [
+          {
+            chartType: "Disco",
+            subfolder: "disco",
+            extension: "ts",
+            overrides: computeOverrides(_overrides, termdbConfig, genomeObj, sample)
+          }
+        ]
+      }
+    };
+    const plot = await import("./plot.app-T7CQMBRV.js");
+    const plotAppApi = await plot.appInit(opts);
+    loadingDiv.remove();
+    return true;
+  } catch (e) {
+    if (showError) loadingDiv.text("Error: " + (e.message || e));
+    else loadingDiv.remove();
+    return false;
+  }
+}
+function computeOverrides(o, termdbConfig, genomeObj, sample) {
+  const overrides = structuredClone(o);
+  if (!overrides.Disco) overrides.Disco = {};
+  if (genomeObj.geneset) {
+    overrides.Disco.showPrioritizeGeneLabelsByGeneSets = true;
+    overrides.Disco.prioritizeGeneLabelsByGeneSets = termdbConfig.queries.singleSampleMutation.discoPlot?.prioritizeGeneLabelsByGeneSets;
+  }
+  if (!overrides.downloadImgName) {
+    overrides.downloadImgName = sample[termdbConfig.queries.singleSampleMutation.sample_id_key] + " Disco";
+  }
+  return overrides;
+}
+export {
+  plot_disco_default as default
+};
+//# sourceMappingURL=plot.disco-LPH7F6YW.js.map

package/dist/plot.dzi-DYAY4D4E.js

@@ -0,0 +1,33 @@
+import "./chunk-HFNDKYVF.js";
+
+// plots/dziviewer/plot.dzi.js
+async function plot_dzi_default(dslabel, holder, genomeObj, sample_id, dzimages) {
+  const loadingDiv = holder.append("div").style("margin", "20px").text("Loading...");
+  try {
+    const opts = {
+      holder,
+      state: {
+        genome: genomeObj.name,
+        dslabel,
+        sample_id,
+        dzimages,
+        plots: [
+          {
+            chartType: "DziViewer",
+            subfolder: "dziviewer",
+            extension: "ts"
+          }
+        ]
+      }
+    };
+    const plot = await import("./plot.app-T7CQMBRV.js");
+    const plotAppApi = await plot.appInit(opts);
+    loadingDiv.remove();
+  } catch (e) {
+    loadingDiv.text("Error: " + (e.message || e));
+  }
+}
+export {
+  plot_dzi_default as default
+};
+//# sourceMappingURL=plot.dzi-DYAY4D4E.js.map

package/dist/plot.ssgq-CF5VIGYJ.js

@@ -0,0 +1,139 @@
+import {
+  first_genetrack_tolist,
+  gmlst2loci
+} from "./chunk-L4TUTGTA.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-LSEFWW72.js";
+import "./chunk-4FKWINMK.js";
+import "./chunk-HYOEWQ5P.js";
+import "./chunk-HBW42TDT.js";
+import "./chunk-G6O3URDN.js";
+import "./chunk-FN5XPUPH.js";
+import "./chunk-IIT367QZ.js";
+import "./chunk-RZGEKL77.js";
+import "./chunk-XVZ5UJWU.js";
+import "./chunk-WS3NUPNV.js";
+import {
+  dofetch3
+} from "./chunk-6VKTEMFV.js";
+import "./chunk-7IYJZZQI.js";
+import "./chunk-M3J4MINX.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-S4JLRRKK.js";
+import "./chunk-TVADJLMF.js";
+import "./chunk-EBKERML3.js";
+import "./chunk-DD4R5P6W.js";
+import "./chunk-JNITUVXP.js";
+import "./chunk-KSGA62R2.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-TOU7EVFQ.js";
+import "./chunk-OAWQ6LOO.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/plot.ssgq.js
+async function plotSingleSampleGenomeQuantification(termdbConfig, dslabel, queryKey, sample, holder, genomeObj, geneName, showError = true) {
+  const loadingDiv = holder.append("div").text("Loading...");
+  try {
+    if (typeof termdbConfig?.queries?.singleSampleGenomeQuantification != "object")
+      throw "termdbConfig.queries.singleSampleGenomeQuantification{} missing, cannot plot";
+    const q = termdbConfig.queries.singleSampleGenomeQuantification[queryKey];
+    if (!q) throw "invalid queryKey";
+    if (typeof sample != "object") throw "sample{} not object";
+    if (typeof genomeObj != "object") throw "genomeObj{} not object";
+    const body = {
+      genome: genomeObj.name,
+      dslabel,
+      devicePixelRatio: window.devicePixelRatio > 1 ? window.devicePixelRatio : 1,
+      singleSampleGenomeQuantification: { dataType: queryKey, sample: sample[q.sample_id_key] }
+    };
+    const data = await dofetch3("mds3", { body });
+    if (data.error) throw data.error;
+    const q2 = termdbConfig.queries.singleSampleGbtk?.[q.singleSampleGbtk];
+    holder.append("div").attr("data-testid", "sjpp_ssgq_sandbox").text(q.description || queryKey);
+    if (q2) {
+      holder.append("div").attr("data-testid", "sjpp_ssgq_intro_text").text(`Click a chromosomal position to zoom in and view ${q2.description || q.singleSampleGbtk}`);
+    }
+    const img = holder.append("img").attr("data-testid", "sjpp_ssgq_img").attr("width", data.canvasWidth).attr("height", data.canvasHeight).attr("src", data.src);
+    loadingDiv.remove();
+    if (!q2) return;
+    let bb;
+    if (geneName) {
+      const geneData = await dofetch3("genelookup", {
+        body: { genome: genomeObj.name, input: geneName, deep: 1 }
+      });
+      if (geneData.error) throw geneData.error;
+      if (geneData.gmlst && geneData.gmlst.length) {
+        const locs = gmlst2loci(geneData.gmlst);
+        const chr = locs[0].chr;
+        const start = Math.max(0, locs[0].start - (locs[0].stop - locs[0].start));
+        const chrLen = data.chrLst.filter((c) => c.chr == chr)[0].chrLen;
+        const stop = Math.min(chrLen, locs[0].stop + (locs[0].stop - locs[0].start));
+        bb = await plotSingleSampleGbtk(dslabel, sample, holder, genomeObj, q, q2, chr, start, stop);
+      }
+    }
+    img.on("click", async (event) => {
+      const x = event.offsetX - data.xoff;
+      let chr, chrLen, position;
+      for (const c of data.chrLst) {
+        if (c.xStart <= x && c.xStop >= x) {
+          chr = c.chr;
+          chrLen = c.chrLen;
+          position = Math.ceil(c.chrLen / (c.xStop - c.xStart) * (x - c.xStart));
+          break;
+        }
+      }
+      if (!chr) return;
+      const start = Math.max(0, position - 5e5), stop = Math.min(position + 5e5, chrLen);
+      if (bb) {
+        bb.jump_1basedcoordinate({ chr, start, stop });
+        return;
+      }
+      bb = await plotSingleSampleGbtk(dslabel, sample, holder, genomeObj, q, q2, chr, start, stop);
+    });
+    return true;
+  } catch (e) {
+    if (showError) loadingDiv.text("Error: " + (e.message || e));
+    else loadingDiv.remove();
+    return false;
+  }
+}
+async function plotSingleSampleGbtk(dslabel, sample, holder, genomeObj, q, q2, chr, start, stop) {
+  const body = {
+    genome: genomeObj.name,
+    dslabel,
+    singleSampleGbtk: { dataType: q.singleSampleGbtk, sample: sample[q2.sample_id_key] }
+  };
+  const d2 = await dofetch3("mds3", { body });
+  if (!d2.path) return;
+  const tklst = [
+    {
+      type: "bigwig",
+      name: sample[q2.sample_id_key],
+      file: d2.path,
+      height: 100,
+      scale: { min: q2.min, max: q2.max },
+      pcolor: q.positiveColor,
+      ncolor: q.negativeColor
+    }
+  ];
+  first_genetrack_tolist(genomeObj, tklst);
+  const bb = new (await import("./block-5V2FCT7Q.js")).Block({
+    genome: genomeObj,
+    holder: holder.append("div"),
+    nobox: true,
+    tklst,
+    chr,
+    start,
+    stop
+  });
+  return bb;
+}
+export {
+  plotSingleSampleGenomeQuantification
+};
+//# sourceMappingURL=plot.ssgq-CF5VIGYJ.js.map

package/dist/plot.vaf2cov-7HZCKNK6.js

@@ -0,0 +1,259 @@
+import {
+  axisstyle,
+  font,
+  make_table_2col
+} from "./chunk-L4TUTGTA.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-LSEFWW72.js";
+import "./chunk-4FKWINMK.js";
+import "./chunk-HYOEWQ5P.js";
+import "./chunk-HBW42TDT.js";
+import "./chunk-G6O3URDN.js";
+import "./chunk-FN5XPUPH.js";
+import "./chunk-IIT367QZ.js";
+import "./chunk-RZGEKL77.js";
+import "./chunk-XVZ5UJWU.js";
+import "./chunk-WS3NUPNV.js";
+import "./chunk-6VKTEMFV.js";
+import "./chunk-7IYJZZQI.js";
+import "./chunk-M3J4MINX.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-S4JLRRKK.js";
+import "./chunk-TVADJLMF.js";
+import "./chunk-EBKERML3.js";
+import "./chunk-DD4R5P6W.js";
+import "./chunk-JNITUVXP.js";
+import {
+  category10_default
+} from "./chunk-KSGA62R2.js";
+import {
+  axisBottom,
+  axisLeft
+} from "./chunk-LOZEKOES.js";
+import "./chunk-TOU7EVFQ.js";
+import {
+  format,
+  linear,
+  ordinal
+} from "./chunk-OAWQ6LOO.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-KYBIQBXE.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-OMR2DT66.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HFNDKYVF.js";
+
+// src/old/plot.vaf2cov.js
+function plot_vaf2cov(arg) {
+  for (const i of arg.data) {
+    if (!i.sampleobj) i.sampleobj = {};
+  }
+  let width = arg.width || 200;
+  let height = arg.height || 200;
+  const gray = arg.color || "#999";
+  let marksize;
+  let maxtotal = arg.maxtotal || 0;
+  if (arg.automax) {
+    for (const i of arg.data) {
+      maxtotal = Math.max(maxtotal, i.total);
+    }
+  }
+  let maxf = 1;
+  const xbin = [];
+  const ybin = [];
+  const bincount = arg.bincount || 20;
+  for (let i = 0; i < bincount; i++) {
+    xbin.push(0);
+    ybin.push(0);
+  }
+  {
+    const xbs = maxtotal / bincount;
+    const ybs = maxf / bincount;
+    for (const i of arg.data) {
+      if (i.total >= maxtotal) {
+        xbin[bincount - 1]++;
+      } else {
+        xbin[Math.floor(i.total / xbs)]++;
+      }
+      ybin[Math.floor((i.maf == 1 ? 0.99 : i.maf) / ybs)]++;
+    }
+  }
+  const xbinmax = Math.max(...xbin);
+  const ybinmax = Math.max(...ybin);
+  const xscale = linear().domain([0, maxtotal]), yscale = linear().domain([0, maxf]), xbinscale = linear().domain([0, xbinmax]), ybinscale = linear().domain([0, ybinmax]);
+  const svg = arg.holder.append("svg").style("margin", "10px");
+  const xlab = svg.append("text").text("Coverage").attr("text-anchor", "middle").attr("fill", gray).attr("font-family", font);
+  const ylabg = svg.append("g");
+  const ylab = ylabg.append("text").text("VAF").attr("text-anchor", "middle").attr("dominant-baseline", "middle").attr("fill", gray).attr("font-family", font).attr("transform", "rotate(-90)");
+  const xaxis = svg.append("g");
+  const yaxis = svg.append("g");
+  const boxg = svg.append("g");
+  const box = boxg.append("rect").attr("stroke", gray).attr("stroke-dasharray", "2,2").attr("fill", "none").attr("shape-rendering", "crispEdges");
+  const midline = boxg.append("line").attr("stroke", gray).attr("stroke-dasharray", "2,2").attr("shape-rendering", "crispEdges");
+  const ybing = svg.append("g");
+  const ybinbar = ybing.selectAll().data(ybin).enter().append("rect");
+  const ybinaxis = svg.append("g");
+  const xbing = svg.append("g");
+  const xbinbar = xbing.selectAll().data(xbin).enter().append("rect");
+  const xbinaxis = svg.append("g");
+  let gtg = null, gtlab, gt, gtl1, gtl2, gtname;
+  if (arg.genotype) {
+    const gtcolor = ordinal(category10_default);
+    const set = /* @__PURE__ */ new Set();
+    for (const d of arg.data) {
+      if (d.genotype) {
+        set.add(d.genotype);
+        d.color = gtcolor(d.genotype);
+      }
+    }
+    const lst = [...set];
+    gtg = svg.append("g");
+    gtlab = gtg.append("text").text("Genotype").attr("dominant-baseline", "central").attr("font-family", font);
+    gt = gtg.selectAll().data(lst).enter().append("g");
+    gtl1 = gt.append("line").attr("stroke", (d) => gtcolor(d));
+    gtl2 = gt.append("line").attr("stroke", (d) => gtcolor(d));
+    gtname = gt.append("text").text((d) => d).attr("fill", (d) => gtcolor(d)).attr("dominant-baseline", "central").attr("font-family", font);
+  }
+  const spg = boxg.selectAll().data(arg.data).enter().append("g");
+  const spgl1 = spg.append("line").attr("stroke-opacity", 0.6).attr("stroke", (d) => d.color ? d.color : d.sampleobj.color || arg.samplecolor).each(function(d) {
+    d.crosshair1 = select_default(this);
+  });
+  const spgl2 = spg.append("line").attr("stroke-opacity", 0.6).attr("stroke", (d) => d.color ? d.color : d.sampleobj.color || arg.samplecolor).each(function(d) {
+    d.crosshair2 = select_default(this);
+  });
+  const spgkick = spg.append("circle").attr("fill", "white").attr("fill-opacity", 0).on("mouseover", (event, d) => {
+    d.crosshair1.attr("stroke-width", 3).attr("x1", -marksize - 2).attr("y1", -marksize - 2).attr("x2", marksize + 2).attr("y2", marksize + 2);
+    d.crosshair2.attr("stroke-width", 3).attr("x1", marksize + 2).attr("y1", -marksize - 2).attr("x2", -marksize - 2).attr("y2", marksize + 2);
+    arg.tip.clear();
+    arg.tip.show(event.clientX, event.clientY);
+    const lst = [{ k: "mut", v: d.mut }, { k: "total", v: d.total }];
+    if (d.genotype) {
+      lst.push({ k: "genotype", v: d.genotype });
+    }
+    for (const k in d.sampleobj) {
+      if (k == "color") continue;
+      lst.push({ k, v: d.sampleobj[k] });
+    }
+    make_table_2col(arg.tip.d, lst).style("margin", "none");
+    if (arg.mouseover) {
+      arg.mouseover(d);
+    }
+  }).on("mouseout", (event, d) => {
+    d.crosshair1.attr("stroke-width", 1).attr("x1", -marksize).attr("y1", -marksize).attr("x2", marksize).attr("y2", marksize);
+    d.crosshair2.attr("stroke-width", 1).attr("x1", marksize).attr("y1", -marksize).attr("x2", -marksize).attr("y2", marksize);
+    arg.tip.hide();
+    if (arg.mouseout) {
+      arg.mouseout(d);
+    }
+  });
+  if (arg.click) {
+    spgkick.on("click", (event, d) => {
+      arg.click(d);
+    });
+  }
+  const drag = svg.append("text").text("drag to resize").attr("class", "sja_clbtext").attr("font-size", 13).attr("text-anchor", "end").attr("fill", gray).on("mousedown", (event) => {
+    event.preventDefault();
+    const b = select_default(document.body);
+    const x0 = event.clientX, y0 = event.clientY, width0 = width, height0 = height;
+    b.on("mousemove", (event2) => {
+      width = width0 + event2.clientX - x0;
+      height = height0 + event2.clientY - y0;
+      resize();
+    });
+    b.on("mouseup", () => {
+      b.on("mousemove", null).on("mouseup", null);
+    });
+  });
+  function resize() {
+    const fontsize = Math.max(12, Math.min(width, height) / 25);
+    const pad2 = height / 20;
+    marksize = Math.ceil(fontsize / 3);
+    const ticksize = marksize, axisw = ticksize + fontsize * 3, axish = ticksize + 20, pad = fontsize * 1.3, pad0 = fontsize * 1.6, barheight = height / 5, barwidth = width / 5;
+    xscale.range([0, width]);
+    yscale.range([height, 0]);
+    xbinscale.range([barheight, 0]);
+    ybinscale.range([0, barwidth]);
+    svg.attr("width", fontsize + axisw + pad0 + width + pad + barwidth + pad2 + ticksize).attr("height", fontsize / 2 + barheight + pad + height + pad0 + axish + ticksize + fontsize);
+    xlab.attr("font-size", fontsize).attr("x", fontsize + axisw + pad0 + width / 2).attr("y", fontsize / 2 + barheight + pad + height + pad0 + axish + ticksize + fontsize - 5);
+    ylabg.attr("transform", "translate(" + fontsize + "," + (fontsize / 2 + barheight + pad + height / 2) + ")");
+    ylab.attr("font-size", fontsize);
+    xaxis.attr(
+      "transform",
+      "translate(" + (fontsize + axisw + pad0) + "," + (fontsize / 2 + barheight + pad + height + pad0) + ")"
+    ).call(
+      axisBottom().scale(xscale).ticks(4).tickSize(ticksize)
+    );
+    axisstyle({
+      axis: xaxis,
+      color: gray,
+      fontsize,
+      showline: true
+    });
+    yaxis.attr("transform", "translate(" + (fontsize + axisw) + "," + (fontsize / 2 + barheight + pad) + ")").call(
+      axisLeft().scale(yscale).ticks(5).tickSize(ticksize)
+    );
+    axisstyle({
+      axis: yaxis,
+      color: gray,
+      fontsize,
+      showline: true
+    });
+    boxg.attr("transform", "translate(" + (fontsize + axisw + pad0) + "," + (fontsize / 2 + barheight + pad) + ")");
+    box.attr("width", width).attr("height", height);
+    midline.attr("y1", height / 2).attr("x2", width).attr("y2", height / 2);
+    spg.attr(
+      "transform",
+      (d) => "translate(" + xscale(d.total > maxtotal ? maxtotal : d.total) + "," + yscale(d.maf) + ")"
+    );
+    spgl1.attr("x1", -marksize).attr("y1", -marksize).attr("x2", marksize).attr("y2", marksize);
+    spgl2.attr("x1", marksize).attr("y1", -marksize).attr("x2", -marksize).attr("y2", marksize);
+    spgkick.attr("r", marksize);
+    ybing.attr(
+      "transform",
+      "translate(" + (fontsize + axisw + pad0 + width + pad) + "," + (fontsize / 2 + barheight + pad + height) + ")"
+    );
+    const binh = height / bincount;
+    ybinbar.attr("y", (d, i) => -binh * (i + 1)).attr("width", (d) => ybinscale(d)).attr("height", binh).attr("fill", gray);
+    ybinaxis.attr(
+      "transform",
+      "translate(" + (fontsize + axisw + pad0 + width + pad) + "," + (fontsize / 2 + barheight + pad + height + pad0) + ")"
+    ).call(
+      axisBottom().scale(ybinscale).tickValues([0, ybinmax]).tickFormat(format("d"))
+    );
+    axisstyle({
+      axis: ybinaxis,
+      color: gray,
+      showline: true
+    });
+    xbing.attr("transform", "translate(" + (fontsize + axisw + pad0) + "," + (fontsize / 2 + barheight) + ")");
+    const binw = width / bincount;
+    xbinbar.attr("x", (d, i) => binw * i).attr("y", (d) => xbinscale(d) - barheight).attr("height", (d) => barheight - xbinscale(d)).attr("width", binw).attr("fill", gray);
+    xbinaxis.attr("transform", "translate(" + (fontsize + axisw) + "," + fontsize / 2 + ")").call(
+      axisLeft().scale(xbinscale).tickValues([0, xbinmax]).tickFormat(format("d"))
+    );
+    axisstyle({
+      axis: xbinaxis,
+      color: gray,
+      showline: true
+    });
+    drag.attr("x", fontsize + axisw + pad0 + width + pad + barwidth + pad2 + ticksize - 5).attr("y", fontsize / 2 + barheight + pad + height + pad0 + axish + ticksize + fontsize - 5);
+    if (gtg) {
+      gtg.attr("transform", "translate(" + (fontsize + axisw + pad0 + width + pad) + "," + fontsize / 2 + ")");
+      gtlab.attr("font-size", fontsize);
+      gt.attr("transform", (d, i) => {
+        return "translate(0," + (fontsize / 2 + 3 + (fontsize + 1) * i + fontsize / 2) + ")";
+      });
+      gtl1.attr("y1", -fontsize / 2).attr("x2", fontsize).attr("y2", fontsize / 2);
+      gtl2.attr("x1", fontsize).attr("y1", -fontsize / 2).attr("y2", fontsize / 2);
+      gtname.attr("x", fontsize + 5).attr("font-size", fontsize);
+    }
+  }
+  resize();
+  return spg;
+}
+export {
+  plot_vaf2cov as default
+};
+//# sourceMappingURL=plot.vaf2cov-7HZCKNK6.js.map

package/dist/plot.wsi-MU6AXOWO.js

@@ -0,0 +1,36 @@
+import "./chunk-HFNDKYVF.js";
+
+// plots/wsiviewer/plot.wsi.js
+async function plot_wsi_default(dslabel, holder, genomeObj, sample_id, aiProjectID, aiWSIMageFiles, renderAnnotationTable = false) {
+  const loadingDiv = holder.append("div").style("margin", "20px").text("Loading...");
+  try {
+    const opts = {
+      holder,
+      state: {
+        genome: genomeObj.name,
+        dslabel,
+        sample_id,
+        aiProjectID,
+        aiWSIMageFiles,
+        plots: [
+          {
+            chartType: "WSIViewer",
+            subfolder: "wsiviewer",
+            extension: "ts",
+            overrides: { renderAnnotationTable }
+          }
+        ]
+      }
+    };
+    const plot = await import("./plot.app-T7CQMBRV.js");
+    const plotAppApi = await plot.appInit(opts);
+    loadingDiv.remove();
+  } catch (e) {
+    loadingDiv.text("Error: " + (e.message || e));
+    console.error(e.message || e);
+  }
+}
+export {
+  plot_wsi_default as default
+};
+//# sourceMappingURL=plot.wsi-MU6AXOWO.js.map