@aloudata/aloudata-design 2.2.0 → 2.3.0

package/dist/DataPreviewTable/index.js

@@ -103,7 +103,7 @@ var DataPreviewTable = /*#__PURE__*/forwardRef(function (props, ref) {
     columnLayout: columnLayout,
     setWidth: setColumnsWidth,
     columnRange: columnRange
-  }), dataStatus === 'pending' && /*#__PURE__*/React.createElement("div", {
+  }), dataStatus === 'pending' && tableColumns.length > 0 && /*#__PURE__*/React.createElement("div", {
     className: "ald-data-preview-loading"
   }, /*#__PURE__*/React.createElement(Spin, null)), dataStatus === 'success' && /*#__PURE__*/React.createElement(Body, {
     columns: tableColumns,

package/dist/MemberPicker/components/MultipleOption.js

@@ -40,6 +40,7 @@ export default function MultipleList(params) {
   })), isUserGroup(user) && hasNextLevel && /*#__PURE__*/React.createElement(TextLink, {
     className: "ald-member-picker-btn",
     size: "small",
+    disabled: disabled,
     onClick: function onClick(e) {
       onNextLevel === null || onNextLevel === void 0 ? void 0 : onNextLevel(user);
       e.stopPropagation();

package/dist/Switch/index.js

@@ -5,7 +5,9 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 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 { Switch as AntdSwitch } from 'antd';
+import { getMergedStatus, getStatusClassNames } from 'antd/lib/_util/statusUtils';
 import DisabledContext from 'antd/lib/config-provider/DisabledContext';
+import { FormItemInputContext } from 'antd/lib/form/context';
 import classnames from 'classnames';
 import React, { useContext, useEffect, useState } from 'react';
 import SizeContext from "../ConfigProvider/sizeContext";
@@ -31,6 +33,9 @@ var Switch = function Switch(_ref) {
   // ===================== Disabled =====================
   var disabled = React.useContext(DisabledContext);
   var mergedDisabled = customDisabled !== null && customDisabled !== void 0 ? customDisabled : disabled;
+  var _useContext = useContext(FormItemInputContext),
+    contextStatus = _useContext.status;
+  var mergedStatus = getMergedStatus(contextStatus);
   var onChangeCB = function onChangeCB(isChecked, event) {
     if (checked === undefined) {
       setUserChecked(isChecked);
@@ -47,7 +52,7 @@ var Switch = function Switch(_ref) {
     className: classnames(className, 'ald-switch', "ald-switch-".concat(size), {
       'ald-switch-disabled': currentDisabled,
       'ald-switch-checked': userChecked
-    })
+    }, getStatusClassNames('ald-switch', mergedStatus))
   }, /*#__PURE__*/React.createElement(AntdSwitch, {
     disabled: currentDisabled,
     loading: loading,

package/dist/Switch/style/index.less

@@ -1,4 +1,5 @@
 @import '../../style/index.less';
+@import './status.less';
 
 @switch-btn-width-large: 36px;
 @switch-btn-height-large: 20px;

package/dist/Switch/style/status.less

@@ -0,0 +1,12 @@
+.ald-switch.ald-switch.ald-switch-status {
+  &-error {
+    .ald-switch-btn:not(.ant-switch-checked) {
+      box-shadow: 0 0 0 1px var(--alias-colors-icon-inverse-default, #fff),
+        0 0 0 2.5px var(--alias-color-icon-danger, #ef4444);
+    }
+
+    .ald-switch-btn.ant-switch-checked {
+      background-color: var(--alias-color-icon-danger, #ef4444);
+    }
+  }
+}

package/dist/Table/components/Cell.d.ts

@@ -1,6 +1,6 @@
 import { Column, Row } from '@tanstack/react-table';
 import React from 'react';
-export default function Cell<T>(props: IProps<T>): React.JSX.Element;
+export default function CellWithErrorBoundary<T>(props: IProps<T>): React.JSX.Element;
 export interface IProps<T> {
     row: Row<T>;
     column: Column<T>;

package/dist/Table/components/Cell.js

@@ -1,8 +1,9 @@
 import classnames from 'classnames';
 import _ from 'lodash';
-import React from 'react';
+import React, { useCallback } from 'react';
 import { prefixCls } from "../helper";
-export default function Cell(props) {
+import ErrorBoundary from "./ErrorBoundary";
+function Cell(props) {
   var column = props.column,
     row = props.row;
   var meta = column.columnDef.meta;
@@ -17,4 +18,25 @@ export default function Cell(props) {
   }, ellipsis ? /*#__PURE__*/React.createElement("div", {
     className: prefixCls('td-ellipsis-content')
   }, node) : node);
+}
+export default function CellWithErrorBoundary(props) {
+  var column = props.column;
+  var meta = column.columnDef.meta;
+  var dataIndex = meta.dataIndex,
+    onError = meta.onError;
+  var reportError = useCallback(function (err, stack) {
+    if (onError) {
+      onError({
+        error: err,
+        stack: stack,
+        extra: {
+          place: 'bodyCell',
+          dataIndex: dataIndex
+        }
+      });
+    }
+  }, [onError, dataIndex]);
+  return /*#__PURE__*/React.createElement(ErrorBoundary, {
+    onError: reportError
+  }, /*#__PURE__*/React.createElement(Cell, props));
 }

package/dist/Table/components/ErrorBoundary.d.ts

@@ -0,0 +1,15 @@
+import React, { ReactNode } from 'react';
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    onError: (error: Error, stack: string) => void;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+}
+export default class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(): ErrorBoundaryState;
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};

package/dist/Table/components/ErrorBoundary.js

@@ -0,0 +1,56 @@
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import { prefixCls } from "../helper";
+var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
+  _inherits(ErrorBoundary, _React$Component);
+  var _super = _createSuper(ErrorBoundary);
+  function ErrorBoundary(props) {
+    var _this;
+    _classCallCheck(this, ErrorBoundary);
+    _this = _super.call(this, props);
+    _this.state = {
+      hasError: false
+    };
+    return _this;
+  }
+  _createClass(ErrorBoundary, [{
+    key: "componentDidCatch",
+    value: function componentDidCatch(error, info) {
+      // 在这里上报错误信息
+      this.props.onError(error, info.componentStack);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      if (this.state.hasError) {
+        // 你可以渲染任何自定义后备 UI
+        return /*#__PURE__*/React.createElement("div", {
+          className: prefixCls('td-default')
+        }, "\u53D1\u751F\u4E86\u9519\u8BEF");
+      }
+      return this.props.children;
+    }
+  }], [{
+    key: "getDerivedStateFromError",
+    value: function getDerivedStateFromError() {
+      // 更新状态，以便下一次渲染将显示后备 UI。
+      return {
+        hasError: true
+      };
+    }
+  }]);
+  return ErrorBoundary;
+}(React.Component);
+export { ErrorBoundary as default };

package/dist/Table/helper.d.ts

@@ -1,18 +1,28 @@
 /// <reference types="react" />
-import { ITableColumn } from './types';
-export declare function getTableColumns<TDataItem extends object>({ columns, columnSizing, totalWidth, }: {
+import { ITableColumn, ITableProps } from './types';
+export declare function getTableColumns<TDataItem extends object>({ columns, columnSizing, totalWidth, onError, }: {
     columns: ITableColumn<TDataItem>[];
     columnSizing: boolean;
     totalWidth: number;
+    onError: ITableProps<TDataItem>['onError'];
 }): {
     accessorKey: string;
     header: (props: import("./components/Header").IProps<TDataItem>) => import("react").JSX.Element;
     cell: (props: import("./components/Cell").IProps<TDataItem>) => import("react").JSX.Element;
     size: number;
-    meta: ITableColumn<TDataItem>;
+    meta: {
+        onError: ((errorInfo: import("./types").ITableCellErrorInfo) => void) | undefined;
+        title: import("react").ReactNode;
+        dataIndex?: string | undefined;
+        width?: string | number | undefined;
+        render?: ((text: any, record: TDataItem, rowIndex: number) => import("react").ReactNode) | undefined;
+        ellipsis?: boolean | undefined;
+        noPadding?: boolean | undefined;
+        align?: "center" | "left" | "right" | undefined;
+    };
 }[];
 /**
- * 计算
+ * 计算列宽
  * @param columns
  * @param columnSizing
  * @param totalWidth

package/dist/Table/helper.js

@@ -1,10 +1,17 @@
+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); }
 import _ from 'lodash';
 import Cell from "./components/Cell";
 import Header from "./components/Header";
 export function getTableColumns(_ref) {
   var columns = _ref.columns,
     columnSizing = _ref.columnSizing,
-    totalWidth = _ref.totalWidth;
+    totalWidth = _ref.totalWidth,
+    onError = _ref.onError;
   var columnWidths = getColumnWidths(columns, columnSizing, totalWidth);
   return _.map(columns, function (col, index) {
     return {
@@ -13,13 +20,15 @@ export function getTableColumns(_ref) {
       header: Header,
       cell: Cell,
       size: columnWidths[index],
-      meta: col
+      meta: _objectSpread(_objectSpread({}, col), {}, {
+        onError: onError
+      })
     };
   });
 }
 
 /**
- * 计算
+ * 计算列宽
  * @param columns
  * @param columnSizing
  * @param totalWidth

package/dist/Table/index.js

@@ -35,7 +35,8 @@ function Table(props, ref) {
     rowClassName = _props$rowClassName === void 0 ? function () {
       return '';
     } : _props$rowClassName,
-    onRowClick = props.onRowClick;
+    onRowClick = props.onRowClick,
+    onError = props.onError;
   var _useState = useState(null),
     _useState2 = _slicedToArray(_useState, 2),
     totalSize = _useState2[0],
@@ -67,9 +68,10 @@ function Table(props, ref) {
     return getTableColumns({
       columns: columns,
       columnSizing: !!columnSizing,
-      totalWidth: realWidth
+      totalWidth: realWidth,
+      onError: onError
     });
-  }, [columns, totalSize, columnSizing, realWidth]);
+  }, [columns, totalSize, columnSizing, realWidth, onError]);
   var tableInstance = useReactTable({
     columns: tableColumns,
     data: data,
@@ -134,8 +136,7 @@ function Table(props, ref) {
 
   // 渲染 body
   var bodyContent = /*#__PURE__*/React.createElement(Spin, {
-    spinning: !!loading,
-    tip: "Loading..."
+    spinning: !!loading
   }, /*#__PURE__*/React.createElement("div", {
     className: prefixCls('body'),
     style: {
@@ -144,7 +145,6 @@ function Table(props, ref) {
   }, rows.length === 0 && !loading ? emptyComponent || /*#__PURE__*/React.createElement("div", {
     className: prefixCls('empty')
   }, /*#__PURE__*/React.createElement(Empty, {
-    title: "No Data",
     image: Empty.PRESENTED_IMAGE_SEARCH
   })) : _.map(rows, function (row, rowIndex) {
     return /*#__PURE__*/React.createElement("div", {

package/dist/Table/types.d.ts

@@ -14,6 +14,14 @@ export interface ITableProps<TDataItem extends object> {
     empty?: React.ReactNode;
     rowClassName?: (record: TDataItem, index: number) => string;
     onRowClick?: (record: TDataItem, index: number) => void;
+    onError?: (errorInfo: ITableCellErrorInfo) => void;
+}
+export interface ITableCellErrorInfo {
+    error: Error;
+    stack: React.ErrorInfo['componentStack'];
+    extra?: {
+        [key: string]: unknown;
+    };
 }
 export interface ITableRef {
     scrollToFirstRow: () => void;

package/dist/Watermark/index.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export interface IFont {
+    color?: string;
+    fontSize?: number | string;
+    fontWeight?: 'normal' | 'light' | 'weight' | number;
+    fontStyle?: 'none' | 'normal' | 'italic' | 'oblique';
+    fontFamily?: string;
+}
+export interface IWatermarkProps {
+    zIndex?: number;
+    rotate?: number;
+    width?: number;
+    height?: number;
+    image?: string;
+    content?: string | string[];
+    font?: IFont;
+    style?: React.CSSProperties;
+    className?: string;
+    rootClassName?: string;
+    gap?: [number, number];
+    offset?: [number, number];
+    children?: React.ReactNode;
+}
+declare function Watermark(props: IWatermarkProps): React.JSX.Element;
+export default Watermark;

package/dist/Watermark/index.js

@@ -0,0 +1,6 @@
+import { Watermark as AntdWatermark } from 'antd';
+import React from 'react';
+function Watermark(props) {
+  return /*#__PURE__*/React.createElement(AntdWatermark, props);
+}
+export default Watermark;

package/dist/Watermark/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style';
+import './index.less';

package/dist/Watermark/style/index.js

@@ -0,0 +1,2 @@
+import "../../style";
+import "./index.less";

package/dist/Watermark/style/index.less

@@ -0,0 +1 @@
+@import '../../style/index.less';