@leafer/selector 1.0.0-rc.8 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/selector",
-  "version": "1.0.0-rc.8",
+  "version": "1.0.0",
   "description": "@leafer/selector",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -15,16 +15,16 @@
     "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/core": "1.0.0-rc.8"
+    "@leafer/core": "1.0.0"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.8"
+    "@leafer/interface": "1.0.0"
   }
 }

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

@@ -1,15 +1,15 @@
-import { ILeaf, ILeafList, IPointData, IRadiusPointData, ISelectPathResult, ISelectPathOptions, ISelector } from '@leafer/interface'
+import { ILeaf, ILeafList, IPointData, IRadiusPointData, IPickResult, IPickOptions, ISelector, IPickBottom } from '@leafer/interface'
 import { BoundsHelper, LeafList, LeafHelper } from '@leafer/core'
 
 
 const { hitRadiusPoint } = BoundsHelper
 
-export class Pather {
+export class Picker {
 
     protected target: ILeaf
     protected selector: ISelector
 
-    protected findList: ILeaf[]
+    protected findList: ILeafList
     protected exclude: ILeafList
 
     protected point: IRadiusPointData
@@ -19,45 +19,53 @@ export class Pather {
         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 = new LeafList(options.findList)
 
         // path
-        this.eachFind(this.target.children, this.target.__onlyHitMask)
+        if (!options.findList) this.hitBranch(target)  // 包含through元素
 
-        const list = this.findList
-        const leaf = this.getBestMatchLeaf()
+        const { list } = this.findList
+        const leaf = this.getBestMatchLeaf(list, options.bottomList, ignoreHittable)
         const path = ignoreHittable ? this.getPath(leaf) : this.getHitablePath(leaf)
 
         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 {
-        const { findList: targets } = this
-        if (targets.length > 1) {
+    public getBestMatchLeaf(list: ILeaf[], bottomList: IPickBottom[], ignoreHittable: boolean): ILeaf {
+        if (list.length) {
             let find: ILeaf
-            this.findList = []
+            this.findList = new LeafList()
             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]
-                if (LeafHelper.worldHittable(find)) {
+            for (let i = 0, len = list.length; i < len; i++) {
+                find = list[i]
+                if (ignoreHittable || LeafHelper.worldHittable(find)) {
                     this.hitChild(find, point)
-                    if (this.findList.length) return this.findList[0]
+                    if (this.findList.length) return this.findList.list[0]
                 }
             }
         }
-        return targets[0]
+
+        if (bottomList) { // 底部虚拟元素
+            for (let i = 0, len = bottomList.length; i < len; i++) {
+                this.hitChild(bottomList[i].target, this.point, bottomList[i].proxy)
+                if (this.findList.length) return this.findList.list[0]
+            }
+        }
+
+        return list[0]
     }
 
     public getPath(leaf: ILeaf): LeafList {
@@ -71,7 +79,7 @@ export class Pather {
     }
 
     public getHitablePath(leaf: ILeaf): LeafList {
-        const path = this.getPath(leaf)
+        const path = this.getPath(leaf && leaf.hittable ? leaf : null)
         let item: ILeaf, hittablePath = new LeafList()
         for (let i = path.list.length - 1; i > -1; i--) {
             item = path.list[i]
@@ -103,13 +111,16 @@ export class Pather {
         return throughPath
     }
 
+    protected hitBranch(branch: ILeaf): void {
+        this.eachFind(branch.children, branch.__onlyHitMask)
+    }
 
     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 (!child.__.visible || (hitMask && !child.__.isMask)) continue
+            if (!child.__.visible || (hitMask && !child.__.mask)) continue
             hit = child.__.hitRadius ? true : hitRadiusPoint(child.__world, point)
 
             if (child.isBranch) {
@@ -123,9 +134,13 @@ export class Pather {
         }
     }
 
-    protected hitChild(child: ILeaf, point: IRadiusPointData): void {
+    protected hitChild(child: ILeaf, point: IRadiusPointData, proxy?: ILeaf): void {
         if (this.exclude && this.exclude.has(child)) return
-        if (child.__hitWorld(point)) this.findList.push(child)
+        if (child.__hitWorld(point)) {
+            const { parent } = child
+            if (parent && parent.__hasMask && !child.__.mask && !parent.children.some(item => item.__.mask && item.__hitWorld(point))) return
+            this.findList.add(proxy || child)
+        }
     }
 
     protected clear(): void {

package/src/Selector.ts

@@ -1,11 +1,11 @@
-import { ILeaf, ILeafMap, ISelector, ISelectorProxy, ISelectPathResult, ISelectPathOptions, IPointData, IEventListenerId, ISelectorConfig, IFindMethod, AnswerType } from '@leafer/interface'
-import { ChildEvent, LayoutEvent, DataHelper, Platform, PropertyEvent, LeafHelper } from '@leafer/core'
+import { ILeaf, ILeafMap, ISelector, ISelectorProxy, IPickResult, IPickOptions, IPointData, IEventListenerId, ISelectorConfig, IFindMethod, IAnswer, IFindCondition, IBooleanMap } from '@leafer/interface'
+import { ChildEvent, LayoutEvent, DataHelper, Answer, Platform, PropertyEvent, LeafHelper } from '@leafer/core'
 
-import { Pather } from './Pather'
+import { Picker } from './Picker'
 
 
-const { Yes, NoAndSkip, YesAndSkip } = AnswerType
-
+const { Yes, NoAndSkip, YesAndSkip } = Answer
+const idCondition = {} as IFindCondition, classNameCondition = {} as IFindCondition, tagCondition = {} as IFindCondition
 export class Selector implements ISelector {
 
     public target: ILeaf
@@ -14,7 +14,7 @@ export class Selector implements ISelector {
 
     public config: ISelectorConfig = {}
 
-    protected pather: Pather
+    protected picker: Picker
 
     protected innerIdMap: ILeafMap = {}
     protected idMap: ILeafMap = {}
@@ -25,7 +25,8 @@ export class Selector implements ISelector {
         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
+        tag: (leaf: ILeaf, name: string) => leaf.__tag === name ? 1 : 0,
+        tags: (leaf: ILeaf, nameMap: IBooleanMap) => nameMap[leaf.__tag] ? 1 : 0
     }
 
     protected __eventIds: IEventListenerId[]
@@ -34,11 +35,11 @@ export class Selector implements ISelector {
     constructor(target: ILeaf, userConfig?: ISelectorConfig) {
         this.target = target
         if (userConfig) this.config = DataHelper.default(userConfig, this.config)
-        this.pather = new Pather(target, this)
+        this.picker = new Picker(target, this)
         this.__listenEvents()
     }
 
-    public getBy(condition: number | string | IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf | ILeaf[] {
+    public getBy(condition: number | string | IFindCondition | IFindMethod, branch?: ILeaf, one?: boolean, options?: any): ILeaf | ILeaf[] {
         switch (typeof condition) {
             case 'number':
                 const leaf = this.getByInnerId(condition, branch)
@@ -46,21 +47,30 @@ export class Selector implements ISelector {
             case 'string':
                 switch (condition[0]) {
                     case '#':
-                        const leaf = this.getById(condition.substring(1), branch)
-                        return one ? leaf : (leaf ? [leaf] : [])
+                        idCondition.id = condition.substring(1), condition = idCondition; break
                     case '.':
-                        return this.getByMethod(this.methods.className, branch, one, condition.substring(1)) // className
+                        classNameCondition.className = condition.substring(1), condition = classNameCondition; break
                     default:
-                        return this.getByMethod(this.methods.tag, branch, one, condition) // tagName
+                        tagCondition.tag = condition, condition = tagCondition
+                }
+            case 'object':
+                if (condition.id !== undefined) {
+                    const leaf = this.getById(condition.id as string, branch)
+                    return one ? leaf : (leaf ? [leaf] : [])
+                } else if (condition.tag) {
+                    const { tag } = condition, isArray = tag instanceof Array
+                    return this.getByMethod(isArray ? this.methods.tags : this.methods.tag, branch, one, isArray ? DataHelper.toMap(tag) : tag)
+                } else {
+                    return this.getByMethod(this.methods.className, branch, one, condition.className)
                 }
             case 'function':
                 return this.getByMethod(condition as IFindMethod, branch, one, options)
         }
     }
 
-    public getByPoint(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult {
+    public getByPoint(hitPoint: IPointData, hitRadius: number, options?: IPickOptions): IPickResult {
         if (Platform.name === 'node') this.target.emit(LayoutEvent.CHECK_UPDATE)
-        return this.pather.getByPoint(hitPoint, hitRadius, options)
+        return this.picker.getByPoint(hitPoint, hitRadius, options)
     }
 
     public getByInnerId(innerId: number, branch?: ILeaf): ILeaf {
@@ -93,7 +103,7 @@ export class Selector implements ISelector {
 
 
     protected eachFind(children: ILeaf[], method: IFindMethod, list?: ILeaf[], options?: any): void {
-        let child: ILeaf, result: AnswerType
+        let child: ILeaf, result: IAnswer
         for (let i = 0, len = children.length; i < len; i++) {
             child = children[i]
             result = method(child, options)
@@ -144,7 +154,7 @@ export class Selector implements ISelector {
     public destroy(): void {
         if (this.__eventIds.length) {
             this.__removeListenEvents()
-            this.pather.destroy()
+            this.picker.destroy()
             this.findLeaf = null
             this.innerIdMap = {}
             this.idMap = {}

package/types/index.d.ts

@@ -1,20 +1,21 @@
-import { ILeaf, ISelector, ILeafList, IRadiusPointData, IPointData, ISelectPathOptions, ISelectPathResult, ISelectorProxy, ISelectorConfig, ILeafMap, IEventListenerId, IFindMethod } from '@leafer/interface';
+import { ILeaf, ISelector, ILeafList, IRadiusPointData, IPointData, IPickOptions, IPickResult, IPickBottom, ISelectorProxy, ISelectorConfig, ILeafMap, IBooleanMap, IEventListenerId, IFindCondition, IFindMethod } from '@leafer/interface';
 import { LeafList, ChildEvent, PropertyEvent } from '@leafer/core';
 
-declare class Pather {
+declare class Picker {
     protected target: ILeaf;
     protected selector: ISelector;
-    protected findList: ILeaf[];
+    protected findList: ILeafList;
     protected exclude: ILeafList;
     protected point: IRadiusPointData;
     constructor(target: ILeaf, selector: ISelector);
-    getByPoint(hitPoint: IPointData, hitRadius: number, options?: ISelectPathOptions): ISelectPathResult;
-    getBestMatchLeaf(): ILeaf;
+    getByPoint(hitPoint: IPointData, hitRadius: number, options?: IPickOptions): IPickResult;
+    getBestMatchLeaf(list: ILeaf[], bottomList: IPickBottom[], ignoreHittable: boolean): ILeaf;
     getPath(leaf: ILeaf): LeafList;
     getHitablePath(leaf: ILeaf): LeafList;
     getThroughPath(list: ILeaf[]): LeafList;
+    protected hitBranch(branch: ILeaf): void;
     protected eachFind(children: ILeaf[], hitMask: boolean): void;
-    protected hitChild(child: ILeaf, point: IRadiusPointData): void;
+    protected hitChild(child: ILeaf, point: IRadiusPointData, proxy?: ILeaf): void;
     protected clear(): void;
     destroy(): void;
 }
@@ -23,7 +24,7 @@ declare class Selector implements ISelector {
     target: ILeaf;
     proxy?: ISelectorProxy;
     config: ISelectorConfig;
-    protected pather: Pather;
+    protected picker: Picker;
     protected innerIdMap: ILeafMap;
     protected idMap: ILeafMap;
     protected findLeaf: ILeaf;
@@ -32,11 +33,12 @@ declare class Selector implements ISelector {
         innerId: (leaf: ILeaf, innerId: number) => 1 | 0;
         className: (leaf: ILeaf, name: string) => 1 | 0;
         tag: (leaf: ILeaf, name: string) => 1 | 0;
+        tags: (leaf: ILeaf, nameMap: IBooleanMap) => 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?: ISelectPathOptions): ISelectPathResult;
+    getBy(condition: number | string | IFindCondition | 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[];