@leafer-in/motion-path 1.8.0 → 1.9.1

package/dist/motion-path.cjs

@@ -1,11 +1,15 @@
-'use strict';
+"use strict";
 
-var draw = require('@leafer-ui/draw');
+var draw = require("@leafer-ui/draw");
+
+const gaussNodes = [ .1488743389, .4333953941, .6794095682, .8650633666, .9739065285 ];
+
+const gaussWeights = [ .2955242247, .2692667193, .2190863625, .1494513491, .0666713443 ];
+
+const {sqrt: sqrt} = Math;
+
+const {getDerivative: getDerivative} = draw.BezierHelper;
 
-const gaussNodes = [0.1488743389, 0.4333953941, 0.6794095682, 0.8650633666, 0.9739065285];
-const gaussWeights = [0.2955242247, 0.2692667193, 0.2190863625, 0.1494513491, 0.0666713443];
-const { sqrt } = Math;
-const { getDerivative } = draw.BezierHelper;
 const HighBezierHelper = {
     getDistance(fromX, fromY, x1, y1, x2, y2, toX, toY, t = 1) {
         let distance = 0, t1, t2, d1X, d1Y, d2X, d2Y, half = t / 2;
@@ -27,10 +31,8 @@ const HighBezierHelper = {
     },
     getT(distance, totalDistance, fromX, fromY, x1, y1, x2, y2, toX, toY, precision = 1) {
         let low = 0, high = 1, middle = distance / totalDistance, realPrecision = precision / totalDistance / 3;
-        if (middle >= 1)
-            return 1;
-        if (middle <= 0)
-            return 0;
+        if (middle >= 1) return 1;
+        if (middle <= 0) return 0;
         while (high - low > realPrecision) {
             getDistance(fromX, fromY, x1, y1, x2, y2, toX, toY, middle) < distance ? low = middle : high = middle;
             middle = (low + high) / 2;
@@ -48,10 +50,13 @@ const HighBezierHelper = {
         data.push(draw.PathCommandMap.C, ax, ay, bx, by, cx, cy);
     }
 };
-const { getDistance } = HighBezierHelper;
 
-const { M, L, C, Z } = draw.PathCommandMap;
+const {getDistance: getDistance} = HighBezierHelper;
+
+const {M: M, L: L, C: C, Z: Z} = draw.PathCommandMap;
+
 const tempPoint = {}, tempFrom = {};
+
 const HighCurveHelper = {
     transform(data, matrix) {
         let i = 0, command;
@@ -59,17 +64,19 @@ const HighCurveHelper = {
         while (i < len) {
             command = data[i];
             switch (command) {
-                case M:
-                case L:
-                    HighCurveHelper.transformPoints(data, matrix, i, 1);
-                    i += 3;
-                    break;
-                case C:
-                    HighCurveHelper.transformPoints(data, matrix, i, 3);
-                    i += 7;
-                    break;
-                case Z:
-                    i += 1;
+              case M:
+              case L:
+                HighCurveHelper.transformPoints(data, matrix, i, 1);
+                i += 3;
+                break;
+
+              case C:
+                HighCurveHelper.transformPoints(data, matrix, i, 3);
+                i += 7;
+                break;
+
+              case Z:
+                i += 1;
             }
         }
     },
@@ -89,35 +96,42 @@ const HighCurveHelper = {
         while (i < len) {
             command = data[i];
             switch (command) {
-                case M:
-                case L:
-                    toX = data[i + 1];
-                    toY = data[i + 2];
-                    distance = (command === L && i > 0) ? draw.PointHelper.getDistanceFrom(x, y, toX, toY) : 0;
-                    x = toX;
-                    y = toY;
-                    i += 3;
-                    break;
-                case C:
-                    toX = data[i + 5];
-                    toY = data[i + 6];
-                    distance = HighBezierHelper.getDistance(x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], toX, toY);
-                    x = toX;
-                    y = toY;
-                    i += 7;
-                    break;
-                case Z:
-                    i += 1;
-                default:
-                    distance = 0;
+              case M:
+              case L:
+                toX = data[i + 1];
+                toY = data[i + 2];
+                distance = command === L && i > 0 ? draw.PointHelper.getDistanceFrom(x, y, toX, toY) : 0;
+                x = toX;
+                y = toY;
+                i += 3;
+                break;
+
+              case C:
+                toX = data[i + 5];
+                toY = data[i + 6];
+                distance = HighBezierHelper.getDistance(x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], toX, toY);
+                x = toX;
+                y = toY;
+                i += 7;
+                break;
+
+              case Z:
+                i += 1;
+
+              default:
+                distance = 0;
             }
             segments.push(distance);
             total += distance;
         }
-        return { total, segments, data };
+        return {
+            total: total,
+            segments: segments,
+            data: data
+        };
     },
     getDistancePoint(distanceData, motionDistance, motionPrecision) {
-        const { segments, data } = distanceData;
+        const {segments: segments, data: data} = distanceData;
         motionDistance = draw.UnitConvert.number(motionDistance, distanceData.total);
         let total = 0, distance, to = {};
         let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
@@ -126,45 +140,47 @@ const HighCurveHelper = {
         while (i < len) {
             command = data[i];
             switch (command) {
-                case M:
-                case L:
-                    toX = data[i + 1];
-                    toY = data[i + 2];
-                    distance = segments[index];
-                    if (total + distance >= motionDistance || !distanceData.total) {
-                        if (!i)
-                            x = toX, y = toY;
-                        tempFrom.x = x;
-                        tempFrom.y = y;
-                        to.x = toX;
-                        to.y = toY;
-                        draw.PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
-                        to.rotation = draw.PointHelper.getAngle(tempFrom, to);
-                        return to;
-                    }
-                    x = toX;
-                    y = toY;
-                    i += 3;
-                    break;
-                case C:
-                    toX = data[i + 5];
-                    toY = data[i + 6];
-                    distance = segments[index];
-                    if (total + distance >= motionDistance) {
-                        x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
-                        t = HighBezierHelper.getT(motionDistance - total, distance, x, y, x1, y1, x2, y2, toX, toY, motionPrecision);
-                        draw.BezierHelper.getPointAndSet(t, x, y, x1, y1, x2, y2, toX, toY, to);
-                        to.rotation = HighBezierHelper.getRotation(t, x, y, x1, y1, x2, y2, toX, toY);
-                        return to;
-                    }
-                    x = toX;
-                    y = toY;
-                    i += 7;
-                    break;
-                case Z:
-                    i += 1;
-                default:
-                    distance = 0;
+              case M:
+              case L:
+                toX = data[i + 1];
+                toY = data[i + 2];
+                distance = segments[index];
+                if (total + distance >= motionDistance || !distanceData.total) {
+                    if (!i) x = toX, y = toY;
+                    tempFrom.x = x;
+                    tempFrom.y = y;
+                    to.x = toX;
+                    to.y = toY;
+                    draw.PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
+                    to.rotation = draw.PointHelper.getAngle(tempFrom, to);
+                    return to;
+                }
+                x = toX;
+                y = toY;
+                i += 3;
+                break;
+
+              case C:
+                toX = data[i + 5];
+                toY = data[i + 6];
+                distance = segments[index];
+                if (total + distance >= motionDistance) {
+                    x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
+                    t = HighBezierHelper.getT(motionDistance - total, distance, x, y, x1, y1, x2, y2, toX, toY, motionPrecision);
+                    draw.BezierHelper.getPointAndSet(t, x, y, x1, y1, x2, y2, toX, toY, to);
+                    to.rotation = HighBezierHelper.getRotation(t, x, y, x1, y1, x2, y2, toX, toY);
+                    return to;
+                }
+                x = toX;
+                y = toY;
+                i += 7;
+                break;
+
+              case Z:
+                i += 1;
+
+              default:
+                distance = 0;
             }
             index++;
             total += distance;
@@ -172,7 +188,7 @@ const HighCurveHelper = {
         return to;
     },
     getDistancePath(distanceData, motionDistance, motionPrecision) {
-        const { segments, data } = distanceData, path = [];
+        const {segments: segments, data: data} = distanceData, path = [];
         motionDistance = draw.UnitConvert.number(motionDistance, distanceData.total);
         let total = 0, distance, to = {};
         let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
@@ -181,47 +197,49 @@ const HighCurveHelper = {
         while (i < len) {
             command = data[i];
             switch (command) {
-                case M:
-                case L:
-                    toX = data[i + 1];
-                    toY = data[i + 2];
-                    distance = segments[index];
-                    if (total + distance >= motionDistance || !distanceData.total) {
-                        if (!i)
-                            x = toX, y = toY;
-                        tempFrom.x = x;
-                        tempFrom.y = y;
-                        to.x = toX;
-                        to.y = toY;
-                        draw.PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
-                        path.push(command, to.x, to.y);
-                        return path;
-                    }
-                    x = toX;
-                    y = toY;
-                    i += 3;
-                    path.push(command, x, y);
-                    break;
-                case C:
-                    x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
-                    toX = data[i + 5];
-                    toY = data[i + 6];
-                    distance = segments[index];
-                    if (total + distance >= motionDistance) {
-                        t = HighBezierHelper.getT(motionDistance - total, distance, x, y, x1, y1, x2, y2, toX, toY, motionPrecision);
-                        HighBezierHelper.cut(path, t, x, y, x1, y1, x2, y2, toX, toY);
-                        return path;
-                    }
-                    x = toX;
-                    y = toY;
-                    i += 7;
-                    path.push(command, x1, y1, x2, y2, toX, toY);
-                    break;
-                case Z:
-                    i += 1;
-                    path.push(command);
-                default:
-                    distance = 0;
+              case M:
+              case L:
+                toX = data[i + 1];
+                toY = data[i + 2];
+                distance = segments[index];
+                if (total + distance >= motionDistance || !distanceData.total) {
+                    if (!i) x = toX, y = toY;
+                    tempFrom.x = x;
+                    tempFrom.y = y;
+                    to.x = toX;
+                    to.y = toY;
+                    draw.PointHelper.getDistancePoint(tempFrom, to, motionDistance - total, true);
+                    path.push(command, to.x, to.y);
+                    return path;
+                }
+                x = toX;
+                y = toY;
+                i += 3;
+                path.push(command, x, y);
+                break;
+
+              case C:
+                x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
+                toX = data[i + 5];
+                toY = data[i + 6];
+                distance = segments[index];
+                if (total + distance >= motionDistance) {
+                    t = HighBezierHelper.getT(motionDistance - total, distance, x, y, x1, y1, x2, y2, toX, toY, motionPrecision);
+                    HighBezierHelper.cut(path, t, x, y, x1, y1, x2, y2, toX, toY);
+                    return path;
+                }
+                x = toX;
+                y = toY;
+                i += 7;
+                path.push(command, x1, y1, x2, y2, toX, toY);
+                break;
+
+              case Z:
+                i += 1;
+                path.push(command);
+
+              default:
+                distance = 0;
             }
             index++;
             total += distance;
@@ -231,7 +249,7 @@ const HighCurveHelper = {
 };
 
 function motionPathType(defaultValue) {
-    return draw.decorateLeafAttr(defaultValue, (key) => draw.attr({
+    return draw.decorateLeafAttr(defaultValue, key => draw.attr({
         set(value) {
             this.__setAttr(key, value);
             this.__hasMotionPath = this.motionPath || !draw.isNull(this.motion);
@@ -240,108 +258,102 @@ function motionPathType(defaultValue) {
     }));
 }
 
-draw.Plugin.add('motion-path');
-draw.Transition.register('motion', function (from, to, t, target) {
-    if (!from)
-        from = 0;
-    else if (typeof from === 'object')
-        from = draw.UnitConvert.number(from, target.getMotionTotal());
-    if (!to)
-        to = 0;
-    else if (typeof to === 'object')
-        to = draw.UnitConvert.number(to, target.getMotionTotal());
-    return draw.Transition.number(from, to, t);
+draw.Plugin.add("motion-path");
+
+draw.Transition.register("motion", function(from, to, t, target) {
+    if (draw.isObject(from)) from = draw.UnitConvert.number(from, target.getMotionTotal());
+    if (draw.isObject(to)) to = draw.UnitConvert.number(to, target.getMotionTotal());
+    return draw.Transition.number(from || 0, to || 0, t);
 });
-draw.Transition.register('motionRotation', function (from, to, t) {
+
+draw.Transition.register("motionRotation", function(from, to, t) {
     return draw.Transition.number(from, to, t);
 });
+
 const ui = draw.UI.prototype;
-const { updateMatrix, updateAllMatrix } = draw.LeafHelper;
-const { updateBounds } = draw.BranchHelper;
-draw.UI.addAttr('motionPath', undefined, motionPathType);
-draw.UI.addAttr('motionPrecision', 1, motionPathType);
-draw.UI.addAttr('motion', undefined, motionPathType);
-draw.UI.addAttr('motionRotation', true, motionPathType);
-ui.getMotionPathData = function () {
+
+const {updateMatrix: updateMatrix, updateAllMatrix: updateAllMatrix} = draw.LeafHelper;
+
+const {updateBounds: updateBounds} = draw.BranchHelper;
+
+draw.UI.addAttr("motionPath", undefined, motionPathType);
+
+draw.UI.addAttr("motionPrecision", 1, motionPathType);
+
+draw.UI.addAttr("motion", undefined, motionPathType);
+
+draw.UI.addAttr("motionRotation", true, motionPathType);
+
+ui.getMotionPathData = function() {
     return getMotionPathData(getMotionPath(this));
 };
-ui.getMotionPoint = function (motionDistance) {
+
+ui.getMotionPoint = function(motionDistance) {
     const path = getMotionPath(this);
     const data = getMotionPathData(path);
-    if (!data.total)
-        return {};
+    if (!data.total) return {};
     const point = HighCurveHelper.getDistancePoint(data, motionDistance, path.motionPrecision);
     draw.MatrixHelper.toOuterPoint(path.localTransform, point);
-    const { motionRotation } = this;
-    if (motionRotation === false)
-        delete point.rotation;
-    else if (typeof motionRotation === 'number')
-        point.rotation += motionRotation;
+    const {motionRotation: motionRotation} = this;
+    if (motionRotation === false) delete point.rotation; else if (draw.isNumber(motionRotation)) point.rotation += motionRotation;
     return point;
 };
-ui.getMotionTotal = function () {
+
+ui.getMotionTotal = function() {
     return this.getMotionPathData().total;
 };
-ui.__updateMotionPath = function () {
+
+ui.__updateMotionPath = function() {
     const data = this.__;
-    if (this.__layout.resized && data.__pathForMotion)
-        data.__pathForMotion = undefined;
+    if (this.__layout.resized && data.__pathForMotion) data.__pathForMotion = undefined;
     if (this.motionPath) {
         let child;
-        const { children } = this.parent;
+        const {children: children} = this.parent;
         for (let i = 0; i < children.length; i++) {
             child = children[i];
             if (!draw.isNull(child.motion) && !child.__layout.matrixChanged) {
-                if (child !== this)
-                    child.__extraUpdate();
+                if (child !== this) child.__extraUpdate();
                 updateMotion(child);
             }
         }
-    }
-    else
-        updateMotion(this);
+    } else updateMotion(this);
 };
+
 function updateMotion(leaf) {
-    const { motion, leaferIsCreated } = leaf;
-    if (draw.isNull(motion))
-        return;
-    if (leaferIsCreated)
-        leaf.leafer.created = false;
+    const {motion: motion, leaferIsCreated: leaferIsCreated} = leaf;
+    if (draw.isNull(motion)) return;
+    if (leaferIsCreated) leaf.leafer.created = false;
     if (leaf.motionPath) {
         const data = getMotionPathData(leaf);
-        if (data.total)
-            leaf.__.__pathForRender = HighCurveHelper.getDistancePath(data, motion, leaf.motionPrecision);
-    }
-    else {
+        if (data.total) leaf.__.__pathForRender = HighCurveHelper.getDistancePath(data, motion, leaf.motionPrecision);
+    } else {
         leaf.set(leaf.getMotionPoint(motion));
         if (!leaf.__hasAutoLayout) {
-            if (leaf.isBranch)
-                updateAllMatrix(leaf), updateBounds(leaf, leaf);
-            else
-                updateMatrix(leaf);
+            if (leaf.isBranch) updateAllMatrix(leaf), updateBounds(leaf, leaf); else updateMatrix(leaf);
         }
     }
-    if (leaferIsCreated)
-        leaf.leafer.created = true;
+    if (leaferIsCreated) leaf.leafer.created = true;
 }
+
 function getMotionPath(leaf) {
-    const { parent } = leaf;
+    const {parent: parent} = leaf;
     if (!leaf.motionPath && parent) {
-        const { children } = parent;
+        const {children: children} = parent;
         for (let i = 0; i < children.length; i++) {
-            if (children[i].motionPath)
-                return children[i];
+            if (children[i].motionPath) return children[i];
         }
     }
     return leaf;
 }
+
 function getMotionPathData(leaf) {
     const data = leaf.__;
-    if (data.__pathForMotion)
-        return data.__pathForMotion;
+    if (data.__pathForMotion) return data.__pathForMotion;
     return data.__pathForMotion = HighCurveHelper.getMotionPathData(leaf.getPath(true, true));
 }
 
 exports.HighBezierHelper = HighBezierHelper;
+
 exports.HighCurveHelper = HighCurveHelper;
+
 exports.motionPathType = motionPathType;