@leafer-game/worker 1.0.10 → 1.1.0

package/dist/worker.module.js

@@ -108,7 +108,7 @@ const MathHelper = {
         return rotation - oldRotation;
     },
     float(num, maxLength) {
-        const a = maxLength ? pow$2(10, maxLength) : 1000000000000;
+        const a = maxLength !== undefined ? pow$2(10, maxLength) : 1000000000000;
         num = round$3(num * a) / a;
         return num === -0 ? 0 : num;
     },
@@ -4165,20 +4165,17 @@ const LeafHelper = {
         }
         return true;
     },
-    moveWorld(t, x, y = 0, isInnerPoint) {
+    moveWorld(t, x, y = 0, isInnerPoint, transition) {
         const local = typeof x === 'object' ? Object.assign({}, x) : { x, y };
         isInnerPoint ? toOuterPoint$1(t.localTransform, local, local, true) : (t.parent && toInnerPoint$1(t.parent.worldTransform, local, local, true));
-        L$1.moveLocal(t, local.x, local.y);
+        L$1.moveLocal(t, local.x, local.y, transition);
     },
-    moveLocal(t, x, y = 0) {
-        if (typeof x === 'object') {
-            t.x += x.x;
-            t.y += x.y;
-        }
-        else {
-            t.x += x;
-            t.y += y;
-        }
+    moveLocal(t, x, y = 0, transition) {
+        if (typeof x === 'object')
+            y = x.y, x = x.x;
+        x += t.x;
+        y += t.y;
+        transition ? t.animate({ x, y }, transition) : (t.x = x, t.y = y);
     },
     zoomOfWorld(t, origin, scaleX, scaleY, resize) {
         L$1.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize);
@@ -5558,11 +5555,11 @@ let Leaf = class Leaf {
     transform(matrix, resize) {
         transform(this, matrix, resize);
     }
-    move(x, y) {
-        moveLocal(this, x, y);
+    move(x, y, transition) {
+        moveLocal(this, x, y, transition);
     }
-    moveInner(x, y) {
-        moveWorld(this, x, y, true);
+    moveInner(x, y, transition) {
+        moveWorld(this, x, y, true, transition);
     }
     scaleOf(origin, scaleX, scaleY, resize) {
         zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize);
@@ -5576,8 +5573,8 @@ let Leaf = class Leaf {
     transformWorld(worldTransform, resize) {
         transformWorld(this, worldTransform, resize);
     }
-    moveWorld(x, y) {
-        moveWorld(this, x, y);
+    moveWorld(x, y, transition) {
+        moveWorld(this, x, y, false, transition);
     }
     scaleOfWorld(worldOrigin, scaleX, scaleY, resize) {
         zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize);
@@ -5975,7 +5972,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.0.10";
+const version = "1.1.0";
 
 class LeaferCanvas extends LeaferCanvasBase {
     get allowBackgroundColor() { return true; }
@@ -7405,11 +7402,15 @@ let UI = UI_1 = class UI extends Leaf {
         super(data);
     }
     reset(_data) { }
-    set(data, isTemp) {
-        if (isTemp) {
-            this.lockNormalStyle = true;
-            Object.assign(this, data);
-            this.lockNormalStyle = false;
+    set(data, transition) {
+        if (transition) {
+            if (transition === 'temp') {
+                this.lockNormalStyle = true;
+                Object.assign(this, data);
+                this.lockNormalStyle = false;
+            }
+            else
+                this.animate(data, transition);
         }
         else
             Object.assign(this, data);
@@ -7719,17 +7720,17 @@ let Group = class Group extends UI {
         if (!this.children)
             this.children = [];
     }
-    set(data, isTemp) {
+    set(data, transition) {
         if (data.children) {
             const { children } = data;
             delete data.children;
             this.children ? this.clear() : this.__setBranch();
-            super.set(data, isTemp);
+            super.set(data, transition);
             children.forEach(child => this.add(child));
             data.children = children;
         }
         else
-            super.set(data, isTemp);
+            super.set(data, transition);
     }
     toJSON(options) {
         const data = super.toJSON(options);
@@ -7842,8 +7843,8 @@ let Leafer = Leafer_1 = class Leafer extends Group {
     }
     onInit() { }
     initType(_type) { }
-    set(data) {
-        this.waitInit(() => { super.set(data); });
+    set(data, transition) {
+        this.waitInit(() => { super.set(data, transition); });
     }
     start() {
         clearTimeout(this.__startTimer);
@@ -8333,7 +8334,7 @@ Ellipse = __decorate([
 ], Ellipse);
 
 const { moveTo: moveTo$2, lineTo: lineTo$2, drawPoints: drawPoints$1 } = PathCommandDataHelper;
-const { rotate: rotate$1, getAngle: getAngle$1, getDistance: getDistance$2, defaultPoint } = PointHelper;
+const { rotate: rotate$1, getAngle: getAngle$1, getDistance: getDistance$3, defaultPoint } = PointHelper;
 const { toBounds: toBounds$1 } = PathBounds;
 let Line = class Line extends UI {
     get __tag() { return 'Line'; }
@@ -8347,7 +8348,7 @@ let Line = class Line extends UI {
         return to;
     }
     set toPoint(value) {
-        this.width = getDistance$2(defaultPoint, value);
+        this.width = getDistance$3(defaultPoint, value);
         this.rotation = getAngle$1(defaultPoint, value);
         if (this.height)
             this.height = 0;
@@ -9032,10 +9033,8 @@ let DragEvent = class DragEvent extends PointerEvent {
         this.data = data;
     }
     static getValidMove(leaf, start, total) {
-        const { draggable, dragBounds, x, y } = leaf;
-        const move = leaf.getLocalPoint(total, null, true);
-        move.x += start.x - x;
-        move.y += start.y - y;
+        const { draggable, dragBounds } = leaf, move = leaf.getLocalPoint(total, null, true);
+        PointHelper.move(move, start.x - leaf.x, start.y - leaf.y);
         if (dragBounds)
             this.getMoveInDragBounds(leaf.__local, dragBounds === 'parent' ? leaf.parent.boxBounds : dragBounds, move, true);
         if (draggable === 'x')
@@ -9045,8 +9044,7 @@ let DragEvent = class DragEvent extends PointerEvent {
         return move;
     }
     static getMoveInDragBounds(childBox, dragBounds, move, change) {
-        const x = childBox.x + move.x, y = childBox.y + move.y;
-        const right = x + childBox.width, bottom = y + childBox.height;
+        const x = childBox.x + move.x, y = childBox.y + move.y, right = x + childBox.width, bottom = y + childBox.height;
         const boundsRight = dragBounds.x + dragBounds.width, boundsBottom = dragBounds.y + dragBounds.height;
         if (!change)
             move = Object.assign({}, move);
@@ -9098,9 +9096,7 @@ let DragEvent = class DragEvent extends PointerEvent {
         return this.getLocalMove(relative, true);
     }
     getPageBounds() {
-        const total = this.getPageTotal();
-        const start = this.getPagePoint();
-        const bounds = {};
+        const total = this.getPageTotal(), start = this.getPagePoint(), bounds = {};
         BoundsHelper.set(bounds, start.x - total.x, start.y - total.y, total.x, total.y);
         BoundsHelper.unsign(bounds);
         return bounds;
@@ -10488,6 +10484,8 @@ function stroke(stroke, ui, canvas) {
             case 'center':
                 canvas.setStroke(stroke, __strokeWidth, options);
                 canvas.stroke();
+                if (options.__useArrow)
+                    strokeArrow(ui, canvas);
                 break;
             case 'inside':
                 canvas.save();
@@ -10525,6 +10523,8 @@ function strokes(strokes, ui, canvas) {
             case 'center':
                 canvas.setStroke(undefined, __strokeWidth, options);
                 drawStrokesStyle(strokes, false, ui, canvas);
+                if (options.__useArrow)
+                    strokeArrow(ui, canvas);
                 break;
             case 'inside':
                 canvas.save();
@@ -10550,6 +10550,14 @@ function strokes(strokes, ui, canvas) {
         }
     }
 }
+function strokeArrow(ui, canvas) {
+    if (ui.__.dashPattern) {
+        canvas.beginPath();
+        ui.__drawPathByData(canvas, ui.__.__pathForArrow);
+        canvas.dashPattern = null;
+        canvas.stroke();
+    }
+}
 
 const { getSpread, getOuterOf, getByMove, getIntersectData } = BoundsHelper;
 function shape(ui, current, options) {
@@ -11052,7 +11060,7 @@ function applyStops(gradient, stops, opacity) {
     }
 }
 
-const { getAngle, getDistance: getDistance$1 } = PointHelper;
+const { getAngle, getDistance: getDistance$2 } = PointHelper;
 const { get, rotateOfOuter, scaleOfOuter } = MatrixHelper;
 const { toPoint: toPoint$1 } = AroundHelper;
 const realFrom$1 = {};
@@ -11061,7 +11069,7 @@ function radialGradient(paint, box) {
     let { from, to, type, opacity, blendMode, stretch } = paint;
     toPoint$1(from || 'center', box, realFrom$1);
     toPoint$1(to || 'bottom', box, realTo$1);
-    const style = Platform.canvas.createRadialGradient(realFrom$1.x, realFrom$1.y, 0, realFrom$1.x, realFrom$1.y, getDistance$1(realFrom$1, realTo$1));
+    const style = Platform.canvas.createRadialGradient(realFrom$1.x, realFrom$1.y, 0, realFrom$1.x, realFrom$1.y, getDistance$2(realFrom$1, realTo$1));
     applyStops(style, paint.stops, opacity);
     const data = { type, style };
     const transform = getTransform(box, realFrom$1, realTo$1, stretch, true);
@@ -11089,7 +11097,7 @@ function getTransform(box, from, to, stretch, rotate90) {
     return transform;
 }
 
-const { getDistance } = PointHelper;
+const { getDistance: getDistance$1 } = PointHelper;
 const { toPoint } = AroundHelper;
 const realFrom = {};
 const realTo = {};
@@ -11097,7 +11105,7 @@ function conicGradient(paint, box) {
     let { from, to, type, opacity, blendMode, stretch } = paint;
     toPoint(from || 'center', box, realFrom);
     toPoint(to || 'bottom', box, realTo);
-    const style = Platform.conicGradientSupport ? Platform.canvas.createConicGradient(0, realFrom.x, realFrom.y) : Platform.canvas.createRadialGradient(realFrom.x, realFrom.y, 0, realFrom.x, realFrom.y, getDistance(realFrom, realTo));
+    const style = Platform.conicGradientSupport ? Platform.canvas.createConicGradient(0, realFrom.x, realFrom.y) : Platform.canvas.createRadialGradient(realFrom.x, realFrom.y, 0, realFrom.x, realFrom.y, getDistance$1(realFrom, realTo));
     applyStops(style, paint.stops, opacity);
     const data = { type, style };
     const transform = getTransform(box, realFrom, realTo, stretch || 1, Platform.conicGradientRotate90);
@@ -12076,15 +12084,18 @@ let Robot = class Robot extends UI {
         if (typeof action === 'number') {
             this.now = action;
         }
-        else if (action instanceof Array) {
-            const { length } = action;
+        else if (typeof action === 'object') {
+            const isArray = action instanceof Array;
+            const keyframes = isArray ? action : action.keyframes;
+            this.__action = isArray ? undefined : action;
+            const { length } = keyframes;
             if (length > 1) {
-                const start = this.now = action[0], end = action[action.length - 1];
+                const start = this.now = keyframes[0], end = keyframes[keyframes.length - 1];
                 this.play();
                 this.__runAction(start, end);
             }
             else if (length)
-                this.now = action[0];
+                this.now = keyframes[0];
         }
     }
     __loadRobot(frame, start, end) {
@@ -12112,16 +12123,26 @@ let Robot = class Robot extends UI {
         this.emitEvent(new ImageEvent(ImageEvent.LOADED, { image }));
     }
     __runAction(start, end) {
+        let { FPS, loop, __action: a } = this;
+        if (a) {
+            if (a.FPS)
+                FPS = a.FPS;
+            if (a.loop !== undefined)
+                loop = a.loop;
+        }
         this.__timer = setTimeout(() => {
             if (this.running) {
-                if (this.now === end)
+                if (this.now === end) {
+                    if (!loop)
+                        return this.stop();
                     this.now = start;
+                }
                 else
                     this.now++;
                 this.__updateRobotBounds();
             }
             this.__runAction(start, end);
-        }, 1000 / this.FPS);
+        }, 1000 / FPS);
     }
     __updateRobotBounds() {
         const { nowFrame } = this;
@@ -12234,7 +12255,7 @@ function updateStyle(leaf, style, type) {
     const fromStyle = transition ? getFromStyle(leaf, style) : undefined;
     leaf.killAnimate('transition');
     if (normalStyle)
-        leaf.set(normalStyle, true);
+        leaf.set(normalStyle, 'temp');
     const statesStyle = getStyle(leaf);
     if (statesStyle) {
         const { animation } = statesStyle;
@@ -12248,14 +12269,14 @@ function updateStyle(leaf, style, type) {
             delete statesStyle.animation;
         }
         leaf.normalStyle = filterStyle(statesStyle, leaf);
-        leaf.set(statesStyle, true);
+        leaf.set(statesStyle, 'temp');
     }
     else {
         leaf.normalStyle = undefined;
     }
     if (transition) {
         const toStyle = filterStyle(fromStyle, leaf);
-        leaf.set(fromStyle, true);
+        leaf.set(fromStyle, 'temp');
         leaf.animate([fromStyle, toStyle], transition, 'transition', true);
     }
     leaf.__layout.stateStyleChanged = false;
@@ -12953,7 +12974,7 @@ let Animate = class Animate extends Eventer {
         this.emit(AnimateEvent.UPDATE, this);
     }
     setStyle(style) {
-        this.target.set(style, this.isTemp);
+        this.target.set(style, this.isTemp ? 'temp' : false);
     }
     clearTimer(fn) {
         if (this.timer) {
@@ -13329,6 +13350,9 @@ const TransitionList = {
         from = fourNumber(from), to = fourNumber(to);
         return from.map((f, i) => number(f, to[i], t));
     },
+    text(from, to, t) {
+        return (typeof from === 'number' || typeof to === 'number') ? MathHelper.float(number(from, to, t), Math.max(getDecimalLen(from), getDecimalLen(to))) : to;
+    },
     shadow,
     innerShadow: shadow
 };
@@ -13337,6 +13361,10 @@ const TransitionModule = {
     number,
     color
 };
+function getDecimalLen(num) {
+    const decimal = String(num).split('.')[1];
+    return decimal ? decimal.length : 0;
+}
 function value(from, to, t) {
     return (typeof from === 'number' && typeof to === 'number') ? from + (to - from) * t : to;
 }
@@ -13405,23 +13433,40 @@ const gaussNodes = [0.1488743389, 0.4333953941, 0.6794095682, 0.8650633666, 0.97
 const gaussWeights = [0.2955242247, 0.2692667193, 0.2190863625, 0.1494513491, 0.0666713443];
 const { sqrt } = Math;
 const HighBezierHelper = {
-    getDistance(fromX, fromY, x1, y1, x2, y2, toX, toY) {
-        let distance = 0, t1, t2, d1X, d1Y, d2X, d2Y;
+    getDistance(fromX, fromY, x1, y1, x2, y2, toX, toY, t = 1) {
+        let distance = 0, t1, t2, d1X, d1Y, d2X, d2Y, half = t / 2;
         for (let i = 0; i < gaussNodes.length; i++) {
-            t1 = 0.5 * (1 + gaussNodes[i]);
-            t2 = 0.5 * (1 - gaussNodes[i]);
+            t1 = half * (1 + gaussNodes[i]);
+            t2 = half * (1 - gaussNodes[i]);
             d1X = getDerivative(t1, fromX, x1, x2, toX);
             d1Y = getDerivative(t1, fromY, y1, y2, toY);
             d2X = getDerivative(t2, fromX, x1, x2, toX);
             d2Y = getDerivative(t2, fromY, y1, y2, toY);
             distance += gaussWeights[i] * (sqrt(d1X * d1X + d1Y * d1Y) + sqrt(d2X * d2X + d2Y * d2Y));
         }
-        return distance * 0.5;
+        return distance * half;
     },
     getDerivative(t, fromV, v1, v2, toV) {
         const o = 1 - t;
         return 3 * o * o * (v1 - fromV) + 6 * o * t * (v2 - v1) + 3 * t * t * (toV - v2);
     },
+    getRotation(t, fromX, fromY, x1, y1, x2, y2, toX, toY) {
+        const dx = getDerivative(t, fromX, x1, x2, toX);
+        const dy = getDerivative(t, fromY, y1, y2, toY);
+        return Math.atan2(dy, dx) / OneRadian;
+    },
+    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;
+        while (high - low > realPrecision) {
+            getDistance(fromX, fromY, x1, y1, x2, y2, toX, toY, middle) < distance ? low = middle : high = middle;
+            middle = (low + high) / 2;
+        }
+        return middle;
+    },
     cut(data, t, fromX, fromY, x1, y1, x2, y2, toX, toY) {
         const o = 1 - t;
         const ax = o * fromX + t * x1, ay = o * fromY + t * y1;
@@ -13433,7 +13478,7 @@ const HighBezierHelper = {
         data.push(PathCommandMap.C, ax, ay, bx, by, cx, cy);
     }
 };
-const { getDerivative } = HighBezierHelper;
+const { getDerivative, getDistance } = HighBezierHelper;
 
 const { M, L, C, Z } = PathCommandMap;
 const tempPoint = {}, tempFrom = {};
@@ -13501,11 +13546,12 @@ const HighCurveHelper = {
         }
         return { total, segments, data };
     },
-    getDistancePoint(distanceData, motionDistance) {
+    getDistancePoint(distanceData, motionDistance, motionPrecision) {
         const { segments, data } = distanceData;
         motionDistance = UnitConvert.number(motionDistance, distanceData.total);
         let total = 0, distance, to = {};
         let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        let x1, y1, x2, y2, t;
         const len = data.length;
         while (i < len) {
             command = data[i];
@@ -13535,11 +13581,10 @@ const HighCurveHelper = {
                     toY = data[i + 6];
                     distance = segments[index];
                     if (total + distance > motionDistance) {
-                        const x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
-                        motionDistance -= total;
-                        BezierHelper.getPointAndSet(motionDistance / distance, x, y, x1, y1, x2, y2, toX, toY, to);
-                        BezierHelper.getPointAndSet(Math.max(0, motionDistance - 0.1) / distance, x, y, x1, y1, x2, y2, toX, toY, tempFrom);
-                        to.rotation = PointHelper.getAngle(tempFrom, to);
+                        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);
+                        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;
@@ -13556,11 +13601,12 @@ const HighCurveHelper = {
         }
         return to;
     },
-    getDistancePath(distanceData, motionDistance) {
+    getDistancePath(distanceData, motionDistance, motionPrecision) {
         const { segments, data } = distanceData, path = [];
         motionDistance = UnitConvert.number(motionDistance, distanceData.total);
         let total = 0, distance, to = {};
         let i = 0, index = 0, x = 0, y = 0, toX, toY, command;
+        let x1, y1, x2, y2, t;
         const len = data.length;
         while (i < len) {
             command = data[i];
@@ -13587,12 +13633,13 @@ const HighCurveHelper = {
                     path.push(command, x, y);
                     break;
                 case C:
-                    const x1 = data[i + 1], y1 = data[i + 2], x2 = data[i + 3], y2 = data[i + 4];
+                    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) {
-                        HighBezierHelper.cut(path, (motionDistance - total) / distance, x, y, x1, y1, x2, y2, toX, toY);
+                        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;
@@ -13641,6 +13688,7 @@ const ui = UI.prototype;
 const { updateMatrix, updateAllMatrix } = LeafHelper;
 const { updateBounds } = BranchHelper;
 motionPathType()(ui, 'motionPath');
+motionPathType(1)(ui, 'motionPrecision');
 motionPathType()(ui, 'motion');
 motionPathType(true)(ui, 'motionRotation');
 ui.getMotionPathData = function () {
@@ -13651,7 +13699,7 @@ ui.getMotionPoint = function (motionDistance) {
     const data = getMotionPathData(path);
     if (!data.total)
         return {};
-    const point = HighCurveHelper.getDistancePoint(data, motionDistance);
+    const point = HighCurveHelper.getDistancePoint(data, motionDistance, path.motionPrecision);
     MatrixHelper.toOuterPoint(path.localTransform, point);
     const { motionRotation } = this;
     if (motionRotation === false)
@@ -13691,7 +13739,7 @@ function updateMotion(leaf) {
     if (leaf.motionPath) {
         const data = getMotionPathData(leaf);
         if (data.total)
-            leaf.__.__pathForRender = HighCurveHelper.getDistancePath(data, motion);
+            leaf.__.__pathForRender = HighCurveHelper.getDistancePath(data, motion, leaf.motionPrecision);
     }
     else {
         leaf.set(leaf.getMotionPoint(motion));