amis 2.0.0-rc.9 → 2.0.2

package/esm/renderers/Mapping.d.ts

@@ -0,0 +1,354 @@
+/// <reference types="hoist-non-react-statics" />
+import React from 'react';
+import { RendererEnv, RendererProps } from 'amis-core';
+import { Api } from 'amis-core';
+import { BaseSchema, SchemaApi, SchemaTokenizeableString, SchemaTpl } from '../Schema';
+import { Instance } from 'mobx-state-tree';
+/**
+ * Mapping 映射展示控件。
+ * 文档：https://baidu.gitee.io/amis/docs/components/mapping
+ */
+export interface MappingSchema extends BaseSchema {
+    /**
+     * 指定为映射展示控件
+     */
+    type: 'map' | 'mapping';
+    /**
+     * 关联字段名。
+     */
+    name?: string;
+    /**
+     * 配置映射规则，值可以使用模板语法。当 key 为 * 时表示 else，也就是说值没有映射到任何规则时用 * 对应的值展示。
+     */
+    map?: {
+        [propName: string]: SchemaTpl;
+    };
+    /**
+     * 如果想远程拉取字典，请配置 source 为接口。
+     */
+    source?: SchemaApi | SchemaTokenizeableString;
+    /**
+     * 占位符
+     */
+    placeholder?: string;
+}
+export declare const Store: import("mobx-state-tree").IModelType<{
+    id: import("mobx-state-tree").ISimpleType<string>;
+    path: import("mobx-state-tree").IType<string | undefined, string, string>;
+    storeType: import("mobx-state-tree").ISimpleType<string>;
+    disposed: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    parentId: import("mobx-state-tree").IType<string | undefined, string, string>;
+    childrenIds: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>;
+} & {
+    fetching: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    errorMsg: import("mobx-state-tree").IType<string | undefined, string, string>;
+    map: import("mobx-state-tree").IType<{
+        [propName: string]: any;
+    } | null | undefined, {
+        [propName: string]: any;
+    }, {
+        [propName: string]: any;
+    }>;
+}, {
+    readonly parentStore: any;
+    readonly __: any;
+    readonly hasChildren: boolean;
+    readonly children: any[];
+} & {
+    onChildStoreDispose(child: any): void;
+    syncProps(props: any, prevProps: any, list?: string[] | undefined): void;
+    dispose: (callback?: (() => void) | undefined) => void;
+    addChildId: (id: string) => void;
+    removeChildId: (id: string) => void;
+} & {
+    load: (env: RendererEnv, api: Api, data: any) => Promise<any>;
+    setMap(options: any): void;
+}, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>;
+export declare type IStore = Instance<typeof Store>;
+export interface MappingProps extends Omit<RendererProps, 'store'>, Omit<MappingSchema, 'type' | 'className'> {
+    store: IStore;
+}
+export declare const MappingField: {
+    new (props: Omit<MappingProps, "store"> | Readonly<Omit<MappingProps, "store">>): {
+        ref: any;
+        store?: ({
+            id: string;
+            path: string;
+            storeType: string;
+            disposed: boolean;
+            parentId: string;
+            childrenIds: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").ISimpleType<string>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>>;
+            fetching: boolean;
+            errorMsg: string;
+            map: {
+                [propName: string]: any;
+            } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IType<{
+                [propName: string]: any;
+            } | null | undefined, {
+                [propName: string]: any;
+            }, {
+                [propName: string]: any;
+            }>>;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            readonly parentStore: any;
+            readonly __: any;
+            readonly hasChildren: boolean;
+            readonly children: any[];
+        } & {
+            onChildStoreDispose(child: any): void;
+            syncProps(props: any, prevProps: any, list?: string[] | undefined): void;
+            dispose: (callback?: (() => void) | undefined) => void;
+            addChildId: (id: string) => void;
+            removeChildId: (id: string) => void;
+        } & {
+            load: (env: RendererEnv, api: Api, data: any) => Promise<any>;
+            setMap(options: any): void;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").ISimpleType<string>;
+            path: import("mobx-state-tree").IType<string | undefined, string, string>;
+            storeType: import("mobx-state-tree").ISimpleType<string>;
+            disposed: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+            parentId: import("mobx-state-tree").IType<string | undefined, string, string>;
+            childrenIds: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>;
+        } & {
+            fetching: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+            errorMsg: import("mobx-state-tree").IType<string | undefined, string, string>;
+            map: import("mobx-state-tree").IType<{
+                [propName: string]: any;
+            } | null | undefined, {
+                [propName: string]: any;
+            }, {
+                [propName: string]: any;
+            }>;
+        }, {
+            readonly parentStore: any;
+            readonly __: any;
+            readonly hasChildren: boolean;
+            readonly children: any[];
+        } & {
+            onChildStoreDispose(child: any): void;
+            syncProps(props: any, prevProps: any, list?: string[] | undefined): void;
+            dispose: (callback?: (() => void) | undefined) => void;
+            addChildId: (id: string) => void;
+            removeChildId: (id: string) => void;
+        } & {
+            load: (env: RendererEnv, api: Api, data: any) => Promise<any>;
+            setMap(options: any): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined;
+        refFn: (ref: any) => void;
+        componentWillUnmount(): void;
+        getWrappedInstance(): any;
+        render(): JSX.Element;
+        context: any;
+        setState<K_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<MappingProps, "store">>) => {} | Pick<{}, K_1> | null) | Pick<{}, K_1> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<MappingProps, "store">> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<MappingProps, "store">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<MappingProps, "store">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<MappingProps, "store">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<MappingProps, "store">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<MappingProps, "store">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<MappingProps, "store">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<MappingProps, "store">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: Omit<MappingProps, "store">, context: any): {
+        ref: any;
+        store?: ({
+            id: string;
+            path: string;
+            storeType: string;
+            disposed: boolean;
+            parentId: string;
+            childrenIds: import("mobx-state-tree").IMSTArray<import("mobx-state-tree").ISimpleType<string>> & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>>;
+            fetching: boolean;
+            errorMsg: string;
+            map: {
+                [propName: string]: any;
+            } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IType<{
+                [propName: string]: any;
+            } | null | undefined, {
+                [propName: string]: any;
+            }, {
+                [propName: string]: any;
+            }>>;
+        } & import("mobx-state-tree/dist/internal").NonEmptyObject & {
+            readonly parentStore: any;
+            readonly __: any;
+            readonly hasChildren: boolean;
+            readonly children: any[];
+        } & {
+            onChildStoreDispose(child: any): void;
+            syncProps(props: any, prevProps: any, list?: string[] | undefined): void;
+            dispose: (callback?: (() => void) | undefined) => void;
+            addChildId: (id: string) => void;
+            removeChildId: (id: string) => void;
+        } & {
+            load: (env: RendererEnv, api: Api, data: any) => Promise<any>;
+            setMap(options: any): void;
+        } & import("mobx-state-tree").IStateTreeNode<import("mobx-state-tree").IModelType<{
+            id: import("mobx-state-tree").ISimpleType<string>;
+            path: import("mobx-state-tree").IType<string | undefined, string, string>;
+            storeType: import("mobx-state-tree").ISimpleType<string>;
+            disposed: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+            parentId: import("mobx-state-tree").IType<string | undefined, string, string>;
+            childrenIds: import("mobx-state-tree").IOptionalIType<import("mobx-state-tree").IArrayType<import("mobx-state-tree").ISimpleType<string>>, [undefined]>;
+        } & {
+            fetching: import("mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+            errorMsg: import("mobx-state-tree").IType<string | undefined, string, string>;
+            map: import("mobx-state-tree").IType<{
+                [propName: string]: any;
+            } | null | undefined, {
+                [propName: string]: any;
+            }, {
+                [propName: string]: any;
+            }>;
+        }, {
+            readonly parentStore: any;
+            readonly __: any;
+            readonly hasChildren: boolean;
+            readonly children: any[];
+        } & {
+            onChildStoreDispose(child: any): void;
+            syncProps(props: any, prevProps: any, list?: string[] | undefined): void;
+            dispose: (callback?: (() => void) | undefined) => void;
+            addChildId: (id: string) => void;
+            removeChildId: (id: string) => void;
+        } & {
+            load: (env: RendererEnv, api: Api, data: any) => Promise<any>;
+            setMap(options: any): void;
+        }, import("mobx-state-tree")._NotCustomized, import("mobx-state-tree")._NotCustomized>>) | undefined;
+        refFn: (ref: any) => void;
+        componentWillUnmount(): void;
+        getWrappedInstance(): any;
+        render(): JSX.Element;
+        context: any;
+        setState<K_1_1 extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Omit<MappingProps, "store">>) => {} | Pick<{}, K_1_1> | null) | Pick<{}, K_1_1> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<MappingProps, "store">> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Omit<MappingProps, "store">>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<MappingProps, "store">>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Omit<MappingProps, "store">>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<MappingProps, "store">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<MappingProps, "store">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<MappingProps, "store">>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<MappingProps, "store">>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    ComposedComponent: React.ComponentType<{
+        new (props: MappingProps): {
+            componentDidMount(): void;
+            componentDidUpdate(prevProps: MappingProps): void;
+            reload(): void;
+            renderSingleValue(key: any, reactKey?: number): JSX.Element;
+            render(): JSX.Element;
+            context: any;
+            setState<K extends never>(state: object | ((prevState: object, props: Readonly<MappingProps>) => object | Pick<object, K> | null) | Pick<object, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<MappingProps> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            state: object;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<MappingProps>, nextState: object, nextContext: any): boolean;
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<MappingProps>, prevState: object): any;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<MappingProps>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<MappingProps>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<MappingProps>, nextState: object, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<MappingProps>, nextState: object, nextContext: any): void;
+        };
+        defaultProps: Partial<MappingProps>;
+        contextType?: React.Context<any> | undefined;
+    }>;
+    contextType?: React.Context<any> | undefined;
+} & import("hoist-non-react-statics").NonReactStatics<{
+    new (props: MappingProps): {
+        componentDidMount(): void;
+        componentDidUpdate(prevProps: MappingProps): void;
+        reload(): void;
+        renderSingleValue(key: any, reactKey?: number): JSX.Element;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: object | ((prevState: object, props: Readonly<MappingProps>) => object | Pick<object, K> | null) | Pick<object, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<MappingProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: object;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<MappingProps>, nextState: object, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<MappingProps>, prevState: object): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<MappingProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<MappingProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<MappingProps>, nextState: object, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<MappingProps>, nextState: object, nextContext: any): void;
+    };
+    defaultProps: Partial<MappingProps>;
+    contextType?: React.Context<any> | undefined;
+}, {}> & {
+    ComposedComponent: {
+        new (props: MappingProps): {
+            componentDidMount(): void;
+            componentDidUpdate(prevProps: MappingProps): void;
+            reload(): void;
+            renderSingleValue(key: any, reactKey?: number): JSX.Element;
+            render(): JSX.Element;
+            context: any;
+            setState<K extends never>(state: object | ((prevState: object, props: Readonly<MappingProps>) => object | Pick<object, K> | null) | Pick<object, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<MappingProps> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            state: object;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<MappingProps>, nextState: object, nextContext: any): boolean;
+            componentWillUnmount?(): void;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<MappingProps>, prevState: object): any;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<MappingProps>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<MappingProps>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<MappingProps>, nextState: object, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<MappingProps>, nextState: object, nextContext: any): void;
+        };
+        defaultProps: Partial<MappingProps>;
+        contextType?: React.Context<any> | undefined;
+    };
+};
+export declare class MappingFieldRenderer extends React.Component<RendererProps> {
+    render(): JSX.Element;
+}

package/esm/renderers/Mapping.js

@@ -0,0 +1,160 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __generator, __assign, __extends, __decorate } from 'tslib';
+import React from 'react';
+import { StoreNode, normalizeApiResponseData, isObject, guid, isPureVariable, resolveVariableAndFilter, isApiOutdated, isEffectiveApi, normalizeApi, getPropValue, Renderer } from 'amis-core';
+import { withStore } from 'amis-ui';
+import { types, flow } from 'mobx-state-tree';
+
+var _a;
+var Store = StoreNode.named('MappingStore')
+    .props({
+    fetching: false,
+    errorMsg: '',
+    map: types.frozen({})
+})
+    .actions(function (self) {
+    var load = flow(function (env, api, data) {
+        var ret, data_1, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, 3, 4]);
+                    self.fetching = true;
+                    return [4 /*yield*/, env.fetcher(api, data)];
+                case 1:
+                    ret = _a.sent();
+                    if (ret.ok) {
+                        data_1 = normalizeApiResponseData(ret.data);
+                        self.setMap(data_1);
+                    }
+                    else {
+                        throw new Error(ret.msg || 'fetch error');
+                    }
+                    return [3 /*break*/, 4];
+                case 2:
+                    e_1 = _a.sent();
+                    self.errorMsg = e_1.message;
+                    return [3 /*break*/, 4];
+                case 3:
+                    self.fetching = false;
+                    return [7 /*endfinally*/];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+    return {
+        load: load,
+        setMap: function (options) {
+            if (isObject(options)) {
+                self.map = __assign({}, options);
+            }
+        }
+    };
+});
+var MappingField = withStore(function (props) {
+    return Store.create({
+        id: guid(),
+        storeType: Store.name
+    }, props.env);
+})((_a = /** @class */ (function (_super) {
+        __extends(class_1, _super);
+        function class_1(props) {
+            var _this = _super.call(this, props) || this;
+            props.store.syncProps(props, undefined, ['map']);
+            return _this;
+        }
+        class_1.prototype.componentDidMount = function () {
+            var _a = this.props; _a.store; _a.source; _a.data;
+            this.reload();
+        };
+        class_1.prototype.componentDidUpdate = function (prevProps) {
+            var props = this.props;
+            var _a = this.props, store = _a.store, source = _a.source, data = _a.data;
+            store.syncProps(props, prevProps, ['map']);
+            if (isPureVariable(source)) {
+                var prev = resolveVariableAndFilter(prevProps.source, prevProps.data, '| raw');
+                var curr = resolveVariableAndFilter(source, data, '| raw');
+                if (prev !== curr) {
+                    store.setMap(curr);
+                }
+            }
+            else if (isApiOutdated(prevProps.source, props.source, prevProps.data, props.data)) {
+                this.reload();
+            }
+        };
+        class_1.prototype.reload = function () {
+            var _a;
+            var _b = this.props, source = _b.source, data = _b.data, env = _b.env;
+            var store = this.props.store;
+            if (isPureVariable(source)) {
+                store.setMap(resolveVariableAndFilter(source, data, '| raw'));
+            }
+            else if (isEffectiveApi(source, data)) {
+                var api = normalizeApi(source, 'get');
+                api.cache = (_a = api.cache) !== null && _a !== void 0 ? _a : 30 * 1000;
+                store.load(env, api, data);
+            }
+        };
+        class_1.prototype.renderSingleValue = function (key, reactKey) {
+            var _a;
+            var _b = this.props, className = _b.className, placeholder = _b.placeholder, render = _b.render, cx = _b.classnames; _b.name; _b.data; var store = _b.store;
+            var viewValue = (React.createElement("span", { className: "text-muted" }, placeholder));
+            var map = store.map;
+            var value = undefined;
+            // trim 一下，干掉一些空白字符。
+            key = typeof key === 'string' ? key.trim() : key;
+            if (typeof key !== 'undefined' &&
+                map &&
+                (value =
+                    (_a = map[key]) !== null && _a !== void 0 ? _a : (key === true && map['1']
+                        ? map['1']
+                        : key === false && map['0']
+                            ? map['0']
+                            : map['*'])) !== undefined) {
+                viewValue = render('tpl', value);
+            }
+            return (React.createElement("span", { key: "map-".concat(reactKey), className: cx('MappingField', className) }, viewValue));
+        };
+        class_1.prototype.render = function () {
+            var _this = this;
+            var mapKey = getPropValue(this.props);
+            if (Array.isArray(mapKey)) {
+                return (React.createElement("span", null, mapKey.map(function (singleKey, index) {
+                    return _this.renderSingleValue(singleKey, index);
+                })));
+            }
+            else {
+                return this.renderSingleValue(mapKey, 0);
+            }
+        };
+        return class_1;
+    }(React.Component)),
+    _a.defaultProps = {
+        placeholder: '-',
+        map: {
+            '*': '通配值'
+        }
+    },
+    _a));
+/** @class */ ((function (_super) {
+    __extends(MappingFieldRenderer, _super);
+    function MappingFieldRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MappingFieldRenderer.prototype.render = function () {
+        return React.createElement(MappingField, __assign({}, this.props));
+    };
+    MappingFieldRenderer = __decorate([
+        Renderer({
+            test: /(^|\/)(?:map|mapping)$/,
+            name: 'mapping'
+        })
+    ], MappingFieldRenderer);
+    return MappingFieldRenderer;
+})(React.Component));
+
+export { MappingField, Store };

package/esm/renderers/Markdown.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @file 用来渲染 Markdown
+ */
+import React from 'react';
+import { RendererProps } from 'amis-core';
+import { BaseSchema } from '../Schema';
+/**
+ * Markdown 渲染
+ * 文档：https://baidu.gitee.io/amis/docs/components/markdown
+ */
+export interface MarkdownSchema extends BaseSchema {
+    /**
+     * markdown 渲染
+     */
+    type: 'markdown';
+    /**
+     * markdown 内容
+     */
+    value?: string;
+    /**
+     * 样式类
+     */
+    className?: string;
+    /**
+     * 名字映射
+     */
+    name?: string;
+}
+export interface MarkdownProps extends RendererProps, Omit<MarkdownSchema, 'type' | 'className'> {
+}
+interface MarkdownState {
+    content: string;
+}
+export declare class Markdown extends React.Component<MarkdownProps, MarkdownState> {
+    constructor(props: MarkdownProps);
+    componentDidUpdate(prevProps: MarkdownProps): void;
+    updateContent(): Promise<void>;
+    render(): JSX.Element;
+}
+export declare class MarkdownRenderer extends Markdown {
+}
+export {};

package/esm/renderers/Markdown.js

@@ -0,0 +1,97 @@
+/**
+ * amis v2.0.2
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __awaiter, __generator, __decorate } from 'tslib';
+import React from 'react';
+import { getPropValue, isPureVariable, resolveVariableAndFilter, isApiOutdated, isEffectiveApi, LazyComponent, Renderer } from 'amis-core';
+
+function loadComponent() {
+    return import('amis-ui/lib/components/Markdown').then(function (item) { return item.default; });
+}
+var Markdown = /** @class */ (function (_super) {
+    __extends(Markdown, _super);
+    function Markdown(props) {
+        var _this = _super.call(this, props) || this;
+        var _a = _this.props, name = _a.name, data = _a.data, src = _a.src;
+        if (src) {
+            _this.state = { content: '' };
+            _this.updateContent();
+        }
+        else {
+            var content = getPropValue(_this.props) ||
+                (name && isPureVariable(name)
+                    ? resolveVariableAndFilter(name, data, '| raw')
+                    : null);
+            _this.state = { content: content };
+        }
+        return _this;
+    }
+    Markdown.prototype.componentDidUpdate = function (prevProps) {
+        var props = this.props;
+        if (props.src) {
+            if (isApiOutdated(prevProps.src, props.src, prevProps.data, props.data)) {
+                this.updateContent();
+            }
+        }
+        else {
+            this.updateContent();
+        }
+    };
+    Markdown.prototype.updateContent = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, name, data, src, env, ret, content;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, name = _a.name, data = _a.data, src = _a.src, env = _a.env;
+                        if (!(src && isEffectiveApi(src, data))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, env.fetcher(src, data)];
+                    case 1:
+                        ret = _b.sent();
+                        if (typeof ret === 'string') {
+                            this.setState({ content: ret });
+                        }
+                        else if (typeof ret === 'object' && ret.data) {
+                            this.setState({ content: ret.data });
+                        }
+                        else {
+                            console.error('markdown response error', ret);
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        content = getPropValue(this.props) ||
+                            (name && isPureVariable(name)
+                                ? resolveVariableAndFilter(name, data, '| raw')
+                                : null);
+                        if (content !== this.state.content) {
+                            this.setState({ content: content });
+                        }
+                        _b.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Markdown.prototype.render = function () {
+        var _a = this.props, className = _a.className, cx = _a.classnames, options = _a.options;
+        return (React.createElement("div", { className: cx('Markdown', className) },
+            React.createElement(LazyComponent, { getComponent: loadComponent, content: this.state.content || '', options: options })));
+    };
+    return Markdown;
+}(React.Component));
+/** @class */ ((function (_super) {
+    __extends(MarkdownRenderer, _super);
+    function MarkdownRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MarkdownRenderer = __decorate([
+        Renderer({
+            type: 'markdown'
+        })
+    ], MarkdownRenderer);
+    return MarkdownRenderer;
+})(Markdown));
+
+export { Markdown };