amis-rev-ui 6.13.0

package/esm/components/Editor.js

@@ -0,0 +1,238 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __extends, __assign, __decorate, __metadata } from 'tslib';
+import React__default from 'react';
+import { autobind, themeable, localeable } from 'amis-rev-core';
+import { Icon } from './icons.js';
+
+/**
+ * @file Editor
+ * @description
+ * @author fex
+ */
+// 用于发布 sdk 版本的时候替换，因为不确定 sdk 版本怎么部署，而 worker 地址路径不可知。
+// 所以会被 fis3 替换成取相对的代码。
+function filterUrl(url) {
+    return url;
+}
+if (!window.MonacoEnvironment) {
+    window.MonacoEnvironment = {
+        getWorkerUrl: function (moduleId, label) {
+            var url = '/pkg/editor.worker.js';
+            if (label === 'json') {
+                url = '/pkg/json.worker.js';
+            }
+            else if (label === 'css') {
+                url = '/pkg/css.worker.js';
+            }
+            else if (label === 'html') {
+                url = '/pkg/html.worker.js';
+            }
+            else if (label === 'typescript' || label === 'javascript') {
+                url = '/pkg/ts.worker.js';
+            }
+            url = filterUrl(url);
+            // url 有可能会插件替换成 cdn 地址，比如：fis3-prepackager-stand-alone-pack
+            if (/^https?/.test(url)) {
+                return "data:text/javascript;charset=utf-8,".concat(encodeURIComponent("\n        importScripts('".concat(url, "');")), "\n      ");
+            }
+            return url;
+        }
+    };
+}
+function monacoFactory(containerElement, monaco, options) {
+    return monaco.editor.create(containerElement, __assign({ 'autoIndent': true, 'formatOnType': true, 'formatOnPaste': true, 'selectOnLineNumbers': true, 'scrollBeyondLastLine': false, 'folding': true, 'minimap': {
+            enabled: false
+        }, 'scrollbar': {
+            alwaysConsumeMouseWheel: false
+        }, 'bracketPairColorization.enabled': true }, options));
+}
+var Editor = /** @class */ (function (_super) {
+    __extends(Editor, _super);
+    function Editor(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            isFullscreen: false,
+            innerWidth: 'auto',
+            innerHeight: 'auto'
+        };
+        _this.disposes = [];
+        _this.wrapperRef = _this.wrapperRef.bind(_this);
+        _this.getDom = _this.getDom.bind(_this);
+        _this.currentValue = props.value;
+        return _this;
+    }
+    Editor.prototype.componentDidUpdate = function (prevProps) {
+        var _a, _b;
+        if (this.props.value !== this.currentValue &&
+            this.editor &&
+            !this.props.isDiffEditor) {
+            var value = String(this.props.value);
+            if (this.props.language === 'json') {
+                try {
+                    value = JSON.stringify(JSON.parse(value), null, 2);
+                }
+                catch (e) { }
+            }
+            this.preventTriggerChangeEvent = true;
+            var eidtor = this.editor.getModifiedEditor
+                ? this.editor.getModifiedEditor()
+                : this.editor;
+            var model = eidtor.getModel();
+            eidtor.pushUndoStop();
+            // pushEditOperations says it expects a cursorComputer, but doesn't seem to need one.
+            model.pushEditOperations([], [
+                {
+                    range: model.getFullModelRange(),
+                    text: value
+                }
+            ]);
+            eidtor.pushUndoStop();
+            this.preventTriggerChangeEvent = false;
+        }
+        if (this.props.options.readOnly !== prevProps.options.readOnly &&
+            this.editor) {
+            (_b = (_a = this.editor).updateOptions) === null || _b === void 0 ? void 0 : _b.call(_a, this.props.options);
+        }
+    };
+    Editor.prototype.componentWillUnmount = function () {
+        var _a;
+        if (this.editor) {
+            var context = this.props.context || window;
+            var monaco = context.monaco || window.monaco;
+            var editorWillUnmount = this.props.editorWillUnmount;
+            editorWillUnmount && editorWillUnmount(this.editor, monaco);
+        }
+        this.disposes.forEach(function (dispose) { return dispose(); });
+        this.disposes = [];
+        (_a = this.editor) === null || _a === void 0 ? void 0 : _a.dispose();
+    };
+    Editor.prototype.wrapperRef = function (ref) {
+        this.container = ref;
+        if (ref) {
+            this.loadMonaco();
+        }
+        else {
+            try {
+                this.disposes.forEach(function (dispose) { return dispose(); });
+                this.disposes = [];
+                if (this.editor) {
+                    this.editor.getModel().dispose();
+                    this.editor.dispose();
+                }
+                this.editor = null;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+    };
+    Editor.prototype.getDom = function () {
+        return this.container;
+    };
+    Editor.prototype.loadMonaco = function () {
+        var _this = this;
+        // 由于 require.config({'vs/nls': { availableLanguages: { '*': 'xxxx' }}}) 只能在初始化之前设置有用，所以这里只能用全局变量的方式来设置。
+        // 另外此方式只是针对 jssdk 和平台有效，对于其他方式还需要再想想。
+        window.__amis_monaco_editor_locale = this.props.locale;
+        import('monaco-editor').then(function (monaco) { return _this.initMonaco(monaco); });
+    };
+    Editor.prototype.initMonaco = function (monaco) {
+        var _a, _b;
+        var value = this.props.value !== null ? this.props.value : this.props.defaultValue;
+        var _c = this.props, language = _c.language, editorTheme = _c.editorTheme, options = _c.options, editorFactory = _c.editorFactory;
+        var containerElement = this.container;
+        if (!containerElement) {
+            return;
+        }
+        // Before initializing monaco editor
+        this.editorWillMount(monaco);
+        if (this.props.language === 'json') {
+            try {
+                value = JSON.stringify(typeof value === 'string' ? JSON.parse(value) : value, null, 2);
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        var factory = editorFactory || monacoFactory;
+        this.editor = factory(containerElement, monaco, __assign(__assign({}, options), { readOnly: this.props.disabled, automaticLayout: true, value: value, language: language, editorTheme: editorTheme, theme: editorTheme }));
+        // json 默认开启验证。
+        (_a = monaco.languages.json) === null || _a === void 0 ? void 0 : _a.jsonDefaults.setDiagnosticsOptions(__assign({ enableSchemaRequest: true, validate: true, allowComments: true }, (_b = monaco.languages.json) === null || _b === void 0 ? void 0 : _b.jsonDefaults.diagnosticsOptions));
+        // After initializing monaco editor
+        this.editorDidMount(this.editor, monaco);
+    };
+    Editor.prototype.editorWillMount = function (monaco) {
+        var editorWillMount = this.props.editorWillMount;
+        editorWillMount && editorWillMount(monaco);
+    };
+    Editor.prototype.editorDidMount = function (editor, monaco) {
+        var _this = this;
+        var _a, _b, _c;
+        var _d = this.props, editorDidMount = _d.editorDidMount, onChange = _d.onChange, onFocus = _d.onFocus, onBlur = _d.onBlur;
+        editorDidMount && editorDidMount(editor, monaco);
+        editor.onDidChangeModelContent &&
+            this.disposes.push(editor.onDidChangeModelContent(function (event) {
+                var value = editor.getValue();
+                // Always refer to the latest value
+                _this.currentValue = value;
+                // Only invoking when user input changed
+                if (!_this.preventTriggerChangeEvent && onChange) {
+                    onChange(value, event);
+                }
+            }).dispose);
+        onFocus &&
+            editor.onDidFocusEditorWidget &&
+            this.disposes.push(editor.onDidFocusEditorWidget(onFocus).dispose);
+        onBlur &&
+            editor.onDidBlurEditorWidget &&
+            this.disposes.push(editor.onDidBlurEditorWidget(onBlur).dispose);
+        var _e = (_c = (_b = (_a = this === null || this === void 0 ? void 0 : this.editor) === null || _a === void 0 ? void 0 : _a._configuration) === null || _b === void 0 ? void 0 : _b._elementSizeObserver) !== null && _c !== void 0 ? _c : {}, _f = _e.width, width = _f === void 0 ? 'auto' : _f, _g = _e.height, height = _g === void 0 ? 'auto' : _g;
+        this.setState({ innerHeight: height, innerWidth: width });
+    };
+    Editor.prototype.handleFullscreenModeChange = function () {
+        var _this = this;
+        this.setState({ isFullscreen: !this.state.isFullscreen }, function () {
+            // 退出全屏模式后需要resize一下editor的宽高，避免溢出父元素
+            return !_this.state.isFullscreen &&
+                _this.editor.layout({
+                    width: _this.state.innerWidth,
+                    height: _this.state.innerHeight
+                });
+        });
+    };
+    Editor.prototype.render = function () {
+        var _a = this.props, className = _a.className, width = _a.width, height = _a.height, __ = _a.translate, placeholder = _a.placeholder, cx = _a.classnames, value = _a.value;
+        var style = __assign({}, (this.props.style || {}));
+        style.width = width;
+        style.height = height;
+        return (React__default.createElement("div", { className: cx("MonacoEditor", { 'is-fullscreen': this.state.isFullscreen }, className), style: style, ref: this.wrapperRef },
+            this.editor && placeholder && !value ? (React__default.createElement("span", { className: cx('MonacoEditor-placeholder') }, placeholder)) : null,
+            this.editor && this.props.allowFullscreen ? (React__default.createElement("div", { className: cx("MonacoEditor-header") },
+                React__default.createElement("a", { className: cx('Modal-close', "MonacoEditor-fullscreen"), "data-tooltip": this.state.isFullscreen
+                        ? __('Editor.exitFullscreen')
+                        : __('Editor.fullscreen'), "data-position": "left", onClick: this.handleFullscreenModeChange },
+                    React__default.createElement(Icon, { icon: this.state.isFullscreen ? 'compress-alt' : 'expand-alt', className: "icon" })))) : null));
+    };
+    Editor.defaultProps = {
+        language: 'javascript',
+        editorTheme: 'vs',
+        width: '100%',
+        height: '100%',
+        allowFullscreen: false,
+        options: {}
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Editor.prototype, "handleFullscreenModeChange", null);
+    return Editor;
+}(React__default.Component));
+var MonacoEditor = themeable(localeable(Editor, ['getDom']), ['getDom']);
+
+export { Editor, MonacoEditor as default, monacoFactory };

package/esm/components/Form.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file 给组件用的，渲染器里面不要用这个
+ */
+import React from 'react';
+import { ThemeProps } from 'amis-rev-core';
+import { UseFormReturn } from 'react-hook-form';
+import { LocaleProps } from 'amis-rev-core';
+export type FormRef = React.MutableRefObject<{
+    submit: () => void;
+} | undefined>;
+export interface FormProps extends ThemeProps, LocaleProps {
+    defaultValue?: any;
+    value?: any;
+    autoSubmit?: boolean;
+    onValidate?: (errors: any, values: any) => Promise<void>;
+    onChange?: (value: any) => void;
+    onSubmit?: (value: any) => void;
+    forwardRef?: FormRef;
+    children?: (methods: UseFormReturn & {
+        onSubmit: (value: any) => void;
+    }) => JSX.Element | null;
+    className?: string;
+}
+export declare function Form(props: FormProps): React.JSX.Element;
+declare const _default: React.ForwardRefExoticComponent<Omit<Omit<Omit<FormProps, keyof LocaleProps> & {
+    locale?: string;
+    translate?: (str: string, ...args: any[]) => string;
+}, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps, "children"> & Pick<FormProps, "children"> & React.RefAttributes<{
+    submit: () => void;
+} | undefined>>;
+export default _default;

package/esm/components/Form.js

@@ -0,0 +1,84 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __assign } from 'tslib';
+import React__default from 'react';
+import { themeable, localeable, noop, isObjectShallowModified } from 'amis-rev-core';
+import { useForm, FormProvider } from 'react-hook-form';
+import { useValidationResolver } from '../hooks/use-validation-resolver.js';
+import debounce from 'lodash/debounce';
+
+function Form(props) {
+    var _a, _b;
+    var cx = props.classnames, className = props.className, autoSubmit = props.autoSubmit, value = props.value, onChange = props.onChange;
+    var defaultValues = (_a = props.value) !== null && _a !== void 0 ? _a : props.defaultValue;
+    var methods = useForm({
+        defaultValues: defaultValues,
+        resolver: useValidationResolver(props.translate, props.onValidate)
+    });
+    var onSubmit = React__default.useRef(methods.handleSubmit(props.onSubmit || noop));
+    if (autoSubmit) {
+        onSubmit = React__default.useRef(debounce(methods.handleSubmit(props.onSubmit || noop), 250, {
+            leading: false,
+            trailing: true
+        }));
+        React__default.useEffect(function () {
+            var subscriber = methods.watch(onSubmit.current);
+            return function () {
+                var _a, _b;
+                subscriber.unsubscribe();
+                // debounce 后需要销毁
+                (_b = (_a = onSubmit.current) === null || _a === void 0 ? void 0 : _a.cancel) === null || _b === void 0 ? void 0 : _b.call(_a);
+            };
+        }, []);
+    }
+    React__default.useEffect(function () {
+        if (value && isObjectShallowModified(value, methods.getValues(), false)) {
+            Object.keys(value).forEach(function (key) {
+                methods.setValue(key, value[key]);
+            });
+        }
+    }, [value]);
+    if (onChange) {
+        React__default.useEffect(function () {
+            var subscriber = methods.watch(function (value, info) {
+                onChange(__assign(__assign({}, defaultValues), value));
+            });
+            return function () { return subscriber.unsubscribe(); };
+        }, [onChange]);
+    }
+    React__default.useImperativeHandle(props.forwardRef, function () {
+        return {
+            submit: function () {
+                return new Promise(function (resolve) {
+                    methods.handleSubmit(function (values) {
+                        var _a;
+                        (_a = props.onSubmit) === null || _a === void 0 ? void 0 : _a.call(props, values);
+                        resolve(values);
+                    }, function (e) { var _a; return resolve(((_a = e.customValidate) === null || _a === void 0 ? void 0 : _a.message) || false); })();
+                });
+            },
+            validate: function () {
+                return new Promise(function (resolve) {
+                    methods.handleSubmit(function () {
+                        resolve('');
+                    }, function (e) {
+                        var _a;
+                        return resolve(((_a = e.customValidate) === null || _a === void 0 ? void 0 : _a.message) ||
+                            props.translate('Form.validateFailed'));
+                    })();
+                });
+            }
+        };
+    }, []);
+    return (React__default.createElement(FormProvider, __assign({}, methods),
+        React__default.createElement("form", { className: cx('Form', className), onSubmit: onSubmit.current, noValidate: true },
+            React__default.createElement("input", { type: "submit", style: { display: 'none' } }), (_b = props.children) === null || _b === void 0 ? void 0 :
+            _b.call(props, __assign(__assign({}, methods), { onSubmit: onSubmit.current })))));
+}
+var ThemedForm = themeable(localeable(Form));
+var Form$1 = React__default.forwardRef(function (props, ref) { return (React__default.createElement(ThemedForm, __assign({}, props, { forwardRef: ref }))); });
+
+export { Form, Form$1 as default };

package/esm/components/FormField.js

@@ -0,0 +1,78 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __rest, __assign } from 'tslib';
+import React__default from 'react';
+import { themeable, localeable } from 'amis-rev-core';
+import { Controller as Controller$1 } from 'react-hook-form';
+
+function FormField(props) {
+    var _a, _b, _c, _d;
+    var mode = props.mode, children = props.children, cx = props.classnames, className = props.className; props.style; var hasError = props.hasError, isRequired = props.isRequired, label = props.label, labelAlign = props.labelAlign, labelClassName = props.labelClassName, description = props.description;
+    var errors = Array.isArray(props.errors)
+        ? props.errors
+        : props.errors
+            ? [props.errors]
+            : [];
+    if (mode === 'horizontal') {
+        var horizontal = props.horizontal || {
+            leftFixed: true
+        };
+        return (React__default.createElement("div", { "data-role": "form-item", className: cx("Form-item Form-item--horizontal", className, (_a = {
+                    'is-error': hasError
+                },
+                _a["is-required"] = isRequired,
+                _a['Form-item--horizontal-justify'] = horizontal.justify,
+                _a)) },
+            label !== false ? (React__default.createElement("label", { className: cx("Form-label", (_b = {},
+                    _b["Form-itemColumn--".concat(typeof horizontal.leftFixed === 'string'
+                        ? horizontal.leftFixed
+                        : 'normal')] = horizontal.leftFixed,
+                    _b["Form-itemColumn--".concat(horizontal.left)] = !horizontal.leftFixed,
+                    _b['Form-label--left'] = labelAlign === 'left',
+                    _b), labelClassName) },
+                React__default.createElement("span", null,
+                    label,
+                    isRequired && label ? (React__default.createElement("span", { className: cx("Form-star") }, "*")) : null))) : null,
+            React__default.createElement("div", { className: cx("Form-value", (_c = {},
+                    // [`Form-itemColumn--offset${getWidthRate(horizontal.offset)}`]: !label && label !== false,
+                    _c["Form-itemColumn--".concat(horizontal.right)] = !horizontal.leftFixed &&
+                        !!horizontal.right &&
+                        horizontal.right !== 12 - horizontal.left,
+                    _c)) },
+                children,
+                hasError && errors.length ? (React__default.createElement("ul", { className: cx("Form-feedback") }, errors.map(function (msg, key) { return (React__default.createElement("li", { key: key }, msg)); }))) : null,
+                description ? (React__default.createElement("div", { className: cx("Form-description") }, description)) : null)));
+    }
+    return (React__default.createElement("div", { "data-role": "form-item", className: cx("Form-item Form-item--normal", className, (_d = {
+                'is-error': hasError
+            },
+            _d["is-required"] = isRequired,
+            _d)) },
+        label ? (React__default.createElement("label", { className: cx("Form-label", labelClassName) },
+            React__default.createElement("span", null,
+                label,
+                isRequired && label ? (React__default.createElement("span", { className: cx("Form-star") }, "*")) : null))) : null,
+        children,
+        hasError && errors.length ? (React__default.createElement("ul", { className: cx("Form-feedback") }, errors.map(function (msg, key) { return (React__default.createElement("li", { key: key }, msg)); }))) : null,
+        description ? (React__default.createElement("div", { className: cx("Form-description") }, description)) : null));
+}
+var ThemedFormField = themeable(localeable(React__default.memo(FormField)));
+function Controller(props) {
+    var render = props.render, name = props.name, shouldUnregister = props.shouldUnregister, defaultValue = props.defaultValue, control = props.control, wrap = props.wrap, rest = __rest(props, ["render", "name", "shouldUnregister", "defaultValue", "control", "wrap"]);
+    var rules = React__default.useMemo(function () {
+        var rules = __assign({}, props.rules);
+        if (props.isRequired) {
+            rules.required = true;
+        }
+        return rules;
+    }, [props.rules, props.isRequired]);
+    return (React__default.createElement(Controller$1, { name: name || '', rules: rules, shouldUnregister: shouldUnregister, defaultValue: defaultValue, control: control, render: function (methods) {
+            var _a;
+            return wrap === false ? (render(methods)) : (React__default.createElement(ThemedFormField, __assign({}, rest, { hasError: !!methods.fieldState.error, errors: (_a = methods.fieldState.error) === null || _a === void 0 ? void 0 : _a.message }), render(methods)));
+        } }));
+}
+
+export { Controller, ThemedFormField as default };

package/esm/components/FormulaPicker.d.ts

@@ -0,0 +1,2 @@
+import FormulaPicker from './formula/Picker';
+export default FormulaPicker;

package/esm/components/FormulaPicker.js

@@ -0,0 +1,7 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import FormulaPicker from './formula/Picker.js';
+export { default } from './formula/Picker.js';

package/esm/components/GaodeMapPicker.js

@@ -0,0 +1,204 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __extends, __spreadArray, __read, __awaiter, __generator, __decorate, __metadata } from 'tslib';
+import React__default from 'react';
+import { uuid, loadStyle, loadScript, autobind, themeable } from 'amis-rev-core';
+import debounce from 'lodash/debounce';
+
+var BaiduMapPicker = /** @class */ (function (_super) {
+    __extends(BaiduMapPicker, _super);
+    function BaiduMapPicker() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.state = {
+            inputValue: '',
+            locs: [],
+            locIndex: -1,
+            sugs: []
+        };
+        _this.id = uuid();
+        _this.mapRef = React__default.createRef();
+        _this.resultListRef = React__default.createRef();
+        _this.search = debounce(function () {
+            var _a;
+            if (_this.state.inputValue) {
+                (_a = _this.placeSearch) === 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.AMap) {
+            this.initMap();
+        }
+        else {
+            loadStyle('https://cache.amap.com/lbs/static/main1119.css');
+            loadScript("//webapi.amap.com/maps?v=2.0&key=".concat(this.props.ak)).then(this.initMap);
+        }
+    };
+    BaiduMapPicker.prototype.initMap = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var map;
+            var _this = this;
+            return __generator(this, function (_a) {
+                map = new AMap.Map(this.mapRef.current, {
+                    resizeEnable: true,
+                    zoom: 13,
+                });
+                this.map = map;
+                map.plugin(["AMap.Geocoder"], function () {
+                    //加载地理编码插件
+                    _this.geocoder = new AMap.Geocoder({
+                        radius: 1000, //以已知坐标为中心点，radius为半径，返回范围内兴趣点和道路信息
+                        extensions: "all", //返回地址描述以及附近兴趣点和道路信息，默认“base”
+                    });
+                });
+                map.plugin('AMap.Geolocation', function () {
+                    _this.geolocation = new AMap.Geolocation({
+                        enableHighAccuracy: true, //是否使用高精度定位，默认:true
+                        timeout: 10000, //超过10秒后停止定位，默认：无穷大
+                        maximumAge: 0, //定位结果缓存0毫秒，默认：0
+                        convert: true //自动偏移坐标，偏移后的坐标为高德坐标，默认：true
+                    });
+                    map.addControl(_this.geolocation);
+                });
+                AMap.plugin(["AMap.PlaceSearch"], function () {
+                    //构造地点查询类
+                    _this.placeSearch = new AMap.PlaceSearch({
+                        pageSize: 5, // 单页显示结果条数
+                        pageIndex: 1, // 页码
+                        map: map, // 展现结果的地图实例
+                        panel: _this.resultListRef.current, // 结果列表将在此容器中进行展示。
+                        autoFitView: true, // 是否自动调整地图视野使绘制的 Marker点都处于视口的可见范围
+                    });
+                    _this.placeSearch.on("selectChanged", function (e) {
+                        var poi = e.selected.data.location;
+                        _this.syncLocation({
+                            lng: poi.lng,
+                            lat: poi.lat,
+                            address: e.selected.data.address,
+                            city: e.selected.data.cityname,
+                        });
+                    });
+                });
+                if (this.props.value) {
+                    map.setZoomAndCenter(13, [this.props.value.lng, this.props.value.lat]);
+                    this.mark = new AMap.Marker({
+                        position: [this.props.value.lng, this.props.value.lat],
+                    });
+                    this.mark.setMap(map);
+                }
+                else {
+                    this.geolocation.getCurrentPosition(function (status, result) { });
+                }
+                map.on("click", function (e) {
+                    map.setCenter(e.lnglat);
+                    var marker = new AMap.Marker({
+                        position: [e.lnglat.lng, e.lnglat.lat],
+                    });
+                    marker.setMap(map);
+                    if (_this.mark) {
+                        _this.mark.setMap(null);
+                    }
+                    _this.mark = marker;
+                    _this.syncLocation(e.lnglat);
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    BaiduMapPicker.prototype.syncLocation = function (lnglat) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                new Promise(function (resolve, reject) {
+                    var _a, _b;
+                    if (lnglat.address && lnglat.city) {
+                        var data = {
+                            lng: lnglat.lng,
+                            lat: lnglat.lat,
+                            address: lnglat.address,
+                            city: lnglat.city,
+                            vendor: "gaode",
+                        };
+                        if ((_a = _this.props) === null || _a === void 0 ? void 0 : _a.onChange)
+                            (_b = _this.props) === null || _b === void 0 ? void 0 : _b.onChange(data);
+                    }
+                    _this.geocoder.getAddress(lnglat, function (status, result) {
+                        var _a, _b;
+                        if (status === "complete" && result.info === "OK") {
+                            resolve({ status: status, result: result });
+                            var data = {
+                                lng: lnglat.lng,
+                                lat: lnglat.lat,
+                                address: result.regeocode.formattedAddress,
+                                city: result.regeocode.addressComponent.city ||
+                                    result.regeocode.addressComponent.province ||
+                                    result.regeocode.addressComponent.district,
+                                vendor: "gaode",
+                            };
+                            if ((_a = _this.props) === null || _a === void 0 ? void 0 : _a.onChange)
+                                (_b = _this.props) === null || _b === void 0 ? void 0 : _b.onChange(data);
+                        }
+                        else {
+                            reject({ status: status, result: result });
+                        }
+                    });
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    BaiduMapPicker.prototype.handleChange = function (e) {
+        this.setState({
+            inputValue: e.currentTarget.value
+        }, this.search);
+    };
+    BaiduMapPicker.prototype.render = function () {
+        var cx = this.props.classnames;
+        var _a = this.state; _a.locIndex; _a.locs; var inputValue = _a.inputValue; _a.sugs;
+        // const hasSug = Array.isArray(sugs) && sugs.length;
+        return (React__default.createElement("div", { className: cx('MapPicker') },
+            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: "\u641C\u7D22\u5730\u70B9" }))),
+            React__default.createElement("div", { ref: this.mapRef, className: cx('MapPicker-map', {
+                    invisible: false
+                }) }),
+            React__default.createElement("div", { ref: this.resultListRef, className: cx('MapPicker-result', {
+                    invisible: false
+                }) })));
+    };
+    __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]),
+        __metadata("design:returntype", Promise)
+    ], BaiduMapPicker.prototype, "syncLocation", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], BaiduMapPicker.prototype, "handleChange", null);
+    return BaiduMapPicker;
+}(React__default.Component));
+var GaodeMapPicker = themeable(BaiduMapPicker);
+
+export { BaiduMapPicker, GaodeMapPicker as default };