@sjcrh/proteinpaint-client 2.166.0 → 2.167.0

package/dist/chunk-7LKSKJCV.js

@@ -1,480 +0,0 @@
-import {
-  Scatter,
-  ScatterInteractivity
-} from "./chunk-ZHWC5SJP.js";
-import {
-  ScatterModel,
-  ScatterView,
-  ScatterViewModelBase
-} from "./chunk-ETFPL4UP.js";
-import {
-  controlsInit
-} from "./chunk-CZTC4MTE.js";
-import {
-  fillTermWrapper,
-  select2Terms
-} from "./chunk-UT6W4ZZL.js";
-import {
-  getDateFromNumber,
-  isNumericTerm
-} from "./chunk-RYRCMHYR.js";
-import {
-  getColors,
-  plotColor
-} from "./chunk-ECKWM4HB.js";
-import {
-  copyMerge,
-  getCompInit
-} from "./chunk-FYTZCTJC.js";
-import {
-  line_default
-} from "./chunk-PMZS3SHH.js";
-import {
-  median
-} from "./chunk-W2IWHXLL.js";
-import {
-  roundValueAuto
-} from "./chunk-5OHXYXLD.js";
-import {
-  rgb
-} from "./chunk-OMR2DT66.js";
-
-// plots/runchart/model/runchartModel.ts
-var RunchartModel = class extends ScatterModel {
-  createChart(id, data) {
-    const aggregate = this.scatter.settings.aggregateData;
-    const samples = data.samples;
-    if (aggregate !== "None") {
-      const groupedSamples = /* @__PURE__ */ new Map();
-      for (const sample of samples) {
-        const date = new Date(getDateFromNumber(sample.x));
-        const year = date.getFullYear();
-        const month = date.getMonth() + 1;
-        const key = `${year}-${month}`;
-        if (!groupedSamples.has(key)) groupedSamples.set(key, { ysum: sample.y, xsum: sample.x, samples: [sample] });
-        else {
-          const value = groupedSamples.get(key);
-          groupedSamples.set(key, {
-            ysum: value.ysum + sample.y,
-            xsum: value.xsum + sample.x,
-            samples: [...value.samples, sample]
-          });
-        }
-      }
-      for (const value of groupedSamples.values()) {
-        let x, y;
-        if (aggregate == "Median") {
-          x = median(value.samples.map((d) => d.x));
-          y = median(value.samples.map((d) => d.y));
-        } else if (aggregate == "Mean") {
-          y = value.ysum / value.samples.length;
-          x = value.xsum / value.samples.length;
-        }
-        for (const sample of value.samples) {
-          sample.x = x;
-          sample.y = y;
-        }
-      }
-    }
-    const colorLegend = new Map(data.colorLegend);
-    const shapeLegend = new Map(data.shapeLegend);
-    this.charts.push({ id, data, cohortSamples: samples, colorLegend, shapeLegend });
-  }
-};
-
-// plots/runchart/viewmodel/runchartViewModel.ts
-var RunchartViewModel = class extends ScatterViewModelBase {
-  constructor(runchart) {
-    super(runchart);
-    this.runchart = runchart;
-  }
-  render() {
-    this.view.dom.mainDiv.select("svg").selectAll("*").remove();
-    for (const chart of this.model.charts) this.renderChart(chart, this.view.dom.mainDiv, false);
-  }
-  renderSerie(chart, removePrevious) {
-    super.renderSerie(chart, removePrevious);
-    this.showRunChart(chart);
-  }
-  showRunChart(chart) {
-    const g = chart.serie;
-    const color = this.runchart.config.term0 ? this.runchart.cat2Color(chart.id) : this.runchart.settings.defaultColor;
-    const coords = chart.cohortSamples.map((s) => this.model.getCoordinates(chart, s)).sort((a, b) => a.x - b.x);
-    const medianColor = rgb(color).darker(2);
-    const xtext = coords[coords.length - 1].x - 30;
-    const areaBuilder = line_default().x((d) => d.x).y((d) => d.y);
-    g.append("path").attr("stroke", color).attr("fill", "none").attr("stroke-width", 1).attr("stroke-linejoin", "round").attr("opacity", this.runchart.settings.opacity).attr("d", areaBuilder(coords));
-    if (!this.scatter.settings.showCumulativeFrequency) {
-      const median2 = median(chart.cohortSamples, (d) => d.y);
-      const y = chart.yAxisScale(median2);
-      g.append("line").attr("x1", coords[0].x).attr("y1", y).attr("x2", coords[coords.length - 1].x).attr("y2", y).attr("stroke", medianColor).attr("stroke-width", 1).attr("opacity", 0.5);
-      g.append("text").attr("x", xtext).attr("y", y - 5).attr("text-anchor", "start").text("M=" + roundValueAuto(median2, true, 1)).attr("opacity", 0.8).attr("font-size", "0.8em").attr("fill", medianColor);
-    }
-  }
-};
-
-// plots/runchart/view/runchartView.ts
-var minShapeSize = 0.2;
-var maxShapeSize = 6;
-var RunchartView = class extends ScatterView {
-  constructor(runchart) {
-    super(runchart);
-    this.runchart = runchart;
-  }
-  async getControlInputs() {
-    const inputs = [];
-    const shapeOption = {
-      type: "term",
-      configKey: "shapeTW",
-      chartType: "runChart",
-      usecase: { target: "runChart", detail: "shapeTW" },
-      title: "Categories to assign a shape",
-      label: "Shape",
-      vocabApi: this.runchart.app.vocabApi,
-      numericEditMenuVersion: ["discrete"],
-      processInput: async (tw) => {
-        if (isNumericTerm(tw?.term)) {
-          tw.q = { mode: "discrete" };
-          await fillTermWrapper(tw, this.runchart.app.vocabApi);
-        }
-      }
-    };
-    const shapeSizeOption = {
-      label: "Sample size",
-      type: "number",
-      chartType: "runChart",
-      settingsKey: "size",
-      title: "Sample size, represents the factor used to scale the sample",
-      min: 0,
-      step: 0.1
-    };
-    const step = (maxShapeSize - minShapeSize) / 10;
-    const minShapeSizeOption = {
-      label: "Min size",
-      type: "number",
-      chartType: "runChart",
-      settingsKey: "minShapeSize",
-      title: "Minimum sample size",
-      min: minShapeSize,
-      max: maxShapeSize,
-      step
-    };
-    const maxShapeSizeOption = {
-      label: "Max size",
-      type: "number",
-      chartType: "runChart",
-      settingsKey: "maxShapeSize",
-      title: "Maximum sample size",
-      min: minShapeSize,
-      max: maxShapeSize * 2,
-      step
-    };
-    inputs.push(
-      ...[
-        {
-          type: "term",
-          configKey: "term",
-          chartType: "runChart",
-          usecase: { target: "runChart", detail: "numeric" },
-          title: "X coordinate to plot the samples",
-          label: "X",
-          vocabApi: this.runchart.app.vocabApi,
-          menuOptions: "!remove",
-          numericEditMenuVersion: ["continuous"]
-        },
-        {
-          type: "term",
-          configKey: "term2",
-          chartType: "runChart",
-          usecase: { target: "runChart", detail: "numeric" },
-          title: "Y coordinate to plot the samples",
-          label: "Y",
-          vocabApi: this.runchart.app.vocabApi,
-          menuOptions: "!remove",
-          numericEditMenuVersion: ["continuous"]
-        },
-        {
-          boxLabel: "",
-          label: "Aggregate data",
-          chartType: "runChart",
-          settingsKey: "aggregateData",
-          title: `Group samples from the same month and year`,
-          type: "dropdown",
-          options: [
-            { label: "None", value: "None" },
-            //{ label: 'Loess', value: 'Loess' },
-            { label: "Median", value: "Median" },
-            { label: "Mean", value: "Mean" }
-          ]
-        },
-        {
-          type: "term",
-          configKey: "term0",
-          chartType: "runChart",
-          usecase: { target: "runChart", detail: "term0" },
-          title: "Term to to divide by categories",
-          label: "Divide by",
-          vocabApi: this.runchart.app.vocabApi,
-          numericEditMenuVersion: ["discrete"]
-        },
-        {
-          type: "term",
-          configKey: "colorTW",
-          chartType: "runChart",
-          usecase: { target: "runChart", detail: "colorTW" },
-          title: "Categories to color the samples",
-          label: "Color",
-          vocabApi: this.runchart.app.vocabApi,
-          numericEditMenuVersion: ["continuous", "discrete"]
-        },
-        shapeOption,
-        shapeSizeOption,
-        {
-          type: "term",
-          configKey: "scaleDotTW",
-          chartType: "runChart",
-          usecase: { target: "runChart", detail: "numeric" },
-          title: "Scale sample by term value",
-          label: "Scale by",
-          vocabApi: this.runchart.app.vocabApi,
-          numericEditMenuVersion: ["continuous"]
-        },
-        {
-          label: "Opacity",
-          type: "number",
-          chartType: "runChart",
-          settingsKey: "opacity",
-          title: "It represents the opacity of the elements",
-          min: 0,
-          max: 1,
-          step: 0.1
-        },
-        {
-          label: "Chart width",
-          type: "number",
-          chartType: "runChart",
-          settingsKey: "svgw"
-        },
-        {
-          label: "Chart height",
-          type: "number",
-          chartType: "runChart",
-          settingsKey: "svgh"
-        },
-        {
-          label: "Default color",
-          type: "color",
-          chartType: "runChart",
-          settingsKey: "defaultColor"
-        },
-        {
-          label: "Save zoom transform",
-          boxLabel: "",
-          type: "checkbox",
-          chartType: "runChart",
-          settingsKey: "saveZoomTransform",
-          title: `Option to save the zoom transformation in the state. Needed if you want to save a session with zoom and pan applied`,
-          processInput: (value) => this.saveZoomTransform(value)
-        },
-        {
-          label: "Exclude outliers",
-          boxLabel: "",
-          type: "checkbox",
-          chartType: "runChart",
-          settingsKey: "excludeOutliers",
-          title: `Option to exclude outliers from the analysis`
-        }
-      ]
-    );
-    if (this.runchart.config.scaleDotTW)
-      inputs.splice(inputs.length - 5, 0, minShapeSizeOption, maxShapeSizeOption, {
-        label: "Scale order",
-        type: "radio",
-        chartType: "runChart",
-        settingsKey: "scaleDotOrder",
-        options: [
-          { label: "Ascending", value: "Ascending" },
-          { label: "Descending", value: "Descending" }
-        ]
-      });
-    if (!this.runchart.config.term0)
-      inputs.push({
-        label: "Show regression",
-        type: "dropdown",
-        chartType: "runChart",
-        settingsKey: "regression",
-        options: [
-          { label: "None", value: "None" },
-          //{ label: 'Loess', value: 'Loess' },
-          { label: "Lowess", value: "Lowess" },
-          { label: "Polynomial", value: "Polynomial" }
-        ]
-      });
-    inputs.push(...this.getMinMaxInputs());
-    return inputs;
-  }
-};
-
-// plots/runchart/runchart.ts
-var Runchart = class _Runchart extends Scatter {
-  static {
-    this.type = "runChart";
-  }
-  constructor(opts, api) {
-    super(opts, api);
-    this.type = _Runchart.type;
-  }
-  async init(appState) {
-    const state = this.getState(appState);
-    this.config = structuredClone(state.config);
-    this.view = new RunchartView(this);
-    this.model = new RunchartModel(this);
-    this.vm = new RunchartViewModel(this);
-    this.interactivity = new ScatterInteractivity(this);
-  }
-  async main() {
-    this.config = structuredClone(this.state.config);
-    this.settings = this.config.settings[this.type];
-    await this.model.initData();
-    await this.model.processData();
-    this.cat2Color = getColors(this.model.charts.length);
-    await this.setControls();
-    this.vm.render();
-    this.view.dom.loadingDiv.style("display", "none");
-    this.vm.setTools();
-  }
-  async setControls() {
-    this.view.dom.controlsHolder.selectAll("*").remove();
-    const inputs = await this.view.getControlInputs();
-    this.components = {
-      controls: await controlsInit({
-        app: this.app,
-        id: this.id,
-        holder: this.view.dom.controlsHolder,
-        inputs
-      })
-    };
-    this.components.controls.on("downloadClick.scatter", (event) => {
-      this.download(event);
-    });
-  }
-};
-async function getPlotConfig(opts, app) {
-  const defaultConfig = app.vocabApi.termdbConfig?.plotConfigByCohort?.default?.[opts.chartType];
-  const settings = copyMerge(getDefaultRunChartSettings(), defaultConfig?.settings);
-  const plot = {
-    settings: {
-      controls: {
-        isOpen: false
-        // control panel is hidden by default
-      },
-      runChart: settings,
-      startColor: {},
-      //dict to store the start color of the gradient for each chart when using continuous color
-      stopColor: {}
-      //dict to store the stop color of the gradient for each chart when using continuous color
-    }
-  };
-  opts.filter = app.vocabApi?.termdbConfig?.authFilter;
-  copyMerge(plot, defaultConfig, opts);
-  try {
-    if (plot.colorTW) await fillTermWrapper(plot.colorTW, app.vocabApi);
-    if (plot.shapeTW) await fillTermWrapper(plot.shapeTW, app.vocabApi);
-    if (!plot.term.q) plot.term.q = {};
-    if (!plot.term2.q) plot.term2.q = {};
-    plot.term.q.mode = "continuous";
-    plot.term2.q.mode = "continuous";
-    await fillTermWrapper(plot.term, app.vocabApi);
-    await fillTermWrapper(plot.term2, app.vocabApi);
-    if (plot.term0) await fillTermWrapper(plot.term0, app.vocabApi);
-    if (plot.scaleDotTW) await fillTermWrapper(plot.scaleDotTW, app.vocabApi);
-    return plot;
-  } catch (e) {
-    console.log(e);
-    throw `${e} [runChart getPlotConfig()]`;
-  }
-}
-var runChartInit = getCompInit(Runchart);
-var componentInit = runChartInit;
-function makeChartBtnMenu(holder, chartsInstance) {
-  const menuDiv = holder.append("div");
-  menuDiv.append("button").style("margin", "5px").style("padding", "10px 15px").style("border-radius", "20px").style("border-color", "#ededed").style("display", "block").text("Select data to plot ...").on("click", () => {
-    chartsInstance.dom.tip.clear();
-    select2Terms(chartsInstance.dom.tip, chartsInstance.app, "runChart", "date", callback, "numeric");
-    chartsInstance.dom.tip.show();
-  });
-  for (const plot of chartsInstance.state.termdbConfig?.plotConfigByCohort?.default?.runChart?.plots || []) {
-    const config = structuredClone(plot);
-    menuDiv.append("button").style("margin", "5px").style("padding", "10px 15px").style("border-radius", "20px").style("border-color", "#ededed").style("display", "block").text(plot.name).on("click", () => {
-      chartsInstance.app.dispatch({
-        type: "plot_create",
-        config: {
-          chartType: "runChart",
-          ...config
-        }
-      });
-      chartsInstance.dom.tip.hide();
-    });
-  }
-  const callback = (xterm, yterm) => {
-    chartsInstance.app.dispatch({
-      type: "plot_create",
-      config: {
-        chartType: "runChart",
-        term: { term: xterm, q: { mode: "continuous" } },
-        term2: { term: yterm, q: { mode: "continuous" } },
-        name: `${xterm.name} vs ${yterm.name}`
-      }
-    });
-  };
-}
-function getDefaultRunChartSettings() {
-  return {
-    aggregateData: "None",
-    size: 0.5,
-    minShapeSize: 0.5,
-    maxShapeSize: 4,
-    scaleDotOrder: "Ascending",
-    refSize: 0.8,
-    svgw: 1e3,
-    svgh: 500,
-    axisTitleFontSize: 16,
-    opacity: 0.6,
-    defaultColor: plotColor,
-    regression: "None",
-    // Color scale configuration settings
-    // These settings control how numerical values are mapped to colors
-    colorScaleMode: "auto",
-    // Default to automatic scaling based on data range
-    // Other options: 'fixed' (user-defined range) or
-    // 'percentile' (scale based on data distribution)
-    colorScalePercentile: 95,
-    // Default percentile for percentile mode
-    // This means we'll scale colors based on values
-    // up to the 95th percentile by default
-    colorScaleMinFixed: null,
-    // User-defined minimum value for fixed mode
-    // Null indicates this hasn't been set yet
-    colorScaleMaxFixed: null,
-    // User-defined maximum value for fixed mode
-    saveZoomTransform: false,
-    excludeOutliers: false,
-    minXScale: null,
-    maxXScale: null,
-    minYScale: null,
-    maxYScale: null
-  };
-}
-
-export {
-  RunchartModel,
-  RunchartViewModel,
-  RunchartView,
-  Runchart,
-  getPlotConfig,
-  runChartInit,
-  componentInit,
-  makeChartBtnMenu,
-  getDefaultRunChartSettings
-};
-//# sourceMappingURL=chunk-7LKSKJCV.js.map

package/dist/chunk-7P67W6NF.js

@@ -1,190 +0,0 @@
-import {
-  sample_match_termvaluesetting
-} from "./chunk-UT6W4ZZL.js";
-import {
-  isDictionaryType
-} from "./chunk-RYRCMHYR.js";
-import {
-  __export
-} from "./chunk-HFNDKYVF.js";
-
-// plots/matrix/matrix.data.js
-var matrix_data_exports = {};
-__export(matrix_data_exports, {
-  applyLegendValueFilter: () => applyLegendValueFilter,
-  getMatrixRequestOpts: () => getMatrixRequestOpts,
-  mayRequireToken: () => mayRequireToken,
-  setData: () => setData
-});
-function mayRequireToken(tokenMessage = "") {
-  const message = tokenMessage || this.state.tokenVerificationMessage;
-  if (!message && this.state.hasVerifiedToken) {
-    this.dom.errdiv.style("display", "none").html();
-    this.dom.controls.style("display", this.opts.controls ? "inline-block" : "");
-    this.dom.svg.style("display", "");
-    return false;
-  } else {
-    this.dom.errdiv.style("display", "").html(message || "Requires login");
-    this.dom.controls.style("display", "none");
-    this.dom.svg.style("display", "none");
-    return true;
-  }
-}
-function getMatrixRequestOpts(state) {
-  const terms = [];
-  const termgroups = this.chartType == "hierCluster" ? state.config.termgroups.filter((grp) => grp.type != "hierCluster") : state.config.termgroups;
-  for (const grp of termgroups) {
-    terms.push(...getNormalizedTwLstCopy(grp.lst));
-  }
-  if (state.config.divideBy) terms.push(normalizeTwForRequest(structuredClone(state.config.divideBy)));
-  const opts = {
-    terms,
-    filter: state.filter,
-    filter0: state.filter0,
-    maxGenes: state.config.settings.matrix.maxGenes,
-    /*********** quick fix
-    when the flag is true, set artificially large number to ensure all genes are sent in one query
-    this avoids changing getAnnotatedSampleData()
-    additional non-matrix app that calls getAnnotatedSampleData will NEED THE SAME FIX
-    */
-    termsPerRequest: this.app.vocabApi.termdbConfig.queries?.snvindel?.byisoform?.processTwsInOneQuery ? 1e3 : 1
-  };
-  if (this.chartType == "hierCluster") {
-    opts.isHierCluster = 1;
-  }
-  return opts;
-}
-function getNormalizedTwLstCopy(twlst) {
-  const lst = structuredClone(twlst);
-  lst.forEach(normalizeTwForRequest);
-  lst.sort(sortTwLst);
-  return lst;
-}
-function normalizeTwForRequest(tw) {
-  if (!tw?.term) return;
-  delete tw.term.category2samplecount;
-  if (isDictionaryType(tw.term.type) && tw.term.type !== "samplelst") delete tw.term.values;
-  return tw;
-}
-function sortTwLst(twa, twb) {
-  const a = twa?.$id || twa.term?.id || twa?.term?.name;
-  const b = twb?.$id || twb.term?.id || twb?.term?.name;
-  return a < b ? -1 : 1;
-}
-async function setData(_data) {
-  const opts = this.currRequestOpts?.matrix || this.getMatrixRequestOpts(this.state);
-  this.numTerms = opts.terms.length;
-  const abortCtrl = new AbortController();
-  opts.signal = abortCtrl.signal;
-  opts.loadingDiv = this.chartType != "hierCluster" && this.dom.loadingDiv;
-  const data = await this.app.vocabApi.getAnnotatedSampleData(opts, _data);
-  this.data = data;
-  this.origData = structuredClone(this.data);
-  this.sampleIdMap = {};
-  for (const d of this.data.lst) {
-    this.sampleIdMap[d.sample] = d._ref_.label;
-  }
-}
-function applyLegendValueFilter() {
-  const self = this;
-  if (!self.config.legendValueFilter.lst.length && !self.config.legendGrpFilter.lst.length) return;
-  for (const grpFilter of self.config.legendGrpFilter.lst) {
-    if (grpFilter.dt) {
-      const filteredOutCats = /* @__PURE__ */ new Set();
-      for (const oneSampleData of self.origData.lst) {
-        for (const annoForOneTerm of Object.values(oneSampleData)) {
-          if (annoForOneTerm.values) {
-            const newValues = [];
-            for (const v of annoForOneTerm.values) {
-              if (!(grpFilter.dt.includes(v.dt) && (!grpFilter.origin || v.origin == grpFilter.origin))) {
-                newValues.push(v);
-              } else {
-                filteredOutCats.add(v.class);
-              }
-            }
-            annoForOneTerm.values = newValues;
-          }
-        }
-      }
-      grpFilter.filteredOutCats = [...filteredOutCats];
-      for (const oneSampleData of Object.values(self.origData.samples)) {
-        for (const annoForOneTerm of Object.values(oneSampleData)) {
-          if (annoForOneTerm.values)
-            annoForOneTerm.values = annoForOneTerm.values.filter(
-              (v) => !(grpFilter.dt.includes(v.dt) && (!grpFilter.origin || v.origin == grpFilter.origin))
-            );
-        }
-      }
-    }
-  }
-  const geneVariant$ids = Object.values(self.data.refs.byTermId).filter((v) => v.term?.type == "geneVariant").map((v) => v.$id);
-  const data = { samples: {}, lst: [], refs: self.data.refs };
-  const onlyHardFilter = structuredClone(self.config.legendValueFilter);
-  onlyHardFilter.lst = onlyHardFilter.lst.filter(
-    (l) => !l.tvs.legendFilterType || l.tvs.legendFilterType !== "geneVariant_soft"
-  );
-  for (const row of self.origData.lst) {
-    const include = sample_match_termvaluesetting(row, onlyHardFilter, geneVariant$ids);
-    if (include || self.chartType == "hierCluster") {
-      data.samples[row.sample] = row;
-      data.lst.push(row);
-    }
-  }
-  for (const valFilter of self.config.legendValueFilter.lst) {
-    if (valFilter.tvs.legendFilterType !== "geneVariant_soft") continue;
-    const tvsV = valFilter.tvs.values[0];
-    const filteredOutCats = /* @__PURE__ */ new Set();
-    for (const oneSampleData of data.lst) {
-      for (const annoForOneTerm of Object.values(oneSampleData)) {
-        if (annoForOneTerm.values) {
-          const newValues = [];
-          for (const v of annoForOneTerm.values) {
-            if (!(v.dt == tvsV.dt && (!tvsV.origin || v.origin == tvsV.origin) && tvsV.mclasslst.includes(v.class))) {
-              newValues.push(v);
-            } else {
-              filteredOutCats.add(v.class);
-            }
-          }
-          annoForOneTerm.values = newValues;
-        }
-      }
-    }
-    valFilter.filteredOutCats = [...filteredOutCats];
-    for (const oneSampleData of Object.values(data.samples)) {
-      for (const annoForOneTerm of Object.values(oneSampleData)) {
-        if (annoForOneTerm.values)
-          annoForOneTerm.values = annoForOneTerm.values.filter(
-            (v) => !(v.dt == tvsV.dt && (!tvsV.origin || v.origin == tvsV.origin) && tvsV.mclasslst.includes(v.class))
-          );
-      }
-    }
-  }
-  if (self.chartType !== "hierCluster" && geneVariant$ids.length && self.app.vocabApi.vocab?.dslabel == "GDC")
-    remove_empty_sample(data, geneVariant$ids);
-  self.data = data;
-}
-function remove_empty_sample(data) {
-  for (const oneSampleData of data.lst) {
-    let removeSample = true;
-    for (const [key, annoForOneTerm] of Object.entries(oneSampleData)) {
-      if (!annoForOneTerm.values) continue;
-      const annoType = data.refs.byTermId[key].term.type;
-      if (annoType != "geneVariant") continue;
-      if (annoForOneTerm.values.length) removeSample = false;
-    }
-    if (removeSample) {
-      data.lst = data.lst.filter((dl) => dl.sample !== oneSampleData.sample);
-      delete data.samples[parseInt(oneSampleData.sample)];
-    }
-  }
-  return data;
-}
-
-export {
-  mayRequireToken,
-  getMatrixRequestOpts,
-  setData,
-  applyLegendValueFilter,
-  matrix_data_exports
-};
-//# sourceMappingURL=chunk-7P67W6NF.js.map