@sjcrh/proteinpaint-client 2.226.0 → 2.227.1

package/dist/facet-RXUO4LRY.js

@@ -0,0 +1,556 @@
+import {
+  ListSamples,
+  PlotBase,
+  addNewGroup,
+  controlsInit,
+  fillTermWrapper,
+  filterJoin,
+  getCombinedTermFilter,
+  getGroupFilterOfConditions,
+  getGvGroupFilterEntry,
+  getT0T2defaultQ,
+  select2Terms
+} from "./chunk-CXCAQOFB.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-ILAYJZBC.js";
+import {
+  Menu
+} from "./chunk-CNFTQSNE.js";
+import "./chunk-DOC3HBOV.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-VVWZ4BOI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-2IAELUCN.js";
+import {
+  isNumericTerm
+} from "./chunk-CFYWQJ7F.js";
+import "./chunk-2N345NXD.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import {
+  roundValueAuto
+} from "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/facet.ts
+var Facet = class _Facet extends PlotBase {
+  constructor(opts, api) {
+    super(opts, api);
+    this.highlightColRow = (tbody, tr, colIdx, color) => {
+      tbody.selectAll(`td.highlightable-cell:nth-child(${colIdx})`).style("background-color", `${color}`).style("border", `2.5px solid ${color}`);
+      tbody.select(`th:nth-child(${colIdx})`).style("background-color", `${color}`).style("border", `2.5px solid ${color}`);
+      tr.style("background-color", `${color}`);
+    };
+    this.type = _Facet.type;
+    const holder = opts.holder;
+    const controlsHolder = holder.append("div").style("display", "inline-block");
+    const mainDiv = holder.append("div").style("display", "inline-block");
+    this.dom = {
+      holder: opts.holder.style("padding", "20px"),
+      header: opts.header,
+      controlsHolder,
+      mainDiv,
+      tip: opts.tip || new Menu()
+    };
+  }
+  static {
+    this.type = "facet";
+  }
+  async init() {
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (this.dom.header)
+      this.dom.header.html(
+        `${config.columnTw.term.name} <span style="font-size:.8em">(COLUMN)</span> ${config.rowTw.term.name} <span style="font-size:.8em">(ROW) &nbsp; FACET TABLE</span>`
+      );
+    const parentConfig = this.parentId && appState.plots.find((p) => p.id === this.parentId);
+    const termfilter = getCombinedTermFilter(appState, config.filter || parentConfig?.filter);
+    return {
+      config,
+      vocab: appState.vocab,
+      termfilter,
+      groups: appState.groups
+    };
+  }
+  async main() {
+    this.config = JSON.parse(JSON.stringify(this.state.config));
+    this.hasTermCollection = this.config.columnTw.term.type == "termCollection" || this.config.rowTw.term.type == "termCollection";
+    await this.setControls();
+    await this.renderTable();
+  }
+  async renderTable() {
+    const config = this.config;
+    this.dom.mainDiv.selectAll("*").remove();
+    this.dom.tip.clear().hide();
+    const table = this.dom.mainDiv.append("table");
+    const tbody = table.append("tbody");
+    const headerRow = tbody.append("tr").style("text-align", "center");
+    headerRow.append("th");
+    const samplesAuth = this.app.vocabApi.termdbConfig?.displaySampleIds && this.app.vocabApi.hasVerifiedToken();
+    if (samplesAuth) {
+      table.style("border-spacing", "0px");
+      const { result, categories, categories2 } = await this.getSampleTableData(config);
+      if (!categories.length || !categories2.length) {
+        this.showNoSampleMessage(this.dom.mainDiv);
+        return;
+      }
+      for (const category of categories) {
+        const label = config.columnTw.term.type == "termCollection" ? getTermCollectionName(config.columnTw, category) : config.columnTw.term.values?.[category]?.label || category;
+        this.addHeader(headerRow, label);
+      }
+      this.renderSampleTable(tbody, config, result, categories, categories2);
+    } else {
+      table.style("border-spacing", "5px");
+      const { rows, filteredCols, total } = await this.getStaticTableData(config);
+      if (!rows.size || !filteredCols.length) {
+        this.showNoSampleMessage(this.dom.mainDiv);
+        return;
+      }
+      for (const col of filteredCols) {
+        const label = config.columnTw.term.values?.[col.seriesId]?.label || col.seriesId;
+        this.addHeader(headerRow, label);
+      }
+      this.renderStaticTable(tbody, config, rows, total);
+    }
+  }
+  renderSampleTable(tbody, config, result, categories, categories2) {
+    const cells = {};
+    const aggregateBy = config.settings.facet.aggregateBy;
+    if (this.hasTermCollection) {
+      const isColTermCollection = config.columnTw.term.type == "termCollection";
+      const isRowTermCollection = config.rowTw.term.type == "termCollection";
+      if (isColTermCollection && isRowTermCollection) throw "row and col terms cannot both be termCollection";
+      if (aggregateBy != "avg" && aggregateBy != "sum") throw "unexpected aggregateBy value";
+      for (const category2 of categories2) {
+        cells[category2] = {};
+        const tr = tbody.append("tr");
+        const label2 = isRowTermCollection ? getTermCollectionName(config.rowTw, category2) : config.rowTw.term.values?.[category2]?.label || category2;
+        this.addRowLabel(tr, label2);
+        for (const category of categories) {
+          const td = tr.append("td");
+          const samples = result.lst.filter((s) => {
+            const colPass = isColTermCollection ? getTermCollectionData(s, config.columnTw, category) : s[config.columnTw.$id]?.key == category;
+            const rowPass = isRowTermCollection ? getTermCollectionData(s, config.rowTw, category2) : s[config.rowTw.$id]?.key == category2;
+            return colPass && rowPass;
+          });
+          if (samples.length) {
+            const data = samples.map(
+              (s) => isColTermCollection ? getTermCollectionData(s, config.columnTw, category) : getTermCollectionData(s, config.rowTw, category2)
+            );
+            const total = data.reduce((sum, v) => sum + v, 0);
+            const value = aggregateBy == "avg" ? total / data.length : total;
+            td.classed("sja_menuoption", true).style("text-align", "center").style("border", "2.5px solid white").text(roundValueAuto(value));
+          } else {
+            td.classed("highlightable-cell", true);
+          }
+        }
+      }
+    } else {
+      for (const category2 of categories2) {
+        cells[category2] = {};
+        const tr = tbody.append("tr");
+        const label2 = config.rowTw.term.values?.[category2]?.label || category2;
+        this.addRowLabel(tr, label2);
+        for (const category of categories) {
+          const samples = result.lst.filter(
+            (s) => s[config.columnTw.$id]?.key == category && s[config.rowTw.$id]?.key == category2
+          );
+          const percent = this.config.settings.facet.showPercents ? ` <span style="color:gray;"> (${roundValueAuto(
+            samples.length / result.lst.length * 100,
+            true,
+            1
+          )}%)</span>` : "";
+          cells[category2][category] = { samples, selected: false };
+          const td = tr.append("td");
+          if (!samples.length) td.classed("highlightable-cell", true);
+          if (samples.length > 0) {
+            const colIdx = categories.indexOf(category) + 2;
+            td.classed("sja_menuoption", true).style("text-align", "center").style("border", "2.5px solid white").html(`${samples.length}${percent}`).on("mouseover", () => {
+              this.highlightColRow(tbody, tr, colIdx, "#fffec8");
+            }).on("mouseout", () => {
+              this.highlightColRow(tbody, tr, colIdx, "transparent");
+            }).on("click", () => {
+              const selected = cells[category2][category].selected = !cells[category2][category].selected;
+              if (selected) {
+                td.style("border", "1px solid blue");
+              } else {
+                td.style("border", "2.5px solid white");
+              }
+              for (const category22 of categories2) {
+                for (const category3 of categories) {
+                  if (cells[category22][category3].selected) {
+                    buttonDiv.style("display", "");
+                    prompt.text("Choose how to use samples:");
+                    return;
+                  }
+                }
+              }
+              buttonDiv.style("display", "none");
+              prompt.text("Click on cells to select samples");
+            });
+          }
+        }
+      }
+    }
+    const prompt = this.dom.mainDiv.append("div").attr("data-testid", "sjpp-facet-start-prompt").style("margin", "20px 0px 0px 15px").style("opacity", "0.7").text(
+      this.hasTermCollection ? `Values in cells are ${aggregateBy == "avg" ? "averages" : "sums"}` : "Click on cells to select samples"
+    );
+    const buttonDiv = this.dom.mainDiv.append("div").style("margin", "20px 0px 0px 25px").style("display", "none");
+    const btns = [
+      {
+        text: "Show samples view",
+        // disabled: () => {}, add this if needed later
+        callback: () => {
+          const samples = this.getSelectedSamples(categories, categories2, cells);
+          this.app.dispatch({
+            type: "plot_create",
+            config: {
+              chartType: "sampleView",
+              samples: samples.map((d) => ({
+                sampleId: d.sample,
+                sampleName: result.refs.bySampleId[d.sample].label
+              }))
+            }
+          });
+        }
+      },
+      {
+        text: "List samples",
+        callback: () => {
+          const samples = this.getSelectedSamples(categories, categories2, cells);
+          const sampleRows = samples.map((d) => [
+            result.refs.bySampleId[d.sample].label,
+            d[config.columnTw.$id].key,
+            d[config.rowTw.$id].key
+          ]);
+          this.dom.tip.clear().showunder(buttonDiv.node());
+          const tbody2 = this.dom.tip.d.append("table").append("tbody");
+          const headerRow = tbody2.append("tr").style("text-align", "center");
+          headerRow.append("th").text("Sample");
+          headerRow.append("th").text(config.columnTw.term.name);
+          headerRow.append("th").text(config.rowTw.term.name);
+          for (const row of sampleRows) {
+            const tr = tbody2.append("tr");
+            tr.append("td").text(row[0]);
+            tr.append("td").text(row[1]);
+            tr.append("td").text(row[2]);
+          }
+        }
+      },
+      {
+        text: "Create group",
+        callback: () => {
+          this.addGroup(categories, categories2, cells, result);
+        }
+      }
+    ];
+    for (const btn of btns) {
+      this.addBtn(buttonDiv, btn);
+    }
+  }
+  addBtn(div, btn) {
+    return div.append("button").classed("sja_menuoption", true).style("padding", "0px 10px").style("margin", "0px 5px").text(btn.text).on("click", btn.callback);
+  }
+  /* The group is defined by the conditions of the selected cells, and by the filter of the plot
+  when it has one. The cells are taken by the category of one term: each category is stated once,
+  with the categories of the other term that are selected with it, and the categories of the group
+  are joined with "or". */
+  addGroup(categories, categories2, cells, result) {
+    const columns = /* @__PURE__ */ new Map();
+    const rows = /* @__PURE__ */ new Map();
+    for (const row of categories2) {
+      for (const column of categories) {
+        if (!cells[row][column].selected) continue;
+        if (!rows.has(row)) rows.set(row, this.getCategoryFilter(this.config.rowTw, row, result));
+        if (!columns.has(column)) columns.set(column, this.getCategoryFilter(this.config.columnTw, column, result));
+      }
+    }
+    const byColumn = [...rows.values()].every(isOneTvs) && ![...columns.values()].every(isOneTvs);
+    const [outer, inner] = byColumn ? [columns, rows] : [rows, columns];
+    const lst = [];
+    for (const [o, outerFilter] of outer) {
+      const selected2 = [...inner.keys()].filter((i) => (byColumn ? cells[i][o] : cells[o][i]).selected);
+      lst.push(filterJoin([outerFilter, getEither(selected2.map((i) => inner.get(i)))]));
+    }
+    const selected = lst.length == 1 ? lst[0] : { type: "tvslst", in: true, join: "or", lst };
+    const plotFilter = this.config.filter || this.parentId && this.app.getState().plots.find((p) => p.id === this.parentId)?.filter;
+    const filter = getGroupFilterOfConditions([plotFilter, selected]);
+    addNewGroup(this.app, filter, this.state.groups);
+    return filter;
+  }
+  // the filter that selects the samples of one category of a term of the table
+  getCategoryFilter(tw, category, result) {
+    const key = String(category);
+    if (tw.term.type == "geneVariant") {
+      const filter = getGvGroupFilterEntry(tw, key);
+      if (!filter) throw `no filter for '${key}' of ${tw.term.name}`;
+      return filter;
+    }
+    const bins = Object.fromEntries((result.refs?.byTermId?.[tw.$id]?.bins || []).map((b) => [b.label, b]));
+    const { tvslst } = new ListSamples({
+      app: this.app,
+      termfilter: this.state.termfilter,
+      term: tw,
+      plot: { seriesId: key, key },
+      bins: { term1: bins }
+    });
+    const entry = tvslst.lst[0];
+    if (entry.tvs?.ranges?.length) delete entry.tvs.values;
+    return { type: "tvslst", in: true, join: "", lst: [entry] };
+  }
+  getSelectedSamples(categories, categories2, cells) {
+    const samples = [];
+    for (const category2 of categories2) {
+      for (const category of categories) {
+        if (cells[category2][category].selected) {
+          samples.push(...cells[category2][category].samples);
+        }
+      }
+    }
+    return samples;
+  }
+  async getSampleTableData(config) {
+    const result = await this.vocabApi?.getAnnotatedSampleData({
+      filter: this.state.termfilter.filter,
+      terms: [config.columnTw, config.rowTw]
+    });
+    if (!result || !result.lst || !result.lst.length) return { result: { lst: [] }, categories: [], categories2: [] };
+    const categories = this.getCategories(config.columnTw, result.lst);
+    const categories2 = this.getCategories(config.rowTw, result.lst);
+    return { result, categories, categories2 };
+  }
+  getCategories(tw, data) {
+    let categories = [];
+    if (tw.term.type == "termCollection") {
+      for (const sample of data) {
+        const value = sample[tw.$id]?.value;
+        if (value) {
+          const termids = Object.keys(value);
+          categories.push(...termids);
+        }
+      }
+    } else {
+      for (const sample of data) {
+        let key = sample[tw.$id]?.key;
+        if (key) {
+          if (!isNaN(key)) key = Number(key);
+          categories.push(key);
+        }
+      }
+    }
+    const set = new Set(categories);
+    categories = Array.from(set).sort();
+    if (isNumericTerm(tw.term)) {
+      if (tw.term.values) {
+        Object.values(tw.term.values).forEach((i) => {
+          if (i?.uncomputable) {
+            const index = categories.indexOf(i.label);
+            if (index > -1) categories.splice(index, 1);
+          }
+        });
+      }
+      categories = this.orderColNames(categories);
+    }
+    return categories;
+  }
+  orderColNames(cols) {
+    const tmpNums = [];
+    const tmpStrings = [];
+    for (const col of cols) {
+      const c = col.split(" to ");
+      const cx = c[0].replace(/[>≥<≤]/g, "");
+      const x = Number(cx);
+      if (!isNaN(x)) {
+        const key = !c[1] && (col.includes("<") || col.includes("\u2264")) ? x - 1 : !c[1] && (col.includes("\u2265") || col.includes(">")) ? x + 1 : x;
+        tmpNums.push({ key, label: col });
+      } else tmpStrings.push(cx);
+    }
+    return [...tmpNums.sort((a, b) => a.key - b.key).map((i) => i.label), ...tmpStrings.sort()];
+  }
+  renderStaticTable(tbody, config, rows, totalSamples) {
+    for (const row of rows) {
+      const tr = tbody.append("tr");
+      const label = config.rowTw.term.values?.[row[0]]?.label || row[0];
+      this.addRowLabel(tr, label);
+      for (const col of row[1]) {
+        const label2 = col[1].value > 0 ? col[1].value : "";
+        const percent = this.config.settings.facet.showPercents ? `<span style="color:gray;"> (${roundValueAuto(col[1].value / totalSamples * 100, true, 1)}%)</span>` : "";
+        const td = tr.append("td");
+        if (label2)
+          td.classed("sja_menuoption", true).style("border", "2.5px solid white").style("text-align", "center").html(`${label2}${percent}`);
+      }
+    }
+  }
+  async getStaticTableData(config) {
+    const opts = { term: config.columnTw, term2: config.rowTw, filter: this.state.termfilter.filter };
+    if (this.state.termfilter.filter0) opts.filter0 = this.state.termfilter.filter0;
+    await this.getDescrStats(opts.term);
+    await this.getDescrStats(opts.term2);
+    const result = await this.vocabApi?.getNestedChartSeriesData(opts);
+    const rows = /* @__PURE__ */ new Map();
+    const filteredCols = result.data.refs.cols.map((col) => result.data.charts[0].serieses.find((s) => s.seriesId == col));
+    result.data.refs.rows.forEach((row) => {
+      rows.set(row, /* @__PURE__ */ new Map());
+      for (const col of filteredCols) {
+        rows.get(row).set(col.seriesId, { value: col.data.find((d) => d.dataId == row)?.total || 0, selected: false });
+      }
+    });
+    return { rows, filteredCols, total: result.data.charts[0].total };
+  }
+  async getDescrStats(tw) {
+    if (isNumericTerm(tw.term)) {
+      const data = await this.vocabApi?.getDescrStats(tw, this.state.termfilter);
+      if (data.error) throw data.error;
+      tw.q.descrStats = data.values;
+    }
+  }
+  showNoSampleMessage(div) {
+    div.append("div").style("padding", "0px 50px").style("font-size", "1.15em").text("No overlapping samples");
+    return;
+  }
+  addHeader(headerRow, text) {
+    headerRow.append("th").attr("data-testid", "sjpp-facet-col-header").style("border", "2.5px solid white").style("padding", "0px 25px").text(text);
+  }
+  addRowLabel(tr, label) {
+    tr.append("td").attr("data-testid", "sjpp-facet-row-label").style("border", "2.5px solid white").style("font-weight", "bold").text(label);
+  }
+  async setControls() {
+    this.dom.controlsHolder.selectAll("*").remove();
+    const inputs = [
+      {
+        type: "term",
+        configKey: "columnTw",
+        chartType: this.type,
+        usecase: { target: this.type },
+        title: "Facet column categories",
+        label: "Columns",
+        vocabApi: this.app.vocabApi,
+        numericEditMenuVersion: ["discrete"],
+        defaultQ4fillTW: getT0T2defaultQ()
+      },
+      {
+        type: "term",
+        configKey: "rowTw",
+        chartType: this.type,
+        usecase: { target: this.type },
+        title: "Facet row categories",
+        label: "Rows",
+        vocabApi: this.app.vocabApi,
+        numericEditMenuVersion: ["discrete"],
+        defaultQ4fillTW: getT0T2defaultQ()
+      },
+      {
+        boxLabel: "",
+        label: "Show percent",
+        type: "checkbox",
+        chartType: "facet",
+        settingsKey: "showPercents",
+        title: `Option to show/hide percents per cell`
+      }
+    ];
+    if (this.hasTermCollection) {
+      inputs.push({
+        label: "Aggregate by",
+        type: "radio",
+        chartType: "facet",
+        settingsKey: "aggregateBy",
+        title: "Aggregate values by",
+        options: [
+          { label: "Average", value: "avg" },
+          { label: "Sum", value: "sum" }
+        ]
+      });
+    }
+    this.components = {
+      controls: await controlsInit({
+        app: this.app,
+        id: this.id,
+        holder: this.dom.controlsHolder,
+        inputs
+      })
+    };
+  }
+};
+function makeChartBtnMenu(holder, chartsInstance) {
+  const callback = (xterm, yterm) => {
+    const config = {
+      chartType: "facet",
+      columnTw: { term: xterm },
+      rowTw: { term: yterm }
+    };
+    if (isNumericTerm(xterm)) config.columnTw.term.q = { mode: "discrete" };
+    if (isNumericTerm(yterm)) config.rowTw.term.q = { mode: "discrete" };
+    chartsInstance.app.dispatch({
+      type: "plot_create",
+      config
+    });
+  };
+  select2Terms(chartsInstance.dom.tip, chartsInstance.app, "facet", "", callback);
+}
+var facetInit = getCompInit(Facet);
+var componentInit = facetInit;
+async function getPlotConfig(opts, app) {
+  const config = {
+    settings: {
+      facet: {
+        showPercents: false,
+        aggregateBy: "avg"
+      }
+    }
+  };
+  if (!opts.columnTw) throw ".columnTw{} missing";
+  await fillTermWrapper(
+    opts.columnTw,
+    app.vocabApi,
+    opts.columnTw.bins || opts.columnTw.q ? void 0 : getT0T2defaultQ()
+  );
+  if (!opts.rowTw) throw ".rowTw{} missing";
+  await fillTermWrapper(opts.rowTw, app.vocabApi, opts.rowTw.bins || opts.rowTw.q ? void 0 : getT0T2defaultQ());
+  const result = copyMerge(config, opts);
+  return result;
+}
+function getTermCollectionName(tw, termid) {
+  const term = tw.term.termlst.find((t) => t.id == termid);
+  if (!term) throw "term is missing";
+  return term.name;
+}
+function getTermCollectionData(s, tw, termid) {
+  if (tw.term.type != "termCollection") return;
+  const value = s[tw.$id]?.value;
+  if (value) {
+    const data = value[termid];
+    return data;
+  }
+}
+function isOneTvs(f) {
+  return f.lst.length == 1 && f.lst[0].type == "tvs" && !f.lst[0].tvs.isnot;
+}
+function getEither(filters) {
+  if (filters.length == 1) return filters[0];
+  if (!filters.every(isOneTvs)) return { type: "tvslst", in: true, join: "or", lst: filters };
+  const entry = structuredClone(filters[0].lst[0]);
+  for (const f of filters.slice(1)) {
+    const { values, ranges } = f.lst[0].tvs;
+    if (values) (entry.tvs.values ||= []).push(...values);
+    if (ranges) (entry.tvs.ranges ||= []).push(...ranges);
+  }
+  return { type: "tvslst", in: true, join: "", lst: [entry] };
+}
+export {
+  componentInit,
+  facetInit,
+  getPlotConfig,
+  makeChartBtnMenu
+};
+//# sourceMappingURL=facet-RXUO4LRY.js.map

package/dist/gb-NDRFDS5A.js

@@ -0,0 +1,77 @@
+import {
+  appInit
+} from "./chunk-A52K2E32.js";
+import "./chunk-CNDQFKUB.js";
+import "./chunk-OVXHMJJJ.js";
+import "./chunk-SDUMZTIK.js";
+import "./chunk-2E3AJFOA.js";
+import "./chunk-FA2B6PKK.js";
+import "./chunk-4E2F26CC.js";
+import "./chunk-7NVFEGCE.js";
+import "./chunk-2B3CYHUF.js";
+import "./chunk-O6T4SDC7.js";
+import "./chunk-CXCAQOFB.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-ILAYJZBC.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-DOC3HBOV.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-VVWZ4BOI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-2IAELUCN.js";
+import "./chunk-CFYWQJ7F.js";
+import "./chunk-2N345NXD.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/gb.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" },
+      plots: [{ chartType: "genomeBrowser" }]
+    },
+    genomeBrowser: arg.opts?.genomeBrowser || {},
+    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=gb-NDRFDS5A.js.map