office-viewer 0.3.11 → 0.3.13

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

@@ -0,0 +1,492 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helper = require('./helper.js');
+var Path = require('../graphic/Path.js');
+var Image$1 = require('../graphic/Image.js');
+var text = require('../contain/text.js');
+var TSpan = require('../graphic/TSpan.js');
+var SVGPathRebuilder = require('./SVGPathRebuilder.js');
+var mapStyleToAttrs = require('./mapStyleToAttrs.js');
+var core = require('./core.js');
+var util = require('../core/util.js');
+var image = require('../graphic/helper/image.js');
+var cssAnimation = require('./cssAnimation.js');
+var Text = require('../graphic/Text.js');
+var platform = require('../core/platform.js');
+var cssEmphasis = require('./cssEmphasis.js');
+var zrender = require('../zrender.js');
+
+var round = Math.round;
+function isImageLike(val) {
+    return val && util.isString(val.src);
+}
+function isCanvasLike(val) {
+    return val && util.isFunction(val.toDataURL);
+}
+function setStyleAttrs(attrs, style, el, scope) {
+    mapStyleToAttrs["default"](function (key, val) {
+        var isFillStroke = key === 'fill' || key === 'stroke';
+        if (isFillStroke && helper.isGradient(val)) {
+            setGradient(style, attrs, key, scope);
+        }
+        else if (isFillStroke && helper.isPattern(val)) {
+            setPattern(el, attrs, key, scope);
+        }
+        else if (isFillStroke && val === 'none') {
+            attrs[key] = 'transparent';
+        }
+        else {
+            attrs[key] = val;
+        }
+    }, style, el, false);
+    setShadow(el, attrs, scope);
+}
+function setMetaData(attrs, el) {
+    var metaData = zrender.getElementSSRData(el);
+    if (metaData) {
+        metaData.each(function (val, key) {
+            val != null && (attrs[(core.META_DATA_PREFIX + key).toLowerCase()] = val + '');
+        });
+        if (el.isSilent()) {
+            attrs[core.META_DATA_PREFIX + 'silent'] = 'true';
+        }
+    }
+}
+function noRotateScale(m) {
+    return helper.isAroundZero(m[0] - 1)
+        && helper.isAroundZero(m[1])
+        && helper.isAroundZero(m[2])
+        && helper.isAroundZero(m[3] - 1);
+}
+function noTranslate(m) {
+    return helper.isAroundZero(m[4]) && helper.isAroundZero(m[5]);
+}
+function setTransform(attrs, m, compress) {
+    if (m && !(noTranslate(m) && noRotateScale(m))) {
+        var mul = compress ? 10 : 1e4;
+        attrs.transform = noRotateScale(m)
+            ? "translate(" + round(m[4] * mul) / mul + " " + round(m[5] * mul) / mul + ")" : helper.getMatrixStr(m);
+    }
+}
+function convertPolyShape(shape, attrs, mul) {
+    var points = shape.points;
+    var strArr = [];
+    for (var i = 0; i < points.length; i++) {
+        strArr.push(round(points[i][0] * mul) / mul);
+        strArr.push(round(points[i][1] * mul) / mul);
+    }
+    attrs.points = strArr.join(' ');
+}
+function validatePolyShape(shape) {
+    return !shape.smooth;
+}
+function createAttrsConvert(desc) {
+    var normalizedDesc = util.map(desc, function (item) {
+        return (typeof item === 'string' ? [item, item] : item);
+    });
+    return function (shape, attrs, mul) {
+        for (var i = 0; i < normalizedDesc.length; i++) {
+            var item = normalizedDesc[i];
+            var val = shape[item[0]];
+            if (val != null) {
+                attrs[item[1]] = round(val * mul) / mul;
+            }
+        }
+    };
+}
+var builtinShapesDef = {
+    circle: [createAttrsConvert(['cx', 'cy', 'r'])],
+    polyline: [convertPolyShape, validatePolyShape],
+    polygon: [convertPolyShape, validatePolyShape]
+};
+function hasShapeAnimation(el) {
+    var animators = el.animators;
+    for (var i = 0; i < animators.length; i++) {
+        if (animators[i].targetName === 'shape') {
+            return true;
+        }
+    }
+    return false;
+}
+function brushSVGPath(el, scope) {
+    var style = el.style;
+    var shape = el.shape;
+    var builtinShpDef = builtinShapesDef[el.type];
+    var attrs = {};
+    var needsAnimate = scope.animation;
+    var svgElType = 'path';
+    var strokePercent = el.style.strokePercent;
+    var precision = (scope.compress && helper.getPathPrecision(el)) || 4;
+    if (builtinShpDef
+        && !scope.willUpdate
+        && !(builtinShpDef[1] && !builtinShpDef[1](shape))
+        && !(needsAnimate && hasShapeAnimation(el))
+        && !(strokePercent < 1)) {
+        svgElType = el.type;
+        var mul = Math.pow(10, precision);
+        builtinShpDef[0](shape, attrs, mul);
+    }
+    else {
+        var needBuildPath = !el.path || el.shapeChanged();
+        if (!el.path) {
+            el.createPathProxy();
+        }
+        var path = el.path;
+        if (needBuildPath) {
+            path.beginPath();
+            el.buildPath(path, el.shape);
+            el.pathUpdated();
+        }
+        var pathVersion = path.getVersion();
+        var elExt = el;
+        var svgPathBuilder = elExt.__svgPathBuilder;
+        if (elExt.__svgPathVersion !== pathVersion
+            || !svgPathBuilder
+            || strokePercent !== elExt.__svgPathStrokePercent) {
+            if (!svgPathBuilder) {
+                svgPathBuilder = elExt.__svgPathBuilder = new SVGPathRebuilder["default"]();
+            }
+            svgPathBuilder.reset(precision);
+            path.rebuildPath(svgPathBuilder, strokePercent);
+            svgPathBuilder.generateStr();
+            elExt.__svgPathVersion = pathVersion;
+            elExt.__svgPathStrokePercent = strokePercent;
+        }
+        attrs.d = svgPathBuilder.getStr();
+    }
+    setTransform(attrs, el.transform);
+    setStyleAttrs(attrs, style, el, scope);
+    setMetaData(attrs, el);
+    scope.animation && cssAnimation.createCSSAnimation(el, attrs, scope);
+    scope.emphasis && cssEmphasis.createCSSEmphasis(el, attrs, scope);
+    return core.createVNode(svgElType, el.id + '', attrs);
+}
+function brushSVGImage(el, scope) {
+    var style = el.style;
+    var image = style.image;
+    if (image && !util.isString(image)) {
+        if (isImageLike(image)) {
+            image = image.src;
+        }
+        else if (isCanvasLike(image)) {
+            image = image.toDataURL();
+        }
+    }
+    if (!image) {
+        return;
+    }
+    var x = style.x || 0;
+    var y = style.y || 0;
+    var dw = style.width;
+    var dh = style.height;
+    var attrs = {
+        href: image,
+        width: dw,
+        height: dh
+    };
+    if (x) {
+        attrs.x = x;
+    }
+    if (y) {
+        attrs.y = y;
+    }
+    setTransform(attrs, el.transform);
+    setStyleAttrs(attrs, style, el, scope);
+    setMetaData(attrs, el);
+    scope.animation && cssAnimation.createCSSAnimation(el, attrs, scope);
+    return core.createVNode('image', el.id + '', attrs);
+}
+function brushSVGTSpan(el, scope) {
+    var style = el.style;
+    var text$1 = style.text;
+    text$1 != null && (text$1 += '');
+    if (!text$1 || isNaN(style.x) || isNaN(style.y)) {
+        return;
+    }
+    var font = style.font || platform.DEFAULT_FONT;
+    var x = style.x || 0;
+    var y = helper.adjustTextY(style.y || 0, text.getLineHeight(font), style.textBaseline);
+    var textAlign = helper.TEXT_ALIGN_TO_ANCHOR[style.textAlign]
+        || style.textAlign;
+    var attrs = {
+        'dominant-baseline': 'central',
+        'text-anchor': textAlign
+    };
+    if (Text.hasSeparateFont(style)) {
+        var separatedFontStr = '';
+        var fontStyle = style.fontStyle;
+        var fontSize = Text.parseFontSize(style.fontSize);
+        if (!parseFloat(fontSize)) {
+            return;
+        }
+        var fontFamily = style.fontFamily || platform.DEFAULT_FONT_FAMILY;
+        var fontWeight = style.fontWeight;
+        separatedFontStr += "font-size:" + fontSize + ";font-family:" + fontFamily + ";";
+        if (fontStyle && fontStyle !== 'normal') {
+            separatedFontStr += "font-style:" + fontStyle + ";";
+        }
+        if (fontWeight && fontWeight !== 'normal') {
+            separatedFontStr += "font-weight:" + fontWeight + ";";
+        }
+        attrs.style = separatedFontStr;
+    }
+    else {
+        attrs.style = "font: " + font;
+    }
+    if (text$1.match(/\s/)) {
+        attrs['xml:space'] = 'preserve';
+    }
+    if (x) {
+        attrs.x = x;
+    }
+    if (y) {
+        attrs.y = y;
+    }
+    setTransform(attrs, el.transform);
+    setStyleAttrs(attrs, style, el, scope);
+    setMetaData(attrs, el);
+    scope.animation && cssAnimation.createCSSAnimation(el, attrs, scope);
+    return core.createVNode('text', el.id + '', attrs, undefined, text$1);
+}
+function brush(el, scope) {
+    if (el instanceof Path["default"]) {
+        return brushSVGPath(el, scope);
+    }
+    else if (el instanceof Image$1["default"]) {
+        return brushSVGImage(el, scope);
+    }
+    else if (el instanceof TSpan["default"]) {
+        return brushSVGTSpan(el, scope);
+    }
+}
+function setShadow(el, attrs, scope) {
+    var style = el.style;
+    if (helper.hasShadow(style)) {
+        var shadowKey = helper.getShadowKey(el);
+        var shadowCache = scope.shadowCache;
+        var shadowId = shadowCache[shadowKey];
+        if (!shadowId) {
+            var globalScale = el.getGlobalScale();
+            var scaleX = globalScale[0];
+            var scaleY = globalScale[1];
+            if (!scaleX || !scaleY) {
+                return;
+            }
+            var offsetX = style.shadowOffsetX || 0;
+            var offsetY = style.shadowOffsetY || 0;
+            var blur_1 = style.shadowBlur;
+            var _a = helper.normalizeColor(style.shadowColor), opacity = _a.opacity, color = _a.color;
+            var stdDx = blur_1 / 2 / scaleX;
+            var stdDy = blur_1 / 2 / scaleY;
+            var stdDeviation = stdDx + ' ' + stdDy;
+            shadowId = scope.zrId + '-s' + scope.shadowIdx++;
+            scope.defs[shadowId] = core.createVNode('filter', shadowId, {
+                'id': shadowId,
+                'x': '-100%',
+                'y': '-100%',
+                'width': '300%',
+                'height': '300%'
+            }, [
+                core.createVNode('feDropShadow', '', {
+                    'dx': offsetX / scaleX,
+                    'dy': offsetY / scaleY,
+                    'stdDeviation': stdDeviation,
+                    'flood-color': color,
+                    'flood-opacity': opacity
+                })
+            ]);
+            shadowCache[shadowKey] = shadowId;
+        }
+        attrs.filter = helper.getIdURL(shadowId);
+    }
+}
+function setGradient(style, attrs, target, scope) {
+    var val = style[target];
+    var gradientTag;
+    var gradientAttrs = {
+        'gradientUnits': val.global
+            ? 'userSpaceOnUse'
+            : 'objectBoundingBox'
+    };
+    if (helper.isLinearGradient(val)) {
+        gradientTag = 'linearGradient';
+        gradientAttrs.x1 = val.x;
+        gradientAttrs.y1 = val.y;
+        gradientAttrs.x2 = val.x2;
+        gradientAttrs.y2 = val.y2;
+    }
+    else if (helper.isRadialGradient(val)) {
+        gradientTag = 'radialGradient';
+        gradientAttrs.cx = util.retrieve2(val.x, 0.5);
+        gradientAttrs.cy = util.retrieve2(val.y, 0.5);
+        gradientAttrs.r = util.retrieve2(val.r, 0.5);
+    }
+    else {
+        if (process.env.NODE_ENV !== 'production') {
+            util.logError('Illegal gradient type.');
+        }
+        return;
+    }
+    var colors = val.colorStops;
+    var colorStops = [];
+    for (var i = 0, len = colors.length; i < len; ++i) {
+        var offset = helper.round4(colors[i].offset) * 100 + '%';
+        var stopColor = colors[i].color;
+        var _a = helper.normalizeColor(stopColor), color = _a.color, opacity = _a.opacity;
+        var stopsAttrs = {
+            'offset': offset
+        };
+        stopsAttrs['stop-color'] = color;
+        if (opacity < 1) {
+            stopsAttrs['stop-opacity'] = opacity;
+        }
+        colorStops.push(core.createVNode('stop', i + '', stopsAttrs));
+    }
+    var gradientVNode = core.createVNode(gradientTag, '', gradientAttrs, colorStops);
+    var gradientKey = core.vNodeToString(gradientVNode);
+    var gradientCache = scope.gradientCache;
+    var gradientId = gradientCache[gradientKey];
+    if (!gradientId) {
+        gradientId = scope.zrId + '-g' + scope.gradientIdx++;
+        gradientCache[gradientKey] = gradientId;
+        gradientAttrs.id = gradientId;
+        scope.defs[gradientId] = core.createVNode(gradientTag, gradientId, gradientAttrs, colorStops);
+    }
+    attrs[target] = helper.getIdURL(gradientId);
+}
+function setPattern(el, attrs, target, scope) {
+    var val = el.style[target];
+    var boundingRect = el.getBoundingRect();
+    var patternAttrs = {};
+    var repeat = val.repeat;
+    var noRepeat = repeat === 'no-repeat';
+    var repeatX = repeat === 'repeat-x';
+    var repeatY = repeat === 'repeat-y';
+    var child;
+    if (helper.isImagePattern(val)) {
+        var imageWidth_1 = val.imageWidth;
+        var imageHeight_1 = val.imageHeight;
+        var imageSrc = void 0;
+        var patternImage = val.image;
+        if (util.isString(patternImage)) {
+            imageSrc = patternImage;
+        }
+        else if (isImageLike(patternImage)) {
+            imageSrc = patternImage.src;
+        }
+        else if (isCanvasLike(patternImage)) {
+            imageSrc = patternImage.toDataURL();
+        }
+        if (typeof Image === 'undefined') {
+            var errMsg = 'Image width/height must been given explictly in svg-ssr renderer.';
+            util.assert(imageWidth_1, errMsg);
+            util.assert(imageHeight_1, errMsg);
+        }
+        else if (imageWidth_1 == null || imageHeight_1 == null) {
+            var setSizeToVNode_1 = function (vNode, img) {
+                if (vNode) {
+                    var svgEl = vNode.elm;
+                    var width = imageWidth_1 || img.width;
+                    var height = imageHeight_1 || img.height;
+                    if (vNode.tag === 'pattern') {
+                        if (repeatX) {
+                            height = 1;
+                            width /= boundingRect.width;
+                        }
+                        else if (repeatY) {
+                            width = 1;
+                            height /= boundingRect.height;
+                        }
+                    }
+                    vNode.attrs.width = width;
+                    vNode.attrs.height = height;
+                    if (svgEl) {
+                        svgEl.setAttribute('width', width);
+                        svgEl.setAttribute('height', height);
+                    }
+                }
+            };
+            var createdImage = image.createOrUpdateImage(imageSrc, null, el, function (img) {
+                noRepeat || setSizeToVNode_1(patternVNode, img);
+                setSizeToVNode_1(child, img);
+            });
+            if (createdImage && createdImage.width && createdImage.height) {
+                imageWidth_1 = imageWidth_1 || createdImage.width;
+                imageHeight_1 = imageHeight_1 || createdImage.height;
+            }
+        }
+        child = core.createVNode('image', 'img', {
+            href: imageSrc,
+            width: imageWidth_1,
+            height: imageHeight_1
+        });
+        patternAttrs.width = imageWidth_1;
+        patternAttrs.height = imageHeight_1;
+    }
+    else if (val.svgElement) {
+        child = util.clone(val.svgElement);
+        patternAttrs.width = val.svgWidth;
+        patternAttrs.height = val.svgHeight;
+    }
+    if (!child) {
+        return;
+    }
+    var patternWidth;
+    var patternHeight;
+    if (noRepeat) {
+        patternWidth = patternHeight = 1;
+    }
+    else if (repeatX) {
+        patternHeight = 1;
+        patternWidth = patternAttrs.width / boundingRect.width;
+    }
+    else if (repeatY) {
+        patternWidth = 1;
+        patternHeight = patternAttrs.height / boundingRect.height;
+    }
+    else {
+        patternAttrs.patternUnits = 'userSpaceOnUse';
+    }
+    if (patternWidth != null && !isNaN(patternWidth)) {
+        patternAttrs.width = patternWidth;
+    }
+    if (patternHeight != null && !isNaN(patternHeight)) {
+        patternAttrs.height = patternHeight;
+    }
+    var patternTransform = helper.getSRTTransformString(val);
+    patternTransform && (patternAttrs.patternTransform = patternTransform);
+    var patternVNode = core.createVNode('pattern', '', patternAttrs, [child]);
+    var patternKey = core.vNodeToString(patternVNode);
+    var patternCache = scope.patternCache;
+    var patternId = patternCache[patternKey];
+    if (!patternId) {
+        patternId = scope.zrId + '-p' + scope.patternIdx++;
+        patternCache[patternKey] = patternId;
+        patternAttrs.id = patternId;
+        patternVNode = scope.defs[patternId] = core.createVNode('pattern', patternId, patternAttrs, [child]);
+    }
+    attrs[target] = helper.getIdURL(patternId);
+}
+function setClipPath(clipPath, attrs, scope) {
+    var clipPathCache = scope.clipPathCache, defs = scope.defs;
+    var clipPathId = clipPathCache[clipPath.id];
+    if (!clipPathId) {
+        clipPathId = scope.zrId + '-c' + scope.clipPathIdx++;
+        var clipPathAttrs = {
+            id: clipPathId
+        };
+        clipPathCache[clipPath.id] = clipPathId;
+        defs[clipPathId] = core.createVNode('clipPath', clipPathId, clipPathAttrs, [brushSVGPath(clipPath, scope)]);
+    }
+    attrs['clip-path'] = helper.getIdURL(clipPathId);
+}
+
+exports.brush = brush;
+exports.brushSVGImage = brushSVGImage;
+exports.brushSVGPath = brushSVGPath;
+exports.brushSVGTSpan = brushSVGTSpan;
+exports.setClipPath = setClipPath;
+exports.setGradient = setGradient;
+exports.setPattern = setPattern;

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

@@ -0,0 +1,165 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../core/util.js');
+var color = require('../tool/color.js');
+var env = require('../core/env.js');
+
+var mathRound = Math.round;
+function normalizeColor(color$1) {
+    var opacity;
+    if (!color$1 || color$1 === 'transparent') {
+        color$1 = 'none';
+    }
+    else if (typeof color$1 === 'string' && color$1.indexOf('rgba') > -1) {
+        var arr = color.parse(color$1);
+        if (arr) {
+            color$1 = 'rgb(' + arr[0] + ',' + arr[1] + ',' + arr[2] + ')';
+            opacity = arr[3];
+        }
+    }
+    return {
+        color: color$1,
+        opacity: opacity == null ? 1 : opacity
+    };
+}
+var EPSILON = 1e-4;
+function isAroundZero(transform) {
+    return transform < EPSILON && transform > -EPSILON;
+}
+function round3(transform) {
+    return mathRound(transform * 1e3) / 1e3;
+}
+function round4(transform) {
+    return mathRound(transform * 1e4) / 1e4;
+}
+function getMatrixStr(m) {
+    return 'matrix('
+        + round3(m[0]) + ','
+        + round3(m[1]) + ','
+        + round3(m[2]) + ','
+        + round3(m[3]) + ','
+        + round4(m[4]) + ','
+        + round4(m[5])
+        + ')';
+}
+var TEXT_ALIGN_TO_ANCHOR = {
+    left: 'start',
+    right: 'end',
+    center: 'middle',
+    middle: 'middle'
+};
+function adjustTextY(y, lineHeight, textBaseline) {
+    if (textBaseline === 'top') {
+        y += lineHeight / 2;
+    }
+    else if (textBaseline === 'bottom') {
+        y -= lineHeight / 2;
+    }
+    return y;
+}
+function hasShadow(style) {
+    return style
+        && (style.shadowBlur || style.shadowOffsetX || style.shadowOffsetY);
+}
+function getShadowKey(displayable) {
+    var style = displayable.style;
+    var globalScale = displayable.getGlobalScale();
+    return [
+        style.shadowColor,
+        (style.shadowBlur || 0).toFixed(2),
+        (style.shadowOffsetX || 0).toFixed(2),
+        (style.shadowOffsetY || 0).toFixed(2),
+        globalScale[0],
+        globalScale[1]
+    ].join(',');
+}
+function isImagePattern(val) {
+    return val && (!!val.image);
+}
+function isSVGPattern(val) {
+    return val && (!!val.svgElement);
+}
+function isPattern(val) {
+    return isImagePattern(val) || isSVGPattern(val);
+}
+function isLinearGradient(val) {
+    return val.type === 'linear';
+}
+function isRadialGradient(val) {
+    return val.type === 'radial';
+}
+function isGradient(val) {
+    return val && (val.type === 'linear'
+        || val.type === 'radial');
+}
+function getIdURL(id) {
+    return "url(#" + id + ")";
+}
+function getPathPrecision(el) {
+    var scale = el.getGlobalScale();
+    var size = Math.max(scale[0], scale[1]);
+    return Math.max(Math.ceil(Math.log(size) / Math.log(10)), 1);
+}
+function getSRTTransformString(transform) {
+    var x = transform.x || 0;
+    var y = transform.y || 0;
+    var rotation = (transform.rotation || 0) * util.RADIAN_TO_DEGREE;
+    var scaleX = util.retrieve2(transform.scaleX, 1);
+    var scaleY = util.retrieve2(transform.scaleY, 1);
+    var skewX = transform.skewX || 0;
+    var skewY = transform.skewY || 0;
+    var res = [];
+    if (x || y) {
+        res.push("translate(" + x + "px," + y + "px)");
+    }
+    if (rotation) {
+        res.push("rotate(" + rotation + ")");
+    }
+    if (scaleX !== 1 || scaleY !== 1) {
+        res.push("scale(" + scaleX + "," + scaleY + ")");
+    }
+    if (skewX || skewY) {
+        res.push("skew(" + mathRound(skewX * util.RADIAN_TO_DEGREE) + "deg, " + mathRound(skewY * util.RADIAN_TO_DEGREE) + "deg)");
+    }
+    return res.join(' ');
+}
+var encodeBase64 = (function () {
+    if (env["default"].hasGlobalWindow && util.isFunction(window.btoa)) {
+        return function (str) {
+            return window.btoa(unescape(encodeURIComponent(str)));
+        };
+    }
+    if (typeof Buffer !== 'undefined') {
+        return function (str) {
+            return Buffer.from(str).toString('base64');
+        };
+    }
+    return function (str) {
+        if (process.env.NODE_ENV !== 'production') {
+            util.logError('Base64 isn\'t natively supported in the current environment.');
+        }
+        return null;
+    };
+})();
+
+exports.TEXT_ALIGN_TO_ANCHOR = TEXT_ALIGN_TO_ANCHOR;
+exports.adjustTextY = adjustTextY;
+exports.encodeBase64 = encodeBase64;
+exports.getIdURL = getIdURL;
+exports.getMatrixStr = getMatrixStr;
+exports.getPathPrecision = getPathPrecision;
+exports.getSRTTransformString = getSRTTransformString;
+exports.getShadowKey = getShadowKey;
+exports.hasShadow = hasShadow;
+exports.isAroundZero = isAroundZero;
+exports.isGradient = isGradient;
+exports.isImagePattern = isImagePattern;
+exports.isLinearGradient = isLinearGradient;
+exports.isPattern = isPattern;
+exports.isRadialGradient = isRadialGradient;
+exports.isSVGPattern = isSVGPattern;
+exports.normalizeColor = normalizeColor;
+exports.round3 = round3;
+exports.round4 = round4;