@sjcrh/proteinpaint-client 2.210.0 → 2.210.1

package/dist/chunk-G5USS6FI.js

@@ -0,0 +1,56 @@
+import {
+  sayerror
+} from "./chunk-CSAS3PVJ.js";
+import {
+  TermTypeGroups
+} from "./chunk-UYKJOBRO.js";
+
+// termdb/handlers/singleCellNumericValue.ts
+var SearchHandler = class {
+  async init(opts) {
+    this.validateOpts(opts);
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    const scnvTerms = opts.app.vocabApi.termdbConfig?.termType2terms?.[TermTypeGroups.SINGLECELL_NUMERIC_VALUE];
+    if (!scnvTerms?.length) {
+      sayerror(
+        holder,
+        `termType2terms[${TermTypeGroups.SINGLECELL_NUMERIC_VALUE}]:[] is required in termdbConfig for singleCellNumericValue handler`
+      );
+      return;
+    }
+    const usecaseConfig = opts.usecase?.specialCase?.config;
+    const plots = usecaseConfig?.sample?.plots;
+    const isMeta = usecaseConfig?.sample?.isMetaResult;
+    const filtered = plots ? scnvTerms.filter((t) => plots.includes(t.plot)) : usecaseConfig?.name ? scnvTerms.filter((t) => t.plot === usecaseConfig.name) : scnvTerms;
+    const getLabel = (t) => isMeta || plots?.length == 1 ? t.name : `${t.name} (${t.plot})`;
+    const filteredTerms = new Set(
+      plots || !usecaseConfig?.name ? filtered.map((t) => ({ ...t, label: getLabel(t) })) : filtered
+    );
+    for (const t of Array.from(filteredTerms)) {
+      holder.append("div").classed("termdiv", true).style("padding", "0px 5px").append("div").classed("termlabel sja_filter_tag_btn sja_tree_click_term ts_pill", true).style("display", "inline-block").style("padding", "5px 8px").style("margin", "1px 0px").style("border-radius", "6px").text(t.label || t.name).on("click", () => {
+        const term = this.makeTerm(t, usecaseConfig);
+        this.callback(term);
+      });
+    }
+  }
+  makeTerm(_term, usecaseConfig) {
+    const term = { ..._term };
+    if (!term.sample && usecaseConfig?.sample) term.sample = usecaseConfig.sample;
+    return term;
+  }
+  validateOpts(opts) {
+    if (opts.callback == null) throw new Error("callback is required");
+    if (opts.app == null) throw new Error("app is required");
+    if (opts.holder == null) throw new Error("holder is required");
+    if (opts.usecase == null) throw new Error("usecase is required");
+    if (!opts.app.vocabApi.termdbConfig?.termType2terms)
+      throw new Error("termType2terms is required in termdbConfig for singleCellNumericValue handler");
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-G5USS6FI.js.map

package/dist/chunk-GLPTPX45.js

@@ -0,0 +1,203 @@
+import {
+  tkt
+} from "./chunk-CSAS3PVJ.js";
+import {
+  stratinput
+} from "./chunk-PF4DSFDR.js";
+import {
+  stratify_default
+} from "./chunk-4OLM3KSB.js";
+
+// src/vcf.tkconvert.js
+function vcf2dstk(arg) {
+  const ds = {
+    id2vcf: {},
+    label: arg.name || "Unnamed VCF file"
+  };
+  let vcfobj;
+  if (arg.file) {
+    const id = Math.random().toString();
+    vcfobj = {
+      file: arg.file,
+      indexURL: arg.indexURL,
+      vcfid: id
+    };
+    ds.id2vcf[id] = vcfobj;
+  } else if (arg.url) {
+    const id = Math.random().toString();
+    vcfobj = {
+      url: arg.url,
+      indexURL: arg.indexURL,
+      vcfid: id
+    };
+    ds.id2vcf[id] = vcfobj;
+  } else {
+    return ["no .file or .url"];
+  }
+  vcfobj.headernotloaded = true;
+  if (arg.samplenamemap) {
+    vcfobj.samplenamemap = arg.samplenamemap;
+  }
+  if (arg.variant2img) {
+    if (!arg.variant2img.path) return [".path missing from .variant2img{}"];
+  }
+  const tk = {
+    type: tkt.ds,
+    // to be loaded by loadvcftk() as a custom track, rather than "/dsdata" for official ds
+    isvcf: true,
+    name: ds.label,
+    ds,
+    populationfrequencyfilter: arg.populationfrequencyfilter,
+    vcfinfofilter: arg.vcfinfofilter,
+    itemlabelname: arg.itemlabelname,
+    viewrangeupperlimit: arg.viewrangeupperlimit,
+    variant2img: arg.variant2img,
+    axisheight: arg.axisheight
+  };
+  if (arg.url4variant) {
+    const err = check_url4variant(arg.url4variant);
+    if (err) return [".url4variant error: " + err];
+    tk.url4variant = arg.url4variant;
+  }
+  if (arg.button4variant) {
+    const err = check_button4variant(arg.button4variant);
+    if (err) return [".button4variant error: " + err];
+    tk.button4variant = arg.button4variant;
+  }
+  if (arg.sampleannotation) {
+    const sn = arg.sampleannotation;
+    if (!sn.annotation) return [".annotation{} missing from .sampleannotation"];
+    if (sn.levels) {
+      if (!Array.isArray(sn.levels)) return [".sampleannotation.levels should be array"];
+      const lst = [];
+      for (const sample in sn.annotation) {
+        const o = { sample_name: sample };
+        for (const k in sn.annotation[sample]) {
+          o[k] = sn.annotation[sample][k];
+        }
+        lst.push(o);
+      }
+      const nodes = stratinput(lst, sn.levels);
+      sn.root = stratify_default()(nodes);
+      sn.root.sum((i) => i.value);
+    }
+    if (sn.variantsunburst) {
+      if (!sn.levels) return [".levels missing when .variantsunburst is on from .sampleannotation"];
+    }
+    tk.ds.cohort = sn;
+  }
+  if (arg.vcfcohorttrack) {
+    if (!arg.vcfcohorttrack.file && !arg.vcfcohorttrack.url) return ["no .file or .url provided from .vcfcohorttrack"];
+    tk.ds.vcfcohorttrack = arg.vcfcohorttrack;
+  }
+  if (arg.germline2dvafplot) {
+    if (!arg.germline2dvafplot.individualkey) return [".individualkey missing from germline2dvafplot"];
+    if (!arg.germline2dvafplot.sampletypekey) return [".sampletypekey missing from germline2dvafplot"];
+    if (!arg.germline2dvafplot.xsampletype) return [".xsampletype missing from germline2dvafplot"];
+    if (!arg.germline2dvafplot.yleftsampletype) return [".yleftsampletype missing from germline2dvafplot"];
+    if (arg.germline2dvafplot.yrightsampletype) {
+      if (arg.germline2dvafplot.yrightsampletype == arg.germline2dvafplot.yleftsampletype)
+        return [".yrightsampletype should not be same as yleftsampletype"];
+    }
+    tk.ds.germline2dvafplot = arg.germline2dvafplot;
+  }
+  if (arg.vaf2coverageplot) {
+    if (arg.vaf2coverageplot.categorykey) {
+      if (!arg.vaf2coverageplot.categories)
+        return [".categories missing when .categorykey is in use for .vaf2coverageplot"];
+    }
+    tk.ds.vaf2coverageplot = arg.vaf2coverageplot;
+  }
+  if (arg.genotype2boxplot) {
+    if (arg.genotype2boxplot.boxplotvaluekey) {
+    } else if (arg.genotype2boxplot.sampleannotationkey) {
+      if (!tk.ds.cohort) return ["sampleannotation missing when using genotype2boxplot.sampleannotationkey"];
+      if (!tk.ds.cohort.annotation)
+        return ["sampleannotation.annotation missing when using genotype2boxplot.sampleannotationkey"];
+      let found = false;
+      for (const k in tk.ds.cohort.annotation) {
+        if (arg.genotype2boxplot.sampleannotationkey in tk.ds.cohort.annotation[k]) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return [arg.genotype2boxplot.sampleannotationkey + " not found in any sample annotation"];
+    } else {
+      return ["incomplete instruction for genotype2boxplot"];
+    }
+    tk.ds.genotype2boxplot = arg.genotype2boxplot;
+  }
+  if (arg.discardsymbolicallele) {
+    tk.ds.discardsymbolicallele = true;
+  }
+  if (arg.samplebynumericvalue) {
+    if (!arg.samplebynumericvalue.attrkey) return ["attrkey missing from samplebynumericvalue"];
+    if (!tk.ds.cohort) return ["sampleannotation missing when using samplebynumericvalue"];
+    if (!tk.ds.cohort.annotation) return ["sampleannotation.annotation missing when using samplebynumericvalue"];
+    let found = false;
+    for (const k in tk.ds.cohort.annotation) {
+      if (Number.isFinite(tk.ds.cohort.annotation[k][arg.samplebynumericvalue.attrkey])) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) return ["samplebynumericvalue.attrkey not found in any sample annotation"];
+    tk.ds.samplebynumericvalue = arg.samplebynumericvalue;
+  }
+  {
+    const g = arg.genotypebynumericvalue;
+    if (g) {
+      if (!g.refref) return [tk.name + ": refref missing from genotypebynumericvalue"];
+      if (!g.refalt) return [tk.name + ": refalt missing from genotypebynumericvalue"];
+      if (!g.altalt) return [tk.name + ": altalt missing from genotypebynumericvalue"];
+      if (!g.refref.infokey) return [tk.name + ": refref.infokey missing from genotypebynumericvalue"];
+      if (!g.refalt.infokey) return [tk.name + ": refalt.infokey missing from genotypebynumericvalue"];
+      if (!g.altalt.infokey) return [tk.name + ": altalt.infokey missing from genotypebynumericvalue"];
+      if (g.refref.genotypeCountInfokey || g.refalt.genotypeCountInfokey || g.altalt.genotypeCountInfokey) {
+        if (!g.refref.genotypeCountInfokey)
+          return [tk.name + ": genotypeCountInfokey missing from genotypebynumericvalue.refref{}"];
+        if (!g.refalt.genotypeCountInfokey)
+          return [tk.name + ": genotypeCountInfokey missing from genotypebynumericvalue.refalt{}"];
+        if (!g.altalt.genotypeCountInfokey)
+          return [tk.name + ": genotypeCountInfokey missing from genotypebynumericvalue.altalt{}"];
+      }
+      tk.ds.genotypebynumericvalue = g;
+    }
+  }
+  if (arg.pointdown) {
+    tk.aboveprotein = false;
+  }
+  if (arg.dstk_novcferror) {
+    tk.dstk_novcferror = true;
+  }
+  return [null, tk];
+}
+function check_url4variant(lst) {
+  if (!Array.isArray(lst)) return "value is not an array";
+  for (const item of lst) {
+    if (!item.makeurl) {
+      return ".makeurl missing";
+    }
+    if (typeof item.makeurl != "function") {
+      return ".makeurl must be a function";
+    }
+  }
+  return false;
+}
+function check_button4variant(lst) {
+  if (!Array.isArray(lst)) return "value is not an array";
+  for (const item of lst) {
+    if (!item.makebutton) {
+      return ".makebutton missing";
+    }
+    if (typeof item.makebutton != "function") {
+      return ".makebutton must be a function";
+    }
+  }
+  return false;
+}
+
+export {
+  vcf2dstk
+};
+//# sourceMappingURL=chunk-GLPTPX45.js.map

package/dist/chunk-GPY6SBCX.js

@@ -0,0 +1,339 @@
+import {
+  summaryInit
+} from "./chunk-NJWNKBRC.js";
+import {
+  navInit
+} from "./chunk-GWHIKECP.js";
+import {
+  skipPrevActionAbort,
+  storeInit
+} from "./chunk-BSWPONNA.js";
+import {
+  AppBase,
+  downloadSVGsAsPdf,
+  filterRxCompInit,
+  newSandboxDiv,
+  sayerror,
+  vocabInit
+} from "./chunk-CSAS3PVJ.js";
+import {
+  importPlot
+} from "./chunk-T4RYLTR3.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import {
+  AppApi,
+  getCompInit,
+  multiInit
+} from "./chunk-WINIL2KN.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+
+// mass/plot.js
+var MassPlot = class _MassPlot {
+  static type = "plot";
+  constructor(opts) {
+    this.type = _MassPlot.type;
+    setRenderers(this);
+    this.initUi(opts);
+  }
+  reactsTo(action) {
+    if (action.type.endsWith("_group")) return true;
+    if (action.type.startsWith("plot_")) {
+      return action.id === this.id || action.id == this.parentId || action.config?.parentId === this.id || action.parentId === this.id;
+    }
+    if (action.type.startsWith("filter")) return true;
+    if (action.type.startsWith("cohort")) return true;
+    if (action.type == "app_refresh") return true;
+    if (action.type.endsWith("customTerm")) return true;
+  }
+  // !!! NOTE: This getState() method is reused by the plot-specific recover component.
+  // When logging something within getState, it may have been called by either the plot or recover instance
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) {
+      throw `No plot with id='${this.id}' found. Did you set this.id before this.api = getComponentApi(this)?`;
+    }
+    return {
+      termfilter: appState.termfilter,
+      config,
+      groups: appState.groups,
+      // quick fix to skip history tracking as needed
+      _scope_: appState._scope_
+    };
+  }
+  async main() {
+    this.dom.errdiv.style("display", "none").style("background-color", "rgba(255,100,100,0.2)").html("");
+    if (!this.components) await this.setComponents(this.opts);
+  }
+  async setComponents(opts) {
+    const _ = await importPlot(opts.chartType);
+    const promises = {
+      // recover: recoverInit({
+      // 	app: this.app,
+      // 	holder: this.dom.localRecoverDiv,
+      // 	getState: appState => this.getState(appState),
+      // 	reactsTo: action =>
+      // 		action.id == this.id &&
+      // 		(action.type == 'plot_edit' || action.type == 'plot_nestedEdits') &&
+      // 		action._track_ != 'none',
+      // 	plot_id: this.id,
+      // 	maxHistoryLen: 10,
+      // 	hideLabel: true
+      // }),
+      chart: _.componentInit({
+        app: this.app,
+        holder: this.dom.viz,
+        header: this.dom.paneTitleDiv,
+        id: this.id,
+        plotDiv: select_default(this.dom.holder.app_div.node().parentNode),
+        /******* reason for passing plotDiv to chart ********
+        				- this plot instance may allow to launch a new plot as a persistent sandbox
+        				  inside mass plotDiv, maintaining the uniform plot appearance despite it's ad-hoc
+        				  the new plot is not a formal mass plot type, and cannot be done via app.dispatch()
+        				  thus the need to directly access plotDiv
+        				- example: mds3 tk from genome browser can launch disco etc
+        				- having access to plotDiv may offer flexibility for the plot to do stuff
+        
+        				since plot.js has no access to mass app .dom.plotDiv in which all apps are shown,
+        				this workarounds gets the parent node of sandbox.app_div which is app.dom.plotDiv
+        				*/
+        getFilterImage: async () => this.components.filter.getFilterImage()
+      })
+    };
+    if (!this.state.config.hidePlotFilter) {
+      const filterDisabledMsg = this.app.vocabApi.termdbConfig?.plotFilter?.disabledMessage;
+      const filterHolder = filterDisabledMsg ? this.dom.filterDiv.append("div").style("pointer-events", "none").style("opacity", 0.5) : this.dom.filterDiv;
+      if (filterDisabledMsg) this.dom.filterDiv.attr("title", filterDisabledMsg).style("cursor", "not-allowed");
+      promises.filter = filterRxCompInit({
+        app: this.app,
+        vocabApi: this.app.vocabApi,
+        parentId: this.id,
+        holder: filterHolder,
+        hideLabel: true,
+        emptyLabel: "+Add new filter",
+        callback: (filter) => {
+          this.app.dispatch({
+            id: this.id,
+            type: "plot_edit",
+            config: { filter }
+          });
+        }
+      });
+    }
+    this.components = await multiInit(promises);
+  }
+  destroy() {
+    this.dom.holder.app_div.selectAll("*").remove();
+    this.dom.holder.app_div.remove();
+    for (const key in this.dom) {
+      delete this.dom[key];
+    }
+  }
+};
+var plotInit = getCompInit(MassPlot);
+function setRenderers(self) {
+  self.initUi = function(opts) {
+    const holder = opts.holder;
+    opts.holder.app_div.attr("data-testid", "sjpp-massplot-sandbox-" + opts.chartType);
+    holder.header.style("padding", 0);
+    try {
+      self.dom = {
+        tip: new Menu({ padding: "0px" }),
+        holder,
+        paneTitleDiv: holder.header.append("div").style("display", "inline-block").style("color", "#555").style("padding-left", "7px").style("vertical-align", "sub"),
+        localRecoverDiv: holder.header.append("div").style("display", "inline-block"),
+        filterDiv: holder.header.append("div").style("display", "inline-block").style("zoom", 0.9),
+        body: holder.body.style("white-space", "nowrap").style("overflow-x", "auto"),
+        // will hold no data notice or the page title in multichart views
+        errdiv: holder.body.append("div").style("display", "none").style("padding", "5px").style("background-color", "rgba(255,100,100,0.2)"),
+        // dom.viz will hold the rendered view
+        viz: holder.body.append("div")
+      };
+    } catch (e) {
+      self.dom.errdiv.style("display", "none").text(e);
+    }
+  };
+}
+
+// mass/app.ts
+var MassApp = class extends AppBase {
+  // expected class-specific props
+  constructor(opts, api) {
+    super(opts);
+    this.components = {};
+    this.wasDestroyed = false;
+    this.api = api;
+    if (opts.addLoginCallback) {
+      opts.addLoginCallback(() => this.api.dispatch({ type: "app_refresh" }));
+    }
+    this.type = "app";
+    this.dom = {
+      holder: opts.holder,
+      // do not modify holder style
+      topbar: opts.holder.append("div"),
+      errdiv: opts.holder.append("div"),
+      plotDiv: opts.holder.append("div")
+    };
+    if (opts.getPlotConfig_mutateSummary) {
+      if (typeof opts.getPlotConfig_mutateSummary != "function")
+        throw new Error("opts.getPlotConfig_mutateSummary is not function");
+    }
+    this.plotIdToSandboxId = {};
+  }
+  static {
+    this.type = "app";
+  }
+  async preApiFreeze(api) {
+    try {
+      api.tip = new Menu({ padding: "5px" });
+      api.tip.d.on("keyup", (event) => {
+        if (event.key == "Escape") api.tip.hide();
+      });
+      api.printError = (e) => this.printError(e);
+      api.vocabApi = await vocabInit({
+        app: api,
+        state: { vocab: this.opts.state.vocab },
+        fetchOpts: this.opts.fetchOpts,
+        getDatasetAccessToken: this.opts.getDatasetAccessToken
+      });
+      api.hasWebGL = function() {
+        try {
+          const canvas = document.createElement("canvas");
+          return !!(window.WebGLRenderingContext && (canvas.getContext("webgl") || canvas.getContext("experimental-webgl")));
+        } catch (_) {
+          return false;
+        }
+      };
+      this.opts.state.vocab = api.vocabApi.vocab;
+    } catch (e) {
+      console.log(`preApiFreeze error`, e);
+      throw e;
+    }
+  }
+  async init() {
+    try {
+      const debounceInterval = "debounceInterval" in this.opts ? this.opts.debounceInterval : 0;
+      const embeddedSessionState = this.opts.embeddedSessionState;
+      if (embeddedSessionState) {
+        Object.assign(this.opts.state, embeddedSessionState);
+      }
+      this.store = await storeInit({ app: this.api, state: this.opts.state, debounceInterval });
+      this.state = await this.store.copyState();
+      this.components = {};
+      if (this.state.nav.header_mode != "hidden") {
+        this.components.nav = await navInit({
+          app: this.api,
+          holder: this.dom.topbar,
+          header_mode: this.state && this.state.nav && this.state.nav.header_mode,
+          vocab: this.state.vocab,
+          massSessionDuration: this.state.termdbConfig.massSessionDuration,
+          // this.opts.massSessionDuration
+          pkgver: this.opts.pkgver,
+          downloadPlots: () => {
+            this.downloadPlots();
+          }
+        });
+      }
+      this.components.plots = {};
+      if (this.opts.app?.doNotAwaitInitRender) {
+        this.api.dispatch();
+      } else {
+        await this.api.dispatch();
+      }
+    } catch (e) {
+      this.printError(e);
+      throw e;
+    }
+  }
+  async main() {
+    await this.api.vocabApi.main();
+    this.dom.plotDiv?.style(
+      "display",
+      this.state.nav?.header_mode != "hidden" && this.state.nav?.activeTab == 0 ? "none" : "block"
+    );
+    const newPlots = {};
+    let sandbox;
+    for (const plot of this.state.plots) {
+      if (plot.parentId) continue;
+      if (this.components.plots && !(plot.id in this.components.plots)) {
+        sandbox = newSandboxDiv(this.dom.plotDiv, {
+          close: () => {
+            this.api.dispatch({
+              type: "plot_delete",
+              id: plot.id
+            });
+          },
+          plotId: plot.id,
+          beforePlotId: plot.insertBefore || null,
+          style: {
+            width: "98.5%"
+          }
+        });
+        if (plot.chartType == "summary")
+          newPlots[plot.id] = summaryInit(Object.assign({ app: this.api, holder: sandbox }, plot));
+        else newPlots[plot.id] = plotInit(Object.assign({ app: this.api, holder: sandbox }, plot));
+      }
+    }
+    const numNewPlots = Object.keys(newPlots).length;
+    if (numNewPlots) {
+      await Promise.all(Object.values(newPlots));
+      for (const plotId in newPlots) {
+        this.components.plots[plotId] = await newPlots[plotId];
+      }
+    }
+    for (const plotId in this.components.plots) {
+      if (!this.state.plots.find((p) => p.id === plotId)) {
+        this.components.plots[plotId].destroy();
+        delete this.components.plots[plotId];
+      }
+    }
+  }
+  printError(e) {
+    const errdiv = e.errdiv || this.dom.errdiv;
+    if (errdiv) errdiv.style("display", "").html("").style("background-color", "");
+    sayerror(errdiv || this.opts.holder, "Error: " + (e.message || e.error || e));
+    if (e.stack) console.log(e.stack);
+    this.bus.emit("error");
+    if (this.opts?.debug) {
+      console.groupCollapsed("Stack trace from MassApp.printError() call.");
+      console.trace();
+      console.groupEnd();
+    }
+  }
+  skipPrevActionAbort(action) {
+    return skipPrevActionAbort(action);
+  }
+  async downloadPlots() {
+    const chartImagesAll = [];
+    let i = 1;
+    const values = Object.values(this.components.plots);
+    for (const plot of values) {
+      const chart = plot.type == "plot" ? plot.getComponents("chart") : plot;
+      const chartImages = chart.getChartImages ? chart.getChartImages() : null;
+      if (!chartImages) {
+        console.log(`The ${chart.type} does not support downloading images yet`);
+        continue;
+      }
+      for (const chartImage of chartImages) {
+        if (values.length > 1) chartImage.name = `${i}. ${chartImage.name}`;
+        chartImagesAll.push(chartImage);
+      }
+      i++;
+    }
+    if (chartImagesAll.length > 0) {
+      const filters = [];
+      const globalFilterImg = await this.components.nav.getComponents("filter").getFilterImage();
+      if (globalFilterImg) filters.push(globalFilterImg);
+      downloadSVGsAsPdf(chartImagesAll, "plots", "landscape", filters);
+    } else alert("No chart images available for download");
+  }
+};
+var appInit = AppApi.getInitFxn(MassApp);
+
+export {
+  appInit
+};
+//# sourceMappingURL=chunk-GPY6SBCX.js.map