leafer-draw 2.1.3 → 2.1.5

package/dist/web.module.js

@@ -260,7 +260,7 @@ const IncrementId = {
     RUNTIME: "runtime",
     LEAF: "leaf",
     TASK: "task",
-    CNAVAS: "canvas",
+    CANVAS: "canvas",
     IMAGE: "image",
     types: {},
     create(typeName) {
@@ -914,7 +914,7 @@ const PointHelper = {
         return quick ? t.x === point.x && t.y === point.y : float$1(t.x) === float$1(point.x) && float$1(t.y) === float$1(point.y);
     },
     reset(t) {
-        P$5.reset(t);
+        t.x = t.y = 0;
     }
 };
 
@@ -1123,6 +1123,7 @@ class Matrix {
     }
     reset() {
         MatrixHelper.reset(this);
+        return this;
     }
 }
 
@@ -2346,7 +2347,7 @@ class LeaferCanvasBase extends Canvas$1 {
         this.worldTransform = {};
         if (!config) config = minSize;
         this.manager = manager;
-        this.innerId = IncrementId.create(IncrementId.CNAVAS);
+        this.innerId = IncrementId.create(IncrementId.CANVAS);
         const {width: width, height: height, pixelRatio: pixelRatio} = config;
         this.autoLayout = !width || !height;
         this.size.pixelRatio = pixelRatio || Platform.devicePixelRatio;
@@ -2496,6 +2497,7 @@ class LeaferCanvasBase extends Canvas$1 {
     }
     useGrayscaleAlpha(bounds) {
         this.setTempPixelBounds(bounds, true, true);
+        if (!tempPixelBounds.width || !tempPixelBounds.height) return;
         let alpha, pixel;
         const {context: context} = this, imageData = context.getImageData(tempPixelBounds.x, tempPixelBounds.y, tempPixelBounds.width, tempPixelBounds.height), {data: data} = imageData;
         for (let i = 0, len = data.length; i < len; i += 4) {
@@ -3048,7 +3050,8 @@ const PathConvert = {
                 current.length = PathCommandLengthMap[char];
                 current.index = 0;
                 pushData(data, current.name);
-                if (char === "m") current.name = PathCommandMap["l"]; else if (char === "M") current.name = PathCommandMap["L"]; else if (!needConvert && convertCommand[char]) needConvert = true;
+                if (char === "m") current.name = PathCommandMap["l"]; else if (char === "M") current.name = PathCommandMap["L"];
+                if (!needConvert && convertCommand[char]) needConvert = true;
             } else {
                 if (char === "-" || char === "+") {
                     if (lastChar === "e" || lastChar === "E") {
@@ -3124,8 +3127,8 @@ const PathConvert = {
 
               case S:
                 smooth = lastCommand === C$3 || lastCommand === S;
-                x1 = smooth ? x * 2 - controlX : old[i + 1];
-                y1 = smooth ? y * 2 - controlY : old[i + 2];
+                x1 = smooth ? x * 2 - controlX : x;
+                y1 = smooth ? y * 2 - controlY : y;
                 controlX = old[i + 1];
                 controlY = old[i + 2];
                 x = old[i + 3];
@@ -3159,8 +3162,8 @@ const PathConvert = {
 
               case T:
                 smooth = lastCommand === Q$3 || lastCommand === T;
-                controlX = smooth ? x * 2 - controlX : old[i + 1];
-                controlY = smooth ? y * 2 - controlY : old[i + 2];
+                controlX = smooth ? x * 2 - controlX : x;
+                controlY = smooth ? y * 2 - controlY : y;
                 curveMode ? quadraticCurveTo$1(data, x, y, controlX, controlY, old[i + 1], old[i + 2]) : data.push(Q$3, controlX, controlY, old[i + 1], old[i + 2]);
                 x = old[i + 1];
                 y = old[i + 2];
@@ -4865,10 +4868,10 @@ const LeafHelper = {
             y: y
         }, transition) : (t.x = x, t.y = y);
     },
-    zoomOfWorld(t, origin, scaleX, scaleY, resize, transition) {
-        L.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize, transition);
+    zoomOfWorld(t, origin, scaleX, scaleY, resize, transition, boundsType) {
+        L.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize, transition, boundsType);
     },
-    zoomOfLocal(t, origin, scaleX, scaleY = scaleX, resize, transition) {
+    zoomOfLocal(t, origin, scaleX, scaleY = scaleX, resize, transition, boundsType) {
         const o = t.__localMatrix;
         if (!isNumber(scaleY)) {
             if (scaleY) transition = scaleY;
@@ -4877,7 +4880,7 @@ const LeafHelper = {
         copy$5(matrix, o);
         scaleOfOuter$2(matrix, origin, scaleX, scaleY);
         if (L.hasHighPosition(t)) {
-            L.setTransform(t, matrix, resize, transition);
+            L.setTransform(t, matrix, resize, transition, boundsType);
         } else {
             const x = t.x + matrix.e - o.e, y = t.y + matrix.f - o.f;
             if (transition && !resize) t.animate({
@@ -4885,7 +4888,7 @@ const LeafHelper = {
                 y: y,
                 scaleX: t.scaleX * scaleX,
                 scaleY: t.scaleY * scaleY
-            }, transition); else t.x = x, t.y = y, t.scaleResize(scaleX, scaleY, resize !== true);
+            }, transition); else t.x = x, t.y = y, t.scaleResize(scaleX, scaleY, resize !== true, boundsType);
         }
     },
     rotateOfWorld(t, origin, angle, transition) {
@@ -4909,18 +4912,18 @@ const LeafHelper = {
         skewOfOuter(matrix, origin, skewX, skewY);
         L.setTransform(t, matrix, resize, transition);
     },
-    transformWorld(t, transform, resize, transition) {
+    transformWorld(t, transform, resize, transition, boundsType) {
         copy$5(matrix, t.worldTransform);
         multiplyParent$3(matrix, transform);
         if (t.parent) divideParent(matrix, t.parent.scrollWorldTransform);
-        L.setTransform(t, matrix, resize, transition);
+        L.setTransform(t, matrix, resize, transition, boundsType);
     },
-    transform(t, transform, resize, transition) {
+    transform(t, transform, resize, transition, boundsType) {
         copy$5(matrix, t.localTransform);
         multiplyParent$3(matrix, transform);
-        L.setTransform(t, matrix, resize, transition);
+        L.setTransform(t, matrix, resize, transition, boundsType);
     },
-    setTransform(t, transform, resize, transition) {
+    setTransform(t, transform, resize, transition, boundsType) {
         const data = t.__, originPoint = data.origin && L.getInnerOrigin(t, data.origin);
         const layout = getLayout(transform, originPoint, data.around && L.getInnerOrigin(t, data.around));
         if (L.hasOffset(t)) {
@@ -4936,7 +4939,7 @@ const LeafHelper = {
                 PointHelper.move(layout, originPoint.x - changedPoint.x, originPoint.y - changedPoint.y);
             }
             t.set(layout);
-            t.scaleResize(scaleX, scaleY, false);
+            t.scaleResize(scaleX, scaleY, false, boundsType);
         } else t.set(layout, transition);
     },
     getFlipTransform(t, axis) {
@@ -5518,6 +5521,7 @@ class LeafLayout {
         this.renderChanged = true;
         this.renderSpread || (this.renderSpread = 1);
         this.boundsChanged = true;
+        this.hitCanvasChanged = true;
     }
     scaleChange() {
         this.scaleChanged = true;
@@ -6458,10 +6462,6 @@ let Leaf = class Leaf {
             }
         }
     }
-    set(_data, _isTemp) {}
-    get(_name) {
-        return undefined;
-    }
     setAttr(name, value) {
         this[name] = value;
     }
@@ -6478,37 +6478,10 @@ let Leaf = class Leaf {
     toString(options) {
         return JSON.stringify(this.toJSON(options));
     }
-    toSVG() {
-        return undefined;
-    }
-    __SVG(_data) {}
-    toHTML() {
-        return undefined;
-    }
-    __setAttr(_attrName, _newValue) {
-        return true;
-    }
-    __getAttr(_attrName) {
-        return undefined;
-    }
-    setProxyAttr(_attrName, _newValue) {}
-    getProxyAttr(_attrName) {
-        return undefined;
-    }
-    find(_condition, _options) {
-        return undefined;
-    }
-    findTag(_tag) {
-        return undefined;
-    }
-    findOne(_condition, _options) {
-        return undefined;
-    }
-    findId(_id) {
-        return undefined;
+    scaleResize(scaleX, scaleY = scaleX, _noResize, _boundsType) {
+        this.scaleX *= scaleX;
+        this.scaleY *= scaleY;
     }
-    focus(_value) {}
-    updateState() {}
     updateLayout() {
         this.__layout.update();
     }
@@ -6524,27 +6497,6 @@ let Leaf = class Leaf {
     __extraUpdate() {
         if (this.leaferIsReady) this.leafer.layouter.addExtra(this);
     }
-    __updateWorldMatrix() {}
-    __updateLocalMatrix() {}
-    __updateWorldBounds() {}
-    __updateLocalBounds() {}
-    __updateLocalBoxBounds() {}
-    __updateLocalStrokeBounds() {}
-    __updateLocalRenderBounds() {}
-    __updateBoxBounds(_secondLayout, _bounds) {}
-    __updateContentBounds() {}
-    __updateStrokeBounds(_bounds) {}
-    __updateRenderBounds(_bounds) {}
-    __updateAutoLayout() {}
-    __updateFlowLayout() {}
-    __updateNaturalSize() {}
-    __updateStrokeSpread() {
-        return 0;
-    }
-    __updateRenderSpread() {
-        return 0;
-    }
-    __onUpdateSize() {}
     __updateEraser(value) {
         this.__hasEraser = value ? true : this.children.some(item => item.__.eraser);
     }
@@ -6558,7 +6510,6 @@ let Leaf = class Leaf {
     __updateMask(_value) {
         this.__hasMask = this.children.some(item => item.__.mask && item.__.visible && item.__.opacity);
     }
-    __renderMask(_canvas, _options) {}
     __getNowWorld(options) {
         if (options.matrix) {
             if (!this.__cameraWorld) this.__cameraWorld = {};
@@ -6675,11 +6626,11 @@ let Leaf = class Leaf {
         const layer = this.leafer ? this.leafer.zoomLayer : this;
         return layer.getWorldPoint(page, relative, distance, change);
     }
-    setTransform(matrix, resize, transition) {
-        setTransform(this, matrix, resize, transition);
+    setTransform(matrix, resize, transition, boundsType) {
+        setTransform(this, matrix, resize, transition, boundsType);
     }
-    transform(matrix, resize, transition) {
-        transform(this, matrix, resize, transition);
+    transform(matrix, resize, transition, boundsType) {
+        transform(this, matrix, resize, transition, boundsType);
     }
     move(x, y, transition) {
         moveLocal(this, x, y, transition);
@@ -6687,8 +6638,8 @@ let Leaf = class Leaf {
     moveInner(x, y, transition) {
         moveWorld(this, x, y, true, transition);
     }
-    scaleOf(origin, scaleX, scaleY, resize, transition) {
-        zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize, transition);
+    scaleOf(origin, scaleX, scaleY, resize, transition, boundsType) {
+        zoomOfLocal(this, getLocalOrigin(this, origin), scaleX, scaleY, resize, transition, boundsType);
     }
     rotateOf(origin, rotation, transition) {
         rotateOfLocal(this, getLocalOrigin(this, origin), rotation, transition);
@@ -6696,14 +6647,14 @@ let Leaf = class Leaf {
     skewOf(origin, skewX, skewY, resize, transition) {
         skewOfLocal(this, getLocalOrigin(this, origin), skewX, skewY, resize, transition);
     }
-    transformWorld(worldTransform, resize, transition) {
-        transformWorld(this, worldTransform, resize, transition);
+    transformWorld(worldTransform, resize, transition, boundsType) {
+        transformWorld(this, worldTransform, resize, transition, boundsType);
     }
     moveWorld(x, y, transition) {
         moveWorld(this, x, y, false, transition);
     }
-    scaleOfWorld(worldOrigin, scaleX, scaleY, resize, transition) {
-        zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize, transition);
+    scaleOfWorld(worldOrigin, scaleX, scaleY, resize, transition, boundsType) {
+        zoomOfWorld(this, worldOrigin, scaleX, scaleY, resize, transition, boundsType);
     }
     rotateOfWorld(worldOrigin, rotation) {
         rotateOfWorld(this, worldOrigin, rotation);
@@ -6714,76 +6665,12 @@ let Leaf = class Leaf {
     flip(axis, transition) {
         transform(this, getFlipTransform(this, axis), false, transition);
     }
-    scaleResize(scaleX, scaleY = scaleX, _noResize) {
-        this.scaleX *= scaleX;
-        this.scaleY *= scaleY;
-    }
-    __scaleResize(_scaleX, _scaleY) {}
-    resizeWidth(_width) {}
-    resizeHeight(_height) {}
-    hit(_world, _hitRadius) {
-        return true;
-    }
-    __hitWorld(_point, _forceHitFill) {
-        return true;
-    }
-    __hit(_local, _forceHitFill) {
-        return true;
-    }
-    __hitFill(_inner) {
-        return true;
-    }
-    __hitStroke(_inner, _strokeWidth) {
-        return true;
-    }
-    __hitPixel(_inner) {
-        return true;
-    }
-    __drawHitPath(_canvas) {}
-    __updateHitCanvas() {}
-    __render(_canvas, _options) {}
-    __drawFast(_canvas, _options) {}
-    __draw(_canvas, _options, _originCanvas) {}
-    __clip(_canvas, _options) {}
-    __renderShape(_canvas, _options) {}
-    __drawShape(_canvas, _options) {}
-    __updateWorldOpacity() {}
-    __updateChange() {}
-    __drawPath(_canvas) {}
-    __drawRenderPath(_canvas) {}
-    __updatePath() {}
-    __updateRenderPath(_updateCache) {}
-    getMotionPathData() {
-        return Plugin.need("path");
-    }
-    getMotionPoint(_motionDistance) {
-        return Plugin.need("path");
-    }
-    getMotionTotal() {
-        return 0;
-    }
-    __updateMotionPath() {}
-    __runAnimation(_type, _complete) {}
-    __updateSortChildren() {}
-    add(_child, _index) {}
     remove(_child, destroy) {
         if (this.parent) this.parent.remove(this, destroy);
     }
     dropTo(parent, index, resize) {
         drop(this, parent, index, resize);
     }
-    on(_type, _listener, _options) {}
-    off(_type, _listener, _options) {}
-    on_(_type, _listener, _bind, _options) {
-        return undefined;
-    }
-    off_(_id) {}
-    once(_type, _listener, _captureOrBind, _capture) {}
-    emit(_type, _event, _capture) {}
-    emitEvent(_event, _capture) {}
-    hasEvent(_type, _capture) {
-        return false;
-    }
     static changeAttr(attrName, defaultValue, fn) {
         fn ? this.addAttr(attrName, defaultValue, fn) : defineDataProcessor(this.prototype, attrName, defaultValue);
     }
@@ -7089,7 +6976,7 @@ class LeafLevelList {
     }
 }
 
-const version = "2.1.3";
+const version = "2.1.5";
 
 const debug$4 = Debug.get("LeaferCanvas");
 
@@ -8570,17 +8457,12 @@ let UI = UI_1 = class UI extends Leaf {
         if (!path) this.__drawPathByBox(pen);
         return pen;
     }
-    reset(_data) {}
     set(data, _transition) {
         if (data) Object.assign(this, data);
     }
     get(name) {
         return isString(name) ? this.__.__getInput(name) : this.__.__getInputData(name);
     }
-    createProxyData() {
-        return undefined;
-    }
-    clearProxyData() {}
     find(_condition, _options) {
         return Plugin.need("find");
     }
@@ -8618,6 +8500,7 @@ let UI = UI_1 = class UI extends Leaf {
             data.lazy && !this.__inLazyBounds && !Export.running ? data.__needComputePaint = true : data.__computePaint();
         }
     }
+    __updatePath() {}
     __updateRenderPath(updateCache) {
         const data = this.__;
         if (data.path) {
@@ -8653,7 +8536,6 @@ let UI = UI_1 = class UI extends Leaf {
         this.set(keyframe);
         return Plugin.need("animate");
     }
-    killAnimate(_type, _nextStyle) {}
     export(_filename, _options) {
         return Plugin.need("export");
     }
@@ -8829,8 +8711,6 @@ __decorate([ dataType(100) ], UI.prototype, "placeholderDelay", void 0);
 
 __decorate([ dataType({}) ], UI.prototype, "data", void 0);
 
-__decorate([ rewrite(Leaf.prototype.reset) ], UI.prototype, "reset", null);
-
 UI = UI_1 = __decorate([ useModule(UIBounds), useModule(UIRender), rewriteAble() ], UI);
 
 let Group = class Group extends UI {
@@ -8867,9 +8747,6 @@ let Group = class Group extends UI {
         }
         return data;
     }
-    pick(_hitPoint, _options) {
-        return undefined;
-    }
     addAt(child, index) {
         this.add(child, index);
     }
@@ -8879,11 +8756,6 @@ let Group = class Group extends UI {
     addBefore(child, before) {
         this.add(child, this.children.indexOf(before));
     }
-    add(_child, _index) {}
-    addMany(..._children) {}
-    remove(_child, _destroy) {}
-    removeAll(_destroy) {}
-    clear() {}
 };
 
 __decorate([ dataProcessor(GroupData) ], Group.prototype, "__", void 0);
@@ -9857,51 +9729,6 @@ let Pen = class Pen extends Group {
         this.add(path);
         return this;
     }
-    beginPath() {
-        return this;
-    }
-    moveTo(_x, _y) {
-        return this;
-    }
-    lineTo(_x, _y) {
-        return this;
-    }
-    bezierCurveTo(_x1, _y1, _x2, _y2, _x, _y) {
-        return this;
-    }
-    quadraticCurveTo(_x1, _y1, _x, _y) {
-        return this;
-    }
-    closePath() {
-        return this;
-    }
-    rect(_x, _y, _width, _height) {
-        return this;
-    }
-    roundRect(_x, _y, _width, _height, _cornerRadius) {
-        return this;
-    }
-    ellipse(_x, _y, _radiusX, _radiusY, _rotation, _startAngle, _endAngle, _anticlockwise) {
-        return this;
-    }
-    arc(_x, _y, _radius, _startAngle, _endAngle, _anticlockwise) {
-        return this;
-    }
-    arcTo(_x1, _y1, _x2, _y2, _radius) {
-        return this;
-    }
-    drawEllipse(_x, _y, _radiusX, _radiusY, _rotation, _startAngle, _endAngle, _anticlockwise) {
-        return this;
-    }
-    drawArc(_x, _y, _radius, _startAngle, _endAngle, _anticlockwise) {
-        return this;
-    }
-    drawPoints(_points, _curve, _close) {
-        return this;
-    }
-    clearPath() {
-        return this;
-    }
     paint() {
         const {pathElement: pathElement} = this;
         if (!pathElement.__layout.boxChanged) pathElement.forceUpdate("path");
@@ -10367,7 +10194,7 @@ function checkSizeAndCreateData(ui, attrName, paint, image, leafPaint, boxBounds
             needUpdate = false;
         }
     }
-    if (paint.mode === "brush") PaintImage.brush(leafPaint, ui);
+    if (paint.mode === "brush") PaintImage.brush(leafPaint, ui, attrName);
     if (!leafPaint.data) {
         PaintImage.createData(leafPaint, image, paint, boxBounds);
         const {transform: transform} = leafPaint.data, {opacity: opacity} = paint;