@king-design/react 2.1.4 → 2.1.5

package/components/diagram/shapes/base.js

@@ -6,27 +6,33 @@ import mx from '../mxgraph';
 import { isNullOrUndefined, EMPTY_OBJ } from 'intact-shared';
 import { DIAGRAM, LAYOUT } from '../constants';
 var mxCell = mx.mxCell,
-  mxGeometry = mx.mxGeometry;
+    mxGeometry = mx.mxGeometry;
 var typeDefs = {
   strokeStyle: ['solid', 'dashed', 'dotted'],
   label: [String, Number],
   style: Object,
   data: null
 };
+
 var defaults = function defaults() {
   return {
     strokeStyle: 'solid'
   };
 };
+
 var uniqueId = 0;
 export var DBase = /*#__PURE__*/function (_Component) {
   _inheritsLoose(DBase, _Component);
+
   function DBase() {
     var _context;
+
     var _this;
+
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
+
     _this = _Component.call.apply(_Component, _concatInstanceProperty(_context = [this]).call(_context, args)) || this;
     _this.uniqueId = uniqueId++;
     _this.cell = null;
@@ -35,22 +41,28 @@ export var DBase = /*#__PURE__*/function (_Component) {
     _this.layout = inject(LAYOUT, null);
     return _this;
   }
+
   var _proto = DBase.prototype;
+
   _proto.mounted = function mounted() {
     var _this$get = this.get(),
-      data = _this$get.data;
-    var cell = this.cell = this.createCell();
-    // add data to the cell, so that we can get it when select the cell
+        data = _this$get.data;
+
+    var cell = this.cell = this.createCell(); // add data to the cell, so that we can get it when select the cell
+
     cell.data = data;
     cell.instance = this;
     this.addToDigram();
+
     if (this.layout) {
       this.layout.addShape(this);
     }
   };
+
   _proto.beforeUpdate = function beforeUpdate(lastVNode, nextVNode) {
     var lastProps = lastVNode.props || EMPTY_OBJ;
     var nextProps = nextVNode.props || EMPTY_OBJ;
+
     if (lastProps !== nextProps) {
       var graph = this.diagram.graph;
       var model = graph.getModel();
@@ -59,65 +71,83 @@ export var DBase = /*#__PURE__*/function (_Component) {
       model.endUpdate();
     }
   };
+
   _proto.beforeUnmount = function beforeUnmount() {
     var graph = this.diagram.graph;
     this.deleteFromDiagram();
     graph.removeCells([this.cell], false);
+
     if (this.layout) {
       this.layout.deleteShape(this);
     }
   };
+
   _proto.draw = function draw() {
     if (this.hasDrew) return;
     this.startDraw();
     this.hasDrew = true;
   };
+
   _proto.updateProps = function updateProps(model, lastProps, nextProps) {
     var cell = this.cell;
+
     if (lastProps.label !== nextProps.label) {
       // update value
       model.setValue(cell, this.getValue());
-    }
-    // update style
+    } // update style
+
+
     model.setStyle(cell, this.getStylesheet());
-    this.setStyle();
-    // update data
+    this.setStyle(); // update data
+
     cell.data = nextProps.data;
   };
+
   _proto.createCell = function createCell() {
     return new mxCell(this.getValue(), this.getGeometry(), this.getStylesheet());
   };
+
   _proto.getValue = function getValue() {
     var _this$get2 = this.get(),
-      label = _this$get2.label;
+        label = _this$get2.label;
+
     return isNullOrUndefined(label) ? null : String(label);
   };
+
   _proto.setStyle = function setStyle() {
     var graph = this.diagram.graph;
     var cells = [this.cell];
+
     var styles = _extends({}, this.get('style'), this.genStyles());
+
     for (var key in styles) {
       graph.setCellStyles(key, styles[key], cells);
     }
   };
+
   _proto.genStyles = function genStyles() {
     var styles = {};
+
     switch (this.get('strokeStyle')) {
       case 'dashed':
         styles.dashed = 1;
         styles.dashPattern = null;
         break;
+
       case 'dotted':
         styles.dashed = 1;
         styles.dashPattern = '1 2';
         break;
+
       case 'solid':
         styles.dashed = null;
         styles.dashPattern = null;
         break;
     }
+
     return styles;
   };
+
   return DBase;
 }(Component);
 DBase.typeDefs = typeDefs;

package/components/diagram/shapes/callout.js

@@ -4,50 +4,61 @@ import { DShape } from './shape';
 import mx from '../mxgraph';
 import { hasDocumentAvailable } from 'intact-shared';
 var mxActor = mx.mxActor,
-  mxUtils = mx.mxUtils,
-  mxRectangle = mx.mxRectangle,
-  mxCellRenderer = mx.mxCellRenderer,
-  mxHexagon = mx.mxHexagon,
-  mxConstants = mx.mxConstants,
-  mxPoint = mx.mxPoint,
-  mxPerimeter = mx.mxPerimeter,
-  mxStyleRegistry = mx.mxStyleRegistry;
+    mxUtils = mx.mxUtils,
+    mxRectangle = mx.mxRectangle,
+    mxCellRenderer = mx.mxCellRenderer,
+    mxHexagon = mx.mxHexagon,
+    mxConstants = mx.mxConstants,
+    mxPoint = mx.mxPoint,
+    mxPerimeter = mx.mxPerimeter,
+    mxStyleRegistry = mx.mxStyleRegistry;
 export var DCallout = /*#__PURE__*/function (_DShape) {
   _inheritsLoose(DCallout, _DShape);
+
   function DCallout() {
     return _DShape.apply(this, arguments) || this;
   }
+
   DCallout.defaults = function defaults() {
     return _extends({}, DShape.defaults(), {
       width: 120,
       height: 80
     });
   };
+
   var _proto = DCallout.prototype;
+
   _proto.getStylesheet = function getStylesheet() {
     return 'shape=callout;whiteSpace=wrap;html=1;perimeter=calloutPerimeter;';
   };
+
   return DCallout;
 }(DShape);
 DCallout.displayName = 'DCallout';
+
 if (hasDocumentAvailable) {
   // Callout shape
   var CalloutShape = function CalloutShape() {
     mxActor.call(this);
   };
+
   mxUtils.extend(CalloutShape, mxHexagon);
   CalloutShape.prototype.size = 30;
   CalloutShape.prototype.position = 0.5;
   CalloutShape.prototype.position2 = 0.5;
   CalloutShape.prototype.base = 20;
   /* istanbul ignore next */
+
   CalloutShape.prototype.getLabelMargins = function () {
     return new mxRectangle(0, 0, 0, parseFloat(mxUtils.getValue(this.style, 'size', this.size)) * this.scale);
   };
   /* istanbul ignore next */
+
+
   CalloutShape.prototype.isRoundable = function () {
     return true;
   };
+
   CalloutShape.prototype.redrawPath = function (c, x, y, w, h) {
     var arcSize = mxUtils.getValue(this.style, mxConstants.STYLE_ARCSIZE, mxConstants.LINE_ARCSIZE) / 2;
     var s = Math.max(0, Math.min(h, parseFloat(mxUtils.getValue(this.style, 'size', this.size))));
@@ -56,10 +67,12 @@ if (hasDocumentAvailable) {
     var base = Math.max(0, Math.min(w, parseFloat(mxUtils.getValue(this.style, 'base', this.base))));
     this.addPoints(c, [new mxPoint(0, 0), new mxPoint(w, 0), new mxPoint(w, h - s), new mxPoint(Math.min(w, dx + base), h - s), new mxPoint(dx2, h), new mxPoint(Math.max(0, dx), h - s), new mxPoint(0, h - s)], this.isRounded, arcSize, true, [4]);
   };
-  mxCellRenderer.registerShape('callout', CalloutShape);
-  // Callout Perimeter
+
+  mxCellRenderer.registerShape('callout', CalloutShape); // Callout Perimeter
+
   mxPerimeter.CalloutPerimeter = function (bounds, vertex, next, orthogonal) {
     return mxPerimeter.RectanglePerimeter(mxUtils.getDirectedBounds(bounds, new mxRectangle(0, 0, 0, Math.max(0, Math.min(bounds.height, parseFloat(mxUtils.getValue(vertex.style, 'size', CalloutShape.prototype.size)) * vertex.view.scale))), vertex.style), vertex, next, orthogonal);
   };
+
   mxStyleRegistry.putValue('calloutPerimeter', mxPerimeter.CalloutPerimeter);
 }

package/components/diagram/shapes/circle.js

@@ -5,25 +5,32 @@ import mx from '../mxgraph';
 var mxGeometry = mx.mxGeometry;
 export var DCircle = /*#__PURE__*/function (_DShape) {
   _inheritsLoose(DCircle, _DShape);
+
   function DCircle() {
     return _DShape.apply(this, arguments) || this;
   }
+
   DCircle.defaults = function defaults() {
     return _extends({}, DShape.defaults(), {
       width: 80
     });
   };
+
   var _proto = DCircle.prototype;
+
   _proto.getGeometry = function getGeometry() {
     var _this$get = this.get(),
-      width = _this$get.width,
-      left = _this$get.left,
-      top = _this$get.top;
+        width = _this$get.width,
+        left = _this$get.left,
+        top = _this$get.top;
+
     return new mxGeometry(+left, +top, +width, +width);
   };
+
   _proto.getStylesheet = function getStylesheet() {
     return 'ellipse;whiteSpace=wrap;html=1;aspect=fixed;';
   };
+
   return DCircle;
 }(DShape);
 DCircle.displayName = 'DCircle';

package/components/diagram/shapes/document.js

@@ -4,43 +4,53 @@ import { DShape } from './shape';
 import mx from '../mxgraph';
 import { hasDocumentAvailable } from 'intact-shared';
 var mxActor = mx.mxActor,
-  mxUtils = mx.mxUtils,
-  mxRectangle = mx.mxRectangle,
-  mxCellRenderer = mx.mxCellRenderer,
-  mxConnectionConstraint = mx.mxConnectionConstraint,
-  mxPoint = mx.mxPoint;
+    mxUtils = mx.mxUtils,
+    mxRectangle = mx.mxRectangle,
+    mxCellRenderer = mx.mxCellRenderer,
+    mxConnectionConstraint = mx.mxConnectionConstraint,
+    mxPoint = mx.mxPoint;
 export var DDocument = /*#__PURE__*/function (_DShape) {
   _inheritsLoose(DDocument, _DShape);
+
   function DDocument() {
     return _DShape.apply(this, arguments) || this;
   }
+
   DDocument.defaults = function defaults() {
     return _extends({}, DShape.defaults(), {
       width: 120,
       height: 80
     });
   };
+
   var _proto = DDocument.prototype;
+
   _proto.getStylesheet = function getStylesheet() {
     return 'shape=document;whiteSpace=wrap;html=1;boundedLbl=1;';
   };
+
   return DDocument;
 }(DShape);
 DDocument.displayName = 'DDocument';
+
 if (hasDocumentAvailable) {
   // Document shape
   var DocumentShape = function DocumentShape() {
     mxActor.call(this);
   };
+
   mxUtils.extend(DocumentShape, mxActor);
   DocumentShape.prototype.size = 0.3;
   /* istanbul ignore next */
+
   DocumentShape.prototype.getLabelMargins = function (rect) {
     if (mxUtils.getValue(this.style, 'boundedLbl', false)) {
       return new mxRectangle(0, 0, 0, parseFloat(mxUtils.getValue(this.style, 'size', this.size)) * rect.height);
     }
+
     return null;
   };
+
   DocumentShape.prototype.redrawPath = function (c, x, y, w, h) {
     var dy = h * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'size', this.size))));
     var fy = 1.4;
@@ -53,6 +63,7 @@ if (hasDocumentAvailable) {
     c.close();
     c.end();
   };
+
   mxCellRenderer.registerShape('document', DocumentShape);
   DocumentShape.prototype.constraints = [new mxConnectionConstraint(new mxPoint(0.25, 0), true), new mxConnectionConstraint(new mxPoint(0.5, 0), true), new mxConnectionConstraint(new mxPoint(0.75, 0), true), new mxConnectionConstraint(new mxPoint(0, 0.25), true), new mxConnectionConstraint(new mxPoint(0, 0.5), true), new mxConnectionConstraint(new mxPoint(0, 0.75), true), new mxConnectionConstraint(new mxPoint(1, 0.25), true), new mxConnectionConstraint(new mxPoint(1, 0.5), true), new mxConnectionConstraint(new mxPoint(1, 0.75), true)];
 }

package/components/diagram/shapes/ellipse.js

@@ -5,19 +5,24 @@ import mx from '../mxgraph';
 var mxGeometry = mx.mxGeometry;
 export var DEllipse = /*#__PURE__*/function (_DShape) {
   _inheritsLoose(DEllipse, _DShape);
+
   function DEllipse() {
     return _DShape.apply(this, arguments) || this;
   }
+
   DEllipse.defaults = function defaults() {
     return _extends({}, DShape.defaults(), {
       width: 120,
       height: 80
     });
   };
+
   var _proto = DEllipse.prototype;
+
   _proto.getStylesheet = function getStylesheet() {
     return 'ellipse;whiteSpace=wrap;html=1;';
   };
+
   return DEllipse;
 }(DShape);
 DEllipse.displayName = 'DEllipse';

package/components/diagram/shapes/generateShapes.d.ts

@@ -1,6 +1,6 @@
 import { DShape } from './shape';
 import { ComponentConstructor } from 'intact-react';
-type ShapeConstructor = ComponentConstructor<DShape>;
+declare type ShapeConstructor = ComponentConstructor<DShape>;
 declare const shapes: {
     Diamond: {
         width: number;

package/components/diagram/shapes/generateShapes.js

@@ -24,28 +24,37 @@ var shapes = {
   }
 };
 var components = {};
+
 var _loop = function _loop(key) {
   var _class;
+
   var value = shapes[key];
   components[key] = (_class = /*#__PURE__*/function (_DShape) {
     _inheritsLoose(_class, _DShape);
+
     function _class() {
       return _DShape.apply(this, arguments) || this;
     }
+
     _class.defaults = function defaults() {
       return _extends({}, DShape.defaults(), {
         width: value.width,
         height: value.height
       });
     };
+
     var _proto = _class.prototype;
+
     _proto.getStylesheet = function getStylesheet() {
       return value.stylesheet;
     };
+
     return _class;
   }(DShape), _class.displayName = "D" + key, _class);
 };
+
 for (var key in shapes) {
   _loop(key);
 }
+
 export default components;

package/components/diagram/shapes/hexagon.js

@@ -4,54 +4,66 @@ import { DShape } from './shape';
 import mx from '../mxgraph';
 import { hasDocumentAvailable } from 'intact-shared';
 var mxActor = mx.mxActor,
-  mxUtils = mx.mxUtils,
-  mxCellRenderer = mx.mxCellRenderer,
-  mxHexagon = mx.mxHexagon,
-  mxConstants = mx.mxConstants,
-  mxPoint = mx.mxPoint,
-  mxPerimeter = mx.mxPerimeter,
-  mxStyleRegistry = mx.mxStyleRegistry;
+    mxUtils = mx.mxUtils,
+    mxCellRenderer = mx.mxCellRenderer,
+    mxHexagon = mx.mxHexagon,
+    mxConstants = mx.mxConstants,
+    mxPoint = mx.mxPoint,
+    mxPerimeter = mx.mxPerimeter,
+    mxStyleRegistry = mx.mxStyleRegistry;
 export var DHexagon = /*#__PURE__*/function (_DShape) {
   _inheritsLoose(DHexagon, _DShape);
+
   function DHexagon() {
     return _DShape.apply(this, arguments) || this;
   }
+
   DHexagon.defaults = function defaults() {
     return _extends({}, DShape.defaults(), {
       width: 120,
       height: 80
     });
   };
+
   var _proto = DHexagon.prototype;
+
   _proto.getStylesheet = function getStylesheet() {
     return 'shape=hexagon;perimeter=hexagonPerimeter2;whiteSpace=wrap;html=1;';
   };
+
   return DHexagon;
 }(DShape);
 DHexagon.displayName = 'DHexagon';
+
 if (hasDocumentAvailable) {
   // Hexagon shape
   var HexagonShape = function HexagonShape() {
     mxActor.call(this);
   };
+
   mxUtils.extend(HexagonShape, mxHexagon);
   HexagonShape.prototype.size = 0.25;
   /* istanbul ignore next */
+
   HexagonShape.prototype.isRoundable = function () {
     return true;
   };
+
   HexagonShape.prototype.redrawPath = function (c, x, y, w, h) {
     var s = w * Math.max(0, Math.min(1, parseFloat(mxUtils.getValue(this.style, 'size', this.size))));
     var arcSize = mxUtils.getValue(this.style, mxConstants.STYLE_ARCSIZE, mxConstants.LINE_ARCSIZE) / 2;
     this.addPoints(c, [new mxPoint(s, 0), new mxPoint(w - s, 0), new mxPoint(w, 0.5 * h), new mxPoint(w - s, h), new mxPoint(s, h), new mxPoint(0, 0.5 * h)], this.isRounded, arcSize, true);
   };
-  mxCellRenderer.registerShape('hexagon', HexagonShape);
-  // Hexagon Perimeter 2 (keep existing one)
+
+  mxCellRenderer.registerShape('hexagon', HexagonShape); // Hexagon Perimeter 2 (keep existing one)
+
   mxPerimeter.HexagonPerimeter2 = function (bounds, vertex, next, orthogonal) {
     var size = HexagonShape.prototype.size;
+
     if (vertex != null) {
       size = mxUtils.getValue(vertex.style, 'size', size);
     }
+
     var x = bounds.x;
     var y = bounds.y;
     var w = bounds.width;
@@ -61,6 +73,7 @@ if (hasDocumentAvailable) {
     var direction = vertex != null ? mxUtils.getValue(vertex.style, mxConstants.STYLE_DIRECTION, mxConstants.DIRECTION_EAST) : mxConstants.DIRECTION_EAST;
     var vertical = direction == mxConstants.DIRECTION_NORTH || direction == mxConstants.DIRECTION_SOUTH;
     var points;
+
     if (vertical) {
       var dy = h * Math.max(0, Math.min(1, size));
       points = [new mxPoint(cx, y), new mxPoint(x + w, y + dy), new mxPoint(x + w, y + h - dy), new mxPoint(cx, y + h), new mxPoint(x, y + h - dy), new mxPoint(x, y + dy), new mxPoint(cx, y)];
@@ -68,7 +81,9 @@ if (hasDocumentAvailable) {
       var dx = w * Math.max(0, Math.min(1, size));
       points = [new mxPoint(x + dx, y), new mxPoint(x + w - dx, y), new mxPoint(x + w, cy), new mxPoint(x + w - dx, y + h), new mxPoint(x + dx, y + h), new mxPoint(x, cy), new mxPoint(x + dx, y)];
     }
+
     var p1 = new mxPoint(cx, cy);
+
     if (orthogonal) {
       if (next.x < x || next.x > x + w) {
         p1.y = next.y;
@@ -76,7 +91,9 @@ if (hasDocumentAvailable) {
         p1.x = next.x;
       }
     }
+
     return mxUtils.getPerimeterPoint(points, p1, next);
   };
+
   mxStyleRegistry.putValue('hexagonPerimeter2', mxPerimeter.HexagonPerimeter2);
 }

package/components/diagram/shapes/image.js

@@ -1,14 +1,18 @@
 import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
 import _extends from "@babel/runtime-corejs3/helpers/extends";
 import { DShape } from './shape';
+
 var typeDefs = _extends({}, DShape.typeDefs, {
   src: String
 });
+
 export var DImage = /*#__PURE__*/function (_DShape) {
   _inheritsLoose(DImage, _DShape);
+
   function DImage() {
     return _DShape.apply(this, arguments) || this;
   }
+
   DImage.defaults = function defaults() {
     return _extends({}, DShape.defaults(), {
       width: 80,
@@ -16,12 +20,16 @@ export var DImage = /*#__PURE__*/function (_DShape) {
       src: ''
     });
   };
+
   var _proto = DImage.prototype;
+
   _proto.getStylesheet = function getStylesheet() {
     var _this$get = this.get(),
-      src = _this$get.src;
+        src = _this$get.src;
+
     return "image;html=1;labelBackgroundColor=#ffffff;image=" + src + ";";
   };
+
   return DImage;
 }(DShape);
 DImage.displayName = 'DImage';

package/components/diagram/shapes/line.d.ts

@@ -11,8 +11,8 @@ export interface DLineProps extends DBaseProps {
     exit?: Point;
     entry?: Point;
 }
-type Arrow = 'none' | 'classic' | 'classicThin' | 'block' | 'blockThin' | 'open' | 'openThin' | 'oval' | 'diamond' | 'diamondThin';
-type Point = [number, number];
+declare type Arrow = 'none' | 'classic' | 'classicThin' | 'block' | 'blockThin' | 'open' | 'openThin' | 'oval' | 'diamond' | 'diamondThin';
+declare type Point = [number, number];
 export declare class DLine extends DBase<DLineProps> {
     static template: (this: DLine) => import("intact").VNode<"dline">;
     static typeDefs: Required<TypeDefs<DLineProps>>;