@fle-ui/next 2.0.0-alpha.7 → 2.0.0-alpha.8

package/lib/config-provider/SizeContext.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.SizeContextProvider = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var SizeContext = /*#__PURE__*/React.createContext(undefined);
+
+var SizeContextProvider = function SizeContextProvider(_ref) {
+  var children = _ref.children,
+      size = _ref.size;
+  return /*#__PURE__*/React.createElement(SizeContext.Consumer, null, function (originSize) {
+    return /*#__PURE__*/React.createElement(SizeContext.Provider, {
+      value: size || originSize
+    }, children);
+  });
+};
+
+exports.SizeContextProvider = SizeContextProvider;
+var _default = SizeContext;
+exports["default"] = _default;

package/lib/config-provider/context.d.ts

@@ -0,0 +1,58 @@
+import * as React from 'react';
+import type { RequiredMark } from '../form/Form';
+import type { Locale } from '../locale-provider';
+import type { RenderEmptyHandler } from './defaultRenderEmpty';
+import type { SizeType } from './SizeContext';
+export interface Theme {
+    primaryColor?: string;
+    infoColor?: string;
+    successColor?: string;
+    processingColor?: string;
+    errorColor?: string;
+    warningColor?: string;
+}
+export interface CSPConfig {
+    nonce?: string;
+}
+export type DirectionType = 'ltr' | 'rtl' | undefined;
+export interface ConfigConsumerProps {
+    getTargetContainer?: () => HTMLElement;
+    getPopupContainer?: (triggerNode?: HTMLElement) => HTMLElement;
+    rootPrefixCls?: string;
+    iconPrefixCls?: string;
+    getPrefixCls: (suffixCls?: string, customizePrefixCls?: string) => string;
+    renderEmpty?: RenderEmptyHandler;
+    csp?: CSPConfig;
+    autoInsertSpaceInButton?: boolean;
+    input?: {
+        autoComplete?: string;
+    };
+    pagination?: {
+        showSizeChanger?: boolean;
+    };
+    locale?: Locale;
+    pageHeader?: {
+        ghost: boolean;
+    };
+    direction?: DirectionType;
+    space?: {
+        size?: SizeType | number;
+    };
+    virtual?: boolean;
+    dropdownMatchSelectWidth?: boolean;
+    form?: {
+        requiredMark?: RequiredMark;
+        colon?: boolean;
+    };
+}
+export declare const ConfigContext: React.Context<ConfigConsumerProps>;
+export declare const ConfigConsumer: React.Consumer<ConfigConsumerProps>;
+interface BasicExportProps {
+    prefixCls?: string;
+}
+interface ConsumerConfig {
+    prefixCls: string;
+}
+/** @deprecated Use hooks instead. This is a legacy function */
+export declare function withConfigConsumer<ExportProps extends BasicExportProps>(config: ConsumerConfig): <ComponentDef>(Component: React.ComponentType<ExportProps>) => React.FC<ExportProps> & ComponentDef;
+export {};

package/lib/config-provider/context.js

@@ -0,0 +1,57 @@
+"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.ConfigContext = exports.ConfigConsumer = void 0;
+exports.withConfigConsumer = withConfigConsumer;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var defaultGetPrefixCls = function defaultGetPrefixCls(suffixCls, customizePrefixCls) {
+  if (customizePrefixCls) return customizePrefixCls;
+  return suffixCls ? "ant-".concat(suffixCls) : 'ant';
+}; // zombieJ: 🚨 Do not pass `defaultRenderEmpty` here since it will case circular dependency.
+
+
+var ConfigContext = /*#__PURE__*/React.createContext({
+  // We provide a default function for Context without provider
+  getPrefixCls: defaultGetPrefixCls
+});
+exports.ConfigContext = ConfigContext;
+var ConfigConsumer = ConfigContext.Consumer;
+/** @deprecated Use hooks instead. This is a legacy function */
+
+exports.ConfigConsumer = ConfigConsumer;
+
+function withConfigConsumer(config) {
+  return function withConfigConsumerFunc(Component) {
+    // Wrap with ConfigConsumer. Since we need compatible with react 15, be care when using ref methods
+    var SFC = function SFC(props) {
+      return /*#__PURE__*/React.createElement(ConfigConsumer, null, function (configProps) {
+        var basicPrefixCls = config.prefixCls;
+        var getPrefixCls = configProps.getPrefixCls;
+        var customizePrefixCls = props.prefixCls;
+        var prefixCls = getPrefixCls(basicPrefixCls, customizePrefixCls);
+        return /*#__PURE__*/React.createElement(Component, (0, _extends2["default"])({}, configProps, props, {
+          prefixCls: prefixCls
+        }));
+      });
+    };
+
+    var cons = Component.constructor;
+    var name = cons && cons.displayName || Component.name || 'Component';
+
+    if (process.env.NODE_ENV !== 'production') {
+      SFC.displayName = "withConfigConsumer(".concat(name, ")");
+    }
+
+    return SFC;
+  };
+}

package/lib/config-provider/cssVariables.d.ts

@@ -0,0 +1,3 @@
+import type { Theme } from './context';
+export declare function getStyle(globalPrefixCls: string, theme: Theme): string;
+export declare function registerTheme(globalPrefixCls: string, theme: Theme): void;

package/lib/config-provider/cssVariables.js

@@ -0,0 +1,115 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStyle = getStyle;
+exports.registerTheme = registerTheme;
+
+var _colors = require("@ant-design/colors");
+
+var _tinycolor = require("@ctrl/tinycolor");
+
+var _canUseDom = _interopRequireDefault(require("rc-util/lib/Dom/canUseDom"));
+
+var _dynamicCSS = require("rc-util/lib/Dom/dynamicCSS");
+
+var _warning = _interopRequireDefault(require("../_util/warning"));
+/* eslint-disable import/prefer-default-export, prefer-destructuring */
+
+
+var dynamicStyleMark = "-ant-".concat(Date.now(), "-").concat(Math.random());
+
+function getStyle(globalPrefixCls, theme) {
+  var variables = {};
+
+  var formatColor = function formatColor(color, updater) {
+    var clone = color.clone();
+    clone = (updater === null || updater === void 0 ? void 0 : updater(clone)) || clone;
+    return clone.toRgbString();
+  };
+
+  var fillColor = function fillColor(colorVal, type) {
+    var baseColor = new _tinycolor.TinyColor(colorVal);
+    var colorPalettes = (0, _colors.generate)(baseColor.toRgbString());
+    variables["".concat(type, "-color")] = formatColor(baseColor);
+    variables["".concat(type, "-color-disabled")] = colorPalettes[1];
+    variables["".concat(type, "-color-hover")] = colorPalettes[4];
+    variables["".concat(type, "-color-active")] = colorPalettes[6];
+    variables["".concat(type, "-color-outline")] = baseColor.clone().setAlpha(0.2).toRgbString();
+    variables["".concat(type, "-color-deprecated-bg")] = colorPalettes[0];
+    variables["".concat(type, "-color-deprecated-border")] = colorPalettes[2];
+  }; // ================ Primary Color ================
+
+
+  if (theme.primaryColor) {
+    fillColor(theme.primaryColor, 'primary');
+    var primaryColor = new _tinycolor.TinyColor(theme.primaryColor);
+    var primaryColors = (0, _colors.generate)(primaryColor.toRgbString()); // Legacy - We should use semantic naming standard
+
+    primaryColors.forEach(function (color, index) {
+      variables["primary-".concat(index + 1)] = color;
+    }); // Deprecated
+
+    variables['primary-color-deprecated-l-35'] = formatColor(primaryColor, function (c) {
+      return c.lighten(35);
+    });
+    variables['primary-color-deprecated-l-20'] = formatColor(primaryColor, function (c) {
+      return c.lighten(20);
+    });
+    variables['primary-color-deprecated-t-20'] = formatColor(primaryColor, function (c) {
+      return c.tint(20);
+    });
+    variables['primary-color-deprecated-t-50'] = formatColor(primaryColor, function (c) {
+      return c.tint(50);
+    });
+    variables['primary-color-deprecated-f-12'] = formatColor(primaryColor, function (c) {
+      return c.setAlpha(c.getAlpha() * 0.12);
+    });
+    var primaryActiveColor = new _tinycolor.TinyColor(primaryColors[0]);
+    variables['primary-color-active-deprecated-f-30'] = formatColor(primaryActiveColor, function (c) {
+      return c.setAlpha(c.getAlpha() * 0.3);
+    });
+    variables['primary-color-active-deprecated-d-02'] = formatColor(primaryActiveColor, function (c) {
+      return c.darken(2);
+    });
+  } // ================ Success Color ================
+
+
+  if (theme.successColor) {
+    fillColor(theme.successColor, 'success');
+  } // ================ Warning Color ================
+
+
+  if (theme.warningColor) {
+    fillColor(theme.warningColor, 'warning');
+  } // ================= Error Color =================
+
+
+  if (theme.errorColor) {
+    fillColor(theme.errorColor, 'error');
+  } // ================= Info Color ==================
+
+
+  if (theme.infoColor) {
+    fillColor(theme.infoColor, 'info');
+  } // Convert to css variables
+
+
+  var cssList = Object.keys(variables).map(function (key) {
+    return "--".concat(globalPrefixCls, "-").concat(key, ": ").concat(variables[key], ";");
+  });
+  return "\n  :root {\n    ".concat(cssList.join('\n'), "\n  }\n  ").trim();
+}
+
+function registerTheme(globalPrefixCls, theme) {
+  var style = getStyle(globalPrefixCls, theme);
+
+  if ((0, _canUseDom["default"])()) {
+    (0, _dynamicCSS.updateCSS)(style, "".concat(dynamicStyleMark, "-dynamic-theme"));
+  } else {
+    process.env.NODE_ENV !== "production" ? (0, _warning["default"])(false, 'ConfigProvider', 'SSR do not support dynamic theme with css variables.') : void 0;
+  }
+}

package/lib/config-provider/defaultRenderEmpty.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+declare const defaultRenderEmpty: (componentName?: string) => React.ReactNode;
+export type RenderEmptyHandler = typeof defaultRenderEmpty;
+export default defaultRenderEmpty;

package/lib/config-provider/defaultRenderEmpty.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _ = require(".");
+
+var _empty = _interopRequireDefault(require("../empty"));
+
+var defaultRenderEmpty = function defaultRenderEmpty(componentName) {
+  return /*#__PURE__*/React.createElement(_.ConfigConsumer, null, function (_ref) {
+    var getPrefixCls = _ref.getPrefixCls;
+    var prefix = getPrefixCls('empty');
+
+    switch (componentName) {
+      case 'Table':
+      case 'List':
+        return /*#__PURE__*/React.createElement(_empty["default"], {
+          image: _empty["default"].PRESENTED_IMAGE_SIMPLE
+        });
+
+      case 'Select':
+      case 'TreeSelect':
+      case 'Cascader':
+      case 'Transfer':
+      case 'Mentions':
+        return /*#__PURE__*/React.createElement(_empty["default"], {
+          image: _empty["default"].PRESENTED_IMAGE_SIMPLE,
+          className: "".concat(prefix, "-small")
+        });
+
+      /* istanbul ignore next */
+
+      default:
+        // Should never hit if we take all the component into consider.
+        return /*#__PURE__*/React.createElement(_empty["default"], null);
+    }
+  });
+};
+
+var _default = defaultRenderEmpty;
+exports["default"] = _default;

package/lib/config-provider/index.d.ts

@@ -1,5 +1,61 @@
-import { FC } from 'react';
-import 'moment/locale/zh-cn';
-import type { ConfigProviderProps } from 'antd/es/config-provider/index';
-declare const Config: FC<ConfigProviderProps>;
-export default Config;
+import type { ValidateMessages } from 'rc-field-form/lib/interface';
+import * as React from 'react';
+import type { RequiredMark } from '../form/Form';
+import type { Locale } from '../locale-provider';
+import type { Theme } from './context';
+import { ConfigConsumer, ConfigConsumerProps, ConfigContext, CSPConfig, DirectionType } from './context';
+import { RenderEmptyHandler } from './defaultRenderEmpty';
+import type { SizeType } from './SizeContext';
+import SizeContext from './SizeContext';
+export { RenderEmptyHandler, ConfigContext, ConfigConsumer, CSPConfig, DirectionType, ConfigConsumerProps, };
+export declare const configConsumerProps: string[];
+export interface ConfigProviderProps {
+    getTargetContainer?: () => HTMLElement | Window;
+    getPopupContainer?: (triggerNode?: HTMLElement) => HTMLElement;
+    prefixCls?: string;
+    iconPrefixCls?: string;
+    children?: React.ReactNode;
+    renderEmpty?: RenderEmptyHandler;
+    csp?: CSPConfig;
+    autoInsertSpaceInButton?: boolean;
+    form?: {
+        validateMessages?: ValidateMessages;
+        requiredMark?: RequiredMark;
+        colon?: boolean;
+    };
+    input?: {
+        autoComplete?: string;
+    };
+    pagination?: {
+        showSizeChanger?: boolean;
+    };
+    locale?: Locale;
+    pageHeader?: {
+        ghost: boolean;
+    };
+    componentSize?: SizeType;
+    componentDisabled?: boolean;
+    direction?: DirectionType;
+    space?: {
+        size?: SizeType | number;
+    };
+    virtual?: boolean;
+    dropdownMatchSelectWidth?: boolean;
+}
+export declare const defaultPrefixCls = "ant";
+export declare const defaultIconPrefixCls = "anticon";
+declare function getGlobalIconPrefixCls(): string;
+declare const setGlobalConfig: ({ prefixCls, iconPrefixCls, theme, }: Pick<ConfigProviderProps, "prefixCls" | "iconPrefixCls"> & {
+    theme?: Theme | undefined;
+}) => void;
+export declare const globalConfig: () => {
+    getPrefixCls: (suffixCls?: string, customizePrefixCls?: string) => string;
+    getIconPrefixCls: typeof getGlobalIconPrefixCls;
+    getRootPrefixCls: (rootPrefixCls?: string, customizePrefixCls?: string) => string;
+};
+declare const ConfigProvider: React.FC<ConfigProviderProps> & {
+    ConfigContext: typeof ConfigContext;
+    SizeContext: typeof SizeContext;
+    config: typeof setGlobalConfig;
+};
+export default ConfigProvider;

package/lib/config-provider/index.js

@@ -1,14 +1,254 @@
-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); }
+"use strict";
 
-import React from 'react';
-import { ConfigProvider } from 'antd';
-import zhCN from 'antd/es/locale/zh_CN';
-import 'moment/locale/zh-cn';
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
 
-var Config = function Config(props) {
-  return /*#__PURE__*/React.createElement(ConfigProvider, _extends({
-    locale: zhCN
-  }, props), props.children);
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ConfigConsumer", {
+  enumerable: true,
+  get: function get() {
+    return _context.ConfigConsumer;
+  }
+});
+Object.defineProperty(exports, "ConfigContext", {
+  enumerable: true,
+  get: function get() {
+    return _context.ConfigContext;
+  }
+});
+exports.globalConfig = exports.defaultPrefixCls = exports.defaultIconPrefixCls = exports["default"] = exports.configConsumerProps = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _Context = _interopRequireDefault(require("@ant-design/icons/lib/components/Context"));
+
+var _rcFieldForm = require("rc-field-form");
+
+var _useMemo = _interopRequireDefault(require("rc-util/lib/hooks/useMemo"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _localeProvider = _interopRequireWildcard(require("../locale-provider"));
+
+var _LocaleReceiver = _interopRequireDefault(require("../locale-provider/LocaleReceiver"));
+
+var _default2 = _interopRequireDefault(require("../locale/default"));
+
+var _message = _interopRequireDefault(require("../message"));
+
+var _notification = _interopRequireDefault(require("../notification"));
+
+var _context = require("./context");
+
+var _cssVariables = require("./cssVariables");
+
+var _DisabledContext = require("./DisabledContext");
+
+var _SizeContext = _interopRequireWildcard(require("./SizeContext"));
+
+var configConsumerProps = ['getTargetContainer', 'getPopupContainer', 'rootPrefixCls', 'getPrefixCls', 'renderEmpty', 'csp', 'autoInsertSpaceInButton', 'locale', 'pageHeader']; // These props is used by `useContext` directly in sub component
+
+exports.configConsumerProps = configConsumerProps;
+var PASSED_PROPS = ['getTargetContainer', 'getPopupContainer', 'renderEmpty', 'pageHeader', 'input', 'pagination', 'form'];
+var defaultPrefixCls = 'ant';
+exports.defaultPrefixCls = defaultPrefixCls;
+var defaultIconPrefixCls = 'anticon';
+exports.defaultIconPrefixCls = defaultIconPrefixCls;
+var globalPrefixCls;
+var globalIconPrefixCls;
+
+function getGlobalPrefixCls() {
+  return globalPrefixCls || defaultPrefixCls;
+}
+
+function getGlobalIconPrefixCls() {
+  return globalIconPrefixCls || defaultIconPrefixCls;
+}
+
+var setGlobalConfig = function setGlobalConfig(_ref) {
+  var prefixCls = _ref.prefixCls,
+      iconPrefixCls = _ref.iconPrefixCls,
+      theme = _ref.theme;
+
+  if (prefixCls !== undefined) {
+    globalPrefixCls = prefixCls;
+  }
+
+  if (iconPrefixCls !== undefined) {
+    globalIconPrefixCls = iconPrefixCls;
+  }
+
+  if (theme) {
+    (0, _cssVariables.registerTheme)(getGlobalPrefixCls(), theme);
+  }
 };
 
-export default Config;
+var globalConfig = function globalConfig() {
+  return {
+    getPrefixCls: function getPrefixCls(suffixCls, customizePrefixCls) {
+      if (customizePrefixCls) return customizePrefixCls;
+      return suffixCls ? "".concat(getGlobalPrefixCls(), "-").concat(suffixCls) : getGlobalPrefixCls();
+    },
+    getIconPrefixCls: getGlobalIconPrefixCls,
+    getRootPrefixCls: function getRootPrefixCls(rootPrefixCls, customizePrefixCls) {
+      // Customize rootPrefixCls is first priority
+      if (rootPrefixCls) {
+        return rootPrefixCls;
+      } // If Global prefixCls provided, use this
+
+
+      if (globalPrefixCls) {
+        return globalPrefixCls;
+      } // [Legacy] If customize prefixCls provided, we cut it to get the prefixCls
+
+
+      if (customizePrefixCls && customizePrefixCls.includes('-')) {
+        return customizePrefixCls.replace(/^(.*)-[^-]*$/, '$1');
+      } // Fallback to default prefixCls
+
+
+      return getGlobalPrefixCls();
+    }
+  };
+};
+
+exports.globalConfig = globalConfig;
+
+var ProviderChildren = function ProviderChildren(props) {
+  var _a, _b;
+
+  var children = props.children,
+      csp = props.csp,
+      autoInsertSpaceInButton = props.autoInsertSpaceInButton,
+      form = props.form,
+      locale = props.locale,
+      componentSize = props.componentSize,
+      direction = props.direction,
+      space = props.space,
+      virtual = props.virtual,
+      dropdownMatchSelectWidth = props.dropdownMatchSelectWidth,
+      legacyLocale = props.legacyLocale,
+      parentContext = props.parentContext,
+      iconPrefixCls = props.iconPrefixCls,
+      componentDisabled = props.componentDisabled;
+  var getPrefixCls = React.useCallback(function (suffixCls, customizePrefixCls) {
+    var prefixCls = props.prefixCls;
+    if (customizePrefixCls) return customizePrefixCls;
+    var mergedPrefixCls = prefixCls || parentContext.getPrefixCls('');
+    return suffixCls ? "".concat(mergedPrefixCls, "-").concat(suffixCls) : mergedPrefixCls;
+  }, [parentContext.getPrefixCls, props.prefixCls]);
+  var config = (0, _extends2["default"])((0, _extends2["default"])({}, parentContext), {
+    csp: csp,
+    autoInsertSpaceInButton: autoInsertSpaceInButton,
+    locale: locale || legacyLocale,
+    direction: direction,
+    space: space,
+    virtual: virtual,
+    dropdownMatchSelectWidth: dropdownMatchSelectWidth,
+    getPrefixCls: getPrefixCls
+  }); // Pass the props used by `useContext` directly with child component.
+  // These props should merged into `config`.
+
+  PASSED_PROPS.forEach(function (propName) {
+    var propValue = props[propName];
+
+    if (propValue) {
+      config[propName] = propValue;
+    }
+  }); // https://github.com/ant-design/ant-design/issues/27617
+
+  var memoedConfig = (0, _useMemo["default"])(function () {
+    return config;
+  }, config, function (prevConfig, currentConfig) {
+    var prevKeys = Object.keys(prevConfig);
+    var currentKeys = Object.keys(currentConfig);
+    return prevKeys.length !== currentKeys.length || prevKeys.some(function (key) {
+      return prevConfig[key] !== currentConfig[key];
+    });
+  });
+  var memoIconContextValue = React.useMemo(function () {
+    return {
+      prefixCls: iconPrefixCls,
+      csp: csp
+    };
+  }, [iconPrefixCls, csp]);
+  var childNode = children; // Additional Form provider
+
+  var validateMessages = {};
+
+  if (locale) {
+    validateMessages = ((_a = locale.Form) === null || _a === void 0 ? void 0 : _a.defaultValidateMessages) || ((_b = _default2["default"].Form) === null || _b === void 0 ? void 0 : _b.defaultValidateMessages) || {};
+  }
+
+  if (form && form.validateMessages) {
+    validateMessages = (0, _extends2["default"])((0, _extends2["default"])({}, validateMessages), form.validateMessages);
+  }
+
+  if (Object.keys(validateMessages).length > 0) {
+    childNode = /*#__PURE__*/React.createElement(_rcFieldForm.FormProvider, {
+      validateMessages: validateMessages
+    }, children);
+  }
+
+  if (locale) {
+    childNode = /*#__PURE__*/React.createElement(_localeProvider["default"], {
+      locale: locale,
+      _ANT_MARK__: _localeProvider.ANT_MARK
+    }, childNode);
+  }
+
+  if (iconPrefixCls || csp) {
+    childNode = /*#__PURE__*/React.createElement(_Context["default"].Provider, {
+      value: memoIconContextValue
+    }, childNode);
+  }
+
+  if (componentSize) {
+    childNode = /*#__PURE__*/React.createElement(_SizeContext.SizeContextProvider, {
+      size: componentSize
+    }, childNode);
+  }
+
+  if (componentDisabled !== undefined) {
+    childNode = /*#__PURE__*/React.createElement(_DisabledContext.DisabledContextProvider, {
+      disabled: componentDisabled
+    }, childNode);
+  }
+
+  return /*#__PURE__*/React.createElement(_context.ConfigContext.Provider, {
+    value: memoedConfig
+  }, childNode);
+};
+
+var ConfigProvider = function ConfigProvider(props) {
+  React.useEffect(function () {
+    if (props.direction) {
+      _message["default"].config({
+        rtl: props.direction === 'rtl'
+      });
+
+      _notification["default"].config({
+        rtl: props.direction === 'rtl'
+      });
+    }
+  }, [props.direction]);
+  return /*#__PURE__*/React.createElement(_LocaleReceiver["default"], null, function (_, __, legacyLocale) {
+    return /*#__PURE__*/React.createElement(_context.ConfigConsumer, null, function (context) {
+      return /*#__PURE__*/React.createElement(ProviderChildren, (0, _extends2["default"])({
+        parentContext: context,
+        legacyLocale: legacyLocale
+      }, props));
+    });
+  });
+};
+/** @private internal Usage. do not use in your production */
+
+
+ConfigProvider.ConfigContext = _context.ConfigContext;
+ConfigProvider.SizeContext = _SizeContext["default"];
+ConfigProvider.config = setGlobalConfig;
+var _default = ConfigProvider;
+exports["default"] = _default;

package/lib/config-provider/style/css.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require("./index.css");

package/lib/config-provider/style/index-pure.less

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

package/lib/config-provider/style/index.css

@@ -0,0 +1,4 @@
+/* stylelint-disable at-rule-empty-line-before,at-rule-name-space-after,at-rule-no-unknown */
+/* stylelint-disable no-duplicate-selectors */
+/* stylelint-disable */
+/* stylelint-disable declaration-bang-space-before,no-duplicate-selectors,string-no-newline */

package/lib/config-provider/style/index.d.ts

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

package/lib/config-provider/style/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+require("./index.less");

package/lib/config-provider/style/index.less

@@ -0,0 +1,3 @@
+@root-entry-name: default;
+
+@import './index-pure.less';