@nocobase/plugin-client 0.11.1-alpha.5 → 0.12.0-alpha.2

package/dist/locale/antd/notification/PurePanel.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.TypeIcon = exports.PureContent = void 0;
+exports.getCloseIcon = getCloseIcon;
+var _CheckCircleFilled = _interopRequireDefault(require("@ant-design/icons/CheckCircleFilled"));
+var _CloseCircleFilled = _interopRequireDefault(require("@ant-design/icons/CloseCircleFilled"));
+var _CloseOutlined = _interopRequireDefault(require("@ant-design/icons/CloseOutlined"));
+var _ExclamationCircleFilled = _interopRequireDefault(require("@ant-design/icons/ExclamationCircleFilled"));
+var _InfoCircleFilled = _interopRequireDefault(require("@ant-design/icons/InfoCircleFilled"));
+var _LoadingOutlined = _interopRequireDefault(require("@ant-design/icons/LoadingOutlined"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rcNotification = require("rc-notification");
+var React = _interopRequireWildcard(require("react"));
+var _configProvider = require("../config-provider");
+var _style = _interopRequireDefault(require("./style"));
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+const TypeIcon = {
+  info: /*#__PURE__*/React.createElement(_InfoCircleFilled.default, null),
+  success: /*#__PURE__*/React.createElement(_CheckCircleFilled.default, null),
+  error: /*#__PURE__*/React.createElement(_CloseCircleFilled.default, null),
+  warning: /*#__PURE__*/React.createElement(_ExclamationCircleFilled.default, null),
+  loading: /*#__PURE__*/React.createElement(_LoadingOutlined.default, null)
+};
+exports.TypeIcon = TypeIcon;
+function getCloseIcon(prefixCls, closeIcon) {
+  if (closeIcon === null || closeIcon === false) {
+    return null;
+  }
+  return closeIcon || /*#__PURE__*/React.createElement("span", {
+    className: `${prefixCls}-close-x`
+  }, /*#__PURE__*/React.createElement(_CloseOutlined.default, {
+    className: `${prefixCls}-close-icon`
+  }));
+}
+const typeToIcon = {
+  success: _CheckCircleFilled.default,
+  info: _InfoCircleFilled.default,
+  error: _CloseCircleFilled.default,
+  warning: _ExclamationCircleFilled.default
+};
+const PureContent = props => {
+  const {
+    prefixCls,
+    icon,
+    type,
+    message,
+    description,
+    btn,
+    role = 'alert'
+  } = props;
+  let iconNode = null;
+  if (icon) {
+    iconNode = /*#__PURE__*/React.createElement("span", {
+      className: `${prefixCls}-icon`
+    }, icon);
+  } else if (type) {
+    iconNode = /*#__PURE__*/React.createElement(typeToIcon[type] || null, {
+      className: (0, _classnames.default)(`${prefixCls}-icon`, `${prefixCls}-icon-${type}`)
+    });
+  }
+  return /*#__PURE__*/React.createElement("div", {
+    className: (0, _classnames.default)({
+      [`${prefixCls}-with-icon`]: iconNode
+    }),
+    role: role
+  }, iconNode, /*#__PURE__*/React.createElement("div", {
+    className: `${prefixCls}-message`
+  }, message), /*#__PURE__*/React.createElement("div", {
+    className: `${prefixCls}-description`
+  }, description), btn && /*#__PURE__*/React.createElement("div", {
+    className: `${prefixCls}-btn`
+  }, btn));
+};
+/** @private Internal Component. Do not use in your production. */
+exports.PureContent = PureContent;
+const PurePanel = props => {
+  const {
+      prefixCls: staticPrefixCls,
+      className,
+      icon,
+      type,
+      message,
+      description,
+      btn,
+      closable = true,
+      closeIcon
+    } = props,
+    restProps = __rest(props, ["prefixCls", "className", "icon", "type", "message", "description", "btn", "closable", "closeIcon"]);
+  const {
+    getPrefixCls
+  } = React.useContext(_configProvider.ConfigContext);
+  const prefixCls = staticPrefixCls || getPrefixCls('notification');
+  const noticePrefixCls = `${prefixCls}-notice`;
+  const [, hashId] = (0, _style.default)(prefixCls);
+  return /*#__PURE__*/React.createElement(_rcNotification.Notice, Object.assign({}, restProps, {
+    prefixCls: prefixCls,
+    className: (0, _classnames.default)(className, hashId, `${noticePrefixCls}-pure-panel`),
+    eventKey: "pure",
+    duration: null,
+    closable: closable,
+    closeIcon: getCloseIcon(prefixCls, closeIcon),
+    content: /*#__PURE__*/React.createElement(PureContent, {
+      prefixCls: noticePrefixCls,
+      icon: icon,
+      type: type,
+      message: message,
+      description: description,
+      btn: btn
+    })
+  }));
+};
+var _default = PurePanel;
+exports.default = _default;

package/dist/locale/antd/notification/index.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import PurePanel from './PurePanel';
+import type { ArgsProps } from './interface';
+import useNotification from './useNotification';
+interface BaseMethods {
+    open: (config: ArgsProps) => void;
+    destroy: (key?: React.Key) => void;
+    config: any;
+    useNotification: typeof useNotification;
+    /** @private Internal Component. Do not use in your production. */
+    _InternalPanelDoNotUseOrYouWillBeFired: typeof PurePanel;
+}
+type StaticFn = (config: ArgsProps) => void;
+interface NoticeMethods {
+    success: StaticFn;
+    info: StaticFn;
+    warning: StaticFn;
+    error: StaticFn;
+}
+declare const staticMethods: NoticeMethods & BaseMethods;
+export default staticMethods;

package/dist/locale/antd/notification/index.js

@@ -0,0 +1,203 @@
+"use strict";
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.actWrapper = void 0;
+var _render = require("rc-util/lib/React/render");
+var React = _interopRequireWildcard(require("react"));
+var _configProvider = _interopRequireWildcard(require("../config-provider"));
+var _PurePanel = _interopRequireDefault(require("./PurePanel"));
+var _useNotification = _interopRequireWildcard(require("./useNotification"));
+let notification = null;
+let act = callback => callback();
+let taskQueue = [];
+let defaultGlobalConfig = {};
+function getGlobalContext() {
+  const {
+    prefixCls: globalPrefixCls,
+    getContainer: globalGetContainer,
+    rtl,
+    maxCount,
+    top,
+    bottom
+  } = defaultGlobalConfig;
+  const mergedPrefixCls = globalPrefixCls !== null && globalPrefixCls !== void 0 ? globalPrefixCls : (0, _configProvider.globalConfig)().getPrefixCls('notification');
+  const mergedContainer = (globalGetContainer === null || globalGetContainer === void 0 ? void 0 : globalGetContainer()) || document.body;
+  return {
+    prefixCls: mergedPrefixCls,
+    container: mergedContainer,
+    rtl,
+    maxCount,
+    top,
+    bottom
+  };
+}
+const GlobalHolder = /*#__PURE__*/React.forwardRef((_, ref) => {
+  const [prefixCls, setPrefixCls] = React.useState();
+  const [container, setContainer] = React.useState();
+  const [maxCount, setMaxCount] = React.useState();
+  const [rtl, setRTL] = React.useState();
+  const [top, setTop] = React.useState();
+  const [bottom, setBottom] = React.useState();
+  const [api, holder] = (0, _useNotification.useInternalNotification)({
+    prefixCls,
+    getContainer: () => container,
+    maxCount,
+    rtl,
+    top,
+    bottom
+  });
+  const global = (0, _configProvider.globalConfig)();
+  const rootPrefixCls = global.getRootPrefixCls();
+  const rootIconPrefixCls = global.getIconPrefixCls();
+  const theme = global.getTheme();
+  const sync = () => {
+    const {
+      prefixCls: nextGlobalPrefixCls,
+      container: nextGlobalContainer,
+      maxCount: nextGlobalMaxCount,
+      rtl: nextGlobalRTL,
+      top: nextTop,
+      bottom: nextBottom
+    } = getGlobalContext();
+    setPrefixCls(nextGlobalPrefixCls);
+    setContainer(nextGlobalContainer);
+    setMaxCount(nextGlobalMaxCount);
+    setRTL(nextGlobalRTL);
+    setTop(nextTop);
+    setBottom(nextBottom);
+  };
+  React.useEffect(sync, []);
+  React.useImperativeHandle(ref, () => {
+    const instance = Object.assign({}, api);
+    Object.keys(instance).forEach(method => {
+      instance[method] = function () {
+        sync();
+        return api[method].apply(api, arguments);
+      };
+    });
+    return {
+      instance,
+      sync
+    };
+  });
+  return /*#__PURE__*/React.createElement(_configProvider.default, {
+    prefixCls: rootPrefixCls,
+    iconPrefixCls: rootIconPrefixCls,
+    theme: theme
+  }, holder);
+});
+function flushNotice() {
+  if (!notification) {
+    const holderFragment = document.createDocumentFragment();
+    const newNotification = {
+      fragment: holderFragment
+    };
+    notification = newNotification;
+    // Delay render to avoid sync issue
+    act(() => {
+      (0, _render.render)( /*#__PURE__*/React.createElement(GlobalHolder, {
+        ref: node => {
+          const {
+            instance,
+            sync
+          } = node || {};
+          Promise.resolve().then(() => {
+            if (!newNotification.instance && instance) {
+              newNotification.instance = instance;
+              newNotification.sync = sync;
+              flushNotice();
+            }
+          });
+        }
+      }), holderFragment);
+    });
+    return;
+  }
+  // Notification not ready
+  if (!notification.instance) {
+    return;
+  }
+  // >>> Execute task
+  taskQueue.forEach(task => {
+    // eslint-disable-next-line default-case
+    switch (task.type) {
+      case 'open':
+        {
+          act(() => {
+            notification.instance.open(Object.assign(Object.assign({}, defaultGlobalConfig), task.config));
+          });
+          break;
+        }
+      case 'destroy':
+        act(() => {
+          notification === null || notification === void 0 ? void 0 : notification.instance.destroy(task.key);
+        });
+        break;
+    }
+  });
+  // Clean up
+  taskQueue = [];
+}
+// ==============================================================================
+// ==                                  Export                                  ==
+// ==============================================================================
+function setNotificationGlobalConfig(config) {
+  defaultGlobalConfig = Object.assign(Object.assign({}, defaultGlobalConfig), config);
+  // Trigger sync for it
+  act(() => {
+    var _a;
+    (_a = notification === null || notification === void 0 ? void 0 : notification.sync) === null || _a === void 0 ? void 0 : _a.call(notification);
+  });
+}
+function open(config) {
+  // Warning if exist theme
+  if (process.env.NODE_ENV !== 'production') {
+    (0, _configProvider.warnContext)('notification');
+  }
+  taskQueue.push({
+    type: 'open',
+    config
+  });
+  flushNotice();
+}
+function destroy(key) {
+  taskQueue.push({
+    type: 'destroy',
+    key
+  });
+  flushNotice();
+}
+const methods = ['success', 'info', 'warning', 'error'];
+const baseStaticMethods = {
+  open,
+  destroy,
+  config: setNotificationGlobalConfig,
+  useNotification: _useNotification.default,
+  _InternalPanelDoNotUseOrYouWillBeFired: _PurePanel.default
+};
+const staticMethods = baseStaticMethods;
+methods.forEach(type => {
+  staticMethods[type] = config => open(Object.assign(Object.assign({}, config), {
+    type
+  }));
+});
+// ==============================================================================
+// ==                                   Test                                   ==
+// ==============================================================================
+const noop = () => {};
+/** @internal Only Work in test env */
+// eslint-disable-next-line import/no-mutable-exports
+let actWrapper = noop;
+exports.actWrapper = actWrapper;
+if (process.env.NODE_ENV === 'test') {
+  exports.actWrapper = actWrapper = wrapper => {
+    act = wrapper;
+  };
+}
+var _default = staticMethods;
+exports.default = _default;

package/dist/locale/antd/notification/interface.d.ts

@@ -0,0 +1,54 @@
+import type * as React from 'react';
+interface DivProps extends React.HTMLProps<HTMLDivElement> {
+    'data-testid'?: string;
+}
+export type NotificationPlacement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight';
+export type IconType = 'success' | 'info' | 'error' | 'warning';
+export interface ArgsProps {
+    message: React.ReactNode;
+    description?: React.ReactNode;
+    btn?: React.ReactNode;
+    key?: React.Key;
+    onClose?: () => void;
+    duration?: number | null;
+    icon?: React.ReactNode;
+    placement?: NotificationPlacement;
+    style?: React.CSSProperties;
+    className?: string;
+    readonly type?: IconType;
+    onClick?: () => void;
+    closeIcon?: boolean | React.ReactNode;
+    props?: DivProps;
+    role?: 'alert' | 'status';
+}
+type StaticFn = (args: ArgsProps) => void;
+export interface NotificationInstance {
+    success: StaticFn;
+    error: StaticFn;
+    info: StaticFn;
+    warning: StaticFn;
+    open: StaticFn;
+    destroy(key?: React.Key): void;
+}
+export interface GlobalConfigProps {
+    top?: number;
+    bottom?: number;
+    duration?: number;
+    prefixCls?: string;
+    getContainer?: () => HTMLElement | ShadowRoot;
+    placement?: NotificationPlacement;
+    closeIcon?: React.ReactNode;
+    rtl?: boolean;
+    maxCount?: number;
+    props?: DivProps;
+}
+export interface NotificationConfig {
+    top?: number;
+    bottom?: number;
+    prefixCls?: string;
+    getContainer?: () => HTMLElement | ShadowRoot;
+    placement?: NotificationPlacement;
+    maxCount?: number;
+    rtl?: boolean;
+}
+export {};

package/dist/locale/antd/notification/interface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/locale/antd/notification/style/index.d.ts

@@ -0,0 +1,27 @@
+import type { FullToken } from '../../theme/internal';
+/** Component only token. Which will handle additional calculation of alias token */
+export interface ComponentToken {
+    /**
+     * @desc 提醒框 z-index
+     * @descEN z-index of Notification
+     */
+    zIndexPopup: number;
+    /**
+     * @desc 提醒框宽度
+     * @descEN Width of Notification
+     */
+    width: number;
+}
+export interface NotificationToken extends FullToken<'Notification'> {
+    animationMaxHeight: number;
+    notificationBg: string;
+    notificationPadding: string;
+    notificationPaddingVertical: number;
+    notificationPaddingHorizontal: number;
+    notificationIconSize: number;
+    notificationCloseButtonSize: number;
+    notificationMarginBottom: number;
+    notificationMarginEdge: number;
+}
+declare const _default: (prefixCls: string) => import("../../theme/interface").UseComponentStyleResult;
+export default _default;

package/dist/locale/antd/notification/style/index.js

@@ -0,0 +1,238 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cssinjs = require("@ant-design/cssinjs");
+var _style = require("../../style");
+var _internal = require("../../theme/internal");
+var _placement = _interopRequireDefault(require("./placement"));
+const genNotificationStyle = token => {
+  const {
+    iconCls,
+    componentCls,
+    // .ant-notification
+    boxShadow,
+    fontSizeLG,
+    notificationMarginBottom,
+    borderRadiusLG,
+    colorSuccess,
+    colorInfo,
+    colorWarning,
+    colorError,
+    colorTextHeading,
+    notificationBg,
+    notificationPadding,
+    notificationMarginEdge,
+    motionDurationMid,
+    motionEaseInOut,
+    fontSize,
+    lineHeight,
+    width,
+    notificationIconSize,
+    colorText
+  } = token;
+  const noticeCls = `${componentCls}-notice`;
+  const notificationFadeIn = new _cssinjs.Keyframes('antNotificationFadeIn', {
+    '0%': {
+      left: {
+        _skip_check_: true,
+        value: width
+      },
+      opacity: 0
+    },
+    '100%': {
+      left: {
+        _skip_check_: true,
+        value: 0
+      },
+      opacity: 1
+    }
+  });
+  const notificationFadeOut = new _cssinjs.Keyframes('antNotificationFadeOut', {
+    '0%': {
+      maxHeight: token.animationMaxHeight,
+      marginBottom: notificationMarginBottom,
+      opacity: 1
+    },
+    '100%': {
+      maxHeight: 0,
+      marginBottom: 0,
+      paddingTop: 0,
+      paddingBottom: 0,
+      opacity: 0
+    }
+  });
+  const noticeStyle = {
+    position: 'relative',
+    width,
+    maxWidth: `calc(100vw - ${notificationMarginEdge * 2}px)`,
+    marginBottom: notificationMarginBottom,
+    marginInlineStart: 'auto',
+    padding: notificationPadding,
+    overflow: 'hidden',
+    lineHeight,
+    wordWrap: 'break-word',
+    background: notificationBg,
+    borderRadius: borderRadiusLG,
+    boxShadow,
+    [`${componentCls}-close-icon`]: {
+      fontSize,
+      cursor: 'pointer'
+    },
+    [`${noticeCls}-message`]: {
+      marginBottom: token.marginXS,
+      color: colorTextHeading,
+      fontSize: fontSizeLG,
+      lineHeight: token.lineHeightLG
+    },
+    [`${noticeCls}-description`]: {
+      fontSize,
+      color: colorText
+    },
+    [`&${noticeCls}-closable ${noticeCls}-message`]: {
+      paddingInlineEnd: token.paddingLG
+    },
+    [`${noticeCls}-with-icon ${noticeCls}-message`]: {
+      marginBottom: token.marginXS,
+      marginInlineStart: token.marginSM + notificationIconSize,
+      fontSize: fontSizeLG
+    },
+    [`${noticeCls}-with-icon ${noticeCls}-description`]: {
+      marginInlineStart: token.marginSM + notificationIconSize,
+      fontSize
+    },
+    // Icon & color style in different selector level
+    // https://github.com/ant-design/ant-design/issues/16503
+    // https://github.com/ant-design/ant-design/issues/15512
+    [`${noticeCls}-icon`]: {
+      position: 'absolute',
+      fontSize: notificationIconSize,
+      lineHeight: 0,
+      // icon-font
+      [`&-success${iconCls}`]: {
+        color: colorSuccess
+      },
+      [`&-info${iconCls}`]: {
+        color: colorInfo
+      },
+      [`&-warning${iconCls}`]: {
+        color: colorWarning
+      },
+      [`&-error${iconCls}`]: {
+        color: colorError
+      }
+    },
+    [`${noticeCls}-close`]: {
+      position: 'absolute',
+      top: token.notificationPaddingVertical,
+      insetInlineEnd: token.notificationPaddingHorizontal,
+      color: token.colorIcon,
+      outline: 'none',
+      width: token.notificationCloseButtonSize,
+      height: token.notificationCloseButtonSize,
+      borderRadius: token.borderRadiusSM,
+      transition: `background-color ${token.motionDurationMid}, color ${token.motionDurationMid}`,
+      display: 'flex',
+      alignItems: 'center',
+      justifyContent: 'center',
+      '&:hover': {
+        color: token.colorIconHover,
+        backgroundColor: token.wireframe ? 'transparent' : token.colorFillContent
+      }
+    },
+    [`${noticeCls}-btn`]: {
+      float: 'right',
+      marginTop: token.marginSM
+    }
+  };
+  return [
+  // ============================ Holder ============================
+  {
+    [componentCls]: Object.assign(Object.assign(Object.assign(Object.assign({}, (0, _style.resetComponent)(token)), {
+      position: 'fixed',
+      zIndex: token.zIndexPopup,
+      marginInlineEnd: notificationMarginEdge,
+      [`${componentCls}-hook-holder`]: {
+        position: 'relative'
+      },
+      [`&${componentCls}-top, &${componentCls}-bottom`]: {
+        [noticeCls]: {
+          marginInline: 'auto auto'
+        }
+      },
+      [`&${componentCls}-topLeft, &${componentCls}-bottomLeft`]: {
+        [noticeCls]: {
+          marginInlineEnd: 'auto',
+          marginInlineStart: 0
+        }
+      },
+      //  animation
+      [`${componentCls}-fade-enter, ${componentCls}-fade-appear`]: {
+        animationDuration: token.motionDurationMid,
+        animationTimingFunction: motionEaseInOut,
+        animationFillMode: 'both',
+        opacity: 0,
+        animationPlayState: 'paused'
+      },
+      [`${componentCls}-fade-leave`]: {
+        animationTimingFunction: motionEaseInOut,
+        animationFillMode: 'both',
+        animationDuration: motionDurationMid,
+        animationPlayState: 'paused'
+      },
+      [`${componentCls}-fade-enter${componentCls}-fade-enter-active, ${componentCls}-fade-appear${componentCls}-fade-appear-active`]: {
+        animationName: notificationFadeIn,
+        animationPlayState: 'running'
+      },
+      [`${componentCls}-fade-leave${componentCls}-fade-leave-active`]: {
+        animationName: notificationFadeOut,
+        animationPlayState: 'running'
+      }
+    }), (0, _placement.default)(token)), {
+      // RTL
+      '&-rtl': {
+        direction: 'rtl',
+        [`${noticeCls}-btn`]: {
+          float: 'left'
+        }
+      }
+    })
+  },
+  // ============================ Notice ============================
+  {
+    [componentCls]: {
+      [noticeCls]: Object.assign({}, noticeStyle)
+    }
+  },
+  // ============================= Pure =============================
+  {
+    [`${noticeCls}-pure-panel`]: Object.assign(Object.assign({}, noticeStyle), {
+      margin: 0
+    })
+  }];
+};
+// ============================== Export ==============================
+var _default = (0, _internal.genComponentStyleHook)('Notification', token => {
+  const notificationPaddingVertical = token.paddingMD;
+  const notificationPaddingHorizontal = token.paddingLG;
+  const notificationToken = (0, _internal.mergeToken)(token, {
+    // index.less variables
+    notificationBg: token.colorBgElevated,
+    notificationPaddingVertical,
+    notificationPaddingHorizontal,
+    notificationIconSize: token.fontSizeLG * token.lineHeightLG,
+    notificationCloseButtonSize: token.controlHeightLG * 0.55,
+    notificationMarginBottom: token.margin,
+    notificationPadding: `${token.paddingMD}px ${token.paddingContentHorizontalLG}px`,
+    notificationMarginEdge: token.marginLG,
+    animationMaxHeight: 150
+  });
+  return [genNotificationStyle(notificationToken)];
+}, token => ({
+  zIndexPopup: token.zIndexPopupBase + 50,
+  width: 384
+}));
+exports.default = _default;

package/dist/locale/antd/notification/style/placement.d.ts

@@ -0,0 +1,5 @@
+import type { CSSObject } from '@ant-design/cssinjs';
+import type { NotificationToken } from '.';
+import type { GenerateStyle } from '../../theme/internal';
+declare const genNotificationPlacementStyle: GenerateStyle<NotificationToken, CSSObject>;
+export default genNotificationPlacementStyle;