@devgateway/dvz-ui-react 1.0.0

package/dist/esm/embeddable/d3Map/Legends.js

@@ -0,0 +1,234 @@
+import { jsx as e, jsxs as l, Fragment as f } from "react/jsx-runtime";
+import { useRef as P } from "react";
+import { symbol as _ } from "prop-types";
+import j from "papaparse";
+const B = ({ breaks: n, isPoint: d }) => n.length > 0 && /* @__PURE__ */ e("div", { className: "legend-breaks", children: n.map((a, o) => a.type !== "graterThan" ? /* @__PURE__ */ l("div", { className: "break", children: [
+  /* @__PURE__ */ e(
+    "div",
+    {
+      className: `break-item ${d ? "point" : ""}`,
+      style: {
+        backgroundColor: a.color,
+        border: `1px solid ${a.borderColor}`
+      }
+    }
+  ),
+  /* @__PURE__ */ l("div", { className: "break-label", children: [
+    " < ",
+    a.end
+  ] })
+] }) : /* @__PURE__ */ l("div", { className: "break", children: [
+  /* @__PURE__ */ e(
+    "div",
+    {
+      className: `break-item ${_}`,
+      style: {
+        backgroundColor: a.color,
+        border: `1px solid ${a.borderColor}`
+      }
+    }
+  ),
+  /* @__PURE__ */ l("div", { className: "break-label", children: [
+    " > ",
+    a.end
+  ] })
+] })) }), M = (n) => {
+  const {
+    name: d,
+    breaks: a,
+    pointStyleBy: o,
+    dimension2: c,
+    pointDimensionStyles: s = {},
+    markFillColor: r,
+    markBorderColor: t,
+    measures: m,
+    visible: g,
+    id: v,
+    onItemClick: N,
+    customMeasuresLabels: k
+  } = n;
+  let b = m[0];
+  return k && (b = k[m[0]]), [...new Set(Object.keys(s).map((h) => h.split("_")[0]))], /* @__PURE__ */ e("div", { className: "legend", children: /* @__PURE__ */ l("div", { children: [
+    /* @__PURE__ */ l("div", { className: "legend-item", children: [
+      /* @__PURE__ */ e(
+        "div",
+        {
+          className: "legend-color legend-check",
+          onClick: (h) => N(v),
+          style: {
+            backgroundColor: r,
+            borderColor: t
+          },
+          children: g != !1 && /* @__PURE__ */ e(f, { children: "✓" })
+        }
+      ),
+      /* @__PURE__ */ l("div", { className: "legend-label", children: [
+        d,
+        " (",
+        b,
+        ")"
+      ] })
+    ] }),
+    g != !1 && /* @__PURE__ */ e(B, { breaks: a, symbol: "arrow" })
+  ] }) });
+}, R = (n) => {
+  const {
+    id: d,
+    name: a,
+    breaks: o,
+    pointStyleBy: c,
+    dimension2: s,
+    pointDimensionStyles: r = {},
+    markFillColor: t,
+    markBorderColor: m,
+    measures: g,
+    visible: v,
+    onItemClick: N,
+    customMeasuresLabels: k,
+    allCategories: b
+  } = n;
+  let h = g[0];
+  k && (h = k[g[0]]);
+  const L = s && b ? b.filter((i) => i.type.toUpperCase() == s.toUpperCase()) : [], C = (L.length > 0 ? L[0].items : []).map((i) => i.value), D = c === "dimension" ? s : h;
+  return /* @__PURE__ */ e("div", { className: "legend", children: /* @__PURE__ */ l("div", { children: [
+    /* @__PURE__ */ l("div", { className: "legend-item", children: [
+      /* @__PURE__ */ e(
+        "div",
+        {
+          className: "legend-color legend-check",
+          onClick: (i) => N(d),
+          style: {
+            backgroundColor: t,
+            borderColor: m
+          },
+          children: v != !1 && /* @__PURE__ */ e(f, { children: "✓" })
+        }
+      ),
+      /* @__PURE__ */ l("div", { className: "legend-label", children: [
+        a,
+        " "
+      ] })
+    ] }),
+    /* @__PURE__ */ e("div", { className: "legend", children: /* @__PURE__ */ e("div", { className: "legend-item", children: /* @__PURE__ */ e("div", { className: "legend-label", children: D }) }) }),
+    c === "dimension" && v != !1 && /* @__PURE__ */ e("div", { className: "legend-breaks", children: C.map((i) => /* @__PURE__ */ l("div", { className: "break", children: [
+      /* @__PURE__ */ e("div", { className: "break-item", style: {
+        backgroundColor: r[i + "_color"] || t,
+        border: `1px solid ${r[i + "_border"] || m}`
+      } }),
+      /* @__PURE__ */ e("div", { className: "break-label", children: i })
+    ] })) }),
+    c === "measure" && v != !1 && /* @__PURE__ */ e("div", { className: "legend-breaks", children: o.map((i, S) => /* @__PURE__ */ l("div", { className: "break", children: [
+      /* @__PURE__ */ e("div", { className: "break-item", style: {
+        backgroundColor: i.color,
+        border: `1px solid ${i.borderColor}`
+      } }),
+      /* @__PURE__ */ l("div", { className: "break-label", children: [
+        " < ",
+        i.end
+      ] })
+    ] })) })
+  ] }) });
+}, T = (n) => {
+  const { fillColor: d, borderColor: a, name: o, visible: c, id: s, onItemClick: r } = n;
+  return /* @__PURE__ */ e("div", { className: "legend", children: /* @__PURE__ */ l("div", { className: "legend-item", children: [
+    /* @__PURE__ */ e(
+      "div",
+      {
+        className: "legend-color legend-check",
+        onClick: (t) => r(s),
+        style: { backgroundColor: d, borderColor: a },
+        children: c != !1 && /* @__PURE__ */ e(f, { children: "✓" })
+      }
+    ),
+    /* @__PURE__ */ e("div", { className: "legend-label", children: o })
+  ] }) });
+}, U = (n) => {
+  const {
+    markFillColor: d,
+    fillColor: a,
+    markSizeScale: o,
+    markBorderColor: c,
+    useCentroidPoint: s,
+    name: r,
+    useBreaks: t,
+    breaks: m,
+    usePattern: g,
+    patternsData: v,
+    patternDiscriminator: N,
+    patternDiscriminatorLabel: k,
+    measures: b,
+    borderColor: h,
+    data: L,
+    app: $,
+    customMeasuresLabels: C,
+    divRef: D,
+    id: i,
+    patternWidth: S = 0.35,
+    patternHeight: q = 0.25,
+    group: I,
+    csv: w,
+    visible: y,
+    onItemClick: F
+  } = n;
+  let u = "";
+  if ($ != "csv" && C)
+    u = C[b[0]];
+  else {
+    const p = j.parse(w, { header: !0, dynamicTyping: !0 });
+    u = p.meta.fields.length > 0 ? p.meta.fields[1] : "";
+  }
+  const x = (p) => p ? p.toString().replace(/ /g, "_").toLocaleLowerCase() : "";
+  return /* @__PURE__ */ e("div", { className: `legend layer_${x(i)}`, id: x(`${I} ${r} ${i}`), children: /* @__PURE__ */ l("div", { children: [
+    /* @__PURE__ */ l("div", { className: "legend-item", children: [
+      /* @__PURE__ */ e(
+        "div",
+        {
+          className: "legend-color legend-check",
+          onClick: (p) => F(i),
+          style: { backgroundColor: a, borderColor: h },
+          children: y != !1 && /* @__PURE__ */ e(f, { children: "✓" })
+        }
+      ),
+      /* @__PURE__ */ l("div", { className: "legend-label", children: [
+        r,
+        " ",
+        !s && /* @__PURE__ */ l("span", { children: [
+          "(",
+          u,
+          ")"
+        ] })
+      ] })
+    ] }),
+    s && !t && y != !1 && /* @__PURE__ */ e("div", { className: "legend-breaks", children: /* @__PURE__ */ l("div", { className: "break", children: [
+      /* @__PURE__ */ e("div", { className: "break-item point", style: {
+        backgroundColor: d,
+        border: `1px solid ${c}`
+      } }),
+      u
+    ] }) }),
+    t && y != !1 && /* @__PURE__ */ l("div", { children: [
+      s && /* @__PURE__ */ e("div", { className: "legend-breaks", children: /* @__PURE__ */ e("div", { className: "break-item", children: u }) }),
+      /* @__PURE__ */ e(B, { symbol: s ? "point" : "square", breaks: m, visible: y })
+    ] })
+  ] }) });
+}, W = (n) => {
+  const d = P(null), { layers: a = [], onItemClick: o, patternsData: c, group: s } = n;
+  return /* @__PURE__ */ e("div", { className: "legends", ref: d, children: a && a.map((r) => /* @__PURE__ */ l("div", { children: [
+    r.type == "base" && /* @__PURE__ */ e(T, { ...r, group: s, onItemClick: o }),
+    r.type == "data" && /* @__PURE__ */ e(
+      U,
+      {
+        group: s,
+        patternsData: c ? c[r.id] : null,
+        divRef: d,
+        ...r,
+        onItemClick: o
+      }
+    ),
+    r.type == "dataPoints" && /* @__PURE__ */ e(R, { group: s, ...r, onItemClick: o }),
+    r.type == "flow" && /* @__PURE__ */ e(M, { group: s, ...r, onItemClick: o })
+  ] })) });
+};
+export {
+  W as default
+};

package/dist/esm/embeddable/d3Map/Map.js

@@ -0,0 +1,49 @@
+import { jsx as g } from "react/jsx-runtime";
+import a from "react";
+import * as s from "d3";
+class u extends a.Component {
+  constructor(t) {
+    super(t), this.svgRef = a.createRef(), this.dragged = this.dragged.bind(this);
+  }
+  componentDidUpdate(t, o, r) {
+    if (t.projection !== this.props.projection) {
+      const n = s.geoPath().projection(this.props.projection);
+      this.setState({ projection: this.props.projection, path: n });
+    }
+    const { rotationEnabled: i } = this.props, e = s.select(this.svgRef.current).datum({
+      x: 0,
+      y: 0
+    });
+    i ? e.call(s.drag().on("drag", this.dragged)) : e.on(".drag", null);
+  }
+  componentDidMount() {
+    const { rotationEnabled: t } = this.props, o = s.select(this.svgRef.current).datum({
+      x: 0,
+      y: 0
+    });
+    t && o.call(s.drag().on("drag", this.dragged));
+  }
+  dragged(t, o) {
+    const r = {
+      x: 0,
+      y: 0
+    }, { projection: i, width: e, height: n } = this.props, c = s.scaleLinear().domain([-e, e]).range([-180, 180]), h = s.scaleLinear().domain([-n, n]).range([90, -90]), p = {
+      x: c(o.x = t.x),
+      y: h(o.y = t.y)
+    };
+    i.rotate([r.x + p.x, r.y + p.y]);
+    const d = s.geoPath().projection(i);
+    this.setState({ projection: i, path: d });
+  }
+  render() {
+    const { projection: t, width: o, height: r, path: i } = this.props;
+    return /* @__PURE__ */ g("svg", { viewBox: `0 0 ${o} ${r}`, className: "map", height: r, width: o, ref: this.svgRef, children: t && this.props.children ? this.props.children.map((e) => a.cloneElement(e, {
+      ...this.props,
+      svg: this.svgRef.current,
+      ...this.state
+    })) : null });
+  }
+}
+export {
+  u as default
+};

package/dist/esm/embeddable/d3Map/ProjectedContainer.js

@@ -0,0 +1,50 @@
+import { jsx as m } from "react/jsx-runtime";
+import n, { Children as h } from "react";
+import * as p from "d3";
+class f extends n.Component {
+  constructor(t) {
+    super(t), this.state = {}, this.divRef = n.createRef(), this.createProjection = this.createProjection.bind(this);
+  }
+  createProjection() {
+    const { editing: t, height: i, width: e, scale: o = 200, center: r = [0, 0], projectionName: c } = this.props, s = p[c]().fitSize([e, i]).scale(o).center(r).translate([e / 2, i / 2]);
+    return { path: p.geoPath().projection(s), projection: s };
+  }
+  componentDidMount() {
+    const { svg: t } = this.props, { path: i, projection: e } = this.createProjection();
+    this.setState({ path: i, projection: e });
+  }
+  componentDidUpdate(t, i, e) {
+    if (t.height !== this.props.height || t.width !== this.props.width || t.projectionName !== this.props.projectionName) {
+      const { path: o, projection: r } = this.createProjection();
+      this.setState({ path: o, projection: r });
+    }
+  }
+  render() {
+    const { editing: t, backgroundColor: i, height: e, width: o, scale: r = 190, center: c = [0, 0], initialPosition: s, settings: a } = this.props, d = h.toArray(this.props.children);
+    return /* @__PURE__ */ m(
+      "div",
+      {
+        className: "projected",
+        width: o,
+        height: e,
+        style: {
+          margin: "auto",
+          backgroundColor: i,
+          height: `${e}px`,
+          width: `${o}px`
+        },
+        children: h.map(d, (l) => n.cloneElement(l, {
+          ...this.state,
+          initialPosition: s,
+          editing: t,
+          height: e,
+          width: o,
+          settings: a
+        }))
+      }
+    );
+  }
+}
+export {
+  f as default
+};

package/dist/esm/embeddable/d3Map/Tooltip.js

@@ -0,0 +1,28 @@
+import { jsx as m } from "react/jsx-runtime";
+import "react";
+import g from "string-template";
+const x = /(\+?\%)[\(]([A-z0-9,.,-]+)\)/gi, d = /(\+?\#)[\(]([A-z0-9,.,-]+)\)/gi, y = /(\+?\#C)[\(]([A-z0-9,.,-]+)\)/gi, a = (o, e, r, t, l, h) => {
+  let n, s = e;
+  for (; (n = o.exec(e)) !== null; ) {
+    const p = n[2], c = n[1], u = ((i, f = 2) => l.formatNumber(t ? i / 100 : i, {
+      maximumFractionDigits: f,
+      ...r,
+      signDisplay: c && c.startsWith("+") ? "never" : "auto"
+    })).apply(void 0, p.split(","));
+    s = s.replaceAll(n[0], u);
+  }
+  return s;
+}, A = (o, e, r) => {
+  let t = g(o, { ...e, ...e.meta }).replace(/(?:\r\n|\r|\n)/g, "<br>");
+  return t = a(x, t, { style: "percent" }, !0, r), t = a(d, t, { style: "decimal" }, !1, r), t = a(y, t, { notation: "compact" }, !1, r), t;
+}, C = ({ tooltip: o, data: e, intl: r }) => {
+  if (e) {
+    const t = A(o, e, r);
+    return /* @__PURE__ */ m("div", { dangerouslySetInnerHTML: { __html: t } });
+  } else
+    return /* @__PURE__ */ m("div", {});
+};
+export {
+  C as default,
+  A as formatContent
+};

package/dist/esm/embeddable/d3Map/ZoomControl.js

@@ -0,0 +1,86 @@
+import { jsx as o, jsxs as u } from "react/jsx-runtime";
+import c from "react";
+import * as l from "d3";
+import { Icon as r, Popup as p } from "semantic-ui-react";
+import { FormattedMessage as g } from "react-intl";
+class y extends c.Component {
+  constructor(t) {
+    super(t), this.zooming = !1, this.zoomstarted = this.zoomStarted.bind(this), this.zoomEnd = this.zoomEnd.bind(this), this.zoomed = this.zoomed.bind(this), this.zoomIn = this.zoomIn.bind(this), this.zoomOut = this.zoomOut.bind(this), this.reset = this.reset.bind(this), this.fullView = this.fullView.bind(this), this.transition2fullView = this.transition2fullView.bind(this), this._fullView = this._fullView.bind(this), this.zoomRef = c.createRef(), this.zoom = l.zoom().scaleExtent([0, 300]).on("start", this.zoomStarted).on("zoom", this.zoomed).on("end", this.zoomEnd);
+  }
+  componentDidMount() {
+    const { zoomEnabled: t = !0, rotationEnabled: i } = this.props, s = this.getSelection();
+    s && t && (s.call(this.zoom), this.transition2fullView());
+  }
+  componentDidUpdate(t, i, s) {
+    const e = this.getSelection();
+    t.zoomEnabled != this.props.zoomEnabled && (this.props.zoomEnabled ? e && (e.call(this.zoom), e.on(".zoom", this.zoom), this.transition2fullView()) : e && e.on(".zoom", null)), !t.readyState && this.props.readyState && this.fullView(), (t.height !== this.props.height || t.width !== this.props.width) && this.fullView();
+  }
+  reset() {
+    const {
+      editing: t
+    } = this.props;
+    if (t) {
+      const i = this.getSelection();
+      i && i.call(
+        this.zoom.transform,
+        l.zoomIdentity.translate(0, 0).scale(1)
+      );
+    } else
+      this.transition2fullView();
+  }
+  zoomStarted() {
+  }
+  zoomed(t) {
+    this.props.onZoomed(t.transform);
+  }
+  /*Button Zoom in*/
+  zoomIn(t) {
+    const i = this.getSelection();
+    i && i.transition().call(this.zoom.scaleBy, 1.5);
+  }
+  /*Button zoom oit*/
+  zoomOut() {
+    const t = this.getSelection();
+    t && t.transition().call(this.zoom.scaleBy, 0.6667);
+  }
+  getSelection() {
+    return this.zoomRef.current ? l.select(this.zoomRef.current.parentNode.getElementsByTagName("svg")[0]) : null;
+  }
+  _fullView(t = !0) {
+    const { editing: i, initialPosition: s, width: e, height: m } = this.props, { x: h = 100, y: a = 23, k: n = 1, width: f, height: z } = s || {}, d = this.getSelection();
+    z && f && n && d && d.transition().call(
+      this.zoom.transform,
+      l.zoomIdentity.translate(h, a).scale(n)
+    );
+  }
+  transition2fullView() {
+    this._fullView(!0);
+  }
+  fullView() {
+    this._fullView(!1);
+  }
+  zoomEnd(t) {
+    const { group: i, editing: s, width: e, height: m } = this.props;
+    if (s) {
+      const { x: h, y: a, k: n } = t.transform;
+      window.parent.postMessage({ type: `d3_map_${i}`, value: { k: n, x: h, y: a, width: e, height: m } }, "*");
+    }
+  }
+  render() {
+    const { editing: t, zoomEnabled: i = !0 } = this.props;
+    return /* @__PURE__ */ o("div", { ref: this.zoomRef, className: `zoom ${i ? "" : "disabled"}`, children: (t || i) && /* @__PURE__ */ u("div", { children: [
+      /* @__PURE__ */ o("div", { className: " button plus", onClick: this.zoomIn, children: /* @__PURE__ */ o(r, { name: "plus", size: "small" }) }),
+      /* @__PURE__ */ o("div", { className: " button minus", onClick: this.zoomOut, children: /* @__PURE__ */ o(r, { name: "minus", size: "small" }) }),
+      /* @__PURE__ */ o(
+        p,
+        {
+          content: /* @__PURE__ */ o(g, { id: "map.reset.tooltip", defaultMessage: "Reset zoom" }),
+          trigger: /* @__PURE__ */ o("div", { className: "button reset", onClick: this.reset, children: /* @__PURE__ */ o(r, { name: "repeat", size: "small" }) })
+        }
+      )
+    ] }) });
+  }
+}
+export {
+  y as default
+};

package/dist/esm/embeddable/d3Map/index.js

@@ -0,0 +1,123 @@
+import { jsx as t, jsxs as M } from "react/jsx-runtime";
+import { useState as h, useRef as y, useEffect as S } from "react";
+import { connect as k } from "react-redux";
+import { parse as n, compareJsonProps as D, decode as I } from "../utils/parseUtils.js";
+import N from "./Map.js";
+import R from "./BaseLayer.js";
+import T from "./DataLayer.js";
+import U from "./LatLongLayer.js";
+import Z from "./ZoomControl.js";
+import q from "./ProjectedContainer.js";
+import A from "./Legends.js";
+import B from "./FlowLayer.js";
+import { SettingProvider as F, SettingsConsumer as J } from "@devgateway/wp-react-lib";
+const V = (p) => {
+  const {
+    unique: r,
+    editing: a,
+    "data-group": i,
+    "data-layers": f = "[]",
+    "data-height": u = 400,
+    "data-width": g = 1e3,
+    "data-back-ground-color": w = "#88e8dc",
+    "data-map-position": P = "{}",
+    "data-projection": z = "geoMercator",
+    "data-zoom-enabled": C = !0,
+    "data-rotation-enabled": b = !1,
+    intl: s
+  } = p, [m, L] = h(n(f), []), E = y(null), d = y(null), [c, j] = h(null);
+  S(() => {
+    const o = n(f);
+    D(m, o) || L(o);
+  }, [f]);
+  const v = (o) => {
+    const e = m.slice(), l = e.find((x) => x.id == o);
+    l && (l.visible = !l.visible), L(e);
+  };
+  return /* @__PURE__ */ t("div", { ref: E, className: "d3map-container", children: /* @__PURE__ */ t(F, { locale: s.locale, changeUUID: r, children: /* @__PURE__ */ t(J, { children: /* @__PURE__ */ M(
+    q,
+    {
+      backgroundColor: I(w),
+      height: u,
+      width: g,
+      projectionName: z,
+      editing: a,
+      initialPosition: n(P, a),
+      children: [
+        /* @__PURE__ */ t(N, { rotationEnabled: n(b, a), children: m && m.filter((o) => o.visible != !1).map((o, e) => {
+          if (o.type === "base")
+            return /* @__PURE__ */ t(
+              R,
+              {
+                transform: c,
+                intl: s,
+                zoom: d,
+                unique: r,
+                ...o
+              },
+              e
+            );
+          if (o.type === "data")
+            return /* @__PURE__ */ t(
+              T,
+              {
+                onLayerCreated: (l) => {
+                },
+                transform: c,
+                intl: s,
+                group: i,
+                zoom: d,
+                unique: r,
+                ...o,
+                settings: p.wordress
+              },
+              e
+            );
+          if (o.type === "flow")
+            return /* @__PURE__ */ t(
+              B,
+              {
+                transform: c,
+                intl: s,
+                group: i,
+                zoom: d,
+                unique: r,
+                ...o
+              },
+              e
+            );
+          if (o.type === "dataPoints")
+            return /* @__PURE__ */ t(
+              U,
+              {
+                transform: c,
+                intl: s,
+                group: i,
+                zoom: d,
+                unique: r,
+                ...o
+              },
+              e
+            );
+        }) }),
+        /* @__PURE__ */ t(A, { patternsData: null, layers: m, group: i, onItemClick: v }),
+        /* @__PURE__ */ t(
+          Z,
+          {
+            rootationEmabled: n(b, a),
+            zoomEnabled: n(C, a),
+            onZoomed: j,
+            width: g,
+            height: u,
+            ref: d,
+            group: i,
+            editing: a
+          }
+        )
+      ]
+    }
+  ) }) }) });
+}, W = (p, r) => ({}), G = {}, no = k(W, G)(V);
+export {
+  no as default
+};

package/dist/esm/embeddable/data/CategoriesConsumer.js

@@ -0,0 +1,7 @@
+import { jsx as n } from "react/jsx-runtime";
+import e from "react";
+import { CategoriesContext as m } from "./DataContext.js";
+const s = (r) => /* @__PURE__ */ n(m.Consumer, { children: (t) => t && /* @__PURE__ */ n(e.Fragment, { children: e.Children.map(r.children, (o) => e.cloneElement(o, { ...r, data: t })) }) });
+export {
+  s as default
+};

package/dist/esm/embeddable/data/CategoriesProvider.js

@@ -0,0 +1,35 @@
+import { jsx as t, jsxs as h } from "react/jsx-runtime";
+import { useState as J, useRef as b, useEffect as m } from "react";
+import { useDispatch as j, useSelector as u } from "react-redux";
+import { CategoriesContext as w } from "./DataContext.js";
+import { getCategories as v, setData as z } from "../reducers/data.js";
+import { Container as S, Segment as x } from "semantic-ui-react";
+const k = (d) => {
+  const {
+    app: e,
+    filters: n,
+    source: a,
+    store: C,
+    params: r = {},
+    csv: s,
+    group: I,
+    editing: g,
+    children: P
+  } = d, f = j(), [L, y] = J(!1), o = b({ filters: n, params: r, app: e, source: a, csv: s }), c = ["data", "categories", e];
+  r.dvzProxyDatasetId && c.push(r.dvzProxyDatasetId);
+  const l = u((i) => i.getIn([...c, "items"])), D = u((i) => i.getIn([...c, "error"])), p = u((i) => i.getIn([...c, "loading"]));
+  return m(() => {
+    !l && !p && f(v(d));
+  }, []), m(() => {
+    (n !== o.current.filters || JSON.stringify(r) !== JSON.stringify(o.current.params) || e !== o.current.app || o.current.source !== a || s !== o.current.csv) && (e === "csv" ? f(z({ app: e, csv: s, store: C, params: r, group: I })) : (g && (r.v = (Math.random() + 1).toString(36).substring(7)), y(!1), f(v(d)))), o.current = { filters: n, params: r, app: e, source: a, csv: s };
+  }, [n, r, e, a, s, g]), p ? /* @__PURE__ */ t(S, {}) : l ? /* @__PURE__ */ t(w.Provider, { value: l.toJS(), children: P }) : D ? /* @__PURE__ */ h(x, { color: "red", children: [
+    /* @__PURE__ */ t("h1", { children: "500" }),
+    /* @__PURE__ */ t("p", { children: "Wasn't able to load data" })
+  ] }) : /* @__PURE__ */ t(S, { children: /* @__PURE__ */ h(x, { color: "red", children: [
+    /* @__PURE__ */ t("h1", { children: "404" }),
+    /* @__PURE__ */ t("p", { children: "Can't find this page" })
+  ] }) });
+};
+export {
+  k as default
+};

package/dist/esm/embeddable/data/DataConsumer.js

@@ -0,0 +1,10 @@
+import { jsx as t } from "react/jsx-runtime";
+import r from "react";
+import { DataContext as m } from "./DataContext.js";
+const c = (n) => /* @__PURE__ */ t(m.Consumer, { children: (e) => e && /* @__PURE__ */ t(r.Fragment, { children: r.Children.map(n.children, (o) => r.cloneElement(
+  o,
+  { data: e }
+)) }) });
+export {
+  c as default
+};

package/dist/esm/embeddable/data/DataContext.js

@@ -0,0 +1,7 @@
+import t from "react";
+const o = t.createContext(), a = t.createContext();
+export {
+  a as CategoriesContext,
+  o as DataContext,
+  o as default
+};