@sjcrh/proteinpaint-client 2.190.2 → 2.191.2

package/dist/chunk-DVH6K2NP.js

@@ -1,14 +0,0 @@
-// src/block.lazyload.js
-var Block;
-async function blocklazyload(arg) {
-  if (!Block) {
-    const b = await import("./block-OYSZ2JXC.js");
-    Block = b.Block;
-  }
-  return new Block(arg);
-}
-
-export {
-  blocklazyload
-};
-//# sourceMappingURL=chunk-DVH6K2NP.js.map

package/dist/chunk-DYVY7D67.js

@@ -1,263 +0,0 @@
-import {
-  hierCluster_renderers_exports
-} from "./chunk-S6H6OUOA.js";
-import {
-  hierCluster_interactivity_exports
-} from "./chunk-SDMZUHN7.js";
-import {
-  Matrix
-} from "./chunk-DBFPAZG3.js";
-import {
-  filterJoin,
-  getNormalRoot
-} from "./chunk-UK3PTE3P.js";
-import {
-  clusterMethodLst,
-  distanceMethodLst,
-  dofetch3
-} from "./chunk-STQU7XZV.js";
-import {
-  deepEqual,
-  getCompInit
-} from "./chunk-5V43Y2RC.js";
-import {
-  NUMERIC_DICTIONARY_TERM,
-  TermTypes2Dt
-} from "./chunk-XOCO3LVN.js";
-import {
-  colorScaleMap
-} from "./chunk-EBKERML3.js";
-import {
-  extent,
-  linear
-} from "./chunk-OAWQ6LOO.js";
-
-// plots/matrix/hierCluster.js
-var HierCluster = class _HierCluster extends Matrix {
-  static type = "hierCluster";
-  constructor(opts) {
-    super(opts);
-    this.type = _HierCluster.type;
-    this.chartType = _HierCluster.type;
-  }
-  async init(appState) {
-    await super.init(appState);
-    this.maySetSandboxHeader(appState);
-    this.hcClipId = this.seriesClipId + "-hc";
-    this.dom.hcClipRect = this.dom.svg.select("defs").append("clipPath").attr("id", this.hcClipId).attr("clipPathUnits", "userSpaceOnUse").append("rect").attr("display", "block");
-    this.dom.topDendrogram = this.dom.svg.insert("g", "g").attr("clip-path", `url(#${this.hcClipId})`).append("g").attr("class", "sjpp-matrix-dendrogram").attr("data-testid", "hierCluster_top_dendrogram").on("click", (event) => {
-      const clickedClusterId = this.getClusterFromTopDendrogram(event);
-      if (clickedClusterId) {
-        this.clickedClusterIds = this.getAllChildrenClusterIds(clickedClusterId);
-        this.clickedClusterIds.push(clickedClusterId);
-        const clickedCluster = this.hierClusterData.clustering.col.mergedClusters.get(clickedClusterId);
-        const clickedClusterSampleNames = clickedCluster.children.map((c) => c.name);
-        this.addSelectedSamplesOptions(clickedClusterSampleNames, event);
-      } else {
-        delete this.clickedClusterIds;
-      }
-      if (this.clickedLeftClusterIds) {
-        delete this.clickedLeftClusterIds;
-        this.plotDendrogramHclust();
-      } else this.plotDendrogramHclust("top");
-    });
-    this.dom.leftDendrogram = this.dom.svg.insert("g", "g").attr("class", "sjpp-matrix-dendrogram").attr("data-testid", "hierCluster_left_dendrogram").on("click", (event) => {
-      const clickedLeftClusterId = this.getClusterFromLeftDendrogram(event);
-      if (clickedLeftClusterId) {
-        this.clickedLeftClusterIds = this.getAllChildrenClusterIds(clickedLeftClusterId, true);
-        this.clickedLeftClusterIds.push(clickedLeftClusterId);
-        const clickedLeftCluster = this.hierClusterData.clustering.row.mergedClusters.get(clickedLeftClusterId);
-        const clickedLeftClusterRowsNames = clickedLeftCluster.children.map((c) => c.name);
-        this.addSelectedRowsOptions(clickedLeftClusterRowsNames, event);
-      } else {
-        delete this.clickedLeftClusterIds;
-      }
-      if (this.clickedClusterIds) {
-        delete this.clickedClusterIds;
-        this.plotDendrogramHclust();
-      } else this.plotDendrogramHclust("left");
-    });
-  }
-  async setHierClusterData(_data = {}) {
-    this.prevServerData = this.currServerData;
-    const [d, twlst] = await this.requestData({});
-    if (d.error) throw d.error;
-    this.currServerData = structuredClone(d);
-    if (!deepEqual(this.prevServerData, this.currServerData)) {
-      delete this.clickedClusterIds;
-      delete this.clickedLeftClusterIds;
-    }
-    const s = this.settings.hierCluster;
-    if (!d.clustering) {
-      if (d.gene) {
-        throw `Cannot do clustering: data is only available for 1 gene (${d.gene}). Try again by adding more genes.`;
-      }
-    }
-    this.hierClusterData = d;
-    const c = this.hierClusterData.clustering;
-    this.setHierColorScale(c);
-    const samples = {};
-    for (const [i, column] of c.col.order.entries()) {
-      samples[column.name] = { sample: column.name };
-      for (const [j, row] of c.row.order.entries()) {
-        const tw = twlst.find((tw2) => tw2.$id === row.name || tw2.id === row.name);
-        const value = c.matrix[j][i];
-        samples[column.name][tw.$id] = {
-          key: tw.term.name,
-          values: [
-            {
-              sample: column.name,
-              dt: TermTypes2Dt[this.state.config.dataType],
-              label: s.termGroupName,
-              // gene: tw.term.name,
-              // chr: tw.term.chr,
-              // pos: `${tw.term.start}-${tw.term.stop}`,
-              value
-              // the color will be computed in matrix.cells, so that
-              // it can get updated even when there are no nonsetting state diff
-            }
-          ]
-        };
-      }
-    }
-    this.hcTermNameOrder = this.settings.hierCluster.sortClusterRows == "asListed" ? twlst.map((t) => t.term.name) : this.settings.hierCluster.sortClusterRows == "byName" ? twlst.map((t) => t.term.name).sort() : this.config.dataType === NUMERIC_DICTIONARY_TERM ? c.row.order.map((row) => twlst.find((t) => t.$id == row.name || t.term.id == row.name)?.term.name) : c.row.order.map((row) => twlst.find((t) => t.$id == row.name)?.term.name);
-    if (this.hcTermNameOrder.includes(void 0)) throw `unable to map row.name to term.name`;
-    this.hcTermSorter = (a, b) => {
-      const i = this.hcTermNameOrder.indexOf(a.tw.term.name);
-      const j = this.hcTermNameOrder.indexOf(b.tw.term.name);
-      if (i == -1 && j == -1) return 0;
-      if (i == -1) return 1;
-      if (j == -1) return -1;
-      return i - j;
-    };
-    this.hcSampleNameOrder = c.col.order.map((col) => col.name);
-    this.hcSampleSorter = (a, b) => {
-      const i = this.hcSampleNameOrder.indexOf(a.sample);
-      const j = this.hcSampleNameOrder.indexOf(b.sample);
-      if (i == -1 && j == -1) return 0;
-      if (i == -1) return 1;
-      if (j == -1) return -1;
-      return i - j;
-    };
-    const byTermId = {};
-    for (const tw of twlst) {
-      if (d.byTermId?.[tw.term.name]) byTermId[tw.$id] = d.byTermId[tw.term.name];
-    }
-    this.hierClusterSamples = {
-      refs: { byTermId, bySampleId: d.bySampleId },
-      lst: c.col.order.map((c2) => samples[c2.name]),
-      samples,
-      removedHierClusterTerms: d.removedHierClusterTerms
-    };
-  }
-  async requestData() {
-    const body = this.currRequestOpts?.hierCluster || this.getHCRequestBody(this.state);
-    const twlst = this.hcTermGroup.lst;
-    const data = await dofetch3("termdb/cluster", { body, signal: this.api.getAbortSignal?.() });
-    return [data, twlst];
-  }
-  getHCRequestBody(state) {
-    this.hcTermGroup = this.config.termgroups.find((grp) => grp.type == "hierCluster") || this.termOrder?.find((t) => t.grp.type == "hierCluster")?.grp;
-    const s = state.config.settings.hierCluster;
-    const dictionaryLegendFilter = {
-      type: "tvslst",
-      in: true,
-      join: "and",
-      lst: state.config.legendValueFilter.lst.filter((f) => !f.tvs.legendFilterType)
-    };
-    const terms = this.getClusterRowTermsAsParameter();
-    if (!terms.length) throw "no data";
-    if (!clusterMethodLst.find((i) => i.value == s.clusterMethod)) throw "Invalid cluster method";
-    if (!distanceMethodLst.find((i) => i.value == s.distanceMethod)) throw "Invalid distance method";
-    const body = {
-      genome: state.vocab.genome,
-      dslabel: state.vocab.dslabel,
-      dataType: state.config.dataType,
-      clusterMethod: s.clusterMethod,
-      distanceMethod: s.distanceMethod,
-      zScoreTransformation: s.zScoreTransformation,
-      terms,
-      filter: getNormalRoot(filterJoin([state.filter, dictionaryLegendFilter])),
-      filter0: state.filter0
-    };
-    if (state.config.dataType == "proteomeAbundance") {
-      body.proteomeDetails = {
-        organism: state.config.proteomeDetails?.organism,
-        assay: state.config.proteomeDetails?.assay,
-        cohort: state.config.proteomeDetails?.cohort
-      };
-    }
-    return body;
-  }
-  combineData() {
-    if (!this.hierClusterSamples) return;
-    const d = this.data;
-    const removedHierClusterTerms = this.hierClusterSamples.removedHierClusterTerms;
-    const samples = {};
-    const lst = [];
-    for (const sampleId in this.hierClusterSamples.samples) {
-      const s = this.hierClusterSamples.samples[sampleId];
-      samples[sampleId] = s;
-      lst.push(s);
-      if (sampleId in d.samples) Object.assign(s, d.samples[sampleId]);
-      const _ref_ = this.hierClusterSamples.refs.bySampleId[sampleId] || {};
-      if (!s._ref_) s._ref_ = _ref_;
-      else Object.assign(s._ref_, _ref_);
-    }
-    const t = this.hierClusterSamples.refs.byTermId;
-    for (const $id of Object.keys(t)) {
-      d.refs.byTermId[$id] = Object.assign({}, d.refs.byTermId[$id] || {}, t[$id]);
-    }
-    this.data = { samples, lst, refs: d.refs, removedHierClusterTerms };
-  }
-  setHierColorScale(c) {
-    const hc = this.settings.hierCluster;
-    const scale = linear(colorScaleMap[hc.colorScale].domain, colorScaleMap[hc.colorScale].range).clamp(true);
-    const globalMinMaxes = [];
-    for (const row of c.matrix) {
-      globalMinMaxes.push(...extent(row));
-    }
-    const absMax = Math.min(hc.zScoreCap, Math.max(...extent(globalMinMaxes).map(Math.abs)));
-    const [min, max] = hc.zScoreTransformation ? [-absMax, absMax] : [Math.min(...globalMinMaxes), Math.max(...globalMinMaxes)];
-    this.hierClusterValues = { scale, min, max };
-  }
-  getValueColor(value) {
-    const hc = this.settings.hierCluster;
-    if (hc.zScoreTransformation) {
-      const zScoreCap = this.settings.hierCluster.zScoreCap;
-      return this.hierClusterValues.scale((value - -zScoreCap) / (zScoreCap * 2));
-    } else {
-      return this.hierClusterValues.scale(value / this.hierClusterValues.max);
-    }
-  }
-  /* returns list of gene terms as request parameter, e.g. {gene,chr,start,stop}
-  	request parameter only need term but not tw, as it will simply fetch continuous sample values on terms without transform
-  
-  	use of this function is unfortunate because:
-  		the incomplete migration of {name} to {gene} for gene-based term
-  		geneset edit ui is hardcoded to return {name}
-  		existing plot states contain {name}
-  
-  	!!! migration instruction !!!
-  	- term.name is for display only, if a term is gene-based, it has term.gene=str
-  	- a geneVariant term can be based on a genomic range (and not a gene), in that case it won't have term.gene and cannot be used where gene is expected, e.g. gene-based clustering analysis
-  
-  	*/
-  getClusterRowTermsAsParameter() {
-    const lst = this.hcTermGroup.lst.map(this.opts.app.vocabApi.getTwMinCopy);
-    lst.sort((a, b) => a.term.name < b.term.name ? -1 : 1);
-    return lst;
-  }
-};
-for (const methods of [hierCluster_renderers_exports, hierCluster_interactivity_exports]) {
-  for (const methodName in methods) HierCluster.prototype[methodName] = methods[methodName];
-}
-var hierClusterInit = getCompInit(HierCluster);
-var componentInit = hierClusterInit;
-
-export {
-  HierCluster,
-  hierClusterInit,
-  componentInit
-};
-//# sourceMappingURL=chunk-DYVY7D67.js.map

package/dist/chunk-E4IHE23N.js

@@ -1,398 +0,0 @@
-import {
-  StoreBase,
-  getAppInit,
-  getStoreInit
-} from "./chunk-5V43Y2RC.js";
-
-// test/Locator.ts
-var Locator = class _Locator {
-  // arg could be one of the following, must always
-  // - DOM element
-  // - string selector
-  // - d3-selection
-  constructor(arg, opts = {}) {
-    //HTMLElement | SVGElement | SVGGElement | SVGLineElement | SVGRectElement | SVGSVGElement | SVGTextElement
-    this.opts = {
-      intervalWait: 25,
-      maxWait: 3e3
-    };
-    this.pending = [];
-    this.result = [];
-    Object.assign(this.opts, opts);
-    this.setRoot(arg);
-  }
-  // convenience method to allow await Locator.init(elem).whenVisible('')
-  static init(elem) {
-    return new _Locator(elem);
-  }
-  setRoot(arg) {
-    if (typeof arg == "string") {
-      const node = document.body.querySelector(arg);
-      if (!node) throw `missing elem by selector='${arg}'`;
-      this.rootElem = node;
-    } else if (typeof arg.node == "function") {
-      const numMatch = arg.size();
-      if (!numMatch) throw `missing elem from d3-selection`;
-      this.rootElem = arg.node();
-    } else {
-      this.rootElem = arg;
-    }
-    this.pending = [];
-  }
-  root(arg) {
-    if (arg) this.setRoot(arg);
-    return this.rootElem;
-  }
-  // selector: string selector such as '#my-id', '.my-class', `[data-testid='my-id-here']`, `[role='button']`, etc
-  shows(selector, opts = {}) {
-    this.pending.push([
-      shows,
-      {
-        selector,
-        targetCount: opts.count || 1,
-        //'>=1',
-        visibility: opts.visibility ?? true,
-        intervalWait: opts.intervalWait || this.opts.intervalWait,
-        maxWait: opts.maxWait || this.opts.maxWait,
-        attr: opts.attr || {}
-      }
-    ]);
-    return this;
-  }
-  // same argument as this.shows(), but visibility is not checked
-  // and assumes that the elements targeted by the selector are
-  // ready to be queried
-  find(selector) {
-    this.pending.push([find, { selector }]);
-    return this;
-  }
-  // cannot chain another method after get(), since
-  // the retured promise would require wrapping in parentheses
-  //
-  // get()
-  // - run the pending functions in sequence and return the resolved
-  //   queried elems or its properties based on the argument
-  //
-  // Arguments:
-  //  arg: undefined | string | number | callback
-  //
-  // returns
-  //  - no argument: get the matched elements as an array
-  //  - callback function: passes the matched elements to the callback and returns its returned value
-  //  - number: use as index key to return elems[index]
-  //  - string: see the processing in the
-  async get(arg) {
-    const pending = this.pending;
-    this.pending = [];
-    let elems = [this.rootElem];
-    for (const [fxn, opts] of pending) {
-      elems = await fxn(elems, opts);
-    }
-    if (!arguments.length || arg === void 0) return elems;
-    if (typeof arg === "function") return arg(elems);
-    if (typeof arg === "number") return elems[arg];
-    if (typeof arg === "string") {
-      if (arg == "length") return elems.length;
-      const key = arg.slice(1);
-      if (!key) return elems;
-      const char = arg[0];
-      if (char === ".") return elems.map((elem) => elem[key]);
-      if (char === "@") return elems.map((elem) => elem.getAttribute(key));
-      if (char === ":") return elems.map((elem) => elem.style[key]);
-    }
-    throw `invalid Locator.get() argument='${arg}'`;
-  }
-  // TODO: support .set(arg, value)???
-  /*** convenient aliased methods for .get(arg) ***/
-  async length() {
-    return await this.get("length");
-  }
-  async value() {
-    return await this.get(".value");
-  }
-  async text() {
-    return await this.get(".innerText");
-  }
-  hides(selector) {
-    return this.shows(selector, { visibility: false });
-  }
-  async click(arg) {
-    const elems = await this.get(arg);
-    const arr = Array.isArray(elems) ? elems : [elems];
-    for (const elem of arr) {
-      const box = elem.getBoundingClientRect();
-      const clientX = box.x + 0.5 * box.width;
-      const clientY = box.y + box.height;
-      elem.dispatchEvent(new MouseEvent("click", { bubbles: true, clientX, clientY }));
-    }
-    return elems;
-  }
-};
-async function shows(elems, opts) {
-  return new Promise((resolve) => {
-    const { selector, targetCount, intervalWait, maxWait, visibility, attr } = opts;
-    const matchedElems = /* @__PURE__ */ new Set();
-    let elapsed = 0, pending = false;
-    const i = setInterval(() => {
-      if (pending) return;
-      pending = true;
-      for (const elem of elems) {
-        for (const descendant of elem.querySelectorAll(selector)) {
-          if (matchedElems.has(descendant)) continue;
-          if (descendant.checkVisibility() === visibility) {
-            if (!attr) matchedElems.add(descendant);
-            else {
-              const kvEntries = Object.entries(attr);
-              const matchedKeys = [];
-              for (const [key, value2] of kvEntries) {
-                if (elem.getAttribute(key) !== value2) matchedKeys.push(key);
-              }
-              if (matchedKeys.length === kvEntries.length) matchedElems.add(descendant);
-            }
-          }
-        }
-      }
-      elapsed += intervalWait;
-      if (matchedElems.size >= targetCount || elapsed > maxWait) {
-        clearInterval(i);
-        resolve([...matchedElems]);
-      }
-      pending = false;
-    }, intervalWait);
-  });
-}
-async function find(elems, opts) {
-  for (const elem of elems) {
-    const match = elem.querySelector(opts.selector);
-    if (match) {
-      return [match];
-    }
-  }
-  return [];
-}
-
-// test/test.helpers.js
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function detectLst(_opts = {}) {
-  const defaults = {
-    target: _opts.target || _opts.elem,
-    selector: _opts.selector,
-    maxTime: 12e3,
-    // default is increased from 5 to 12 specifically for gdc live tests with high latency
-    observe: {
-      childList: true,
-      subtree: true,
-      attributes: true,
-      characterData: true
-    }
-  };
-  if (!_opts.matcher) {
-    defaults.count = 1;
-    defaults.matchAs = "=";
-  }
-  const opts = Object.assign(defaults, _opts);
-  if (!opts.target) throw `missing opts.target (alias for opts.elem)`;
-  if (!opts.trigger && opts.count > 0) await sleep(0);
-  const start = Date.now();
-  return new Promise((resolve, reject) => {
-    if (!opts.matcher && opts.selector) {
-      const elems = opts.target.querySelectorAll(opts.selector);
-      const matched = matchedCount(elems.length, opts);
-      if (matched) {
-        resolve([...elems]);
-        return;
-      }
-    }
-    const callback = (mutations) => {
-      const elems = opts.selector ? [...opts.target.querySelectorAll(opts.selector)] : [opts.target];
-      const mutated = mutations.filter((m) => elems.includes(m.target));
-      if (!mutated.length && opts.count !== 0) return;
-      const matched = opts.matcher ? opts.matcher(mutated, observer) : matchedCount(elems.length, opts);
-      const expired = Date.now() - start > opts.maxTime;
-      if (matched || expired) {
-        observer.disconnect();
-        if (t) clearTimeout(t);
-        if (matched) resolve(Array.isArray(matched) ? matched : elems);
-        else reject(`test exceeded maxTime=${opts.maxTime}`);
-      }
-    };
-    const observer = new MutationObserver(callback);
-    observer.observe(opts.target, opts.observe);
-    let t;
-    if (opts.maxTime) {
-      t = setTimeout(() => {
-        if (opts.count === 0) {
-        } else reject(`the elem '${opts.target}' did not render within ${opts.maxTime} milliseconds`);
-      }, opts.maxTime);
-    }
-    if (opts.trigger) opts.trigger();
-  });
-}
-function matchedCount(actual, opts) {
-  const expected = opts.count;
-  switch (opts.matchAs) {
-    case "=":
-      return actual === expected;
-    case "<":
-      return actual < expected;
-    case "<=":
-      return actual <= expected;
-    case ">":
-      return actual > expected;
-    case ">=":
-      return actual >= expected;
-    default:
-      throw `unknown matchAs='${opts.matchAs}'`;
-  }
-}
-async function detectAttr(opts) {
-  if (!opts.observe) opts.observe = {};
-  opts.observe.attributes = true;
-  const lst = await detectLst(opts);
-  return lst;
-}
-async function detectChildAttr(opts) {
-  if (!opts.observe) opts.observe = {};
-  opts.observe.subtree = true;
-  opts.observe.attributes = true;
-  if (opts.attr) {
-    if (opts.matcher) console.warn(`will not use opts.attr since an opts.matcher is already available`);
-    else {
-      if (!("count" in opts)) opts.count = 1;
-      opts.matcher = (mutations) => {
-        const matched = mutations.filter((m) => {
-          for (const key in opts.attr) {
-            if (typeof opts.attr[key] === "function") {
-              const value2 = m.target.getAttribute(key);
-              if (!opts.attr[key](value2)) return false;
-            } else if (value != opts.attr[key]) {
-              return false;
-            }
-          }
-          return true;
-        });
-        if (matched.length === opts.count) return matched.map((d) => d.target);
-      };
-    }
-  }
-  const lst = await detectLst(opts);
-  return lst;
-}
-async function detectStyle(opts) {
-  if (!opts.observe) opts.observe = {};
-  opts.observe.attributes = true;
-  opts.observe.attributeFilter = ["style"];
-  const lst = await detectLst(opts);
-  return lst;
-}
-async function detectChildStyle(opts) {
-  if (!opts.observe) opts.observe = {};
-  opts.observe.subtree = true;
-  opts.observe.attributes = true;
-  opts.observe.attributeFilter = ["style"];
-  if (opts.style) {
-    if (opts.matcher) console.warn(`will not use opts.style since an opts.matcher is already available`);
-    else {
-      if (!("count" in opts)) opts.count = 1;
-      opts.matcher = (mutations) => {
-        const matched = mutations.filter((m) => {
-          for (const key in opts.style) {
-            const value2 = m.target.style[key];
-            if (typeof opts.style[key] == "function") {
-              if (!opts.style[key](value2)) return false;
-            } else if (value2 != opts.style[key]) return false;
-          }
-          return true;
-        });
-        if (matched.length === opts.count) return matched.map((d) => d.target);
-      };
-    }
-  }
-  const lst = await detectLst(opts);
-  return lst;
-}
-async function detectGt(opts) {
-  opts.matchAs = ">";
-  const lst = await detectLst(opts);
-  return lst;
-}
-async function detectGte(opts) {
-  opts.matchAs = ">=";
-  const lst = await detectLst(opts);
-  return lst;
-}
-async function detectOne(opts) {
-  opts.count = 1;
-  const lst = await detectLst(opts);
-  return lst[0];
-}
-async function whenVisible(elem, opts = {}) {
-  const intervalWait = 25;
-  const totalWait = opts.wait || 5e3;
-  const numRepeats = totalWait / intervalWait;
-  return new Promise((resolve, reject) => {
-    let j = 0;
-    const i = setInterval(() => {
-      if (elem.style.display != "none") {
-        clearInterval(i);
-        resolve(elem);
-      } else {
-        j++;
-        if (j > numRepeats) {
-          reject(`elem did not become visible within 5 seconds`);
-          clearInterval(i);
-        }
-      }
-    }, intervalWait);
-  });
-}
-var TestAppStore = class _TestAppStore extends StoreBase {
-  static type = "store";
-  constructor(opts) {
-    super(opts);
-    this.type = _TestAppStore.type;
-    this.defaultState = {
-      debug: true
-    };
-  }
-  async init() {
-  }
-};
-var storeInit = getStoreInit(TestAppStore);
-var TestApp = class {
-  static type = "app";
-  constructor(opts) {
-    this.type = "app";
-    this.opts = opts;
-    this.fetchOpts = opts.fetchOpts;
-  }
-  async init() {
-    try {
-      this.store = await storeInit({ app: this.api, state: this.opts.state });
-      this.state = await this.store.copyState();
-      if (this.opts.dom) this.dom = this.opts.dom;
-      await this.api.dispatch();
-    } catch (e) {
-      if (e.stack) console.log(e.stack);
-      else throw `TestApp Error: ${e}`;
-    }
-  }
-};
-var testAppInit = getAppInit(TestApp);
-
-export {
-  Locator,
-  sleep,
-  detectLst,
-  detectAttr,
-  detectChildAttr,
-  detectStyle,
-  detectChildStyle,
-  detectGt,
-  detectGte,
-  detectOne,
-  whenVisible
-};
-//# sourceMappingURL=chunk-E4IHE23N.js.map