@leafer/list 1.0.0-beta.15 → 1.0.0-beta.17

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@leafer/list",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.17",
   "description": "@leafer/list",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
   "main": "src/index.ts",
   "types": "types/index.d.ts",
   "files": [
+    "src",
     "types",
     "dist"
   ],
@@ -21,6 +22,6 @@
     "leaferjs"
   ],
   "devDependencies": {
-    "@leafer/interface": "1.0.0-beta.15"
+    "@leafer/interface": "1.0.0-beta.17"
   }
 }

package/src/LeafLevelList.ts

@@ -0,0 +1,73 @@
+import { ILeaf, ILeafArrayMap, ILeafLevelList, ILeafListItemCallback, INumberMap } from '@leafer/interface'
+
+export class LeafLevelList implements ILeafLevelList {
+
+    public levelMap: ILeafArrayMap
+    public keys: INumberMap
+    public levels: number[]
+
+    public get length(): number { return this._length }
+    private _length = 0
+
+    constructor(item?: ILeaf | ILeaf[]) {
+        this.reset()
+        if (item) item instanceof Array ? this.pushList(item) : this.push(item)
+    }
+
+    public has(leaf: ILeaf): boolean {
+        return this.keys[leaf.innerId] !== undefined
+    }
+
+    public without(leaf: ILeaf): boolean {
+        return this.keys[leaf.innerId] === undefined
+    }
+
+    public sort(reverse?: boolean): void {
+        const { levels } = this
+        if (reverse) {
+            levels.sort((a, b) => b - a) // 倒序
+        } else {
+            levels.sort((a, b) => a - b) // 顺序
+        }
+    }
+
+    public pushList(list: ILeaf[]): void {
+        list.forEach(leaf => { this.push(leaf) })
+    }
+
+    public push(leaf: ILeaf): void {
+        const { keys, levelMap } = this
+        if (!keys[leaf.innerId]) {
+            keys[leaf.innerId] = 1
+            if (!levelMap[leaf.__level]) {
+                levelMap[leaf.__level] = [leaf]
+                this.levels.push(leaf.__level)
+            } else {
+                levelMap[leaf.__level].push(leaf)
+            }
+            this._length++
+        }
+    }
+
+    public forEach(itemCallback: ILeafListItemCallback): void {
+        let list: ILeaf[]
+        this.levels.forEach(level => {
+            list = this.levelMap[level]
+            for (let i = 0, len = list.length; i < len; i++) {
+                itemCallback(list[i])
+            }
+        })
+    }
+
+    public reset(): void {
+        this.levelMap = {}
+        this.keys = {}
+        this.levels = []
+        this._length = 0
+    }
+
+    public destroy(): void {
+        this.levelMap = null
+    }
+
+}

package/src/LeafList.ts

@@ -0,0 +1,93 @@
+import { ILeaf, ILeafList, ILeafListItemCallback, INumberMap } from '@leafer/interface'
+
+export class LeafList implements ILeafList {
+
+    public list: ILeaf[]
+    public keys: INumberMap
+
+    public get length(): number { return this.list.length }
+
+    constructor(item?: ILeaf | ILeaf[]) {
+        this.reset()
+        if (item) item instanceof Array ? this.pushList(item) : this.push(item)
+    }
+
+    public has(leaf: ILeaf): boolean {
+        return leaf && this.keys[leaf.innerId] !== undefined
+    }
+
+    public indexAt(index: number): ILeaf {
+        return this.list[index]
+    }
+
+    public indexOf(leaf: ILeaf): number {
+        const index = this.keys[leaf.innerId]
+        return index === undefined ? -1 : index
+    }
+
+    public pushList(list: ILeaf[]): void {
+        list.forEach(leaf => { this.push(leaf) })
+    }
+
+    public unshift(leaf: ILeaf): void {
+        const { keys } = this
+        if (keys[leaf.innerId] === undefined) {
+            this.list.unshift(leaf)
+            Object.keys(keys).forEach(innerId => {
+                if (keys[innerId] !== undefined) keys[innerId]++
+            })
+            keys[leaf.innerId] = 0
+        }
+    }
+
+    public push(leaf: ILeaf): void {
+        const { list, keys } = this
+        if (keys[leaf.innerId] === undefined) {
+            list.push(leaf)
+            keys[leaf.innerId] = list.length - 1
+        }
+    }
+
+    public sort(reverse?: boolean): void {
+        const { list } = this
+        if (reverse) {
+            list.sort((a, b) => b.__level - a.__level) // 倒序
+        } else {
+            list.sort((a, b) => a.__level - b.__level) // 顺序
+        }
+    }
+
+    public remove(leaf: ILeaf): void {
+        const { list } = this
+        let findIndex: number
+        for (let i = 0, len = list.length; i < len; i++) {
+            if (findIndex !== undefined) {
+                this.keys[list[i].innerId] = i - 1 // update rest keys
+            } else if (list[i].innerId === leaf.innerId) {
+                findIndex = i
+                delete this.keys[leaf.innerId]
+            }
+        }
+
+        if (findIndex !== undefined) list.splice(findIndex, 1)
+    }
+
+    public forEach(itemCallback: ILeafListItemCallback): void {
+        this.list.forEach(itemCallback)
+    }
+
+    public clone(): ILeafList {
+        const list = new LeafList()
+        this.list.forEach(item => { list.push(item) })
+        return list
+    }
+
+    public reset(): void {
+        this.list = []
+        this.keys = {}
+    }
+
+    public destroy(): void {
+        this.list = null
+    }
+}