@sjcrh/proteinpaint-client 2.224.0 → 2.224.1

package/dist/DE-A327BZNW.js

@@ -0,0 +1,85 @@
+import {
+  appInit
+} from "./chunk-2FTQ5RMP.js";
+import "./chunk-IW5XJT3H.js";
+import "./chunk-C7KUMZQM.js";
+import "./chunk-TZVSDB7S.js";
+import "./chunk-ZV7LZY67.js";
+import "./chunk-FZYVPRVQ.js";
+import "./chunk-4E2F26CC.js";
+import "./chunk-FE5TCBIT.js";
+import "./chunk-K2ARLT2A.js";
+import "./chunk-O6T4SDC7.js";
+import "./chunk-3YQYWX4M.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-R3RD3VEX.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-KBTFT76L.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";
+
+// gdc/DE.ts
+async function init(arg, holder, genomes) {
+  const useGenome = arg.genome || "hg38";
+  const useDslabel = arg.dslabel || "GDC";
+  const genome = genomes[useGenome];
+  const massApi = await appInit({
+    //debug: arg.debugmode, // is debug accepted?
+    genome,
+    holder,
+    state: {
+      genome: useGenome,
+      dslabel: useDslabel,
+      termfilter: { filter0: arg.filter0 },
+      nav: { activeTab: 1, header_mode: "hidden" },
+      // an embedder may supply prebuilt groups, see config.groups[] in plots/DEinput.ts
+      plots: arg.state?.plots || [{ chartType: "DEinput" }]
+    },
+    opts: Object.assign(
+      {
+        // todo additional customizations
+        // dictionary:{header:'Select a variable to build Correlation Plot'}
+        // some way to make gene exp violin/boxplot to use log scale by default, but numeric dict term should not
+      },
+      arg.opts || {}
+    ),
+    app: arg.opts?.app || {}
+  });
+  const api = {
+    update: async (updateArg) => {
+      if (!massApi) return;
+      if ("filter0" in updateArg) {
+        massApi.dispatch({
+          type: "app_refresh",
+          subactions: [
+            {
+              type: "filter_replace",
+              filter0: updateArg.filter0
+            }
+          ]
+        });
+      }
+    },
+    triggerAbort: (reason = "") => massApi.triggerAbort(reason)
+  };
+  return api;
+}
+export {
+  init
+};
+//# sourceMappingURL=DE-A327BZNW.js.map

package/dist/DEinput-VKRBFYUE.js

@@ -0,0 +1,479 @@
+import {
+  rehydrateFilter
+} from "./chunk-FE5TCBIT.js";
+import {
+  PlotBase,
+  Tabs,
+  excludeFilterByTag,
+  filterInit,
+  filterJoin,
+  filterPromptInit,
+  getNormalRoot,
+  getSamplelstTWFromFilters,
+  make_radios,
+  negateFilter,
+  renderPreAnalysisData,
+  renderTable
+} from "./chunk-3YQYWX4M.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-R3RD3VEX.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import {
+  dofetch3
+} from "./chunk-KBTFT76L.js";
+import {
+  uiLabel
+} from "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import {
+  termType2label
+} from "./chunk-JHLF2ZC2.js";
+import {
+  TermTypeGroups,
+  TermTypes,
+  getColors
+} from "./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 {
+  color,
+  rgb
+} from "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/DEinput.ts
+var colorScale = getColors(5);
+var DEinputPlot = class _DEinputPlot extends PlotBase {
+  constructor(opts, api) {
+    super(opts, api);
+    this.components = {};
+    this.type = _DEinputPlot.type;
+    this.dom = this.getDom();
+    this.groups = [];
+  }
+  static {
+    this.type = "DEinput";
+  }
+  get isGE() {
+    return this.termType == TermTypes.GENE_EXPRESSION;
+  }
+  getDom() {
+    const header = this.opts?.header || void 0;
+    const holder = this.opts.holder.append("div").style("margin", "10px");
+    const expressionSource = holder.append("div").style("margin-bottom", "15px");
+    const table = holder.append("div");
+    const btns = holder.append("div").style("margin-top", "5px");
+    const addGroup = btns.append("div").style("display", "inline-block");
+    const submit = btns.append("div").style("display", "none").style("margin-left", "15px").attr("class", "sja_new_filter_btn sja_menuoption");
+    const loading = holder.append("div").style("display", "none").style("margin", "20px 10px").text("Loading...");
+    const preAnalysis = holder.append("div").style("display", "none").style("margin-top", "20px").style("margin-left", "5px");
+    const dom = { header, expressionSource, table, addGroup, submit, loading, preAnalysis };
+    return dom;
+  }
+  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 init(appState) {
+    const state = this.getState(appState);
+    this.termType = state.config.termType || TermTypes.GENE_EXPRESSION;
+    this.dom.header?.html(`Differential ${termType2label(this.termType)}`);
+    await this.renderExpressionSourceUI();
+  }
+  // TODO: handle errors
+  async main() {
+    if (!this.state) return;
+    this.dom.preAnalysis.selectAll("*").remove();
+    if (!this.expressionSource || this.expressionSource === "pseudobulk" && !this.pseudobulk) {
+      this.dom.table.style("display", "none");
+      this.dom.addGroup.style("display", "none");
+      this.dom.submit.style("display", "none");
+      return;
+    }
+    this.dom.addGroup.style("display", "inline-block");
+    this.maySeedGroups();
+    this.hasCohort0 = this.groups.some((g) => g.filter.lst.some((item) => item.tvs?.term.type == "cohort"));
+    await this.makeGroupsUI();
+    this.mayRenderSubmit();
+    await this.mayAutoSubmit();
+  }
+  /* config.groups[] lets a caller launch this ui with prebuilt groups, each defined by a mass
+  filter, instead of requiring the user to build both groups by hand. seeded only once: main() reruns
+  on every state change, and a seeded group is editable like any other, so a rerun must not undo a
+  rename, edit, or deletion */
+  maySeedGroups() {
+    if (this.groupsSeeded) return;
+    this.groupsSeeded = true;
+    if (!this.state.config.groups?.length) return;
+    const massFilter = getNormalRoot(excludeFilterByTag(structuredClone(this.state.termfilter.filter), "cohortFilter"));
+    for (const g of this.state.config.groups) {
+      this.addNewGroup(filterJoin([massFilter, getNormalRoot(g.filter)]), this.groups, g.name, g.color);
+    }
+  }
+  /* config.autoSubmit runs the analysis on the seeded groups without waiting for a click, for a caller
+  that already knows the groups to compare. runs only once: main() reruns on every state change, and
+  each run is a round trip to termdb/DE */
+  async mayAutoSubmit() {
+    if (!this.state.config.autoSubmit || this.autoSubmitted) return;
+    if (this.dom.submit.style("display") == "none") return;
+    this.autoSubmitted = true;
+    await this.clickSubmit(this.getSubmitGroups());
+  }
+  /** the groups as compared by the analysis: a lone group is compared against all other samples */
+  getSubmitGroups() {
+    if (this.groups.length != 1) return this.groups;
+    const group = this.groups[0];
+    return [
+      group,
+      {
+        name: "Not in " + group.name,
+        color: "#ccc",
+        filter: negateFilter(group.filter)
+      }
+    ];
+  }
+  async renderExpressionSourceUI() {
+    const config = this.app.vocabApi.termdbConfig;
+    if (!this.isGE) {
+      const dm = config.queries?.dnaMethylation;
+      if (!dm?.promoter && !dm?.elementTypes?.length)
+        throw new Error("No DNA methylation data configured for differential analysis");
+      this.expressionSource = "bulk";
+      return;
+    }
+    const hasBulk = !!config.queries?.rnaseqGeneCount;
+    const terms = config.termType2terms?.[TermTypeGroups.PSEUDOBULK] || [];
+    const hasPseudobulk = terms.length > 0;
+    if (!hasBulk && !hasPseudobulk)
+      throw new Error("No gene expression count data configured for differential analysis");
+    if (hasBulk && !hasPseudobulk) {
+      this.expressionSource = "bulk";
+      return;
+    }
+    if (!hasBulk) {
+      this.expressionSource = "pseudobulk";
+      this.renderPseudobulkSelection(this.dom.expressionSource, terms);
+      return;
+    }
+    const tabs = [
+      {
+        label: "Bulk RNA-seq",
+        active: true,
+        callback: async () => {
+          this.expressionSource = "bulk";
+          await this.main();
+        }
+      },
+      {
+        label: "Single-cell pseudobulk",
+        callback: async (_event, tab) => {
+          this.expressionSource = "pseudobulk";
+          tab.contentHolder.selectAll("*").remove();
+          this.renderPseudobulkSelection(tab.contentHolder, terms);
+          await this.main();
+        }
+      }
+    ];
+    await new Tabs({ holder: this.dom.expressionSource, tabs }).main();
+  }
+  renderPseudobulkSelection(holder, terms) {
+    const assayMap = /* @__PURE__ */ new Map();
+    for (const term of terms) {
+      if (!assayMap.has(term.assay)) assayMap.set(term.assay, /* @__PURE__ */ new Map());
+      const memberMap = assayMap.get(term.assay);
+      if (!memberMap.has(term.memberId)) memberMap.set(term.memberId, []);
+      memberMap.get(term.memberId).push(term);
+    }
+    const renderAssay = (assayHolder, assay, memberMap) => {
+      assayHolder.selectAll("*").remove();
+      const renderMember = (memberHolder, memberId, memberTerms) => {
+        memberHolder.selectAll("*").remove();
+        memberHolder.append("div").style("opacity", 0.7).text(`Select from ${memberId}:`);
+        make_radios({
+          holder: memberHolder,
+          inputName: `sjpp-de-pseudobulk-${this.id}-${assay}-${memberId}`,
+          options: memberTerms.map((term) => ({
+            label: term.name,
+            value: term.id,
+            checked: this.pseudobulk?.assay === assay && this.pseudobulk?.memberId === memberId && this.pseudobulk?.category === (term.category || term.id),
+            testid: `sjpp-de-pseudobulk-category-${term.id}`
+          })),
+          styles: { display: "block", padding: "3px 5px" },
+          callback: async (value) => {
+            const term = memberTerms.find((term2) => term2.id == value);
+            this.pseudobulk = { assay, memberId, category: term.category || term.id };
+            await this.main();
+          }
+        });
+      };
+      if (memberMap.size === 1) {
+        const [memberId, memberTerms] = memberMap.entries().next().value;
+        renderMember(assayHolder, memberId, memberTerms);
+      } else {
+        const memberTabs = Array.from(memberMap, ([memberId, memberTerms]) => ({
+          label: memberId,
+          callback: (_event, tab) => renderMember(tab.contentHolder, memberId, memberTerms)
+        }));
+        new Tabs({ holder: assayHolder, tabs: memberTabs }).main();
+      }
+    };
+    if (assayMap.size === 1) {
+      const [assay, memberMap] = Array.from(assayMap)[0];
+      holder.append("div").text("Single-cell pseudobulk " + termType2label(assay));
+      renderAssay(holder.append("div"), assay, memberMap);
+    } else {
+      const assayTabs = Array.from(assayMap, ([assay, memberMap]) => ({
+        label: termType2label(assay),
+        callback: (_event, tab) => renderAssay(tab.contentHolder, assay, memberMap)
+      }));
+      new Tabs({ holder, tabs: assayTabs, linePosition: "right", tabsPosition: "vertical" }).main();
+    }
+  }
+  async makeGroupsUI() {
+    if (!this.filterPrompt) {
+      this.filterPrompt = await filterPromptInit({
+        holder: this.dom.addGroup,
+        vocabApi: this.app.vocabApi,
+        emptyLabel: "Add group",
+        header_mode: this.opts?.header_mode,
+        callback: async (f) => {
+          const filter2 = getNormalRoot(f);
+          this.addNewGroup(filter2, this.groups);
+          await this.main();
+        },
+        debug: this.opts.debug
+      });
+    }
+    const filter = structuredClone(this.state?.termfilter?.filter);
+    this.filterPrompt.main(excludeFilterByTag(filter, "cohortFilter"));
+    if (!this.groups.length) {
+      this.dom.table.style("display", "none");
+      return;
+    }
+    this.dom.table.style("display", "block").selectAll("*").remove();
+    const tableArg = {
+      div: this.dom.table,
+      columns: [
+        {},
+        // blank column to add delete buttons
+        {
+          label: "NAME",
+          editCallback: async (i, cell) => {
+            const newName = cell.value;
+            const index = this.groups.findIndex((group) => group.name == newName);
+            if (index != -1) {
+              alert(`Group named ${newName} already exists`);
+              await this.main();
+            } else {
+              this.groups[i].name = newName;
+              await this.main();
+            }
+          }
+        },
+        {
+          label: "COLOR",
+          editCallback: async (i, cell) => {
+            this.groups[i].color = cell.color;
+            this.main();
+          }
+        },
+        // dataset may rename what a row counts (GDC: cases, not samples)
+        { label: `#${uiLabel(this.app.vocabApi.termdbConfig?.uiLabels, "Sample", "Sample").toUpperCase()}` },
+        { label: "FILTER" }
+      ],
+      rows: [],
+      striped: false,
+      // no alternating row bg color so delete button appears more visible
+      showLines: false
+    };
+    for (const g of this.groups) {
+      tableArg.rows.push([
+        {},
+        // blank cell to add delete button
+        { value: g.name },
+        // to allow click to show <input>
+        { color: g.color },
+        { value: "" },
+        // filled in asynchronously below, so one slow count does not hold up the table
+        {}
+        // 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", () => {
+        this.groups.splice(i, 1);
+        this.main();
+      });
+      this.app.vocabApi.getFilteredSampleCount(this.groups[i].filter, this.hasCohort0 ? null : this.state.termfilter.filter0).then((n) => row[3].__td.text(n)).catch((e) => row[3].__td.text("n/a").attr("title", e?.message || e));
+      const group = this.groups[i];
+      filterInit({
+        holder: row[4].__td,
+        vocabApi: this.app.vocabApi,
+        header_mode: "hide_search",
+        callback: (f) => {
+          if (!f || f.lst.length == 0) {
+            const i2 = this.groups.findIndex((g) => g.name == group.name);
+            this.groups.splice(i2, 1);
+          } else {
+            group.filter = f;
+          }
+          this.main();
+        }
+      }).main(group.filter);
+    }
+    this.dom.addGroup.select(".sja_new_filter_btn").style("pointer-events", "auto").style("opacity", 1);
+  }
+  addNewGroup(filter, groups, name, color2) {
+    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;
+      }
+    }
+    const newGroup = {
+      name,
+      filter,
+      color: color2 || rgb(colorScale(groups.length)).formatHex()
+    };
+    groups.push(newGroup);
+  }
+  mayRenderSubmit() {
+    if (!this.groups.length || this.groups.length == 1 && this.hasCohort0) {
+      this.dom.submit.style("display", "none");
+      return;
+    }
+    this.dom.submit.style("display", "inline-block");
+    if (this.groups.length == 1) {
+      this.dom.submit.text(`Submit (${this.groups[0].name} vs others)`);
+      this.dom.submit.on("click", async () => {
+        await this.clickSubmit(this.getSubmitGroups());
+      });
+    } else if (this.groups.length == 2) {
+      this.dom.addGroup.select(".sja_new_filter_btn").style("pointer-events", "none").style("opacity", 0.5);
+      this.dom.submit.text(`Submit (${this.groups[0].name} vs ${this.groups[1].name})`);
+      this.dom.submit.on("click", async () => {
+        await this.clickSubmit(this.groups);
+      });
+    } else {
+      throw new Error("cannot exceed 2 groups");
+    }
+  }
+  async clickSubmit(groups) {
+    this.dom.loading.style("display", "block");
+    const filter0 = this.hasCohort0 ? null : this.state.termfilter.filter0;
+    const samplelstTW = getSamplelstTWFromFilters(
+      groups.map((g) => ({
+        name: g.name,
+        color: g.color,
+        filter: filterJoin([g.filter, this.state.termfilter.filter]),
+        filter0,
+        mapParent2Children: true
+        // DE/DM data assumed to be at sample-level so map parent samples to child samples
+      })),
+      groups.map((g) => g.name).join(" vs ")
+    );
+    delete samplelstTW.isAtomic;
+    if (this.expressionSource === "pseudobulk") samplelstTW.pseudobulk = this.pseudobulk;
+    const body = {
+      genome: this.app.vocabApi.vocab.genome,
+      dslabel: this.app.vocabApi.vocab.dslabel,
+      samplelst: { groups: samplelstTW.q.groups },
+      filter: this.state.termfilter.filter,
+      filter0,
+      preAnalysis: true
+    };
+    if (this.expressionSource === "pseudobulk") body.pseudobulk = this.pseudobulk;
+    const preAnalysisData = await dofetch3(this.isGE ? "termdb/DE" : "termdb/diffMeth", { body });
+    this.dom.loading.style("display", "none");
+    this.dom.preAnalysis.style("display", "block").selectAll("*").remove();
+    renderPreAnalysisData({
+      preAnalysisData,
+      samplelstTW,
+      groups: samplelstTW.q.groups,
+      holder: this.dom.preAnalysis,
+      termType: this.termType,
+      self: this
+    });
+  }
+};
+var DEinputInit = getCompInit(DEinputPlot);
+var componentInit = DEinputInit;
+var supportedTermTypes = /* @__PURE__ */ new Set([TermTypes.GENE_EXPRESSION, TermTypes.DNA_METHYLATION]);
+async function getPlotConfig(opts, app) {
+  if (opts.termType && !supportedTermTypes.has(opts.termType))
+    throw new Error(`termType='${opts.termType}' is not supported by DEinput`);
+  const config = {
+    chartType: "DEinput",
+    // default keeps every existing caller on gene expression without passing anything
+    termType: opts.termType || TermTypes.GENE_EXPRESSION,
+    settings: {}
+  };
+  const c = copyMerge(config, opts);
+  if (c.groups) c.groups = await getValidGroups(c.groups, app);
+  return c;
+}
+async function getValidGroups(groups, app) {
+  if (!Array.isArray(groups)) throw "config.groups must be an array";
+  if (groups.length > 2) throw "config.groups[] cannot exceed 2 groups";
+  const names = /* @__PURE__ */ new Set();
+  for (const g of groups) {
+    if (!g?.filter) throw "config.groups[] entry is missing .filter{}";
+    if ("name" in g && typeof g.name != "string") throw "config.groups[].name must be a string";
+    if (!g.name) continue;
+    if (names.has(g.name)) throw `duplicate config.groups[].name='${g.name}'`;
+    names.add(g.name);
+  }
+  const validated = [];
+  for (const g of groups) {
+    const filter = getNormalRoot(g.filter);
+    if (!filter.lst.length) throw "config.groups[] entry has a blank .filter{}";
+    if (app?.vocabApi) await Promise.all(rehydrateFilter(filter, app.vocabApi));
+    const name = g.name || getUnusedGroupName(names);
+    names.add(name);
+    const valid = Object.assign({}, g, { filter, name });
+    if ("color" in g) {
+      const c = color(g.color);
+      if (!c) throw `invalid config.groups[].color='${g.color}'`;
+      valid.color = c.formatHex();
+    }
+    validated.push(valid);
+  }
+  return validated;
+}
+function getUnusedGroupName(names) {
+  const base = "New group";
+  for (let i = 0; ; i++) {
+    const name = base + (i === 0 ? "" : " " + i);
+    if (!names.has(name)) return name;
+  }
+}
+export {
+  DEinputInit,
+  componentInit,
+  getPlotConfig
+};
+//# sourceMappingURL=DEinput-VKRBFYUE.js.map

package/dist/DM-NU23H5PL.js

@@ -0,0 +1,86 @@
+import {
+  appInit
+} from "./chunk-2FTQ5RMP.js";
+import "./chunk-IW5XJT3H.js";
+import "./chunk-C7KUMZQM.js";
+import "./chunk-TZVSDB7S.js";
+import "./chunk-ZV7LZY67.js";
+import "./chunk-FZYVPRVQ.js";
+import "./chunk-4E2F26CC.js";
+import "./chunk-FE5TCBIT.js";
+import "./chunk-K2ARLT2A.js";
+import "./chunk-O6T4SDC7.js";
+import "./chunk-3YQYWX4M.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-R3RD3VEX.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-KBTFT76L.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";
+
+// gdc/DM.ts
+async function init(arg, holder, genomes) {
+  const useGenome = arg.genome || "hg38";
+  const useDslabel = arg.dslabel || "GDC";
+  const genome = genomes[useGenome];
+  const massApi = await appInit({
+    genome,
+    holder,
+    state: {
+      genome: useGenome,
+      dslabel: useDslabel,
+      termfilter: { filter0: arg.filter0 },
+      nav: { activeTab: 1, header_mode: "hidden" },
+      // an embedder may supply prebuilt groups, see config.groups[] in plots/DEinput.ts.
+      // DEinput is the group-building submission ui, shared with DE and switched by termType;
+      // it launches the 'differentialAnalysis' results chart once groups are submitted
+      plots: arg.state?.plots || [{ chartType: "DEinput", termType: "dnaMethylation" }]
+    },
+    opts: Object.assign(
+      {
+        // todo additional customizations
+        // dictionary:{header:'Select a variable to build Correlation Plot'}
+        // some way to make gene exp violin/boxplot to use log scale by default, but numeric dict term should not
+      },
+      arg.opts || {}
+    ),
+    app: arg.opts?.app || {}
+  });
+  const api = {
+    update: async (updateArg) => {
+      if (!massApi) return;
+      if ("filter0" in updateArg) {
+        massApi.dispatch({
+          type: "app_refresh",
+          subactions: [
+            {
+              type: "filter_replace",
+              filter0: updateArg.filter0
+            }
+          ]
+        });
+      }
+    },
+    triggerAbort: (reason = "") => massApi.triggerAbort(reason)
+  };
+  return api;
+}
+export {
+  init
+};
+//# sourceMappingURL=DM-NU23H5PL.js.map