@leafer/display-module 1.0.0-rc.3 → 1.0.0-rc.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/display-module",
-  "version": "1.0.0-rc.3",
+  "version": "1.0.0-rc.30",
   "description": "@leafer/display-module",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -15,17 +15,19 @@
     "type": "git",
     "url": "https://github.com/leaferjs/leafer.git"
   },
-  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/display-module",
+  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/display-module/display-module",
   "bugs": "https://github.com/leaferjs/leafer/issues",
   "keywords": [
     "leafer",
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/event": "1.0.0-rc.3",
-    "@leafer/math": "1.0.0-rc.3"
+    "@leafer/helper": "1.0.0-rc.30",
+    "@leafer/event": "1.0.0-rc.30",
+    "@leafer/math": "1.0.0-rc.30",
+    "@leafer/debug": "1.0.0-rc.30"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.3"
+    "@leafer/interface": "1.0.0-rc.30"
   }
 }

package/src/BranchRender.ts

@@ -1,6 +1,9 @@
-import { ILeaf, ILeaferCanvas, IRenderOptions, IBranchRenderModule } from '@leafer/interface'
+import { LeafBoundsHelper } from '@leafer/helper'
+import { ILeaferCanvas, IRenderOptions, IBranchRenderModule } from '@leafer/interface'
 
 
+const { excludeRenderBounds } = LeafBoundsHelper
+
 export const BranchRender: IBranchRenderModule = {
 
     __updateChange(): void {
@@ -18,73 +21,54 @@ export const BranchRender: IBranchRenderModule = {
         if (this.__worldOpacity) {
 
             if (this.__.__single) {
-                canvas.resetTransform()
-                const tempCanvas = canvas.getSameCanvas()
+
+                if (this.__.eraser === 'path') return this.__renderEraser(canvas, options)
+
+                const tempCanvas = canvas.getSameCanvas(false, true)
 
                 this.__renderBranch(tempCanvas, options)
 
-                canvas.opacity = this.__worldOpacity
+                const nowWorld = this.__getNowWorld(options)
 
-                const blendMode = this.__.isEraser ? 'destination-out' : this.__.blendMode
-                options.matrix ? canvas.copyWorld(tempCanvas, null, null, blendMode) : canvas.copyWorld(tempCanvas, this.__world, this.__world, blendMode)
+                canvas.opacity = this.__.opacity
+                canvas.copyWorldByReset(tempCanvas, nowWorld, nowWorld, this.__.__blendMode, true)
+
+                tempCanvas.recycle(nowWorld)
 
-                tempCanvas.recycle()
             } else {
+
                 this.__renderBranch(canvas, options)
+
             }
 
         }
+
     },
 
     __renderBranch(canvas: ILeaferCanvas, options: IRenderOptions): void {
+        if (this.__hasMask) {
 
-        let child: ILeaf
-        const { children } = this
-
-        if (this.__hasMask && children.length > 1) {
+            this.__renderMask(canvas, options)
 
-            let mask: boolean
-            let maskCanvas = canvas.getSameCanvas()
-            let contentCanvas = canvas.getSameCanvas()
+        } else {
 
+            const { children } = this
             for (let i = 0, len = children.length; i < len; i++) {
-                child = children[i]
-
-                if (child.isMask) {
-                    if (mask) {
-                        this.__renderMask(canvas, contentCanvas, maskCanvas)
-                        maskCanvas.clear()
-                        contentCanvas.clear()
-                    } else {
-                        mask = true
-                    }
-
-                    child.__render(maskCanvas, options)
-                    continue
-                }
-
-                child.__render(contentCanvas, options)
+                if (excludeRenderBounds(children[i], options)) continue
+                children[i].__render(canvas, options)
             }
 
-            this.__renderMask(canvas, contentCanvas, maskCanvas)
-            maskCanvas.recycle()
-            contentCanvas.recycle()
-
-        } else {
+        }
+    },
 
-            const { bounds, hideBounds } = options
 
+    __clip(canvas: ILeaferCanvas, options: IRenderOptions): void {
+        if (this.__worldOpacity) {
+            const { children } = this
             for (let i = 0, len = children.length; i < len; i++) {
-                child = children[i]
-
-                if (bounds && !bounds.hit(child.__world, options.matrix)) continue
-                if (hideBounds && hideBounds.includes(child.__world, options.matrix)) continue
-
-                child.__render(canvas, options)
+                if (excludeRenderBounds(children[i], options)) continue
+                children[i].__clip(canvas, options)
             }
-
         }
-
     }
-
 }

package/src/LeafBounds.ts

@@ -1,140 +1,170 @@
 import { ILeafBoundsModule } from '@leafer/interface'
 import { BoundsHelper } from '@leafer/math'
+import { PathBounds } from '@leafer/path'
+import { BranchHelper, LeafHelper } from '@leafer/helper'
 
 
-const { toOuterOf, copyAndSpread } = BoundsHelper
+const { updateMatrix, updateAllMatrix } = LeafHelper
+const { updateBounds } = BranchHelper
+const { toOuterOf, copyAndSpread, copy } = BoundsHelper
+const { toBounds } = PathBounds
 
 export const LeafBounds: ILeafBoundsModule = {
 
     __updateWorldBounds(): void {
 
-        if (this.__layout.boundsChanged) {
+        toOuterOf(this.__layout.renderBounds, this.__world, this.__world)
 
-            let resize: boolean
-            const layout = this.__layout
+        if (this.__layout.resized) {
+            this.__onUpdateSize()
+            this.__layout.resized = false
+        }
 
+    },
 
-            if (layout.boxChanged) {
+    __updateLocalBounds(): void {
 
-                this.__updatePath()
-                this.__updateRenderPath()
+        const layout = this.__layout
 
-                this.__updateBoxBounds()
-                layout.boxChanged = false
-                resize = true
-            }
+        if (layout.boxChanged) {
 
+            if (!this.__.__pathInputed) this.__updatePath()
+            this.__updateRenderPath()
 
-            if (layout.localBoxChanged) { // position change
+            this.__updateBoxBounds()
+            layout.resized = true
+        }
 
-                this.__updateLocalBoxBounds()
-                layout.localBoxChanged = false
 
-                if (layout.strokeSpread) layout.strokeChanged = true
-                if (layout.renderSpread) layout.renderChanged = true
-                this.parent?.__layout.boxChange()
-            }
+        if (layout.localBoxChanged) { // position change
 
+            if (this.__local) this.__updateLocalBoxBounds()
+            layout.localBoxChanged = false
 
-            if (layout.strokeChanged) {
-
-                layout.strokeSpread = this.__updateStrokeSpread()
+            if (layout.strokeSpread) layout.strokeChanged = true
+            if (layout.renderSpread) layout.renderChanged = true
+            if (this.parent) this.parent.__layout.boxChange()
+        }
 
-                if (layout.strokeSpread) {
 
-                    if (layout.strokeBounds === layout.boxBounds) {
-                        layout.spreadStroke()
-                    }
+        layout.boxChanged = false // must after updateLocalBoxBounds()
 
-                    this.__updateStrokeBounds()
-                    this.__updateLocalStrokeBounds()
 
-                } else {
-                    layout.spreadStrokeCancel()
-                }
+        if (layout.strokeChanged) {
 
-                layout.strokeChanged = false
-                if (layout.renderSpread) layout.renderChanged = true
+            layout.strokeSpread = this.__updateStrokeSpread()
 
-                if (this.parent) this.parent.__layout.strokeChange()
-                resize || (resize = true)
-            }
+            if (layout.strokeSpread) {
 
+                if (layout.strokeBounds === layout.boxBounds) layout.spreadStroke()
 
-            if (layout.renderChanged) {
+                this.__updateStrokeBounds()
+                this.__updateLocalStrokeBounds()
 
-                layout.renderSpread = this.__updateRenderSpread()
+            } else {
+                layout.spreadStrokeCancel()
+            }
 
-                if (layout.renderSpread) {
+            layout.strokeChanged = false
+            if (layout.renderSpread || layout.strokeSpread !== layout.strokeBoxSpread) layout.renderChanged = true
 
-                    if (layout.renderBounds === layout.boxBounds || layout.renderBounds === layout.strokeBounds) {
-                        layout.spreadRender()
-                    }
+            if (this.parent) this.parent.__layout.strokeChange()
+            layout.resized = true
+        }
 
-                    this.__updateRenderBounds()
-                    this.__updateLocalRenderBounds()
 
-                } else {
-                    layout.spreadRenderCancel()
-                }
+        if (layout.renderChanged) {
 
-                layout.renderChanged = false
+            layout.renderSpread = this.__updateRenderSpread()
 
-                if (this.parent) this.parent.__layout.renderChange()
-            }
+            if (layout.renderSpread) {
 
+                if (layout.renderBounds === layout.boxBounds || layout.renderBounds === layout.strokeBounds) layout.spreadRender()
 
-            layout.boundsChanged = false
+                this.__updateRenderBounds()
+                this.__updateLocalRenderBounds()
 
-            toOuterOf(this.__layout.renderBounds, this.__world, this.__world)
+            } else {
+                layout.spreadRenderCancel()
+            }
 
-            if (resize) this.__onUpdateSize()
+            layout.renderChanged = false
 
-        } else {
-            toOuterOf(this.__layout.renderBounds, this.__world, this.__world)
+            if (this.parent) this.parent.__layout.renderChange()
         }
 
+        layout.boundsChanged = false
+
     },
 
     __updateLocalBoxBounds(): void {
+        if (this.__hasAutoLayout) this.__updateAutoLayout() //  origin / around / flow
         toOuterOf(this.__layout.boxBounds, this.__local, this.__local)
     },
 
     __updateLocalStrokeBounds(): void {
-        toOuterOf(this.__layout.strokeBounds, this.__local, this.__layout.localStrokeBounds)
+        toOuterOf(this.__layout.strokeBounds, this.__localMatrix, this.__layout.localStrokeBounds)
     },
 
     __updateLocalRenderBounds(): void {
-        toOuterOf(this.__layout.renderBounds, this.__local, this.__layout.localRenderBounds)
+        toOuterOf(this.__layout.renderBounds, this.__localMatrix, this.__layout.localRenderBounds)
     },
 
 
     __updateBoxBounds(): void {
         const b = this.__layout.boxBounds
-        const { width, height } = this.__
-        b.x = 0
-        b.y = 0
-        b.width = width
-        b.height = height
+        const data = this.__
+        if (data.__pathInputed) {
+            toBounds(data.__pathForRender, b)
+        } else {
+            b.x = 0
+            b.y = 0
+            b.width = data.width
+            b.height = data.height
+        }
+    },
+
+
+    __updateAutoLayout(): void {
+        this.__layout.matrixChanged = true
+        if (this.isBranch) {
+            if (this.leafer && this.leafer.ready) this.leafer.layouter.addExtra(this) // add part 
+
+            if (this.__.flow) {
+
+                if (this.__layout.boxChanged) this.__updateFlowLayout()
+
+                updateAllMatrix(this)
+                updateBounds(this, this)
+
+                if (this.__.__autoSide) this.__updateBoxBounds()
+
+            } else {
+
+                updateAllMatrix(this)
+                updateBounds(this, this)
+
+            }
+
+        } else {
+            updateMatrix(this)
+        }
     },
 
     __updateNaturalSize(): void {
         const { __: data, __layout: layout } = this
         data.__naturalWidth = layout.boxBounds.width
         data.__naturalHeight = layout.boxBounds.height
-
-        if (this.around) {
-            layout.positionChanged = layout.matrixChanged = true
-            this.__updateWorldMatrix()
-        }
     },
 
     __updateStrokeBounds(): void {
-        copyAndSpread(this.__layout.strokeBounds, this.__layout.boxBounds, this.__layout.strokeSpread)
+        const layout = this.__layout
+        copyAndSpread(layout.strokeBounds, layout.boxBounds, layout.strokeBoxSpread)
     },
 
     __updateRenderBounds(): void {
-        copyAndSpread(this.__layout.renderBounds, this.__layout.strokeBounds, this.__layout.renderSpread)
-    },
+        const layout = this.__layout
+        layout.renderSpread > 0 ? copyAndSpread(layout.renderBounds, layout.boxBounds, layout.renderSpread) : copy(layout.renderBounds, layout.strokeBounds) // Box use -1
+    }
 
 }

package/src/LeafDataProxy.ts

@@ -1,25 +1,50 @@
-import { ILeafDataProxyModule } from '@leafer/interface'
+import { ILeafDataProxyModule, IObject, IValue } from '@leafer/interface'
 import { PropertyEvent } from '@leafer/event'
+import { Debug } from '@leafer/debug'
 
 
+const { isFinite } = Number
+const debug = Debug.get('setAttr')
+
 export const LeafDataProxy: ILeafDataProxyModule = {
 
-    __setAttr(name: string, newValue: unknown): void {
+    __setAttr(name: string, newValue: IValue, checkFiniteNumber?: boolean): boolean {
         if (this.leafer && this.leafer.created) {
-            if (typeof newValue === 'object' || this.__.__getInput(name) !== newValue) {
-                this.__[name] = newValue
+            const oldValue = this.__.__getInput(name)
+
+            if (checkFiniteNumber && !isFinite(newValue) && newValue !== undefined) { // 警告 NaN、Infinity、-Infinity、null、非有效数字
+                debug.warn(this.innerName, name, newValue)
+                newValue = undefined // must
+            }
+
+            if (typeof newValue === 'object' || oldValue !== newValue) {
+                (this.__ as IObject)[name] = newValue
+                if (this.__proxyData) this.setProxyAttr(name, newValue)
+
                 const { CHANGE } = PropertyEvent
-                const event = new PropertyEvent(CHANGE, this, name, this.__.__get(name), newValue)
-                if (this.hasEvent(CHANGE) && !this.isLeafer) this.emitEvent(event)
+                const event = new PropertyEvent(CHANGE, this, name, oldValue, newValue)
+
+                if (this.isLeafer) {
+                    this.emitEvent(new PropertyEvent(PropertyEvent.LEAFER_CHANGE, this, name, oldValue, newValue))
+                } else {
+                    if (this.hasEvent(CHANGE)) this.emitEvent(event)
+                }
+
                 this.leafer.emitEvent(event)
+                return true
+            } else {
+                return false
             }
+
         } else {
-            this.__[name] = newValue
+            (this.__ as IObject)[name] = newValue
+            if (this.__proxyData) this.setProxyAttr(name, newValue)
+            return true
         }
     },
 
-    __getAttr(name: string): unknown {
+    __getAttr(name: string): IValue {
+        if (this.__proxyData) return this.getProxyAttr(name)
         return this.__.__get(name)
     }
-
 }

package/src/LeafEventer.ts

@@ -33,36 +33,59 @@ export const LeafEventer: ILeafEventerModule = {
         })
     },
 
-    off(type: string | string[], listener: IEventListener, options?: IEventListenerOptions | boolean): void {
-        let capture: boolean
-        if (options) capture = typeof options === 'boolean' ? options : options.capture
+    off(type?: string | string[], listener?: IEventListener, options?: IEventListenerOptions | boolean): void {
+        if (type) {
 
-        let events: IEventListenerItem[], index: number
-        const map = __getListenerMap(this, capture)
-        const typeList = typeof type === 'string' ? type.split(' ') : type
+            const typeList = typeof type === 'string' ? type.split(' ') : type
+
+            if (listener) {
+
+                let capture: boolean
+                if (options) capture = typeof options === 'boolean' ? options : options.capture
+
+                let events: IEventListenerItem[], index: number
+                const map = __getListenerMap(this, capture)
+
+                typeList.forEach(type => {
+                    if (type) {
+                        events = map[type]
+                        if (events) {
+                            index = events.findIndex(item => item.listener === listener)
+                            if (index > -1) events.splice(index, 1)
+                            if (!events.length) delete map[type]
+                        }
+                    }
+                })
+
+            } else {
+
+                // off type
+                const { __bubbleMap: b, __captureMap: c } = this
+                typeList.forEach(type => {
+                    if (b) delete b[type]
+                    if (c) delete c[type]
+                })
 
-        typeList.forEach(type => {
-            if (type) {
-                events = map[type]
-                if (events) {
-                    index = events.findIndex(item => item.listener === listener)
-                    if (index > -1) events.splice(index, 1)
-                    if (!events.length) delete map[type]
-                }
             }
-        })
+
+        } else {
+
+            this.__bubbleMap = this.__captureMap = undefined  // off all
+
+        }
+
     },
 
     on_(type: string | string[], listener: IEventListener, bind?: IObject, options?: IEventListenerOptions | boolean): IEventListenerId {
         if (bind) listener = listener.bind(bind)
         this.on(type, listener, options)
-        return { type, listener, options }
+        return { type, current: this, listener, options }
     },
 
     off_(id: IEventListenerId | IEventListenerId[]): void {
         if (!id) return
         const list = id instanceof Array ? id : [id]
-        list.forEach(item => this.off(item.type, item.listener, item.options))
+        list.forEach(item => item.current.off(item.type, item.listener, item.options))
         list.length = 0
     },
 
@@ -87,6 +110,8 @@ export const LeafEventer: ILeafEventerModule = {
                 if (event && (event as IEvent).isStopNow) break
             }
         }
+
+        this.syncEventer && this.syncEventer.emitEvent(event, capture)
     },
 
     emitEvent(event: IEvent, capture?: boolean): void {
@@ -95,12 +120,11 @@ export const LeafEventer: ILeafEventerModule = {
     },
 
     hasEvent(type: string, capture?: boolean): boolean {
+        if (this.syncEventer && this.syncEventer.hasEvent(type, capture)) return true
+
         const { __bubbleMap: b, __captureMap: c } = this
-        if (capture === undefined) {
-            return !!((c && c[type]) || (b && b[type]))
-        } else {
-            return !!(capture ? (c && c[type]) : (b && b[type]))
-        }
+        const hasB = b && b[type], hasC = c && c[type]
+        return !!(capture === undefined ? (hasB || hasC) : (capture ? hasC : hasB))
     },
 
 }

package/src/LeafMatrix.ts

@@ -1,122 +1,46 @@
-import { ILeafMatrixModule, IPointData } from '@leafer/interface'
-import { OneRadian, MatrixHelper } from '@leafer/math'
+import { ILeafMatrixModule, ILayoutData, IScrollPointData } from '@leafer/interface'
+import { AroundHelper, MatrixHelper } from '@leafer/math'
 
 
-const { sin, cos } = Math
-const defaultWorld = { ...MatrixHelper.defaultMatrix, scaleX: 1, scaleY: 1, rotation: 0, skewX: 0, skewY: 0 }
-const defaultCenter: IPointData = { x: 0.5, y: 0.5 }
+const { setLayout, multiplyParent, translateInner, defaultWorld } = MatrixHelper
+const { toPoint, tempPoint } = AroundHelper
 
 export const LeafMatrix: ILeafMatrixModule = {
 
     __updateWorldMatrix(): void {
 
-        const pw = this.parent ? this.parent.__world : defaultWorld
-        const r = this.__local
-        const w = this.__world
-
-        if (this.__layout.matrixChanged) this.__updateLocalMatrix()
-
-        if (this.__layout.affectScaleOrRotation) {
-            w.a = r.a * pw.a + r.b * pw.c
-            w.b = r.a * pw.b + r.b * pw.d
-            w.c = r.c * pw.a + r.d * pw.c
-            w.d = r.c * pw.b + r.d * pw.d
-            w.e = r.e * pw.a + r.f * pw.c + pw.e
-            w.f = r.e * pw.b + r.f * pw.d + pw.f
-
-            const data = this.__
-            w.scaleX = pw.scaleX * data.scaleX
-            w.scaleY = pw.scaleY * data.scaleY
-
-            w.rotation = pw.rotation + data.rotation
-            w.skewX = pw.skewX + data.skewX
-            w.skewY = pw.skewY + data.skewY
-        } else {
-            w.a = pw.a
-            w.b = pw.b
-            w.c = pw.c
-            w.d = pw.d
-            w.e = r.e * pw.a + r.f * pw.c + pw.e
-            w.f = r.e * pw.b + r.f * pw.d + pw.f
-
-            w.scaleX = pw.scaleX
-            w.scaleY = pw.scaleY
-
-            w.rotation = pw.rotation
-            w.skewX = pw.skewX
-            w.skewY = pw.skewY
-        }
+        multiplyParent(this.__local || this.__layout, this.parent ? this.parent.__world : defaultWorld, this.__world, !!this.__layout.affectScaleOrRotation, this.__ as ILayoutData, this.parent && this.parent.__ as IScrollPointData)
+
     },
 
     __updateLocalMatrix(): void {
 
-        const r = this.__local
-        const layout = this.__layout
-
-        if (layout.affectScaleOrRotation) {
+        if (this.__local) {
 
-            const { scaleX, scaleY } = this.__
+            const layout = this.__layout, local = this.__local, data = this.__
 
-            if (layout.affectRotation) {
+            if (layout.affectScaleOrRotation) {
 
                 if (layout.scaleChanged || layout.rotationChanged) {
-
-                    let { rotation, skewX, skewY } = this.__
-
-                    if (rotation || skewX || skewY) {
-
-                        rotation *= OneRadian
-                        if (skewX) skewX *= OneRadian
-                        if (skewY) skewY *= OneRadian
-
-                        r.a = scaleX * cos(rotation + skewY)
-                        r.b = scaleX * sin(rotation + skewY)
-                        r.c = scaleY * -sin(rotation - skewX)
-                        r.d = scaleY * cos(rotation - skewX)
-
-                    } else {
-
-                        r.a = scaleX
-                        r.b = 0
-                        r.c = 0
-                        r.d = scaleY
-
-                        layout.affectRotation = false
-                    }
-
-                    layout.scaleChanged = false
-                    layout.rotationChanged = false
-
-                }
-
-            } else {
-
-                if (layout.scaleChanged) {
-                    r.a = scaleX
-                    r.d = scaleY
-                    layout.scaleChanged = false
+                    setLayout(local, data as ILayoutData, null, layout.affectRotation)
+                    layout.scaleChanged = layout.rotationChanged = false
                 }
 
             }
 
-        }
+            local.e = data.x + data.offsetX
+            local.f = data.y + data.offsetY
 
-        if (layout.positionChanged) {
-            r.e = this.__.x
-            r.f = this.__.y
-            const { width, height, around } = this.__
-            if (around && width && height) {
-                const origin = (around === 'center') ? defaultCenter : around
-                const offsetX = width * origin.x, offsetY = height * origin.y
-                r.e -= offsetX * r.a + offsetY * r.c
-                r.f -= offsetX * r.b + offsetY * r.d
+            if (data.around || data.origin) {
+                toPoint(data.around || data.origin, layout.boxBounds, tempPoint)
+                translateInner(local, -tempPoint.x, -tempPoint.y, data.origin as unknown as boolean)
             }
-            layout.positionChanged = false
+
         }
 
         this.__layout.matrixChanged = false
-    }
 
+    }
 
 }
 

package/src/LeafRender.ts

@@ -5,24 +5,39 @@ export const LeafRender: ILeafRenderModule = {
 
     __render(canvas: ILeaferCanvas, options: IRenderOptions): void {
         if (this.__worldOpacity) {
-            canvas.setWorld(this.__world, options.matrix)
-            canvas.opacity = this.__worldOpacity
+
+            canvas.setWorld(this.__nowWorld = this.__getNowWorld(options))
+            canvas.opacity = this.__.opacity
 
             if (this.__.__single) {
-                const tempCanvas = canvas.getSameCanvas(true)
 
+                if (this.__.eraser === 'path') return this.__renderEraser(canvas, options)
+
+                const tempCanvas = canvas.getSameCanvas(true, true)
                 this.__draw(tempCanvas, options)
 
-                const blendMode = this.__.isEraser ? 'destination-out' : this.__.blendMode
-                if (options.matrix || this.__hasMirror) {
-                    canvas.copyWorldByReset(tempCanvas, null, null, blendMode)
+                if (this.__worldFlipped) {
+                    canvas.copyWorldByReset(tempCanvas, this.__nowWorld, null, this.__.__blendMode, true)
                 } else {
-                    canvas.copyWorldToInner(tempCanvas, this.__world, this.__layout.renderBounds, blendMode)
+                    canvas.copyWorldToInner(tempCanvas, this.__nowWorld, this.__layout.renderBounds, this.__.__blendMode)
                 }
-                tempCanvas.recycle()
+
+                tempCanvas.recycle(this.__nowWorld)
+
             } else {
+
                 this.__draw(canvas, options)
+
             }
+
+        }
+    },
+
+    __clip(canvas: ILeaferCanvas, options: IRenderOptions): void {
+        if (this.__worldOpacity) {
+            canvas.setWorld(this.__nowWorld = this.__getNowWorld(options))
+            this.__drawRenderPath(canvas)
+            this.__.windingRule ? canvas.clip(this.__.windingRule) : canvas.clip()
         }
     },
 

package/src/index.ts

@@ -2,8 +2,6 @@ export { LeafEventer } from './LeafEventer'
 export { LeafDataProxy } from './LeafDataProxy'
 export { LeafMatrix } from './LeafMatrix'
 export { LeafBounds } from './LeafBounds'
-export { LeafHit } from './LeafHit'
 export { LeafRender } from './LeafRender'
-export { LeafMask } from './LeafMask'
 
 export { BranchRender } from './BranchRender'

package/types/index.d.ts

@@ -1,4 +1,4 @@
-import { ILeafEventerModule, ILeafDataProxyModule, ILeafMatrixModule, ILeafBoundsModule, ILeafHitModule, ILeafRenderModule, ILeafMaskModule, IBranchRenderModule } from '@leafer/interface';
+import { ILeafEventerModule, ILeafDataProxyModule, ILeafMatrixModule, ILeafBoundsModule, ILeafRenderModule, IBranchRenderModule } from '@leafer/interface';
 
 declare const LeafEventer: ILeafEventerModule;
 
@@ -8,12 +8,8 @@ declare const LeafMatrix: ILeafMatrixModule;
 
 declare const LeafBounds: ILeafBoundsModule;
 
-declare const LeafHit: ILeafHitModule;
-
 declare const LeafRender: ILeafRenderModule;
 
-declare const LeafMask: ILeafMaskModule;
-
 declare const BranchRender: IBranchRenderModule;
 
-export { BranchRender, LeafBounds, LeafDataProxy, LeafEventer, LeafHit, LeafMask, LeafMatrix, LeafRender };
+export { BranchRender, LeafBounds, LeafDataProxy, LeafEventer, LeafMatrix, LeafRender };

package/src/LeafHit.ts

@@ -1,29 +0,0 @@
-import { ILeafHitModule, IRadiusPointData, ILeaferCanvas } from '@leafer/interface'
-import { PointHelper } from '@leafer/math'
-
-
-const { toInnerRadiusPointOf, copy, setRadius } = PointHelper
-const inner = {} as IRadiusPointData
-
-export const LeafHit: ILeafHitModule = {
-
-    __hitWorld(point: IRadiusPointData): boolean {
-        if (this.__layout.hitCanvasChanged || !this.__hitCanvas) {
-            this.__updateHitCanvas()
-            this.__layout.hitCanvasChanged = false
-        }
-
-        if (this.__.hitRadius) {
-            copy(inner, point), point = inner
-            setRadius(point, this.__.hitRadius)
-        }
-
-        toInnerRadiusPointOf(point, this.__world, inner)
-        return this.__hit(inner)
-    },
-
-    __drawHitPath(canvas: ILeaferCanvas): void {
-        this.__drawRenderPath(canvas)
-    }
-
-}

package/src/LeafMask.ts

@@ -1,38 +0,0 @@
-import { ILeaf, ILeaferCanvas, ILeafMaskModule } from '@leafer/interface'
-
-
-export const LeafMask: ILeafMaskModule = {
-
-    __updateEraser(value?: boolean): void {
-        this.__hasEraser = value ? true : this.children.some(item => item.__.isEraser)
-    },
-
-    __updateMask(value?: boolean): void {
-        this.__hasMask = value ? true : this.children.some(item => item.__.isMask)
-    },
-
-    __renderMask(canvas: ILeaferCanvas, content: ILeaferCanvas, mask: ILeaferCanvas): void {
-        content.resetTransform()
-        content.useMask(mask)
-        canvas.resetTransform()
-        canvas.opacity = this.__worldOpacity
-        canvas.copyWorld(content)
-    },
-
-    __removeMask(child?: ILeaf): void {
-        if (child) {
-            child.isMask = false
-            this.remove(child)
-        } else {
-            const { children } = this
-            for (let i = 0, len = children.length; i < len; i++) {
-                child = children[i]
-                if (child.isMask) {
-                    this.__removeMask(child)
-                    len--, i--
-                }
-            }
-        }
-    }
-
-}