@zhenliang/sheet 0.1.22 → 0.1.23

package/dist/example/valuationAnalyze.js

@@ -0,0 +1,227 @@
+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 { getNumberEditor, getSelectEditor, Table } from "./..";
+import { Button } from 'antd';
+import { isNil } from 'lodash';
+import { useCallback, useState } from 'react';
+import { SwitchViewer } from "../core/viewer";
+import { SheetType } from "../type";
+import { jsx as _jsx } from "react/jsx-runtime";
+var RateValueInput = getNumberEditor({
+  addonAfter: '%',
+  min: 0,
+  max: 100
+});
+var ValueInput = getNumberEditor({
+  min: 0,
+  max: 100000000
+});
+var RateViewer = function RateViewer(props) {
+  var value = props.value;
+  return /*#__PURE__*/_jsx("span", {
+    children: value ? value + '%' : '-'
+  });
+};
+var data = [{
+  id: 2443,
+  draftId: '101601',
+  valuationType: 2,
+  termDiscountRate: null,
+  reversionDiscountRate: null,
+  vacancyDiscountRate: null,
+  discountRate: 8.5,
+  exitCapRate: 4.5,
+  gfaUnitPrice: 107350.31545913525,
+  nlaUnitPrice: 90130.38038659678,
+  totalValuation: 1622707368.4802885,
+  isEnabled: true
+}, {
+  id: 2444,
+  draftId: '101601',
+  valuationType: 5,
+  termDiscountRate: 4.5,
+  reversionDiscountRate: 5.5,
+  vacancyDiscountRate: 5.5,
+  discountRate: null,
+  exitCapRate: null,
+  gfaUnitPrice: 89327.04427210477,
+  nlaUnitPrice: 89327.04427210477,
+  totalValuation: 1429232708.3536763,
+  isEnabled: false
+}];
+var evaluateMethods = [{
+  label: 'DCF',
+  value: 2
+}, {
+  label: 'T&R',
+  value: 5
+}];
+var EvaSelect = getSelectEditor(evaluateMethods);
+export default (function () {
+  var _useState = useState(data),
+    _useState2 = _slicedToArray(_useState, 1),
+    state = _useState2[0];
+  var columns = [{
+    title: '默认使用',
+    dataIndex: 'isEnabled',
+    width: 66,
+    // cellType: 'operate',
+    readonly: function readonly(value, record) {
+      return !!record.valuationType;
+    },
+    render: SwitchViewer
+    // component: (record: any, row: number, col: number) => (
+    //   <Switch
+    //     disabled={isNil(record.valuationType)}
+    //     checked={record.isEnabled}
+    //     onChange={handleSwitchChange(record, row)}
+    //   />
+    // ),
+  }, {
+    title: '评估方法',
+    dataIndex: 'valuationType',
+    width: 134,
+    readonly: function readonly(value, record, row) {
+      return !row;
+    },
+    render: function (props) {
+      var _evaluateMethods$find;
+      return /*#__PURE__*/_jsx("span", {
+        children: (_evaluateMethods$find = evaluateMethods.find(function (item) {
+          return item.value === props.value;
+        })) === null || _evaluateMethods$find === void 0 ? void 0 : _evaluateMethods$find.label
+      });
+    },
+    editor: getSelectEditor(evaluateMethods)
+    // calcReadOnly: (record, rowIndex) => !rowIndex,
+    // getSelectOptions: (record: any) => {
+    //   if (record.valuationType === 2) {
+    //     return evaluateMethods.slice(0, 1);
+    //   }
+    //   return evaluateMethods.slice(1);
+    // },
+  }, {
+    title: '租期内折现率',
+    dataIndex: 'termDiscountRate',
+    width: 134,
+    editor: RateValueInput,
+    render: RateViewer,
+    readonly: function readonly(value, record, row) {
+      return !row || isNil(record.valuationType);
+    }
+    // calcReadOnly: (record, rowIndex) => !rowIndex || isNil(record.valuationType),
+  }, {
+    title: '租期外折现率',
+    dataIndex: 'reversionDiscountRate',
+    width: 134,
+    render: RateViewer,
+    editor: RateValueInput,
+    readonly: function readonly(value, record, row) {
+      return !row || isNil(record.valuationType);
+    }
+  }, {
+    title: '空置面积折现率',
+    dataIndex: 'vacancyDiscountRate',
+    width: 134,
+    render: RateViewer,
+    editor: RateValueInput,
+    readonly: function readonly(value, record, row) {
+      return !row || isNil(record.valuationType);
+    }
+  }, {
+    title: '折现率',
+    dataIndex: 'discountRate',
+    width: 134,
+    render: RateViewer,
+    editor: EvaSelect,
+    readonly: function readonly(value, record, row) {
+      return !row || isNil(record.valuationType);
+    }
+  }, {
+    title: '退出资本化率',
+    dataIndex: 'exitCapRate',
+    width: 134,
+    render: RateViewer,
+    editor: RateValueInput,
+    readonly: function readonly(value, record, row) {
+      return !row || isNil(record.valuationType);
+    }
+  }, {
+    title: '估值单价/GFA',
+    dataIndex: 'gfaUnitPrice',
+    width: 134,
+    editor: ValueInput,
+    readonly: true
+  }, {
+    title: '估值单价/NLA',
+    dataIndex: 'nlaUnitPrice',
+    width: 134,
+    editor: ValueInput,
+    readonly: true
+  }, {
+    title: '估值',
+    dataIndex: 'totalValuation',
+    width: 134,
+    editor: ValueInput,
+    readonly: true
+  }, {
+    title: '操作',
+    width: 62,
+    dataIndex: 'id',
+    fixed: SheetType.CellAlign.right,
+    editable: false,
+    render: function (props) {
+      var row = props.row,
+        record = props.record;
+      if (row) {
+        return /*#__PURE__*/_jsx("div", {
+          children: /*#__PURE__*/_jsx(Button, {
+            type: "link",
+            onClick: function onClick() {
+              // handleDelete((record as { id: number }).id);
+              // const infos = [{ id: record.id, row, extra: record }];
+              // operateCb && operateCb(4, { row, infos });
+            },
+            size: "small",
+            children: "\u5220\u9664"
+          })
+        });
+      }
+      return /*#__PURE__*/_jsx("div", {
+        className: "value-viewer number-value-viewer"
+      });
+    }
+
+    // component: (record: any, row: number, col: number, operateCb?: ExcelTableType.OperateCollector) => {
+    //   if (row) {
+    //     return (
+    //       <div>
+    //         <Button
+    //           type="link"
+    //           onClick={() => {
+    //             handleDelete(record.id);
+    //             const infos = [{ id: record.id, row, extra: record }];
+    //             operateCb && operateCb(4, { row, infos });
+    //           }}
+    //           size="small"
+    //         >
+    //           删除
+    //         </Button>
+    //       </div>
+    //     );
+    //   }
+    //   return <div className="value-viewer number-value-viewer" />;
+    // },
+  }];
+
+  var handleChange = useCallback(function () {}, [state]);
+  return /*#__PURE__*/_jsx(Table, {
+    columns: columns,
+    dataSource: state,
+    onChange: handleChange
+  });
+});

package/dist/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export { useEventBus } from './useEventBus';
+export { useKeyBoard } from './useKeyboard';
+export { useMiddlewareReducer } from './useMiddlewareReducer';
+export type { Dispatch, FunctionAction, NormalAction, } from './useMiddlewareReducer';
+export { useMouse } from './useMouse';
+export { useSetState } from './useSetState';
+export { SheetEventContext, useSheetEvent } from './useSheetEvent';
+export { useWidth, WidthContext } from './useWidthConfig';

package/dist/hooks/index.js

@@ -0,0 +1,7 @@
+export { useEventBus } from "./useEventBus";
+export { useKeyBoard } from "./useKeyboard";
+export { useMiddlewareReducer } from "./useMiddlewareReducer";
+export { useMouse } from "./useMouse";
+export { useSetState } from "./useSetState";
+export { SheetEventContext, useSheetEvent } from "./useSheetEvent";
+export { useWidth, WidthContext } from "./useWidthConfig";

package/dist/hooks/useEventBus.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+declare const useEventBus: () => EventEmitter;
+export { useEventBus };

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.d.ts

@@ -0,0 +1,18 @@
+declare type KeyOrClipBoardEvent = (event: KeyboardEvent | ClipboardEvent, value?: any) => void;
+declare type KeyboardHandler = {
+    move: KeyOrClipBoardEvent;
+    escape: KeyOrClipBoardEvent;
+    delete: KeyOrClipBoardEvent;
+    enter: KeyOrClipBoardEvent;
+    otherInput: KeyOrClipBoardEvent;
+    copy: KeyOrClipBoardEvent;
+    paste: KeyOrClipBoardEvent;
+    reverse: KeyOrClipBoardEvent;
+    cut: KeyOrClipBoardEvent;
+};
+export declare function move(keyCode: number, isShiftKey: boolean): {
+    row: number;
+    col: number;
+} | undefined;
+export declare const useKeyBoard: (handler: KeyboardHandler, listenElement: HTMLSpanElement | null) => void;
+export {};

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 false;
+    }
+    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.d.ts

@@ -0,0 +1,12 @@
+export declare type NormalAction = {
+    type: string;
+    payload?: any;
+};
+export declare type FunctionAction = (dispatch: any, getState?: () => any) => any;
+export declare type Dispatch = (action: any) => any;
+export declare type MiddlewareAPI<A> = {
+    getState: () => A;
+    dispatch: Dispatch;
+};
+export declare type Middleware<A> = (api: MiddlewareAPI<A>) => (next: Dispatch) => Dispatch;
+export declare const useMiddlewareReducer: <A, B>(reducer: (state: A, action: B) => A, initialState: A, middleware?: Middleware<A>[]) => [A, Dispatch];

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.d.ts

@@ -0,0 +1,11 @@
+declare type MouseHandler = {
+    mouseUp: (value: MouseEvent) => void;
+    mouseDown: (value: MouseEvent) => void;
+    mouseOver: (value: MouseEvent) => void;
+    mouseLeave: (value: MouseEvent) => void;
+    mouseEnter: (value: MouseEvent) => void;
+    doubleClick: (value: MouseEvent) => void;
+    loseFocus: (value: MouseEvent) => void;
+};
+export declare const useMouse: (handler: MouseHandler, listenElement: HTMLSpanElement | null) => void;
+export {};

package/dist/hooks/useMouse.js

@@ -0,0 +1,68 @@
+import { debounce } from 'lodash';
+import { useCallback, useEffect, useRef } 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;
+  var handlerRef = useRef();
+
+  // todo
+  var wrapper = useCallback(function (handle) {
+    return function (e) {
+      if (!listenElement.contains(e.target)) {
+        return;
+      }
+      handle(e);
+    };
+  }, [listenElement]);
+  useEffect(function () {
+    return function () {
+      if (!handlerRef.current) return;
+      var _handlerRef$current = handlerRef.current,
+        listenerMouseUp = _handlerRef$current.mouseUp,
+        listenerMouseDown = _handlerRef$current.mouseDown,
+        listenerMouseOver = _handlerRef$current.mouseOver,
+        listenerMouseLeave = _handlerRef$current.mouseLeave,
+        listenerMouseEnter = _handlerRef$current.mouseEnter,
+        listenerDoubleClick = _handlerRef$current.doubleClick;
+      document.removeEventListener('mouseup', listenerMouseUp);
+      document.removeEventListener('mousedown', listenerMouseDown);
+      document.removeEventListener('dblclick', listenerDoubleClick);
+      listenElement === null || listenElement === void 0 ? void 0 : listenElement.removeEventListener('mouseover', listenerMouseOver);
+      listenElement === null || listenElement === void 0 ? void 0 : listenElement.removeEventListener('mouseleave', listenerMouseLeave);
+      listenElement === null || listenElement === void 0 ? void 0 : listenElement.removeEventListener('mouseenter', listenerMouseEnter);
+    };
+  }, []);
+  useEffect(function () {
+    if (!listenElement) return;
+    var debounceOver = debounce(mouseOver, 10);
+    var wrappedMouseUp = mouseUp;
+    var wrappedMouseDown = function wrappedMouseDown(e) {
+      if (!(listenElement !== null && listenElement !== void 0 && listenElement.contains(e.target))) {
+        loseFocus(e);
+        return;
+      }
+      mouseDown(e);
+    };
+    var wrappedMouseDoubleClick = wrapper(doubleClick);
+    handlerRef.current = {
+      mouseUp: wrappedMouseUp,
+      mouseDown: wrappedMouseDown,
+      doubleClick: wrappedMouseDoubleClick,
+      mouseOver: debounceOver,
+      mouseLeave: mouseLeave,
+      mouseEnter: mouseEnter,
+      loseFocus: loseFocus
+    };
+    document.addEventListener('mouseup', wrappedMouseUp);
+    document.addEventListener('mousedown', wrappedMouseDown);
+    document.addEventListener('dblclick', wrappedMouseDoubleClick);
+    listenElement === null || listenElement === void 0 ? void 0 : listenElement.addEventListener('mouseover', debounceOver);
+    listenElement === null || listenElement === void 0 ? void 0 : listenElement.addEventListener('mouseleave', mouseLeave);
+    listenElement === null || listenElement === void 0 ? void 0 : listenElement.addEventListener('mouseenter', mouseEnter);
+  }, [listenElement]);
+};

package/dist/hooks/useSetState.d.ts

@@ -0,0 +1,2 @@
+declare const useSetState: <T extends object>(initialState?: T) => [T, (patch: Partial<T> | ((prevState: T) => Partial<T>)) => void];
+export { useSetState };

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.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/// <reference types="react" />
+import Events from 'events';
+export declare const SheetEventContext: import("react").Context<Events | undefined>;
+export declare function useSheetEvent(): Events;

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/hooks/useWidthConfig.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { WidthConfig } from '../type/sheet';
+export declare const WidthContext: import("react").Context<WidthConfig>;
+export declare function useWidth(): WidthConfig;

package/dist/hooks/useWidthConfig.js

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

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { SheetTableType, SheetType } from './type';
+export * from './core/editor';
+export { default as Sheet } from './core/sheet';
+export { default as Table } from './core/table';
+export * from './core/viewer';
+export * from './hooks';
+export { useSheetEvent } from './hooks/useSheetEvent';
+export { SheetTableType, SheetType };

package/dist/index.js

@@ -0,0 +1,8 @@
+import { SheetTableType, SheetType } from "./type";
+export * from "./core/editor";
+export { default as Sheet } from "./core/sheet";
+export { default as Table } from "./core/table";
+export * from "./core/viewer";
+export * from "./hooks";
+export { useSheetEvent } from "./hooks/useSheetEvent";
+export { SheetTableType, SheetType };

package/dist/standardUtils/index.d.ts

@@ -0,0 +1,9 @@
+declare type ValueParams = string | number | null | undefined;
+export declare const formatPrecision: (value: ValueParams, precision?: number) => string;
+/**
+ * 千位分隔符
+ * @param value 需要千分符格式化的数据
+ * @returns 含千分符的字符串
+ */
+export declare const thousandsSeparator: (value: string | number) => string;
+export {};