@carbon/charts 1.7.6 → 1.9.0-next.0

package/dist/model/index.mjs

@@ -0,0 +1,1107 @@
+import { U as z, W as F, ad as U, g as u, z as S, f as G, y as j, ab as M, N as k, ae as L, h as _, v as V, a2 as K, a3 as y, P as R, a0 as x } from "../color-scale-utils-5eb3eeaa.mjs";
+import { bin as Z, stack as A, stackOffsetDiverging as H, scaleOrdinal as $, quantile as E, ascending as Q, min as P, max as N, extent as W, scaleLinear as X, scaleQuantize as Y } from "d3";
+import { S as D, _ as B, d as w, e as O, s as J } from "../enums-a96ef472.mjs";
+import { b as tt } from "../_baseEach-603421de.mjs";
+import "../index-becfb567.mjs";
+function et(h, t, e, s) {
+  for (var a = -1, o = h == null ? 0 : h.length; ++a < o; ) {
+    var i = h[a];
+    t(s, i, e(i), h);
+  }
+  return s;
+}
+function st(h, t, e, s) {
+  return tt(h, function(a, o, i) {
+    t(s, a, e(a), i);
+  }), s;
+}
+function at(h, t) {
+  return function(e, s) {
+    var a = z(e) ? et : st, o = t ? t() : {};
+    return a(e, h, F(s), o);
+  };
+}
+function ot(h) {
+  for (var t = -1, e = h == null ? 0 : h.length, s = {}; ++t < e; ) {
+    var a = h[t];
+    s[a[0]] = a[1];
+  }
+  return s;
+}
+var it = Object.prototype, rt = it.hasOwnProperty, nt = at(function(h, t, e) {
+  rt.call(h, e) ? h[e].push(t) : U(h, e, [t]);
+});
+const lt = nt;
+class m {
+  constructor(t) {
+    this.state = {
+      options: {}
+    }, this.colorScale = {}, this.colorClassNames = {}, this.services = t;
+  }
+  getAllDataFromDomain(t) {
+    if (!this.getData())
+      return null;
+    const e = this.getOptions();
+    let s = this.getData();
+    const a = this.getDataGroups(), { groupMapsTo: o } = u(e, "data"), i = u(e, "axes");
+    return t && (s = s.filter((r) => t.includes(r[o]))), i && Object.keys(i).forEach((r) => {
+      const n = i[r].mapsTo, l = i[r].scaleType;
+      if ((l === D.LINEAR || l === D.LOG) && (s = s.map((c) => ({
+        ...c,
+        [n]: c[n] === null ? c[n] : Number(c[n])
+      }))), n && i[r].domain)
+        if (l === D.LABELS)
+          s = s.filter(
+            (c) => i[r].domain.includes(c[n])
+          );
+        else {
+          const [c, p] = i[r].domain;
+          s = s.filter(
+            (g) => !(n in g) || g[n] >= c && g[n] <= p
+          );
+        }
+    }), s.filter((r) => a.find((n) => n.name === r[o]));
+  }
+  /**
+   * Charts that have group configs passed into them, only want to retrieve the display data relevant to that chart
+   * @param groups the included datasets for the particular chart
+   */
+  getDisplayData(t) {
+    if (!this.get("data"))
+      return null;
+    const { ACTIVE: e } = S.items.status, s = this.getDataGroups(t), { groupMapsTo: a } = this.getOptions().data;
+    return this.getAllDataFromDomain(t).filter((i) => s.find(
+      (r) => r.name === i[a] && r.status === e
+    ));
+  }
+  getData() {
+    return this.get("data");
+  }
+  isDataEmpty() {
+    return !this.getData().length;
+  }
+  /**
+   *
+   * @param newData The new raw data to be set
+   */
+  setData(t) {
+    const e = this.sanitize(G(t)), s = this.generateDataGroups(e);
+    return this.set({
+      data: e,
+      dataGroups: s
+    }), e;
+  }
+  getDataGroups(t) {
+    return u(this.getOptions(), "data", "loading") ? [] : t ? this.get("dataGroups").filter((s) => t.includes(s.name)) : this.get("dataGroups");
+  }
+  getActiveDataGroups(t) {
+    const { ACTIVE: e } = S.items.status;
+    return this.getDataGroups(t).filter((s) => s.status === e);
+  }
+  getDataGroupNames(t) {
+    return this.getDataGroups(t).map((s) => s.name);
+  }
+  getActiveDataGroupNames(t) {
+    return this.getActiveDataGroups(t).map((s) => s.name);
+  }
+  aggregateBinDataByGroup(t) {
+    return lt(t, "group");
+  }
+  getBinConfigurations() {
+    const t = this.getDisplayData(), e = this.getOptions(), s = this.services.cartesianScales.getMainXAxisPosition(), a = this.services.cartesianScales.getDomainIdentifier(), o = e.axes[s], { groupMapsTo: i } = e.data, { bins: r = j.defaultBins } = o, n = Array.isArray(r), l = Z().value((d) => d[a]).thresholds(r)(t);
+    if (n)
+      l[l.length - 1].x1 = r[r.length - 1];
+    else {
+      const d = l[0].x1 - l[0].x0;
+      l[l.length - 1].x1 = +l[l.length - 1].x0 + d;
+    }
+    const c = n ? [r[0], r[r.length - 1]] : [l[0].x0, l[l.length - 1].x1], p = Array.from(new Set(t.map((d) => d[i]))), g = [];
+    return l.forEach((d) => {
+      const f = `${d.x0}-${d.x1}`, b = this.aggregateBinDataByGroup(d);
+      p.forEach((C) => {
+        g.push({
+          group: C,
+          key: f,
+          value: b[C] || 0,
+          bin: d.x0
+        });
+      });
+    }), {
+      bins: l,
+      binsDomain: c
+    };
+  }
+  getBinnedStackedData() {
+    const t = this.getOptions(), { groupMapsTo: e } = t.data, s = this.getActiveDataGroupNames(), { bins: a } = this.getBinConfigurations(), o = this.getDataValuesGroupedByKeys({
+      bins: a
+    });
+    return A().keys(s)(o).map((i, r) => Object.keys(i).filter((n) => !isNaN(n)).map((n) => {
+      const l = i[n];
+      return l[e] = s[r], l;
+    }));
+  }
+  getGroupedData(t) {
+    const e = this.getDisplayData(t), s = {}, { groupMapsTo: a } = this.getOptions().data;
+    return e.map((o) => {
+      const i = o[a];
+      s[i] !== null && s[i] !== void 0 ? s[i].push(o) : s[i] = [o];
+    }), Object.keys(s).map((o) => ({
+      name: o,
+      data: s[o]
+    }));
+  }
+  getStackKeys({ bins: t = null, groups: e = null } = { bins: null, groups: null }) {
+    const s = this.getOptions(), a = this.getDisplayData(e);
+    let o;
+    t ? o = t.map((n) => `${n.x0}-${n.x1}`) : o = M(
+      a.map((n) => {
+        const l = this.services.cartesianScales.getDomainIdentifier(n);
+        return n[l] instanceof Date ? k(n[l]) : n[l] && typeof n[l].toString == "function" ? n[l].toString() : n[l];
+      })
+    );
+    const i = this.services.cartesianScales.domainAxisPosition, r = s.axes[i].scaleType;
+    return r === D.TIME ? o.sort((n, l) => {
+      const c = new Date(n), p = new Date(l);
+      return c - p;
+    }) : (r === D.LOG || r === D.LINEAR) && o.sort((n, l) => n - l), o;
+  }
+  getDataValuesGroupedByKeys({ bins: t = null, groups: e = null }) {
+    const s = this.getOptions(), { groupMapsTo: a } = s.data, o = this.getDisplayData(e), i = this.getDataGroupNames(), r = this.getStackKeys({ bins: t, groups: e });
+    return t ? r.map((n) => {
+      const [l, c] = n.split("-"), p = { x0: l, x1: c }, g = t.find((d) => d.x0.toString() === l.toString());
+      return i.forEach((d) => {
+        p[d] = g.filter(
+          (f) => f[a] === d
+        ).length;
+      }), p;
+    }) : r.map((n) => {
+      const l = { sharedStackKey: n };
+      return i.forEach((c) => {
+        const p = o.find((d) => {
+          const f = this.services.cartesianScales.getDomainIdentifier(d);
+          return d[a] === c && Object.prototype.hasOwnProperty.call(d, f) && (d[f] instanceof Date ? k(d[f]) === n : d[f].toString() === n);
+        }), g = this.services.cartesianScales.getRangeIdentifier(l);
+        l[c] = p ? p[g] : null;
+      }), l;
+    });
+  }
+  getStackedData({ percentage: t = !1, groups: e = null, divergent: s = !1 }) {
+    const a = this.getOptions(), { groupMapsTo: o } = a.data, i = this.getActiveDataGroupNames(e), r = this.getDataValuesGroupedByKeys({
+      groups: e
+    });
+    if (t) {
+      const l = ot(r.map((c) => [c.sharedStackKey, 0]));
+      r.forEach((c) => {
+        i.forEach((p) => {
+          l[c.sharedStackKey] += c[p];
+        });
+      }), r.forEach((c) => {
+        i.forEach((p) => {
+          const g = l[c.sharedStackKey];
+          l[c.sharedStackKey] ? c[p] = c[p] / g * 100 : c[p] = 0;
+        });
+      });
+    }
+    return (s ? A().offset(H) : A()).keys(i)(r).map((l, c) => Object.keys(l).filter((p) => !isNaN(p)).map((p) => {
+      const g = l[p];
+      return g[o] = i[c], g;
+    }));
+  }
+  /**
+   * @return {Object} The chart's options
+   */
+  getOptions() {
+    return this.state.options;
+  }
+  set(t, e) {
+    this.state = Object.assign({}, this.state, t);
+    const s = Object.assign(
+      { skipUpdate: !1, animate: !0 },
+      // default configs
+      e
+    );
+    s.skipUpdate || this.update(s.animate);
+  }
+  get(t) {
+    return t ? this.state[t] : this.state;
+  }
+  /**
+   *
+   * @param newOptions New options to be set
+   */
+  setOptions(t) {
+    const e = this.getOptions();
+    L(e, t), this.set({
+      options: _(e, t)
+    });
+  }
+  /**
+   *
+   * Updates miscellanous information within the model
+   * such as the color scales, or the legend data labels
+   */
+  update(t = !0) {
+    this.getDisplayData() && (this.updateAllDataGroups(), this.setCustomColorScale(), this.setColorClassNames(), this.services.events.dispatchEvent(B.Model.UPDATE, { animate: t }));
+  }
+  /*
+   * Data labels
+   */
+  toggleDataLabel(t) {
+    const { ACTIVE: e, DISABLED: s } = S.items.status, a = this.getDataGroups(), o = a.some((c) => c.status === s), i = a.filter((c) => c.status === e);
+    if (o)
+      if (i.length === 1 && i[0].name === t)
+        a.forEach((c, p) => {
+          a[p].status = e;
+        });
+      else {
+        const c = a.findIndex((p) => p.name === t);
+        a[c].status = a[c].status === s ? e : s;
+      }
+    else
+      a.forEach((c, p) => {
+        a[p].status = c.name === t ? e : s;
+      });
+    const r = a.filter((c) => c.status === e), n = this.getOptions();
+    a.some((c) => c.status === s) ? n.data.selectedGroups = r.map((c) => c.name) : n.data.selectedGroups = [], this.services.events.dispatchEvent(B.Legend.ITEMS_UPDATE, {
+      dataGroups: a
+    }), this.set({
+      dataGroups: a
+    });
+  }
+  /**
+   * Should the data point be filled?
+   * @param group
+   * @param key
+   * @param value
+   * @param defaultFilled the default for this chart
+   */
+  getIsFilled(t, e, s, a) {
+    const o = this.getOptions();
+    return o.getIsFilled ? o.getIsFilled(t, e, s, a) : a;
+  }
+  getFillColor(t, e, s) {
+    const a = this.getOptions(), o = u(this.colorScale, t);
+    return a.getFillColor ? a.getFillColor(t, e, s, o) : o;
+  }
+  getStrokeColor(t, e, s) {
+    const a = this.getOptions(), o = u(this.colorScale, t);
+    return a.getStrokeColor ? a.getStrokeColor(t, e, s, o) : o;
+  }
+  isUserProvidedColorScaleValid() {
+    const t = u(this.getOptions(), "color", "scale"), e = this.getDataGroups();
+    return t == null || Object.keys(t).length == 0 ? !1 : e.some(
+      (s) => Object.keys(t).includes(s.name)
+    );
+  }
+  getColorClassName(t) {
+    const e = this.colorClassNames(t.dataGroupName);
+    let s = t.originalClassName;
+    return t.classNameTypes.forEach(
+      (a) => s = t.originalClassName ? `${s} ${a}-${e}` : `${a}-${e}`
+    ), s || "";
+  }
+  /**
+   * For charts that might hold an associated status for their dataset
+   */
+  getStatus() {
+    return null;
+  }
+  getAllDataGroupsNames() {
+    return this.allDataGroups;
+  }
+  /**
+   * Converts data provided in the older format to tabular
+   *
+   */
+  transformToTabularData(t) {
+    console.warn(
+      "We've updated the charting data format to be tabular by default. The current format you're using is deprecated and will be removed in v1.0, read more here https://carbon-design-system.github.io/carbon-charts/?path=/story/docs-tutorials--tabular-data-format"
+    );
+    const e = [], { datasets: s, labels: a } = t;
+    return s.forEach((o) => {
+      o.data.forEach((i, r) => {
+        let n;
+        const l = u(o, "label");
+        if (l === null) {
+          const p = u(a, r);
+          p ? n = p : n = "Ungrouped";
+        } else
+          n = l;
+        const c = {
+          group: n,
+          key: a[r]
+        };
+        isNaN(i) ? (c.value = i.value, c.date = i.date) : c.value = i, e.push(c);
+      });
+    }), e;
+  }
+  getTabularDataArray() {
+    return [];
+  }
+  exportToCSV() {
+    const t = this.getTabularDataArray().map(
+      (a) => a.map((o) => `"${o === "&ndash;" ? "–" : o}"`)
+    );
+    let e = "", s = "";
+    t.forEach(function(a, o) {
+      s = a.join(","), e += o < t.length ? s + `
+` : s;
+    }), this.services.files.downloadCSV(e, "myChart.csv");
+  }
+  getTabularData(t) {
+    return Array.isArray(t) ? t : this.transformToTabularData(t);
+  }
+  sanitize(t) {
+    return t = this.getTabularData(t), t;
+  }
+  /*
+   * Data groups
+   */
+  updateAllDataGroups() {
+    this.allDataGroups ? this.getDataGroupNames().forEach((t) => {
+      this.allDataGroups.indexOf(t) === -1 && this.allDataGroups.push(t);
+    }) : this.allDataGroups = this.getDataGroupNames();
+  }
+  generateDataGroups(t) {
+    const { groupMapsTo: e } = this.getOptions().data, { ACTIVE: s, DISABLED: a } = S.items.status, o = this.getOptions(), i = M(t.map((n) => n[e]));
+    o.data.selectedGroups.length && (o.data.selectedGroups.every(
+      (l) => i.includes(l)
+    ) || (o.data.selectedGroups = []));
+    const r = (n) => !o.data.selectedGroups.length || o.data.selectedGroups.includes(n) ? s : a;
+    return i.map((n) => ({
+      name: n,
+      status: r(n)
+    }));
+  }
+  /*
+   * Fill scales
+   */
+  setCustomColorScale() {
+    if (!this.isUserProvidedColorScaleValid())
+      return;
+    const t = this.getOptions(), e = u(t, "color", "scale");
+    Object.keys(e).forEach((a) => {
+      this.allDataGroups.includes(a) || console.warn(`"${a}" does not exist in data groups.`);
+    }), this.allDataGroups.filter(
+      (a) => e[a]
+    ).forEach(
+      (a) => this.colorScale[a] = e[a]
+    );
+  }
+  /*
+   * Color palette
+   */
+  setColorClassNames() {
+    const t = u(this.getOptions(), "color", "pairing");
+    let e = u(t, "numberOfVariants");
+    (!e || e < this.allDataGroups.length) && (e = this.allDataGroups.length);
+    let s = u(t, "option");
+    const a = V.pairingOptions, o = e > 5 ? 14 : e, i = `${o}-color`;
+    s = s <= a[i] ? s : 1;
+    const r = this.allDataGroups.map(
+      (n, l) => `${o}-${s}-${l % 14 + 1}`
+    );
+    this.colorClassNames = $().range(r).domain(this.allDataGroups);
+  }
+}
+class T extends m {
+  // can't be protected as it's used by two-dimensional-axes.ts
+  constructor(t) {
+    super(t), this.axisFlavor = w.DEFAULT;
+  }
+  // get the scales information
+  // needed for getTabularArray()
+  assignRangeAndDomains() {
+    const { cartesianScales: t } = this.services, e = this.getOptions(), s = t.isDualAxes(), a = {
+      primaryDomain: t.domainAxisPosition,
+      primaryRange: t.rangeAxisPosition,
+      secondaryDomain: null,
+      secondaryRange: null
+    };
+    return s && (a.secondaryDomain = t.secondaryDomainAxisPosition, a.secondaryRange = t.secondaryRangeAxisPosition), Object.keys(a).forEach((o) => {
+      const i = a[o];
+      t.scales[i] ? a[o] = {
+        position: i,
+        label: t.getScaleLabel(i),
+        identifier: u(e, "axes", i, "mapsTo")
+      } : a[o] = null;
+    }), a;
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData(), e = this.getOptions(), { groupMapsTo: s } = e.data, { cartesianScales: a } = this.services, { primaryDomain: o, primaryRange: i, secondaryDomain: r, secondaryRange: n } = this.assignRangeAndDomains(), l = a.getDomainAxisScaleType();
+    let c;
+    return l === D.TIME && (c = (g) => K(g, "MMM d, yyyy")), [
+      [
+        "Group",
+        o.label,
+        i.label,
+        ...r ? [r.label] : [],
+        ...n ? [n.label] : []
+      ],
+      ...t.map((g) => [
+        g[s],
+        g[o.identifier] === null ? "&ndash;" : c ? c(g[o.identifier]) : g[o.identifier],
+        g[i.identifier] === null || isNaN(g[i.identifier]) ? "&ndash;" : g[i.identifier].toLocaleString(),
+        ...r ? [
+          g[r.identifier] === null ? "&ndash;" : g[r.identifier]
+        ] : [],
+        ...n ? [
+          g[n.identifier] === null || isNaN(g[n.identifier]) ? "&ndash;" : g[n.identifier]
+        ] : []
+      ])
+    ];
+  }
+  setData(t) {
+    let e;
+    if (t && (e = super.setData(t), u(this.getOptions(), "zoomBar", O.TOP, "enabled"))) {
+      const s = u(
+        this.getOptions(),
+        "zoomBar",
+        O.TOP,
+        "data"
+      );
+      this.setZoomBarData(s);
+    }
+    return e;
+  }
+  /**
+   * @param zoomBarData any special zoom bar data to use instead of the model data
+   */
+  setZoomBarData(t) {
+    const e = t ? this.sanitize(G(t)) : this.getDisplayData();
+    let s = e;
+    const { cartesianScales: a } = this.services;
+    if (e && a.domainAxisPosition && a.rangeAxisPosition) {
+      const o = a.getDomainIdentifier(), i = a.getRangeIdentifier();
+      let r = e.map((n) => n[o].getTime());
+      r = M(r).sort(), s = r.map((n) => {
+        let l = 0;
+        const c = {};
+        return e.forEach((p) => {
+          p[o].getTime() === n && (l += p[i]);
+        }), c[o] = new Date(n), c[i] = l, c;
+      });
+    }
+    this.set({ zoomBarData: s });
+  }
+  getZoomBarData() {
+    return this.get("zoomBarData");
+  }
+  sanitizeDateValues(t) {
+    const e = this.getOptions();
+    if (!e.axes)
+      return t;
+    const s = [];
+    return Object.keys(O).forEach((a) => {
+      const o = O[a], i = e.axes[o];
+      if (i && i.scaleType === D.TIME) {
+        const r = i.mapsTo;
+        (r !== null || r !== void 0) && s.push(r);
+      }
+    }), s.length > 0 && t.forEach((a) => {
+      s.forEach((o) => {
+        u(a, o, "getTime") === null && (a[o] = new Date(a[o]));
+      });
+    }), t;
+  }
+  sanitize(t) {
+    return t = super.sanitize(t), t = this.sanitizeDateValues(t), t;
+  }
+}
+class dt extends T {
+  constructor(t) {
+    super(t);
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData();
+    return t.sort((s, a) => s.source.localeCompare(a.source)), [
+      ["Source", "Target", "Value"],
+      ...t.map((s) => [s.source, s.target, s.value])
+    ];
+  }
+}
+class Dt extends T {
+  constructor(t) {
+    super(t);
+  }
+  getBoxQuartiles(t) {
+    return {
+      q_25: E(t, 0.25),
+      q_50: E(t, 0.5),
+      q_75: E(t, 0.75)
+    };
+  }
+  getBoxplotData() {
+    const t = this.getOptions(), { groupMapsTo: e } = t.data, s = this.getGroupedData(), a = [];
+    for (const { name: o, data: i } of s) {
+      const r = this.services.cartesianScales.getRangeIdentifier(), n = i.map((v) => v[r]).sort(Q), l = {
+        [e]: o,
+        counts: n,
+        quartiles: this.getBoxQuartiles(n),
+        outliers: null,
+        whiskers: null
+      }, c = l.quartiles.q_25, p = l.quartiles.q_75, g = (p - c) * 1.5, d = c - g, f = p + g, b = [], C = [];
+      for (const v of n)
+        v < d || v > f ? b.push(v) : C.push(v);
+      l.outliers = b;
+      const I = P(C), q = N(C);
+      l.whiskers = {
+        min: I || P([l.quartiles.q_25, l.quartiles.q_50, l.quartiles.q_75]),
+        max: q || N([l.quartiles.q_25, l.quartiles.q_50, l.quartiles.q_75])
+      }, a.push(l);
+    }
+    return a;
+  }
+  getTabularDataArray() {
+    const t = this.getOptions(), { groupMapsTo: e } = t.data, s = this.getBoxplotData();
+    return [
+      ["Group", "Minimum", "Q1", "Median", "Q3", "Maximum", "IQR", "Outlier(s)"],
+      ...s.map((o) => {
+        let i = u(o, "outliers");
+        return (i === null || i.length === 0) && (i = ["&ndash;"]), [
+          o[e],
+          u(o, "whiskers", "min") !== null ? u(o, "whiskers", "min").toLocaleString() : "&ndash;",
+          u(o, "quartiles", "q_25") !== null ? u(o, "quartiles", "q_25").toLocaleString() : "&ndash;",
+          u(o, "quartiles", "q_50") !== null ? u(o, "quartiles", "q_50").toLocaleString() : "&ndash;",
+          u(o, "quartiles", "q_75") !== null ? u(o, "quartiles", "q_75").toLocaleString() : "&ndash;",
+          u(o, "whiskers", "max") !== null ? u(o, "whiskers", "max").toLocaleString() : "&ndash;",
+          u(o, "quartiles", "q_75") !== null && u(o, "quartiles", "q_25") !== null ? (u(o, "quartiles", "q_75") - u(o, "quartiles", "q_25")).toLocaleString() : "&ndash;",
+          i.map((r) => r.toLocaleString()).join(",")
+        ];
+      })
+    ];
+  }
+  setColorClassNames() {
+    const e = u(this.getOptions(), "color", "pairing");
+    let s = u(e, "option");
+    const a = V.pairingOptions;
+    s = s <= a["1-color"] ? s : 1;
+    const o = this.allDataGroups.map(() => `1-${s}-1`);
+    this.colorClassNames = $().range(o).domain(this.allDataGroups);
+  }
+}
+class ft extends T {
+  constructor(t) {
+    super(t);
+  }
+  /**
+   * Determines the index of the performance area titles to use
+   * @param datum
+   * @returns number
+   */
+  getMatchingRangeIndexForDatapoint(t) {
+    let e;
+    for (let s = t.ranges.length - 1; s > 0; s--) {
+      const a = t.ranges[s];
+      if (t.value >= a)
+        return e = s, e;
+    }
+    return 0;
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData(), e = this.getOptions(), { groupMapsTo: s } = e.data, a = this.services.cartesianScales.getRangeIdentifier(), o = u(e, "bullet", "performanceAreaTitles");
+    return [
+      ["Title", "Group", "Value", "Target", "Percentage", "Performance"],
+      ...t.map((r) => [
+        r.title,
+        r[s],
+        r.value === null ? "&ndash;" : r.value,
+        u(r, "marker") === null ? "&ndash;" : r.marker,
+        u(r, "marker") === null ? "&ndash;" : `${Math.floor(r[a] / r.marker * 100)}%`,
+        o[this.getMatchingRangeIndexForDatapoint(r)]
+      ])
+    ];
+  }
+}
+class mt extends m {
+  constructor(t) {
+    super(t), this._colorScale = void 0, this._matrix = {};
+  }
+  /**
+   * @override
+   * @param value
+   * @returns string
+   */
+  getFillColor(t) {
+    return this._colorScale(t);
+  }
+  /**
+   * Helper function that will generate a dictionary
+   */
+  getCombinedData() {
+    if (y(this._matrix)) {
+      const t = this.getOptions(), e = this.getDisplayData();
+      !y(e) && !y(t.geoData.objects.countries) && (t.geoData.objects.countries.geometries.forEach((s) => {
+        this._matrix[s.properties.NAME] = s;
+      }), e.forEach((s) => {
+        this._matrix[s.name] ? this._matrix[s.name].value = s.value || null : console.warn(`Data point ${s} is missing geographical data.`);
+      }));
+    }
+    return this._matrix;
+  }
+  /**
+   * Generate tabular data from display data
+   * @returns Array<Object>
+   */
+  getTabularDataArray() {
+    const t = this.getDisplayData();
+    return [
+      ["Country ID", "Country Name", "Value"],
+      ...t.map((s) => [
+        s.id === null ? "&ndash;" : s.id,
+        s.name,
+        s.value
+      ])
+    ];
+  }
+  // Uses quantize scale to return class names
+  getColorClassName(t) {
+    return `${t.originalClassName} ${this._colorScale(t.value)}`;
+  }
+  setColorClassNames() {
+    const t = u(this.getOptions(), "color");
+    this._colorScale = R(this.getDisplayData(), t);
+  }
+}
+class yt extends m {
+  constructor(t) {
+    super(t), this.parentNode = !1, this.set({ depth: 2 }, { skipUpdate: !0 });
+  }
+  setData(t) {
+    super.setData(t), this.setDataGroups(), t.length === 1 && (this.parentNode = !0), this.setZoom();
+  }
+  setOptions(t) {
+    const e = this.getOptions(), s = _({}, t, this.getZoomOptions(t));
+    L(e, s);
+    const a = this.getHierarchyLevel(), o = u(e, "circlePack", "hierarchyLevel");
+    this.set({
+      options: _(e, s),
+      depth: o && o < 4 ? o : a
+    });
+  }
+  getZoomOptions(t) {
+    if (!this.getDisplayData())
+      return {};
+    const e = this.getDisplayData(), s = t || this.getOptions(), a = e.length === 1 && u(e, 0, "children") ? u(e, 0, "children") : e;
+    let o = this.getHierarchyLevel();
+    return a.some((i) => {
+      if (i.children && i.children.some((r) => r.children))
+        return o = 3, !1;
+    }), u(s, "canvasZoom", "enabled") === !0 && o > 2 ? {
+      legend: {
+        additionalItems: [
+          {
+            type: J.ZOOM,
+            name: "Click to zoom"
+          }
+        ]
+      }
+    } : null;
+  }
+  setZoom(t) {
+    this.setOptions(this.getZoomOptions(t));
+  }
+  // update the hierarchy level
+  updateHierarchyLevel(t) {
+    this.set({ depth: t });
+  }
+  getHierarchyLevel() {
+    return this.get("depth");
+  }
+  hasParentNode() {
+    return this.parentNode;
+  }
+  // set the datagroup name on the items that are it's children
+  setDataGroups() {
+    const t = this.getData(), e = this.getOptions(), { groupMapsTo: s } = e.data, a = t.map((o) => {
+      const i = o[s];
+      return this.setChildrenDataGroup(o, i);
+    });
+    this.set(
+      {
+        data: a
+      },
+      { skipUpdate: !0 }
+    );
+  }
+  // sets name recursively down the node tree
+  setChildrenDataGroup(t, e) {
+    return t.children ? {
+      ...t,
+      dataGroupName: e,
+      children: t.children.map((s) => this.setChildrenDataGroup(s, e))
+    } : { ...t, dataGroupName: e };
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData(), e = [["Child", "Parent", "Value"]];
+    return t.forEach((s) => {
+      let a = s.value ? s.value : 0;
+      s.children && (a += this.getChildrenDatums(s.children, s.name, e, 0)), e.push(["&ndash;", s.name, a]);
+    }), e;
+  }
+  /**
+   * Recursively determine the relationship between all the nested elements in the child
+   * @param children: Object
+   * @param parent: String
+   * @param result: Array<Object>
+   * @param totalSum: number
+   * @returns: number
+   */
+  getChildrenDatums(t, e, s = [], a = 0) {
+    const o = e;
+    return t.forEach((i) => {
+      const r = i.name;
+      let n = 0;
+      if (i.children)
+        i.children.length > 0 && (typeof i.value == "number" && (a += i.value), n += this.getChildrenDatums(i.children, r, s, n), s.push([r, o, n]), a += n);
+      else {
+        let l = 0;
+        typeof i.value == "number" && (l = i.value, a += i.value), s.push([i.name, o, l]);
+      }
+    }), a;
+  }
+}
+class vt extends m {
+  constructor(t) {
+    super(t);
+  }
+  getTabularData(t) {
+    const e = super.getTabularData(t);
+    return t !== e && e.forEach((s) => {
+      s.key && s.key !== s.group && (s.group = s.key);
+    }), e;
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData(), e = this.getOptions(), { groupMapsTo: s } = e.data;
+    return [
+      ["Group", "Value"],
+      ...t.map((o) => [
+        o[s],
+        o.value === null ? "&ndash;" : o.value.toLocaleString()
+      ])
+    ];
+  }
+  sanitize(t) {
+    return this.getTabularData(t).sort((s, a) => a.value - s.value);
+  }
+}
+class xt extends m {
+  constructor(t) {
+    super(t);
+  }
+  getDataGroups() {
+    return super.getDataGroups().filter((t) => t.name !== "delta");
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData(), e = this.getOptions(), { groupMapsTo: s } = e.data;
+    return [
+      ["Group", "Value"],
+      ...t.map((o) => [
+        o[s],
+        o.value === null ? "&ndash;" : o.value.toLocaleString()
+      ])
+    ];
+  }
+}
+class Ct extends T {
+  constructor(t) {
+    super(t), this.axisFlavor = w.HOVERABLE, this._colorScale = void 0, this._domains = [], this._ranges = [], this._matrix = {};
+    const e = u(this.getOptions(), "axes");
+    if (u(e, "left", "scaleType") && u(e, "left", "scaleType") !== D.LABELS || u(e, "right", "scaleType") && u(e, "right", "scaleType") !== D.LABELS || u(e, "top", "scaleType") && u(e, "top", "scaleType") !== D.LABELS || u(e, "bottom", "scaleType") && u(e, "bottom", "scaleType") !== D.LABELS)
+      throw Error("Heatmap only supports label scaletypes.");
+  }
+  /**
+   * Get min and maximum value of the display data
+   * @returns Array consisting of smallest and largest values in  data
+   */
+  getValueDomain() {
+    const t = W(this.getDisplayData(), (s) => s.value), e = X().domain(t).nice().domain();
+    if (e[0] > 0)
+      e[0] = 0;
+    else if (e[0] === 0 && e[1] === 0)
+      return [0, 1];
+    return e[0] < 0 && e[1] > 0 && (Math.abs(e[0]) > e[1] ? e[1] = Math.abs(e[0]) : e[0] = -e[1]), e;
+  }
+  /**
+   * @override
+   * @param value
+   * @returns string
+   */
+  getFillColor(t) {
+    return this._colorScale(t);
+  }
+  /**
+   * Generate a list of all unique domains
+   * @returns String[]
+   */
+  getUniqueDomain() {
+    if (y(this._domains)) {
+      const t = this.getDisplayData(), { cartesianScales: e } = this.services, s = e.getDomainIdentifier(), a = e.getMainXAxisPosition(), o = e.getCustomDomainValuesByposition(a);
+      if (o)
+        return o;
+      this._domains = Array.from(
+        new Set(
+          t.map((i) => i[s])
+        )
+      );
+    }
+    return this._domains;
+  }
+  /**
+   * Generates a list of all unique ranges
+   * @returns String[]
+   */
+  getUniqueRanges() {
+    if (y(this._ranges)) {
+      const t = this.getDisplayData(), { cartesianScales: e } = this.services, s = e.getRangeIdentifier(), a = e.getMainYAxisPosition(), o = e.getCustomDomainValuesByposition(a);
+      if (o)
+        return o;
+      this._ranges = Array.from(
+        new Set(
+          t.map((i) => i[s])
+        )
+      );
+    }
+    return this._ranges;
+  }
+  /**
+   * Generates a matrix (If doesn't exist) and returns it
+   * @returns Object
+   */
+  getMatrix() {
+    if (y(this._matrix)) {
+      const t = this.getUniqueDomain(), e = this.getUniqueRanges(), s = this.services.cartesianScales.getDomainIdentifier(), a = this.services.cartesianScales.getRangeIdentifier(), o = {};
+      e.forEach((i) => {
+        o[i] = {
+          value: null,
+          index: -1
+        };
+      }), t.forEach((i) => {
+        this._matrix[i] = G(o);
+      }), this.getDisplayData().forEach((i, r) => {
+        this._matrix[i[s]][i[a]] = {
+          value: i.value,
+          index: r
+        };
+      });
+    }
+    return this._matrix;
+  }
+  /**
+   *
+   * @param newData The new raw data to be set
+   */
+  setData(t) {
+    const e = this.sanitize(G(t)), s = this.generateDataGroups(e);
+    return this.set({
+      data: e,
+      dataGroups: s
+    }), this._domains = [], this._ranges = [], this._matrix = {}, e;
+  }
+  /**
+   * Converts Object matrix into a single array
+   * @returns object[]
+   */
+  getMatrixAsArray() {
+    y(this._matrix) && this.getMatrix();
+    const t = this.getUniqueDomain(), e = this.getUniqueRanges(), s = this.services.cartesianScales.getDomainIdentifier(), a = this.services.cartesianScales.getRangeIdentifier(), o = [];
+    return t.forEach((i) => {
+      e.forEach((r) => {
+        const n = {
+          value: this._matrix[i][r].value,
+          index: this._matrix[i][r].index
+        };
+        n[s] = i, n[a] = r, o.push(n);
+      });
+    }), o;
+  }
+  /**
+   * Generate tabular data from display data
+   * @returns Array<Object>
+   */
+  getTabularDataArray() {
+    const t = this.getDisplayData(), { primaryDomain: e, primaryRange: s } = this.assignRangeAndDomains();
+    return [
+      [e.label, s.label, "Value"],
+      ...t.map((o) => [
+        o[e.identifier] === null ? "&ndash;" : o[e.identifier],
+        o[s.identifier] === null ? "&ndash;" : o[s.identifier].toLocaleString(),
+        o.value
+      ])
+    ];
+  }
+  // Uses quantize scale to return class names
+  getColorClassName(t) {
+    return `${t.originalClassName} ${this._colorScale(t.value)}`;
+  }
+  setColorClassNames() {
+    const t = this.getOptions(), e = u(t, "color", "gradient", "colors"), s = !y(e);
+    let a = u(t, "color", "pairing", "option");
+    const o = this.getValueDomain(), i = o[0] < 0 && o[1] > 0 ? "diverge" : "mono";
+    (a < 1 && a > 4 && i === "mono" || a < 1 && a > 2 && i === "diverge") && (a = 1);
+    const r = s ? e : [];
+    if (!s) {
+      const l = i === "diverge" ? 17 : 11;
+      for (let c = 1; c < l + 1; c++)
+        r.push(`fill-${i}-${a}-${c}`);
+    }
+    this._colorScale = Y().domain(o).range(r);
+    const n = u(this.getOptions(), "color");
+    this._colorScale = R(this.getDisplayData(), n);
+  }
+}
+class Tt extends T {
+  getTabularDataArray() {
+    const t = this.getOptions(), { groupMapsTo: e } = t.data, s = this.getBinnedStackedData();
+    return [
+      [
+        x(t, "bins.rangeLabel") || "Range",
+        ...s.map((o) => x(o, `0.${e}`))
+      ],
+      ...x(s, 0).map((o, i) => [
+        `${x(o, "data.x0")} – ${x(o, "data.x1")}`,
+        ...s.map((r) => x(r[i], `data.${x(r[i], e)}`))
+      ])
+    ];
+  }
+}
+class bt extends m {
+  constructor(t) {
+    super(t);
+  }
+  getMaximumDomain(t) {
+    return t.reduce((s, a) => s + a.value, 0);
+  }
+  /**
+   * Use a provided color for the bar or default to carbon color if no status provided.
+   * Defaults to carbon color otherwise.
+   * @param group dataset group label
+   */
+  getFillColor(t) {
+    const e = this.getOptions(), s = u(e, "color", "scale"), a = this.getStatus();
+    return s || !a ? super.getFillColor(t) : null;
+  }
+  /**
+   * Get the associated status for the data by checking the ranges
+   */
+  getStatus() {
+    const t = this.getOptions(), e = u(this.getDisplayData()), { value: s } = e ? e.reduce((i, r) => ({ value: i.value + r.value })) : 0, a = u(t, "meter", "proportional") ? s : s > 100 ? 100 : s, o = u(t, "meter", "status", "ranges");
+    if (o) {
+      const i = o.filter(
+        (r) => r.range[0] <= a && a <= r.range[1]
+      );
+      if (i.length > 0)
+        return i[0].status;
+    }
+    return null;
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData(), e = this.getOptions(), { groupMapsTo: s } = e.data, a = this.getStatus(), o = u(e, "meter", "proportional");
+    let i = [], r;
+    if (o === null) {
+      r = 100;
+      const n = t[0];
+      i = [
+        ["Group", "Value", ...a ? ["Status"] : []],
+        [n[s], n.value, ...a ? [a] : []]
+      ];
+    } else {
+      const n = u(o, "total");
+      r = n || this.getMaximumDomain(t), i = [
+        ["Group", "Value", "Percentage of total"],
+        ...t.map((l) => [
+          l[s],
+          l.value,
+          (l.value / r * 100).toFixed(2) + " %"
+        ])
+      ];
+    }
+    return i;
+  }
+}
+class St extends T {
+  constructor(t) {
+    super(t);
+  }
+  getTabularDataArray() {
+    const t = this.getOptions(), e = this.getGroupedData(), { angle: s, value: a } = u(t, "radar", "axes"), o = u(e, "0", "data").map((r) => r[s]);
+    return [
+      ["Group", ...o],
+      ...e.map((r) => [
+        r.name,
+        ...o.map(
+          (n, l) => u(r, "data", l, a) !== null ? u(r, "data", l, a).toLocaleString() : "&ndash;"
+        )
+      ])
+    ];
+  }
+}
+class Ot extends m {
+  constructor(t) {
+    super(t);
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData(), e = [["Child", "Parent"]];
+    return t.forEach((s) => {
+      this.getChildrenDatums(s, e), e.push([s.name, "&ndash;"]);
+    }), e;
+  }
+  /**
+   * Determine the child parent relationship in nested data
+   * @param datum: Object
+   * @param result: Array<Object>
+   */
+  getChildrenDatums(t, e = []) {
+    t.children && t.children.length > 0 && t.children.forEach((s) => {
+      this.getChildrenDatums(s, e), e.push([s.name, t.name]);
+    });
+  }
+}
+class Gt extends m {
+  constructor(t) {
+    super(t);
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData(), e = [["Child", "Group", "Value"]];
+    return t.forEach((s) => {
+      Array.isArray(s.children) ? s.children.forEach((a) => {
+        e.push([a.name, s.name, a.value]);
+      }) : u(s.name) !== null && u(s.value) && e.push(["–", s.name, s.value]);
+    }), e;
+  }
+}
+class At extends m {
+  constructor(t) {
+    super(t);
+  }
+  getTabularDataArray() {
+    const t = this.getDisplayData(), e = this.getOptions(), { fontSizeMapsTo: s, wordMapsTo: a } = e.wordCloud, { groupMapsTo: o } = e.data;
+    return [
+      [e.tooltip.wordLabel, "Group", e.tooltip.valueLabel],
+      ...t.map((r) => [
+        r[a],
+        r[o],
+        r[s]
+      ])
+    ];
+  }
+}
+export {
+  dt as AlluvialChartModel,
+  Dt as BoxplotChartModel,
+  ft as BulletChartModel,
+  m as ChartModel,
+  Tt as ChartModelBinned,
+  T as ChartModelCartesian,
+  mt as ChoroplethModel,
+  yt as CirclePackChartModel,
+  xt as GaugeChartModel,
+  Ct as HeatmapModel,
+  bt as MeterChartModel,
+  vt as PieChartModel,
+  St as RadarChartModel,
+  Ot as TreeChartModel,
+  Gt as TreemapChartModel,
+  At as WordCloudModel
+};
+//# sourceMappingURL=index.mjs.map