office-viewer 0.3.13 → 0.3.15

package/esm/node_modules/zrender/lib/tool/morphPath.js

@@ -1,593 +0,0 @@
-import { cubicSubdivide } from '../core/curve.js';
-import Path from '../graphic/Path.js';
-import { defaults, map } from '../core/util.js';
-import { lerp } from '../core/vector.js';
-import { clonePath } from './path.js';
-import Transformable from '../core/Transformable.js';
-import { split } from './dividePath.js';
-export { split as defaultDividePath } from './dividePath.js';
-import { pathToBezierCurves } from './convertPath.js';
-
-function alignSubpath(subpath1, subpath2) {
-    var len1 = subpath1.length;
-    var len2 = subpath2.length;
-    if (len1 === len2) {
-        return [subpath1, subpath2];
-    }
-    var tmpSegX = [];
-    var tmpSegY = [];
-    var shorterPath = len1 < len2 ? subpath1 : subpath2;
-    var shorterLen = Math.min(len1, len2);
-    var diff = Math.abs(len2 - len1) / 6;
-    var shorterBezierCount = (shorterLen - 2) / 6;
-    var eachCurveSubDivCount = Math.ceil(diff / shorterBezierCount) + 1;
-    var newSubpath = [shorterPath[0], shorterPath[1]];
-    var remained = diff;
-    for (var i = 2; i < shorterLen;) {
-        var x0 = shorterPath[i - 2];
-        var y0 = shorterPath[i - 1];
-        var x1 = shorterPath[i++];
-        var y1 = shorterPath[i++];
-        var x2 = shorterPath[i++];
-        var y2 = shorterPath[i++];
-        var x3 = shorterPath[i++];
-        var y3 = shorterPath[i++];
-        if (remained <= 0) {
-            newSubpath.push(x1, y1, x2, y2, x3, y3);
-            continue;
-        }
-        var actualSubDivCount = Math.min(remained, eachCurveSubDivCount - 1) + 1;
-        for (var k = 1; k <= actualSubDivCount; k++) {
-            var p = k / actualSubDivCount;
-            cubicSubdivide(x0, x1, x2, x3, p, tmpSegX);
-            cubicSubdivide(y0, y1, y2, y3, p, tmpSegY);
-            x0 = tmpSegX[3];
-            y0 = tmpSegY[3];
-            newSubpath.push(tmpSegX[1], tmpSegY[1], tmpSegX[2], tmpSegY[2], x0, y0);
-            x1 = tmpSegX[5];
-            y1 = tmpSegY[5];
-            x2 = tmpSegX[6];
-            y2 = tmpSegY[6];
-        }
-        remained -= actualSubDivCount - 1;
-    }
-    return shorterPath === subpath1 ? [newSubpath, subpath2] : [subpath1, newSubpath];
-}
-function createSubpath(lastSubpathSubpath, otherSubpath) {
-    var len = lastSubpathSubpath.length;
-    var lastX = lastSubpathSubpath[len - 2];
-    var lastY = lastSubpathSubpath[len - 1];
-    var newSubpath = [];
-    for (var i = 0; i < otherSubpath.length;) {
-        newSubpath[i++] = lastX;
-        newSubpath[i++] = lastY;
-    }
-    return newSubpath;
-}
-function alignBezierCurves(array1, array2) {
-    var _a;
-    var lastSubpath1;
-    var lastSubpath2;
-    var newArray1 = [];
-    var newArray2 = [];
-    for (var i = 0; i < Math.max(array1.length, array2.length); i++) {
-        var subpath1 = array1[i];
-        var subpath2 = array2[i];
-        var newSubpath1 = void 0;
-        var newSubpath2 = void 0;
-        if (!subpath1) {
-            newSubpath1 = createSubpath(lastSubpath1 || subpath2, subpath2);
-            newSubpath2 = subpath2;
-        }
-        else if (!subpath2) {
-            newSubpath2 = createSubpath(lastSubpath2 || subpath1, subpath1);
-            newSubpath1 = subpath1;
-        }
-        else {
-            _a = alignSubpath(subpath1, subpath2), newSubpath1 = _a[0], newSubpath2 = _a[1];
-            lastSubpath1 = newSubpath1;
-            lastSubpath2 = newSubpath2;
-        }
-        newArray1.push(newSubpath1);
-        newArray2.push(newSubpath2);
-    }
-    return [newArray1, newArray2];
-}
-function centroid(array) {
-    var signedArea = 0;
-    var cx = 0;
-    var cy = 0;
-    var len = array.length;
-    for (var i = 0, j = len - 2; i < len; j = i, i += 2) {
-        var x0 = array[j];
-        var y0 = array[j + 1];
-        var x1 = array[i];
-        var y1 = array[i + 1];
-        var a = x0 * y1 - x1 * y0;
-        signedArea += a;
-        cx += (x0 + x1) * a;
-        cy += (y0 + y1) * a;
-    }
-    if (signedArea === 0) {
-        return [array[0] || 0, array[1] || 0];
-    }
-    return [cx / signedArea / 3, cy / signedArea / 3, signedArea];
-}
-function findBestRingOffset(fromSubBeziers, toSubBeziers, fromCp, toCp) {
-    var bezierCount = (fromSubBeziers.length - 2) / 6;
-    var bestScore = Infinity;
-    var bestOffset = 0;
-    var len = fromSubBeziers.length;
-    var len2 = len - 2;
-    for (var offset = 0; offset < bezierCount; offset++) {
-        var cursorOffset = offset * 6;
-        var score = 0;
-        for (var k = 0; k < len; k += 2) {
-            var idx = k === 0 ? cursorOffset : ((cursorOffset + k - 2) % len2 + 2);
-            var x0 = fromSubBeziers[idx] - fromCp[0];
-            var y0 = fromSubBeziers[idx + 1] - fromCp[1];
-            var x1 = toSubBeziers[k] - toCp[0];
-            var y1 = toSubBeziers[k + 1] - toCp[1];
-            var dx = x1 - x0;
-            var dy = y1 - y0;
-            score += dx * dx + dy * dy;
-        }
-        if (score < bestScore) {
-            bestScore = score;
-            bestOffset = offset;
-        }
-    }
-    return bestOffset;
-}
-function reverse(array) {
-    var newArr = [];
-    var len = array.length;
-    for (var i = 0; i < len; i += 2) {
-        newArr[i] = array[len - i - 2];
-        newArr[i + 1] = array[len - i - 1];
-    }
-    return newArr;
-}
-function findBestMorphingRotation(fromArr, toArr, searchAngleIteration, searchAngleRange) {
-    var result = [];
-    var fromNeedsReverse;
-    for (var i = 0; i < fromArr.length; i++) {
-        var fromSubpathBezier = fromArr[i];
-        var toSubpathBezier = toArr[i];
-        var fromCp = centroid(fromSubpathBezier);
-        var toCp = centroid(toSubpathBezier);
-        if (fromNeedsReverse == null) {
-            fromNeedsReverse = fromCp[2] < 0 !== toCp[2] < 0;
-        }
-        var newFromSubpathBezier = [];
-        var newToSubpathBezier = [];
-        var bestAngle = 0;
-        var bestScore = Infinity;
-        var tmpArr = [];
-        var len = fromSubpathBezier.length;
-        if (fromNeedsReverse) {
-            fromSubpathBezier = reverse(fromSubpathBezier);
-        }
-        var offset = findBestRingOffset(fromSubpathBezier, toSubpathBezier, fromCp, toCp) * 6;
-        var len2 = len - 2;
-        for (var k = 0; k < len2; k += 2) {
-            var idx = (offset + k) % len2 + 2;
-            newFromSubpathBezier[k + 2] = fromSubpathBezier[idx] - fromCp[0];
-            newFromSubpathBezier[k + 3] = fromSubpathBezier[idx + 1] - fromCp[1];
-        }
-        newFromSubpathBezier[0] = fromSubpathBezier[offset] - fromCp[0];
-        newFromSubpathBezier[1] = fromSubpathBezier[offset + 1] - fromCp[1];
-        if (searchAngleIteration > 0) {
-            var step = searchAngleRange / searchAngleIteration;
-            for (var angle = -searchAngleRange / 2; angle <= searchAngleRange / 2; angle += step) {
-                var sa = Math.sin(angle);
-                var ca = Math.cos(angle);
-                var score = 0;
-                for (var k = 0; k < fromSubpathBezier.length; k += 2) {
-                    var x0 = newFromSubpathBezier[k];
-                    var y0 = newFromSubpathBezier[k + 1];
-                    var x1 = toSubpathBezier[k] - toCp[0];
-                    var y1 = toSubpathBezier[k + 1] - toCp[1];
-                    var newX1 = x1 * ca - y1 * sa;
-                    var newY1 = x1 * sa + y1 * ca;
-                    tmpArr[k] = newX1;
-                    tmpArr[k + 1] = newY1;
-                    var dx = newX1 - x0;
-                    var dy = newY1 - y0;
-                    score += dx * dx + dy * dy;
-                }
-                if (score < bestScore) {
-                    bestScore = score;
-                    bestAngle = angle;
-                    for (var m = 0; m < tmpArr.length; m++) {
-                        newToSubpathBezier[m] = tmpArr[m];
-                    }
-                }
-            }
-        }
-        else {
-            for (var i_1 = 0; i_1 < len; i_1 += 2) {
-                newToSubpathBezier[i_1] = toSubpathBezier[i_1] - toCp[0];
-                newToSubpathBezier[i_1 + 1] = toSubpathBezier[i_1 + 1] - toCp[1];
-            }
-        }
-        result.push({
-            from: newFromSubpathBezier,
-            to: newToSubpathBezier,
-            fromCp: fromCp,
-            toCp: toCp,
-            rotation: -bestAngle
-        });
-    }
-    return result;
-}
-function isCombineMorphing(path) {
-    return path.__isCombineMorphing;
-}
-var SAVED_METHOD_PREFIX = '__mOriginal_';
-function saveAndModifyMethod(obj, methodName, modifiers) {
-    var savedMethodName = SAVED_METHOD_PREFIX + methodName;
-    var originalMethod = obj[savedMethodName] || obj[methodName];
-    if (!obj[savedMethodName]) {
-        obj[savedMethodName] = obj[methodName];
-    }
-    var replace = modifiers.replace;
-    var after = modifiers.after;
-    var before = modifiers.before;
-    obj[methodName] = function () {
-        var args = arguments;
-        var res;
-        before && before.apply(this, args);
-        if (replace) {
-            res = replace.apply(this, args);
-        }
-        else {
-            res = originalMethod.apply(this, args);
-        }
-        after && after.apply(this, args);
-        return res;
-    };
-}
-function restoreMethod(obj, methodName) {
-    var savedMethodName = SAVED_METHOD_PREFIX + methodName;
-    if (obj[savedMethodName]) {
-        obj[methodName] = obj[savedMethodName];
-        obj[savedMethodName] = null;
-    }
-}
-function applyTransformOnBeziers(bezierCurves, mm) {
-    for (var i = 0; i < bezierCurves.length; i++) {
-        var subBeziers = bezierCurves[i];
-        for (var k = 0; k < subBeziers.length;) {
-            var x = subBeziers[k];
-            var y = subBeziers[k + 1];
-            subBeziers[k++] = mm[0] * x + mm[2] * y + mm[4];
-            subBeziers[k++] = mm[1] * x + mm[3] * y + mm[5];
-        }
-    }
-}
-function prepareMorphPath(fromPath, toPath) {
-    var fromPathProxy = fromPath.getUpdatedPathProxy();
-    var toPathProxy = toPath.getUpdatedPathProxy();
-    var _a = alignBezierCurves(pathToBezierCurves(fromPathProxy), pathToBezierCurves(toPathProxy)), fromBezierCurves = _a[0], toBezierCurves = _a[1];
-    var fromPathTransform = fromPath.getComputedTransform();
-    var toPathTransform = toPath.getComputedTransform();
-    function updateIdentityTransform() {
-        this.transform = null;
-    }
-    fromPathTransform && applyTransformOnBeziers(fromBezierCurves, fromPathTransform);
-    toPathTransform && applyTransformOnBeziers(toBezierCurves, toPathTransform);
-    saveAndModifyMethod(toPath, 'updateTransform', { replace: updateIdentityTransform });
-    toPath.transform = null;
-    var morphingData = findBestMorphingRotation(fromBezierCurves, toBezierCurves, 10, Math.PI);
-    var tmpArr = [];
-    saveAndModifyMethod(toPath, 'buildPath', { replace: function (path) {
-            var t = toPath.__morphT;
-            var onet = 1 - t;
-            var newCp = [];
-            for (var i = 0; i < morphingData.length; i++) {
-                var item = morphingData[i];
-                var from = item.from;
-                var to = item.to;
-                var angle = item.rotation * t;
-                var fromCp = item.fromCp;
-                var toCp = item.toCp;
-                var sa = Math.sin(angle);
-                var ca = Math.cos(angle);
-                lerp(newCp, fromCp, toCp, t);
-                for (var m = 0; m < from.length; m += 2) {
-                    var x0_1 = from[m];
-                    var y0_1 = from[m + 1];
-                    var x1 = to[m];
-                    var y1 = to[m + 1];
-                    var x = x0_1 * onet + x1 * t;
-                    var y = y0_1 * onet + y1 * t;
-                    tmpArr[m] = (x * ca - y * sa) + newCp[0];
-                    tmpArr[m + 1] = (x * sa + y * ca) + newCp[1];
-                }
-                var x0 = tmpArr[0];
-                var y0 = tmpArr[1];
-                path.moveTo(x0, y0);
-                for (var m = 2; m < from.length;) {
-                    var x1 = tmpArr[m++];
-                    var y1 = tmpArr[m++];
-                    var x2 = tmpArr[m++];
-                    var y2 = tmpArr[m++];
-                    var x3 = tmpArr[m++];
-                    var y3 = tmpArr[m++];
-                    if (x0 === x1 && y0 === y1 && x2 === x3 && y2 === y3) {
-                        path.lineTo(x3, y3);
-                    }
-                    else {
-                        path.bezierCurveTo(x1, y1, x2, y2, x3, y3);
-                    }
-                    x0 = x3;
-                    y0 = y3;
-                }
-            }
-        } });
-}
-function morphPath(fromPath, toPath, animationOpts) {
-    if (!fromPath || !toPath) {
-        return toPath;
-    }
-    var oldDone = animationOpts.done;
-    var oldDuring = animationOpts.during;
-    prepareMorphPath(fromPath, toPath);
-    toPath.__morphT = 0;
-    function restoreToPath() {
-        restoreMethod(toPath, 'buildPath');
-        restoreMethod(toPath, 'updateTransform');
-        toPath.__morphT = -1;
-        toPath.createPathProxy();
-        toPath.dirtyShape();
-    }
-    toPath.animateTo({
-        __morphT: 1
-    }, defaults({
-        during: function (p) {
-            toPath.dirtyShape();
-            oldDuring && oldDuring(p);
-        },
-        done: function () {
-            restoreToPath();
-            oldDone && oldDone();
-        }
-    }, animationOpts));
-    return toPath;
-}
-function hilbert(x, y, minX, minY, maxX, maxY) {
-    var bits = 16;
-    x = (maxX === minX) ? 0 : Math.round(32767 * (x - minX) / (maxX - minX));
-    y = (maxY === minY) ? 0 : Math.round(32767 * (y - minY) / (maxY - minY));
-    var d = 0;
-    var tmp;
-    for (var s = (1 << bits) / 2; s > 0; s /= 2) {
-        var rx = 0;
-        var ry = 0;
-        if ((x & s) > 0) {
-            rx = 1;
-        }
-        if ((y & s) > 0) {
-            ry = 1;
-        }
-        d += s * s * ((3 * rx) ^ ry);
-        if (ry === 0) {
-            if (rx === 1) {
-                x = s - 1 - x;
-                y = s - 1 - y;
-            }
-            tmp = x;
-            x = y;
-            y = tmp;
-        }
-    }
-    return d;
-}
-function sortPaths(pathList) {
-    var xMin = Infinity;
-    var yMin = Infinity;
-    var xMax = -Infinity;
-    var yMax = -Infinity;
-    var cps = map(pathList, function (path) {
-        var rect = path.getBoundingRect();
-        var m = path.getComputedTransform();
-        var x = rect.x + rect.width / 2 + (m ? m[4] : 0);
-        var y = rect.y + rect.height / 2 + (m ? m[5] : 0);
-        xMin = Math.min(x, xMin);
-        yMin = Math.min(y, yMin);
-        xMax = Math.max(x, xMax);
-        yMax = Math.max(y, yMax);
-        return [x, y];
-    });
-    var items = map(cps, function (cp, idx) {
-        return {
-            cp: cp,
-            z: hilbert(cp[0], cp[1], xMin, yMin, xMax, yMax),
-            path: pathList[idx]
-        };
-    });
-    return items.sort(function (a, b) { return a.z - b.z; }).map(function (item) { return item.path; });
-}
-function defaultDividePath(param) {
-    return split(param.path, param.count);
-}
-function createEmptyReturn() {
-    return {
-        fromIndividuals: [],
-        toIndividuals: [],
-        count: 0
-    };
-}
-function combineMorph(fromList, toPath, animationOpts) {
-    var fromPathList = [];
-    function addFromPath(fromList) {
-        for (var i = 0; i < fromList.length; i++) {
-            var from = fromList[i];
-            if (isCombineMorphing(from)) {
-                addFromPath(from.childrenRef());
-            }
-            else if (from instanceof Path) {
-                fromPathList.push(from);
-            }
-        }
-    }
-    addFromPath(fromList);
-    var separateCount = fromPathList.length;
-    if (!separateCount) {
-        return createEmptyReturn();
-    }
-    var dividePath = animationOpts.dividePath || defaultDividePath;
-    var toSubPathList = dividePath({
-        path: toPath, count: separateCount
-    });
-    if (toSubPathList.length !== separateCount) {
-        console.error('Invalid morphing: unmatched splitted path');
-        return createEmptyReturn();
-    }
-    fromPathList = sortPaths(fromPathList);
-    toSubPathList = sortPaths(toSubPathList);
-    var oldDone = animationOpts.done;
-    var oldDuring = animationOpts.during;
-    var individualDelay = animationOpts.individualDelay;
-    var identityTransform = new Transformable();
-    for (var i = 0; i < separateCount; i++) {
-        var from = fromPathList[i];
-        var to = toSubPathList[i];
-        to.parent = toPath;
-        to.copyTransform(identityTransform);
-        if (!individualDelay) {
-            prepareMorphPath(from, to);
-        }
-    }
-    toPath.__isCombineMorphing = true;
-    toPath.childrenRef = function () {
-        return toSubPathList;
-    };
-    function addToSubPathListToZr(zr) {
-        for (var i = 0; i < toSubPathList.length; i++) {
-            toSubPathList[i].addSelfToZr(zr);
-        }
-    }
-    saveAndModifyMethod(toPath, 'addSelfToZr', {
-        after: function (zr) {
-            addToSubPathListToZr(zr);
-        }
-    });
-    saveAndModifyMethod(toPath, 'removeSelfFromZr', {
-        after: function (zr) {
-            for (var i = 0; i < toSubPathList.length; i++) {
-                toSubPathList[i].removeSelfFromZr(zr);
-            }
-        }
-    });
-    function restoreToPath() {
-        toPath.__isCombineMorphing = false;
-        toPath.__morphT = -1;
-        toPath.childrenRef = null;
-        restoreMethod(toPath, 'addSelfToZr');
-        restoreMethod(toPath, 'removeSelfFromZr');
-    }
-    var toLen = toSubPathList.length;
-    if (individualDelay) {
-        var animating_1 = toLen;
-        var eachDone = function () {
-            animating_1--;
-            if (animating_1 === 0) {
-                restoreToPath();
-                oldDone && oldDone();
-            }
-        };
-        for (var i = 0; i < toLen; i++) {
-            var indivdualAnimationOpts = individualDelay ? defaults({
-                delay: (animationOpts.delay || 0) + individualDelay(i, toLen, fromPathList[i], toSubPathList[i]),
-                done: eachDone
-            }, animationOpts) : animationOpts;
-            morphPath(fromPathList[i], toSubPathList[i], indivdualAnimationOpts);
-        }
-    }
-    else {
-        toPath.__morphT = 0;
-        toPath.animateTo({
-            __morphT: 1
-        }, defaults({
-            during: function (p) {
-                for (var i = 0; i < toLen; i++) {
-                    var child = toSubPathList[i];
-                    child.__morphT = toPath.__morphT;
-                    child.dirtyShape();
-                }
-                oldDuring && oldDuring(p);
-            },
-            done: function () {
-                restoreToPath();
-                for (var i = 0; i < fromList.length; i++) {
-                    restoreMethod(fromList[i], 'updateTransform');
-                }
-                oldDone && oldDone();
-            }
-        }, animationOpts));
-    }
-    if (toPath.__zr) {
-        addToSubPathListToZr(toPath.__zr);
-    }
-    return {
-        fromIndividuals: fromPathList,
-        toIndividuals: toSubPathList,
-        count: toLen
-    };
-}
-function separateMorph(fromPath, toPathList, animationOpts) {
-    var toLen = toPathList.length;
-    var fromPathList = [];
-    var dividePath = animationOpts.dividePath || defaultDividePath;
-    function addFromPath(fromList) {
-        for (var i = 0; i < fromList.length; i++) {
-            var from = fromList[i];
-            if (isCombineMorphing(from)) {
-                addFromPath(from.childrenRef());
-            }
-            else if (from instanceof Path) {
-                fromPathList.push(from);
-            }
-        }
-    }
-    if (isCombineMorphing(fromPath)) {
-        addFromPath(fromPath.childrenRef());
-        var fromLen = fromPathList.length;
-        if (fromLen < toLen) {
-            var k = 0;
-            for (var i = fromLen; i < toLen; i++) {
-                fromPathList.push(clonePath(fromPathList[k++ % fromLen]));
-            }
-        }
-        fromPathList.length = toLen;
-    }
-    else {
-        fromPathList = dividePath({ path: fromPath, count: toLen });
-        var fromPathTransform = fromPath.getComputedTransform();
-        for (var i = 0; i < fromPathList.length; i++) {
-            fromPathList[i].setLocalTransform(fromPathTransform);
-        }
-        if (fromPathList.length !== toLen) {
-            console.error('Invalid morphing: unmatched splitted path');
-            return createEmptyReturn();
-        }
-    }
-    fromPathList = sortPaths(fromPathList);
-    toPathList = sortPaths(toPathList);
-    var individualDelay = animationOpts.individualDelay;
-    for (var i = 0; i < toLen; i++) {
-        var indivdualAnimationOpts = individualDelay ? defaults({
-            delay: (animationOpts.delay || 0) + individualDelay(i, toLen, fromPathList[i], toPathList[i])
-        }, animationOpts) : animationOpts;
-        morphPath(fromPathList[i], toPathList[i], indivdualAnimationOpts);
-    }
-    return {
-        fromIndividuals: fromPathList,
-        toIndividuals: toPathList,
-        count: toPathList.length
-    };
-}
-
-export { alignBezierCurves, centroid, combineMorph, isCombineMorphing, morphPath, separateMorph };