@leafer/helper 1.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023-present, Chao (Leafer) Wan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @leafer/helper

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@leafer/helper",
+  "version": "1.0.0-alpha.1",
+  "description": "@leafer/helper",
+  "author": "Chao (Leafer) Wan",
+  "license": "MIT",
+  "main": "src/index.ts",
+  "files": ["src"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leaferjs/leafer.git"
+  },
+  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/helper",
+  "bugs": "https://github.com/leaferjs/leafer/issues",
+  "keywords": [
+    "leafer",
+    "leaferjs"
+  ],
+  "dependencies": {
+    "@leafer/math": "1.0.0-alpha.1"
+  },
+  "devDependencies": {
+     "@leafer/interface": "1.0.0-alpha.1"
+  }
+}

package/src/BranchHelper.ts

@@ -0,0 +1,79 @@
+import { ILeaf, ILeafList } from '@leafer/interface'
+
+
+interface ILeafPushList {
+    push(item: ILeaf): void
+}
+
+
+export const BranchHelper = {
+
+    sort(a: ILeaf, b: ILeaf): number {
+        return (a.__.zIndex === b.__.zIndex) ? (a.__tempNumber - b.__tempNumber) : (a.__.zIndex - b.__.zIndex)
+    },
+
+    // push
+
+    pushAllChildBranch(branch: ILeaf, pushList: ILeafPushList): void {
+        branch.__tempNumber = 1   // 标识需要更新子Leaf元素的WorldBounds分支 Layouter需使用
+
+        if (branch.__childBranchNumber) {
+            const { children } = branch
+            for (let i = 0, len = children.length; i < len; i++) {
+                branch = children[i]
+                if (branch.__isBranch) {
+                    branch.__tempNumber = 1
+                    pushList.push(branch)
+                    pushAllChildBranch(branch, pushList)
+                }
+            }
+        }
+    },
+
+    pushAllParent(leaf: ILeaf, pushList: ILeafPushList): void {
+        const { keys } = (pushList as ILeafList)
+        if (keys) {
+            while (leaf.parent) {
+                if (keys[leaf.parent.innerId] === undefined) {
+                    pushList.push(leaf.parent)
+                    leaf = leaf.parent
+                } else {
+                    break
+                }
+            }
+        } else {
+            while (leaf.parent) {
+                pushList.push(leaf.parent)
+                leaf = leaf.parent
+            }
+        }
+    },
+
+    pushAllBranchStack(branch: ILeaf, pushList: ILeaf[]): void {
+        let start = pushList.length
+        const { children } = branch
+        for (let i = 0, len = children.length; i < len; i++) {
+            if (children[i].__isBranch) {
+                pushList.push(children[i])
+            }
+        }
+
+        // 找子级
+        for (let i = start, len = pushList.length; i < len; i++) {
+            pushAllBranchStack(pushList[i], pushList)
+        }
+    },
+
+    updateWorldBoundsByBranchStack(branchStack: ILeaf[]): void {
+        let branch: ILeaf
+        for (let i = branchStack.length - 1; i > -1; i--) {
+            branch = branchStack[i]
+            for (let j = 0, len = branch.children.length; j < len; j++) {
+                branch.children[j].__updateWorldBounds()
+            }
+        }
+        branch.__updateWorldBounds()
+    }
+}
+
+const { pushAllChildBranch, pushAllBranchStack } = BranchHelper

package/src/LeafBoundsHelper.ts

@@ -0,0 +1,22 @@
+import { ILeaf, IBoundsData } from '@leafer/interface'
+
+
+export const LeafBoundsHelper = {
+
+    worldBounds(target: ILeaf): IBoundsData {
+        return target.__world
+    },
+
+    relativeBoxBounds(target: ILeaf): IBoundsData {
+        return target.__relative
+    },
+
+    relativeEventBounds(target: ILeaf): IBoundsData {
+        return target.__layout.relativeEventBounds
+    },
+
+    relativeRenderBounds(target: ILeaf): IBoundsData {
+        return target.__layout.relativeRenderBounds
+    }
+
+}

package/src/LeafHelper.ts

@@ -0,0 +1,94 @@
+import { ILeaf, IPointData } from '@leafer/interface'
+import { Matrix, MatrixHelper, PointHelper } from '@leafer/math'
+
+
+export const LeafHelper = {
+
+    updateAllWorldMatrix(leaf: ILeaf): void {
+        leaf.__updateWorldMatrix()
+
+        if (leaf.__isBranch) {
+            const { children } = leaf
+            for (let i = 0, len = children.length; i < len; i++) {
+                updateAllWorldMatrix(children[i])
+            }
+        }
+    },
+
+    updateAllWorldOpacity(leaf: ILeaf): void {
+        leaf.__updateWorldOpacity()
+
+        if (leaf.__isBranch) {
+            const { children } = leaf
+            for (let i = 0, len = children.length; i < len; i++) {
+                updateAllWorldOpacity(children[i])
+            }
+        }
+    },
+
+    updateAllChange(leaf: ILeaf): void {
+
+        updateAllWorldOpacity(leaf)
+
+        leaf.__updateChange()
+
+        if (leaf.__isBranch) {
+            const { children } = leaf
+            for (let i = 0, len = children.length; i < len; i++) {
+                updateAllChange(children[i])
+            }
+        }
+    },
+
+
+    // transform
+
+    moveByWorld(t: ILeaf, worldX: number, worldY: number): void {
+        const local = { x: worldX, y: worldY }
+        if (t.parent) MatrixHelper.toLocalPoint(t.parent.__world, local, local, true)
+        L.move(t, local.x, local.y)
+    },
+
+    move(t: ILeaf, x: number, y: number): void {
+        t.x = t.__.x + x
+        t.y = t.__.y + y
+    },
+
+    zoomByWorld(t: ILeaf, scale: number, world: IPointData, moveLayer?: ILeaf): void {
+        const local = t.parent ? PointHelper.tempToLocal(world, t.parent.__world) : world
+        this.zoom(t, scale, local, moveLayer)
+    },
+
+    zoom(t: ILeaf, scale: number, local: IPointData, moveLayer?: ILeaf): void {
+        if (!moveLayer) moveLayer = t
+        const { x, y } = moveLayer.__
+        const { scaleX, scaleY } = t.__
+        const centerX = local.x - x
+        const centerY = local.y - y
+        const matrix = new Matrix().translate(centerX, centerY).scale(scale).translate(-centerX, -centerY)
+        moveLayer.x = x - matrix.e
+        moveLayer.y = y - matrix.f
+        t.scaleX = scaleX * scale
+        t.scaleY = scaleY * scale
+    },
+
+    rotateByWorld(t: ILeaf, angle: number, world: IPointData, moveLayer?: ILeaf): void {
+        const local = t.parent ? PointHelper.tempToLocal(world, t.parent.__world) : world
+        this.rotate(t, angle, local, moveLayer)
+    },
+
+    rotate(t: ILeaf, angle: number, local: IPointData, moveLayer?: ILeaf): void {
+        if (!moveLayer) moveLayer = t
+        const { x, y } = moveLayer.__
+        const { rotation } = t.__
+        const centerX = local.x - x
+        const centerY = local.y - y
+        const matrix = new Matrix().translate(centerX, centerY).rotate(angle).translate(-centerX, -centerY)
+        moveLayer.x = x - matrix.e
+        moveLayer.y = y - matrix.f
+        t.rotation = rotation + angle
+    }
+
+}
+const L = LeafHelper
+const { updateAllWorldMatrix, updateAllWorldOpacity, updateAllChange } = L

package/src/index.ts

@@ -0,0 +1,3 @@
+export { LeafHelper } from './LeafHelper'
+export { LeafBoundsHelper } from './LeafBoundsHelper'
+export { BranchHelper } from './BranchHelper'