@sjcrh/proteinpaint-client 2.205.0 → 2.206.1

package/dist/geneExpClustering-7EEK4LBZ.js

@@ -0,0 +1,244 @@
+import {
+  appInit
+} from "./chunk-IUREQGFN.js";
+import "./chunk-AGUZCQDL.js";
+import "./chunk-X46YA4CB.js";
+import "./chunk-SKMFMGCD.js";
+import {
+  fillTermWrapper,
+  vocabInit
+} from "./chunk-XDLCPJCK.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-TU2E4653.js";
+import "./chunk-N7DVQTPC.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-RPDVFM7E.js";
+import "./chunk-M4XXKTH2.js";
+import "./chunk-5ILEFNXJ.js";
+import {
+  TermTypes
+} from "./chunk-IZUYLFOX.js";
+import {
+  copyMerge
+} 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 {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// gdc/geneExpClustering.js
+async function init(arg, holder, genomes) {
+  try {
+    const useGenome = arg.genome || "hg38";
+    const useDslabel = arg.dslabel || "GDC";
+    const genome = genomes[useGenome];
+    if (!genome) throw useGenome + " missing";
+    const settings = arg.settings || {};
+    if (typeof settings != "object") throw "arg.settings{} not object";
+    if (!settings.hierCluster) settings.hierCluster = {};
+    if (typeof settings.hierCluster != "object") throw "arg.settings.hierCluster{} not object";
+    if (!Number.isInteger(settings.hierCluster.maxGenes)) settings.hierCluster.maxGenes = 1e3;
+    if (arg.filter0 && typeof arg.filter0 != "object") throw "arg.filter0 not object";
+    const vocabApi = await vocabInit({
+      state: { vocab: { genome: useGenome, dslabel: useDslabel } }
+    });
+    vocabApi.getTermdbConfig();
+    const plotAppApi = await appInit({
+      debug: arg.debug,
+      holder: select_default(arg.holder).select(".sja_root_holder"),
+      genome,
+      state: {
+        genome: useGenome,
+        dslabel: useDslabel,
+        termfilter: { filter0: arg.filter0 },
+        plots: [
+          // Initialize with a geneset component, in case the genes lst is empty.
+          // This will be replaced with the actual matrix/hierCluster app once
+          // a valid geneset is selected.
+          {
+            chartType: "geneset",
+            toolName: "Gene Expression Clustering",
+            settings: {
+              maxGenes: settings.hierCluster.maxGenes
+            }
+          }
+        ]
+      },
+      app: arg.opts?.app || {},
+      hierCluster: copyMerge(
+        {
+          reactsTo(action) {
+            if (action.type.startsWith("plot_")) return action.id === this.id;
+            if (action.type.startsWith("filter")) return true;
+            if (action.type == "app_refresh") return true;
+          },
+          callbacks: {
+            "firstRender.gdcHierCluster": async (hierClusterApi2) => {
+              hierClusterApi2.on("firstRender.gdcHierCluster", null);
+              if (!genesetCompApi) return;
+              plotAppApi.dispatch({
+                type: "plot_delete",
+                id: genesetCompApi.id
+              });
+              genesetCompApi = void 0;
+            }
+          }
+        },
+        arg.opts?.hierCluster || {}
+      ),
+      matrix: arg.opts?.matrix || {},
+      geneset: {
+        mode: "geneExpression",
+        // consistent with GeneSetEdit
+        genome,
+        genes: arg.genes,
+        showEditUI: arg.opts?.geneset?.showEditUI,
+        reactsTo(action) {
+          if (action.type.startsWith("plot_")) return action.id === this.id;
+          if (action.type.startsWith("filter")) return true;
+          if (action.type == "app_refresh") return true;
+        },
+        showWaitMessage(div) {
+          div.style("margin", "20px");
+          div.append("div").text("Loading genes that are top variably expressed in current cohort...");
+          div.append("div").style("font-size", ".8em").html(`
+						Only up to 1000 cases with gene expression data will be used to select genes.<br>
+						Genes are selected from all protein-coding genes, may take over 1 minute.
+					`);
+        },
+        async callback(_genesetCompApi, twlst) {
+          if (!_genesetCompApi) return;
+          genesetCompApi = _genesetCompApi;
+          if (!hierClusterApi) {
+            const plotConfig = plotAppApi.getState().plots.find((p) => p.chartType == "hierCluster");
+            if (plotConfig) hierClusterApi = plotAppApi.getComponents(`plots.${plotConfig.id}`);
+          }
+          const termgroups = [
+            {
+              name: "Gene Expression",
+              type: "hierCluster",
+              lst: twlst
+            },
+            ...arg.termgroups || []
+          ];
+          if (hierClusterApi) {
+            plotAppApi.dispatch({
+              type: "plot_edit",
+              id: hierClusterApi.id,
+              config: { termgroups }
+            });
+          } else {
+            plotAppApi.dispatch({
+              type: "plot_create",
+              config: {
+                chartType: "hierCluster",
+                // avoid making a dictionary request when there is no gene data;
+                // if there is gene data, then the arg.termgroups can be submitted and rehydrated on app/store.init()
+                termgroups,
+                divideBy: arg.divideBy || void 0,
+                // moved default settings to gdc.hg38.js termdb[chartType].settings
+                // but can still override in the runpp() argument
+                settings,
+                dataType: TermTypes.GENE_EXPRESSION
+              }
+            });
+          }
+        }
+      },
+      recover: {
+        undoHtml: "Undo",
+        redoHtml: "Redo",
+        resetHtml: "Restore",
+        hide(state) {
+          return state.plots[0]?.chartType != "hierCluster";
+        },
+        adjustTrackedState: (state) => {
+          const s = structuredClone(state);
+          delete s.termfilter.filter0;
+          if (s.plots) {
+            for (const plot of s.plots) {
+              if (!plot.termgroups) continue;
+              for (const grp of plot.termgroups) {
+                if (!grp.lst) continue;
+                for (const tw of grp.lst) {
+                  if (!tw?.term) continue;
+                  delete tw.term.category2samplecount;
+                  delete tw.term.values;
+                }
+              }
+            }
+          }
+          return s;
+        }
+      }
+    });
+    let hierClusterApi, genesetCompApi;
+    const api = {
+      type: "hierCluster",
+      update: async (_arg) => {
+        const plotConfig = plotAppApi.getState().plots.find((p) => p.chartType == "hierCluster");
+        if (!hierClusterApi) {
+          if (plotConfig) hierClusterApi = plotAppApi.getComponents(`plots.${plotConfig.id}`);
+        }
+        if (_arg.genes) {
+          const t0 = plotConfig.termgroups.find((g) => g.type == "hierCluster");
+          plotAppApi.dispatch({
+            type: "plot_edit",
+            id: hierClusterApi.id,
+            config: {
+              termgroups: [
+                {
+                  name: t0.name,
+                  type: "hierCluster",
+                  lst: await Promise.all(
+                    _arg.genes.map(async (g) => {
+                      return await fillTermWrapper(
+                        {
+                          term: { gene: g.gene, type: "geneExpression", name: g.gene }
+                        },
+                        vocabApi
+                      );
+                    })
+                  )
+                }
+              ]
+            }
+          });
+        } else if ("filter0" in _arg) {
+          plotAppApi.dispatch({
+            type: "filter_replace",
+            filter0: _arg.filter0
+          });
+        } else if (hierClusterApi) {
+          plotAppApi.dispatch({
+            type: "plot_edit",
+            id: hierClusterApi.id,
+            config: _arg
+          });
+        }
+      },
+      triggerAbort: (_) => plotAppApi.triggerAbort(_)
+    };
+    return api;
+  } catch (e) {
+    throw e;
+  }
+}
+export {
+  init
+};
+//# sourceMappingURL=geneExpClustering-7EEK4LBZ.js.map

package/dist/geneExpression-4J2JRTUQ.js

@@ -0,0 +1,33 @@
+import {
+  SearchHandler
+} from "./chunk-4F57QD3H.js";
+import "./chunk-XDLCPJCK.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-TU2E4653.js";
+import "./chunk-N7DVQTPC.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-RPDVFM7E.js";
+import "./chunk-M4XXKTH2.js";
+import "./chunk-5ILEFNXJ.js";
+import "./chunk-IZUYLFOX.js";
+import "./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";
+export {
+  SearchHandler
+};
+//# sourceMappingURL=geneExpression-4J2JRTUQ.js.map

package/dist/geneExpression-FXQ4L2J2.js

@@ -0,0 +1,310 @@
+import {
+  dofetch3
+} from "./chunk-RPDVFM7E.js";
+import "./chunk-M4XXKTH2.js";
+import "./chunk-5ILEFNXJ.js";
+import "./chunk-IZUYLFOX.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import {
+  rgb_default
+} from "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/geneExpression.js
+var defaultConfig = {
+  clusterMethod: "average",
+  distanceMethod: "euclidean"
+};
+var clusterMethodLst = [
+  "average",
+  "complete",
+  "mcquitty"
+  //'single', very slow
+  //'median', 'centroid', crashes R with "No connections found!"
+  //'ward.D','ward.D2', crashes client
+];
+var distanceMethodLst = ["euclidean", "maximum", "manhattan", "canberra"];
+var GeneExpression = class _GeneExpression {
+  static type = "geneExpression";
+  constructor() {
+    this.type = _GeneExpression.type;
+  }
+  async init(opts) {
+    const holder = this.opts.holder.append("div");
+    this.dom = {
+      holder,
+      controlsDiv: holder.append("div"),
+      canvas: holder.append("canvas"),
+      colorScaleDiv: holder.append("div")
+    };
+    this.makeControls();
+    this.components = {};
+  }
+  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 body = this.getParam();
+    const data = await dofetch3("mds3", { body });
+    plotHeatmap_R(data, this);
+  }
+  getParam() {
+    console.log(this.state.config.genes);
+    const body = {
+      genome: this.app.opts.state.vocab.genome,
+      dslabel: this.app.opts.state.vocab.dslabel,
+      geneExpression: 1,
+      genes: this.state.config.genes,
+      clusterMethod: this.state.config.clusterMethod
+    };
+    return body;
+  }
+  makeControls() {
+    const s = this.dom.controlsDiv.append("select");
+    for (const n of clusterMethodLst) s.append("option").text(n);
+    this.dom.clusterMethodSelect = s;
+    s.on("change", () => {
+      this.app.dispatch({
+        type: "plot_edit",
+        id: this.id,
+        config: { clusterMethod: clusterMethodLst[s.property("selectedIndex")] }
+      });
+    });
+  }
+};
+async function getPlotConfig(opts, app) {
+  try {
+    const config = structuredClone(defaultConfig);
+    return copyMerge(config, opts);
+  } catch (e) {
+    throw `${e} [geneExpression getPlotConfig()]`;
+  }
+}
+var geneExpressionInit = getCompInit(GeneExpression);
+var componentInit = geneExpressionInit;
+function makeChartBtnMenu(holder, chartsInstance) {
+  holder.append("div").attr("class", "sja_menuoption sja_sharp_border").text("Clustering analysis").on("click", () => {
+    chartsInstance.dom.tip.hide();
+    chartsInstance.prepPlot({
+      config: {
+        chartType: "geneExpression"
+      }
+    });
+  });
+}
+function plotHeatmap_R(data, self) {
+  self.dom.clusterMethodSelect.property("selectedIndex", clusterMethodLst.indexOf(self.state.config.clusterMethod));
+  self.dom.distanceMethodSelect.property("selectedIndex", distanceMethodLst.indexOf(self.state.config.distanceMethod));
+  const obj = data.clustering;
+  console.log(obj);
+  obj.d = {
+    minColor: "#0c306b",
+    maxColor: "#ffcc00",
+    xDendrogramHeight: 150,
+    yDendrogramHeight: 150
+  };
+  obj.d.colorScale = rgb_default(obj.d.minColor, obj.d.maxColor);
+  const ctx = self.dom.canvas.node().getContext("2d");
+  obj.d.rowHeight = getRowHeight(obj);
+  obj.d.colWidth = getColWidth(obj);
+  getLabHeight(ctx, obj);
+  self.dom.canvas.attr("width", obj.d.xDendrogramHeight + obj.d.xLabHeight + obj.d.colWidth * obj.matrix[0].length).attr("height", obj.d.yDendrogramHeight + obj.d.yLabHeight + obj.d.rowHeight * obj.matrix.length);
+  plotNames(obj, ctx);
+  drawHeatmap(obj, ctx);
+  plotDendrogram_R(ctx, obj);
+  plotHmColorScale(self, obj);
+}
+function plotDendrogram_R(ctx, obj) {
+  try {
+    obj.row_dendro.map(validateRline);
+  } catch (e) {
+    throw "row_dendro error: " + e;
+  }
+  try {
+    obj.col_dendro.map(validateRline);
+  } catch (e) {
+    throw "col_dendro error: " + e;
+  }
+  for (const r of obj.row_dendro) {
+    let t = r.x1;
+    r.x1 = r.y1;
+    r.y1 = t;
+    t = r.x2;
+    r.x2 = r.y2;
+    r.y2 = t;
+  }
+  {
+    let max = 0;
+    for (const r of obj.row_dendro) max = Math.max(max, r.x1, r.x2);
+    const sf = obj.d.xDendrogramHeight / max;
+    for (const r of obj.row_dendro) {
+      r.x1 = sf * (max - r.x1);
+      r.x2 = sf * (max - r.x2);
+      r.y1 *= obj.d.rowHeight;
+      r.y2 *= obj.d.rowHeight;
+    }
+  }
+  {
+    let max = 0;
+    for (const r of obj.col_dendro) max = Math.max(max, r.y1, r.y2);
+    const sf = obj.d.yDendrogramHeight / max;
+    for (const r of obj.col_dendro) {
+      r.y1 = sf * (max - r.y1);
+      r.y2 = sf * (max - r.y2);
+      r.x1 *= obj.d.colWidth;
+      r.x2 *= obj.d.colWidth;
+    }
+  }
+  ctx.strokeStyle = "black";
+  let F = obj.d.yDendrogramHeight + obj.d.yLabHeight;
+  for (const r of obj.row_dendro) {
+    ctx.beginPath();
+    const x1 = Math.min(r.x1, r.x2), x2 = Math.max(r.x1, r.x2), y1 = Math.min(r.y1, r.y2), y2 = Math.max(r.y1, r.y2);
+    ctx.moveTo(x1, y1 + F);
+    ctx.lineTo(x1, y2 + F);
+    if (r.x1 > r.x2 && r.y1 > r.y2 || r.x1 < r.x2 && r.y1 < r.y2) {
+      ctx.lineTo(x2, y2 + F);
+    } else {
+      ctx.moveTo(x1, y1 + F);
+      ctx.lineTo(x2, y1 + F);
+    }
+    ctx.stroke();
+    ctx.closePath();
+  }
+  F = obj.d.xDendrogramHeight + obj.d.xLabHeight;
+  for (const r of obj.col_dendro) {
+    ctx.beginPath();
+    const x1 = Math.min(r.x1, r.x2), x2 = Math.max(r.x1, r.x2), y1 = Math.min(r.y1, r.y2), y2 = Math.max(r.y1, r.y2);
+    ctx.moveTo(F + x1, y1);
+    ctx.lineTo(F + x2, y1);
+    if (r.x1 > r.x2 && r.y1 > r.y2 || r.x1 < r.x2 && r.y1 < r.y2) {
+      ctx.lineTo(F + x2, y2);
+    } else {
+      ctx.moveTo(F + x1, y1);
+      ctx.lineTo(F + x1, y2);
+    }
+    ctx.stroke();
+    ctx.closePath();
+  }
+}
+function validateRline(r) {
+  if (r.r1 < 0) throw `r.r1<0 ${r.r1}`;
+  if (r.r2 < 0) throw `r.r2<0 ${r.r2}`;
+  if (r.x1 < 1) throw `r.x1<1 ${r.x1}`;
+  if (r.x2 < 1) throw `r.x2<1 ${r.x2}`;
+  r.x1 -= 0.5;
+  r.x2 -= 0.5;
+  if (r.y1 < 0) throw `r.y1<0 ${r.y1}`;
+  if (r.y2 < 0) throw `r.y2<0 ${r.y2}`;
+}
+function plotNames(obj, ctx) {
+  if (obj.d.xLabHeight) {
+    ctx.font = obj.d.rowHeight + "px Arial";
+    ctx.textAlign = "end";
+    ctx.fillStyle = "black";
+    for (const [rowIdx, geneIdx] of obj.row_names_index.entries()) {
+      ctx.fillText(
+        obj.geneNameLst[geneIdx - 1],
+        obj.d.xDendrogramHeight + obj.d.xLabHeight,
+        obj.d.yDendrogramHeight + obj.d.yLabHeight + obj.d.rowHeight * (rowIdx + 1)
+      );
+    }
+  }
+}
+function drawHeatmap(obj, ctx) {
+  for (let i = 0; i < obj.row_names_index.length; i++) {
+    const sampleValues = obj.matrix[obj.row_names_index[i] - 1];
+    const [min, max] = getMinMax(sampleValues);
+    for (let j = 0; j < obj.col_names_index.length; j++) {
+      const v = sampleValues[obj.col_names_index[j] - 1];
+      ctx.fillStyle = obj.d.colorScale((v - min) / (max - min));
+      ctx.fillRect(
+        obj.d.xDendrogramHeight + obj.d.xLabHeight + obj.d.colWidth * j,
+        obj.d.yDendrogramHeight + obj.d.yLabHeight + obj.d.rowHeight * i,
+        obj.d.colWidth,
+        obj.d.rowHeight
+      );
+    }
+  }
+}
+function getRowHeight(obj) {
+  const h = 500 / obj.matrix.length;
+  if (h > 20) return 20;
+  if (h < 10) return 10;
+  return Math.ceil(h);
+}
+function getColWidth(obj) {
+  const w = 2e3 / obj.matrix[0].length;
+  if (w > 10) return 10;
+  return Math.ceil(w);
+}
+function getLabHeight(ctx, obj) {
+  if (obj.geneNameLst && obj.d.rowHeight >= 7) {
+    ctx.font = obj.d.rowHeight + "px Arial";
+    let max = 0;
+    for (const n of obj.geneNameLst) {
+      max = Math.max(max, ctx.measureText(n).width);
+    }
+    obj.d.xLabHeight = max;
+  } else {
+    obj.d.xLabHeight = 0;
+  }
+  if (obj.sampleNameLst && obj.d.colWidth >= 7) {
+    ctx.font = obj.d.colWidth + "px Arial";
+    let max = 0;
+    for (const n of obj.sampleNameLst) {
+      max = Math.max(max, ctx.measureText(n).width);
+    }
+    obj.d.yLabHeight = max;
+  } else {
+    obj.d.yLabHeight = 0;
+  }
+}
+function getMinMax(row) {
+  let min = null, max;
+  for (const v of row) {
+    if (min == null) {
+      min = v;
+      max = v;
+    } else {
+      min = Math.min(min, v);
+      max = Math.max(max, v);
+    }
+  }
+  return [min, max];
+}
+function plotHmColorScale(self, obj) {
+  self.dom.colorScaleDiv.selectAll("*").remove();
+  const width = 100, height = 20;
+  self.dom.colorScaleDiv.append("span").text("Min");
+  const svg = self.dom.colorScaleDiv.append("svg");
+  self.dom.colorScaleDiv.append("span").text("Max");
+  const grad = svg.append("defs").append("linearGradient").attr("id", "grad");
+  grad.append("stop").attr("offset", "0%").attr("stop-color", obj.d.minColor);
+  grad.append("stop").attr("offset", "100%").attr("stop-color", obj.d.maxColor);
+  svg.append("rect").attr("width", width).attr("height", height).attr("fill", "url(#grad)");
+  svg.attr("width", width).attr("height", height);
+}
+export {
+  componentInit,
+  geneExpressionInit,
+  getPlotConfig,
+  makeChartBtnMenu
+};
+//# sourceMappingURL=geneExpression-FXQ4L2J2.js.map

package/dist/geneExpression.unit.spec-JRLUIYIU.js

@@ -0,0 +1,99 @@
+import {
+  SearchHandler
+} from "./chunk-4F57QD3H.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import "./chunk-XDLCPJCK.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-TU2E4653.js";
+import "./chunk-N7DVQTPC.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-RPDVFM7E.js";
+import "./chunk-M4XXKTH2.js";
+import "./chunk-5ILEFNXJ.js";
+import {
+  TermTypes
+} from "./chunk-IZUYLFOX.js";
+import "./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 {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// termdb/handlers/test/geneExpression.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+(0, import_tape.default)("\n", function(test) {
+  test.comment("-***- termdb/handlers/geneExpression -***-");
+  test.end();
+});
+(0, import_tape.default)("selectGene() should throw when no gene is selected", async (test) => {
+  const handler = new SearchHandler();
+  handler.app = { vocabApi: { termdbConfig: { queries: { geneExpression: {} } } } };
+  handler.callback = () => {
+  };
+  try {
+    await handler.selectGene(void 0);
+    test.fail("Should throw when no gene is selected");
+  } catch (e) {
+    test.match(String(e), /No gene selected/, "Should throw expected message when gene is missing");
+  }
+  test.end();
+});
+(0, import_tape.default)("selectGene() should call callback with configured unit from termdbConfig", async (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {
+          geneExpression: { unit: "log2 TPM" }
+        }
+      }
+    }
+  };
+  await handler.selectGene({ geneSymbol: "TP53", sampleType: "tumor" });
+  test.equal(selected?.q?.sampleType, "tumor", "Should pass selected sampleType in q payload");
+  test.equal(selected?.term.gene, "TP53", "Should pass selected gene");
+  test.equal(selected?.term.name, "TP53 log2 TPM", "Should include configured unit in term name");
+  test.equal(selected?.term.type, TermTypes.GENE_EXPRESSION, "Should set type to geneExpression");
+  test.end();
+});
+(0, import_tape.default)("selectGene() should use default unit when not configured", async (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {}
+      }
+    }
+  };
+  await handler.selectGene({ geneSymbol: "BRCA1" });
+  test.equal(selected?.q?.sampleType, void 0, "Should include sampleType key with undefined value when not provided");
+  test.equal(selected?.term.gene, "BRCA1", "Should pass selected gene");
+  test.equal(selected?.term.name, "BRCA1 Gene Expression", "Should use default unit when config unit is not provided");
+  test.equal(selected?.term.type, TermTypes.GENE_EXPRESSION, "Should set type to geneExpression");
+  test.end();
+});
+//# sourceMappingURL=geneExpression.unit.spec-JRLUIYIU.js.map