@sjcrh/proteinpaint-client 2.219.1 → 2.220.0

package/dist/chunk-6BBUIRHA.js

@@ -0,0 +1,123 @@
+import {
+  pickCollectionFraction,
+  renderTable
+} from "./chunk-PEKCVKJK.js";
+
+// termdb/handlers/termCollection.ts
+var SearchHandler = class {
+  async init(opts) {
+    this.callback = opts.callback;
+    this.app = opts.app;
+    opts.holder.style("display", "");
+    const termlst = opts.details.termlst ?? [];
+    const memberType = opts.details.memberType || opts.details.type;
+    if (opts.termCollectionSelectionMode === "fraction" && memberType === "numeric") {
+      pickCollectionFraction({
+        holder: opts.holder,
+        term: makeTerm(opts.details, termlst, opts.usecase),
+        callback: (tw) => opts.callback(tw)
+      });
+      return;
+    }
+    const tableDiv = opts.holder.append("div");
+    renderTable({
+      columns: [{ label: "VARIABLES" }],
+      rows: termlst.map((t) => {
+        return [{ value: t.name }];
+      }),
+      div: tableDiv,
+      maxWidth: "30vw",
+      maxHeight: "40vh",
+      // the button is disabled while the selection cannot be submitted
+      noButtonCallback: () => updateSelectBtn(),
+      striped: false,
+      showHeader: true,
+      //false,
+      selectAll: true,
+      columnButtons: void 0,
+      //Leave until table.js is typed
+      buttons: void 0
+    });
+    let categoryTable;
+    let ckSource = [];
+    if (opts.details.categoryKeys) {
+      ckSource = opts.details.categoryKeys;
+      const categoryDiv = opts.holder.append("div").style("margin-top", "15px");
+      const values = opts.details.termlst[0].values || {};
+      categoryTable = categoryDiv.append("div");
+      renderTable({
+        columns: [{ label: "CATEGORIES" }],
+        rows: ckSource.map((ck) => {
+          return [{ value: values[ck.key]?.label ?? ck.key, checked: ck.shown }];
+        }),
+        div: categoryTable,
+        maxWidth: "30vw",
+        maxHeight: "40vh",
+        noButtonCallback: () => updateSelectBtn(),
+        striped: false,
+        showHeader: true,
+        //false,
+        selectAll: true,
+        columnButtons: void 0,
+        //Leave until table.js is typed
+        buttons: void 0
+      });
+    }
+    function getRowChecks(div) {
+      const trs = div.select("table").select("tbody").node().querySelectorAll("tr");
+      return [...trs].map((tr) => tr.querySelectorAll("td")[1]?.querySelector("input")?.checked === true);
+    }
+    function getSelectedTermlst() {
+      const checked = getRowChecks(tableDiv);
+      return termlst.filter((term, i) => checked[i]);
+    }
+    function getCategoryKeys() {
+      if (!categoryTable) return void 0;
+      const checked = getRowChecks(categoryTable);
+      return ckSource.map((ck, i) => ({ key: ck.key, shown: checked[i] }));
+    }
+    function getSelectionError() {
+      if (getSelectedTermlst().length < 2) return "Select at least two variables.";
+      if (getCategoryKeys()?.every((ck) => !ck.shown)) return "Select at least one category.";
+      return void 0;
+    }
+    function updateSelectBtn() {
+      if (!selectBtn) return;
+      const error = getSelectionError();
+      selectBtn.property("disabled", Boolean(error)).attr("title", error || null);
+    }
+    const selectBtn = opts.holder.append("div").style("float", "right").style("padding", "6px 20px").append("button").attr("data-testid", "sjpp-term-collection-select").text("Select").on("click", () => {
+      opts.callback({
+        // makeTerm() extracts propsByTermId (color, etc) for the selected terms
+        ...makeTerm(opts.details, getSelectedTermlst(), opts.usecase),
+        categoryKeys: getCategoryKeys()
+      });
+    });
+    updateSelectBtn();
+  }
+};
+function makeTerm(details, termlst, usecase) {
+  const propsByTermId = {};
+  if (details.propsByTermId) {
+    for (const term of termlst) {
+      if (details.propsByTermId[term.id]) propsByTermId[term.id] = details.propsByTermId[term.id];
+    }
+  }
+  return {
+    type: "termCollection",
+    termIds: termlst.map((term) => term.id),
+    termlst,
+    name: details.name,
+    valueTransform: details.valueTransformByPlots?.[usecase?.target],
+    // memberType = ds.cohort.termdb.termCollections[].type for client code
+    memberType: details.memberType || details.type,
+    categoryKeys: details.categoryKeys,
+    isleaf: true,
+    propsByTermId
+  };
+}
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-6BBUIRHA.js.map

package/dist/chunk-6DESNDD5.js

@@ -0,0 +1,468 @@
+import {
+  getDefaultScatterSettings
+} from "./chunk-C7KUMZQM.js";
+import {
+  getDefaultViolinSettings
+} from "./chunk-FZYVPRVQ.js";
+import {
+  getDefaultBoxplotSettings
+} from "./chunk-K2ARLT2A.js";
+import {
+  PlotBase,
+  Tabs,
+  defaultUiLabels,
+  fillTermWrapper,
+  filterRxCompInit,
+  getCurrentCohortChartTypes,
+  getDefaultBarSettings,
+  getDefaultFractionBins,
+  getT0T2defaultQ
+} from "./chunk-PEKCVKJK.js";
+import {
+  importPlot
+} from "./chunk-YR6EXI2K.js";
+import {
+  Menu
+} from "./chunk-CNFTQSNE.js";
+import {
+  isNumericTw
+} from "./chunk-JHLF2ZC2.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-HBNB5TRH.js";
+
+// plots/summary.ts
+var SummaryPlot = class _SummaryPlot extends PlotBase {
+  constructor(opts, api) {
+    super(opts, api);
+    this.components = {};
+    // expected class-specific props
+    this.chartsByType = {};
+    this.configTermKeys = ["term", "term0", "term2"];
+    this.type = _SummaryPlot.type;
+    this.dom = this.getDom(opts);
+    this.tabsData = this.getTabsData();
+    this.chartToggles = new Tabs({ holder: this.dom.chartToggles, tabs: this.tabsData, noContent: true });
+    this.components = {
+      plots: {}
+    };
+  }
+  static {
+    this.type = "summary";
+  }
+  preApiFreeze(api) {
+    api.getError = () => {
+      return this.error;
+    };
+  }
+  getDom(opts) {
+    const holder = opts.holder;
+    holder.header.style("padding", 0);
+    const paneTitleDiv = holder.header.append("div").style("display", "inline-block").style("color", "#555").style("padding-left", "7px");
+    return {
+      tip: new Menu({ padding: "0px" }),
+      holder,
+      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").attr("class", "sja_errorbar").style("display", "none").style("padding", "5px"),
+      loading: holder.body.append("div").style("display", "none").style("padding", "5px").html("Loading ..."),
+      // dom.viz will hold the rendered view
+      viz: holder.body.append("div"),
+      plotDivs: {},
+      paneTitleDiv,
+      paneTitleText: paneTitleDiv.append("div").classed("sjpp-term-header", true).style("display", "inline-block").style("vertical-align", "sub"),
+      chartToggles: paneTitleDiv.append("div").style("display", "inline-block").style("margin-left", "10px"),
+      localRecoverDiv: paneTitleDiv.append("div").style("display", "inline-block"),
+      filterDiv: holder.header.append("div").style("display", "inline-block").style("zoom", 0.9)
+    };
+  }
+  getTabsData() {
+    const callback = (event, tab) => this.tabClickCallback(event, tab);
+    return [
+      {
+        childType: "barchart",
+        label: "Barchart",
+        isVisible: () => true,
+        disabled: () => false,
+        getConfig: async () => {
+          if (!this.config) return;
+          const config = { id: this.id, childType: "barchart" };
+          const { term, term2 } = this.config || {};
+          if (term) {
+            const mode = isNumericTw(term) ? "discrete" : term?.q.mode || "discrete";
+            config.term = await this.getWrappedTermCopy(term, mode);
+          }
+          if (term2) {
+            const mode = isNumericTw(term2) ? "discrete" : term2.q.mode || "discrete";
+            config.term2 = await this.getWrappedTermCopy(term2, mode);
+          }
+          return config;
+        },
+        active: true,
+        callback
+      },
+      {
+        childType: "violin",
+        label: "Violin",
+        disabled: () => false,
+        isVisible: () => isNumericTw(this.config?.term) || isNumericTw(this.config?.term2),
+        getConfig: async () => {
+          const term = this.config?.term;
+          const term2 = this.config.term2;
+          let _term, _term2;
+          this.violinContTerm = isNumericTw(term) ? "term" : "term2";
+          if (this.violinContTerm && this.violinContTerm === "term" || term.q?.mode == "continuous") {
+            _term = await this.getWrappedTermCopy(term, "continuous");
+            _term2 = await this.getWrappedTermCopy(term2, "discrete");
+            this.violinContTerm = "term";
+          } else if (this.violinContTerm && this.violinContTerm === "term2" || term2?.q?.mode == "continuous") {
+            _term = await this.getWrappedTermCopy(term, "discrete");
+            _term2 = await this.getWrappedTermCopy(term2, "continuous");
+            this.violinContTerm = "term2";
+          } else if (term2?.q?.mode == "discrete") {
+            _term = await this.getWrappedTermCopy(term, "discrete");
+            _term2 = await this.getWrappedTermCopy(term2, "continuous");
+            this.violinContTerm = "term2";
+          } else {
+            _term = await this.getWrappedTermCopy(term, "continuous");
+            _term2 = await this.getWrappedTermCopy(term2, "discrete");
+            this.violinContTerm = "term";
+          }
+          const config = { childType: "violin", term: _term, term2: _term2 };
+          return config;
+        },
+        active: false,
+        callback
+      },
+      {
+        childType: "boxplot",
+        label: "Boxplot",
+        disabled: () => false,
+        isVisible: () => isNumericTw(this.config?.term) || isNumericTw(this.config?.term2),
+        getConfig: async () => {
+          const _term = this.config?.term;
+          const _term2 = this.config.term2;
+          let termMode = "continuous", term2Mode = "discrete";
+          this.boxContTerm = isNumericTw(_term) ? "term" : "term2";
+          if (this.boxContTerm && this.boxContTerm === "term" || _term.q?.mode == "continuous") {
+            termMode = "continuous";
+            term2Mode = "discrete";
+            this.boxContTerm = "term";
+          } else if (this.boxContTerm && this.boxContTerm === "term2" || _term2?.q?.mode == "continuous") {
+            termMode = "discrete";
+            term2Mode = "continuous";
+            this.boxContTerm = "term2";
+          } else if (_term2?.q?.mode == "discrete") {
+            termMode = "discrete";
+            term2Mode = "continuous";
+            this.boxContTerm = "term2";
+          }
+          const term = await this.getWrappedTermCopy(_term, termMode);
+          const term2 = await this.getWrappedTermCopy(_term2, term2Mode);
+          const config = {
+            childType: "boxplot",
+            term,
+            term2
+          };
+          return config;
+        },
+        active: false,
+        callback
+      },
+      {
+        childType: "sampleScatter",
+        label: "Scatter",
+        disabled: () => false,
+        isVisible: () => isScatterToggleVisible(this.app.getState(), this.config?.term, this.config?.term2),
+        getConfig: async () => {
+          const _term = await this.getWrappedTermCopy(this.config?.term, "continuous");
+          const _term2 = await this.getWrappedTermCopy(this.config?.term2, "continuous");
+          const config = {
+            childType: "sampleScatter",
+            term: _term,
+            term2: _term2,
+            groups: [],
+            term0: this.config.term0
+          };
+          return config;
+        },
+        active: false,
+        callback
+      }
+    ];
+  }
+  async init(appState) {
+    const state = this.getState(appState);
+    const config = structuredClone(state.config);
+    this.initUi(this.opts, config);
+    if (config?.hidePlotFilter) return;
+    this.components.filter = await filterRxCompInit({
+      app: this.app,
+      vocabApi: this.app.vocabApi,
+      parentId: this.id,
+      holder: this.dom.filterDiv,
+      hideLabel: true,
+      emptyLabel: "+Add new filter",
+      callback: (filter) => {
+        this.app.dispatch({
+          id: this.id,
+          type: "plot_edit",
+          config: { filter }
+        });
+      }
+    });
+  }
+  reactsTo(action) {
+    if (action.type.startsWith("plot_")) {
+      if (action.type.startsWith("plot_")) {
+        return action.id === this.id || action.id == this.parentId;
+      }
+    }
+    if (action.type.startsWith("filter")) return true;
+    if (action.type.startsWith("cohort")) return true;
+    if (action.type == "app_refresh") return true;
+    return false;
+  }
+  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,
+      // quick fix to skip history tracking as needed
+      _scope_: appState._scope_
+    };
+  }
+  async main() {
+    delete this.error;
+    this.dom.errdiv.style("display", "none").html("");
+    this.dom.loading.style("display", "");
+    this.config = await this.getMutableConfig();
+    this.maySetSandboxHeader();
+    if (!this.components.plots[this.config.childType]) {
+      await this.setComponent(this.config);
+    }
+    this.dom.loading.style("display", "none");
+    this.render();
+    const activeTabIndex = this.tabsData.findIndex((tab) => tab.childType == this.config.childType);
+    this.chartToggles.update(activeTabIndex);
+    const numVisTabs = this.tabsData.filter((d) => d.isVisible()).length;
+    if (numVisTabs > 1) this.dom.chartToggles.style("display", "inline-block");
+    else this.dom.chartToggles.style("display", "none");
+  }
+  maySetSandboxHeader() {
+    const { term, term2, headerText, assayCohortTitle } = this.config;
+    const mainTerm = term.getTitleText?.() || term.term.name;
+    const _headerPretext = headerText ? `${headerText} ` : "";
+    const _headerSuffix = assayCohortTitle ? ` (${assayCohortTitle})` : "";
+    const titleBase = mainTerm + _headerSuffix;
+    if (term2?.type) {
+      this.dom.paneTitleText.text(`${_headerPretext}${term2.getTitleText?.() || term2.term.name} vs ${titleBase}`);
+    } else {
+      this.dom.paneTitleText.text(`${_headerPretext}${titleBase}`);
+    }
+  }
+  async setComponent(config) {
+    const _ = await importPlot(config.childType, `unsupported childType='${config.childType}'`);
+    this.dom.plotDivs[config.childType] = this.dom.viz.append("div");
+    const componentOpts = {
+      app: this.app,
+      holder: this.dom.plotDivs[config.childType],
+      id: this.id,
+      parent: this.api
+    };
+    if (config.parentId) componentOpts.parentId = config.parentId;
+    this.components.plots[config.childType] = await _.componentInit(componentOpts);
+  }
+  destroy() {
+    this.dom.holder.app_div.selectAll("*").remove();
+    this.dom.holder.app_div.remove();
+    for (const key in this.dom) {
+      delete this.dom[key];
+    }
+  }
+  initUi(opts, config) {
+    this.dom.paneTitleText.text(config.term.term.name);
+    this.chartToggles.main();
+  }
+  async tabClickCallback(event, tab) {
+    if (!tab || !tab.getConfig) return;
+    let config;
+    try {
+      this.dom.viz.style("display", "none");
+      this.dom.loading.style("display", "");
+      config = await tab.getConfig();
+      this.dom.loading.style("display", "none");
+      this.dom.viz.style("display", "");
+      if (config)
+        this.app.dispatch({
+          type: "plot_edit",
+          id: this.id,
+          config
+        });
+    } catch (e) {
+      this.dom.loading.style("display", "none");
+      this.error = e;
+      this.dom.errdiv.style("display", "").html(`Error: ${e.message || e.error || e}`);
+    }
+  }
+  async getWrappedTermCopy(term, mode) {
+    if (!term) return;
+    const tw = structuredClone(term);
+    tw.q.mode = mode;
+    if (tw.type === "TermCollectionTWFraction") {
+      if (mode === "discrete" && tw.q.type !== "regular-bin" && tw.q.type !== "custom-bin") {
+        tw.q = {
+          mode: "discrete",
+          type: "custom-bin",
+          lst: getDefaultFractionBins(),
+          denominators: tw.q.denominators,
+          numerators: tw.q.numerators
+        };
+      } else if (mode === "continuous") {
+        tw.q = {
+          mode: "continuous",
+          denominators: tw.q.denominators,
+          numerators: tw.q.numerators
+        };
+      }
+    }
+    await fillTermWrapper(tw, this.app.vocabApi);
+    return tw;
+  }
+  render() {
+    for (const childType of Object.keys(this.components.plots)) {
+      const chart = this.components.plots[childType];
+      if (chart.type != this.config.childType) {
+        this.dom.plotDivs[chart.type].style("display", "none");
+      }
+    }
+    this.dom.plotDivs[this.config.childType].style("display", "");
+  }
+  getChartImages() {
+    const chart = this.components.plots[this.config.childType];
+    if (chart?.getChartImages) {
+      return chart.getChartImages();
+    }
+    return null;
+  }
+};
+var summaryInit = getCompInit(SummaryPlot);
+var componentInit = summaryInit;
+async function getPlotConfig(opts, app) {
+  try {
+    await app.opts?.getPlotConfig_mutateSummary?.(opts);
+    if (!opts.term) throw new Error("summary getPlotConfig: opts.term{} missing");
+    opts.term = await fillTermWrapper(
+      opts.term,
+      app.vocabApi,
+      opts.term.q || { geneVariant: { type: "predefined-groupset" } }
+    );
+    if (opts.term2)
+      opts.term2 = await fillTermWrapper(
+        opts.term2,
+        app.vocabApi,
+        opts.term2.bins || opts.term2.q ? void 0 : getT0T2defaultQ()
+      );
+    if (opts.term0)
+      opts.term0 = await fillTermWrapper(
+        opts.term0,
+        app.vocabApi,
+        opts.term0.bins || opts.term0.q ? void 0 : getT0T2defaultQ()
+      );
+    if (opts.colorTW) opts.colorTW = await fillTermWrapper(opts.colorTW, app.vocabApi);
+    if (opts.shapeTW) opts.shapeTW = await fillTermWrapper(opts.shapeTW, app.vocabApi);
+    if (opts.scaleDotTW) opts.scaleDotTW = await fillTermWrapper(opts.scaleDotTW, app.vocabApi);
+  } catch (e) {
+    if (e.stack) console.log(e.stack);
+    throw new Error(`${e} [summary getPlotConfig()]`);
+  }
+  const config = {
+    chartType: "summary",
+    childType: "barchart",
+    term: opts.term,
+    groups: [],
+    controlLabels: Object.assign({}, defaultUiLabels, app.vocabApi.termdbConfig.uiLabels || {}),
+    //Allow hiding the plot filter when appropriate (e.g. single cell summary plots)
+    hidePlotFilter: opts.hidePlotFilter || false,
+    settings: {
+      controls: {
+        isOpen: false
+      },
+      common: {
+        use_logscale: false,
+        // flag for y-axis scale type, 0=linear, 1=log
+        use_percentage: false
+        // Move to barchart settings
+        // barheight: 300, // maximum bar length
+        // barwidth: 20, // bar thickness
+        // barspace: 2 // space between two bars
+      },
+      barchart: getDefaultBarSettings(app),
+      violin: getDefaultViolinSettings(app),
+      boxplot: getDefaultBoxplotSettings(app),
+      sampleScatter: getDefaultScatterSettings(opts)
+    },
+    mayAdjustConfig(config2, edits = {}) {
+      return mayAdjustConfig(config2, opts, edits);
+    }
+  };
+  if (config.term.term.type == "geneVariant") config.settings.barchart.colorBars = true;
+  copyMerge(config, opts);
+  Object.assign(config.controlLabels, app.vocabApi.termdbConfig.uiLabels || {});
+  return config;
+}
+function isScatterToggleVisible(appState, term, term2) {
+  const isSupportedChart = getCurrentCohortChartTypes(appState).includes("dynamicScatter");
+  return isSupportedChart && isNumericTw(term) && isNumericTw(term2);
+}
+var discreteByContinuousPlots = /* @__PURE__ */ new Set(["violin", "boxplot"]);
+function mayAdjustConfig(config, opts, edits = {}) {
+  if (edits.childType) {
+    if (config.childType != edits.childType) throw `action.config.childType was not applied in mass store.plot_edit()`;
+    return;
+  }
+  if (config.term?.q?.mode == "continuous" && config.term2?.q?.mode == "continuous") {
+    config.childType = "sampleScatter";
+  } else if (config.term?.term?.type == "termCollection" && config.term?.type !== "TermCollectionTWFraction") {
+    if (config.term.term.memberType == "categorical") {
+      config.childType = "barchart";
+    } else if (config.term.term.memberType == "numeric") {
+      if (config.childType) {
+        if (config.childType == "barchart") {
+          config.childType = "violin";
+        } else {
+        }
+      } else {
+        config.childType = "violin";
+      }
+    } else {
+      throw new Error("config.term.term.memberType not categorical or numeric");
+    }
+  } else if (config.term?.q?.mode == "continuous" || config.term2?.q?.mode == "continuous") {
+    if (!discreteByContinuousPlots.has(config.childType)) {
+      if (opts.childType && !discreteByContinuousPlots.has(opts.childType)) {
+        console.warn(
+          `ignoring summary opts.childType='${opts.childType}' since it does not support plotting discrete by continuous tw's`
+        );
+        config.childType = "violin";
+      } else {
+        config.childType = opts.childType || "violin";
+      }
+    }
+  } else {
+    config.childType = "barchart";
+  }
+}
+
+export {
+  summaryInit,
+  componentInit,
+  getPlotConfig,
+  isScatterToggleVisible,
+  mayAdjustConfig
+};
+//# sourceMappingURL=chunk-6DESNDD5.js.map