amis-ui 1.0.0-beta.0

package/dist/components/virtual-list/index.js

@@ -0,0 +1,309 @@
+/**
+ * amis-ui v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+var PropTypes = require('prop-types');
+var SizeAndPositionManager = require('./SizeAndPositionManager.js');
+var constants = require('./constants.js');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var PropTypes__namespace = /*#__PURE__*/_interopNamespace(PropTypes);
+
+/**
+ * 基于 https://github.com/clauderic/react-tiny-virtual-list 改造，主要是加了宽度自适应
+ */
+var STYLE_WRAPPER = {
+    overflow: 'auto',
+    willChange: 'transform',
+    WebkitOverflowScrolling: 'touch'
+};
+var STYLE_INNER = {
+    position: 'relative',
+    width: 'auto',
+    whiteSpace: 'nowrap',
+    minHeight: '100%'
+};
+var STYLE_ITEM = {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    width: 'auto'
+};
+var STYLE_STICKY_ITEM = tslib.__assign(tslib.__assign({}, STYLE_ITEM), { position: 'sticky' });
+var VirtualList = /** @class */ (function (_super) {
+    tslib.__extends(VirtualList, _super);
+    function VirtualList() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.itemSizeGetter = function (itemSize) {
+            return function (index) { return _this.getSize(index, itemSize); };
+        };
+        _this.sizeAndPositionManager = new SizeAndPositionManager["default"]({
+            itemCount: _this.props.itemCount,
+            itemSizeGetter: _this.itemSizeGetter(_this.props.itemSize),
+            estimatedItemSize: _this.getEstimatedItemSize()
+        });
+        _this.state = {
+            offset: _this.props.scrollOffset ||
+                (_this.props.scrollToIndex != null &&
+                    _this.getOffsetForIndex(_this.props.scrollToIndex)) ||
+                0,
+            scrollChangeReason: constants.SCROLL_CHANGE_REASON.REQUESTED
+        };
+        _this.styleCache = {};
+        _this.getRef = function (node) {
+            _this.rootNode = node;
+        };
+        _this.handleScroll = function (event) {
+            var onScroll = _this.props.onScroll;
+            var offset = _this.getNodeOffset();
+            if (offset < 0 ||
+                _this.state.offset === offset ||
+                event.target !== _this.rootNode) {
+                return;
+            }
+            _this.setState({
+                offset: offset,
+                scrollChangeReason: constants.SCROLL_CHANGE_REASON.OBSERVED
+            });
+            if (typeof onScroll === 'function') {
+                onScroll(offset, event);
+            }
+        };
+        return _this;
+    }
+    VirtualList.prototype.componentDidMount = function () {
+        var _a = this.props, scrollOffset = _a.scrollOffset, scrollToIndex = _a.scrollToIndex;
+        this.rootNode.addEventListener('scroll', this.handleScroll, {
+            passive: true
+        });
+        this.updateRootWidth();
+        if (scrollOffset != null) {
+            this.scrollTo(scrollOffset);
+        }
+        else if (scrollToIndex != null) {
+            this.scrollTo(this.getOffsetForIndex(scrollToIndex));
+        }
+    };
+    // 自适应宽度
+    VirtualList.prototype.updateRootWidth = function () {
+        var itemsDom = this.rootNode.children[0].children;
+        var scrollbarWidth = window.innerWidth - document.documentElement.clientWidth || 15;
+        var containerWidth = this.rootNode.parentElement.getBoundingClientRect().width;
+        var maxItemWidth = 0;
+        for (var i = 0; i < itemsDom.length; i++) {
+            var itemWidth = itemsDom[i].getBoundingClientRect().width;
+            if (itemWidth > maxItemWidth) {
+                maxItemWidth = itemWidth;
+            }
+        }
+        if (maxItemWidth > containerWidth) {
+            this.rootNode.style.width = maxItemWidth + scrollbarWidth + 'px';
+        }
+    };
+    VirtualList.prototype.componentDidUpdate = function (prevProps, prevState) {
+        var props = this.props;
+        var estimatedItemSize = prevProps.estimatedItemSize, itemCount = prevProps.itemCount, itemSize = prevProps.itemSize, scrollOffset = prevProps.scrollOffset, scrollToAlignment = prevProps.scrollToAlignment, scrollToIndex = prevProps.scrollToIndex;
+        var scrollPropsHaveChanged = props.scrollToIndex !== scrollToIndex ||
+            props.scrollToAlignment !== scrollToAlignment;
+        var itemPropsHaveChanged = props.itemCount !== itemCount ||
+            props.itemSize !== itemSize ||
+            props.estimatedItemSize !== estimatedItemSize;
+        if (props.itemSize !== itemSize) {
+            this.sizeAndPositionManager.updateConfig({
+                itemSizeGetter: this.itemSizeGetter(props.itemSize)
+            });
+        }
+        if (props.itemCount !== itemCount ||
+            props.estimatedItemSize !== estimatedItemSize) {
+            this.sizeAndPositionManager.updateConfig({
+                itemCount: props.itemCount,
+                estimatedItemSize: this.getEstimatedItemSize(props)
+            });
+        }
+        if (itemPropsHaveChanged) {
+            this.recomputeSizes();
+        }
+        if (props.scrollOffset !== scrollOffset) {
+            this.setState({
+                offset: props.scrollOffset || 0,
+                scrollChangeReason: constants.SCROLL_CHANGE_REASON.REQUESTED
+            });
+        }
+        else if (typeof props.scrollToIndex === 'number' &&
+            (scrollPropsHaveChanged || itemPropsHaveChanged)) {
+            this.setState({
+                offset: this.getOffsetForIndex(props.scrollToIndex, props.scrollToAlignment, props.itemCount),
+                scrollChangeReason: constants.SCROLL_CHANGE_REASON.REQUESTED
+            });
+        }
+        var _a = this.state, offset = _a.offset, scrollChangeReason = _a.scrollChangeReason;
+        if (prevState.offset !== offset &&
+            scrollChangeReason === constants.SCROLL_CHANGE_REASON.REQUESTED) {
+            this.scrollTo(offset);
+        }
+    };
+    VirtualList.prototype.componentWillUnmount = function () {
+        this.rootNode.removeEventListener('scroll', this.handleScroll);
+    };
+    VirtualList.prototype.scrollTo = function (value) {
+        var _a = this.props.scrollDirection, scrollDirection = _a === void 0 ? constants.DIRECTION.VERTICAL : _a;
+        this.rootNode[constants.scrollProp[scrollDirection]] = value;
+    };
+    VirtualList.prototype.getOffsetForIndex = function (index, scrollToAlignment, itemCount) {
+        if (scrollToAlignment === void 0) { scrollToAlignment = this.props.scrollToAlignment; }
+        if (itemCount === void 0) { itemCount = this.props.itemCount; }
+        var _a = this.props.scrollDirection, scrollDirection = _a === void 0 ? constants.DIRECTION.VERTICAL : _a;
+        if (index < 0 || index >= itemCount) {
+            index = 0;
+        }
+        return this.sizeAndPositionManager.getUpdatedOffsetForIndex({
+            align: scrollToAlignment,
+            containerSize: this.props[constants.sizeProp[scrollDirection]],
+            currentOffset: (this.state && this.state.offset) || 0,
+            targetIndex: index
+        });
+    };
+    VirtualList.prototype.recomputeSizes = function (startIndex) {
+        if (startIndex === void 0) { startIndex = 0; }
+        this.styleCache = {};
+        this.sizeAndPositionManager.resetItem(startIndex);
+    };
+    VirtualList.prototype.render = function () {
+        var _a;
+        var _this = this;
+        var _b = this.props; _b.estimatedItemSize; var height = _b.height, _c = _b.overscanCount, overscanCount = _c === void 0 ? 3 : _c, renderItem = _b.renderItem; _b.itemCount; _b.itemSize; var onItemsRendered = _b.onItemsRendered; _b.onScroll; var _d = _b.scrollDirection, scrollDirection = _d === void 0 ? constants.DIRECTION.VERTICAL : _d; _b.scrollOffset; _b.scrollToIndex; _b.scrollToAlignment; var stickyIndices = _b.stickyIndices, style = _b.style, width = _b.width, props = tslib.__rest(_b, ["estimatedItemSize", "height", "overscanCount", "renderItem", "itemCount", "itemSize", "onItemsRendered", "onScroll", "scrollDirection", "scrollOffset", "scrollToIndex", "scrollToAlignment", "stickyIndices", "style", "width"]);
+        var offset = this.state.offset;
+        var _e = this.sizeAndPositionManager.getVisibleRange({
+            containerSize: this.props[constants.sizeProp[scrollDirection]] || 0,
+            offset: offset,
+            overscanCount: overscanCount
+        }), start = _e.start, stop = _e.stop;
+        var items = [];
+        var wrapperStyle = tslib.__assign(tslib.__assign(tslib.__assign({}, STYLE_WRAPPER), style), { height: height, width: width });
+        var innerStyle = tslib.__assign(tslib.__assign({}, STYLE_INNER), (_a = {}, _a[constants.sizeProp[scrollDirection]] = this.sizeAndPositionManager.getTotalSize(), _a));
+        if (stickyIndices != null && stickyIndices.length !== 0) {
+            stickyIndices.forEach(function (index) {
+                return items.push(renderItem({
+                    index: index,
+                    style: _this.getStyle(index, true)
+                }));
+            });
+            if (scrollDirection === constants.DIRECTION.HORIZONTAL) {
+                innerStyle.display = 'flex';
+            }
+        }
+        if (typeof start !== 'undefined' && typeof stop !== 'undefined') {
+            for (var index = start; index <= stop; index++) {
+                if (stickyIndices != null && ~stickyIndices.indexOf(index)) {
+                    continue;
+                }
+                items.push(renderItem({
+                    index: index,
+                    style: this.getStyle(index, false)
+                }));
+            }
+            if (typeof onItemsRendered === 'function') {
+                onItemsRendered({
+                    startIndex: start,
+                    stopIndex: stop
+                });
+            }
+        }
+        return (React__namespace.createElement("div", tslib.__assign({ ref: this.getRef }, props, { style: wrapperStyle }),
+            React__namespace.createElement("div", { style: innerStyle }, items)));
+    };
+    VirtualList.prototype.getNodeOffset = function () {
+        var _a = this.props.scrollDirection, scrollDirection = _a === void 0 ? constants.DIRECTION.VERTICAL : _a;
+        return this.rootNode[constants.scrollProp[scrollDirection]];
+    };
+    VirtualList.prototype.getEstimatedItemSize = function (props) {
+        if (props === void 0) { props = this.props; }
+        return (props.estimatedItemSize ||
+            (typeof props.itemSize === 'number' && props.itemSize) ||
+            50);
+    };
+    VirtualList.prototype.getSize = function (index, itemSize) {
+        if (typeof itemSize === 'function') {
+            return itemSize(index);
+        }
+        return Array.isArray(itemSize) ? itemSize[index] : itemSize;
+    };
+    VirtualList.prototype.getStyle = function (index, sticky) {
+        var _a, _b;
+        var style = this.styleCache[index];
+        if (style) {
+            return style;
+        }
+        var _c = this.props.scrollDirection, scrollDirection = _c === void 0 ? constants.DIRECTION.VERTICAL : _c;
+        var _d = this.sizeAndPositionManager.getSizeAndPositionForIndex(index), size = _d.size, offset = _d.offset;
+        return (this.styleCache[index] = sticky
+            ? tslib.__assign(tslib.__assign({}, STYLE_STICKY_ITEM), (_a = {}, _a[constants.sizeProp[scrollDirection]] = size, _a[constants.marginProp[scrollDirection]] = offset, _a[constants.oppositeMarginProp[scrollDirection]] = -(offset + size), _a.zIndex = 1, _a)) : tslib.__assign(tslib.__assign({}, STYLE_ITEM), (_b = {}, _b[constants.sizeProp[scrollDirection]] = size, _b[constants.positionProp[scrollDirection]] = offset, _b)));
+    };
+    VirtualList.defaultProps = {
+        overscanCount: 3,
+        scrollDirection: constants.DIRECTION.VERTICAL,
+        width: '100%'
+    };
+    VirtualList.propTypes = {
+        estimatedItemSize: PropTypes__namespace.number,
+        height: PropTypes__namespace.oneOfType([PropTypes__namespace.number, PropTypes__namespace.string])
+            .isRequired,
+        itemCount: PropTypes__namespace.number.isRequired,
+        itemSize: PropTypes__namespace.oneOfType([
+            PropTypes__namespace.number,
+            PropTypes__namespace.array,
+            PropTypes__namespace.func
+        ]).isRequired,
+        onScroll: PropTypes__namespace.func,
+        onItemsRendered: PropTypes__namespace.func,
+        overscanCount: PropTypes__namespace.number,
+        renderItem: PropTypes__namespace.func.isRequired,
+        scrollOffset: PropTypes__namespace.number,
+        scrollToIndex: PropTypes__namespace.number,
+        scrollToAlignment: PropTypes__namespace.oneOf([
+            constants.ALIGNMENT.AUTO,
+            constants.ALIGNMENT.START,
+            constants.ALIGNMENT.CENTER,
+            constants.ALIGNMENT.END
+        ]),
+        scrollDirection: PropTypes__namespace.oneOf([
+            constants.DIRECTION.HORIZONTAL,
+            constants.DIRECTION.VERTICAL
+        ]),
+        stickyIndices: PropTypes__namespace.arrayOf(PropTypes__namespace.number),
+        style: PropTypes__namespace.object,
+        width: PropTypes__namespace.oneOfType([PropTypes__namespace.number, PropTypes__namespace.string])
+    };
+    return VirtualList;
+}(React__namespace.PureComponent));
+
+Object.defineProperty(exports, 'ScrollDirection', {
+    enumerable: true,
+    get: function () { return constants.DIRECTION; }
+});
+exports["default"] = VirtualList;

package/dist/hooks/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file 常用 hooks
+ */
+export { default as useSetState } from './use-set-state';
+export { default as useUpdateEffect } from './use-update-effect';
+export { default as useTouch } from './use-touch';
+export { default as useValidationResolver } from './use-validation-resolver';

package/dist/hooks/use-set-state.d.ts

@@ -0,0 +1,2 @@
+declare const useSetState: <T extends object>(initialState?: T) => [T, (patch: Partial<T> | ((prevState: T) => Partial<T>)) => void];
+export default useSetState;

package/dist/hooks/use-set-state.js

@@ -0,0 +1,27 @@
+/**
+ * amis-ui v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+var isFunction = require('lodash/isFunction');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isFunction__default = /*#__PURE__*/_interopDefaultLegacy(isFunction);
+
+var useSetState = function (initialState) {
+    if (initialState === void 0) { initialState = {}; }
+    var _a = React.useState(initialState), state = _a[0], setState = _a[1];
+    var setMergeState = React.useCallback(function (patch) {
+        setState(function (prevState) { return (tslib.__assign(tslib.__assign({}, prevState), (isFunction__default["default"](patch) ? patch(prevState) : patch))); });
+    }, []);
+    return [state, setMergeState];
+};
+
+exports["default"] = useSetState;

package/dist/hooks/use-touch.d.ts

@@ -0,0 +1,16 @@
+declare type Direction = '' | 'vertical' | 'horizontal';
+declare const useTouch: () => {
+    move: EventListener;
+    start: EventListener;
+    reset: () => void;
+    isVertical: () => boolean;
+    isHorizontal: () => boolean;
+    startX: number;
+    startY: number;
+    deltaX: number;
+    deltaY: number;
+    offsetX: number;
+    offsetY: number;
+    direction: Direction;
+};
+export default useTouch;

package/dist/hooks/use-touch.js

@@ -0,0 +1,81 @@
+/**
+ * amis-ui v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+
+var MIN_DISTANCE = 10;
+function getDirection(x, y) {
+    if (x > y && x > MIN_DISTANCE) {
+        return 'horizontal';
+    }
+    if (y > x && y > MIN_DISTANCE) {
+        return 'vertical';
+    }
+    return '';
+}
+var INITIAL_STATE = {
+    startX: 0,
+    startY: 0,
+    deltaX: 0,
+    deltaY: 0,
+    offsetX: 0,
+    offsetY: 0,
+    direction: ''
+};
+var useTouch = function () {
+    var refState = React.useRef(INITIAL_STATE);
+    var innerState = refState.current;
+    var update = function (value) {
+        if (typeof value === 'function') {
+            value = value(refState.current);
+        }
+        Object.entries(value).forEach(function (_a) {
+            var k = _a[0], v = _a[1];
+            //@ts-ignore
+            refState.current[k] = v;
+        });
+    };
+    var isVertical = React.useCallback(function () { return innerState.direction === 'vertical'; }, [innerState.direction]);
+    var isHorizontal = React.useCallback(function () { return innerState.direction === 'horizontal'; }, [innerState.direction]);
+    var reset = function () {
+        update({
+            deltaX: 0,
+            deltaY: 0,
+            offsetX: 0,
+            offsetY: 0,
+            direction: ''
+        });
+    };
+    var start = (function (event) {
+        reset();
+        update({
+            startX: event.touches[0].clientX,
+            startY: event.touches[0].clientY
+        });
+    });
+    var move = (function (event) {
+        var touch = event.touches[0];
+        update(function (value) {
+            // Fix: Safari back will set clientX to negative number
+            var newState = tslib.__assign({}, value);
+            newState.deltaX = touch.clientX < 0 ? 0 : touch.clientX - newState.startX;
+            newState.deltaY = touch.clientY - newState.startY;
+            newState.offsetX = Math.abs(newState.deltaX);
+            newState.offsetY = Math.abs(newState.deltaY);
+            if (!newState.direction) {
+                newState.direction = getDirection(newState.offsetX, newState.offsetY);
+            }
+            return newState;
+        });
+    });
+    return tslib.__assign(tslib.__assign({}, innerState), { move: move, start: start, reset: reset, isVertical: isVertical, isHorizontal: isHorizontal });
+};
+
+exports["default"] = useTouch;

package/dist/hooks/use-update-effect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useUpdateEffect: typeof useEffect;
+export default useUpdateEffect;

package/dist/hooks/use-update-effect.js

@@ -0,0 +1,25 @@
+/**
+ * amis-ui v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+var useUpdateEffect = function (effect, deps) {
+    var isMounted = React.useRef(false);
+    React.useEffect(function () {
+        if (!isMounted.current) {
+            isMounted.current = true;
+        }
+        else {
+            return effect();
+        }
+        return undefined;
+    }, deps);
+};
+
+exports["default"] = useUpdateEffect;

package/dist/hooks/use-validation-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function useValidationResolver(__?: (str: string) => string): any;
+export default useValidationResolver;

package/dist/hooks/use-validation-resolver.js

@@ -0,0 +1,59 @@
+/**
+ * amis-ui v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var pick = require('lodash/pick');
+var React = require('react');
+var amisCore = require('amis-core');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var pick__default = /*#__PURE__*/_interopDefaultLegacy(pick);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+function formatErrors(errors) {
+    var formated = {};
+    Object.keys(errors).forEach(function (key) {
+        var origin = errors[key][0];
+        if (origin) {
+            formated[key] = {
+                type: origin.rule,
+                message: origin.msg
+            };
+        }
+    });
+    return formated;
+}
+function useValidationResolver(__) {
+    var _this = this;
+    if (__ === void 0) { __ = function (str) { return str; }; }
+    return React__default["default"].useCallback(function (values, context, config) { return tslib.__awaiter(_this, void 0, void 0, function () {
+        var rules, ruleKeys, _i, _a, key, field, errors;
+        return tslib.__generator(this, function (_b) {
+            rules = {};
+            ruleKeys = Object.keys(amisCore.validations);
+            for (_i = 0, _a = Object.keys(config.fields); _i < _a.length; _i++) {
+                key = _a[_i];
+                field = config.fields[key];
+                rules[key] = pick__default["default"](field, ruleKeys);
+                if (field.required) {
+                    rules[key].isRequired = true;
+                }
+            }
+            errors = amisCore.validateObject(values, rules, undefined, __);
+            return [2 /*return*/, {
+                    values: values,
+                    errors: formatErrors(errors)
+                }];
+        });
+    }); }, [__]);
+}
+
+exports["default"] = useValidationResolver;
+exports.useValidationResolver = useValidationResolver;

package/dist/icons/alert-danger.svg.js

@@ -0,0 +1,48 @@
+/**
+ * amis-ui v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopNamespace(e) {
+	if (e && e.__esModule) return e;
+	var n = Object.create(null);
+	if (e) {
+		Object.keys(e).forEach(function (k) {
+			if (k !== 'default') {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	}
+	n["default"] = e;
+	return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var _path;
+
+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); }
+
+var SvgAlertDanger = function SvgAlertDanger(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends({
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 1024 1024",
+    width: 16,
+    fill: "currentColor"
+  }, props), _path || (_path = /*#__PURE__*/React__namespace.createElement("path", {
+    d: "M667.904 704.32 508.992 546.56 351.104 705.472l-45.376-45.056L463.552 501.44 304.64 343.488l45.12-45.376 158.912 157.824L666.56 297.088 712 342.144 553.984 501.12 712.96 659.008l-45.12 45.44zM510.528 64a448 448 0 1 0 2.944 896 448 448 0 0 0-2.944-896z",
+    fill: "#E8684A"
+  })));
+};
+
+exports["default"] = SvgAlertDanger;

package/dist/icons/alert-info.svg.js

@@ -0,0 +1,48 @@
+/**
+ * amis-ui v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+function _interopNamespace(e) {
+	if (e && e.__esModule) return e;
+	var n = Object.create(null);
+	if (e) {
+		Object.keys(e).forEach(function (k) {
+			if (k !== 'default') {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	}
+	n["default"] = e;
+	return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var _path;
+
+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); }
+
+var SvgAlertInfo = function SvgAlertInfo(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends({
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 1024 1024",
+    width: 16,
+    fill: "currentColor"
+  }, props), _path || (_path = /*#__PURE__*/React__namespace.createElement("path", {
+    d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm32 354.944h-64V768h64V418.944zM512 256a38.4 38.4 0 1 0-.128 76.672A38.4 38.4 0 0 0 512 256z",
+    fill: "#2468F2"
+  })));
+};
+
+exports["default"] = SvgAlertInfo;