@leafer/selector 1.0.0-alpha.9 → 1.0.0-bate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/selector",
-  "version": "1.0.0-alpha.9",
+  "version": "1.0.0-bate",
   "description": "@leafer/selector",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -19,11 +19,11 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/event": "1.0.0-alpha.9",
-    "@leafer/math": "1.0.0-alpha.9",
-    "@leafer/list": "1.0.0-alpha.9"
+    "@leafer/event": "1.0.0-bate",
+    "@leafer/math": "1.0.0-bate",
+    "@leafer/list": "1.0.0-bate"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-alpha.9"
+    "@leafer/interface": "1.0.0-bate"
   }
 }

package/src/FindPath.ts

@@ -0,0 +1,141 @@
+import { ILeaf, ILeafList, IPointData, IRadiusPointData, ISelectPathResult, ISelectPathOptions, ISelector } from '@leafer/interface'
+import { BoundsHelper } from '@leafer/math'
+import { LeafList } from '@leafer/list'
+
+
+const { hitRadiusPoint } = BoundsHelper
+
+export class FindPath {
+
+    protected target: ILeaf
+    protected selector: ISelector
+
+    protected findList: ILeaf[]
+    protected exclude: ILeafList
+
+    protected point: IRadiusPointData
+
+    constructor(target: ILeaf, selector: ISelector) {
+        this.target = target
+        this.selector = selector
+    }
+
+    public getByPoint(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult {
+        if (!hitRadius) hitRadius = 0
+        if (!options) options = {}
+
+        const through = options.through || false
+        const ignoreHittable = options.ignoreHittable || false
+        this.exclude = options.exclude || null
+
+        this.point = { x: hitPoint.x, y: hitPoint.y, radiusX: hitRadius, radiusY: hitRadius }
+        this.findList = []
+
+        // path
+        this.eachFind(this.target.children, this.target.__onlyHitMask)
+
+        const list = this.findList
+        const leaf = this.getBestMatchLeaf()
+        const path = ignoreHittable ? this.getPath(leaf) : this.getHitablePath(leaf)
+
+        this.clear()
+
+        return through ? { path, leaf, throughPath: list.length ? this.getThroughPath(list) : path } : { path, leaf }
+    }
+
+    public getBestMatchLeaf(): ILeaf {
+        const { findList: targets } = this
+        if (targets.length > 1) {
+            let find: ILeaf
+            this.findList = []
+            const { x, y } = this.point
+            const point = { x, y, radiusX: 0, radiusY: 0 }
+            for (let i = 0, len = targets.length; i < len; i++) {
+                find = targets[i]
+                this.hitChild(find, point)
+                if (this.findList.length) return this.findList[0]
+            }
+        }
+        return targets[0]
+    }
+
+    public getPath(leaf: ILeaf): LeafList {
+        const path = new LeafList()
+        while (leaf) {
+            path.push(leaf)
+            leaf = leaf.parent
+        }
+        path.push(this.target)
+        return path
+    }
+
+    public getHitablePath(leaf: ILeaf): LeafList {
+        const path = this.getPath(leaf)
+        let item: ILeaf, hittablePath = new LeafList()
+        for (let i = path.list.length - 1; i > -1; i--) {
+            item = path.list[i]
+            if (!item.__.hittable) break
+            hittablePath.unshift(item)
+            if (!item.__.hitChildren) break
+        }
+        return hittablePath
+    }
+
+    public getThroughPath(list: ILeaf[]): LeafList {
+        const throughPath = new LeafList()
+        const pathList: ILeafList[] = []
+
+        for (let i = list.length - 1; i > -1; i--) {
+            pathList.push(this.getPath(list[i]))
+        }
+
+        let path: ILeafList, nextPath: ILeafList, leaf: ILeaf
+        for (let i = 0, len = pathList.length; i < len; i++) {
+            path = pathList[i], nextPath = pathList[i + 1]
+            for (let j = 0, jLen = path.length; j < jLen; j++) {
+                leaf = path.list[j]
+                if (nextPath && nextPath.has(leaf)) break
+                throughPath.push(leaf)
+            }
+        }
+
+        return throughPath
+    }
+
+
+    protected eachFind(children: Array<ILeaf>, hitMask: boolean): void {
+        let child: ILeaf, hit: boolean
+        const { point } = this, len = children.length
+        for (let i = len - 1; i > -1; i--) {
+            child = children[i]
+            if (hitMask && !child.isMask) continue
+            hit = hitRadiusPoint(child.__world, point)
+
+            if (child.isBranch) {
+                if (hit || child.__ignoreHitWorld) {
+                    this.eachFind(child.children, child.__onlyHitMask)
+                    if (child.isBranchLeaf && !this.findList.length) this.hitChild(child, point) // like frame
+                }
+            } else {
+                if (hit) this.hitChild(child, point)
+            }
+        }
+    }
+
+    protected hitChild(child: ILeaf, point: IRadiusPointData): void {
+        if (this.exclude && this.exclude.has(child)) return
+        if (child.__hitWorld(point)) this.findList.push(child)
+    }
+
+    protected clear(): void {
+        this.point = null
+        this.findList = null
+        this.exclude = null
+    }
+
+    public destroy(): void {
+        this.target = null
+        this.selector = null
+    }
+
+}

package/src/Selector.ts

@@ -1,8 +1,8 @@
-import { ILeaf, ILeafArrayMap, ILeafMap, ISelector, ISelectPathResult, ISelectPathOptions, IPointData, ILeafList, IEventListenerId } from '@leafer/interface'
-import { ChildEvent } from '@leafer/event'
-import { LeafList } from '@leafer/list'
+import { ILeaf, ILeafArrayMap, ILeafMap, ISelector, ISelectPathResult, ISelectPathOptions, IPointData, IEventListenerId, ISelectorConfig } from '@leafer/interface'
+import { ChildEvent, LayoutEvent } from '@leafer/event'
+import { DataHelper } from '@leafer/data'
 
-import { PathFinder } from './PathFinder'
+import { FindPath } from './FindPath'
 
 
 interface IFind {
@@ -13,45 +13,30 @@ interface IFind {
 export class Selector implements ISelector {
 
     public target: ILeaf
-    protected pathFinder: PathFinder
 
-    public defaultPath: ILeafList
+    public config: ISelectorConfig = {}
 
-    protected eventIds: IEventListenerId[]
+    protected findPath: FindPath
 
     protected innerIdList: ILeafMap = {}
     protected idList: ILeafMap = {}
     protected classNameList: ILeafArrayMap = {}
     protected tagNameList: ILeafArrayMap = {}
 
-    constructor(target: ILeaf) {
-        this.target = target
-        this.defaultPath = new LeafList(target)
-        this.pathFinder = new PathFinder(target, this)
-        this.listenEvents()
-    }
-
-    protected listenEvents(): void {
-        this.eventIds = [
-            this.target.on__(ChildEvent.REMOVE, this.onRemoveChild, this)
-        ]
-    }
+    protected __eventIds: IEventListenerId[]
 
-    protected removeListenEvents(): void {
-        this.target.off__(this.eventIds)
-    }
-
-    protected onRemoveChild(event: ChildEvent): void {
-        const target = event.target as ILeaf
-        if (this.idList[target.id]) this.idList[target.id] = undefined
-        if (this.innerIdList[target.id]) this.innerIdList[target.innerId] = undefined
+    constructor(target: ILeaf, userConfig?: ISelectorConfig) {
+        this.target = target
+        if (userConfig) this.config = DataHelper.default(userConfig, this.config)
+        this.findPath = new FindPath(target, this)
+        this.__listenEvents()
     }
 
-    public getHitPointPath(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult {
-        return this.pathFinder.getHitPointPath(hitPoint, hitRadius, options)
+    public getByPoint(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult {
+        this.target.emit(LayoutEvent.CHECK_UPDATE)
+        return this.findPath.getByPoint(hitPoint, hitRadius, options)
     }
 
-
     public find(name: number | string, branch?: ILeaf): ILeaf | ILeaf[] {
         if (typeof name === 'number') {
             return this.getByInnerId(name, branch)
@@ -112,7 +97,7 @@ export class Selector implements ISelector {
         if (!branch) branch = this.target
         let find: Array<ILeaf | ILeaf> = []
         this.loopFind(branch, (leaf) => {
-            if (leaf.tag === name) find.push(leaf)
+            if (leaf.__tag === name) find.push(leaf)
             return false
         })
         return find
@@ -124,21 +109,38 @@ export class Selector implements ISelector {
         for (let i = 0, len = children.length; i < len; i++) {
             branch = children[i] as ILeaf
             if (find(branch)) return
-            if (branch.__isBranch) this.loopFind(branch, find)
+            if (branch.isBranch) this.loopFind(branch, find)
         }
     }
 
+    protected __onRemoveChild(event: ChildEvent): void {
+        const target = event.target as ILeaf
+        if (this.idList[target.id]) this.idList[target.id] = null
+        if (this.innerIdList[target.id]) this.innerIdList[target.innerId] = null
+    }
+
+
+    protected __listenEvents(): void {
+        this.__eventIds = [
+            this.target.on_(ChildEvent.REMOVE, this.__onRemoveChild, this)
+        ]
+    }
+
+    protected __removeListenEvents(): void {
+        this.target.off_(this.__eventIds)
+    }
+
     public destroy(): void {
         if (this.target) {
-            this.removeListenEvents()
-            this.pathFinder.destroy()
-
-            this.target = undefined
-            this.pathFinder = undefined
-            this.innerIdList = undefined
-            this.idList = undefined
-            this.classNameList = undefined
-            this.tagNameList = undefined
+            this.__removeListenEvents()
+            this.findPath.destroy()
+
+            this.target = null
+            this.findPath = null
+            this.innerIdList = null
+            this.idList = null
+            this.classNameList = null
+            this.tagNameList = null
         }
     }
 

package/src/PathFinder.ts

@@ -1,131 +0,0 @@
-import { ILeaf, ILeafList, IPointData, IRadiusPointData, ISelectPathResult, ISelectPathOptions, ISelector } from '@leafer/interface'
-import { BoundsHelper } from '@leafer/math'
-import { LeafList } from '@leafer/list'
-
-const { hitRadiusPoint } = BoundsHelper
-
-
-export class PathFinder {
-
-    protected target: ILeaf
-    protected selector: ISelector
-
-    protected leaf?: ILeaf
-    protected throughPath: ILeafList
-    protected exclude: ILeafList
-
-    protected point: IRadiusPointData
-    protected isStop: boolean
-
-    constructor(target: ILeaf, selector: ISelector) {
-        this.target = target
-        this.selector = selector
-    }
-
-    public getHitPointPath(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult {
-        const through = options ? options.through : false
-        this.exclude = options ? options.exclude : undefined
-
-        this.isStop = false
-        this.point = { x: hitPoint.x, y: hitPoint.y, radiusX: hitRadius, radiusY: hitRadius }
-
-        // path
-        this.eachFind(this.target.children)
-
-        const { leaf } = this
-        const { defaultPath } = this.selector
-        const path = this.getPath(leaf)
-        path.pushList(defaultPath.list)
-
-        let result: ISelectPathResult
-
-        // throughPath
-        if (through) {
-            const throughPath = this.throughPath = new LeafList()
-            this.eachThroughFind(this.target.children)
-            throughPath.pushList(defaultPath.list)
-            result = { path, leaf, throughPath }
-        } else {
-            result = { path, leaf }
-        }
-
-        this.clear()
-
-        return result
-
-    }
-
-    public getPath(leaf: ILeaf): LeafList {
-        const list: LeafList = new LeafList()
-        while (leaf) {
-            list.push(leaf)
-            leaf = leaf.parent
-        }
-        return list
-    }
-
-    protected eachThroughFind(children: Array<ILeaf>): void {
-        let child: ILeaf
-        const { point } = this, len = children.length
-        for (let i = len - 1; i > -1; i--) {
-            child = children[i]
-            if (child.__interactionOff) continue
-
-            if (hitRadiusPoint(child.__world, point)) {
-                if (child.__isBranch) {
-                    child.__childrenInteractionOff || this.eachThroughFind(child.children)
-                }
-
-                if (this.exclude && this.exclude.has(child)) continue
-                if (child.__hitWorld(point)) this.throughPath.push(child)
-            }
-
-        }
-    }
-
-    protected eachFind(children: Array<ILeaf>): void {
-        let child: ILeaf
-        const { point } = this, len = children.length
-        for (let i = len - 1; i > -1; i--) {
-            child = children[i]
-            if (child.__interactionOff) continue
-
-            if (hitRadiusPoint(child.__world, point)) {
-                if (child.__isBranch) {
-
-                    child.__childrenInteractionOff || this.eachFind(child.children)
-
-                    if (child.__isBranchLeaf) { // 填充了背景色的Group, 如画板/Frame元素
-                        if (!this.isStop) this.hitChild(child, point)
-                    }
-
-                } else {
-                    this.hitChild(child, point)
-                }
-            }
-
-            if (this.isStop) break
-        }
-    }
-
-    protected hitChild(child: ILeaf, point: IRadiusPointData): void {
-        if (this.exclude && this.exclude.has(child)) return
-        if (child.__hitWorld(point)) {
-            this.leaf = child
-            this.isStop = true
-        }
-    }
-
-    protected clear(): void {
-        this.point = undefined
-        this.leaf = undefined
-        this.throughPath = undefined
-        this.exclude = undefined
-    }
-
-    public destroy(): void {
-        this.target = undefined
-        this.selector = undefined
-    }
-
-}