leafer-ui 1.10.0 → 1.11.0

package/dist/web.js

@@ -831,9 +831,10 @@ var LeaferUI = function(exports) {
         getAtan2(t, to) {
             return atan2$2(to.y - t.y, to.x - t.x);
         },
-        getDistancePoint(t, to, distance, changeTo) {
+        getDistancePoint(t, to, distance, changeTo, fromTo) {
             const r = getAtan2(t, to);
-            to = changeTo ? to : {};
+            fromTo && (t = to);
+            changeTo || (to = {});
             to.x = t.x + cos$4(r) * distance;
             to.y = t.y + sin$4(r) * distance;
             return to;
@@ -843,6 +844,9 @@ var LeaferUI = function(exports) {
             if (isObject(originPoints[0])) points = [], originPoints.forEach(p => points.push(p.x, p.y));
             return points;
         },
+        isSame(t, point) {
+            return t.x === point.x && t.y === point.y;
+        },
         reset(t) {
             P$5.reset(t);
         }
@@ -904,8 +908,8 @@ var LeaferUI = function(exports) {
         getDistance(to) {
             return PointHelper.getDistance(this, to);
         }
-        getDistancePoint(to, distance, changeTo) {
-            return new Point(PointHelper.getDistancePoint(this, to, distance, changeTo));
+        getDistancePoint(to, distance, changeTo, fromTo) {
+            return new Point(PointHelper.getDistancePoint(this, to, distance, changeTo, fromTo));
         }
         getAngle(to) {
             return PointHelper.getAngle(this, to);
@@ -913,6 +917,9 @@ var LeaferUI = function(exports) {
         getAtan2(to) {
             return PointHelper.getAtan2(this, to);
         }
+        isSame(point) {
+            return PointHelper.isSame(this, point);
+        }
         reset() {
             PointHelper.reset(this);
             return this;
@@ -2689,6 +2696,14 @@ var LeaferUI = function(exports) {
             }
         }
     };
+    const PathCommandNodeHelper = {
+        toCommand(_nodes) {
+            return [];
+        },
+        toNode(_data) {
+            return [];
+        }
+    };
     const {M: M$4, m: m, L: L$5, l: l, H: H, h: h, V: V, v: v, C: C$3, c: c, S: S, s: s, Q: Q$3, q: q, T: T, t: t, A: A, a: a, Z: Z$4, z: z, N: N$3, D: D$4, X: X$3, G: G$3, F: F$4, O: O$3, P: P$3, U: U$3} = PathCommandMap;
     const {rect: rect$3, roundRect: roundRect$2, arcTo: arcTo$3, arc: arc$3, ellipse: ellipse$4, quadraticCurveTo: quadraticCurveTo$1} = BezierHelper;
     const {ellipticalArc: ellipticalArc} = EllipseHelper;
@@ -2962,30 +2977,34 @@ var LeaferUI = function(exports) {
             return data;
         },
         objectToCanvasData(list) {
-            const data = [];
-            list.forEach(item => {
-                switch (item.name) {
-                  case "M":
-                    data.push(M$4, item.x, item.y);
-                    break;
+            if (list[0].name.length > 1) {
+                return PathCommandNodeHelper.toCommand(list);
+            } else {
+                const data = [];
+                list.forEach(item => {
+                    switch (item.name) {
+                      case "M":
+                        data.push(M$4, item.x, item.y);
+                        break;
 
-                  case "L":
-                    data.push(L$5, item.x, item.y);
-                    break;
+                      case "L":
+                        data.push(L$5, item.x, item.y);
+                        break;
 
-                  case "C":
-                    data.push(C$3, item.x1, item.y1, item.x2, item.y2, item.x, item.y);
-                    break;
+                      case "C":
+                        data.push(C$3, item.x1, item.y1, item.x2, item.y2, item.x, item.y);
+                        break;
 
-                  case "Q":
-                    data.push(Q$3, item.x1, item.y1, item.x, item.y);
-                    break;
+                      case "Q":
+                        data.push(Q$3, item.x1, item.y1, item.x, item.y);
+                        break;
 
-                  case "Z":
-                    data.push(Z$4);
-                }
-            });
-            return data;
+                      case "Z":
+                        data.push(Z$4);
+                    }
+                });
+                return data;
+            }
         },
         copyData(data, old, index, count) {
             for (let i = index, end = index + count; i < end; i++) {
@@ -6428,7 +6447,7 @@ var LeaferUI = function(exports) {
             this.levelMap = null;
         }
     }
-    const version = "1.10.0";
+    const version = "1.11.0";
     const debug$5 = Debug.get("LeaferCanvas");
     class LeaferCanvas extends LeaferCanvasBase {
         set zIndex(zIndex) {
@@ -7550,7 +7569,9 @@ var LeaferUI = function(exports) {
     };
     const {parse: parse, objectToCanvasData: objectToCanvasData} = PathConvert;
     const {stintSet: stintSet$3} = DataHelper, {hasTransparent: hasTransparent$2} = ColorConvert;
-    const emptyPaint = {};
+    const emptyPaint = {
+        originPaint: {}
+    };
     const debug$2 = Debug.get("UIData");
     class UIData extends LeafData {
         get scale() {
@@ -8063,7 +8084,7 @@ var LeaferUI = function(exports) {
                 drawer.roundRect(x, y, width, height, isNumber(cornerRadius) ? [ cornerRadius ] : cornerRadius);
             } else drawer.rect(x, y, width, height);
         }
-        drawImagePlaceholder(_image, canvas, renderOptions) {
+        drawImagePlaceholder(_paint, canvas, renderOptions) {
             Paint.fill(this.__.placeholderColor, this, canvas, renderOptions);
         }
         animate(keyframe, _options, _type, _isTemp) {
@@ -8655,7 +8676,7 @@ var LeaferUI = function(exports) {
                 const data = this.__, layout = this.__layout, {renderBounds: renderBounds, boxBounds: boxBounds} = layout, {overflow: overflow} = data;
                 const childrenRenderBounds = layout.childrenRenderBounds || (layout.childrenRenderBounds = getBoundsData());
                 super.__updateRenderBounds(childrenRenderBounds);
-                if (isScrollMode = overflow.includes("scroll")) {
+                if (isScrollMode = overflow && overflow.includes("scroll")) {
                     add(childrenRenderBounds, boxBounds);
                     scroll(childrenRenderBounds, data);
                 }
@@ -9664,10 +9685,12 @@ var LeaferUI = function(exports) {
             if (throughPath) this.dragData.throughPath = throughPath;
             this.dragData.path = path;
             if (this.moving) {
+                data.moving = true;
                 this.dragData.moveType = "drag";
                 interaction.emit(exports.MoveEvent.BEFORE_MOVE, this.dragData);
                 interaction.emit(exports.MoveEvent.MOVE, this.dragData);
             } else if (this.dragging) {
+                data.dragging = true;
                 this.dragReal();
                 interaction.emit(exports.DragEvent.BEFORE_DRAG, this.dragData);
                 interaction.emit(exports.DragEvent.DRAG, this.dragData);
@@ -9772,13 +9795,9 @@ var LeaferUI = function(exports) {
         if (!path && !data.path) return;
         let leaf;
         data.type = type;
-        if (path) {
-            data = Object.assign(Object.assign({}, data), {
-                path: path
-            });
-        } else {
-            path = data.path;
-        }
+        if (path) data = Object.assign(Object.assign({}, data), {
+            path: path
+        }); else path = data.path;
         data.target = path.indexAt(0);
         try {
             for (let i = path.length - 1; i > -1; i--) {
@@ -10818,30 +10837,31 @@ var LeaferUI = function(exports) {
         fillPathOrText(ui, canvas, renderOptions);
     }
     function fills(fills, ui, canvas, renderOptions) {
-        let item;
+        let item, originPaint, countImage;
         for (let i = 0, len = fills.length; i < len; i++) {
-            item = fills[i];
+            item = fills[i], originPaint = item.originPaint;
             if (item.image) {
+                countImage ? countImage++ : countImage = 1;
                 if (PaintImage.checkImage(item, !ui.__.__font, ui, canvas, renderOptions)) continue;
                 if (!item.style) {
-                    if (!i && item.image.isPlacehold) ui.drawImagePlaceholder(item.image, canvas, renderOptions);
+                    if (countImage === 1 && item.image.isPlacehold) ui.drawImagePlaceholder(item, canvas, renderOptions);
                     continue;
                 }
             }
             canvas.fillStyle = item.style;
-            if (item.transform || item.scaleFixed) {
+            if (item.transform || originPaint.scaleFixed) {
                 canvas.save();
                 if (item.transform) canvas.transform(item.transform);
-                if (item.scaleFixed) {
+                if (originPaint.scaleFixed) {
                     const {scaleX: scaleX, scaleY: scaleY} = ui.getRenderScaleData(true);
-                    if (item.scaleFixed === true || item.scaleFixed === "zoom-in" && scaleX > 1 && scaleY > 1) canvas.scale(1 / scaleX, 1 / scaleY);
+                    if (originPaint.scaleFixed === true || originPaint.scaleFixed === "zoom-in" && scaleX > 1 && scaleY > 1) canvas.scale(1 / scaleX, 1 / scaleY);
                 }
-                if (item.blendMode) canvas.blendMode = item.blendMode;
+                if (originPaint.blendMode) canvas.blendMode = originPaint.blendMode;
                 fillPathOrText(ui, canvas, renderOptions);
                 canvas.restore();
             } else {
-                if (item.blendMode) {
-                    canvas.saveBlendMode(item.blendMode);
+                if (originPaint.blendMode) {
+                    canvas.saveBlendMode(originPaint.blendMode);
                     fillPathOrText(ui, canvas, renderOptions);
                     canvas.restoreBlendMode();
                 } else fillPathOrText(ui, canvas, renderOptions);
@@ -10982,8 +11002,8 @@ var LeaferUI = function(exports) {
                     const {strokeStyle: strokeStyle} = item;
                     strokeStyle ? canvas.setStroke(item.style, data.__getRealStrokeWidth(strokeStyle) * strokeWidthScale, data, strokeStyle) : canvas.setStroke(item.style, data.__strokeWidth * strokeWidthScale, data);
                 } else canvas.strokeStyle = item.style;
-                if (item.blendMode) {
-                    canvas.saveBlendMode(item.blendMode);
+                if (item.originPaint.blendMode) {
+                    canvas.saveBlendMode(item.originPaint.blendMode);
                     isText ? Paint.drawTextStroke(ui, canvas, renderOptions) : canvas.stroke();
                     canvas.restoreBlendMode();
                 } else {
@@ -11074,61 +11094,62 @@ var LeaferUI = function(exports) {
                 if (leafPaints.some(item => item.image)) isAlphaPixel = true;
                 isTransparent = true;
             }
-        }
-        if (attrName === "fill") {
-            stintSet(data, "__isAlphaPixelFill", isAlphaPixel);
-            stintSet(data, "__isTransparentFill", isTransparent);
+            if (attrName === "fill") {
+                stintSet(data, "__isAlphaPixelFill", isAlphaPixel);
+                stintSet(data, "__isTransparentFill", isTransparent);
+            } else {
+                stintSet(data, "__isAlphaPixelStroke", isAlphaPixel);
+                stintSet(data, "__isTransparentStroke", isTransparent);
+                stintSet(data, "__hasMultiStrokeStyle", maxChildStrokeWidth);
+            }
         } else {
-            stintSet(data, "__isAlphaPixelStroke", isAlphaPixel);
-            stintSet(data, "__isTransparentStroke", isTransparent);
-            stintSet(data, "__hasMultiStrokeStyle", maxChildStrokeWidth);
+            data.__removePaint(attrName, false);
         }
     }
     function getLeafPaint(attrName, paint, ui) {
         if (!isObject(paint) || paint.visible === false || paint.opacity === 0) return undefined;
-        let data;
+        let leafPaint;
         const {boxBounds: boxBounds} = ui.__layout;
         switch (paint.type) {
           case "image":
-            data = PaintImage.image(ui, attrName, paint, boxBounds, !recycleMap || !recycleMap[paint.url]);
+            leafPaint = PaintImage.image(ui, attrName, paint, boxBounds, !recycleMap || !recycleMap[paint.url]);
             break;
 
           case "linear":
-            data = PaintGradient.linearGradient(paint, boxBounds);
+            leafPaint = PaintGradient.linearGradient(paint, boxBounds);
             break;
 
           case "radial":
-            data = PaintGradient.radialGradient(paint, boxBounds);
+            leafPaint = PaintGradient.radialGradient(paint, boxBounds);
             break;
 
           case "angular":
-            data = PaintGradient.conicGradient(paint, boxBounds);
+            leafPaint = PaintGradient.conicGradient(paint, boxBounds);
             break;
 
           case "solid":
             const {type: type, color: color, opacity: opacity} = paint;
-            data = {
+            leafPaint = {
                 type: type,
                 style: ColorConvert.string(color, opacity)
             };
             break;
 
           default:
-            if (!isUndefined(paint.r)) data = {
+            if (!isUndefined(paint.r)) leafPaint = {
                 type: "solid",
                 style: ColorConvert.string(paint)
             };
         }
-        if (data) {
-            if (isString(data.style) && hasTransparent$1(data.style)) data.isTransparent = true;
+        if (leafPaint) {
+            leafPaint.originPaint = paint;
+            if (isString(leafPaint.style) && hasTransparent$1(leafPaint.style)) leafPaint.isTransparent = true;
             if (paint.style) {
                 if (paint.style.strokeWidth === 0) return undefined;
-                data.strokeStyle = paint.style;
+                leafPaint.strokeStyle = paint.style;
             }
-            if (paint.editing) data.editing = paint.editing;
-            if (paint.blendMode) data.blendMode = paint.blendMode;
         }
-        return data;
+        return leafPaint;
     }
     const PaintModule = {
         compute: compute,
@@ -11246,10 +11267,6 @@ var LeaferUI = function(exports) {
     const tempScaleData = {};
     const tempImage = {};
     function createData(leafPaint, image, paint, box) {
-        const {changeful: changeful, sync: sync, scaleFixed: scaleFixed} = paint;
-        if (changeful) leafPaint.changeful = changeful;
-        if (sync) leafPaint.sync = sync;
-        if (scaleFixed) leafPaint.scaleFixed = scaleFixed;
         leafPaint.data = PaintImage.getPatternData(paint, box, image);
     }
     function getPatternData(paint, box, image) {
@@ -11460,14 +11477,14 @@ var LeaferUI = function(exports) {
     }
     function checkImage(paint, drawImage, ui, canvas, renderOptions) {
         const {scaleX: scaleX, scaleY: scaleY} = PaintImage.getImageRenderScaleData(paint, ui, canvas, renderOptions);
-        const {image: image, data: data} = paint, {exporting: exporting} = renderOptions;
+        const {image: image, data: data, originPaint: originPaint} = paint, {exporting: exporting} = renderOptions;
         if (!data || paint.patternId === scaleX + "-" + scaleY && !exporting) {
             return false;
         } else {
             if (drawImage) {
                 if (data.repeat) {
                     drawImage = false;
-                } else if (!(paint.changeful || Platform.name === "miniapp" && ResizeEvent.isResizing(ui) || exporting)) {
+                } else if (!(originPaint.changeful || Platform.name === "miniapp" && ResizeEvent.isResizing(ui) || exporting)) {
                     drawImage = Platform.image.isLarge(image, scaleX, scaleY);
                 }
             }
@@ -11479,15 +11496,15 @@ var LeaferUI = function(exports) {
                 PaintImage.drawImage(paint, scaleX, scaleY, ui, canvas, renderOptions);
                 return true;
             } else {
-                if (!paint.style || paint.sync || exporting) PaintImage.createPattern(paint, ui, canvas, renderOptions); else PaintImage.createPatternTask(paint, ui, canvas, renderOptions);
+                if (!paint.style || originPaint.sync || exporting) PaintImage.createPattern(paint, ui, canvas, renderOptions); else PaintImage.createPatternTask(paint, ui, canvas, renderOptions);
                 return false;
             }
         }
     }
     function drawImage(paint, _imageScaleX, _imageScaleY, ui, canvas, _renderOptions) {
-        const {data: data, image: image, blendMode: blendMode} = paint, {opacity: opacity, transform: transform} = data, view = image.getFull(data.filters), u = ui.__;
+        const {data: data, image: image} = paint, {blendMode: blendMode} = paint.originPaint, {opacity: opacity, transform: transform} = data, view = image.getFull(data.filters), u = ui.__;
         let {width: width, height: height} = image, clipUI;
-        if (transform && !transform.onlyScale || (clipUI = u.path || u.cornerRadius) || opacity || blendMode) {
+        if ((clipUI = transform && !transform.onlyScale || u.path || u.cornerRadius) || opacity || blendMode) {
             canvas.save();
             clipUI && canvas.clipUI(ui);
             blendMode && (canvas.blendMode = blendMode);
@@ -11501,7 +11518,7 @@ var LeaferUI = function(exports) {
         }
     }
     function getImageRenderScaleData(paint, ui, canvas, _renderOptions) {
-        const scaleData = ui.getRenderScaleData(true, paint.scaleFixed), {data: data} = paint;
+        const scaleData = ui.getRenderScaleData(true, paint.originPaint.scaleFixed), {data: data} = paint;
         if (canvas) {
             const {pixelRatio: pixelRatio} = canvas;
             scaleData.scaleX *= pixelRatio;
@@ -12417,6 +12434,7 @@ var LeaferUI = function(exports) {
     exports.PathBounds = PathBounds;
     exports.PathCommandDataHelper = PathCommandDataHelper;
     exports.PathCommandMap = PathCommandMap;
+    exports.PathCommandNodeHelper = PathCommandNodeHelper;
     exports.PathConvert = PathConvert;
     exports.PathCorner = PathCorner;
     exports.PathCreator = PathCreator;