office-viewer 0.3.11 → 0.3.13

package/lib/node_modules/zrender/lib/svg/core.js

@@ -0,0 +1,123 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../core/util.js');
+var dom = require('../core/dom.js');
+
+var SVGNS = 'http://www.w3.org/2000/svg';
+var XLINKNS = 'http://www.w3.org/1999/xlink';
+var XMLNS = 'http://www.w3.org/2000/xmlns/';
+var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+var META_DATA_PREFIX = 'ecmeta_';
+function createElement(name) {
+    return document.createElementNS(SVGNS, name);
+}
+function createVNode(tag, key, attrs, children, text) {
+    return {
+        tag: tag,
+        attrs: attrs || {},
+        children: children,
+        text: text,
+        key: key
+    };
+}
+function createElementOpen(name, attrs) {
+    var attrsStr = [];
+    if (attrs) {
+        for (var key in attrs) {
+            var val = attrs[key];
+            var part = key;
+            if (val === false) {
+                continue;
+            }
+            else if (val !== true && val != null) {
+                part += "=\"" + val + "\"";
+            }
+            attrsStr.push(part);
+        }
+    }
+    return "<" + name + " " + attrsStr.join(' ') + ">";
+}
+function createElementClose(name) {
+    return "</" + name + ">";
+}
+function vNodeToString(el, opts) {
+    opts = opts || {};
+    var S = opts.newline ? '\n' : '';
+    function convertElToString(el) {
+        var children = el.children, tag = el.tag, attrs = el.attrs, text = el.text;
+        return createElementOpen(tag, attrs)
+            + (tag !== 'style' ? dom.encodeHTML(text) : text || '')
+            + (children ? "" + S + util.map(children, function (child) { return convertElToString(child); }).join(S) + S : '')
+            + createElementClose(tag);
+    }
+    return convertElToString(el);
+}
+function getCssString(selectorNodes, animationNodes, opts) {
+    opts = opts || {};
+    var S = opts.newline ? '\n' : '';
+    var bracketBegin = " {" + S;
+    var bracketEnd = S + "}";
+    var selectors = util.map(util.keys(selectorNodes), function (className) {
+        return className + bracketBegin + util.map(util.keys(selectorNodes[className]), function (attrName) {
+            return attrName + ":" + selectorNodes[className][attrName] + ";";
+        }).join(S) + bracketEnd;
+    }).join(S);
+    var animations = util.map(util.keys(animationNodes), function (animationName) {
+        return "@keyframes " + animationName + bracketBegin + util.map(util.keys(animationNodes[animationName]), function (percent) {
+            return percent + bracketBegin + util.map(util.keys(animationNodes[animationName][percent]), function (attrName) {
+                var val = animationNodes[animationName][percent][attrName];
+                if (attrName === 'd') {
+                    val = "path(\"" + val + "\")";
+                }
+                return attrName + ":" + val + ";";
+            }).join(S) + bracketEnd;
+        }).join(S) + bracketEnd;
+    }).join(S);
+    if (!selectors && !animations) {
+        return '';
+    }
+    return ['<![CDATA[', selectors, animations, ']]>'].join(S);
+}
+function createBrushScope(zrId) {
+    return {
+        zrId: zrId,
+        shadowCache: {},
+        patternCache: {},
+        gradientCache: {},
+        clipPathCache: {},
+        defs: {},
+        cssNodes: {},
+        cssAnims: {},
+        cssStyleCache: {},
+        cssAnimIdx: 0,
+        shadowIdx: 0,
+        gradientIdx: 0,
+        patternIdx: 0,
+        clipPathIdx: 0
+    };
+}
+function createSVGVNode(width, height, children, useViewBox) {
+    return createVNode('svg', 'root', {
+        'width': width,
+        'height': height,
+        'xmlns': SVGNS,
+        'xmlns:xlink': XLINKNS,
+        'version': '1.1',
+        'baseProfile': 'full',
+        'viewBox': useViewBox ? "0 0 " + width + " " + height : false
+    }, children);
+}
+
+exports.META_DATA_PREFIX = META_DATA_PREFIX;
+exports.SVGNS = SVGNS;
+exports.XLINKNS = XLINKNS;
+exports.XMLNS = XMLNS;
+exports.XML_NAMESPACE = XML_NAMESPACE;
+exports.createBrushScope = createBrushScope;
+exports.createElement = createElement;
+exports.createSVGVNode = createSVGVNode;
+exports.createVNode = createVNode;
+exports.getCssString = getCssString;
+exports.vNodeToString = vNodeToString;

package/lib/node_modules/zrender/lib/svg/cssAnimation.js

@@ -0,0 +1,283 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Transformable = require('../core/Transformable.js');
+var core = require('./core.js');
+var SVGPathRebuilder = require('./SVGPathRebuilder.js');
+var PathProxy = require('../core/PathProxy.js');
+var helper = require('./helper.js');
+var util = require('../core/util.js');
+var CompoundPath = require('../graphic/CompoundPath.js');
+var cubicEasing = require('../animation/cubicEasing.js');
+var cssClassId = require('./cssClassId.js');
+
+var EASING_MAP = {
+    cubicIn: '0.32,0,0.67,0',
+    cubicOut: '0.33,1,0.68,1',
+    cubicInOut: '0.65,0,0.35,1',
+    quadraticIn: '0.11,0,0.5,0',
+    quadraticOut: '0.5,1,0.89,1',
+    quadraticInOut: '0.45,0,0.55,1',
+    quarticIn: '0.5,0,0.75,0',
+    quarticOut: '0.25,1,0.5,1',
+    quarticInOut: '0.76,0,0.24,1',
+    quinticIn: '0.64,0,0.78,0',
+    quinticOut: '0.22,1,0.36,1',
+    quinticInOut: '0.83,0,0.17,1',
+    sinusoidalIn: '0.12,0,0.39,0',
+    sinusoidalOut: '0.61,1,0.88,1',
+    sinusoidalInOut: '0.37,0,0.63,1',
+    exponentialIn: '0.7,0,0.84,0',
+    exponentialOut: '0.16,1,0.3,1',
+    exponentialInOut: '0.87,0,0.13,1',
+    circularIn: '0.55,0,1,0.45',
+    circularOut: '0,0.55,0.45,1',
+    circularInOut: '0.85,0,0.15,1'
+};
+var transformOriginKey = 'transform-origin';
+function buildPathString(el, kfShape, path) {
+    var shape = util.extend({}, el.shape);
+    util.extend(shape, kfShape);
+    el.buildPath(path, shape);
+    var svgPathBuilder = new SVGPathRebuilder["default"]();
+    svgPathBuilder.reset(helper.getPathPrecision(el));
+    path.rebuildPath(svgPathBuilder, 1);
+    svgPathBuilder.generateStr();
+    return svgPathBuilder.getStr();
+}
+function setTransformOrigin(target, transform) {
+    var originX = transform.originX, originY = transform.originY;
+    if (originX || originY) {
+        target[transformOriginKey] = originX + "px " + originY + "px";
+    }
+}
+var ANIMATE_STYLE_MAP = {
+    fill: 'fill',
+    opacity: 'opacity',
+    lineWidth: 'stroke-width',
+    lineDashOffset: 'stroke-dashoffset'
+};
+function addAnimation(cssAnim, scope) {
+    var animationName = scope.zrId + '-ani-' + scope.cssAnimIdx++;
+    scope.cssAnims[animationName] = cssAnim;
+    return animationName;
+}
+function createCompoundPathCSSAnimation(el, attrs, scope) {
+    var paths = el.shape.paths;
+    var composedAnim = {};
+    var cssAnimationCfg;
+    var cssAnimationName;
+    util.each(paths, function (path) {
+        var subScope = core.createBrushScope(scope.zrId);
+        subScope.animation = true;
+        createCSSAnimation(path, {}, subScope, true);
+        var cssAnims = subScope.cssAnims;
+        var cssNodes = subScope.cssNodes;
+        var animNames = util.keys(cssAnims);
+        var len = animNames.length;
+        if (!len) {
+            return;
+        }
+        cssAnimationName = animNames[len - 1];
+        var lastAnim = cssAnims[cssAnimationName];
+        for (var percent in lastAnim) {
+            var kf = lastAnim[percent];
+            composedAnim[percent] = composedAnim[percent] || { d: '' };
+            composedAnim[percent].d += kf.d || '';
+        }
+        for (var className in cssNodes) {
+            var val = cssNodes[className].animation;
+            if (val.indexOf(cssAnimationName) >= 0) {
+                cssAnimationCfg = val;
+            }
+        }
+    });
+    if (!cssAnimationCfg) {
+        return;
+    }
+    attrs.d = false;
+    var animationName = addAnimation(composedAnim, scope);
+    return cssAnimationCfg.replace(cssAnimationName, animationName);
+}
+function getEasingFunc(easing) {
+    return util.isString(easing)
+        ? EASING_MAP[easing]
+            ? "cubic-bezier(" + EASING_MAP[easing] + ")"
+            : cubicEasing.createCubicEasingFunc(easing) ? easing : ''
+        : '';
+}
+function createCSSAnimation(el, attrs, scope, onlyShape) {
+    var animators = el.animators;
+    var len = animators.length;
+    var cssAnimations = [];
+    if (el instanceof CompoundPath["default"]) {
+        var animationCfg = createCompoundPathCSSAnimation(el, attrs, scope);
+        if (animationCfg) {
+            cssAnimations.push(animationCfg);
+        }
+        else if (!len) {
+            return;
+        }
+    }
+    else if (!len) {
+        return;
+    }
+    var groupAnimators = {};
+    for (var i = 0; i < len; i++) {
+        var animator = animators[i];
+        var cfgArr = [animator.getMaxTime() / 1000 + 's'];
+        var easing = getEasingFunc(animator.getClip().easing);
+        var delay = animator.getDelay();
+        if (easing) {
+            cfgArr.push(easing);
+        }
+        else {
+            cfgArr.push('linear');
+        }
+        if (delay) {
+            cfgArr.push(delay / 1000 + 's');
+        }
+        if (animator.getLoop()) {
+            cfgArr.push('infinite');
+        }
+        var cfg = cfgArr.join(' ');
+        groupAnimators[cfg] = groupAnimators[cfg] || [cfg, []];
+        groupAnimators[cfg][1].push(animator);
+    }
+    function createSingleCSSAnimation(groupAnimator) {
+        var animators = groupAnimator[1];
+        var len = animators.length;
+        var transformKfs = {};
+        var shapeKfs = {};
+        var finalKfs = {};
+        var animationTimingFunctionAttrName = 'animation-timing-function';
+        function saveAnimatorTrackToCssKfs(animator, cssKfs, toCssAttrName) {
+            var tracks = animator.getTracks();
+            var maxTime = animator.getMaxTime();
+            for (var k = 0; k < tracks.length; k++) {
+                var track = tracks[k];
+                if (track.needsAnimate()) {
+                    var kfs = track.keyframes;
+                    var attrName = track.propName;
+                    toCssAttrName && (attrName = toCssAttrName(attrName));
+                    if (attrName) {
+                        for (var i = 0; i < kfs.length; i++) {
+                            var kf = kfs[i];
+                            var percent = Math.round(kf.time / maxTime * 100) + '%';
+                            var kfEasing = getEasingFunc(kf.easing);
+                            var rawValue = kf.rawValue;
+                            if (util.isString(rawValue) || util.isNumber(rawValue)) {
+                                cssKfs[percent] = cssKfs[percent] || {};
+                                cssKfs[percent][attrName] = kf.rawValue;
+                                if (kfEasing) {
+                                    cssKfs[percent][animationTimingFunctionAttrName] = kfEasing;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        for (var i = 0; i < len; i++) {
+            var animator = animators[i];
+            var targetProp = animator.targetName;
+            if (!targetProp) {
+                !onlyShape && saveAnimatorTrackToCssKfs(animator, transformKfs);
+            }
+            else if (targetProp === 'shape') {
+                saveAnimatorTrackToCssKfs(animator, shapeKfs);
+            }
+        }
+        for (var percent in transformKfs) {
+            var transform = {};
+            Transformable.copyTransform(transform, el);
+            util.extend(transform, transformKfs[percent]);
+            var str = helper.getSRTTransformString(transform);
+            var timingFunction = transformKfs[percent][animationTimingFunctionAttrName];
+            finalKfs[percent] = str ? {
+                transform: str
+            } : {};
+            setTransformOrigin(finalKfs[percent], transform);
+            if (timingFunction) {
+                finalKfs[percent][animationTimingFunctionAttrName] = timingFunction;
+            }
+        }
+        var path;
+        var canAnimateShape = true;
+        for (var percent in shapeKfs) {
+            finalKfs[percent] = finalKfs[percent] || {};
+            var isFirst = !path;
+            var timingFunction = shapeKfs[percent][animationTimingFunctionAttrName];
+            if (isFirst) {
+                path = new PathProxy["default"]();
+            }
+            var len_1 = path.len();
+            path.reset();
+            finalKfs[percent].d = buildPathString(el, shapeKfs[percent], path);
+            var newLen = path.len();
+            if (!isFirst && len_1 !== newLen) {
+                canAnimateShape = false;
+                break;
+            }
+            if (timingFunction) {
+                finalKfs[percent][animationTimingFunctionAttrName] = timingFunction;
+            }
+        }
+        if (!canAnimateShape) {
+            for (var percent in finalKfs) {
+                delete finalKfs[percent].d;
+            }
+        }
+        if (!onlyShape) {
+            for (var i = 0; i < len; i++) {
+                var animator = animators[i];
+                var targetProp = animator.targetName;
+                if (targetProp === 'style') {
+                    saveAnimatorTrackToCssKfs(animator, finalKfs, function (propName) { return ANIMATE_STYLE_MAP[propName]; });
+                }
+            }
+        }
+        var percents = util.keys(finalKfs);
+        var allTransformOriginSame = true;
+        var transformOrigin;
+        for (var i = 1; i < percents.length; i++) {
+            var p0 = percents[i - 1];
+            var p1 = percents[i];
+            if (finalKfs[p0][transformOriginKey] !== finalKfs[p1][transformOriginKey]) {
+                allTransformOriginSame = false;
+                break;
+            }
+            transformOrigin = finalKfs[p0][transformOriginKey];
+        }
+        if (allTransformOriginSame && transformOrigin) {
+            for (var percent in finalKfs) {
+                if (finalKfs[percent][transformOriginKey]) {
+                    delete finalKfs[percent][transformOriginKey];
+                }
+            }
+            attrs[transformOriginKey] = transformOrigin;
+        }
+        if (util.filter(percents, function (percent) { return util.keys(finalKfs[percent]).length > 0; }).length) {
+            var animationName = addAnimation(finalKfs, scope);
+            return animationName + " " + groupAnimator[0] + " both";
+        }
+    }
+    for (var key in groupAnimators) {
+        var animationCfg = createSingleCSSAnimation(groupAnimators[key]);
+        if (animationCfg) {
+            cssAnimations.push(animationCfg);
+        }
+    }
+    if (cssAnimations.length) {
+        var className = scope.zrId + '-cls-' + cssClassId.getClassId();
+        scope.cssNodes['.' + className] = {
+            animation: cssAnimations.join(',')
+        };
+        attrs["class"] = className;
+    }
+}
+
+exports.ANIMATE_STYLE_MAP = ANIMATE_STYLE_MAP;
+exports.EASING_MAP = EASING_MAP;
+exports.createCSSAnimation = createCSSAnimation;

package/lib/node_modules/zrender/lib/svg/cssClassId.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cssClassIdx = 0;
+function getClassId() {
+    return cssClassIdx++;
+}
+
+exports.getClassId = getClassId;

package/lib/node_modules/zrender/lib/svg/cssEmphasis.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var color = require('../tool/color.js');
+var cssClassId = require('./cssClassId.js');
+
+function createCSSEmphasis(el, attrs, scope) {
+    if (!el.ignore) {
+        if (el.isSilent()) {
+            var style = {
+                'pointer-events': 'none'
+            };
+            setClassAttribute(style, attrs, scope, true);
+        }
+        else {
+            var emphasisStyle = el.states.emphasis && el.states.emphasis.style
+                ? el.states.emphasis.style
+                : {};
+            var fill = emphasisStyle.fill;
+            if (!fill) {
+                var normalFill = el.style && el.style.fill;
+                var selectFill = el.states.select
+                    && el.states.select.style
+                    && el.states.select.style.fill;
+                var fromFill = el.currentStates.indexOf('select') >= 0
+                    ? (selectFill || normalFill)
+                    : normalFill;
+                if (fromFill) {
+                    fill = color.liftColor(fromFill);
+                }
+            }
+            var lineWidth = emphasisStyle.lineWidth;
+            if (lineWidth) {
+                var scaleX = (!emphasisStyle.strokeNoScale && el.transform)
+                    ? el.transform[0]
+                    : 1;
+                lineWidth = lineWidth / scaleX;
+            }
+            var style = {
+                cursor: 'pointer'
+            };
+            if (fill) {
+                style.fill = fill;
+            }
+            if (emphasisStyle.stroke) {
+                style.stroke = emphasisStyle.stroke;
+            }
+            if (lineWidth) {
+                style['stroke-width'] = lineWidth;
+            }
+            setClassAttribute(style, attrs, scope, true);
+        }
+    }
+}
+function setClassAttribute(style, attrs, scope, withHover) {
+    var styleKey = JSON.stringify(style);
+    var className = scope.cssStyleCache[styleKey];
+    if (!className) {
+        className = scope.zrId + '-cls-' + cssClassId.getClassId();
+        scope.cssStyleCache[styleKey] = className;
+        scope.cssNodes['.' + className + (withHover ? ':hover' : '')] = style;
+    }
+    attrs["class"] = attrs["class"] ? (attrs["class"] + ' ' + className) : className;
+}
+
+exports.createCSSEmphasis = createCSSEmphasis;

package/lib/node_modules/zrender/lib/svg/domapi.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function createTextNode(text) {
+    return document.createTextNode(text);
+}
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
+}
+function removeChild(node, child) {
+    node.removeChild(child);
+}
+function appendChild(node, child) {
+    node.appendChild(child);
+}
+function parentNode(node) {
+    return node.parentNode;
+}
+function nextSibling(node) {
+    return node.nextSibling;
+}
+function setTextContent(node, text) {
+    node.textContent = text;
+}
+
+exports.appendChild = appendChild;
+exports.createTextNode = createTextNode;
+exports.insertBefore = insertBefore;
+exports.nextSibling = nextSibling;
+exports.parentNode = parentNode;
+exports.removeChild = removeChild;
+exports.setTextContent = setTextContent;