@leafer/core 1.3.2 → 1.4.0

package/lib/core.cjs

@@ -1535,10 +1535,10 @@ const DataHelper = {
         Object.keys(merge).forEach(key => {
             var _a, _b;
             value = merge[key];
-            if ((value === null || value === void 0 ? void 0 : value.constructor) === Object && ((_a = t[key]) === null || _a === void 0 ? void 0 : _a.constructor) === Object)
+            if ((value === null || value === undefined ? undefined : value.constructor) === Object && ((_a = t[key]) === null || _a === undefined ? undefined : _a.constructor) === Object)
                 return assign(t[key], merge[key], exclude && exclude[key]);
             if (exclude && (key in exclude)) {
-                if (((_b = exclude[key]) === null || _b === void 0 ? void 0 : _b.constructor) === Object)
+                if (((_b = exclude[key]) === null || _b === undefined ? undefined : _b.constructor) === Object)
                     assign(t[key] = {}, merge[key], exclude[key]);
                 return;
             }
@@ -1707,7 +1707,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
 function __decorate(decorators, target, key, desc) {
@@ -1775,7 +1775,7 @@ class Canvas {
     }
     setTransform(_a, _b, _c, _d, _e, _f) { }
     resetTransform() { }
-    getTransform() { return void 0; }
+    getTransform() { return undefined; }
     save() { }
     restore() { }
     transform(a, b, c, d, e, f) {
@@ -1832,12 +1832,12 @@ class Canvas {
     ellipse(_x, _y, _radiusX, _radiusY, _rotation, _startAngle, _endAngle, _anticlockwise) { }
     rect(_x, _y, _width, _height) { }
     roundRect(_x, _y, _width, _height, _radius) { }
-    createConicGradient(_startAngle, _x, _y) { return void 0; }
-    createLinearGradient(_x0, _y0, _x1, _y1) { return void 0; }
-    createPattern(_image, _repetition) { return void 0; }
-    createRadialGradient(_x0, _y0, _r0, _x1, _y1, _r1) { return void 0; }
+    createConicGradient(_startAngle, _x, _y) { return undefined; }
+    createLinearGradient(_x0, _y0, _x1, _y1) { return undefined; }
+    createPattern(_image, _repetition) { return undefined; }
+    createRadialGradient(_x0, _y0, _r0, _x1, _y1, _r1) { return undefined; }
     fillText(_text, _x, _y, _maxWidth) { }
-    measureText(_text) { return void 0; }
+    measureText(_text) { return undefined; }
     strokeText(_text, _x, _y, _maxWidth) { }
     destroy() {
         this.context = null;
@@ -1845,79 +1845,79 @@ class Canvas {
 }
 __decorate([
     contextAttr('imageSmoothingEnabled')
-], Canvas.prototype, "smooth", void 0);
+], Canvas.prototype, "smooth", undefined);
 __decorate([
     contextAttr('imageSmoothingQuality')
-], Canvas.prototype, "smoothLevel", void 0);
+], Canvas.prototype, "smoothLevel", undefined);
 __decorate([
     contextAttr('globalAlpha')
-], Canvas.prototype, "opacity", void 0);
+], Canvas.prototype, "opacity", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "fillStyle", void 0);
+], Canvas.prototype, "fillStyle", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "strokeStyle", void 0);
+], Canvas.prototype, "strokeStyle", undefined);
 __decorate([
     contextAttr('lineWidth')
-], Canvas.prototype, "strokeWidth", void 0);
+], Canvas.prototype, "strokeWidth", undefined);
 __decorate([
     contextAttr('lineCap')
-], Canvas.prototype, "strokeCap", void 0);
+], Canvas.prototype, "strokeCap", undefined);
 __decorate([
     contextAttr('lineJoin')
-], Canvas.prototype, "strokeJoin", void 0);
+], Canvas.prototype, "strokeJoin", undefined);
 __decorate([
     contextAttr('lineDashOffset')
-], Canvas.prototype, "dashOffset", void 0);
+], Canvas.prototype, "dashOffset", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "miterLimit", void 0);
+], Canvas.prototype, "miterLimit", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "shadowBlur", void 0);
+], Canvas.prototype, "shadowBlur", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "shadowColor", void 0);
+], Canvas.prototype, "shadowColor", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "shadowOffsetX", void 0);
+], Canvas.prototype, "shadowOffsetX", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "shadowOffsetY", void 0);
+], Canvas.prototype, "shadowOffsetY", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "filter", void 0);
+], Canvas.prototype, "filter", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "font", void 0);
+], Canvas.prototype, "font", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "fontKerning", void 0);
+], Canvas.prototype, "fontKerning", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "fontStretch", void 0);
+], Canvas.prototype, "fontStretch", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "fontVariantCaps", void 0);
+], Canvas.prototype, "fontVariantCaps", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "textAlign", void 0);
+], Canvas.prototype, "textAlign", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "textBaseline", void 0);
+], Canvas.prototype, "textBaseline", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "textRendering", void 0);
+], Canvas.prototype, "textRendering", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "wordSpacing", void 0);
+], Canvas.prototype, "wordSpacing", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "letterSpacing", void 0);
+], Canvas.prototype, "letterSpacing", undefined);
 __decorate([
     contextAttr()
-], Canvas.prototype, "direction", void 0);
+], Canvas.prototype, "direction", undefined);
 __decorate([
     contextMethod()
 ], Canvas.prototype, "setTransform", null);
@@ -3386,7 +3386,7 @@ class TaskItem {
         this.task = task;
     }
     run() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, undefined, undefined, function* () {
             try {
                 if (this.task && !this.isComplete && this.parent.running)
                     yield this.task();
@@ -3698,7 +3698,7 @@ class LeaferImage {
     load(onSuccess, onError) {
         if (!this.loading) {
             this.loading = true;
-            ImageManager.tasker.add(() => __awaiter(this, void 0, void 0, function* () {
+            ImageManager.tasker.add(() => __awaiter(this, undefined, undefined, function* () {
                 return yield Platform.origin.loadImage(this.url).then((img) => {
                     this.ready = true;
                     this.width = img.naturalWidth || img.width;
@@ -3823,10 +3823,10 @@ function autoLayoutType(defaultValue) {
     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);
             }
         }
     }));
@@ -4209,55 +4209,62 @@ const LeafHelper = {
         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$3(matrix, 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$3(matrix, o);
         scaleOfOuter(matrix, origin, scaleX, scaleY);
         if (t.origin || t.around) {
-            L.setTransform(t, matrix, resize);
+            L.setTransform(t, matrix, resize, transition);
         }
         else {
-            moveByMatrix(t, matrix);
-            t.scaleResize(scaleX, scaleY, resize !== true);
+            const x = t.x + matrix.e - o.e, y = t.y + matrix.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$3(matrix, t.__localMatrix);
+    rotateOfLocal(t, origin, angle, transition) {
+        const o = t.__localMatrix;
+        copy$3(matrix, o);
         rotateOfOuter(matrix, origin, angle);
-        if (t.origin || t.around) {
-            L.setTransform(t, matrix);
-        }
-        else {
-            moveByMatrix(t, matrix);
-            t.rotation = MathHelper.formatRotation(t.rotation + angle);
-        }
+        if (t.origin || t.around)
+            L.setTransform(t, matrix, false, transition);
+        else
+            t.set({ x: t.x + matrix.e - o.e, y: t.y + matrix.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$3(matrix, t.__localMatrix);
         skewOfOuter(matrix, origin, skewX, skewY);
-        L.setTransform(t, matrix, resize);
+        L.setTransform(t, matrix, resize, transition);
     },
-    transformWorld(t, transform, resize) {
+    transformWorld(t, transform, resize, transition) {
         copy$3(matrix, t.worldTransform);
         multiplyParent$2(matrix, transform);
         if (t.parent)
             divideParent(matrix, t.parent.worldTransform);
-        L.setTransform(t, matrix, resize);
+        L.setTransform(t, matrix, resize, transition);
     },
-    transform(t, transform, resize) {
+    transform(t, transform, resize, transition) {
         copy$3(matrix, t.localTransform);
         multiplyParent$2(matrix, transform);
-        L.setTransform(t, matrix, resize);
+        L.setTransform(t, matrix, 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) {
@@ -4272,7 +4279,7 @@ const LeafHelper = {
             t.scaleResize(scaleX, scaleY, false);
         }
         else
-            t.set(layout);
+            t.set(layout, transition);
     },
     getFlipTransform(t, axis) {
         const m = getMatrixData();
@@ -4309,11 +4316,6 @@ const LeafHelper = {
 };
 const L = LeafHelper;
 const { updateAllMatrix: updateAllMatrix$1, updateMatrix: updateMatrix$1, updateAllWorldOpacity, updateAllChange } = 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;
@@ -5177,8 +5179,7 @@ const LeafBounds = {
     __updateAutoLayout() {
         this.__layout.matrixChanged = true;
         if (this.isBranch) {
-            if (this.leaferIsReady)
-                this.leafer.layouter.addExtra(this);
+            this.__extraUpdate();
             if (this.__.flow) {
                 if (this.__layout.boxChanged)
                     this.__updateFlowLayout();
@@ -5331,7 +5332,7 @@ exports.Leaf = class Leaf {
     get __worldFlipped() { return this.__world.scaleX < 0 || this.__world.scaleY < 0; }
     get __onlyHitMask() { return this.__hasMask && !this.__.hitChildren; }
     get __ignoreHitWorld() { return (this.__hasMask || this.__hasEraser) && this.__.hitChildren; }
-    get __inLazyBounds() { const { leafer } = this; return leafer && leafer.created && leafer.lazyBounds.hit(this.__world); }
+    get __inLazyBounds() { return this.leaferIsCreated && this.leafer.lazyBounds.hit(this.__world); }
     get pathInputed() { return this.__.__pathInputed; }
     set event(map) { this.on(map); }
     constructor(data) {
@@ -5442,6 +5443,10 @@ exports.Leaf = class Leaf {
     forceRender(_bounds, _sync) {
         this.forceUpdate('surface');
     }
+    __extraUpdate() {
+        if (this.leaferIsReady)
+            this.leafer.layouter.addExtra(this);
+    }
     __updateWorldMatrix() { }
     __updateLocalMatrix() { }
     __updateWorldBounds() { }
@@ -5584,11 +5589,11 @@ exports.Leaf = class Leaf {
         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);
@@ -5596,32 +5601,32 @@ exports.Leaf = class Leaf {
     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;
@@ -6009,7 +6014,7 @@ class LeafLevelList {
     }
 }
 
-const version = "1.3.2";
+const version = "1.4.0";
 
 exports.AlignHelper = AlignHelper;
 exports.AroundHelper = AroundHelper;
@@ -6127,3 +6132,4 @@ exports.tempPoint = tempPoint$2;
 exports.useModule = useModule;
 exports.version = version;
 exports.visibleType = visibleType;
+//# sourceMappingURL=core.cjs.map