@sjcrh/proteinpaint-client 2.211.0 → 2.212.0

package/dist/NumDiscreteEditor-7AO35XU7.js

@@ -0,0 +1,170 @@
+import {
+  NumCustomBinEditor
+} from "./chunk-XZCRYWVL.js";
+import {
+  NumRegularBinEditor
+} from "./chunk-PBWB5ZG2.js";
+import {
+  Tabs
+} from "./chunk-VHDYIOWU.js";
+import "./chunk-HJ6L54YS.js";
+import {
+  HandlerBase
+} from "./chunk-KV4W2ACA.js";
+import "./chunk-5WIA4KFA.js";
+import "./chunk-7XZA2XR2.js";
+import "./chunk-DD3DWHUY.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-RMUK3TLD.js";
+import "./chunk-HH5JKOE6.js";
+import "./chunk-RU2UHH7M.js";
+import "./chunk-57Z4VYLM.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-6XKAOSQE.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";
+
+// termsetting/handlers/NumDiscreteEditor.ts
+var NumDiscreteEditor = class extends HandlerBase {
+  constructor(opts, handler) {
+    super(opts);
+    this.dom = {};
+    this.boundaryInclusion = "stopinclusive";
+    this.activeTab = "regular-bin";
+    this.termsetting = opts.termsetting;
+    this.tw = opts.termsetting.tw;
+    this.handler = handler;
+    this.editorsByType = {
+      "regular-bin": new NumRegularBinEditor(this),
+      "custom-bin": new NumCustomBinEditor(this)
+    };
+    if (this.tw.term.bins?.default.type != "regular-bin") this.activeTab = "custom-bin";
+  }
+  setDefaultBoundaryInclusion() {
+    if (this.tw.q.mode == "discrete") {
+      if (this.tw.q.type == "regular-bin")
+        this.boundaryInclusion = this.tw.q.startinclusive ? "startinclusive" : "stopinclusive";
+      else this.boundaryInclusion = this.tw.q.lst[0].startinclusive ? "startinclusive" : "stopinclusive";
+    } else {
+      this.boundaryInclusion = "stopinclusive";
+    }
+  }
+  async showEditMenu(div) {
+    if (this.dom.boundaryInclusionDiv) {
+      if (div.node().contains(this.dom.boundaryInclusionDiv.node())) {
+        await this.handler.density.showViolin(this.dom.density_div);
+        if (this.tabs?.tabs) {
+          const tab = this.tabs.tabs[this.activeTab == "regular-bin" ? 0 : 1];
+          await this.editorsByType[this.activeTab].render(tab.contentHolder);
+        } else if (this.dom.typeInputsDiv) {
+          await this.editorsByType[this.activeTab].render(this.dom.typeInputsDiv);
+        }
+        return;
+      } else delete this.dom.boundaryInclusionDiv;
+    }
+    this.dom.density_div = div.append("div");
+    await this.handler.density.showViolin(this.dom.density_div);
+    this.mayShowValueconversionMsg(div);
+    const self = this.termsetting;
+    if (self.term && !self.term.bins) {
+      self.handler.showLoading(div);
+      const tw = {
+        term: self.term,
+        q: self.q
+        /*, $id: ''*/
+      };
+      try {
+        await self.vocabApi.setTermBins(tw);
+      } catch (e) {
+        div.append("div").attr("class", "sja_errorbar").text(e);
+      }
+      this.handler.hideLoading();
+    }
+    this.tw = this.termsetting.tw;
+    this.setDefaultBoundaryInclusion();
+    this.renderBoundaryInclusionInput(div);
+    this.renderTypeInputs(div);
+  }
+  renderBoundaryInclusionInput(div) {
+    this.dom.boundaryInclusionDiv = div.append("div");
+    this.dom.boundaryInclusionDiv.append("span").style("padding", "5px").style("color", "rgb(136, 136, 136)").html("Boundary Inclusion");
+    const x = '<span style="font-family:Times;font-style:italic">x</span>';
+    this.dom.boundaryInput = this.dom.boundaryInclusionDiv.append("select").style("margin-left", "10px").on("change", () => {
+      this.boundaryInclusion = this.dom.boundaryInput.property("value");
+      if (this.activeTab == "custom-bin") this.editorsByType[this.activeTab].handleInputChange();
+      const q = this.editorsByType["regular-bin"].q;
+      q.startinclusive = this.boundaryInclusion === "startinclusive";
+      q.stopinclusive = this.boundaryInclusion === "stopinclusive";
+    });
+    const options = [];
+    if (this.termsetting?.opts?.usecase?.target == "runChart2") {
+    } else {
+      options.push({ value: "stopinclusive", html: `start &lt; ${x} &le; end` });
+    }
+    options.push({ value: "startinclusive", html: `start &le; ${x} &lt; end` });
+    this.dom.boundaryInput.selectAll("option").data(options).enter().append("option").property("value", (d) => d.value).property("selected", (d) => d.value === this.boundaryInclusion).html((d) => d.html);
+  }
+  renderTypeInputs(_div) {
+    this.dom.binsDiv = _div.append("div");
+    const div = this.dom.typeInputsDiv = this.dom.binsDiv.append("div").style("margin", "10px");
+    if (this.tw.term.bins?.default.type == "custom-bin") {
+      this.editorsByType["custom-bin"].render(div);
+      return;
+    }
+    if (this.tw.term.bins?.default.type != "regular-bin")
+      throw "self.bins.default.type is neither regular-bin or custom-bin, cannot render ui";
+    const tabs = [
+      {
+        active: this.tw.q.type == "regular-bin",
+        label: "Same bin size",
+        callback: async (_, tab) => {
+          if (tab.isInitialized) return;
+          this.activeTab = "regular-bin";
+          await this.editorsByType["regular-bin"].render(tab.contentHolder);
+        }
+      },
+      {
+        active: this.tw.q.type == "custom-bin",
+        label: "Varying bin sizes",
+        callback: async (event, tab) => {
+          if (tab.isInitialized) return;
+          this.activeTab = "custom-bin";
+          await this.editorsByType["custom-bin"].render(tab.contentHolder);
+        }
+      }
+    ];
+    this.tabs = new Tabs({ holder: div, tabs });
+    this.tabs.main();
+  }
+  getEditedQ(destroyDom = true) {
+    this.boundaryInclusion = this.dom.boundaryInput.property("value");
+    return this.editorsByType[this.activeTab].getEditedQ(destroyDom);
+    if (destroyDom) this.destroy();
+  }
+  undoEdits() {
+    this.setDefaultBoundaryInclusion();
+    this.dom.boundaryInput.property("value", this.boundaryInclusion);
+    this.editorsByType[this.activeTab].undoEdits();
+  }
+  destroy() {
+    for (const name of Object.keys(this.dom)) {
+      this.dom[name].remove();
+      delete this.dom[name];
+    }
+  }
+};
+export {
+  NumDiscreteEditor
+};
+//# sourceMappingURL=NumDiscreteEditor-7AO35XU7.js.map

package/dist/NumDiscreteEditor.unit.spec-SNDHS6VK.js

@@ -0,0 +1,233 @@
+import {
+  agedx
+} from "./chunk-32AI7I4C.js";
+import {
+  NumericHandler
+} from "./chunk-NC4RKYVE.js";
+import "./chunk-F4DM3WS4.js";
+import {
+  termjson
+} from "./chunk-FQYXNCZI.js";
+import {
+  sleep
+} from "./chunk-FYXIK6Y6.js";
+import {
+  require_tape
+} from "./chunk-PJYCTAMC.js";
+import {
+  TwRouter
+} from "./chunk-VHDYIOWU.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-5WIA4KFA.js";
+import "./chunk-7XZA2XR2.js";
+import "./chunk-DD3DWHUY.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-RMUK3TLD.js";
+import "./chunk-HH5JKOE6.js";
+import "./chunk-RU2UHH7M.js";
+import "./chunk-57Z4VYLM.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-6XKAOSQE.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/NumDiscreteEditor.unit.spec.ts
+var import_tape = __toESM(require_tape(), 1);
+async function getNumericHandler(opts = {}) {
+  const term = opts.term || JSON.parse(JSON.stringify(termjson.agedx));
+  if (term.bins.default.type == "regular-bin") term.bins.default.bin_size = 500;
+  const rawTw = {
+    term,
+    q: term.bins.default
+  };
+  let handler = {};
+  const vocabApi = {
+    state: {
+      termfilter: { filter: { type: "tvslst", in: "", lst: [] } }
+    },
+    getViolinBox() {
+      return agedx;
+    }
+  };
+  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]);
+  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("-***- NumDiscreteEditor.unit.spec -***-");
+  test.end();
+});
+(0, import_tape.default)("handler methods", async (test) => {
+  const { editHandler, destroy } = await getNumericHandler();
+  editHandler.setDefaultBoundaryInclusion();
+  test.equal(editHandler.boundaryInclusion, "stopinclusive", "should set the expected default boundaryInclusion");
+  editHandler.termsetting.tw.q = {
+    mode: "discrete",
+    type: "custom-bin",
+    lst: [
+      { start: 0, stop: 5, startinclusive: true },
+      { start: 5, stop: 10, startinclusive: true }
+    ]
+  };
+  editHandler.setDefaultBoundaryInclusion();
+  test.equal(
+    editHandler.boundaryInclusion,
+    "startinclusive",
+    "should set the expected default boundaryInclusion for custom-bin"
+  );
+  editHandler.termsetting.tw.q = { mode: "continuous" };
+  editHandler.setDefaultBoundaryInclusion();
+  test.equal(
+    editHandler.boundaryInclusion,
+    "stopinclusive",
+    `should set the expected default boundaryInclusion when q.mode != 'discrete'`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+(0, import_tape.default)("initial rendered UI", 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.boundaryInclusionDiv.selectAll("option").size(),
+    2,
+    `should render a boundary inclusion dropdown with 2 options`
+  );
+  test.equal(
+    editHandler.dom.boundaryInclusionDiv.select("select").property("value"),
+    "stopinclusive",
+    `should default to startinclusive boundary inclusion input value`
+  );
+  test.deepEqual(
+    [...editHandler.dom.binsDiv.node().querySelectorAll(`button[data-testid='sja_toggle_button']`)].map(
+      (b) => b.firstChild.innerText
+    ),
+    ["Same bin size", "Varying bin sizes"],
+    `should render 2 toggle buttons, one each for regular-bin and custom-bin menu`
+  );
+  const boundaryInclusionDiv = editHandler.dom.boundaryInclusionDiv.node();
+  await editHandler.showEditMenu(holder);
+  test.equal(
+    boundaryInclusionDiv,
+    editHandler.dom.boundaryInclusionDiv.node(),
+    `should not re-render the menu when the holder has not changed`
+  );
+  editHandler.dom.boundaryInput.property("value", "startinclusive");
+  editHandler.dom.boundaryInput.node().dispatchEvent(new Event("change", { bubbles: true }));
+  test.deepEqual(
+    editHandler.getEditedQ(false),
+    {
+      mode: "discrete",
+      type: "regular-bin",
+      startinclusive: true,
+      stopinclusive: false,
+      bin_size: 500,
+      first_bin: { startunbounded: true, stop: 2 },
+      rounding: ".0f"
+    },
+    `should give the expected edited tw.q object`
+  );
+  await editHandler.undoEdits();
+  test.deepEqual(
+    editHandler.getEditedQ(false),
+    {
+      mode: "discrete",
+      type: "regular-bin",
+      startinclusive: false,
+      stopinclusive: true,
+      bin_size: 500,
+      first_bin: { startunbounded: true, stop: 2 },
+      rounding: ".0f"
+    },
+    `should give the expected edited tw.q object`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+(0, import_tape.default)("re-showing the menu for a term whose default bin type is custom-bin", async (test) => {
+  const term = JSON.parse(JSON.stringify(termjson.agedx));
+  term.bins = {
+    default: {
+      mode: "discrete",
+      type: "custom-bin",
+      lst: [
+        { startunbounded: true, stop: 10950, stopinclusive: true, label: "<=30 years" },
+        { start: 10950, stop: 21900, stopinclusive: true, label: "30-60 years" },
+        { start: 21900, stopunbounded: true, startinclusive: false, label: ">60 years" }
+      ]
+    }
+  };
+  const { editHandler, holder, destroy } = await getNumericHandler({ term });
+  await editHandler.showEditMenu(holder);
+  await sleep(0);
+  test.equal(editHandler.tabs, void 0, `should not render a regular/custom bin switch`);
+  let err;
+  try {
+    await editHandler.showEditMenu(holder);
+    await sleep(0);
+  } catch (e) {
+    err = e;
+  }
+  test.equal(err, void 0, `should not throw when the menu is shown again on the same holder`);
+  test.equal(
+    holder.node().querySelectorAll("textarea").length,
+    1,
+    `should keep the custom bin boundary input rendered`
+  );
+  if (test._ok) destroy();
+  test.end();
+});
+//# sourceMappingURL=NumDiscreteEditor.unit.spec-SNDHS6VK.js.map

package/dist/NumRegularBinEditor-OREKM2DX.js

@@ -0,0 +1,33 @@
+import {
+  NumRegularBinEditor
+} from "./chunk-PBWB5ZG2.js";
+import "./chunk-VHDYIOWU.js";
+import "./chunk-HJ6L54YS.js";
+import "./chunk-KV4W2ACA.js";
+import "./chunk-5WIA4KFA.js";
+import "./chunk-7XZA2XR2.js";
+import "./chunk-DD3DWHUY.js";
+import "./chunk-EEB5VE2A.js";
+import "./chunk-6RRZRISL.js";
+import "./chunk-2KM4PRQM.js";
+import "./chunk-RMUK3TLD.js";
+import "./chunk-HH5JKOE6.js";
+import "./chunk-RU2UHH7M.js";
+import "./chunk-57Z4VYLM.js";
+import "./chunk-WINIL2KN.js";
+import "./chunk-PF4DSFDR.js";
+import "./chunk-7X6NF7NI.js";
+import "./chunk-W5J3LTYS.js";
+import "./chunk-Z2ZITHT4.js";
+import "./chunk-4OLM3KSB.js";
+import "./chunk-6XKAOSQE.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 {
+  NumRegularBinEditor
+};
+//# sourceMappingURL=NumRegularBinEditor-OREKM2DX.js.map