@leafer/helper 1.0.0-rc.3 → 1.0.0-rc.30

package/package.json

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

package/src/BranchHelper.ts

@@ -1,10 +1,8 @@
-import { ILeaf, ILeafList } from '@leafer/interface'
+import { ILeaf, ILeafLevelList, ILeafList } from '@leafer/interface'
 
+import { LeafHelper } from './LeafHelper'
 
-interface ILeafPushList {
-    push(item: ILeaf): void
-}
-
+const { updateBounds } = LeafHelper
 
 export const BranchHelper = {
 
@@ -14,7 +12,7 @@ export const BranchHelper = {
 
     // push
 
-    pushAllChildBranch(branch: ILeaf, pushList: ILeafPushList): void {
+    pushAllChildBranch(branch: ILeaf, leafList: ILeafList | ILeafLevelList): void {
         branch.__tempNumber = 1   // 标识需要更新子Leaf元素的WorldBounds分支 Layouter需使用
 
         if (branch.__.__childBranchNumber) {
@@ -23,19 +21,19 @@ export const BranchHelper = {
                 branch = children[i]
                 if (branch.isBranch) {
                     branch.__tempNumber = 1
-                    pushList.push(branch)
-                    pushAllChildBranch(branch, pushList)
+                    leafList.add(branch)
+                    pushAllChildBranch(branch, leafList)
                 }
             }
         }
     },
 
-    pushAllParent(leaf: ILeaf, pushList: ILeafPushList): void {
-        const { keys } = (pushList as ILeafList)
+    pushAllParent(leaf: ILeaf, leafList: ILeafList | ILeafLevelList): void {
+        const { keys } = (leafList as ILeafList)
         if (keys) {
             while (leaf.parent) {
                 if (keys[leaf.parent.innerId] === undefined) {
-                    pushList.push(leaf.parent)
+                    leafList.add(leaf.parent)
                     leaf = leaf.parent
                 } else {
                     break
@@ -43,7 +41,7 @@ export const BranchHelper = {
             }
         } else {
             while (leaf.parent) {
-                pushList.push(leaf.parent)
+                leafList.add(leaf.parent)
                 leaf = leaf.parent
             }
         }
@@ -64,16 +62,24 @@ export const BranchHelper = {
         }
     },
 
-    updateWorldBoundsByBranchStack(branchStack: ILeaf[]): void {
-        let branch: ILeaf
+    updateBounds(branch: ILeaf, exclude?: ILeaf): void {
+        const branchStack: ILeaf[] = [branch]
+        pushAllBranchStack(branch, branchStack)
+        updateBoundsByBranchStack(branchStack, exclude)
+    },
+
+    updateBoundsByBranchStack(branchStack: ILeaf[], exclude?: ILeaf): void {
+        let branch: ILeaf, children: 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()
+            children = branch.children
+            for (let j = 0, len = children.length; j < len; j++) {
+                updateBounds(children[j])
             }
+            if (exclude && exclude === branch) continue
+            updateBounds(branch)
         }
-        branch.__updateWorldBounds()
     }
 }
 
-const { pushAllChildBranch, pushAllBranchStack } = BranchHelper
+const { pushAllChildBranch, pushAllBranchStack, updateBoundsByBranchStack } = BranchHelper

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
+        return target.__.eraser || target.__.visible === 0 ? null : (target.__local || target.__layout)
     },
 
-    localEventBounds(target: ILeaf): IBoundsData {
-        return target.__.isEraser ? null : target.__layout.localStrokeBounds
+    localStrokeBounds(target: ILeaf): IBoundsData {
+        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.__local : null
+        return target.__.mask ? target.__localBoxBounds : null
     },
 
-    maskLocalEventBounds(target: ILeaf): IBoundsData {
-        return target.__.isMask ? target.__layout.localStrokeBounds : null
+    maskLocalStrokeBounds(target: ILeaf): IBoundsData {
+        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,23 +1,47 @@
-import { IBranch, 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, translate, toInnerPoint, scaleOfOuter, rotateOfOuter, skewOfOuter } = MatrixHelper
+const { copy, toInnerPoint, scaleOfOuter, rotateOfOuter, skewOfOuter, multiplyParent, divideParent, getLayout } = MatrixHelper
 const matrix = {} as IMatrixData
 
 export const LeafHelper = {
 
-    updateAllWorldMatrix(leaf: ILeaf): void {
-        leaf.__updateWorldMatrix()
+    updateAllMatrix(leaf: ILeaf, checkAutoLayout?: boolean, waitAutoLayout?: boolean): void {
+        if (checkAutoLayout && leaf.__hasAutoLayout && leaf.__layout.matrixChanged) waitAutoLayout = true
+
+        updateMatrix(leaf, checkAutoLayout, waitAutoLayout)
 
         if (leaf.isBranch) {
             const { children } = leaf
             for (let i = 0, len = children.length; i < len; i++) {
-                updateAllWorldMatrix(children[i])
+                updateAllMatrix(children[i], checkAutoLayout, waitAutoLayout)
             }
         }
     },
 
+    updateMatrix(leaf: ILeaf, checkAutoLayout?: boolean, waitAutoLayout?: boolean): void {
+        const layout = leaf.__layout
+
+        if (checkAutoLayout) {
+            if (waitAutoLayout) {
+                layout.waitAutoLayout = true
+                if (leaf.__hasAutoLayout) layout.matrixChanged = false // wait updateAutoLayout
+            }
+        } else if (layout.waitAutoLayout) {
+            layout.waitAutoLayout = false
+        }
+
+        if (layout.matrixChanged) leaf.__updateLocalMatrix()
+        if (!layout.waitAutoLayout) leaf.__updateWorldMatrix()
+    },
+
+    updateBounds(leaf: ILeaf): void {
+        const layout = leaf.__layout
+        if (layout.boundsChanged) leaf.__updateLocalBounds()
+        if (!layout.waitAutoLayout) leaf.__updateWorldBounds()
+    },
+
     updateAllWorldOpacity(leaf: ILeaf): void {
         leaf.__updateWorldOpacity()
 
@@ -30,7 +54,6 @@ export const LeafHelper = {
     },
 
     updateAllChange(leaf: ILeaf): void {
-
         updateAllWorldOpacity(leaf)
 
         leaf.__updateChange()
@@ -44,88 +67,130 @@ export const LeafHelper = {
     },
 
     worldHittable(t: ILeaf): boolean {
-        if (!t.__.hittable) return false
-        let { parent } = t
-        while (parent) {
-            if (!parent.__.hittable || !parent.__.hitChildren) return false
-            parent = parent.parent
+        while (t) {
+            if (!t.__.hittable) return false
+            t = t.parent
         }
         return true
     },
 
     // 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)
+    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, 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, resize?: boolean): void {
+        L.zoomOfLocal(t, getTempLocal(t, origin), scaleX, scaleY, resize)
     },
 
-    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)
+    zoomOfLocal(t: ILeaf, origin: IPointData, scaleX: number, scaleY: number = scaleX, resize?: boolean): void {
+        copy(matrix, t.__localMatrix)
         scaleOfOuter(matrix, origin, scaleX, scaleY)
-        if (!moveLayer) moveLayer = t
-        moveLayer.x += matrix.e - t.__local.e
-        moveLayer.y += matrix.f - t.__local.f
-        t.scaleX *= scaleX
-        t.scaleY *= scaleY
+        moveByMatrix(t, matrix)
+        t.scaleResize(scaleX, scaleY, resize !== true)
     },
 
-    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 {
+        L.rotateOfLocal(t, getTempLocal(t, origin), angle)
     },
 
-    rotateOfLocal(t: ILeaf, origin: IPointData, angle: number, moveLayer?: ILeaf): void {
-        copy(matrix, t.__local)
-        if (moveLayer) translate(matrix, moveLayer.x, moveLayer.y)
+    rotateOfLocal(t: ILeaf, origin: IPointData, angle: number): void {
+        copy(matrix, t.__localMatrix)
         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, resize?: boolean): void {
+        L.skewOfLocal(t, getTempLocal(t, origin), skewX, skewY, resize)
     },
 
-    skewOfLocal(t: ILeaf, origin: IPointData, skewX: number, skewY: number, moveLayer?: ILeaf): void {
-        copy(matrix, t.__local)
-        if (moveLayer) translate(matrix, moveLayer.x, moveLayer.y)
+    skewOfLocal(t: ILeaf, origin: IPointData, skewX: number, skewY: number = 0, resize?: boolean): void {
+        copy(matrix, t.__localMatrix)
         skewOfOuter(matrix, origin, skewX, skewY)
-        if (!moveLayer) moveLayer = t
-        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 {
-        const position = { x: t.x, y: t.y }
-        t.localToWorld(position)
-        parent.worldToInner(position)
-        t.set(position)
-        parent.add(t)
+        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)
+        L.setTransform(t, matrix, resize)
+    },
+
+    setTransform(t: ILeaf, transform: IMatrixData, resize?: boolean): void {
+        const layout = getLayout(transform)
+        if (resize) {
+            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)
+        }
+    },
+
+    getLocalOrigin(t: ILeaf, origin: IPointData | IAlign): IPointData {
+        return PointHelper.tempToOuterOf(L.getInnerOrigin(t, origin), t.localTransform)
+    },
+
+    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, 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)
+    },
+
+    hasParent(p: ILeaf, parent: ILeaf): boolean | void {
+        if (!parent) return false
+        while (p) {
+            if (parent === p) return true
+            p = p.parent
+        }
     }
 
 }
+
 const L = LeafHelper
-const { updateAllWorldMatrix, updateAllWorldOpacity, updateAllChange } = L
+const { updateAllMatrix, updateMatrix, updateAllWorldOpacity, updateAllChange } = L
+
+function moveByMatrix(t: ILeaf, matrix: IMatrixData): void {
+    const { e, f } = t.__localMatrix
+    t.x += matrix.e - e
+    t.y += matrix.f - f
+}
+
+function getTempLocal(t: ILeaf, world: IPointData): IPointData {
+    t.__layout.update()
+    return t.parent ? PointHelper.tempToInnerOf(world, t.parent.__world) : world
+}

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,40 +1,48 @@
-import { ILeaf, IPointData, IBranch, IBoundsData, IFunction } from '@leafer/interface';
+import { ILeaf, IPointData, IMatrixData, IAlign, IBoundsData, IRenderOptions, ILeafList, ILeafLevelList, IFunction } from '@leafer/interface';
 
 declare const LeafHelper: {
-    updateAllWorldMatrix(leaf: ILeaf): void;
+    updateAllMatrix(leaf: ILeaf, checkAutoLayout?: boolean, waitAutoLayout?: boolean): void;
+    updateMatrix(leaf: ILeaf, checkAutoLayout?: boolean, waitAutoLayout?: boolean): void;
+    updateBounds(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;
+    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;
 };
 
 declare const LeafBoundsHelper: {
     worldBounds(target: ILeaf): IBoundsData;
     localBoxBounds(target: ILeaf): IBoundsData;
-    localEventBounds(target: ILeaf): IBoundsData;
+    localStrokeBounds(target: ILeaf): IBoundsData;
     localRenderBounds(target: ILeaf): IBoundsData;
     maskLocalBoxBounds(target: ILeaf): IBoundsData;
-    maskLocalEventBounds(target: ILeaf): IBoundsData;
+    maskLocalStrokeBounds(target: ILeaf): IBoundsData;
     maskLocalRenderBounds(target: ILeaf): IBoundsData;
+    excludeRenderBounds(child: ILeaf, options: IRenderOptions): boolean;
 };
 
-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;
+    pushAllChildBranch(branch: ILeaf, leafList: ILeafList | ILeafLevelList): void;
+    pushAllParent(leaf: ILeaf, leafList: ILeafList | ILeafLevelList): void;
     pushAllBranchStack(branch: ILeaf, pushList: ILeaf[]): void;
-    updateWorldBoundsByBranchStack(branchStack: ILeaf[]): void;
+    updateBounds(branch: ILeaf, exclude?: ILeaf): void;
+    updateBoundsByBranchStack(branchStack: ILeaf[], exclude?: ILeaf): void;
 };
 
 declare const WaitHelper: {