amis-core 2.6.0 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amis-core",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "amis-core",
   "main": "lib/index.js",
   "module": "esm/index.js",
@@ -101,5 +101,5 @@
       "/.rollup.cache/"
     ]
   },
-  "gitHead": "eb43508d3e904813dd2dc24e4174e45f2fbf8ebf"
+  "gitHead": "e5c1331382b89b481e969273175b1435744d83f9"
 }

package/esm/Root.d.ts

@@ -1,46 +0,0 @@
-import React from 'react';
-import { RendererEnv } from './env';
-import { RendererProps } from './factory';
-import { TranslateFn } from './locale';
-import { IRendererStore } from './store';
-import { SchemaNode } from './types';
-export interface RootRenderProps {
-    location?: Location;
-    theme?: string;
-    [propName: string]: any;
-}
-export interface RootProps {
-    schema: SchemaNode;
-    rootStore: IRendererStore;
-    env: RendererEnv;
-    theme: string;
-    pathPrefix?: string;
-    locale?: string;
-    translate?: TranslateFn;
-    [propName: string]: any;
-}
-export interface RootWrapperProps {
-    env: RendererEnv;
-    children: React.ReactNode;
-    schema: SchemaNode;
-    rootStore: IRendererStore;
-    theme: string;
-    [propName: string]: any;
-}
-export declare function addRootWrapper(fn: (props: RootWrapperProps) => React.ReactNode): void;
-export declare class Root extends React.Component<RootProps> {
-    resolveDefinitions(name: string): {} | undefined;
-    render(): JSX.Element;
-}
-export interface renderChildProps extends Partial<RendererProps> {
-    env: RendererEnv;
-}
-export type ReactElement = React.ReactNode[] | JSX.Element | null | false;
-export declare function renderChildren(prefix: string, node: SchemaNode, props: renderChildProps): ReactElement;
-export declare function renderChild(prefix: string, node: SchemaNode, props: renderChildProps): ReactElement;
-declare const _default: React.ComponentType<RootProps & {
-    scopeRef?: ((ref: any) => void) | undefined;
-}> & {
-    ComposedComponent: React.ComponentType<RootProps>;
-};
-export default _default;

package/esm/Root.js

@@ -1,89 +0,0 @@
-/**
- * amis-core v2.6.0
- * Copyright 2018-2022 fex
- */
-
-import { __extends, __rest, __assign, __decorate, __metadata } from 'tslib';
-import isPlainObject from 'lodash/isPlainObject';
-import React from 'react';
-import { LocaleContext } from './locale.js';
-import { RootRenderer } from './RootRenderer.js';
-import { SchemaRenderer } from './SchemaRenderer.js';
-import { HocScoped } from './Scoped.js';
-import { ThemeContext } from './theme.js';
-import { isEmpty, autobind } from './utils/helper.js';
-import { RootStoreContext } from './WithRootStore.js';
-
-var rootWrappers = [];
-function addRootWrapper(fn) {
-    rootWrappers.push(fn);
-}
-var Root = /** @class */ (function (_super) {
-    __extends(Root, _super);
-    function Root() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Root.prototype.resolveDefinitions = function (name) {
-        var definitions = this.props.schema.definitions;
-        if (!name || isEmpty(definitions)) {
-            return {};
-        }
-        return definitions && definitions[name];
-    };
-    Root.prototype.render = function () {
-        var _a = this.props, schema = _a.schema, rootStore = _a.rootStore, env = _a.env, pathPrefix = _a.pathPrefix, location = _a.location, data = _a.data, locale = _a.locale, translate = _a.translate, rest = __rest(_a, ["schema", "rootStore", "env", "pathPrefix", "location", "data", "locale", "translate"]);
-        var theme = env.theme;
-        var themeName = this.props.theme || 'cxd';
-        if (themeName === 'default') {
-            themeName = 'cxd';
-        }
-        return (React.createElement(RootStoreContext.Provider, { value: rootStore },
-            React.createElement(ThemeContext.Provider, { value: themeName },
-                React.createElement(LocaleContext.Provider, { value: this.props.locale }, rootWrappers.reduce(function (props, wrapper) {
-                    return __assign(__assign({}, props), { children: wrapper(props) });
-                }, __assign(__assign({ pathPrefix: pathPrefix || '', schema: isPlainObject(schema)
-                        ? __assign({ type: 'page' }, schema) : schema }, rest), { render: renderChild, rootStore: rootStore, resolveDefinitions: this.resolveDefinitions, location: location, data: data, env: env, classnames: theme.classnames, classPrefix: theme.classPrefix, locale: locale, translate: translate, children: (React.createElement(RootRenderer, __assign({ pathPrefix: pathPrefix || '', schema: isPlainObject(schema)
-                            ? __assign({ type: 'page' }, schema) : schema }, rest, { render: renderChild, rootStore: rootStore, resolveDefinitions: this.resolveDefinitions, location: location, data: data, env: env, classnames: theme.classnames, classPrefix: theme.classPrefix, locale: locale, translate: translate }))) })).children))));
-    };
-    __decorate([
-        autobind,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [String]),
-        __metadata("design:returntype", void 0)
-    ], Root.prototype, "resolveDefinitions", null);
-    return Root;
-}(React.Component));
-function renderChildren(prefix, node, props) {
-    if (Array.isArray(node)) {
-        var elemKey = props.key || props.propKey || props.id || '';
-        return node.map(function (node, index) {
-            return renderChild("".concat(prefix, "/").concat(index), node, __assign(__assign({}, props), { key: "".concat(elemKey ? "".concat(elemKey, "-") : '').concat(index) }));
-        });
-    }
-    return renderChild(prefix, node, props);
-}
-function renderChild(prefix, node, props) {
-    if (Array.isArray(node)) {
-        return renderChildren(prefix, node, props);
-    }
-    var typeofnode = typeof node;
-    if (typeofnode === 'undefined' || node === null) {
-        return null;
-    }
-    else if (React.isValidElement(node)) {
-        return node;
-    }
-    var schema = typeofnode === 'string' || typeofnode === 'number'
-        ? { type: 'tpl', tpl: String(node) }
-        : node;
-    var transform = props.propsTransform;
-    if (transform) {
-        props = __assign({}, props);
-        delete props.propsTransform;
-        props = transform(props);
-    }
-    return (React.createElement(SchemaRenderer, __assign({ render: renderChild }, props, { schema: schema, propKey: schema.key, "$path": "".concat(prefix ? "".concat(prefix, "/") : '').concat((schema && schema.type) || '') })));
-}
-var ScopedRootRenderer = HocScoped(Root);
-
-export { Root, addRootWrapper, ScopedRootRenderer as default, renderChild, renderChildren };

package/esm/RootRenderer.d.ts

@@ -1,27 +0,0 @@
-import React from 'react';
-import type { RootProps } from './Root';
-import { IScopedContext } from './Scoped';
-import { IRootStore } from './store/root';
-import { ActionObject } from './types';
-export interface RootRendererProps extends RootProps {
-    location?: any;
-    render: (region: string, schema: any, props: any) => React.ReactNode;
-}
-export declare class RootRenderer extends React.Component<RootRendererProps> {
-    store: IRootStore;
-    static contextType: React.Context<IScopedContext>;
-    constructor(props: RootRendererProps);
-    componentDidMount(): void;
-    componentDidUpdate(prevProps: RootRendererProps): void;
-    componentDidCatch(error: any, errorInfo: any): void;
-    componentWillUnmount(): void;
-    handlePageVisibilityChange(): void;
-    handleAction(e: React.UIEvent<any> | void, action: ActionObject, ctx: object, throwErrors?: boolean, delegate?: IScopedContext): void;
-    handleDialogConfirm(values: object[], action: ActionObject, ...args: Array<any>): void;
-    handleDialogClose(confirmed?: boolean): void;
-    handleDrawerConfirm(values: object[], action: ActionObject, ...args: Array<any>): void;
-    handleDrawerClose(): void;
-    openFeedback(dialog: any, ctx: any): Promise<unknown>;
-    reloadTarget(scoped: IScopedContext, target: string, data?: any): void;
-    render(): React.ReactNode;
-}

package/esm/RootRenderer.js

@@ -1,279 +0,0 @@
-/**
- * amis-core v2.6.0
- * Copyright 2018-2022 fex
- */
-
-import { __extends, __assign, __awaiter, __generator, __spreadArray, __rest, __decorate, __metadata } from 'tslib';
-import { observer } from 'mobx-react';
-import React from 'react';
-import { ScopedContext } from './Scoped.js';
-import { RootStore } from './store/root.js';
-import { guid, bulkBindFunctions, isVisible } from './utils/helper.js';
-import { filter } from './utils/tpl.js';
-import qs from 'qs';
-import pick from 'lodash/pick';
-import mapValues from 'lodash/mapValues';
-import { saveAs } from 'file-saver';
-import { normalizeApi } from './utils/api.js';
-
-var RootRenderer = /** @class */ (function (_super) {
-    __extends(RootRenderer, _super);
-    function RootRenderer(props) {
-        var _this = this;
-        var _a;
-        _this = _super.call(this, props) || this;
-        _this.store = props.rootStore.addStore({
-            id: guid(),
-            path: _this.props.$path,
-            storeType: RootStore.name,
-            parentId: ''
-        });
-        _this.store.initData(props.data);
-        _this.store.updateLocation(props.location, (_a = _this.props.env) === null || _a === void 0 ? void 0 : _a.parseLocation);
-        bulkBindFunctions(_this, [
-            'handleAction',
-            'handleDialogConfirm',
-            'handleDialogClose',
-            'handleDrawerConfirm',
-            'handleDrawerClose',
-            'handlePageVisibilityChange'
-        ]);
-        return _this;
-    }
-    RootRenderer.prototype.componentDidMount = function () {
-        document.addEventListener('visibilitychange', this.handlePageVisibilityChange);
-    };
-    RootRenderer.prototype.componentDidUpdate = function (prevProps) {
-        var props = this.props;
-        if (props.data !== prevProps.data) {
-            this.store.initData(props.data);
-        }
-        if (props.location !== prevProps.location) {
-            this.store.updateLocation(props.location);
-        }
-    };
-    RootRenderer.prototype.componentDidCatch = function (error, errorInfo) {
-        this.store.setRuntimeError(error, errorInfo);
-    };
-    RootRenderer.prototype.componentWillUnmount = function () {
-        this.props.rootStore.removeStore(this.store);
-        document.removeEventListener('visibilitychange', this.handlePageVisibilityChange);
-    };
-    RootRenderer.prototype.handlePageVisibilityChange = function () {
-        var env = this.props.env;
-        if (document.visibilityState === 'hidden') {
-            env === null || env === void 0 ? void 0 : env.tracker({
-                eventType: 'pageHidden'
-            });
-        }
-        else if (document.visibilityState === 'visible') {
-            env === null || env === void 0 ? void 0 : env.tracker({
-                eventType: 'pageVisible'
-            });
-        }
-    };
-    RootRenderer.prototype.handleAction = function (e, action, ctx, throwErrors, delegate) {
-        var _this = this;
-        var _a, _b;
-        if (throwErrors === void 0) { throwErrors = false; }
-        var _c = this.props, env = _c.env, messages = _c.messages, onAction = _c.onAction, render = _c.render;
-        var store = this.store;
-        if ((onAction === null || onAction === void 0 ? void 0 : onAction(e, action, ctx, throwErrors, delegate || this.context)) ===
-            false) {
-            return;
-        }
-        var scoped = delegate || this.context;
-        if (action.actionType === 'reload') {
-            action.target && scoped.reload(action.target, ctx);
-        }
-        else if (action.target) {
-            action.target.split(',').forEach(function (name) {
-                var target = scoped.getComponentByName(name);
-                target &&
-                    target.doAction &&
-                    target.doAction(__assign(__assign({}, action), { target: undefined }), ctx);
-            });
-        }
-        else if (action.actionType === 'url' ||
-            action.actionType === 'link' ||
-            action.actionType === 'jump') {
-            if (!env || !env.jumpTo) {
-                throw new Error('env.jumpTo is required!');
-            }
-            env.jumpTo(filter((action.to || action.url || action.link), ctx, '| raw'), action, ctx);
-        }
-        else if (action.actionType === 'email') {
-            var mailTo = filter(action.to, ctx);
-            var mailInfo = mapValues(pick(action, 'to', 'cc', 'bcc', 'subject', 'body'), function (val) { return filter(val, ctx); });
-            var mailStr = qs.stringify(mailInfo);
-            var mailto = "mailto:".concat(mailTo, "?").concat(mailStr);
-            window.open(mailto);
-        }
-        else if (action.actionType === 'dialog') {
-            store.setCurrentAction(action);
-            store.openDialog(ctx);
-        }
-        else if (action.actionType === 'drawer') {
-            store.setCurrentAction(action);
-            store.openDrawer(ctx);
-        }
-        else if (action.actionType === 'toast') {
-            (_b = (_a = action.toast) === null || _a === void 0 ? void 0 : _a.items) === null || _b === void 0 ? void 0 : _b.forEach(function (item) {
-                env.notify(item.level || 'info', item.body
-                    ? render('body', item.body, __assign(__assign({}, _this.props), { data: ctx }))
-                    : '', __assign(__assign(__assign({}, action.toast), item), { title: item.title
-                        ? render('title', item.title, __assign(__assign({}, _this.props), { data: ctx }))
-                        : null, useMobileUI: env.useMobileUI }));
-            });
-        }
-        else if (action.actionType === 'ajax') {
-            store.setCurrentAction(action);
-            store
-                .saveRemote(action.api, ctx, {
-                successMessage: (action.messages && action.messages.success) ||
-                    (messages && messages.saveSuccess),
-                errorMessage: (action.messages && action.messages.failed) ||
-                    (messages && messages.saveSuccess)
-            })
-                .then(function () { return __awaiter(_this, void 0, void 0, function () {
-                var redirect;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!(action.feedback && isVisible(action.feedback, store.data))) return [3 /*break*/, 2];
-                            return [4 /*yield*/, this.openFeedback(action.feedback, store.data)];
-                        case 1:
-                            _a.sent();
-                            _a.label = 2;
-                        case 2:
-                            redirect = action.redirect && filter(action.redirect, store.data);
-                            redirect && env.jumpTo(redirect, action);
-                            action.reload &&
-                                this.reloadTarget(delegate || this.context, action.reload, store.data);
-                            return [2 /*return*/];
-                    }
-                });
-            }); })
-                .catch(function (e) {
-                if (throwErrors || action.countDown) {
-                    throw e;
-                }
-            });
-        }
-        else if (action.actionType === 'copy' &&
-            (action.content || action.copy)) {
-            env.copy &&
-                env.copy(filter(action.content || action.copy, ctx, '| raw'), {
-                    format: action.copyFormat
-                });
-        }
-        else if (action.actionType === 'saveAs') {
-            // 使用 saveAs 实现下载
-            // 不支持 env，除非以后将 saveAs 代码拷过来改
-            var api = normalizeApi(action.api);
-            if (typeof api.url === 'string') {
-                var fileName = action.fileName || 'data.txt';
-                if (!action.fileName && api.url.indexOf('.') !== -1) {
-                    fileName = api.url.split('/').pop();
-                }
-                saveAs(api.url, fileName);
-            }
-        }
-    };
-    RootRenderer.prototype.handleDialogConfirm = function (values, action) {
-        var args = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
-        }
-        var store = this.store;
-        if (action.mergeData && values.length === 1 && values[0]) {
-            store.updateData(values[0]);
-        }
-        var dialog = store.action.dialog;
-        if (dialog &&
-            dialog.onConfirm &&
-            dialog.onConfirm.apply(dialog, __spreadArray([values, action], args, false)) === false) {
-            return;
-        }
-        store.closeDialog(true);
-    };
-    RootRenderer.prototype.handleDialogClose = function (confirmed) {
-        if (confirmed === void 0) { confirmed = false; }
-        var store = this.store;
-        store.closeDialog(confirmed);
-    };
-    RootRenderer.prototype.handleDrawerConfirm = function (values, action) {
-        var args = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
-        }
-        var store = this.store;
-        if (action.mergeData && values.length === 1 && values[0]) {
-            store.updateData(values[0]);
-        }
-        var drawer = store.action.drawer;
-        if (drawer &&
-            drawer.onConfirm &&
-            drawer.onConfirm.apply(drawer, __spreadArray([values, action], args, false)) === false) {
-            return;
-        }
-        store.closeDrawer();
-    };
-    RootRenderer.prototype.handleDrawerClose = function () {
-        var store = this.store;
-        store.closeDrawer();
-    };
-    RootRenderer.prototype.openFeedback = function (dialog, ctx) {
-        var _this = this;
-        return new Promise(function (resolve) {
-            var store = _this.store;
-            store.setCurrentAction({
-                type: 'button',
-                actionType: 'dialog',
-                dialog: dialog
-            });
-            store.openDialog(ctx, undefined, function (confirmed) {
-                resolve(confirmed);
-            });
-        });
-    };
-    RootRenderer.prototype.reloadTarget = function (scoped, target, data) {
-        scoped.reload(target, data);
-    };
-    RootRenderer.prototype.render = function () {
-        var _a;
-        var _b = this.props, pathPrefix = _b.pathPrefix, schema = _b.schema, render = _b.render, rest = __rest(_b, ["pathPrefix", "schema", "render"]);
-        var store = this.store;
-        if (store.runtimeError) {
-            return render('error', {
-                type: 'alert',
-                level: 'danger'
-            }, __assign(__assign({}, rest), { topStore: this.store, body: (React.createElement(React.Fragment, null,
-                    React.createElement("h3", null, (_a = this.store.runtimeError) === null || _a === void 0 ? void 0 : _a.toString()),
-                    React.createElement("pre", null,
-                        React.createElement("code", null, this.store.runtimeErrorStack.componentStack)))) }));
-        }
-        return (React.createElement(React.Fragment, null,
-            render(pathPrefix, schema, __assign(__assign({}, rest), { topStore: this.store, data: this.store.downStream, onAction: this.handleAction })),
-            render('spinner', {
-                type: 'spinner'
-            }, __assign(__assign({}, rest), { topStore: this.store, show: store.loading })),
-            store.error
-                ? render('error', {
-                    type: 'alert'
-                }, __assign(__assign({}, rest), { topStore: this.store, body: store.msg, showCloseButton: true, onClose: store.clearMessage }))
-                : null,
-            render('dialog', __assign(__assign({}, (store.action &&
-                store.action.dialog)), { type: 'dialog' }), __assign(__assign({}, rest), { key: 'dialog', topStore: this.store, data: store.dialogData, onConfirm: this.handleDialogConfirm, onClose: this.handleDialogClose, show: store.dialogOpen, onAction: this.handleAction })),
-            render('drawer', __assign(__assign({}, (store.action &&
-                store.action.drawer)), { type: 'drawer' }), __assign(__assign({}, rest), { key: 'drawer', topStore: this.store, data: store.drawerData, onConfirm: this.handleDrawerConfirm, onClose: this.handleDrawerClose, show: store.drawerOpen, onAction: this.handleAction }))));
-    };
-    RootRenderer.contextType = ScopedContext;
-    RootRenderer = __decorate([
-        observer,
-        __metadata("design:paramtypes", [Object])
-    ], RootRenderer);
-    return RootRenderer;
-}(React.Component));
-
-export { RootRenderer };

package/esm/SchemaRenderer.d.ts

@@ -1,37 +0,0 @@
-import React from 'react';
-import { RendererConfig, RendererEnv, RendererProps } from './factory';
-import { Schema, SchemaNode } from './types';
-import { RendererEvent } from './utils/renderer-event';
-interface SchemaRendererProps extends Partial<RendererProps> {
-    schema: Schema;
-    $path: string;
-    env: RendererEnv;
-}
-export declare class SchemaRenderer extends React.Component<SchemaRendererProps, any> {
-    static displayName: string;
-    static contextType: React.Context<import("./Scoped").IScopedContext>;
-    rendererKey: string;
-    renderer: RendererConfig | null;
-    ref: any;
-    cRef: any;
-    schema: any;
-    path: string;
-    reaction: any;
-    unbindEvent: (() => void) | undefined;
-    constructor(props: SchemaRendererProps);
-    componentDidMount(): void;
-    componentWillUnmount(): void;
-    shouldComponentUpdate(nextProps: SchemaRendererProps): boolean;
-    resolveRenderer(props: SchemaRendererProps, force?: boolean): any;
-    getWrappedInstance(): any;
-    refFn(ref: any): void;
-    childRef(ref: any): void;
-    dispatchEvent(e: React.MouseEvent<any>, data: any, renderer?: React.Component<RendererProps>): Promise<RendererEvent<any> | void>;
-    renderChild(region: string, node?: SchemaNode, subProps?: {
-        data?: object;
-        [propName: string]: any;
-    }): JSX.Element;
-    reRender(): void;
-    render(): JSX.Element | null;
-}
-export {};