@leafer/task 1.0.0-beta → 1.0.0-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/task",
-  "version": "1.0.0-beta",
+  "version": "1.0.0-beta.10",
   "description": "@leafer/task",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -19,10 +19,10 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/math": "1.0.0-beta",
-    "@leafer/debug": "1.0.0-beta"
+    "@leafer/math": "1.0.0-beta.10",
+    "@leafer/debug": "1.0.0-beta.10"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-beta"
+    "@leafer/interface": "1.0.0-beta.10"
   }
 }

package/src/TaskItem.ts

@@ -1,9 +1,11 @@
 import { IFunction } from '@leafer/interface'
 import { IncrementId } from '@leafer/math'
+import { Debug } from '@leafer/debug'
 
 import { TaskProcessor } from './TaskProcessor'
 
 
+const debug = Debug.get('TaskProcessor')
 export class TaskItem {
 
     readonly id: number
@@ -23,8 +25,10 @@ export class TaskItem {
     }
 
     async run(): Promise<void> {
-        if (this.task && !this.isComplete && this.parent.running) {
-            await this.task()
+        try {
+            if (this.task && !this.isComplete && this.parent.running) await this.task()
+        } catch (error) {
+            debug.error(error)
         }
     }
 

package/src/TaskProcessor.ts

@@ -1,92 +1,74 @@
-import { IFunction } from '@leafer/interface'
-import { Debug } from '@leafer/debug'
+import { IFunction, ITaskProcessor, ITaskProcessorConfig } from '@leafer/interface'
+import { DataHelper } from '@leafer/data'
 
 import { TaskItem } from './TaskItem'
 
 
-const debug = Debug.get('TaskProcessor')
+export class TaskProcessor implements ITaskProcessor {
 
+    public config: ITaskProcessorConfig = { parallel: 6 }
 
-export interface ITaskProcessorParams {
-    onComplete?: IFunction
-    onTask?: IFunction
-    onError?: IFunction
-    parallel?: number
-}
-
-
-export class TaskProcessor {
-
-    private parallel = 6
-    private params: ITaskProcessorParams = {}
-
-    // 需要初始化的动态数据
     private list: Array<TaskItem> = []
-    private index = 0
 
     private parallelList: Array<TaskItem>
     private parallelSuccessNumber: number
 
+    public get isComplete(): boolean { return this._isComplete }
     private _isComplete: boolean
-    public get isComplete(): boolean {
-        return this._isComplete
-    }
 
+    public get running(): boolean { return this._running }
     private _running: boolean
-    public get running(): boolean {
-        return this._running
-    }
+    private _timer: any
 
-    constructor(params?: ITaskProcessorParams) {
-        if (params) {
-            this.params = params
-            if (params.parallel) this.parallel = params.parallel
-        }
-        this.init()
-    }
+    public get percent(): number {
+        const { total } = this
+        let totalTime = 0, runTime = 0
 
-    get percent(): number {
-        const len = this.list.length
-        let totalTime = 0
-        let runTime = 0
-        for (let i = 0; i < len; i++) {
-            if (i <= this.index) {
+        for (let i = 0; i < total; i++) {
+            if (i <= this.finishedIndex) {
                 runTime += this.list[i].taskTime
-                if (i === this.index) totalTime = runTime
+                if (i === this.finishedIndex) totalTime = runTime
             } else {
                 totalTime += this.list[i].taskTime
             }
         }
 
-        let percent = this._isComplete ? 1 : (runTime / totalTime)
-        if (Number.isNaN(percent)) percent = 0
-        return percent
-
+        return this._isComplete ? 1 : (runTime / totalTime)
     }
 
-    get total(): number {
+    public get total(): number {
         return this.list.length
     }
 
-    get runIndex(): number {
-        return this.index
+    public index = 0
+
+    public get finishedIndex(): number {
+        return this._isComplete ? 0 : this.index + this.parallelSuccessNumber
+    }
+
+    public get remain(): number {
+        return this._isComplete ? this.total : this.total - this.finishedIndex
+    }
+
+
+    constructor(config?: ITaskProcessorConfig) {
+        if (config) DataHelper.assign(this.config, config)
+        this.init()
     }
 
     protected init(): void {
         this.empty()
-        this.index = 0
-        this.parallelSuccessNumber = 0
         this._running = false
-        this._isComplete = false
+        this._isComplete = true
     }
 
     protected empty(): void {
+        this.index = 0
+        this.parallelSuccessNumber = 0
         this.list = []
         this.parallelList = []
     }
 
-
-
     public start(): void {
         this._running = true
         this._isComplete = false
@@ -94,6 +76,7 @@ export class TaskProcessor {
     }
 
     public pause(): void {
+        clearTimeout(this._timer)
         this._running = false
     }
 
@@ -109,7 +92,9 @@ export class TaskProcessor {
     }
 
     public stop(): void {
+        clearTimeout(this._timer)
         this._running = false
+        this._isComplete = true
         this.list.forEach(item => {
             item.complete()
         })
@@ -118,26 +103,25 @@ export class TaskProcessor {
 
 
 
-    public add(taskCallback: IFunction, taskTime?: number): void {
-        this.push(new TaskItem(taskCallback), taskTime)
+    public add(taskCallback: IFunction, taskTime?: number, start?: boolean,): void {
+        this.push(new TaskItem(taskCallback), taskTime, start)
     }
 
-    public addParallel(taskCallback: IFunction, taskTime?: number): void {
+    public addParallel(taskCallback: IFunction, taskTime?: number, start?: boolean): void {
         const task = new TaskItem(taskCallback)
         task.parallel = true
-        this.push(task, taskTime)
+        this.push(task, taskTime, start)
     }
 
     public addEmpty(callback?: IFunction): void {
         this.push(new TaskItem(callback))
     }
 
-
-
-    private push(task: TaskItem, taskTime?: number): void {
+    private push(task: TaskItem, taskTime?: number, start?: boolean): void {
         if (taskTime) task.taskTime = taskTime
         task.parent = this
         this.list.push(task)
+        if (start && !this.running) this.start()
     }
 
     private run(): void {
@@ -151,7 +135,7 @@ export class TaskProcessor {
 
         } else {
 
-            this.runTask()
+            this.remain ? this.runTask() : this.onComplete()
 
         }
     }
@@ -187,7 +171,7 @@ export class TaskProcessor {
 
         this.parallelList = []
         this.parallelSuccessNumber = 0
-        let end = this.index + this.parallel
+        let end = this.index + this.config.parallel
 
         if (end > this.list.length) end = this.list.length
 
@@ -213,13 +197,13 @@ export class TaskProcessor {
 
         // 找到下一个可以并行的任务
         const parallelWaitNumber = parallelList.length
-        const nextIndex = this.index + this.parallelSuccessNumber + parallelWaitNumber
+        const nextIndex = this.finishedIndex + parallelWaitNumber
 
         if (parallelList.length) {
 
             if (!this._running) return
 
-            if (nextIndex < this.list.length) {
+            if (nextIndex < this.total) {
 
                 task = this.list[nextIndex]
 
@@ -236,36 +220,37 @@ export class TaskProcessor {
                     })
 
                 }
+
             }
 
         } else {
 
             this.index += this.parallelSuccessNumber
+            this.parallelSuccessNumber = 0
             this.nextTask()
 
         }
     }
 
     private nextTask(): void {
-        setTimeout(() => {
-            this.run()
-        }, 0)
+        if (this.total === this.finishedIndex) {
+            this.onComplete()
+        } else {
+            this._timer = setTimeout(() => this.run(), 0)
+        }
     }
 
     private onComplete(): void {
         this.stop()
-        this._isComplete = true
-        if (this.params.onComplete) this.params.onComplete()
+        if (this.config.onComplete) this.config.onComplete()
     }
 
     private onTask(task: TaskItem): void {
         task.complete()
-        if (this.params.onTask) this.params.onTask()
-        if (this.index === this.list.length - 1) this.onComplete()
+        if (this.config.onTask) this.config.onTask()
     }
 
     private onParallelError(error: unknown): void {
-        debug.error('ParallelError')
 
         // 并行变串行, 以便下次重试
         this.parallelList.forEach(task => {
@@ -279,6 +264,11 @@ export class TaskProcessor {
 
     private onError(error: unknown): void {
         this.pause()
-        if (this.params.onError) this.params.onError(error)
+        if (this.config.onError) this.config.onError(error)
+    }
+
+    public destroy(): void {
+        this.empty()
+        this.config = {}
     }
 }