ronds-metadata 1.0.60 → 1.0.63

package/es/comps/AutoSize/detectElementResize.d.ts

@@ -0,0 +1,4 @@
+export default function createDetectElementResize(nonce: any): {
+    addResizeListener: (element: any, fn: any) => void;
+    removeResizeListener: (element: any, fn: any) => void;
+};

package/es/comps/AutoSize/detectElementResize.js

@@ -0,0 +1,195 @@
+// @ts-nocheck
+export default function createDetectElementResize(nonce) {
+  // Check `document` and `window` in case of server-side rendering
+  var _window;
+
+  if (typeof window !== 'undefined') {
+    _window = window;
+  } else {
+    _window = global;
+  }
+
+  var attachEvent = typeof document !== 'undefined' && document.attachEvent;
+
+  if (!attachEvent) {
+    var requestFrame = function () {
+      var raf = _window.requestAnimationFrame || _window.mozRequestAnimationFrame || _window.webkitRequestAnimationFrame || function (fn) {
+        return _window.setTimeout(fn, 20);
+      };
+
+      return function (fn) {
+        return raf(fn);
+      };
+    }();
+
+    var cancelFrame = function () {
+      var cancel = _window.cancelAnimationFrame || _window.mozCancelAnimationFrame || _window.webkitCancelAnimationFrame || _window.clearTimeout;
+      return function (id) {
+        return cancel(id);
+      };
+    }();
+
+    var resetTriggers = function resetTriggers(element) {
+      var triggers = element.__resizeTriggers__,
+          expand = triggers.firstElementChild,
+          contract = triggers.lastElementChild,
+          expandChild = expand.firstElementChild;
+      contract.scrollLeft = contract.scrollWidth;
+      contract.scrollTop = contract.scrollHeight;
+      expandChild.style.width = expand.offsetWidth + 1 + 'px';
+      expandChild.style.height = expand.offsetHeight + 1 + 'px';
+      expand.scrollLeft = expand.scrollWidth;
+      expand.scrollTop = expand.scrollHeight;
+    };
+
+    var checkTriggers = function checkTriggers(element) {
+      return element.offsetWidth !== element.__resizeLast__.width || element.offsetHeight !== element.__resizeLast__.height;
+    };
+
+    var scrollListener = function scrollListener(e) {
+      // Don't measure (which forces) reflow for scrolls that happen inside of children!
+      if (e.target.className.indexOf('contract-trigger') < 0 && e.target.className.indexOf('expand-trigger') < 0) {
+        return;
+      }
+
+      var element = this;
+      resetTriggers(this);
+
+      if (this.__resizeRAF__) {
+        cancelFrame(this.__resizeRAF__);
+      }
+
+      this.__resizeRAF__ = requestFrame(function () {
+        if (checkTriggers(element)) {
+          element.__resizeLast__.width = element.offsetWidth;
+          element.__resizeLast__.height = element.offsetHeight;
+
+          element.__resizeListeners__.forEach(function (fn) {
+            fn.call(element, e);
+          });
+        }
+      });
+    };
+    /* Detect CSS Animations support to detect element display/re-attach */
+
+
+    var animation = false,
+        keyframeprefix = '',
+        animationstartevent = 'animationstart',
+        domPrefixes = 'Webkit Moz O ms'.split(' '),
+        startEvents = 'webkitAnimationStart animationstart oAnimationStart MSAnimationStart'.split(' '),
+        pfx = ''; // {
+
+    var elm = document.createElement('fakeelement');
+
+    if (elm.style.animationName !== undefined) {
+      animation = true;
+    }
+
+    if (animation === false) {
+      for (var i = 0; i < domPrefixes.length; i++) {
+        if (elm.style[domPrefixes[i] + 'AnimationName'] !== undefined) {
+          pfx = domPrefixes[i];
+          keyframeprefix = '-' + pfx.toLowerCase() + '-';
+          animationstartevent = startEvents[i];
+          animation = true;
+          break;
+        }
+      }
+    } // }
+
+
+    var animationName = 'resizeanim';
+    var animationKeyframes = '@' + keyframeprefix + 'keyframes ' + animationName + ' { from { opacity: 0; } to { opacity: 0; } } ';
+    var animationStyle = keyframeprefix + 'animation: 1ms ' + animationName + '; ';
+  }
+
+  var createStyles = function createStyles(doc) {
+    if (!doc.getElementById('detectElementResize')) {
+      //opacity:0 works around a chrome bug https://code.google.com/p/chromium/issues/detail?id=286360
+      var css = (animationKeyframes ? animationKeyframes : '') + '.resize-triggers { ' + (animationStyle ? animationStyle : '') + 'visibility: hidden; opacity: 0; } ' + '.resize-triggers, .resize-triggers > div, .contract-trigger:before { content: " "; display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; z-index: -1; } .resize-triggers > div { background: #eee; overflow: auto; } .contract-trigger:before { width: 200%; height: 200%; }',
+          head = doc.head || doc.getElementsByTagName('head')[0],
+          style = doc.createElement('style');
+      style.id = 'detectElementResize';
+      style.type = 'text/css';
+
+      if (nonce !== null) {
+        style.setAttribute('nonce', nonce);
+      }
+
+      if (style.styleSheet) {
+        style.styleSheet.cssText = css;
+      } else {
+        style.appendChild(doc.createTextNode(css));
+      }
+
+      head.appendChild(style);
+    }
+  };
+
+  var addResizeListener = function addResizeListener(element, fn) {
+    if (attachEvent) {
+      element.attachEvent('onresize', fn);
+    } else {
+      if (!element.__resizeTriggers__) {
+        var doc = element.ownerDocument;
+
+        var elementStyle = _window.getComputedStyle(element);
+
+        if (elementStyle && elementStyle.position === 'static') {
+          element.style.position = 'relative';
+        }
+
+        createStyles(doc);
+        element.__resizeLast__ = {};
+        element.__resizeListeners__ = [];
+        (element.__resizeTriggers__ = doc.createElement('div')).className = 'resize-triggers';
+        element.__resizeTriggers__.innerHTML = '<div class="expand-trigger"><div></div></div><div class="contract-trigger"></div>';
+        element.appendChild(element.__resizeTriggers__);
+        resetTriggers(element);
+        element.addEventListener('scroll', scrollListener, true);
+        /* Listen for a css animation to detect element display/re-attach */
+
+        if (animationstartevent) {
+          element.__resizeTriggers__.__animationListener__ = function animationListener(e) {
+            if (e.animationName === animationName) {
+              resetTriggers(element);
+            }
+          };
+
+          element.__resizeTriggers__.addEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);
+        }
+      }
+
+      element.__resizeListeners__.push(fn);
+    }
+  };
+
+  var removeResizeListener = function removeResizeListener(element, fn) {
+    if (attachEvent) {
+      element.detachEvent('onresize', fn);
+    } else {
+      element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);
+
+      if (!element.__resizeListeners__.length) {
+        element.removeEventListener('scroll', scrollListener, true);
+
+        if (element.__resizeTriggers__.__animationListener__) {
+          element.__resizeTriggers__.removeEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);
+
+          element.__resizeTriggers__.__animationListener__ = null;
+        }
+
+        try {
+          element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);
+        } catch (e) {// Preact compat; see developit/preact-compat/issues/228
+        }
+      }
+    }
+  };
+
+  return {
+    addResizeListener: addResizeListener,
+    removeResizeListener: removeResizeListener
+  };
+}

package/es/comps/AutoSize/index.d.ts

@@ -0,0 +1,57 @@
+import * as React from 'react';
+export declare type Size = {
+    height: number;
+    width: number;
+};
+export interface Props {
+    /** 子组件 */
+    children: (size: Size) => React.ReactElement;
+    /** 样式名  */
+    className?: string;
+    /** 默认高度 一般用于ssr */
+    defaultHeight?: number;
+    /** 默认高度 */
+    defaultWidth?: number;
+    /** 禁止高度变化  */
+    disableHeight: boolean;
+    /** 禁止宽度变化 */
+    disableWidth: boolean;
+    /** Nonce of the inlined stylesheet for Content Security Policy */
+    nonce?: string;
+    /** Callback to be invoked on-resize */
+    onResize: (size: Size) => void;
+    /** 被隐藏时是否渲染 DOM 结构  默认不渲染 */
+    forceRender?: boolean;
+    /** 样式*/
+    style?: Object;
+}
+declare type State = {
+    height: number;
+    width: number;
+};
+declare type ResizeHandler = (element: HTMLElement, onResize: () => void) => void;
+declare type DetectElementResize = {
+    addResizeListener: ResizeHandler;
+    removeResizeListener: ResizeHandler;
+};
+export default class AutoSizer extends React.PureComponent<Props, State> {
+    static defaultProps: {
+        onResize: () => void;
+        disableHeight: boolean;
+        disableWidth: boolean;
+        style: {};
+    };
+    state: {
+        height: number;
+        width: number;
+    };
+    _parentNode?: HTMLElement;
+    _autoSizer?: HTMLElement;
+    _detectElementResize: DetectElementResize;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+    _onResize: () => void;
+    _setRef: (autoSizer?: HTMLElement) => void;
+}
+export {};

package/es/comps/AutoSize/index.js

@@ -0,0 +1,158 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import * as React from 'react';
+import createDetectElementResize from './detectElementResize';
+
+var AutoSizer = /*#__PURE__*/function (_React$PureComponent) {
+  _inherits(AutoSizer, _React$PureComponent);
+
+  var _super = _createSuper(AutoSizer);
+
+  function AutoSizer() {
+    var _this;
+
+    _classCallCheck(this, AutoSizer);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.state = {
+      height: _this.props.defaultHeight || 0,
+      width: _this.props.defaultWidth || 0
+    };
+    _this._parentNode = void 0;
+    _this._autoSizer = void 0;
+    _this._detectElementResize = void 0;
+
+    _this._onResize = function () {
+      var _this$props = _this.props,
+          disableHeight = _this$props.disableHeight,
+          disableWidth = _this$props.disableWidth,
+          onResize = _this$props.onResize;
+
+      if (_this._parentNode) {
+        // Guard against AutoSizer component being removed from the DOM immediately after being added.
+        // This can result in invalid style values which can result in NaN values if we don't handle them.
+        // See issue #150 for more context.
+        var height = _this._parentNode.offsetHeight || 0;
+        var width = _this._parentNode.offsetWidth || 0;
+        var style = window.getComputedStyle(_this._parentNode) || {};
+        var paddingLeft = parseInt(style.paddingLeft, 10) || 0;
+        var paddingRight = parseInt(style.paddingRight, 10) || 0;
+        var paddingTop = parseInt(style.paddingTop, 10) || 0;
+        var paddingBottom = parseInt(style.paddingBottom, 10) || 0;
+        var newHeight = height - paddingTop - paddingBottom;
+        var newWidth = width - paddingLeft - paddingRight;
+
+        if (!disableHeight && _this.state.height !== newHeight || !disableWidth && _this.state.width !== newWidth) {
+          _this.setState({
+            height: height - paddingTop - paddingBottom,
+            width: width - paddingLeft - paddingRight
+          });
+
+          onResize({
+            height: height,
+            width: width
+          });
+        }
+      }
+    };
+
+    _this._setRef = function (autoSizer) {
+      _this._autoSizer = autoSizer;
+    };
+
+    return _this;
+  }
+
+  _createClass(AutoSizer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var nonce = this.props.nonce;
+
+      if (this._autoSizer && this._autoSizer.parentNode && this._autoSizer.parentNode.ownerDocument && this._autoSizer.parentNode.ownerDocument.defaultView && this._autoSizer.parentNode instanceof this._autoSizer.parentNode.ownerDocument.defaultView.HTMLElement) {
+        // Delay access of parentNode until mount.
+        // This handles edge-cases where the component has already been unmounted before its ref has been set,
+        // As well as libraries like react-lite which have a slightly different lifecycle.
+        this._parentNode = this._autoSizer.parentNode; // Defer requiring resize handler in order to support server-side rendering.
+        // See issue #41
+
+        this._detectElementResize = createDetectElementResize(nonce);
+
+        this._detectElementResize.addResizeListener(this._parentNode, this._onResize);
+
+        this._onResize();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this._detectElementResize && this._parentNode) {
+        this._detectElementResize.removeResizeListener(this._parentNode, this._onResize);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+          children = _this$props2.children,
+          className = _this$props2.className,
+          disableHeight = _this$props2.disableHeight,
+          disableWidth = _this$props2.disableWidth,
+          style = _this$props2.style,
+          forceRender = _this$props2.forceRender;
+      var _this$state = this.state,
+          height = _this$state.height,
+          width = _this$state.width; // Outer div should not force width/height since that may prevent containers from shrinking.
+      // Inner component should overflow and use calculated width/height.
+      // See issue #68 for more information.
+
+      var outerStyle = {
+        overflow: 'visible'
+      };
+      var childParams = {}; // Avoid rendering children before the initial measurements have been collected.
+      // At best this would just be wasting cycles.
+
+      var bailoutOnChildren = false;
+
+      if (!disableHeight) {
+        if (height === 0) {
+          bailoutOnChildren = true;
+        }
+
+        outerStyle.height = 0;
+        childParams.height = height;
+      }
+
+      if (!disableWidth) {
+        if (width === 0) {
+          bailoutOnChildren = true;
+        }
+
+        outerStyle.width = 0;
+        childParams.width = width;
+      }
+
+      return /*#__PURE__*/React.createElement("div", {
+        className: className,
+        ref: this._setRef,
+        style: _objectSpread(_objectSpread({}, outerStyle), style)
+      }, (!bailoutOnChildren || forceRender) && children(childParams));
+    }
+  }]);
+
+  return AutoSizer;
+}(React.PureComponent);
+
+AutoSizer.defaultProps = {
+  onResize: function onResize() {},
+  disableHeight: false,
+  disableWidth: false,
+  style: {}
+};
+export { AutoSizer as default };

package/es/comps/Editable/comps/EditableAction.js

@@ -102,7 +102,6 @@ var EditableAction = function EditableAction(props) {
     type: "link",
     size: "small",
     icon: /*#__PURE__*/React.createElement(DeleteOutlined, null),
-    onClick: onDelete,
     title: '删除'
   })));
 };

package/es/comps/Editable/index.js

@@ -18,6 +18,7 @@ import { isFreeEditRow, removeCurKeyFromEditRow } from './utils';
 import EditableHeardCell from './comps/EditableHeardCell';
 import useMemoSubject from '../../framework/rxjs-hooks/useMemoSubject';
 import useObservable from '../../framework/rxjs-hooks/useObservable';
+import AutoSize from '../AutoSize';
 
 var Editable = function Editable(props) {
   var _props$type = props.type,
@@ -290,11 +291,9 @@ var Editable = function Editable(props) {
       var _aciton_ = {
         dataKey: '_aciton_',
         title: '操作',
-        width: 50,
-        maxWidth: 50,
-        export: false,
-        minWidth: 50,
+        width: 40,
         frozen: 'right',
+        ellipsis: true,
         render: function render(val, record) {
           return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(EditableAction, {
             type: type,
@@ -373,30 +372,38 @@ var Editable = function Editable(props) {
         editHeardCellKey: editHeardCellKey
       }
     }
-  }, /*#__PURE__*/React.createElement(_Table, _extends({
-    bordered: true
-  }, tableProps, {
-    pagination: false,
-    rowKey: "_rowKey_",
-    size: "small",
-    columns: _columns,
-    dataSource: _dataSource,
-    components: {
-      header: {
-        cell: EditableHeardCell
+  }, /*#__PURE__*/React.createElement(AutoSize, null, function (_ref) {
+    var height = _ref.height,
+        width = _ref.width;
+    return /*#__PURE__*/React.createElement(_Table, _extends({
+      bordered: true,
+      scroll: {
+        y: height,
+        x: width
+      }
+    }, tableProps, {
+      pagination: false,
+      rowKey: "_rowKey_",
+      size: "small",
+      columns: _columns,
+      dataSource: _dataSource,
+      components: {
+        header: {
+          cell: EditableHeardCell
+        },
+        body: {
+          row: EditableRow,
+          cell: EditableCell
+        }
       },
-      body: {
-        row: EditableRow,
-        cell: EditableCell
+      onRow: function onRow(record, index) {
+        return {
+          record: record,
+          index: index
+        };
       }
-    },
-    onRow: function onRow(record, index) {
-      return {
-        record: record,
-        index: index
-      };
-    }
-  })), (type === 'multiple' || type === 'freedom') && !readonly && defaultValue && /*#__PURE__*/React.createElement(_Button, {
+    }));
+  }), (type === 'multiple' || type === 'freedom') && !readonly && defaultValue && /*#__PURE__*/React.createElement(_Button, {
     block: true,
     type: "dashed",
     style: {

package/es/comps/MetadataEditV2/index.js

@@ -82,9 +82,8 @@ var MetadataEditV2 = function MetadataEditV2(props) {
   }, [form, initialValues]);
 
   var onMyFinish = function onMyFinish(values) {
-    debugger; // console.log('values:', values, JSON.stringify(values));
+    // console.log('values:', values, JSON.stringify(values));
     // console.log('values:', values);
-
     var _metaSchema = metaSchemaRef.current;
     _metaSchema.id = values.id;
     _metaSchema.type = values.type;
@@ -164,7 +163,6 @@ var MetadataEditV2 = function MetadataEditV2(props) {
   };
 
   var onAddFields = function onAddFields(index) {
-    // debugger;
     if (index === -1) {
       var _id = form.getFieldValue('id');
 
@@ -208,8 +206,6 @@ var MetadataEditV2 = function MetadataEditV2(props) {
   };
 
   var onFieldsChange = function onFieldsChange(values) {
-    // debugger;
-    // console.log('onFieldsChange', values, curFields);
     var _fields = fields;
     _fields[curFields.id] = values;
     setFields(_objectSpread({}, _fields));
@@ -221,7 +217,6 @@ var MetadataEditV2 = function MetadataEditV2(props) {
   };
 
   var processFileds = function processFileds(schema) {
-    debugger;
     var _properties = schema.properties;
     var _fields = fields;
 

package/es/comps/MetadataForm/DataCell/Array.js

@@ -4,6 +4,12 @@ import "antd/es/button/style";
 import _Button from "antd/es/button";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+
+/*
+ * @Author: wangxian
+ * @Date: 2021-09-18 14:15:04
+ * @LastEditTime: 2022-04-11 10:20:33
+ */
 import React from 'react';
 import { MinusCircleOutlined, PlusOutlined } from '@ant-design/icons';
 import { MetadataFormContext } from '../interface';
@@ -11,12 +17,12 @@ import { useGetExtraInfo } from '../hooks';
 import { getDataCell } from '../utils';
 
 function Index(props) {
-  var _fields$0$value;
+  var _fieldRule$, _fieldRule$$value;
 
   var id = props.id,
       items = props.items,
       isRefForm = props.isRefForm,
-      fields = props.fields,
+      fieldRule = props.fields,
       initEnumValue = props.initEnumValue,
       disabled = props.disabled;
   var formContext = React.useContext(MetadataFormContext) || {};
@@ -33,7 +39,6 @@ function Index(props) {
       setHelp(arr[arr.length - 1]);
     }
   }, [items]);
-  debugger;
   return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("div", {
     style: {
       position: 'relative',
@@ -43,7 +48,7 @@ function Index(props) {
     className: "ant-form-item-label mt-1"
   }, /*#__PURE__*/React.createElement("label", {
     className: "".concat((extraInfo === null || extraInfo === void 0 ? void 0 : extraInfo.require) && 'ant-form-item-required')
-  }, extraInfo.label || ((_fields$0$value = fields[0].value) === null || _fields$0$value === void 0 ? void 0 : _fields$0$value.label) || id)), formContext.isShowTypeInfo && /*#__PURE__*/React.createElement("div", {
+  }, extraInfo.label || fieldRule && ((_fieldRule$ = fieldRule[0]) === null || _fieldRule$ === void 0 ? void 0 : (_fieldRule$$value = _fieldRule$.value) === null || _fieldRule$$value === void 0 ? void 0 : _fieldRule$$value.label) || id)), formContext.isShowTypeInfo && /*#__PURE__*/React.createElement("div", {
     style: {
       padding: '0 6px',
       position: 'absolute',

package/es/framework/metadata/index.js

@@ -320,7 +320,6 @@ export var JsonMetadataProvider = /*#__PURE__*/function (_MetadataProvider) {
   }, {
     key: "__visit_field",
     value: function __visit_field(id, value) {
-      debugger;
       return this.__visit_type(id, value);
     }
   }, {

package/package.json

@@ -1,7 +1,7 @@
 {
   "public": true,
   "name": "ronds-metadata",
-  "version": "1.0.60",
+  "version": "1.0.63",
   "scripts": {
     "start": "dumi dev",
     "docs:build": "dumi build",