@leafer/helper 1.0.0-rc.8 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/helper",
-  "version": "1.0.0-rc.8",
+  "version": "1.0.0",
   "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.8"
+    "@leafer/math": "1.0.0"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.8"
+    "@leafer/interface": "1.0.0"
   }
 }

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 } from '@leafer/interface'
+import { MathHelper, MatrixHelper, PointHelper, AroundHelper } from '@leafer/math'
 
 
 const { copy, toInnerPoint, scaleOfOuter, rotateOfOuter, skewOfOuter, multiplyParent, divideParent, getLayout } = MatrixHelper
@@ -76,19 +76,24 @@ 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 {
@@ -99,7 +104,7 @@ export const LeafHelper = {
     },
 
     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 {
@@ -110,7 +115,7 @@ export const LeafHelper = {
     },
 
     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 +124,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)
@@ -128,18 +140,34 @@ export const LeafHelper = {
     setTransform(t: ILeaf, transform: IMatrixData, resize?: boolean): void {
         const layout = getLayout(transform)
         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)
     },
 
+    getLocalOrigin(t: ILeaf, origin: IPointData | IAlign): IPointData {
+        return PointHelper.tempToOuterOf(L.getInnerOrigin(t, origin), t.localTransform)
+    },
 
-    drop(t: ILeaf, parent: ILeaf, index?: number, resize?: boolean): void {
+    getInnerOrigin(t: ILeaf, origin: IPointData | IAlign): IPointData {
+        if (typeof origin === 'string') AroundHelper.toPoint(origin, t.boxBounds, origin = {} as IPointData)
+        return origin
+    },
+
+    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 +177,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, IAlign, IBoundsData, IRenderOptions, ILeafList, ILeafLevelList, IFunction } from '@leafer/interface';
 
 declare const LeafHelper: {
     updateAllMatrix(leaf: ILeaf, checkAutoLayout?: boolean, waitAutoLayout?: boolean): void;
@@ -7,19 +7,22 @@ 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;
+    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 +33,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: {