@leafer/helper 1.0.0-beta.9 → 1.0.0-rc.2

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@leafer/helper",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.2",
   "description": "@leafer/helper",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
   "main": "src/index.ts",
+  "types": "types/index.d.ts",
   "files": [
-    "src"
+    "src",
+    "types",
+    "dist"
   ],
   "repository": {
     "type": "git",
@@ -19,9 +22,9 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/math": "1.0.0-beta.9"
+    "@leafer/math": "1.0.0-rc.2"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-beta.9"
+    "@leafer/interface": "1.0.0-rc.2"
   }
 }

package/src/LeafHelper.ts

@@ -1,7 +1,10 @@
-import { IBranch, ILeaf, IPointData } from '@leafer/interface'
-import { Matrix, MatrixHelper, PointHelper } from '@leafer/math'
+import { IBranch, ILeaf, IMatrixData, IPointData } from '@leafer/interface'
+import { MathHelper, MatrixHelper, PointHelper } from '@leafer/math'
 
 
+const { copy, translate, toInnerPoint, scaleOfOuter, rotateOfOuter, skewOfOuter } = MatrixHelper
+const matrix = {} as IMatrixData
+
 export const LeafHelper = {
 
     updateAllWorldMatrix(leaf: ILeaf): void {
@@ -53,44 +56,66 @@ export const LeafHelper = {
     // transform
 
     moveWorld(t: ILeaf, x: number, y: number): void {
+        t.__layout.checkUpdate()
         const local = { x, y }
-        if (t.parent) MatrixHelper.toInnerPoint(t.parent.__world, local, local, true)
+        if (t.parent) toInnerPoint(t.parent.__world, local, local, true)
         L.moveLocal(t, local.x, local.y)
     },
 
     moveLocal(t: ILeaf, x: number, y: number = 0): void {
-        t.x = t.__.x + x
-        t.y = t.__.y + y
+        t.x += x
+        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)
     },
 
-    zoomOfLocal(t: ILeaf, origin: IPointData, scaleX: number, scaleY?: number, moveLayer?: ILeaf): void {
-        if (!scaleY) scaleY = scaleX
+    zoomOfLocal(t: ILeaf, origin: IPointData, scaleX: number, scaleY: number = scaleX, moveLayer?: ILeaf): void {
+        copy(matrix, t.__local)
+        if (moveLayer) translate(matrix, moveLayer.x, moveLayer.y)
+        scaleOfOuter(matrix, origin, scaleX, scaleY)
         if (!moveLayer) moveLayer = t
-        const { x, y } = moveLayer.__
-        const matrix = new Matrix().translate(x, y).scaleOfOuter(origin, scaleX, scaleY)
-        moveLayer.x = matrix.e
-        moveLayer.y = matrix.f
-        t.scaleX = t.__.scaleX * scaleX
-        t.scaleY = t.__.scaleY * scaleY
+        moveLayer.x += matrix.e - t.__local.e
+        moveLayer.y += matrix.f - t.__local.f
+        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)
     },
 
     rotateOfLocal(t: ILeaf, origin: IPointData, angle: number, moveLayer?: ILeaf): 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
+        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)
+    },
+
+    skewOfLocal(t: ILeaf, origin: IPointData, skewX: number, skewY: number, moveLayer?: ILeaf): void {
+        copy(matrix, t.__local)
+        if (moveLayer) translate(matrix, moveLayer.x, moveLayer.y)
+        skewOfOuter(matrix, origin, skewX, skewY)
         if (!moveLayer) moveLayer = t
-        const { x, y } = moveLayer.__
-        const matrix = new Matrix().translate(x, y).rotateOfOuter(origin, angle)
-        moveLayer.x = matrix.e
-        moveLayer.y = matrix.f
-        t.rotation = t.__.rotation + angle
+        moveLayer.x = matrix.e - t.__local.e
+        moveLayer.y = matrix.f - t.__local.f
+        t.skewX = MathHelper.formatSkew(t.skewX + skewX)
+        t.skewY = MathHelper.formatSkew(t.skewY + skewY)
     },
 
     drop(t: ILeaf, parent: IBranch): void {

package/types/index.d.ts

@@ -0,0 +1,44 @@
+import { ILeaf, IPointData, IBranch, IBoundsData, IFunction } from '@leafer/interface';
+
+declare const LeafHelper: {
+    updateAllWorldMatrix(leaf: ILeaf): void;
+    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;
+    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;
+    drop(t: ILeaf, parent: IBranch): void;
+};
+
+declare const LeafBoundsHelper: {
+    worldBounds(target: ILeaf): IBoundsData;
+    localBoxBounds(target: ILeaf): IBoundsData;
+    localEventBounds(target: ILeaf): IBoundsData;
+    localRenderBounds(target: ILeaf): IBoundsData;
+    maskLocalBoxBounds(target: ILeaf): IBoundsData;
+    maskLocalEventBounds(target: ILeaf): IBoundsData;
+    maskLocalRenderBounds(target: ILeaf): IBoundsData;
+};
+
+interface ILeafPushList {
+    push(item: ILeaf): void;
+}
+declare const BranchHelper: {
+    sort(a: ILeaf, b: ILeaf): number;
+    pushAllChildBranch(branch: ILeaf, pushList: ILeafPushList): void;
+    pushAllParent(leaf: ILeaf, pushList: ILeafPushList): void;
+    pushAllBranchStack(branch: ILeaf, pushList: ILeaf[]): void;
+    updateWorldBoundsByBranchStack(branchStack: ILeaf[]): void;
+};
+
+declare const WaitHelper: {
+    run(wait: IFunction[]): void;
+};
+
+export { BranchHelper, LeafBoundsHelper, LeafHelper, WaitHelper };