@leafer/task 1.0.0-beta.9 → 1.0.0-rc.2

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@leafer/task",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.2",
   "description": "@leafer/task",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
   "main": "src/index.ts",
+  "types": "types/index.d.ts",
   "files": [
-    "src"
+    "src",
+    "types",
+    "dist"
   ],
   "repository": {
     "type": "git",
@@ -19,10 +22,10 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/math": "1.0.0-beta.9",
-    "@leafer/debug": "1.0.0-beta.9"
+    "@leafer/math": "1.0.0-rc.2",
+    "@leafer/debug": "1.0.0-rc.2"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-beta.9"
+    "@leafer/interface": "1.0.0-rc.2"
   }
 }

package/src/TaskItem.ts

@@ -1,30 +1,35 @@
-import { IFunction } from '@leafer/interface'
+import { IFunction, ITaskItem } from '@leafer/interface'
 import { IncrementId } from '@leafer/math'
+import { Debug } from '@leafer/debug'
 
 import { TaskProcessor } from './TaskProcessor'
 
 
-export class TaskItem {
+const debug = Debug.get('TaskProcessor')
+export class TaskItem implements ITaskItem {
 
     readonly id: number
 
     public parent: TaskProcessor
 
-    public parallel: boolean
+    public parallel = true
+    public time = 1 // 预估任务需要运行的时间， 毫秒为单位
+
     public isComplete: boolean
+    public isCancel: boolean
 
     private task: IFunction
 
-    public taskTime = 1 // 预估任务需要运行的时间， 毫秒为单位
-
     constructor(task?: IFunction) {
         this.id = IncrementId.create(IncrementId.TASK)
         this.task = task
     }
 
     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)
         }
     }
 
@@ -34,4 +39,9 @@ export class TaskItem {
         this.task = null
     }
 
+    public cancel(): void {
+        this.isCancel = true
+        this.complete()
+    }
+
 }

package/src/TaskProcessor.ts

@@ -1,27 +1,38 @@
-import { IFunction, ITaskProcessor, ITaskProcessorConfig } from '@leafer/interface'
+import { IFunction, ITaskProcessor, ITaskProcessorConfig, ITaskOptions, ITaskItem } from '@leafer/interface'
 import { DataHelper } from '@leafer/data'
-import { Debug } from '@leafer/debug'
 
 import { TaskItem } from './TaskItem'
 
 
-const debug = Debug.get('TaskProcessor')
-
 export class TaskProcessor implements ITaskProcessor {
 
     public config: ITaskProcessorConfig = { parallel: 6 }
 
-    private list: Array<TaskItem> = []
+    protected list: ITaskItem[] = []
+
+    protected parallelList: ITaskItem[]
+    protected parallelSuccessNumber: number
+
+    public running = false
+    public isComplete = true
 
-    private parallelList: Array<TaskItem>
-    private parallelSuccessNumber: number
+    protected timer: any
 
-    public get isComplete(): boolean { return this._isComplete }
-    private _isComplete: boolean
+    public get total(): number {
+        return this.list.length + this.delayNumber
+    }
 
-    public get running(): boolean { return this._running }
-    private _running: boolean
-    private _timer: any
+    public index = 0
+
+    public delayNumber = 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
+    }
 
     public get percent(): number {
         const { total } = this
@@ -29,40 +40,62 @@ export class TaskProcessor implements ITaskProcessor {
 
         for (let i = 0; i < total; i++) {
             if (i <= this.finishedIndex) {
-                runTime += this.list[i].taskTime
+                runTime += this.list[i].time
                 if (i === this.finishedIndex) totalTime = runTime
             } else {
-                totalTime += this.list[i].taskTime
+                totalTime += this.list[i].time
             }
         }
 
-        return this._isComplete ? 1 : (runTime / totalTime)
+        return this.isComplete ? 1 : (runTime / totalTime)
     }
 
-    public get total(): number {
-        return this.list.length
+
+    constructor(config?: ITaskProcessorConfig) {
+        if (config) DataHelper.assign(this.config, config)
+        this.empty()
     }
 
-    public index = 0
+    // list
 
-    public get finishedIndex(): number {
-        return this._isComplete ? 0 : this.index + this.parallelSuccessNumber
-    }
+    public add(taskCallback: IFunction, options?: ITaskOptions | number): ITaskItem {
+        let start: boolean, parallel: boolean, time: number, delay: number
 
-    public get remain(): number {
-        return this._isComplete ? this.total : this.total - this.finishedIndex
-    }
+        const task = new TaskItem(taskCallback)
+        task.parent = this
+
+        if (typeof options === 'number') {
+            delay = options
+        } else if (options) {
+            parallel = options.parallel
+            start = options.start
+            time = options.time
+            delay = options.delay
+        }
 
+        if (time) task.time = time
+        if (parallel === false) task.parallel = false
 
-    constructor(config?: ITaskProcessorConfig) {
-        if (config) DataHelper.assign(this.config, config)
-        this.init()
+        if (delay === undefined) {
+            this.push(task, start)
+        } else {
+            this.delayNumber++
+            setTimeout(() => {
+                this.delayNumber--
+                this.push(task, start)
+            }, delay)
+        }
+
+        this.isComplete = false
+
+        return task
     }
 
-    protected init(): void {
-        this.empty()
-        this._running = false
-        this._isComplete = true
+    protected push(task: ITaskItem, start?: boolean): void {
+        this.list.push(task)
+        if (start !== false && !this.timer) {
+            this.timer = setTimeout(() => this.start())
+        }
     }
 
     protected empty(): void {
@@ -72,21 +105,24 @@ export class TaskProcessor implements ITaskProcessor {
         this.parallelList = []
     }
 
+    // control
+
     public start(): void {
-        this._running = true
-        this._isComplete = false
-        this.run()
+        if (!this.running) {
+            this.running = true
+            this.isComplete = false
+            this.run()
+        }
     }
 
     public pause(): void {
-        clearTimeout(this._timer)
-        this._running = false
+        clearTimeout(this.timer)
+        this.timer = null
+        this.running = false
     }
 
     public resume(): void {
-        this._running = true
-        this._isComplete = false
-        this.run()
+        this.start()
     }
 
     public skip(): void {
@@ -95,45 +131,22 @@ export class TaskProcessor implements ITaskProcessor {
     }
 
     public stop(): void {
-        clearTimeout(this._timer)
-        this._running = false
-        this._isComplete = true
-        this.list.forEach(item => {
-            item.complete()
-        })
+        this.isComplete = true
+        this.list.forEach(task => { if (!task.isComplete) task.cancel() })
+        this.pause()
         this.empty()
     }
 
+    // run 
 
-
-    public add(taskCallback: IFunction, taskTime?: number): void {
-        this.push(new TaskItem(taskCallback), taskTime)
-    }
-
-    public addParallel(taskCallback: IFunction, taskTime?: number): void {
-        const task = new TaskItem(taskCallback)
-        task.parallel = true
-        this.push(task, taskTime)
-    }
-
-    public addEmpty(callback?: IFunction): void {
-        this.push(new TaskItem(callback))
-    }
-
-    private push(task: TaskItem, taskTime?: number): void {
-        if (taskTime) task.taskTime = taskTime
-        task.parent = this
-        this.list.push(task)
-    }
-
-    private run(): void {
-        if (!this._running) return
+    protected run(): void {
+        if (!this.running) return
 
         this.setParallelList()
 
         if (this.parallelList.length > 1) {
 
-            this.runParallelTask()
+            this.runParallelTasks()
 
         } else {
 
@@ -144,6 +157,10 @@ export class TaskProcessor implements ITaskProcessor {
 
     protected runTask(): void {
         const task = this.list[this.index]
+        if (!task) {
+            this.nextTask() // 存在延时任务
+            return
+        }
         task.run().then(() => {
 
             this.onTask(task)
@@ -156,20 +173,31 @@ export class TaskProcessor implements ITaskProcessor {
         })
     }
 
-    protected runParallelTask(): void {
-        this.parallelList.forEach(task => {
-            task.run().then(() => {
+    protected runParallelTasks(): void {
+        this.parallelList.forEach(task => this.runParallelTask(task))
+    }
+
+    protected runParallelTask(task: ITaskItem): void {
+        task.run().then(() => {
+
+            this.onTask(task)
+            this.fillParallelTask()
 
-                this.onTask(task)
-                this.fillParallelTask()
-            }).catch(error => {
-                this.onParallelError(error)
-            })
+        }).catch(error => {
+            this.onParallelError(error)
         })
     }
 
+    private nextTask(): void {
+        if (this.total === this.finishedIndex) {
+            this.onComplete()
+        } else {
+            this.timer = setTimeout(() => this.run())
+        }
+    }
+
     protected setParallelList(): void {
-        let task: TaskItem
+        let task: ITaskItem
 
         this.parallelList = []
         this.parallelSuccessNumber = 0
@@ -189,8 +217,7 @@ export class TaskProcessor implements ITaskProcessor {
 
 
     protected fillParallelTask(): void {
-
-        let task: TaskItem
+        let task: ITaskItem
         const parallelList = this.parallelList
 
         // 完成一个任务
@@ -203,24 +230,15 @@ export class TaskProcessor implements ITaskProcessor {
 
         if (parallelList.length) {
 
-            if (!this._running) return
+            if (!this.running) return
 
             if (nextIndex < this.total) {
 
                 task = this.list[nextIndex]
 
-                if (task.parallel) {
-
+                if (task && task.parallel) {
                     parallelList.push(task)
-
-                    task.run().then(() => {
-
-                        this.onTask(task)
-                        this.fillParallelTask()
-                    }).catch(error => {
-                        this.onParallelError(error)
-                    })
-
+                    this.runParallelTask(task)
                 }
 
             }
@@ -234,27 +252,19 @@ export class TaskProcessor implements ITaskProcessor {
         }
     }
 
-    private nextTask(): void {
-        if (this.total === this.finishedIndex) {
-            this.onComplete()
-        } else {
-            this._timer = setTimeout(() => this.run(), 0)
-        }
-    }
+    // event
 
-    private onComplete(): void {
+    protected onComplete(): void {
         this.stop()
         if (this.config.onComplete) this.config.onComplete()
     }
 
-    private onTask(task: TaskItem): void {
+    protected onTask(task: ITaskItem): void {
         task.complete()
         if (this.config.onTask) this.config.onTask()
     }
 
-    private onParallelError(error: unknown): void {
-        debug.error('ParallelError')
-
+    protected onParallelError(error: unknown): void {
         // 并行变串行, 以便下次重试
         this.parallelList.forEach(task => {
             task.parallel = false
@@ -265,13 +275,12 @@ export class TaskProcessor implements ITaskProcessor {
         this.onError(error)
     }
 
-    private onError(error: unknown): void {
+    protected onError(error: unknown): void {
         this.pause()
         if (this.config.onError) this.config.onError(error)
     }
 
     public destroy(): void {
-        this.empty()
-        this.config = {}
+        this.stop()
     }
 }

package/types/index.d.ts

@@ -0,0 +1,54 @@
+import { ITaskProcessor, ITaskProcessorConfig, ITaskItem, IFunction, ITaskOptions } from '@leafer/interface';
+
+declare class TaskProcessor implements ITaskProcessor {
+    config: ITaskProcessorConfig;
+    protected list: ITaskItem[];
+    protected parallelList: ITaskItem[];
+    protected parallelSuccessNumber: number;
+    running: boolean;
+    isComplete: boolean;
+    protected timer: any;
+    get total(): number;
+    index: number;
+    delayNumber: number;
+    get finishedIndex(): number;
+    get remain(): number;
+    get percent(): number;
+    constructor(config?: ITaskProcessorConfig);
+    add(taskCallback: IFunction, options?: ITaskOptions | number): ITaskItem;
+    protected push(task: ITaskItem, start?: boolean): void;
+    protected empty(): void;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    skip(): void;
+    stop(): void;
+    protected run(): void;
+    protected runTask(): void;
+    protected runParallelTasks(): void;
+    protected runParallelTask(task: ITaskItem): void;
+    private nextTask;
+    protected setParallelList(): void;
+    protected fillParallelTask(): void;
+    protected onComplete(): void;
+    protected onTask(task: ITaskItem): void;
+    protected onParallelError(error: unknown): void;
+    protected onError(error: unknown): void;
+    destroy(): void;
+}
+
+declare class TaskItem implements ITaskItem {
+    readonly id: number;
+    parent: TaskProcessor;
+    parallel: boolean;
+    time: number;
+    isComplete: boolean;
+    isCancel: boolean;
+    private task;
+    constructor(task?: IFunction);
+    run(): Promise<void>;
+    complete(): void;
+    cancel(): void;
+}
+
+export { TaskItem, TaskProcessor };