@sjcrh/proteinpaint-client 2.220.0 → 2.221.0

package/dist/singleCellNumericValue.unit.spec-QGLHES7H.js

@@ -0,0 +1,412 @@
+import {
+  SearchHandler
+} from "./chunk-3PCRAPUV.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-WXSMUSU7.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import {
+  TermTypeGroups
+} from "./chunk-WJLRU5OF.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/singleCellNumericValue.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+function getHolder() {
+  return select_default("body").append("div");
+}
+function createMockApp(termType2terms = []) {
+  return {
+    vocabApi: {
+      termdbConfig: {
+        termType2terms: {
+          [TermTypeGroups.SINGLECELL_NUMERIC_VALUE]: termType2terms
+        }
+      }
+    }
+  };
+}
+function createMockUsecase(config = {}) {
+  return {
+    specialCase: {
+      config
+    }
+  };
+}
+function createMockTerm(overrides = {}) {
+  return {
+    name: "test_term",
+    plot: "UMAP",
+    sample: void 0,
+    ...overrides
+  };
+}
+function createValidOpts(overrides = {}) {
+  return {
+    callback: () => {
+    },
+    app: createMockApp(),
+    holder: getHolder(),
+    usecase: createMockUsecase(),
+    ...overrides
+  };
+}
+(0, import_tape.default)("\n", function(test) {
+  test.comment("-***- termdb/handlers/singleCellNumericValue -***-");
+  test.end();
+});
+(0, import_tape.default)("constructor: creates SearchHandler instance", function(test) {
+  const handler = new SearchHandler();
+  test.ok(handler instanceof SearchHandler, "creates instance of SearchHandler");
+  test.equal(handler.callback, void 0, "callback starts as undefined");
+  test.equal(handler.app, void 0, "app starts as undefined");
+  test.end();
+});
+(0, import_tape.default)("validateOpts: accepts valid opts object", function(test) {
+  const handler = new SearchHandler();
+  const opts = createValidOpts();
+  test.doesNotThrow(
+    () => handler.validateOpts(opts),
+    "validateOpts accepts valid options"
+  );
+  test.end();
+});
+(0, import_tape.default)("validateOpts: throws error for missing callback", function(test) {
+  const handler = new SearchHandler();
+  const opts = createValidOpts({ callback: null });
+  test.throws(
+    () => handler.validateOpts(opts),
+    /callback is required/,
+    "throws error when callback is null"
+  );
+  test.end();
+});
+(0, import_tape.default)("validateOpts: throws error for missing app", function(test) {
+  const handler = new SearchHandler();
+  const opts = createValidOpts({ app: null });
+  test.throws(
+    () => handler.validateOpts(opts),
+    /app is required/,
+    "throws error when app is null"
+  );
+  test.end();
+});
+(0, import_tape.default)("validateOpts: throws error for missing holder", function(test) {
+  const handler = new SearchHandler();
+  const opts = createValidOpts({ holder: null });
+  test.throws(
+    () => handler.validateOpts(opts),
+    /holder is required/,
+    "throws error when holder is null"
+  );
+  test.end();
+});
+(0, import_tape.default)("validateOpts: throws error for missing usecase", function(test) {
+  const handler = new SearchHandler();
+  const opts = createValidOpts({ usecase: null });
+  test.throws(
+    () => handler.validateOpts(opts),
+    /usecase is required/,
+    "throws error when usecase is null"
+  );
+  test.end();
+});
+(0, import_tape.default)("makeTerm: creates term from raw term", function(test) {
+  const handler = new SearchHandler();
+  const rawTerm = createMockTerm({ sample: "sample1" });
+  const result = handler.makeTerm(rawTerm, {});
+  test.equal(result.name, "test_term", "preserves term name");
+  test.equal(result.plot, "UMAP", "preserves UMAP");
+  test.equal(result.sample, "sample1", "preserves original sample");
+  test.end();
+});
+(0, import_tape.default)("makeTerm: adds sample from usecase config when term missing sample", function(test) {
+  const handler = new SearchHandler();
+  const rawTerm = createMockTerm({ sample: void 0 });
+  const usecaseConfig = { sample: "usecase_sample" };
+  const result = handler.makeTerm(rawTerm, usecaseConfig);
+  test.equal(result.sample, "usecase_sample", "uses sample from usecase config");
+  test.end();
+});
+(0, import_tape.default)("makeTerm: does not override term sample with usecase config sample", function(test) {
+  const handler = new SearchHandler();
+  const rawTerm = createMockTerm({ sample: "term_sample" });
+  const usecaseConfig = { sample: "usecase_sample" };
+  const result = handler.makeTerm(rawTerm, usecaseConfig);
+  test.equal(result.sample, "term_sample", "preserves term sample over usecase config");
+  test.end();
+});
+(0, import_tape.default)("makeTerm: does not mutate original term", function(test) {
+  const handler = new SearchHandler();
+  const rawTerm = createMockTerm({ sample: void 0 });
+  const usecaseConfig = { sample: "usecase_sample" };
+  const result = handler.makeTerm(rawTerm, usecaseConfig);
+  test.equal(rawTerm.sample, void 0, "original term is not mutated");
+  test.notEqual(result, rawTerm, "returns new term object");
+  test.end();
+});
+(0, import_tape.default)("init: throws error when no terms in termType2terms", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const opts = createValidOpts({
+    holder,
+    app: createMockApp([])
+    // empty terms array
+  });
+  await handler.init(opts);
+  const errorDiv = holder.select("div");
+  const hasError = errorDiv.node() !== null;
+  test.ok(hasError, "displays error message when no terms available");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: displays error with correct message format", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const opts = createValidOpts({
+    holder,
+    app: createMockApp([])
+  });
+  await handler.init(opts);
+  const divCount = holder.selectAll("div").size();
+  test.ok(divCount > 0, "error message appended to holder");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: sets callback and app on instance", async function(test) {
+  const handler = new SearchHandler();
+  const callback = () => {
+  };
+  const app = createMockApp([createMockTerm()]);
+  const opts = createValidOpts({ callback, app });
+  await handler.init(opts);
+  test.equal(handler.callback, callback, "callback set on instance");
+  test.equal(handler.app, app, "app set on instance");
+  if (test["_ok"]) opts.holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: creates term divs for available terms", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const terms = [
+    createMockTerm({ name: "term1", plot: "plot1" }),
+    createMockTerm({ name: "term2", plot: "plot2" })
+  ];
+  const opts = createValidOpts({
+    holder,
+    app: createMockApp(terms)
+  });
+  await handler.init(opts);
+  const termLabels = holder.selectAll(".termlabel");
+  test.equal(termLabels.size(), 2, "creates label for each term");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: filters terms by plots when sample.plots provided", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const terms = [
+    createMockTerm({ name: "term1", plot: "plot1" }),
+    createMockTerm({ name: "term2", plot: "plot2" }),
+    createMockTerm({ name: "term3", plot: "plot3" })
+  ];
+  const usecaseConfig = {
+    sample: {
+      plots: ["plot1", "plot2"]
+    }
+  };
+  const opts = createValidOpts({
+    holder,
+    app: createMockApp(terms),
+    usecase: createMockUsecase(usecaseConfig)
+  });
+  await handler.init(opts);
+  const termLabels = holder.selectAll(".termlabel");
+  test.equal(termLabels.size(), 2, "displays only terms matching filtered plots");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: filters terms by usecase.name when provided", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const terms = [
+    createMockTerm({ name: "term1", plot: "plot1" }),
+    createMockTerm({ name: "term2", plot: "plot2" }),
+    createMockTerm({ name: "term3", plot: "plot2" })
+  ];
+  const usecaseConfig = {
+    name: "plot2"
+  };
+  const opts = createValidOpts({
+    holder,
+    app: createMockApp(terms),
+    usecase: createMockUsecase(usecaseConfig)
+  });
+  await handler.init(opts);
+  const termLabels = holder.selectAll(".termlabel");
+  test.equal(termLabels.size(), 2, "displays only terms matching usecase.name");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: displays all terms when no filter provided", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const terms = [
+    createMockTerm({ name: "term1", plot: "plot1" }),
+    createMockTerm({ name: "term2", plot: "plot2" }),
+    createMockTerm({ name: "term3", plot: "plot3" })
+  ];
+  const opts = createValidOpts({
+    holder,
+    app: createMockApp(terms)
+  });
+  await handler.init(opts);
+  const termLabels = holder.selectAll(".termlabel");
+  test.equal(termLabels.size(), 3, "displays all terms when no filter applied");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: label includes plot name for multiple plots or no meta", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const terms = [
+    createMockTerm({ name: "term1", plot: "plot1" })
+  ];
+  const usecaseConfig = {
+    sample: {
+      plots: ["plot1", "plot2"]
+      // multiple plots
+    }
+  };
+  const opts = createValidOpts({
+    holder,
+    app: createMockApp(terms),
+    usecase: createMockUsecase(usecaseConfig)
+  });
+  await handler.init(opts);
+  const label = holder.select(".termlabel").text();
+  test.ok(label.includes("term1"), "label includes term name");
+  test.ok(label.includes("plot1"), "label includes plot name for multiple plots");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: label excludes plot name when single plot or isMeta", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const terms = [
+    createMockTerm({ name: "term1", plot: "plot1" })
+  ];
+  const usecaseConfig = {
+    sample: {
+      plots: ["plot1"],
+      isMetaResult: true
+    }
+  };
+  const opts = createValidOpts({
+    holder,
+    app: createMockApp(terms),
+    usecase: createMockUsecase(usecaseConfig)
+  });
+  await handler.init(opts);
+  const label = holder.select(".termlabel").text();
+  test.equal(label, "term1", "label is just term name for single plot with meta");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: callback invoked with correct term on click", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const callbackResult = { captured: null };
+  const callback = (term) => {
+    callbackResult.captured = term;
+  };
+  const terms = [
+    createMockTerm({ name: "term1", plot: "plot1", sample: "sample1" })
+  ];
+  const opts = createValidOpts({
+    holder,
+    callback,
+    app: createMockApp(terms)
+  });
+  await handler.init(opts);
+  const labelNode = holder.select(".termlabel").node();
+  if (labelNode) {
+    const clickEvent = new MouseEvent("click");
+    labelNode.dispatchEvent(clickEvent);
+  }
+  test.ok(callbackResult.captured, "callback was invoked");
+  test.equal(callbackResult.captured?.name, "term1", "callback receives correct term");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: callback term includes sample from usecase if not in term", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const callbackResult = { captured: null };
+  const callback = (term) => {
+    callbackResult.captured = term;
+  };
+  const terms = [
+    createMockTerm({ name: "term1", plot: "plot1", sample: void 0 })
+  ];
+  const usecaseConfig = {
+    sample: "usecase_sample"
+  };
+  const opts = createValidOpts({
+    holder,
+    callback,
+    app: createMockApp(terms),
+    usecase: createMockUsecase(usecaseConfig)
+  });
+  await handler.init(opts);
+  const labelNode = holder.select(".termlabel").node();
+  if (labelNode) {
+    const clickEvent = new MouseEvent("click");
+    labelNode.dispatchEvent(clickEvent);
+  }
+  test.equal(callbackResult.captured?.sample, "usecase_sample", "callback term includes usecase sample");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+(0, import_tape.default)("init: applies termdiv and pill styling classes", async function(test) {
+  const handler = new SearchHandler();
+  const holder = getHolder();
+  const terms = [createMockTerm()];
+  const opts = createValidOpts({
+    holder,
+    app: createMockApp(terms)
+  });
+  await handler.init(opts);
+  const termdiv = holder.select(".termdiv");
+  const label = holder.select(".termlabel");
+  test.ok(termdiv.node() !== null, "applies termdiv class");
+  test.ok(label.classed("sja_filter_tag_btn"), "applies sja_filter_tag_btn class");
+  test.ok(label.classed("sja_tree_click_term"), "applies sja_tree_click_term class");
+  test.ok(label.classed("ts_pill"), "applies ts_pill class");
+  if (test["_ok"]) holder.remove();
+  test.end();
+});
+//# sourceMappingURL=singleCellNumericValue.unit.spec-QGLHES7H.js.map

package/dist/singleCellPlot-RU5T6SJK.js

@@ -0,0 +1,44 @@
+import {
+  componentInit,
+  getContourImage,
+  getDefaultSingleCellSettings,
+  getMouseNDC,
+  getPlotConfig,
+  scatterInit
+} from "./chunk-FPMJJBLV.js";
+import "./chunk-JH73IL4C.js";
+import "./chunk-SFPZUBPM.js";
+import "./chunk-72PLI3GC.js";
+import "./chunk-4E2F26CC.js";
+import "./chunk-O6T4SDC7.js";
+import "./chunk-WD7FZ5EE.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-WXSMUSU7.js";
+import "./chunk-CNFTQSNE.js";
+import "./chunk-RIHO7ZD5.js";
+import "./chunk-TVJOSRCH.js";
+import "./chunk-3CIL7KH7.js";
+import "./chunk-T4XPCSLP.js";
+import "./chunk-4TJO2DGU.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-MHWYRNGA.js";
+import "./chunk-JHLF2ZC2.js";
+import "./chunk-WJLRU5OF.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 {
+  componentInit,
+  getContourImage,
+  getDefaultSingleCellSettings,
+  getMouseNDC,
+  getPlotConfig,
+  scatterInit
+};
+//# sourceMappingURL=singleCellPlot-RU5T6SJK.js.map