@cuipengyu5/bling-renderer-core 0.0.1

package/lib/adapter/index.js

@@ -0,0 +1,99 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.Env = void 0;
+var Env = exports.Env = /*#__PURE__*/function (Env) {
+  Env["React"] = "react";
+  return Env;
+}({});
+var Adapter = /*#__PURE__*/function () {
+  function Adapter() {
+    this.runtime = void 0;
+    this.builtinModules = ['Component', 'PureComponent', 'createElement', 'createContext', 'forwardRef', 'findDOMNode'];
+    this.env = void 0;
+    this.renderers = void 0;
+    this.configProvider = void 0;
+    this.initRuntime();
+  }
+  var _proto = Adapter.prototype;
+  _proto.initRuntime = function initRuntime() {
+    var Component = /*#__PURE__*/function () {
+      function Component() {
+        this.state = void 0;
+        this.props = void 0;
+        this.refs = void 0;
+        this.context = void 0;
+      }
+      var _proto2 = Component.prototype;
+      _proto2.setState = function setState() {};
+      _proto2.forceUpdate = function forceUpdate() {};
+      _proto2.render = function render() {};
+      return Component;
+    }();
+    var PureComponent = /*#__PURE__*/function () {
+      function PureComponent() {
+        this.state = void 0;
+        this.props = void 0;
+        this.refs = void 0;
+        this.context = void 0;
+      }
+      var _proto3 = PureComponent.prototype;
+      _proto3.setState = function setState() {};
+      _proto3.forceUpdate = function forceUpdate() {};
+      _proto3.render = function render() {};
+      return PureComponent;
+    }();
+    var createElement = function createElement() {};
+    var createContext = function createContext() {};
+    var forwardRef = function forwardRef() {};
+    var findDOMNode = function findDOMNode() {};
+    this.runtime = {
+      Component: Component,
+      PureComponent: PureComponent,
+      createElement: createElement,
+      createContext: createContext,
+      forwardRef: forwardRef,
+      findDOMNode: findDOMNode
+    };
+  };
+  _proto.setRuntime = function setRuntime(runtime) {
+    if (this.isValidRuntime(runtime)) {
+      this.runtime = runtime;
+    }
+  };
+  _proto.isValidRuntime = function isValidRuntime(runtime) {
+    if (typeof runtime !== 'object' || Array.isArray(runtime)) {
+      return false;
+    }
+    return this.builtinModules.every(function (m) {
+      var flag = !!runtime[m];
+      if (!flag) {
+        throw new Error("runtime is invalid, module '" + m + "' does not exist");
+      }
+      return flag;
+    });
+  };
+  _proto.getRuntime = function getRuntime() {
+    return this.runtime;
+  };
+  _proto.setEnv = function setEnv(env) {
+    this.env = env;
+  };
+  _proto.isReact = function isReact() {
+    return this.env === Env.React;
+  };
+  _proto.setRenderers = function setRenderers(renderers) {
+    this.renderers = renderers;
+  };
+  _proto.getRenderers = function getRenderers() {
+    return this.renderers || {};
+  };
+  _proto.setConfigProvider = function setConfigProvider(Comp) {
+    this.configProvider = Comp;
+  };
+  _proto.getConfigProvider = function getConfigProvider() {
+    return this.configProvider;
+  };
+  return Adapter;
+}();
+var _default = exports["default"] = new Adapter();

package/lib/components/Div.d.ts

@@ -0,0 +1,2 @@
+import { IGeneralConstructor } from '../types';
+export default function divFactory(): IGeneralConstructor;

package/lib/components/Div.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports["default"] = divFactory;
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+var _adapter = _interopRequireDefault(require("../adapter"));
+function divFactory() {
+  var _Div;
+  var _adapter$getRuntime = _adapter["default"].getRuntime(),
+    PureComponent = _adapter$getRuntime.PureComponent,
+    createElement = _adapter$getRuntime.createElement;
+  return _Div = /*#__PURE__*/function (_PureComponent) {
+    function Div() {
+      return _PureComponent.apply(this, arguments) || this;
+    }
+    (0, _inheritsLoose2["default"])(Div, _PureComponent);
+    var _proto = Div.prototype;
+    _proto.render = function render() {
+      return createElement('div', this.props);
+    };
+    return Div;
+  }(PureComponent), _Div.displayName = 'Div', _Div.version = '0.0.0', _Div;
+}

package/lib/components/VisualDom/index.css

@@ -0,0 +1,19 @@
+.visual-dom .panel-container {
+  box-sizing: border-box;
+  border: 1px solid #e9e9e9;
+}
+
+.visual-dom .panel-container .title {
+  display: block;
+  font-size: 12px;
+  color: #333;
+  background-color: #ebecf0;
+  line-height: 28px;
+  padding: 0 12px;
+  border-bottom: 1px solid #e9e9e9;
+}
+
+.visual-dom .panel-container .content {
+  min-height: 20px;
+  padding: 5px;
+}

package/lib/components/VisualDom/index.d.ts

@@ -0,0 +1,3 @@
+import { IGeneralConstructor } from '../../types';
+import './index.css';
+export default function visualDomFactory(): IGeneralConstructor;

package/lib/components/VisualDom/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports["default"] = visualDomFactory;
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _adapter = _interopRequireDefault(require("../../adapter"));
+require("./index.css");
+function visualDomFactory() {
+  var _VisualDom;
+  var _adapter$getRuntime = _adapter["default"].getRuntime(),
+    PureComponent = _adapter$getRuntime.PureComponent,
+    createElement = _adapter$getRuntime.createElement;
+  return _VisualDom = /*#__PURE__*/function (_PureComponent) {
+    function VisualDom() {
+      return _PureComponent.apply(this, arguments) || this;
+    }
+    (0, _inheritsLoose2["default"])(VisualDom, _PureComponent);
+    var _proto = VisualDom.prototype;
+    _proto.render = function render() {
+      var _this$props = this.props,
+        children = _this$props.children,
+        cell = _this$props.cell,
+        title = _this$props.title,
+        label = _this$props.label,
+        text = _this$props.text,
+        __componentName = _this$props.__componentName;
+      var mainContent = children;
+      if (cell && typeof cell === 'function') {
+        mainContent = cell();
+      }
+      return createElement('div', {
+        className: 'visual-dom'
+      }, createElement('div', {
+        className: 'panel-container'
+      }, [createElement('span', {
+        className: 'title'
+      }, title || label || text || __componentName), createElement('div', {
+        className: 'content'
+      }, mainContent)]));
+    };
+    return VisualDom;
+  }(PureComponent), _VisualDom.displayName = 'VisualDom', _VisualDom.propTypes = {
+    children: _propTypes["default"].oneOfType([_propTypes["default"].element, _propTypes["default"].arrayOf(_propTypes["default"].element)])
+  }, _VisualDom.defaultProps = {
+    children: null
+  }, _VisualDom;
+}

package/lib/context/index.d.ts

@@ -0,0 +1 @@
+export default function contextFactory(): any;

package/lib/context/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports["default"] = contextFactory;
+var _adapter = _interopRequireDefault(require("../adapter"));
+function contextFactory() {
+  var _adapter$getRuntime = _adapter["default"].getRuntime(),
+    createContext = _adapter$getRuntime.createContext;
+  var context = window.__appContext;
+  if (!context) {
+    context = createContext({});
+    window.__appContext = context;
+  }
+  return context;
+}

package/lib/hoc/index.d.ts

@@ -0,0 +1,7 @@
+import { IBaseRendererInstance } from '../types';
+interface Options {
+    baseRenderer: IBaseRendererInstance;
+    schema: any;
+}
+export declare function compWrapper(Comp: any, options: Options): any;
+export {};

package/lib/hoc/index.js

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.compWrapper = compWrapper;
+var _inheritsLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/inheritsLoose"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _lowcodeUtils = require("@alilc/lowcode-utils");
+var _adapter = _interopRequireDefault(require("../adapter"));
+function patchDidCatch(Comp, _ref) {
+  var baseRenderer = _ref.baseRenderer;
+  if (Comp.patchedCatch) {
+    return;
+  }
+  Comp.patchedCatch = true;
+  var _adapter$getRuntime = _adapter["default"].getRuntime(),
+    PureComponent = _adapter$getRuntime.PureComponent;
+  // Rax 的 getDerivedStateFromError 有 BUG，这里先用 componentDidCatch 来替代
+  // @see https://github.com/alibaba/rax/issues/2211
+  var originalDidCatch = Comp.prototype.componentDidCatch;
+  Comp.prototype.componentDidCatch = function didCatch(error, errorInfo) {
+    this.setState({
+      engineRenderError: true,
+      error: error
+    });
+    if (originalDidCatch && typeof originalDidCatch === 'function') {
+      originalDidCatch.call(this, error, errorInfo);
+    }
+  };
+  var engine = baseRenderer.context.engine;
+  var originRender = Comp.prototype.render;
+  Comp.prototype.render = function () {
+    if (this.state && this.state.engineRenderError) {
+      this.state.engineRenderError = false;
+      return engine.createElement(engine.getFaultComponent(), (0, _extends2["default"])({}, this.props, {
+        error: this.state.error,
+        componentName: this.props._componentName
+      }));
+    }
+    return originRender.call(this);
+  };
+  if (!(Comp.prototype instanceof PureComponent)) {
+    var originShouldComponentUpdate = Comp.prototype.shouldComponentUpdate;
+    Comp.prototype.shouldComponentUpdate = function (nextProps, nextState) {
+      if (nextState && nextState.engineRenderError) {
+        return true;
+      }
+      return originShouldComponentUpdate ? originShouldComponentUpdate.call(this, nextProps, nextState) : true;
+    };
+  }
+}
+var cache = new Map();
+function compWrapper(Comp, options) {
+  var _Comp$prototype, _Comp$prototype2, _cache$get;
+  var _adapter$getRuntime2 = _adapter["default"].getRuntime(),
+    createElement = _adapter$getRuntime2.createElement,
+    Component = _adapter$getRuntime2.Component,
+    forwardRef = _adapter$getRuntime2.forwardRef;
+  if (Comp !== null && Comp !== void 0 && (_Comp$prototype = Comp.prototype) !== null && _Comp$prototype !== void 0 && _Comp$prototype.isReactComponent || // react
+  Comp !== null && Comp !== void 0 && (_Comp$prototype2 = Comp.prototype) !== null && _Comp$prototype2 !== void 0 && _Comp$prototype2.setState ||
+  // rax
+  (Comp === null || Comp === void 0 ? void 0 : Comp.prototype) instanceof Component) {
+    patchDidCatch(Comp, options);
+    return Comp;
+  }
+  if (cache.has(options.schema.id) && ((_cache$get = cache.get(options.schema.id)) === null || _cache$get === void 0 ? void 0 : _cache$get.Comp) === Comp) {
+    var _cache$get2;
+    return (_cache$get2 = cache.get(options.schema.id)) === null || _cache$get2 === void 0 ? void 0 : _cache$get2.WrapperComponent;
+  }
+  var Wrapper = /*#__PURE__*/function (_Component) {
+    function Wrapper() {
+      return _Component.apply(this, arguments) || this;
+    }
+    (0, _inheritsLoose2["default"])(Wrapper, _Component);
+    var _proto = Wrapper.prototype;
+    _proto.render = function render() {
+      return createElement(Comp, (0, _extends2["default"])({}, this.props, {
+        ref: this.props.forwardRef
+      }));
+    };
+    return Wrapper;
+  }(Component);
+  Wrapper.displayName = Comp.displayName;
+  patchDidCatch(Wrapper, options);
+  var WrapperComponent = (0, _lowcodeUtils.cloneEnumerableProperty)(forwardRef(function (props, ref) {
+    return createElement(Wrapper, (0, _extends2["default"])({}, props, {
+      forwardRef: ref
+    }));
+  }), Comp);
+  cache.set(options.schema.id, {
+    WrapperComponent: WrapperComponent,
+    Comp: Comp
+  });
+  return WrapperComponent;
+}

package/lib/hoc/leaf.d.ts

@@ -0,0 +1,32 @@
+import { IPublicTypeEngineOptions } from '@alilc/lowcode-types';
+import * as types from '../types/index';
+export interface IComponentHocInfo {
+    schema: any;
+    baseRenderer: types.IBaseRendererInstance;
+    componentInfo: any;
+    scope: any;
+}
+export interface IComponentHocProps {
+    __tag: any;
+    componentId: any;
+    _leaf: any;
+    forwardedRef?: any;
+}
+export interface IComponentHocState {
+    childrenInState: boolean;
+    nodeChildren: any;
+    nodeCacheProps: any;
+    /** 控制是否显示隐藏 */
+    visible: boolean;
+    /** 控制是否渲染 */
+    condition: boolean;
+    nodeProps: any;
+}
+type DesignMode = Pick<IPublicTypeEngineOptions, 'designMode'>['designMode'];
+export interface IComponentHoc {
+    designMode: DesignMode | DesignMode[];
+    hoc: IComponentConstruct;
+}
+export type IComponentConstruct = (Comp: types.IBaseRenderComponent, info: IComponentHocInfo) => types.IGeneralConstructor;
+export declare function leafWrapper(Comp: types.IBaseRenderComponent, { schema, baseRenderer, componentInfo, scope, }: IComponentHocInfo): any;
+export {};