@leafer-draw/node 1.9.6 → 1.9.8

package/dist/node.cjs

@@ -452,6 +452,7 @@ class Renderer {
             usePartRender: true,
             maxFPS: 120
         };
+        this.frames = [];
         this.target = target;
         this.canvas = canvas;
         if (userConfig) this.config = core.DataHelper.default(userConfig, this.config);
@@ -581,7 +582,7 @@ class Renderer {
         };
         if (this.needFill) canvas.fillWorld(bounds, this.config.fill);
         if (core.Debug.showRepaint) core.Debug.drawRepaint(canvas, bounds);
-        this.target.__render(canvas, options);
+        core.Platform.render(this.target, canvas, options);
         this.renderBounds = realBounds = realBounds || bounds;
         this.renderOptions = options;
         this.totalBounds.isEmpty() ? this.totalBounds = realBounds : this.totalBounds.add(realBounds);
@@ -604,12 +605,15 @@ class Renderer {
         const target = this.target;
         if (this.requestTime || !target) return;
         if (target.parentApp) return target.parentApp.requestRender(false);
-        const requestTime = this.requestTime = Date.now();
+        this.requestTime = this.frameTime || Date.now();
         const render = () => {
-            const nowFPS = 1e3 / (Date.now() - requestTime);
+            const nowFPS = 1e3 / ((this.frameTime = Date.now()) - this.requestTime);
             const {maxFPS: maxFPS} = this.config;
-            if (maxFPS && nowFPS > maxFPS - .5) return core.Platform.requestRender(render);
-            this.FPS = Math.min(120, Math.ceil(nowFPS));
+            if (maxFPS && nowFPS > maxFPS) return core.Platform.requestRender(render);
+            const {frames: frames} = this;
+            if (frames.length > 30) frames.shift();
+            frames.push(nowFPS);
+            this.FPS = Math.round(frames.reduce((a, b) => a + b, 0) / frames.length);
             this.requestTime = 0;
             this.checkRender();
         };
@@ -674,6 +678,15 @@ Object.assign(core.Creator, {
 
 core.Platform.layout = Layouter.fullLayout;
 
+core.Platform.render = function(target, canvas, options) {
+    const topOptions = Object.assign(Object.assign({}, options), {
+        topRendering: true
+    });
+    options.topList = new core.LeafList;
+    target.__render(canvas, options);
+    if (options.topList.length) options.topList.forEach(item => item.__render(canvas, topOptions));
+};
+
 function fillText(ui, canvas) {
     const data = ui.__, {rows: rows, decorationY: decorationY} = data.__textDrawData;
     if (data.__isPlacehold && data.placeholderColor) canvas.fillStyle = data.placeholderColor;
@@ -867,24 +880,29 @@ function drawOutside(stroke, ui, canvas) {
     }
 }
 
-const {getSpread: getSpread, getOuterOf: getOuterOf, getByMove: getByMove, getIntersectData: getIntersectData} = core.BoundsHelper;
+const {getSpread: getSpread, copyAndSpread: copyAndSpread, toOuterOf: toOuterOf, getOuterOf: getOuterOf, getByMove: getByMove, move: move$1, getIntersectData: getIntersectData} = core.BoundsHelper;
+
+const tempBounds$1 = {};
 
 function shape(ui, current, options) {
     const canvas = current.getSameCanvas();
-    const nowWorld = ui.__nowWorld, currentBounds = current.bounds;
-    let bounds, matrix, fitMatrix, shapeBounds, worldCanvas;
+    const currentBounds = current.bounds, nowWorld = ui.__nowWorld, layout = ui.__layout;
+    const nowWorldShapeBounds = ui.__nowWorldShapeBounds || (ui.__nowWorldShapeBounds = {});
+    toOuterOf(layout.strokeSpread ? (copyAndSpread(tempBounds$1, layout.boxBounds, layout.strokeSpread), 
+    tempBounds$1) : layout.boxBounds, nowWorld, nowWorldShapeBounds);
+    let bounds, renderBounds, matrix, fitMatrix, shapeBounds, worldCanvas;
     let {scaleX: scaleX, scaleY: scaleY} = ui.getRenderScaleData(true);
-    if (currentBounds.includes(nowWorld)) {
+    if (currentBounds.includes(nowWorldShapeBounds)) {
         worldCanvas = canvas;
-        bounds = shapeBounds = nowWorld;
+        bounds = shapeBounds = nowWorldShapeBounds;
+        renderBounds = nowWorld;
     } else {
-        const {renderShapeSpread: spread} = ui.__layout;
         let worldClipBounds;
         if (core.Platform.fullImageShadow) {
-            worldClipBounds = nowWorld;
+            worldClipBounds = nowWorldShapeBounds;
         } else {
-            const spreadBounds = spread ? getSpread(currentBounds, scaleX === scaleY ? spread * scaleX : [ spread * scaleY, spread * scaleX ]) : currentBounds;
-            worldClipBounds = getIntersectData(spreadBounds, nowWorld);
+            const spreadBounds = layout.renderShapeSpread ? getSpread(currentBounds, core.FourNumberHelper.swapAndScale(layout.renderShapeSpread, scaleX, scaleY)) : currentBounds;
+            worldClipBounds = getIntersectData(spreadBounds, nowWorldShapeBounds);
         }
         fitMatrix = currentBounds.getFitMatrix(worldClipBounds);
         let {a: fitScaleX, d: fitScaleY} = fitMatrix;
@@ -894,8 +912,10 @@ function shape(ui, current, options) {
             scaleX *= fitScaleX;
             scaleY *= fitScaleY;
         }
-        shapeBounds = getOuterOf(nowWorld, fitMatrix);
+        shapeBounds = getOuterOf(nowWorldShapeBounds, fitMatrix);
         bounds = getByMove(shapeBounds, -fitMatrix.e, -fitMatrix.f);
+        renderBounds = getOuterOf(nowWorld, fitMatrix);
+        move$1(renderBounds, -fitMatrix.e, -fitMatrix.f);
         const userMatrix = options.matrix;
         if (userMatrix) {
             matrix = new core.Matrix(fitMatrix);
@@ -914,6 +934,7 @@ function shape(ui, current, options) {
         matrix: matrix,
         fitMatrix: fitMatrix,
         bounds: bounds,
+        renderBounds: renderBounds,
         worldCanvas: worldCanvas,
         shapeBounds: shapeBounds,
         scaleX: scaleX,
@@ -1017,7 +1038,7 @@ const PaintModule = {
     shape: shape
 };
 
-let origin = {}, tempMatrix = core.getMatrixData();
+let origin = {}, tempMatrix$1 = core.getMatrixData();
 
 const {get: get$3, rotateOfOuter: rotateOfOuter$1, translate: translate$1, scaleOfOuter: scaleOfOuter$1, multiplyParent: multiplyParent, scale: scaleHelper, rotate: rotate, skew: skewHelper} = core.MatrixHelper;
 
@@ -1032,12 +1053,12 @@ function fillOrFitMode(data, box, x, y, scaleX, scaleY, rotation) {
     data.transform = transform;
 }
 
-function clipMode(data, box, x, y, scaleX, scaleY, rotation, skew, clipSize) {
+function clipMode(data, box, x, y, scaleX, scaleY, rotation, skew, clipScaleX, clipScaleY) {
     const transform = get$3();
     layout(transform, box, x, y, scaleX, scaleY, rotation, skew);
-    if (clipSize) {
-        tempMatrix.a = box.width / clipSize.width, tempMatrix.d = box.height / clipSize.height;
-        multiplyParent(transform, tempMatrix);
+    if (clipScaleX) {
+        tempMatrix$1.a = clipScaleX, tempMatrix$1.d = clipScaleY;
+        multiplyParent(transform, tempMatrix$1);
     }
     data.transform = transform;
 }
@@ -1138,7 +1159,12 @@ function getPatternData(paint, box, image) {
 
       case "normal":
       case "clip":
-        if (tempImage.x || tempImage.y || scaleX || clipSize || rotation || skew) clipMode(data, box, tempImage.x, tempImage.y, scaleX, scaleY, rotation, skew, paint.clipSize);
+        if (tempImage.x || tempImage.y || scaleX || clipSize || rotation || skew) {
+            let clipScaleX, clipScaleY;
+            if (clipSize) clipScaleX = box.width / clipSize.width, clipScaleY = box.height / clipSize.height;
+            clipMode(data, box, tempImage.x, tempImage.y, scaleX, scaleY, rotation, skew, clipScaleX, clipScaleY);
+            if (clipScaleX) scaleX = scaleX ? scaleX * clipScaleX : scaleX, scaleY = scaleY ? scaleY * clipScaleY : clipScaleY;
+        }
         break;
 
       case "repeat":
@@ -1296,7 +1322,7 @@ function ignoreRender(ui, value) {
 
 const {get: get$1, scale: scale, copy: copy$1} = core.MatrixHelper;
 
-const {floor: floor, ceil: ceil, max: max, abs: abs} = Math;
+const {floor: floor, ceil: ceil, max: max$1, abs: abs} = Math;
 
 function createPattern(ui, paint, pixelRatio) {
     let {scaleX: scaleX, scaleY: scaleY} = ui.getRenderScaleData(true, paint.scaleFixed);
@@ -1345,8 +1371,8 @@ function createPattern(ui, paint, pixelRatio) {
         if (transform || scaleX !== 1 || scaleY !== 1) {
             const canvasWidth = width + (xGap || 0);
             const canvasHeight = height + (yGap || 0);
-            scaleX /= canvasWidth / max(floor(canvasWidth), 1);
-            scaleY /= canvasHeight / max(floor(canvasHeight), 1);
+            scaleX /= canvasWidth / max$1(floor(canvasWidth), 1);
+            scaleY /= canvasHeight / max$1(floor(canvasHeight), 1);
             if (!imageMatrix) {
                 imageMatrix = get$1();
                 if (transform) copy$1(imageMatrix, transform);
@@ -1372,17 +1398,15 @@ function checkImage(ui, canvas, paint, allowDraw) {
         if (allowDraw) {
             if (data.repeat) {
                 allowDraw = false;
-            } else {
-                if (!(paint.changeful || core.Platform.name === "miniapp" && core.ResizeEvent.isResizing(ui) || draw.Export.running)) {
-                    let {width: width, height: height} = data;
-                    width *= scaleX * pixelRatio;
-                    height *= scaleY * pixelRatio;
-                    if (data.scaleX) {
-                        width *= data.scaleX;
-                        height *= data.scaleY;
-                    }
-                    allowDraw = width * height > core.Platform.image.maxCacheSize;
+            } else if (!(paint.changeful || core.Platform.name === "miniapp" && core.ResizeEvent.isResizing(ui) || draw.Export.running)) {
+                let {width: width, height: height} = data;
+                width *= scaleX * pixelRatio;
+                height *= scaleY * pixelRatio;
+                if (data.scaleX) {
+                    width *= data.scaleX;
+                    height *= data.scaleY;
                 }
+                allowDraw = width * height > core.Platform.image.maxCacheSize;
             }
         }
         if (allowDraw) {
@@ -1562,20 +1586,20 @@ const PaintGradientModule = {
     getTransform: getTransform
 };
 
-const {copy: copy, toOffsetOutBounds: toOffsetOutBounds$1} = core.BoundsHelper;
+const {copy: copy, move: move, toOffsetOutBounds: toOffsetOutBounds$1} = core.BoundsHelper, {max: max} = Math;
 
-const tempBounds = {};
+const tempBounds = {}, tempMatrix = new core.Matrix;
 
 const offsetOutBounds$1 = {};
 
 function shadow(ui, current, shape) {
-    let copyBounds, spreadScale;
-    const {__nowWorld: nowWorld, __layout: __layout} = ui;
+    let copyBounds, transform;
+    const {__nowWorld: nowWorld} = ui;
     const {shadow: shadow} = ui.__;
-    const {worldCanvas: worldCanvas, bounds: bounds, shapeBounds: shapeBounds, scaleX: scaleX, scaleY: scaleY} = shape;
+    const {worldCanvas: worldCanvas, bounds: bounds, renderBounds: renderBounds, shapeBounds: shapeBounds, scaleX: scaleX, scaleY: scaleY} = shape;
     const other = current.getSameCanvas();
     const end = shadow.length - 1;
-    toOffsetOutBounds$1(bounds, offsetOutBounds$1);
+    toOffsetOutBounds$1(bounds, offsetOutBounds$1, renderBounds);
     shadow.forEach((item, index) => {
         let otherScale = 1;
         if (item.scaleFixed) {
@@ -1583,54 +1607,61 @@ function shadow(ui, current, shape) {
             if (sx > 1) otherScale = 1 / sx;
         }
         other.setWorldShadow(offsetOutBounds$1.offsetX + item.x * scaleX * otherScale, offsetOutBounds$1.offsetY + item.y * scaleY * otherScale, item.blur * scaleX * otherScale, draw.ColorConvert.string(item.color));
-        spreadScale = item.spread ? 1 + item.spread * 2 / (__layout.boxBounds.width + (__layout.strokeBoxSpread || 0) * 2) * otherScale : 0;
-        drawWorldShadow(other, offsetOutBounds$1, spreadScale, shape);
-        copyBounds = bounds;
+        transform = getShadowTransform(ui, other, shape, item, offsetOutBounds$1, otherScale);
+        if (transform) other.setTransform(transform);
+        drawWorldShadow(other, offsetOutBounds$1, shape);
+        if (transform) other.resetTransform();
+        copyBounds = renderBounds;
         if (item.box) {
             other.restore();
             other.save();
             if (worldCanvas) {
-                other.copyWorld(other, bounds, nowWorld, "copy");
+                other.copyWorld(other, renderBounds, nowWorld, "copy");
                 copyBounds = nowWorld;
             }
             worldCanvas ? other.copyWorld(worldCanvas, nowWorld, nowWorld, "destination-out") : other.copyWorld(shape.canvas, shapeBounds, bounds, "destination-out");
         }
-        if (draw.Effect.isTransformShadow(item)) draw.Effect.renderTransformShadow(ui, current, other, copyBounds, item); else core.LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
+        core.LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
         if (end && index < end) other.clearWorld(copyBounds);
     });
     other.recycle(copyBounds);
 }
 
-function getShadowSpread(_ui, shadow) {
-    let width = 0;
-    shadow.forEach(item => width = Math.max(width, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread > 0 ? item.spread : 0) + item.blur * 1.5));
-    return width;
+function getShadowRenderSpread(_ui, shadow) {
+    let top = 0, right = 0, bottom = 0, left = 0, x, y, spread, blur;
+    shadow.forEach(item => {
+        x = item.x || 0, y = item.y || 0, spread = item.spread || 0, blur = (item.blur || 0) * 1.5;
+        top = max(top, spread + blur - y);
+        right = max(right, spread + blur + x);
+        bottom = max(bottom, spread + blur + y);
+        left = max(left, spread + blur - x);
+    });
+    return top === right && right === bottom && bottom === left ? top : [ top, right, bottom, left ];
+}
+
+function getShadowTransform(ui, canvas, _shape, shadow, outBounds, otherScale, isInnerShaodw) {
+    if (shadow.spread) {
+        const spreadScale = 1 + shadow.spread * 2 / ui.__layout.strokeBounds.width * otherScale * (isInnerShaodw ? -1 : 1);
+        tempMatrix.set().scaleOfOuter({
+            x: (outBounds.x + outBounds.width / 2) * canvas.pixelRatio,
+            y: (outBounds.y + outBounds.height / 2) * canvas.pixelRatio
+        }, spreadScale);
+        return tempMatrix;
+    }
+    return undefined;
 }
 
-function drawWorldShadow(canvas, outBounds, spreadScale, shape) {
-    const {bounds: bounds, shapeBounds: shapeBounds} = shape;
+function drawWorldShadow(canvas, outBounds, shape) {
+    const {shapeBounds: shapeBounds} = shape;
+    let from, to;
     if (core.Platform.fullImageShadow) {
         copy(tempBounds, canvas.bounds);
-        tempBounds.x += outBounds.x - shapeBounds.x;
-        tempBounds.y += outBounds.y - shapeBounds.y;
-        if (spreadScale) {
-            const {fitMatrix: fitMatrix} = shape;
-            tempBounds.x -= (bounds.x + (fitMatrix ? fitMatrix.e : 0) + bounds.width / 2) * (spreadScale - 1);
-            tempBounds.y -= (bounds.y + (fitMatrix ? fitMatrix.f : 0) + bounds.height / 2) * (spreadScale - 1);
-            tempBounds.width *= spreadScale;
-            tempBounds.height *= spreadScale;
-        }
-        canvas.copyWorld(shape.canvas, canvas.bounds, tempBounds);
+        move(tempBounds, outBounds.x - shapeBounds.x, outBounds.y - shapeBounds.y);
+        from = canvas.bounds, to = tempBounds;
     } else {
-        if (spreadScale) {
-            copy(tempBounds, outBounds);
-            tempBounds.x -= outBounds.width / 2 * (spreadScale - 1);
-            tempBounds.y -= outBounds.height / 2 * (spreadScale - 1);
-            tempBounds.width *= spreadScale;
-            tempBounds.height *= spreadScale;
-        }
-        canvas.copyWorld(shape.canvas, shapeBounds, spreadScale ? tempBounds : outBounds);
+        from = shapeBounds, to = outBounds;
     }
+    canvas.copyWorld(shape.canvas, from, to);
 }
 
 const {toOffsetOutBounds: toOffsetOutBounds} = core.BoundsHelper;
@@ -1638,13 +1669,13 @@ const {toOffsetOutBounds: toOffsetOutBounds} = core.BoundsHelper;
 const offsetOutBounds = {};
 
 function innerShadow(ui, current, shape) {
-    let copyBounds, spreadScale;
-    const {__nowWorld: nowWorld, __layout: __layout} = ui;
+    let copyBounds, transform;
+    const {__nowWorld: nowWorld} = ui;
     const {innerShadow: innerShadow} = ui.__;
-    const {worldCanvas: worldCanvas, bounds: bounds, shapeBounds: shapeBounds, scaleX: scaleX, scaleY: scaleY} = shape;
+    const {worldCanvas: worldCanvas, bounds: bounds, renderBounds: renderBounds, shapeBounds: shapeBounds, scaleX: scaleX, scaleY: scaleY} = shape;
     const other = current.getSameCanvas();
     const end = innerShadow.length - 1;
-    toOffsetOutBounds(bounds, offsetOutBounds);
+    toOffsetOutBounds(bounds, offsetOutBounds, renderBounds);
     innerShadow.forEach((item, index) => {
         let otherScale = 1;
         if (item.scaleFixed) {
@@ -1653,16 +1684,17 @@ function innerShadow(ui, current, shape) {
         }
         other.save();
         other.setWorldShadow(offsetOutBounds.offsetX + item.x * scaleX * otherScale, offsetOutBounds.offsetY + item.y * scaleY * otherScale, item.blur * scaleX * otherScale);
-        spreadScale = item.spread ? 1 - item.spread * 2 / (__layout.boxBounds.width + (__layout.strokeBoxSpread || 0) * 2) * otherScale : 0;
-        drawWorldShadow(other, offsetOutBounds, spreadScale, shape);
+        transform = getShadowTransform(ui, other, shape, item, offsetOutBounds, otherScale, true);
+        if (transform) other.setTransform(transform);
+        drawWorldShadow(other, offsetOutBounds, shape);
         other.restore();
         if (worldCanvas) {
-            other.copyWorld(other, bounds, nowWorld, "copy");
+            other.copyWorld(other, renderBounds, nowWorld, "copy");
             other.copyWorld(worldCanvas, nowWorld, nowWorld, "source-out");
             copyBounds = nowWorld;
         } else {
             other.copyWorld(shape.canvas, shapeBounds, bounds, "source-out");
-            copyBounds = bounds;
+            copyBounds = renderBounds;
         }
         other.fillWorld(copyBounds, draw.ColorConvert.string(item.color), "source-in");
         core.LeafHelper.copyCanvasByWorld(ui, current, other, copyBounds, item.blendMode);
@@ -1671,6 +1703,8 @@ function innerShadow(ui, current, shape) {
     other.recycle(copyBounds);
 }
 
+const getInnerShadowSpread = getShadowRenderSpread;
+
 function blur(ui, current, origin) {
     const {blur: blur} = ui.__;
     origin.setWorldBlur(blur * ui.__nowWorld.a);
@@ -1685,10 +1719,12 @@ const EffectModule = {
     innerShadow: innerShadow,
     blur: blur,
     backgroundBlur: backgroundBlur,
-    getShadowSpread: getShadowSpread,
+    getShadowRenderSpread: getShadowRenderSpread,
+    getShadowTransform: getShadowTransform,
     isTransformShadow(_shadow) {
         return undefined;
-    }
+    },
+    getInnerShadowSpread: getInnerShadowSpread
 };
 
 const {excludeRenderBounds: excludeRenderBounds} = core.LeafBoundsHelper;
@@ -1705,6 +1741,7 @@ draw.Group.prototype.__renderMask = function(canvas, options) {
                 maskEnd(this, currentMask, canvas, contentCanvas, maskCanvas, maskOpacity, undefined, true);
                 maskCanvas = contentCanvas = null;
             }
+            if (mask === "clipping" || mask === "clipping-path") excludeRenderBounds(child, options) || child.__render(canvas, options);
             maskOpacity = child.__.opacity;
             usedGrayscaleAlpha = false;
             if (mask === "path" || mask === "clipping-path") {
@@ -1722,7 +1759,6 @@ draw.Group.prototype.__renderMask = function(canvas, options) {
                 if (!contentCanvas) contentCanvas = getCanvas(canvas);
                 child.__render(maskCanvas, options);
             }
-            if (mask === "clipping" || mask === "clipping-path") excludeRenderBounds(child, options) || child.__render(canvas, options);
             continue;
         }
         const childBlendMode = maskOpacity === 1 && child.__.__blendMode;
@@ -2420,14 +2456,10 @@ const ExportModule = {
                     renderOptions.bounds = canvas.bounds;
                 }
                 canvas.save();
-                if (isFrame && !draw.isUndefined(fill)) {
-                    const oldFill = leaf.get("fill");
-                    leaf.fill = "";
-                    leaf.__render(canvas, renderOptions);
-                    leaf.fill = oldFill;
-                } else {
-                    leaf.__render(canvas, renderOptions);
-                }
+                const igroneFill = isFrame && !draw.isUndefined(fill), oldFill = leaf.get("fill");
+                if (igroneFill) leaf.fill = "";
+                draw.Platform.render(leaf, canvas, renderOptions);
+                if (igroneFill) leaf.fill = oldFill;
                 canvas.restore();
                 if (sliceLeaf) sliceLeaf.__updateWorldOpacity();
                 if (trim) {