@leafer/selector 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/selector

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@leafer/selector",
+  "version": "1.0.0-alpha.1",
+  "description": "@leafer/selector",
+  "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/selector",
+  "bugs": "https://github.com/leaferjs/leafer/issues",
+  "keywords": [
+    "leafer",
+    "leaferjs"
+  ],
+  "dependencies": {
+    "@leafer/event": "1.0.0-alpha.1",
+    "@leafer/math": "1.0.0-alpha.1",
+    "@leafer/list": "1.0.0-alpha.1"
+  },
+  "devDependencies": {
+     "@leafer/interface": "1.0.0-alpha.1"
+  }
+}

package/src/PathFinder.ts

@@ -0,0 +1,131 @@
+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
+    }
+
+}

package/src/Selector.ts

@@ -0,0 +1,145 @@
+import { ILeaf, ILeafArrayMap, ILeafMap, ISelector, ISelectPathResult, ISelectPathOptions, IPointData, ILeafList, IEventListenerId } from '@leafer/interface'
+import { ChildEvent } from '@leafer/event'
+import { LeafList } from '@leafer/list'
+
+import { PathFinder } from './PathFinder'
+
+
+interface IFind {
+    (leaf: ILeaf): boolean
+}
+
+
+export class Selector implements ISelector {
+
+    public target: ILeaf
+    protected pathFinder: PathFinder
+
+    public defaultPath: ILeafList
+
+    protected eventIds: IEventListenerId[]
+
+    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 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
+    }
+
+    public getHitPointPath(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult {
+        return this.pathFinder.getHitPointPath(hitPoint, hitRadius, options)
+    }
+
+
+    public find(name: number | string, branch?: ILeaf): ILeaf | ILeaf[] {
+        if (typeof name === 'number') {
+            return this.getByInnerId(name, branch)
+        } else if (name.startsWith('#')) {
+            return this.getById(name.substring(1), branch)
+        } else if (name.startsWith('.')) {
+            return this.getByClassName(name.substring(1), branch)
+        } else {
+            return this.getByTagName(name, branch)
+        }
+    }
+
+    public getByInnerId(name: number, branch?: ILeaf): ILeaf {
+        let cache = this.innerIdList[name]
+        if (cache) return cache
+        if (!branch) branch = this.target
+        let find: ILeaf
+        this.loopFind(branch, (leaf) => {
+            if (leaf.innerId === name) {
+                find = leaf
+                this.innerIdList[name] = find
+                return true
+            } else {
+                return false
+            }
+        })
+        return find
+    }
+
+    public getById(name: string, branch?: ILeaf): ILeaf {
+        let cache = this.idList[name]
+        if (cache) return cache
+        if (!branch) branch = this.target
+        let find: ILeaf
+        this.loopFind(branch, (leaf) => {
+            if (leaf.id === name) {
+                find = leaf
+                this.idList[name] = find
+                return true
+            } else {
+                return false
+            }
+        })
+        return find
+    }
+
+    public getByClassName(name: string, branch?: ILeaf): ILeaf[] {
+        if (!branch) branch = this.target
+        let find: Array<ILeaf | ILeaf> = []
+        this.loopFind(branch, (leaf) => {
+            if (leaf.className === name) find.push(leaf)
+            return false
+        })
+        return find
+    }
+
+    public getByTagName(name: string, branch?: ILeaf): ILeaf[] {
+        if (!branch) branch = this.target
+        let find: Array<ILeaf | ILeaf> = []
+        this.loopFind(branch, (leaf) => {
+            if (leaf.tag === name) find.push(leaf)
+            return false
+        })
+        return find
+    }
+
+    protected loopFind(branch: ILeaf, find: IFind): void {
+        if (find(branch)) return
+        const { children } = branch
+        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)
+        }
+    }
+
+    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
+        }
+    }
+
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { Selector } from './Selector'