office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/zrender/lib/graphic/Displayable.js

@@ -0,0 +1,333 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Element = require('../Element.js');
+var BoundingRect = require('../core/BoundingRect.js');
+var util = require('../core/util.js');
+var constants = require('./constants.js');
+
+var STYLE_MAGIC_KEY = '__zr_style_' + Math.round((Math.random() * 10));
+var DEFAULT_COMMON_STYLE = {
+    shadowBlur: 0,
+    shadowOffsetX: 0,
+    shadowOffsetY: 0,
+    shadowColor: '#000',
+    opacity: 1,
+    blend: 'source-over'
+};
+var DEFAULT_COMMON_ANIMATION_PROPS = {
+    style: {
+        shadowBlur: true,
+        shadowOffsetX: true,
+        shadowOffsetY: true,
+        shadowColor: true,
+        opacity: true
+    }
+};
+DEFAULT_COMMON_STYLE[STYLE_MAGIC_KEY] = true;
+var PRIMARY_STATES_KEYS = ['z', 'z2', 'invisible'];
+var PRIMARY_STATES_KEYS_IN_HOVER_LAYER = ['invisible'];
+var Displayable = (function (_super) {
+    tslib.__extends(Displayable, _super);
+    function Displayable(props) {
+        return _super.call(this, props) || this;
+    }
+    Displayable.prototype._init = function (props) {
+        var keysArr = util.keys(props);
+        for (var i = 0; i < keysArr.length; i++) {
+            var key = keysArr[i];
+            if (key === 'style') {
+                this.useStyle(props[key]);
+            }
+            else {
+                _super.prototype.attrKV.call(this, key, props[key]);
+            }
+        }
+        if (!this.style) {
+            this.useStyle({});
+        }
+    };
+    Displayable.prototype.beforeBrush = function () { };
+    Displayable.prototype.afterBrush = function () { };
+    Displayable.prototype.innerBeforeBrush = function () { };
+    Displayable.prototype.innerAfterBrush = function () { };
+    Displayable.prototype.shouldBePainted = function (viewWidth, viewHeight, considerClipPath, considerAncestors) {
+        var m = this.transform;
+        if (this.ignore
+            || this.invisible
+            || this.style.opacity === 0
+            || (this.culling
+                && isDisplayableCulled(this, viewWidth, viewHeight))
+            || (m && !m[0] && !m[3])) {
+            return false;
+        }
+        if (considerClipPath && this.__clipPaths) {
+            for (var i = 0; i < this.__clipPaths.length; ++i) {
+                if (this.__clipPaths[i].isZeroArea()) {
+                    return false;
+                }
+            }
+        }
+        if (considerAncestors && this.parent) {
+            var parent_1 = this.parent;
+            while (parent_1) {
+                if (parent_1.ignore) {
+                    return false;
+                }
+                parent_1 = parent_1.parent;
+            }
+        }
+        return true;
+    };
+    Displayable.prototype.contain = function (x, y) {
+        return this.rectContain(x, y);
+    };
+    Displayable.prototype.traverse = function (cb, context) {
+        cb.call(context, this);
+    };
+    Displayable.prototype.rectContain = function (x, y) {
+        var coord = this.transformCoordToLocal(x, y);
+        var rect = this.getBoundingRect();
+        return rect.contain(coord[0], coord[1]);
+    };
+    Displayable.prototype.getPaintRect = function () {
+        var rect = this._paintRect;
+        if (!this._paintRect || this.__dirty) {
+            var transform = this.transform;
+            var elRect = this.getBoundingRect();
+            var style = this.style;
+            var shadowSize = style.shadowBlur || 0;
+            var shadowOffsetX = style.shadowOffsetX || 0;
+            var shadowOffsetY = style.shadowOffsetY || 0;
+            rect = this._paintRect || (this._paintRect = new BoundingRect["default"](0, 0, 0, 0));
+            if (transform) {
+                BoundingRect["default"].applyTransform(rect, elRect, transform);
+            }
+            else {
+                rect.copy(elRect);
+            }
+            if (shadowSize || shadowOffsetX || shadowOffsetY) {
+                rect.width += shadowSize * 2 + Math.abs(shadowOffsetX);
+                rect.height += shadowSize * 2 + Math.abs(shadowOffsetY);
+                rect.x = Math.min(rect.x, rect.x + shadowOffsetX - shadowSize);
+                rect.y = Math.min(rect.y, rect.y + shadowOffsetY - shadowSize);
+            }
+            var tolerance = this.dirtyRectTolerance;
+            if (!rect.isZero()) {
+                rect.x = Math.floor(rect.x - tolerance);
+                rect.y = Math.floor(rect.y - tolerance);
+                rect.width = Math.ceil(rect.width + 1 + tolerance * 2);
+                rect.height = Math.ceil(rect.height + 1 + tolerance * 2);
+            }
+        }
+        return rect;
+    };
+    Displayable.prototype.setPrevPaintRect = function (paintRect) {
+        if (paintRect) {
+            this._prevPaintRect = this._prevPaintRect || new BoundingRect["default"](0, 0, 0, 0);
+            this._prevPaintRect.copy(paintRect);
+        }
+        else {
+            this._prevPaintRect = null;
+        }
+    };
+    Displayable.prototype.getPrevPaintRect = function () {
+        return this._prevPaintRect;
+    };
+    Displayable.prototype.animateStyle = function (loop) {
+        return this.animate('style', loop);
+    };
+    Displayable.prototype.updateDuringAnimation = function (targetKey) {
+        if (targetKey === 'style') {
+            this.dirtyStyle();
+        }
+        else {
+            this.markRedraw();
+        }
+    };
+    Displayable.prototype.attrKV = function (key, value) {
+        if (key !== 'style') {
+            _super.prototype.attrKV.call(this, key, value);
+        }
+        else {
+            if (!this.style) {
+                this.useStyle(value);
+            }
+            else {
+                this.setStyle(value);
+            }
+        }
+    };
+    Displayable.prototype.setStyle = function (keyOrObj, value) {
+        if (typeof keyOrObj === 'string') {
+            this.style[keyOrObj] = value;
+        }
+        else {
+            util.extend(this.style, keyOrObj);
+        }
+        this.dirtyStyle();
+        return this;
+    };
+    Displayable.prototype.dirtyStyle = function (notRedraw) {
+        if (!notRedraw) {
+            this.markRedraw();
+        }
+        this.__dirty |= constants.STYLE_CHANGED_BIT;
+        if (this._rect) {
+            this._rect = null;
+        }
+    };
+    Displayable.prototype.dirty = function () {
+        this.dirtyStyle();
+    };
+    Displayable.prototype.styleChanged = function () {
+        return !!(this.__dirty & constants.STYLE_CHANGED_BIT);
+    };
+    Displayable.prototype.styleUpdated = function () {
+        this.__dirty &= ~constants.STYLE_CHANGED_BIT;
+    };
+    Displayable.prototype.createStyle = function (obj) {
+        return util.createObject(DEFAULT_COMMON_STYLE, obj);
+    };
+    Displayable.prototype.useStyle = function (obj) {
+        if (!obj[STYLE_MAGIC_KEY]) {
+            obj = this.createStyle(obj);
+        }
+        if (this.__inHover) {
+            this.__hoverStyle = obj;
+        }
+        else {
+            this.style = obj;
+        }
+        this.dirtyStyle();
+    };
+    Displayable.prototype.isStyleObject = function (obj) {
+        return obj[STYLE_MAGIC_KEY];
+    };
+    Displayable.prototype._innerSaveToNormal = function (toState) {
+        _super.prototype._innerSaveToNormal.call(this, toState);
+        var normalState = this._normalState;
+        if (toState.style && !normalState.style) {
+            normalState.style = this._mergeStyle(this.createStyle(), this.style);
+        }
+        this._savePrimaryToNormal(toState, normalState, PRIMARY_STATES_KEYS);
+    };
+    Displayable.prototype._applyStateObj = function (stateName, state, normalState, keepCurrentStates, transition, animationCfg) {
+        _super.prototype._applyStateObj.call(this, stateName, state, normalState, keepCurrentStates, transition, animationCfg);
+        var needsRestoreToNormal = !(state && keepCurrentStates);
+        var targetStyle;
+        if (state && state.style) {
+            if (transition) {
+                if (keepCurrentStates) {
+                    targetStyle = state.style;
+                }
+                else {
+                    targetStyle = this._mergeStyle(this.createStyle(), normalState.style);
+                    this._mergeStyle(targetStyle, state.style);
+                }
+            }
+            else {
+                targetStyle = this._mergeStyle(this.createStyle(), keepCurrentStates ? this.style : normalState.style);
+                this._mergeStyle(targetStyle, state.style);
+            }
+        }
+        else if (needsRestoreToNormal) {
+            targetStyle = normalState.style;
+        }
+        if (targetStyle) {
+            if (transition) {
+                var sourceStyle = this.style;
+                this.style = this.createStyle(needsRestoreToNormal ? {} : sourceStyle);
+                if (needsRestoreToNormal) {
+                    var changedKeys = util.keys(sourceStyle);
+                    for (var i = 0; i < changedKeys.length; i++) {
+                        var key = changedKeys[i];
+                        if (key in targetStyle) {
+                            targetStyle[key] = targetStyle[key];
+                            this.style[key] = sourceStyle[key];
+                        }
+                    }
+                }
+                var targetKeys = util.keys(targetStyle);
+                for (var i = 0; i < targetKeys.length; i++) {
+                    var key = targetKeys[i];
+                    this.style[key] = this.style[key];
+                }
+                this._transitionState(stateName, {
+                    style: targetStyle
+                }, animationCfg, this.getAnimationStyleProps());
+            }
+            else {
+                this.useStyle(targetStyle);
+            }
+        }
+        var statesKeys = this.__inHover ? PRIMARY_STATES_KEYS_IN_HOVER_LAYER : PRIMARY_STATES_KEYS;
+        for (var i = 0; i < statesKeys.length; i++) {
+            var key = statesKeys[i];
+            if (state && state[key] != null) {
+                this[key] = state[key];
+            }
+            else if (needsRestoreToNormal) {
+                if (normalState[key] != null) {
+                    this[key] = normalState[key];
+                }
+            }
+        }
+    };
+    Displayable.prototype._mergeStates = function (states) {
+        var mergedState = _super.prototype._mergeStates.call(this, states);
+        var mergedStyle;
+        for (var i = 0; i < states.length; i++) {
+            var state = states[i];
+            if (state.style) {
+                mergedStyle = mergedStyle || {};
+                this._mergeStyle(mergedStyle, state.style);
+            }
+        }
+        if (mergedStyle) {
+            mergedState.style = mergedStyle;
+        }
+        return mergedState;
+    };
+    Displayable.prototype._mergeStyle = function (targetStyle, sourceStyle) {
+        util.extend(targetStyle, sourceStyle);
+        return targetStyle;
+    };
+    Displayable.prototype.getAnimationStyleProps = function () {
+        return DEFAULT_COMMON_ANIMATION_PROPS;
+    };
+    Displayable.initDefaultProps = (function () {
+        var dispProto = Displayable.prototype;
+        dispProto.type = 'displayable';
+        dispProto.invisible = false;
+        dispProto.z = 0;
+        dispProto.z2 = 0;
+        dispProto.zlevel = 0;
+        dispProto.culling = false;
+        dispProto.cursor = 'pointer';
+        dispProto.rectHover = false;
+        dispProto.incremental = false;
+        dispProto._rect = null;
+        dispProto.dirtyRectTolerance = 0;
+        dispProto.__dirty = constants.REDRAW_BIT | constants.STYLE_CHANGED_BIT;
+    })();
+    return Displayable;
+}(Element["default"]));
+var tmpRect = new BoundingRect["default"](0, 0, 0, 0);
+var viewRect = new BoundingRect["default"](0, 0, 0, 0);
+function isDisplayableCulled(el, width, height) {
+    tmpRect.copy(el.getBoundingRect());
+    if (el.transform) {
+        tmpRect.applyTransform(el.transform);
+    }
+    viewRect.width = width;
+    viewRect.height = height;
+    return !tmpRect.intersect(viewRect);
+}
+var Displayable$1 = Displayable;
+
+exports.DEFAULT_COMMON_ANIMATION_PROPS = DEFAULT_COMMON_ANIMATION_PROPS;
+exports.DEFAULT_COMMON_STYLE = DEFAULT_COMMON_STYLE;
+exports["default"] = Displayable$1;

package/lib/node_modules/zrender/lib/graphic/Gradient.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Gradient = (function () {
+    function Gradient(colorStops) {
+        this.colorStops = colorStops || [];
+    }
+    Gradient.prototype.addColorStop = function (offset, color) {
+        this.colorStops.push({
+            offset: offset,
+            color: color
+        });
+    };
+    return Gradient;
+}());
+var Gradient$1 = Gradient;
+
+exports["default"] = Gradient$1;

package/lib/node_modules/zrender/lib/graphic/Group.js

@@ -0,0 +1,186 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../core/util.js');
+var Element = require('../Element.js');
+var BoundingRect = require('../core/BoundingRect.js');
+
+var Group = (function (_super) {
+    tslib.__extends(Group, _super);
+    function Group(opts) {
+        var _this = _super.call(this) || this;
+        _this.isGroup = true;
+        _this._children = [];
+        _this.attr(opts);
+        return _this;
+    }
+    Group.prototype.childrenRef = function () {
+        return this._children;
+    };
+    Group.prototype.children = function () {
+        return this._children.slice();
+    };
+    Group.prototype.childAt = function (idx) {
+        return this._children[idx];
+    };
+    Group.prototype.childOfName = function (name) {
+        var children = this._children;
+        for (var i = 0; i < children.length; i++) {
+            if (children[i].name === name) {
+                return children[i];
+            }
+        }
+    };
+    Group.prototype.childCount = function () {
+        return this._children.length;
+    };
+    Group.prototype.add = function (child) {
+        if (child) {
+            if (child !== this && child.parent !== this) {
+                this._children.push(child);
+                this._doAdd(child);
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (child.__hostTarget) {
+                    throw 'This elemenet has been used as an attachment';
+                }
+            }
+        }
+        return this;
+    };
+    Group.prototype.addBefore = function (child, nextSibling) {
+        if (child && child !== this && child.parent !== this
+            && nextSibling && nextSibling.parent === this) {
+            var children = this._children;
+            var idx = children.indexOf(nextSibling);
+            if (idx >= 0) {
+                children.splice(idx, 0, child);
+                this._doAdd(child);
+            }
+        }
+        return this;
+    };
+    Group.prototype.replace = function (oldChild, newChild) {
+        var idx = util.indexOf(this._children, oldChild);
+        if (idx >= 0) {
+            this.replaceAt(newChild, idx);
+        }
+        return this;
+    };
+    Group.prototype.replaceAt = function (child, index) {
+        var children = this._children;
+        var old = children[index];
+        if (child && child !== this && child.parent !== this && child !== old) {
+            children[index] = child;
+            old.parent = null;
+            var zr = this.__zr;
+            if (zr) {
+                old.removeSelfFromZr(zr);
+            }
+            this._doAdd(child);
+        }
+        return this;
+    };
+    Group.prototype._doAdd = function (child) {
+        if (child.parent) {
+            child.parent.remove(child);
+        }
+        child.parent = this;
+        var zr = this.__zr;
+        if (zr && zr !== child.__zr) {
+            child.addSelfToZr(zr);
+        }
+        zr && zr.refresh();
+    };
+    Group.prototype.remove = function (child) {
+        var zr = this.__zr;
+        var children = this._children;
+        var idx = util.indexOf(children, child);
+        if (idx < 0) {
+            return this;
+        }
+        children.splice(idx, 1);
+        child.parent = null;
+        if (zr) {
+            child.removeSelfFromZr(zr);
+        }
+        zr && zr.refresh();
+        return this;
+    };
+    Group.prototype.removeAll = function () {
+        var children = this._children;
+        var zr = this.__zr;
+        for (var i = 0; i < children.length; i++) {
+            var child = children[i];
+            if (zr) {
+                child.removeSelfFromZr(zr);
+            }
+            child.parent = null;
+        }
+        children.length = 0;
+        return this;
+    };
+    Group.prototype.eachChild = function (cb, context) {
+        var children = this._children;
+        for (var i = 0; i < children.length; i++) {
+            var child = children[i];
+            cb.call(context, child, i);
+        }
+        return this;
+    };
+    Group.prototype.traverse = function (cb, context) {
+        for (var i = 0; i < this._children.length; i++) {
+            var child = this._children[i];
+            var stopped = cb.call(context, child);
+            if (child.isGroup && !stopped) {
+                child.traverse(cb, context);
+            }
+        }
+        return this;
+    };
+    Group.prototype.addSelfToZr = function (zr) {
+        _super.prototype.addSelfToZr.call(this, zr);
+        for (var i = 0; i < this._children.length; i++) {
+            var child = this._children[i];
+            child.addSelfToZr(zr);
+        }
+    };
+    Group.prototype.removeSelfFromZr = function (zr) {
+        _super.prototype.removeSelfFromZr.call(this, zr);
+        for (var i = 0; i < this._children.length; i++) {
+            var child = this._children[i];
+            child.removeSelfFromZr(zr);
+        }
+    };
+    Group.prototype.getBoundingRect = function (includeChildren) {
+        var tmpRect = new BoundingRect["default"](0, 0, 0, 0);
+        var children = includeChildren || this._children;
+        var tmpMat = [];
+        var rect = null;
+        for (var i = 0; i < children.length; i++) {
+            var child = children[i];
+            if (child.ignore || child.invisible) {
+                continue;
+            }
+            var childRect = child.getBoundingRect();
+            var transform = child.getLocalTransform(tmpMat);
+            if (transform) {
+                BoundingRect["default"].applyTransform(tmpRect, childRect, transform);
+                rect = rect || tmpRect.clone();
+                rect.union(tmpRect);
+            }
+            else {
+                rect = rect || childRect.clone();
+                rect.union(childRect);
+            }
+        }
+        return rect || tmpRect;
+    };
+    return Group;
+}(Element["default"]));
+Group.prototype.type = 'group';
+var Group$1 = Group;
+
+exports["default"] = Group$1;

package/lib/node_modules/zrender/lib/graphic/Image.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Displayable = require('./Displayable.js');
+var BoundingRect = require('../core/BoundingRect.js');
+var util = require('../core/util.js');
+
+var DEFAULT_IMAGE_STYLE = util.defaults({
+    x: 0,
+    y: 0
+}, Displayable.DEFAULT_COMMON_STYLE);
+var DEFAULT_IMAGE_ANIMATION_PROPS = {
+    style: util.defaults({
+        x: true,
+        y: true,
+        width: true,
+        height: true,
+        sx: true,
+        sy: true,
+        sWidth: true,
+        sHeight: true
+    }, Displayable.DEFAULT_COMMON_ANIMATION_PROPS.style)
+};
+function isImageLike(source) {
+    return !!(source
+        && typeof source !== 'string'
+        && source.width && source.height);
+}
+var ZRImage = (function (_super) {
+    tslib.__extends(ZRImage, _super);
+    function ZRImage() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ZRImage.prototype.createStyle = function (obj) {
+        return util.createObject(DEFAULT_IMAGE_STYLE, obj);
+    };
+    ZRImage.prototype._getSize = function (dim) {
+        var style = this.style;
+        var size = style[dim];
+        if (size != null) {
+            return size;
+        }
+        var imageSource = isImageLike(style.image)
+            ? style.image : this.__image;
+        if (!imageSource) {
+            return 0;
+        }
+        var otherDim = dim === 'width' ? 'height' : 'width';
+        var otherDimSize = style[otherDim];
+        if (otherDimSize == null) {
+            return imageSource[dim];
+        }
+        else {
+            return imageSource[dim] / imageSource[otherDim] * otherDimSize;
+        }
+    };
+    ZRImage.prototype.getWidth = function () {
+        return this._getSize('width');
+    };
+    ZRImage.prototype.getHeight = function () {
+        return this._getSize('height');
+    };
+    ZRImage.prototype.getAnimationStyleProps = function () {
+        return DEFAULT_IMAGE_ANIMATION_PROPS;
+    };
+    ZRImage.prototype.getBoundingRect = function () {
+        var style = this.style;
+        if (!this._rect) {
+            this._rect = new BoundingRect["default"](style.x || 0, style.y || 0, this.getWidth(), this.getHeight());
+        }
+        return this._rect;
+    };
+    return ZRImage;
+}(Displayable["default"]));
+ZRImage.prototype.type = 'image';
+var ZRImage$1 = ZRImage;
+
+exports.DEFAULT_IMAGE_ANIMATION_PROPS = DEFAULT_IMAGE_ANIMATION_PROPS;
+exports.DEFAULT_IMAGE_STYLE = DEFAULT_IMAGE_STYLE;
+exports["default"] = ZRImage$1;