@sjcrh/proteinpaint-client 2.221.0 → 2.222.0

package/dist/chunk-MXZYJ7WN.js

@@ -0,0 +1,182 @@
+import {
+  Tabs,
+  addGeneSearchbox,
+  make_one_checkbox,
+  make_radios
+} from "./chunk-4ASBDE27.js";
+import {
+  Menu
+} from "./chunk-CNFTQSNE.js";
+import {
+  termType2label
+} from "./chunk-JHLF2ZC2.js";
+import {
+  TermTypeGroups
+} from "./chunk-WJLRU5OF.js";
+
+// termdb/handlers/pseudobulk.ts
+var SearchHandler = class {
+  async init(opts) {
+    const pseudobulkTerms = this.validateOpts(opts);
+    this.callback = opts.callback;
+    this.app = opts.app;
+    this.genome = opts.genomeObj;
+    const holder = opts.holder.append("div").style("padding", "10px 0px");
+    this.multiSelect = opts?.usecase?.target == "aggregateMatrix";
+    this.selectedTerm = void 0;
+    this.map = this.buildRenderingDataMap(pseudobulkTerms);
+    this.renderPseudobulkSearch(holder);
+  }
+  validateOpts(opts) {
+    if (!opts) throw new Error("opts is required");
+    if (!opts.app) throw new Error("opts.app is required");
+    if (!opts.holder) throw new Error("opts.holder is required");
+    if (opts.genomeObj == null || typeof opts.genomeObj !== "object") throw new Error("genomeObj is required");
+    if (!opts.callback) throw new Error("opts.callback is required");
+    const pseudobulkTerms = opts.app.vocabApi.termdbConfig?.termType2terms?.[TermTypeGroups.PSEUDOBULK];
+    if (!pseudobulkTerms?.length) {
+      throw new Error(
+        `termType2terms[${TermTypeGroups.PSEUDOBULK}]:[] is required in termdbConfig for pseudobulk handler`
+      );
+    }
+    return pseudobulkTerms;
+  }
+  /** Builds a map from assay to memberId to terms */
+  buildRenderingDataMap(pseudobulkTerms) {
+    const map = /* @__PURE__ */ new Map();
+    for (const term of pseudobulkTerms) {
+      const { assay, memberId } = term;
+      if (!map.has(assay)) map.set(assay, /* @__PURE__ */ new Map());
+      const assayMap = map.get(assay);
+      if (!assayMap.has(memberId)) assayMap.set(memberId, []);
+      assayMap.get(memberId).push(term);
+    }
+    return map;
+  }
+  /** If more than one assay, render tabs for each assay. Member IDs within
+   * an assay are rendered as tabs when there is more than one. */
+  renderPseudobulkSearch(holder) {
+    if (!this.map || this.map.size < 1) throw new Error("map is not initialized");
+    if (this.map.size === 1) {
+      const label = termType2label(this.map.keys().next().value);
+      holder.append("div").style("padding-bottom", "10px").text("Single-cell pseudobulk " + label);
+      this.renderMemberIdsByAssay(holder.append("div"), this.map);
+      return;
+    }
+    const tabs = this.buildTabsOpts(this.map);
+    new Tabs({ holder, tabs, tabsPosition: "vertical" }).main();
+  }
+  buildTabsOpts(map) {
+    const tabs = [];
+    for (const [key, valuesMap] of map.entries()) {
+      const label = termType2label(key);
+      tabs.push({
+        label,
+        active: false,
+        callback: (_, tab) => {
+          this.renderMemberIdsByAssay(tab.contentHolder, /* @__PURE__ */ new Map([[key, valuesMap]]));
+        }
+      });
+    }
+    return tabs;
+  }
+  renderMemberIdsByAssay(holder, map) {
+    const memberIdMap = map.values().next().value;
+    holder.selectAll("*").remove();
+    this.renderTermdByMemberId(holder, memberIdMap);
+  }
+  renderTermdByMemberId(holder, memberIdMap) {
+    const layout = holder.append("div").style("display", "flex").style("align-items", "flex-start").style("gap", "30px");
+    const pseudoTermsWrapper = layout.append("div").attr("data-testid", "sjpp-pseudobulk-terms-wrapper");
+    const geneSearchWrapper = layout.append("div").attr("data-testid", "sjpp-pseudobulk-gene-search-wrapper");
+    this.renderPseudobulkTerms(pseudoTermsWrapper, memberIdMap, geneSearchWrapper);
+  }
+  renderPseudobulkTerms(holder, memberIdMap, geneSearchHolder) {
+    if (memberIdMap.size === 1) {
+      const [memberId, terms] = memberIdMap.entries().next().value;
+      if (this.multiSelect) {
+        this.renderCategoriesAsTerms(holder, terms);
+      } else this.renderCategoryRadios(holder, memberId, terms, geneSearchHolder);
+      return;
+    }
+    const memberEntries = Array.from(memberIdMap.entries());
+    const tabs = memberEntries.map(([memberId, terms]) => ({
+      label: memberId,
+      active: false,
+      testid: `sjpp-pseudobulk-member-${memberId}`,
+      callback: (_, tab) => {
+        geneSearchHolder.selectAll("*").remove();
+        tab.contentHolder.selectAll("*").remove();
+        if (this.multiSelect) this.renderCategoriesAsTerms(tab.contentHolder, terms);
+        else this.renderCategoryRadios(tab.contentHolder, memberId, terms, geneSearchHolder);
+      }
+    }));
+    new Tabs({ holder, tabs, tabsPosition: "vertical" }).main();
+  }
+  renderCategoryRadios(holder, memberId, terms, geneSearchHolder) {
+    if (!terms || terms.length < 1) throw new Error("No terms found for memberId");
+    const options = terms.map((term) => ({
+      label: term.name,
+      value: term.id,
+      checked: false,
+      testid: `sjpp-pseudobulk-category-${term.id}`
+    }));
+    make_radios({
+      holder,
+      inputName: `sjpp-pseudobulk-category-radios-${memberId}`,
+      options,
+      styles: { display: "block", padding: "3px 5px" },
+      callback: (value) => {
+        const term = terms.find((term2) => term2.id == value);
+        if (!term) throw new Error(`No pseudobulk term found for category ${value}`);
+        this.selectedTerm = term;
+        this.renderGeneSelection(geneSearchHolder);
+      }
+    });
+  }
+  renderGeneSelection(holder) {
+    holder.selectAll("*").remove();
+    const geneSearch = addGeneSearchbox({
+      tip: new Menu({ padding: "0px" }),
+      genome: this.genome,
+      row: holder,
+      searchOnly: "gene",
+      callback: () => {
+        if (!geneSearch.geneSymbol) throw new Error("No gene selected");
+        if (!this.selectedTerm) throw new Error("No pseudobulk cell type selected");
+        this.callback(createPseudobulkTerm(this.selectedTerm, geneSearch.geneSymbol));
+      }
+    });
+  }
+  /** Mimics the style and functionality of pills created in tree.js.
+   * Returns the term object(s) from termdbConfig.termType2terms.[TermTypeGroups.PSEUDOBULK]
+   * without the gene. */
+  renderCategoriesAsTerms(holder, terms) {
+    holder.style("padding", "0px 10px");
+    make_one_checkbox({
+      holder,
+      labeltext: "Select all",
+      divstyle: { opacity: "0.7" },
+      callback: () => this.callback(terms)
+    });
+    const wrapper = holder.append("div").style("display", "block").style("padding", "10px 15px 0px");
+    wrapper.selectAll(".pseudobulk-term").data(terms, (term) => term.id).join((enter) => {
+      const row = enter.append("div").attr("class", "pseudobulk-term");
+      row.append("div").attr("class", "termlabel sja_filter_tag_btn sja_tree_click_term ts_pill").style("padding", "5px 8px").style("margin", "1px 0px").style("border-radius", "6px").text((term) => term.name).on("click", async (_, term) => {
+        await this.callback(term);
+      });
+      return row;
+    });
+  }
+};
+function createPseudobulkTerm(selectedTerm, gene) {
+  const category = selectedTerm.category || selectedTerm.id;
+  const name = `${selectedTerm.assay} ${category} ${gene}`;
+  return { ...selectedTerm, id: name, category, gene, name };
+}
+
+export {
+  SearchHandler,
+  createPseudobulkTerm
+};
+//# sourceMappingURL=chunk-MXZYJ7WN.js.map

package/dist/chunk-NZB6RZK2.js

@@ -0,0 +1,176 @@
+import {
+  appInit
+} from "./chunk-7TRD7A2U.js";
+import {
+  showErrorsWithCounter
+} from "./chunk-4ASBDE27.js";
+import {
+  mclass
+} from "./chunk-WJLRU5OF.js";
+
+// plots/disco/launch.adhoc.ts
+async function launch(arg, genomeObj, holder) {
+  const [mlst, errors] = await getMlst(arg);
+  if (errors?.length) {
+    return showErrorsWithCounter(errors, holder);
+  }
+  const opts = {
+    holder,
+    vocabApi: {
+      // api is required by plot.app.js, so create a mock one for the adhoc data
+      vocab: { terms: [] },
+      main: () => {
+        return;
+      },
+      getTermdbConfig: () => {
+        return {};
+      }
+    },
+    state: {
+      args: {
+        data: mlst,
+        genome: genomeObj
+      },
+      plots: [
+        {
+          chartType: "Disco",
+          subfolder: "disco",
+          extension: "ts",
+          /** NOTE: Users should only override the settings in the default
+           * settings.Disco:{}, not the entire settings:{} object.*/
+          overrides: { Disco: arg?.settings || {} }
+        }
+      ]
+    }
+  };
+  const plotAppApi = await appInit(opts);
+  return plotAppApi;
+}
+async function getMlst(arg) {
+  if (Array.isArray(arg.mlst)) {
+    return [arg.mlst, null];
+  }
+  const mlst = [];
+  const errors = [];
+  if (arg.snvText) parseSnvText(arg.snvText, mlst, errors);
+  if (arg.svText) parseSvText(arg.svText, mlst, errors);
+  if (arg.cnvText) parseCnvText(arg.cnvText, mlst, errors);
+  return [mlst, errors];
+}
+function parseSnvText(text, mlst, errors) {
+  for (const line of text.trim().split("\n")) {
+    const l = line.trim().split("	");
+    if (![5, 7, 9].includes(l.length)) {
+      errors.push("snv input not equal to 5, 7, or 9 columns");
+      continue;
+    }
+    let m;
+    try {
+      m = {
+        dt: 1,
+        chr: l[0],
+        position: Number(l[1]),
+        gene: l[2],
+        mname: l[3],
+        class: validateMutation(l[4], errors)
+      };
+      const vafs = parseOptionalVafs(l, errors);
+      if (vafs.length) m.vafs = vafs;
+    } catch (e) {
+      errors.push(e);
+      continue;
+    }
+    mlst.push(m);
+  }
+}
+function parseOptionalVafs(line, errors) {
+  const vafs = [];
+  const addVaf = (id, totalIndex, altIndex) => {
+    if (line.length <= altIndex) return;
+    const totalCount = Number(line[totalIndex]);
+    const altCount = Number(line[altIndex]);
+    if (!Number.isInteger(totalCount) || !Number.isInteger(altCount) || totalCount <= 0 || altCount < 0 || altCount > totalCount) {
+      errors.push(`${id} total/alt counts must be integers with total > 0, alt >= 0, and alt cannot exceed total`);
+      return;
+    }
+    vafs.push({ id, totalCount, altCount });
+  };
+  addVaf("DNA", 5, 6);
+  addVaf("RNA", 7, 8);
+  return vafs;
+}
+function parseSvText(text, mlst, errors) {
+  for (const line of text.trim().split("\n")) {
+    const l = line.trim().split("	");
+    if (l.length < 4 || l.length > 6) {
+      errors.push("sv input not equal to 4 or 6 columns");
+      continue;
+    }
+    let m;
+    try {
+      const length = l.length;
+      if (length == 4) {
+        m = {
+          dt: 2,
+          chrA: l[0],
+          posA: Number(l[1]),
+          chrB: l[2],
+          posB: Number(l[3])
+        };
+      } else {
+        m = {
+          dt: 2,
+          chrA: l[0],
+          posA: Number(l[1]),
+          geneA: l[2],
+          chrB: l[3],
+          posB: Number(l[4]),
+          geneB: l[5]
+        };
+      }
+    } catch (e) {
+      errors.push(e);
+      continue;
+    }
+    mlst.push(m);
+  }
+}
+function parseCnvText(text, mlst, errors) {
+  for (const line of text.trim().split("\n")) {
+    const l = line.trim().split("	");
+    if (l.length != 4) {
+      errors.push("cnv input not equal to 4 columns");
+      continue;
+    }
+    let m;
+    try {
+      m = {
+        dt: 4,
+        chr: l[0],
+        start: Number(l[1]),
+        stop: Number(l[2]),
+        value: Number(l[3])
+      };
+    } catch (e) {
+      errors.push(e);
+      continue;
+    }
+    mlst.push(m);
+  }
+}
+function validateMutation(mutation, errors) {
+  const mut2check = mutation.toLowerCase();
+  const foundMutation = Object.values(mclass).find(
+    (m) => m.key.toLowerCase() === mut2check || m.label.toLowerCase() === mut2check
+  );
+  if (foundMutation) {
+    return foundMutation.key;
+  } else {
+    errors.push(`Invalid mutation class: ${mutation}`);
+  }
+}
+
+export {
+  launch
+};
+//# sourceMappingURL=chunk-NZB6RZK2.js.map

package/dist/chunk-OF6FDDKV.js

@@ -0,0 +1,184 @@
+import {
+  __glob
+} from "./chunk-HS5PO5ZQ.js";
+
+// import("../plots/**/*.js") in plots/importPlot.js
+var globImport_plots_js = __glob({
+  "../plots/controls.btns.js": () => import("./controls.btns-6AKLIWOG.js"),
+  "../plots/controls.config.js": () => import("./controls.config-UVC4Q7BS.js"),
+  "../plots/controls.js": () => import("./controls-OWC25VQN.js"),
+  "../plots/dictionary.js": () => import("./dictionary-4VZEPGW5.js"),
+  "../plots/gb/test/genomeBrowser.spec.js": () => import("./genomeBrowser.spec-BFTGLRHG.js"),
+  "../plots/geneExpression.js": () => import("./geneExpression-KPUOZ4PT.js"),
+  "../plots/geneORA.js": () => import("./geneORA-KYPN66QU.js"),
+  "../plots/geneset.js": () => import("./geneset-BH5MWNJQ.js"),
+  "../plots/hierCluster.js": () => import("./hierCluster-IJHBVO2N.js"),
+  "../plots/importPlot.js": () => import("./importPlot-EMI6BVPR.js"),
+  "../plots/matrix.js": () => import("./matrix-HMLF5MDD.js"),
+  "../plots/matrix/hierCluster.config.js": () => import("./hierCluster.config-UUQEFTIG.js"),
+  "../plots/matrix/hierCluster.interactivity.js": () => import("./hierCluster.interactivity-6CN5PNFR.js"),
+  "../plots/matrix/hierCluster.js": () => import("./hierCluster-POJBHBN6.js"),
+  "../plots/matrix/hierCluster.renderers.js": () => import("./hierCluster.renderers-YGX6MZZW.js"),
+  "../plots/matrix/matrix.cells.js": () => import("./matrix.cells-5RTZUJVN.js"),
+  "../plots/matrix/matrix.cluster.js": () => import("./matrix.cluster-RH4BOM5F.js"),
+  "../plots/matrix/matrix.config.js": () => import("./matrix.config-RX5GWHTM.js"),
+  "../plots/matrix/matrix.data.js": () => import("./matrix.data-Y5TPRGMW.js"),
+  "../plots/matrix/matrix.dom.js": () => import("./matrix.dom-Q5XSAUUH.js"),
+  "../plots/matrix/matrix.groups.js": () => import("./matrix.groups-6DXCAY4P.js"),
+  "../plots/matrix/matrix.interactivity.js": () => import("./matrix.interactivity-6AJ5BGEP.js"),
+  "../plots/matrix/matrix.js": () => import("./matrix-EABQEAMC.js"),
+  "../plots/matrix/matrix.layout.js": () => import("./matrix.layout-CTHRQE7U.js"),
+  "../plots/matrix/matrix.legend.js": () => import("./matrix.legend-S3E76TVO.js"),
+  "../plots/matrix/matrix.renderers.js": () => import("./matrix.renderers-UGQXONTG.js"),
+  "../plots/matrix/matrix.serieses.js": () => import("./matrix.serieses-3UGLZW25.js"),
+  "../plots/matrix/matrix.sort.js": () => import("./matrix.sort-A7CNLDUJ.js"),
+  "../plots/matrix/matrix.sorterUi.js": () => import("./matrix.sorterUi-6PZR3YOD.js"),
+  "../plots/matrix/test/hierCluster.integration.spec.js": () => import("./hierCluster.integration.spec-PZFUAOHX.js"),
+  "../plots/matrix/test/matrix.integration.spec.js": () => import("./matrix.integration.spec-MZPSYXTF.js"),
+  "../plots/matrix/test/matrix.sort.unit.spec.js": () => import("./matrix.sort.unit.spec-FJKIBDTU.js"),
+  "../plots/matrix/test/matrix.sorterUi.unit.spec.js": () => import("./matrix.sorterUi.unit.spec-6DQ6KGXT.js"),
+  "../plots/matrix/test/matrix.unit.spec.js": () => import("./matrix.unit.spec-7Y3BKFNQ.js"),
+  "../plots/matrix/test/oncomatrix.spec.js": () => import("./oncomatrix.spec-H6AAIP7H.js"),
+  "../plots/plot.brainImaging.js": () => import("./plot.brainImaging-GGUARYRT.js"),
+  "../plots/plot.disco.js": () => import("./plot.disco-EP274JEW.js"),
+  "../plots/plot.ssgq.js": () => import("./plot.ssgq-4VUH3ZWV.js"),
+  "../plots/singleCellPlot.js": () => import("./singleCellPlot-CCG2KSCO.js"),
+  "../plots/stattable.js": () => import("./stattable-ICUZQHUF.js"),
+  "../plots/survival/test/survival.integration.spec.js": () => import("./survival.integration.spec-GVSQL4VB.js"),
+  "../plots/table.js": () => import("./table-XQCTNHSZ.js"),
+  "../plots/test/expclust.gdc.spec.js": () => import("./expclust.gdc.spec-NAN4M75R.js"),
+  "../plots/test/summary.integration.spec.js": () => import("./summary.integration.spec-MXERZOVY.js"),
+  "../plots/volcano/test/testData.js": () => import("./testData-DRM5HWQB.js")
+});
+
+// plots/importPlot.js
+async function importPlot(chartType, notFoundMessage = "") {
+  switch (chartType) {
+    case "aggMatrixInput":
+      return await import("./AggMatrixInput-7D4ZUYJK.js");
+    case "aggregateMatrix":
+      return await import("./AggregateMatrix-NVSFZEW3.js");
+    case "animatedBubbleChart":
+      return await import("./animatedBubbleChart-PUPXCFJW.js");
+    case "brainImaging":
+      return await import("./brainImaging-WFRZQANN.js");
+    case "brainRegions":
+      return await import("./brainRegions-66KWCUF2.js");
+    case "barchart":
+      return await import("./barchart-WRAEMD7B.js");
+    case "boxplot":
+      return await import("./BoxPlot-52WWBGKN.js");
+    case "bubbleHeatmap":
+      return await import("./bubbleHeatmap-VKLIJOMM.js");
+    case "cellTypeBubbleHeatmap":
+      return await import("./cellTypeBubbleHeatmap-ZPCXC52I.js");
+    case "correlationVolcano":
+      return await import("./CorrelationVolcano-WS23O2JT.js");
+    case "cuminc":
+      return await import("./Cuminc-5LJQYFEE.js");
+    case "dataDownload":
+      return await import("./dataDownload-WIPQU33P.js");
+    case "DEinput":
+      return await import("./DEinput-3EAIVG5U.js");
+    case "dictionary":
+      return await import("./dictionary-4VZEPGW5.js");
+    case "differentialAnalysis":
+      return await import("./DifferentialAnalysis-LRAPDIXB.js");
+    case "Disco":
+      return await import("./Disco-IDOTCKSD.js");
+    case "dmr":
+      return await import("./DmrPlot-5CRGQNM3.js");
+    case "facet":
+      return await import("./facet-BJFUIWHK.js");
+    case "GeneExpInput":
+      return await import("./GeneExpInput-PPOTCILZ.js");
+    case "geneRanking":
+      return await import("./geneRanking-VEHFMRFL.js");
+    case "genomeBrowser":
+      return await import("./GB-YCDIORF3.js");
+    case "geomap":
+      return await import("./Geomap-D5JPCJ5L.js");
+    case "grin2":
+      return await import("./grin2-5T557HKM.js");
+    case "gsea":
+      return await import("./GSEA-IGWX3AG7.js");
+    case "imagePlot":
+      return await import("./imagePlot-HKPPACFV.js");
+    case "numericDictTermCluster":
+      return await import("./numericDictTermCluster-6XDVVWLE.js");
+    case "profileBarchart2":
+      return await import("./barchart2-5CX3CO4K.js");
+    case "profileForms":
+      return await import("./profileForms-2IKL3SZU.js");
+    case "profilePlot":
+      return await import("./profilePlot-IURW2HQN.js");
+    case "profilePolar2":
+      return await import("./polar2-7W5JRMB5.js");
+    case "profileRadar2":
+      return await import("./radar2-VXP322F7.js");
+    case "profileRadarFacility2":
+      return await import("./radarFacility2-IJGJ3AJB.js");
+    case "proteinView":
+      return await import("./proteinView-4ZRODQN3.js");
+    case "proteomeAbundance":
+      return await import("./proteomeAbundance-NH3Y4YC7.js");
+    case "proteomeCohortCompare":
+      return await import("./proteomeCohortCompare-BK3FLW4Z.js");
+    case "ProteomeInput":
+      return await import("./ProteomeInput-KB7YRARQ.js");
+    case "regression":
+      return await import("./Regression-5KSKHUEJ.js");
+    case "report":
+      return await import("./report-F22EFD7C.js");
+    case "runChart2":
+    //See frequencyChart
+    case "frequencyChart":
+      return await import("./RunChart2-JJ4GQF44.js");
+    case "sampleView":
+      return await import("./sampleView-3DVB2PQT.js");
+    case "sampleScatter":
+      return await import("./scatter-IFP5NTZU.js");
+    case "sc":
+      return await import("./SC-LKCBWZQX.js");
+    case "studyCatalog":
+      return await import("./studyCatalog-PCFXVOI3.js");
+    case "cohortSunburst":
+      return await import("./cohortSunburst-Z5DANXVS.js");
+    case "summarizeCnvGeneexp":
+      return await import("./summarizeCnvGeneexp-DK6HNUFE.js");
+    case "summarizeGeneexpSurvival":
+      return await import("./summarizeGeneexpSurvival-JLCR2VIX.js");
+    case "summarizeMutationDiagnosis":
+      return await import("./summarizeMutationDiagnosis-5HMVSYMI.js");
+    case "summarizeMutationSurvival":
+      return await import("./summarizeMutationSurvival-GP2OQMUS.js");
+    case "summarizeMutationCnv":
+      return await import("./summarizeMutationCnv-CFAKT6IP.js");
+    case "summaryInput":
+      return await import("./summaryInput-V2G6HFJS.js");
+    case "summary":
+      return await import("./summary-6K553VNS.js");
+    case "sunburst":
+      return await import("./sunburst-6GKVNIRF.js");
+    case "swimmer":
+      return await import("./swimmer-XHORJEVI.js");
+    case "survival":
+      return await import("./survival-GHTV2ZPX.js");
+    case "table":
+      return await import("./table-XQCTNHSZ.js");
+    case "violin":
+      return await import("./Violin-JRP7R53K.js");
+    case "volcano":
+      return await import("./Volcano-BDD3PZ4T.js");
+    case "wsi":
+      return await import("./Wsi-3C3ERYSG.js");
+    default:
+      if (notFoundMessage) throw notFoundMessage;
+      return await globImport_plots_js(`../plots/${chartType}.js`);
+  }
+}
+
+export {
+  importPlot
+};
+//# sourceMappingURL=chunk-OF6FDDKV.js.map

package/dist/chunk-OPMEDR4F.js

@@ -0,0 +1,50 @@
+import {
+  runproteinpaint
+} from "./chunk-QI4EZK7S.js";
+
+// test/front.helpers.js
+var serverData = /* @__PURE__ */ Object.create(null);
+function getRunPp(appname = "", defaultArgs = {}, _host = "http://localhost:3000") {
+  const host = window.testHost || _host;
+  const arg = {
+    host: window.testHost || _host,
+    noheader: 1,
+    nobox: true,
+    debug: 1,
+    norecover: true
+  };
+  if (appname == "mass" || appname == "termdb") {
+    defaultArgs.debounceInterval = 0;
+  }
+  if (appname) arg[appname] = defaultArgs;
+  else copyMerge(arg, defaultArgs);
+  const argStr = JSON.stringify(arg);
+  return function runpp(overrides = {}) {
+    const argCopy = JSON.parse(argStr);
+    if (appname) copyMerge(argCopy[appname], overrides);
+    else copyMerge(argCopy, overrides);
+    if (appname && defaultArgs.fetchOpts) {
+      argCopy[appname].fetchOpts = defaultArgs.fetchOpts;
+    }
+    return runproteinpaint(Object.assign(argCopy, { serverData }));
+  };
+}
+function copyMerge(base, ...args) {
+  const target = typeof base == "string" ? JSON.parse(base) : base;
+  for (const arg of args) {
+    if (arg) {
+      const source = typeof base == "string" ? JSON.parse(JSON.stringify(arg)) : arg;
+      for (const key in source) {
+        if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+        if (!target[key] || Array.isArray(target[key]) || typeof target[key] !== "object") target[key] = source[key];
+        else copyMerge(target[key], source[key]);
+      }
+    }
+  }
+  return target;
+}
+
+export {
+  getRunPp
+};
+//# sourceMappingURL=chunk-OPMEDR4F.js.map