@leafer/helper 1.0.0-rc.4 → 1.0.0-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/helper",
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0-rc.6",
   "description": "@leafer/helper",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,9 +22,9 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/math": "1.0.0-rc.4"
+    "@leafer/math": "1.0.0-rc.6"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.4"
+    "@leafer/interface": "1.0.0-rc.6"
   }
 }

package/src/LeafHelper.ts

@@ -2,7 +2,7 @@ import { IBranch, ILeaf, IMatrixData, IPointData } from '@leafer/interface'
 import { MathHelper, MatrixHelper, PointHelper } from '@leafer/math'
 
 
-const { copy, translate, toInnerPoint, scaleOfOuter, rotateOfOuter, skewOfOuter } = MatrixHelper
+const { copy, toInnerPoint, scaleOfOuter, rotateOfOuter, skewOfOuter } = MatrixHelper
 const matrix = {} as IMatrixData
 
 export const LeafHelper = {
@@ -56,9 +56,8 @@ export const LeafHelper = {
     // transform
 
     moveWorld(t: ILeaf, x: number, y: number): void {
-        t.__layout.checkUpdate()
         const local = { x, y }
-        if (t.parent) toInnerPoint(t.parent.__world, local, local, true)
+        if (t.parent) toInnerPoint(t.parent.worldTransform, local, local, true)
         L.moveLocal(t, local.x, local.y)
     },
 
@@ -67,53 +66,37 @@ export const LeafHelper = {
         t.y += y
     },
 
-    zoomOfWorld(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number, moveLayer?: ILeaf): void {
-        t.__layout.checkUpdate()
-        const local = t.parent ? PointHelper.tempToInnerOf(origin, t.parent.__world) : origin
-        this.zoomOfLocal(t, local, scaleX, scaleY, moveLayer)
+    zoomOfWorld(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number): void {
+        this.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY)
     },
 
-    zoomOfLocal(t: ILeaf, origin: IPointData, scaleX: number, scaleY: number = scaleX, moveLayer?: ILeaf): void {
+    zoomOfLocal(t: ILeaf, origin: IPointData, scaleX: number, scaleY: number = scaleX): void {
         copy(matrix, t.__local)
-        if (moveLayer) translate(matrix, moveLayer.x, moveLayer.y)
         scaleOfOuter(matrix, origin, scaleX, scaleY)
-        if (!moveLayer) moveLayer = t
-        moveLayer.x += matrix.e - t.__local.e
-        moveLayer.y += matrix.f - t.__local.f
+        moveByMatrix(t, matrix)
         t.scaleX *= scaleX
         t.scaleY *= scaleY
     },
 
-    rotateOfWorld(t: ILeaf, origin: IPointData, angle: number, moveLayer?: ILeaf): void {
-        t.__layout.checkUpdate()
-        const local = t.parent ? PointHelper.tempToInnerOf(origin, t.parent.__world) : origin
-        this.rotateOfLocal(t, local, angle, moveLayer)
+    rotateOfWorld(t: ILeaf, origin: IPointData, angle: number): void {
+        this.rotateOfLocal(t, getTempLocal(t, origin), angle)
     },
 
-    rotateOfLocal(t: ILeaf, origin: IPointData, angle: number, moveLayer?: ILeaf): void {
+    rotateOfLocal(t: ILeaf, origin: IPointData, angle: number): void {
         copy(matrix, t.__local)
-        if (moveLayer) translate(matrix, moveLayer.x, moveLayer.y)
         rotateOfOuter(matrix, origin, angle)
-        if (!moveLayer) moveLayer = t
-        moveLayer.x += matrix.e - t.__local.e
-        moveLayer.y += matrix.f - t.__local.f
+        moveByMatrix(t, matrix)
         t.rotation = MathHelper.formatRotation(t.rotation + angle)
-
     },
 
-    skewOfWorld(t: ILeaf, origin: IPointData, skewX: number, skewY?: number, moveLayer?: ILeaf): void {
-        t.__layout.checkUpdate()
-        const local = t.parent ? PointHelper.tempToInnerOf(origin, t.parent.__world) : origin
-        this.skewOfLocal(t, local, skewX, skewY, moveLayer)
+    skewOfWorld(t: ILeaf, origin: IPointData, skewX: number, skewY?: number): void {
+        this.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY)
     },
 
-    skewOfLocal(t: ILeaf, origin: IPointData, skewX: number, skewY: number, moveLayer?: ILeaf): void {
+    skewOfLocal(t: ILeaf, origin: IPointData, skewX: number, skewY: number): void {
         copy(matrix, t.__local)
-        if (moveLayer) translate(matrix, moveLayer.x, moveLayer.y)
         skewOfOuter(matrix, origin, skewX, skewY)
-        if (!moveLayer) moveLayer = t
-        moveLayer.x = matrix.e - t.__local.e
-        moveLayer.y = matrix.f - t.__local.f
+        moveByMatrix(t, matrix)
         t.skewX = MathHelper.formatSkew(t.skewX + skewX)
         t.skewY = MathHelper.formatSkew(t.skewY + skewY)
     },
@@ -124,8 +107,29 @@ export const LeafHelper = {
         parent.worldToInner(position)
         t.set(position)
         parent.add(t)
+    },
+
+    hasParent(t: ILeaf, parent: ILeaf): boolean {
+        if (!parent) return false
+        let p = t
+        while (p) {
+            if (parent === p) return true
+            p = p.parent
+        }
+        return false
     }
 
 }
+
 const L = LeafHelper
-const { updateAllWorldMatrix, updateAllWorldOpacity, updateAllChange } = L
+const { updateAllWorldMatrix, updateAllWorldOpacity, updateAllChange } = L
+
+function moveByMatrix(t: ILeaf, matrix: IMatrixData): void {
+    t.x += matrix.e - t.__local.e
+    t.y += matrix.f - t.__local.f
+}
+
+function getTempLocal(t: ILeaf, world: IPointData): IPointData {
+    t.__layout.checkUpdate()
+    return t.parent ? PointHelper.tempToInnerOf(world, t.parent.__world) : world
+}

package/types/index.d.ts

@@ -7,13 +7,14 @@ declare const LeafHelper: {
     worldHittable(t: ILeaf): boolean;
     moveWorld(t: ILeaf, x: number, y: number): void;
     moveLocal(t: ILeaf, x: number, y?: number): void;
-    zoomOfWorld(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number, moveLayer?: ILeaf): void;
-    zoomOfLocal(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number, moveLayer?: ILeaf): void;
-    rotateOfWorld(t: ILeaf, origin: IPointData, angle: number, moveLayer?: ILeaf): void;
-    rotateOfLocal(t: ILeaf, origin: IPointData, angle: number, moveLayer?: ILeaf): void;
-    skewOfWorld(t: ILeaf, origin: IPointData, skewX: number, skewY?: number, moveLayer?: ILeaf): void;
-    skewOfLocal(t: ILeaf, origin: IPointData, skewX: number, skewY: number, moveLayer?: ILeaf): void;
+    zoomOfWorld(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number): void;
+    zoomOfLocal(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number): 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): void;
+    skewOfLocal(t: ILeaf, origin: IPointData, skewX: number, skewY: number): void;
     drop(t: ILeaf, parent: IBranch): void;
+    hasParent(t: ILeaf, parent: ILeaf): boolean;
 };
 
 declare const LeafBoundsHelper: {