@qsxy/element-plus-react 1.0.2 → 2.0.0

package/dist/TableV2/src/renderers/header.js

@@ -0,0 +1,39 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { HeaderRow } from "../components";
+import { tryCall } from "../utils";
+import classNames from 'classnames';
+import React from 'react';
+var HeaderRenderer = function HeaderRenderer(_ref) {
+  var columns = _ref.columns,
+    columnsStyles = _ref.columnsStyles,
+    headerIndex = _ref.headerIndex,
+    style = _ref.style,
+    headerFormatter = _ref.headerFormatter,
+    cellFormatter = _ref.cellFormatter,
+    headerClass = _ref.headerClass,
+    headerProps = _ref.headerProps,
+    ns = _ref.ns,
+    children = _ref.children;
+  var param = {
+    columns: columns,
+    headerIndex: headerIndex
+  };
+  var extraProps = _objectSpread(_objectSpread({}, tryCall(headerProps, param)), {}, {
+    columnsStyles: columnsStyles,
+    className: classNames(ns.e('header-row'), tryCall(headerClass, param, ''), ns.is({
+      customized: Boolean(headerFormatter)
+    })),
+    columns: columns,
+    headerIndex: headerIndex,
+    style: style,
+    headerFormatter: headerFormatter,
+    cellFormatter: cellFormatter
+  });
+  return /*#__PURE__*/React.createElement(HeaderRow, extraProps, children);
+};
+export default HeaderRenderer;

package/dist/TableV2/src/renderers/left-table.d.ts

@@ -0,0 +1,32 @@
+import { TableGridInstance } from '../table-grid';
+import React, { RefObject } from 'react';
+declare const LeftTable: React.ForwardRefExoticComponent<{
+    columns: import("../..").Column<any>[];
+    data: any[];
+    fixedData: any[];
+    estimatedRowHeight: number;
+    height: number;
+    width: number;
+    headerWidth?: number;
+    headerHeight?: number | number[];
+    footerHeight?: number;
+    bodyWidth?: number;
+    rowHeight?: number;
+    cache?: number;
+    useIsScrolling?: boolean;
+    scrollbarAlwaysOn?: boolean;
+    scrollbarStartGap?: number;
+    scrollbarEndGap?: number;
+    containerStyle?: React.CSSProperties;
+    getRowHeight: (index: number) => number;
+    rowKey?: string | number | symbol;
+    headerFormatter?: (props: import("../..").HeaderSlotProps) => React.ReactNode;
+    rowFormatter?: (props: import("../..").TableGridRowSlotParams) => React.ReactNode;
+    onRowsRendered?: (params: import("../grid").onRowRenderedParams) => void;
+    onScroll?: (...args: any[]) => void;
+    children?: (params: import("../..").TableGridRowSlotParams) => React.ReactNode;
+} & import("../../..").NativeProps & {
+    leftTableRef: RefObject<TableGridInstance | undefined>;
+    children?: React.ReactNode;
+} & React.RefAttributes<TableGridInstance>>;
+export default LeftTable;

package/dist/TableV2/src/renderers/left-table.js

@@ -0,0 +1,15 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import Table from "../table-grid";
+import React, { forwardRef } from 'react';
+var LeftTable = /*#__PURE__*/forwardRef(function (props, ref) {
+  if (!props.columns.length) {
+    return;
+  }
+  return /*#__PURE__*/React.createElement(Table, _extends({
+    ref: ref
+  }, props), function (params) {
+    return props.rowFormatter && props.rowFormatter(params);
+  });
+});
+LeftTable.displayName = 'LeftTable';
+export default LeftTable;

package/dist/TableV2/src/renderers/main-table.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { TableGridInstance } from '../table-grid';
+import type { TableV2GridProps } from '../grid';
+export type MainTableRendererProps = TableV2GridProps & {};
+declare const MainTable: React.ForwardRefExoticComponent<{
+    columns: import("../..").Column<any>[];
+    data: any[];
+    fixedData: any[];
+    estimatedRowHeight: number;
+    height: number;
+    width: number;
+    headerWidth?: number;
+    headerHeight?: number | number[];
+    footerHeight?: number;
+    bodyWidth?: number;
+    rowHeight?: number;
+    cache?: number;
+    useIsScrolling?: boolean;
+    scrollbarAlwaysOn?: boolean;
+    scrollbarStartGap?: number;
+    scrollbarEndGap?: number;
+    containerStyle?: React.CSSProperties;
+    getRowHeight: (index: number) => number;
+    rowKey?: string | number | symbol;
+    headerFormatter?: (props: import("../..").HeaderSlotProps) => React.ReactNode;
+    rowFormatter?: (props: import("../..").TableGridRowSlotParams) => React.ReactNode;
+    onRowsRendered?: (params: import("../grid").onRowRenderedParams) => void;
+    onScroll?: (...args: any[]) => void;
+    children?: (params: import("../..").TableGridRowSlotParams) => React.ReactNode;
+} & import("../../..").NativeProps & React.RefAttributes<TableGridInstance>>;
+export default MainTable;

package/dist/TableV2/src/renderers/main-table.js

@@ -0,0 +1,12 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import React, { forwardRef } from 'react';
+import Table from "../table-grid";
+var MainTable = /*#__PURE__*/forwardRef(function (props, ref) {
+  return /*#__PURE__*/React.createElement(Table, _extends({
+    ref: ref
+  }, props), function (params) {
+    return props.rowFormatter && props.rowFormatter(params);
+  });
+});
+MainTable.displayName = 'MainTable';
+export default MainTable;

package/dist/TableV2/src/renderers/overlay.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleFunctionalComponent } from '../types';
+declare const Overlay: SimpleFunctionalComponent;
+export default Overlay;

package/dist/TableV2/src/renderers/overlay.js

@@ -0,0 +1,9 @@
+import React from 'react';
+var Overlay = function Overlay(props) {
+  return /*#__PURE__*/React.createElement("div", {
+    className: props.className,
+    style: props.style
+  }, props.children);
+};
+Overlay.displayName = 'ElTableV2Overlay';
+export default Overlay;

package/dist/TableV2/src/renderers/right-table.d.ts

@@ -0,0 +1,31 @@
+import { TableGridInstance } from '../table-grid';
+import React from 'react';
+declare const RightTable: React.ForwardRefExoticComponent<{
+    columns: import("../..").Column<any>[];
+    data: any[];
+    fixedData: any[];
+    estimatedRowHeight: number;
+    height: number;
+    width: number;
+    headerWidth?: number;
+    headerHeight?: number | number[];
+    footerHeight?: number;
+    bodyWidth?: number;
+    rowHeight?: number;
+    cache?: number;
+    useIsScrolling?: boolean;
+    scrollbarAlwaysOn?: boolean;
+    scrollbarStartGap?: number;
+    scrollbarEndGap?: number;
+    containerStyle?: React.CSSProperties;
+    getRowHeight: (index: number) => number;
+    rowKey?: string | number | symbol;
+    headerFormatter?: (props: import("../..").HeaderSlotProps) => React.ReactNode;
+    rowFormatter?: (props: import("../..").TableGridRowSlotParams) => React.ReactNode;
+    onRowsRendered?: (params: import("../grid").onRowRenderedParams) => void;
+    onScroll?: (...args: any[]) => void;
+    children?: (params: import("../..").TableGridRowSlotParams) => React.ReactNode;
+} & import("../../..").NativeProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<TableGridInstance>>;
+export default RightTable;

package/dist/TableV2/src/renderers/right-table.js

@@ -0,0 +1,15 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import Table from "../table-grid";
+import React, { forwardRef } from 'react';
+var RightTable = /*#__PURE__*/forwardRef(function (props, ref) {
+  if (!props.columns.length) {
+    return;
+  }
+  return /*#__PURE__*/React.createElement(Table, _extends({
+    ref: ref
+  }, props), function (params) {
+    return props.rowFormatter && props.rowFormatter(params);
+  });
+});
+RightTable.displayName = 'RightTable';
+export default RightTable;

package/dist/TableV2/src/renderers/row.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { UseNamespaceReturn } from '../../../hooks/useClassNames';
+import type { TableV2Props } from '../table';
+import type { TableGridRowSlotParams } from '../table-grid';
+import type { UseTableReturn } from '../use-table';
+type RowRendererProps = TableGridRowSlotParams & Pick<TableV2Props, 'expandColumnKey' | 'estimatedRowHeight' | 'rowProps' | 'rowClass' | 'rowKey' | 'rowEventHandlers' | 'rowFormatter' | 'cellFormatter'> & Pick<UseTableReturn, 'depthMap' | 'expandedRowKeys' | 'hasFixedColumns' | 'onRowHovered' | 'onRowExpanded' | 'columnsStyles'> & {
+    ns: UseNamespaceReturn;
+    tableInstance?: any;
+};
+declare const _default: React.MemoExoticComponent<(props: RowRendererProps) => React.JSX.Element>;
+export default _default;

package/dist/TableV2/src/renderers/row.js

@@ -0,0 +1,96 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React from 'react';
+import { Row } from "../components";
+import { tryCall } from "../utils";
+import classNames from 'classnames';
+var RowRenderer = function RowRenderer(props) {
+  var columns = props.columns,
+    columnsStyles = props.columnsStyles,
+    depthMap = props.depthMap,
+    expandColumnKey = props.expandColumnKey,
+    expandedRowKeys = props.expandedRowKeys,
+    estimatedRowHeight = props.estimatedRowHeight,
+    hasFixedColumns = props.hasFixedColumns,
+    rowData = props.rowData,
+    rowIndex = props.rowIndex,
+    style = props.style,
+    isScrolling = props.isScrolling,
+    rowProps = props.rowProps,
+    rowClass = props.rowClass,
+    rowKey = props.rowKey,
+    rowEventHandlers = props.rowEventHandlers,
+    ns = props.ns,
+    onRowHovered = props.onRowHovered,
+    onRowExpanded = props.onRowExpanded;
+  var rowKls = tryCall(rowClass, {
+    columns: columns,
+    rowData: rowData,
+    rowIndex: rowIndex
+  }, '');
+  var additionalProps = tryCall(rowProps, {
+    columns: columns,
+    rowData: rowData,
+    rowIndex: rowIndex
+  });
+  var _rowKey = rowData[rowKey];
+  var depth = depthMap[_rowKey] || 0;
+  var canExpand = Boolean(expandColumnKey);
+  var isFixedRow = rowIndex < 0;
+  var kls = classNames(ns.e('row'), rowKls, ns.is({
+    expanded: canExpand && expandedRowKeys.includes(_rowKey),
+    fixed: !depth && isFixedRow,
+    customized: Boolean(props.rowFormatter)
+  }), _defineProperty({}, ns.e("row-depth-".concat(depth)), canExpand && rowIndex >= 0));
+  var onRowHover = hasFixedColumns ? onRowHovered : undefined;
+  var _rowProps = _objectSpread(_objectSpread({}, props), {}, {
+    columns: columns,
+    columnsStyles: columnsStyles,
+    className: kls,
+    depth: depth,
+    expandColumnKey: expandColumnKey,
+    estimatedRowHeight: isFixedRow ? undefined : estimatedRowHeight,
+    isScrolling: isScrolling,
+    rowIndex: rowIndex,
+    rowData: rowData,
+    rowKey: _rowKey,
+    rowEventHandlers: rowEventHandlers,
+    style: style,
+    rowFormatter: props.rowFormatter,
+    cellFormatter: props.cellFormatter
+  });
+  var handlerMouseEnter = function handlerMouseEnter(_ref) {
+    var e = _ref.event;
+    onRowHover === null || onRowHover === void 0 || onRowHover({
+      hovered: true,
+      rowKey: _rowKey,
+      event: e,
+      rowData: rowData,
+      rowIndex: rowIndex
+    });
+  };
+  var handlerMouseLeave = function handlerMouseLeave(_ref2) {
+    var e = _ref2.event;
+    onRowHover === null || onRowHover === void 0 || onRowHover({
+      hovered: false,
+      rowKey: _rowKey,
+      event: e,
+      rowData: rowData,
+      rowIndex: rowIndex
+    });
+  };
+  return /*#__PURE__*/React.createElement(Row, _extends({}, _rowProps, {
+    onRowExpand: onRowExpanded,
+    rowEventHandlers: {
+      onMouseEnter: handlerMouseEnter,
+      onMouseLeave: handlerMouseLeave
+    },
+    rowKey: _rowKey
+  }));
+};
+export default /*#__PURE__*/React.memo(RowRenderer);

package/dist/TableV2/src/row.d.ts

@@ -0,0 +1,51 @@
+import React, { CSSProperties } from 'react';
+import { CellFormatProps, RowFormatProps } from './table';
+import type { Column, FixedDirection, KeyType, RowCommonParams } from './types';
+export type RowExpandParams = {
+    expanded: boolean;
+    rowKey: KeyType;
+} & RowCommonParams;
+export type RowHoverParams = {
+    event?: MouseEvent;
+    hovered: boolean;
+    rowKey: KeyType;
+} & Partial<RowCommonParams>;
+export type RowEventHandlerParams = {
+    rowKey?: KeyType;
+    event: Event;
+} & Partial<RowCommonParams>;
+export type RowHeightChangedParams = {
+    rowKey: KeyType;
+    height: number;
+    rowIndex: number;
+};
+export type RowExpandHandler = (params: RowExpandParams) => void;
+export type RowHoverHandler = (params: RowHoverParams) => void;
+export type RowEventHandler = (params: RowEventHandlerParams) => void;
+export type RowHeightChangeHandler = (row: RowHeightChangedParams, fixedDirection: boolean | FixedDirection | undefined) => void;
+export type RowEventHandlers = {
+    onClick?: RowEventHandler;
+    onContextMenu?: RowEventHandler;
+    onDblClick?: RowEventHandler;
+    onMouseEnter?: RowEventHandler;
+    onMouseLeave?: RowEventHandler;
+};
+export interface TableV2RowProps {
+    className?: string;
+    columns: Column<any>[];
+    columnsStyles: Record<KeyType, CSSProperties>;
+    depth?: number;
+    expandColumnKey?: string;
+    estimatedRowHeight?: number;
+    isScrolling?: boolean;
+    onRowExpand?: RowExpandHandler;
+    onRowHover?: RowHoverHandler;
+    onRowHeightChange?: RowHeightChangeHandler;
+    rowData: any;
+    rowEventHandlers?: RowEventHandlers;
+    rowIndex: number;
+    rowKey: KeyType;
+    style?: CSSProperties;
+    rowFormatter?: (props: RowFormatProps) => React.ReactNode[];
+    cellFormatter?: (props: CellFormatProps<any>) => React.ReactNode;
+}

package/dist/TableV2/src/row.js

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

package/dist/TableV2/src/table-grid.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import { GridDefaultSlotParams, GridScrollOptions, ResetAfterIndex } from "../../VirtualList";
+import { ScrollStrategy } from './composables';
+import { TableV2GridProps } from './grid';
+export interface TableGridInstance {
+    forceUpdate: () => void;
+    totalHeight: number | undefined;
+    scrollTo(leftOrOptions: number | GridScrollOptions, top?: number): void;
+    scrollToTop(scrollTop: number): void;
+    scrollToRow(row: number, strategy: ScrollStrategy): void;
+    resetAfterRowIndex: ResetAfterIndex;
+}
+declare const TableGrid: React.ForwardRefExoticComponent<{
+    columns: import("..").Column<any>[];
+    data: any[];
+    fixedData: any[];
+    estimatedRowHeight: number;
+    height: number;
+    width: number;
+    headerWidth?: number;
+    headerHeight?: number | number[];
+    footerHeight?: number;
+    bodyWidth?: number;
+    rowHeight?: number;
+    cache?: number;
+    useIsScrolling?: boolean;
+    scrollbarAlwaysOn?: boolean;
+    scrollbarStartGap?: number;
+    scrollbarEndGap?: number;
+    containerStyle?: React.CSSProperties;
+    getRowHeight: (index: number) => number;
+    rowKey?: string | number | symbol;
+    headerFormatter?: (props: import("..").HeaderSlotProps) => React.ReactNode;
+    rowFormatter?: (props: import("..").TableGridRowSlotParams) => React.ReactNode;
+    onRowsRendered?: (params: import("./grid").onRowRenderedParams) => void;
+    onScroll?: (...args: any[]) => void;
+    children?: (params: import("..").TableGridRowSlotParams) => React.ReactNode;
+} & import("../..").NativeProps & React.RefAttributes<TableGridInstance>>;
+export default TableGrid;
+export type TableGridRowSlotParams = {
+    columns: TableV2GridProps['columns'];
+    rowData: any;
+} & GridDefaultSlotParams;