@sjcrh/proteinpaint-client 2.201.0 → 2.202.0

package/dist/brainImaging-F4GZRF53.js

@@ -0,0 +1,423 @@
+import {
+  controlsInit,
+  getT0T2defaultQ,
+  renderTable,
+  svgLegend
+} from "./chunk-73PFJ2VF.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-XFAL46LZ.js";
+import "./chunk-ZZMIDYRE.js";
+import {
+  Menu
+} from "./chunk-HYOEWQ5P.js";
+import "./chunk-6QCYT6G2.js";
+import "./chunk-FN5XPUPH.js";
+import "./chunk-VSSZJHOR.js";
+import "./chunk-5RUVBYLK.js";
+import "./chunk-ZFJUVP2N.js";
+import "./chunk-R3ARQMM4.js";
+import {
+  dofetch3
+} from "./chunk-X4QQRHFB.js";
+import "./chunk-4WF3XDQP.js";
+import "./chunk-X6VTVZY7.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-H6INPPUC.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-L44P5N4U.js";
+import "./chunk-GEQUQ3GG.js";
+import "./chunk-WPHUM5S5.js";
+import "./chunk-75T7ESEO.js";
+import "./chunk-2KXLYFAO.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-VQZ2Z5YU.js";
+import {
+  linear
+} from "./chunk-UJELJXJG.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import {
+  rgb
+} from "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HFNDKYVF.js";
+
+// plots/brainImaging.js
+var BrainImaging = class _BrainImaging {
+  static type = "brainImaging";
+  constructor(opts) {
+    this.opts = opts;
+    this.type = _BrainImaging.type;
+    setInteractivity(this);
+  }
+  async init(appState) {
+    const state = this.getState(appState);
+    const holder = this.opts.holder;
+    if (this.opts.header)
+      this.opts.header.style("padding-left", "7px").style("color", "rgb(85, 85, 85)").html(`Brain Imaging: ${state.config.queryKey}/${state.config.selectedSampleFileNames.join(" ")}`);
+    const controlsHolder = holder.append("div").style("display", "inline-block").style("vertical-align", "top");
+    const rightDiv = holder.append("div").style("display", "inline-block").style("vertical-align", "top");
+    const headerHolder = rightDiv.append("div").style("display", "inline-block").style("vertical-align", "top").style("padding", "10px");
+    const contentHolder = rightDiv.append("div").style("vertical-align", "top");
+    const table = contentHolder.append("table").style("border-collapse", "collapse");
+    const headerTr = table.append("tr");
+    const contentTr = table.append("tr").style("background-color", "black");
+    const tdL = contentTr.append("td");
+    const tdF = contentTr.append("td");
+    const tdT = contentTr.append("td");
+    const legendHolder = contentHolder.append("svg").style("width", "100%").on("mouseup", this.legendLabelMouseup);
+    const legendMenu = new Menu({ padding: "0px" });
+    this.dom = {
+      headerHolder,
+      contentHolder,
+      headerTr,
+      tdL,
+      tdF,
+      tdT,
+      legendHolder,
+      legendMenu
+    };
+    this.addSliders(state.config.settings.brainImaging);
+    const configInputsOptions = this.getConfigInputsOptions(state);
+    this.components = {
+      controls: await controlsInit({
+        app: this.app,
+        id: this.id,
+        holder: controlsHolder,
+        inputs: configInputsOptions
+      })
+    };
+    this.components.controls.on("downloadClick.brainImaging", () => {
+      const urls = [];
+      for (const key in this.imagesData)
+        for (const category in this.imagesData[key].dataUrls) {
+          const dataUrl = this.imagesData[key].dataUrls[category].url;
+          urls.push(dataUrl);
+        }
+      this.downloadImage(urls);
+    });
+    this.legendRenderer = svgLegend({ holder: this.dom.legendHolder });
+  }
+  addSliders(settings) {
+    const tr = this.dom.headerTr;
+    let td = tr.append("td");
+    td.append("label").attr("for", "saggital").text("Sagittal:");
+    this.dom.saggitalSlider = td.append("input").attr("id", "saggital").attr("type", "range").attr("min", 0).attr("max", 192).attr("value", settings.brainImageL).on("change", (e) => {
+      this.editBrainImage("brainImageL", e.target.value);
+    });
+    this.dom.saggitalInput = td.append("input").attr("type", "number").attr("min", 0).attr("max", 192).attr("value", settings.brainImageL).on("change", (e) => {
+      this.editBrainImage("brainImageL", e.target.value);
+    }).style("vertical-align", "top");
+    td = tr.append("td");
+    td.append("label").attr("for", "coronal").text("Coronal:");
+    this.dom.coronalSlider = td.append("input").attr("type", "range").attr("min", 0).attr("max", 228).attr("value", settings.brainImageF).on("change", (e) => {
+      this.editBrainImage("brainImageF", e.target.value);
+    });
+    this.dom.coronalInput = td.append("input").attr("type", "number").attr("min", 0).attr("max", 192).attr("value", settings.brainImageF).on("change", (e) => {
+      this.editBrainImage("brainImageF", e.target.value);
+    }).style("vertical-align", "top");
+    td = tr.append("td");
+    td.append("label").attr("for", "axial").text("Axial:");
+    this.dom.axialSlider = td.append("input").attr("id", "axial").attr("type", "range").attr("min", 0).attr("max", 192).attr("value", settings.brainImageT).on("change", (e) => {
+      this.editBrainImage("brainImageT", e.target.value);
+    });
+    this.dom.axialInput = td.append("input").attr("type", "number").attr("min", 0).attr("max", 192).attr("value", settings.brainImageT).on("change", (e) => {
+      this.editBrainImage("brainImageT", e.target.value);
+    });
+  }
+  editBrainImage(key, value) {
+    if (!value) return;
+    const settings = { [key]: Number(value) };
+    this.app.dispatch({ type: "plot_edit", id: this.id, config: { settings: { brainImaging: settings } } });
+  }
+  downloadImage(dataUrls) {
+    for (const dataUrl of dataUrls) {
+      const downloadImgName = "brainImaging";
+      const a = document.createElement("a");
+      document.body.appendChild(a);
+      a.addEventListener(
+        "click",
+        () => {
+          a.download = downloadImgName + ".png";
+          a.href = dataUrl;
+          document.body.removeChild(a);
+        },
+        false
+      );
+      a.click();
+    }
+  }
+  getConfigInputsOptions(state) {
+    if (state.config.selectedSampleFileNames.length == 1) return [];
+    const mandatoryConfigInputOptions = [
+      {
+        label: "Divide by",
+        type: "term",
+        chartType: "brainImaging",
+        configKey: "divideByTW",
+        title: "Categories to divide by",
+        usecase: { target: "brainImaging", detail: "term0" },
+        vocabApi: this.app.vocabApi,
+        numericEditMenuVersion: ["discrete"],
+        defaultQ4fillTW: getT0T2defaultQ()
+      },
+      {
+        label: "Color by",
+        type: "term",
+        chartType: "brainImaging",
+        configKey: "overlayTW",
+        title: "Categories to color the samples",
+        usecase: { target: "brainImaging", detail: "term2" },
+        vocabApi: this.app.vocabApi,
+        numericEditMenuVersion: ["discrete"],
+        defaultQ4fillTW: getT0T2defaultQ()
+      }
+    ];
+    return mandatoryConfigInputOptions;
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    return {
+      config,
+      dslabel: appState.vocab.dslabel,
+      genome: appState.vocab.genome,
+      RefNIdata: appState.termdbConfig.queries.NIdata[config.queryKey]
+    };
+  }
+  async main() {
+    this.config = structuredClone(this.state.config);
+    this.settings = this.state.config.settings.brainImaging;
+    this.dom.saggitalSlider.property("value", this.settings.brainImageL);
+    this.dom.saggitalInput.property("value", this.settings.brainImageL);
+    this.dom.coronalSlider.property("value", this.settings.brainImageF);
+    this.dom.coronalInput.property("value", this.settings.brainImageF);
+    this.dom.axialSlider.property("value", this.settings.brainImageT);
+    this.dom.axialInput.property("value", this.settings.brainImageT);
+    const data = await Promise.all([
+      this.requestImage("l", this.settings.brainImageL),
+      this.requestImage("f", this.settings.brainImageF),
+      this.requestImage("t", this.settings.brainImageT)
+    ]);
+    this.imagesData = {
+      brainImageL: { dataUrls: {}, td: this.dom.tdL, data: data[0] },
+      brainImageF: { dataUrls: {}, td: this.dom.tdF, data: data[1] },
+      brainImageT: { dataUrls: {}, td: this.dom.tdT, data: data[2] }
+    };
+    for (const img of Object.values(this.imagesData)) this.renderImages(img);
+    this.renderLegend();
+  }
+  async requestImage(key, value) {
+    const body = {
+      genome: this.state.genome,
+      dslabel: this.state.dslabel,
+      refKey: this.state.config.queryKey,
+      [key]: value,
+      selectedSampleFileNames: this.state.config.selectedSampleFileNames,
+      divideByTW: this.state.config.divideByTW,
+      overlayTW: this.state.config.overlayTW,
+      legendFilter: this.state.config.legendFilter
+    };
+    return await dofetch3("brainImaging", { body });
+  }
+  renderImages({ data, td, dataUrls }) {
+    this.legendValues = data.legend;
+    if (data.error) throw data.error;
+    for (const [termV, result] of Object.entries(data.brainImage)) {
+      dataUrls[termV] = result;
+    }
+    td.selectAll("*").remove();
+    for (const [termV, result] of Object.entries(dataUrls)) {
+      if (this.state.config.divideByTW)
+        td.append("div").attr("class", "pp-chart-title").style("text-align", "center").text(`${termV} (n=${result.catNum})`).style("font-weight", "600").style("color", "white").style("font-size", "24px").style("margin-bottom", "5px").style("margin-top", "5px").style("display", "block");
+      td.append("div").append("img").attr("src", result.url);
+    }
+  }
+  renderLegend() {
+    const legendItems = [];
+    for (const [label, v] of Object.entries(this.legendValues)) {
+      const scale = linear(["white", v.color], [0, v.maxLength]).clamp(true);
+      legendItems.push({
+        text: label == "default" ? "Combined Intensity" : label,
+        width: 100,
+        scale,
+        colors: ["white", v.color],
+        domain: [0, v.maxLength],
+        key: label,
+        crossedOut: v.crossedOut
+      });
+    }
+    this.legendItems = legendItems;
+    const legendRendererData = [
+      {
+        items: legendItems
+      }
+    ];
+    this.legendRenderer(legendRendererData, {
+      settings: {
+        fontsize: 16,
+        iconh: 14,
+        iconw: 14,
+        dimensions: {
+          xOffset: 0
+        }
+      }
+    });
+  }
+};
+function makeChartBtnMenu(holder, chartsInstance) {
+  chartsInstance.dom.tip.clear();
+  const menuDiv = holder.append("div");
+  if (chartsInstance.state.termdbConfig.queries.NIdata) {
+    for (const [refKey, ref] of Object.entries(chartsInstance.state.termdbConfig.queries.NIdata)) {
+      const refDiv = menuDiv.append("div");
+      const refOption = refDiv.append("div").attr("class", "sja_menuoption sja_sharp_border").text(refKey).on("click", async () => {
+        refOption.attr("class", "sja_menuoption_not_interactive");
+        refOption.on("click", null);
+        const body = {
+          genome: chartsInstance.opts.vocab.genome,
+          dslabel: chartsInstance.opts.vocab.dslabel,
+          refKey,
+          samplesOnly: true
+        };
+        const result = await dofetch3("brainImagingSamples", { body });
+        const samples = result.samples;
+        const [rows, columns] = await getTableData(chartsInstance, samples, chartsInstance.state, refKey);
+        const applybt = {
+          text: "APPLY",
+          class: "sjpp_apply_btn sja_filter_tag_btn",
+          callback: (indexes) => {
+            chartsInstance.dom.tip.hide();
+            const selectedSampleFileNames = indexes.map((i) => samples[i].sample + ".nii");
+            const config = {
+              chartType: "brainImaging",
+              queryKey: refKey,
+              settings: {
+                brainImaging: {
+                  brainImageL: ref.parameters.l,
+                  brainImageF: ref.parameters.f,
+                  brainImageT: ref.parameters.t
+                }
+              },
+              selectedSampleFileNames
+            };
+            chartsInstance.app.dispatch({
+              type: "plot_create",
+              config
+            });
+          }
+        };
+        renderTable({
+          rows,
+          columns,
+          resize: true,
+          singleMode: false,
+          div: refDiv.append("div"),
+          maxHeight: "40vh",
+          buttons: [applybt]
+        });
+      });
+    }
+  }
+}
+var brainImaging = getCompInit(BrainImaging);
+var componentInit = brainImaging;
+async function getPlotConfig(opts) {
+  const settings = {
+    brainImaging: { brainImageL: 76, brainImageF: 116, brainImageT: 80 }
+  };
+  const config = { chartType: "brainImaging", settings, hidePlotFilter: true };
+  return copyMerge(config, opts);
+}
+async function getTableData(self, samples, state, refKey) {
+  const rows = [];
+  for (const sample of samples) {
+    const row = [{ value: sample.sample }];
+    for (const c of state.termdbConfig.queries.NIdata[refKey].sampleColumns || []) {
+      row.push({ value: sample[c.termid] });
+    }
+    rows.push(row);
+  }
+  const columns = [{ label: "Sample" }];
+  for (const c of state.termdbConfig.queries.NIdata[refKey].sampleColumns || []) {
+    columns.push({
+      label: (await self.app.vocabApi.getterm(c.termid)).name
+    });
+  }
+  return [rows, columns];
+}
+function setInteractivity(self) {
+  self.legendLabelMouseup = (event) => {
+    const targetData = event.target.__data__;
+    if (!targetData || targetData.key == "default") return;
+    const legendMenu = self.dom.legendMenu.clear();
+    const legendMenuDiv = legendMenu.d.append("div");
+    const legendFilter = self.state.config.legendFilter ? [...self.state.config.legendFilter] : [];
+    const legendFilterIndex = legendFilter.indexOf(targetData.key);
+    if (legendFilterIndex !== -1 || legendFilter.length + 1 !== self.legendItems.length) {
+      legendMenuDiv.append("div").attr("class", "sja_menuoption sja_sharp_border").text(legendFilterIndex == -1 ? "Hide" : "Show").on("click", () => {
+        legendMenu.hide();
+        if (legendFilterIndex == -1) legendFilter.push(targetData.key);
+        else legendFilter.splice(legendFilterIndex, 1);
+        self.app.dispatch({
+          type: "plot_edit",
+          id: self.id,
+          config: { legendFilter }
+        });
+      });
+    }
+    legendMenuDiv.append("div").attr("class", "sja_menuoption sja_sharp_border").text("Show only").on("click", () => {
+      legendMenu.hide();
+      const legendFilter2 = [];
+      for (const legendCat of self.legendItems) {
+        if (legendCat.key !== targetData.key) legendFilter2.push(legendCat.key);
+      }
+      self.app.dispatch({
+        type: "plot_edit",
+        id: self.id,
+        config: { legendFilter: legendFilter2 }
+      });
+    });
+    legendMenuDiv.append("div").attr("class", "sja_menuoption sja_sharp_border").text("Show all").on("click", () => {
+      legendMenu.hide();
+      self.app.dispatch({
+        type: "plot_edit",
+        id: self.id,
+        config: { legendFilter: [] }
+      });
+    });
+    if (self.state.config.overlayTW.term.type != "geneVariant") {
+      let color = self.state.config.overlayTW?.term?.values?.[targetData.key]?.color || "red";
+      color = rgb(color).formatHex();
+      legendMenuDiv.append("div").attr("class", "sja_sharp_border").style("padding", "0px 10px").text("Color:").append("input").attr("type", "color").attr("value", color).on("change", (e) => {
+        self.changeColor(targetData.key, e.target.value);
+      });
+    }
+    legendMenu.showunder(event.target);
+  };
+  self.changeColor = async function(key, color) {
+    const tw = self.config.overlayTW;
+    if (!(tw.term.type == "geneVariant" && tw.q.type == "values") && tw.term.values[key])
+      tw.term.values[key].color = color;
+    else {
+      if (!tw.term.values) tw.term.values = {};
+      if (!tw.term.values[key]) tw.term.values[key] = {};
+      tw.term.values[key].color = color;
+    }
+    await self.app.dispatch({
+      type: "plot_edit",
+      id: self.id,
+      config: { overlayTW: tw }
+    });
+  };
+}
+export {
+  brainImaging,
+  componentInit,
+  getPlotConfig,
+  makeChartBtnMenu
+};
+//# sourceMappingURL=brainImaging-F4GZRF53.js.map

package/dist/brainRegions-ONUXPD7P.js

@@ -0,0 +1,221 @@
+import {
+  loadBrainAssets,
+  renderBrainSvg
+} from "./chunk-VVDFRJVN.js";
+import {
+  PlotBase,
+  addGeneSearchbox
+} from "./chunk-73PFJ2VF.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-XFAL46LZ.js";
+import "./chunk-ZZMIDYRE.js";
+import {
+  Menu
+} from "./chunk-HYOEWQ5P.js";
+import "./chunk-6QCYT6G2.js";
+import "./chunk-FN5XPUPH.js";
+import "./chunk-VSSZJHOR.js";
+import "./chunk-5RUVBYLK.js";
+import "./chunk-ZFJUVP2N.js";
+import "./chunk-R3ARQMM4.js";
+import {
+  dofetch3
+} from "./chunk-X4QQRHFB.js";
+import "./chunk-4WF3XDQP.js";
+import "./chunk-X6VTVZY7.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-H6INPPUC.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-L44P5N4U.js";
+import "./chunk-GEQUQ3GG.js";
+import "./chunk-WPHUM5S5.js";
+import "./chunk-75T7ESEO.js";
+import "./chunk-2KXLYFAO.js";
+import "./chunk-LOZEKOES.js";
+import "./chunk-VQZ2Z5YU.js";
+import {
+  linear
+} from "./chunk-UJELJXJG.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-HFNDKYVF.js";
+
+// plots/brainRegions.ts
+var defaultConfig = {
+  chartType: "brainRegions"
+};
+var P_VALUE_THRESHOLD = 0.05;
+var NONSIG_COLOR = "#ccc";
+var BRAIN_RENDER_W = 520;
+var gradientSeq = 0;
+var BrainRegions = class _BrainRegions extends PlotBase {
+  static {
+    this.type = "brainRegions";
+  }
+  constructor(opts, api) {
+    super(opts, api);
+    this.type = _BrainRegions.type;
+  }
+  async init() {
+    const holder = this.opts.holder.append("div").style("padding", "10px");
+    this.dom = {
+      holder,
+      body: holder.append("div"),
+      tip: new Menu({ padding: "" }),
+      header: this.opts.header
+    };
+    if (this.dom.header) this.dom.header.html("Brain Regional Proteome");
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) throw `No plot with id='${this.id}' found`;
+    return { config };
+  }
+  async main() {
+    const gene = this.state.config?.gene;
+    if (!gene) throw new Error("brainRegions: gene is missing");
+    if (this.dom.header) this.dom.header.text(`Brain Regional Proteome: ${gene}`);
+    const body = {
+      genome: this.app.opts.state.vocab.genome,
+      dslabel: this.app.opts.state.vocab.dslabel,
+      gene
+    };
+    const data = await dofetch3("termdb/brainRegions", { body });
+    if (data.error) throw data.error;
+    this.dom.body.selectAll("*").remove();
+    const description = this.app.vocabApi.termdbConfig?.queries?.proteome?.brainRegions?.description;
+    if (description) {
+      this.dom.body.append("div").style("font-size", "0.85em").style("color", "#555").style("margin-bottom", "10px").style("line-height", "1.4").style("max-width", "600px").style("white-space", "normal").style("overflow-wrap", "break-word").text(description);
+    }
+    const isoformIds = Object.keys(data.isoforms);
+    if (isoformIds.length === 0) {
+      this.dom.body.append("div").style("padding", "20px").style("color", "#666").text(`No brain-region data found for gene "${gene}".`);
+      return;
+    }
+    const brainAssets = await loadBrainAssets(data.svgUrl, Object.keys(data.regions));
+    const controlRow = this.dom.body.append("div").style("margin-bottom", "15px");
+    controlRow.append("span").style("font-weight", "bold").text("Isoform: ");
+    const selectedIsoform = isoformIds[0];
+    if (isoformIds.length > 1) {
+      const sel = controlRow.append("select").style("margin-left", "5px").style("padding", "3px 6px").on("change", () => {
+        this.renderBrains(data, sel.node().value, brainAssets);
+      });
+      sel.selectAll("option").data(isoformIds).enter().append("option").attr("value", (d) => d).text((d) => `${data.isoforms[d].gene_name} \u2014 ${d}`);
+    } else {
+      controlRow.append("span").style("margin-left", "5px").text(`${data.isoforms[selectedIsoform].gene_name} \u2014 ${selectedIsoform}`);
+    }
+    this.renderBrains(data, selectedIsoform, brainAssets);
+  }
+  renderBrains(data, selectedIsoform, brainAssets) {
+    const existing = this.dom.body.select(".sjpp-brain-regions-container");
+    if (!existing.empty()) existing.remove();
+    const container = this.dom.body.append("div").attr("class", "sjpp-brain-regions-container").style("display", "flex").style("gap", "40px").style("flex-wrap", "wrap");
+    const isoformData = data.isoforms[selectedIsoform];
+    if (!isoformData) return;
+    const allFCs = [];
+    for (const disease of data.diseases) {
+      const regionData = isoformData.data[disease] || {};
+      for (const entry of Object.values(regionData)) {
+        if (entry.p_value < P_VALUE_THRESHOLD) {
+          allFCs.push(entry.fold_change);
+        }
+      }
+    }
+    const maxAbsFC = allFCs.length > 0 ? Math.max(...allFCs.map((v) => Math.abs(v))) : 1;
+    const colorScale = linear().domain([-maxAbsFC, 0, maxAbsFC]).range(["#2166ac", "#f7f7f7", "#b2182b"]).clamp(true);
+    for (const disease of data.diseases) {
+      const regionData = isoformData.data[disease] || {};
+      renderBrainSvg({
+        holder: container,
+        width: BRAIN_RENDER_W,
+        templateUrl: data.templateUrl,
+        assets: brainAssets,
+        regions: data.regions,
+        title: disease,
+        tip: this.dom.tip,
+        fillByRegion: (code) => {
+          const entry = regionData[code];
+          if (entry && entry.p_value < P_VALUE_THRESHOLD) return colorScale(entry.fold_change);
+          return NONSIG_COLOR;
+        },
+        tooltipByRegion: (code, label) => {
+          const entry = regionData[code];
+          if (!entry) return `${label} (${code})
+No data`;
+          const fc = entry.fold_change.toFixed(4);
+          const p = entry.p_value >= 1e-4 ? entry.p_value.toFixed(4) : entry.p_value.toExponential(3);
+          return `${label} (${code})
+log\u2082 fold change: ${fc}
+p-value: ${p}`;
+        }
+      });
+    }
+    this.renderLegend(container, colorScale, maxAbsFC);
+  }
+  renderLegend(container, colorScale, maxAbsFC) {
+    const legendDiv = container.append("div").style("display", "flex").style("flex-direction", "column").style("justify-content", "center").style("padding", "10px");
+    legendDiv.append("div").style("font-weight", "bold").style("font-size", "13px").style("margin-bottom", "8px").text("Fold Change (log\u2082)");
+    const legendWidth = 20;
+    const legendHeight = 200;
+    const svg = legendDiv.append("svg").attr("width", legendWidth + 60).attr("height", legendHeight + 30);
+    const defs = svg.append("defs");
+    const gradientId = `brain-fc-gradient-${gradientSeq++}`;
+    const gradient = defs.append("linearGradient").attr("id", gradientId).attr("x1", "0").attr("y1", "0").attr("x2", "0").attr("y2", "1");
+    const steps = 10;
+    for (let i = 0; i <= steps; i++) {
+      const t = i / steps;
+      const val = maxAbsFC * (1 - 2 * t);
+      gradient.append("stop").attr("offset", `${t * 100}%`).attr("stop-color", colorScale(val));
+    }
+    svg.append("rect").attr("x", 0).attr("y", 10).attr("width", legendWidth).attr("height", legendHeight).style("fill", `url(#${gradientId})`).attr("stroke", "#999");
+    const legendScale = linear().domain([maxAbsFC, -maxAbsFC]).range([10, legendHeight + 10]);
+    const ticks = [-maxAbsFC, -maxAbsFC / 2, 0, maxAbsFC / 2, maxAbsFC];
+    for (const tick of ticks) {
+      const y = legendScale(tick);
+      svg.append("line").attr("x1", legendWidth).attr("y1", y).attr("x2", legendWidth + 5).attr("y2", y).attr("stroke", "#666");
+      svg.append("text").attr("x", legendWidth + 8).attr("y", y).attr("dominant-baseline", "central").attr("font-size", "10px").text(tick.toFixed(2));
+    }
+    legendDiv.append("div").style("margin-top", "10px").style("font-size", "12px").style("color", "#666").html(
+      `<span style="display:inline-block;width:14px;height:14px;background:${NONSIG_COLOR};border:1px solid #999;vertical-align:middle;margin-right:4px"></span> Not significant (p \u2265 0.05)`
+    );
+  }
+};
+var componentInit = getCompInit(BrainRegions);
+async function getPlotConfig(opts) {
+  const config = structuredClone(defaultConfig);
+  if (!opts.gene) throw new Error("brainRegions requires opts.gene");
+  return copyMerge(config, opts);
+}
+function makeChartBtnMenu(holder, chartsInstance) {
+  const row = holder.append("div").style("padding", "5px");
+  row.append("span").style("font-weight", "bold").text("Enter a gene name:");
+  const geneSearch = addGeneSearchbox({
+    row,
+    genome: chartsInstance.app.opts.genome,
+    tip: new Menu({ padding: "0px" }),
+    searchOnly: "gene",
+    callback: async () => {
+      if (!geneSearch.geneSymbol) throw new Error("A valid gene selection is required");
+      chartsInstance.dom.tip.hide();
+      chartsInstance.app.dispatch({
+        type: "plot_create",
+        config: {
+          chartType: "brainRegions",
+          gene: geneSearch.geneSymbol
+        }
+      });
+    }
+  });
+}
+export {
+  componentInit,
+  getPlotConfig,
+  makeChartBtnMenu
+};
+//# sourceMappingURL=brainRegions-ONUXPD7P.js.map