amis-core 6.11.0-beta.1 → 6.11.0-beta.2

package/esm/globalVar.d.ts

@@ -0,0 +1,173 @@
+/**
+ * 全局变量
+ *
+ * 用于实现跨组件、跨页面的数据共享，支持持久化。
+ */
+import { JSONSchema } from './types';
+import { IRootStore } from './store/root';
+/**
+ * 全局变量的定义
+ */
+export interface GlobalVariableItem {
+    id?: string;
+    /**
+     * 设计态属性。
+     * 全局变量类型，不是数据体类型，而是用于区分不同的配置方式。
+     * 这个字段运行时无含义，主要用于编辑器中的分类。
+     *
+     * 比如平台可能扩充：应用级别、页面级别、用户级别、数据字典关联、数据模型关联等。
+     * amis 中内置了：builtin 为简单的客户端存储，服务端存储需要外部扩充。
+     *
+     * @default builtin
+     */
+    type?: string | 'builtin';
+    /**
+     * 变量名
+     */
+    key: string;
+    /**
+     * 变量标题
+     */
+    label?: string;
+    /**
+     * 变量描述
+     */
+    description?: string;
+    /**
+     * 默认值
+     */
+    defaultValue?: string;
+    /**
+     * 值的数据类型定义
+     */
+    valueSchema?: JSONSchema;
+    /**
+     * 数据作用域
+     */
+    scope?: 'page' | 'app';
+    /**
+     * 数据存储方式
+     */
+    storageOn?: 'client' | 'server' | 'session';
+    /**
+     * 是否只读，不允许修改，运行态属性。
+     */
+    readonly?: boolean;
+    /**
+     * @default true
+     * 是否自动保存，如果不特殊配置，会自动保存
+     */
+    autoSave?: boolean;
+    validationErrors?: any;
+    validations?: any;
+    [propName: string]: any;
+}
+export type GlobalVarGetter = (variable: GlobalVariableItem, context: GlobalVarContext) => Promise<any>;
+export type GlobalVarBulkGetter = (context: GlobalVarContext) => Promise<Record<string, any>> | Record<string, any>;
+export type GlobalVarSetter = (variable: GlobalVariableItem, value: Record<string, any>, context: GlobalVarContext) => Promise<any>;
+export type GlobalVarBulkSetter = (values: Record<string, any>, context: GlobalVarContext) => Promise<any> | any;
+export interface GlobalVariableItemFull extends GlobalVariableItem {
+    /**
+     * 校验数值是否合法
+     * @param value
+     * @returns
+     */
+    validate?: (value: any, values: Record<string, any>) => string | void;
+    /**
+     * 权重，用于排序
+     */
+    order?: number;
+    /**
+     * 单个数据初始化获取
+     * @returns
+     */
+    getter?: GlobalVarGetter;
+    /**
+     * 批量数据初始化获取
+     * @returns
+     */
+    bulkGetter?: GlobalVarBulkGetter;
+    /**
+     * 当个数据修改保存
+     * @param value
+     * @returns
+     */
+    setter?: GlobalVarSetter;
+    /**
+     * 批量全局变量数据保存，多个变量一起保存
+     * @param values
+     * @returns
+     */
+    bulkSetter?: GlobalVarBulkSetter;
+}
+/**
+ * 全局变量的状态
+ */
+export interface GlobalVariableState {
+    /**
+     * 当前值
+     */
+    value: any;
+    /**
+     * 原始值
+     */
+    pristine: any;
+    /**
+     * 是否正在加载, 或者说正在获取
+     */
+    busy?: boolean;
+    /**
+     * 是否已经初始化
+     */
+    initialized: boolean;
+    /**
+     * 数据是否合法
+     */
+    valid: boolean;
+    /**
+     * 错误馨馨
+     */
+    errorMessages: string[];
+    /**
+     * 是否有变更
+     */
+    touched: boolean;
+    /**
+     * 是否有保存
+     */
+    saved: boolean;
+}
+export interface GlobalVarContext {
+    variables: Array<GlobalVariableItem>;
+    [propName: string]: any;
+}
+/**
+ * 全局变量处理器, 可以处理全变量的初始化、校验、存储等操作
+ */
+export type GlobalVariableHandler = (variable: GlobalVariableItem | GlobalVariableItemFull, context: GlobalVarContext) => GlobalVariableItemFull | void | ((variable: GlobalVariableItem | GlobalVariableItemFull, context: GlobalVarContext) => GlobalVariableItemFull | void);
+/**
+ * 注册全局变量处理器
+ * @param handler
+ */
+export declare function registerGlobalVariableHandler(handler: GlobalVariableHandler): void;
+/**
+ * 通过处理器构建全局变量细节对象，用于后续的初始化、校验、存储等操作
+ * @param variable
+ * @param context
+ * @returns
+ */
+export declare function buildGlobalVariable(variable: GlobalVariableItem | GlobalVariableItemFull, context: GlobalVarContext): GlobalVariableItemFull;
+/**
+ * 构建变量初始状态
+ * @returns
+ */
+export declare function createGlobalVarState(): GlobalVariableState;
+export declare function isGlobalVarExpression(value: string): boolean;
+/**
+ * 监控组件的全局变量
+ * @param schema
+ * @param topStore
+ * @param callback
+ * @returns
+ */
+export declare function observeGlobalVars(schema: any, topStore: IRootStore, callback: () => void): () => void;

package/esm/globalVar.js

@@ -0,0 +1,122 @@
+/**
+ * amis-core v6.11.0-beta.2
+ * Copyright 2018-2024 fex
+ */
+
+import { isExpression } from './utils/formula.js';
+import { reaction } from 'mobx';
+import { resolveVariableAndFilter } from './utils/resolveVariableAndFilter.js';
+
+/**
+ * 全局变量
+ *
+ * 用于实现跨组件、跨页面的数据共享，支持持久化。
+ */
+var handlers = [];
+/**
+ * 注册全局变量处理器
+ * @param handler
+ */
+function registerGlobalVariableHandler(handler) {
+    handlers.push(handler);
+}
+/**
+ * 通过处理器构建全局变量细节对象，用于后续的初始化、校验、存储等操作
+ * @param variable
+ * @param context
+ * @returns
+ */
+function buildGlobalVariable(variable, context) {
+    var postHandlers = [];
+    var result = handlers.reduce(function (item, handler) {
+        var result = handler(item, context);
+        if (typeof result === 'function') {
+            postHandlers.push(result);
+        }
+        return (result !== null && result !== void 0 ? result : item);
+    }, variable);
+    result = postHandlers.reduce(function (item, handler) { var _a; return (_a = handler(item, context)) !== null && _a !== void 0 ? _a : item; }, result);
+    return result;
+}
+/**
+ * 构建变量初始状态
+ * @returns
+ */
+function createGlobalVarState() {
+    return {
+        value: undefined,
+        pristine: undefined,
+        initialized: false,
+        valid: true,
+        errorMessages: [],
+        touched: false,
+        saved: false
+    };
+}
+// 前两个是历史遗留，后两个是新的
+var globalVarFields = ['__page.', 'appVariables.', 'global.', 'globalState.'];
+function isGlobalVarExpression(value) {
+    return (typeof value === 'string' &&
+        isExpression(value) &&
+        globalVarFields.some(function (k) { return value.includes(k); }));
+}
+/**
+ * 监控组件的全局变量
+ * @param schema
+ * @param topStore
+ * @param callback
+ * @returns
+ */
+function observeGlobalVars(schema, topStore, callback) {
+    var expressions = [];
+    Object.keys(schema).forEach(function (key) {
+        var value = schema[key];
+        if (isGlobalVarExpression(value)) {
+            expressions.push({
+                key: key,
+                value: value
+            });
+        }
+        else if ([
+            'items',
+            'body',
+            'buttons',
+            'header',
+            'columns',
+            'tabs',
+            'footer',
+            'actions',
+            'toolbar'
+        ].includes(key)) {
+            var items = Array.isArray(value) ? value : [value];
+            items.forEach(function (item) {
+                if (isGlobalVarExpression(item === null || item === void 0 ? void 0 : item.visibleOn)) {
+                    expressions.push({
+                        key: "".concat(key, ".x.visibleOn"),
+                        value: item.visibleOn
+                    });
+                }
+                else if (isGlobalVarExpression(item === null || item === void 0 ? void 0 : item.hiddenOn)) {
+                    expressions.push({
+                        key: "".concat(key, ".x.hiddenOn"),
+                        value: item.hiddenOn
+                    });
+                }
+            });
+        }
+    });
+    if (!expressions.length) {
+        return function () { };
+    }
+    var unReaction = reaction(function () {
+        return expressions
+            .map(function (exp) {
+            return "".concat(exp.key, ":").concat(resolveVariableAndFilter(exp.value, topStore.downStream, '| json' // 如果用了复杂对象，要靠这个来比较
+            ));
+        })
+            .join(',');
+    }, callback);
+    return unReaction;
+}
+
+export { buildGlobalVariable, createGlobalVarState, isGlobalVarExpression, observeGlobalVars, registerGlobalVariableHandler };

package/esm/globalVarClientHandler.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/globalVarClientHandler.js

@@ -0,0 +1,65 @@
+/**
+ * amis-core v6.11.0-beta.2
+ * Copyright 2018-2024 fex
+ */
+
+import { __assign } from 'tslib';
+import { registerGlobalVariableHandler } from './globalVar.js';
+
+function loadClientData(key, variables) {
+    var str = localStorage.getItem(key);
+    var data = {};
+    try {
+        data = JSON.parse(str || '{}');
+    }
+    catch (e) {
+        console.error("parse localstorage \"".concat(key, " error\""), e);
+    }
+    var filterData = {};
+    variables.forEach(function (item) {
+        if (data.hasOwnProperty(item.key)) {
+            filterData[item.key] = data[item.key];
+        }
+    });
+    return filterData;
+}
+function saveClientData(key, values, variables) {
+    var str = localStorage.getItem(key);
+    var data = {};
+    try {
+        data = JSON.parse(str || '{}');
+    }
+    catch (e) {
+        console.error("parse localstorage \"".concat(key, " error\""), e);
+    }
+    Object.assign(data, values);
+    localStorage.setItem(key, JSON.stringify(data));
+}
+function bulkClientGetter(_a) {
+    var variables = _a.variables;
+    return loadClientData('amis-client-vars', variables);
+}
+function bulkClientSetter(values, context) {
+    return saveClientData('amis-client-vars', values, context.variables);
+}
+function pageBulkClientGetter(context) {
+    var variables = context.variables;
+    var key = "amis-client-vars-".concat(context.pageId || location.pathname);
+    return loadClientData(key, variables);
+}
+function pageBulkClientSetter(values, context) {
+    var key = "amis-client-vars-".concat(context.pageId || location.pathname);
+    return saveClientData(key, values, context.variables);
+}
+/**
+ * 注册全局变量处理器，用来处理 storageOn 为 client 的变量
+ *
+ * 并且根据变量的 scope 来决定是 page 还是全局的
+ *
+ * 将数据存入 localStorage
+ */
+registerGlobalVariableHandler(function (variable, context) {
+    if (variable.storageOn === 'client') {
+        return __assign(__assign({}, variable), { bulkGetter: variable.scope === 'page' ? pageBulkClientGetter : bulkClientGetter, bulkSetter: variable.scope === 'page' ? pageBulkClientSetter : bulkClientSetter });
+    }
+});

package/esm/globalVarDefaultValueHandler.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/globalVarDefaultValueHandler.js

@@ -0,0 +1,28 @@
+/**
+ * amis-core v6.11.0-beta.2
+ * Copyright 2018-2024 fex
+ */
+
+import { __assign } from 'tslib';
+import { registerGlobalVariableHandler } from './globalVar.js';
+
+/**
+ * 格式化默认值
+ */
+registerGlobalVariableHandler(function (variable, context) {
+    var _a;
+    if (variable.defaultValue && typeof variable.defaultValue === 'string') {
+        var defaultValue = variable.defaultValue;
+        try {
+            var value = defaultValue;
+            var valueType = (_a = variable.valueSchema) === null || _a === void 0 ? void 0 : _a.type;
+            if (valueType && ['number', 'array', 'object'].includes(valueType)) {
+                value = JSON.parse(defaultValue);
+            }
+            return __assign(__assign({}, variable), { defaultValue: value });
+        }
+        catch (e) {
+            // do nothing
+        }
+    }
+});

package/esm/index.d.ts

@@ -15,7 +15,10 @@ export * from './utils/index';
 export * from './utils/animations';
 export * from './types';
 export * from './store';
+export * from './globalVar';
 import * as utils from './utils/helper';
+import './globalVarClientHandler';
+import './globalVarDefaultValueHandler';
 import { RegisterStore, registerStore } from './store';
 import type { IColumn, IColumn2, IRow, IRow2 } from './store';
 import { setDefaultLocale, getDefaultLocale, makeTranslator, register as registerLocale, extendLocale, removeLocaleData, localeable } from './locale';

package/esm/index.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.1
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 
@@ -10,7 +10,7 @@ import './polyfills.js';
 import './renderers/builtin.js';
 import './renderers/register.js';
 import { wrapFetcher } from './utils/api.js';
-export { addApiRequestAdaptor, addApiResponseAdaptor, addApiResponseAdator, buildApi, callStrFunction, clearApiCache, getApiCache, isApiOutdated, isApiOutdatedWithData, isEffectiveApi, isSameApi, isValidApi, jsFetcher, jsonpFetcher, normalizeApi, normalizeApiResponseData, removeApiRequestAdaptor, removeApiResponseAdaptor, responseAdaptor, setApiCache, str2AsyncFunction, str2function, wrapAdaptor, wrapFetcher } from './utils/api.js';
+export { addApiRequestAdaptor, addApiResponseAdaptor, addApiResponseAdator, buildApi, callStrFunction, clearApiCache, getApiCache, isApiOutdated, isApiOutdatedWithData, isEffectiveApi, isSameApi, isValidApi, jsFetcher, jsonpFetcher, normalizeApi, normalizeApiResponseData, removeApiRequestAdaptor, removeApiResponseAdaptor, responseAdaptor, setApiCache, shouldBlockedBySendOnApi, str2AsyncFunction, str2function, wrapAdaptor, wrapFetcher } from './utils/api.js';
 export { attachmentAdpator } from './utils/attachmentAdpator.js';
 export { autobindMethod, bind } from './utils/autobind.js';
 export { chromeVersion, isSafari } from './utils/browser.js';
@@ -81,6 +81,9 @@ export { default as animation } from './utils/Animation.js';
 export { createAnimationStyle } from './utils/animations.js';
 import { RendererStore } from './store/index.js';
 export { RegisterStore, RendererStore, registerStore } from './store/index.js';
+export { buildGlobalVariable, createGlobalVarState, isGlobalVarExpression, observeGlobalVars, registerGlobalVariableHandler } from './globalVar.js';
+import './globalVarClientHandler.js';
+import './globalVarDefaultValueHandler.js';
 import { getEnv } from 'mobx-state-tree';
 import { getDefaultLocale, makeTranslator } from './locale.js';
 export { extendLocale, getDefaultLocale, localeable, makeTranslator, register as registerLocale, removeLocaleData, setDefaultLocale } from './locale.js';
@@ -151,10 +154,10 @@ export { StoreNode } from './store/node.js';
  */
 var classPrefix = getClassPrefix();
 // @ts-ignore
-var version = '6.11.0-beta.1';
+var version = '6.11.0-beta.2';
 window.amisVersionInfo = {
-    version: '6.11.0-beta.1',
-    buildTime: '2024-12-13T01:40:09.304Z'
+    version: '6.11.0-beta.2',
+    buildTime: '2024-12-24T03:28:24.148Z'
 };
 function render(schema, props, options, pathPrefix) {
     if (props === void 0) { props = {}; }

package/esm/locale.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.1
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/polyfills.js

@@ -1,5 +1,5 @@
 /**
- * amis-core v6.11.0-beta.1
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 

package/esm/renderers/Form.d.ts

@@ -381,7 +381,7 @@ export default class Form extends React.Component<FormProps, object> {
     renderBody(): React.JSX.Element;
     render(): JSX.Element;
 }
-export declare class FormRenderer extends Form {
+export declare class FormRendererBase extends Form {
     static contextType: React.Context<IScopedContext>;
     constructor(props: FormProps, context: IScopedContext);
     componentDidMount(): void;
@@ -397,3 +397,5 @@ export declare class FormRenderer extends Form {
     setData(values: object, replace?: boolean): void;
     getData(): any;
 }
+export declare class FormRenderer extends FormRendererBase {
+}

package/esm/renderers/Form.js

@@ -1,9 +1,9 @@
 /**
- * amis-core v6.11.0-beta.1
+ * amis-core v6.11.0-beta.2
  * Copyright 2018-2024 fex
  */
 
-import { __extends, __awaiter, __generator, __assign, __values, __decorate, __metadata } from 'tslib';
+import { __extends, __awaiter, __generator, __assign, __values, __decorate } from 'tslib';
 import React from 'react';
 import { Renderer } from '../factory.js';
 import { FormStore } from '../store/form.js';
@@ -21,7 +21,7 @@ import '../utils/memoryParse.js';
 import '@rc-component/mini-decimal';
 import { dataMapping } from '../utils/dataMapping.js';
 import '../utils/filter.js';
-import { isEffectiveApi, isApiOutdated } from '../utils/api.js';
+import { isEffectiveApi, isApiOutdated, shouldBlockedBySendOnApi } from '../utils/api.js';
 import themedLazyComponent from '../components/LazyComponent.js';
 import { isAlive } from 'mobx-state-tree';
 import '../utils/browser.js';
@@ -750,7 +750,7 @@ var Form = /** @class */ (function (_super) {
                                             _b.label = 2;
                                         case 2:
                                             // 走到这里代表校验成功了
-                                            dispatchEvent_2('validateSucc', this.props.data);
+                                            dispatchEvent_2('validateSucc', createObject(this.props.data, values));
                                             if (target) {
                                                 this.submitToTarget(filterTarget(target, values), values);
                                                 /** 可能配置页面跳转事件，页面路由变化导致persistKey不一致，无法清除持久化数据，所以提交成功事件之前先清理一下 */
@@ -868,6 +868,10 @@ var Form = /** @class */ (function (_super) {
                                                         });
                                                     }); })];
                                             }
+                                            else if (shouldBlockedBySendOnApi(action.api || api, values)) {
+                                                // api存在，但是不满足sendOn时，走这里，不派发submitSucc事件
+                                                return [2 /*return*/];
+                                            }
                                             else {
                                                 clearPersistDataAfterSubmit && store.clearLocalPersistData();
                                                 // type为submit，但是没有配api以及target时，只派发事件
@@ -1476,15 +1480,15 @@ var Form = /** @class */ (function (_super) {
     ];
     return Form;
 }(React.Component));
-var FormRenderer = /** @class */ (function (_super) {
-    __extends(FormRenderer, _super);
-    function FormRenderer(props, context) {
+var FormRendererBase = /** @class */ (function (_super) {
+    __extends(FormRendererBase, _super);
+    function FormRendererBase(props, context) {
         var _this = _super.call(this, props) || this;
         var scoped = context;
         scoped.registerComponent(_this);
         return _this;
     }
-    FormRenderer.prototype.componentDidMount = function () {
+    FormRendererBase.prototype.componentDidMount = function () {
         _super.prototype.componentDidMount.call(this);
         if (this.props.autoFocus) {
             var scoped = this.context;
@@ -1493,17 +1497,17 @@ var FormRenderer = /** @class */ (function (_super) {
             focuableInput_1 && setTimeout(function () { return focuableInput_1.focus(); }, 200);
         }
     };
-    FormRenderer.prototype.componentWillUnmount = function () {
+    FormRendererBase.prototype.componentWillUnmount = function () {
         var scoped = this.context;
         scoped.unRegisterComponent(this);
         _super.prototype.componentWillUnmount.call(this);
     };
-    FormRenderer.prototype.doAction = function (action, data, throwErrors) {
+    FormRendererBase.prototype.doAction = function (action, data, throwErrors) {
         if (data === void 0) { data = this.props.store.data; }
         if (throwErrors === void 0) { throwErrors = false; }
         return this.handleAction(undefined, action, data, throwErrors);
     };
-    FormRenderer.prototype.handleAction = function (e, action, ctx, throwErrors, delegate) {
+    FormRendererBase.prototype.handleAction = function (e, action, ctx, throwErrors, delegate) {
         if (throwErrors === void 0) { throwErrors = false; }
         return __awaiter(this, void 0, void 0, function () {
             var scoped_1;
@@ -1521,13 +1525,16 @@ var FormRenderer = /** @class */ (function (_super) {
                                 target.doAction(__assign(__assign({}, action), { target: undefined }), ctx, throwErrors));
                         }))];
                 }
+                else if (action.actionType === 'clearError') {
+                    return [2 /*return*/, _super.prototype.clearErrors.call(this)];
+                }
                 else {
                     return [2 /*return*/, _super.prototype.handleAction.call(this, e, action, ctx, throwErrors, delegate)];
                 }
             });
         });
     };
-    FormRenderer.prototype.handleDialogConfirm = function (values, action, ctx, targets) {
+    FormRendererBase.prototype.handleDialogConfirm = function (values, action, ctx, targets) {
         _super.prototype.handleDialogConfirm.call(this, values, action, ctx, targets);
         var store = this.props.store;
         var scoped = this.context;
@@ -1538,19 +1545,19 @@ var FormRenderer = /** @class */ (function (_super) {
             scoped.reload(store.action.reload, ctx);
         }
     };
-    FormRenderer.prototype.submitToTarget = function (target, values) {
+    FormRendererBase.prototype.submitToTarget = function (target, values) {
         var scoped = this.context;
         scoped.send(target, values);
     };
-    FormRenderer.prototype.reloadTarget = function (target, data) {
+    FormRendererBase.prototype.reloadTarget = function (target, data) {
         var scoped = this.context;
         scoped.reload(target, data);
     };
-    FormRenderer.prototype.closeTarget = function (target) {
+    FormRendererBase.prototype.closeTarget = function (target) {
         var scoped = this.context;
         scoped.close(target);
     };
-    FormRenderer.prototype.reload = function (target, query, ctx, silent, replace) {
+    FormRendererBase.prototype.reload = function (target, query, ctx, silent, replace) {
         return __awaiter(this, void 0, void 0, function () {
             var scoped, subPath, idx, subQuery, idx2, component, components;
             return __generator(this, function (_a) {
@@ -1592,7 +1599,7 @@ var FormRenderer = /** @class */ (function (_super) {
             });
         });
     };
-    FormRenderer.prototype.receive = function (values, name, replace) {
+    FormRendererBase.prototype.receive = function (values, name, replace) {
         return __awaiter(this, void 0, void 0, function () {
             var scoped, idx, subPath, component;
             return __generator(this, function (_a) {
@@ -1612,17 +1619,25 @@ var FormRenderer = /** @class */ (function (_super) {
             });
         });
     };
-    FormRenderer.prototype.setData = function (values, replace) {
+    FormRendererBase.prototype.setData = function (values, replace) {
         var _a = this.props, onChange = _a.onChange, store = _a.store;
         _super.prototype.setValues.call(this, values, replace);
         // 触发表单change
         onChange &&
             onChange(store.data, difference(store.data, store.pristine), this.props);
     };
-    FormRenderer.prototype.getData = function () {
+    FormRendererBase.prototype.getData = function () {
         return this.getValues();
     };
-    FormRenderer.contextType = ScopedContext;
+    FormRendererBase.contextType = ScopedContext;
+    return FormRendererBase;
+}(Form));
+var FormRenderer = /** @class */ (function (_super) {
+    __extends(FormRenderer, _super);
+    // 装饰器装饰后的类无法继承父类上的方法，所以多包了一层FormRendererBase用来继承
+    function FormRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
     FormRenderer = __decorate([
         Renderer({
             type: 'form',
@@ -1641,10 +1656,10 @@ var FormRenderer = /** @class */ (function (_super) {
                 }
                 return undefined;
             }
-        }),
-        __metadata("design:paramtypes", [Object, Object])
+        })
+        // 装饰器装饰后的类无法继承父类上的方法，所以多包了一层FormRendererBase用来继承
     ], FormRenderer);
     return FormRenderer;
-}(Form));
+}(FormRendererBase));
 
-export { FormRenderer, Form as default };
+export { FormRenderer, FormRendererBase, Form as default };