@sjcrh/proteinpaint-client 2.204.0 → 2.205.0

package/dist/NumContEditor.unit.spec-G2QBBNH7.js

@@ -0,0 +1,164 @@
+import {
+  agedx
+} from "./chunk-32AI7I4C.js";
+import {
+  NumericHandler
+} from "./chunk-756KZF5Y.js";
+import "./chunk-BEJJS2HC.js";
+import {
+  termjson
+} from "./chunk-FQYXNCZI.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import {
+  TwRouter
+} from "./chunk-J7JDCNLU.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-N635HDJ4.js";
+import "./chunk-T46FA72N.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-JYOIO5UY.js";
+import "./chunk-YN5NY3D3.js";
+import "./chunk-RN4BOWRH.js";
+import "./chunk-IK2BO37K.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-D6G64XPJ.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-YLJOZP4P.js";
+import "./chunk-HDTFYTEL.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// termsetting/handlers/test/NumContEditor.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+async function getNumericHandler(opts = {}) {
+  const term = JSON.parse(JSON.stringify(termjson.agedx));
+  const rawTw = {
+    term,
+    q: {
+      mode: "continuous"
+    }
+  };
+  const tw = await TwRouter.initRaw(rawTw);
+  const handler = new NumericHandler({
+    termsetting: {
+      tw,
+      term: rawTw.term,
+      q: rawTw.q,
+      opts: {
+        numericEditMenuVersion: ["continuous", "discrete", "binary", "spline"],
+        usecase: opts.usecase
+      },
+      api: {
+        runCallback() {
+        }
+      },
+      dom: {
+        tip: {
+          hide() {
+          }
+        }
+      },
+      vocabApi: {
+        getViolinBox() {
+          return agedx;
+        }
+      }
+    }
+  });
+  const holder = select_default("body").append("div").style("position", "relative").style("width", "fit-content").style("margin", "20px").style("padding", "5px").style("border", "1px solid #000");
+  await handler.setEditHandler(handler.tabs[0]);
+  return {
+    rawTw,
+    tw,
+    handler,
+    editHandler: handler.editHandler,
+    holder,
+    destroy: () => {
+      if ("destroy" in handler.editHandler) handler.editHandler.destroy();
+      if (typeof handler.destroy == "function") handler.destroy();
+      holder.remove();
+    }
+  };
+}
+(0, import_tape.default)("\n", (test) => {
+  test.comment("-***- NumContEditor.unit.spec -***-");
+  test.end();
+});
+(0, import_tape.default)("no opts.usecase", async (test) => {
+  const { editHandler, holder, destroy } = await getNumericHandler();
+  await editHandler.showEditMenu(holder);
+  test.equal(editHandler.dom?.density_div.selectAll("svg").size(), 1, `should render a density plot svg`);
+  test.equal(
+    editHandler.dom.inputsDiv.selectAll("option").size(),
+    4,
+    `should render scale dropdown with the expected number of options`
+  );
+  test.equal(
+    editHandler.dom.inputsDiv.selectAll(`input[type='checkbox']`).size(),
+    0,
+    `should not render a checkbox for z-score conversion`
+  );
+  const scaleValue = 100;
+  editHandler.dom?.scaleSelect.property("value", scaleValue);
+  editHandler.dom?.scaleSelect.node().dispatchEvent(new Event("change", { bubbles: true }));
+  test.equal(editHandler.q.scale, scaleValue, `should set q.scale to ${scaleValue}`);
+  test.deepEqual(
+    editHandler.getEditedQ(),
+    { mode: "continuous", isAtomic: true, hiddenValues: {}, scale: 100 },
+    `should give the expected edited q object`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+(0, import_tape.default)(`opts.usecase={target: 'matrix'}`, async (test) => {
+  const { editHandler, holder, destroy } = await getNumericHandler({ usecase: { target: "matrix" } });
+  await editHandler.showEditMenu(holder);
+  test.equal(editHandler.dom?.density_div.selectAll("svg").size(), 1, `should render a density plot svg`);
+  test.equal(
+    editHandler.dom?.inputsDiv.selectAll("option").size(),
+    4,
+    `should render scale dropdown with the expected number of options`
+  );
+  test.equal(
+    editHandler.dom?.inputsDiv.selectAll(`input[type='checkbox']`).size(),
+    1,
+    `should render a checkbox for z-score conversion`
+  );
+  const scaleValue = 1e3;
+  editHandler.dom.scaleSelect.property("value", scaleValue);
+  editHandler.dom.scaleSelect.node().dispatchEvent(new Event("change", { bubbles: true }));
+  editHandler.dom.convert2ZCheckbox.property("checked", true);
+  editHandler.dom.convert2ZCheckbox.node().dispatchEvent(new Event("input", { bubbles: true }));
+  test.equal(editHandler.q.scale, void 0, `should delete q.scale when convert2ZCheckbox is checked`);
+  editHandler.dom.scaleSelect.property("value", scaleValue);
+  editHandler.dom.scaleSelect.node().dispatchEvent(new Event("change", { bubbles: true }));
+  test.equal(
+    editHandler.dom.convert2ZCheckbox.property("checked"),
+    false,
+    `should set convert2ZCheckbox to false when scale is set to >1`
+  );
+  test.deepEqual(
+    editHandler.getEditedQ(),
+    { mode: "continuous", isAtomic: true, hiddenValues: {}, convert2ZScore: false, scale: 1e3 },
+    `should give the expected edited q object`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+//# sourceMappingURL=NumContEditor.unit.spec-G2QBBNH7.js.map

package/dist/NumCustomBinEditor-P44G67KS.js

@@ -0,0 +1,33 @@
+import {
+  NumCustomBinEditor
+} from "./chunk-LHP7RXET.js";
+import "./chunk-J7JDCNLU.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-N635HDJ4.js";
+import "./chunk-T46FA72N.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-JYOIO5UY.js";
+import "./chunk-YN5NY3D3.js";
+import "./chunk-RN4BOWRH.js";
+import "./chunk-IK2BO37K.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-D6G64XPJ.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-YLJOZP4P.js";
+import "./chunk-HDTFYTEL.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import "./chunk-HS5PO5ZQ.js";
+export {
+  NumCustomBinEditor
+};
+//# sourceMappingURL=NumCustomBinEditor-P44G67KS.js.map

package/dist/NumCustomBinEditor.unit.spec-AZHJN3V6.js

@@ -0,0 +1,397 @@
+import {
+  agedx
+} from "./chunk-32AI7I4C.js";
+import {
+  NumericHandler
+} from "./chunk-756KZF5Y.js";
+import "./chunk-BEJJS2HC.js";
+import {
+  termjson
+} from "./chunk-FQYXNCZI.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import {
+  TwRouter
+} from "./chunk-J7JDCNLU.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-N635HDJ4.js";
+import "./chunk-T46FA72N.js";
+import "./chunk-ELJX3QIQ.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-JYOIO5UY.js";
+import "./chunk-YN5NY3D3.js";
+import "./chunk-RN4BOWRH.js";
+import "./chunk-IK2BO37K.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-D6G64XPJ.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-YLJOZP4P.js";
+import "./chunk-HDTFYTEL.js";
+import "./chunk-FXQXCOII.js";
+import "./chunk-TLT4YIG3.js";
+import "./chunk-5R63Q5KH.js";
+import {
+  select_default
+} from "./chunk-I6Y4O3RR.js";
+import "./chunk-Q5RDQNIT.js";
+import "./chunk-DQC5FFGV.js";
+import {
+  __toESM
+} from "./chunk-HS5PO5ZQ.js";
+
+// termsetting/handlers/test/NumCustomBinEditor.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+var pct50 = 6.3475409836;
+var pct70 = 1000.36986301355;
+var DAY_TO_YEAR = 1 / 365.25;
+function getConvertedTerm() {
+  const term = JSON.parse(JSON.stringify(termjson.agedx));
+  term.valueConversion = { fromUnit: "day", toUnit: "year", scaleFactor: DAY_TO_YEAR };
+  return term;
+}
+async function getNumericHandler(opts = {}) {
+  const term = opts.term || JSON.parse(JSON.stringify(termjson.agedx));
+  const rawTw = {
+    term,
+    q: {
+      mode: "discrete",
+      type: "custom-bin",
+      preferredBins: "median"
+    }
+  };
+  let handler = {};
+  const vocabApi = {
+    state: {
+      termfilter: { filter: { type: "tvslst", in: "", lst: [] } }
+    },
+    getViolinBox() {
+      return agedx;
+    },
+    getPercentile() {
+      return {
+        values: handler?.editHandler?.q.cutoffPercentile === 70 ? [pct70] : [pct50]
+      };
+    }
+  };
+  const tw = await TwRouter.initRaw(rawTw, { vocabApi });
+  handler = new NumericHandler({
+    termsetting: {
+      tw,
+      term: rawTw.term,
+      q: rawTw.q,
+      opts: {
+        numericEditMenuVersion: ["discrete"],
+        usecase: opts.usecase
+      },
+      api: {
+        runCallback() {
+        }
+      },
+      dom: {
+        tip: {
+          hide() {
+          }
+        }
+      },
+      vocabApi
+    }
+  });
+  handler.density_data = { min: agedx.min, max: agedx.max };
+  const holder = select_default("body").append("div").style("position", "relative").style("width", "fit-content").style("margin", "20px").style("padding", "5px").style("border", "1px solid #000");
+  handler.dom.editDiv = holder;
+  await handler.setEditHandler(handler.tabs[0]);
+  const binsEditor = handler.editHandler.editorsByType["custom-bin"];
+  return {
+    rawTw,
+    tw,
+    handler,
+    editHandler: handler.editHandler,
+    binsEditor,
+    holder,
+    destroy: () => {
+      if ("destroy" in handler.editHandler) handler.editHandler.destroy();
+      if (typeof handler.destroy == "function") handler.destroy();
+      holder.remove();
+    }
+  };
+}
+function simulateDrag(elem, xOffset) {
+  const box = elem.getBoundingClientRect();
+  for (const [type, clientX] of [
+    ["mousedown", box.x],
+    ["mousemove", box.x + xOffset],
+    ["mouseup", box.x + xOffset]
+  ]) {
+    elem.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, clientX, clientY: box.y, view: window }));
+  }
+}
+(0, import_tape.default)("\n", (test) => {
+  test.comment("-***- NumCustomBinEditor.unit.spec -***-");
+  test.end();
+});
+(0, import_tape.default)("handler methods", async (test) => {
+  const { binsEditor, destroy } = await getNumericHandler();
+  test.deepEqual(
+    binsEditor.getDefaultQ(),
+    {
+      mode: "discrete",
+      type: "custom-bin",
+      isAtomic: true,
+      lst: [
+        {
+          startunbounded: true,
+          stop: 6.35,
+          stopinclusive: false,
+          label: "<6.35",
+          range: '<span style="font-family:Times;font-style:italic;">x</span> <6.35'
+        },
+        {
+          start: 6.35,
+          startinclusive: true,
+          stopunbounded: true,
+          label: "\u22656.35",
+          range: '<span style="font-family:Times;font-style:italic;">x</span> \u22656.35'
+        }
+      ],
+      hiddenValues: {}
+    },
+    `should give the expected default tw.q object`
+  );
+  binsEditor.tw.q = { mode: "continuous" };
+  test.deepEqual(
+    binsEditor.getDefaultQ(),
+    {
+      mode: "discrete",
+      type: "custom-bin",
+      lst: [
+        {
+          startunbounded: true,
+          startinclusive: false,
+          stopinclusive: false,
+          stop: 2355,
+          label: "<2355",
+          range: '<span style="font-family:Times;font-style:italic;">x</span> <2355'
+        },
+        {
+          stopunbounded: true,
+          startinclusive: true,
+          stopinclusive: false,
+          start: 2355,
+          label: "\u22652355",
+          range: '<span style="font-family:Times;font-style:italic;">x</span> \u22652355'
+        }
+      ]
+    },
+    `should give the expected default tw.q object if the mode is not discrete`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+(0, import_tape.default)("initial rendered UI", async (test) => {
+  const { editHandler, binsEditor, holder, destroy } = await getNumericHandler();
+  await editHandler.showEditMenu(holder);
+  test.equal(binsEditor.dom.customBinBoundaryInput?.size(), 1, `should render a textarea input for custom bin entries`);
+  const textInputs = binsEditor.dom.inputsDiv.node().querySelectorAll(`input[type='text']`);
+  test.equal(textInputs.length, 2, `should render 2 number inputs to match tw.q.lst[]`);
+  const ranges = binsEditor.dom.inputsDiv.node().querySelectorAll('div[name="range"]');
+  test.equal(ranges[0].innerText, "x <6.35", `should render the expected first bin range`);
+  test.equal(ranges[1].innerText, "x \u22656.35", `should render the expected last bin range`);
+  const binInputs = binsEditor.dom.inputsDiv.node().querySelectorAll("input");
+  test.equal(binInputs[0].value, "<6.35", `should render the expected first bin input value`);
+  test.equal(binInputs[1].value, "\u22656.35", `should render the expected last bin input value`);
+  if (test._ok) destroy();
+  test.end();
+});
+(0, import_tape.default)("edit interactivity", async (test) => {
+  const { editHandler, binsEditor, holder, destroy } = await getNumericHandler();
+  await editHandler.showEditMenu(holder);
+  const newKnots = [10, 200, 600, 3e3];
+  binsEditor.dom.customBinBoundaryInput.property("value", newKnots.join("\n"));
+  binsEditor.dom.customBinBoundaryInput.node().dispatchEvent(new Event("change", { bubbles: true }));
+  const lines = [...editHandler.handler.density.dom.binsize_g.node().querySelectorAll("line")];
+  test.deepEqual(
+    lines.map((l) => l.getAttribute("x1")),
+    ["11", "31", "74", "328"],
+    `should re-render the draggable lines in the updated x-positions`
+  );
+  const input0 = binsEditor.dom.customBinLabelInput.node();
+  input0.value = "- TEST -";
+  input0.dispatchEvent(new Event("change", { bubbles: true }));
+  test.deepEqual(
+    binsEditor.getEditedQ(false),
+    {
+      mode: "discrete",
+      type: "custom-bin",
+      lst: [
+        {
+          startunbounded: true,
+          stop: 10,
+          startinclusive: false,
+          stopinclusive: true,
+          label: "- TEST -",
+          range: '<span style="font-family:Times;font-style:italic;">x</span> \u226410'
+        },
+        {
+          start: 10,
+          startinclusive: false,
+          stopinclusive: true,
+          stop: 200,
+          label: ">10 to 200",
+          range: '10 < <span style="font-family:Times;font-style:italic;">x</span> \u2264 200'
+        },
+        {
+          start: 200,
+          startinclusive: false,
+          stopinclusive: true,
+          stop: 600,
+          label: ">200 to 600",
+          range: '200 < <span style="font-family:Times;font-style:italic;">x</span> \u2264 600'
+        },
+        {
+          start: 600,
+          startinclusive: false,
+          stopinclusive: true,
+          stop: 3e3,
+          label: ">600 to 3000",
+          range: '600 < <span style="font-family:Times;font-style:italic;">x</span> \u2264 3000'
+        },
+        {
+          start: 3e3,
+          startinclusive: false,
+          stopinclusive: false,
+          stopunbounded: true,
+          label: ">3000",
+          range: '<span style="font-family:Times;font-style:italic;">x</span> >3000'
+        }
+      ]
+    },
+    `should give the expected edited q object`
+  );
+  const inputsDiv = binsEditor.dom.inputsDiv.node();
+  await binsEditor.render(editHandler.dom.binsDiv.node().firstChild);
+  test.equal(
+    inputsDiv,
+    binsEditor.dom.inputsDiv.node(),
+    `should not re-render the menu when the holder has not changed`
+  );
+  editHandler.undoEdits();
+  {
+    const lines2 = [...editHandler.handler.density.dom.binsize_g.node().querySelectorAll("line")];
+    test.equal(lines2.length, 1, `should render 1 draggable line in the density plot`);
+    test.deepEqual(
+      lines2.map((l) => l.getAttribute("x1")),
+      ["11"],
+      `should render the draggable lines in the expected x-positions`
+    );
+  }
+  if (test._ok) destroy();
+  test.end();
+});
+(0, import_tape.default)("dragging a boundary line with more than one boundary", async (test) => {
+  const { editHandler, binsEditor, holder, destroy } = await getNumericHandler();
+  await editHandler.showEditMenu(holder);
+  binsEditor.dom.customBinBoundaryInput.property("value", [10, 200].join("\n"));
+  binsEditor.dom.customBinBoundaryInput.node().dispatchEvent(new Event("change", { bubbles: true }));
+  const drag = (value) => binsEditor.getBoundaryOpts().callback({ index: 1 }, value);
+  drag(500);
+  drag(500);
+  test.equal(
+    binsEditor.dom.customBinBoundaryInput.property("value"),
+    "10\n500",
+    `should list one boundary per line, keeping the boundary that was not dragged`
+  );
+  test.deepEqual(
+    binsEditor.q.lst.map((bin) => "start" in bin ? bin.start : null),
+    [null, 10, 500],
+    `should keep every bin, moving only the dragged boundary`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+(0, import_tape.default)("dragging a bin boundary line towards its neighboring line", async (test) => {
+  const { editHandler, binsEditor, holder, destroy } = await getNumericHandler();
+  await editHandler.showEditMenu(holder);
+  binsEditor.dom.customBinBoundaryInput.property("value", [10, 200].join("\n"));
+  binsEditor.dom.customBinBoundaryInput.node().dispatchEvent(new Event("change", { bubbles: true }));
+  const getLines = () => [...editHandler.handler.density.dom.binsize_g.node().querySelectorAll("line")];
+  const getBoundaries = () => binsEditor.dom.customBinBoundaryInput.property("value").split("\n");
+  test.equal(getLines().length, 2, `should render one line per boundary`);
+  simulateDrag(getLines()[0], 400);
+  test.deepEqual(getBoundaries(), ["188.4", "200"], `should stop the dragged boundary below the neighboring one`);
+  test.deepEqual(
+    binsEditor.q.lst.map((bin) => "start" in bin ? bin.start : null),
+    [null, 188.4, 200],
+    `should keep every bin when a drag is stopped at the neighboring line`
+  );
+  test.equal(getLines().length, 2, `should keep one line per boundary when a drag is stopped at the neighboring line`);
+  simulateDrag(getLines()[0], -10);
+  test.deepEqual(getBoundaries(), ["94.2", "200"], `should move only the dragged boundary`);
+  test.deepEqual(
+    binsEditor.q.lst.map((bin) => "start" in bin ? bin.start : null),
+    [null, 94.2, 200],
+    `should keep every bin, moving only the dragged boundary`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+(0, import_tape.default)("returning to the tab with unapplied bin boundary edits", async (test) => {
+  const { editHandler, binsEditor, holder, destroy } = await getNumericHandler();
+  await editHandler.showEditMenu(holder);
+  binsEditor.dom.customBinBoundaryInput.property("value", [10, 200].join("\n"));
+  binsEditor.dom.customBinBoundaryInput.node().dispatchEvent(new Event("change", { bubbles: true }));
+  const getLineXs = () => [...editHandler.handler.density.dom.binsize_g.node().querySelectorAll("line")].map((l) => l.getAttribute("x1"));
+  const editedLineXs = getLineXs();
+  await binsEditor.render(editHandler.dom.binsDiv.node().firstChild);
+  test.deepEqual(getLineXs(), editedLineXs, `should leave the boundary lines at the edited positions`);
+  test.equal(
+    binsEditor.dom.customBinBoundaryInput.property("value"),
+    "10\n200",
+    `should leave the edited bin boundaries in the textarea`
+  );
+  test.deepEqual(
+    binsEditor.q.lst.map((bin) => "start" in bin ? bin.start : null),
+    [null, 10, 200],
+    `should leave the bins parsed from the edits in q`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+(0, import_tape.default)("converted term", async (test) => {
+  const { editHandler, binsEditor, holder, destroy } = await getNumericHandler({ term: getConvertedTerm() });
+  await editHandler.showEditMenu(holder);
+  test.equal(
+    binsEditor.dom.customBinBoundaryInput.property("value"),
+    String(Number((pct50 * DAY_TO_YEAR).toFixed(2))),
+    `should fill the boundary textarea in years`
+  );
+  binsEditor.dom.customBinBoundaryInput.property("value", [5, 10].join("\n"));
+  binsEditor.dom.customBinBoundaryInput.node().dispatchEvent(new Event("change", { bubbles: true }));
+  test.deepEqual(
+    binsEditor.q.lst.map((bin) => "start" in bin ? bin.start : null),
+    [null, 1826.25, 3652.5],
+    `should store boundaries typed in years as days`
+  );
+  const editedQ = binsEditor.getEditedQ(false);
+  test.deepEqual(
+    editedQ.lst.map((bin) => ({ start: "start" in bin ? bin.start : null, stop: "stop" in bin ? bin.stop : null })),
+    [
+      { start: null, stop: 1826.25 },
+      { start: 1826.25, stop: 3652.5 },
+      { start: 3652.5, stop: null }
+    ],
+    `should give an edited q whose bins are in days`
+  );
+  test.deepEqual(
+    editedQ.lst.map((bin) => bin.label),
+    ["\u22645y", ">5y to 10y", ">10y"],
+    `should label the bins in years`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+//# sourceMappingURL=NumCustomBinEditor.unit.spec-AZHJN3V6.js.map