@lobehub/charts 1.0.0

package/es/common/NoData.js

@@ -0,0 +1,43 @@
+import { Empty } from 'antd';
+import { useTheme } from 'antd-style';
+import { isValidElement, memo } from 'react';
+import { Center, Flexbox } from 'react-layout-kit';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var NoData = /*#__PURE__*/memo(function (_ref) {
+  var _ref$noDataText = _ref.noDataText,
+    noDataText = _ref$noDataText === void 0 ? {
+      desc: "There's no data available for your selection.",
+      title: 'No Data'
+    } : _ref$noDataText,
+    className = _ref.className;
+  var theme = useTheme();
+  var isReactNodeText = /*#__PURE__*/isValidElement(noDataText);
+  return /*#__PURE__*/_jsx(Center, {
+    height: '100%',
+    width: '100%',
+    children: /*#__PURE__*/_jsx(Empty, {
+      className: className,
+      description: isReactNodeText ? noDataText : /*#__PURE__*/_jsxs(Flexbox, {
+        gap: 4,
+        padding: 8,
+        children: [/*#__PURE__*/_jsx("div", {
+          style: {
+            color: theme.colorText,
+            fontSize: 14,
+            fontWeight: 'bold'
+          },
+          children: noDataText === null || noDataText === void 0 ? void 0 : noDataText.title
+        }), /*#__PURE__*/_jsx("div", {
+          style: {
+            color: theme.colorTextDescription,
+            fontSize: 14
+          },
+          children: noDataText === null || noDataText === void 0 ? void 0 : noDataText.desc
+        })]
+      }),
+      image: Empty.PRESENTED_IMAGE_SIMPLE
+    })
+  });
+});
+export default NoData;

package/es/common/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const constructCategoryColors: (categories: string[], colors: string[]) => Map<string, string>;
+export declare const getYAxisDomain: (autoMinValue: boolean, minValue: number | undefined, maxValue: number | undefined) => (string | number)[];
+export declare const constructCategories: (data: any[], color?: string) => string[];
+export declare function deepEqual(obj1: any, obj2: any): boolean;
+export declare function hasOnlyOneValueForThisKey(array: any[], keyToCheck: string): boolean;

package/es/common/utils.js

@@ -0,0 +1,77 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+export var constructCategoryColors = function constructCategoryColors(categories, colors) {
+  var categoryColors = new Map();
+  var _iterator = _createForOfIteratorHelper(categories.entries()),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+        idx = _step$value[0],
+        category = _step$value[1];
+      categoryColors.set(category, colors[idx % colors.length]);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return categoryColors;
+};
+export var getYAxisDomain = function getYAxisDomain(autoMinValue, minValue, maxValue) {
+  return [autoMinValue ? 'auto' : minValue !== null && minValue !== void 0 ? minValue : 0, maxValue !== null && maxValue !== void 0 ? maxValue : 'auto'];
+};
+export var constructCategories = function constructCategories(data, color) {
+  if (!color) {
+    return [];
+  }
+  var categories = new Set();
+  var _iterator2 = _createForOfIteratorHelper(data),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var datum = _step2.value;
+      categories.add(datum[color]);
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return _toConsumableArray(categories);
+};
+export function deepEqual(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (_typeof(obj1) !== 'object' || _typeof(obj2) !== 'object' || obj1 === null || obj2 === null) return false;
+  var keys1 = Object.keys(obj1);
+  var keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (var _i = 0, _keys = keys1; _i < _keys.length; _i++) {
+    var key = _keys[_i];
+    if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) return false;
+  }
+  return true;
+}
+export function hasOnlyOneValueForThisKey(array, keyToCheck) {
+  var val = [];
+  var _iterator3 = _createForOfIteratorHelper(array),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var obj = _step3.value;
+      if (Object.prototype.hasOwnProperty.call(obj, keyToCheck)) {
+        val.push(obj[keyToCheck]);
+        if (val.length > 1) {
+          return false;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return true;
+}

package/es/components/Legend/LegendItem.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+export interface LegendItemProps {
+    activeLegend?: string;
+    color: string;
+    name: string;
+    onClick?: (name: string, color: string) => void;
+}
+declare const LegendItem: import("react").NamedExoticComponent<LegendItemProps>;
+export default LegendItem;

package/es/components/Legend/LegendItem.js

@@ -0,0 +1,65 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+import { Icon } from '@lobehub/ui';
+import { Typography } from 'antd';
+import { createStyles } from 'antd-style';
+import { Circle } from 'lucide-react';
+import { memo } from 'react';
+import { Flexbox } from 'react-layout-kit';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var useStyles = createStyles(function (_ref) {
+  var css = _ref.css,
+    token = _ref.token;
+  return {
+    container: css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    display: inline-flex;\n    align-items: center;\n\n    color: ", ";\n    white-space: nowrap;\n\n    border-radius: ", "px;\n  "])), token.colorTextDescription, token.borderRadius),
+    hasOnValueChange: css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n    transition: all 0.25s ", ";\n\n    &:hover {\n      color: ", ";\n      background: ", ";\n    }\n  "])), token.motionEaseInOut, token.colorTextSecondary, token.colorFillTertiary),
+    itemContent: css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n    font-size: 14px;\n    color: inherit;\n  "])))
+  };
+});
+var LegendItem = /*#__PURE__*/memo(function (_ref2) {
+  var name = _ref2.name,
+    color = _ref2.color,
+    _onClick = _ref2.onClick,
+    activeLegend = _ref2.activeLegend;
+  var _useStyles = useStyles(),
+    cx = _useStyles.cx,
+    styles = _useStyles.styles,
+    theme = _useStyles.theme;
+  var hasOnValueChange = !!_onClick;
+  return /*#__PURE__*/_jsxs(Flexbox, {
+    className: cx(styles.container, hasOnValueChange && styles.hasOnValueChange),
+    gap: 8,
+    horizontal: true,
+    onClick: function onClick(e) {
+      e.stopPropagation();
+      _onClick === null || _onClick === void 0 || _onClick(name, color);
+    },
+    paddingBlock: 2,
+    paddingInline: 8,
+    style: {
+      cursor: hasOnValueChange ? 'pointer' : 'default'
+    },
+    children: [/*#__PURE__*/_jsx(Icon, {
+      color: color,
+      fill: color,
+      icon: Circle,
+      size: {
+        fontSize: 10
+      },
+      style: {
+        opacity: activeLegend && activeLegend !== name ? 0.4 : 1
+      }
+    }), /*#__PURE__*/_jsx(Typography.Paragraph, {
+      className: styles.itemContent,
+      ellipsis: true,
+      style: {
+        color: activeLegend && activeLegend === name ? theme.colorTextSecondary : undefined,
+        margin: 0,
+        opacity: activeLegend && activeLegend !== name ? 0.4 : 1
+      },
+      children: name
+    })]
+  });
+});
+export default LegendItem;

package/es/components/Legend/ScrollButton.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { LucideIcon } from 'lucide-react';
+export interface ScrollButtonProps {
+    disabled?: boolean;
+    icon: LucideIcon;
+    onClick?: () => void;
+}
+declare const ScrollButton: import("react").NamedExoticComponent<ScrollButtonProps>;
+export default ScrollButton;

package/es/components/Legend/ScrollButton.js

@@ -0,0 +1,58 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { Icon } from '@lobehub/ui';
+import { Button } from 'antd';
+import { memo, useEffect, useRef, useState } from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+var ScrollButton = /*#__PURE__*/memo(function (_ref) {
+  var icon = _ref.icon,
+    _onClick = _ref.onClick,
+    disabled = _ref.disabled;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isPressed = _useState2[0],
+    setIsPressed = _useState2[1];
+  var intervalRef = useRef(null);
+  useEffect(function () {
+    if (isPressed) {
+      intervalRef.current = setInterval(function () {
+        _onClick === null || _onClick === void 0 || _onClick();
+      }, 300);
+    } else {
+      clearInterval(intervalRef.current);
+    }
+    return function () {
+      return clearInterval(intervalRef.current);
+    };
+  }, [isPressed, _onClick]);
+  useEffect(function () {
+    if (disabled) {
+      clearInterval(intervalRef.current);
+      setIsPressed(false);
+    }
+  }, [disabled]);
+  return /*#__PURE__*/_jsx(Button, {
+    disabled: disabled,
+    icon: /*#__PURE__*/_jsx(Icon, {
+      className: 'w-full',
+      icon: icon
+    }),
+    onClick: function onClick(e) {
+      e.stopPropagation();
+      _onClick === null || _onClick === void 0 || _onClick();
+    },
+    onMouseDown: function onMouseDown(e) {
+      e.stopPropagation();
+      setIsPressed(true);
+    },
+    onMouseUp: function onMouseUp(e) {
+      e.stopPropagation();
+      setIsPressed(false);
+    },
+    size: 'small',
+    style: {
+      height: 24,
+      width: 24
+    }
+  });
+});
+export default ScrollButton;

package/es/components/Legend/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { FlexboxProps } from 'react-layout-kit';
+export interface LegendProps extends FlexboxProps {
+    activeLegend?: string;
+    categories: string[];
+    colors?: string[];
+    enableLegendSlider?: boolean;
+    onClickLegendItem?: (category: string, color: string) => void;
+}
+declare const Legend: import("react").ForwardRefExoticComponent<LegendProps & import("react").RefAttributes<HTMLDivElement>>;
+export default Legend;

package/es/components/Legend/index.js

@@ -0,0 +1,173 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _excluded = ["categories", "colors", "className", "onClickLegendItem", "activeLegend", "enableLegendSlider"];
+var _templateObject, _templateObject2, _templateObject3;
+import { createStyles } from 'antd-style';
+import { ChevronLeft, ChevronRight } from 'lucide-react';
+import { forwardRef, useCallback, useEffect, useRef, useState } from 'react';
+import { Flexbox } from 'react-layout-kit';
+import { useThemeColorRange } from "../../hooks/useThemeColorRange";
+import LegendItem from "./LegendItem";
+import ScrollButton from "./ScrollButton";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var useStyles = createStyles(function (_ref) {
+  var css = _ref.css;
+  return {
+    container: css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    position: relative;\n    overflow: hidden;\n  "]))),
+    enableLegendSlider: css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n    scrollbar-width: none;\n\n    overflow: auto;\n    align-items: center;\n\n    padding-right: 48px;\n    padding-left: 16px;\n  "]))),
+    scrollButtons: css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n    top: 0;\n    right: 0;\n    bottom: 0;\n  "])))
+  };
+});
+var Legend = /*#__PURE__*/forwardRef(function (props, ref) {
+  var _hasScroll$left, _hasScroll$right;
+  var _useStyles = useStyles(),
+    cx = _useStyles.cx,
+    styles = _useStyles.styles;
+  var themeColorRange = useThemeColorRange();
+  var categories = props.categories,
+    _props$colors = props.colors,
+    colors = _props$colors === void 0 ? themeColorRange : _props$colors,
+    className = props.className,
+    onClickLegendItem = props.onClickLegendItem,
+    activeLegend = props.activeLegend,
+    _props$enableLegendSl = props.enableLegendSlider,
+    enableLegendSlider = _props$enableLegendSl === void 0 ? false : _props$enableLegendSl,
+    rest = _objectWithoutProperties(props, _excluded);
+  var scrollableRef = useRef(null);
+  var scrollButtonsRef = useRef(null);
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    hasScroll = _useState2[0],
+    setHasScroll = _useState2[1];
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isKeyDowned = _useState4[0],
+    setIsKeyDowned = _useState4[1];
+  var intervalRef = useRef(null);
+  var checkScroll = useCallback(function () {
+    var scrollable = scrollableRef === null || scrollableRef === void 0 ? void 0 : scrollableRef.current;
+    if (!scrollable) return;
+    var hasLeftScroll = scrollable.scrollLeft > 0;
+    var hasRightScroll = scrollable.scrollWidth - scrollable.clientWidth > scrollable.scrollLeft;
+    setHasScroll({
+      left: hasLeftScroll,
+      right: hasRightScroll
+    });
+  }, [setHasScroll]); // dependencies are listed here in the array
+
+  var scrollToTest = useCallback(function (direction) {
+    var _element$clientWidth, _scrollButtons$client;
+    var element = scrollableRef === null || scrollableRef === void 0 ? void 0 : scrollableRef.current;
+    var scrollButtons = scrollButtonsRef === null || scrollButtonsRef === void 0 ? void 0 : scrollButtonsRef.current;
+    var width = (_element$clientWidth = element === null || element === void 0 ? void 0 : element.clientWidth) !== null && _element$clientWidth !== void 0 ? _element$clientWidth : 0;
+    var scrollButtonsWith = (_scrollButtons$client = scrollButtons === null || scrollButtons === void 0 ? void 0 : scrollButtons.clientWidth) !== null && _scrollButtons$client !== void 0 ? _scrollButtons$client : 0;
+    if (element && enableLegendSlider) {
+      element.scrollTo({
+        behavior: 'smooth',
+        left: direction === 'left' ? element.scrollLeft - width + scrollButtonsWith : element.scrollLeft + width - scrollButtonsWith
+      });
+      setTimeout(function () {
+        checkScroll();
+      }, 400);
+    }
+  }, [enableLegendSlider, checkScroll]);
+  useEffect(function () {
+    var keyDownHandler = function keyDownHandler(key) {
+      if (key === 'ArrowLeft') {
+        scrollToTest('left');
+      } else if (key === 'ArrowRight') {
+        scrollToTest('right');
+      }
+    };
+    if (isKeyDowned) {
+      keyDownHandler(isKeyDowned);
+      intervalRef.current = setInterval(function () {
+        keyDownHandler(isKeyDowned);
+      }, 300);
+    } else {
+      clearInterval(intervalRef.current);
+    }
+    return function () {
+      return clearInterval(intervalRef.current);
+    };
+  }, [isKeyDowned, scrollToTest]);
+  var keyDown = function keyDown(e) {
+    e.stopPropagation();
+    if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') {
+      e.preventDefault();
+      setIsKeyDowned(e.key);
+    }
+  };
+  var keyUp = function keyUp(e) {
+    e.stopPropagation();
+    setIsKeyDowned(null);
+  };
+  useEffect(function () {
+    var scrollable = scrollableRef === null || scrollableRef === void 0 ? void 0 : scrollableRef.current;
+    if (enableLegendSlider) {
+      checkScroll();
+      scrollable === null || scrollable === void 0 || scrollable.addEventListener('keydown', keyDown);
+      scrollable === null || scrollable === void 0 || scrollable.addEventListener('keyup', keyUp);
+    }
+    return function () {
+      scrollable === null || scrollable === void 0 || scrollable.removeEventListener('keydown', keyDown);
+      scrollable === null || scrollable === void 0 || scrollable.removeEventListener('keyup', keyUp);
+    };
+  }, [checkScroll, enableLegendSlider]);
+  return /*#__PURE__*/_jsxs(Flexbox, _objectSpread(_objectSpread({
+    className: cx(styles.container, className),
+    gap: 8,
+    horizontal: true,
+    ref: ref
+  }, rest), {}, {
+    children: [/*#__PURE__*/_jsx(Flexbox, {
+      className: cx(enableLegendSlider && ((hasScroll === null || hasScroll === void 0 ? void 0 : hasScroll.right) || (hasScroll === null || hasScroll === void 0 ? void 0 : hasScroll.left)) && styles.enableLegendSlider),
+      flex: 1,
+      height: '100%',
+      horizontal: true,
+      ref: scrollableRef,
+      style: {
+        overflow: 'hidden'
+      },
+      tabIndex: 0,
+      wrap: enableLegendSlider ? 'nowrap' : 'wrap',
+      children: categories.map(function (category, idx) {
+        return /*#__PURE__*/_jsx(LegendItem, {
+          activeLegend: activeLegend,
+          color: colors[idx % colors.length],
+          name: category,
+          onClick: onClickLegendItem
+        }, "item-".concat(idx));
+      })
+    }), enableLegendSlider && (hasScroll !== null && hasScroll !== void 0 && hasScroll.right || hasScroll !== null && hasScroll !== void 0 && hasScroll.left) ? /*#__PURE__*/_jsxs(Flexbox, {
+      align: 'center',
+      className: styles.scrollButtons,
+      flex: 'none',
+      gap: 4,
+      height: '100%',
+      horizontal: true,
+      justify: 'center',
+      ref: scrollButtonsRef,
+      children: [/*#__PURE__*/_jsx(ScrollButton, {
+        disabled: (_hasScroll$left = !(hasScroll !== null && hasScroll !== void 0 && hasScroll.left)) !== null && _hasScroll$left !== void 0 ? _hasScroll$left : true,
+        icon: ChevronLeft,
+        onClick: function onClick() {
+          setIsKeyDowned(null);
+          scrollToTest('left');
+        }
+      }), /*#__PURE__*/_jsx(ScrollButton, {
+        disabled: (_hasScroll$right = !(hasScroll !== null && hasScroll !== void 0 && hasScroll.right)) !== null && _hasScroll$right !== void 0 ? _hasScroll$right : true,
+        icon: ChevronRight,
+        onClick: function onClick() {
+          setIsKeyDowned(null);
+          scrollToTest('right');
+        }
+      })]
+    }) : null]
+  }));
+});
+Legend.displayName = 'Legend';
+export default Legend;

package/es/hooks/useOnWindowResize.d.ts

@@ -0,0 +1,3 @@
+export declare const useOnWindowResize: (handler: {
+    (): void;
+}) => void;

package/es/hooks/useOnWindowResize.js

@@ -0,0 +1,14 @@
+import { useEffect } from 'react';
+export var useOnWindowResize = function useOnWindowResize(handler) {
+  useEffect(function () {
+    if (window === undefined) return;
+    var handleResize = function handleResize() {
+      handler();
+    };
+    handleResize();
+    window.addEventListener('resize', handleResize);
+    return function () {
+      return window.removeEventListener('resize', handleResize);
+    };
+  }, [handler]);
+};

package/es/hooks/useThemeColorRange.d.ts

@@ -0,0 +1 @@
+export declare const useThemeColorRange: () => string[];

package/es/hooks/useThemeColorRange.js

@@ -0,0 +1,5 @@
+import { useTheme } from 'antd-style';
+export var useThemeColorRange = function useThemeColorRange() {
+  var theme = useTheme();
+  return [theme.geekblue, theme.gold, theme.lime, theme.volcano, theme.purple, theme.blue, theme.orange, theme.green, theme.red, theme.cyan, theme.yellow, theme.magenta];
+};

package/es/index.d.ts

@@ -0,0 +1,8 @@
+export { default as AreaChart, type AreaChartProps } from './AreaChart';
+export { default as BarChart, type BarChartProps } from './BarChart';
+export { default as ChartTooltipFrame } from './common/ChartTooltip/ChartTooltipFrame';
+export { default as Legend, type LegendProps } from './components/Legend';
+export { default as DonutChart, type DonutChartProps } from './DonutChart';
+export { default as LineChart, type LineChartProps } from './LineChart';
+export { default as ScatterChart, type ScatterChartProps } from './ScatterChart';
+export type * from './types';

package/es/index.js

@@ -0,0 +1,7 @@
+export { default as AreaChart } from "./AreaChart";
+export { default as BarChart } from "./BarChart";
+export { default as ChartTooltipFrame } from "./common/ChartTooltip/ChartTooltipFrame";
+export { default as Legend } from "./components/Legend";
+export { default as DonutChart } from "./DonutChart";
+export { default as LineChart } from "./LineChart";
+export { default as ScatterChart } from "./ScatterChart";

package/es/types.d.ts

@@ -0,0 +1,20 @@
+type FixedProps = {
+    categoryClicked: string;
+    eventType: 'dot' | 'category' | 'bar' | 'slice' | 'bubble';
+};
+type BaseEventProps = FixedProps & {
+    [key: string]: number | string;
+};
+export type EventProps = BaseEventProps | null | undefined;
+export type Interval = 'preserveStartEnd' | 'equidistantPreserveStart';
+export type IntervalType = 'preserveStartEnd' | Interval;
+export type CurveType = 'linear' | 'natural' | 'monotone' | 'step';
+export type ValueFormatter = {
+    (value: number): string;
+};
+export type ScatterChartValueFormatter = {
+    size?: ValueFormatter;
+    x?: ValueFormatter;
+    y?: ValueFormatter;
+};
+export {};

package/es/types.js

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

package/es/utils/index.d.ts

@@ -0,0 +1,3 @@
+import { ValueFormatter } from "../types";
+export declare const defaultValueFormatter: ValueFormatter;
+export declare const sumNumericArray: (arr: number[]) => number;

package/es/utils/index.js

@@ -0,0 +1,8 @@
+export var defaultValueFormatter = function defaultValueFormatter(value) {
+  return value.toString();
+};
+export var sumNumericArray = function sumNumericArray(arr) {
+  return arr.reduce(function (prefixSum, num) {
+    return prefixSum + num;
+  }, 0);
+};

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@lobehub/charts",
+  "version": "1.0.0",
+  "description": "React modern charts components built on recharts",
+  "keywords": [
+    "lobehub",
+    "charts"
+  ],
+  "homepage": "https://github.com/lobehub/lobe-charts",
+  "bugs": {
+    "url": "https://github.com/lobehub/lobe-charts/issues/new"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lobehub/lobe-charts.git"
+  },
+  "license": "MIT",
+  "author": "LobeHub <i@lobehub.com>",
+  "sideEffects": false,
+  "main": "es/index.js",
+  "module": "es/index.js",
+  "types": "es/index.d.ts",
+  "files": [
+    "es"
+  ],
+  "scripts": {
+    "build": "father build",
+    "build:watch": "father dev",
+    "ci": "npm run lint && npm run type-check",
+    "clean": "rm -r es lib dist coverage .dumi/tmp .eslintcache node_modules/.cache",
+    "dev": "dumi dev",
+    "docs:build": "dumi build",
+    "docs:build-analyze": "ANALYZE=1 dumi build",
+    "doctor": "father doctor",
+    "lint": "eslint \"{src,tests}/**/*.{js,jsx,ts,tsx}\" --fix",
+    "lint:md": "remark . --quiet --frail --output",
+    "lint:style": "stylelint \"{src,tests}/**/*.{js,jsx,ts,tsx}\" --fix",
+    "prepare": "husky install && npm run setup",
+    "prepublishOnly": "npm run build",
+    "prettier": "prettier -c --write --no-error-on-unmatched-pattern \"**/**\"",
+    "pull": "git pull",
+    "release": "semantic-release",
+    "setup": "dumi setup",
+    "start": "npm run dev",
+    "test": "vitest --passWithNoTests",
+    "test:coverage": "vitest run --coverage  --passWithNoTests",
+    "test:update": "vitest -u",
+    "type-check": "tsc -p tsconfig-check.json"
+  },
+  "lint-staged": {
+    "*.md": [
+      "remark --quiet --output --",
+      "prettier --write --no-error-on-unmatched-pattern"
+    ],
+    "*.json": [
+      "prettier --write --no-error-on-unmatched-pattern"
+    ],
+    "*.{js,jsx}": [
+      "prettier --write",
+      "stylelint --fix",
+      "eslint --fix"
+    ],
+    "*.{ts,tsx}": [
+      "prettier --parser=typescript --write",
+      "stylelint --fix",
+      "eslint --fix"
+    ]
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.24.8",
+    "polished": "^4.3.1",
+    "react-layout-kit": "^1.9.0",
+    "recharts": "^2.12.7"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.3.0",
+    "@lobehub/lint": "^1.24.3",
+    "@lobehub/ui": "^1.146.8",
+    "@testing-library/react": "^14.3.1",
+    "@types/pangu": "^4.0.2",
+    "@types/query-string": "^6.3.0",
+    "@types/react": "18.2.40",
+    "@types/react-dom": "^18.3.0",
+    "@vitest/coverage-v8": "latest",
+    "babel-plugin-antd-style": "latest",
+    "commitlint": "^19.3.0",
+    "concurrently": "^8.2.2",
+    "cross-env": "^7.0.3",
+    "dumi": "2.2.17",
+    "dumi-theme-lobehub": "^1.8.1",
+    "eslint": "^8.57.0",
+    "father": "4.3.1",
+    "husky": "^9.0.11",
+    "jsdom": "^23.2.0",
+    "lint-staged": "^15.2.7",
+    "prettier": "^3.3.3",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "remark": "^14.0.3",
+    "remark-cli": "^11.0.0",
+    "semantic-release": "^21.1.2",
+    "stylelint": "^15.11.0",
+    "typescript": "^5.5.3",
+    "vitest": "~1.2.2"
+  },
+  "peerDependencies": {
+    "@lobehub/ui": ">=1",
+    "ahooks": ">=3",
+    "antd": ">=5.13.0",
+    "antd-style": ">=3",
+    "lucide-react": ">=0.396.0",
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}