@sjcrh/proteinpaint-client 2.219.1 → 2.221.0

package/dist/rememberedGvQ.unit.spec-SHTMMZGG.js

@@ -0,0 +1,210 @@
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import {
+  mayShowRememberedGvQ
+} from "./chunk-TVJOSRCH.js";
+import {
+  dtcnv,
+  dtfusionrna,
+  dtsnvindel
+} from "./chunk-WJLRU5OF.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-5R63Q5KH.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// termdb/handlers/test/rememberedGvQ.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+var term = { type: "geneVariant", name: "BCR", genes: [{ kind: "gene", gene: "BCR", name: "BCR" }] };
+var lst = [
+  { label: "BCR-ABL1 fusion / Others", q: { type: "custom-groupset", customset: { groups: [{ name: "BCR-ABL1" }] } } },
+  { label: "BCR-JAK2 fusion / Others", q: { type: "custom-groupset", customset: { groups: [{ name: "BCR-JAK2" }] } } }
+];
+function getQ(dtTerms) {
+  return {
+    type: "custom-groupset",
+    customset: {
+      groups: [
+        {
+          name: "Group 1",
+          filter: {
+            type: "tvslst",
+            join: "and",
+            in: true,
+            lst: dtTerms.map((t) => ({ type: "tvs", tvs: { term: { id: "dt", ...t }, values: [] } }))
+          }
+        }
+      ]
+    }
+  };
+}
+function getVocabApi(remembered) {
+  return remembered ? { getGvQLst: () => structuredClone(remembered) } : {};
+}
+function getHolder() {
+  return select_default("body").append("div");
+}
+(0, import_tape.default)("\n", function(test) {
+  test.comment("-***- termdb/handlers/rememberedGvQ -***-");
+  test.end();
+});
+(0, import_tape.default)("renders the remembered settings of a term", (test) => {
+  const holder = getHolder();
+  const shown = mayShowRememberedGvQ({
+    holder,
+    vocabApi: getVocabApi(lst),
+    term,
+    skipLabel: "Continue without one",
+    callback: () => {
+    }
+  });
+  test.equal(shown, true, "should report that the caller must wait for a choice");
+  test.equal(holder.style("display"), "block", "should show the holder");
+  const options = holder.selectAll(".sja_menuoption").nodes();
+  test.deepEqual(
+    options.map((n) => n.textContent),
+    ["BCR-ABL1 fusion / Others", "BCR-JAK2 fusion / Others", "Continue without one"],
+    "should offer each setting, then the way to decline them"
+  );
+  test.equal(
+    holder.selectAll('[data-testid="sjpp-genevariant-rememberedQ"]').size(),
+    2,
+    "should mark only the remembered settings"
+  );
+  test.ok(
+    options.every((n) => n.getAttribute("tabindex") == "0" && n.getAttribute("role") == "button"),
+    "should make every option keyboard operable"
+  );
+  test.equal(document.activeElement, options[0], "should focus the most recent setting");
+  options[0].dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowUp", bubbles: true }));
+  test.equal(document.activeElement, options[2], "should wrap when arrowing past the first option");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("orders the settings by the selected mutation type", (test) => {
+  const cnvEntry = { label: "CNV groups", q: getQ([{ dt: dtcnv }]) };
+  const snvindelEntry = { label: "Somatic SNV/indel groups", q: getQ([{ dt: dtsnvindel, origin: "somatic" }]) };
+  const allelicEntry = { label: "Bi-allelic / Mono-allelic", q: getQ([{ dt: dtsnvindel }, { dt: dtcnv }]) };
+  const remembered = [cnvEntry, snvindelEntry, allelicEntry];
+  const getLabels = (holder) => holder.selectAll(".sja_menuoption").nodes().map((n) => n.textContent);
+  {
+    const holder = getHolder();
+    mayShowRememberedGvQ({
+      holder,
+      vocabApi: getVocabApi(remembered),
+      term,
+      mutationType: { dt: dtsnvindel },
+      skipLabel: "Continue with SNV/indel",
+      callback: () => {
+      }
+    });
+    test.deepEqual(
+      getLabels(holder),
+      ["Somatic SNV/indel groups", "CNV groups", "Bi-allelic / Mono-allelic", "Continue with SNV/indel"],
+      "should lead with the setting built for the selected mutation type, keeping the rest in order"
+    );
+    test.equal(
+      document.activeElement,
+      holder.selectAll(".sja_menuoption").nodes()[0],
+      "should focus the leading setting"
+    );
+    holder.remove();
+  }
+  {
+    const holder = getHolder();
+    mayShowRememberedGvQ({
+      holder,
+      vocabApi: getVocabApi(remembered),
+      term,
+      mutationType: { dts: [dtsnvindel, dtcnv] },
+      skipLabel: "Continue with Bi/mono-allelic",
+      callback: () => {
+      }
+    });
+    test.deepEqual(
+      getLabels(holder)[0],
+      "Bi-allelic / Mono-allelic",
+      "should lead with the setting filtering by the same dts as a multi-dt mutation type"
+    );
+    holder.remove();
+  }
+  {
+    const holder = getHolder();
+    mayShowRememberedGvQ({
+      holder,
+      vocabApi: getVocabApi(remembered),
+      term,
+      mutationType: { dt: dtfusionrna },
+      skipLabel: "Continue with Fusion RNA",
+      callback: () => {
+      }
+    });
+    test.deepEqual(
+      getLabels(holder),
+      ["Continue with Fusion RNA", "CNV groups", "Somatic SNV/indel groups", "Bi-allelic / Mono-allelic"],
+      "should lead with the mutation type when nothing was remembered for it"
+    );
+    test.equal(
+      document.activeElement,
+      holder.selectAll(".sja_menuoption").nodes()[0],
+      "should focus the way to continue with the mutation type"
+    );
+    test.equal(
+      holder.selectAll('[data-testid="sjpp-genevariant-rememberedQ"]').size(),
+      3,
+      "should still mark only the remembered settings"
+    );
+    holder.remove();
+  }
+  test.end();
+});
+(0, import_tape.default)("picks a setting, or declines them", (test) => {
+  const picked = [];
+  const holder = getHolder();
+  mayShowRememberedGvQ({
+    holder,
+    vocabApi: getVocabApi(lst),
+    term,
+    skipLabel: "Continue without one",
+    callback: (q) => {
+      picked.push(q);
+    }
+  });
+  const options = holder.selectAll(".sja_menuoption").nodes();
+  options[1].dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+  test.deepEqual(picked[0], lst[1].q, "should call back with the q of the picked setting");
+  options[2].click();
+  test.equal(picked[1], void 0, "should call back with nothing when the settings are declined");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("renders nothing when there is nothing to offer", (test) => {
+  const holder = getHolder();
+  test.equal(
+    mayShowRememberedGvQ({ holder, vocabApi: getVocabApi(), term, skipLabel: "x", callback: () => {
+    } }),
+    false,
+    "should offer nothing in a host app that does not remember settings"
+  );
+  test.equal(
+    mayShowRememberedGvQ({ holder, vocabApi: getVocabApi([]), term, skipLabel: "x", callback: () => {
+    } }),
+    false,
+    "should offer nothing when the term has none remembered"
+  );
+  mayShowRememberedGvQ({ holder, vocabApi: getVocabApi(lst), term, skipLabel: "x", callback: () => {
+  } });
+  mayShowRememberedGvQ({ holder, vocabApi: getVocabApi(), term, skipLabel: "x", callback: () => {
+  } });
+  test.equal(holder.selectAll(".sja_menuoption").size(), 0, "should clear options left from a previous gene");
+  test.equal(holder.style("display"), "none", "should hide the holder again");
+  holder.remove();
+  test.end();
+});
+//# sourceMappingURL=rememberedGvQ.unit.spec-SHTMMZGG.js.map

package/dist/render-7UZSGX3Q.js

@@ -0,0 +1,29 @@
+import {
+  renderGeomap
+} from "./chunk-C7ROKWV2.js";
+import "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-WXSMUSU7.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import "./chunk-WJLRU5OF.js";
+import "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+export {
+  renderGeomap
+};
+//# sourceMappingURL=render-7UZSGX3Q.js.map

package/dist/report-J7HKTXZ2.js

@@ -0,0 +1,213 @@
+import {
+  PlotBase,
+  controlsInit,
+  downloadSVGsAsPdf
+} from "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import {
+  importPlot
+} from "./chunk-WXSMUSU7.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import {
+  icons
+} from "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import "./chunk-WJLRU5OF.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/report/view/reportView.ts
+var ReportView = class {
+  constructor(report) {
+    this.opts = report.opts;
+    this.report = report;
+    const leftDiv = this.opts.holder.insert("div").style("display", "inline-block");
+    const controlsHolder = leftDiv.insert("div").style("display", "inline-block");
+    const mainDiv = this.opts.holder.insert("div").style("display", "inline-block").style("vertical-align", "top").style("padding", "20px");
+    const headerDiv = mainDiv.append("div").style("padding", "10px");
+    const downloadDiv = headerDiv.append("div").style("display", "inline-block").style("padding-left", "10px").style("vertical-align", "middle");
+    icons["pdf"](downloadDiv, {
+      handler: () => this.report.downloadReport(),
+      title: "Download the report",
+      width: 20,
+      height: 20
+    });
+    const plotsDiv = mainDiv.append("div");
+    this.dom = {
+      headerDiv,
+      plotsDiv,
+      header: this.opts.header,
+      //holder,
+      controlsHolder
+    };
+    if (this.dom.header) {
+      this.dom.header.html(this.report.config.name || "Summary Report");
+    }
+  }
+  getControlInputs() {
+    const inputs = [];
+    return inputs;
+  }
+};
+
+// plots/report/report.ts
+var Report = class _Report extends PlotBase {
+  constructor(opts, api) {
+    super(opts, api);
+    this.components = {};
+    this.type = _Report.type;
+  }
+  static {
+    this.type = "report";
+  }
+  async init(appState) {
+    this.config = appState.plots.find((p) => p.id === this.id);
+    this.view = new ReportView(this);
+    this.components = { plots: {} };
+    const state = this.getState(appState);
+    for (const section of state.config.sections) {
+      const div = this.view.dom.plotsDiv.append("div");
+      const headerIcon = div.append("span").style("margin-right", "10px").style("cursor", "pointer").text("\u25BC");
+      div.append("div").style("display", "inline-block").style("font-size", "1.2em").style("margin", "10px 0px").style("font-weight", "bold").text(section.name);
+      const sectionDiv = div.append("div").style("margin", "10px").style("display", "flex").style("flex-direction", "row").style("flex-wrap", "wrap").style("width", "100vw");
+      headerIcon.on("click", () => {
+        const display = sectionDiv.style("display");
+        headerIcon.text(display === "none" ? "\u25BC" : "\u25B2");
+        sectionDiv.style("display", display === "none" ? "flex" : "none");
+      });
+      for (const plot of section.plots) {
+        if (this.components.plots[plot.id]) continue;
+        await this.setPlot(plot, sectionDiv);
+      }
+    }
+  }
+  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 {
+      config,
+      plots: appState.plots.filter((p) => p.parentId === this.id),
+      //this property is needed to indicate that child plots need to be added to the appState plots
+      termfilter: appState.termfilter,
+      vocab: appState.vocab,
+      termdbConfig: appState.termdbConfig
+    };
+  }
+  async main() {
+    this.config = structuredClone(this.state.config);
+    this.settings = this.config.settings.report;
+  }
+  async setPlot(plot, sectionDiv) {
+    const plotDiv = sectionDiv.append("div").style("display", "inline-block").style("margin", "10px");
+    const headerDiv = plotDiv.append("div");
+    const headerIcon = headerDiv.append("span").style("margin", "10px").style("cursor", "pointer").text("\u25BC");
+    const header = headerDiv.append("div").style("display", "inline-block").style("font-size", "1.1em").style("margin-top", "10px");
+    headerIcon.on("click", () => {
+      const display = holder.style("display");
+      headerIcon.text(display === "none" ? "\u25BC" : "\u25B2");
+      holder.style("display", display === "none" ? "block" : "none");
+    });
+    const holder = plotDiv.append("div");
+    const opts = structuredClone(plot);
+    opts.header = header;
+    opts.holder = holder;
+    opts.app = this.app;
+    opts.parentId = this.id;
+    const { componentInit: componentInit2 } = await importPlot(opts.chartType);
+    this.components.plots[opts.id] = await componentInit2(opts);
+  }
+  async setControls() {
+    this.view.dom.controlsHolder.selectAll("*").remove();
+    const inputs = this.view.getControlInputs();
+    this.components = {
+      controls: await controlsInit({
+        app: this.app,
+        id: this.id,
+        holder: this.view.dom.controlsHolder,
+        inputs
+      })
+    };
+  }
+  getChartImages() {
+    const chartImagesAll = [];
+    for (const section of this.config.sections) {
+      for (const plotConfig of section.plots) {
+        const plot = this.components.plots[plotConfig.id];
+        if (plot?.getChartImages) {
+          const chartImages = plot.getChartImages();
+          for (const chartImage of chartImages) {
+            if (chartImage.name.trim()) chartImage.name = `${section.name} / ${chartImage.name}`;
+            else chartImage.name = section.name;
+            chartImagesAll.push(chartImage);
+          }
+        }
+      }
+    }
+    return chartImagesAll;
+  }
+  async downloadReport() {
+    const chartImagesAll = this.getChartImages();
+    const globalFilterImg = await this.app.getComponents("nav.filter").getFilterImage();
+    const filterImg = await this.opts.getFilterImage();
+    const filterImgs = [];
+    if (globalFilterImg) filterImgs.push(globalFilterImg);
+    if (filterImg) filterImgs.push(filterImg);
+    downloadSVGsAsPdf(chartImagesAll, "report", "landscape", filterImgs);
+  }
+};
+async function getPlotConfig(opts, app) {
+  const settings = getDefaultReportSettings();
+  const plot = {
+    settings: {
+      controls: {
+        isOpen: false
+        // control panel is hidden by default
+      },
+      report: settings,
+      startColor: {},
+      //dict to store the start color of the gradient for each chart when using continuous color
+      stopColor: {}
+      //dict to store the stop color of the gradient for each chart when using continuous color
+    }
+  };
+  try {
+    const config = app.vocabApi?.termdbConfig?.plotConfigByCohort?.default?.report;
+    opts.filter = app.vocabApi?.termdbConfig?.authFilter;
+    copyMerge(plot, config, opts);
+    return plot;
+  } catch (e) {
+    console.log(e);
+    throw `${e} [sampleScatter getPlotConfig()]`;
+  }
+}
+var reportInit = getCompInit(Report);
+var componentInit = reportInit;
+function getDefaultReportSettings() {
+  return {};
+}
+export {
+  Report,
+  componentInit,
+  getDefaultReportSettings,
+  getPlotConfig,
+  reportInit
+};
+//# sourceMappingURL=report-J7HKTXZ2.js.map

package/dist/sampleView-6547OUIM.js

@@ -0,0 +1,39 @@
+import {
+  componentInit,
+  getPlotConfig,
+  getSamplesRelated,
+  getTermValue,
+  sampleViewInit,
+  searchSampleInput
+} from "./chunk-IFPRYTS7.js";
+import "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-WXSMUSU7.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import "./chunk-WJLRU5OF.js";
+import "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+export {
+  componentInit,
+  getPlotConfig,
+  getSamplesRelated,
+  getTermValue,
+  sampleViewInit,
+  searchSampleInput
+};
+//# sourceMappingURL=sampleView-6547OUIM.js.map

package/dist/samplelst-UHF23UEB.js

@@ -0,0 +1,114 @@
+import {
+  getPillNameDefault,
+  renderTable
+} from "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-WXSMUSU7.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import "./chunk-WJLRU5OF.js";
+import "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// termsetting/handlers/samplelst.ts
+function getHandler(self) {
+  return {
+    showEditMenu(div) {
+      div.selectAll("*").remove();
+      const q = self.q;
+      const groups = q.groups.filter((g) => Array.isArray(g.values));
+      for (const group of q.groups) {
+        if (groups.includes(group)) continue;
+        const row = div.append("div").style("padding", "6px 10px").style("font-size", "0.8rem");
+        row.append("b").text(group.name);
+        if (Number.isFinite(group.sampleCount)) row.append("span").text(`, n=${group.sampleCount}`);
+      }
+      if (!groups.length) return;
+      if (self.vocabApi.termdbConfig?.displaySampleIds && self.vocabApi.hasVerifiedToken()) {
+        for (const group of groups) {
+          const groupDiv = div.append("div").style("display", "inline-block").style("vertical-align", "top");
+          const noButtonCallback = (i, node) => {
+            group.values[i].checked = node.checked;
+          };
+          const name = group.in ? group.name : `${group.name} will exclude these samples`;
+          addTable(groupDiv, name, group, noButtonCallback);
+        }
+        div.append("div").style("padding", "6px").append("button").attr("data-testid", "sjpp-ts-samplelst-apply").text("Apply").on("click", () => {
+          for (const group of groups)
+            group.values = group.values.filter((value) => !("checked" in value) || value.checked);
+          self.api.runCallback();
+        });
+      } else {
+        const e = self.vocabApi.tokenVerificationPayload;
+        const missingAccess = e?.error == "Missing access" && self.vocabApi.termdbConfig.dataDownloadCatch?.missingAccess;
+        const message = e && missingAccess?.message?.replace("MISSING-ACCESS-LINK", missingAccess?.links[e.linkKey || ""]);
+        const helpLink = self.vocabApi.termdbConfig?.dataDownloadCatch?.helpLink;
+        div.append("div").style("color", "#e44").style("padding", "10px").html(
+          message || (self.vocabApi.tokenVerificationMessage || "Requires sign-in") + (helpLink ? ` <a href='${helpLink}' target=_blank>Tutorial</a>` : "")
+        );
+      }
+    },
+    getPillStatus() {
+    },
+    getPillName(d) {
+      return getPillNameDefault(self, d);
+    }
+  };
+}
+function addTable(div, name, group, noButtonCallback) {
+  div.style("padding", "6px").append("div").style("margin", "10px").style("font-size", "0.8rem").html(`<b> ${name}</b>.`);
+  const rows = [];
+  for (const value of group.values) rows.push([{ value: value.sample }]);
+  const columns = [{ label: "Sample" }];
+  renderTable({
+    rows,
+    columns,
+    div,
+    maxWidth: "30vw",
+    maxHeight: "40vh",
+    noButtonCallback,
+    striped: false,
+    showHeader: false,
+    selectAll: true,
+    columnButtons: void 0,
+    //Leave until table.js is typed
+    buttons: void 0
+  });
+}
+async function fillTW(tw, vocabApi) {
+  if (!tw.q.groups) tw.q.groups = [];
+  if (tw.q.groups.length == 0 && Object.values(tw.term.values || {}).some((v) => !Array.isArray(v.list))) {
+    const customTws = await vocabApi?.getCustomTerms?.() || [];
+    const customTw = customTws.find((t) => t.term.type == "samplelst" && t.term.name == tw.term.name);
+    if (customTw?.q?.groups?.length) tw.q.groups = structuredClone(customTw.q.groups);
+  }
+  if (tw.q.groups.length == 0) {
+    for (const k in tw.term.values) {
+      const v = tw.term.values[k];
+      tw.q.groups.push({
+        name: k,
+        inuse: v.inuse,
+        values: v.list
+      });
+    }
+  }
+}
+export {
+  fillTW,
+  getHandler
+};
+//# sourceMappingURL=samplelst-UHF23UEB.js.map