zmdms-webui 0.0.1

package/dist/es/node_modules/redux/es/redux.js

@@ -0,0 +1,383 @@
+/**
+ * Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js
+ *
+ * Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes
+ * during build.
+ * @param {number} code
+ */
+function formatProdErrorMessage(code) {
+  return "Minified Redux error #" + code + "; visit https://redux.js.org/Errors?code=" + code + " for the full message or " + 'use the non-minified dev environment for full errors. ';
+}
+
+// Inlined version of the `symbol-observable` polyfill
+var $$observable = (function () {
+  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
+})();
+
+/**
+ * These are private action types reserved by Redux.
+ * For any unknown actions, you must return the current state.
+ * If the current state is undefined, you must return the initial state.
+ * Do not reference these action types directly in your code.
+ */
+var randomString = function randomString() {
+  return Math.random().toString(36).substring(7).split('').join('.');
+};
+
+var ActionTypes = {
+  INIT: "@@redux/INIT" + randomString(),
+  REPLACE: "@@redux/REPLACE" + randomString(),
+  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
+    return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
+  }
+};
+
+/**
+ * @param {any} obj The object to inspect.
+ * @returns {boolean} True if the argument appears to be a plain object.
+ */
+function isPlainObject(obj) {
+  if (typeof obj !== 'object' || obj === null) return false;
+  var proto = obj;
+
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return Object.getPrototypeOf(obj) === proto;
+}
+
+// Inlined / shortened version of `kindOf` from https://github.com/jonschlinkert/kind-of
+function miniKindOf(val) {
+  if (val === void 0) return 'undefined';
+  if (val === null) return 'null';
+  var type = typeof val;
+
+  switch (type) {
+    case 'boolean':
+    case 'string':
+    case 'number':
+    case 'symbol':
+    case 'function':
+      {
+        return type;
+      }
+  }
+
+  if (Array.isArray(val)) return 'array';
+  if (isDate(val)) return 'date';
+  if (isError(val)) return 'error';
+  var constructorName = ctorName(val);
+
+  switch (constructorName) {
+    case 'Symbol':
+    case 'Promise':
+    case 'WeakMap':
+    case 'WeakSet':
+    case 'Map':
+    case 'Set':
+      return constructorName;
+  } // other
+
+
+  return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
+}
+
+function ctorName(val) {
+  return typeof val.constructor === 'function' ? val.constructor.name : null;
+}
+
+function isError(val) {
+  return val instanceof Error || typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number';
+}
+
+function isDate(val) {
+  if (val instanceof Date) return true;
+  return typeof val.toDateString === 'function' && typeof val.getDate === 'function' && typeof val.setDate === 'function';
+}
+
+function kindOf(val) {
+  var typeOfVal = typeof val;
+
+  if (process.env.NODE_ENV !== 'production') {
+    typeOfVal = miniKindOf(val);
+  }
+
+  return typeOfVal;
+}
+
+/**
+ * @deprecated
+ *
+ * **We recommend using the `configureStore` method
+ * of the `@reduxjs/toolkit` package**, which replaces `createStore`.
+ *
+ * Redux Toolkit is our recommended approach for writing Redux logic today,
+ * including store setup, reducers, data fetching, and more.
+ *
+ * **For more details, please read this Redux docs page:**
+ * **https://redux.js.org/introduction/why-rtk-is-redux-today**
+ *
+ * `configureStore` from Redux Toolkit is an improved version of `createStore` that
+ * simplifies setup and helps avoid common bugs.
+ *
+ * You should not be using the `redux` core package by itself today, except for learning purposes.
+ * The `createStore` method from the core `redux` package will not be removed, but we encourage
+ * all users to migrate to using Redux Toolkit for all Redux code.
+ *
+ * If you want to use `createStore` without this visual deprecation warning, use
+ * the `legacy_createStore` import instead:
+ *
+ * `import { legacy_createStore as createStore} from 'redux'`
+ *
+ */
+
+function createStore(reducer, preloadedState, enhancer) {
+  var _ref2;
+
+  if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {
+    throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : 'It looks like you are passing several store enhancers to ' + 'createStore(). This is not supported. Instead, compose them ' + 'together to a single function. See https://redux.js.org/tutorials/fundamentals/part-4-store#creating-a-store-with-enhancers for an example.');
+  }
+
+  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
+    enhancer = preloadedState;
+    preloadedState = undefined;
+  }
+
+  if (typeof enhancer !== 'undefined') {
+    if (typeof enhancer !== 'function') {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(1) : "Expected the enhancer to be a function. Instead, received: '" + kindOf(enhancer) + "'");
+    }
+
+    return enhancer(createStore)(reducer, preloadedState);
+  }
+
+  if (typeof reducer !== 'function') {
+    throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(2) : "Expected the root reducer to be a function. Instead, received: '" + kindOf(reducer) + "'");
+  }
+
+  var currentReducer = reducer;
+  var currentState = preloadedState;
+  var currentListeners = [];
+  var nextListeners = currentListeners;
+  var isDispatching = false;
+  /**
+   * This makes a shallow copy of currentListeners so we can use
+   * nextListeners as a temporary list while dispatching.
+   *
+   * This prevents any bugs around consumers calling
+   * subscribe/unsubscribe in the middle of a dispatch.
+   */
+
+  function ensureCanMutateNextListeners() {
+    if (nextListeners === currentListeners) {
+      nextListeners = currentListeners.slice();
+    }
+  }
+  /**
+   * Reads the state tree managed by the store.
+   *
+   * @returns {any} The current state tree of your application.
+   */
+
+
+  function getState() {
+    if (isDispatching) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(3) : 'You may not call store.getState() while the reducer is executing. ' + 'The reducer has already received the state as an argument. ' + 'Pass it down from the top reducer instead of reading it from the store.');
+    }
+
+    return currentState;
+  }
+  /**
+   * Adds a change listener. It will be called any time an action is dispatched,
+   * and some part of the state tree may potentially have changed. You may then
+   * call `getState()` to read the current state tree inside the callback.
+   *
+   * You may call `dispatch()` from a change listener, with the following
+   * caveats:
+   *
+   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
+   * If you subscribe or unsubscribe while the listeners are being invoked, this
+   * will not have any effect on the `dispatch()` that is currently in progress.
+   * However, the next `dispatch()` call, whether nested or not, will use a more
+   * recent snapshot of the subscription list.
+   *
+   * 2. The listener should not expect to see all state changes, as the state
+   * might have been updated multiple times during a nested `dispatch()` before
+   * the listener is called. It is, however, guaranteed that all subscribers
+   * registered before the `dispatch()` started will be called with the latest
+   * state by the time it exits.
+   *
+   * @param {Function} listener A callback to be invoked on every dispatch.
+   * @returns {Function} A function to remove this change listener.
+   */
+
+
+  function subscribe(listener) {
+    if (typeof listener !== 'function') {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(4) : "Expected the listener to be a function. Instead, received: '" + kindOf(listener) + "'");
+    }
+
+    if (isDispatching) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(5) : 'You may not call store.subscribe() while the reducer is executing. ' + 'If you would like to be notified after the store has been updated, subscribe from a ' + 'component and invoke store.getState() in the callback to access the latest state. ' + 'See https://redux.js.org/api/store#subscribelistener for more details.');
+    }
+
+    var isSubscribed = true;
+    ensureCanMutateNextListeners();
+    nextListeners.push(listener);
+    return function unsubscribe() {
+      if (!isSubscribed) {
+        return;
+      }
+
+      if (isDispatching) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(6) : 'You may not unsubscribe from a store listener while the reducer is executing. ' + 'See https://redux.js.org/api/store#subscribelistener for more details.');
+      }
+
+      isSubscribed = false;
+      ensureCanMutateNextListeners();
+      var index = nextListeners.indexOf(listener);
+      nextListeners.splice(index, 1);
+      currentListeners = null;
+    };
+  }
+  /**
+   * Dispatches an action. It is the only way to trigger a state change.
+   *
+   * The `reducer` function, used to create the store, will be called with the
+   * current state tree and the given `action`. Its return value will
+   * be considered the **next** state of the tree, and the change listeners
+   * will be notified.
+   *
+   * The base implementation only supports plain object actions. If you want to
+   * dispatch a Promise, an Observable, a thunk, or something else, you need to
+   * wrap your store creating function into the corresponding middleware. For
+   * example, see the documentation for the `redux-thunk` package. Even the
+   * middleware will eventually dispatch plain object actions using this method.
+   *
+   * @param {Object} action A plain object representing “what changed”. It is
+   * a good idea to keep actions serializable so you can record and replay user
+   * sessions, or use the time travelling `redux-devtools`. An action must have
+   * a `type` property which may not be `undefined`. It is a good idea to use
+   * string constants for action types.
+   *
+   * @returns {Object} For convenience, the same action object you dispatched.
+   *
+   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
+   * return something else (for example, a Promise you can await).
+   */
+
+
+  function dispatch(action) {
+    if (!isPlainObject(action)) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(7) : "Actions must be plain objects. Instead, the actual type was: '" + kindOf(action) + "'. You may need to add middleware to your store setup to handle dispatching other values, such as 'redux-thunk' to handle dispatching functions. See https://redux.js.org/tutorials/fundamentals/part-4-store#middleware and https://redux.js.org/tutorials/fundamentals/part-6-async-logic#using-the-redux-thunk-middleware for examples.");
+    }
+
+    if (typeof action.type === 'undefined') {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(8) : 'Actions may not have an undefined "type" property. You may have misspelled an action type string constant.');
+    }
+
+    if (isDispatching) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(9) : 'Reducers may not dispatch actions.');
+    }
+
+    try {
+      isDispatching = true;
+      currentState = currentReducer(currentState, action);
+    } finally {
+      isDispatching = false;
+    }
+
+    var listeners = currentListeners = nextListeners;
+
+    for (var i = 0; i < listeners.length; i++) {
+      var listener = listeners[i];
+      listener();
+    }
+
+    return action;
+  }
+  /**
+   * Replaces the reducer currently used by the store to calculate the state.
+   *
+   * You might need this if your app implements code splitting and you want to
+   * load some of the reducers dynamically. You might also need this if you
+   * implement a hot reloading mechanism for Redux.
+   *
+   * @param {Function} nextReducer The reducer for the store to use instead.
+   * @returns {void}
+   */
+
+
+  function replaceReducer(nextReducer) {
+    if (typeof nextReducer !== 'function') {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(10) : "Expected the nextReducer to be a function. Instead, received: '" + kindOf(nextReducer));
+    }
+
+    currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT.
+    // Any reducers that existed in both the new and old rootReducer
+    // will receive the previous state. This effectively populates
+    // the new state tree with any relevant data from the old one.
+
+    dispatch({
+      type: ActionTypes.REPLACE
+    });
+  }
+  /**
+   * Interoperability point for observable/reactive libraries.
+   * @returns {observable} A minimal observable of state changes.
+   * For more information, see the observable proposal:
+   * https://github.com/tc39/proposal-observable
+   */
+
+
+  function observable() {
+    var _ref;
+
+    var outerSubscribe = subscribe;
+    return _ref = {
+      /**
+       * The minimal observable subscription method.
+       * @param {Object} observer Any object that can be used as an observer.
+       * The observer object should have a `next` method.
+       * @returns {subscription} An object with an `unsubscribe` method that can
+       * be used to unsubscribe the observable from the store, and prevent further
+       * emission of values from the observable.
+       */
+      subscribe: function subscribe(observer) {
+        if (typeof observer !== 'object' || observer === null) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(11) : "Expected the observer to be an object. Instead, received: '" + kindOf(observer) + "'");
+        }
+
+        function observeState() {
+          if (observer.next) {
+            observer.next(getState());
+          }
+        }
+
+        observeState();
+        var unsubscribe = outerSubscribe(observeState);
+        return {
+          unsubscribe: unsubscribe
+        };
+      }
+    }, _ref[$$observable] = function () {
+      return this;
+    }, _ref;
+  } // When a store is created, an "INIT" action is dispatched so that every
+  // reducer returns their initial state. This effectively populates
+  // the initial state tree.
+
+
+  dispatch({
+    type: ActionTypes.INIT
+  });
+  return _ref2 = {
+    dispatch: dispatch,
+    subscribe: subscribe,
+    getState: getState,
+    replaceReducer: replaceReducer
+  }, _ref2[$$observable] = observable, _ref2;
+}
+
+export { ActionTypes as __DO_NOT_USE__ActionTypes, createStore };

package/dist/es/pagination/index.d.ts

@@ -0,0 +1,5 @@
+import Pagination from './pagination.js';
+
+
+
+export { Pagination as default };

package/dist/es/pagination/index.js

@@ -0,0 +1,5 @@
+import Pagination from './pagination.js';
+
+
+
+export { Pagination as default };

package/dist/es/pagination/pagination.d.ts

@@ -0,0 +1,8 @@
+import React__default from 'react';
+import { PaginationProps } from 'antd/lib/pagination';
+
+interface IPaginationProps extends PaginationProps {
+}
+declare const Pagination: React__default.FC<IPaginationProps>;
+
+export { Pagination as default };

package/dist/es/pagination/pagination.js

@@ -0,0 +1,12 @@
+import { __rest, __assign } from '../_virtual/_tslib.js';
+import { jsx } from 'react/jsx-runtime';
+import { Pagination as Pagination$1 } from 'antd';
+import classNames from '../node_modules/classnames/index.js';
+
+var Pagination = function (props) {
+    var className = props.className, restProps = __rest(props, ["className"]);
+    var classes = classNames("ztxk-pagination", className, {});
+    return jsx(Pagination$1, __assign({ className: classes }, restProps));
+};
+
+export { Pagination as default };

package/dist/es/protectedroute/index.d.ts

@@ -0,0 +1,14 @@
+import React__default from 'react';
+
+/**
+ * 受保护的组件，是否需要登录信息
+ */
+
+interface IProps {
+    hasAuth?: boolean;
+    element: any;
+    backLogin: () => React__default.ReactNode;
+}
+declare function ProtectedRoute(props: IProps): any;
+
+export { ProtectedRoute as default };

package/dist/es/protectedroute/index.js

@@ -0,0 +1,17 @@
+import { jsx } from 'react/jsx-runtime';
+import { getToken } from 'zmdms-utils';
+
+function ProtectedRoute(props) {
+    var _a = props.hasAuth, hasAuth = _a === void 0 ? true : _a, element = props.element, backLogin = props.backLogin;
+    var token = getToken();
+    if (!token) {
+        console.log("当前页面需要登录! 请登录成功后再进行访问！");
+        return backLogin();
+    }
+    if (hasAuth) {
+        return element;
+    }
+    return jsx("div", { children: "\u60A8\u6CA1\u6709\u6743\u9650\u8BBF\u95EE\u5F53\u524D\u9875\u9762\uFF01" });
+}
+
+export { ProtectedRoute as default };

package/dist/es/suspensecomponent/index.d.ts

@@ -0,0 +1,9 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React__default from 'react';
+
+interface IProps {
+    children: React__default.ReactNode;
+}
+declare const SuspenseComponent: ({ children }: IProps) => react_jsx_runtime.JSX.Element;
+
+export { SuspenseComponent as default };

package/dist/es/suspensecomponent/index.js

@@ -0,0 +1,10 @@
+import { __assign } from '../_virtual/_tslib.js';
+import { jsx } from 'react/jsx-runtime';
+import { Suspense } from 'react';
+
+var SuspenseComponent = function (_a) {
+    var children = _a.children;
+    return jsx(Suspense, __assign({ fallback: jsx("div", { children: "loading..." }) }, { children: children }));
+};
+
+export { SuspenseComponent as default };

package/dist/es/table/components/CopyIcon.js

@@ -0,0 +1,10 @@
+import { jsx } from 'react/jsx-runtime';
+import { copyColData } from '../utils.js';
+import IconFont from '../../icon/index.js';
+
+var CopyIcon = function (_a) {
+    var copyKey = _a.copyKey, dataSourceRef = _a.dataSourceRef;
+    return (jsx(IconFont, { type: "icon-copy", style: { fontSize: "22px" }, className: "thead-icon", title: "\u590D\u5236\u6574\u5217", onClick: function () { return copyColData(copyKey, dataSourceRef.current); } }));
+};
+
+export { CopyIcon as default };

package/dist/es/table/components/EnhanceCell.js

@@ -0,0 +1,48 @@
+import { __rest, __assign } from '../../_virtual/_tslib.js';
+import { jsx } from 'react/jsx-runtime';
+import { useState } from 'react';
+import { useEditing, useIptRef } from './hooks.js';
+import MemoInput from '../../input/input.js';
+import InputNumber from '../../inputnumber/inputNumber.js';
+
+var EnhanceCell = function (props) {
+    var record = props.record, index = props.index, editable = props.editable, editableConfig = props.editableConfig, dataIndex = props.dataIndex; props.title; var onEditableSave = props.onEditableSave; props.onMouseEnter; props.onMouseLeave; var children = props.children, resetProps = __rest(props, ["record", "index", "editable", "editableConfig", "dataIndex", "title", "onEditableSave", "onMouseEnter", "onMouseLeave", "children"]);
+    // 当前数据
+    var _a = useState(record ? record[dataIndex] : undefined), val = _a[0], setVal = _a[1];
+    // 当前是否是编辑状态 性能优化，显示纯字段比显示一个完整的组件 性能要高出许多
+    var _b = useEditing(), editing = _b.editing, toggleEdit = _b.toggleEdit;
+    // 输入框ref对象
+    var iptRef = useIptRef(editing);
+    // 触发表格保存事件
+    var onSave = function (info) {
+        var _a;
+        if (!onEditableSave) {
+            throw Error("如果开启了editable， 那么必须传递 onEditableSave属性 来更改表格数据!");
+        }
+        toggleEdit();
+        onEditableSave(__assign(__assign({}, record), (_a = {}, _a[dataIndex] = val, _a)), index, dataIndex);
+    };
+    // 如果开启编辑 那么内部直接代理
+    if (editable) {
+        var _c = editableConfig || {
+            type: "input",
+        }, type = _c.type, resetEditableConfigProps = __rest(_c, ["type"]);
+        var CurrentReactNode = null;
+        // 输入框处理
+        if (type === "input") {
+            CurrentReactNode = (jsx(MemoInput, __assign({ value: val, onChange: function (e) {
+                    setVal(e.target.value);
+                }, onPressEnter: onSave, onBlur: onSave, ref: iptRef }, resetEditableConfigProps)));
+        }
+        // 数字输入框处理
+        if (type === "inputNumber") {
+            CurrentReactNode = (jsx(InputNumber, __assign({ value: val, onChange: function (value) {
+                    setVal(value);
+                }, onPressEnter: onSave, onBlur: onSave, ref: iptRef }, resetEditableConfigProps)));
+        }
+        return (jsx("td", __assign({}, resetProps, { children: editing ? (jsx("div", __assign({ className: "ztxk-table__enhance-cell" }, { children: CurrentReactNode }))) : (jsx("div", __assign({ className: "ztxk-table__enhance-cell-wrap", onClick: toggleEdit }, { children: children }))) })));
+    }
+    return jsx("td", __assign({}, resetProps, { children: children }));
+};
+
+export { EnhanceCell as default };

package/dist/es/table/components/EnhanceRow.js

@@ -0,0 +1,11 @@
+import { __rest, __assign } from '../../_virtual/_tslib.js';
+import { jsx } from 'react/jsx-runtime';
+import classNames from '../../node_modules/classnames/index.js';
+
+var EnhanceRow = function (props) {
+    var className = props.className, resetProps = __rest(props, ["className"]);
+    var classes = classNames("ztxk-table__enhance-row", className);
+    return jsx("tr", __assign({ className: classes }, resetProps));
+};
+
+export { EnhanceRow as default };

package/dist/es/table/components/hooks.js

@@ -0,0 +1,24 @@
+import { useState, useRef, useEffect } from 'react';
+
+function useEditing() {
+    var _a = useState(false), editing = _a[0], setEditing = _a[1];
+    var toggleEdit = function () {
+        setEditing(!editing);
+    };
+    return {
+        editing: editing,
+        toggleEdit: toggleEdit,
+    };
+}
+function useIptRef(editing) {
+    // 输入框ref对象
+    var iptRef = useRef();
+    useEffect(function () {
+        if (editing) {
+            iptRef.current.focus();
+        }
+    }, [editing]);
+    return iptRef;
+}
+
+export { useEditing, useIptRef };

package/dist/es/table/constant.js

@@ -0,0 +1,3 @@
+var TABLE_DYNAMIC_KEY = "ztxk-webui-dynamic-table";
+
+export { TABLE_DYNAMIC_KEY };

package/dist/es/table/hooks.js

@@ -0,0 +1,24 @@
+import { useCallback } from 'react';
+
+function useEditChange(dataSourceRef, onTableChange) {
+    // 内部表格编辑事件
+    var onEditableSave = useCallback(function (record, index, dataIndex, otherInfo) {
+        var _a;
+        var newDataSource = (_a = dataSourceRef.current) === null || _a === void 0 ? void 0 : _a.slice();
+        if (newDataSource[index][dataIndex] === record[dataIndex]) {
+            // 说明数据没发生改变 这里什么也不做
+            return;
+        }
+        newDataSource[index] = record;
+        onTableChange &&
+            onTableChange(newDataSource, dataSourceRef.current, {
+                type: "edit",
+                currentIndex: index,
+            });
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [onTableChange]);
+    return onEditableSave;
+}
+
+export { useEditChange };

package/dist/es/table/index.d.ts

@@ -0,0 +1,5 @@
+import MemoTable from './table.js';
+
+
+
+export { MemoTable as default };

package/dist/es/table/index.js

@@ -0,0 +1,5 @@
+import MemoTable from './table.js';
+
+
+
+export { MemoTable as default };

package/dist/es/table/interface.d.ts

@@ -0,0 +1,43 @@
+import { Table } from 'antd';
+import { TableProps, ColumnType } from 'antd/lib/table';
+import { IInputProps } from '../input/input.js';
+import { IInputNumberProps } from '../inputnumber/inputNumber.js';
+
+type IEditableConfigOtherProps = IInputProps & IInputNumberProps;
+interface IEditableConfig extends Partial<IEditableConfigOtherProps> {
+    type: "input" | "inputNumber";
+    [props: string]: any;
+}
+interface IColumnType<RecordType> extends ColumnType<RecordType> {
+    dynamicDisabled?: boolean;
+    isCopy?: boolean | string | string[];
+    editable?: boolean;
+    editableConfig?: IEditableConfig;
+}
+interface IColumnGroupType<RecordType> extends Omit<IColumnType<RecordType>, "dataIndex"> {
+    children: IColumnsType<RecordType>;
+}
+type IColumnsTypeProp<RecordType> = IColumnGroupType<RecordType> | IColumnType<RecordType>;
+declare type IColumnsType<RecordType = unknown> = IColumnsTypeProp<RecordType>[];
+interface ITableProps<RecordType> extends Omit<TableProps<RecordType>, "columns"> {
+    dynamicKey?: string;
+    columns?: IColumnsType<RecordType>;
+    onTableChange?: (dataSource: any, preDataSource: any, other?: {
+        currentIndex: number;
+        type?: "edit" | "move" | "add" | "del";
+    }) => void;
+    isEdit?: boolean;
+    isMove?: boolean;
+}
+interface TableComponent<T> extends React.FC<ITableProps<T>> {
+    SELECTION_COLUMN: typeof Table.SELECTION_COLUMN;
+    EXPAND_COLUMN: typeof Table.EXPAND_COLUMN;
+    SELECTION_ALL: typeof Table.SELECTION_ALL;
+    SELECTION_INVERT: typeof Table.SELECTION_INVERT;
+    SELECTION_NONE: typeof Table.SELECTION_NONE;
+    Column: typeof Table.Column;
+    ColumnGroup: typeof Table.ColumnGroup;
+    Summary: typeof Table.Summary;
+}
+
+export { IColumnGroupType, IColumnType, IColumnsType, IColumnsTypeProp, IEditableConfig, ITableProps, TableComponent };

package/dist/es/table/table.d.ts

@@ -0,0 +1,5 @@
+import { TableComponent } from './interface.js';
+
+declare const MemoTable: TableComponent<any>;
+
+export { MemoTable as default };