@sjcrh/proteinpaint-client 2.166.0 → 2.167.0

package/dist/SC-SUUATZYR.js

@@ -0,0 +1,714 @@
+import {
+  importPlot
+} from "./chunk-PN6GLQWD.js";
+import {
+  PlotBase
+} from "./chunk-OA7TPCTX.js";
+import {
+  GeneSetEditUI,
+  digestMessage,
+  newSandboxDiv,
+  renderTable
+} from "./chunk-PX7A6LBY.js";
+import "./chunk-HJ6L54YS.js";
+import {
+  dofetch3
+} from "./chunk-6ADTREVX.js";
+import "./chunk-DKI7YOTJ.js";
+import "./chunk-6VQ4C735.js";
+import {
+  Menu
+} from "./chunk-TGZA4ETW.js";
+import "./chunk-5MWX5HUZ.js";
+import "./chunk-IQIXGTQV.js";
+import "./chunk-ZFFHOEBE.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-DDOM4XYV.js";
+import "./chunk-7NTZWOJV.js";
+import "./chunk-LD45BCVM.js";
+import "./chunk-RA5EXEHB.js";
+import "./chunk-2MN5JLZB.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-TOU7EVFQ.js";
+import "./chunk-W2IWHXLL.js";
+import "./chunk-5OHXYXLD.js";
+import "./chunk-UJUXE42U.js";
+import "./chunk-OMR2DT66.js";
+import "./chunk-NDWTN4U5.js";
+import "./chunk-HFNDKYVF.js";
+
+// plots/sc/model/SCModel.ts
+var SCModel = class {
+  constructor(app, id) {
+    this.app = app;
+    this.id = id;
+    this.state = this.app.getState();
+  }
+  /********** Single Cell SAMPLES for rendering the table *********/
+  //The table data does not update
+  //Should only need to init once
+  async getSampleData() {
+    const body = this.getSampleRequestOpts();
+    return await dofetch3("termdb/singlecellSamples", { body });
+  }
+  //May involve more complicated logic later
+  getSampleRequestOpts() {
+    return {
+      genome: this.state.vocab.genome,
+      dslabel: this.state.vocab.dslabel,
+      filter0: this.state.termfilter.filter0 || null
+    };
+  }
+  //Fetches optional name for ds defined columns
+  async getColumnLabels(dsScSamples) {
+    if (!dsScSamples || !dsScSamples.sampleColumns) return;
+    const colsCopy = structuredClone(dsScSamples.sampleColumns);
+    for (const col of colsCopy) {
+      let label = col.termid;
+      try {
+        label = (await this.app.vocabApi.getterm(col.termid)).name;
+      } catch (e) {
+        if (e.message) {
+        }
+      }
+      col.label = label;
+    }
+    return colsCopy;
+  }
+  /********** Single Cell DATA for rendering plots *********/
+  async getData() {
+    const body = this.getDataRequestOpts();
+    if (!body) return;
+    return await dofetch3("termdb/singlecellData", { body });
+  }
+  getDataRequestOpts() {
+    const state = this.app.getState();
+    const singleCellTermdbConfig = state.termdbConfig?.queries?.singleCell;
+    if (!singleCellTermdbConfig?.data) throw new Error("No singleCell.data defined in termdbConfig.queries");
+    const config = state.plots.find((p) => p.id === this.id);
+    if (!config.settings.sc.item) return;
+    const plots = singleCellTermdbConfig.data.plots.map((p) => p.name);
+    return {
+      genome: this.state.vocab.genome,
+      dslabel: this.state.vocab.dslabel,
+      plots,
+      sample: {
+        eID: config.settings.sc.item.experiment,
+        sID: config.settings.sc.item.sample
+      }
+    };
+  }
+};
+
+// plots/sc/viewModel/SCViewModel.ts
+var SCViewModel = class {
+  constructor(app, config, items, sampleColumns) {
+    this.app = app;
+    this.state = this.app.getState();
+    const [rows, columns] = this.getTabelData(config, items, sampleColumns);
+    const selectedRows = [];
+    const i = items.findIndex((i2) => i2.sample == config.settings.sc.item?.sample);
+    if (i != -1) selectedRows.push(i);
+    this.tableData = {
+      rows,
+      columns,
+      selectedRows
+    };
+  }
+  getTabelData(plotConfig, items, sampleColumns) {
+    const rows = [];
+    const hasExperiments = items.some((i) => i.experiments);
+    const columns = [{ label: plotConfig.settings.sc.columns.sample, sortable: true }];
+    if (hasExperiments) columns.push({ label: "Sample", sortable: true });
+    for (const col of sampleColumns || []) {
+      columns.push({
+        label: col.label,
+        width: "14vw",
+        sortable: true
+      });
+    }
+    if (hasExperiments) columns.push({ label: "Experiment", sortable: true });
+    for (const item of items) {
+      if (hasExperiments)
+        for (const exp of item.experiments) {
+          const row = [{ value: item.sample, __experimentID: exp.experimentID }];
+          row.push({ value: exp.sampleName });
+          for (const col of sampleColumns || []) {
+            row.push({ value: item[col.termid] });
+          }
+          if (this.state.vocab.dslabel == "GDC")
+            row.push({ value: exp.experimentID, url: `https://portal.gdc.cancer.gov/files/${exp.experimentID}` });
+          else row.push({ value: exp.experimentID });
+          rows.push(row);
+        }
+      else {
+        const row = [{ value: item.sample }];
+        for (const col of sampleColumns || []) {
+          row.push({ value: item[col.termid] });
+        }
+        rows.push(row);
+      }
+    }
+    return [rows, columns];
+  }
+};
+
+// plots/sc/interactions/SCInteractions.ts
+var SCInteractions = class {
+  constructor(app, dom, id, getState) {
+    this.app = app;
+    this.dom = dom;
+    this.id = id;
+    this.getState = getState();
+  }
+  /** Used in the gene search menu shown on click from a plot btn
+   * Add the plot to the state.plots array with .parentId. Adding
+   * .parentId prevents the plot from launching in a new sandbox.
+   * Pass the .parentId to both the plotConfig and the action.
+   * this.getState() in SC.ts will find all the subplots with the parentId==this.id
+   * SC.main() initializes the subplots as components in chartsDiv
+   */
+  async createSubplot(config) {
+    const item = this.app.getState().plots.find((p) => p.id === this.id)?.settings.sc.item;
+    await this.app.dispatch({
+      type: "plot_create",
+      parentId: this.id,
+      config: Object.assign({}, config, { parentId: this.id, scItem: item })
+    });
+  }
+  /** Updates the item in the plot settings */
+  async updateItem(item) {
+    await this.app.dispatch({
+      type: "plot_edit",
+      id: this.id,
+      config: { settings: { sc: { item } } }
+    });
+  }
+  toggleLoading(on) {
+    if (on) {
+      this.dom.loading.selectAll("*").remove();
+      this.dom.loading.style("display", "block").append("div").style("position", "relative").style("top", "50%").append("span").attr("class", "sjpp-spinner");
+      this.dom.loading.style("display", "");
+    } else {
+      this.dom.loading.selectAll(".sjpp-spinner").remove();
+      this.dom.loading.style("display", "none");
+    }
+  }
+};
+
+// plots/sc/view/PlotSelectionRenderer.ts
+var PlotSelectionRenderer = class {
+  constructor(dom, interactions, tableData) {
+    this.dom = dom;
+    this.interactions = interactions;
+    this.renderSamplesTable(tableData);
+  }
+  /** Users select one item at a time to render the plot buttons
+   * to init() plots in the dashboard.*/
+  renderSamplesTable(tableData) {
+    renderTable({
+      rows: tableData.rows,
+      columns: tableData.columns,
+      div: this.dom.tableDiv,
+      singleMode: true,
+      maxWidth: tableData.columns.length > 3 ? "98vw" : "40vw",
+      maxHeight: "30vh",
+      header: {
+        allowSort: true,
+        style: { "text-transform": "capitalize" }
+      },
+      striped: true,
+      selectedRows: tableData.selectedRows,
+      noButtonCallback: (index) => {
+        const item = {};
+        tableData.rows[index].forEach((r, idx) => {
+          if (!r.value) return;
+          item[tableData.columns[idx].label.toLowerCase()] = r.value;
+        });
+        this.interactions.updateItem(item);
+        this.dom.plotsBtnsDiv.style("display", "block");
+      }
+    });
+  }
+};
+
+// plots/sc/view/PlotButtons.ts
+var PlotButtons = class {
+  constructor(interactions, holder) {
+    holder.style("padding", "10px");
+    const promptDiv = holder.append("div").style("padding", "10px 0").text("Select data from");
+    this.plotBtnsDom = {
+      promptDiv,
+      selectPrompt: promptDiv.append("span"),
+      btnsDiv: holder.append("div"),
+      tip: new Menu({ padding: "" })
+    };
+    this.interactions = interactions;
+    const state = this.interactions.getState;
+    this.scTermdbConfig = state.termdbConfig.queries.singleCell;
+  }
+  update(settings, data) {
+    const item = settings.sc.item;
+    this.plotBtnsDom.promptDiv.style("display", !item ? "none" : "block");
+    if (!item) return;
+    if (data != null && data.plots) this.data = data;
+    this.settings = settings;
+    this.item = item;
+    const name = item.sample;
+    this.plotBtnsDom.selectPrompt.text(` ${name}:`);
+    this.renderChartBtns();
+  }
+  renderChartBtns() {
+    this.plotBtnsDom.btnsDiv.selectAll("*").remove();
+    const btns = this.getChartBtnOpts();
+    this.plotBtnsDom.btnsDiv.selectAll("button").data(btns.filter((b) => b.isVisible())).enter().append("button").style("padding", "10px 15px").style("border-radius", "20px").style("border-color", "transparent").style("background-color", "#CFE2F3").style("margin", "0 10px").style("cursor", "pointer").text((b) => b.label).on("click", async (e, plot) => {
+      if (plot.open) {
+        this.plotBtnsDom.tip.clear().showunder(e.target);
+        plot.open(plot, this);
+      } else {
+        const config = await plot.getPlotConfig();
+        await this.interactions.createSubplot(config);
+      }
+    });
+  }
+  getChartBtnOpts() {
+    const btns = [];
+    for (const plots of this.scTermdbConfig?.data?.plots || []) {
+      btns.push({
+        label: plots.name,
+        isVisible: () => true,
+        getPlotConfig: async () => {
+          return await this.getSingleCellConfig(plots.name);
+        }
+      });
+    }
+    btns.push(
+      {
+        label: "Gene expression",
+        isVisible: () => true,
+        open: this.geneSearchMenu,
+        getPlotConfig: async (geneLst) => {
+          if (!geneLst.length) {
+            alert("No genes selected to launch gene expression subplot [PlotButtons.ts getChartBtnOpts()]");
+            return;
+          }
+          if (geneLst.length == 1) return await this.getViolinConfig(geneLst[0].gene);
+          else if (geneLst.length == 2) return await this.getScatterConfig(geneLst);
+          else return this.getClusteringConfig(geneLst);
+        }
+      },
+      {
+        label: "Differential expression",
+        isVisible: () => this.scTermdbConfig.DEgenes,
+        open: this.termDropdownMenu,
+        getPlotConfig: (value) => {
+          return {
+            chartType: "differentialAnalysis",
+            termType: "singleCellCellType",
+            //Eventually category will be updated to a term
+            // term: {
+            // 	name: term
+            // },
+            categoryName: `${value}`,
+            termId: this.data.plots[0].colorBy || "Cluster",
+            //CHANGEME
+            sample: this.item.experiment || this.item.sample
+          };
+        }
+      }
+    );
+    return btns;
+  }
+  //********** Btn Menus **********/
+  geneSearchMenu(plot, self) {
+    self.plotBtnsDom.tip.clear();
+    new GeneSetEditUI({
+      holder: self.plotBtnsDom.tip.d.append("div"),
+      genome: self.interactions.app.opts.genome,
+      vocabApi: {},
+      callback: async (result) => {
+        self.plotBtnsDom.tip.hide();
+        const config = await plot.getPlotConfig(result.geneList);
+        await self.interactions.createSubplot(config);
+      }
+    });
+  }
+  /** CHANGEME: This elem is a placeholder for now
+   * Ideally this will call the tree with singleCellCellTerms.
+   * That term type is not implemented yet. Once it is,
+   * refactor this workflow to use the tree. */
+  termDropdownMenu(plot, self) {
+    self.plotBtnsDom.tip.clear();
+    const _plot = self.data.plots[0];
+    const wrapper = self.plotBtnsDom.tip.d.append("div").style("padding", "10px");
+    wrapper.append("div").style("display", "block").style("width", "300px").text(`View differentially expressed genes of a ${_plot.colorBy.toLowerCase()} versus rest of the cells:`);
+    const select = wrapper.append("select").style("margin", "10px 0").style("width", "auto").style("padding", "5px").on("change", async function() {
+      self.plotBtnsDom.tip.hide();
+      const value = select.node().value;
+      if (value.indexOf("Select") == 0) return;
+      const config = plot.getPlotConfig(value, _plot.colorBy);
+      await self.interactions.createSubplot(config);
+    });
+    const regex = new RegExp(_plot.colorBy, "g");
+    _plot.clusters.unshift(`Select ${_plot.colorBy}...`);
+    for (const cluster of _plot.clusters) {
+      select.append("option").attr("value", cluster.replace(regex, "").trim()).text(cluster);
+    }
+  }
+  //********** Plot Config Helpers **********/
+  async getViolinConfig(gene) {
+    if (!this.item) throw new Error("No item selected");
+    return {
+      chartType: "violin",
+      term: {
+        $id: await digestMessage(`${gene}-${this.item.sample}-${this.item.experiment}`),
+        term: {
+          /** NOTE: There are no term handlers for the single cell types */
+          type: "singleCellGeneExpression",
+          id: gene,
+          gene,
+          name: gene,
+          sample: {
+            sID: this.item.sample,
+            eID: this.item.experiment
+          }
+        }
+      },
+      term2: {
+        //CHANGE ME
+        $id: await digestMessage(`CHANGEME-${this.item.sample}-${this.item.experiment}`),
+        term: {
+          /** NOTE: There are no term handlers for the single cell types */
+          type: "singleCellCellType",
+          id: "cluster",
+          //CHANGE ME, singlecell.data.plots.[i].colorColumns
+          name: "cluster",
+          //CHANGE ME
+          sample: {
+            sID: this.item.sample,
+            eID: this.item.experiment
+          },
+          plot: "UMAP"
+          //CHANGEME
+        }
+      }
+    };
+  }
+  async getScatterConfig(geneLst) {
+    if (!this.item) throw new Error("No item selected");
+    const gene1 = geneLst[0].gene;
+    const gene2 = geneLst[1].gene;
+    return {
+      chartType: "sampleScatter",
+      term: {
+        $id: await digestMessage(`${gene1}-${this.item.sample}-${this.item.experiment}`),
+        term: {
+          type: "singleCellGeneExpression",
+          gene: gene1,
+          id: gene1,
+          name: gene1,
+          sample: {
+            sID: this.item.sample,
+            eID: this.item.experiment
+          }
+        },
+        q: { mode: "continuous" }
+      },
+      term2: {
+        $id: await digestMessage(`${gene2}-${this.item.sample}-${this.item.experiment}`),
+        term: {
+          type: "singleCellGeneExpression",
+          gene: gene2,
+          id: gene2,
+          name: gene2,
+          sample: {
+            sID: this.item.sample,
+            eID: this.item.experiment
+          }
+        },
+        q: { mode: "continuous" }
+      }
+    };
+  }
+  getClusteringConfig(geneLst) {
+    if (!this.item) throw new Error("No item selected");
+    const tws = geneLst.slice(0, 100).map((g) => {
+      return {
+        term: {
+          gene: g.gene,
+          name: `${g.gene} ${this.settings.hierCluster.unit}`,
+          type: "singleCellGeneExpression",
+          sample: this.item
+        },
+        q: {}
+      };
+    });
+    return {
+      chartType: "hierCluster",
+      termgroups: [{ lst: tws, type: "hierCluster" }],
+      dataType: "geneExpression",
+      settings: { hierCluster: this.settings.hierCluster }
+    };
+  }
+  async getSingleCellConfig(plotName) {
+    if (!this.item) throw new Error("No item selected");
+    const plot = this.scTermdbConfig.data.plots.find((p) => p.name == plotName);
+    if (!plot) throw new Error(`No plot by name ${plotName} in data.plots [PlotButtons.ts getSingleCellConfig()]`);
+    const cfg = {
+      chartType: "sampleScatter",
+      singleCellPlot: {
+        name: plotName,
+        sample: {
+          sID: this.item.sample,
+          eID: this.item.experiment
+        }
+      }
+    };
+    if (plot.colorColumns?.[0]) {
+      cfg.colorTW = {
+        $id: await digestMessage(`${plot.name}-${this.item.sample}-${this.item.experiment}`),
+        term: {
+          type: "singleCellCellType",
+          name: plot.colorColumns[0].name,
+          sample: {
+            sID: this.item.sample,
+            eID: this.item.experiment
+          },
+          plot: plotName
+        }
+      };
+    }
+    return cfg;
+  }
+};
+
+// plots/sc/view/SCViewRenderer.ts
+var SCViewRenderer = class _SCViewRenderer {
+  static {
+    //On load, show table
+    //Eventually maybe an app dispatch and not a flag
+    this.inUse = true;
+  }
+  constructor(dom, interactions, segments) {
+    this.dom = dom;
+    this.interactions = interactions;
+    this.plotBtns = new PlotButtons(this.interactions, this.dom.plotsBtnsDiv);
+    this.segments = segments;
+  }
+  render(tableData) {
+    this.renderSelectBtn();
+    new PlotSelectionRenderer(this.dom, this.interactions, tableData);
+    this.dom.plotsBtnsDiv.style("display", "none");
+  }
+  /** Renders the select btn at the top of the page that
+   * show/hides the item table and plot buttons */
+  renderSelectBtn() {
+    this.dom.selectBtnDiv.style("padding", "10px");
+    const btn = this.dom.selectBtnDiv.append("button").attr("data-testid", "sjpp-sc-item-table-select-btn").style("border-radius", "20px").style("padding", "5px 10px").style("background-color", "transparent").text("Select sample and plots");
+    const arrowSpan = btn.append("span").style("font-size", "0.8em").style("padding-left", "3px").text("\u25BC");
+    btn.on("click", () => {
+      _SCViewRenderer.inUse = !_SCViewRenderer.inUse;
+      arrowSpan.text(_SCViewRenderer.inUse ? "\u25BC" : "\u25B2");
+      this.dom.tableDiv.style("display", _SCViewRenderer.inUse ? "block" : "none");
+      this.dom.plotsBtnsDiv.style("display", _SCViewRenderer.inUse ? "block" : "none");
+    });
+  }
+  update(settings, data) {
+    this.plotBtns.update(settings, data);
+  }
+  removeSegments() {
+    if (!Object.keys(this.segments).length) return;
+    for (const [key, segment] of Object.entries(this.segments)) {
+      const plots = segment.subplots.selectAll(".sjpp-output-sandbox-header").size();
+      if (!plots) {
+        segment.title.remove();
+        segment.subplots.remove();
+        delete this.segments[key];
+      }
+    }
+  }
+};
+
+// plots/sc/defaults.ts
+function getDefaultSCAppSettings(overrides = {}, app) {
+  const defaults = {
+    sc: {
+      columns: {
+        // TODO: Implement ds specific column name
+        sample: "Sample"
+      },
+      item: void 0
+    },
+    hierCluster: {
+      unit: app.vocabApi.termdbConfig.queries.geneExpression?.unit || "Gene Expression",
+      yDendrogramHeight: 0,
+      clusterSamples: false
+    }
+  };
+  return Object.assign(defaults, overrides);
+}
+
+// plots/sc/viewModel/plotData.ts
+function formatPlotData(_plots) {
+  const plots = structuredClone(_plots);
+  for (const plot of plots) {
+    const expCells = plot.expCells.sort((a, b) => a.geneExp - b.geneExp);
+    plot.cells = [...plot.noExpCells, ...expCells];
+    const clusters = new Set(plot.cells.map((c) => c.category));
+    plot.clusters = Array.from(clusters).sort((a, b) => {
+      const num1 = parseInt(a.split(" ")[1]);
+      const num2 = parseInt(b.split(" ")[1]);
+      return num1 - num2;
+    });
+  }
+  return plots;
+}
+
+// plots/sc/SC.ts
+var SCViewer = class extends PlotBase {
+  constructor(opts, api) {
+    super(opts, api);
+    this.type = "sc";
+    this.components = {
+      plots: {}
+    };
+    const div = opts.holder.classed("sjpp-sc-main", true).append("div").style("padding", "5px").style("display", "inline-block").style("vertical-align", "top");
+    this.dom = {
+      div,
+      loading: opts.holder.append("div").attr("class", "sjpp-sc-loading").style("position", "absolute").style("top", "0").style("left", "0").style("width", "100%").style("height", "100%").style("background-color", "rgba(255, 255, 255, 0.95)").style("text-align", "center"),
+      selectBtnDiv: div.append("div").attr("id", "sjpp-sc-select-btn"),
+      tableDiv: div.append("div").attr("id", "sjpp-sc-item-table"),
+      plotsBtnsDiv: div.append("div").attr("id", "sjpp-sc-plot-buttons").style("display", "none")
+    };
+    this.segments = {};
+    if (opts.header) opts.header.html(`SINGLE CELL`).style("font-size", "0.9em");
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) {
+      throw new Error(
+        `No plot with id='${this.id}' found. Did you set this.id before this.api = getComponentApi(this)?`
+      );
+    }
+    return {
+      config,
+      subplots: appState.plots.filter((p) => p.parentId === this.id),
+      termfilter: appState.termfilter,
+      termdbConfig: appState.termdbConfig,
+      vocab: appState.vocab
+    };
+  }
+  async init(appState) {
+    const state = this.getState(appState);
+    const dsScSamples = state.termdbConfig.queries?.singleCell?.samples;
+    this.model = new SCModel(this.app, this.id);
+    try {
+      const response = await this.model.getSampleData();
+      if (response.error || !response.samples || !response.samples.length) {
+        this.app.printError("No samples found for this dataset");
+        return;
+      }
+      this.items = response.samples;
+      this.itemColumns = await this.model.getColumnLabels(dsScSamples);
+    } catch (e) {
+      if (e instanceof Error) console.error(`${e.message || e} [SC init()]`);
+      else if (e.stack) console.log(e.stack);
+      throw new Error(e.message || e);
+    }
+    this.interactions = new SCInteractions(this.app, this.dom, this.id, () => this.getState(this.app.getState()));
+    this.viewModel = new SCViewModel(this.app, state.config, this.items, this.itemColumns);
+    this.view = new SCViewRenderer(this.dom, this.interactions, this.segments);
+    this.view.render(this.viewModel.tableData);
+  }
+  //TODO: .text() should be ds specific
+  async initSegment(item) {
+    const caseText = item.case ? `Case: ${item.case}` : "";
+    const itemText = item.sample ? `Sample: ${item.sample}` : "";
+    const projectText = item["project id"] ? `Project: ${item["project id"]}` : "";
+    const headerText = [itemText, caseText, projectText].join(" ");
+    this.segments[item.sample] = {
+      title: this.dom.div.append("div").style("margin-left", "10px").style("padding", "10px").style("font-weight", 600).text(headerText),
+      subplots: this.dom.div.append("div").style("margin-left", "10px")
+    };
+  }
+  /** The plot obj is already in state.plots[] but not rendered
+   * (see SCInteractions). This creates the component and renders the plot */
+  async initSubplotComponent(subplot) {
+    const sandbox = newSandboxDiv(this.segments[subplot.scItem.sample].subplots, {
+      close: () => {
+        delete this.components.plots[subplot.id];
+        this.app.dispatch({
+          type: "plot_delete",
+          id: subplot.id,
+          parentId: this.id
+        });
+        this.view?.removeSegments();
+      },
+      plotId: subplot.id,
+      // beforePlotId: plot.insertBefore || null,
+      style: {
+        //TODO: What width is appropriate here? 50%?
+        width: "98.5%"
+      }
+    });
+    const opts = Object.assign({}, subplot, {
+      app: this.app,
+      holder: sandbox.body,
+      header: sandbox.header,
+      parentId: this.id,
+      id: subplot.id
+    });
+    const { componentInit: componentInit2 } = await importPlot(opts.chartType);
+    this.components.plots[subplot.id] = await componentInit2(opts);
+  }
+  async main() {
+    const state = this.getState(this.app.getState());
+    const config = state.config;
+    if (!this.model) throw new Error(`Model not initialized`);
+    if (!this.viewModel) throw new Error(`ViewModel not initialized`);
+    if (!this.view) throw new Error(`View not initialized`);
+    if (!this.interactions) throw new Error(`Interactions not initialized`);
+    this.interactions.toggleLoading(true);
+    for (const subplot of state.subplots) {
+      if (!this.segments[subplot.scItem.sample]) this.initSegment(subplot.scItem);
+      if (!this.components.plots[subplot.id]) await this.initSubplotComponent(subplot);
+    }
+    let data = null;
+    if (config.settings.sc.item) {
+      try {
+        data = await this.model.getData();
+        if (data.error || !data.plots || !data.plots.length) {
+          this.interactions.toggleLoading(false);
+          this.app.printError(data.error);
+          return;
+        }
+      } catch (e) {
+        this.interactions.toggleLoading(false);
+        if (e instanceof Error) console.error(`${e.message || e} [SC main()]`);
+        else if (e.stack) console.log(e.stack);
+        throw new Error(e.message || e);
+      }
+      data.plots = formatPlotData(data.plots);
+    }
+    this.view.update(config.settings, data);
+    this.interactions.toggleLoading(false);
+  }
+};
+var SCInit = getCompInit(SCViewer);
+var componentInit = SCInit;
+function getPlotConfig(opts, app) {
+  const config = {
+    chartType: "sc",
+    hidePlotFilter: true,
+    settings: getDefaultSCAppSettings(opts.overrides, app)
+  };
+  return copyMerge(config, opts);
+}
+export {
+  SCInit,
+  componentInit,
+  getPlotConfig
+};
+//# sourceMappingURL=SC-SUUATZYR.js.map