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

package/package.json

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

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 = undefined
+    }
+
+}

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 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 = undefined
+    }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { LeafList } from './LeafList'
+export { LeafLevelList } from './LeafLevelList'