amis-core 1.0.0-beta.0

package/dist/SchemaRenderer.js

@@ -0,0 +1,323 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var difference = require('lodash/difference');
+var omit = require('lodash/omit');
+var React = require('react');
+var LazyComponent = require('./components/LazyComponent.js');
+var factory = require('./factory.js');
+var Item = require('./renderers/Item.js');
+var Scoped = require('./Scoped.js');
+var debug = require('./utils/debug.js');
+var filterSchema = require('./utils/filter-schema.js');
+var helper = require('./utils/helper.js');
+var SimpleMap = require('./utils/SimpleMap.js');
+var rendererEvent = require('./utils/renderer-event.js');
+var mobxStateTree = require('mobx-state-tree');
+var mobx = require('mobx');
+require('amis-formula');
+require('moment');
+require('lodash/isPlainObject');
+var resolveVariableAndFilter = require('./utils/resolveVariableAndFilter.js');
+require('./utils/filter.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var difference__default = /*#__PURE__*/_interopDefaultLegacy(difference);
+var omit__default = /*#__PURE__*/_interopDefaultLegacy(omit);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+var defaultOmitList = [
+    'type',
+    'name',
+    '$ref',
+    'className',
+    'data',
+    'children',
+    'ref',
+    'visible',
+    'visibleOn',
+    'hidden',
+    'hiddenOn',
+    'disabled',
+    'disabledOn',
+    'component',
+    'detectField',
+    'defaultValue',
+    'defaultData',
+    'required',
+    'requiredOn',
+    'syncSuperStore',
+    'mode',
+    'body'
+];
+var componentCache = new SimpleMap.SimpleMap();
+var SchemaRenderer = /** @class */ (function (_super) {
+    tslib.__extends(SchemaRenderer, _super);
+    function SchemaRenderer(props) {
+        var _this = _super.call(this, props) || this;
+        _this.rendererKey = '';
+        _this.unbindEvent = undefined;
+        _this.refFn = _this.refFn.bind(_this);
+        _this.renderChild = _this.renderChild.bind(_this);
+        _this.reRender = _this.reRender.bind(_this);
+        _this.resolveRenderer(_this.props);
+        _this.dispatchEvent = _this.dispatchEvent.bind(_this);
+        // 监听rootStore更新
+        _this.reaction = mobx.reaction(function () {
+            return "".concat(props.rootStore.visibleState[props.schema.id || props.$path]).concat(props.rootStore.disableState[props.schema.id || props.$path]);
+        }, function () { return _this.forceUpdate(); });
+        return _this;
+    }
+    SchemaRenderer.prototype.componentDidMount = function () {
+        // 这里无法区分监听的是不是广播，所以又bind一下，主要是为了绑广播
+        this.unbindEvent = rendererEvent.bindEvent(this.cRef);
+    };
+    SchemaRenderer.prototype.componentWillUnmount = function () {
+        var _a, _b;
+        (_a = this.reaction) === null || _a === void 0 ? void 0 : _a.call(this);
+        (_b = this.unbindEvent) === null || _b === void 0 ? void 0 : _b.call(this);
+    };
+    // 限制：只有 schema 除外的 props 变化，或者 schema 里面的某个成员值发生变化才更新。
+    SchemaRenderer.prototype.shouldComponentUpdate = function (nextProps) {
+        var props = this.props;
+        var list = difference__default["default"](Object.keys(nextProps), [
+            'schema',
+            'scope'
+        ]);
+        if (difference__default["default"](Object.keys(props), ['schema', 'scope']).length !==
+            list.length ||
+            helper.anyChanged(list, this.props, nextProps)) {
+            return true;
+        }
+        else {
+            var list_1 = Object.keys(nextProps.schema);
+            if (Object.keys(props.schema).length !== list_1.length ||
+                helper.anyChanged(list_1, props.schema, nextProps.schema)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    SchemaRenderer.prototype.resolveRenderer = function (props, force) {
+        if (force === void 0) { force = false; }
+        var schema = props.schema;
+        var path = props.$path;
+        if (schema && schema.$ref) {
+            schema = tslib.__assign(tslib.__assign({}, props.resolveDefinitions(schema.$ref)), schema);
+            path = path.replace(/(?!.*\/).*/, schema.type);
+        }
+        if ((schema === null || schema === void 0 ? void 0 : schema.type) &&
+            (force ||
+                !this.renderer ||
+                this.rendererKey !== "".concat(schema.type, "-").concat(schema.$$id))) {
+            var rendererResolver = props.env.rendererResolver || factory.resolveRenderer;
+            this.renderer = rendererResolver(path, schema, props);
+            this.rendererKey = "".concat(schema.type, "-").concat(schema.$$id);
+        }
+        else {
+            // 自定义组件如果在节点设置了 label name 什么的，就用 formItem 包一层
+            // 至少自动支持了 valdiations, label, description 等逻辑。
+            if (schema.children && !schema.component && schema.asFormItem) {
+                schema.component = PlaceholderComponent;
+                schema.renderChildren = schema.children;
+                delete schema.children;
+            }
+            if (schema.component &&
+                !schema.component.wrapedAsFormItem &&
+                schema.asFormItem) {
+                var cache = componentCache.get(schema.component);
+                if (cache) {
+                    schema.component = cache;
+                }
+                else {
+                    var cache_1 = Item.asFormItem(tslib.__assign({ strictMode: false }, schema.asFormItem))(schema.component);
+                    componentCache.set(schema.component, cache_1);
+                    cache_1.wrapedAsFormItem = true;
+                    schema.component = cache_1;
+                }
+            }
+        }
+        return { path: path, schema: schema };
+    };
+    SchemaRenderer.prototype.getWrappedInstance = function () {
+        return this.cRef;
+    };
+    SchemaRenderer.prototype.refFn = function (ref) {
+        this.ref = ref;
+    };
+    SchemaRenderer.prototype.childRef = function (ref) {
+        while (ref && ref.getWrappedInstance) {
+            ref = ref.getWrappedInstance();
+        }
+        this.cRef = ref;
+    };
+    SchemaRenderer.prototype.dispatchEvent = function (e, data) {
+        return tslib.__awaiter(this, void 0, void 0, function () {
+            return tslib.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, rendererEvent.dispatchEvent(e, this.cRef, this.context, data)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    SchemaRenderer.prototype.renderChild = function (region, node, subProps) {
+        if (subProps === void 0) { subProps = {}; }
+        var _a = this.props; _a.schema; _a.$path; var env = _a.env, render = _a.render, rest = tslib.__rest(_a, ["schema", "$path", "env", "render"]);
+        var $path = this.resolveRenderer(this.props).path;
+        var omitList = defaultOmitList.concat();
+        if (this.renderer) {
+            var Component = this.renderer.component;
+            Component.propsList &&
+                omitList.push.apply(omitList, Component.propsList);
+        }
+        return render("".concat($path).concat(region ? "/".concat(region) : ''), node || '', tslib.__assign(tslib.__assign(tslib.__assign({}, omit__default["default"](rest, omitList)), subProps), { data: subProps.data || rest.data, env: env }));
+    };
+    SchemaRenderer.prototype.reRender = function () {
+        this.resolveRenderer(this.props, true);
+        this.forceUpdate();
+    };
+    SchemaRenderer.prototype.render = function () {
+        var _this = this;
+        var _a, _b, _c;
+        var _d = this.props; _d.$path; var __ = _d.schema, rootStore = _d.rootStore, render = _d.render, rest = tslib.__rest(_d, ["$path", "schema", "rootStore", "render"]);
+        if (__ == null) {
+            return null;
+        }
+        var _e = this.resolveRenderer(this.props), $path = _e.path, schema = _e.schema;
+        var theme = this.props.env.theme;
+        if (Array.isArray(schema)) {
+            return render($path, schema, rest);
+        }
+        var detectData = schema &&
+            (schema.detectField === '&' ? rest : rest[schema.detectField || 'data']);
+        var exprProps = detectData
+            ? filterSchema["default"](schema, detectData, undefined, rest)
+            : {};
+        // 控制显隐
+        var visible = mobxStateTree.isAlive(rootStore)
+            ? rootStore.visibleState[schema.id || $path]
+            : undefined;
+        var disable = mobxStateTree.isAlive(rootStore)
+            ? rootStore.disableState[schema.id || $path]
+            : undefined;
+        if (visible === false ||
+            (visible !== true &&
+                exprProps &&
+                (exprProps.hidden ||
+                    exprProps.visible === false ||
+                    schema.hidden ||
+                    schema.visible === false ||
+                    rest.hidden ||
+                    rest.visible === false))) {
+            rest.invisible = true;
+        }
+        if (schema.children) {
+            return rest.invisible
+                ? null
+                : React__default["default"].isValidElement(schema.children)
+                    ? schema.children
+                    : schema.children(tslib.__assign(tslib.__assign(tslib.__assign({}, rest), exprProps), { $path: $path, $schema: schema, render: this.renderChild, forwardedRef: this.refFn, rootStore: rootStore, dispatchEvent: this.dispatchEvent }));
+        }
+        else if (typeof schema.component === 'function') {
+            var isSFC = !(schema.component.prototype instanceof React__default["default"].Component);
+            var defaultData_1 = schema.data, defaultValue_1 = schema.value, // render时的value改放defaultValue中
+            defaultActiveKey_1 = schema.activeKey, propKey_1 = schema.key, restSchema_1 = tslib.__rest(schema, ["data", "value", "activeKey", "key"]);
+            return rest.invisible
+                ? null
+                : React__default["default"].createElement(schema.component, tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, rest), restSchema_1), exprProps), { 
+                    // value: defaultValue, // 备注: 此处并没有将value传递给渲染器
+                    defaultData: defaultData_1, defaultValue: defaultValue_1, defaultActiveKey: defaultActiveKey_1, propKey: propKey_1, $path: $path, $schema: schema, ref: isSFC ? undefined : this.refFn, forwardedRef: isSFC ? this.refFn : undefined, render: this.renderChild, rootStore: rootStore, dispatchEvent: this.dispatchEvent }));
+        }
+        else if (Object.keys(schema).length === 0) {
+            return null;
+        }
+        else if (!this.renderer) {
+            return rest.invisible ? null : (React__default["default"].createElement(LazyComponent["default"], tslib.__assign({}, rest, exprProps, { getComponent: function () { return tslib.__awaiter(_this, void 0, void 0, function () {
+                    var result;
+                    return tslib.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, rest.env.loadRenderer(schema, $path, this.reRender)];
+                            case 1:
+                                result = _a.sent();
+                                if (result && typeof result === 'function') {
+                                    return [2 /*return*/, result];
+                                }
+                                else if (result && React__default["default"].isValidElement(result)) {
+                                    return [2 /*return*/, function () { return result; }];
+                                }
+                                this.reRender();
+                                return [2 /*return*/, function () { return factory.loadRenderer(schema, $path); }];
+                        }
+                    });
+                }); }, "$path": $path, "$schema": schema, retry: this.reRender, rootStore: rootStore, dispatchEvent: this.dispatchEvent })));
+        }
+        var renderer = this.renderer;
+        schema = factory.filterSchema(schema, renderer, rest);
+        var defaultData = schema.data, defaultValue = schema.value, propKey = schema.key, defaultActiveKey = schema.activeKey, restSchema = tslib.__rest(schema, ["data", "value", "key", "activeKey"]);
+        var Component = renderer.component;
+        // 原来表单项的 visible: false 和 hidden: true 表单项的值和验证是有效的
+        // 而 visibleOn 和 hiddenOn 是无效的，
+        // 这个本来就是个bug，但是已经被广泛使用了
+        // 我只能继续实现这个bug了
+        if (rest.invisible &&
+            (exprProps.hidden ||
+                exprProps.visible === false ||
+                !renderer.isFormItem ||
+                (schema.visible !== false && !schema.hidden))) {
+            return null;
+        }
+        var isClassComponent = (_a = Component.prototype) === null || _a === void 0 ? void 0 : _a.isReactComponent;
+        var $schema = tslib.__assign(tslib.__assign({}, schema), exprProps);
+        var props = tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, theme.getRendererConfig(renderer.name)), restSchema), helper.chainEvents(rest, restSchema)), exprProps), { 
+            // value: defaultValue, // 备注: 此处并没有将value传递给渲染器
+            defaultData: (_b = restSchema.defaultData) !== null && _b !== void 0 ? _b : defaultData, defaultValue: (_c = restSchema.defaultValue) !== null && _c !== void 0 ? _c : defaultValue, defaultActiveKey: defaultActiveKey, propKey: propKey, $path: $path, $schema: $schema, ref: this.refFn, render: this.renderChild, rootStore: rootStore, dispatchEvent: this.dispatchEvent });
+        if (disable !== undefined) {
+            props.disabled = disable;
+        }
+        // 自动解析变量模式，主要是方便直接引入第三方组件库，无需为了支持变量封装一层
+        if (renderer.autoVar) {
+            for (var _i = 0, _f = Object.keys($schema); _i < _f.length; _i++) {
+                var key = _f[_i];
+                if (typeof props[key] === 'string') {
+                    props[key] = resolveVariableAndFilter.resolveVariableAndFilter(props[key], props.data, '| raw');
+                }
+            }
+        }
+        var component = isClassComponent ? (React__default["default"].createElement(Component, tslib.__assign({}, props, { ref: this.childRef }))) : (React__default["default"].createElement(Component, tslib.__assign({}, props)));
+        return this.props.env.enableAMISDebug ? (React__default["default"].createElement(debug.DebugWrapper, { renderer: renderer }, component)) : (component);
+    };
+    SchemaRenderer.displayName = 'Renderer';
+    SchemaRenderer.contextType = Scoped.ScopedContext;
+    tslib.__decorate([
+        helper.autobind,
+        tslib.__metadata("design:type", Function),
+        tslib.__metadata("design:paramtypes", [Object]),
+        tslib.__metadata("design:returntype", void 0)
+    ], SchemaRenderer.prototype, "childRef", null);
+    return SchemaRenderer;
+}(React__default["default"].Component));
+var PlaceholderComponent = /** @class */ (function (_super) {
+    tslib.__extends(PlaceholderComponent, _super);
+    function PlaceholderComponent() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PlaceholderComponent.prototype.render = function () {
+        var _a = this.props, renderChildren = _a.renderChildren, rest = tslib.__rest(_a, ["renderChildren"]);
+        if (typeof renderChildren === 'function') {
+            return renderChildren(rest);
+        }
+        return null;
+    };
+    return PlaceholderComponent;
+}(React__default["default"].Component));
+
+exports.SchemaRenderer = SchemaRenderer;

package/dist/Scoped.js

@@ -0,0 +1,252 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+var find = require('lodash/find');
+var hoistNonReactStatic = require('hoist-non-react-statics');
+require('amis-formula');
+require('moment');
+require('lodash/isPlainObject');
+var dataMapping = require('./utils/dataMapping.js');
+require('./utils/filter.js');
+var helper = require('./utils/helper.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var find__default = /*#__PURE__*/_interopDefaultLegacy(find);
+var hoistNonReactStatic__default = /*#__PURE__*/_interopDefaultLegacy(hoistNonReactStatic);
+
+/**
+ * @file 用来创建一个域，在这个域里面会把里面的运行时实例注册进来，方便组件之间的通信。
+ * @author fex
+ */
+var ScopedContext = React__default["default"].createContext(createScopedTools(''));
+function createScopedTools(path, parent, env) {
+    var components = [];
+    var self = {
+        parent: parent,
+        registerComponent: function (component) {
+            // 不要把自己注册在自己的 Scoped 上，自己的 Scoped 是给子节点们注册的。
+            if (component.props.$path === path && parent) {
+                return parent.registerComponent(component);
+            }
+            if (!~components.indexOf(component)) {
+                components.push(component);
+            }
+        },
+        unRegisterComponent: function (component) {
+            // 自己本身实际上注册在父级 Scoped 上。
+            if (component.props.$path === path && parent) {
+                return parent.unRegisterComponent(component);
+            }
+            var idx = components.indexOf(component);
+            if (~idx) {
+                components.splice(idx, 1);
+            }
+        },
+        getComponentByName: function (name) {
+            if (~name.indexOf('.')) {
+                var paths = name.split('.');
+                var len_1 = paths.length;
+                return paths.reduce(function (scope, name, idx) {
+                    if (scope && scope.getComponentByName) {
+                        var result = scope.getComponentByName(name);
+                        return result && idx < len_1 - 1 ? result.context : result;
+                    }
+                    return null;
+                }, this);
+            }
+            var resolved = find__default["default"](components, function (component) {
+                return component.props.name === name || component.props.id === name;
+            });
+            return resolved || (parent && parent.getComponentByName(name));
+        },
+        getComponentById: function (id) {
+            var root = this;
+            // 找到顶端scoped
+            while (root.parent) {
+                root = root.parent;
+            }
+            // 向下查找
+            var component = undefined;
+            helper.findTree([root], function (item) {
+                return item.getComponents().find(function (cmpt) {
+                    if (cmpt.props.id === id) {
+                        component = cmpt;
+                        return true;
+                    }
+                    return false;
+                });
+            });
+            return component;
+        },
+        getComponents: function () {
+            return components.concat();
+        },
+        reload: function (target, ctx) {
+            var scoped = this;
+            var targets = typeof target === 'string' ? target.split(/\s*,\s*/) : target;
+            targets.forEach(function (name) {
+                var idx2 = name.indexOf('?');
+                var query = null;
+                if (~idx2) {
+                    var queryObj = helper.qsparse(name
+                        .substring(idx2 + 1)
+                        .replace(/\$\{(.*?)\}/, function (_, match) { return '${' + encodeURIComponent(match) + '}'; }));
+                    query = dataMapping.dataMapping(queryObj, ctx);
+                    name = name.substring(0, idx2);
+                }
+                var idx = name.indexOf('.');
+                var subPath = '';
+                if (~idx) {
+                    subPath = name.substring(1 + idx);
+                    name = name.substring(0, idx);
+                }
+                if (name === 'window') {
+                    if (query) {
+                        var link = location.pathname + '?' + helper.qsstringify(query);
+                        env ? env.updateLocation(link, true) : location.replace(link);
+                    }
+                    else {
+                        location.reload();
+                    }
+                }
+                else {
+                    var component = scoped.getComponentByName(name);
+                    component &&
+                        component.reload &&
+                        component.reload(subPath, query, ctx);
+                }
+            });
+        },
+        send: function (receive, values) {
+            var scoped = this;
+            var receives = typeof receive === 'string' ? receive.split(/\s*,\s*/) : receive;
+            // todo 没找到做提示！
+            receives.forEach(function (name) {
+                var askIdx = name.indexOf('?');
+                if (~askIdx) {
+                    var query = name.substring(askIdx + 1);
+                    var queryObj = helper.qsparse(query.replace(/\$\{(.*?)\}/, function (_, match) { return '${' + encodeURIComponent(match) + '}'; }));
+                    name = name.substring(0, askIdx);
+                    values = dataMapping.dataMapping(queryObj, values);
+                }
+                var idx = name.indexOf('.');
+                var subPath = '';
+                if (~idx) {
+                    subPath = name.substring(1 + idx);
+                    name = name.substring(0, idx);
+                }
+                var component = scoped.getComponentByName(name);
+                if (component && component.receive) {
+                    component.receive(values, subPath);
+                }
+                else if (name === 'window' && env && env.updateLocation) {
+                    var query = tslib.__assign(tslib.__assign({}, (location.search ? helper.qsparse(location.search.substring(1)) : {})), values);
+                    var link = location.pathname + '?' + helper.qsstringify(query);
+                    env.updateLocation(link, true);
+                }
+            });
+        },
+        /**
+         * 主要是用来关闭指定弹框的
+         *
+         * @param target 目标 name
+         */
+        close: function (target) {
+            var scoped = this;
+            if (typeof target === 'string') {
+                // 过滤已经关掉的，当用户 close 配置多个弹框 name 时会出现这种情况
+                target
+                    .split(/\s*,\s*/)
+                    .map(function (name) { return scoped.getComponentByName(name); })
+                    .filter(function (component) { return component && component.props.show; })
+                    .forEach(closeDialog);
+            }
+        },
+        /**
+         * 关闭指定id的弹窗
+         * @param id
+         */
+        closeById: function (id) {
+            var scoped = this;
+            var component = scoped.getComponentById(id);
+            if (component && component.props.show) {
+                closeDialog(component);
+            }
+        }
+    };
+    if (!parent) {
+        return self;
+    }
+    !parent.children && (parent.children = []);
+    // 把孩子带上
+    parent.children.push(self);
+    return self;
+}
+function closeDialog(component) {
+    component.context
+        .getComponents()
+        .filter(function (item) {
+        return item &&
+            (item.props.type === 'dialog' || item.props.type === 'drawer') &&
+            item.props.show;
+    })
+        .forEach(closeDialog);
+    component.props.onClose && component.props.onClose();
+}
+function HocScoped(ComposedComponent) {
+    var ScopedComponent = /** @class */ (function (_super) {
+        tslib.__extends(ScopedComponent, _super);
+        function ScopedComponent(props, context) {
+            var _this = _super.call(this, props) || this;
+            _this.scoped = createScopedTools(_this.props.$path, context, _this.props.env);
+            var scopeRef = props.scopeRef;
+            scopeRef && scopeRef(_this.scoped);
+            return _this;
+        }
+        ScopedComponent.prototype.getWrappedInstance = function () {
+            return this.ref;
+        };
+        ScopedComponent.prototype.childRef = function (ref) {
+            while (ref && ref.getWrappedInstance) {
+                ref = ref.getWrappedInstance();
+            }
+            this.ref = ref;
+        };
+        ScopedComponent.prototype.componentWillUnmount = function () {
+            var scopeRef = this.props.scopeRef;
+            scopeRef && scopeRef(null);
+            delete this.scoped;
+        };
+        ScopedComponent.prototype.render = function () {
+            var _a = this.props; _a.scopeRef; var rest = tslib.__rest(_a, ["scopeRef"]);
+            return (React__default["default"].createElement(ScopedContext.Provider, { value: this.scoped },
+                React__default["default"].createElement(ComposedComponent, tslib.__assign({}, rest /* todo */, { ref: this.childRef }))));
+        };
+        ScopedComponent.displayName = "Scoped(".concat(ComposedComponent.displayName || ComposedComponent.name, ")");
+        ScopedComponent.contextType = ScopedContext;
+        ScopedComponent.ComposedComponent = ComposedComponent;
+        tslib.__decorate([
+            helper.autobind,
+            tslib.__metadata("design:type", Function),
+            tslib.__metadata("design:paramtypes", [Object]),
+            tslib.__metadata("design:returntype", void 0)
+        ], ScopedComponent.prototype, "childRef", null);
+        return ScopedComponent;
+    }(React__default["default"].Component));
+    hoistNonReactStatic__default["default"](ScopedComponent, ComposedComponent);
+    return ScopedComponent;
+}
+
+exports.HocScoped = HocScoped;
+exports.ScopedContext = ScopedContext;
+exports["default"] = HocScoped;

package/dist/WithRootStore.js

@@ -0,0 +1,44 @@
+/**
+ * amis-core v1.0.0-beta.0
+ * Copyright 2018-2022 fex
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var React = require('react');
+var hoistNonReactStatic = require('hoist-non-react-statics');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var hoistNonReactStatic__default = /*#__PURE__*/_interopDefaultLegacy(hoistNonReactStatic);
+
+var RootStoreContext = React__default["default"].createContext(undefined);
+function withRootStore(ComposedComponent) {
+    var _a;
+    var result = hoistNonReactStatic__default["default"]((_a = /** @class */ (function (_super) {
+            tslib.__extends(class_1, _super);
+            function class_1() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            class_1.prototype.render = function () {
+                var rootStore = this.context;
+                var injectedProps = {
+                    rootStore: rootStore
+                };
+                return (React__default["default"].createElement(ComposedComponent, tslib.__assign({}, this.props, injectedProps)));
+            };
+            return class_1;
+        }(React__default["default"].Component)),
+        _a.displayName = "WithRootStore(".concat(ComposedComponent.displayName || ComposedComponent.name, ")"),
+        _a.contextType = RootStoreContext,
+        _a.ComposedComponent = ComposedComponent,
+        _a), ComposedComponent);
+    return result;
+}
+
+exports.RootStoreContext = RootStoreContext;
+exports.withRootStore = withRootStore;