@sjcrh/proteinpaint-client 2.210.0 → 2.210.1

package/dist/chunk-SP6WCXY6.js

@@ -0,0 +1,217 @@
+import {
+  dofetch,
+  dofetch2
+} from "./chunk-VTHZGUSZ.js";
+import {
+  contigNameNoChr2
+} from "./chunk-UYKJOBRO.js";
+
+// tracks/hic/data/parseData.ts
+async function hicParseFile(hic, debugmode, errList = []) {
+  if (debugmode) window["hic"] = hic;
+  if (hic.tklst) {
+    const lst = [];
+    for (const t of hic.tklst) {
+      if (!t.type) {
+        errList.push("type missing from one of the tracks accompanying HiC");
+      } else {
+        t.iscustom = true;
+        lst.push(t);
+      }
+    }
+    if (lst.length) {
+      hic.tklst = lst;
+    } else {
+      delete hic.tklst;
+    }
+  }
+  if (hic.enzyme) {
+    if (hic.genome.hicenzymefragment) {
+      let frag = null;
+      for (const f of hic.genome.hicenzymefragment) {
+        if (f.enzyme == hic.enzyme) {
+          frag = f;
+          break;
+        }
+      }
+      if (frag) {
+        hic.enzymefile = frag.file;
+      } else {
+        errList.push("unknown enzyme: " + hic.enzyme);
+        delete hic.enzyme;
+      }
+    } else {
+      errList.push("no enzyme fragment information available for this genome");
+      delete hic.enzyme;
+    }
+  }
+  try {
+    if (hic.sv && hic.sv.file) {
+      const re = await dofetch(hic.hostURL + "/textfile", {
+        method: "POST",
+        body: JSON.stringify({ file: hic.sv.file, jwt: hic.jwt })
+      });
+      const data2 = re.json();
+      const [err2, header, items] = parseSV(data2.text);
+      if (err2) throw { message: "Error parsing SV: " + err2 };
+      hic.sv.header = header;
+      hic.sv.items = items;
+    }
+    const data = await dofetch2("hicstat?" + (hic.file ? "file=" + hic.file : "url=" + hic.url));
+    if (data.error) {
+      errList.push(data.error);
+      return;
+    }
+    const err = hicparsestat(hic, data.out);
+    if (err) throw { message: err };
+  } catch (err) {
+    errList.push(err.message || err);
+    if (err.stack) {
+      console.log(err.stack);
+    }
+  }
+  return hic;
+}
+function parseSV(txt) {
+  const lines = txt.trim().split(/\r?\n/);
+  const [err, header] = parseSVheader(lines[0]);
+  if (err) return ["header error: " + err];
+  const items = [];
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line[0] == "#") continue;
+    const [e, m] = parseSVline(line, header);
+    if (e) return ["line " + (i + 1) + " error: " + e];
+    items.push(m);
+  }
+  return [null, header, items];
+}
+function parseSVheader(line) {
+  const header = line.toLowerCase().split("	");
+  if (header.length <= 1) return "invalid file header for fusions";
+  const htry = (...lst) => {
+    for (const a of lst) {
+      const j = header.indexOf(a);
+      if (j != -1) return j;
+    }
+    return -1;
+  };
+  let i = htry("chr_a", "chr1", "chra");
+  if (i == -1) return "chr_A missing from header";
+  header[i] = "chr1";
+  i = htry("chr_b", "chr2", "chrb");
+  if (i == -1) return "chr_B missing from header";
+  header[i] = "chr2";
+  i = htry("pos_a", "position_a", "position1", "posa");
+  if (i == -1) return "pos_a missing from header";
+  header[i] = "position1";
+  i = htry("pos_b", "position_b", "position2", "posb");
+  if (i == -1) return "pos_b missing from header";
+  header[i] = "position2";
+  i = htry("strand_a", "orta", "orienta");
+  if (i == -1) return "strand_a missing from header";
+  header[i] = "strand1";
+  i = htry("strand_b", "ortb", "orientb");
+  if (i == -1) return "strand_b missing from header";
+  header[i] = "strand2";
+  i = htry("numreadsa");
+  if (i != -1) header[i] = "reads1";
+  i = htry("numreadsb");
+  if (i != -1) header[i] = "reads2";
+  return [null, header];
+}
+function parseSVline(line, header) {
+  const lst = line.split("	");
+  const m = {};
+  for (let j = 0; j < header.length; j++) {
+    m[header[j]] = lst[j];
+  }
+  if (!m.chr1) return ["missing chr1"];
+  if (m.chr1.toLowerCase().indexOf("chr") != 0) {
+    m.chr1 = "chr" + m.chr1;
+  }
+  if (!m.chr2) return ["missing chr2"];
+  if (m.chr2.toLowerCase().indexOf("chr") != 0) {
+    m.chr2 = "chr" + m.chr2;
+  }
+  if (!m.position1) return ["missing position1"];
+  let v = Number.parseInt(m.position1);
+  if (Number.isNaN(v) || v <= 0) return ["position1 invalid value"];
+  m.position1 = v;
+  if (!m.position2) return ["missing position2"];
+  v = Number.parseInt(m.position2);
+  if (Number.isNaN(v) || v <= 0) return ["position2 invalid value"];
+  m.position2 = v;
+  if (m.reads1) {
+    v = Number.parseInt(m.reads1);
+    if (Number.isNaN(v)) return ["reads1 invalid value"];
+    m.reads1 = v;
+  }
+  if (m.reads2) {
+    v = Number.parseInt(m.reads2);
+    if (Number.isNaN(v)) return ["reads2 invalid value"];
+    m.reads2 = v;
+  }
+  return [null, m];
+}
+function hicparsestat(hic, j) {
+  if (!j) return "cannot stat hic file";
+  hic.normalization = j.normalization;
+  hic.version = j.version;
+  if (!j.Chromosomes) return "Chromosomes not found in file stat";
+  if (!Array.isArray(j.chrorder)) return ".chrorder[] missing";
+  if (j.chrorder.length == 0) return ".chrorder[] empty array";
+  hic.chrorder = j.chrorder;
+  if (!j["Base pair-delimited resolutions"]) return "Base pair-delimited resolutions not found in file stat";
+  if (!Array.isArray(j["Base pair-delimited resolutions"])) return "Base pair-delimited resolutions should be array";
+  hic.bpresolution = j["Base pair-delimited resolutions"];
+  if (!j["Fragment-delimited resolutions"]) return "Fragment-delimited resolutions not found in file stat";
+  if (!Array.isArray(j["Fragment-delimited resolutions"])) return "Fragment-delimited resolutions is not array";
+  hic.fragresolution = j["Fragment-delimited resolutions"];
+  const chrlst = [];
+  for (const chr in j.Chromosomes) {
+    chrlst.push(chr);
+  }
+  const [nochrcount, haschrcount] = contigNameNoChr2(hic.genome, chrlst);
+  if (nochrcount + haschrcount == 0) return "chromosome names do not match with genome build";
+  if (nochrcount > 0) {
+    hic.nochr = true;
+    for (let i = 0; i < hic.chrorder.length; i++) hic.chrorder[i] = "chr" + hic.chrorder[i];
+  }
+  hic.chrlst = [];
+  for (const chr of hic.genome.majorchrorder) {
+    const c2 = hic.nochr ? chr.replace("chr", "") : chr;
+    if (chrlst.indexOf(c2) != -1) {
+      hic.chrlst.push(chr);
+    }
+  }
+}
+function hicparsefragdata(items) {
+  const id2coord = /* @__PURE__ */ new Map();
+  let min = null, max;
+  for (const i of items) {
+    if (!i.rest || !i.rest[0]) {
+      return ["items[].rest data problem"];
+    }
+    const id = Number.parseInt(i.rest[0]);
+    if (Number.isNaN(id)) {
+      return [i.start + "." + i.stop + " invalid fragment id: " + i.rest[0]];
+    }
+    id2coord.set(id, [i.start, i.stop]);
+    if (min == null) {
+      min = id;
+      max = id;
+    } else {
+      min = Math.min(min, id);
+      max = Math.max(max, id);
+    }
+  }
+  return [null, id2coord, min, max];
+}
+
+export {
+  hicParseFile,
+  hicparsestat,
+  hicparsefragdata
+};
+//# sourceMappingURL=chunk-SP6WCXY6.js.map

package/dist/chunk-SRTZQOK7.js

@@ -0,0 +1,102 @@
+import {
+  getPlotConfig
+} from "./chunk-TOFOT2BN.js";
+import {
+  fillTermWrapper
+} from "./chunk-CSAS3PVJ.js";
+import {
+  dictionaryNumericTypes,
+  numericTypes
+} from "./chunk-4Y5W26UF.js";
+import {
+  copyMerge
+} from "./chunk-WINIL2KN.js";
+
+// plots/matrix/hierCluster.config.js
+async function getPlotConfig2(opts = {}, app) {
+  opts.chartType = "hierCluster";
+  if (dictionaryNumericTypes.has(opts.dataType) || opts.dataType == "numericDictTerm") {
+    const grp = opts.termgroups?.find((g) => g.type == "hierCluster");
+    for (const tw of grp?.lst || []) tw.q = { ...tw.q, mode: "continuous" };
+  }
+  const config = await getPlotConfig(opts, app);
+  delete config.genes;
+  if (config.dataType == "numericDictTerm") {
+    const lst = config.termgroups?.find((g) => g.type == "hierCluster")?.lst;
+    config.dataType = lst?.[0]?.term?.type || "float";
+  }
+  config.settings.hierCluster = {
+    /* type of data used for clustering
+    exciting todo: (to introduce new dt values)
+    - gene dependency
+    - numeric dic term
+    - non-gene genomic stuff that resolves into numeric quantities (cpg meth)
+    - metabolite
+    */
+    dataType: config.dataType,
+    // adjust the default group name based on automatically detected term types
+    // Done in matrix.cells.js: setHierClusterCellProps
+    // termGroupName: 'Expression',
+    clusterSamples: true,
+    clusterRows: true,
+    clusterMethod: "average",
+    // complete
+    distanceMethod: "euclidean",
+    zScoreCap: 5,
+    zScoreTransformation: true,
+    xDendrogramHeight: 100,
+    yDendrogramHeight: 200,
+    colorScale: "blueWhiteRed"
+  };
+  const overrides = app.vocabApi.termdbConfig.hierCluster || {};
+  const numericDictTermClusterOverrides = dictionaryNumericTypes.has(config.dataType) && app.vocabApi.termdbConfig.numericDictTermCluster ? app.vocabApi.termdbConfig.numericDictTermCluster : {};
+  copyMerge(
+    config.settings.hierCluster,
+    overrides.settings,
+    opts.settings?.hierCluster || {},
+    numericDictTermClusterOverrides.settings
+  );
+  {
+    const c = config.settings.hierCluster.colorScale;
+    if (!c) throw "colorScale missing";
+  }
+  config.settings.matrix.collabelpos = "top";
+  const termGroupName = config.settings.hierCluster.termGroupName;
+  const hcTermGroup = config.termgroups.find((g) => g.type == "hierCluster" || g.name == termGroupName) || {
+    name: termGroupName
+  };
+  hcTermGroup.type = "hierCluster";
+  if (!hcTermGroup.lst?.length) {
+    if (!Array.isArray(opts.terms)) throw "opts.terms[] not array (may show geneset edit ui)";
+    const promises = [];
+    for (const i of opts.terms) {
+      const tw = i.term ? i : { term: i };
+      if (!tw.term.type) {
+        if (config.dataType && numericTypes.has(config.dataType)) {
+          tw.term.type = config.dataType;
+        } else {
+          throw `term type missing and cannot be assigned by dataType '${config.dataType}'`;
+        }
+      } else if (!numericTypes.has(tw.term.type)) {
+        throw "term type is not numeric";
+      } else if (config.dataType && !canTermBeInHierGrp(config.dataType, tw.term.type)) {
+        throw `cannot have term type ${tw.term.type} in ${config.dataType} term group`;
+      }
+      if (dictionaryNumericTypes.has(tw.term.type)) tw.q = { ...tw.q, mode: "continuous" };
+      promises.push(fillTermWrapper(tw, app.vocabApi));
+    }
+    hcTermGroup.lst = await Promise.all(promises);
+    if (config.termgroups.indexOf(hcTermGroup) == -1) config.termgroups.unshift(hcTermGroup);
+  }
+  config.settings.matrix.maxSample = 1e5;
+  return config;
+}
+function canTermBeInHierGrp(grpType, twType) {
+  if (dictionaryNumericTypes.has(grpType) && dictionaryNumericTypes.has(twType)) return true;
+  return twType == grpType;
+}
+
+export {
+  getPlotConfig2 as getPlotConfig
+};
+//# sourceMappingURL=chunk-SRTZQOK7.js.map

package/dist/chunk-T4RYLTR3.js

@@ -0,0 +1,178 @@
+import {
+  __glob
+} from "./chunk-HS5PO5ZQ.js";
+
+// import("../plots/**/*.js") in plots/importPlot.js
+var globImport_plots_js = __glob({
+  "../plots/controls.btns.js": () => import("./controls.btns-BYM4DON4.js"),
+  "../plots/controls.config.js": () => import("./controls.config-4PK7HLFJ.js"),
+  "../plots/controls.js": () => import("./controls-LMTWS3SY.js"),
+  "../plots/dictionary.js": () => import("./dictionary-MS6R3VNY.js"),
+  "../plots/gb/test/genomeBrowser.spec.js": () => import("./genomeBrowser.spec-5IS5Y2NG.js"),
+  "../plots/geneExpression.js": () => import("./geneExpression-54RGEGML.js"),
+  "../plots/geneORA.js": () => import("./geneORA-TELI5AFV.js"),
+  "../plots/geneset.js": () => import("./geneset-VG4SFYML.js"),
+  "../plots/hierCluster.js": () => import("./hierCluster-XBL2TOOL.js"),
+  "../plots/importPlot.js": () => import("./importPlot-CLBY6QZN.js"),
+  "../plots/matrix.js": () => import("./matrix-DDKSOJ4C.js"),
+  "../plots/matrix/hierCluster.config.js": () => import("./hierCluster.config-VCBRBGDZ.js"),
+  "../plots/matrix/hierCluster.interactivity.js": () => import("./hierCluster.interactivity-PEEJ3BRC.js"),
+  "../plots/matrix/hierCluster.js": () => import("./hierCluster-WLAFGZAT.js"),
+  "../plots/matrix/hierCluster.renderers.js": () => import("./hierCluster.renderers-7ESGKIGM.js"),
+  "../plots/matrix/matrix.cells.js": () => import("./matrix.cells-JTMC35SK.js"),
+  "../plots/matrix/matrix.cluster.js": () => import("./matrix.cluster-RH4BOM5F.js"),
+  "../plots/matrix/matrix.config.js": () => import("./matrix.config-EUBXWEBS.js"),
+  "../plots/matrix/matrix.data.js": () => import("./matrix.data-CO5RBWY5.js"),
+  "../plots/matrix/matrix.dom.js": () => import("./matrix.dom-2SA43BPT.js"),
+  "../plots/matrix/matrix.groups.js": () => import("./matrix.groups-AKOJ2W6U.js"),
+  "../plots/matrix/matrix.interactivity.js": () => import("./matrix.interactivity-DY5YJIYB.js"),
+  "../plots/matrix/matrix.js": () => import("./matrix-H2ZH2QKC.js"),
+  "../plots/matrix/matrix.layout.js": () => import("./matrix.layout-MQQNHBI2.js"),
+  "../plots/matrix/matrix.legend.js": () => import("./matrix.legend-CGU7T6GF.js"),
+  "../plots/matrix/matrix.renderers.js": () => import("./matrix.renderers-HC7PJN4B.js"),
+  "../plots/matrix/matrix.serieses.js": () => import("./matrix.serieses-W4L6ZO37.js"),
+  "../plots/matrix/matrix.sort.js": () => import("./matrix.sort-T74DWFB2.js"),
+  "../plots/matrix/matrix.sorterUi.js": () => import("./matrix.sorterUi-GFQG4HFV.js"),
+  "../plots/matrix/test/hierCluster.integration.spec.js": () => import("./hierCluster.integration.spec-TNJD2QT6.js"),
+  "../plots/matrix/test/matrix.integration.spec.js": () => import("./matrix.integration.spec-66KNZO3S.js"),
+  "../plots/matrix/test/matrix.sort.unit.spec.js": () => import("./matrix.sort.unit.spec-EQEHQXTO.js"),
+  "../plots/matrix/test/matrix.sorterUi.unit.spec.js": () => import("./matrix.sorterUi.unit.spec-XQHFOEYE.js"),
+  "../plots/matrix/test/matrix.unit.spec.js": () => import("./matrix.unit.spec-4ZWUGZUC.js"),
+  "../plots/matrix/test/oncomatrix.spec.js": () => import("./oncomatrix.spec-SO3ZN5BF.js"),
+  "../plots/plot.brainImaging.js": () => import("./plot.brainImaging-2F6E6QS4.js"),
+  "../plots/plot.disco.js": () => import("./plot.disco-H4P4B6QS.js"),
+  "../plots/plot.ssgq.js": () => import("./plot.ssgq-LEQF3STZ.js"),
+  "../plots/singleCellPlot.js": () => import("./singleCellPlot-ZU655L4Z.js"),
+  "../plots/stattable.js": () => import("./stattable-R7O6OIMB.js"),
+  "../plots/survival/test/survival.integration.spec.js": () => import("./survival.integration.spec-UW6SYVLP.js"),
+  "../plots/table.js": () => import("./table-GJUXHKQI.js"),
+  "../plots/test/expclust.gdc.spec.js": () => import("./expclust.gdc.spec-C5ZMBCGO.js"),
+  "../plots/test/summary.integration.spec.js": () => import("./summary.integration.spec-SDCGE6BQ.js"),
+  "../plots/volcano/test/testData.js": () => import("./testData-DRM5HWQB.js")
+});
+
+// plots/importPlot.js
+async function importPlot(chartType, notFoundMessage = "") {
+  switch (chartType) {
+    case "aggMatrixInput":
+      return await import("./AggMatrixInput-UTUOXTGA.js");
+    case "aggregateMatrix":
+      return await import("./AggregateMatrix-X75HUZYO.js");
+    case "animatedBubbleChart":
+      return await import("./animatedBubbleChart-LZKNERIM.js");
+    case "brainImaging":
+      return await import("./brainImaging-GUQTOHQF.js");
+    case "brainRegions":
+      return await import("./brainRegions-JWBIBCTG.js");
+    case "barchart":
+      return await import("./barchart-BPUEO4RK.js");
+    case "boxplot":
+      return await import("./BoxPlot-NQMPJICU.js");
+    case "bubbleHeatmap":
+      return await import("./bubbleHeatmap-EUO3DUVT.js");
+    case "cellTypeBubbleHeatmap":
+      return await import("./cellTypeBubbleHeatmap-TIBGPZTB.js");
+    case "correlationVolcano":
+      return await import("./CorrelationVolcano-IDBUJH2E.js");
+    case "cuminc":
+      return await import("./Cuminc-BYFIMOLO.js");
+    case "dataDownload":
+      return await import("./dataDownload-TFRI3VFM.js");
+    case "DEinput":
+      return await import("./DEinput-W66CT4U2.js");
+    case "dictionary":
+      return await import("./dictionary-MS6R3VNY.js");
+    case "differentialAnalysis":
+      return await import("./DifferentialAnalysis-PRTA6CYW.js");
+    case "Disco":
+      return await import("./Disco-4JQP3FRW.js");
+    case "dmr":
+      return await import("./DmrPlot-VYQYMTQ7.js");
+    case "facet":
+      return await import("./facet-LPXKLX53.js");
+    case "GeneExpInput":
+      return await import("./GeneExpInput-UILWAGRH.js");
+    case "geneRanking":
+      return await import("./geneRanking-7YZA5GNG.js");
+    case "genomeBrowser":
+      return await import("./GB-LULUM5LH.js");
+    case "geomap":
+      return await import("./Geomap-AFKEGMR5.js");
+    case "grin2":
+      return await import("./grin2-FOOH736B.js");
+    case "gsea":
+      return await import("./GSEA-DT3SYXOZ.js");
+    case "imagePlot":
+      return await import("./imagePlot-LWL6JMKM.js");
+    case "numericDictTermCluster":
+      return await import("./numericDictTermCluster-RLX5CLTN.js");
+    case "profileBarchart2":
+      return await import("./barchart2-Z36PNSM2.js");
+    case "profileForms":
+      return await import("./profileForms-CUSUGTPC.js");
+    case "profilePlot":
+      return await import("./profilePlot-67Z7AXQ4.js");
+    case "profilePolar2":
+      return await import("./polar2-AVEZM2T5.js");
+    case "profileRadar2":
+      return await import("./radar2-QJDGNLED.js");
+    case "profileRadarFacility2":
+      return await import("./radarFacility2-LGGOOWX4.js");
+    case "proteinView":
+      return await import("./proteinView-7K7VHGX3.js");
+    case "proteomeAbundance":
+      return await import("./proteomeAbundance-NH3Y4YC7.js");
+    case "proteomeCohortCompare":
+      return await import("./proteomeCohortCompare-MRGH6HHI.js");
+    case "ProteomeInput":
+      return await import("./ProteomeInput-3WKTVCYT.js");
+    case "regression":
+      return await import("./Regression-M7AQTYXL.js");
+    case "report":
+      return await import("./report-TTECPO44.js");
+    case "runChart2":
+    //See frequencyChart
+    case "frequencyChart":
+      return await import("./RunChart2-54SVOXJR.js");
+    case "sampleView":
+      return await import("./sampleView-EFS2UBRS.js");
+    case "sampleScatter":
+      return await import("./scatter-AVRTALYY.js");
+    case "sc":
+      return await import("./SC-QRWDGHB2.js");
+    case "studyCatalog":
+      return await import("./studyCatalog-OMDE4JRD.js");
+    case "summarizeCnvGeneexp":
+      return await import("./summarizeCnvGeneexp-A7HW6FJI.js");
+    case "summarizeGeneexpSurvival":
+      return await import("./summarizeGeneexpSurvival-ODI4HGFH.js");
+    case "summarizeMutationDiagnosis":
+      return await import("./summarizeMutationDiagnosis-4Y322NYU.js");
+    case "summarizeMutationSurvival":
+      return await import("./summarizeMutationSurvival-7IHNURLC.js");
+    case "summarizeMutationCnv":
+      return await import("./summarizeMutationCnv-C2YB73OL.js");
+    case "summaryInput":
+      return await import("./summaryInput-DHIMU5DM.js");
+    case "summary":
+      return await import("./summary-E4L5MZTF.js");
+    case "survival":
+      return await import("./survival-KWWH6REE.js");
+    case "table":
+      return await import("./table-GJUXHKQI.js");
+    case "violin":
+      return await import("./Violin-2AD6QRJB.js");
+    case "volcano":
+      return await import("./Volcano-T57VFSWR.js");
+    case "wsi":
+      return await import("./Wsi-U3U3EILE.js");
+    default:
+      if (notFoundMessage) throw notFoundMessage;
+      return await globImport_plots_js(`../plots/${chartType}.js`);
+  }
+}
+
+export {
+  importPlot
+};
+//# sourceMappingURL=chunk-T4RYLTR3.js.map

package/dist/chunk-TANWA6SU.js

@@ -0,0 +1,54 @@
+import {
+  addGeneSearchbox,
+  getSCGEunit,
+  getSampleAssayInfo
+} from "./chunk-CSAS3PVJ.js";
+import {
+  Menu
+} from "./chunk-ELJX3QIQ.js";
+import {
+  SINGLECELL_GENE_EXPRESSION
+} from "./chunk-UYKJOBRO.js";
+
+// termdb/handlers/singleCellGeneExpression.ts
+var SearchHandler = class {
+  async init(opts) {
+    this.validateOpts(opts);
+    this.callback = opts.callback;
+    this.app = opts.app;
+    const sample = opts.usecase?.specialCase?.config?.sample;
+    const { genes: geneList } = await getSampleAssayInfo(this.app.vocabApi, sample);
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: opts.genomeObj,
+      geneList,
+      row: holder,
+      searchOnly: "gene",
+      callback: () => this.selectGene(geneSearch.geneSymbol, sample)
+    });
+  }
+  /**TODO: scge tw handler will validate that a sample is included. Need to resolve issue
+   * with sample info not included.*/
+  async selectGene(gene, sample) {
+    if (!gene) throw new Error("No gene selected");
+    const unit = getSCGEunit(this.app.vocabApi);
+    const name = `${gene} ${unit}`;
+    this.callback({ gene, name, type: SINGLECELL_GENE_EXPRESSION, sample });
+  }
+  validateOpts(opts) {
+    if (opts.callback == null) throw new Error("callback is required");
+    if (opts.app == null) throw new Error("app is required");
+    if (opts.holder == null) throw new Error("holder is required");
+    if (opts.genomeObj == null) throw new Error("genomeObj is required");
+    if (opts.usecase == null) throw new Error("usecase is required");
+    if (!opts.usecase?.specialCase?.config?.sample) {
+      throw new Error("usecase.specialCase.config.sample is required for singleCellGeneExpression handler");
+    }
+  }
+};
+
+export {
+  SearchHandler
+};
+//# sourceMappingURL=chunk-TANWA6SU.js.map