office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/zrender/lib/animation/Clip.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var easing = require('./easing.js');
+var util = require('../core/util.js');
+var cubicEasing = require('./cubicEasing.js');
+
+var Clip = (function () {
+    function Clip(opts) {
+        this._inited = false;
+        this._startTime = 0;
+        this._pausedTime = 0;
+        this._paused = false;
+        this._life = opts.life || 1000;
+        this._delay = opts.delay || 0;
+        this.loop = opts.loop || false;
+        this.onframe = opts.onframe || util.noop;
+        this.ondestroy = opts.ondestroy || util.noop;
+        this.onrestart = opts.onrestart || util.noop;
+        opts.easing && this.setEasing(opts.easing);
+    }
+    Clip.prototype.step = function (globalTime, deltaTime) {
+        if (!this._inited) {
+            this._startTime = globalTime + this._delay;
+            this._inited = true;
+        }
+        if (this._paused) {
+            this._pausedTime += deltaTime;
+            return;
+        }
+        var life = this._life;
+        var elapsedTime = globalTime - this._startTime - this._pausedTime;
+        var percent = elapsedTime / life;
+        if (percent < 0) {
+            percent = 0;
+        }
+        percent = Math.min(percent, 1);
+        var easingFunc = this.easingFunc;
+        var schedule = easingFunc ? easingFunc(percent) : percent;
+        this.onframe(schedule);
+        if (percent === 1) {
+            if (this.loop) {
+                var remainder = elapsedTime % life;
+                this._startTime = globalTime - remainder;
+                this._pausedTime = 0;
+                this.onrestart();
+            }
+            else {
+                return true;
+            }
+        }
+        return false;
+    };
+    Clip.prototype.pause = function () {
+        this._paused = true;
+    };
+    Clip.prototype.resume = function () {
+        this._paused = false;
+    };
+    Clip.prototype.setEasing = function (easing$1) {
+        this.easing = easing$1;
+        this.easingFunc = util.isFunction(easing$1)
+            ? easing$1
+            : easing["default"][easing$1] || cubicEasing.createCubicEasingFunc(easing$1);
+    };
+    return Clip;
+}());
+var Clip$1 = Clip;
+
+exports["default"] = Clip$1;

package/lib/node_modules/zrender/lib/animation/cubicEasing.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var curve = require('../core/curve.js');
+var util = require('../core/util.js');
+
+var regexp = /cubic-bezier\(([0-9,\.e ]+)\)/;
+function createCubicEasingFunc(cubicEasingStr) {
+    var cubic = cubicEasingStr && regexp.exec(cubicEasingStr);
+    if (cubic) {
+        var points = cubic[1].split(',');
+        var a_1 = +util.trim(points[0]);
+        var b_1 = +util.trim(points[1]);
+        var c_1 = +util.trim(points[2]);
+        var d_1 = +util.trim(points[3]);
+        if (isNaN(a_1 + b_1 + c_1 + d_1)) {
+            return;
+        }
+        var roots_1 = [];
+        return function (p) {
+            return p <= 0
+                ? 0 : p >= 1
+                ? 1
+                : curve.cubicRootAt(0, a_1, c_1, 1, p, roots_1) && curve.cubicAt(0, b_1, d_1, 1, roots_1[0]);
+        };
+    }
+}
+
+exports.createCubicEasingFunc = createCubicEasingFunc;

package/lib/node_modules/zrender/lib/animation/easing.js

@@ -0,0 +1,201 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var easingFuncs = {
+    linear: function (k) {
+        return k;
+    },
+    quadraticIn: function (k) {
+        return k * k;
+    },
+    quadraticOut: function (k) {
+        return k * (2 - k);
+    },
+    quadraticInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return 0.5 * k * k;
+        }
+        return -0.5 * (--k * (k - 2) - 1);
+    },
+    cubicIn: function (k) {
+        return k * k * k;
+    },
+    cubicOut: function (k) {
+        return --k * k * k + 1;
+    },
+    cubicInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return 0.5 * k * k * k;
+        }
+        return 0.5 * ((k -= 2) * k * k + 2);
+    },
+    quarticIn: function (k) {
+        return k * k * k * k;
+    },
+    quarticOut: function (k) {
+        return 1 - (--k * k * k * k);
+    },
+    quarticInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return 0.5 * k * k * k * k;
+        }
+        return -0.5 * ((k -= 2) * k * k * k - 2);
+    },
+    quinticIn: function (k) {
+        return k * k * k * k * k;
+    },
+    quinticOut: function (k) {
+        return --k * k * k * k * k + 1;
+    },
+    quinticInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return 0.5 * k * k * k * k * k;
+        }
+        return 0.5 * ((k -= 2) * k * k * k * k + 2);
+    },
+    sinusoidalIn: function (k) {
+        return 1 - Math.cos(k * Math.PI / 2);
+    },
+    sinusoidalOut: function (k) {
+        return Math.sin(k * Math.PI / 2);
+    },
+    sinusoidalInOut: function (k) {
+        return 0.5 * (1 - Math.cos(Math.PI * k));
+    },
+    exponentialIn: function (k) {
+        return k === 0 ? 0 : Math.pow(1024, k - 1);
+    },
+    exponentialOut: function (k) {
+        return k === 1 ? 1 : 1 - Math.pow(2, -10 * k);
+    },
+    exponentialInOut: function (k) {
+        if (k === 0) {
+            return 0;
+        }
+        if (k === 1) {
+            return 1;
+        }
+        if ((k *= 2) < 1) {
+            return 0.5 * Math.pow(1024, k - 1);
+        }
+        return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2);
+    },
+    circularIn: function (k) {
+        return 1 - Math.sqrt(1 - k * k);
+    },
+    circularOut: function (k) {
+        return Math.sqrt(1 - (--k * k));
+    },
+    circularInOut: function (k) {
+        if ((k *= 2) < 1) {
+            return -0.5 * (Math.sqrt(1 - k * k) - 1);
+        }
+        return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1);
+    },
+    elasticIn: function (k) {
+        var s;
+        var a = 0.1;
+        var p = 0.4;
+        if (k === 0) {
+            return 0;
+        }
+        if (k === 1) {
+            return 1;
+        }
+        if (!a || a < 1) {
+            a = 1;
+            s = p / 4;
+        }
+        else {
+            s = p * Math.asin(1 / a) / (2 * Math.PI);
+        }
+        return -(a * Math.pow(2, 10 * (k -= 1))
+            * Math.sin((k - s) * (2 * Math.PI) / p));
+    },
+    elasticOut: function (k) {
+        var s;
+        var a = 0.1;
+        var p = 0.4;
+        if (k === 0) {
+            return 0;
+        }
+        if (k === 1) {
+            return 1;
+        }
+        if (!a || a < 1) {
+            a = 1;
+            s = p / 4;
+        }
+        else {
+            s = p * Math.asin(1 / a) / (2 * Math.PI);
+        }
+        return (a * Math.pow(2, -10 * k)
+            * Math.sin((k - s) * (2 * Math.PI) / p) + 1);
+    },
+    elasticInOut: function (k) {
+        var s;
+        var a = 0.1;
+        var p = 0.4;
+        if (k === 0) {
+            return 0;
+        }
+        if (k === 1) {
+            return 1;
+        }
+        if (!a || a < 1) {
+            a = 1;
+            s = p / 4;
+        }
+        else {
+            s = p * Math.asin(1 / a) / (2 * Math.PI);
+        }
+        if ((k *= 2) < 1) {
+            return -0.5 * (a * Math.pow(2, 10 * (k -= 1))
+                * Math.sin((k - s) * (2 * Math.PI) / p));
+        }
+        return a * Math.pow(2, -10 * (k -= 1))
+            * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1;
+    },
+    backIn: function (k) {
+        var s = 1.70158;
+        return k * k * ((s + 1) * k - s);
+    },
+    backOut: function (k) {
+        var s = 1.70158;
+        return --k * k * ((s + 1) * k + s) + 1;
+    },
+    backInOut: function (k) {
+        var s = 1.70158 * 1.525;
+        if ((k *= 2) < 1) {
+            return 0.5 * (k * k * ((s + 1) * k - s));
+        }
+        return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);
+    },
+    bounceIn: function (k) {
+        return 1 - easingFuncs.bounceOut(1 - k);
+    },
+    bounceOut: function (k) {
+        if (k < (1 / 2.75)) {
+            return 7.5625 * k * k;
+        }
+        else if (k < (2 / 2.75)) {
+            return 7.5625 * (k -= (1.5 / 2.75)) * k + 0.75;
+        }
+        else if (k < (2.5 / 2.75)) {
+            return 7.5625 * (k -= (2.25 / 2.75)) * k + 0.9375;
+        }
+        else {
+            return 7.5625 * (k -= (2.625 / 2.75)) * k + 0.984375;
+        }
+    },
+    bounceInOut: function (k) {
+        if (k < 0.5) {
+            return easingFuncs.bounceIn(k * 2) * 0.5;
+        }
+        return easingFuncs.bounceOut(k * 2 - 1) * 0.5 + 0.5;
+    }
+};
+var easingFuncs$1 = easingFuncs;
+
+exports["default"] = easingFuncs$1;

package/lib/node_modules/zrender/lib/animation/requestAnimationFrame.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var env = require('../core/env.js');
+
+var requestAnimationFrame;
+requestAnimationFrame = (env["default"].hasGlobalWindow
+    && ((window.requestAnimationFrame && window.requestAnimationFrame.bind(window))
+        || (window.msRequestAnimationFrame && window.msRequestAnimationFrame.bind(window))
+        || window.mozRequestAnimationFrame
+        || window.webkitRequestAnimationFrame)) || function (func) {
+    return setTimeout(func, 16);
+};
+var requestAnimationFrame$1 = requestAnimationFrame;
+
+exports["default"] = requestAnimationFrame$1;

package/lib/node_modules/zrender/lib/canvas/Layer.js

@@ -0,0 +1,302 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var util = require('../core/util.js');
+var config = require('../config.js');
+var Eventful = require('../core/Eventful.js');
+var helper = require('./helper.js');
+var graphic = require('./graphic.js');
+var BoundingRect = require('../core/BoundingRect.js');
+var constants = require('../graphic/constants.js');
+var platform = require('../core/platform.js');
+
+function createDom(id, painter, dpr) {
+    var newDom = platform.platformApi.createCanvas();
+    var width = painter.getWidth();
+    var height = painter.getHeight();
+    var newDomStyle = newDom.style;
+    if (newDomStyle) {
+        newDomStyle.position = 'absolute';
+        newDomStyle.left = '0';
+        newDomStyle.top = '0';
+        newDomStyle.width = width + 'px';
+        newDomStyle.height = height + 'px';
+        newDom.setAttribute('data-zr-dom-id', id);
+    }
+    newDom.width = width * dpr;
+    newDom.height = height * dpr;
+    return newDom;
+}
+var Layer = (function (_super) {
+    tslib.__extends(Layer, _super);
+    function Layer(id, painter, dpr) {
+        var _this = _super.call(this) || this;
+        _this.motionBlur = false;
+        _this.lastFrameAlpha = 0.7;
+        _this.dpr = 1;
+        _this.virtual = false;
+        _this.config = {};
+        _this.incremental = false;
+        _this.zlevel = 0;
+        _this.maxRepaintRectCount = 5;
+        _this.__dirty = true;
+        _this.__firstTimePaint = true;
+        _this.__used = false;
+        _this.__drawIndex = 0;
+        _this.__startIndex = 0;
+        _this.__endIndex = 0;
+        _this.__prevStartIndex = null;
+        _this.__prevEndIndex = null;
+        var dom;
+        dpr = dpr || config.devicePixelRatio;
+        if (typeof id === 'string') {
+            dom = createDom(id, painter, dpr);
+        }
+        else if (util.isObject(id)) {
+            dom = id;
+            id = dom.id;
+        }
+        _this.id = id;
+        _this.dom = dom;
+        var domStyle = dom.style;
+        if (domStyle) {
+            util.disableUserSelect(dom);
+            dom.onselectstart = function () { return false; };
+            domStyle.padding = '0';
+            domStyle.margin = '0';
+            domStyle.borderWidth = '0';
+        }
+        _this.painter = painter;
+        _this.dpr = dpr;
+        return _this;
+    }
+    Layer.prototype.getElementCount = function () {
+        return this.__endIndex - this.__startIndex;
+    };
+    Layer.prototype.afterBrush = function () {
+        this.__prevStartIndex = this.__startIndex;
+        this.__prevEndIndex = this.__endIndex;
+    };
+    Layer.prototype.initContext = function () {
+        this.ctx = this.dom.getContext('2d');
+        this.ctx.dpr = this.dpr;
+    };
+    Layer.prototype.setUnpainted = function () {
+        this.__firstTimePaint = true;
+    };
+    Layer.prototype.createBackBuffer = function () {
+        var dpr = this.dpr;
+        this.domBack = createDom('back-' + this.id, this.painter, dpr);
+        this.ctxBack = this.domBack.getContext('2d');
+        if (dpr !== 1) {
+            this.ctxBack.scale(dpr, dpr);
+        }
+    };
+    Layer.prototype.createRepaintRects = function (displayList, prevList, viewWidth, viewHeight) {
+        if (this.__firstTimePaint) {
+            this.__firstTimePaint = false;
+            return null;
+        }
+        var mergedRepaintRects = [];
+        var maxRepaintRectCount = this.maxRepaintRectCount;
+        var full = false;
+        var pendingRect = new BoundingRect["default"](0, 0, 0, 0);
+        function addRectToMergePool(rect) {
+            if (!rect.isFinite() || rect.isZero()) {
+                return;
+            }
+            if (mergedRepaintRects.length === 0) {
+                var boundingRect = new BoundingRect["default"](0, 0, 0, 0);
+                boundingRect.copy(rect);
+                mergedRepaintRects.push(boundingRect);
+            }
+            else {
+                var isMerged = false;
+                var minDeltaArea = Infinity;
+                var bestRectToMergeIdx = 0;
+                for (var i = 0; i < mergedRepaintRects.length; ++i) {
+                    var mergedRect = mergedRepaintRects[i];
+                    if (mergedRect.intersect(rect)) {
+                        var pendingRect_1 = new BoundingRect["default"](0, 0, 0, 0);
+                        pendingRect_1.copy(mergedRect);
+                        pendingRect_1.union(rect);
+                        mergedRepaintRects[i] = pendingRect_1;
+                        isMerged = true;
+                        break;
+                    }
+                    else if (full) {
+                        pendingRect.copy(rect);
+                        pendingRect.union(mergedRect);
+                        var aArea = rect.width * rect.height;
+                        var bArea = mergedRect.width * mergedRect.height;
+                        var pendingArea = pendingRect.width * pendingRect.height;
+                        var deltaArea = pendingArea - aArea - bArea;
+                        if (deltaArea < minDeltaArea) {
+                            minDeltaArea = deltaArea;
+                            bestRectToMergeIdx = i;
+                        }
+                    }
+                }
+                if (full) {
+                    mergedRepaintRects[bestRectToMergeIdx].union(rect);
+                    isMerged = true;
+                }
+                if (!isMerged) {
+                    var boundingRect = new BoundingRect["default"](0, 0, 0, 0);
+                    boundingRect.copy(rect);
+                    mergedRepaintRects.push(boundingRect);
+                }
+                if (!full) {
+                    full = mergedRepaintRects.length >= maxRepaintRectCount;
+                }
+            }
+        }
+        for (var i = this.__startIndex; i < this.__endIndex; ++i) {
+            var el = displayList[i];
+            if (el) {
+                var shouldPaint = el.shouldBePainted(viewWidth, viewHeight, true, true);
+                var prevRect = el.__isRendered && ((el.__dirty & constants.REDRAW_BIT) || !shouldPaint)
+                    ? el.getPrevPaintRect()
+                    : null;
+                if (prevRect) {
+                    addRectToMergePool(prevRect);
+                }
+                var curRect = shouldPaint && ((el.__dirty & constants.REDRAW_BIT) || !el.__isRendered)
+                    ? el.getPaintRect()
+                    : null;
+                if (curRect) {
+                    addRectToMergePool(curRect);
+                }
+            }
+        }
+        for (var i = this.__prevStartIndex; i < this.__prevEndIndex; ++i) {
+            var el = prevList[i];
+            var shouldPaint = el && el.shouldBePainted(viewWidth, viewHeight, true, true);
+            if (el && (!shouldPaint || !el.__zr) && el.__isRendered) {
+                var prevRect = el.getPrevPaintRect();
+                if (prevRect) {
+                    addRectToMergePool(prevRect);
+                }
+            }
+        }
+        var hasIntersections;
+        do {
+            hasIntersections = false;
+            for (var i = 0; i < mergedRepaintRects.length;) {
+                if (mergedRepaintRects[i].isZero()) {
+                    mergedRepaintRects.splice(i, 1);
+                    continue;
+                }
+                for (var j = i + 1; j < mergedRepaintRects.length;) {
+                    if (mergedRepaintRects[i].intersect(mergedRepaintRects[j])) {
+                        hasIntersections = true;
+                        mergedRepaintRects[i].union(mergedRepaintRects[j]);
+                        mergedRepaintRects.splice(j, 1);
+                    }
+                    else {
+                        j++;
+                    }
+                }
+                i++;
+            }
+        } while (hasIntersections);
+        this._paintRects = mergedRepaintRects;
+        return mergedRepaintRects;
+    };
+    Layer.prototype.debugGetPaintRects = function () {
+        return (this._paintRects || []).slice();
+    };
+    Layer.prototype.resize = function (width, height) {
+        var dpr = this.dpr;
+        var dom = this.dom;
+        var domStyle = dom.style;
+        var domBack = this.domBack;
+        if (domStyle) {
+            domStyle.width = width + 'px';
+            domStyle.height = height + 'px';
+        }
+        dom.width = width * dpr;
+        dom.height = height * dpr;
+        if (domBack) {
+            domBack.width = width * dpr;
+            domBack.height = height * dpr;
+            if (dpr !== 1) {
+                this.ctxBack.scale(dpr, dpr);
+            }
+        }
+    };
+    Layer.prototype.clear = function (clearAll, clearColor, repaintRects) {
+        var dom = this.dom;
+        var ctx = this.ctx;
+        var width = dom.width;
+        var height = dom.height;
+        clearColor = clearColor || this.clearColor;
+        var haveMotionBLur = this.motionBlur && !clearAll;
+        var lastFrameAlpha = this.lastFrameAlpha;
+        var dpr = this.dpr;
+        var self = this;
+        if (haveMotionBLur) {
+            if (!this.domBack) {
+                this.createBackBuffer();
+            }
+            this.ctxBack.globalCompositeOperation = 'copy';
+            this.ctxBack.drawImage(dom, 0, 0, width / dpr, height / dpr);
+        }
+        var domBack = this.domBack;
+        function doClear(x, y, width, height) {
+            ctx.clearRect(x, y, width, height);
+            if (clearColor && clearColor !== 'transparent') {
+                var clearColorGradientOrPattern = void 0;
+                if (util.isGradientObject(clearColor)) {
+                    var shouldCache = clearColor.global || (clearColor.__width === width
+                        && clearColor.__height === height);
+                    clearColorGradientOrPattern = shouldCache
+                        && clearColor.__canvasGradient
+                        || helper.getCanvasGradient(ctx, clearColor, {
+                            x: 0,
+                            y: 0,
+                            width: width,
+                            height: height
+                        });
+                    clearColor.__canvasGradient = clearColorGradientOrPattern;
+                    clearColor.__width = width;
+                    clearColor.__height = height;
+                }
+                else if (util.isImagePatternObject(clearColor)) {
+                    clearColor.scaleX = clearColor.scaleX || dpr;
+                    clearColor.scaleY = clearColor.scaleY || dpr;
+                    clearColorGradientOrPattern = graphic.createCanvasPattern(ctx, clearColor, {
+                        dirty: function () {
+                            self.setUnpainted();
+                            self.painter.refresh();
+                        }
+                    });
+                }
+                ctx.save();
+                ctx.fillStyle = clearColorGradientOrPattern || clearColor;
+                ctx.fillRect(x, y, width, height);
+                ctx.restore();
+            }
+            if (haveMotionBLur) {
+                ctx.save();
+                ctx.globalAlpha = lastFrameAlpha;
+                ctx.drawImage(domBack, x, y, width, height);
+                ctx.restore();
+            }
+        }
+        if (!repaintRects || haveMotionBLur) {
+            doClear(0, 0, width, height);
+        }
+        else if (repaintRects.length) {
+            util.each(repaintRects, function (rect) {
+                doClear(rect.x * dpr, rect.y * dpr, rect.width * dpr, rect.height * dpr);
+            });
+        }
+    };
+    return Layer;
+}(Eventful["default"]));
+var Layer$1 = Layer;
+
+exports["default"] = Layer$1;