dune-react 0.0.1 → 0.0.3

package/dist/node_modules/.pnpm/react-style-singleton@2.2.3_@types_react@18.3.28_react@18.3.1/node_modules/react-style-singleton/dist/es2015/component.js

@@ -0,0 +1,13 @@
+import { styleHookSingleton } from "./hook.js";
+var styleSingleton = function() {
+  var useStyle = styleHookSingleton();
+  var Sheet = function(_a) {
+    var styles = _a.styles, dynamic = _a.dynamic;
+    useStyle(styles, dynamic);
+    return null;
+  };
+  return Sheet;
+};
+export {
+  styleSingleton
+};

package/dist/node_modules/.pnpm/react-style-singleton@2.2.3_@types_react@18.3.28_react@18.3.1/node_modules/react-style-singleton/dist/es2015/hook.js

@@ -0,0 +1,16 @@
+import * as React from "react";
+import { stylesheetSingleton } from "./singleton.js";
+var styleHookSingleton = function() {
+  var sheet = stylesheetSingleton();
+  return function(styles, isDynamic) {
+    React.useEffect(function() {
+      sheet.add(styles);
+      return function() {
+        sheet.remove();
+      };
+    }, [styles && isDynamic]);
+  };
+};
+export {
+  styleHookSingleton
+};

package/dist/node_modules/.pnpm/react-style-singleton@2.2.3_@types_react@18.3.28_react@18.3.1/node_modules/react-style-singleton/dist/es2015/singleton.js

@@ -0,0 +1,48 @@
+import { getNonce } from "../../../../../get-nonce@1.0.1/node_modules/get-nonce/dist/es2015/index.js";
+function makeStyleTag() {
+  if (!document)
+    return null;
+  var tag = document.createElement("style");
+  tag.type = "text/css";
+  var nonce = getNonce();
+  if (nonce) {
+    tag.setAttribute("nonce", nonce);
+  }
+  return tag;
+}
+function injectStyles(tag, css) {
+  if (tag.styleSheet) {
+    tag.styleSheet.cssText = css;
+  } else {
+    tag.appendChild(document.createTextNode(css));
+  }
+}
+function insertStyleTag(tag) {
+  var head = document.head || document.getElementsByTagName("head")[0];
+  head.appendChild(tag);
+}
+var stylesheetSingleton = function() {
+  var counter = 0;
+  var stylesheet = null;
+  return {
+    add: function(style) {
+      if (counter == 0) {
+        if (stylesheet = makeStyleTag()) {
+          injectStyles(stylesheet, style);
+          insertStyleTag(stylesheet);
+        }
+      }
+      counter++;
+    },
+    remove: function() {
+      counter--;
+      if (!counter && stylesheet) {
+        stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet);
+        stylesheet = null;
+      }
+    }
+  };
+};
+export {
+  stylesheetSingleton
+};

package/dist/node_modules/.pnpm/recharts@2.15.4_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/recharts/es6/component/DefaultLegendContent.js

@@ -0,0 +1,292 @@
+import React__default, { PureComponent } from "react";
+import isFunction from "../../../../../lodash@4.17.23/node_modules/lodash/isFunction.js";
+import { clsx } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { warn } from "../util/LogUtils.js";
+import { Surface } from "../container/Surface.js";
+import { Symbols } from "../shape/Symbols.js";
+import { adaptEventsOfChild } from "../util/types.js";
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+function _callSuper(t, o, e) {
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+  return _assertThisInitialized(self);
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch (t2) {
+  }
+  return (_isNativeReflectConstruct = function _isNativeReflectConstruct2() {
+    return !!t;
+  })();
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+  Object.defineProperty(subClass, "prototype", { writable: false });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+function _toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(t);
+}
+var SIZE = 32;
+var DefaultLegendContent = /* @__PURE__ */ function(_PureComponent) {
+  function DefaultLegendContent2() {
+    _classCallCheck(this, DefaultLegendContent2);
+    return _callSuper(this, DefaultLegendContent2, arguments);
+  }
+  _inherits(DefaultLegendContent2, _PureComponent);
+  return _createClass(DefaultLegendContent2, [{
+    key: "renderIcon",
+    value: (
+      /**
+       * Render the path of icon
+       * @param {Object} data Data of each legend item
+       * @return {String} Path element
+       */
+      function renderIcon(data) {
+        var inactiveColor = this.props.inactiveColor;
+        var halfSize = SIZE / 2;
+        var sixthSize = SIZE / 6;
+        var thirdSize = SIZE / 3;
+        var color = data.inactive ? inactiveColor : data.color;
+        if (data.type === "plainline") {
+          return /* @__PURE__ */ React__default.createElement("line", {
+            strokeWidth: 4,
+            fill: "none",
+            stroke: color,
+            strokeDasharray: data.payload.strokeDasharray,
+            x1: 0,
+            y1: halfSize,
+            x2: SIZE,
+            y2: halfSize,
+            className: "recharts-legend-icon"
+          });
+        }
+        if (data.type === "line") {
+          return /* @__PURE__ */ React__default.createElement("path", {
+            strokeWidth: 4,
+            fill: "none",
+            stroke: color,
+            d: "M0,".concat(halfSize, "h").concat(thirdSize, "\n            A").concat(sixthSize, ",").concat(sixthSize, ",0,1,1,").concat(2 * thirdSize, ",").concat(halfSize, "\n            H").concat(SIZE, "M").concat(2 * thirdSize, ",").concat(halfSize, "\n            A").concat(sixthSize, ",").concat(sixthSize, ",0,1,1,").concat(thirdSize, ",").concat(halfSize),
+            className: "recharts-legend-icon"
+          });
+        }
+        if (data.type === "rect") {
+          return /* @__PURE__ */ React__default.createElement("path", {
+            stroke: "none",
+            fill: color,
+            d: "M0,".concat(SIZE / 8, "h").concat(SIZE, "v").concat(SIZE * 3 / 4, "h").concat(-SIZE, "z"),
+            className: "recharts-legend-icon"
+          });
+        }
+        if (/* @__PURE__ */ React__default.isValidElement(data.legendIcon)) {
+          var iconProps = _objectSpread({}, data);
+          delete iconProps.legendIcon;
+          return /* @__PURE__ */ React__default.cloneElement(data.legendIcon, iconProps);
+        }
+        return /* @__PURE__ */ React__default.createElement(Symbols, {
+          fill: color,
+          cx: halfSize,
+          cy: halfSize,
+          size: SIZE,
+          sizeType: "diameter",
+          type: data.type
+        });
+      }
+    )
+    /**
+     * Draw items of legend
+     * @return {ReactElement} Items
+     */
+  }, {
+    key: "renderItems",
+    value: function renderItems() {
+      var _this = this;
+      var _this$props = this.props, payload = _this$props.payload, iconSize = _this$props.iconSize, layout = _this$props.layout, formatter = _this$props.formatter, inactiveColor = _this$props.inactiveColor;
+      var viewBox = {
+        x: 0,
+        y: 0,
+        width: SIZE,
+        height: SIZE
+      };
+      var itemStyle = {
+        display: layout === "horizontal" ? "inline-block" : "block",
+        marginRight: 10
+      };
+      var svgStyle = {
+        display: "inline-block",
+        verticalAlign: "middle",
+        marginRight: 4
+      };
+      return payload.map(function(entry, i) {
+        var finalFormatter = entry.formatter || formatter;
+        var className = clsx(_defineProperty(_defineProperty({
+          "recharts-legend-item": true
+        }, "legend-item-".concat(i), true), "inactive", entry.inactive));
+        if (entry.type === "none") {
+          return null;
+        }
+        var entryValue = !isFunction(entry.value) ? entry.value : null;
+        warn(
+          !isFunction(entry.value),
+          `The name property is also required when using a function for the dataKey of a chart's cartesian components. Ex: <Bar name="Name of my Data"/>`
+          // eslint-disable-line max-len
+        );
+        var color = entry.inactive ? inactiveColor : entry.color;
+        return /* @__PURE__ */ React__default.createElement("li", _extends({
+          className,
+          style: itemStyle,
+          key: "legend-item-".concat(i)
+        }, adaptEventsOfChild(_this.props, entry, i)), /* @__PURE__ */ React__default.createElement(Surface, {
+          width: iconSize,
+          height: iconSize,
+          viewBox,
+          style: svgStyle
+        }, _this.renderIcon(entry)), /* @__PURE__ */ React__default.createElement("span", {
+          className: "recharts-legend-item-text",
+          style: {
+            color
+          }
+        }, finalFormatter ? finalFormatter(entryValue, entry, i) : entryValue));
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props, payload = _this$props2.payload, layout = _this$props2.layout, align = _this$props2.align;
+      if (!payload || !payload.length) {
+        return null;
+      }
+      var finalStyle = {
+        padding: 0,
+        margin: 0,
+        textAlign: layout === "horizontal" ? align : "left"
+      };
+      return /* @__PURE__ */ React__default.createElement("ul", {
+        className: "recharts-default-legend",
+        style: finalStyle
+      }, this.renderItems());
+    }
+  }]);
+}(PureComponent);
+_defineProperty(DefaultLegendContent, "displayName", "Legend");
+_defineProperty(DefaultLegendContent, "defaultProps", {
+  iconSize: 14,
+  layout: "horizontal",
+  align: "center",
+  verticalAlign: "middle",
+  inactiveColor: "#ccc"
+});
+export {
+  DefaultLegendContent
+};

package/dist/node_modules/.pnpm/recharts@2.15.4_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/recharts/es6/component/DefaultTooltipContent.js

@@ -0,0 +1,203 @@
+import React__default from "react";
+import sortBy from "../../../../../lodash@4.17.23/node_modules/lodash/sortBy.js";
+import isNil from "../../../../../lodash@4.17.23/node_modules/lodash/isNil.js";
+import { clsx } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.js";
+import { isNumOrStr } from "../util/DataUtils.js";
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ;
+      else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
+    } catch (r2) {
+      o = true, n = r2;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+function _toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function defaultFormatter(value) {
+  return Array.isArray(value) && isNumOrStr(value[0]) && isNumOrStr(value[1]) ? value.join(" ~ ") : value;
+}
+var DefaultTooltipContent = function DefaultTooltipContent2(props) {
+  var _props$separator = props.separator, separator = _props$separator === void 0 ? " : " : _props$separator, _props$contentStyle = props.contentStyle, contentStyle = _props$contentStyle === void 0 ? {} : _props$contentStyle, _props$itemStyle = props.itemStyle, itemStyle = _props$itemStyle === void 0 ? {} : _props$itemStyle, _props$labelStyle = props.labelStyle, labelStyle = _props$labelStyle === void 0 ? {} : _props$labelStyle, payload = props.payload, formatter = props.formatter, itemSorter = props.itemSorter, wrapperClassName = props.wrapperClassName, labelClassName = props.labelClassName, label = props.label, labelFormatter = props.labelFormatter, _props$accessibilityL = props.accessibilityLayer, accessibilityLayer = _props$accessibilityL === void 0 ? false : _props$accessibilityL;
+  var renderContent = function renderContent2() {
+    if (payload && payload.length) {
+      var listStyle = {
+        padding: 0,
+        margin: 0
+      };
+      var items = (itemSorter ? sortBy(payload, itemSorter) : payload).map(function(entry, i) {
+        if (entry.type === "none") {
+          return null;
+        }
+        var finalItemStyle = _objectSpread({
+          display: "block",
+          paddingTop: 4,
+          paddingBottom: 4,
+          color: entry.color || "#000"
+        }, itemStyle);
+        var finalFormatter = entry.formatter || formatter || defaultFormatter;
+        var value = entry.value, name = entry.name;
+        var finalValue = value;
+        var finalName = name;
+        if (finalFormatter && finalValue != null && finalName != null) {
+          var formatted = finalFormatter(value, name, entry, i, payload);
+          if (Array.isArray(formatted)) {
+            var _formatted = _slicedToArray(formatted, 2);
+            finalValue = _formatted[0];
+            finalName = _formatted[1];
+          } else {
+            finalValue = formatted;
+          }
+        }
+        return (
+          // eslint-disable-next-line react/no-array-index-key
+          /* @__PURE__ */ React__default.createElement("li", {
+            className: "recharts-tooltip-item",
+            key: "tooltip-item-".concat(i),
+            style: finalItemStyle
+          }, isNumOrStr(finalName) ? /* @__PURE__ */ React__default.createElement("span", {
+            className: "recharts-tooltip-item-name"
+          }, finalName) : null, isNumOrStr(finalName) ? /* @__PURE__ */ React__default.createElement("span", {
+            className: "recharts-tooltip-item-separator"
+          }, separator) : null, /* @__PURE__ */ React__default.createElement("span", {
+            className: "recharts-tooltip-item-value"
+          }, finalValue), /* @__PURE__ */ React__default.createElement("span", {
+            className: "recharts-tooltip-item-unit"
+          }, entry.unit || ""))
+        );
+      });
+      return /* @__PURE__ */ React__default.createElement("ul", {
+        className: "recharts-tooltip-item-list",
+        style: listStyle
+      }, items);
+    }
+    return null;
+  };
+  var finalStyle = _objectSpread({
+    margin: 0,
+    padding: 10,
+    backgroundColor: "#fff",
+    border: "1px solid #ccc",
+    whiteSpace: "nowrap"
+  }, contentStyle);
+  var finalLabelStyle = _objectSpread({
+    margin: 0
+  }, labelStyle);
+  var hasLabel = !isNil(label);
+  var finalLabel = hasLabel ? label : "";
+  var wrapperCN = clsx("recharts-default-tooltip", wrapperClassName);
+  var labelCN = clsx("recharts-tooltip-label", labelClassName);
+  if (hasLabel && labelFormatter && payload !== void 0 && payload !== null) {
+    finalLabel = labelFormatter(label, payload);
+  }
+  var accessibilityAttributes = accessibilityLayer ? {
+    role: "status",
+    "aria-live": "assertive"
+  } : {};
+  return /* @__PURE__ */ React__default.createElement("div", _extends({
+    className: wrapperCN,
+    style: finalStyle
+  }, accessibilityAttributes), /* @__PURE__ */ React__default.createElement("p", {
+    className: labelCN,
+    style: finalLabelStyle
+  }, /* @__PURE__ */ React__default.isValidElement(finalLabel) ? finalLabel : "".concat(finalLabel)), renderContent());
+};
+export {
+  DefaultTooltipContent
+};