npm - @guanghechen/task - Versions diffs - 1.0.0-alpha.1 → 1.0.0-alpha.3 - Mend

@guanghechen/task 1.0.0-alpha.1 → 1.0.0-alpha.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+# [1.0.0-alpha.3](https://github.com/guanghechen/sora/compare/@guanghechen/task@1.0.0-alpha.2...@guanghechen/task@1.0.0-alpha.3) (2023-08-30)
+### Performance Improvements
+* 🎨 reuse constants and types ([5efb70e](https://github.com/guanghechen/sora/commit/5efb70e6df130dc870ccb5add632291dcbd94809))
+# [1.0.0-alpha.2](https://github.com/guanghechen/sora/compare/@guanghechen/task@1.0.0-alpha.1...@guanghechen/task@1.0.0-alpha.2) (2023-08-28)
+### Features
+* ✨ add @guanghechen/error & refactor other sub packages ([c50e94d](https://github.com/guanghechen/sora/commit/c50e94de4b9e6d7fd635c10e202eb8bdc4f4f8dd))
 # 1.0.0-alpha.1 (2023-08-27)

package/lib/cjs/index.cjs CHANGED Viewed

@@ -1,51 +1,35 @@
 'use strict';
+var constant = require('@guanghechen/constant');
+var error = require('@guanghechen/error');
 var monitor = require('@guanghechen/monitor');
-exports.TaskStatus = void 0;
-(function (TaskStatus) {
-    TaskStatus[TaskStatus["PENDING"] = 1] = "PENDING";
-    TaskStatus[TaskStatus["RUNNING"] = 2] = "RUNNING";
-    TaskStatus[TaskStatus["SUSPENDED"] = 4] = "SUSPENDED";
-    TaskStatus[TaskStatus["CANCELLED"] = 8] = "CANCELLED";
-    TaskStatus[TaskStatus["FAILED"] = 16] = "FAILED";
-    TaskStatus[TaskStatus["FINISHED"] = 32] = "FINISHED";
-    TaskStatus[TaskStatus["ATTEMPT_SUSPENDING"] = 64] = "ATTEMPT_SUSPENDING";
-    TaskStatus[TaskStatus["ATTEMPT_RESUMING"] = 128] = "ATTEMPT_RESUMING";
-    TaskStatus[TaskStatus["ATTEMPT_CANCELING"] = 256] = "ATTEMPT_CANCELING";
-    TaskStatus[TaskStatus["ATTEMPT_FINISHING"] = 512] = "ATTEMPT_FINISHING";
-})(exports.TaskStatus || (exports.TaskStatus = {}));
-exports.TaskStrategy = void 0;
-(function (TaskStrategy) {
-    TaskStrategy[TaskStrategy["ABORT_ON_ERROR"] = 1] = "ABORT_ON_ERROR";
-    TaskStrategy[TaskStrategy["CONTINUE_ON_ERROR"] = 2] = "CONTINUE_ON_ERROR";
-})(exports.TaskStrategy || (exports.TaskStrategy = {}));
-const active = exports.TaskStatus.RUNNING |
-    exports.TaskStatus.ATTEMPT_SUSPENDING |
-    exports.TaskStatus.ATTEMPT_RESUMING;
-const alive = exports.TaskStatus.PENDING |
-    exports.TaskStatus.RUNNING |
-    exports.TaskStatus.SUSPENDED |
-    exports.TaskStatus.ATTEMPT_SUSPENDING |
-    exports.TaskStatus.ATTEMPT_RESUMING;
-const terminated = exports.TaskStatus.CANCELLED |
-    exports.TaskStatus.FAILED |
-    exports.TaskStatus.FINISHED;
+function noop(..._args) { }
-const noop = () => { };
+const active = constant.TaskStatusEnum.RUNNING |
+    constant.TaskStatusEnum.ATTEMPT_SUSPENDING |
+    constant.TaskStatusEnum.ATTEMPT_RESUMING;
+const alive = constant.TaskStatusEnum.PENDING |
+    constant.TaskStatusEnum.RUNNING |
+    constant.TaskStatusEnum.SUSPENDED |
+    constant.TaskStatusEnum.ATTEMPT_SUSPENDING |
+    constant.TaskStatusEnum.ATTEMPT_RESUMING;
+const terminated = constant.TaskStatusEnum.CANCELLED |
+    constant.TaskStatusEnum.FAILED |
+    constant.TaskStatusEnum.FINISHED;
 class TaskState {
     name;
+    _errorCollector;
     _monitors;
-    _errorDetails;
     _status;
     constructor(name) {
         this.name = name;
+        this._errorCollector = new error.SoraErrorCollector(name);
         this._monitors = {
             onAddError: new monitor.Monitor('onAddError'),
             onStatusChange: new monitor.Monitor('onStatusChange'),
         };
-        this._errorDetails = [];
-        this._status = exports.TaskStatus.PENDING;
+        this._status = constant.TaskStatusEnum.PENDING;
     }
     get status() {
         return this._status;
@@ -60,12 +44,12 @@ class TaskState {
         return (this._status & terminated) > 0;
     }
     get hasError() {
-        return this._errorDetails.length > 0;
+        return this._errorCollector.size > 0;
     }
     get error() {
-        if (this._errorDetails.length === 0)
+        if (this._errorCollector.size === 0)
             return undefined;
-        return { from: this.name, details: this._errorDetails.slice() };
+        return { from: this.name, details: this._errorCollector.errors };
     }
     set status(status) {
         const curStatus = this._status;
@@ -84,12 +68,8 @@ class TaskState {
         if (this.terminated)
             return noop;
         const { onAddError, onStatusChange } = monitor;
-        const unsubscribeOnAddError = onAddError
-            ? this._monitors.onAddError.subscribe(onAddError)
-            : noop;
-        const unsubscribeOnStatusChange = onStatusChange
-            ? this._monitors.onStatusChange.subscribe(onStatusChange)
-            : noop;
+        const unsubscribeOnAddError = this._monitors.onAddError.subscribe(onAddError);
+        const unsubscribeOnStatusChange = this._monitors.onStatusChange.subscribe(onStatusChange);
         return () => {
             unsubscribeOnAddError();
             unsubscribeOnStatusChange();
@@ -98,30 +78,30 @@ class TaskState {
     check(nextStatus) {
         const status = this._status;
         switch (nextStatus) {
-            case exports.TaskStatus.PENDING:
+            case constant.TaskStatusEnum.PENDING:
                 return false;
-            case exports.TaskStatus.RUNNING:
-                return status === exports.TaskStatus.PENDING || status === exports.TaskStatus.ATTEMPT_RESUMING;
-            case exports.TaskStatus.SUSPENDED:
-                return status === exports.TaskStatus.ATTEMPT_SUSPENDING;
-            case exports.TaskStatus.CANCELLED:
-                return status === exports.TaskStatus.ATTEMPT_CANCELING;
-            case exports.TaskStatus.FAILED:
-                return (status !== exports.TaskStatus.PENDING &&
-                    status !== exports.TaskStatus.SUSPENDED &&
+            case constant.TaskStatusEnum.RUNNING:
+                return status === constant.TaskStatusEnum.PENDING || status === constant.TaskStatusEnum.ATTEMPT_RESUMING;
+            case constant.TaskStatusEnum.SUSPENDED:
+                return status === constant.TaskStatusEnum.ATTEMPT_SUSPENDING;
+            case constant.TaskStatusEnum.CANCELLED:
+                return status === constant.TaskStatusEnum.ATTEMPT_CANCELING;
+            case constant.TaskStatusEnum.FAILED:
+                return (status !== constant.TaskStatusEnum.PENDING &&
+                    status !== constant.TaskStatusEnum.SUSPENDED &&
                     (status & terminated) === 0);
-            case exports.TaskStatus.FINISHED:
-                return (status !== exports.TaskStatus.PENDING &&
-                    status !== exports.TaskStatus.SUSPENDED &&
+            case constant.TaskStatusEnum.FINISHED:
+                return (status !== constant.TaskStatusEnum.PENDING &&
+                    status !== constant.TaskStatusEnum.SUSPENDED &&
                     (status & terminated) === 0);
-            case exports.TaskStatus.ATTEMPT_SUSPENDING:
-                return status === exports.TaskStatus.RUNNING;
-            case exports.TaskStatus.ATTEMPT_RESUMING:
-                return status === exports.TaskStatus.SUSPENDED;
-            case exports.TaskStatus.ATTEMPT_CANCELING:
+            case constant.TaskStatusEnum.ATTEMPT_SUSPENDING:
+                return status === constant.TaskStatusEnum.RUNNING;
+            case constant.TaskStatusEnum.ATTEMPT_RESUMING:
+                return status === constant.TaskStatusEnum.SUSPENDED;
+            case constant.TaskStatusEnum.ATTEMPT_CANCELING:
                 return (status & alive) > 0;
-            case exports.TaskStatus.ATTEMPT_FINISHING:
-                return status !== exports.TaskStatus.PENDING && (status & alive) > 0;
+            case constant.TaskStatusEnum.ATTEMPT_FINISHING:
+                return status !== constant.TaskStatusEnum.PENDING && (status & alive) > 0;
             default:
                 return false;
         }
@@ -129,13 +109,13 @@ class TaskState {
     cleanup() {
         if (!this.terminated)
             throw new Error(`[cleanup] task(${this.name}) is not terminated`);
-        this._errorDetails.length = 0;
+        this._errorCollector.cleanup();
         this._monitors.onStatusChange.destroy();
         this._monitors.onAddError.destroy();
     }
-    _addError(type, error) {
-        this._errorDetails.push({ type, error });
-        this._monitors.onAddError.notify(type, error);
+    _addError(type, error, level = constant.ErrorLevelEnum.ERROR) {
+        this._errorCollector.add(type, error, level);
+        this._monitors.onAddError.notify(type, error, level);
     }
 }
@@ -146,15 +126,15 @@ class AtomicTask extends TaskState {
         this._promise = undefined;
     }
     async start() {
-        if (this.status === exports.TaskStatus.PENDING) {
-            this.status = exports.TaskStatus.RUNNING;
+        if (this.status === constant.TaskStatusEnum.PENDING) {
+            this.status = constant.TaskStatusEnum.RUNNING;
             this._promise = this.run()
                 .then(() => {
-                this.status = exports.TaskStatus.FINISHED;
+                this.status = constant.TaskStatusEnum.FINISHED;
             })
                 .catch(error => {
-                this.status = exports.TaskStatus.FAILED;
                 this._addError('AtomicTaskError', error);
+                this.status = constant.TaskStatusEnum.FAILED;
             });
         }
         return this._promise;
@@ -166,20 +146,20 @@ class AtomicTask extends TaskState {
         await this._promise;
     }
     async cancel() {
-        if (this.status === exports.TaskStatus.PENDING) {
-            this.status = exports.TaskStatus.ATTEMPT_CANCELING;
-            this.status = exports.TaskStatus.CANCELLED;
+        if (this.status === constant.TaskStatusEnum.PENDING) {
+            this.status = constant.TaskStatusEnum.ATTEMPT_CANCELING;
+            this.status = constant.TaskStatusEnum.CANCELLED;
             return;
         }
         if (this.alive)
-            this.status = exports.TaskStatus.ATTEMPT_CANCELING;
+            this.status = constant.TaskStatusEnum.ATTEMPT_CANCELING;
         await this._promise;
     }
     async finish() {
-        if (this.status === exports.TaskStatus.PENDING)
+        if (this.status === constant.TaskStatusEnum.PENDING)
             await this.start();
         if (this.alive)
-            this.status = exports.TaskStatus.ATTEMPT_FINISHING;
+            this.status = constant.TaskStatusEnum.ATTEMPT_FINISHING;
         await this._promise;
     }
 }
@@ -197,63 +177,63 @@ class ResumableTask extends TaskState {
         this._step = undefined;
     }
     async start() {
-        if (this.status === exports.TaskStatus.PENDING) {
-            this.status = exports.TaskStatus.RUNNING;
+        if (this.status === constant.TaskStatusEnum.PENDING) {
+            this.status = constant.TaskStatusEnum.RUNNING;
             this._execution = this.run();
             this.launchStep();
             await this._step;
         }
     }
     async pause() {
-        if (this.status === exports.TaskStatus.RUNNING) {
-            this.status = exports.TaskStatus.ATTEMPT_SUSPENDING;
+        if (this.status === constant.TaskStatusEnum.RUNNING) {
+            this.status = constant.TaskStatusEnum.ATTEMPT_SUSPENDING;
             await this._step;
-            if (this.status === exports.TaskStatus.ATTEMPT_SUSPENDING) {
-                this.status = exports.TaskStatus.SUSPENDED;
+            if (this.status === constant.TaskStatusEnum.ATTEMPT_SUSPENDING) {
+                this.status = constant.TaskStatusEnum.SUSPENDED;
             }
         }
     }
     async resume() {
-        if (this.status === exports.TaskStatus.SUSPENDED) {
-            this.status = exports.TaskStatus.ATTEMPT_RESUMING;
+        if (this.status === constant.TaskStatusEnum.SUSPENDED) {
+            this.status = constant.TaskStatusEnum.ATTEMPT_RESUMING;
             await this._step;
-            if (this.status === exports.TaskStatus.ATTEMPT_RESUMING) {
-                this.status = exports.TaskStatus.RUNNING;
+            if (this.status === constant.TaskStatusEnum.ATTEMPT_RESUMING) {
+                this.status = constant.TaskStatusEnum.RUNNING;
                 this.queueStep();
             }
         }
     }
     async cancel() {
         if (this.alive) {
-            this.status = exports.TaskStatus.ATTEMPT_CANCELING;
+            this.status = constant.TaskStatusEnum.ATTEMPT_CANCELING;
             await this._step;
-            if (this.status === exports.TaskStatus.ATTEMPT_CANCELING) {
-                this.status = exports.TaskStatus.CANCELLED;
+            if (this.status === constant.TaskStatusEnum.ATTEMPT_CANCELING) {
+                this.status = constant.TaskStatusEnum.CANCELLED;
             }
         }
     }
     async finish() {
-        if (this.status === exports.TaskStatus.PENDING)
+        if (this.status === constant.TaskStatusEnum.PENDING)
             await this.start();
         if (this.alive) {
-            this.status = exports.TaskStatus.ATTEMPT_FINISHING;
+            this.status = constant.TaskStatusEnum.ATTEMPT_FINISHING;
             await this._step;
             const execution = this._execution;
             if (execution) {
-                while (this.status === exports.TaskStatus.ATTEMPT_FINISHING) {
+                while (this.status === constant.TaskStatusEnum.ATTEMPT_FINISHING) {
                     const step = execution.next();
                     if (step.done) {
-                        this.status = this.hasError ? exports.TaskStatus.FAILED : exports.TaskStatus.FINISHED;
+                        this.status = this.hasError ? constant.TaskStatusEnum.FAILED : constant.TaskStatusEnum.FINISHED;
                         break;
                     }
                     await step.value.catch(error => {
                         this._addError('ResumableTaskError', error);
                         switch (this.strategy) {
-                            case exports.TaskStrategy.ABORT_ON_ERROR:
+                            case constant.TaskStrategyEnum.ABORT_ON_ERROR:
                                 if (!this.terminated)
-                                    this.status = exports.TaskStatus.FAILED;
+                                    this.status = constant.TaskStatusEnum.FAILED;
                                 break;
-                            case exports.TaskStrategy.CONTINUE_ON_ERROR:
+                            case constant.TaskStrategyEnum.CONTINUE_ON_ERROR:
                                 break;
                         }
                     });
@@ -262,10 +242,10 @@ class ResumableTask extends TaskState {
         }
     }
     launchStep() {
-        if (this.status === exports.TaskStatus.RUNNING && this._step === undefined && this._execution) {
+        if (this.status === constant.TaskStatusEnum.RUNNING && this._step === undefined && this._execution) {
             const step = this._execution.next();
             if (step.done) {
-                this.status = this.hasError ? exports.TaskStatus.FAILED : exports.TaskStatus.FINISHED;
+                this.status = this.hasError ? constant.TaskStatusEnum.FAILED : constant.TaskStatusEnum.FINISHED;
                 return;
             }
             this._step = step.value
@@ -277,11 +257,11 @@ class ResumableTask extends TaskState {
                 this._step = undefined;
                 this._addError('ResumableTaskError', error);
                 switch (this.strategy) {
-                    case exports.TaskStrategy.ABORT_ON_ERROR:
+                    case constant.TaskStrategyEnum.ABORT_ON_ERROR:
                         if (!this.terminated)
-                            this.status = exports.TaskStatus.FAILED;
+                            this.status = constant.TaskStatusEnum.FAILED;
                         break;
-                    case exports.TaskStrategy.CONTINUE_ON_ERROR:
+                    case constant.TaskStrategyEnum.CONTINUE_ON_ERROR:
                         this.queueStep();
                         break;
                 }
@@ -296,6 +276,3 @@ class ResumableTask extends TaskState {
 exports.AtomicTask = AtomicTask;
 exports.ResumableTask = ResumableTask;
 exports.TaskState = TaskState;
-exports.active = active;
-exports.alive = alive;
-exports.terminated = terminated;

package/lib/esm/index.mjs CHANGED Viewed

@@ -1,49 +1,33 @@
+import { TaskStatusEnum, ErrorLevelEnum, TaskStrategyEnum } from '@guanghechen/constant';
+import { SoraErrorCollector } from '@guanghechen/error';
 import { Monitor } from '@guanghechen/monitor';
-var TaskStatus;
-(function (TaskStatus) {
-    TaskStatus[TaskStatus["PENDING"] = 1] = "PENDING";
-    TaskStatus[TaskStatus["RUNNING"] = 2] = "RUNNING";
-    TaskStatus[TaskStatus["SUSPENDED"] = 4] = "SUSPENDED";
-    TaskStatus[TaskStatus["CANCELLED"] = 8] = "CANCELLED";
-    TaskStatus[TaskStatus["FAILED"] = 16] = "FAILED";
-    TaskStatus[TaskStatus["FINISHED"] = 32] = "FINISHED";
-    TaskStatus[TaskStatus["ATTEMPT_SUSPENDING"] = 64] = "ATTEMPT_SUSPENDING";
-    TaskStatus[TaskStatus["ATTEMPT_RESUMING"] = 128] = "ATTEMPT_RESUMING";
-    TaskStatus[TaskStatus["ATTEMPT_CANCELING"] = 256] = "ATTEMPT_CANCELING";
-    TaskStatus[TaskStatus["ATTEMPT_FINISHING"] = 512] = "ATTEMPT_FINISHING";
-})(TaskStatus || (TaskStatus = {}));
-var TaskStrategy;
-(function (TaskStrategy) {
-    TaskStrategy[TaskStrategy["ABORT_ON_ERROR"] = 1] = "ABORT_ON_ERROR";
-    TaskStrategy[TaskStrategy["CONTINUE_ON_ERROR"] = 2] = "CONTINUE_ON_ERROR";
-})(TaskStrategy || (TaskStrategy = {}));
-const active = TaskStatus.RUNNING |
-    TaskStatus.ATTEMPT_SUSPENDING |
-    TaskStatus.ATTEMPT_RESUMING;
-const alive = TaskStatus.PENDING |
-    TaskStatus.RUNNING |
-    TaskStatus.SUSPENDED |
-    TaskStatus.ATTEMPT_SUSPENDING |
-    TaskStatus.ATTEMPT_RESUMING;
-const terminated = TaskStatus.CANCELLED |
-    TaskStatus.FAILED |
-    TaskStatus.FINISHED;
+function noop(..._args) { }
-const noop = () => { };
+const active = TaskStatusEnum.RUNNING |
+    TaskStatusEnum.ATTEMPT_SUSPENDING |
+    TaskStatusEnum.ATTEMPT_RESUMING;
+const alive = TaskStatusEnum.PENDING |
+    TaskStatusEnum.RUNNING |
+    TaskStatusEnum.SUSPENDED |
+    TaskStatusEnum.ATTEMPT_SUSPENDING |
+    TaskStatusEnum.ATTEMPT_RESUMING;
+const terminated = TaskStatusEnum.CANCELLED |
+    TaskStatusEnum.FAILED |
+    TaskStatusEnum.FINISHED;
 class TaskState {
     name;
+    _errorCollector;
     _monitors;
-    _errorDetails;
     _status;
     constructor(name) {
         this.name = name;
+        this._errorCollector = new SoraErrorCollector(name);
         this._monitors = {
             onAddError: new Monitor('onAddError'),
             onStatusChange: new Monitor('onStatusChange'),
         };
-        this._errorDetails = [];
-        this._status = TaskStatus.PENDING;
+        this._status = TaskStatusEnum.PENDING;
     }
     get status() {
         return this._status;
@@ -58,12 +42,12 @@ class TaskState {
         return (this._status & terminated) > 0;
     }
     get hasError() {
-        return this._errorDetails.length > 0;
+        return this._errorCollector.size > 0;
     }
     get error() {
-        if (this._errorDetails.length === 0)
+        if (this._errorCollector.size === 0)
             return undefined;
-        return { from: this.name, details: this._errorDetails.slice() };
+        return { from: this.name, details: this._errorCollector.errors };
     }
     set status(status) {
         const curStatus = this._status;
@@ -82,12 +66,8 @@ class TaskState {
         if (this.terminated)
             return noop;
         const { onAddError, onStatusChange } = monitor;
-        const unsubscribeOnAddError = onAddError
-            ? this._monitors.onAddError.subscribe(onAddError)
-            : noop;
-        const unsubscribeOnStatusChange = onStatusChange
-            ? this._monitors.onStatusChange.subscribe(onStatusChange)
-            : noop;
+        const unsubscribeOnAddError = this._monitors.onAddError.subscribe(onAddError);
+        const unsubscribeOnStatusChange = this._monitors.onStatusChange.subscribe(onStatusChange);
         return () => {
             unsubscribeOnAddError();
             unsubscribeOnStatusChange();
@@ -96,30 +76,30 @@ class TaskState {
     check(nextStatus) {
         const status = this._status;
         switch (nextStatus) {
-            case TaskStatus.PENDING:
+            case TaskStatusEnum.PENDING:
                 return false;
-            case TaskStatus.RUNNING:
-                return status === TaskStatus.PENDING || status === TaskStatus.ATTEMPT_RESUMING;
-            case TaskStatus.SUSPENDED:
-                return status === TaskStatus.ATTEMPT_SUSPENDING;
-            case TaskStatus.CANCELLED:
-                return status === TaskStatus.ATTEMPT_CANCELING;
-            case TaskStatus.FAILED:
-                return (status !== TaskStatus.PENDING &&
-                    status !== TaskStatus.SUSPENDED &&
+            case TaskStatusEnum.RUNNING:
+                return status === TaskStatusEnum.PENDING || status === TaskStatusEnum.ATTEMPT_RESUMING;
+            case TaskStatusEnum.SUSPENDED:
+                return status === TaskStatusEnum.ATTEMPT_SUSPENDING;
+            case TaskStatusEnum.CANCELLED:
+                return status === TaskStatusEnum.ATTEMPT_CANCELING;
+            case TaskStatusEnum.FAILED:
+                return (status !== TaskStatusEnum.PENDING &&
+                    status !== TaskStatusEnum.SUSPENDED &&
                     (status & terminated) === 0);
-            case TaskStatus.FINISHED:
-                return (status !== TaskStatus.PENDING &&
-                    status !== TaskStatus.SUSPENDED &&
+            case TaskStatusEnum.FINISHED:
+                return (status !== TaskStatusEnum.PENDING &&
+                    status !== TaskStatusEnum.SUSPENDED &&
                     (status & terminated) === 0);
-            case TaskStatus.ATTEMPT_SUSPENDING:
-                return status === TaskStatus.RUNNING;
-            case TaskStatus.ATTEMPT_RESUMING:
-                return status === TaskStatus.SUSPENDED;
-            case TaskStatus.ATTEMPT_CANCELING:
+            case TaskStatusEnum.ATTEMPT_SUSPENDING:
+                return status === TaskStatusEnum.RUNNING;
+            case TaskStatusEnum.ATTEMPT_RESUMING:
+                return status === TaskStatusEnum.SUSPENDED;
+            case TaskStatusEnum.ATTEMPT_CANCELING:
                 return (status & alive) > 0;
-            case TaskStatus.ATTEMPT_FINISHING:
-                return status !== TaskStatus.PENDING && (status & alive) > 0;
+            case TaskStatusEnum.ATTEMPT_FINISHING:
+                return status !== TaskStatusEnum.PENDING && (status & alive) > 0;
             default:
                 return false;
         }
@@ -127,13 +107,13 @@ class TaskState {
     cleanup() {
         if (!this.terminated)
             throw new Error(`[cleanup] task(${this.name}) is not terminated`);
-        this._errorDetails.length = 0;
+        this._errorCollector.cleanup();
         this._monitors.onStatusChange.destroy();
         this._monitors.onAddError.destroy();
     }
-    _addError(type, error) {
-        this._errorDetails.push({ type, error });
-        this._monitors.onAddError.notify(type, error);
+    _addError(type, error, level = ErrorLevelEnum.ERROR) {
+        this._errorCollector.add(type, error, level);
+        this._monitors.onAddError.notify(type, error, level);
     }
 }
@@ -144,15 +124,15 @@ class AtomicTask extends TaskState {
         this._promise = undefined;
     }
     async start() {
-        if (this.status === TaskStatus.PENDING) {
-            this.status = TaskStatus.RUNNING;
+        if (this.status === TaskStatusEnum.PENDING) {
+            this.status = TaskStatusEnum.RUNNING;
             this._promise = this.run()
                 .then(() => {
-                this.status = TaskStatus.FINISHED;
+                this.status = TaskStatusEnum.FINISHED;
             })
                 .catch(error => {
-                this.status = TaskStatus.FAILED;
                 this._addError('AtomicTaskError', error);
+                this.status = TaskStatusEnum.FAILED;
             });
         }
         return this._promise;
@@ -164,20 +144,20 @@ class AtomicTask extends TaskState {
         await this._promise;
     }
     async cancel() {
-        if (this.status === TaskStatus.PENDING) {
-            this.status = TaskStatus.ATTEMPT_CANCELING;
-            this.status = TaskStatus.CANCELLED;
+        if (this.status === TaskStatusEnum.PENDING) {
+            this.status = TaskStatusEnum.ATTEMPT_CANCELING;
+            this.status = TaskStatusEnum.CANCELLED;
             return;
         }
         if (this.alive)
-            this.status = TaskStatus.ATTEMPT_CANCELING;
+            this.status = TaskStatusEnum.ATTEMPT_CANCELING;
         await this._promise;
     }
     async finish() {
-        if (this.status === TaskStatus.PENDING)
+        if (this.status === TaskStatusEnum.PENDING)
             await this.start();
         if (this.alive)
-            this.status = TaskStatus.ATTEMPT_FINISHING;
+            this.status = TaskStatusEnum.ATTEMPT_FINISHING;
         await this._promise;
     }
 }
@@ -195,63 +175,63 @@ class ResumableTask extends TaskState {
         this._step = undefined;
     }
     async start() {
-        if (this.status === TaskStatus.PENDING) {
-            this.status = TaskStatus.RUNNING;
+        if (this.status === TaskStatusEnum.PENDING) {
+            this.status = TaskStatusEnum.RUNNING;
             this._execution = this.run();
             this.launchStep();
             await this._step;
         }
     }
     async pause() {
-        if (this.status === TaskStatus.RUNNING) {
-            this.status = TaskStatus.ATTEMPT_SUSPENDING;
+        if (this.status === TaskStatusEnum.RUNNING) {
+            this.status = TaskStatusEnum.ATTEMPT_SUSPENDING;
             await this._step;
-            if (this.status === TaskStatus.ATTEMPT_SUSPENDING) {
-                this.status = TaskStatus.SUSPENDED;
+            if (this.status === TaskStatusEnum.ATTEMPT_SUSPENDING) {
+                this.status = TaskStatusEnum.SUSPENDED;
             }
         }
     }
     async resume() {
-        if (this.status === TaskStatus.SUSPENDED) {
-            this.status = TaskStatus.ATTEMPT_RESUMING;
+        if (this.status === TaskStatusEnum.SUSPENDED) {
+            this.status = TaskStatusEnum.ATTEMPT_RESUMING;
             await this._step;
-            if (this.status === TaskStatus.ATTEMPT_RESUMING) {
-                this.status = TaskStatus.RUNNING;
+            if (this.status === TaskStatusEnum.ATTEMPT_RESUMING) {
+                this.status = TaskStatusEnum.RUNNING;
                 this.queueStep();
             }
         }
     }
     async cancel() {
         if (this.alive) {
-            this.status = TaskStatus.ATTEMPT_CANCELING;
+            this.status = TaskStatusEnum.ATTEMPT_CANCELING;
             await this._step;
-            if (this.status === TaskStatus.ATTEMPT_CANCELING) {
-                this.status = TaskStatus.CANCELLED;
+            if (this.status === TaskStatusEnum.ATTEMPT_CANCELING) {
+                this.status = TaskStatusEnum.CANCELLED;
             }
         }
     }
     async finish() {
-        if (this.status === TaskStatus.PENDING)
+        if (this.status === TaskStatusEnum.PENDING)
             await this.start();
         if (this.alive) {
-            this.status = TaskStatus.ATTEMPT_FINISHING;
+            this.status = TaskStatusEnum.ATTEMPT_FINISHING;
             await this._step;
             const execution = this._execution;
             if (execution) {
-                while (this.status === TaskStatus.ATTEMPT_FINISHING) {
+                while (this.status === TaskStatusEnum.ATTEMPT_FINISHING) {
                     const step = execution.next();
                     if (step.done) {
-                        this.status = this.hasError ? TaskStatus.FAILED : TaskStatus.FINISHED;
+                        this.status = this.hasError ? TaskStatusEnum.FAILED : TaskStatusEnum.FINISHED;
                         break;
                     }
                     await step.value.catch(error => {
                         this._addError('ResumableTaskError', error);
                         switch (this.strategy) {
-                            case TaskStrategy.ABORT_ON_ERROR:
+                            case TaskStrategyEnum.ABORT_ON_ERROR:
                                 if (!this.terminated)
-                                    this.status = TaskStatus.FAILED;
+                                    this.status = TaskStatusEnum.FAILED;
                                 break;
-                            case TaskStrategy.CONTINUE_ON_ERROR:
+                            case TaskStrategyEnum.CONTINUE_ON_ERROR:
                                 break;
                         }
                     });
@@ -260,10 +240,10 @@ class ResumableTask extends TaskState {
         }
     }
     launchStep() {
-        if (this.status === TaskStatus.RUNNING && this._step === undefined && this._execution) {
+        if (this.status === TaskStatusEnum.RUNNING && this._step === undefined && this._execution) {
             const step = this._execution.next();
             if (step.done) {
-                this.status = this.hasError ? TaskStatus.FAILED : TaskStatus.FINISHED;
+                this.status = this.hasError ? TaskStatusEnum.FAILED : TaskStatusEnum.FINISHED;
                 return;
             }
             this._step = step.value
@@ -275,11 +255,11 @@ class ResumableTask extends TaskState {
                 this._step = undefined;
                 this._addError('ResumableTaskError', error);
                 switch (this.strategy) {
-                    case TaskStrategy.ABORT_ON_ERROR:
+                    case TaskStrategyEnum.ABORT_ON_ERROR:
                         if (!this.terminated)
-                            this.status = TaskStatus.FAILED;
+                            this.status = TaskStatusEnum.FAILED;
                         break;
-                    case TaskStrategy.CONTINUE_ON_ERROR:
+                    case TaskStrategyEnum.CONTINUE_ON_ERROR:
                         this.queueStep();
                         break;
                 }
@@ -291,4 +271,4 @@ class ResumableTask extends TaskState {
     }
 }
-export { AtomicTask, ResumableTask, TaskState, TaskStatus, TaskStrategy, active, alive, terminated };
+export { AtomicTask, ResumableTask, TaskState };

package/lib/types/index.d.ts CHANGED Viewed

@@ -1,104 +1,23 @@
-declare enum TaskStatus {
-    PENDING = 1,
-    RUNNING = 2,
-    SUSPENDED = 4,
-    CANCELLED = 8,
-    FAILED = 16,
-    FINISHED = 32,
-    ATTEMPT_SUSPENDING = 64,
-    ATTEMPT_RESUMING = 128,
-    ATTEMPT_CANCELING = 256,
-    ATTEMPT_FINISHING = 512
-}
-declare enum TaskStrategy {
-    ABORT_ON_ERROR = 1,
-    CONTINUE_ON_ERROR = 2
-}
-declare const active: number;
-declare const alive: number;
-declare const terminated: number;
-interface ITaskErrorDetail {
-    type: string;
-    error: unknown;
-}
-interface ITaskError {
-    from: string;
-    details: ITaskErrorDetail[];
-}
-interface ITaskMonitor {
-    onAddError(type: string, error: unknown): void;
-    onStatusChange(status: TaskStatus, prevStatus: TaskStatus): void;
-}
-type IUnMonitorTask = () => void;
-interface ITaskState {
-    readonly status: TaskStatus;
-    readonly active: boolean;
-    readonly alive: boolean;
-    readonly terminated: boolean;
-}
-interface ITask extends ITaskState {
-    /**
-     * Task name.
-     */
-    readonly name: string;
-    /**
-     * Task error.
-     */
-    readonly error: ITaskError | undefined;
-    /**
-     * Indicate if the task has error.
-     */
-    readonly hasError: boolean;
-    /**
-     * Start the task.
-     */
-    start(): Promise<void>;
-    /**
-     * Pause the task.
-     */
-    pause(): Promise<void>;
-    /**
-     * Resume the task.
-     */
-    resume(): Promise<void>;
-    /**
-     * Cancel the task.
-     */
-    cancel(): Promise<void>;
-    /**
-     * finish the task: run to completed no matter if the task started or not.
-     */
-    finish(): Promise<void>;
-    /**
-     * Perform a clean up.
-     * Will thrown an error if the task is not terminated.
-     */
-    cleanup(): void;
-    /**
-     * Register a monitor to subscribe the task changes.
-     * @param monitor
-     */
-    monitor(monitor: Partial<ITaskMonitor>): IUnMonitorTask;
-}
+import { ITaskState, ISoraErrorCollector, ITaskError, ITaskMonitor, IUnMonitorTask, ITask } from '@guanghechen/types';
+import { TaskStatusEnum, ErrorLevelEnum, TaskStrategyEnum } from '@guanghechen/constant';
 declare class TaskState implements ITaskState {
     readonly name: string;
+    protected readonly _errorCollector: ISoraErrorCollector;
     private readonly _monitors;
-    private readonly _errorDetails;
     private _status;
     constructor(name: string);
-    get status(): TaskStatus;
+    get status(): TaskStatusEnum;
     get active(): boolean;
     get alive(): boolean;
     get terminated(): boolean;
     get hasError(): boolean;
     get error(): ITaskError | undefined;
-    set status(status: TaskStatus);
+    set status(status: TaskStatusEnum);
     monitor(monitor: Partial<ITaskMonitor>): IUnMonitorTask;
-    check(nextStatus: TaskStatus): boolean;
+    check(nextStatus: TaskStatusEnum): boolean;
     cleanup(): void;
-    protected _addError(type: string, error: unknown): void;
+    protected _addError(type: string, error: unknown, level?: ErrorLevelEnum): void;
 }
 declare abstract class AtomicTask extends TaskState implements ITask {
@@ -114,11 +33,11 @@ declare abstract class AtomicTask extends TaskState implements ITask {
 interface IResumableTaskProps {
     name: string;
-    strategy: TaskStrategy;
+    strategy: TaskStrategyEnum;
     pollInterval: number;
 }
 declare abstract class ResumableTask extends TaskState implements ITask {
-    readonly strategy: TaskStrategy;
+    readonly strategy: TaskStrategyEnum;
     private readonly _pollInterval;
     private _execution;
     private _step;
@@ -133,4 +52,4 @@ declare abstract class ResumableTask extends TaskState implements ITask {
     private queueStep;
 }
-export { AtomicTask, type ITask, type ITaskError, type ITaskErrorDetail, type ITaskMonitor, type ITaskState, type IUnMonitorTask, ResumableTask, TaskState, TaskStatus, TaskStrategy, active, alive, terminated };
+export { AtomicTask, ResumableTask, TaskState };

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@guanghechen/task",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.3",
   "description": "Atomic and resumable tasks",
   "author": {
     "name": "guanghechen",
@@ -8,10 +8,10 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/guanghechen/sora/tree/@guanghechen/task@5.1.0",
+    "url": "https://github.com/guanghechen/sora/tree/@guanghechen/task@1.0.0-alpha.2",
     "directory": "packages/task"
   },
-  "homepage": "https://github.com/guanghechen/sora/tree/@guanghechen/task@5.1.0/packages/task#readme",
+  "homepage": "https://github.com/guanghechen/sora/tree/@guanghechen/task@1.0.0-alpha.2/packages/task#readme",
   "type": "module",
   "main": "./lib/cjs/index.cjs",
   "module": "./lib/esm/index.mjs",
@@ -39,13 +39,16 @@
     "test": "node --experimental-vm-modules ../../node_modules/.bin/jest --config ../../jest.config.mjs --rootDir ."
   },
   "dependencies": {
-    "@guanghechen/monitor": "^1.0.0-alpha.1"
+    "@guanghechen/constant": "^1.0.0-alpha.1",
+    "@guanghechen/error": "^1.0.0-alpha.3",
+    "@guanghechen/monitor": "^1.0.0-alpha.3"
   },
   "devDependencies": {
+    "@guanghechen/shared": "^1.0.0-alpha.3",
     "cross-env": "^7.0.3",
     "jest": "^29.6.4",
     "rimraf": "^5.0.1",
     "rollup": "^3.28.1"
   },
-  "gitHead": "39cf17711022736f580c1dff68a535cea6ffa3ef"
+  "gitHead": "6209b28c7340c77e5954b697dddfa2893d8f30df"
 }