@zhenliang/sheet 0.0.1

package/dist/hooks/useEventBus.js

@@ -0,0 +1,17 @@
+import EventEmitter from 'events';
+import { useEffect, useRef } from 'react';
+var useEventBus = function useEventBus() {
+  var eventBus = useRef(new EventEmitter());
+  useEffect(function () {
+    return function () {
+      var _eventBus$current;
+      (_eventBus$current = eventBus.current) === null || _eventBus$current === void 0 ? void 0 : _eventBus$current.removeAllListeners();
+      eventBus.current = null;
+    };
+  }, []);
+  if (!eventBus.current) {
+    eventBus.current = new EventEmitter();
+  }
+  return eventBus.current;
+};
+export { useEventBus };

package/dist/hooks/useKeyboard.js

@@ -0,0 +1,108 @@
+import { useCallback, useEffect } from 'react';
+import { BACKSPACE_KEY, C_KEY, DELETE_KEY, DOWN_KEY, ENTER_KEY, ESCAPE_KEY, LEFT_KEY, RIGHT_KEY, TAB_KEY, UP_KEY, V_KEY, X_KEY, Z_KEY } from "../core/config";
+import { isInputKey } from "../core/util";
+var ua = window.navigator.userAgent;
+var isIE = /MSIE|Trident/.test(ua);
+export function move(keyCode, isShiftKey) {
+  if (keyCode === TAB_KEY) {
+    return {
+      row: 0,
+      col: isShiftKey ? -1 : 1
+    };
+  } else if (keyCode === RIGHT_KEY) {
+    return {
+      row: 0,
+      col: 1
+    };
+  } else if (keyCode === LEFT_KEY) {
+    return {
+      row: 0,
+      col: -1
+    };
+  } else if (keyCode === UP_KEY) {
+    return {
+      row: -1,
+      col: 0
+    };
+  } else if (keyCode === DOWN_KEY) {
+    return {
+      row: 1,
+      col: 0
+    };
+  } else if (keyCode === ENTER_KEY) {
+    return {
+      row: isShiftKey ? -1 : 1,
+      col: 0
+    };
+  }
+}
+export var useKeyBoard = function useKeyBoard(handler, listenElement) {
+  var handleKey = useCallback(function (e) {
+    if (e.defaultPrevented) {
+      return;
+    }
+    var ctrlKey = e.ctrlKey,
+      metaKey = e.metaKey,
+      keyCode = e.keyCode,
+      shiftKey = e.shiftKey;
+    var ctrlKeyPressed = ctrlKey || metaKey;
+    var isEscape = keyCode === ESCAPE_KEY;
+    if (isEscape) {
+      handler.escape(e);
+      return;
+    }
+    var isReverse = ctrlKeyPressed && keyCode === Z_KEY;
+    if (isReverse) {
+      handler.reverse(e);
+      return;
+    }
+    var isCopy = ctrlKeyPressed && keyCode === C_KEY;
+    if (isCopy && isIE) {
+      handler.copy(e);
+      return;
+    }
+    var isCut = ctrlKeyPressed && keyCode === X_KEY;
+    if (isCut && isIE) {
+      handler.copy(e);
+      return;
+    }
+    var isPaste = ctrlKeyPressed && keyCode === V_KEY;
+    if (isPaste && isIE) {
+      handler.paste(e);
+      return;
+    }
+    var isDelete = keyCode === DELETE_KEY || keyCode === BACKSPACE_KEY;
+    if (isDelete) {
+      handler.delete(e);
+      return;
+    }
+    var isEnter = keyCode === ENTER_KEY;
+    if (isEnter && !shiftKey) {
+      handler.enter(e);
+      return;
+    }
+    if (ctrlKeyPressed) {
+      return;
+    }
+    var isValueInput = isInputKey(keyCode);
+    if (isValueInput) {
+      handler.otherInput(e, e.key);
+      return;
+    }
+    var moveInfo = move(keyCode, shiftKey);
+    moveInfo && handler.move(e, moveInfo);
+  }, [handler]);
+  useEffect(function () {
+    if (!listenElement) return;
+    listenElement.addEventListener('keydown', handleKey);
+    document.addEventListener('copy', handler.copy);
+    document.addEventListener('paste', handler.paste);
+    document.addEventListener('cut', handler.cut);
+    return function () {
+      listenElement.removeEventListener('keydown', handleKey);
+      document.removeEventListener('copy', handler.copy);
+      document.removeEventListener('paste', handler.paste);
+      document.removeEventListener('cut', handler.cut);
+    };
+  }, [listenElement]);
+};

package/dist/hooks/useMiddlewareReducer.js

@@ -0,0 +1,47 @@
+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(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from 'react';
+export var useMiddlewareReducer = function useMiddlewareReducer(reducer, initialState) {
+  var middleware = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var _React$useState = React.useState(initialState),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    state = _React$useState2[0],
+    setState = _React$useState2[1];
+  var stateRef = React.useRef(state);
+  var dispatch = React.useMemo(function () {
+    var dispatch = function dispatch() {
+      throw new Error("Dispatching while constructing your middleware is not allowed. " + "Other middleware would not be applied to this dispatch.");
+    };
+    var middlewareAPI = {
+      getState: function getState() {
+        return stateRef.current;
+      },
+      dispatch: function (_dispatch) {
+        function dispatch(_x2) {
+          return _dispatch.apply(this, arguments);
+        }
+        dispatch.toString = function () {
+          return _dispatch.toString();
+        };
+        return dispatch;
+      }(function (action) {
+        return dispatch(action);
+      })
+    };
+    var localDispatch = function localDispatch(action) {
+      stateRef.current = reducer(stateRef.current, action);
+      setState(stateRef.current);
+    };
+    dispatch = middleware.map(function (middleware) {
+      return middleware(middlewareAPI);
+    }).reduceRight(function (acc, middleware) {
+      return middleware(acc);
+    }, localDispatch);
+    return dispatch;
+  }, []);
+  return [state, dispatch];
+};

package/dist/hooks/useMouse.js

@@ -0,0 +1,52 @@
+import { debounce } from 'lodash';
+import { useCallback, useEffect } from 'react';
+export var useMouse = function useMouse(handler, listenElement) {
+  var mouseUp = handler.mouseUp,
+    mouseDown = handler.mouseDown,
+    mouseOver = handler.mouseOver,
+    mouseLeave = handler.mouseLeave,
+    mouseEnter = handler.mouseEnter,
+    doubleClick = handler.doubleClick,
+    loseFocus = handler.loseFocus;
+
+  // todo
+  var wrapper = useCallback(function (handle) {
+    return function (e) {
+      if (!listenElement.contains(e.target)) {
+        return;
+      }
+      handle(e);
+    };
+  }, [listenElement]);
+
+  // useEffect(() => {
+  //   if (!listenElement) return;
+  // }, [mouseUp]);
+  useEffect(function () {
+    if (!listenElement) return;
+    var debounceOver = debounce(mouseOver, 10);
+    var wrappedMouseUp = mouseUp;
+    var wrappedMouseDown = function wrappedMouseDown(e) {
+      if (!listenElement.contains(e.target)) {
+        loseFocus(e);
+        return;
+      }
+      mouseDown(e);
+    };
+    var wrappedMouseDoubleClick = wrapper(doubleClick);
+    document.addEventListener('mouseup', wrappedMouseUp);
+    document.addEventListener('mousedown', wrappedMouseDown);
+    document.addEventListener('dblclick', wrappedMouseDoubleClick);
+    listenElement.addEventListener('mouseover', debounceOver);
+    listenElement.addEventListener('mouseleave', mouseLeave);
+    listenElement.addEventListener('mouseenter', mouseEnter);
+    return function () {
+      listenElement.removeEventListener('mouseover', debounceOver);
+      listenElement.removeEventListener('mouseleave', mouseLeave);
+      listenElement.removeEventListener('mouseenter', mouseEnter);
+      document.removeEventListener('mousedown', wrappedMouseUp);
+      document.removeEventListener('mouseup', wrappedMouseDown);
+      document.removeEventListener('dblclick', wrappedMouseDoubleClick);
+    };
+  }, [listenElement, mouseUp, mouseDown, mouseOver, mouseLeave, doubleClick, loseFocus]);
+};

package/dist/hooks/useSetState.js

@@ -0,0 +1,27 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+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(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useCallback, useState } from 'react';
+var useSetState = function useSetState() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _useState = useState(initialState),
+    _useState2 = _slicedToArray(_useState, 2),
+    state = _useState2[0],
+    setState = _useState2[1];
+  var setMergeState = useCallback(function (patch) {
+    setState(function (prevState) {
+      return _objectSpread(_objectSpread({}, prevState), typeof patch === 'function' ? patch(prevState) : patch);
+    });
+  }, []);
+  return [state, setMergeState];
+};
+export { useSetState };

package/dist/hooks/useSheetEvent.js

@@ -0,0 +1,5 @@
+import { createContext, useContext } from 'react';
+export var SheetEventContext = /*#__PURE__*/createContext(undefined);
+export function useSheetEvent() {
+  return useContext(SheetEventContext);
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { default as Sheet } from "./core/sheet";
+export { default as Table } from "./core/table";
+// export { default as Excel } from './historyComponent/ExcelTable';

package/dist/standardUtils/index.js

@@ -0,0 +1,32 @@
+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(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+export var formatPrecision = function formatPrecision(value) {
+  var precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  if (Number.isNaN(Number(value)) || value === null || value === 0) {
+    return '0';
+  }
+  var b = Math.pow(10, precision);
+  var res = Math.round(Number(value) * b) / b;
+  return res.toFixed(precision);
+};
+
+/**
+ * 千位分隔符
+ * @param value 需要千分符格式化的数据
+ * @returns 含千分符的字符串
+ */
+export var thousandsSeparator = function thousandsSeparator(value) {
+  var _String$split = String(value).split('.'),
+    _String$split2 = _slicedToArray(_String$split, 2),
+    integer = _String$split2[0],
+    decimal = _String$split2[1];
+  var formattedData = integer.replace(/(\d{1,3})(?=(\d{3})+$)/g, '$1,');
+  if (decimal && decimal.length) {
+    formattedData += ".".concat(decimal);
+  }
+  return formattedData;
+};

package/dist/typings/index.d.ts

@@ -0,0 +1 @@
+declare module '*.less';

package/dist/typings/sheet.d.ts

@@ -0,0 +1,209 @@
+declare namespace Sheet {
+  type Cell = {
+    id: string;
+    key?: string;
+    readonly?: boolean;
+    component?: CellViewer;
+    editable?: boolean;
+    colSpan?: number;
+    rowSpan?: number;
+    width?: number;
+    record?: Record<string, unknown>;
+    disableEvents?: boolean;
+    dataEditor?: CellEditor;
+    valueViewer?: CellViewer;
+    className?: string;
+    align?: 'left' | 'center' | 'right';
+    fixed?: 'left' | 'right';
+    value?: string | number | null;
+  };
+
+  type CellEditorProps = {
+    value: unknown;
+    cell?: Cell;
+    onChange: (value) => void;
+    onConfirm: (value) => void;
+  };
+
+  type CellViewerProps = {
+    value: unknown;
+    record?: Record<string, unknown>;
+    row: number;
+    col: number;
+    cell?: Cell;
+  };
+
+  type CellEditor = React.FC<CellEditorProps> & {
+    checker?: (value: unknown) => boolean;
+    formatter?: (value: unknown) => unknown;
+  };
+  type CellViewer = React.FC<CellViewerProps>;
+
+  type CellPosition = {
+    row: number;
+    col: number;
+  };
+
+  type CellData = {
+    id: string;
+    cell: Cell;
+    row: number;
+    col: number;
+    value?: string;
+  };
+
+  type CellNavigable = (cell?: Cell, row?: number, col?: number) => boolean;
+  type CellChangeHandler = (cells: CellData[], additions?: CellData[]) => void;
+
+  type RowGroup = {
+    groupName: string;
+    groupStart: number;
+    groupEnd: number;
+  };
+  type RowGroupConfig = {
+    groups: RowGroup[];
+    groupOpen: boolean[];
+  };
+  type MenuRenderProps = {
+    position?: { top: number; left: number };
+    cell?: Sheet.CellPosition;
+    onContextMenu?: (event: any) => void;
+  };
+
+  type SheetInstance = {
+    zoomTo: (row?: number) => void;
+    pushToHistory: (value: OperateHistory) => void;
+    selectRow: (row?: number) => void;
+    popHistory: () => OperateHistory;
+  };
+
+  type SheetProps = {
+    sheetInstance?: React.MutableRefObject<Sheet.SheetInstance | null>;
+    sheetRenderer?: any;
+    rowRenderer?: any;
+    className?: string;
+    data: Cell[][];
+    freePaste?: boolean;
+    virtualized?: boolean;
+
+    groupConfig?: RowGroupConfig;
+
+    onCellsChanged?: CellChangeHandler;
+    menuRenderer?: React.FC<MenuRenderProps>;
+    onContextMenu?: (event: any) => void;
+
+    scroll?: { x?: number | string; y?: number | string };
+    rowClassName?:
+      | string
+      | ((record: Record<string, unknown>, index: number) => string);
+    children?: (React.Element | null)[];
+  };
+
+  type SheetShell = Pick<SheetTable.TableProps, 'columns'> & {
+    className?: string;
+    showGroup?: boolean;
+    showSelect?: boolean;
+    controlWidth?: number;
+    controlProps?: {
+      check?: {
+        checked: boolean;
+        indeterminate?: boolean;
+      };
+      group?: {
+        open: boolean;
+      };
+    };
+  };
+
+  type SheetRow = {
+    row: number;
+    cells: Cell[];
+    selected: boolean;
+    children: React.ElementType;
+  };
+
+  // todo
+  type windowAssertion = {
+    clipboardData?: {
+      getData?: (type: string) => string;
+      setData?: (type: string, data: string) => string;
+    };
+  };
+
+  type refAssertion = {
+    contains?: (target: EventTarget | null) => boolean;
+    focus?: () => boolean;
+  } & HTMLSpanElement;
+
+  type AttributesRenderer = (
+    cell: Sheet.Cell,
+    row: number,
+    col: number,
+  ) => Record<string, string>;
+
+  type CellProps = {
+    row: number;
+    col: number;
+    cell: Cell;
+    cellRenderer?: React.ElementType;
+    dataEditor?: React.ElementType;
+    valueViewer?: React.ElementType;
+    attributesRenderer?: AttributesRenderer;
+  };
+
+  type UpdateStateType = {
+    eventBus: EventEmitter;
+    start: Sheet.CellPosition;
+    end: Sheet.CellPosition;
+    selecting: boolean;
+    forceEdit: boolean;
+    clear: CellPosition;
+    editing: CellPosition & { value?: string };
+    history: OperateHistory[];
+    freePaste?: boolean;
+    data: Cell[][];
+    mouseDown: boolean;
+    lastSelected?: { start?: Sheet.CellPosition; end?: Sheet.CellPosition };
+    groupConfig?: {
+      groups: RowGroup[];
+      groupOpen: boolean[];
+    };
+    lastFocus: { id: string; col: number }[];
+    lastEditing: CellPosition & { confirm?: boolean };
+    cellChangeHandler: (cells: CellData[], additions?: CellData[]) => void;
+  };
+  type UpdateFocus = (start: CellPosition, end: CellPosition) => void;
+
+  type Options<T> = {
+    value: string;
+    label: string;
+  } & T;
+
+  type OptionsType = Options<{
+    disabled?: boolean;
+    children?: Common.Option<{
+      children?: Common.Options<Record<string, unknown>>;
+    }>;
+  }>;
+
+  type OperateHistory = {
+    changes: Partial<CellData>[];
+    type: OperateType;
+
+    rowInfo?: {
+      newRow?: number;
+      deleteRow?: number;
+    };
+    extraInfo?: Record<string, unknown>;
+  };
+
+  type OperateType =
+    // 前三个Type 直接调用 onCellChange
+    | 'Edit'
+    | 'Paste'
+    | 'Delete'
+    // 后三个单独Event 处理
+    | 'DeleteRow'
+    | 'NewRow'
+    | 'Custom';
+}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@zhenliang/sheet",
+  "version": "0.0.1",
+  "description": "A react library developed with dumi",
+  "license": "MIT",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "father build",
+    "build:watch": "father dev",
+    "dev": "dumi dev",
+    "docs:build": "dumi build",
+    "doctor": "father doctor",
+    "lint": "npm run lint:es && npm run lint:css",
+    "lint:css": "stylelint \"{src,test}/**/*.{css,less}\"",
+    "lint:es": "eslint \"{src,test}/**/*.{js,jsx,ts,tsx}\"",
+    "prepare": "husky install && dumi setup",
+    "prepublishOnly": "father doctor && npm run build",
+    "start": "npm run dev"
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "lint-staged": {
+    "*.{md,json}": [
+      "prettier --write --no-error-on-unmatched-pattern"
+    ],
+    "*.{css,less}": [
+      "stylelint --fix",
+      "prettier --write"
+    ],
+    "*.{js,jsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{ts,tsx}": [
+      "eslint --fix",
+      "prettier --parser=typescript --write"
+    ]
+  },
+  "dependencies": {
+    "@ant-design/icons": "^4.6.2",
+    "events": "^3.3.0",
+    "lodash": "^4.17.21",
+    "moment": "^2.29.4",
+    "redux-logger": "^3.0.6",
+    "redux-thunk": "^2.4.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.1.2",
+    "@commitlint/config-conventional": "^17.1.0",
+    "@types/lodash": "^4.14.195",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "@umijs/lint": "^4.0.0",
+    "dumi": "^2.2.0",
+    "eslint": "^8.23.0",
+    "father": "^4.1.0",
+    "husky": "^8.0.1",
+    "lint-staged": "^13.0.3",
+    "prettier": "^2.7.1",
+    "prettier-plugin-organize-imports": "^3.0.0",
+    "prettier-plugin-packagejson": "^2.2.18",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "stylelint": "^14.9.1"
+  },
+  "peerDependencies": {
+    "antd": "^4.24.0",
+    "react": ">=16.9.0",
+    "react-dom": ">=16.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "authors": [
+    "fizz.zhou@ap.jll.com"
+  ]
+}