@sjcrh/proteinpaint-client 2.214.0 → 2.215.0

package/dist/geneVariant-RTGLL2CG.js

@@ -0,0 +1,289 @@
+import {
+  excludeFilterByTag,
+  fillGroupsetGroups,
+  filterInit,
+  filterPromptInit,
+  getDtTermValues,
+  getNormalRoot,
+  getPillNameDefault,
+  make_radios,
+  renderTable,
+  vocabInit
+} from "./chunk-LEVWXJOQ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-PE5N5AC6.js";
+import "./chunk-PZEM6AII.js";
+import "./chunk-K2QVSMX7.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-A4BTSAIY.js";
+import "./chunk-J3AJ4C7O.js";
+import {
+  getDtsFromGroups
+} from "./chunk-VIX2TKWP.js";
+import {
+  getColors
+} from "./chunk-TZRCFVG7.js";
+import "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-6XKAOSQE.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import {
+  rgb
+} from "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// termsetting/handlers/geneVariant.ts
+var colorScale = getColors(5);
+function getHandler(self) {
+  return {
+    getPillName(d) {
+      let name = d.name;
+      if (!name) {
+        if (d.genes) name = d.genes.map((g) => g.gene).join(", ");
+        else if (d.chr) name = `${d.chr}:${d.start}-${d.stop}`;
+        else name = d.id || "geneVariant";
+      }
+      return getPillNameDefault(self, { name });
+    },
+    getPillStatus() {
+      let text;
+      const q = self.q;
+      if (q.type == "predefined-groupset") {
+        const groupsetting = self.term.groupsetting;
+        if (!groupsetting?.lst?.length) throw "no predefined groupsets found";
+        const groupset = groupsetting.lst[q.predefined_groupset_idx];
+        text = groupset.name;
+      } else if (q.type == "custom-groupset") {
+        const n = q.customset.groups.length;
+        text = `Divided into ${n} groups`;
+      } else {
+        text = "any variant class";
+      }
+      if (self.term.sampleTypeLabel) {
+        text += ` (${self.term.sampleTypeLabel})`;
+      }
+      return { text };
+    },
+    async showEditMenu(div) {
+      await makeEditMenu(self, div);
+    }
+  };
+}
+async function makeEditMenu(self, _div) {
+  delete self.groups;
+  const div = _div.append("div").style("margin", "10px");
+  div.append("div").style("font-size", "1.2rem").text(self.term.name);
+  const optsDiv = div.append("div").style("margin-top", "10px").style("margin-bottom", "1px");
+  const groupsDiv = div.append("div").style("display", "none").style("margin", "10px").style("vertical-align", "top");
+  optsDiv.append("div").style("font-weight", "bold").text("Group samples");
+  const q = self.q;
+  const isGroupset = q.type == "predefined-groupset" || q.type == "custom-groupset";
+  make_radios({
+    holder: optsDiv,
+    options: [
+      { label: "No sample grouping", value: "noGroup", checked: !isGroupset },
+      { label: "Assign samples to groups", value: "group", checked: isGroupset }
+    ],
+    callback: async (v) => {
+      if (v == "group") {
+        if (q.type == "values") Object.assign(q, { type: "custom-groupset", customset: { groups: [] } });
+        await makeGroupUI(self, groupsDiv);
+      } else {
+        clearGroupset(self);
+        groupsDiv.style("display", "none");
+      }
+    }
+  });
+  if (isGroupset) await makeGroupUI(self, groupsDiv);
+  if (self.usecase?.detail && ["term", "term0", "term2"].includes(self.usecase.detail) || self.opts.geneVariantEditMenuOnlyGrp) {
+    optsDiv.style("display", "none");
+    groupsDiv.style("margin", "0px");
+  }
+  div.append("div").style("margin-top", "25px").append("button").attr("data-testid", "sjpp-ts-gv-editui-applyBtn").text("Apply").on("click", () => {
+    const q2 = self.q;
+    if (q2.type == "predefined-groupset" || q2.type == "custom-groupset") {
+      if (!self.groups?.length) {
+        window.alert("Samples must be assigned to at least one group.");
+        return;
+      } else {
+        const dtLst = getDtsFromGroups(self.groups);
+        Object.assign(q2, { type: "custom-groupset", customset: { groups: self.groups }, dtLst });
+        self.vocabApi.rememberGvQ?.(self.term, q2);
+      }
+    } else {
+      if (q2.type != "values") throw `q.type must be 'values'`;
+    }
+    self.api.runCallback();
+  });
+}
+async function makeGroupUI(self, div) {
+  div.style("display", "block");
+  div.selectAll("*").remove();
+  div.append("div").style("margin", "15px 0px").text(
+    "Group samples by mutation status. Samples are assigned to first possible group. Only tested samples are considered."
+  );
+  const filterTableDiv = div.append("div");
+  const addNewGroupBtnHolder = div.append("div");
+  const q = self.q;
+  if (q.type != "predefined-groupset" && q.type != "custom-groupset") throw "unexpected q.type";
+  if (!self.groups) {
+    let groupset;
+    if (q.type == "predefined-groupset") {
+      const groupsetting = self.term.groupsetting;
+      if (!groupsetting.lst?.length) throw "no predefined groupsets found";
+      await fillGroupsetGroups(self.term, q.predefined_groupset_idx, self.vocabApi);
+      groupset = groupsetting.lst[q.predefined_groupset_idx];
+    } else {
+      groupset = q.customset;
+    }
+    if (!groupset) throw "groupset is missing";
+    if (!Array.isArray(groupset.groups)) throw "groupset.groups is not array";
+    self.groups = structuredClone(groupset.groups);
+  }
+  const dtTerms = structuredClone(self.term.childTerms);
+  for (const dtTerm of dtTerms) {
+    await getDtTermValues(dtTerm, self.filter, self.vocabApi, { withMnames: true });
+  }
+  const vocabApi = vocabInit({ vocab: { terms: dtTerms } });
+  vocabApi.termdbConfig = { queries: self.vocabApi.termdbConfig.queries };
+  vocabApi.vocab.genome = self.vocabApi.vocab?.genome;
+  const filterPrompt = await filterPromptInit({
+    holder: addNewGroupBtnHolder,
+    vocabApi,
+    emptyLabel: "Add group",
+    header_mode: "hide_search",
+    callback: (f) => {
+      const filter2 = getNormalRoot(f);
+      addNewGroup(filter2, self.groups);
+      makeGroupUI(self, div);
+    },
+    debug: self.opts.debug
+  });
+  const filter = structuredClone(self.filter);
+  filterPrompt.main(excludeFilterByTag(filter, "cohortFilter"));
+  if (!self.groups.length) {
+    filterTableDiv.style("display", "none");
+    return;
+  }
+  filterTableDiv.style("display", "").selectAll("*").remove();
+  const tableArg = {
+    div: filterTableDiv,
+    columns: [
+      {},
+      // blank column to add delete buttons
+      {
+        label: "NAME",
+        editCallback: async (i, cell) => {
+          const newName = cell.value;
+          const index = self.groups.findIndex((group) => group.name == newName);
+          if (index != -1) {
+            alert(`Group named ${newName} already exists`);
+            makeGroupUI(self, div);
+          } else {
+            self.groups[i].name = newName;
+            makeGroupUI(self, div);
+          }
+        }
+      },
+      {
+        label: "COLOR",
+        editCallback: async (i, cell) => {
+          self.groups[i].color = cell.color;
+          makeGroupUI(self, div);
+        }
+      },
+      //{ label: '#SAMPLE' }, // will re-enable when filtered sample count can be supported for gdc
+      { label: "FILTER" }
+    ],
+    rows: [],
+    striped: false,
+    // no alternating row bg color so delete button appears more visible
+    showLines: false
+  };
+  for (const g of self.groups) {
+    tableArg.rows.push([
+      {},
+      // blank cell to add delete button
+      { value: g.name },
+      // to allow click to show <input>
+      { color: g.color },
+      // { value: 'n=' + (await self.vocabApi.getFilteredSampleCount(g.filter)) }, // will re-enable when filtered sample count can be supported for gdc
+      {}
+      // blank cell to show filter ui
+    ]);
+  }
+  renderTable(tableArg);
+  for (const [i, row] of tableArg.rows.entries()) {
+    row[0].__td.append("div").attr("class", "sja_menuoption").style("padding", "1px 6px").html("&times;").on("click", () => {
+      self.groups.splice(i, 1);
+      makeGroupUI(self, div);
+    });
+    const group = self.groups[i];
+    filterInit({
+      holder: row[3].__td,
+      vocabApi,
+      header_mode: "hide_search",
+      callback: (f) => {
+        if (!f || f.lst.length == 0) {
+          const i2 = self.groups.findIndex((g) => g.name == group.name);
+          self.groups.splice(i2, 1);
+        } else {
+          excludeGeneNameFromFilter(f);
+          group.filter = f;
+        }
+        makeGroupUI(self, div);
+      }
+    }).main(group.filter);
+  }
+}
+function addNewGroup(filter, groups, name) {
+  if (!groups) throw "groups is missing";
+  if (!name) {
+    const base = "New group";
+    name = base;
+    for (let i = 0; ; i++) {
+      name = base + (i === 0 ? "" : " " + i);
+      if (!groups.find((g) => g.name === name)) break;
+    }
+  }
+  excludeGeneNameFromFilter(filter);
+  const newGroup = {
+    name,
+    type: "filter",
+    filter,
+    color: rgb(colorScale(groups.length)).formatHex()
+  };
+  groups.push(newGroup);
+}
+function excludeGeneNameFromFilter(filter) {
+  for (const item of filter.lst) {
+    if (item.type == "tvslst") {
+      excludeGeneNameFromFilter(item);
+    } else if (item.type == "tvs") {
+      item.tvs.excludeGeneName = true;
+    } else {
+      throw "unexpected item.type";
+    }
+  }
+}
+function clearGroupset(self) {
+  self.q.type = "values";
+  delete self.q.predefined_groupset_idx;
+  delete self.q.customset;
+  delete self.q.dtLst;
+  self.q.hiddenValues = {};
+}
+export {
+  getHandler
+};
+//# sourceMappingURL=geneVariant-RTGLL2CG.js.map