@sjcrh/proteinpaint-client 2.210.0 → 2.210.1

package/dist/grin2-FOOH736B.js

@@ -0,0 +1,949 @@
+import {
+  manhattanLayoutDefaults,
+  plotManhattan
+} from "./chunk-YMEWZVRG.js";
+import {
+  PlotBase,
+  controlsInit,
+  filterInit,
+  getCombinedTermFilter,
+  getNormalRoot,
+  make_one_checkbox,
+  make_radios,
+  sayerror,
+  showResultsTable,
+  table2col
+} from "./chunk-CSAS3PVJ.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-T4RYLTR3.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-Y3SDMRDX.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-VTHZGUSZ.js";
+import "./chunk-3TV5WWUN.js";
+import "./chunk-4Y5W26UF.js";
+import {
+  dt2lesion,
+  dtcnv,
+  dtfusionrna,
+  dtitd,
+  dtsnvindel,
+  dtsv,
+  mclass,
+  mclasscnvAmp,
+  mclasscnvHomozygousDel,
+  mclasscnvgain,
+  mclasscnvloh,
+  mclasscnvloss,
+  proteinChangingMutations
+} from "./chunk-UYKJOBRO.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/grin2/model/GRIN2Model.ts
+var GRIN2Model = class {
+  constructor(vocabApi) {
+    this.vocabApi = vocabApi;
+  }
+  async fetchGrin2Data(requestData, signal) {
+    return this.vocabApi.getGrin2Data(requestData, signal);
+  }
+};
+
+// plots/grin2/viewModel/GRIN2ViewModel.ts
+var GRIN2ViewModel = class {
+  constructor(response, manhattanSettings, dtUsage) {
+    this.viewData = {
+      manhattan: response.pngImg ? { plotData: response, settings: manhattanSettings } : null,
+      topGenes: this.buildTopGenes(response, manhattanSettings, dtUsage),
+      statsSections: response.stats?.lst || []
+    };
+  }
+  buildTopGenes(response, manhattanSettings, dtUsage) {
+    if (!response.topGeneTable || !response.stats?.lst) return null;
+    const totalGenes = response.stats.lst[0].rows.find((r) => r[0] === "Total Genes")?.[1] ?? "?";
+    const headerText = `Top Genes (showing ${response.topGeneTable.rows.length.toLocaleString()} of ${totalGenes})`;
+    const qValueEntries = this.buildQValueEntries(response.topGeneTable.columns, dtUsage);
+    const lesionTypeCircleCache = this.buildCircleCache(manhattanSettings.lesionTypeColors);
+    const qValueThreshold = manhattanSettings.qValueThreshold;
+    const rows = response.topGeneTable.rows.map((row) => {
+      const circles = qValueEntries.filter(({ colIndex }) => {
+        const qValue = row[colIndex]?.value;
+        return typeof qValue === "number" && qValue < qValueThreshold;
+      }).map(({ type }) => lesionTypeCircleCache.get(type));
+      return [{ value: "", html: circles.join("") }, ...row];
+    });
+    return {
+      headerText,
+      columns: [{ label: "", width: "20px" }, ...response.topGeneTable.columns],
+      rows,
+      dataItems: response.topGeneTable.rows
+    };
+  }
+  buildQValueEntries(columns, dtUsage) {
+    const dtMapping = {};
+    Object.entries(dt2lesion).forEach(([dt, cfg]) => {
+      dtMapping[dt] = cfg.lesionTypes.map((lt) => ({
+        col: `Q-value (${lt.name})`,
+        type: lt.lesionType
+      }));
+    });
+    const entries = [];
+    Object.entries(dtUsage).forEach(([key, info]) => {
+      const isChecked = typeof info === "object" ? info?.checked : !!info;
+      if (isChecked && dtMapping[key]) {
+        dtMapping[key].forEach(({ col, type }) => {
+          const colIndex = columns.findIndex((c) => c.label === col);
+          if (colIndex !== -1) entries.push({ colIndex, type });
+        });
+      }
+    });
+    return entries;
+  }
+  buildCircleCache(lesionTypeColors) {
+    return new Map(
+      Object.entries(lesionTypeColors).map(([type, color]) => [
+        type,
+        `<span style="display:inline-block;width:8px;height:8px;border-radius:50%;background-color:${color};margin-right:3px;"></span>`
+      ])
+    );
+  }
+};
+
+// plots/grin2/view/GRIN2ResultsView.ts
+var sectionMargin = "20px 0";
+var btnMargin = "10px";
+var headerMargin = "0 10px 0 0";
+var headerFontSize = 14;
+var statsTableFontWeight = "bold";
+var backgroundColor = "#f8f8f8";
+var GRIN2ResultsView = class {
+  constructor(holder, app) {
+    this.holder = holder;
+    this.app = app;
+  }
+  clear() {
+    this.holder.selectAll("*").remove();
+  }
+  render(viewData) {
+    if (viewData.manhattan) {
+      plotManhattan(this.holder, viewData.manhattan.plotData, viewData.manhattan.settings, this.app);
+    }
+    if (viewData.topGenes) {
+      const { headerText, columns, rows, dataItems } = viewData.topGenes;
+      const tableContainer = this.holder.append("div").style("margin", sectionMargin);
+      const headerDiv = tableContainer.append("div").style("display", "flex").style("align-items", "center").style("margin", btnMargin);
+      headerDiv.append("h3").style("margin", headerMargin).style("font-size", `${headerFontSize}px`).text(headerText);
+      showResultsTable({
+        tableDiv: tableContainer.append("div"),
+        app: this.app,
+        columns,
+        rows,
+        dataItems,
+        getRowKey: (row) => row[0]?.value,
+        matrixButtonFormat: "Matrix ({n} genes selected)",
+        maxHeight: "400px",
+        maxWidth: "100%",
+        dataTestId: "sjpp-grin2-top-genes-table",
+        resize: "both",
+        selectAll: false,
+        allowRestoreRowOrder: true,
+        restoreButtonInFooter: true,
+        download: {
+          fileName: `grin2_top_genes_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, -5)}.tsv`
+        },
+        header: {
+          allowSort: true,
+          style: {
+            "font-weight": statsTableFontWeight,
+            "background-color": backgroundColor
+          }
+        }
+      });
+    }
+    if (viewData.statsSections.length > 0) {
+      const tablesContainer = this.holder.append("div").style("margin-top", "50px");
+      for (const section of viewData.statsSections) {
+        tablesContainer.append("h4").style("margin", headerMargin).style("margin-top", "15px").style("font-size", `${headerFontSize - 2}px`).text(section.name);
+        const table = table2col({ holder: tablesContainer.append("div"), margin: "2px 8px" });
+        for (const [k, v] of section.rows) {
+          table.addRow(k, v);
+        }
+      }
+    }
+  }
+};
+
+// plots/grin2/settings/defaults.ts
+var CNV_LOSS_THRESHOLD_FALLBACK = -0.4;
+var CNV_GAIN_THRESHOLD_FALLBACK = 0.4;
+var CNV_MAX_SEG_LENGTH_FALLBACK = 2e6;
+var SNVINDEL_HYPERMUTATOR_FALLBACK = 8e3;
+var CNV_HYPERMUTATOR_FALLBACK = 0;
+var CNV_TYPE_CONFIG = {
+  log2ratio: {
+    lossDefault: CNV_LOSS_THRESHOLD_FALLBACK,
+    gainDefault: CNV_GAIN_THRESHOLD_FALLBACK,
+    lossMin: -5,
+    lossMax: 0,
+    gainMin: 0,
+    gainMax: 5,
+    step: 0.05,
+    hideThresholds: false,
+    unitLabel: "log2 ratio"
+  },
+  segmean: {
+    lossDefault: CNV_LOSS_THRESHOLD_FALLBACK,
+    gainDefault: CNV_GAIN_THRESHOLD_FALLBACK,
+    lossMin: -5,
+    lossMax: 0,
+    gainMin: 0,
+    gainMax: 5,
+    step: 0.05,
+    hideThresholds: false,
+    unitLabel: "segment mean"
+  },
+  copyNumber: {
+    lossDefault: 1,
+    gainDefault: 3,
+    lossMin: 0,
+    lossMax: 2,
+    gainMin: 2,
+    gainMax: 20,
+    step: 1,
+    hideThresholds: false,
+    unitLabel: "copy number"
+  },
+  category: {
+    lossDefault: 0,
+    gainDefault: 0,
+    lossMin: 0,
+    lossMax: 0,
+    gainMin: 0,
+    gainMax: 0,
+    step: 1,
+    hideThresholds: true,
+    unitLabel: ""
+  }
+};
+var EXCLUDE_OVERLAP_FRAC_FALLBACK = 0.5;
+function getDefaultGRIN2Settings(opts) {
+  const defaults = {
+    manhattan: {
+      /* The layout the Manhattan component draws by, from its own module rather than restated
+      here: these 22 keys were a second copy, so a spacing tweak for one plot silently left
+      the other rendering differently. GRIN2's own knobs follow. */
+      ...manhattanLayoutDefaults,
+      // Max genes to show in table
+      maxGenesToShow: 500,
+      // Q-value threshold for significance indicators in the table, tooltips, and for determining which dots become interactive
+      qValueThreshold: 0.05,
+      // Colors for lesion types, derived from the shared dt2lesion source of truth so every data
+      // type (incl. itd and any future dt) is covered without a parallel hardcoded list. Used for
+      // table significance indicators and passed to the Manhattan renderer as dot colors.
+      lesionTypeColors: Object.fromEntries(
+        Object.values(dt2lesion).flatMap((d) => d.lesionTypes.map((lt) => [lt.lesionType, lt.color]))
+      ),
+      // Threshold for the rust code when determining if we need to raise the cap value from the default
+      maxCappedPoints: 5,
+      // Bin size for cap calculations
+      binSize: 10,
+      // Hard cap regardless of data distribution
+      hardCap: 200
+    }
+  };
+  return Object.assign(defaults, opts?.overrides);
+}
+
+// plots/grin2/view/GRIN2ControlsView.ts
+var CNV_CLASS_ORDER = [mclasscnvgain, mclasscnvAmp, mclasscnvloss, mclasscnvHomozygousDel, mclasscnvloh];
+var optionsTextFontSize = 12;
+var tableFontSize = 11;
+var inputWidth = "80px";
+var inputPadding = "2px 4px";
+var inputBorderColor = "#ddd";
+var inputBorderRadius = "2px";
+var checkboxContainerMaxHeight = "150px";
+var checkboxContainerBorder = "1px solid #ddd";
+var controlGap = "8px";
+var checkboxMarginBottom = "2px";
+var checkboxRowLabelWidth = "110px";
+var GRIN2ControlsView = class {
+  constructor(opts) {
+    this.snvindelCheckbox = null;
+    this.cnvCheckbox = null;
+    this.fusionCheckbox = null;
+    this.svCheckbox = null;
+    this.itdCheckbox = null;
+    this.runButton = null;
+    this.consequenceCheckboxes = {};
+    this.snvindelSelectAllBtn = null;
+    this.snvindelClearAllBtn = null;
+    this.snvindelDefaultBtn = null;
+    // one checkbox per supported categorical cnv-segment class (populated only for ds.queries.cnv.type='category')
+    this.cnvCategoryCheckboxes = {};
+    this.cnv_lossThreshold = null;
+    this.cnv_gainThreshold = null;
+    this.cnv_maxSegLength = null;
+    this.cnv_hyperMutator = null;
+    this.snvindel_hyperMutator = null;
+    /** how this ds quantifies cnv values; from the selected cnv type or ds.queries.cnv.type, default 'log2ratio' */
+    this.cnvType = "log2ratio";
+    /** id of the user-selected cnv file type, when the ds exposes singleSampleMutation.cnvTypes (else null) */
+    this.cnvSelectedTypeId = null;
+    // one checkbox per genome-declared blacklist source, keyed by source name
+    this.excludeCheckboxes = {};
+    this.exclude_overlapFrac = null;
+    this.snvindelMafFilter = null;
+    this.headerHolder = opts.headerHolder;
+    this.controlsHolder = opts.controlsHolder;
+    this.config = opts.config;
+    this.vocabApi = opts.vocabApi;
+    this.genome = opts.genome;
+    this.actionsHolder = opts.actionsHolder;
+    this.callbacks = opts.callbacks;
+  }
+  build() {
+    this.headerHolder.style("margin", "15px").html(
+      "GRIN2 stands for Genomic Random Interval (GRIN) statistical model. For details, see <a href=https://pubmed.ncbi.nlm.nih.gov/23842812/ target=_blank>Pounds, S. et al. Bioinformatics 2013</a>."
+    );
+    const table = table2col({ holder: this.controlsHolder, disableScroll: true });
+    const queries = this.vocabApi.termdbConfig.queries;
+    if (queries.snvindel) this.addSnvindelRow(table);
+    if (queries.cnv || queries.singleSampleMutation?.cnvTypes?.length) this.addCnvRow(table);
+    if (queries.svfusion?.dtLst?.includes(dtfusionrna)) this.addFusionRow(table);
+    if (queries.svfusion?.dtLst?.includes(dtsv)) this.addSvRow(table);
+    if (queries.itd) this.addItdRow(table);
+    this.addExcludeRow(table);
+    this.runButton = this.actionsHolder.append("button").attr("data-testid", "sjpp-grin2-run-button").text("Run GRIN2").on("click", () => this.callbacks.onRun());
+    this.updateRunButtonFromCheckboxes();
+  }
+  getDtUsage() {
+    const dtUsage = structuredClone(this.config.settings.dtUsage);
+    if (dtUsage[dtsnvindel]) dtUsage[dtsnvindel].checked = this.snvindelCheckbox.property("checked");
+    if (dtUsage[dtcnv]) dtUsage[dtcnv].checked = this.cnvCheckbox.property("checked");
+    if (dtUsage[dtfusionrna]) dtUsage[dtfusionrna].checked = this.fusionCheckbox.property("checked");
+    if (dtUsage[dtsv]) dtUsage[dtsv].checked = this.svCheckbox.property("checked");
+    if (dtUsage[dtitd]) dtUsage[dtitd].checked = this.itdCheckbox.property("checked");
+    return dtUsage;
+  }
+  getConfigValues(dtUsage) {
+    const requestConfig = {};
+    if (dtUsage[dtsnvindel]?.checked) {
+      requestConfig.snvindelOptions = {
+        consequences: this.getSelectedConsequences()
+      };
+      if (this.snvindel_hyperMutator) {
+        const v = parseFloat(this.snvindel_hyperMutator.property("value"));
+        requestConfig.snvindelOptions.hyperMutator = Number.isFinite(v) ? v : SNVINDEL_HYPERMUTATOR_FALLBACK;
+      }
+      if (this.snvindelMafFilter) {
+        requestConfig.snvindelOptions.mafFilter = this.snvindelMafFilter;
+      }
+    }
+    if (dtUsage[dtcnv]?.checked) {
+      requestConfig.cnvOptions = {
+        maxSegLength: parseFloat(this.cnv_maxSegLength.property("value"))
+      };
+      if (this.cnv_hyperMutator) {
+        const v = parseFloat(this.cnv_hyperMutator.property("value"));
+        requestConfig.cnvOptions.hyperMutator = Number.isFinite(v) ? v : CNV_HYPERMUTATOR_FALLBACK;
+      }
+      if (this.cnvSelectedTypeId) requestConfig.cnvOptions.cnvType = this.cnvSelectedTypeId;
+      if (this.cnv_lossThreshold && this.cnv_gainThreshold) {
+        requestConfig.cnvOptions.lossThreshold = parseFloat(this.cnv_lossThreshold.property("value"));
+        requestConfig.cnvOptions.gainThreshold = parseFloat(this.cnv_gainThreshold.property("value"));
+      }
+      if (Object.keys(this.cnvCategoryCheckboxes).length) {
+        requestConfig.cnvOptions.cnvCategories = this.getSelectedCnvCategories();
+      }
+    }
+    if (dtUsage[dtfusionrna]?.checked) requestConfig.fusionOptions = {};
+    if (dtUsage[dtsv]?.checked) requestConfig.svOptions = {};
+    if (dtUsage[dtitd]?.checked) requestConfig.itdOptions = {};
+    if (Object.keys(this.excludeCheckboxes).length > 0) {
+      const blacklists = Object.entries(this.excludeCheckboxes).filter(([, cb]) => cb.property("checked")).map(([name]) => name);
+      const overlapFracRaw = this.exclude_overlapFrac ? parseFloat(this.exclude_overlapFrac.property("value")) : EXCLUDE_OVERLAP_FRAC_FALLBACK;
+      requestConfig.excludeOptions = {
+        blacklists,
+        overlapFrac: Number.isFinite(overlapFracRaw) ? overlapFracRaw : EXCLUDE_OVERLAP_FRAC_FALLBACK
+      };
+    }
+    return requestConfig;
+  }
+  setBusy(busy) {
+    this.controlsHolder?.style("pointer-events", busy ? "none" : "auto").style("opacity", busy ? "0.5" : "1");
+    this.runButton?.property("disabled", busy).text(busy ? "Running GRIN2..." : "Run GRIN2");
+  }
+  updateRunButtonFromCheckboxes() {
+    const dtUsage = this.snvindelCheckbox ? this.getDtUsage() : this.config.settings.dtUsage;
+    const anyEffective = Object.entries(dtUsage).some(([dt, info]) => {
+      if (!info.checked) return false;
+      if (Number(dt) === dtsnvindel && Object.keys(this.consequenceCheckboxes).length > 0) {
+        return this.getSelectedConsequences().length > 0;
+      }
+      if (Number(dt) === dtcnv && Object.keys(this.cnvCategoryCheckboxes).length > 0) {
+        return this.getSelectedCnvCategories().length > 0;
+      }
+      return true;
+    });
+    this.runButton?.property("disabled", !anyEffective);
+  }
+  getSelectedConsequences() {
+    const consequences = [];
+    Object.entries(this.consequenceCheckboxes).forEach(([classKey, checkbox]) => {
+      if (checkbox.property("checked")) consequences.push(classKey);
+    });
+    return consequences;
+  }
+  addSnvindelRow(table) {
+    const [left, right] = table.addRow();
+    const t2 = table2col({ holder: right });
+    {
+      const [labelCell, containerCell] = t2.addRow();
+      labelCell.text("Consequences").style("padding-top", "8px").style("min-width", checkboxRowLabelWidth);
+      this.createConsequenceCheckboxes(containerCell);
+    }
+    const mafFilterConfig = this.vocabApi.termdbConfig.queries?.snvindel?.mafFilter;
+    if (mafFilterConfig) {
+      this.snvindelMafFilter = structuredClone(
+        this.config.settings?.snvindelOptions?.mafFilter || mafFilterConfig.filter
+      );
+      const [td1, td2] = t2.addRow();
+      td1.text("MAF filter");
+      filterInit({
+        emptyLabel: "+",
+        holder: td2,
+        header_mode: "hide_search",
+        vocab: { terms: mafFilterConfig.terms },
+        callback: async (filter) => {
+          this.snvindelMafFilter = filter;
+        }
+      }).main(this.snvindelMafFilter);
+    }
+    this.snvindel_hyperMutator = this.addOptionRowToTable(
+      t2,
+      "Hypermutator Cutoff",
+      this.config.settings?.snvindelOptions?.hyperMutator ?? SNVINDEL_HYPERMUTATOR_FALLBACK,
+      0,
+      void 0,
+      1
+    ).attr("title", "Exclude a sample from SNV/indel when it has more than this many records. 0 disables.");
+    const isChecked = this.config.settings.dtUsage[dtsnvindel].checked;
+    t2.table.style("display", isChecked ? "" : "none");
+    this.snvindelCheckbox = make_one_checkbox({
+      holder: left,
+      labeltext: dt2lesion[dtsnvindel].uilabel,
+      checked: isChecked,
+      testid: "sjpp-grin2-checkbox-snvindel",
+      callback: (checked) => {
+        t2.table.style("display", checked ? "" : "none");
+        this.updateRunButtonFromCheckboxes();
+      }
+    });
+  }
+  addCnvRow(table) {
+    const [left, right] = table.addRow();
+    const cnvBody = right.append("div");
+    const useSaved = this.config.settings.runAnalysis === true;
+    const savedCnv = useSaved ? this.config.settings.cnvOptions : void 0;
+    const cnvQuery = this.vocabApi.termdbConfig.queries.cnv;
+    const cnvTypes = this.vocabApi.termdbConfig.queries.singleSampleMutation?.cnvTypes;
+    const radioHolder = cnvTypes?.length ? cnvBody.append("div").style("margin-bottom", "6px") : null;
+    const thresholdHolder = cnvBody.append("div");
+    if (cnvTypes?.length) {
+      const savedId = savedCnv?.cnvType;
+      this.cnvSelectedTypeId = savedId && cnvTypes.find((t) => t.id === savedId)?.id || cnvTypes[0].id;
+      make_radios({
+        holder: radioHolder,
+        options: cnvTypes.map((t) => ({
+          label: t.label,
+          value: t.id,
+          checked: t.id === this.cnvSelectedTypeId,
+          testid: `sjpp-grin2-cnvtype-${t.id}`
+        })),
+        styles: { display: "block" },
+        callback: (value) => {
+          this.cnvSelectedTypeId = value;
+          const def = cnvTypes.find((t) => t.id === value);
+          const savedForType = value === savedCnv?.cnvType ? savedCnv : void 0;
+          this.renderCnvThresholdRows(thresholdHolder, def?.valueType ?? "log2ratio", savedForType, cnvQuery);
+        }
+      });
+    } else {
+      this.cnvSelectedTypeId = null;
+    }
+    const initialValueType = (cnvTypes?.length ? cnvTypes.find((t) => t.id === this.cnvSelectedTypeId)?.valueType : cnvQuery?.type) ?? "log2ratio";
+    const initialSaved = !cnvTypes?.length || this.cnvSelectedTypeId === savedCnv?.cnvType ? savedCnv : void 0;
+    this.renderCnvThresholdRows(thresholdHolder, initialValueType, initialSaved, cnvQuery);
+    const dtUsage = this.config.settings.dtUsage;
+    const isChecked = useSaved && dtUsage[dtcnv]?.checked !== void 0 ? dtUsage[dtcnv].checked : !!(cnvQuery || cnvTypes?.length);
+    cnvBody.style("display", isChecked ? "" : "none");
+    this.cnvCheckbox = make_one_checkbox({
+      holder: left,
+      labeltext: dt2lesion[dtcnv].uilabel,
+      checked: isChecked,
+      testid: "sjpp-grin2-checkbox-cnv",
+      callback: (checked) => {
+        cnvBody.style("display", checked ? "" : "none");
+        this.updateRunButtonFromCheckboxes();
+      }
+    });
+  }
+  /** (Re)build the loss/gain/maxSeg inputs for a given cnv value type. Called on first render and whenever
+   *  the user switches cnv type — segmean/copyNumber/log2ratio have type-specific defaults and ranges, and
+   *  'category' is qualitative and hides the thresholds entirely. */
+  renderCnvThresholdRows(holder, valueType, savedCnv, cnvQuery) {
+    holder.selectAll("*").remove();
+    this.cnvType = valueType;
+    const cfg = CNV_TYPE_CONFIG[valueType];
+    this.cnvCategoryCheckboxes = {};
+    if (cfg.hideThresholds) {
+      this.cnv_lossThreshold = null;
+      this.cnv_gainThreshold = null;
+      this.createCnvCategoryCheckboxes(holder, savedCnv);
+    }
+    const t2 = table2col({ holder });
+    if (!cfg.hideThresholds) {
+      this.cnv_lossThreshold = this.addOptionRowToTable(
+        t2,
+        cfg.unitLabel ? `Loss Threshold (${cfg.unitLabel})` : "Loss Threshold",
+        savedCnv?.lossThreshold ?? cnvQuery?.cnvLossCutoff ?? cfg.lossDefault,
+        cfg.lossMin,
+        cfg.lossMax,
+        cfg.step
+      );
+      this.cnv_gainThreshold = this.addOptionRowToTable(
+        t2,
+        cfg.unitLabel ? `Gain Threshold (${cfg.unitLabel})` : "Gain Threshold",
+        savedCnv?.gainThreshold ?? cnvQuery?.cnvGainCutoff ?? cfg.gainDefault,
+        cfg.gainMin,
+        cfg.gainMax,
+        cfg.step
+      );
+    }
+    this.cnv_maxSegLength = this.addOptionRowToTable(
+      t2,
+      "Max Segment Length",
+      savedCnv?.maxSegLength ?? cnvQuery?.cnvMaxLength ?? CNV_MAX_SEG_LENGTH_FALLBACK,
+      0,
+      1e9,
+      1e3
+    );
+    this.cnv_hyperMutator = this.addOptionRowToTable(
+      t2,
+      "Hypermutator Cutoff",
+      savedCnv?.hyperMutator ?? CNV_HYPERMUTATOR_FALLBACK,
+      0,
+      void 0,
+      1
+    ).attr("title", "Exclude a sample from CNV when it has more than this many segments. 0 disables.");
+  }
+  addFusionRow(table) {
+    const [left, right] = table.addRow();
+    const t2 = table2col({ holder: right });
+    const isChecked = this.config.settings.dtUsage[dtfusionrna].checked;
+    t2.table.style("display", isChecked ? "" : "none");
+    this.fusionCheckbox = make_one_checkbox({
+      holder: left,
+      labeltext: dt2lesion[dtfusionrna].uilabel,
+      checked: isChecked,
+      testid: "grin2-checkbox-fusion",
+      callback: (checked) => {
+        t2.table.style("display", checked ? "" : "none");
+        this.updateRunButtonFromCheckboxes();
+      }
+    });
+  }
+  addSvRow(table) {
+    const [left, right] = table.addRow();
+    const t2 = table2col({ holder: right });
+    const isChecked = this.config.settings.dtUsage[dtsv].checked;
+    t2.table.style("display", isChecked ? "" : "none");
+    this.svCheckbox = make_one_checkbox({
+      holder: left,
+      labeltext: dt2lesion[dtsv].uilabel,
+      checked: isChecked,
+      testid: "sjpp-grin2-checkbox-sv",
+      callback: (checked) => {
+        t2.table.style("display", checked ? "" : "none");
+        this.updateRunButtonFromCheckboxes();
+      }
+    });
+  }
+  addItdRow(table) {
+    const [left, right] = table.addRow();
+    const t2 = table2col({ holder: right });
+    const isChecked = this.config.settings.dtUsage[dtitd].checked;
+    t2.table.style("display", isChecked ? "" : "none");
+    this.itdCheckbox = make_one_checkbox({
+      holder: left,
+      labeltext: dt2lesion[dtitd].uilabel,
+      checked: isChecked,
+      testid: "sjpp-grin2-checkbox-itd",
+      callback: (checked) => {
+        t2.table.style("display", checked ? "" : "none");
+        this.updateRunButtonFromCheckboxes();
+      }
+    });
+  }
+  /** Artifact-region mask row. Renders one checkbox per blacklist source declared for the genome
+   * (Genome.blacklists, exposed to the client as {name}[]), plus the gene-overlap-fraction input.
+   * Skipped entirely when the genome declares no blacklists. Unchecking all sources disables the
+   * mask (server resolves an empty source list to no masking). */
+  addExcludeRow(table) {
+    const blacklists = this.genome?.blacklists || [];
+    if (!blacklists.length) return;
+    const [left, right] = table.addRow();
+    left.text("Exclude genes overlapping").style("padding-top", "4px");
+    const savedExclude = this.config.settings.runAnalysis === true ? this.config.settings.excludeOptions : void 0;
+    const savedNames = savedExclude?.blacklists;
+    const isChecked = (name) => savedNames ? savedNames.includes(name) : true;
+    this.excludeCheckboxes = {};
+    const cbContainer = right.append("div").style("margin-bottom", "6px");
+    blacklists.forEach((bl) => {
+      const div = cbContainer.append("div").style("margin-bottom", checkboxMarginBottom);
+      this.excludeCheckboxes[bl.name] = make_one_checkbox({
+        holder: div,
+        labeltext: bl.name,
+        checked: isChecked(bl.name),
+        divstyle: { "font-size": `${tableFontSize}px` },
+        callback: () => {
+        }
+      });
+    });
+    const t2 = table2col({ holder: right });
+    this.exclude_overlapFrac = this.addOptionRowToTable(
+      t2,
+      "Min gene overlap",
+      savedExclude?.overlapFrac ?? EXCLUDE_OVERLAP_FRAC_FALLBACK,
+      0,
+      1,
+      0.05
+    );
+  }
+  addOptionRowToTable(table, label, defaultValue, min, max, step) {
+    const [labelCell, inputCell] = table.addRow();
+    labelCell.text(label);
+    const input = inputCell.append("input").attr("type", "number").attr("value", defaultValue).style("width", inputWidth).style("padding", inputPadding).style("border", `1px solid ${inputBorderColor}`).style("border-radius", inputBorderRadius).style("font-size", `${optionsTextFontSize}px`);
+    if (min !== null && min !== void 0) input.attr("min", min);
+    if (max !== null && max !== void 0) input.attr("max", max);
+    if (step !== null && step !== void 0) input.attr("step", step);
+    return input;
+  }
+  createConsequenceCheckboxes(container) {
+    const snvIndelClasses = Object.entries(mclass).filter(
+      ([key, cls]) => cls.dt === dtsnvindel && key !== "Blank" && key !== "WT"
+    );
+    const saved = this.config.settings.snvindelOptions?.consequences;
+    const useSaved = this.config.settings.runAnalysis === true && !!saved && saved.length > 0;
+    const canonicalDefault = /* @__PURE__ */ new Set([...proteinChangingMutations, "StartLost", "StopLost"]);
+    const initialChecked = useSaved ? new Set(saved) : canonicalDefault;
+    const controlDiv = container.append("div").style("margin-bottom", "6px").style("display", "flex").style("gap", controlGap);
+    this.snvindelSelectAllBtn = controlDiv.append("button").style("font-size", `${tableFontSize}px`).text("Select All");
+    this.snvindelClearAllBtn = controlDiv.append("button").style("font-size", `${tableFontSize}px`).text("Clear All");
+    this.snvindelDefaultBtn = controlDiv.append("button").style("font-size", `${tableFontSize}px`).text("Default");
+    const checkboxContainer = container.append("div").style("max-height", checkboxContainerMaxHeight).style("overflow-y", "auto").style("border", checkboxContainerBorder);
+    this.consequenceCheckboxes = {};
+    snvIndelClasses.forEach(([classKey, classInfo]) => {
+      const checkboxDiv = checkboxContainer.append("div").style("margin-bottom", checkboxMarginBottom);
+      const checkbox = make_one_checkbox({
+        holder: checkboxDiv,
+        labeltext: classInfo.label,
+        checked: initialChecked.has(classKey),
+        divstyle: { "font-size": `${tableFontSize}px` },
+        // clearing every consequence includes nothing, which can disable the run button (see
+        // updateRunButtonFromCheckboxes), so re-evaluate it on each toggle
+        callback: () => this.updateRunButtonFromCheckboxes()
+      });
+      checkboxDiv.select("label").attr("title", classInfo.desc);
+      this.consequenceCheckboxes[classKey] = checkbox;
+    });
+    this.snvindelSelectAllBtn.on("click", () => {
+      Object.values(this.consequenceCheckboxes).forEach((cb) => cb.property("checked", true));
+      this.updateRunButtonFromCheckboxes();
+    });
+    this.snvindelClearAllBtn.on("click", () => {
+      Object.values(this.consequenceCheckboxes).forEach((cb) => cb.property("checked", false));
+      this.updateRunButtonFromCheckboxes();
+    });
+    this.snvindelDefaultBtn.on("click", () => {
+      Object.entries(this.consequenceCheckboxes).forEach(([classKey, checkbox]) => {
+        checkbox.property("checked", canonicalDefault.has(classKey));
+      });
+      this.updateRunButtonFromCheckboxes();
+    });
+  }
+  getSelectedCnvCategories() {
+    const categories = [];
+    Object.entries(this.cnvCategoryCheckboxes).forEach(([classKey, checkbox]) => {
+      if (checkbox.property("checked")) categories.push(classKey);
+    });
+    return categories;
+  }
+  /** One checkbox per categorical cnv-segment class supported by this dataset, all checked by default —
+   * the cnv analog of the snvindel consequence checkboxes. The supported classes are the CNV entries the
+   * dataset declares in termdbConfig.mclass (e.g. GDC: Gain / Heterozygous Deletion / Amplification /
+   * Homozygous Deletion), identified via the global mclass dt; labels prefer the dataset override. Rendered
+   * in its own table2col with a fixed label width so the checkbox box aligns with "Consequences" above. */
+  createCnvCategoryCheckboxes(holder, savedCnv) {
+    const dsMclass = this.vocabApi.termdbConfig?.mclass || {};
+    const cnvClasses = Object.keys(dsMclass).filter((key) => mclass[key]?.dt === dtcnv).map((key) => ({ key, label: dsMclass[key]?.label || mclass[key]?.label || key, desc: mclass[key]?.desc || "" })).sort((a, b) => {
+      const ia = CNV_CLASS_ORDER.indexOf(a.key);
+      const ib = CNV_CLASS_ORDER.indexOf(b.key);
+      return (ia === -1 ? Infinity : ia) - (ib === -1 ? Infinity : ib);
+    });
+    this.cnvCategoryCheckboxes = {};
+    if (!cnvClasses.length) return;
+    const saved = savedCnv?.cnvCategories;
+    const useSaved = this.config.settings.runAnalysis === true && Array.isArray(saved);
+    const initialChecked = useSaved ? new Set(saved) : new Set(cnvClasses.map((c) => c.key));
+    const t2 = table2col({ holder });
+    const [labelCell, containerCell] = t2.addRow();
+    labelCell.text("Classes").style("padding-top", "8px").style("min-width", checkboxRowLabelWidth);
+    const controlDiv = containerCell.append("div").style("margin-bottom", "6px").style("display", "flex").style("gap", controlGap);
+    const selectAllBtn = controlDiv.append("button").style("font-size", `${tableFontSize}px`).text("Select All");
+    const clearAllBtn = controlDiv.append("button").style("font-size", `${tableFontSize}px`).text("Clear All");
+    const checkboxContainer = containerCell.append("div").style("max-height", checkboxContainerMaxHeight).style("overflow-y", "auto").style("border", checkboxContainerBorder).style("margin-bottom", "6px");
+    cnvClasses.forEach((c) => {
+      const checkboxDiv = checkboxContainer.append("div").style("margin-bottom", checkboxMarginBottom);
+      const checkbox = make_one_checkbox({
+        holder: checkboxDiv,
+        labeltext: c.label,
+        checked: initialChecked.has(c.key),
+        divstyle: { "font-size": `${tableFontSize}px` },
+        // clearing every class excludes all cnv, which can disable the run button (see
+        // updateRunButtonFromCheckboxes), so re-evaluate it on each toggle
+        callback: () => this.updateRunButtonFromCheckboxes()
+      });
+      if (c.desc) checkboxDiv.select("label").attr("title", c.desc);
+      this.cnvCategoryCheckboxes[c.key] = checkbox;
+    });
+    selectAllBtn.on("click", () => {
+      Object.values(this.cnvCategoryCheckboxes).forEach((cb) => cb.property("checked", true));
+      this.updateRunButtonFromCheckboxes();
+    });
+    clearAllBtn.on("click", () => {
+      Object.values(this.cnvCategoryCheckboxes).forEach((cb) => cb.property("checked", false));
+      this.updateRunButtonFromCheckboxes();
+    });
+  }
+};
+
+// plots/grin2/grin2.ts
+var GRIN2 = class _GRIN2 extends PlotBase {
+  constructor(opts, api) {
+    super(opts, api);
+    this.controlsView = null;
+    this.controlsToggleButton = null;
+    this.hasResults = false;
+    this.inputPanelCollapsed = false;
+    this.cohortFilterSignature = null;
+    this.type = _GRIN2.type;
+    this.components = { controls: {} };
+    opts.holder.classed("sjpp-grin2-main", true);
+    const massControls = opts.holder.append("div").style("display", "inline-block");
+    const inputPanel = opts.holder.append("div").attr("data-testid", "sjpp-grin2-input-panel").style("display", "grid").style("grid-template-rows", "1fr").style("opacity", "1").style("transition", "grid-template-rows 250ms ease, opacity 200ms ease");
+    const inputPanelContent = inputPanel.append("div").style("min-height", "0").style("overflow", "hidden");
+    this.dom = {
+      massControls,
+      inputPanel,
+      headerText: inputPanelContent.append("div").style("display", "inline-block"),
+      controls: inputPanelContent.append("div"),
+      controlsToggle: opts.holder.append("div").style("display", "flex").style("align-items", "center").style("gap", "8px").style("margin", "10px 20px 10px 100px"),
+      div: opts.holder.append("div").style("margin", "20px")
+    };
+    if (opts.header) this.dom.header = opts.header.text("GRIN2");
+  }
+  static {
+    this.type = "grin2";
+  }
+  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)?`;
+    }
+    const parentConfig = appState.plots.find((p) => p.id === this.parentId);
+    const termfilter = getCombinedTermFilter(appState, config.filter || parentConfig?.filter);
+    return { config, termfilter };
+  }
+  async init() {
+    this.model = new GRIN2Model(this.app.vocabApi);
+    this.resultsView = new GRIN2ResultsView(this.dom.div, this.app);
+    this.controlsToggleButton = this.dom.controlsToggle.append("button").attr("type", "button").attr("data-testid", "sjpp-grin2-input-toggle").style("display", "none").on("click", () => {
+      if (!this.hasResults) return;
+      this.inputPanelCollapsed = !this.inputPanelCollapsed;
+      this.updateInputPanel();
+    });
+    this.updateInputPanel();
+    this.components.controls = await controlsInit({
+      app: this.app,
+      id: this.id,
+      holder: this.dom.massControls.style("display", "inline-block"),
+      inputs: []
+    });
+    const burgerMenu = this.dom.massControls.select("div > svg.bi.bi-copy");
+    if (burgerMenu) burgerMenu.remove();
+    const downloadBtn = this.dom.massControls.select("div > svg.bi.bi-download");
+    if (downloadBtn) downloadBtn.remove();
+    this.components.controls.on("helpClick.grin2", () => {
+      window.open("https://github.com/stjude/proteinpaint/wiki/Grin2");
+    });
+  }
+  async main() {
+    const config = structuredClone(this.state.config);
+    if (config.childType != this.type && config.chartType != this.type) return;
+    const cohortFilterSignature = this.getCohortFilterSignature();
+    if (this.cohortFilterSignature === null) {
+      this.cohortFilterSignature = cohortFilterSignature;
+    } else if (this.cohortFilterSignature !== cohortFilterSignature) {
+      this.cohortFilterSignature = cohortFilterSignature;
+      this.clearResultsAndShowInputs();
+    }
+    if (!this.controlsView) {
+      this.controlsView = new GRIN2ControlsView({
+        headerHolder: this.dom.headerText,
+        controlsHolder: this.dom.controls,
+        config: this.state.config,
+        vocabApi: this.app.vocabApi,
+        genome: this.app.opts.genome,
+        actionsHolder: this.dom.controlsToggle,
+        callbacks: { onRun: () => this.handleRun() }
+      });
+      this.controlsView.build();
+      if (this.state.config.settings.runAnalysis) this.handleRun();
+    }
+  }
+  async handleRun() {
+    if (!this.controlsView) return;
+    const runFilterSignature = this.cohortFilterSignature;
+    this.clearResultsAndShowInputs();
+    this.controlsView.setBusy(true);
+    try {
+      const dtUsage = this.controlsView.getDtUsage();
+      const configValues = this.controlsView.getConfigValues(dtUsage);
+      const manhattan = this.state.config.settings.manhattan;
+      const requestData = {
+        filter: getNormalRoot(this.state.termfilter.filter),
+        filter0: this.state.termfilter.filter0,
+        width: manhattan?.plotWidth,
+        height: manhattan?.plotHeight,
+        pngDotRadius: manhattan?.pngDotRadius,
+        devicePixelRatio: window.devicePixelRatio,
+        maxGenesToShow: manhattan?.maxGenesToShow,
+        lesionTypeColors: manhattan?.lesionTypeColors,
+        qValueThreshold: manhattan?.qValueThreshold,
+        maxCappedPoints: manhattan?.maxCappedPoints,
+        hardCap: manhattan?.hardCap,
+        binSize: manhattan?.binSize,
+        ...configValues
+      };
+      const response = await this.model.fetchGrin2Data(requestData, this.api.getAbortSignal());
+      if (response.status === "error") throw `GRIN2 analysis failed: ${response.error}`;
+      if (runFilterSignature !== this.cohortFilterSignature) return;
+      const vm = new GRIN2ViewModel(response, manhattan, dtUsage);
+      this.resultsView.render(vm.viewData);
+      this.hasResults = true;
+      this.inputPanelCollapsed = true;
+      this.updateInputPanel();
+      this.app.dispatch({
+        type: "plot_edit",
+        id: this.id,
+        config: {
+          ...this.state.config,
+          settings: {
+            ...this.state.config.settings,
+            ...configValues,
+            dtUsage,
+            runAnalysis: true
+          }
+        }
+      });
+    } catch (error) {
+      if (this.app.isAbortError(error)) return;
+      if (this.dom.div) {
+        sayerror(this.dom.div, `Error running GRIN2: ${error instanceof Error ? error.message : error}`);
+      }
+    } finally {
+      this.controlsView?.setBusy(false);
+    }
+  }
+  getCohortFilterSignature() {
+    return JSON.stringify({
+      filter: this.state.termfilter?.filter ?? null,
+      filter0: this.state.termfilter?.filter0 ?? null
+    });
+  }
+  clearResultsAndShowInputs() {
+    this.resultsView.clear();
+    this.hasResults = false;
+    this.inputPanelCollapsed = false;
+    this.updateInputPanel();
+  }
+  updateInputPanel() {
+    this.dom.inputPanel.attr("aria-hidden", String(this.inputPanelCollapsed)).property("inert", this.inputPanelCollapsed).style("grid-template-rows", this.inputPanelCollapsed ? "0fr" : "1fr").style("opacity", this.inputPanelCollapsed ? "0" : "1").style("pointer-events", this.inputPanelCollapsed ? "none" : "auto");
+    this.controlsToggleButton?.style("display", this.hasResults ? null : "none");
+    this.dom.controlsToggle.select('[data-testid="sjpp-grin2-run-button"]').style("display", this.inputPanelCollapsed ? "none" : null);
+    this.controlsToggleButton?.attr("aria-expanded", String(!this.inputPanelCollapsed)).text(this.inputPanelCollapsed ? "Show input options" : "Hide input options");
+  }
+};
+var grin2Init = getCompInit(GRIN2);
+var componentInit = grin2Init;
+async function getPlotConfig(opts, app) {
+  const queries = app.vocabApi.termdbConfig.queries;
+  const defaultSettings = getDefaultGRIN2Settings(opts);
+  const dtUsage = {};
+  if (queries?.snvindel) {
+    dtUsage[dtsnvindel] = { checked: true, label: dt2lesion[dtsnvindel].uilabel };
+  }
+  if (queries?.cnv || queries?.singleSampleMutation?.cnvTypes?.length) {
+    dtUsage[dtcnv] = { checked: true, label: dt2lesion[dtcnv].uilabel };
+  }
+  if (queries?.svfusion) {
+    if (queries.svfusion.dtLst.includes(dtfusionrna)) {
+      dtUsage[dtfusionrna] = { checked: false, label: dt2lesion[dtfusionrna].uilabel };
+    }
+    if (queries.svfusion.dtLst.includes(dtsv)) {
+      dtUsage[dtsv] = { checked: false, label: dt2lesion[dtsv].uilabel };
+    }
+  }
+  if (queries?.itd) {
+    dtUsage[dtitd] = { checked: false, label: dt2lesion[dtitd].uilabel };
+  }
+  const config = {
+    chartType: "grin2",
+    settings: {
+      controls: {},
+      dtUsage,
+      runAnalysis: false,
+      manhattan: {
+        ...defaultSettings.manhattan,
+        ...opts?.manhattan
+      }
+    }
+  };
+  return copyMerge(config, opts);
+}
+export {
+  componentInit,
+  getPlotConfig,
+  grin2Init
+};
+//# sourceMappingURL=grin2-FOOH736B.js.map