@leafer-ui/worker 1.3.3 → 1.4.0

package/dist/worker.js

@@ -3824,10 +3824,10 @@ var LeaferUI = (function (exports) {
         return decorateLeafAttr(defaultValue, (key) => attr({
             set(value) {
                 if (this.__setAttr(key, value)) {
-                    this.__layout.matrixChanged || this.__layout.matrixChange();
                     this.__hasAutoLayout = !!(this.origin || this.around || this.flow);
                     if (!this.__local)
                         this.__layout.createLocal();
+                    doBoundsType(this);
                 }
             }
         }));
@@ -4210,55 +4210,62 @@ var LeaferUI = (function (exports) {
             y += t.y;
             transition ? t.animate({ x, y }, transition) : (t.x = x, t.y = y);
         },
-        zoomOfWorld(t, origin, scaleX, scaleY, resize) {
-            L.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize);
+        zoomOfWorld(t, origin, scaleX, scaleY, resize, transition) {
+            L.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize, transition);
         },
-        zoomOfLocal(t, origin, scaleX, scaleY = scaleX, resize) {
-            copy$7(matrix$1, t.__localMatrix);
+        zoomOfLocal(t, origin, scaleX, scaleY = scaleX, resize, transition) {
+            const o = t.__localMatrix;
+            if (typeof scaleY !== 'number') {
+                if (scaleY)
+                    transition = scaleY;
+                scaleY = scaleX;
+            }
+            copy$7(matrix$1, o);
             scaleOfOuter$2(matrix$1, origin, scaleX, scaleY);
             if (t.origin || t.around) {
-                L.setTransform(t, matrix$1, resize);
+                L.setTransform(t, matrix$1, resize, transition);
             }
             else {
-                moveByMatrix(t, matrix$1);
-                t.scaleResize(scaleX, scaleY, resize !== true);
+                const x = t.x + matrix$1.e - o.e, y = t.y + matrix$1.f - o.f;
+                if (transition && !resize)
+                    t.animate({ x, y, scaleX: t.scaleX * scaleX, scaleY: t.scaleY * scaleY }, transition);
+                else
+                    t.x = x, t.y = y, t.scaleResize(scaleX, scaleY, resize !== true);
             }
         },
-        rotateOfWorld(t, origin, angle) {
-            L.rotateOfLocal(t, getTempLocal(t, origin), angle);
+        rotateOfWorld(t, origin, angle, transition) {
+            L.rotateOfLocal(t, getTempLocal(t, origin), angle, transition);
         },
-        rotateOfLocal(t, origin, angle) {
-            copy$7(matrix$1, t.__localMatrix);
+        rotateOfLocal(t, origin, angle, transition) {
+            const o = t.__localMatrix;
+            copy$7(matrix$1, o);
             rotateOfOuter$2(matrix$1, origin, angle);
-            if (t.origin || t.around) {
-                L.setTransform(t, matrix$1);
-            }
-            else {
-                moveByMatrix(t, matrix$1);
-                t.rotation = MathHelper.formatRotation(t.rotation + angle);
-            }
+            if (t.origin || t.around)
+                L.setTransform(t, matrix$1, false, transition);
+            else
+                t.set({ x: t.x + matrix$1.e - o.e, y: t.y + matrix$1.f - o.f, rotation: MathHelper.formatRotation(t.rotation + angle) }, transition);
         },
-        skewOfWorld(t, origin, skewX, skewY, resize) {
-            L.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize);
+        skewOfWorld(t, origin, skewX, skewY, resize, transition) {
+            L.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize, transition);
         },
-        skewOfLocal(t, origin, skewX, skewY = 0, resize) {
+        skewOfLocal(t, origin, skewX, skewY = 0, resize, transition) {
             copy$7(matrix$1, t.__localMatrix);
             skewOfOuter(matrix$1, origin, skewX, skewY);
-            L.setTransform(t, matrix$1, resize);
+            L.setTransform(t, matrix$1, resize, transition);
         },
-        transformWorld(t, transform, resize) {
+        transformWorld(t, transform, resize, transition) {
             copy$7(matrix$1, t.worldTransform);
             multiplyParent$2(matrix$1, transform);
             if (t.parent)
                 divideParent(matrix$1, t.parent.worldTransform);
-            L.setTransform(t, matrix$1, resize);
+            L.setTransform(t, matrix$1, resize, transition);
         },
-        transform(t, transform, resize) {
+        transform(t, transform, resize, transition) {
             copy$7(matrix$1, t.localTransform);
             multiplyParent$2(matrix$1, transform);
-            L.setTransform(t, matrix$1, resize);
+            L.setTransform(t, matrix$1, resize, transition);
         },
-        setTransform(t, transform, resize) {
+        setTransform(t, transform, resize, transition) {
             const data = t.__, originPoint = data.origin && L.getInnerOrigin(t, data.origin);
             const layout = getLayout(transform, originPoint, data.around && L.getInnerOrigin(t, data.around));
             if (resize) {
@@ -4273,7 +4280,7 @@ var LeaferUI = (function (exports) {
                 t.scaleResize(scaleX, scaleY, false);
             }
             else
-                t.set(layout);
+                t.set(layout, transition);
         },
         getFlipTransform(t, axis) {
             const m = getMatrixData();
@@ -4310,11 +4317,6 @@ var LeaferUI = (function (exports) {
     };
     const L = LeafHelper;
     const { updateAllMatrix: updateAllMatrix$3, updateMatrix: updateMatrix$2, updateAllWorldOpacity: updateAllWorldOpacity$1, updateAllChange: updateAllChange$1 } = L;
-    function moveByMatrix(t, matrix) {
-        const { e, f } = t.__localMatrix;
-        t.x += matrix.e - e;
-        t.y += matrix.f - f;
-    }
     function getTempLocal(t, world) {
         t.__layout.update();
         return t.parent ? PointHelper.tempToInnerOf(world, t.parent.__world) : world;
@@ -5588,11 +5590,11 @@ var LeaferUI = (function (exports) {
             const layer = this.leafer ? this.leafer.zoomLayer : this;
             return layer.getWorldPoint(page, relative, distance, change);
         }
-        setTransform(matrix, resize) {
-            setTransform(this, matrix, resize);
+        setTransform(matrix, resize, transition) {
+            setTransform(this, matrix, resize, transition);
         }
-        transform(matrix, resize) {
-            transform(this, matrix, resize);
+        transform(matrix, resize, transition) {
+            transform(this, matrix, resize, transition);
         }
         move(x, y, transition) {
             moveLocal(this, x, y, transition);
@@ -5600,32 +5602,32 @@ var LeaferUI = (function (exports) {
         moveInner(x, y, transition) {
             moveWorld(this, x, y, true, transition);
         }
-        scaleOf(origin, scaleX, scaleY, resize) {
-            zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize);
+        scaleOf(origin, scaleX, scaleY, resize, transition) {
+            zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize, transition);
         }
-        rotateOf(origin, rotation) {
-            rotateOfLocal(this, getLocalOrigin(this, origin), rotation);
+        rotateOf(origin, rotation, transition) {
+            rotateOfLocal(this, getLocalOrigin(this, origin), rotation, transition);
         }
-        skewOf(origin, skewX, skewY, resize) {
-            skewOfLocal(this, getLocalOrigin(this, origin), skewX, skewY, resize);
+        skewOf(origin, skewX, skewY, resize, transition) {
+            skewOfLocal(this, getLocalOrigin(this, origin), skewX, skewY, resize, transition);
         }
-        transformWorld(worldTransform, resize) {
-            transformWorld(this, worldTransform, resize);
+        transformWorld(worldTransform, resize, transition) {
+            transformWorld(this, worldTransform, resize, transition);
         }
         moveWorld(x, y, transition) {
             moveWorld(this, x, y, false, transition);
         }
-        scaleOfWorld(worldOrigin, scaleX, scaleY, resize) {
-            zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize);
+        scaleOfWorld(worldOrigin, scaleX, scaleY, resize, transition) {
+            zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize, transition);
         }
         rotateOfWorld(worldOrigin, rotation) {
             rotateOfWorld(this, worldOrigin, rotation);
         }
-        skewOfWorld(worldOrigin, skewX, skewY, resize) {
-            skewOfWorld(this, worldOrigin, skewX, skewY, resize);
+        skewOfWorld(worldOrigin, skewX, skewY, resize, transition) {
+            skewOfWorld(this, worldOrigin, skewX, skewY, resize, transition);
         }
-        flip(axis) {
-            transform(this, getFlipTransform(this, axis));
+        flip(axis, transition) {
+            transform(this, getFlipTransform(this, axis), false, transition);
         }
         scaleResize(scaleX, scaleY = scaleX, _noResize) {
             this.scaleX *= scaleX;
@@ -6013,7 +6015,7 @@ var LeaferUI = (function (exports) {
         }
     }
 
-    const version = "1.3.3";
+    const version = "1.4.0";
 
     class LeaferCanvas extends LeaferCanvasBase {
         get allowBackgroundColor() { return true; }
@@ -9518,10 +9520,9 @@ var LeaferUI = (function (exports) {
             }
         }
         pointerMoveReal(data) {
-            const { dragHover, dragDistance } = this.p;
             this.emit(exports.PointerEvent.BEFORE_MOVE, data, this.defaultPath);
             if (this.downData) {
-                const canDrag = PointHelper.getDistance(this.downData, data) > dragDistance;
+                const canDrag = PointHelper.getDistance(this.downData, data) > this.p.dragDistance;
                 if (canDrag) {
                     if (this.waitTap)
                         this.pointerWaitCancel();
@@ -9533,9 +9534,8 @@ var LeaferUI = (function (exports) {
                 this.updateHoverData(data);
                 this.checkPath(data);
                 this.emit(exports.PointerEvent.MOVE, data);
-                if (!(this.dragging && !dragHover))
-                    this.pointerHover(data);
-                if (this.dragger.dragging) {
+                this.pointerHover(data);
+                if (this.dragging) {
                     this.dragger.dragOverOrOut(data);
                     this.dragger.dragEnterOrLeave(data);
                 }
@@ -9616,7 +9616,8 @@ var LeaferUI = (function (exports) {
                 this.updateCursor();
         }
         pointerHover(data) {
-            if (this.canHover) {
+            if (this.canHover && !(this.dragging && !this.p.dragHover)) {
+                data.path || (data.path = new LeafList());
                 this.pointerOverOrOut(data);
                 this.pointerEnterOrLeave(data);
             }
@@ -11263,11 +11264,11 @@ var LeaferUI = (function (exports) {
     function layoutChar(drawData, style, width, _height) {
         const { rows } = drawData;
         const { textAlign, paraIndent, letterSpacing } = style;
-        let charX, addWordWidth, indentWidth, mode, wordChar;
+        let charX, addWordWidth, indentWidth, mode, wordChar, wordsLength;
         rows.forEach(row => {
             if (row.words) {
-                indentWidth = paraIndent && row.paraStart ? paraIndent : 0;
-                addWordWidth = (width && (textAlign === 'justify' || textAlign === 'both') && row.words.length > 1) ? (width - row.width - indentWidth) / (row.words.length - 1) : 0;
+                indentWidth = paraIndent && row.paraStart ? paraIndent : 0, wordsLength = row.words.length;
+                addWordWidth = (width && (textAlign === 'justify' || textAlign === 'both') && wordsLength > 1) ? (width - row.width - indentWidth) / (wordsLength - 1) : 0;
                 mode = (letterSpacing || row.isOverflow) ? CharMode : (addWordWidth > 0.01 ? WordMode : TextMode);
                 if (row.isOverflow && !letterSpacing)
                     row.textMode = true;
@@ -11279,7 +11280,7 @@ var LeaferUI = (function (exports) {
                     row.x += indentWidth;
                     charX = row.x;
                     row.data = [];
-                    row.words.forEach(word => {
+                    row.words.forEach((word, index) => {
                         if (mode === WordMode) {
                             wordChar = { char: '', x: charX };
                             charX = toWordChar(word.data, charX, wordChar);
@@ -11289,7 +11290,7 @@ var LeaferUI = (function (exports) {
                         else {
                             charX = toChar(word.data, charX, row.data, row.isOverflow);
                         }
-                        if (addWordWidth && (!row.paraEnd || textAlign === 'both')) {
+                        if (addWordWidth && (!row.paraEnd || textAlign === 'both') && (index !== wordsLength - 1)) {
                             charX += addWordWidth;
                             row.width += addWordWidth;
                         }
@@ -11715,3 +11716,4 @@ var LeaferUI = (function (exports) {
     return exports;
 
 })({});
+//# sourceMappingURL=worker.js.map