@sjcrh/proteinpaint-client 2.225.0 → 2.227.0

package/dist/imagePlot-J4PHG7V2.js

@@ -0,0 +1,152 @@
+import {
+  PlotBase,
+  controlsInit
+} 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 {
+  dofetch3
+} from "./chunk-VVWZ4BOI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-2IAELUCN.js";
+import "./chunk-CFYWQJ7F.js";
+import "./chunk-2N345NXD.js";
+import {
+  copyMerge,
+  getCompInit
+} from "./chunk-HBNB5TRH.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-PWYMHUXY.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+
+// plots/imagePlot.ts
+var ImagePlot = class _ImagePlot extends PlotBase {
+  static {
+    this.type = "imagePlot";
+  }
+  constructor(opts, api) {
+    super(opts, api);
+    this.type = _ImagePlot.type;
+    if (this.opts?.header) {
+      if (this.opts?.headerText)
+        this.opts.header.append("span").style("padding-right", "5px").text(this.opts.headerText);
+      this.opts.header.append("span").text("IMAGE PLOT").style("font-size", "0.7em").style("opacity", 0.6);
+    }
+  }
+  getState(appState) {
+    const config = appState.plots.find((p) => p.id === this.id);
+    if (!config) {
+      throw `No plot with id='${this.id}' found. Did you set this.id before this.api = getComponentApi(this)?`;
+    }
+    return {
+      config,
+      termfilter: appState.termfilter,
+      vocab: appState.vocab
+    };
+  }
+  async init(appState) {
+    const config = this.getState(appState).config;
+    const holder = this.opts.holder.append("div").attr("data-testid", "sjpp-imagePlot-holder");
+    this.dom = {
+      holder,
+      controlsHolder: holder.append("div").attr("data-testid", "sjpp-imagePlot-controlsDiv").style("display", "inline-block"),
+      imageHolder: holder.append("div").attr("data-testid", "sjpp-imagePlot-imagesDiv").style("display", "inline-block")
+    };
+    const sampleId = config.sample?.sampleId || config.sample?.sID;
+    let images;
+    if (config?.imgDir) {
+      const img = await dofetch3(
+        `img?file=${config.imgDir.folder}${config.imgDir.folder.endsWith("/") ? "" : "/"}${sampleId}/${config.imgDir.fileName}`
+      );
+      if (!img || img?.error) throw new Error(img?.error || "Error fetching image");
+      images = [img];
+    } else {
+      const result = await this.vocabApi.getSampleImages(sampleId);
+      if (result.error) throw new Error(result.error);
+      images = result.images;
+    }
+    for (const img of images) {
+      this.dom.imageHolder.append("img").style("padding", "10px").attr("src", img.src).attr("width", config.settings.imagePlot.width).attr("height", config.settings.imagePlot.height);
+    }
+  }
+  async setControls() {
+    this.components = {
+      controls: await controlsInit({
+        app: this.app,
+        id: this.id,
+        holder: this.dom.controlsHolder,
+        inputs: [
+          {
+            label: "Image width",
+            type: "number",
+            chartType: this.type,
+            settingsKey: "width"
+          },
+          {
+            label: "Image height",
+            type: "number",
+            chartType: this.type,
+            settingsKey: "height"
+          }
+        ]
+      })
+    };
+  }
+  async main() {
+  }
+};
+async function getPlotConfig(opts) {
+  const settings = getDefaultImagePlotSettings();
+  if (opts.settings) copyMerge(settings, opts.settings);
+  const config = {
+    settings: {
+      controls: {
+        isOpen: false
+      },
+      imagePlot: settings
+    }
+  };
+  return copyMerge(config, opts);
+}
+function getDefaultImagePlotSettings() {
+  return {
+    width: 500,
+    height: 500
+  };
+}
+var imagePlotInit = getCompInit(ImagePlot);
+var componentInit = imagePlotInit;
+async function renderImagePlot(state, holder, sample) {
+  const opts = {
+    holder,
+    state: {
+      vocab: state.vocab,
+      plots: [
+        {
+          chartType: "imagePlot",
+          sample
+        }
+      ]
+    }
+  };
+  const plot = await import("./plot.app-JYBZEBHK.js");
+  await plot.appInit(opts);
+}
+export {
+  componentInit,
+  getDefaultImagePlotSettings,
+  getPlotConfig,
+  imagePlotInit,
+  renderImagePlot
+};
+//# sourceMappingURL=imagePlot-J4PHG7V2.js.map

package/dist/importPlot-U67MZZXY.js

@@ -0,0 +1,8 @@
+import {
+  importPlot
+} from "./chunk-QKVKQD6S.js";
+import "./chunk-HS5PO5ZQ.js";
+export {
+  importPlot
+};
+//# sourceMappingURL=importPlot-U67MZZXY.js.map

package/dist/isoformExpression-K5BCDJLL.js

@@ -0,0 +1,31 @@
+import {
+  SearchHandler,
+  filterIsoforms
+} from "./chunk-UVES3USV.js";
+import "./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 "./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 "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+export {
+  SearchHandler,
+  filterIsoforms
+};
+//# sourceMappingURL=isoformExpression-K5BCDJLL.js.map

package/dist/isoformExpression.unit.spec-35FHEO27.js

@@ -0,0 +1,233 @@
+import {
+  SearchHandler,
+  filterIsoforms
+} from "./chunk-UVES3USV.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import "./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 {
+  ISOFORM_EXPRESSION
+} 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/isoformExpression.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+function mockGm(isoform) {
+  return { isoform, chr: "chr1", start: 0, stop: 100, exon: [[0, 100]] };
+}
+(0, import_tape.default)("\n", function(test) {
+  test.comment("-***- termdb/handlers/isoformExpression -***-");
+  test.end();
+});
+(0, import_tape.default)("selectIsoform() should call callback with configured unit from termdbConfig", (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {
+          isoformExpression: { unit: "TPM" }
+        }
+      }
+    }
+  };
+  handler.selectIsoform("ENST00000269305", "TP53");
+  test.equal(selected?.isoform, "ENST00000269305", "Should pass selected isoform");
+  test.equal(selected?.gene, "TP53", "Should pass gene");
+  test.equal(selected?.name, "ENST00000269305 TPM", "Should include configured unit in term name");
+  test.equal(selected?.type, ISOFORM_EXPRESSION, "Should set type to isoformExpression");
+  test.end();
+});
+(0, import_tape.default)("selectIsoform() should use default unit when not configured", (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {}
+      }
+    }
+  };
+  handler.selectIsoform("ENST00000269305", "TP53");
+  test.equal(selected?.isoform, "ENST00000269305", "Should pass selected isoform");
+  test.equal(selected?.name, "ENST00000269305 TPM", "Should use default unit TPM");
+  test.equal(selected?.type, ISOFORM_EXPRESSION, "Should set type to isoformExpression");
+  test.end();
+});
+(0, import_tape.default)("selectCollection() should create a custom termCollection from multiple isoforms", (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {
+          isoformExpression: { unit: "TPM" }
+        }
+      }
+    }
+  };
+  handler.selectCollection([mockGm("ENST00000256078"), mockGm("ENST00000311936")], "KRAS");
+  test.equal(selected?.type, "termCollection", "Should set type to termCollection");
+  test.equal(selected?.isCustom, true, "Should set isCustom flag");
+  test.equal(selected?.memberType, "numeric", "Should set memberType to numeric");
+  test.equal(selected?.name, "KRAS Isoforms (TPM)", "Should include gene and unit in name");
+  test.equal(selected?.isleaf, true, "Should set isleaf");
+  test.ok(selected?.propsByTermId.ENST00000256078.color, "Should assign the first isoform a color");
+  test.ok(selected?.propsByTermId.ENST00000311936.color, "Should assign the second isoform a color");
+  test.notEqual(
+    selected?.propsByTermId.ENST00000256078.color,
+    selected?.propsByTermId.ENST00000311936.color,
+    "Should assign distinct member colors"
+  );
+  test.equal(selected?.termlst?.length, 2, "Should have 2 member terms");
+  const mt = selected.termlst[0];
+  test.equal(mt.id, "ENST00000256078", "Member term id should be the isoform ID");
+  test.equal(mt.name, "ENST00000256078", "Member term name should be the isoform ID");
+  test.equal(mt.type, "isoformExpression", "Member term type should be isoformExpression");
+  test.equal(mt.isoform, "ENST00000256078", "Member term should carry isoform field");
+  test.end();
+});
+(0, import_tape.default)("selectCollection() should use default unit when not configured", (test) => {
+  const handler = new SearchHandler();
+  let selected;
+  handler.callback = (t) => {
+    selected = t;
+  };
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {}
+      }
+    }
+  };
+  handler.selectCollection([mockGm("ENST00000256078"), mockGm("ENST00000311936")], "KRAS");
+  test.equal(selected?.name, "KRAS Isoforms (TPM)", "Should use default unit TPM");
+  test.end();
+});
+(0, import_tape.default)("selectCollection() renders fraction choices when requested", (test) => {
+  const handler = new SearchHandler();
+  const holder = select_default("body").append("div");
+  let selected;
+  handler.callback = (term) => {
+    selected = term;
+  };
+  handler.app = {
+    vocabApi: { termdbConfig: { queries: { isoformExpression: { unit: "TPM" } } } }
+  };
+  handler.termCollectionSelectionMode = "fraction";
+  handler.dom = { errDiv: holder.append("div"), isoformDiv: holder.append("div") };
+  handler.selectCollection([mockGm("ENST00000256078"), mockGm("ENST00000311936")], "KRAS");
+  test.ok(holder.text().includes("Denominator"), "renders denominator choices");
+  holder.select('[data-testid="sjpp-term-collection-fraction-select"]').node().click();
+  test.equal(selected?.type, "TermCollectionTWFraction", "returns a fraction wrapper");
+  test.deepEqual(
+    selected?.q.denominators,
+    ["ENST00000256078", "ENST00000311936"],
+    "defaults every isoform as a denominator"
+  );
+  test.deepEqual(selected?.q.numerators, ["ENST00000256078"], "defaults only the first isoform as numerator");
+  test.equal(selected?.term.termlst.length, 2, "retains every isoform on the collection term");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("showIsoforms multi-select: single isoform calls selectIsoform, multiple calls selectCollection", (test) => {
+  const handler = new SearchHandler();
+  const calls = [];
+  handler.app = {
+    vocabApi: {
+      termdbConfig: {
+        queries: {
+          isoformExpression: { unit: "TPM" }
+        }
+      }
+    }
+  };
+  handler.selectIsoform = (isoform, gene) => {
+    calls.push({ method: "selectIsoform", args: { isoform, gene } });
+  };
+  handler.selectCollection = (gms, gene) => {
+    calls.push({ method: "selectCollection", args: { gms, gene } });
+  };
+  const onMultiSelect1 = (selected) => {
+    if (selected.length === 1) handler.selectIsoform(selected[0].isoform, "TP53");
+    else handler.selectCollection(selected, "TP53");
+  };
+  onMultiSelect1([mockGm("ENST00000269305")]);
+  test.equal(calls.length, 1, "Should have one call");
+  test.equal(calls[0].method, "selectIsoform", "Single isoform should call selectIsoform");
+  const onMultiSelect2 = (selected) => {
+    if (selected.length === 1) handler.selectIsoform(selected[0].isoform, "KRAS");
+    else handler.selectCollection(selected, "KRAS");
+  };
+  onMultiSelect2([mockGm("ENST00000256078"), mockGm("ENST00000311936")]);
+  test.equal(calls.length, 2, "Should have two calls total");
+  test.equal(calls[1].method, "selectCollection", "Multiple isoforms should call selectCollection");
+  test.equal(calls[1].args.gms.length, 2, "Should pass both gene models");
+  test.end();
+});
+(0, import_tape.default)("filterIsoforms() should return only ENST isoforms present in availableItems", (test) => {
+  const gmlst = [mockGm("ENST00000269305"), mockGm("ENST00000413465"), mockGm("NM_000546"), mockGm("ENST00000359597")];
+  const availableItems = ["ENST00000269305", "ENST00000359597"];
+  const result = filterIsoforms(gmlst, availableItems);
+  test.equal(result.length, 2, "Should return 2 matching isoforms");
+  test.equal(result[0].isoform, "ENST00000269305", "First match correct");
+  test.equal(result[1].isoform, "ENST00000359597", "Second match correct");
+  test.end();
+});
+(0, import_tape.default)("filterIsoforms() should exclude non-ENST isoforms even if in availableItems", (test) => {
+  const gmlst = [mockGm("NM_000546"), mockGm("NR_176326"), mockGm("ENST00000269305")];
+  const availableItems = ["NM_000546", "ENST00000269305"];
+  const result = filterIsoforms(gmlst, availableItems);
+  test.equal(result.length, 1, "Should only return ENST isoform");
+  test.equal(result[0].isoform, "ENST00000269305", "Should be the ENST match");
+  test.end();
+});
+(0, import_tape.default)("filterIsoforms() should return all ENST isoforms when availableItems is empty", (test) => {
+  const gmlst = [mockGm("ENST00000269305"), mockGm("ENST00000413465"), mockGm("NM_000546")];
+  const result = filterIsoforms(gmlst, []);
+  test.equal(result.length, 2, "Should return all ENST isoforms when no filter");
+  test.equal(result[0].isoform, "ENST00000269305", "First ENST correct");
+  test.equal(result[1].isoform, "ENST00000413465", "Second ENST correct");
+  test.end();
+});
+(0, import_tape.default)("filterIsoforms() should return empty array when no ENST isoforms match", (test) => {
+  const gmlst = [mockGm("ENST00000269305"), mockGm("ENST00000413465")];
+  const availableItems = ["ENST00000999999"];
+  const result = filterIsoforms(gmlst, availableItems);
+  test.equal(result.length, 0, "Should return empty when no matches");
+  test.end();
+});
+//# sourceMappingURL=isoformExpression.unit.spec-35FHEO27.js.map

package/dist/junction-6GGWFF2J.js

@@ -0,0 +1,32 @@
+import {
+  SearchHandler,
+  getJunctionCustomTerms
+} from "./chunk-JKPMBNRM.js";
+import "./chunk-FIWVGOSE.js";
+import "./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 "./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 "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-HS5PO5ZQ.js";
+export {
+  SearchHandler,
+  getJunctionCustomTerms
+};
+//# sourceMappingURL=junction-6GGWFF2J.js.map

package/dist/junction.unit.spec-7EJK4HML.js

@@ -0,0 +1,224 @@
+import {
+  SearchHandler
+} from "./chunk-JKPMBNRM.js";
+import {
+  makeJunctionCustomTerm
+} from "./chunk-FIWVGOSE.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import "./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 "./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/junction.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+function makeJunction(id) {
+  return {
+    type: "junction",
+    id,
+    name: `Name ${id}`,
+    chr: "chr1",
+    start: 100,
+    stop: 200,
+    strand: "+",
+    info: {}
+  };
+}
+function getOpts(holder, dslabel, customTerms = [], callback = (_term) => {
+}, termCollectionSelectionMode) {
+  const state = { customTerms };
+  return {
+    holder,
+    callback,
+    termCollectionSelectionMode,
+    genomeObj: { name: "hg38" },
+    app: {
+      vocabApi: {
+        vocab: { dslabel },
+        state,
+        async deleteCustomTermById(id) {
+          const index = state.customTerms.findIndex((term) => term.id === id);
+          if (index !== -1) state.customTerms.splice(index, 1);
+        }
+      }
+    }
+  };
+}
+(0, import_tape.default)("\n", (test) => {
+  test.comment("-***- termdb/handlers/junction -***-");
+  test.end();
+});
+(0, import_tape.default)("init() shows the empty-state message", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  await handler.init(getOpts(holder, "junction-handler-empty"));
+  test.ok(holder.text().includes("Junctions selected from genome browser"), "shows the empty-state instructions");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("ungrouped junctions render as selectable pills and can be deleted", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  let selected;
+  const dslabel = "junction-handler-ungrouped";
+  const customTerms = [makeJunctionCustomTerm([makeJunction("junction-1")])];
+  await handler.init(
+    getOpts(holder, dslabel, customTerms, (term) => {
+      selected = term;
+    })
+  );
+  const pill = holder.select(".ts_pill");
+  test.equal(pill.text(), "Name junction-1", "renders the junction name in a pill");
+  pill.node().click();
+  test.equal(selected?.id, "junction-1", "selects the individual junction");
+  holder.select('[data-testid="sjpp-junction-delete"]').node().click();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  test.equal(holder.selectAll(".ts_pill").size(), 0, "removes the deleted junction pill");
+  test.ok(holder.text().includes("Junctions selected from genome browser"), "restores the empty state");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("event junctions render as one pill that selects and deletes the term collection", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  let selected;
+  const dslabel = "junction-handler-event";
+  const customTerms = [makeJunctionCustomTerm([makeJunction("junction-1"), makeJunction("junction-2")], "Event A")];
+  await handler.init(
+    getOpts(holder, dslabel, customTerms, (term) => {
+      selected = term;
+    })
+  );
+  const pills = holder.selectAll(".ts_pill");
+  test.equal(pills.size(), 1, "renders one pill for the event and no member junction pills");
+  test.equal(pills.text(), "Event A", "uses the event label as the pill text");
+  test.ok(holder.text().includes("junction-1"), "lists the first junction ID");
+  test.ok(holder.text().includes("junction-2"), "lists the second junction ID");
+  pills.node().click();
+  test.equal(selected?.type, "termCollection", "selects a term collection");
+  test.equal(selected?.memberType, "numeric", "creates a numeric collection");
+  test.equal(selected?.name, "Event A", "uses the event label as the collection name");
+  test.deepEqual(selected?.termIds, ["junction-1", "junction-2"], "includes all event junction IDs");
+  test.ok(selected?.propsByTermId["junction-1"].color, "assigns the first junction a color");
+  test.ok(selected?.propsByTermId["junction-2"].color, "assigns the second junction a color");
+  test.notEqual(
+    selected?.propsByTermId["junction-1"].color,
+    selected?.propsByTermId["junction-2"].color,
+    "assigns distinct member colors"
+  );
+  holder.select('[data-testid="sjpp-junction-delete"]').node().click();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  test.equal(holder.selectAll(".ts_pill").size(), 0, "removes the complete event choice");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init() only shows state-backed junction custom terms", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  const customTerms = [
+    makeJunctionCustomTerm([makeJunction("active-junction")]),
+    { id: "other-custom-term", name: "Other", tw: { term: { type: "float", id: "other", name: "Other" } } }
+  ];
+  await handler.init(getOpts(holder, "active", customTerms));
+  test.equal(holder.selectAll(".ts_pill").size(), 1, "renders only one matching junction term");
+  test.equal(holder.select(".ts_pill").text(), "Name active-junction", "renders the state-backed junction");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("event junction renders fraction choices when requested", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  let selected;
+  const customTerms = [makeJunctionCustomTerm([makeJunction("junction-1"), makeJunction("junction-2")], "Event A")];
+  await handler.init(
+    getOpts(
+      holder,
+      "junction-handler-fraction",
+      customTerms,
+      (term) => {
+        selected = term;
+      },
+      "fraction"
+    )
+  );
+  holder.select(".ts_pill").node().click();
+  test.ok(holder.text().includes("Denominator"), "renders denominator choices for the event collection");
+  holder.select('[data-testid="sjpp-term-collection-fraction-select"]').node().click();
+  test.equal(selected?.type, "TermCollectionTWFraction", "returns a fraction wrapper");
+  test.deepEqual(selected?.q.denominators, ["junction-1", "junction-2"], "defaults both junctions as denominators");
+  test.deepEqual(selected?.q.numerators, ["junction-1"], "defaults only the first junction as numerator");
+  test.equal(selected?.term.termlst.length, 2, "retains both junction members");
+  holder.remove();
+  test.end();
+});
+(0, import_tape.default)("the sample type row sets the chosen sample types on the picked junction and event", async (test) => {
+  const holder = select_default("body").append("div");
+  const handler = new SearchHandler();
+  let selected;
+  const customTerms = [
+    makeJunctionCustomTerm([makeJunction("junction-1")]),
+    makeJunctionCustomTerm([makeJunction("junction-2"), makeJunction("junction-3")], "Event A")
+  ];
+  const opts = getOpts(holder, "junction-handler-sampletypes", customTerms, (term) => {
+    selected = term;
+  });
+  opts.app.vocabApi.termdbConfig = {
+    queries: { junction: { sampleTypes: [2, 3] } },
+    sampleTypes: {
+      1: { name: "patient", plural_name: "patients", parent_id: null },
+      2: { name: "diagnosis sample", plural_name: "diagnosis samples", parent_id: 1 },
+      3: { name: "relapse sample", plural_name: "relapse samples", parent_id: 1 }
+    }
+  };
+  await handler.init(opts);
+  const pills = () => holder.selectAll(".ts_pill").nodes();
+  const boxes = () => holder.selectAll("input[type=checkbox]").nodes();
+  test.equal(boxes().length, 2, "renders a checkbox for each sample type of the junction file");
+  pills()[0].click();
+  test.equal(selected.name, "Name junction-1", "keeps the name when every sample type is checked");
+  test.notOk("sampleTypes" in selected, "reads every sample, as before the selector, when every type is checked");
+  boxes()[1].click();
+  pills()[0].click();
+  test.deepEqual(selected.sampleTypes, [2], "sets the checked sample types on the junction term");
+  test.equal(selected.name, "Name junction-1 (diagnosis samples)", "names the sample types");
+  test.equal(selected.id, "junction-1", "keeps the junction id");
+  test.notOk(customTerms[0].tw.term.sampleTypes, "leaves the stored custom term unchanged");
+  pills()[1].click();
+  test.deepEqual(selected.sampleTypes, [2], "sets the sample types on the event collection");
+  test.ok(
+    selected.termlst.every((m) => m.sampleTypes?.[0] == 2),
+    "sets them on each member junction, which the server reads on its own"
+  );
+  holder.select('[data-testid="sjpp-junction-delete"]').node().click();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  test.equal(boxes()[1].checked, false, "keeps the sample type choice after a delete");
+  pills()[0].click();
+  test.equal(selected.name, "Event A (diagnosis samples)", "names the sample types once after the list is redrawn");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+//# sourceMappingURL=junction.unit.spec-7EJK4HML.js.map