@gobolt/genesis 0.0.10 → 0.1.0

package/dist/components/Dashboard/__stories__/DashboardLayoutHeader.d.ts

@@ -0,0 +1,2 @@
+declare const DashboardLayoutHeader: () => import("react/jsx-runtime").JSX.Element;
+export default DashboardLayoutHeader;

package/dist/components/Dashboard/__stories__/DashboardLayoutHeader.js

@@ -0,0 +1,85 @@
+import { jsx as r, jsxs as e } from "react/jsx-runtime";
+import "../../Avatar/styles.js";
+import "../../Badge/styles.js";
+import "../../../providers/BreakpointThemeProvider.js";
+import { u as p, a as i } from "../../../Typography-CoZ5qD-t.js";
+import { BREAKPOINTS as n } from "../../../constants/index.js";
+import "../../Breadcrumb/styles.js";
+import "../../Button/styles.js";
+import "../../Card/styles.js";
+import "../../Checkbox/styles.js";
+import "react";
+import "../../ErrorBoundaryFallback/styles.js";
+import "../../Input/styles.js";
+import "../../Layout/Content/styles.js";
+import "../../Message/styles.js";
+import "../../Notification/NotificationBadge/styles.js";
+import "../../Notification/styles.js";
+import "../../../styles-CWdUpZom.js";
+import "../../Progress/styles.js";
+import "../../../styles/global-styles.js";
+import "../../Row/styles.js";
+import "../../Row/RowLabelValue/styles.js";
+import "../../Row/RowActions/styles.js";
+import "../../SegmentedControls/styles.js";
+import "../../Select/styles.js";
+import "../../Switch/styles.js";
+import { S as t } from "../../../styles-qerRs7Rn.js";
+import "../../Tabs/styles.js";
+import "../../Tile/styles.js";
+import "../../Toast/styles.js";
+import "../../Tooltip/styles.js";
+import { L as d } from "../../../index-BvOLXELm.js";
+const { Header: o, Content: q } = d, z = () => {
+  const { breakpoint: a } = p();
+  return a === n.narrow ? /* @__PURE__ */ r(
+    o,
+    {
+      style: {
+        background: "#fff",
+        padding: "16px",
+        display: "flex",
+        flexDirection: "column"
+      },
+      children: /* @__PURE__ */ e(
+        t,
+        {
+          direction: "vertical",
+          style: { width: "100%", justifyContent: "space-between" },
+          children: [
+            /* @__PURE__ */ r(i, { variant: "heading1", level: 4, children: "Driver Dashboard" }),
+            /* @__PURE__ */ r(
+              "div",
+              {
+                style: {
+                  display: "flex",
+                  alignItems: "center",
+                  borderRadius: "8px"
+                },
+                children: /* @__PURE__ */ r(i, { variant: "heading3", level: 4, children: "Febuary 27, 2025" })
+              }
+            )
+          ]
+        }
+      )
+    }
+  ) : /* @__PURE__ */ r(o, { style: { background: "#fff", padding: "16px" }, children: /* @__PURE__ */ e(t, { style: { width: "100%", justifyContent: "space-between" }, children: [
+    /* @__PURE__ */ r(i, { variant: "heading1", level: 4, children: "Driver Dashboard" }),
+    /* @__PURE__ */ r(
+      "div",
+      {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          backgroundColor: "#fafafa",
+          padding: "8px 16px",
+          borderRadius: "8px"
+        },
+        children: /* @__PURE__ */ r(i, { variant: "heading3", level: 4, children: "Febuary 27, 2025" })
+      }
+    )
+  ] }) });
+};
+export {
+  z as default
+};

package/dist/components/Dashboard/__stories__/DashboardLayoutStory.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+
+export interface DeliveryData {
+    id: string;
+    driverName: string;
+    vehicleType: "EV" | "ICE";
+    deliveryTime: string;
+    parcelsDelivered: number;
+    location: string;
+    status: "completed" | "in-progress" | "pending";
+}
+declare const DashboardLayoutStory: React.FC;
+export default DashboardLayoutStory;

package/dist/components/Dashboard/__stories__/DashboardLayoutStory.js

@@ -0,0 +1,22 @@
+import { jsx as e } from "react/jsx-runtime";
+import i, { useState as o, useEffect as n } from "react";
+import a from "./DashboardLayoutHeader.js";
+import s from "./DashboardLayoutContent.js";
+import d from "../../Layout/MainLayout/MainLayout.js";
+const p = () => {
+  i.useState("line");
+  const [m, r] = o(window.innerWidth < 500);
+  return n(() => {
+    const t = () => r(window.innerWidth < 500);
+    return window.addEventListener("resize", t), () => window.removeEventListener("resize", t);
+  }, []), o("1"), /* @__PURE__ */ e(
+    d,
+    {
+      header: /* @__PURE__ */ e(a, {}),
+      main: /* @__PURE__ */ e(s, {})
+    }
+  );
+};
+export {
+  p as default
+};

package/dist/components/Dashboard/__stories__/charts/LineChart.d.ts

@@ -0,0 +1,12 @@
+interface DeliveryData {
+    deliveryTime: string;
+    vehicleType: "EV" | "ICE";
+    parcelsDelivered: number;
+}
+interface LineChartProps {
+    data: DeliveryData[];
+    width?: number;
+    height?: number;
+}
+export declare const DeliveryLineChart: ({ data, width, height, }: LineChartProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Dashboard/__stories__/charts/LineChart.js

@@ -0,0 +1,536 @@
+import { jsxs as st, jsx as S } from "react/jsx-runtime";
+import { G as lt, g as Z, a as Y, i as G, u as ut, D as ct, f as pt, E as ft, L as M, b as R, C as ht, A as dt, c as F, d as yt, h as mt, e as vt, j as gt, X as tt, Y as et, k as bt, l as At, T as xt, m as Pt } from "../../../../generateCategoricalChart-7ceYaiZ2.js";
+import m, { PureComponent as Ot } from "react";
+import { i as Dt } from "../../../../_baseIsEqual-L0-w1QRI.js";
+import { c as q } from "../../../../clsx-OuTLNxxd.js";
+var St = ["type", "layout", "connectNulls", "ref"], Et = ["key"];
+function j(t) {
+  "@babel/helpers - typeof";
+  return j = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
+    return typeof r;
+  } : function(r) {
+    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+  }, j(t);
+}
+function H(t, r) {
+  if (t == null) return {};
+  var n = wt(t, r), e, a;
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(t);
+    for (a = 0; a < o.length; a++)
+      e = o[a], !(r.indexOf(e) >= 0) && Object.prototype.propertyIsEnumerable.call(t, e) && (n[e] = t[e]);
+  }
+  return n;
+}
+function wt(t, r) {
+  if (t == null) return {};
+  var n = {};
+  for (var e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e)) {
+      if (r.indexOf(e) >= 0) continue;
+      n[e] = t[e];
+    }
+  return n;
+}
+function $() {
+  return $ = Object.assign ? Object.assign.bind() : function(t) {
+    for (var r = 1; r < arguments.length; r++) {
+      var n = arguments[r];
+      for (var e in n)
+        Object.prototype.hasOwnProperty.call(n, e) && (t[e] = n[e]);
+    }
+    return t;
+  }, $.apply(this, arguments);
+}
+function J(t, r) {
+  var n = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var e = Object.getOwnPropertySymbols(t);
+    r && (e = e.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(t, a).enumerable;
+    })), n.push.apply(n, e);
+  }
+  return n;
+}
+function g(t) {
+  for (var r = 1; r < arguments.length; r++) {
+    var n = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? J(Object(n), !0).forEach(function(e) {
+      A(t, e, n[e]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(n)) : J(Object(n)).forEach(function(e) {
+      Object.defineProperty(t, e, Object.getOwnPropertyDescriptor(n, e));
+    });
+  }
+  return t;
+}
+function _(t) {
+  return Ct(t) || kt(t) || jt(t) || _t();
+}
+function _t() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function jt(t, r) {
+  if (t) {
+    if (typeof t == "string") return U(t, r);
+    var n = Object.prototype.toString.call(t).slice(8, -1);
+    if (n === "Object" && t.constructor && (n = t.constructor.name), n === "Map" || n === "Set") return Array.from(t);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return U(t, r);
+  }
+}
+function kt(t) {
+  if (typeof Symbol < "u" && t[Symbol.iterator] != null || t["@@iterator"] != null) return Array.from(t);
+}
+function Ct(t) {
+  if (Array.isArray(t)) return U(t);
+}
+function U(t, r) {
+  (r == null || r > t.length) && (r = t.length);
+  for (var n = 0, e = new Array(r); n < r; n++) e[n] = t[n];
+  return e;
+}
+function Lt(t, r) {
+  if (!(t instanceof r))
+    throw new TypeError("Cannot call a class as a function");
+}
+function Q(t, r) {
+  for (var n = 0; n < r.length; n++) {
+    var e = r[n];
+    e.enumerable = e.enumerable || !1, e.configurable = !0, "value" in e && (e.writable = !0), Object.defineProperty(t, nt(e.key), e);
+  }
+}
+function Tt(t, r, n) {
+  return Q(t.prototype, r), Q(t, n), Object.defineProperty(t, "prototype", { writable: !1 }), t;
+}
+function It(t, r, n) {
+  return r = V(r), Nt(t, rt() ? Reflect.construct(r, n, V(t).constructor) : r.apply(t, n));
+}
+function Nt(t, r) {
+  if (r && (j(r) === "object" || typeof r == "function"))
+    return r;
+  if (r !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return Bt(t);
+}
+function Bt(t) {
+  if (t === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return t;
+}
+function rt() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (rt = function() {
+    return !!t;
+  })();
+}
+function V(t) {
+  return V = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(n) {
+    return n.__proto__ || Object.getPrototypeOf(n);
+  }, V(t);
+}
+function Ft(t, r) {
+  if (typeof r != "function" && r !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  t.prototype = Object.create(r && r.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), r && X(t, r);
+}
+function X(t, r) {
+  return X = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(e, a) {
+    return e.__proto__ = a, e;
+  }, X(t, r);
+}
+function A(t, r, n) {
+  return r = nt(r), r in t ? Object.defineProperty(t, r, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : t[r] = n, t;
+}
+function nt(t) {
+  var r = $t(t, "string");
+  return j(r) == "symbol" ? r : r + "";
+}
+function $t(t, r) {
+  if (j(t) != "object" || !t) return t;
+  var n = t[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var e = n.call(t, r || "default");
+    if (j(e) != "object") return e;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (r === "string" ? String : Number)(t);
+}
+var k = /* @__PURE__ */ function(t) {
+  function r() {
+    var n;
+    Lt(this, r);
+    for (var e = arguments.length, a = new Array(e), o = 0; o < e; o++)
+      a[o] = arguments[o];
+    return n = It(this, r, [].concat(a)), A(n, "state", {
+      isAnimationFinished: !0,
+      totalLength: 0
+    }), A(n, "generateSimpleStrokeDasharray", function(i, s) {
+      return "".concat(s, "px ").concat(i - s, "px");
+    }), A(n, "getStrokeDasharray", function(i, s, l) {
+      var p = l.reduce(function(x, O) {
+        return x + O;
+      });
+      if (!p)
+        return n.generateSimpleStrokeDasharray(s, i);
+      for (var f = Math.floor(i / p), h = i % p, c = s - i, d = [], u = 0, y = 0; u < l.length; y += l[u], ++u)
+        if (y + l[u] > h) {
+          d = [].concat(_(l.slice(0, u)), [h - y]);
+          break;
+        }
+      var b = d.length % 2 === 0 ? [0, c] : [c];
+      return [].concat(_(r.repeat(l, f)), _(d), b).map(function(x) {
+        return "".concat(x, "px");
+      }).join(", ");
+    }), A(n, "id", ut("recharts-line-")), A(n, "pathRef", function(i) {
+      n.mainCurve = i;
+    }), A(n, "handleAnimationEnd", function() {
+      n.setState({
+        isAnimationFinished: !0
+      }), n.props.onAnimationEnd && n.props.onAnimationEnd();
+    }), A(n, "handleAnimationStart", function() {
+      n.setState({
+        isAnimationFinished: !1
+      }), n.props.onAnimationStart && n.props.onAnimationStart();
+    }), n;
+  }
+  return Ft(r, t), Tt(r, [{
+    key: "componentDidMount",
+    value: function() {
+      if (this.props.isAnimationActive) {
+        var e = this.getTotalLength();
+        this.setState({
+          totalLength: e
+        });
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function() {
+      if (this.props.isAnimationActive) {
+        var e = this.getTotalLength();
+        e !== this.state.totalLength && this.setState({
+          totalLength: e
+        });
+      }
+    }
+  }, {
+    key: "getTotalLength",
+    value: function() {
+      var e = this.mainCurve;
+      try {
+        return e && e.getTotalLength && e.getTotalLength() || 0;
+      } catch {
+        return 0;
+      }
+    }
+  }, {
+    key: "renderErrorBar",
+    value: function(e, a) {
+      if (this.props.isAnimationActive && !this.state.isAnimationFinished)
+        return null;
+      var o = this.props, i = o.points, s = o.xAxis, l = o.yAxis, p = o.layout, f = o.children, h = pt(f, ft);
+      if (!h)
+        return null;
+      var c = function(y, b) {
+        return {
+          x: y.x,
+          y: y.y,
+          value: y.value,
+          errorVal: Z(y.payload, b)
+        };
+      }, d = {
+        clipPath: e ? "url(#clipPath-".concat(a, ")") : null
+      };
+      return /* @__PURE__ */ m.createElement(M, d, h.map(function(u) {
+        return /* @__PURE__ */ m.cloneElement(u, {
+          key: "bar-".concat(u.props.dataKey),
+          data: i,
+          xAxis: s,
+          yAxis: l,
+          layout: p,
+          dataPointFormatter: c
+        });
+      }));
+    }
+  }, {
+    key: "renderDots",
+    value: function(e, a, o) {
+      var i = this.props.isAnimationActive;
+      if (i && !this.state.isAnimationFinished)
+        return null;
+      var s = this.props, l = s.dot, p = s.points, f = s.dataKey, h = R(this.props, !1), c = R(l, !0), d = p.map(function(y, b) {
+        var x = g(g(g({
+          key: "dot-".concat(b),
+          r: 3
+        }, h), c), {}, {
+          value: y.value,
+          dataKey: f,
+          cx: y.x,
+          cy: y.y,
+          index: b,
+          payload: y.payload
+        });
+        return r.renderDotItem(l, x);
+      }), u = {
+        clipPath: e ? "url(#clipPath-".concat(a ? "" : "dots-").concat(o, ")") : null
+      };
+      return /* @__PURE__ */ m.createElement(M, $({
+        className: "recharts-line-dots",
+        key: "dots"
+      }, u), d);
+    }
+  }, {
+    key: "renderCurveStatically",
+    value: function(e, a, o, i) {
+      var s = this.props, l = s.type, p = s.layout, f = s.connectNulls;
+      s.ref;
+      var h = H(s, St), c = g(g(g({}, R(h, !0)), {}, {
+        fill: "none",
+        className: "recharts-line-curve",
+        clipPath: a ? "url(#clipPath-".concat(o, ")") : null,
+        points: e
+      }, i), {}, {
+        type: l,
+        layout: p,
+        connectNulls: f
+      });
+      return /* @__PURE__ */ m.createElement(ht, $({}, c, {
+        pathRef: this.pathRef
+      }));
+    }
+  }, {
+    key: "renderCurveWithAnimation",
+    value: function(e, a) {
+      var o = this, i = this.props, s = i.points, l = i.strokeDasharray, p = i.isAnimationActive, f = i.animationBegin, h = i.animationDuration, c = i.animationEasing, d = i.animationId, u = i.animateNewValues, y = i.width, b = i.height, x = this.state, O = x.prevPoints, C = x.totalLength;
+      return /* @__PURE__ */ m.createElement(dt, {
+        begin: f,
+        duration: h,
+        isActive: p,
+        easing: c,
+        from: {
+          t: 0
+        },
+        to: {
+          t: 1
+        },
+        key: "line-".concat(d),
+        onAnimationEnd: this.handleAnimationEnd,
+        onAnimationStart: this.handleAnimationStart
+      }, function(E) {
+        var P = E.t;
+        if (O) {
+          var L = O.length / s.length, D = s.map(function(v, z) {
+            var N = Math.floor(z * L);
+            if (O[N]) {
+              var B = O[N], w = F(B.x, v.x), at = F(B.y, v.y);
+              return g(g({}, v), {}, {
+                x: w(P),
+                y: at(P)
+              });
+            }
+            if (u) {
+              var it = F(y * 2, v.x), ot = F(b / 2, v.y);
+              return g(g({}, v), {}, {
+                x: it(P),
+                y: ot(P)
+              });
+            }
+            return g(g({}, v), {}, {
+              x: v.x,
+              y: v.y
+            });
+          });
+          return o.renderCurveStatically(D, e, a);
+        }
+        var K = F(0, C), T = K(P), I;
+        if (l) {
+          var W = "".concat(l).split(/[,\s]+/gim).map(function(v) {
+            return parseFloat(v);
+          });
+          I = o.getStrokeDasharray(T, C, W);
+        } else
+          I = o.generateSimpleStrokeDasharray(C, T);
+        return o.renderCurveStatically(s, e, a, {
+          strokeDasharray: I
+        });
+      });
+    }
+  }, {
+    key: "renderCurve",
+    value: function(e, a) {
+      var o = this.props, i = o.points, s = o.isAnimationActive, l = this.state, p = l.prevPoints, f = l.totalLength;
+      return s && i && i.length && (!p && f > 0 || !yt(p, i)) ? this.renderCurveWithAnimation(e, a) : this.renderCurveStatically(i, e, a);
+    }
+  }, {
+    key: "render",
+    value: function() {
+      var e, a = this.props, o = a.hide, i = a.dot, s = a.points, l = a.className, p = a.xAxis, f = a.yAxis, h = a.top, c = a.left, d = a.width, u = a.height, y = a.isAnimationActive, b = a.id;
+      if (o || !s || !s.length)
+        return null;
+      var x = this.state.isAnimationFinished, O = s.length === 1, C = q("recharts-line", l), E = p && p.allowDataOverflow, P = f && f.allowDataOverflow, L = E || P, D = G(b) ? this.id : b, K = (e = R(i, !1)) !== null && e !== void 0 ? e : {
+        r: 3,
+        strokeWidth: 2
+      }, T = K.r, I = T === void 0 ? 3 : T, W = K.strokeWidth, v = W === void 0 ? 2 : W, z = mt(i) ? i : {}, N = z.clipDot, B = N === void 0 ? !0 : N, w = I * 2 + v;
+      return /* @__PURE__ */ m.createElement(M, {
+        className: C
+      }, E || P ? /* @__PURE__ */ m.createElement("defs", null, /* @__PURE__ */ m.createElement("clipPath", {
+        id: "clipPath-".concat(D)
+      }, /* @__PURE__ */ m.createElement("rect", {
+        x: E ? c : c - d / 2,
+        y: P ? h : h - u / 2,
+        width: E ? d : d * 2,
+        height: P ? u : u * 2
+      })), !B && /* @__PURE__ */ m.createElement("clipPath", {
+        id: "clipPath-dots-".concat(D)
+      }, /* @__PURE__ */ m.createElement("rect", {
+        x: c - w / 2,
+        y: h - w / 2,
+        width: d + w,
+        height: u + w
+      }))) : null, !O && this.renderCurve(L, D), this.renderErrorBar(L, D), (O || i) && this.renderDots(L, B, D), (!y || x) && vt.renderCallByParent(this.props, s));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function(e, a) {
+      return e.animationId !== a.prevAnimationId ? {
+        prevAnimationId: e.animationId,
+        curPoints: e.points,
+        prevPoints: a.curPoints
+      } : e.points !== a.curPoints ? {
+        curPoints: e.points
+      } : null;
+    }
+  }, {
+    key: "repeat",
+    value: function(e, a) {
+      for (var o = e.length % 2 !== 0 ? [].concat(_(e), [0]) : e, i = [], s = 0; s < a; ++s)
+        i = [].concat(_(i), _(o));
+      return i;
+    }
+  }, {
+    key: "renderDotItem",
+    value: function(e, a) {
+      var o;
+      if (/* @__PURE__ */ m.isValidElement(e))
+        o = /* @__PURE__ */ m.cloneElement(e, a);
+      else if (Dt(e))
+        o = e(a);
+      else {
+        var i = a.key, s = H(a, Et), l = q("recharts-line-dot", typeof e != "boolean" ? e.className : "");
+        o = /* @__PURE__ */ m.createElement(ct, $({
+          key: i
+        }, s, {
+          className: l
+        }));
+      }
+      return o;
+    }
+  }]);
+}(Ot);
+A(k, "displayName", "Line");
+A(k, "defaultProps", {
+  xAxisId: 0,
+  yAxisId: 0,
+  connectNulls: !1,
+  activeDot: !0,
+  dot: !0,
+  legendType: "line",
+  stroke: "#3182bd",
+  strokeWidth: 1,
+  fill: "#fff",
+  points: [],
+  isAnimationActive: !lt.isSsr,
+  animateNewValues: !0,
+  animationBegin: 0,
+  animationDuration: 1500,
+  animationEasing: "ease",
+  hide: !1,
+  label: !1
+});
+A(k, "getComposedData", function(t) {
+  var r = t.props, n = t.xAxis, e = t.yAxis, a = t.xAxisTicks, o = t.yAxisTicks, i = t.dataKey, s = t.bandSize, l = t.displayedData, p = t.offset, f = r.layout, h = l.map(function(c, d) {
+    var u = Z(c, i);
+    return f === "horizontal" ? {
+      x: Y({
+        axis: n,
+        ticks: a,
+        bandSize: s,
+        entry: c,
+        index: d
+      }),
+      y: G(u) ? null : e.scale(u),
+      value: u,
+      payload: c
+    } : {
+      x: G(u) ? null : n.scale(u),
+      y: Y({
+        axis: e,
+        ticks: o,
+        bandSize: s,
+        entry: c,
+        index: d
+      }),
+      value: u,
+      payload: c
+    };
+  });
+  return g({
+    points: h,
+    layout: f
+  }, p);
+});
+var Kt = gt({
+  chartName: "LineChart",
+  GraphicalChild: k,
+  axisComponents: [{
+    axisType: "xAxis",
+    AxisComp: tt
+  }, {
+    axisType: "yAxis",
+    AxisComp: et
+  }],
+  formatAxisMap: bt
+});
+const Gt = ({
+  data: t,
+  width: r = 800,
+  height: n = 300
+}) => {
+  const e = t.map((a) => ({
+    deliveryTime: a.deliveryTime,
+    EV: a.vehicleType === "EV" ? a.parcelsDelivered : 0,
+    ICE: a.vehicleType === "ICE" ? a.parcelsDelivered : 0
+  }));
+  return /* @__PURE__ */ st(Kt, { width: r, height: n, data: e, children: [
+    /* @__PURE__ */ S(At, { strokeDasharray: "3 3" }),
+    /* @__PURE__ */ S(tt, { dataKey: "deliveryTime" }),
+    /* @__PURE__ */ S(et, {}),
+    /* @__PURE__ */ S(xt, {}),
+    /* @__PURE__ */ S(Pt, {}),
+    /* @__PURE__ */ S(
+      k,
+      {
+        type: "monotone",
+        dataKey: "EV",
+        stroke: "#8884d8",
+        name: "EV Deliveries"
+      }
+    ),
+    /* @__PURE__ */ S(
+      k,
+      {
+        type: "monotone",
+        dataKey: "ICE",
+        stroke: "#82ca9d",
+        name: "ICE Deliveries"
+      }
+    )
+  ] });
+};
+export {
+  Gt as DeliveryLineChart
+};

package/dist/components/Dashboard/__tests__/Dashboard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/Dashboard/__tests__/Dashboard.test.js

@@ -0,0 +1,16 @@
+import { jsx as s } from "react/jsx-runtime";
+import { a as n } from "../../../setup-CUbCc8fQ.js";
+import a from "../Dashboard.js";
+describe("<DashboardProps />", () => {
+  let t;
+  beforeEach(() => {
+    t = {
+      foo: "write the test"
+    };
+  });
+  const e = () => n(/* @__PURE__ */ s(a, { ...t }));
+  it("should render foo text correctly", () => {
+    const { getByTestId: o } = e(), r = o("Dashboard");
+    expect(r).toHaveTextContent("write the test");
+  });
+});

package/dist/components/Dashboard/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Dashboard';
+export type { DashboardProps } from './Dashboard';