@king-design/vue 2.0.0-beta.0

package/components/diagram/shapes/circle.js

@@ -0,0 +1,38 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import { DShape } from './shape';
+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;
+
+    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';
+
+export {normalize} from 'intact-vue-next';

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

@@ -0,0 +1,24 @@
+import { DShape } from './shape';
+export declare class DDocument extends DShape {
+    static displayName: string;
+    static defaults(): {
+        width: number;
+        height: number;
+        left?: string | number | undefined;
+        top?: string | number | undefined;
+        movable?: boolean | undefined;
+        selectable?: boolean | undefined;
+        resizable?: boolean | undefined;
+        rotatable?: boolean | undefined;
+        editable?: boolean | undefined;
+        connectable?: boolean | undefined;
+        strokeStyle?: "dashed" | "dotted" | "solid" | undefined;
+        label?: string | number | undefined;
+        style?: Record<string, string | number> | undefined;
+        data?: any;
+    };
+    getStylesheet(): string;
+}
+
+
+export {normalize} from 'intact-vue-next';

package/components/diagram/shapes/document.js

@@ -0,0 +1,71 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+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;
+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;
+    c.moveTo(0, 0);
+    c.lineTo(w, 0);
+    c.lineTo(w, h - dy / 2);
+    c.quadTo(w * 3 / 4, h - dy * fy, w / 2, h - dy / 2);
+    c.quadTo(w / 4, h - dy * (1 - fy), 0, h - dy / 2);
+    c.lineTo(0, dy / 2);
+    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)];
+}
+
+export {normalize} from 'intact-vue-next';

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

@@ -0,0 +1,24 @@
+import { DShape } from './shape';
+export declare class DEllipse extends DShape {
+    static displayName: string;
+    static defaults(): {
+        width: number;
+        height: number;
+        left?: string | number | undefined;
+        top?: string | number | undefined;
+        movable?: boolean | undefined;
+        selectable?: boolean | undefined;
+        resizable?: boolean | undefined;
+        rotatable?: boolean | undefined;
+        editable?: boolean | undefined;
+        connectable?: boolean | undefined;
+        strokeStyle?: "dashed" | "dotted" | "solid" | undefined;
+        label?: string | number | undefined;
+        style?: Record<string, string | number> | undefined;
+        data?: any;
+    };
+    getStylesheet(): string;
+}
+
+
+export {normalize} from 'intact-vue-next';

package/components/diagram/shapes/ellipse.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import { DShape } from './shape';
+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';
+
+export {normalize} from 'intact-vue-next';

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

@@ -0,0 +1,32 @@
+import { DShape } from './shape';
+import { ComponentConstructor } from 'intact-vue-next';
+declare type ShapeConstructor = ComponentConstructor<DShape>;
+declare const shapes: {
+    Diamond: {
+        width: number;
+        height: number;
+        stylesheet: string;
+    };
+    Triangle: {
+        width: number;
+        height: number;
+        stylesheet: string;
+    };
+    Cylinder: {
+        width: number;
+        height: number;
+        stylesheet: string;
+    };
+    Cloud: {
+        width: number;
+        height: number;
+        stylesheet: string;
+    };
+};
+declare const components: {
+    [key in keyof typeof shapes]: ShapeConstructor;
+};
+export default components;
+
+
+export {normalize} from 'intact-vue-next';

package/components/diagram/shapes/generateShapes.js

@@ -0,0 +1,62 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import { DShape } from './shape';
+var shapes = {
+  Diamond: {
+    width: 80,
+    height: 80,
+    stylesheet: 'rhombus;whiteSpace=wrap;html=1;'
+  },
+  Triangle: {
+    width: 60,
+    height: 80,
+    stylesheet: 'triangle;whiteSpace=wrap;html=1;'
+  },
+  Cylinder: {
+    width: 60,
+    height: 80,
+    stylesheet: 'shape=cylinder;whiteSpace=wrap;html=1;boundedLbl=1;backgroundOutline=1;'
+  },
+  Cloud: {
+    width: 120,
+    height: 80,
+    stylesheet: 'ellipse;shape=cloud;whiteSpace=wrap;html=1;'
+  }
+};
+var components = {};
+
+var _loop = function _loop(key) {
+  var _class, _temp;
+
+  var value = shapes[key];
+  components[key] = (_temp = _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, _temp);
+};
+
+for (var key in shapes) {
+  _loop(key);
+}
+
+export default components;
+
+export {normalize} from 'intact-vue-next';

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

@@ -0,0 +1,24 @@
+import { DShape } from './shape';
+export declare class DHexagon extends DShape {
+    static displayName: string;
+    static defaults(): {
+        width: number;
+        height: number;
+        left?: string | number | undefined;
+        top?: string | number | undefined;
+        movable?: boolean | undefined;
+        selectable?: boolean | undefined;
+        resizable?: boolean | undefined;
+        rotatable?: boolean | undefined;
+        editable?: boolean | undefined;
+        connectable?: boolean | undefined;
+        strokeStyle?: "dashed" | "dotted" | "solid" | undefined;
+        label?: string | number | undefined;
+        style?: Record<string, string | number> | undefined;
+        data?: any;
+    };
+    getStylesheet(): string;
+}
+
+
+export {normalize} from 'intact-vue-next';

package/components/diagram/shapes/hexagon.js

@@ -0,0 +1,101 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+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;
+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)
+
+  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;
+    var h = bounds.height;
+    var cx = bounds.getCenterX();
+    var cy = bounds.getCenterY();
+    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)];
+    } else {
+      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;
+      } else {
+        p1.x = next.x;
+      }
+    }
+
+    return mxUtils.getPerimeterPoint(points, p1, next);
+  };
+
+  mxStyleRegistry.putValue('hexagonPerimeter2', mxPerimeter.HexagonPerimeter2);
+}
+
+export {normalize} from 'intact-vue-next';

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

@@ -0,0 +1,30 @@
+import { TypeDefs } from 'intact-vue-next';
+import { DShape, DShapeProps } from './shape';
+export interface DImageProps extends DShapeProps {
+    src?: string;
+}
+export declare class DImage extends DShape<DImageProps> {
+    static displayName: string;
+    static typeDefs: Required<TypeDefs<DImageProps>>;
+    static defaults(): {
+        width: number;
+        height: number;
+        src: string;
+        left?: string | number | undefined;
+        top?: string | number | undefined;
+        movable?: boolean | undefined;
+        selectable?: boolean | undefined;
+        resizable?: boolean | undefined;
+        rotatable?: boolean | undefined;
+        editable?: boolean | undefined;
+        connectable?: boolean | undefined;
+        strokeStyle?: "dashed" | "dotted" | "solid" | undefined;
+        label?: string | number | undefined;
+        style?: Record<string, string | number> | undefined;
+        data?: any;
+    };
+    getStylesheet(): string;
+}
+
+
+export {normalize} from 'intact-vue-next';

package/components/diagram/shapes/image.js

@@ -0,0 +1,38 @@
+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,
+      height: 80,
+      src: ''
+    });
+  };
+
+  var _proto = DImage.prototype;
+
+  _proto.getStylesheet = function getStylesheet() {
+    var _this$get = this.get(),
+        src = _this$get.src;
+
+    return "image;html=1;labelBackgroundColor=#ffffff;image=" + src + ";";
+  };
+
+  return DImage;
+}(DShape);
+DImage.displayName = 'DImage';
+DImage.typeDefs = typeDefs;
+
+export {normalize} from 'intact-vue-next';

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

@@ -0,0 +1,46 @@
+import { TypeDefs, Key } from 'intact-vue-next';
+import { DBase, DBaseProps } from './base';
+export interface DLineProps extends DBaseProps {
+    type?: 'rounded' | 'sharp' | 'curved' | 'straight';
+    startArrow?: Arrow;
+    endArrow?: Arrow;
+    startPoint?: Point;
+    endPoint?: Point;
+    exit?: Point;
+    entry?: Point;
+    from?: Key;
+    to?: Key;
+}
+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>>;
+    static defaults: () => Partial<DLineProps>;
+    protected startDraw(): void;
+    private setTerminal;
+    protected addToDigram(): void;
+    protected deleteFromDiagram(): void;
+    protected getStylesheet(): string;
+    protected getGeometry(): any;
+    protected genStyles(): {
+        dashed?: number | null | undefined;
+        dashPattern?: string | null | undefined;
+        edgeStyle?: string | undefined;
+        rounded?: number | undefined;
+        curved?: number | null | undefined;
+        noEdgeStyle?: null | undefined;
+        exitX?: number | undefined;
+        exitY?: number | undefined;
+        perimeter?: number | undefined;
+        entryX?: number | undefined;
+        entryY?: number | undefined;
+    };
+    protected updateProps(model: any, lastProps: DLineProps, nextProps: DLineProps): void;
+    private genStylesForExitAndEntry;
+    private genStylesForType;
+}
+export {};
+
+
+export {normalize} from 'intact-vue-next';