@sjcrh/proteinpaint-client 2.220.0 → 2.221.0

package/dist/chunk-WXSX5OQJ.js

@@ -0,0 +1,296 @@
+import {
+  getSortOptions
+} from "./chunk-5DI4UNH5.js";
+import {
+  defaultUiLabels,
+  fillTermWrapper
+} from "./chunk-WD7FZ5EE.js";
+import {
+  isDictionaryType
+} from "./chunk-JHLF2ZC2.js";
+import {
+  CNVClasses,
+  dtcnv,
+  mclass,
+  mutationClasses,
+  proteinChangingMutations,
+  synonymousMutations,
+  truncatingMutations
+} from "./chunk-WJLRU5OF.js";
+import {
+  copyMerge
+} from "./chunk-HBNB5TRH.js";
+
+// plots/matrix/matrix.config.js
+async function getPlotConfig(opts = {}, app) {
+  const controlLabels = structuredClone(defaultUiLabels);
+  const devicePixelRatio = opts.devicePixelRatio || window.devicePixelRatio;
+  const config = {
+    // data configuration
+    termgroups: [],
+    samplegroups: [],
+    divideBy: null,
+    legendValueFilter: {
+      isAtomic: true,
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: []
+    },
+    legendGrpFilter: {
+      isAtomic: true,
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: []
+    },
+    filter: {
+      isAtomic: true,
+      type: "tvslst",
+      in: true,
+      join: "and",
+      lst: []
+    },
+    // cnvCutoffs: {},
+    // rendering options
+    settings: {
+      matrix: {
+        svgCanvasSwitch: 1e3,
+        // the number of samples to trigger switching between svg and canvas
+        useMinPixelWidth: true,
+        // canvas may be hazy if false, but more accurately reflects column density
+        cellEncoding: "",
+        // can be "oncoprint" | "stacked" | "single"
+        margin: {
+          top: 10,
+          right: 5,
+          bottom: 20,
+          left: 50
+        },
+        // set any dataset-defined sample limits and sort priority, otherwise undefined
+        // put in settings, so that later may be overridden by a user
+        maxGenes: opts.settings?.maxGenes || 50,
+        maxSample: opts.settings?.maxSample || 1e3,
+        sampleNameFilter: "",
+        sortSamplesBy: "a",
+        sortPriority: void 0,
+        // will be filled-in
+        sortBySampleAncestry: app.vocabApi.termdbConfig.hasSampleAncestry ? "last" : false,
+        // indicates sorting priority by sample ancestry
+        mapChildren2Root: false,
+        // for a dataset with sample ancestry, show one column per root sample (e.g. patient)
+        // sortByMutation: 'consequence', computed
+        // sortByCNV: true, computed
+        //sortOptions: getSortOptions(app.vocabApi.termdbConfig, controlLabels),
+        sortSampleGrpsBy: "name",
+        // 'hits' | 'name' | 'sampleCount'
+        sortSamplesTieBreakers: [{
+          $id: "sample",
+          sortSamples: {}
+          /*split: {char: '', index: 0}*/
+        }],
+        sortTermsBy: "sampleCount",
+        // or 'as listed'
+        // do not show number of samples at hiercluster gene row labels
+        samplecount4gene: opts.chartType == "hierCluster" ? "" : "abs",
+        //true, // 'abs' (default, previously true), 'pct', ''  (previously false)
+        geneVariantCountSamplesSkipMclass: [],
+        cellbg: "#ececec",
+        showGrid: "",
+        // false | 'pattern' | 'rect'
+        // whether to show these controls buttons
+        addMutationCNVButtons: false,
+        truncatingMutations,
+        proteinChangingMutations,
+        synonymousMutations,
+        mutationClasses,
+        CNVClasses,
+        gridStroke: "#fff",
+        outlineStroke: "#ccc",
+        beamStroke: "#f00",
+        colw: 0,
+        colwMin: 0.1 / devicePixelRatio,
+        colwMax: 16,
+        colspace: 1,
+        colgspace: 8,
+        colglabelpos: true,
+        collabelpos: "bottom",
+        collabelvisible: true,
+        collabelgap: 5,
+        collabelpad: 1,
+        collabelmaxchars: 32,
+        rowh: 18,
+        //use 0 to auto-compute row height, previous default=18,
+        rowhMin: 1,
+        rowhMax: 20,
+        rowspace: 1,
+        rowgspace: 8,
+        rowlabelpos: "left",
+        // | 'right'
+        rowlabelgap: 5,
+        rowlabelvisible: true,
+        rowlabelpad: 1,
+        rowlabelmaxchars: 32,
+        legendGrpLabelMaxChars: 26,
+        grpLabelFontSize: 12,
+        minLabelFontSize: 6,
+        maxLabelFontSize: 14,
+        transpose: false,
+        // 'auto' shows column labels only when columns are wide enough (colw >= minLabelFontSize);
+        sampleLabelsToggle: "auto",
+        // 'auto' | 'hide'
+        sampleLabelOffset: 120,
+        sampleGrpLabelOffset: 120,
+        sampleGrpLabelMaxChars: 32,
+        termLabelOffset: 80,
+        termGrpLabelOffset: 80,
+        termGrpLabelMaxChars: 32,
+        duration: 0,
+        zoomLevel: 1,
+        zoomCenterPct: 0,
+        zoomIndex: 0,
+        zoomGrpIndex: 0,
+        zoomMin: 0.5,
+        zoomIncrement: 0.1,
+        zoomStep: 1,
+        // renderedWMax should not be exposed as a user-input
+        // 60000 pixels is based on laptop and external monitor tests,
+        // when a canvas dataURL image in a zoomed-in matrix svg stops rendering
+        imgWMax: 6e4 / devicePixelRatio,
+        scrollHeight: 12,
+        controlLabels,
+        cnvUnit: "log2ratio",
+        ignoreCnvValues: false,
+        //will ignore numeric CNV values if true
+        barh: 32,
+        // default bar height for continuous terms,
+        // possible string entries:
+        // - "genesetEdit", for gene-centric embedders only like GDC OncoMatrix
+        // - may add other optional hints later
+        showHints: [],
+        genesetEditUiVersion: "",
+        // '' | 'withTabs'
+        // settings for a specific tw
+        twSpecificSettings: {},
+        oncoPrintSNVindelCellBorder: false,
+        // whether to show white cell border for SNVindel in oncoPrint mode
+        cnvValues: {
+          //Properties match the args for the ColorScales
+          //numericInput arg
+          cutoffMode: "percentile",
+          defaultPercentile: 99,
+          min: null,
+          max: null,
+          percentile: 99
+        }
+      }
+    }
+  };
+  const s = config.settings;
+  const fontsize = Math.max(s.matrix.rowh + s.matrix.rowspace - 3 * s.matrix.rowlabelpad, 12);
+  s.legend = {
+    ontop: false,
+    lineh: 25,
+    padx: 5,
+    padleft: 0,
+    //150,
+    padright: 20,
+    padbtm: 30,
+    fontsize,
+    iconh: fontsize - 2,
+    iconw: fontsize - 2,
+    hangleft: 1,
+    linesep: false
+  };
+  const overrides = app.vocabApi.termdbConfig.matrix || {};
+  copyMerge(config.settings.matrix, overrides.settings);
+  if (overrides.legendGrpFilter) config.legendGrpFilter = overrides.legendGrpFilter;
+  if (overrides.legendValueFilter) config.legendValueFilter = overrides.legendValueFilter;
+  if (overrides.filter) config.filter = overrides.filter;
+  if (opts.name) {
+    const data = await app.vocabApi.getMatrixByName(opts.name);
+    if (!data) throw "error from getMatrixByName()";
+    if (data.error) throw data.error;
+    copyMerge(config, data);
+  }
+  const os = opts?.settings?.matrix;
+  if (os) {
+    if ((os.sortSamplesBy == "custom" || os.sortSamplesBy == "asListed") && os.sortOptions?.custom.label == "against alteration type") {
+      os.sortSamplesBy = "a";
+    }
+    if (os.sortOptions) {
+      delete os.sortOptions.custom;
+      delete os.sortOptions.asListed;
+    }
+  }
+  copyMerge(config, opts);
+  const m = config.settings.matrix;
+  m.sortOptions = getSortOptions(app.vocabApi.termdbConfig, controlLabels, m);
+  m.duration = 0;
+  m.colw = 0;
+  if (m.sortSamplesBy != "asListed" && !m.sortOptions?.[m.sortSamplesBy]) m.sortSamplesBy = "a";
+  else if (["selectedTerms", "class", "dt", "hits"].includes(m.sortSamplesBy)) m.sortSamplesBy = "a";
+  if (m.samplecount4gene === true || m.samplecount4gene === 1) m.samplecount4gene = "abs";
+  if (window.location.hostname == "localhost") {
+    if (window.location.hash == "#canvas") m.svgCanvasSwitch = 0;
+  }
+  for (const grp of config.termgroups) {
+    const promises = [];
+    for (const tw of grp.lst) {
+      if (!tw.term?.type || isDictionaryType(tw.term.type)) {
+        if (!tw.id && tw.term.type != "samplelst" && tw.term.type != "termCollection") {
+          if (!tw.term.id) throw `missing tw.id and tw.term.id`;
+          tw.id = tw.term.id;
+        }
+        if (tw.term?.type != "samplelst" && tw.term?.type != "termCollection") delete tw.term;
+      }
+      promises.push(fillTermWrapper(tw, app.vocabApi));
+    }
+    grp.lst = await Promise.all(promises);
+  }
+  if (config.divideBy) config.divideBy = await fillTermWrapper(config.divideBy, app.vocabApi);
+  return config;
+}
+function setComputedConfig(config) {
+  const s = config.settings.matrix;
+  const allClasses = [...s.mutationClasses, ...s.CNVClasses];
+  s.filterByClass = { isAtomic: true };
+  for (const f of config.legendGrpFilter.lst) {
+    if (!f.dt) continue;
+    allClasses.filter((m) => f.dt.includes(mclass[m].dt)).forEach((key2) => {
+      s.filterByClass[key2] = "value";
+    });
+  }
+  for (const f of config.legendValueFilter.lst) {
+    if (!f.legendGrpName || f.tvs?.term?.type !== "geneVariant") continue;
+    if (f.tvs.values?.[0].mclasslst)
+      f.tvs.values[0].mclasslst.forEach((key2) => {
+        s.filterByClass[key2] = f.legendFilterType?.endsWith("_hard") ? "case" : "value";
+      });
+    else if (f.tvs.values)
+      f.tvs.values.forEach((v) => {
+        s.filterByClass[key] = "value";
+      });
+    else throw `unhandled tvs from legendValueFilter`;
+  }
+  s.hiddenVariants = Object.keys(s.filterByClass).filter((c) => c !== "isAtomic");
+  const hiddenCNVs = new Set(s.hiddenVariants.filter((key2) => mclass[key2]?.dt === dtcnv));
+  s.hiddenCNVs = [...hiddenCNVs];
+  s.showMatrixCNV = !hiddenCNVs.size ? "all" : hiddenCNVs.size == s.CNVClasses.length ? "none" : "bySelection";
+  s.allMatrixCNVHidden = hiddenCNVs.size == s.CNVClasses.length;
+  const hiddenMutations = new Set(s.hiddenVariants.filter((key2) => s.mutationClasses.find((k) => k === key2)));
+  s.hiddenMutations = [...hiddenMutations];
+  const PCset = new Set(s.proteinChangingMutations);
+  const TMset = new Set(s.truncatingMutations);
+  s.showMatrixMutation = !hiddenMutations.size ? "all" : hiddenMutations.size == s.mutationClasses.length ? "none" : hiddenMutations.size === s.mutationClasses.length - PCset.size && [...hiddenMutations].every((m) => !PCset.has(m)) ? "onlyPC" : hiddenMutations.size === s.mutationClasses.length - TMset.size && [...hiddenMutations].every((m) => !TMset.has(m)) ? "onlyTruncating" : "bySelection";
+  s.allMatrixMutationHidden = hiddenMutations.size == s.mutationClasses.length;
+  const tiebreakers = s.sortOptions.a?.sortPriority.find((sp) => sp.types.length == 1 && sp.types[0] == "geneVariant")?.tiebreakers || [];
+  s.sortByMutation = tiebreakers.find((tb) => tb.filter?.values[0]?.dt === 1)?.isOrdered ? "consequence" : "presence";
+  s.sortByCNV = tiebreakers.find((tb) => tb.filter?.values[0]?.dt === 4)?.disabled !== true;
+}
+
+export {
+  getPlotConfig,
+  setComputedConfig
+};
+//# sourceMappingURL=chunk-WXSX5OQJ.js.map

package/dist/chunk-WY3IORKG.js

@@ -0,0 +1,194 @@
+import {
+  violinRenderer
+} from "./chunk-WD7FZ5EE.js";
+import {
+  getValueConversionFactor
+} from "./chunk-W5J3LTYS.js";
+import {
+  linear
+} from "./chunk-4OLM3KSB.js";
+import {
+  drag_default
+} from "./chunk-5R63Q5KH.js";
+import {
+  pointer_default,
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+
+// termsetting/handlers/NumericDensity.ts
+var NumericDensity = class {
+  constructor(opts) {
+    this.dom = {};
+    // WeakMap allows deletion of value when the object/DOM key is deleted,
+    // so better for avoiding memory leak
+    this.vrByDiv = /* @__PURE__ */ new WeakMap();
+    this.ranges = [];
+    this.no_density_data = false;
+    this.brushes = [];
+    this.plot_size = {
+      width: 500,
+      height: 100,
+      xpad: 10,
+      ypad: 20,
+      radius: 8
+    };
+    this.opts = opts;
+    this.termsetting = opts.termsetting;
+    this.tw = opts.termsetting.tw;
+  }
+  /* the boundary values exchanged with the bin/knot editors, and the domain of this.xscale, are in
+  	the term's user-facing unit; density_data is in the unit the values are stored in. only the two
+  	getters below cross that line, to put the plot's endpoints in the same unit as those values.
+  
+  	they multiply instead of calling toUserUnit(), which rounds: rounding is right for a number shown
+  	in an input, but a rounded domain endpoint distorts every scaled x by up to half of the last shown
+  	digit, and collapses the domain outright when the converted range is smaller than that (a stored
+  	range of under 2 days at scaleFactor=1/365.25). it would also disagree with violinRenderer, whose
+  	axis this plot's lines overlay and which scales its own domain unrounded */
+  get scaleFactor() {
+    return getValueConversionFactor(this.tw.term);
+  }
+  get displayMin() {
+    return this.density_data.min * this.scaleFactor;
+  }
+  get displayMax() {
+    return this.density_data.max * this.scaleFactor;
+  }
+  async setData() {
+    const self = this.termsetting;
+    const d = await self.vocabApi.getViolinBox(
+      {
+        plotType: "violin",
+        tw: { type: self.tw.type, term: self.term, q: self.q },
+        svgw: this.plot_size.width,
+        radius: this.plot_size.radius,
+        filter: self.filter
+      },
+      self.opts.getBodyParams?.()
+    );
+    if (d.error) throw d;
+    this.density_data = d;
+    return this.density_data;
+  }
+  async showViolin(div, boundaryOpts) {
+    await this.setData();
+    if (!this.vrByDiv.has(div)) {
+      div.style("padding", "5px").selectAll("*").remove();
+      const loadingDiv = div.append("div").style("padding", "10px").style("text-align", "center").html("Getting distribution data ...<br/>");
+      const densityDiv = div.append("div");
+      loadingDiv.remove();
+      const vr = new violinRenderer({
+        holder: densityDiv,
+        rd: this.density_data,
+        width: this.plot_size.width,
+        height: this.plot_size.height,
+        radius: this.plot_size.radius,
+        // axis ticks are labeled in the term's user-facing unit, e.g. years and not days
+        scaleFactor: this.scaleFactor
+      });
+      this.vrByDiv.set(div, vr);
+    }
+    this.vr = this.vrByDiv.get(div);
+    this.dom.svg = this.vr.svg;
+    this.vr.render();
+    if (boundaryOpts) await this.setBinLines(boundaryOpts);
+    return this.density_data;
+  }
+  async setBinLines(boundaryOpts) {
+    if (this.density_data.max == this.density_data.min) {
+      this.handleNoDensity();
+    } else {
+      if (this.dom.binsize_g) this.dom.binsize_g.selectAll("*").remove();
+      this.dom.binsize_g = this.dom.svg.append("g").attr("transform", `translate(${this.plot_size.xpad}, ${this.plot_size.ypad})`).attr("class", "binsize_g");
+      const maxvalue = this.displayMax;
+      const minvalue = this.displayMin;
+      this.xscale = linear().domain([minvalue, maxvalue]).range([this.plot_size.xpad, this.plot_size.width + this.plot_size.xpad]);
+      this.ranges = [];
+      this.brushes = [];
+      this.renderBinLines(boundaryOpts);
+    }
+  }
+  handleNoDensity() {
+    this.no_density_data = true;
+    this.ranges = [];
+    this.brushes = [];
+  }
+  renderBinLines(boundaryOpts) {
+    const { plot_size, tw, xscale, scaleFactor } = this;
+    if (!this.density_data) throw `Missing .density_data [density.ts, renderBinLines()]`;
+    const scaledMinX = Math.round(this.xscale(this.displayMin));
+    const scaledMaxX = Math.round(this.xscale(this.displayMax));
+    const lines = [];
+    for (const [index, v] of boundaryOpts.values.entries()) {
+      lines.push({ ...v, index, scaledX: Math.round(this.xscale(v.x)) });
+    }
+    const lastVisibleLine = lines.find((l) => l.isLastVisibleLine);
+    const lastVisibleScaledX = lastVisibleLine ? lastVisibleLine.scaledX : scaledMaxX;
+    const dragger = drag_default().on("drag", onDrag).on("end", onDrag);
+    this.dom.binsize_g.selectAll("line").remove();
+    this.dom.binsize_g.selectAll("line").data(lines).enter().append("line").style("stroke", (d) => d.isDraggable ? "#cc0000" : "#555").style("stroke-width", 1).attr("x1", (d) => d.scaledX).attr("y1", 0).attr("x2", (d) => d.scaledX).attr("y2", plot_size.height).style("cursor", (d) => d.isDraggable ? "ew-resize" : "").attr("display", (d) => !d.isDraggable && d.scaledX > lastVisibleScaledX ? "none" : "").on("mouseover", function(_, d) {
+      if (d.isDraggable) select_default(this).style("stroke-width", 3);
+    }).on("mouseout", function() {
+      select_default(this).style("stroke-width", 1);
+    }).each(function(d) {
+      if (d.isDraggable) select_default(this).call(dragger);
+    });
+    const lineElems = this.dom.binsize_g.node().querySelectorAll("line");
+    function toBoundaryValue(x) {
+      const inverted = xscale.invert(x);
+      return Number(
+        scaleFactor != 1 ? inverted.toFixed(2) : tw.term.type == "integer" ? Math.round(inverted) : inverted.toFixed(3)
+      );
+    }
+    function toLineValue(line) {
+      return line.draggedX === void 0 ? line.x : toBoundaryValue(line.draggedX);
+    }
+    function getNeighbors(d) {
+      const x = d.draggedX ?? d.scaledX;
+      let lower, upper;
+      for (const line of lines) {
+        if (line.index === d.index || !line.isDraggable) continue;
+        const lineX = line.draggedX ?? line.scaledX;
+        if (lineX <= x) {
+          if (!lower || lineX > (lower.draggedX ?? lower.scaledX)) lower = line;
+        } else if (!upper || lineX < (upper.draggedX ?? upper.scaledX)) upper = line;
+      }
+      return [lower, upper];
+    }
+    function onDrag(event, _d) {
+      const d = _d;
+      const [lower, upper] = getNeighbors(d);
+      const lowerX = Math.max(scaledMinX, lower ? lower.draggedX ?? lower.scaledX : scaledMinX);
+      const upperX = Math.min(scaledMaxX, upper ? upper.draggedX ?? upper.scaledX : scaledMaxX);
+      if (upperX - lowerX < 2) return;
+      const draggedX = Math.min(Math.max(pointer_default(event, this)[0], lowerX + 1), upperX - 1);
+      const value = toBoundaryValue(draggedX);
+      if (lower && value === toLineValue(lower)) return;
+      if (upper && value === toLineValue(upper)) return;
+      d.draggedX = draggedX;
+      select_default(this).attr("x1", d.draggedX).attr("y1", 0).attr("x2", d.draggedX).attr("y2", plot_size.height);
+      const lastVisibleScaledX2 = lastVisibleLine?.draggedX ?? lastVisibleLine?.scaledX ?? scaledMaxX;
+      const xOffset = d.draggedX - d.scaledX;
+      if (xOffset) {
+        for (const elem of lineElems) {
+          const c = elem.__data__;
+          if (c.movesWithLineIndex !== d.index) continue;
+          c.draggedX = c.scaledX + xOffset;
+          select_default(elem).attr("x1", c.draggedX).attr("x2", c.draggedX).style("display", c.draggedX >= lastVisibleScaledX2 ? "none" : "");
+        }
+        boundaryOpts.callback(d, value);
+      }
+    }
+  }
+  destroy() {
+    for (const [k, v] of Object.entries(this.dom)) {
+      delete this.dom[k];
+      if (typeof v.remove == "function") v.remove();
+    }
+  }
+};
+
+export {
+  NumericDensity
+};
+//# sourceMappingURL=chunk-WY3IORKG.js.map