amis-ui 6.13.0-beta.8 → 6.13.0

package/esm/components/Badge.js

@@ -0,0 +1,154 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __extends, __assign } from 'tslib';
+import React__default from 'react';
+import hoistNonReactStatic from 'hoist-non-react-statics';
+import { buildStyle, resolveVariableAndFilter, evalExpression } from 'amis-core';
+
+/**
+ * @file 角标组件
+ */
+var Badge = /** @class */ (function (_super) {
+    __extends(Badge, _super);
+    function Badge(props) {
+        return _super.call(this, props) || this;
+    }
+    Badge.prototype.renderBadge = function (text, size, position, offsetStyle, sizeStyle, animationElement) {
+        var _a = this.props, cx = _a.classnames, badge = _a.badge, data = _a.data;
+        var _b = badge, _c = _b.mode, mode = _c === void 0 ? 'dot' : _c, _d = _b.level, level = _d === void 0 ? 'danger' : _d, style = _b.style;
+        var customStyle = buildStyle(style, data);
+        if (typeof level === 'string' && level[0] === '$') {
+            level = resolveVariableAndFilter(level, data);
+        }
+        switch (mode) {
+            case 'dot':
+                return (React__default.createElement("span", { className: cx('Badge-dot', "Badge--".concat(position), "Badge--".concat(level)), style: __assign(__assign(__assign({}, offsetStyle), sizeStyle), customStyle) }, animationElement));
+            case 'text':
+                return (React__default.createElement("span", { className: cx('Badge-text', "Badge--".concat(position), "Badge--".concat(level)), style: __assign(__assign(__assign({}, offsetStyle), sizeStyle), customStyle) },
+                    text,
+                    animationElement));
+            case 'ribbon':
+                var outSize = size * Math.sqrt(2) + 5;
+                return (React__default.createElement("div", { className: cx('Badge-ribbon-out', "Badge-ribbon-out--".concat(position)), style: { width: outSize, height: outSize } },
+                    React__default.createElement("span", { className: cx('Badge-ribbon', "Badge-ribbon--".concat(position), "Badge--".concat(level)), style: __assign(__assign({}, sizeStyle), customStyle) },
+                        text,
+                        animationElement)));
+            default:
+                return null;
+        }
+    };
+    Badge.prototype.render = function () {
+        var badge = this.props.badge;
+        if (!badge) {
+            return this.props.children;
+        }
+        var _a = this.props, children = _a.children, cx = _a.classnames, data = _a.data;
+        var isDisplay = true;
+        if (typeof badge === 'string') {
+            isDisplay = evalExpression(badge, data) === true;
+        }
+        var _b = badge.mode, mode = _b === void 0 ? 'dot' : _b, text = badge.text; badge.level; var size = badge.size, style = badge.style, offset = badge.offset, _c = badge.position, position = _c === void 0 ? 'top-right' : _c, _d = badge.overflowCount, overflowCount = _d === void 0 ? 99 : _d, visibleOn = badge.visibleOn, className = badge.className, animation = badge.animation;
+        if (visibleOn) {
+            isDisplay = evalExpression(visibleOn, data) === true;
+        }
+        if (typeof text === 'string' && text[0] === '$') {
+            text = resolveVariableAndFilter(text, data);
+        }
+        // 设置默认值
+        if (typeof size === 'undefined') {
+            if (mode === 'dot') {
+                size = 6;
+            }
+            else if (mode === 'ribbon') {
+                size = 12;
+            }
+            else {
+                size = 16;
+            }
+        }
+        var sizeStyle = {};
+        if (mode === 'text') {
+            sizeStyle = {
+                borderRadius: size / 2,
+                height: size + 2,
+                lineHeight: size + 'px'
+            };
+            // 当text、overflowCount都为number类型时，进行封顶值处理
+            // 当text从模版字符串解析（text: "${badge}"）数字就会变为字符串
+            // 因此当设置了overflowCount属性时 如果text可以强制转换成数字 那么也进行封顶处理
+            if (typeof overflowCount === 'number' &&
+                (typeof text === 'number' || (text && !isNaN(Number(text))))) {
+                text = (text > overflowCount
+                    ? "".concat(overflowCount, "+")
+                    : text);
+            }
+            if (!text) {
+                isDisplay = false;
+            }
+        }
+        if (mode === 'dot') {
+            sizeStyle = { width: size, height: size };
+        }
+        if (mode === 'ribbon') {
+            sizeStyle = {
+                height: size,
+                lineHeight: size + 'px',
+                fontSize: size
+            };
+        }
+        var offsetStyle = {};
+        if (offset && offset.length) {
+            var left = "calc(50% + ".concat(parseInt(offset[0], 10), "px)");
+            var right = "calc(-50% + ".concat(parseInt(offset[1], 10), "px)");
+            offsetStyle = {
+                transform: "translate(".concat(left, ", ").concat(right, ")")
+            };
+        }
+        var animationBackground = 'var(--danger)';
+        if (style && style.background) {
+            animationBackground = style.background;
+        }
+        var animationElement = animation ? (React__default.createElement("div", { style: {
+                position: 'absolute',
+                top: 0,
+                left: 0,
+                width: '100%',
+                height: '100%',
+                border: "1px solid ".concat(animationBackground),
+                borderRadius: '50%',
+                animation: 'badgeDotAnimation 1.2s infinite ease-in-out'
+            } })) : null;
+        return (React__default.createElement("div", { className: cx('Badge', className) },
+            children,
+            isDisplay
+                ? this.renderBadge(text, size, position, offsetStyle, sizeStyle, animationElement)
+                : null));
+    };
+    Badge.propsList = ['body', 'className', 'children'];
+    return Badge;
+}(React__default.Component));
+function withBadge(Component) {
+    var _a;
+    return hoistNonReactStatic((_a = /** @class */ (function (_super) {
+            __extends(WithBadge, _super);
+            function WithBadge() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            WithBadge.prototype.render = function () {
+                var badge = this.props.badge;
+                if (!badge) {
+                    return React__default.createElement(Component, __assign({}, this.props));
+                }
+                return (React__default.createElement(Badge, __assign({}, this.props),
+                    React__default.createElement(Component, __assign({}, this.props))));
+            };
+            return WithBadge;
+        }(React__default.Component)),
+        _a.displayName = "WithBadge(".concat(Component.displayName || Component.name, ")"),
+        _a), Component);
+}
+
+export { Badge, Badge as default, withBadge };

package/esm/components/BaiduMapPicker.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="lodash" />
+/// <reference types="hoist-non-react-statics" />
+import React from 'react';
+import { ClassNamesFn } from 'amis-core';
+interface MapPickerProps {
+    ak: string;
+    coordinatesType: string;
+    classnames: ClassNamesFn;
+    classPrefix: string;
+    placeholder?: string;
+    value?: {
+        address: string;
+        lat: number;
+        lng: number;
+        city?: string;
+        zoom?: number;
+    };
+    onChange?: (value: any) => void;
+    autoSelectCurrentLoc?: boolean;
+    onlySelectCurrentLoc?: boolean;
+    showSug?: boolean;
+    showGeoLoc?: boolean;
+    hideViewControl?: boolean;
+    mapStyle?: React.CSSProperties;
+}
+interface LocationItem {
+    title?: string;
+    address: string;
+    lat: number;
+    lng: number;
+    city?: string;
+}
+interface MapPickerState {
+    inputValue: string;
+    locIndex?: number;
+    locs: Array<LocationItem>;
+    sugs: Array<string>;
+    innerValue?: {
+        address: string;
+        lat: number;
+        lng: number;
+        city?: string;
+        zoom?: number;
+    };
+}
+export declare class BaiduMapPicker extends React.Component<MapPickerProps, MapPickerState> {
+    state: MapPickerState;
+    id: string;
+    mapRef: React.RefObject<HTMLDivElement>;
+    placeholderInput?: HTMLInputElement;
+    map: any;
+    ac: any;
+    search: import("lodash").DebouncedFunc<() => void>;
+    convertor: any;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: Readonly<MapPickerProps>, prevState: Readonly<MapPickerState>): void;
+    initMap(): Promise<void>;
+    getLocations(point: any, selectCurrentLoc?: boolean): void;
+    handleChange(e: React.ChangeEvent<HTMLInputElement>): void;
+    handleSelect(e: React.MouseEvent<HTMLElement>): void;
+    covertPoint(point: any, from: number, to: number): Promise<unknown>;
+    triggerOnChange(loc: LocationItem): void;
+    handleSugSelect(e: React.MouseEvent<HTMLDivElement>): void;
+    render(): React.JSX.Element;
+}
+declare const _default: {
+    new (props: Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps): {
+        ref: any;
+        childRef(ref: any): void;
+        getWrappedInstance(): any;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<MapPickerProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<typeof BaiduMapPicker>;
+} & import("hoist-non-react-statics").NonReactStatics<typeof BaiduMapPicker, {}> & {
+    ComposedComponent: typeof BaiduMapPicker;
+};
+export default _default;

package/esm/components/BaiduMapPicker.js

@@ -0,0 +1,366 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __extends, __awaiter, __generator, __decorate, __metadata } from 'tslib';
+import React__default from 'react';
+import { uuid, loadScript, autobind, themeable } from 'amis-core';
+import debounce from 'lodash/debounce';
+import { Icon } from './icons.js';
+
+var COORDINATES_GCJ02 = 3;
+var COORDINATES_BD09 = 5;
+// 记录百度地图SDK加载状态
+var BMapLoadingPromise = null;
+var BaiduMapPicker = /** @class */ (function (_super) {
+    __extends(BaiduMapPicker, _super);
+    function BaiduMapPicker() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.state = {
+            inputValue: '',
+            locs: [],
+            locIndex: -1,
+            sugs: [],
+            innerValue: _this.props.value // 内部定位的值，用于内部更新地图定位点
+        };
+        _this.id = uuid();
+        _this.mapRef = React__default.createRef();
+        _this.search = debounce(function () {
+            var _a;
+            if (_this.state.inputValue) {
+                (_a = _this.ac) === null || _a === void 0 ? void 0 : _a.search(_this.state.inputValue);
+            }
+            else {
+                _this.setState({
+                    sugs: []
+                });
+            }
+        }, 250, {
+            trailing: true,
+            leading: false
+        });
+        return _this;
+    }
+    BaiduMapPicker.prototype.componentDidMount = function () {
+        if (window.BMap) {
+            this.initMap();
+        }
+        else if (BMapLoadingPromise) {
+            BMapLoadingPromise.then(this.initMap).then(function () {
+                BMapLoadingPromise = null;
+            });
+        }
+        else {
+            BMapLoadingPromise = loadScript("//api.map.baidu.com/api?v=3.0&ak=".concat(this.props.ak, "&callback={{callback}}"));
+            BMapLoadingPromise.then(this.initMap).then(function () {
+                BMapLoadingPromise = null;
+            });
+        }
+    };
+    BaiduMapPicker.prototype.componentWillUnmount = function () {
+        var _a, _b;
+        (_b = (_a = this.ac) === null || _a === void 0 ? void 0 : _a.dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.placeholderInput && document.body.removeChild(this.placeholderInput);
+        delete this.placeholderInput;
+        delete this.map;
+    };
+    BaiduMapPicker.prototype.componentDidUpdate = function (prevProps, prevState) {
+        var _this = this;
+        // 值更新后需要重绘地图
+        if (prevProps.value !== this.props.value) {
+            this.setState({
+                innerValue: this.props.value
+            });
+        }
+        else if (this.state.innerValue !== prevState.innerValue &&
+            this.state.innerValue &&
+            this.map) {
+            this.map.clearOverlays();
+            var value = this.state.innerValue;
+            var point = value
+                ? new BMap.Point(value.lng, value.lat)
+                : new BMap.Point(116.404, 39.915);
+            var zoom_1 = (value === null || value === void 0 ? void 0 : value.zoom) || 15;
+            if (this.props.coordinatesType == 'gcj02') {
+                this.covertPoint(point, COORDINATES_GCJ02, COORDINATES_BD09).then(function (point) { return _this.map.centerAndZoom(point, zoom_1); });
+            }
+            else {
+                this.map.centerAndZoom(point, zoom_1);
+            }
+            var mk = new BMap.Marker(point);
+            // 增加定位点
+            this.map.addOverlay(mk);
+            // 移动到中心
+            this.map.panTo(point);
+        }
+    };
+    BaiduMapPicker.prototype.initMap = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var autoSelectCurrentLoc, map, value, point, zoom, geolocationControl, input;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        autoSelectCurrentLoc = (_a = this.props.autoSelectCurrentLoc) !== null && _a !== void 0 ? _a : false;
+                        map = new BMap.Map(this.mapRef.current, {
+                            enableMapClick: false
+                        });
+                        this.map = map;
+                        this.convertor = new BMap.Convertor();
+                        value = this.props.value;
+                        point = value
+                            ? new BMap.Point(value.lng, value.lat)
+                            : new BMap.Point(116.404, 39.915);
+                        zoom = (value === null || value === void 0 ? void 0 : value.zoom) || 15;
+                        if (!(this.props.coordinatesType == 'gcj02')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.covertPoint(point, COORDINATES_GCJ02, COORDINATES_BD09)];
+                    case 1:
+                        point = _b.sent();
+                        map.centerAndZoom(point, zoom);
+                        return [3 /*break*/, 3];
+                    case 2:
+                        map.centerAndZoom(point, zoom);
+                        _b.label = 3;
+                    case 3:
+                        if (!this.props.hideViewControl) {
+                            map.addControl(
+                            // @ts-ignore
+                            new BMap.NavigationControl({ type: BMAP_NAVIGATION_CONTROL_SMALL }));
+                        }
+                        geolocationControl = new BMap.GeolocationControl();
+                        geolocationControl.addEventListener('locationSuccess', function (e) {
+                            _this.getLocations(e.point, autoSelectCurrentLoc);
+                        });
+                        if (this.props.showGeoLoc === true) {
+                            map.addControl(geolocationControl);
+                        }
+                        map.addEventListener('click', function (e) {
+                            if (_this.props.onlySelectCurrentLoc) {
+                                return;
+                            }
+                            _this.getLocations(e.point, true);
+                        });
+                        input = document.createElement('input');
+                        input.className = 'invisible';
+                        this.placeholderInput = input;
+                        document.body.appendChild(input);
+                        this.ac = new BMap.Autocomplete({
+                            input: input,
+                            location: map,
+                            onSearchComplete: function (result) {
+                                // 说明已经销毁了。
+                                if (!_this.map) {
+                                    return;
+                                }
+                                var sugs = [];
+                                var poiLength = result.getNumPois();
+                                if (poiLength) {
+                                    for (var i = 0; i < poiLength; i++) {
+                                        var poi = result.getPoi(i);
+                                        if (poi) {
+                                            sugs.push([
+                                                poi.province,
+                                                poi.city,
+                                                poi.district,
+                                                poi.street,
+                                                poi.business
+                                            ].join(' '));
+                                        }
+                                    }
+                                    _this.setState({
+                                        sugs: sugs
+                                    });
+                                }
+                            }
+                        });
+                        value ? this.getLocations(point) : geolocationControl.location();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaiduMapPicker.prototype.getLocations = function (point, selectCurrentLoc) {
+        var _this = this;
+        var map = this.map;
+        map.clearOverlays();
+        var mk = new BMap.Marker(point);
+        map.addOverlay(mk);
+        map.panTo(point);
+        var geoc = new BMap.Geocoder();
+        geoc.getLocation(point, function (rs) {
+            // 说明已经销毁了。
+            if (!_this.map) {
+                return;
+            }
+            var index = 0;
+            var locs = [];
+            locs.push({
+                title: '当前位置',
+                address: rs.address,
+                city: rs.addressComponents.city,
+                lat: rs.point.lat,
+                lng: rs.point.lng
+            });
+            if (Array.isArray(rs.surroundingPois)) {
+                rs.surroundingPois.forEach(function (item) {
+                    locs.push({
+                        title: item.title,
+                        address: item.address,
+                        city: item.city,
+                        lat: item.point.lat,
+                        lng: item.point.lng
+                    });
+                });
+            }
+            _this.setState({
+                locIndex: index,
+                locs: locs
+            }, function () {
+                if (!selectCurrentLoc) {
+                    return;
+                }
+                _this.triggerOnChange(locs[0]);
+            });
+        });
+    };
+    BaiduMapPicker.prototype.handleChange = function (e) {
+        this.setState({
+            inputValue: e.currentTarget.value
+        }, this.search);
+    };
+    BaiduMapPicker.prototype.handleSelect = function (e) {
+        var _this = this;
+        var index = parseInt(e.currentTarget.getAttribute('data-index'), 10);
+        var loc = this.state.locs[index];
+        this.setState({
+            locIndex: index,
+            innerValue: loc
+        }, function () {
+            _this.triggerOnChange(loc);
+        });
+    };
+    BaiduMapPicker.prototype.covertPoint = function (point, from, to) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.convertor.translate([point], from, to, function (res) {
+                if (res.status === 0 && res.points.length) {
+                    resolve(new BMap.Point(res.points[0].lng, res.points[0].lat));
+                }
+                else {
+                    reject();
+                }
+            });
+        });
+    };
+    BaiduMapPicker.prototype.triggerOnChange = function (loc) {
+        var _this = this;
+        var _a, _b;
+        var point = new BMap.Point(loc.lng, loc.lat);
+        if (this.props.coordinatesType == 'gcj02') {
+            this.covertPoint(point, COORDINATES_BD09, COORDINATES_GCJ02).then(function (convertedPoint) {
+                var _a;
+                typeof ((_a = _this.props) === null || _a === void 0 ? void 0 : _a.onChange) === 'function' &&
+                    _this.props.onChange({
+                        address: loc.address.trim() || loc.title,
+                        lat: convertedPoint.lat,
+                        lng: convertedPoint.lng,
+                        city: loc.city
+                    });
+            });
+        }
+        else {
+            typeof ((_a = this.props) === null || _a === void 0 ? void 0 : _a.onChange) === 'function' &&
+                ((_b = this.props) === null || _b === void 0 ? void 0 : _b.onChange({
+                    address: loc.address.trim() || loc.title,
+                    lat: loc.lat,
+                    lng: loc.lng,
+                    city: loc.city
+                }));
+        }
+    };
+    BaiduMapPicker.prototype.handleSugSelect = function (e) {
+        var _this = this;
+        var value = e.currentTarget.innerText;
+        this.setState({
+            inputValue: value
+        });
+        var local = new BMap.LocalSearch(this.map, {
+            // 智能搜索
+            onSearchComplete: function () {
+                var results = local.getResults();
+                var poi = results.getPoi(0);
+                _this.setState({
+                    inputValue: poi === null || poi === void 0 ? void 0 : poi.title,
+                    sugs: []
+                });
+                _this.getLocations(poi === null || poi === void 0 ? void 0 : poi.point, true);
+            }
+        });
+        local.search(value);
+    };
+    BaiduMapPicker.prototype.render = function () {
+        var _this = this;
+        var _a, _b;
+        var _c = this.props, cx = _c.classnames, mapStyle = _c.mapStyle, placeholder = _c.placeholder;
+        var onlySelectCurrentLoc = (_a = this.props.onlySelectCurrentLoc) !== null && _a !== void 0 ? _a : false;
+        var _d = this.state, locIndex = _d.locIndex, locs = _d.locs, inputValue = _d.inputValue, sugs = _d.sugs;
+        var showSug = (_b = this.props.showSug) !== null && _b !== void 0 ? _b : true;
+        var hasSug = Array.isArray(sugs) && sugs.length;
+        return (React__default.createElement("div", { className: cx('MapPicker') },
+            !onlySelectCurrentLoc && (React__default.createElement("div", { className: cx('MapPicker-search TextControl-control') },
+                React__default.createElement("div", { className: cx('TextControl-input') },
+                    React__default.createElement("input", { onChange: this.handleChange, value: inputValue, placeholder: placeholder || '搜索地点' })))),
+            React__default.createElement("div", { ref: this.mapRef, className: cx('MapPicker-map', {
+                    invisible: hasSug
+                }), style: mapStyle }),
+            !showSug ? null : (React__default.createElement("div", { className: cx('MapPicker-result', {
+                    invisible: hasSug
+                }) },
+                !onlySelectCurrentLoc &&
+                    locs.map(function (item, index) { return (React__default.createElement("div", { onClick: _this.handleSelect, key: index, "data-index": index, className: cx('MapPicker-item') },
+                        React__default.createElement("div", { className: cx('MapPicker-itemTitle') }, item.title),
+                        React__default.createElement("div", { className: cx('MapPicker-itemDesc') }, item.address),
+                        locIndex === index ? (React__default.createElement(Icon, { icon: "success", className: "icon" })) : null)); }),
+                onlySelectCurrentLoc && locs.length > 0 && (React__default.createElement("div", { onClick: this.handleSelect, key: "locs-current", "data-index": 0, className: cx('MapPicker-item') },
+                    React__default.createElement("div", { className: cx('MapPicker-itemTitle') }, locs[0].title),
+                    React__default.createElement("div", { className: cx('MapPicker-itemDesc') }, locs[0].address),
+                    locIndex === 0 ? (React__default.createElement(Icon, { icon: "success", className: "icon" })) : null)))),
+            showSug && hasSug && !onlySelectCurrentLoc ? (React__default.createElement("div", { className: cx('MapPicker-sug') }, sugs.map(function (item) { return (React__default.createElement("div", { onClick: _this.handleSugSelect, className: cx('MapPicker-sugItem'), key: item }, item)); }))) : null));
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", Promise)
+    ], BaiduMapPicker.prototype, "initMap", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, Boolean]),
+        __metadata("design:returntype", void 0)
+    ], BaiduMapPicker.prototype, "getLocations", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], BaiduMapPicker.prototype, "handleChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], BaiduMapPicker.prototype, "handleSelect", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], BaiduMapPicker.prototype, "handleSugSelect", null);
+    return BaiduMapPicker;
+}(React__default.Component));
+var BaiduMapPicker$1 = themeable(BaiduMapPicker);
+
+export { BaiduMapPicker, BaiduMapPicker$1 as default };

package/esm/components/BarCode.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @file 基于实现 bar code
+ */
+/// <reference types="hoist-non-react-statics" />
+import React from 'react';
+import { ClassNamesFn } from 'amis-core';
+import JsBarcode from 'jsbarcode';
+export interface BarCodeProps {
+    value: string;
+    className?: string;
+    classPrefix: string;
+    options?: JsBarcode.Options;
+    classnames: ClassNamesFn;
+}
+export declare class BarCode extends React.Component<BarCodeProps> {
+    private dom;
+    constructor(props: BarCodeProps);
+    componentDidUpdate(prevProps: BarCodeProps): void;
+    renderBarCode(): void;
+    componentDidMount(): void;
+    render(): React.JSX.Element;
+}
+declare const _default: {
+    new (props: Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps): {
+        ref: any;
+        childRef(ref: any): void;
+        getWrappedInstance(): any;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<BarCodeProps, keyof import("amis-core").ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<typeof BarCode>;
+} & import("hoist-non-react-statics").NonReactStatics<typeof BarCode, {}> & {
+    ComposedComponent: typeof BarCode;
+};
+export default _default;