dcim-topology2d 1.0.1

package/core/src/models/node.js

@@ -0,0 +1,944 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { Pen, PenType } from './pen';
+import { Rect } from './rect';
+import { Point } from './point';
+import { Line } from './line';
+import { anchorsFns, iconRectFns, textRectFns, drawNodeFns } from '../middles';
+import { defaultAnchors } from '../middles/default.anchor';
+import { defaultIconRect, defaultTextRect } from '../middles/default.rect';
+import { text, tableText, defaultText, iconfont } from '../middles/nodes/text';
+import { Store } from 'le5le-store';
+import { abs, s8, animateType, createChildrenDivByElementId } from '../utils';
+export var images = {};
+var Node = /** @class */ (function (_super) {
+    __extends(Node, _super);
+    function Node(json, noChild) {
+        if (noChild === void 0) { noChild = false; }
+        var _this = _super.call(this, json) || this;
+        _this.is3D = false;
+        _this.zRotate = 0;
+        _this.imageRatio = true;
+        _this.anchors = [];
+        _this.rotatedAnchors = [];
+        _this.animateDuration = 0;
+        _this.animateFrames = [];
+        _this.type = PenType.Node;
+        _this.is3D = json.is3D;
+        _this.z = json.z;
+        _this.zRotate = json.zRotate || 0;
+        _this.borderRadius = +json.borderRadius || 0;
+        _this.icon = json.icon;
+        _this.iconFamily = json.iconFamily;
+        _this.iconSize = +json.iconSize;
+        _this.iconColor = json.iconColor;
+        _this.image = json.image;
+        _this.floorImageIndex = json.floorImageIndex || false;
+        _this.formData = json.formData || null;
+        _this.formStyle = json.formStyle || null;
+        _this.formEvents = json.formEvents || [];
+        _this.paginationData = json.paginationData || null;
+        if (json.imgNaturalWidth) {
+            _this.imgNaturalWidth = json.imgNaturalWidth;
+        }
+        if (json.imgNaturalHeight) {
+            _this.imgNaturalHeight = json.imgNaturalHeight;
+        }
+        if (json.imageWidth) {
+            _this.imageWidth = json.imageWidth;
+        }
+        if (json.imageHeight) {
+            _this.imageHeight = json.imageHeight;
+        }
+        _this.imageRatio = json.imageRatio;
+        _this.imageAlign = json.imageAlign || 'center';
+        _this.bkType = json.bkType;
+        _this.gradientFromColor = json.gradientFromColor;
+        _this.gradientToColor = json.gradientToColor;
+        _this.gradientAngle = json.gradientAngle || 0;
+        _this.gradientRadius = json.gradientRadius || 0.01;
+        _this.paddingTop = json.paddingTop || 0;
+        _this.paddingBottom = json.paddingBottom || 0;
+        _this.paddingLeft = json.paddingLeft || 0;
+        _this.paddingRight = json.paddingRight || 0;
+        _this.onlySizeX = json.onlySizeX;
+        _this.onlySizeY = json.onlySizeY;
+        _this.appearance = json.appearance;
+        _this.leakageStart = json.leakageStart || 0;
+        _this.leakageEnd = json.leakageEnd || 0;
+        _this.leakageFillStyle = json.leakageFillStyle || '#ff0000';
+        _this.bindStaticId = json.bindStaticId || '';
+        _this.buttonCheckSlide = json.buttonCheckSlide || '';
+        _this.activeImgeIndex = json.activeImgeIndex || false;
+        _this.thBottomStrokeStyle = json.thBottomStrokeStyle || '#fff';
+        _this.thBottomLineWidth = json.thBottomLineWidth || 1;
+        // 兼容老数据
+        if (json.children && json.children[0] && json.children[0].parentRect) {
+            _this.paddingLeft = json.children[0].parentRect.offsetX;
+            _this.paddingRight = 0;
+            _this.paddingTop = json.children[0].parentRect.offsetY;
+            _this.paddingBottom = 0;
+        }
+        if (json.parentRect) {
+            _this.rectInParent = {
+                x: json.parentRect.x * 100 + '%',
+                y: json.parentRect.y * 100 + '%',
+                width: json.parentRect.width * 100 + '%',
+                height: json.parentRect.height * 100 + '%',
+                marginTop: 0,
+                marginRight: 0,
+                marginBottom: 0,
+                marginLeft: 0,
+                rotate: json.parentRect.rotate,
+            };
+            _this.paddingTop = json.parentRect.marginY;
+            _this.paddingBottom = json.parentRect.marginY;
+            _this.paddingLeft = json.parentRect.marginX;
+            _this.paddingRight = json.parentRect.marginX;
+        }
+        // 兼容老数据 end
+        if (json.animateFrames) {
+            _this.animateFrames = json.animateFrames;
+            for (var _i = 0, _a = _this.animateFrames; _i < _a.length; _i++) {
+                var item = _a[_i];
+                if (!item.state.init) {
+                    item.state = new Node(item.state, true);
+                }
+            }
+        }
+        if (json.animateDuration) {
+            _this.animateDuration = json.animateDuration;
+        }
+        _this.animateType = json.animateType
+                ? json.animateType
+                : json.animateDuration
+                        ? 'custom'
+                        : '';
+        _this.animateAlone = json.animateAlone;
+        _this.iframe = json.iframe;
+        _this.elementId = json.elementId;
+        _this.audio = json.audio;
+        _this.video = json.video;
+        _this.play = json.play;
+        _this.nextPlay = json.nextPlay;
+        if (json.elementLoaded !== undefined) {
+            _this.elementId = null;
+            _this.elementLoaded = false;
+        }
+        if(this.name == 'arbitraryGraph') {
+            this.rect.circles = json.rect.circles;
+            //let {x, y} = this.centroid(json.rect.circles);
+            let minX =  Math.min.apply(Math, json.rect.circles.map((item)=>{ return item.x}));
+            let minY = Math.min.apply(Math, json.rect.circles.map((item)=>{ return item.y}));
+            this.rect.x =  minX;
+            this.rect.y =  minY;
+            this.rect.ex = this.rect.x + this.rect.width;
+            this.rect.ey = this.rect.y + this.rect.height;
+            // this.rect.center.x = x;
+            // this.rect.center.y = y;
+            // console.log('this.rect', this.rect);
+            // console.log('this---node---', this);
+        }
+        if(json.name === 'formTable') _this.setFormTableData(json);
+        if(json.name === 'tablePagination') _this.setTablePagination(json);
+        _this.init();
+        if (!noChild) {
+            _this.setChild(json.children);
+        }
+        else {
+            _this.children = null;
+        }
+
+        return _this;
+    }
+    Node.cloneState = function (json) {
+        var n = new Node(json);
+        delete n.animateFrames;
+        return n;
+    };
+    Node.prototype.init = function () {
+        this.calcAbsPadding();
+        // Calc rect of text.
+        if (textRectFns[this.name]) {
+            textRectFns[this.name](this);
+        }
+        else {
+            defaultTextRect(this);
+        }
+        // Calc rect of icon.
+        if (iconRectFns[this.name]) {
+            iconRectFns[this.name](this);
+        }
+        else {
+            defaultIconRect(this);
+        }
+        this.calcAnchors();
+        this.elementRendered = false;
+        this.addToDiv();
+    };
+    Node.prototype.setFormTableData = function (json) {
+        if(!Store.get('FORM:tableData')){
+            Store.set('FORM:tableData', {
+                data: {
+                    tableNodes: {},
+                    paginationNodes: {},
+                    pageRelevTableNodes: {}
+                }
+            })
+        }
+        const tableData = Store.get('FORM:tableData').data;
+        tableData.tableNodes[json.id] = json
+        Store.set('FORM:tableData', {
+            data: tableData
+        })
+        const fromData = Store.get('SYNC:tableData');
+        if(fromData) {
+            if(!fromData[json.id].loading){
+                this.formData.tableBody = fromData[json.id].tableBody;
+                this.formData.total = fromData[json.id].total;
+            }else {
+                this.formData.tableBody = null;
+                this.formData.total = 0;
+            }
+        }
+    };
+    Node.prototype.setTablePagination = function (json) {
+        if(!Store.get('FORM:tableData')){
+            Store.set('FORM:tableData', {
+                data: {
+                    tableNodes: {},
+                    paginationNodes: {},
+                    pageRelevTableNodes: {}
+                }
+            })
+        }
+        const tableData = Store.get('FORM:tableData').data;
+        const fromData = Store.get('SYNC:tableData');
+        const tnode = fromData ? fromData[json.paginationData.bindFromTableId] : null;
+        if(tnode) json.paginationData.total = tnode.total;
+        tableData.paginationNodes[json.id] = json;
+        Store.set('FORM:tableData', {
+            data: tableData
+        })
+    };
+    Node.prototype.addToDiv = function (type) {
+        if (this.audio ||
+                this.video ||
+                this.iframe ||
+                this.elementId ||
+                this.hasGif()) {
+          if(type) {
+            // 复合Echarts初始化
+            createChildrenDivByElementId(this);
+          }else {
+            Store.set(this.generateStoreKey('LT:addDiv'), this);
+          }
+        }
+    };
+    Node.prototype.hasGif = function () {
+        if (this.gif) {
+            return true;
+        }
+        if (this.children) {
+            for (var _i = 0, _a = this.children; _i < _a.length; _i++) {
+                var item = _a[_i];
+                if (item.type === PenType.Node && item.hasGif()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    Node.prototype.calcAbsPadding = function () {
+        this.paddingLeftNum = abs(this.rect.width, this.paddingLeft);
+        this.paddingRightNum = abs(this.rect.width, this.paddingRight);
+        this.paddingTopNum = abs(this.rect.height, this.paddingTop);
+        this.paddingBottomNum = abs(this.rect.height, this.paddingBottom);
+    };
+    Node.prototype.setChild = function (children) {
+        if (!children) {
+            return;
+        }
+        this.children = [];
+        for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+            var item = children_1[_i];
+            var child = void 0;
+            switch (item.type) {
+                case PenType.Line:
+                    child = new Line(item);
+                    child.calcRectByParent(this);
+                    break;
+                default:
+                    child = new Node(item);
+                    child.parentId = this.id;
+                    child.calcRectByParent(this);
+                    child.init();
+                    child.setChild(item.children);
+                    break;
+            }
+            this.children.push(child);
+        }
+    };
+    Node.prototype.clearChildrenIds = function () {
+        if (!this.children) {
+            return;
+        }
+        for (var _i = 0, _a = this.children; _i < _a.length; _i++) {
+            var item = _a[_i];
+            item.id = s8();
+            switch (item.type) {
+                case PenType.Node:
+                    item.clearChildrenIds();
+                    break;
+            }
+        }
+    };
+    Node.prototype.draw = function (ctx) {
+        if (!drawNodeFns[this.name]) {
+            return;
+        }
+        // DrawBk
+        switch (this.bkType) {
+            case 1:
+                this.drawBkLinearGradient(ctx);
+                break;
+            case 2:
+                this.drawBkRadialGradient(ctx);
+                break;
+        }
+        if(this.name === 'tablePagination') defaultText(ctx, this);
+        // Draw shape.
+        drawNodeFns[this.name](ctx, this);
+        // Draw text.
+        if(this.name === 'formTable') {
+            tableText(ctx, this);
+        }else {
+            if (this.name !== 'text' && this.text && !(this.image && this.floorImageIndex === true)) {
+                text(ctx, this);
+            }
+        }
+        // Draw image.
+        if (this.image) {
+            this.drawImg(ctx);
+            if (this.name !== 'text' && this.text && this.floorImageIndex === true) {
+                text(ctx, this);
+            }
+            return;
+        }
+        // Draw icon
+        if (this.icon) {
+            ctx.save();
+            ctx.shadowColor = '';
+            ctx.shadowBlur = 0;
+            iconfont(ctx, this);
+            ctx.restore();
+        }
+
+    };
+    Node.prototype.drawBkLinearGradient = function (ctx) {
+        var from = new Point(this.rect.x, this.rect.center.y);
+        var to = new Point(this.rect.ex, this.rect.center.y);
+        if (this.gradientAngle % 90 === 0 && this.gradientAngle % 180) {
+            if (this.gradientAngle % 270) {
+                from.x = this.rect.center.x;
+                from.y = this.rect.y;
+                to.x = this.rect.center.x;
+                to.y = this.rect.ey;
+            }
+            else {
+                from.x = this.rect.center.x;
+                from.y = this.rect.ey;
+                to.x = this.rect.center.x;
+                to.y = this.rect.y;
+            }
+        }
+        else if (this.gradientAngle) {
+            from.rotate(this.gradientAngle, this.rect.center);
+            to.rotate(this.gradientAngle, this.rect.center);
+        }
+        // contributor: https://github.com/sunnyguohua/topology
+        var grd = ctx.createLinearGradient(from.x, from.y, to.x, to.y);
+        grd.addColorStop(0, this.gradientFromColor);
+        grd.addColorStop(1, this.gradientToColor);
+        ctx.fillStyle = grd;
+    };
+    Node.prototype.drawBkRadialGradient = function (ctx) {
+        var r = this.rect.width;
+        if (r < this.rect.height) {
+            r = this.rect.height;
+        }
+        r *= 0.5;
+        var grd = ctx.createRadialGradient(this.rect.center.x, this.rect.center.y, r * this.gradientRadius, this.rect.center.x, this.rect.center.y, r);
+        grd.addColorStop(0, this.gradientFromColor);
+        grd.addColorStop(1, this.gradientToColor);
+        ctx.fillStyle = grd;
+    };
+    Node.prototype.drawImg = function (ctx) {
+        var _this = this;
+        if (this.lastImage !== this.image) {
+            this.img = null;
+        }
+        var gif = this.image.indexOf('.gif') > 0;
+        if (!gif && this.img) {
+            this.initDrawImg(ctx);
+            return;
+        }
+        //Load image and draw it.
+        if (!gif && images[this.image]) {
+            this.img = images[this.image].img;
+            ++images[this.image].cnt;
+            this.lastImage = this.img
+            this.imgNaturalWidth = this.img.naturalWidth;
+            this.imgNaturalHeight = this.img.naturalHeight;
+            this.initDrawImg(ctx);
+            //this.drawImg(ctx);
+            return;
+        }
+        var img = new Image();
+        img.crossOrigin = 'anonymous';
+        img.src = this.image;
+        img.onload = function (e) {
+            _this.lastImage = _this.image;
+            _this.imgNaturalWidth = img.naturalWidth;
+            _this.imgNaturalHeight = img.naturalHeight;
+            _this.img = img;
+            images[_this.image] = {
+                img: img,
+                cnt: 1,
+            };
+            Store.set(_this.generateStoreKey('LT:imageLoaded'), true);
+            if (!_this.gif && gif) {
+                _this.gif = true;
+                Store.set(_this.generateStoreKey('LT:addDiv'), _this);
+            }
+        };
+    };
+    Node.prototype.initDrawImg = function (ctx){
+        var _this = this;
+        ctx.save();
+        ctx.shadowColor = '';
+        ctx.shadowBlur = 0;
+        var rect = this.getIconRect();
+        var x = rect.x;
+        var y = rect.y;
+        var w = rect.width;
+        var h = rect.height;
+        if (this.imageWidth) {
+            w = this.imageWidth;
+        }
+        if (this.imageHeight) {
+            h = this.imageHeight;
+        }
+        if (this.imageRatio) {
+            if (this.imageWidth) {
+                h = (this.imgNaturalHeight / this.imgNaturalWidth) * w;
+            }
+            else {
+                w = (this.imgNaturalWidth / this.imgNaturalHeight) * h;
+            }
+        }
+        if (this.name !== 'image') {
+            x += (rect.width - w) / 2;
+            y += (rect.height - h) / 2;
+        }
+        switch (this.imageAlign) {
+            case 'top':
+                y = rect.y;
+                break;
+            case 'bottom':
+                y = rect.ey - h;
+                break;
+            case 'left':
+                x = rect.x;
+                break;
+            case 'right':
+                x = rect.ex - w;
+                break;
+            case 'left-top':
+                x = rect.x;
+                y = rect.y;
+                break;
+            case 'right-top':
+                x = rect.ex - w;
+                y = rect.y;
+                break;
+            case 'left-bottom':
+                x = rect.x;
+                y = rect.ey - h;
+                break;
+            case 'right-bottom':
+                x = rect.ex - w;
+                y = rect.ey - h;
+                break;
+        }
+        if(!_this.activeImgeIndex) ctx.drawImage(this.img, x, y, w, h);
+        ctx.restore();
+    };
+    Node.prototype.calcAnchors = function () {
+        this.anchors = [];
+        if (anchorsFns[this.name]) {
+            anchorsFns[this.name](this);
+        }
+        else {
+            defaultAnchors(this);
+        }
+        this.calcRotateAnchors();
+    };
+    Node.prototype.calcRotateAnchors = function (angle) {
+        if (angle === undefined) {
+            angle = this.rotate;
+        }
+        this.rotatedAnchors = [];
+        for (var _i = 0, _a = this.anchors; _i < _a.length; _i++) {
+            var item = _a[_i];
+            this.rotatedAnchors.push(item.clone().rotate(angle, this.rect.center));
+        }
+    };
+    Node.prototype.getTextRect = function () {
+        var textRect = this.textRect;
+        if ((!this.icon && !this.image) || this.floorImageIndex === true) {
+            textRect = this.fullTextRect;
+        }
+        return textRect;
+    };
+    Node.prototype.getIconRect = function () {
+        var rect = this.iconRect;
+        if (!this.text || this.floorImageIndex === true) {
+            rect = this.fullIconRect || this.fullTextRect || this.rect;
+        }
+        return rect;
+    };
+    // 根据父节点rect计算自己（子节点）的rect
+    Node.prototype.calcRectByParent = function (parent) {
+        if (!this.rectInParent) {
+            return;
+        }
+        var parentW = parent.rect.width - parent.paddingLeftNum - parent.paddingRightNum;
+        var parentH = parent.rect.height - parent.paddingTopNum - parent.paddingBottomNum;
+        var x = parent.rect.x +
+                parent.paddingLeftNum +
+                abs(parentW, this.rectInParent.x) +
+                abs(parentW, this.rectInParent.marginLeft);
+        var y = parent.rect.y +
+                parent.paddingTopNum +
+                abs(parentH, this.rectInParent.y) +
+                abs(parentW, this.rectInParent.marginTop);
+        var w = abs(parentW, this.rectInParent.width);
+        var h = abs(parentH, this.rectInParent.height);
+        if (this.rectInParent.marginLeft === undefined &&
+                this.rectInParent.marginRight) {
+            x -= abs(parentW, this.rectInParent.marginRight);
+        }
+        if (this.rectInParent.marginTop === undefined &&
+                this.rectInParent.marginBottom) {
+            y -= abs(parentW, this.rectInParent.marginBottom);
+        }
+        this.rect = new Rect(x, y, w, h);
+        if (!this.rectInParent.rotate) {
+            this.rectInParent.rotate = 0;
+        }
+        var offsetR = parent.rotate + parent.offsetRotate;
+        this.rotate = this.rectInParent.rotate + offsetR;
+        if (!this.rectInParent.rect) {
+            this.rectInParent.rect = this.rect.clone();
+        }
+    };
+    Node.prototype.calcChildrenRect = function () {
+        if (!this.children) {
+            return;
+        }
+        for (var _i = 0, _a = this.children; _i < _a.length; _i++) {
+            var item = _a[_i];
+            item.calcRectByParent(this);
+            if (item.type === PenType.Node) {
+                item.init();
+                item.calcChildrenRect();
+            }
+        }
+    };
+    Node.prototype.calcRectInParent = function (parent) {
+        var parentW = parent.rect.width - parent.paddingLeftNum - parent.paddingRightNum;
+        var parentH = parent.rect.height - parent.paddingTopNum - parent.paddingBottomNum;
+        this.rectInParent = {
+            x: ((this.rect.x - parent.rect.x - parent.paddingLeftNum) * 100) /
+                    parentW +
+                    '%',
+            y: ((this.rect.y - parent.rect.y - parent.paddingTopNum) * 100) / parentH +
+                    '%',
+            width: (this.rect.width * 100) / parentW + '%',
+            height: (this.rect.height * 100) / parentH + '%',
+            rotate: this.rectInParent
+                    ? this.rectInParent.rotate || 0
+                    : this.rotate || 0,
+            rect: this.rect.clone(),
+        };
+    };
+    Node.prototype.getDockWatchers = function () {
+        this.dockWatchers = this.rect.toPoints();
+        this.dockWatchers.unshift(this.rect.center);
+    };
+    Node.prototype.initAnimateProps = function () {
+        var passed = 0;
+        for (var i = 0; i < this.animateFrames.length; ++i) {
+            this.animateFrames[i].start = passed;
+            passed += this.animateFrames[i].duration;
+            this.animateFrames[i].end = passed;
+            this.animateFrames[i].initState = Node.cloneState(i ? this.animateFrames[i - 1].state : this);
+        }
+    };
+    Node.prototype.animate = function (now) {
+        var timeline = now - this.animateStart;
+        if (timeline > this.animateDuration) {
+            if (++this.animateCycleIndex >= this.animateCycle &&
+                    this.animateCycle > 0) {
+                this.animateStart = 0;
+                this.animateCycleIndex = 0;
+                var item = this.animateFrames[this.animateFrames.length - 1];
+                if (item) {
+                    this.dash = item.state.dash;
+                    this.strokeStyle = item.state.strokeStyle;
+                    this.fillStyle = item.state.fillStyle;
+                    this.text = item.state.text;
+                    this.font = item.state.font;
+                    this.lineWidth = item.state.lineWidth;
+                    this.rotate = item.state.rotate;
+                    this.globalAlpha = item.state.globalAlpha;
+                    this.lineDashOffset = item.state.lineDashOffset || 0;
+                    if (item.state.rect && item.state.rect.width) {
+                        this.rect = new Rect(item.state.rect.x, item.state.rect.y, item.state.rect.width, item.state.rect.height);
+                        this.init();
+                    }
+                }
+                Store.set(this.generateStoreKey('animateEnd'), {
+                    type: 'node',
+                    data: this,
+                });
+                return;
+            }
+            this.animateStart = now;
+            timeline = 0;
+        }
+        var rectChanged = false;
+        for (var i = 0; i < this.animateFrames.length; ++i) {
+            var item = this.animateFrames[i];
+            if (timeline >= item.start && timeline < item.end) {
+                this.dash = item.state.dash;
+                this.strokeStyle = item.state.strokeStyle;
+                this.fillStyle = item.state.fillStyle;
+                this.text = item.state.text;
+                this.font = item.state.font;
+                var rate = (timeline - item.start) / item.duration;
+                if (item.linear) {
+                    // 线条左右流动动画
+                    if([animateType.LeftFlow, animateType.RightFlow].includes(this.animateType) && item.state.lineDashOffset){
+                        const lineDashOffset = item.state.lineDashOffset;
+                        if (lineDashOffset > 100) item.state.lineDashOffset = 1;
+                        if (lineDashOffset < -100) item.state.lineDashOffset = -1;
+                        lineDashOffset > 0 ? item.state.lineDashOffset++ : item.state.lineDashOffset--;
+                        this.lineDashOffset = item.state.lineDashOffset;
+                    }else if(([animateType.Show, animateType.Rotate].includes(this.animateType) || this.name === 'electricFan') && item.state.rotate !== item.initState.rotate) {
+                        // 旋转动画，判断逻辑先这么写，日后将所有动画统一在编辑器中配置，再做优化
+                        this.rotate =
+                                item.initState.rotate +
+                                (item.state.rotate - item.initState.rotate) * rate;
+                        rectChanged = true;
+                    }else {
+
+                        if (item.state.rect.x !== item.initState.rect.x) {
+                            this.rect.x =
+                                    item.initState.rect.x +
+                                    (item.state.rect.x - item.initState.rect.x) * rate;
+                            rectChanged = true;
+                        }
+                        if (item.state.rect.y !== item.initState.rect.y) {
+                            this.rect.y =
+                                    item.initState.rect.y +
+                                    (item.state.rect.y - item.initState.rect.y) * rate;
+                            rectChanged = true;
+                        }
+                        if (item.state.rect.width !== item.initState.rect.width) {
+                            this.rect.width =
+                                    item.initState.rect.width +
+                                    (item.state.rect.width - item.initState.rect.width) * rate;
+                            rectChanged = true;
+                        }
+                        if (item.state.rect.height !== item.initState.rect.height) {
+                            this.rect.height =
+                                    item.initState.rect.height +
+                                    (item.state.rect.height - item.initState.rect.height) * rate;
+                            rectChanged = true;
+                        }
+                        this.rect.ex = this.rect.x + this.rect.width;
+                        this.rect.ey = this.rect.y + this.rect.height;
+                        this.rect.calcCenter();
+                        if (item.initState.z !== undefined &&
+                                item.state.z !== item.initState.z) {
+                            this.z =
+                                    item.initState.z + (item.state.z - item.initState.z) * rate;
+                            rectChanged = true;
+                        }
+                        if (item.state.borderRadius !== item.initState.borderRadius) {
+                            this.borderRadius =
+                                    item.initState.borderRadius +
+                                    (item.state.borderRadius - item.initState.borderRadius) * rate;
+                        }
+                        if (item.state.lineWidth !== item.initState.lineWidth) {
+                            this.lineWidth =
+                                    item.initState.lineWidth +
+                                    (item.state.lineWidth - item.initState.lineWidth) * rate;
+                        }
+                        if (item.state.globalAlpha !== item.initState.globalAlpha) {
+                            this.globalAlpha =
+                                    item.initState.globalAlpha +
+                                    (item.state.globalAlpha - item.initState.globalAlpha) * rate;
+                        }
+                    }
+                }
+                else {
+                    this.rect = item.state.rect;
+                    this.lineWidth = item.state.lineWidth;
+                    this.rotate = item.state.rotate;
+                    this.globalAlpha = item.state.globalAlpha;
+                    this.lineDashOffset = item.state.lineDashOffset;
+                }
+            }
+        }
+        // if (rectChanged) {
+        //   this.init();
+        //   if (!this.animateAlone) {
+        //     Store.set(this.generateStoreKey('LT:rectChanged'), this);
+        //   }
+        // }
+    };
+    Node.prototype.scale = function (scale, center, w, h) {
+        if (!center) {
+            center = this.rect.center;
+        }
+        if (!w) {
+            w = scale;
+        }
+        if (!h) {
+            h = scale;
+        }
+        this['oldRect'] = this.rect.clone();
+        if(this.rect.circles) {
+            for(let c=0, circles= this.rect.circles; c<circles.length; c++) {
+                circles[c].x = (center.x - (center.x - circles[c].x)) * w;
+                circles[c].y = (center.y - (center.y - circles[c].y)) * h + 15;
+            }
+        }else {
+            this.rect.x = center.x - (center.x - this.rect.x) * w;
+            if(this.rotate % 180) {
+                this.rect.x = this.rect.x + (this.rect.width * w - this.rect.width * h) / 2;
+            }
+            this.rect.y = center.y - (center.y - this.rect.y) * h;
+        }
+        this.z *= scale;
+        this.rect.width *= this.rotate % 180 ? h : w;
+        this.rect.height *= h;
+        this.rect.ex = this.rect.x + this.rect.width;
+        this.rect.ey = this.rect.y + this.rect.height;
+        if (this.imageWidth) {
+            this.imageWidth *= w;
+        }
+        if (this.imageHeight) {
+            this.imageHeight *= h;
+        }
+        this.lastImage = null;
+        this.font.fontSize *= scale;
+        this.iconSize *= scale;
+        if (typeof this.paddingLeft === 'number') {
+            this.paddingLeft *= scale;
+        }
+        if (typeof this.paddingTop === 'number') {
+            this.paddingTop *= scale;
+        }
+        if (typeof this.paddingRight === 'number') {
+            this.paddingRight *= scale;
+        }
+        if (typeof this.paddingBottom === 'number') {
+            this.paddingBottom *= scale;
+        }
+        if (this.rectInParent) {
+            if (typeof this.rectInParent.x === 'number') {
+                this.rectInParent.x *= scale;
+            }
+            if (typeof this.rectInParent.y === 'number') {
+                this.rectInParent.y *= scale;
+            }
+            if (typeof this.rectInParent.width === 'number') {
+                this.rectInParent.width *= scale;
+            }
+            if (typeof this.rectInParent.height === 'number') {
+                this.rectInParent.height *= scale;
+            }
+            if (typeof this.rectInParent.marginLeft === 'number') {
+                this.rectInParent.marginLeft *= scale;
+            }
+            if (typeof this.rectInParent.marginTop === 'number') {
+                this.rectInParent.marginTop *= scale;
+            }
+            if (typeof this.rectInParent.marginRight === 'number') {
+                this.rectInParent.marginRight *= scale;
+            }
+            if (typeof this.rectInParent.marginBottom === 'number') {
+                this.rectInParent.marginBottom *= scale;
+            }
+        }
+        this.rect.calcCenter();
+        if (this.animateFrames && this.animateFrames.length) {
+            for (var _i = 0, _a = this.animateFrames; _i < _a.length; _i++) {
+                var item = _a[_i];
+                if (item.initState) {
+                    if (!item.initState.scale) {
+                        item.initState = new Node(item.initState);
+                    }
+                    item.initState.scale(scale, center, w, h);
+                }
+                if (item.state) {
+                    if (!item.state.scale) {
+                        item.state = new Node(item.state);
+                    }
+                    item.state.scale(scale, center, w, h);
+                }
+                if (item.initState && item.state) {
+                    item.state.fontSize = item.initState.fontSize;
+                }
+            }
+        }
+        this.scalePoints(scale, scale);
+        this.elementRendered = false;
+        this.init();
+        if (this.children) {
+            for (var _b = 0, _c = this.children; _b < _c.length; _b++) {
+                var item = _c[_b];
+                item.scale(scale, center, w, h);
+            }
+        }
+    };
+    Node.prototype.scalePoints = function (scaleX, scaleY) {
+        var _this = this;
+        if ((this.points || this.manualAnchors) && this['oldRect']) {
+            if (!scaleX) {
+                scaleX = this.rect.width / this['oldRect'].width;
+            }
+            if (!scaleY) {
+                scaleY = this.rect.height / this['oldRect'].height;
+            }
+            if (this.points) {
+                this.points.forEach(function (pt) {
+                    pt.x = _this.rect.x + (pt.x - _this['oldRect'].x) * scaleX;
+                    pt.y = _this.rect.y + (pt.y - _this['oldRect'].y) * scaleY;
+                });
+            }
+            if (this.manualAnchors) {
+                this.manualAnchors.forEach(function (pt) {
+                    pt.x = _this.rect.x + (pt.x - _this['oldRect'].x) * scaleX;
+                    pt.y = _this.rect.y + (pt.y - _this['oldRect'].y) * scaleY;
+                });
+            }
+        }
+    };
+    Node.prototype.translate = function (x, y) {
+        this.rect.x += x;
+        this.rect.y += y;
+        this.rect.ex = this.rect.x + this.rect.width;
+        this.rect.ey = this.rect.y + this.rect.height;
+        this.rect.calcCenter();
+        if (this.animateFrames && this.animateFrames.length) {
+            for (var _i = 0, _a = this.animateFrames; _i < _a.length; _i++) {
+                var frame = _a[_i];
+                var initState = frame.initState, state = frame.state;
+                if (initState && initState.translate) {
+                    initState.translate(x, y);
+                }
+                if (state && state.translate) {
+                    state.translate(x, y);
+                }
+            }
+        }
+        this.init();
+        if (this.children) {
+            for (var _b = 0, _c = this.children; _b < _c.length; _b++) {
+                var item = _c[_b];
+                item.translate(x, y);
+            }
+        }
+    };
+    Node.prototype.initRect = function () {
+        this.rect.init();
+        if (this.children) {
+            this.calcChildrenRect();
+            for (var _i = 0, _a = this.children; _i < _a.length; _i++) {
+                var item = _a[_i];
+                if (item instanceof Node) {
+                    item.initRect();
+                }
+            }
+        }
+    };
+    Node.prototype.round = function () {
+        this.rect.round();
+        if (this.children) {
+            for (var _i = 0, _a = this.children; _i < _a.length; _i++) {
+                var item = _a[_i];
+                item.rect.round();
+            }
+        }
+    };
+    Node.prototype.clone = function () {
+        var n = new Node(this);
+        n.clearChildrenIds();
+        return n;
+    };
+    //新增属性
+    Node.prototype.area = function(pts) {
+        var area = 0;
+        var pts = pts;
+        var nPts = pts.length;
+        var j = nPts - 1;
+        var p1;
+        var p2;
+        for (var i = 0; i < nPts; j = i++) {
+            p1 = pts[i];
+            p2 = pts[j];
+            area += p1.x * p2.y;
+            area -= p1.y * p2.x;
+        }
+        area /= 2;
+        return area;
+    };
+    Node.prototype.centroid = function(pts) {
+        var pts = pts;
+        var nPts = pts.length;
+        var x = 0;
+        var y = 0;
+        var f;
+        var j = nPts - 1;
+        var p1;
+        var p2;
+        for (var i = 0; i < nPts; j = i++) {
+            p1 = pts[i];
+            p2 = pts[j];
+            f = p1.x * p2.y - p2.x * p1.y;
+            x += (p1.x + p2.x) * f;
+            y += (p1.y + p2.y) * f;
+        }
+        f = this.area(pts) * 6;
+        return new Point(x / f, y / f);
+    }
+    return Node;
+}(Pen));
+export { Node };
+//# sourceMappingURL=node.js.map