@leafer/display 1.0.0-beta.8 → 1.0.0-rc.1

package/package.json

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

package/src/Branch.ts

@@ -57,12 +57,15 @@ export class Branch extends Leaf {
     // own
 
     public __updateSortChildren(): void {
+        let affectSort: boolean
         const { children } = this
         if (children.length > 1) {
             for (let i = 0, len = children.length; i < len; i++) {
                 children[i].__tempNumber = i
+                if (children[i].__.zIndex) affectSort = true
             }
             children.sort(sort)
+            this.__layout.affectChildrenSort = affectSort
         }
     }
 
@@ -78,11 +81,17 @@ export class Branch extends Leaf {
 
         if (this.leafer) {
             child.__bindLeafer(this.leafer)
-            if (this.leafer.ready) this.__emitChildEvent(ChildEvent.ADD, child)
+            if (this.leafer.created) this.__emitChildEvent(ChildEvent.ADD, child)
         }
+
+        this.__layout.affectChildrenSort && this.__layout.childrenSortChange()
+    }
+
+    public addMany(...children: ILeaf[]): void {
+        children.forEach(child => this.add(child))
     }
 
-    public remove(child?: Leaf): void {
+    public remove(child?: Leaf, destroy?: boolean): void {
         if (child) {
             const index = this.children.indexOf(child)
             if (index > -1) {
@@ -90,31 +99,41 @@ export class Branch extends Leaf {
                 if (child.isBranch) this.__.__childBranchNumber = (this.__.__childBranchNumber || 1) - 1
                 this.__preRemove()
                 this.__realRemoveChild(child)
+                if (destroy) child.destroy()
             }
         } else if (child === undefined) {
-            super.remove()
+            super.remove(null, destroy)
         }
     }
 
-    public removeAll(): void {
+    public removeAll(destroy?: boolean): void {
         const { children } = this
-        this.children = []
-        this.__preRemove()
-        this.__.__childBranchNumber = 0
-        children.forEach(child => { this.__realRemoveChild(child) })
+        if (children.length) {
+            this.children = []
+            this.__preRemove()
+            this.__.__childBranchNumber = 0
+            children.forEach(child => {
+                this.__realRemoveChild(child)
+                if (destroy) child.destroy()
+            })
+        }
     }
 
     protected __preRemove(): void {
         if (this.__hasMask) this.__updateMask()
         if (this.__hasEraser) this.__updateEraser()
         this.__layout.boxChange()
+        this.__layout.affectChildrenSort && this.__layout.childrenSortChange()
     }
 
     protected __realRemoveChild(child: ILeaf): void {
         child.parent = null
         if (this.leafer) {
             child.__bindLeafer(null)
-            if (this.leafer.ready) this.__emitChildEvent(ChildEvent.REMOVE, child)
+            if (this.leafer.created) {
+                this.__emitChildEvent(ChildEvent.REMOVE, child)
+                if (this.leafer.hitCanvasManager) this.leafer.hitCanvasManager.clear()
+            }
         }
     }
 
@@ -124,4 +143,5 @@ export class Branch extends Leaf {
         if (this.hasEvent(type) && !this.isLeafer) this.emitEvent(event)
         this.leafer.emitEvent(event)
     }
+
 }

package/src/Leaf.ts

@@ -1,4 +1,4 @@
-import { ILeafer, ILeaf, ILeafInputData, ILeafData, ILeaferCanvas, IRenderOptions, IMatrixWithBoundsData, __Number, __Boolean, __Value, ILeafLayout, InnerId, IHitCanvas, IRadiusPointData, IEventListenerMap, IEventListener, IEventListenerOptions, IEventListenerId, IEvent, IObject, IFunction, __String, IPointData, IMatrixDecompositionAttr, ILayoutBoundsType, ILayoutLocationType, IBoundsData, IMatrixData } from '@leafer/interface'
+import { ILeafer, ILeaf, ILeafInputData, ILeafData, ILeaferCanvas, IRenderOptions, IMatrixWithBoundsData, __Number, __Boolean, __Value, ILeafLayout, InnerId, IHitCanvas, IRadiusPointData, IEventListenerMap, IEventListener, IEventListenerOptions, IEventListenerId, IEvent, IObject, IFunction, __String, IPointData, IMatrixDecompositionAttr, ILayoutBoundsType, ILayoutLocationType, IBoundsData, IBranch, IMatrixWithLayoutData } from '@leafer/interface'
 import { IncrementId, MatrixHelper, PointHelper } from '@leafer/math'
 import { LeafData } from '@leafer/data'
 import { LeafLayout } from '@leafer/layout'
@@ -8,6 +8,9 @@ import { LeafHelper, WaitHelper } from '@leafer/helper'
 
 
 const { LEAF, create } = IncrementId
+const { toInnerPoint, toOuterPoint } = MatrixHelper
+const { tempToOuterOf, copy } = PointHelper
+const { moveLocal, zoomOfLocal, rotateOfLocal, skewOfLocal } = LeafHelper
 
 @useModule(LeafDataProxy)
 @useModule(LeafMatrix)
@@ -38,15 +41,17 @@ export class Leaf implements ILeaf {
     public __: ILeafData
     public __layout: ILeafLayout
 
+    public __world: IMatrixWithLayoutData
     public __local: IMatrixWithBoundsData
-    public __world: IMatrixWithBoundsData
+
     public __worldOpacity: number
 
     // now transform
-    public get worldTransform(): IMatrixData { return this.__layout.getTransform('world') }
-    public get localTransform(): IMatrixData { return this.__layout.getTransform('local') }
+    public get worldTransform(): IMatrixWithLayoutData { return this.__layout.getTransform('world') as IMatrixWithLayoutData }
+    public get localTransform(): IMatrixWithBoundsData { return this.__layout.getTransform('local') as IMatrixWithBoundsData }
 
     // now bounds
+    public get boxBounds(): IBoundsData { return this.getBounds('box', 'inner') }
     public get worldBoxBounds(): IBoundsData { return this.getBounds('box') }
     public get worldStrokeBounds(): IBoundsData { return this.getBounds('stroke') }
     public get worldRenderBounds(): IBoundsData { return this.getBounds('render') }
@@ -57,6 +62,10 @@ export class Leaf implements ILeaf {
     public __level: number // layer level  0 -> branch -> branch -> deep
     public __tempNumber: number // temp sort
 
+    public get resizeable(): boolean { return true }
+
+    public get __hasMirror(): boolean { return this.__world.scaleX < 0 || this.__world.scaleY < 0 }
+
     public __hasMask?: boolean
     public __hasEraser?: boolean
     public __hitCanvas?: IHitCanvas
@@ -74,19 +83,29 @@ export class Leaf implements ILeaf {
     // branch 
     public children?: ILeaf[]
 
+
+    public destroyed: boolean
+
+
     constructor(data?: ILeafInputData) {
 
         this.innerId = create(LEAF)
 
+        this.__world = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0, x: 0, y: 0, width: 0, height: 0, scaleX: 1, scaleY: 1, rotation: 0, skewX: 0, skewY: 0 }
         this.__local = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0, x: 0, y: 0, width: 0, height: 0 }
-        this.__world = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0, x: 0, y: 0, width: 0, height: 0 }
 
         this.__worldOpacity = 1
 
         this.__ = new this.__DataProcessor(this)
         this.__layout = new this.__LayoutProcessor(this)
 
-        if (data) Object.assign(this, data)
+        if (data) {
+            if (data.children) {
+                this.set(data)
+            } else {
+                Object.assign(this, data)
+            }
+        }
     }
 
 
@@ -98,14 +117,21 @@ export class Leaf implements ILeaf {
         this.leafer ? item() : (this.__leaferWait ? this.__leaferWait.push(item) : this.__leaferWait = [item])
     }
 
+    public nextRender(item: IFunction): void {
+        this.leafer ? this.leafer.nextRender(item) : this.waitLeafer(() => this.leafer.nextRender(item))
+    }
 
     public __bindLeafer(leafer: ILeafer | null): void {
-        if (this.isLeafer) leafer = this as unknown as ILeafer
+        if (this.isLeafer) {
+            if (leafer !== null) leafer = this as unknown as ILeafer
+        }
 
         this.leafer = leafer
-        this.__level = this.parent ? this.parent.__level + 1 : 1
 
-        if (this.__leaferWait && leafer) WaitHelper.run(this.__leaferWait)
+        if (leafer) {
+            this.__level = this.parent ? this.parent.__level + 1 : 1
+            if (this.__leaferWait) WaitHelper.run(this.__leaferWait)
+        }
 
         if (this.isBranch) {
             const { children } = this
@@ -115,10 +141,17 @@ export class Leaf implements ILeaf {
         }
     }
 
+    // data
+
     public set(_data: IObject): void { }
 
-    public get(_attrNames?: string[]): IObject { return undefined }
+    public toJSON(): IObject {
+        return this.__.__getInputData()
+    }
 
+    public toString(): string {
+        return JSON.stringify(this.toJSON())
+    }
 
     // LeafDataProxy rewrite
 
@@ -129,8 +162,10 @@ export class Leaf implements ILeaf {
     // ---
 
     public forceUpdate(attrName?: string): void {
-        if (!attrName) attrName = 'x'
-        const value = this.__.__getInput(attrName);
+        if (attrName === undefined) attrName = 'scaleX'
+        else if (attrName === 'surface') attrName = 'blendMode'
+        const value = this.__.__getInput(attrName)
+        this.__[attrName] = value === undefined ? null : undefined;
         (this as any)[attrName] = value
     }
 
@@ -163,6 +198,9 @@ export class Leaf implements ILeaf {
     public __updateRenderBounds(): void { }
 
 
+    public __updateNaturalSize(): void { }
+
+
     public __updateStrokeSpread(): number { return 0 }
 
     public __updateRenderSpread(): number { return 0 }
@@ -188,7 +226,10 @@ export class Leaf implements ILeaf {
     // convert
 
     public getWorld(attrName: IMatrixDecompositionAttr): number {
-        return this.__layout.decomposeTransform('world')[attrName]
+        this.__layout.checkUpdate()
+        if (attrName === 'x') return this.__world.e
+        if (attrName === 'y') return this.__world.f
+        return this.__world[attrName]
     }
 
     public getBounds(type: ILayoutBoundsType, locationType: ILayoutLocationType = 'world'): IBoundsData {
@@ -196,46 +237,86 @@ export class Leaf implements ILeaf {
     }
 
 
-    public worldToLocal(world: IPointData, to?: IPointData, isMovePoint?: boolean): void {
+    public worldToLocal(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void {
         if (this.parent) {
-            MatrixHelper.toInnerPoint(this.parent.worldTransform, world, to, isMovePoint)
+            this.parent.worldToInner(world, to, distance, relative)
         } else {
-            if (to) PointHelper.copy(to, world)
+            if (to) copy(to, world)
         }
     }
 
-    public localToWorld(local: IPointData, to?: IPointData, isMovePoint?: boolean): void {
+    public localToWorld(local: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void {
         if (this.parent) {
-            MatrixHelper.toOuterPoint(this.parent.worldTransform, local, to, isMovePoint)
+            this.parent.innerToWorld(local, to, distance, relative)
         } else {
-            if (to) PointHelper.copy(to, local)
+            if (to) copy(to, local)
+        }
+    }
+
+    public worldToInner(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void {
+        if (relative) {
+            relative.innerToWorld(world, to, distance)
+            world = to ? to : world
         }
+        toInnerPoint(this.worldTransform, world, to, distance)
     }
 
-    public worldToInner(world: IPointData, to?: IPointData, isMovePoint?: boolean): void {
-        MatrixHelper.toInnerPoint(this.worldTransform, world, to, isMovePoint)
+    public innerToWorld(inner: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void {
+        toOuterPoint(this.worldTransform, inner, to, distance)
+        if (relative) relative.worldToInner(to ? to : inner, null, distance)
     }
 
-    public innerToWorld(inner: IPointData, to?: IPointData, isMovePoint?: boolean): void {
-        MatrixHelper.toOuterPoint(this.worldTransform, inner, to, isMovePoint)
+    // simple
+
+    public getInnerPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const point = change ? world : {} as IPointData
+        this.worldToInner(world, point, distance, relative)
+        return point
+    }
+
+    public getInnerPointByLocal(local: IPointData, _relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        return this.getInnerPoint(local, this.parent, distance, change)
+    }
+
+    public getLocalPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const point = change ? world : {} as IPointData
+        this.worldToLocal(world, point, distance, relative)
+        return point
+    }
+
+    public getLocalPointByInner(inner: IPointData, _relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        return this.getWorldPoint(inner, this.parent, distance, change)
+    }
+
+    public getWorldPoint(inner: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const point = change ? inner : {} as IPointData
+        this.innerToWorld(inner, point, distance, relative)
+        return point
+    }
+
+    public getWorldPointByLocal(local: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData {
+        const point = change ? local : {} as IPointData
+        this.localToWorld(local, point, distance, relative)
+        return point
     }
 
 
     // transform
 
     public move(x: number, y?: number): void {
-        LeafHelper.moveLocal(this, x, y)
+        moveLocal(this, x, y)
     }
 
     public scaleOf(origin: IPointData, x: number, y?: number): void {
-        this.__layout.checkUpdate()
-        if (y === undefined) y = x
-        LeafHelper.zoomOfLocal(this, PointHelper.tempToOuterOf(origin, this.__local), x, y)
+        zoomOfLocal(this, tempToOuterOf(origin, this.localTransform), x, y)
     }
 
     public rotateOf(origin: IPointData, angle: number): void {
-        this.__layout.checkUpdate()
-        LeafHelper.rotateOfLocal(this, PointHelper.tempToOuterOf(origin, this.__local), angle)
+        rotateOfLocal(this, tempToOuterOf(origin, this.localTransform), angle)
+    }
+
+    public skewOf(origin: IPointData, x: number, y: number): void {
+        skewOfLocal(this, tempToOuterOf(origin, this.localTransform), x, y)
     }
 
 
@@ -287,8 +368,8 @@ export class Leaf implements ILeaf {
 
     public add(_child: ILeaf, _index?: number): void { }
 
-    public remove(_child?: ILeaf): void {
-        if (this.parent) this.parent.remove(this)
+    public remove(_child?: ILeaf, destroy?: boolean): void {
+        if (this.parent) this.parent.remove(this, destroy)
     }
 
     // ---
@@ -314,28 +395,17 @@ export class Leaf implements ILeaf {
 
     // ---
 
-    public destroy(): void {
-        if (this.__) {
-            if (this.__hitCanvas) {
-                this.__hitCanvas.destroy()
-                this.__hitCanvas = null
-            }
 
-            this.leafer = null
-            this.parent = null
+    public destroy(): void {
+        if (!this.destroyed) {
+            if (this.parent) this.remove()
+            if (this.children) (this as unknown as IBranch).removeAll(true)
 
             this.__.destroy()
             this.__layout.destroy()
-            this.__ = null
-            this.__layout = null
 
-            this.__captureMap = null
-            this.__bubbleMap = null
-
-            if (this.children) {
-                this.children.forEach(child => { child.destroy() })
-                this.children.length = 0
-            }
+            this.__captureMap = this.__bubbleMap = this.__parentWait = this.__leaferWait = null
+            this.destroyed = true
         }
     }
 

package/types/index.d.ts

@@ -0,0 +1,134 @@
+import { ILeaf, InnerId, ILeafer, ILeafData, ILeafLayout, IMatrixWithLayoutData, IMatrixWithBoundsData, IBoundsData, IHitCanvas, IEventListenerMap, IFunction, ILeafInputData, IObject, __Value, ILeaferCanvas, IMatrixDecompositionAttr, ILayoutBoundsType, ILayoutLocationType, IPointData, IRadiusPointData, IRenderOptions, IEventListener, IEventListenerOptions, IEventListenerId, IEvent } from '@leafer/interface';
+import { LeafData } from '@leafer/data';
+import { LeafLayout } from '@leafer/layout';
+
+declare class Leaf implements ILeaf {
+    get tag(): string;
+    set tag(_value: string);
+    get __tag(): string;
+    readonly innerId: InnerId;
+    get innerName(): string;
+    get __DataProcessor(): typeof LeafData;
+    get __LayoutProcessor(): typeof LeafLayout;
+    leafer?: ILeafer;
+    parent?: ILeaf;
+    isLeafer: boolean;
+    isBranch: boolean;
+    isBranchLeaf: boolean;
+    __: ILeafData;
+    __layout: ILeafLayout;
+    __world: IMatrixWithLayoutData;
+    __local: IMatrixWithBoundsData;
+    __worldOpacity: number;
+    get worldTransform(): IMatrixWithLayoutData;
+    get localTransform(): IMatrixWithBoundsData;
+    get boxBounds(): IBoundsData;
+    get worldBoxBounds(): IBoundsData;
+    get worldStrokeBounds(): IBoundsData;
+    get worldRenderBounds(): IBoundsData;
+    get worldOpacity(): number;
+    __level: number;
+    __tempNumber: number;
+    get resizeable(): boolean;
+    get __hasMirror(): boolean;
+    __hasMask?: boolean;
+    __hasEraser?: boolean;
+    __hitCanvas?: IHitCanvas;
+    get __onlyHitMask(): boolean;
+    get __ignoreHitWorld(): boolean;
+    __captureMap?: IEventListenerMap;
+    __bubbleMap?: IEventListenerMap;
+    __parentWait?: IFunction[];
+    __leaferWait?: IFunction[];
+    children?: ILeaf[];
+    destroyed: boolean;
+    constructor(data?: ILeafInputData);
+    waitParent(item: IFunction): void;
+    waitLeafer(item: IFunction): void;
+    nextRender(item: IFunction): void;
+    __bindLeafer(leafer: ILeafer | null): void;
+    set(_data: IObject): void;
+    toJSON(): IObject;
+    toString(): string;
+    __setAttr(_attrName: string, _newValue: __Value): void;
+    __getAttr(_attrName: string): __Value;
+    forceUpdate(attrName?: string): void;
+    __updateWorldMatrix(): void;
+    __updateLocalMatrix(): void;
+    __updateWorldBounds(): void;
+    __updateLocalBoxBounds(): void;
+    __updateLocalStrokeBounds(): void;
+    __updateLocalRenderBounds(): void;
+    __updateBoxBounds(): void;
+    __updateStrokeBounds(): void;
+    __updateRenderBounds(): void;
+    __updateNaturalSize(): void;
+    __updateStrokeSpread(): number;
+    __updateRenderSpread(): number;
+    __onUpdateSize(): void;
+    __updateEraser(_value?: boolean): void;
+    __updateMask(_value?: boolean): void;
+    __renderMask(_canvas: ILeaferCanvas, _content: ILeaferCanvas, _mask: ILeaferCanvas): void;
+    __removeMask(_child?: ILeaf): void;
+    getWorld(attrName: IMatrixDecompositionAttr): number;
+    getBounds(type: ILayoutBoundsType, locationType?: ILayoutLocationType): IBoundsData;
+    worldToLocal(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
+    localToWorld(local: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
+    worldToInner(world: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
+    innerToWorld(inner: IPointData, to?: IPointData, distance?: boolean, relative?: ILeaf): void;
+    getInnerPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getInnerPointByLocal(local: IPointData, _relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getLocalPoint(world: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getLocalPointByInner(inner: IPointData, _relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getWorldPoint(inner: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    getWorldPointByLocal(local: IPointData, relative?: ILeaf, distance?: boolean, change?: boolean): IPointData;
+    move(x: number, y?: number): void;
+    scaleOf(origin: IPointData, x: number, y?: number): void;
+    rotateOf(origin: IPointData, angle: number): void;
+    skewOf(origin: IPointData, x: number, y: number): void;
+    __hitWorld(_point: IRadiusPointData): boolean;
+    __hit(_local: IRadiusPointData): boolean;
+    __drawHitPath(_canvas: ILeaferCanvas): void;
+    __updateHitCanvas(): void;
+    __render(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __drawFast(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __draw(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __renderShape(_canvas: ILeaferCanvas, _options: IRenderOptions): void;
+    __updateWorldOpacity(): void;
+    __updateChange(): void;
+    __drawPath(_canvas: ILeaferCanvas): void;
+    __drawRenderPath(_canvas: ILeaferCanvas): void;
+    __updatePath(): void;
+    __updateRenderPath(): void;
+    __updateSortChildren(): void;
+    add(_child: ILeaf, _index?: number): void;
+    remove(_child?: ILeaf, destroy?: boolean): void;
+    on(_type: string | string[], _listener: IEventListener, _options?: IEventListenerOptions | boolean): void;
+    off(_type: string | string[], _listener: IEventListener, _options?: IEventListenerOptions | boolean): void;
+    on_(_type: string | string[], _listener: IEventListener, _bind?: IObject, _options?: IEventListenerOptions | boolean): IEventListenerId;
+    off_(_id: IEventListenerId | IEventListenerId[]): void;
+    once(_type: string | string[], _listener: IEventListener, _capture?: boolean): void;
+    emit(_type: string, _event?: IEvent | IObject, _capture?: boolean): void;
+    emitEvent(_event?: IEvent, _capture?: boolean): void;
+    hasEvent(_type: string, _capture?: boolean): boolean;
+    destroy(): void;
+}
+
+declare class Branch extends Leaf {
+    constructor();
+    __updateStrokeSpread(): number;
+    __updateRenderSpread(): number;
+    __updateBoxBounds(): void;
+    __updateStrokeBounds(): void;
+    __updateRenderBounds(): void;
+    __updateSortChildren(): void;
+    add(child: ILeaf, index?: number): void;
+    addMany(...children: ILeaf[]): void;
+    remove(child?: Leaf, destroy?: boolean): void;
+    removeAll(destroy?: boolean): void;
+    protected __preRemove(): void;
+    protected __realRemoveChild(child: ILeaf): void;
+    protected __emitChildEvent(type: string, child: ILeaf): void;
+}
+
+export { Branch, Leaf };