linkmore-design 1.0.53 → 1.0.54

package/es/_util/getDataOrAriaProps.js

@@ -0,0 +1,9 @@
+export default function getDataOrAriaProps(props) {
+  return Object.keys(props).reduce(function (prev, key) {
+    if ((key.startsWith('data-') || key.startsWith('aria-') || key === 'role') && !key.startsWith('data-__')) {
+      prev[key] = props[key];
+    }
+
+    return prev;
+  }, {});
+}

package/es/_util/reactNode.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export declare const isValidElement: typeof React.isValidElement;
+declare type AnyObject = Record<any, any>;
+declare type RenderProps = undefined | AnyObject | ((originProps: AnyObject) => AnyObject | undefined);
+export declare function replaceElement(element: React.ReactNode, replacement: React.ReactNode, props: RenderProps): React.ReactNode;
+export declare function cloneElement(element: React.ReactNode, props?: RenderProps): React.ReactElement;
+export {};

package/es/_util/reactNode.js

@@ -0,0 +1,10 @@
+import * as React from 'react';
+var isValidElement = React.isValidElement;
+export { isValidElement };
+export function replaceElement(element, replacement, props) {
+  if (!isValidElement(element)) return replacement;
+  return /*#__PURE__*/React.cloneElement(element, typeof props === 'function' ? props(element.props || {}) : props);
+}
+export function cloneElement(element, props) {
+  return replaceElement(element, element, props);
+}

package/es/index.d.ts

@@ -22,7 +22,7 @@ export { default as LmSelect } from './LmSelect';
 export { default as LoadingPage } from './LoadingPage';
 export { default as Menu } from './Menu';
 export { default as Modal } from './Modal';
-export { default as notification } from './Notification';
+export { default as notification } from './notification';
 export { default as OldModal } from './OldModal';
 export { default as Pagination } from './Pagination';
 export { default as PopTable } from './PopTable';

package/es/index.js

@@ -22,7 +22,7 @@ export { default as LmSelect } from './LmSelect';
 export { default as LoadingPage } from './LoadingPage';
 export { default as Menu } from './Menu';
 export { default as Modal } from './Modal';
-export { default as notification } from './Notification';
+export { default as notification } from './notification';
 export { default as OldModal } from './OldModal';
 export { default as Pagination } from './Pagination';
 export { default as PopTable } from './PopTable';

package/es/message/style/index.css

@@ -519,6 +519,7 @@ html {
   animation-iteration-count: 1;
   animation-fill-mode: forwards;
   transition: width 0.2s;
+  animation-timing-function: linear;
 }
 .lm_message:hover .message_progress {
   width: 100%;

package/es/notification/hooks/useNotification.d.ts

@@ -0,0 +1,7 @@
+import type { NoticeContent as RCNoticeContent, NotificationInstance as RCNotificationInstance } from 'rc-notification/lib/Notification';
+import * as React from 'react';
+import type { ArgsProps, NotificationInstance } from '..';
+export default function createUseNotification(getNotificationInstance: (args: ArgsProps, callback: (info: {
+    prefixCls: string;
+    instance: RCNotificationInstance;
+}) => void) => void, getRCNoticeProps: (args: ArgsProps, prefixCls: string) => RCNoticeContent): () => [NotificationInstance, React.ReactElement];

package/es/notification/hooks/useNotification.js

@@ -0,0 +1,54 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import useRCNotification from 'rc-notification/lib/useNotification';
+import * as React from 'react';
+import { ConfigConsumer } from 'antd/es/config-provider';
+export default function createUseNotification(getNotificationInstance, getRCNoticeProps) {
+  var useNotification = function useNotification() {
+    // We can only get content by render
+    var getPrefixCls; // We create a proxy to handle delay created instance
+
+    var innerInstance = null;
+    var proxy = {
+      add: function add(noticeProps, holderCallback) {
+        innerInstance === null || innerInstance === void 0 ? void 0 : innerInstance.component.add(noticeProps, holderCallback);
+      }
+    };
+
+    var _useRCNotification = useRCNotification(proxy),
+        _useRCNotification2 = _slicedToArray(_useRCNotification, 2),
+        hookNotify = _useRCNotification2[0],
+        holder = _useRCNotification2[1];
+
+    function notify(args) {
+      var customizePrefixCls = args.prefixCls;
+      var mergedPrefixCls = getPrefixCls('notification', customizePrefixCls);
+      getNotificationInstance(Object.assign(Object.assign({}, args), {
+        prefixCls: mergedPrefixCls
+      }), function (_ref) {
+        var prefixCls = _ref.prefixCls,
+            instance = _ref.instance;
+        innerInstance = instance;
+        hookNotify(getRCNoticeProps(args, prefixCls));
+      });
+    } // Fill functions
+
+
+    var hookApiRef = React.useRef({});
+    hookApiRef.current.open = notify;
+    ['success', 'info', 'warning', 'error'].forEach(function (type) {
+      hookApiRef.current[type] = function (args) {
+        return hookApiRef.current.open(Object.assign(Object.assign({}, args), {
+          type: type
+        }));
+      };
+    });
+    return [hookApiRef.current, /*#__PURE__*/React.createElement(ConfigConsumer, {
+      key: "holder"
+    }, function (context) {
+      getPrefixCls = context.getPrefixCls;
+      return holder;
+    })];
+  };
+
+  return useNotification;
+}

package/es/notification/index.d.ts

@@ -0,0 +1,54 @@
+import type { NotificationInstance as RCNotificationInstance } from 'rc-notification/lib/Notification';
+import * as React from 'react';
+export declare type NotificationPlacement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight';
+export declare type IconType = 'success' | 'info' | 'error' | 'warning';
+export interface ConfigProps {
+    top?: number;
+    bottom?: number;
+    duration?: number;
+    prefixCls?: string;
+    placement?: NotificationPlacement;
+    getContainer?: () => HTMLElement;
+    closeIcon?: React.ReactNode;
+    rtl?: boolean;
+    maxCount?: number;
+}
+export interface ArgsProps {
+    message: React.ReactNode;
+    description?: React.ReactNode;
+    btn?: React.ReactNode;
+    key?: string;
+    onClose?: () => void;
+    duration?: number | null;
+    icon?: React.ReactNode;
+    placement?: NotificationPlacement;
+    maxCount?: number;
+    style?: React.CSSProperties;
+    prefixCls?: string;
+    className?: string;
+    readonly type?: IconType;
+    onClick?: () => void;
+    top?: number;
+    bottom?: number;
+    getContainer?: () => HTMLElement;
+    closeIcon?: React.ReactNode;
+    progress?: boolean;
+}
+export interface NotificationInstance {
+    success(args: ArgsProps): void;
+    error(args: ArgsProps): void;
+    info(args: ArgsProps): void;
+    warning(args: ArgsProps): void;
+    open(args: ArgsProps): void;
+}
+export interface NotificationApi extends NotificationInstance {
+    warn(args: ArgsProps): void;
+    close(key: string): void;
+    config(options: ConfigProps): void;
+    destroy(): void;
+    useNotification: () => [NotificationInstance, React.ReactElement];
+}
+/** @private test Only function. Not work on production */
+export declare const getInstance: (cacheKey: string) => Promise<RCNotificationInstance>;
+declare const _default: NotificationApi;
+export default _default;

package/es/notification/index.js

@@ -0,0 +1,342 @@
+import "antd/es/notification/style";
+import _notification from "antd/es/notification";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+import { CheckCircleOutlined, CloseCircleOutlined, CloseOutlined, ExclamationCircleOutlined, InfoCircleOutlined } from '@ant-design/icons';
+import classNames from 'classnames';
+import Notification from 'rc-notification';
+import * as React from 'react';
+import ConfigProvider, { globalConfig } from 'antd/es/config-provider';
+import createUseNotification from './hooks/useNotification';
+var notificationInstance = {};
+var defaultDuration = 4.5;
+var defaultTop = 24;
+var defaultBottom = 24;
+var defaultPrefixCls = '';
+var defaultPlacement = 'topRight';
+var defaultGetContainer;
+var defaultCloseIcon;
+var rtl = false;
+var maxCount;
+
+function setNotificationConfig(options) {
+  var duration = options.duration,
+      placement = options.placement,
+      bottom = options.bottom,
+      top = options.top,
+      getContainer = options.getContainer,
+      closeIcon = options.closeIcon,
+      prefixCls = options.prefixCls;
+
+  if (prefixCls !== undefined) {
+    defaultPrefixCls = prefixCls;
+  }
+
+  if (duration !== undefined) {
+    defaultDuration = duration;
+  }
+
+  if (placement !== undefined) {
+    defaultPlacement = placement;
+  } else if (options.rtl) {
+    defaultPlacement = 'topLeft';
+  }
+
+  if (bottom !== undefined) {
+    defaultBottom = bottom;
+  }
+
+  if (top !== undefined) {
+    defaultTop = top;
+  }
+
+  if (getContainer !== undefined) {
+    defaultGetContainer = getContainer;
+  }
+
+  if (closeIcon !== undefined) {
+    defaultCloseIcon = closeIcon;
+  }
+
+  if (options.rtl !== undefined) {
+    rtl = options.rtl;
+  }
+
+  if (options.maxCount !== undefined) {
+    maxCount = options.maxCount;
+  }
+}
+
+function getPlacementStyle(placement) {
+  var top = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultTop;
+  var bottom = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultBottom;
+  var style;
+
+  switch (placement) {
+    case 'top':
+      style = {
+        left: '50%',
+        transform: 'translateX(-50%)',
+        right: 'auto',
+        top: top,
+        bottom: 'auto'
+      };
+      break;
+
+    case 'topLeft':
+      style = {
+        left: 0,
+        top: top,
+        bottom: 'auto'
+      };
+      break;
+
+    case 'topRight':
+      style = {
+        right: 0,
+        top: top,
+        bottom: 'auto'
+      };
+      break;
+
+    case 'bottom':
+      style = {
+        left: '50%',
+        transform: 'translateX(-50%)',
+        right: 'auto',
+        top: 'auto',
+        bottom: bottom
+      };
+      break;
+
+    case 'bottomLeft':
+      style = {
+        left: 0,
+        top: 'auto',
+        bottom: bottom
+      };
+      break;
+
+    default:
+      style = {
+        right: 0,
+        top: 'auto',
+        bottom: bottom
+      };
+      break;
+  }
+
+  return style;
+}
+
+function getNotificationInstance(args, callback) {
+  var _args$placement = args.placement,
+      placement = _args$placement === void 0 ? defaultPlacement : _args$placement,
+      top = args.top,
+      bottom = args.bottom,
+      _args$getContainer = args.getContainer,
+      getContainer = _args$getContainer === void 0 ? defaultGetContainer : _args$getContainer,
+      customizePrefixCls = args.prefixCls;
+
+  var _globalConfig = globalConfig(),
+      getPrefixCls = _globalConfig.getPrefixCls,
+      getIconPrefixCls = _globalConfig.getIconPrefixCls;
+
+  var prefixCls = getPrefixCls('notification', customizePrefixCls || defaultPrefixCls);
+  var iconPrefixCls = getIconPrefixCls();
+  var cacheKey = "".concat(prefixCls, "-").concat(placement);
+  var cacheInstance = notificationInstance[cacheKey];
+
+  if (cacheInstance) {
+    Promise.resolve(cacheInstance).then(function (instance) {
+      callback({
+        prefixCls: "".concat(prefixCls, "-notice"),
+        iconPrefixCls: iconPrefixCls,
+        instance: instance
+      });
+    });
+    return;
+  }
+
+  var notificationClass = classNames("".concat(prefixCls, "-").concat(placement), _defineProperty({}, "".concat(prefixCls, "-rtl"), rtl === true));
+  notificationInstance[cacheKey] = new Promise(function (resolve) {
+    Notification.newInstance({
+      prefixCls: prefixCls,
+      className: notificationClass,
+      style: getPlacementStyle(placement, top, bottom),
+      getContainer: getContainer,
+      maxCount: maxCount
+    }, function (notification) {
+      resolve(notification);
+      callback({
+        prefixCls: "".concat(prefixCls, "-notice"),
+        iconPrefixCls: iconPrefixCls,
+        instance: notification
+      });
+    });
+  });
+}
+
+var typeToIcon = {
+  success: CheckCircleOutlined,
+  info: InfoCircleOutlined,
+  error: CloseCircleOutlined,
+  warning: ExclamationCircleOutlined
+};
+
+function getRCNoticeProps(args, prefixCls, iconPrefixCls) {
+  var durationArg = args.duration,
+      icon = args.icon,
+      type = args.type,
+      description = args.description,
+      message = args.message,
+      btn = args.btn,
+      onClose = args.onClose,
+      onClick = args.onClick,
+      key = args.key,
+      style = args.style,
+      className = args.className,
+      _args$closeIcon = args.closeIcon,
+      closeIcon = _args$closeIcon === void 0 ? defaultCloseIcon : _args$closeIcon,
+      _args$progress = args.progress,
+      progress = _args$progress === void 0 ? true : _args$progress;
+  var duration = durationArg === undefined ? defaultDuration : durationArg;
+  var iconNode = null;
+
+  if (icon) {
+    iconNode = /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "-icon")
+    }, args.icon);
+  } else if (type) {
+    iconNode = /*#__PURE__*/React.createElement(typeToIcon[type] || null, {
+      className: "".concat(prefixCls, "-icon ").concat(prefixCls, "-icon-").concat(type)
+    });
+  }
+
+  var closeIconToRender = /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-close-x")
+  }, closeIcon || /*#__PURE__*/React.createElement(CloseOutlined, {
+    className: "".concat(prefixCls, "-close-icon")
+  }));
+  var autoMarginTag = !description && iconNode ? /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-message-single-line-auto-margin")
+  }) : null;
+  return {
+    content: /*#__PURE__*/React.createElement(ConfigProvider, {
+      iconPrefixCls: iconPrefixCls
+    }, /*#__PURE__*/React.createElement("div", {
+      className: iconNode ? "".concat(prefixCls, "-with-icon") : '',
+      role: "alert"
+    }, iconNode, /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "-message")
+    }, autoMarginTag, message), /*#__PURE__*/React.createElement("div", {
+      className: "".concat(prefixCls, "-description")
+    }, description), btn ? /*#__PURE__*/React.createElement("span", {
+      className: "".concat(prefixCls, "-btn")
+    }, btn) : null, progress && duration > 0 && /*#__PURE__*/React.createElement("div", {
+      className: 'message_progress',
+      style: {
+        animationDuration: "".concat(duration, "s")
+      }
+    }))),
+    duration: duration,
+    closable: true,
+    closeIcon: closeIconToRender,
+    onClose: onClose,
+    onClick: onClick,
+    key: key,
+    style: style || {},
+    className: classNames(className, _defineProperty({}, "".concat(prefixCls, "-").concat(type), !!type), 'lm_notification')
+  };
+}
+
+function notice(args) {
+  getNotificationInstance(args, function (_ref) {
+    var prefixCls = _ref.prefixCls,
+        iconPrefixCls = _ref.iconPrefixCls,
+        instance = _ref.instance;
+    instance.notice(getRCNoticeProps(args, prefixCls, iconPrefixCls));
+  });
+}
+
+var api = {
+  open: notice,
+  close: function close(key) {
+    Object.keys(notificationInstance).forEach(function (cacheKey) {
+      return Promise.resolve(notificationInstance[cacheKey]).then(function (instance) {
+        instance.removeNotice(key);
+      });
+    });
+  },
+  config: setNotificationConfig,
+  destroy: function destroy() {
+    Object.keys(notificationInstance).forEach(function (cacheKey) {
+      Promise.resolve(notificationInstance[cacheKey]).then(function (instance) {
+        instance.destroy();
+      });
+      delete notificationInstance[cacheKey]; // lgtm[js/missing-await]
+    });
+  }
+};
+['success', 'info', 'warning', 'error'].forEach(function (type) {
+  api[type] = function (args) {
+    return api.open(Object.assign(Object.assign({}, args), {
+      type: type
+    }));
+  };
+});
+api.warn = api.warning;
+api.useNotification = createUseNotification(getNotificationInstance, getRCNoticeProps);
+api.antdNotification = _notification;
+/** @private test Only function. Not work on production */
+
+export var getInstance = function getInstance(cacheKey) {
+  return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", process.env.NODE_ENV === 'test' ? notificationInstance[cacheKey] : null);
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+};
+export default api;