@sjcrh/proteinpaint-client 2.225.0 → 2.227.0

package/dist/geneVariant.integration.spec-UJXGQEZG.js

@@ -0,0 +1,672 @@
+import {
+  hg38
+} from "./chunk-DRVH2UWP.js";
+import {
+  sleep
+} from "./chunk-WA3C3A2M.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import {
+  SearchHandler,
+  vocabInit
+} from "./chunk-YBXQBSFY.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-QKVKQD6S.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-DOC3HBOV.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-VVWZ4BOI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-2IAELUCN.js";
+import "./chunk-CFYWQJ7F.js";
+import {
+  dtcnv,
+  dtsnvindel
+} from "./chunk-2N345NXD.js";
+import "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// termdb/handlers/test/geneVariant.integration.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+async function getVocabApi() {
+  const vocabApi2 = vocabInit({ state: { vocab: { genome: "hg38-test", dslabel: "TermdbTest" } } });
+  if (!vocabApi2) throw "vocabApi is missing";
+  await vocabApi2.getTermdbConfig();
+  return vocabApi2;
+}
+var vocabApi = await getVocabApi();
+function getHolder() {
+  const holder = select_default("body").append("div");
+  return holder;
+}
+async function initializeSearchHandler(opts) {
+  const handler = new SearchHandler();
+  const callback = opts.callback || (() => {
+  });
+  await handler.init({
+    holder: opts.holder,
+    app: { vocabApi: opts.vocabApi || vocabApi },
+    genomeObj: hg38,
+    keepsQ: opts.keepsQ,
+    msg: opts.msg,
+    usecase: opts.usecase,
+    callback
+  });
+  return handler;
+}
+(0, import_tape.default)("\n", function(test) {
+  test.comment("-***- geneVariant search handler -***-");
+  test.end();
+});
+(0, import_tape.default)("Search handler layout", async (test) => {
+  const holder = getHolder();
+  await initializeSearchHandler({ holder });
+  const mutationTypeRadiosDiv = holder.select('[data-testid="sjpp-genevariant-mutationTypeRadios"]');
+  test.ok(
+    mutationTypeRadiosDiv.selectAll('input[type="radio"]').size() > 0,
+    "Mutation type radio buttons should be present"
+  );
+  const inputTypeRadiosDiv = holder.select('[data-testid="sjpp-genevariant-genesetTypeRadios"]');
+  test.equal(
+    inputTypeRadiosDiv.selectAll('input[type="radio"]').size(),
+    2,
+    "Input type radio buttons should be present"
+  );
+  const searchDiv = holder.select('[data-testid="sjpp-genevariant-geneSearchDiv"]');
+  test.equal(searchDiv.selectAll('input[type="search"]').size(), 1, "Gene search input should be present");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Matrix search handler only shows gene search", async (test) => {
+  let tw;
+  const holder = getHolder();
+  const handler = await initializeSearchHandler({
+    holder,
+    usecase: { target: "matrix" },
+    callback: (_tw) => tw = _tw
+  });
+  test.equal(handler.q.type, "values", "matrix q should use values");
+  test.equal(holder.selectAll('input[type="search"]').size(), 1, "should show one gene search input");
+  test.equal(
+    holder.selectAll('input[type="radio"], input[type="checkbox"], select').size(),
+    0,
+    "should show no other selectors"
+  );
+  test.equal(handler.mutationTypeRadio, void 0, "should not initialize mutation type selector");
+  test.equal(handler.inputTypeRadio, void 0, "should not initialize gene set selector");
+  test.equal(handler.mutationTypeTerms, void 0, "should not initialize mutation type selector state");
+  test.equal(handler.maxNumGenes, void 0, "should not initialize gene set selector state");
+  test.equal(handler.originSelect, void 0, "should not initialize origin selector");
+  test.equal(handler.queryOrigins, void 0, "should not initialize origin selector state");
+  test.equal(handler.sampleTypeSelect, void 0, "should not initialize sample type selector");
+  test.equal(handler.querySampleTypes, void 0, "should not initialize sample type selector state");
+  test.equal(handler.querySampleTypesByTerms, void 0, "should not initialize sample type selector state");
+  const geneSearchInput = holder.select('input[type="search"]').node();
+  geneSearchInput.value = "TP53";
+  geneSearchInput.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", bubbles: true }));
+  await sleep(100);
+  test.equal(tw.q.type, "values", "submitted matrix q should use values");
+  test.deepEqual(Object.keys(tw.q), ["type"], "matrix q should not include mutation selector properties");
+  test.equal(tw.term.genes[0].gene, "TP53", "should submit the selected gene");
+  test.equal(tw.term.childTerms, void 0, "should not initialize mutation type terms");
+  test.equal(tw.q.origins, void 0, "should not set origin selector values");
+  test.equal(tw.term.sampleTypes, void 0, "should not set sample type selector values");
+  test.equal(tw.term.sampleTypeLabel, void 0, "should not set sample type label");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Single gene input", async (test) => {
+  let tw;
+  const callback = (_tw) => {
+    tw = _tw;
+  };
+  const holder = getHolder();
+  await initializeSearchHandler({ holder, callback });
+  const geneSearchInput = holder.select('[data-testid="sjpp-genevariant-geneSearchDiv"]').select('input[type="search"]').node();
+  geneSearchInput.value = "TP53";
+  geneSearchInput.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", bubbles: true }));
+  await sleep(100);
+  test.equal(tw.term.type, "geneVariant", "term.type should be geneVariant");
+  test.equal(tw.q.type, "predefined-groupset", "q.type should be predefined-groupset");
+  test.equal(tw.q.predefined_groupset_idx, 0, "q.predefined_groupset_idx should be 0");
+  test.equal(tw.term.genes.length, 1, "term.genes[] should have length of 1");
+  test.deepEqual(
+    tw.term.genes[0],
+    { kind: "gene", id: "TP53", gene: "TP53", name: "TP53", type: "geneVariant" },
+    "term.genes[0] should have expected structure"
+  );
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Change mutation type", async (test) => {
+  let tw;
+  const callback = (_tw) => {
+    tw = _tw;
+  };
+  const holder = getHolder();
+  const handler = await initializeSearchHandler({ holder, callback });
+  const mutationTypeRadiosDiv = holder.select('[data-testid="sjpp-genevariant-mutationTypeRadios"]');
+  const mutationTypeRadios = mutationTypeRadiosDiv.selectAll('input[type="radio"]');
+  const cnvMutationTypeIdx = handler.mutationTypeTerms.findIndex((term) => term.dt == dtcnv);
+  const cnvRadio = mutationTypeRadios.nodes()[cnvMutationTypeIdx];
+  cnvRadio.click();
+  const inputTypeRadiosDiv = holder.select('[data-testid="sjpp-genevariant-genesetTypeRadios"]');
+  const geneSetDiv = inputTypeRadiosDiv.selectAll("div").filter((d) => d.value == "geneset");
+  test.equal(geneSetDiv.style("display"), "none", "Gene set option should be hidden for CNV");
+  const geneSearchInput = holder.select('[data-testid="sjpp-genevariant-geneSearchDiv"]').select('input[type="search"]').node();
+  geneSearchInput.value = "TP53";
+  geneSearchInput.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", bubbles: true }));
+  await sleep(100);
+  test.equal(
+    tw.q.predefined_groupset_idx,
+    handler.mutationTypeTerms[cnvMutationTypeIdx].childTermIdx,
+    "q.predefined_groupset_idx should map the CNV mutation type to its child term"
+  );
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Gene set input", async (test) => {
+  let tw;
+  const callback = (_tw) => {
+    tw = _tw;
+  };
+  const holder = getHolder();
+  await initializeSearchHandler({ holder, callback });
+  const inputTypeRadiosDiv = holder.select('[data-testid="sjpp-genevariant-genesetTypeRadios"]');
+  const inputTypeRadios = inputTypeRadiosDiv.selectAll('input[type="radio"]');
+  const secondRadio = inputTypeRadios.nodes()[1];
+  secondRadio.click();
+  const geneSearchInput = holder.select('[data-testid="sjpp-genevariant-geneSearchDiv"]').select('input[type="search"]').node();
+  geneSearchInput.value = "TP53";
+  geneSearchInput.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", bubbles: true }));
+  await sleep(100);
+  geneSearchInput.value = "KRAS";
+  geneSearchInput.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", bubbles: true }));
+  const buttons = holder.select('[data-testid="sjpp-genevariant-geneSearchDiv"]').selectAll("button").nodes();
+  const submitButton = buttons.find((btn) => btn.textContent.trim() === "Submit");
+  await sleep(100);
+  submitButton.click();
+  await sleep(100);
+  test.equal(tw.term.genes.length, 2, "term.genes[] should have length of 2");
+  test.equal(tw.term.name, "TP53, KRAS", "term.name should concatenate gene names");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Gene set input - custom name", async (test) => {
+  let tw;
+  const callback = (_tw) => {
+    tw = _tw;
+  };
+  const holder = getHolder();
+  await initializeSearchHandler({ holder, callback });
+  const inputTypeRadiosDiv = holder.select('[data-testid="sjpp-genevariant-genesetTypeRadios"]');
+  const inputTypeRadios = inputTypeRadiosDiv.selectAll('input[type="radio"]');
+  const secondRadio = inputTypeRadios.nodes()[1];
+  secondRadio.click();
+  const geneSearchInput = holder.select('[data-testid="sjpp-genevariant-geneSearchDiv"]').select('input[type="search"]').node();
+  geneSearchInput.value = "TP53";
+  geneSearchInput.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", bubbles: true }));
+  await sleep(100);
+  geneSearchInput.value = "KRAS";
+  geneSearchInput.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", bubbles: true }));
+  await sleep(100);
+  const nameInput = holder.select('[data-testid="sja_genesetinput_name"]').node();
+  nameInput.value = "Test gene set";
+  const buttons = holder.select('[data-testid="sjpp-genevariant-geneSearchDiv"]').selectAll("button").nodes();
+  const submitButton = buttons.find((btn) => btn.textContent.trim() === "Submit");
+  await sleep(100);
+  submitButton.click();
+  await sleep(100);
+  test.equal(tw.term.genes.length, 2, "term.genes[] should have length of 2");
+  test.equal(tw.term.name, "Test gene set", "term.name should be custom name");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+function getVocabApiWithRememberedQ(lst) {
+  return Object.assign(Object.create(vocabApi), { getGvQLst: () => structuredClone(lst) });
+}
+function getVocabApiWithSampleTypes() {
+  const termdbConfig = structuredClone(vocabApi.termdbConfig);
+  termdbConfig.sampleTypes = {
+    1: { name: "Primary", plural_name: "Primary tumors" },
+    2: { name: "Relapse", plural_name: "Relapses" }
+  };
+  termdbConfig.assayAvailability ??= { byDt: {} };
+  termdbConfig.assayAvailability.byDt ??= {};
+  termdbConfig.assayAvailability.byDt[dtsnvindel] = {
+    ...termdbConfig.assayAvailability.byDt[dtsnvindel],
+    bySampleType: { 1: { hasSamples: true }, 2: { hasSamples: true } }
+  };
+  delete termdbConfig.assayAvailability.byDt[dtsnvindel].byOrigin;
+  termdbConfig.assayAvailability.byDt[dtcnv] = {
+    ...termdbConfig.assayAvailability.byDt[dtcnv],
+    bySampleType: { 1: { hasSamples: true } }
+  };
+  termdbConfig.queries.snvindel = { ...termdbConfig.queries.snvindel, mafFilter: true };
+  termdbConfig.queries.cnv = { ...termdbConfig.queries.cnv, cnvGainCutoff: 1 };
+  return Object.assign(Object.create(vocabApi), { termdbConfig });
+}
+function getVocabApiWithOrigins() {
+  const termdbConfig = structuredClone(vocabApi.termdbConfig);
+  termdbConfig.sampleTypes = {
+    1: { name: "Primary", plural_name: "Primary tumors" },
+    2: { name: "Relapse", plural_name: "Relapses" },
+    3: { name: "Normal", plural_name: "Normals" }
+  };
+  termdbConfig.assayAvailability ??= { byDt: {} };
+  termdbConfig.assayAvailability.byDt ??= {};
+  termdbConfig.assayAvailability.byDt[dtsnvindel] = {
+    byOrigin: {
+      germline: {
+        label: "Inherited",
+        bySampleType: { 2: { hasSamples: true }, 3: { hasSamples: true } }
+      },
+      somatic: {
+        label: "Tumor acquired",
+        bySampleType: { 1: { hasSamples: true }, 2: { hasSamples: true } }
+      }
+    }
+  };
+  termdbConfig.assayAvailability.byDt[dtcnv] = {
+    bySampleType: { 1: { hasSamples: true } }
+  };
+  return Object.assign(Object.create(vocabApi), { termdbConfig });
+}
+(0, import_tape.default)("Origins are selected separately from mutation type", async (test) => {
+  let tw;
+  const holder = getHolder();
+  const handler = await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: getVocabApiWithOrigins()
+  });
+  const snvindelMutationTypes = handler.mutationTypeTerms.filter((term) => term.dt == dtsnvindel);
+  test.equal(snvindelMutationTypes.length, 1, "should offer one mutation type for an origin-split dt");
+  test.equal(snvindelMutationTypes[0].name, "SNV/indel", "should omit origin from its label");
+  const byOrigin = handler.opts.app.vocabApi.termdbConfig.assayAvailability.byDt[dtsnvindel].byOrigin;
+  byOrigin.unsupported = {};
+  test.throws(() => handler.getQueryOrigins(), /unknown origin 'unsupported'/, "should reject an unrecognized origin");
+  delete byOrigin.unsupported;
+  test.equal(
+    handler.term.childTerms.filter((term) => term.dt == dtsnvindel).length,
+    1,
+    "should create one child term for an origin-split dt"
+  );
+  test.equal(
+    handler.term.childTerms.find((term) => term.dt == dtsnvindel).origin,
+    void 0,
+    "should omit child origin"
+  );
+  const originCheckboxes = holder.selectAll(".sjpp-genesearch-origin-checkboxes input");
+  test.equal(originCheckboxes.size(), 2, "should render the available origins");
+  test.deepEqual(
+    holder.selectAll(".sjpp-genesearch-origin-checkboxes span").nodes().map((node) => node.textContent),
+    ["Tumor acquired", "Inherited"],
+    "should use configured origin labels"
+  );
+  test.ok(
+    originCheckboxes.nodes().every((checkbox) => checkbox.checked),
+    "should select all origins by default"
+  );
+  test.equal(
+    holder.selectAll(".sjpp-genesearch-sampletype-checkboxes input").size(),
+    3,
+    "should show the union of sample types across selected origins"
+  );
+  await pickGene(holder);
+  test.deepEqual(tw.q.origins, ["somatic", "germline"], "should seed every origin when all are selected");
+  test.equal(tw.q.originLabel, "", "should use an empty label when all origins are selected");
+  originCheckboxes.nodes()[0].click();
+  test.deepEqual(handler.getSelectedOrigins(), ["germline"], "should retain the checked origin");
+  test.deepEqual(handler.getQuerySampleTypes(), [2, 3], "should refresh sample types from the checked origin");
+  test.equal(
+    holder.selectAll(".sjpp-genesearch-sampletype-checkboxes input").size(),
+    2,
+    "should rerender the sample type choices"
+  );
+  test.equal(
+    originCheckboxes.nodes()[1].parentElement?.title,
+    "At least one origin must be selected",
+    "should identify the last checked origin"
+  );
+  originCheckboxes.nodes()[1].click();
+  test.equal(originCheckboxes.nodes()[1].checked, true, "should prevent unchecking the last origin");
+  holder.selectAll(".sjpp-genesearch-sampletype-checkboxes input").nodes()[0].click();
+  await pickGene(holder);
+  test.deepEqual(tw.q.origins, ["germline"], "should seed the selected origins on the q");
+  test.equal(tw.q.originLabel, "Inherited", "should name the selected origin subset");
+  test.deepEqual(tw.term.sampleTypes, [3], "should submit selected sample types available to the selected origin");
+  test.equal(tw.term.sampleTypeLabel, "Normals", "should name the selected sample type subset");
+  test.equal(tw.term.name, "TP53", "should not append labels to the term name");
+  const cnvMutationTypeIdx = handler.mutationTypeTerms.findIndex((term) => term.dt == dtcnv);
+  const cnvRadio = holder.select('[data-testid="sjpp-genevariant-mutationTypeRadios"]').selectAll('input[type="radio"]').nodes()[cnvMutationTypeIdx];
+  cnvRadio.click();
+  test.equal(
+    holder.selectAll(".sjpp-genesearch-origin-checkboxes input").size(),
+    0,
+    "should hide origins for a dt without origin availability"
+  );
+  await pickGene(holder, "KRAS");
+  test.equal(tw.q.origins, void 0, "should clear a stale origin seed before submission");
+  test.equal(tw.q.originLabel, "", "should use an empty origin label when origins are not available");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Sample types are derived from current assay availability", async (test) => {
+  const holder = getHolder();
+  const handler = await initializeSearchHandler({ holder, vocabApi: getVocabApiWithSampleTypes() });
+  test.deepEqual(handler.getQuerySampleTypes(), [1, 2], "should return available SNV/indel sample types");
+  delete handler.opts.app.vocabApi.termdbConfig.assayAvailability.byDt[dtsnvindel].bySampleType;
+  test.equal(handler.getQuerySampleTypes(), void 0, "should not retain sample types after availability is removed");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Sample types are intersected for a multi-DT mutation type", async (test) => {
+  const holder = getHolder();
+  const handler = await initializeSearchHandler({ holder, vocabApi: getVocabApiWithSampleTypes() });
+  const allelicRadio = holder.select('[data-testid="sjpp-genevariant-mutationTypeRadios"]').selectAll('input[type="radio"]').nodes().slice(-1)[0];
+  allelicRadio.click();
+  test.deepEqual(handler.getQuerySampleTypes(), [1], "should return only sample types available for SNV/indel and CNV");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Sample type selection is cleared when changing to a mutation type without a selector", async (test) => {
+  let tw;
+  const holder = getHolder();
+  const handler = await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: getVocabApiWithSampleTypes()
+  });
+  const sampleTypeCheckboxes = holder.selectAll(".sjpp-genesearch-sampletype-checkboxes input");
+  test.equal(sampleTypeCheckboxes.size(), 2, "should render sample type choices for SNV/indel");
+  sampleTypeCheckboxes.nodes()[0].checked = false;
+  await pickGene(holder);
+  test.deepEqual(tw.term.sampleTypes, [2], "should submit the selected sample type");
+  const cnvMutationTypeIdx = handler.mutationTypeTerms.findIndex((term) => term.dt == dtcnv);
+  const cnvRadio = holder.select('[data-testid="sjpp-genevariant-mutationTypeRadios"]').selectAll('input[type="radio"]').nodes()[cnvMutationTypeIdx];
+  cnvRadio.click();
+  test.equal(
+    holder.selectAll(".sjpp-genesearch-sampletype-checkboxes input").size(),
+    0,
+    "should remove stale sample type choices"
+  );
+  await pickGene(holder, "KRAS");
+  test.deepEqual(tw.term.sampleTypes, [1], "should carry the only available CNV sample type");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Sample type label is empty for all types and names a selected subset", async (test) => {
+  let tw;
+  const holder = getHolder();
+  await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: getVocabApiWithSampleTypes()
+  });
+  await pickGene(holder);
+  test.equal(tw.term.sampleTypeLabel, "", "should use an empty label when all sample types are selected");
+  holder.selectAll(".sjpp-genesearch-sampletype-checkboxes input").nodes()[0].click();
+  await pickGene(holder);
+  test.equal(tw.term.sampleTypeLabel, "Relapses", "should name the selected sample type subset");
+  test.equal(tw.term.name, "TP53", "should not append the sample type label to the term name");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Continuing past remembered settings does not retain sample types from another mutation type", async (test) => {
+  let tw;
+  const holder = getHolder();
+  const sampleTypeVocabApi = getVocabApiWithSampleTypes();
+  const vocabApiWithRememberedKrasQ = Object.assign(Object.create(sampleTypeVocabApi), {
+    getGvQLst: (term) => term.name == "KRAS" ? structuredClone(rememberedLst) : []
+  });
+  const handler = await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: vocabApiWithRememberedKrasQ,
+    keepsQ: true
+  });
+  holder.selectAll(".sjpp-genesearch-sampletype-checkboxes input").nodes()[0].checked = false;
+  await pickGene(holder);
+  test.deepEqual(tw.term.sampleTypes, [2], "should submit the selected SNV/indel sample type");
+  const cnvMutationTypeIdx = handler.mutationTypeTerms.findIndex((term) => term.dt == dtcnv);
+  const cnvRadio = holder.select('[data-testid="sjpp-genevariant-mutationTypeRadios"]').selectAll('input[type="radio"]').nodes()[cnvMutationTypeIdx];
+  cnvRadio.click();
+  await pickGene(holder, "KRAS");
+  const continueWithCnv = holder.selectAll(".sja_menuoption").nodes().find((option) => option.textContent == `Continue with ${handler.mutationTypeTerms[cnvMutationTypeIdx].name}`);
+  continueWithCnv.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+  await sleep(100);
+  test.deepEqual(tw.term.sampleTypes, [1], "should not retain the prior SNV/indel sample type");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+function getRememberedQ(name) {
+  return {
+    type: "custom-groupset",
+    customset: {
+      groups: [
+        {
+          name,
+          filter: {
+            type: "tvslst",
+            join: "",
+            in: true,
+            lst: [{ type: "tvs", tvs: { term: { id: "snvindel_somatic", dt: dtsnvindel, origin: "somatic" } } }]
+          }
+        }
+      ]
+    }
+  };
+}
+var rememberedLst = [
+  { label: "TP53 missense", q: getRememberedQ("TP53 missense") },
+  { label: "TP53 truncating", q: getRememberedQ("TP53 truncating") }
+];
+async function pickGene(holder, gene = "TP53") {
+  const geneSearchInput = holder.select('[data-testid="sjpp-genevariant-geneSearchDiv"]').select('input[type="search"]').node();
+  geneSearchInput.value = gene;
+  geneSearchInput.dispatchEvent(new KeyboardEvent("keyup", { key: "Enter", code: "Enter", bubbles: true }));
+  await sleep(100);
+}
+(0, import_tape.default)("Remembered settings are offered for the picked gene", async (test) => {
+  let tw;
+  const holder = getHolder();
+  await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: getVocabApiWithRememberedQ(rememberedLst),
+    keepsQ: true,
+    // as client/plots/summarizeMutationSurvival.ts supplies it
+    msg: "Hit ENTER to launch plot."
+  });
+  await pickGene(holder);
+  test.equal(tw, void 0, "should not apply the mutation type while the settings are offered");
+  const msgDiv = holder.selectAll("div").nodes().find((n) => n.textContent == "Hit ENTER to launch plot.");
+  test.equal(msgDiv?.style.display, "none", "should hide a caller message that no longer describes what happens");
+  const remembered = holder.selectAll('[data-testid="sjpp-genevariant-rememberedQ"]');
+  test.equal(remembered.size(), 2, "should offer both remembered settings");
+  test.deepEqual(
+    remembered.nodes().map((n) => n.textContent),
+    ["TP53 missense", "TP53 truncating"],
+    "should label each by its remembered label"
+  );
+  const options = holder.selectAll(".sja_menuoption").nodes();
+  test.equal(options.length, 3, "should offer a way to continue with the mutation type instead");
+  test.ok(
+    options.every((n) => n.getAttribute("tabindex") == "0"),
+    "should make every option keyboard focusable"
+  );
+  test.equal(document.activeElement, options[0], "should focus the most recent setting");
+  options[0].dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowDown", bubbles: true }));
+  test.equal(document.activeElement, options[1], "should move focus down");
+  options[1].dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowUp", bubbles: true }));
+  test.equal(document.activeElement, options[0], "should move focus up");
+  options[0].dispatchEvent(new KeyboardEvent("keydown", { key: "ArrowUp", bubbles: true }));
+  test.equal(document.activeElement, options[2], "should wrap to the last option");
+  options[2].dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+  await sleep(100);
+  test.equal(tw?.q?.type, "predefined-groupset", "should continue with the mutation type on Enter");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Remembered settings are applied on Enter", async (test) => {
+  let tw;
+  const holder = getHolder();
+  await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: getVocabApiWithRememberedQ(rememberedLst),
+    keepsQ: true
+  });
+  await pickGene(holder);
+  const first = holder.selectAll('[data-testid="sjpp-genevariant-rememberedQ"]').nodes()[0];
+  first.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+  await sleep(100);
+  test.equal(tw.q.type, "custom-groupset", "should apply the remembered q");
+  test.deepEqual(
+    tw.q.customset.groups.map((g) => g.name),
+    ["TP53 missense"],
+    "should apply the groups of the setting that was focused"
+  );
+  test.equal(tw.term.name, "TP53", "should apply it to the gene that was picked");
+  test.equal(
+    holder.select('[data-testid="sjpp-genevariant-rememberedQ"]').empty(),
+    true,
+    "should clear the offered settings once one is applied"
+  );
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Applying remembered settings applies the selected sample type", async (test) => {
+  let tw;
+  const holder = getHolder();
+  const sampleTypeVocabApi = getVocabApiWithSampleTypes();
+  await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: Object.assign(Object.create(sampleTypeVocabApi), {
+      getGvQLst: () => structuredClone(rememberedLst)
+    }),
+    keepsQ: true
+  });
+  holder.selectAll(".sjpp-genesearch-sampletype-checkboxes input").nodes()[0].checked = false;
+  await pickGene(holder);
+  const first = holder.selectAll('[data-testid="sjpp-genevariant-rememberedQ"]').nodes()[0];
+  first.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+  await sleep(100);
+  test.deepEqual(tw.term.sampleTypes, [2], "should apply the selected sample type with the remembered q");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Remembered settings of another mutation type do not lead", async (test) => {
+  let tw;
+  const holder = getHolder();
+  const handler = await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: getVocabApiWithRememberedQ(rememberedLst),
+    keepsQ: true
+  });
+  const cnvMutationTypeIdx = handler.mutationTypeTerms.findIndex((term) => term.dt == dtcnv);
+  const cnvRadio = holder.select('[data-testid="sjpp-genevariant-mutationTypeRadios"]').selectAll('input[type="radio"]').nodes()[cnvMutationTypeIdx];
+  cnvRadio.click();
+  await pickGene(holder);
+  const options = holder.selectAll(".sja_menuoption").nodes();
+  test.deepEqual(
+    options.map((n) => n.textContent),
+    ["Continue with CNV", "TP53 missense", "TP53 truncating"],
+    "should lead with the selected mutation type, followed by the settings of other mutation types"
+  );
+  test.equal(document.activeElement, options[0], "should focus the way to continue with the mutation type");
+  options[0].dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+  await sleep(100);
+  test.equal(
+    tw?.q?.predefined_groupset_idx,
+    handler.mutationTypeTerms[cnvMutationTypeIdx].childTermIdx,
+    "should continue with the selected mutation type on Enter"
+  );
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Remembered settings are cleared on changing the mutation type", async (test) => {
+  let tw;
+  const holder = getHolder();
+  const handler = await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: getVocabApiWithRememberedQ(rememberedLst),
+    keepsQ: true,
+    msg: "Hit ENTER to launch plot."
+  });
+  await pickGene(holder);
+  test.equal(holder.selectAll(".sja_menuoption").size(), 3, "should offer the settings of the picked gene");
+  const cnvMutationTypeIdx = handler.mutationTypeTerms.findIndex((term) => term.dt == dtcnv);
+  const cnvRadio = holder.select('[data-testid="sjpp-genevariant-mutationTypeRadios"]').selectAll('input[type="radio"]').nodes()[cnvMutationTypeIdx];
+  cnvRadio.click();
+  await sleep(100);
+  test.equal(holder.selectAll(".sja_menuoption").size(), 0, "should clear the offered settings");
+  test.equal(tw, void 0, "should not apply anything on its own");
+  const msgDiv = holder.selectAll("div").nodes().find((n) => n.textContent == "Hit ENTER to launch plot.");
+  test.equal(msgDiv?.style.display, "block", "should put back the caller message that describes picking a gene again");
+  await pickGene(holder);
+  const options = holder.selectAll(".sja_menuoption").nodes();
+  test.equal(
+    options[0]?.textContent,
+    "Continue with CNV",
+    "should offer the settings against the mutation type now selected"
+  );
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Remembered settings are cleared on changing the input type", async (test) => {
+  let tw;
+  const holder = getHolder();
+  await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: getVocabApiWithRememberedQ(rememberedLst),
+    keepsQ: true
+  });
+  await pickGene(holder);
+  test.equal(holder.selectAll(".sja_menuoption").size(), 3, "should offer the settings of the picked gene");
+  const geneSetRadio = holder.select('[data-testid="sjpp-genevariant-genesetTypeRadios"]').selectAll('input[type="radio"]').nodes()[1];
+  geneSetRadio.click();
+  await sleep(100);
+  test.equal(holder.selectAll(".sja_menuoption").size(), 0, "should clear the offered settings");
+  test.equal(tw, void 0, "should not apply anything on its own");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("Remembered settings are not offered where the q would be dropped", async (test) => {
+  let tw;
+  const holder = getHolder();
+  await initializeSearchHandler({
+    holder,
+    callback: (_tw) => tw = _tw,
+    vocabApi: getVocabApiWithRememberedQ(rememberedLst)
+  });
+  await pickGene(holder);
+  test.equal(
+    holder.select('[data-testid="sjpp-genevariant-rememberedQ"]').empty(),
+    true,
+    "should offer no remembered setting"
+  );
+  test.equal(tw.q.type, "predefined-groupset", "should apply the mutation type directly");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+//# sourceMappingURL=geneVariant.integration.spec-UJXGQEZG.js.map