@leafer/selector 1.0.0-beta.9 → 1.0.0-rc.10

package/package.json

@@ -1,29 +1,30 @@
 {
   "name": "@leafer/selector",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.10",
   "description": "@leafer/selector",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
   "main": "src/index.ts",
+  "types": "types/index.d.ts",
   "files": [
-    "src"
+    "src",
+    "types",
+    "dist"
   ],
   "repository": {
     "type": "git",
     "url": "https://github.com/leaferjs/leafer.git"
   },
-  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/selector",
+  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/partner/selector",
   "bugs": "https://github.com/leaferjs/leafer/issues",
   "keywords": [
     "leafer",
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/event": "1.0.0-beta.9",
-    "@leafer/math": "1.0.0-beta.9",
-    "@leafer/list": "1.0.0-beta.9"
+    "@leafer/core": "1.0.0-rc.10"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-beta.9"
+    "@leafer/interface": "1.0.0-rc.10"
   }
 }

package/src/{FindPath.ts → Picker.ts}

@@ -1,12 +1,10 @@
-import { ILeaf, ILeafList, IPointData, IRadiusPointData, ISelectPathResult, ISelectPathOptions, ISelector } from '@leafer/interface'
-import { BoundsHelper } from '@leafer/math'
-import { LeafList } from '@leafer/list'
-import { LeafHelper } from '@leafer/helper'
+import { ILeaf, ILeafList, IPointData, IRadiusPointData, IPickResult, IPickOptions, ISelector } from '@leafer/interface'
+import { BoundsHelper, LeafList, LeafHelper } from '@leafer/core'
 
 
 const { hitRadiusPoint } = BoundsHelper
 
-export class FindPath {
+export class Picker {
 
     protected target: ILeaf
     protected selector: ISelector
@@ -21,19 +19,20 @@ export class FindPath {
         this.selector = selector
     }
 
-    public getByPoint(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult {
+    public getByPoint(hitPoint: IPointData, hitRadius: number, options?: IPickOptions): IPickResult {
         if (!hitRadius) hitRadius = 0
         if (!options) options = {}
 
         const through = options.through || false
         const ignoreHittable = options.ignoreHittable || false
+        const target = options.target || this.target
         this.exclude = options.exclude || null
 
         this.point = { x: hitPoint.x, y: hitPoint.y, radiusX: hitRadius, radiusY: hitRadius }
-        this.findList = []
+        this.findList = options.findList || []
 
         // path
-        this.eachFind(this.target.children, this.target.__onlyHitMask)
+        if (!options.findList) this.eachFind(target.children, target.__onlyHitMask)
 
         const list = this.findList
         const leaf = this.getBestMatchLeaf()
@@ -41,7 +40,7 @@ export class FindPath {
 
         this.clear()
 
-        return through ? { path, leaf, throughPath: list.length ? this.getThroughPath(list) : path } : { path, leaf }
+        return through ? { path, target: leaf, throughPath: list.length ? this.getThroughPath(list) : path } : { path, target: leaf }
     }
 
     public getBestMatchLeaf(): ILeaf {
@@ -65,10 +64,10 @@ export class FindPath {
     public getPath(leaf: ILeaf): LeafList {
         const path = new LeafList()
         while (leaf) {
-            path.push(leaf)
+            path.add(leaf)
             leaf = leaf.parent
         }
-        path.push(this.target)
+        path.add(this.target)
         return path
     }
 
@@ -78,7 +77,7 @@ export class FindPath {
         for (let i = path.list.length - 1; i > -1; i--) {
             item = path.list[i]
             if (!item.__.hittable) break
-            hittablePath.unshift(item)
+            hittablePath.addAt(item, 0)
             if (!item.__.hitChildren) break
         }
         return hittablePath
@@ -98,7 +97,7 @@ export class FindPath {
             for (let j = 0, jLen = path.length; j < jLen; j++) {
                 leaf = path.list[j]
                 if (nextPath && nextPath.has(leaf)) break
-                throughPath.push(leaf)
+                throughPath.add(leaf)
             }
         }
 
@@ -106,13 +105,13 @@ export class FindPath {
     }
 
 
-    protected eachFind(children: Array<ILeaf>, hitMask: boolean): void {
+    protected eachFind(children: 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.__.visible || (hitMask && !child.__.mask)) continue
+            hit = child.__.hitRadius ? true : hitRadiusPoint(child.__world, point)
 
             if (child.isBranch) {
                 if (hit || child.__ignoreHitWorld) {
@@ -137,8 +136,7 @@ export class FindPath {
     }
 
     public destroy(): void {
-        this.target = null
-        this.selector = null
+        this.clear()
     }
 
 }

package/src/Selector.ts

@@ -1,147 +1,155 @@
-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 { Platform } from '@leafer/platform'
+import { ILeaf, ILeafMap, ISelector, ISelectorProxy, IPickResult, IPickOptions, IPointData, IEventListenerId, ISelectorConfig, IFindMethod, IAnswer } from '@leafer/interface'
+import { ChildEvent, LayoutEvent, DataHelper, Answer, Platform, PropertyEvent, LeafHelper } from '@leafer/core'
 
-import { FindPath } from './FindPath'
+import { Picker } from './Picker'
 
 
-interface IFind {
-    (leaf: ILeaf): boolean
-}
 
 
+const { Yes, NoAndSkip, YesAndSkip } = Answer
+
 export class Selector implements ISelector {
 
     public target: ILeaf
 
+    public proxy?: ISelectorProxy // editor
+
     public config: ISelectorConfig = {}
 
-    protected findPath: FindPath
+    protected picker: Picker
+
+    protected innerIdMap: ILeafMap = {}
+    protected idMap: ILeafMap = {}
 
-    protected innerIdList: ILeafMap = {}
-    protected idList: ILeafMap = {}
-    protected classNameList: ILeafArrayMap = {}
-    protected tagNameList: ILeafArrayMap = {}
+    protected findLeaf: ILeaf
+
+    protected methods = {
+        id: (leaf: ILeaf, name: string) => leaf.id === name ? (this.idMap[name] = leaf, 1) : 0,
+        innerId: (leaf: ILeaf, innerId: number) => leaf.innerId === innerId ? (this.innerIdMap[innerId] = leaf, 1) : 0,
+        className: (leaf: ILeaf, name: string) => leaf.className === name ? 1 : 0,
+        tag: (leaf: ILeaf, name: string) => leaf.__tag === name ? 1 : 0
+    }
 
     protected __eventIds: IEventListenerId[]
 
+
     constructor(target: ILeaf, userConfig?: ISelectorConfig) {
         this.target = target
         if (userConfig) this.config = DataHelper.default(userConfig, this.config)
-        this.findPath = new FindPath(target, this)
+        this.picker = new Picker(target, this)
         this.__listenEvents()
     }
 
-    public getByPoint(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult {
-        if (Platform.name === 'node') 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)
-        } 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 getBy(condition: number | string | IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf | ILeaf[] {
+        switch (typeof condition) {
+            case 'number':
+                const leaf = this.getByInnerId(condition, branch)
+                return one ? leaf : (leaf ? [leaf] : [])
+            case 'string':
+                switch (condition[0]) {
+                    case '#':
+                        const leaf = this.getById(condition.substring(1), branch)
+                        return one ? leaf : (leaf ? [leaf] : [])
+                    case '.':
+                        return this.getByMethod(this.methods.className, branch, one, condition.substring(1)) // className
+                    default:
+                        return this.getByMethod(this.methods.tag, branch, one, condition) // tagName
+                }
+            case 'function':
+                return this.getByMethod(condition as IFindMethod, branch, one, options)
         }
     }
 
-    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 getByPoint(hitPoint: IPointData, hitRadius: number, options?: IPickOptions): IPickResult {
+        if (Platform.name === 'node') this.target.emit(LayoutEvent.CHECK_UPDATE)
+        return this.picker.getByPoint(hitPoint, hitRadius, options)
     }
 
-    public getById(name: string, branch?: ILeaf): ILeaf {
-        let cache = this.idList[name]
+    public getByInnerId(innerId: number, branch?: ILeaf): ILeaf {
+        const cache = this.innerIdMap[innerId]
         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
+        this.eachFind(this.toChildren(branch), this.methods.innerId, null, innerId)
+        return this.findLeaf
     }
 
-    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 getById(id: string, branch?: ILeaf): ILeaf {
+        const cache = this.idMap[id]
+        if (cache && LeafHelper.hasParent(cache, branch || this.target)) return cache
+        this.eachFind(this.toChildren(branch), this.methods.id, null, id)
+        return this.findLeaf
     }
 
-    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
+    public getByClassName(className: string, branch?: ILeaf): ILeaf[] {
+        return this.getByMethod(this.methods.className, branch, false, className) as ILeaf[]
     }
 
-    protected loopFind(branch: ILeaf, find: IFind): void {
-        if (find(branch)) return
-        const { children } = branch
+    public getByTag(tag: string, branch?: ILeaf): ILeaf[] {
+        return this.getByMethod(this.methods.tag, branch, false, tag) as ILeaf[]
+    }
+
+    public getByMethod(method: IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf[] | ILeaf {
+        const list: ILeaf[] = one ? null : []
+        this.eachFind(this.toChildren(branch), method, list, options)
+        return list || this.findLeaf
+    }
+
+
+    protected eachFind(children: ILeaf[], method: IFindMethod, list?: ILeaf[], options?: any): void {
+        let child: ILeaf, result: IAnswer
         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)
+            child = children[i]
+            result = method(child, options)
+            if (result === Yes || result === YesAndSkip) {
+                if (list) {
+                    list.push(child)
+                } else {
+                    this.findLeaf = child
+                    return
+                }
+            }
+            if (child.isBranch && result < NoAndSkip) this.eachFind(child.children, method, list, options)
         }
     }
 
+    protected toChildren(branch: ILeaf): ILeaf[] {
+        this.findLeaf = null
+        return [branch || this.target]
+    }
+
+
     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
+        const { id, innerId } = event.child
+        if (this.idMap[id]) delete this.idMap[id]
+        if (this.innerIdMap[innerId]) delete this.innerIdMap[innerId]
+    }
+
+    protected __checkIdChange(event: PropertyEvent): void {
+        if (event.attrName === 'id') {
+            const id = event.oldValue as string
+            if (this.idMap[id]) delete this.idMap[id]
+        }
     }
 
 
     protected __listenEvents(): void {
         this.__eventIds = [
-            this.target.on_(ChildEvent.REMOVE, this.__onRemoveChild, this)
+            this.target.on_(ChildEvent.REMOVE, this.__onRemoveChild, this),
+            this.target.on_(PropertyEvent.CHANGE, this.__checkIdChange, this)
         ]
     }
 
     protected __removeListenEvents(): void {
         this.target.off_(this.__eventIds)
+        this.__eventIds.length = 0
     }
 
     public destroy(): void {
-        if (this.target) {
+        if (this.__eventIds.length) {
             this.__removeListenEvents()
-            this.findPath.destroy()
-
-            this.target = null
-            this.findPath = null
-            this.innerIdList = null
-            this.idList = null
-            this.classNameList = null
-            this.tagNameList = null
+            this.picker.destroy()
+            this.findLeaf = null
+            this.innerIdMap = {}
+            this.idMap = {}
         }
     }
 

package/types/index.d.ts

@@ -0,0 +1,54 @@
+import { ILeaf, ISelector, ILeafList, IRadiusPointData, IPointData, IPickOptions, IPickResult, ISelectorProxy, ISelectorConfig, ILeafMap, IEventListenerId, IFindMethod } from '@leafer/interface';
+import { LeafList, ChildEvent, PropertyEvent } from '@leafer/core';
+
+declare class Picker {
+    protected target: ILeaf;
+    protected selector: ISelector;
+    protected findList: ILeaf[];
+    protected exclude: ILeafList;
+    protected point: IRadiusPointData;
+    constructor(target: ILeaf, selector: ISelector);
+    getByPoint(hitPoint: IPointData, hitRadius: number, options?: IPickOptions): IPickResult;
+    getBestMatchLeaf(): ILeaf;
+    getPath(leaf: ILeaf): LeafList;
+    getHitablePath(leaf: ILeaf): LeafList;
+    getThroughPath(list: ILeaf[]): LeafList;
+    protected eachFind(children: ILeaf[], hitMask: boolean): void;
+    protected hitChild(child: ILeaf, point: IRadiusPointData): void;
+    protected clear(): void;
+    destroy(): void;
+}
+
+declare class Selector implements ISelector {
+    target: ILeaf;
+    proxy?: ISelectorProxy;
+    config: ISelectorConfig;
+    protected picker: Picker;
+    protected innerIdMap: ILeafMap;
+    protected idMap: ILeafMap;
+    protected findLeaf: ILeaf;
+    protected methods: {
+        id: (leaf: ILeaf, name: string) => 1 | 0;
+        innerId: (leaf: ILeaf, innerId: number) => 1 | 0;
+        className: (leaf: ILeaf, name: string) => 1 | 0;
+        tag: (leaf: ILeaf, name: string) => 1 | 0;
+    };
+    protected __eventIds: IEventListenerId[];
+    constructor(target: ILeaf, userConfig?: ISelectorConfig);
+    getBy(condition: number | string | IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf | ILeaf[];
+    getByPoint(hitPoint: IPointData, hitRadius: number, options?: IPickOptions): IPickResult;
+    getByInnerId(innerId: number, branch?: ILeaf): ILeaf;
+    getById(id: string, branch?: ILeaf): ILeaf;
+    getByClassName(className: string, branch?: ILeaf): ILeaf[];
+    getByTag(tag: string, branch?: ILeaf): ILeaf[];
+    getByMethod(method: IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf[] | ILeaf;
+    protected eachFind(children: ILeaf[], method: IFindMethod, list?: ILeaf[], options?: any): void;
+    protected toChildren(branch: ILeaf): ILeaf[];
+    protected __onRemoveChild(event: ChildEvent): void;
+    protected __checkIdChange(event: PropertyEvent): void;
+    protected __listenEvents(): void;
+    protected __removeListenEvents(): void;
+    destroy(): void;
+}
+
+export { Selector };