amis-ui 6.13.0-beta.8 → 6.13.0

package/esm/components/LocationPicker.js

@@ -0,0 +1,208 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __extends, __assign, __decorate, __metadata } from 'tslib';
+import React__default from 'react';
+import { Overlay, PopOver, autobind, themeable, localeable } from 'amis-core';
+import { Icon } from './icons.js';
+import Alert2 from './Alert2.js';
+import BaiduMapPicker from './BaiduMapPicker.js';
+import GaodeMapPicker from './GaodeMapPicker.js';
+import PopUp from './PopUp.js';
+
+var LocationPicker = /** @class */ (function (_super) {
+    __extends(LocationPicker, _super);
+    function LocationPicker() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.domRef = React__default.createRef();
+        _this.state = {
+            isFocused: false,
+            isOpened: false
+        };
+        return _this;
+    }
+    LocationPicker.prototype.handleKeyPress = function (e) {
+        if (e.key === ' ') {
+            this.handleClick();
+            e.preventDefault();
+        }
+    };
+    LocationPicker.prototype.handleFocus = function () {
+        this.setState({
+            isFocused: true
+        });
+    };
+    LocationPicker.prototype.handleBlur = function () {
+        this.setState({
+            isFocused: true
+        });
+    };
+    LocationPicker.prototype.handleClick = function () {
+        this.state.isOpened ? this.close() : this.open();
+    };
+    LocationPicker.prototype.getTarget = function () {
+        return this.domRef.current;
+    };
+    LocationPicker.prototype.getParent = function () {
+        var _a;
+        return (_a = this.domRef.current) === null || _a === void 0 ? void 0 : _a.parentElement;
+    };
+    LocationPicker.prototype.open = function (fn) {
+        this.props.disabled ||
+            this.setState({
+                isOpened: true
+            }, fn);
+        this.tempValue = this.props.value;
+    };
+    LocationPicker.prototype.close = function () {
+        this.setState({
+            isOpened: false
+        });
+    };
+    LocationPicker.prototype.clearValue = function (e) {
+        e.preventDefault();
+        e.stopPropagation();
+        var onChange = this.props.onChange;
+        onChange('');
+    };
+    LocationPicker.prototype.handlePopOverClick = function (e) {
+        e.stopPropagation();
+        e.preventDefault();
+    };
+    LocationPicker.prototype.handleChange = function (value) {
+        if (value) {
+            value = __assign(__assign({}, value), { vendor: this.props.vendor });
+        }
+        this.props.onChange(value);
+    };
+    LocationPicker.prototype.handleTempChange = function (value) {
+        if (value) {
+            value = __assign(__assign({}, value), { vendor: this.props.vendor });
+        }
+        this.tempValue = value;
+    };
+    LocationPicker.prototype.handleConfirm = function () {
+        this.props.onChange(this.tempValue);
+        this.close();
+    };
+    LocationPicker.prototype.render = function () {
+        var _this = this;
+        var _a;
+        var _b = this.props, cx = _b.classnames, value = _b.value, className = _b.className, popoverClassName = _b.popoverClassName, disabled = _b.disabled, placeholder = _b.placeholder, getLocationPlaceholder = _b.getLocationPlaceholder, clearable = _b.clearable, popOverContainer = _b.popOverContainer, vendor = _b.vendor, coordinatesType = _b.coordinatesType, ak = _b.ak, mobileUI = _b.mobileUI, autoSelectCurrentLoc = _b.autoSelectCurrentLoc, onlySelectCurrentLoc = _b.onlySelectCurrentLoc, _c = _b.hideViewControl, hideViewControl = _c === void 0 ? false : _c;
+        var __ = this.props.translate;
+        var _d = this.state, isFocused = _d.isFocused, isOpened = _d.isOpened;
+        ((function () {
+            switch (vendor) {
+                case 'baidu':
+                    return (React__default.createElement(BaiduMapPicker, { ak: ak, value: value, placeholder: __('MapPicker.searchPlaceholder'), coordinatesType: coordinatesType, autoSelectCurrentLoc: autoSelectCurrentLoc, onlySelectCurrentLoc: onlySelectCurrentLoc, onChange: _this.handleChange, hideViewControl: hideViewControl }));
+                case 'gaode':
+                    return (React__default.createElement(GaodeMapPicker, { ak: ak, value: value, coordinatesType: coordinatesType, onChange: _this.handleChange }));
+                default:
+                    return React__default.createElement(Alert2, null, __("{{vendor}} \u5730\u56FE\u63A7\u4EF6\u4E0D\u652F\u6301", { vendor: vendor }));
+            }
+        }))();
+        return (React__default.createElement("div", { tabIndex: 0, onKeyPress: this.handleKeyPress, onFocus: this.handleFocus, onBlur: this.handleBlur, className: cx("LocationPicker", {
+                'is-mobile': mobileUI,
+                'is-disabled': disabled,
+                'is-focused': isFocused,
+                'is-active': isOpened
+            }, className), ref: this.domRef, onClick: this.handleClick },
+            value ? (React__default.createElement("span", { className: cx('LocationPicker-value') }, value.address)) : (React__default.createElement("span", { className: cx('LocationPicker-placeholder') }, __(onlySelectCurrentLoc ? getLocationPlaceholder : placeholder))),
+            clearable && !disabled && value ? (React__default.createElement("a", { className: cx('LocationPicker-clear'), onClick: this.clearValue },
+                React__default.createElement(Icon, { icon: "input-clear", className: "icon" }))) : null,
+            React__default.createElement("a", { className: cx('LocationPicker-toggler') },
+                React__default.createElement(Icon, { icon: "location", className: "icon" })),
+            mobileUI ? (React__default.createElement(PopUp, { className: cx("LocationPicker-popup"), container: popOverContainer || this.getParent, isShow: isOpened, onHide: this.close, showConfirm: true, onConfirm: this.handleConfirm },
+                React__default.createElement("div", { className: cx('LocationPicker-popup-inner') }, vendor === 'baidu' ? (React__default.createElement(BaiduMapPicker, { ak: ak, value: value, placeholder: __('MapPicker.searchPlaceholder'), coordinatesType: coordinatesType, autoSelectCurrentLoc: autoSelectCurrentLoc, onlySelectCurrentLoc: onlySelectCurrentLoc, onChange: this.handleTempChange, hideViewControl: hideViewControl })) : (React__default.createElement(Alert2, null, __('{{vendor}} 地图控件不支持', { vendor: vendor })))))) : (React__default.createElement(Overlay, { target: this.getTarget, container: popOverContainer || this.getParent, rootClose: false, show: isOpened },
+                React__default.createElement(PopOver, { className: cx('LocationPicker-popover', popoverClassName), onHide: this.close, overlay: true, onClick: this.handlePopOverClick, style: { width: (_a = this.getTarget()) === null || _a === void 0 ? void 0 : _a.offsetWidth } }, vendor === 'baidu' ? (React__default.createElement(BaiduMapPicker, { ak: ak, value: value, placeholder: __('MapPicker.searchPlaceholder'), coordinatesType: coordinatesType, autoSelectCurrentLoc: autoSelectCurrentLoc, onlySelectCurrentLoc: onlySelectCurrentLoc, onChange: this.handleChange, hideViewControl: hideViewControl })) : (React__default.createElement(Alert2, null, __('{{vendor}} 地图控件不支持', { vendor: vendor }))))))));
+    };
+    LocationPicker.defaultProps = {
+        placeholder: 'LocationPicker.placeholder',
+        getLocationPlaceholder: 'LocationPicker.getLocation',
+        clearable: false
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "handleKeyPress", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "handleFocus", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "handleBlur", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "handleClick", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "getTarget", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "getParent", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Function]),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "open", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "close", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "clearValue", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "handlePopOverClick", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "handleChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "handleTempChange", null);
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], LocationPicker.prototype, "handleConfirm", null);
+    return LocationPicker;
+}(React__default.Component));
+var ThemedCity = themeable(localeable(LocationPicker));
+
+export { LocationPicker, ThemedCity as default };

package/esm/components/Markdown.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+/**
+ * @file markdown 解析
+ */
+import markdownIt from 'markdown-it';
+export declare function markdown(content: string, options?: markdownIt.Options): string;
+interface MarkdownProps {
+    content: string;
+    options: object;
+}
+export default class Markdown extends React.Component<MarkdownProps> {
+    dom: any;
+    static defaultProps: {
+        content: string;
+        options: {
+            linkify: boolean;
+        };
+    };
+    constructor(props: MarkdownProps);
+    htmlRef(dom: any): void;
+    componentDidUpdate(nextProps: MarkdownProps): void;
+    _render(): Promise<void>;
+    render(): React.JSX.Element;
+}
+export {};

package/esm/components/Markdown.js

@@ -0,0 +1,70 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __extends, __awaiter, __generator } from 'tslib';
+import React__default from 'react';
+import markdownIt from 'markdown-it';
+import { html5Media } from 'markdown-it-html5-media';
+
+var doMarkdown = markdownIt();
+doMarkdown.use(html5Media);
+function markdown(content, options) {
+    if (options) {
+        doMarkdown.set(options);
+    }
+    return doMarkdown.render(content);
+}
+var Markdown = /** @class */ (function (_super) {
+    __extends(Markdown, _super);
+    function Markdown(props) {
+        var _this = _super.call(this, props) || this;
+        _this.htmlRef = _this.htmlRef.bind(_this);
+        return _this;
+    }
+    Markdown.prototype.htmlRef = function (dom) {
+        this.dom = dom;
+        if (!dom) {
+            return;
+        }
+        this._render();
+    };
+    Markdown.prototype.componentDidUpdate = function (nextProps) {
+        if (this.props.content !== nextProps.content) {
+            this._render();
+        }
+    };
+    Markdown.prototype._render = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, content, options;
+            return __generator(this, function (_b) {
+                _a = this.props, content = _a.content, options = _a.options;
+                this.dom.innerHTML = markdown(content, options);
+                // @ts-ignore 需要用户手动加载 katex
+                if (typeof renderMathInElement === 'function') {
+                    // @ts-ignore
+                    renderMathInElement(this.dom, {
+                        delimiters: [
+                            { left: '$$', right: '$$', display: true },
+                            { left: '$', right: '$', display: false }
+                        ]
+                    });
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    Markdown.prototype.render = function () {
+        return (React__default.createElement("div", { "data-testid": "markdown-body", className: "markdown-body", ref: this.htmlRef }));
+    };
+    Markdown.defaultProps = {
+        content: '',
+        options: {
+            linkify: true
+        }
+    };
+    return Markdown;
+}(React__default.Component));
+
+export { Markdown as default, markdown };

package/esm/components/Menu.d.ts

@@ -0,0 +1,2 @@
+import Menu from './menu/index';
+export default Menu;

package/esm/components/Menu.js

@@ -0,0 +1,7 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import Menu from './menu/index.js';
+export { default } from './menu/index.js';

package/esm/components/MixedInput.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="hoist-non-react-statics" />
+import React from 'react';
+import { ThemeProps } from 'amis-core';
+interface MixedInputProps extends ThemeProps {
+    renderInput?: (schema: any, props: any) => React.ReactNode;
+    value?: any;
+    onChange?: (value: any) => void;
+    methods: Array<{
+        label: string;
+        value?: any;
+        test?: (value: any, defaultMethod?: any) => boolean;
+        convert?: (value: any, raw: any) => any;
+        pipeIn?: (value: any) => any;
+        pipeOut?: (value: any) => any;
+        type?: 'text' | 'number' | 'date' | 'time' | 'datetime' | 'select' | 'custom' | 'boolean' | string;
+        inputSettings?: any;
+    }>;
+    disabled?: boolean;
+    hasError?: boolean;
+    popOverContainer?: any;
+}
+declare const _default: {
+    new (props: Omit<MixedInputProps, keyof 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<MixedInputProps, keyof 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<MixedInputProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<MixedInputProps, keyof 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<MixedInputProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<MixedInputProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<MixedInputProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<MixedInputProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<MixedInputProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<MixedInputProps, keyof ThemeProps> & import("packages/amis-core/lib/theme").ThemeOuterProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<React.FC<MixedInputProps>>;
+} & import("hoist-non-react-statics").NonReactStatics<React.FC<MixedInputProps>, {}> & {
+    ComposedComponent: React.FC<MixedInputProps>;
+};
+export default _default;

package/esm/components/MixedInput.js

@@ -0,0 +1,88 @@
+/**
+ * amis-ui v6.13.0
+ * Copyright 2018-2025 fex
+ */
+
+import { __read, __assign } from 'tslib';
+import React__default from 'react';
+import { themeable } from 'amis-core';
+import FieldValue from './condition-builder/Value.js';
+import EnhancedSelect from './Select.js';
+
+var MixedInput = function (_a) {
+    var _b;
+    var value = _a.value, onChange = _a.onChange, methods = _a.methods, hasError = _a.hasError, disabled = _a.disabled, cx = _a.classnames, className = _a.className, style = _a.style, popOverContainer = _a.popOverContainer;
+    var _c = __read(React__default.useState(false), 2), focused = _c[0], setFocused = _c[1];
+    var handleFocus = React__default.useCallback(function () {
+        setFocused(true);
+    }, []);
+    var handleBlur = React__default.useCallback(function () {
+        setFocused(false);
+    }, []);
+    var _d = __read(React__default.useState(null), 2), defaultMethod = _d[0], setDefaultMethod = _d[1];
+    var method = React__default.useMemo(function () {
+        if (!Array.isArray(methods) || !methods.length) {
+            return null;
+        }
+        return (methods.find(function (m) { return m.test && m.test(value, defaultMethod); }) ||
+            defaultMethod ||
+            methods[0]);
+    }, [value, methods, defaultMethod]);
+    var options = React__default.useMemo(function () {
+        return methods.map(function (m) {
+            var _a;
+            return ({
+                label: m.label,
+                value: (_a = m.value) !== null && _a !== void 0 ? _a : m.label
+            });
+        });
+    }, [methods]);
+    var methodChange = React__default.useCallback(function (methodType) {
+        var newMethod = methods.find(function (m) { var _a; return ((_a = m.value) !== null && _a !== void 0 ? _a : m.label) === methodType; });
+        if (!newMethod) {
+            return;
+        }
+        if (newMethod.convert) {
+            // 如果有转换方法，先转换一下
+            value = newMethod.convert((method === null || method === void 0 ? void 0 : method.pipeIn) ? method.pipeIn(value) : value, value);
+        }
+        else {
+            value = (method === null || method === void 0 ? void 0 : method.pipeIn) ? method.pipeIn(value) : value; // 如果有转换方法，先转换一下
+        }
+        setDefaultMethod(newMethod);
+        onChange === null || onChange === void 0 ? void 0 : onChange(newMethod.pipeOut ? newMethod.pipeOut(value) : value);
+    }, [methods, method, value]);
+    var inputValue = React__default.useMemo(function () {
+        if (!method) {
+            return value;
+        }
+        return method.pipeIn ? method.pipeIn(value) : value;
+    }, [value, method]);
+    var inputOnChange = React__default.useCallback(function (newValue) {
+        if (method && method.pipeOut) {
+            newValue = method.pipeOut(newValue);
+        }
+        onChange === null || onChange === void 0 ? void 0 : onChange(newValue);
+    }, [method]);
+    var field = React__default.useMemo(function () {
+        if (!method) {
+            return {
+                type: 'text',
+                label: 'whatever',
+                name: 'whatever'
+            };
+        }
+        return __assign(__assign({}, method.inputSettings), { name: 'whatever', type: (method.type || 'text'), label: method.label });
+    }, [method]);
+    return (React__default.createElement("div", { style: style, className: cx("InputGroup MixedInput", className, {
+            'is-focused': focused,
+            'is-error': hasError,
+            'is-disabled': disabled
+        }) },
+        React__default.createElement(FieldValue, { className: "MixedInput-input", disabled: disabled, field: field, value: inputValue, onChange: inputOnChange, onFocus: handleFocus, onBlur: handleBlur }),
+        React__default.createElement("div", { className: cx('MixedInput-select') },
+            React__default.createElement(EnhancedSelect, { className: cx('MixedInput-select'), value: method ? (_b = method.value) !== null && _b !== void 0 ? _b : method.label : '', options: options, disabled: disabled, simpleValue: true, onChange: methodChange, clearable: false, popOverContainer: popOverContainer }))));
+};
+var MixedInput$1 = themeable(MixedInput);
+
+export { MixedInput$1 as default };

package/esm/components/MobileDevTool.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare const dimensions: {
+    name: string;
+    width: number;
+    height: number;
+}[];
+export default function MobileDevTool(props: {
+    container: HTMLElement | null;
+    previewBody: HTMLElement | null;
+    border?: number;
+    onChangeScale?: (scale: number) => void;
+}): React.JSX.Element;