office-viewer 0.3.11 → 0.3.13

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

@@ -0,0 +1,119 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Displayable = require('./Displayable.js');
+var BoundingRect = require('../core/BoundingRect.js');
+
+var m = [];
+var IncrementalDisplayable = (function (_super) {
+    tslib.__extends(IncrementalDisplayable, _super);
+    function IncrementalDisplayable() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.notClear = true;
+        _this.incremental = true;
+        _this._displayables = [];
+        _this._temporaryDisplayables = [];
+        _this._cursor = 0;
+        return _this;
+    }
+    IncrementalDisplayable.prototype.traverse = function (cb, context) {
+        cb.call(context, this);
+    };
+    IncrementalDisplayable.prototype.useStyle = function () {
+        this.style = {};
+    };
+    IncrementalDisplayable.prototype.getCursor = function () {
+        return this._cursor;
+    };
+    IncrementalDisplayable.prototype.innerAfterBrush = function () {
+        this._cursor = this._displayables.length;
+    };
+    IncrementalDisplayable.prototype.clearDisplaybles = function () {
+        this._displayables = [];
+        this._temporaryDisplayables = [];
+        this._cursor = 0;
+        this.markRedraw();
+        this.notClear = false;
+    };
+    IncrementalDisplayable.prototype.clearTemporalDisplayables = function () {
+        this._temporaryDisplayables = [];
+    };
+    IncrementalDisplayable.prototype.addDisplayable = function (displayable, notPersistent) {
+        if (notPersistent) {
+            this._temporaryDisplayables.push(displayable);
+        }
+        else {
+            this._displayables.push(displayable);
+        }
+        this.markRedraw();
+    };
+    IncrementalDisplayable.prototype.addDisplayables = function (displayables, notPersistent) {
+        notPersistent = notPersistent || false;
+        for (var i = 0; i < displayables.length; i++) {
+            this.addDisplayable(displayables[i], notPersistent);
+        }
+    };
+    IncrementalDisplayable.prototype.getDisplayables = function () {
+        return this._displayables;
+    };
+    IncrementalDisplayable.prototype.getTemporalDisplayables = function () {
+        return this._temporaryDisplayables;
+    };
+    IncrementalDisplayable.prototype.eachPendingDisplayable = function (cb) {
+        for (var i = this._cursor; i < this._displayables.length; i++) {
+            cb && cb(this._displayables[i]);
+        }
+        for (var i = 0; i < this._temporaryDisplayables.length; i++) {
+            cb && cb(this._temporaryDisplayables[i]);
+        }
+    };
+    IncrementalDisplayable.prototype.update = function () {
+        this.updateTransform();
+        for (var i = this._cursor; i < this._displayables.length; i++) {
+            var displayable = this._displayables[i];
+            displayable.parent = this;
+            displayable.update();
+            displayable.parent = null;
+        }
+        for (var i = 0; i < this._temporaryDisplayables.length; i++) {
+            var displayable = this._temporaryDisplayables[i];
+            displayable.parent = this;
+            displayable.update();
+            displayable.parent = null;
+        }
+    };
+    IncrementalDisplayable.prototype.getBoundingRect = function () {
+        if (!this._rect) {
+            var rect = new BoundingRect["default"](Infinity, Infinity, -Infinity, -Infinity);
+            for (var i = 0; i < this._displayables.length; i++) {
+                var displayable = this._displayables[i];
+                var childRect = displayable.getBoundingRect().clone();
+                if (displayable.needLocalTransform()) {
+                    childRect.applyTransform(displayable.getLocalTransform(m));
+                }
+                rect.union(childRect);
+            }
+            this._rect = rect;
+        }
+        return this._rect;
+    };
+    IncrementalDisplayable.prototype.contain = function (x, y) {
+        var localPos = this.transformCoordToLocal(x, y);
+        var rect = this.getBoundingRect();
+        if (rect.contain(localPos[0], localPos[1])) {
+            for (var i = 0; i < this._displayables.length; i++) {
+                var displayable = this._displayables[i];
+                if (displayable.contain(x, y)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    return IncrementalDisplayable;
+}(Displayable["default"]));
+var IncrementalDisplayable$1 = IncrementalDisplayable;
+
+exports["default"] = IncrementalDisplayable$1;

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

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Gradient = require('./Gradient.js');
+
+var LinearGradient = (function (_super) {
+    tslib.__extends(LinearGradient, _super);
+    function LinearGradient(x, y, x2, y2, colorStops, globalCoord) {
+        var _this = _super.call(this, colorStops) || this;
+        _this.x = x == null ? 0 : x;
+        _this.y = y == null ? 0 : y;
+        _this.x2 = x2 == null ? 1 : x2;
+        _this.y2 = y2 == null ? 0 : y2;
+        _this.type = 'linear';
+        _this.global = globalCoord || false;
+        return _this;
+    }
+    return LinearGradient;
+}(Gradient["default"]));
+var LinearGradient$1 = LinearGradient;
+
+exports["default"] = LinearGradient$1;

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

@@ -0,0 +1,407 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Displayable = require('./Displayable.js');
+var PathProxy = require('../core/PathProxy.js');
+var path = require('../contain/path.js');
+var util = require('../core/util.js');
+var color = require('../tool/color.js');
+var config = require('../config.js');
+var constants = require('./constants.js');
+var Transformable = require('../core/Transformable.js');
+
+var DEFAULT_PATH_STYLE = util.defaults({
+    fill: '#000',
+    stroke: null,
+    strokePercent: 1,
+    fillOpacity: 1,
+    strokeOpacity: 1,
+    lineDashOffset: 0,
+    lineWidth: 1,
+    lineCap: 'butt',
+    miterLimit: 10,
+    strokeNoScale: false,
+    strokeFirst: false
+}, Displayable.DEFAULT_COMMON_STYLE);
+var DEFAULT_PATH_ANIMATION_PROPS = {
+    style: util.defaults({
+        fill: true,
+        stroke: true,
+        strokePercent: true,
+        fillOpacity: true,
+        strokeOpacity: true,
+        lineDashOffset: true,
+        lineWidth: true,
+        miterLimit: true
+    }, Displayable.DEFAULT_COMMON_ANIMATION_PROPS.style)
+};
+var pathCopyParams = Transformable.TRANSFORMABLE_PROPS.concat(['invisible',
+    'culling', 'z', 'z2', 'zlevel', 'parent'
+]);
+var Path = (function (_super) {
+    tslib.__extends(Path, _super);
+    function Path(opts) {
+        return _super.call(this, opts) || this;
+    }
+    Path.prototype.update = function () {
+        var _this = this;
+        _super.prototype.update.call(this);
+        var style = this.style;
+        if (style.decal) {
+            var decalEl = this._decalEl = this._decalEl || new Path();
+            if (decalEl.buildPath === Path.prototype.buildPath) {
+                decalEl.buildPath = function (ctx) {
+                    _this.buildPath(ctx, _this.shape);
+                };
+            }
+            decalEl.silent = true;
+            var decalElStyle = decalEl.style;
+            for (var key in style) {
+                if (decalElStyle[key] !== style[key]) {
+                    decalElStyle[key] = style[key];
+                }
+            }
+            decalElStyle.fill = style.fill ? style.decal : null;
+            decalElStyle.decal = null;
+            decalElStyle.shadowColor = null;
+            style.strokeFirst && (decalElStyle.stroke = null);
+            for (var i = 0; i < pathCopyParams.length; ++i) {
+                decalEl[pathCopyParams[i]] = this[pathCopyParams[i]];
+            }
+            decalEl.__dirty |= constants.REDRAW_BIT;
+        }
+        else if (this._decalEl) {
+            this._decalEl = null;
+        }
+    };
+    Path.prototype.getDecalElement = function () {
+        return this._decalEl;
+    };
+    Path.prototype._init = function (props) {
+        var keysArr = util.keys(props);
+        this.shape = this.getDefaultShape();
+        var defaultStyle = this.getDefaultStyle();
+        if (defaultStyle) {
+            this.useStyle(defaultStyle);
+        }
+        for (var i = 0; i < keysArr.length; i++) {
+            var key = keysArr[i];
+            var value = props[key];
+            if (key === 'style') {
+                if (!this.style) {
+                    this.useStyle(value);
+                }
+                else {
+                    util.extend(this.style, value);
+                }
+            }
+            else if (key === 'shape') {
+                util.extend(this.shape, value);
+            }
+            else {
+                _super.prototype.attrKV.call(this, key, value);
+            }
+        }
+        if (!this.style) {
+            this.useStyle({});
+        }
+    };
+    Path.prototype.getDefaultStyle = function () {
+        return null;
+    };
+    Path.prototype.getDefaultShape = function () {
+        return {};
+    };
+    Path.prototype.canBeInsideText = function () {
+        return this.hasFill();
+    };
+    Path.prototype.getInsideTextFill = function () {
+        var pathFill = this.style.fill;
+        if (pathFill !== 'none') {
+            if (util.isString(pathFill)) {
+                var fillLum = color.lum(pathFill, 0);
+                if (fillLum > 0.5) {
+                    return config.DARK_LABEL_COLOR;
+                }
+                else if (fillLum > 0.2) {
+                    return config.LIGHTER_LABEL_COLOR;
+                }
+                return config.LIGHT_LABEL_COLOR;
+            }
+            else if (pathFill) {
+                return config.LIGHT_LABEL_COLOR;
+            }
+        }
+        return config.DARK_LABEL_COLOR;
+    };
+    Path.prototype.getInsideTextStroke = function (textFill) {
+        var pathFill = this.style.fill;
+        if (util.isString(pathFill)) {
+            var zr = this.__zr;
+            var isDarkMode = !!(zr && zr.isDarkMode());
+            var isDarkLabel = color.lum(textFill, 0) < config.DARK_MODE_THRESHOLD;
+            if (isDarkMode === isDarkLabel) {
+                return pathFill;
+            }
+        }
+    };
+    Path.prototype.buildPath = function (ctx, shapeCfg, inBatch) { };
+    Path.prototype.pathUpdated = function () {
+        this.__dirty &= ~constants.SHAPE_CHANGED_BIT;
+    };
+    Path.prototype.getUpdatedPathProxy = function (inBatch) {
+        !this.path && this.createPathProxy();
+        this.path.beginPath();
+        this.buildPath(this.path, this.shape, inBatch);
+        return this.path;
+    };
+    Path.prototype.createPathProxy = function () {
+        this.path = new PathProxy["default"](false);
+    };
+    Path.prototype.hasStroke = function () {
+        var style = this.style;
+        var stroke = style.stroke;
+        return !(stroke == null || stroke === 'none' || !(style.lineWidth > 0));
+    };
+    Path.prototype.hasFill = function () {
+        var style = this.style;
+        var fill = style.fill;
+        return fill != null && fill !== 'none';
+    };
+    Path.prototype.getBoundingRect = function () {
+        var rect = this._rect;
+        var style = this.style;
+        var needsUpdateRect = !rect;
+        if (needsUpdateRect) {
+            var firstInvoke = false;
+            if (!this.path) {
+                firstInvoke = true;
+                this.createPathProxy();
+            }
+            var path = this.path;
+            if (firstInvoke || (this.__dirty & constants.SHAPE_CHANGED_BIT)) {
+                path.beginPath();
+                this.buildPath(path, this.shape, false);
+                this.pathUpdated();
+            }
+            rect = path.getBoundingRect();
+        }
+        this._rect = rect;
+        if (this.hasStroke() && this.path && this.path.len() > 0) {
+            var rectStroke = this._rectStroke || (this._rectStroke = rect.clone());
+            if (this.__dirty || needsUpdateRect) {
+                rectStroke.copy(rect);
+                var lineScale = style.strokeNoScale ? this.getLineScale() : 1;
+                var w = style.lineWidth;
+                if (!this.hasFill()) {
+                    var strokeContainThreshold = this.strokeContainThreshold;
+                    w = Math.max(w, strokeContainThreshold == null ? 4 : strokeContainThreshold);
+                }
+                if (lineScale > 1e-10) {
+                    rectStroke.width += w / lineScale;
+                    rectStroke.height += w / lineScale;
+                    rectStroke.x -= w / lineScale / 2;
+                    rectStroke.y -= w / lineScale / 2;
+                }
+            }
+            return rectStroke;
+        }
+        return rect;
+    };
+    Path.prototype.contain = function (x, y) {
+        var localPos = this.transformCoordToLocal(x, y);
+        var rect = this.getBoundingRect();
+        var style = this.style;
+        x = localPos[0];
+        y = localPos[1];
+        if (rect.contain(x, y)) {
+            var pathProxy = this.path;
+            if (this.hasStroke()) {
+                var lineWidth = style.lineWidth;
+                var lineScale = style.strokeNoScale ? this.getLineScale() : 1;
+                if (lineScale > 1e-10) {
+                    if (!this.hasFill()) {
+                        lineWidth = Math.max(lineWidth, this.strokeContainThreshold);
+                    }
+                    if (path.containStroke(pathProxy, lineWidth / lineScale, x, y)) {
+                        return true;
+                    }
+                }
+            }
+            if (this.hasFill()) {
+                return path.contain(pathProxy, x, y);
+            }
+        }
+        return false;
+    };
+    Path.prototype.dirtyShape = function () {
+        this.__dirty |= constants.SHAPE_CHANGED_BIT;
+        if (this._rect) {
+            this._rect = null;
+        }
+        if (this._decalEl) {
+            this._decalEl.dirtyShape();
+        }
+        this.markRedraw();
+    };
+    Path.prototype.dirty = function () {
+        this.dirtyStyle();
+        this.dirtyShape();
+    };
+    Path.prototype.animateShape = function (loop) {
+        return this.animate('shape', loop);
+    };
+    Path.prototype.updateDuringAnimation = function (targetKey) {
+        if (targetKey === 'style') {
+            this.dirtyStyle();
+        }
+        else if (targetKey === 'shape') {
+            this.dirtyShape();
+        }
+        else {
+            this.markRedraw();
+        }
+    };
+    Path.prototype.attrKV = function (key, value) {
+        if (key === 'shape') {
+            this.setShape(value);
+        }
+        else {
+            _super.prototype.attrKV.call(this, key, value);
+        }
+    };
+    Path.prototype.setShape = function (keyOrObj, value) {
+        var shape = this.shape;
+        if (!shape) {
+            shape = this.shape = {};
+        }
+        if (typeof keyOrObj === 'string') {
+            shape[keyOrObj] = value;
+        }
+        else {
+            util.extend(shape, keyOrObj);
+        }
+        this.dirtyShape();
+        return this;
+    };
+    Path.prototype.shapeChanged = function () {
+        return !!(this.__dirty & constants.SHAPE_CHANGED_BIT);
+    };
+    Path.prototype.createStyle = function (obj) {
+        return util.createObject(DEFAULT_PATH_STYLE, obj);
+    };
+    Path.prototype._innerSaveToNormal = function (toState) {
+        _super.prototype._innerSaveToNormal.call(this, toState);
+        var normalState = this._normalState;
+        if (toState.shape && !normalState.shape) {
+            normalState.shape = util.extend({}, this.shape);
+        }
+    };
+    Path.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 targetShape;
+        if (state && state.shape) {
+            if (transition) {
+                if (keepCurrentStates) {
+                    targetShape = state.shape;
+                }
+                else {
+                    targetShape = util.extend({}, normalState.shape);
+                    util.extend(targetShape, state.shape);
+                }
+            }
+            else {
+                targetShape = util.extend({}, keepCurrentStates ? this.shape : normalState.shape);
+                util.extend(targetShape, state.shape);
+            }
+        }
+        else if (needsRestoreToNormal) {
+            targetShape = normalState.shape;
+        }
+        if (targetShape) {
+            if (transition) {
+                this.shape = util.extend({}, this.shape);
+                var targetShapePrimaryProps = {};
+                var shapeKeys = util.keys(targetShape);
+                for (var i = 0; i < shapeKeys.length; i++) {
+                    var key = shapeKeys[i];
+                    if (typeof targetShape[key] === 'object') {
+                        this.shape[key] = targetShape[key];
+                    }
+                    else {
+                        targetShapePrimaryProps[key] = targetShape[key];
+                    }
+                }
+                this._transitionState(stateName, {
+                    shape: targetShapePrimaryProps
+                }, animationCfg);
+            }
+            else {
+                this.shape = targetShape;
+                this.dirtyShape();
+            }
+        }
+    };
+    Path.prototype._mergeStates = function (states) {
+        var mergedState = _super.prototype._mergeStates.call(this, states);
+        var mergedShape;
+        for (var i = 0; i < states.length; i++) {
+            var state = states[i];
+            if (state.shape) {
+                mergedShape = mergedShape || {};
+                this._mergeStyle(mergedShape, state.shape);
+            }
+        }
+        if (mergedShape) {
+            mergedState.shape = mergedShape;
+        }
+        return mergedState;
+    };
+    Path.prototype.getAnimationStyleProps = function () {
+        return DEFAULT_PATH_ANIMATION_PROPS;
+    };
+    Path.prototype.isZeroArea = function () {
+        return false;
+    };
+    Path.extend = function (defaultProps) {
+        var Sub = (function (_super) {
+            tslib.__extends(Sub, _super);
+            function Sub(opts) {
+                var _this = _super.call(this, opts) || this;
+                defaultProps.init && defaultProps.init.call(_this, opts);
+                return _this;
+            }
+            Sub.prototype.getDefaultStyle = function () {
+                return util.clone(defaultProps.style);
+            };
+            Sub.prototype.getDefaultShape = function () {
+                return util.clone(defaultProps.shape);
+            };
+            return Sub;
+        }(Path));
+        for (var key in defaultProps) {
+            if (typeof defaultProps[key] === 'function') {
+                Sub.prototype[key] = defaultProps[key];
+            }
+        }
+        return Sub;
+    };
+    Path.initDefaultProps = (function () {
+        var pathProto = Path.prototype;
+        pathProto.type = 'path';
+        pathProto.strokeContainThreshold = 5;
+        pathProto.segmentIgnoreThreshold = 0;
+        pathProto.subPixelOptimize = false;
+        pathProto.autoBatch = false;
+        pathProto.__dirty = constants.REDRAW_BIT | constants.STYLE_CHANGED_BIT | constants.SHAPE_CHANGED_BIT;
+    })();
+    return Path;
+}(Displayable["default"]));
+var Path$1 = Path;
+
+exports.DEFAULT_PATH_ANIMATION_PROPS = DEFAULT_PATH_ANIMATION_PROPS;
+exports.DEFAULT_PATH_STYLE = DEFAULT_PATH_STYLE;
+exports["default"] = Path$1;

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

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Gradient = require('./Gradient.js');
+
+var RadialGradient = (function (_super) {
+    tslib.__extends(RadialGradient, _super);
+    function RadialGradient(x, y, r, colorStops, globalCoord) {
+        var _this = _super.call(this, colorStops) || this;
+        _this.x = x == null ? 0.5 : x;
+        _this.y = y == null ? 0.5 : y;
+        _this.r = r == null ? 0.5 : r;
+        _this.type = 'radial';
+        _this.global = globalCoord || false;
+        return _this;
+    }
+    return RadialGradient;
+}(Gradient["default"]));
+var RadialGradient$1 = RadialGradient;
+
+exports["default"] = RadialGradient$1;

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

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var Displayable = require('./Displayable.js');
+var text = require('../contain/text.js');
+var Path = require('./Path.js');
+var util = require('../core/util.js');
+var platform = require('../core/platform.js');
+
+var DEFAULT_TSPAN_STYLE = util.defaults({
+    strokeFirst: true,
+    font: platform.DEFAULT_FONT,
+    x: 0,
+    y: 0,
+    textAlign: 'left',
+    textBaseline: 'top',
+    miterLimit: 2
+}, Path.DEFAULT_PATH_STYLE);
+var TSpan = (function (_super) {
+    tslib.__extends(TSpan, _super);
+    function TSpan() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TSpan.prototype.hasStroke = function () {
+        var style = this.style;
+        var stroke = style.stroke;
+        return stroke != null && stroke !== 'none' && style.lineWidth > 0;
+    };
+    TSpan.prototype.hasFill = function () {
+        var style = this.style;
+        var fill = style.fill;
+        return fill != null && fill !== 'none';
+    };
+    TSpan.prototype.createStyle = function (obj) {
+        return util.createObject(DEFAULT_TSPAN_STYLE, obj);
+    };
+    TSpan.prototype.setBoundingRect = function (rect) {
+        this._rect = rect;
+    };
+    TSpan.prototype.getBoundingRect = function () {
+        var style = this.style;
+        if (!this._rect) {
+            var text$1 = style.text;
+            text$1 != null ? (text$1 += '') : (text$1 = '');
+            var rect = text.getBoundingRect(text$1, style.font, style.textAlign, style.textBaseline);
+            rect.x += style.x || 0;
+            rect.y += style.y || 0;
+            if (this.hasStroke()) {
+                var w = style.lineWidth;
+                rect.x -= w / 2;
+                rect.y -= w / 2;
+                rect.width += w;
+                rect.height += w;
+            }
+            this._rect = rect;
+        }
+        return this._rect;
+    };
+    TSpan.initDefaultProps = (function () {
+        var tspanProto = TSpan.prototype;
+        tspanProto.dirtyRectTolerance = 10;
+    })();
+    return TSpan;
+}(Displayable["default"]));
+TSpan.prototype.type = 'tspan';
+var TSpan$1 = TSpan;
+
+exports.DEFAULT_TSPAN_STYLE = DEFAULT_TSPAN_STYLE;
+exports["default"] = TSpan$1;