@leafer/helper 1.0.0-rc.9 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/helper",
-  "version": "1.0.0-rc.9",
+  "version": "1.0.1",
   "description": "@leafer/helper",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -15,16 +15,16 @@
     "type": "git",
     "url": "https://github.com/leaferjs/leafer.git"
   },
-  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/helper",
+  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/display-module/helper",
   "bugs": "https://github.com/leaferjs/leafer/issues",
   "keywords": [
     "leafer",
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/math": "1.0.0-rc.9"
+    "@leafer/math": "1.0.1"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.9"
+    "@leafer/interface": "1.0.1"
   }
 }

package/src/LeafBoundsHelper.ts

@@ -1,4 +1,4 @@
-import { ILeaf, IBoundsData } from '@leafer/interface'
+import { ILeaf, IBoundsData, IRenderOptions } from '@leafer/interface'
 
 
 export const LeafBoundsHelper = {
@@ -8,27 +8,33 @@ export const LeafBoundsHelper = {
     },
 
     localBoxBounds(target: ILeaf): IBoundsData {
-        return target.__.isEraser ? null : (target.__local || target.__ as IBoundsData)
+        return target.__.eraser || target.__.visible === 0 ? null : (target.__local || target.__layout)
     },
 
     localStrokeBounds(target: ILeaf): IBoundsData {
-        return target.__.isEraser ? null : target.__layout.localStrokeBounds
+        return target.__.eraser || target.__.visible === 0 ? null : target.__layout.localStrokeBounds
     },
 
     localRenderBounds(target: ILeaf): IBoundsData {
-        return target.__.isEraser ? null : target.__layout.localRenderBounds
+        return target.__.eraser || target.__.visible === 0 ? null : target.__layout.localRenderBounds
     },
 
     maskLocalBoxBounds(target: ILeaf): IBoundsData {
-        return target.__.isMask ? target.__localBounds : null
+        return target.__.mask ? target.__localBoxBounds : null
     },
 
     maskLocalStrokeBounds(target: ILeaf): IBoundsData {
-        return target.__.isMask ? target.__layout.localStrokeBounds : null
+        return target.__.mask ? target.__layout.localStrokeBounds : null
     },
 
     maskLocalRenderBounds(target: ILeaf): IBoundsData {
-        return target.__.isMask ? target.__layout.localRenderBounds : null
+        return target.__.mask ? target.__layout.localRenderBounds : null
+    },
+
+    excludeRenderBounds(child: ILeaf, options: IRenderOptions): boolean {
+        if (options.bounds && !options.bounds.hit(child.__world, options.matrix)) return true
+        if (options.hideBounds && options.hideBounds.includes(child.__world, options.matrix)) return true
+        return false
     }
 
 }

package/src/LeafHelper.ts

@@ -1,5 +1,5 @@
-import { ILeaf, IMatrixData, IPointData } from '@leafer/interface'
-import { MathHelper, MatrixHelper, PointHelper } from '@leafer/math'
+import { IAlign, ILeaf, IMatrixData, IPointData, IAxis } from '@leafer/interface'
+import { MathHelper, MatrixHelper, PointHelper, AroundHelper, getMatrixData } from '@leafer/math'
 
 
 const { copy, toInnerPoint, scaleOfOuter, rotateOfOuter, skewOfOuter, multiplyParent, divideParent, getLayout } = MatrixHelper
@@ -76,41 +76,54 @@ export const LeafHelper = {
 
     // transform
 
-    moveWorld(t: ILeaf, x: number, y: number): void {
-        const local = { x, y }
+    moveWorld(t: ILeaf, x: number | IPointData, y = 0): void {
+        const local = typeof x === 'object' ? { ...x } : { x, y }
         if (t.parent) toInnerPoint(t.parent.worldTransform, local, local, true)
         L.moveLocal(t, local.x, local.y)
     },
 
-    moveLocal(t: ILeaf, x: number, y: number = 0): void {
-        t.x += x
-        t.y += y
+    moveLocal(t: ILeaf, x: number | IPointData, y = 0): void {
+        if (typeof x === 'object') {
+            t.x += x.x
+            t.y += x.y
+        } else {
+            t.x += x
+            t.y += y
+        }
     },
 
     zoomOfWorld(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number, resize?: boolean): void {
-        this.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize)
+        L.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize)
     },
 
     zoomOfLocal(t: ILeaf, origin: IPointData, scaleX: number, scaleY: number = scaleX, resize?: boolean): void {
         copy(matrix, t.__localMatrix)
         scaleOfOuter(matrix, origin, scaleX, scaleY)
-        moveByMatrix(t, matrix)
-        t.scaleResize(scaleX, scaleY, resize !== true)
+        if (t.origin || t.around) {
+            L.setTransform(t, matrix, resize)
+        } else {
+            moveByMatrix(t, matrix)
+            t.scaleResize(scaleX, scaleY, resize !== true)
+        }
     },
 
     rotateOfWorld(t: ILeaf, origin: IPointData, angle: number): void {
-        this.rotateOfLocal(t, getTempLocal(t, origin), angle)
+        L.rotateOfLocal(t, getTempLocal(t, origin), angle)
     },
 
     rotateOfLocal(t: ILeaf, origin: IPointData, angle: number): void {
         copy(matrix, t.__localMatrix)
         rotateOfOuter(matrix, origin, angle)
-        moveByMatrix(t, matrix)
-        t.rotation = MathHelper.formatRotation(t.rotation + angle)
+        if (t.origin || t.around) {
+            L.setTransform(t, matrix)
+        } else {
+            moveByMatrix(t, matrix)
+            t.rotation = MathHelper.formatRotation(t.rotation + angle)
+        }
     },
 
     skewOfWorld(t: ILeaf, origin: IPointData, skewX: number, skewY?: number, resize?: boolean): void {
-        this.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize)
+        L.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize)
     },
 
     skewOfLocal(t: ILeaf, origin: IPointData, skewX: number, skewY: number = 0, resize?: boolean): void {
@@ -119,6 +132,13 @@ export const LeafHelper = {
         L.setTransform(t, matrix, resize)
     },
 
+    transformWorld(t: ILeaf, transform: IMatrixData, resize?: boolean): void {
+        copy(matrix, t.worldTransform)
+        multiplyParent(matrix, transform)
+        if (t.parent) divideParent(matrix, t.parent.worldTransform)
+        L.setTransform(t, matrix, resize)
+    },
+
     transform(t: ILeaf, transform: IMatrixData, resize?: boolean): void {
         copy(matrix, t.localTransform)
         multiplyParent(matrix, transform)
@@ -126,20 +146,44 @@ export const LeafHelper = {
     },
 
     setTransform(t: ILeaf, transform: IMatrixData, resize?: boolean): void {
-        const layout = getLayout(transform)
+        const layout = getLayout(transform, t.origin && L.getInnerOrigin(t, t.origin), t.around && L.getInnerOrigin(t, t.around))
         if (resize) {
-            t.scaleResize(layout.scaleX / t.scaleX, layout.scaleY / t.scaleY, resize !== true)
+            const scaleX = layout.scaleX / t.scaleX
+            const scaleY = layout.scaleY / t.scaleY
             delete layout.scaleX
             delete layout.scaleY
+            t.set(layout)
+            t.scaleResize(scaleX, scaleY, resize !== true)
+        } else {
+            t.set(layout)
         }
-        t.set(layout)
     },
 
+    getFlipTransform(t: ILeaf, axis: IAxis): IMatrixData {
+        const m = getMatrixData()
+        const sign = axis === 'x' ? 1 : -1
+        scaleOfOuter(m, L.getLocalOrigin(t, 'center'), -1 * sign, 1 * sign)
+        return m
+    },
 
-    drop(t: ILeaf, parent: ILeaf, index?: number, resize?: boolean): void {
+    getLocalOrigin(t: ILeaf, origin: IPointData | IAlign): IPointData {
+        return PointHelper.tempToOuterOf(L.getInnerOrigin(t, origin), t.localTransform)
+    },
+
+    getInnerOrigin(t: ILeaf, origin: IPointData | IAlign): IPointData {
+        const innerOrigin = {} as IPointData
+        AroundHelper.toPoint(origin, t.boxBounds, innerOrigin)
+        return innerOrigin
+    },
+
+    getRelativeWorld(t: ILeaf, relative: ILeaf, temp?: boolean): IMatrixData {
         copy(matrix, t.worldTransform)
-        divideParent(matrix, parent.worldTransform)
-        t.setTransform(matrix, resize)
+        divideParent(matrix, relative.worldTransform)
+        return temp ? matrix : { ...matrix }
+    },
+
+    drop(t: ILeaf, parent: ILeaf, index?: number, resize?: boolean): void {
+        t.setTransform(L.getRelativeWorld(t, parent, true), resize)
         parent.add(t, index)
     },
 
@@ -149,13 +193,6 @@ export const LeafHelper = {
             if (parent === p) return true
             p = p.parent
         }
-    },
-
-    hasParentAutoLayout(p: ILeaf): boolean | void {
-        while (p.parent) {
-            p = p.parent
-            if (p.__hasAutoLayout) return true
-        }
     }
 
 }

package/src/WaitHelper.ts

@@ -2,7 +2,10 @@ import { IFunction } from '@leafer/interface'
 
 export const WaitHelper = {
     run(wait: IFunction[]): void {
-        for (let i = 0, len = wait.length; i < len; i++) { wait[i]() }
-        wait.length = 0
+        if (wait && wait.length) {
+            const len = wait.length
+            for (let i = 0; i < len; i++) { wait[i]() }
+            wait.length === len ? wait.length = 0 : wait.splice(0, len)
+        }
     }
 }

package/types/index.d.ts

@@ -1,4 +1,4 @@
-import { ILeaf, IPointData, IMatrixData, IBoundsData, ILeafList, ILeafLevelList, IFunction } from '@leafer/interface';
+import { ILeaf, IPointData, IMatrixData, IAxis, IAlign, IBoundsData, IRenderOptions, ILeafList, ILeafLevelList, IFunction } from '@leafer/interface';
 
 declare const LeafHelper: {
     updateAllMatrix(leaf: ILeaf, checkAutoLayout?: boolean, waitAutoLayout?: boolean): void;
@@ -7,19 +7,23 @@ declare const LeafHelper: {
     updateAllWorldOpacity(leaf: ILeaf): void;
     updateAllChange(leaf: ILeaf): void;
     worldHittable(t: ILeaf): boolean;
-    moveWorld(t: ILeaf, x: number, y: number): void;
-    moveLocal(t: ILeaf, x: number, y?: number): void;
+    moveWorld(t: ILeaf, x: number | IPointData, y?: number): void;
+    moveLocal(t: ILeaf, x: number | IPointData, y?: number): void;
     zoomOfWorld(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number, resize?: boolean): void;
     zoomOfLocal(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number, resize?: boolean): void;
     rotateOfWorld(t: ILeaf, origin: IPointData, angle: number): void;
     rotateOfLocal(t: ILeaf, origin: IPointData, angle: number): void;
     skewOfWorld(t: ILeaf, origin: IPointData, skewX: number, skewY?: number, resize?: boolean): void;
     skewOfLocal(t: ILeaf, origin: IPointData, skewX: number, skewY?: number, resize?: boolean): void;
+    transformWorld(t: ILeaf, transform: IMatrixData, resize?: boolean): void;
     transform(t: ILeaf, transform: IMatrixData, resize?: boolean): void;
     setTransform(t: ILeaf, transform: IMatrixData, resize?: boolean): void;
+    getFlipTransform(t: ILeaf, axis: IAxis): IMatrixData;
+    getLocalOrigin(t: ILeaf, origin: IPointData | IAlign): IPointData;
+    getInnerOrigin(t: ILeaf, origin: IPointData | IAlign): IPointData;
+    getRelativeWorld(t: ILeaf, relative: ILeaf, temp?: boolean): IMatrixData;
     drop(t: ILeaf, parent: ILeaf, index?: number, resize?: boolean): void;
     hasParent(p: ILeaf, parent: ILeaf): boolean | void;
-    hasParentAutoLayout(p: ILeaf): boolean | void;
 };
 
 declare const LeafBoundsHelper: {
@@ -30,6 +34,7 @@ declare const LeafBoundsHelper: {
     maskLocalBoxBounds(target: ILeaf): IBoundsData;
     maskLocalStrokeBounds(target: ILeaf): IBoundsData;
     maskLocalRenderBounds(target: ILeaf): IBoundsData;
+    excludeRenderBounds(child: ILeaf, options: IRenderOptions): boolean;
 };
 
 declare const BranchHelper: {