@guanghechen/task 1.0.0-alpha.9 → 1.0.0-beta.1

package/lib/esm/index.mjs

@@ -1,138 +1,125 @@
-import { TaskStatusEnum, ErrorLevelEnum, TaskStrategyEnum } from '@guanghechen/constant';
-export { TaskStatusEnum, TaskStrategyEnum } from '@guanghechen/constant';
-import { SoraErrorCollector } from '@guanghechen/error';
-import { Monitor } from '@guanghechen/monitor';
+import { Observable } from '@guanghechen/observable';
+import { ErrorLevelEnum } from '@guanghechen/error.types';
 
-function noop(..._args) { }
+var TaskStrategyEnum;
+(function (TaskStrategyEnum) {
+    TaskStrategyEnum[TaskStrategyEnum["ABORT_ON_ERROR"] = 1] = "ABORT_ON_ERROR";
+    TaskStrategyEnum[TaskStrategyEnum["CONTINUE_ON_ERROR"] = 2] = "CONTINUE_ON_ERROR";
+})(TaskStrategyEnum || (TaskStrategyEnum = {}));
+var TaskStatusEnum;
+(function (TaskStatusEnum) {
+    TaskStatusEnum[TaskStatusEnum["PENDING"] = 1] = "PENDING";
+    TaskStatusEnum[TaskStatusEnum["RUNNING"] = 2] = "RUNNING";
+    TaskStatusEnum[TaskStatusEnum["SUSPENDED"] = 4] = "SUSPENDED";
+    TaskStatusEnum[TaskStatusEnum["CANCELLED"] = 8] = "CANCELLED";
+    TaskStatusEnum[TaskStatusEnum["FAILED"] = 16] = "FAILED";
+    TaskStatusEnum[TaskStatusEnum["COMPLETED"] = 32] = "COMPLETED";
+    TaskStatusEnum[TaskStatusEnum["ATTEMPT_SUSPENDING"] = 64] = "ATTEMPT_SUSPENDING";
+    TaskStatusEnum[TaskStatusEnum["ATTEMPT_RESUMING"] = 128] = "ATTEMPT_RESUMING";
+    TaskStatusEnum[TaskStatusEnum["ATTEMPT_CANCELING"] = 256] = "ATTEMPT_CANCELING";
+    TaskStatusEnum[TaskStatusEnum["ATTEMPT_COMPLETING"] = 512] = "ATTEMPT_COMPLETING";
+})(TaskStatusEnum || (TaskStatusEnum = {}));
 
-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;
-    _monitorAddError;
-    _monitorStatusChange;
-    _status;
-    constructor(name) {
-        this.name = name;
-        this._errorCollector = new SoraErrorCollector(name);
-        this._monitorAddError = new Monitor('onAddError');
-        this._monitorStatusChange = new Monitor('onStatusChange');
-        this._status = TaskStatusEnum.PENDING;
-    }
-    get status() {
-        return this._status;
-    }
-    get active() {
-        return (this._status & active) > 0;
+const _terminated = TaskStatusEnum.CANCELLED | TaskStatusEnum.FAILED | TaskStatusEnum.COMPLETED;
+const _transitionMap = {
+    [TaskStatusEnum.PENDING]: TaskStatusEnum.PENDING |
+        TaskStatusEnum.RUNNING |
+        TaskStatusEnum.CANCELLED |
+        TaskStatusEnum.ATTEMPT_CANCELING,
+    [TaskStatusEnum.RUNNING]: TaskStatusEnum.RUNNING |
+        TaskStatusEnum.SUSPENDED |
+        _terminated |
+        TaskStatusEnum.ATTEMPT_SUSPENDING |
+        TaskStatusEnum.ATTEMPT_CANCELING |
+        TaskStatusEnum.ATTEMPT_COMPLETING,
+    [TaskStatusEnum.SUSPENDED]: TaskStatusEnum.RUNNING |
+        TaskStatusEnum.SUSPENDED |
+        _terminated |
+        TaskStatusEnum.ATTEMPT_RESUMING |
+        TaskStatusEnum.ATTEMPT_CANCELING |
+        TaskStatusEnum.ATTEMPT_COMPLETING,
+    [TaskStatusEnum.CANCELLED]: TaskStatusEnum.CANCELLED,
+    [TaskStatusEnum.FAILED]: TaskStatusEnum.FAILED,
+    [TaskStatusEnum.COMPLETED]: TaskStatusEnum.COMPLETED,
+    [TaskStatusEnum.ATTEMPT_SUSPENDING]: TaskStatusEnum.SUSPENDED |
+        _terminated |
+        TaskStatusEnum.ATTEMPT_SUSPENDING |
+        TaskStatusEnum.ATTEMPT_CANCELING |
+        TaskStatusEnum.ATTEMPT_COMPLETING,
+    [TaskStatusEnum.ATTEMPT_RESUMING]: TaskStatusEnum.RUNNING |
+        _terminated |
+        TaskStatusEnum.ATTEMPT_RESUMING |
+        TaskStatusEnum.ATTEMPT_CANCELING |
+        TaskStatusEnum.ATTEMPT_COMPLETING,
+    [TaskStatusEnum.ATTEMPT_CANCELING]: _terminated | TaskStatusEnum.ATTEMPT_CANCELING,
+    [TaskStatusEnum.ATTEMPT_COMPLETING]: _terminated | TaskStatusEnum.ATTEMPT_COMPLETING,
+};
+class TaskStatus extends Observable {
+    constructor() {
+        super(TaskStatusEnum.PENDING);
     }
     get alive() {
-        return (this._status & alive) > 0;
+        const value = this.getSnapshot();
+        return (value & _terminated) === 0;
     }
     get terminated() {
-        return (this._status & terminated) > 0;
+        const value = this.getSnapshot();
+        return (value & _terminated) > 0;
     }
-    get hasError() {
-        return this._errorCollector.size > 0;
-    }
-    get error() {
-        if (this._errorCollector.size === 0)
-            return undefined;
-        return { from: this.name, details: this._errorCollector.errors };
-    }
-    set status(status) {
-        const curStatus = this._status;
-        if (status !== curStatus) {
-            const accepted = this.check(status);
-            if (accepted) {
-                this._status = status;
-                this._monitorStatusChange.notify(status, curStatus);
-            }
-            else {
-                throw new TypeError(`[transit] unexpected status: task(${this.name}) cur(${curStatus}) next(${status})`);
-            }
+    next(nextStatus, options) {
+        const curStatus = this.getSnapshot();
+        if (this._verifyTransition(curStatus, nextStatus)) {
+            super.next(nextStatus, options);
+            if ((nextStatus & _terminated) > 0)
+                this.dispose();
+            return;
         }
-    }
-    monitor(monitor) {
-        if (this.terminated)
-            return noop;
-        const { onAddError, onStatusChange } = monitor;
-        const unsubscribeOnAddError = this._monitorAddError.subscribe(onAddError);
-        const unsubscribeOnStatusChange = this._monitorStatusChange.subscribe(onStatusChange);
-        return () => {
-            unsubscribeOnAddError();
-            unsubscribeOnStatusChange();
-        };
-    }
-    check(nextStatus) {
-        const status = this._status;
-        switch (nextStatus) {
-            case TaskStatusEnum.PENDING:
-                return false;
-            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 TaskStatusEnum.FINISHED:
-                return (status !== TaskStatusEnum.PENDING &&
-                    status !== TaskStatusEnum.SUSPENDED &&
-                    (status & terminated) === 0);
-            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 TaskStatusEnum.ATTEMPT_FINISHING:
-                return status !== TaskStatusEnum.PENDING && (status & alive) > 0;
-            default:
-                return false;
+        const strict = options?.strict ?? true;
+        if (strict) {
+            const curStatusName = TaskStatusEnum[curStatus];
+            const nextStatusName = TaskStatusEnum[nextStatus];
+            throw new RangeError(`Invalid status transition: ${curStatusName} -> ${nextStatusName}.`);
         }
     }
-    cleanup() {
-        if (!this.terminated)
-            throw new Error(`[cleanup] task(${this.name}) is not terminated`);
-        this._errorCollector.cleanup();
-        this._monitorStatusChange.destroy();
-        this._monitorAddError.destroy();
-    }
-    _addError(type, error, level = ErrorLevelEnum.ERROR) {
-        this._errorCollector.add(type, error, level);
-        this._monitorAddError.notify(type, error, level);
+    _verifyTransition(curStatus, nextStatus) {
+        const validTransitions = _transitionMap[curStatus];
+        if (validTransitions === undefined)
+            return false;
+        return (nextStatus & validTransitions) > 0;
     }
 }
 
-class AtomicTask extends TaskState {
+class AtomicTask {
+    name;
+    status;
+    strategy;
+    _errors;
     _promise;
-    constructor(name) {
-        super(name);
+    constructor(name, strategy) {
+        this.name = name;
+        this.strategy = strategy;
+        this.status = new TaskStatus();
+        this._errors = [];
         this._promise = undefined;
     }
+    get errors() {
+        return this._errors;
+    }
     async start() {
-        if (this.status === TaskStatusEnum.PENDING) {
-            this.status = TaskStatusEnum.RUNNING;
+        if (this.status.getSnapshot() === TaskStatusEnum.PENDING) {
+            this.status.next(TaskStatusEnum.RUNNING);
             this._promise = this.run()
                 .then(() => {
-                this.status = TaskStatusEnum.FINISHED;
+                this.status.next(TaskStatusEnum.COMPLETED);
             })
                 .catch(error => {
-                this._addError('AtomicTaskError', error);
-                this.status = TaskStatusEnum.FAILED;
+                const soraError = {
+                    from: this.name,
+                    level: ErrorLevelEnum.ERROR,
+                    details: error,
+                };
+                this._errors.push(soraError);
+                this.status.next(TaskStatusEnum.FAILED);
             });
         }
         return this._promise;
@@ -144,131 +131,164 @@ class AtomicTask extends TaskState {
         await this._promise;
     }
     async cancel() {
-        if (this.status === TaskStatusEnum.PENDING) {
-            this.status = TaskStatusEnum.ATTEMPT_CANCELING;
-            this.status = TaskStatusEnum.CANCELLED;
+        if (this.status.terminated)
             return;
-        }
-        if (this.alive)
-            this.status = TaskStatusEnum.ATTEMPT_CANCELING;
+        this.status.next(TaskStatusEnum.ATTEMPT_CANCELING);
         await this._promise;
+        this.status.next(TaskStatusEnum.CANCELLED, { strict: false });
     }
-    async finish() {
-        if (this.status === TaskStatusEnum.PENDING)
+    async complete() {
+        const status = this.status;
+        if (status.getSnapshot() === TaskStatusEnum.PENDING)
             await this.start();
-        if (this.alive)
-            this.status = TaskStatusEnum.ATTEMPT_FINISHING;
+        if (status.terminated)
+            return;
+        status.next(TaskStatusEnum.ATTEMPT_COMPLETING);
         await this._promise;
+        status.next(TaskStatusEnum.COMPLETED, { strict: false });
     }
 }
 
-class ResumableTask extends TaskState {
+class ResumableTask {
+    name;
+    status;
     strategy;
+    _errors;
     _pollInterval;
     _execution;
     _step;
-    constructor(props) {
-        super(props.name);
-        this.strategy = props.strategy;
-        this._pollInterval = Math.max(0, props.pollInterval);
+    constructor(name, strategy, pollInterval) {
+        this.name = name;
+        this.strategy = strategy;
+        this.status = new TaskStatus();
+        this._errors = [];
+        this._pollInterval = Math.max(0, pollInterval);
         this._execution = undefined;
         this._step = undefined;
     }
+    get errors() {
+        return this._errors;
+    }
     async start() {
-        if (this.status === TaskStatusEnum.PENDING) {
-            this.status = TaskStatusEnum.RUNNING;
+        if (this.status.getSnapshot() === TaskStatusEnum.PENDING) {
+            this.status.next(TaskStatusEnum.RUNNING);
             this._execution = this.run();
-            this.launchStep();
-            await this._step;
+            void this._launchStep();
         }
     }
     async pause() {
-        if (this.status === TaskStatusEnum.RUNNING) {
-            this.status = TaskStatusEnum.ATTEMPT_SUSPENDING;
+        if (this.status.getSnapshot() === TaskStatusEnum.RUNNING) {
+            this.status.next(TaskStatusEnum.ATTEMPT_SUSPENDING);
             await this._step;
-            if (this.status === TaskStatusEnum.ATTEMPT_SUSPENDING) {
-                this.status = TaskStatusEnum.SUSPENDED;
-            }
+            this.status.next(TaskStatusEnum.SUSPENDED, { strict: false });
         }
     }
     async resume() {
-        if (this.status === TaskStatusEnum.SUSPENDED) {
-            this.status = TaskStatusEnum.ATTEMPT_RESUMING;
+        if (this.status.getSnapshot() === TaskStatusEnum.SUSPENDED) {
+            this.status.next(TaskStatusEnum.ATTEMPT_RESUMING);
             await this._step;
-            if (this.status === TaskStatusEnum.ATTEMPT_RESUMING) {
-                this.status = TaskStatusEnum.RUNNING;
-                this.queueStep();
+            if (this.status.getSnapshot() === TaskStatusEnum.ATTEMPT_RESUMING) {
+                this.status.next(TaskStatusEnum.RUNNING);
+                void this._queueStep();
             }
         }
     }
     async cancel() {
-        if (this.alive) {
-            this.status = TaskStatusEnum.ATTEMPT_CANCELING;
-            await this._step;
-            if (this.status === TaskStatusEnum.ATTEMPT_CANCELING) {
-                this.status = TaskStatusEnum.CANCELLED;
-            }
-        }
+        if (this.status.terminated)
+            return;
+        this.status.next(TaskStatusEnum.ATTEMPT_CANCELING);
+        await this._step;
+        this.status.next(TaskStatusEnum.CANCELLED, { strict: false });
     }
-    async finish() {
-        if (this.status === TaskStatusEnum.PENDING)
+    async complete() {
+        const status = this.status;
+        if (status.getSnapshot() === TaskStatusEnum.PENDING)
             await this.start();
-        if (this.alive) {
-            this.status = TaskStatusEnum.ATTEMPT_FINISHING;
-            await this._step;
-            const execution = this._execution;
-            if (execution) {
-                while (this.status === TaskStatusEnum.ATTEMPT_FINISHING) {
-                    const step = execution.next();
-                    if (step.done) {
-                        this.status = this.hasError ? TaskStatusEnum.FAILED : TaskStatusEnum.FINISHED;
-                        break;
-                    }
-                    await step.value.catch(error => {
-                        this._addError('ResumableTaskError', error);
-                        switch (this.strategy) {
-                            case TaskStrategyEnum.ABORT_ON_ERROR:
-                                if (!this.terminated)
-                                    this.status = TaskStatusEnum.FAILED;
-                                break;
-                            case TaskStrategyEnum.CONTINUE_ON_ERROR:
-                                break;
-                        }
-                    });
-                }
-            }
-        }
-    }
-    launchStep() {
-        if (this.status === TaskStatusEnum.RUNNING && this._step === undefined && this._execution) {
-            const step = this._execution.next();
+        if (status.terminated)
+            return;
+        status.next(TaskStatusEnum.ATTEMPT_COMPLETING);
+        await this._step;
+        const execution = this._execution;
+        for (let alive = true; alive;) {
+            const step = execution.next();
             if (step.done) {
-                this.status = this.hasError ? TaskStatusEnum.FAILED : TaskStatusEnum.FINISHED;
-                return;
+                const nextStatus = this._errors.length > 0 ? TaskStatusEnum.FAILED : TaskStatusEnum.COMPLETED;
+                status.next(nextStatus, { strict: false });
+                break;
             }
-            this._step = step.value
-                .then(() => {
-                this._step = undefined;
-                this.queueStep();
-            })
-                .catch(error => {
-                this._step = undefined;
-                this._addError('ResumableTaskError', error);
+            try {
+                await step.value;
+            }
+            catch (error) {
+                const soraError = {
+                    from: this.name,
+                    level: ErrorLevelEnum.ERROR,
+                    details: error,
+                };
+                this._errors.push(soraError);
                 switch (this.strategy) {
                     case TaskStrategyEnum.ABORT_ON_ERROR:
-                        if (!this.terminated)
-                            this.status = TaskStatusEnum.FAILED;
+                        status.next(TaskStatusEnum.FAILED, { strict: false });
+                        alive = false;
                         break;
                     case TaskStrategyEnum.CONTINUE_ON_ERROR:
-                        this.queueStep();
+                        await this._queueStep();
                         break;
                 }
+            }
+        }
+        if (status.alive) {
+            const soraError = {
+                from: this.name,
+                level: ErrorLevelEnum.ERROR,
+                details: new RangeError('The task is not terminated.'),
+            };
+            this._errors.push(soraError);
+        }
+    }
+    async _launchStep() {
+        if (this._execution === undefined)
+            return;
+        if (this._step !== undefined)
+            return;
+        if (this.status.getSnapshot() !== TaskStatusEnum.RUNNING)
+            return;
+        const execution = this._execution;
+        const step = execution.next();
+        if (step.done) {
+            this.status.next(this._errors.length > 0 ? TaskStatusEnum.FAILED : TaskStatusEnum.COMPLETED, {
+                strict: false,
             });
+            return;
+        }
+        this._step = step.value;
+        try {
+            await step.value;
+            this._step = undefined;
+            void this._queueStep();
+        }
+        catch (error) {
+            this._step = undefined;
+            const soraError = {
+                from: this.name,
+                level: ErrorLevelEnum.ERROR,
+                details: error,
+            };
+            this._errors.push(soraError);
+            switch (this.strategy) {
+                case TaskStrategyEnum.ABORT_ON_ERROR:
+                    this.status.next(TaskStatusEnum.FAILED, { strict: false });
+                    break;
+                case TaskStrategyEnum.CONTINUE_ON_ERROR:
+                    void this._queueStep();
+                    break;
+            }
         }
     }
-    queueStep() {
-        setTimeout(() => this.launchStep(), this._pollInterval);
+    async _queueStep() {
+        await new Promise(resolve => setTimeout(resolve, this._pollInterval));
+        await this._launchStep();
     }
 }
 
-export { AtomicTask, ResumableTask, TaskState };
+export { AtomicTask, ResumableTask, TaskStatus, TaskStatusEnum, TaskStrategyEnum };

package/lib/types/index.d.ts

@@ -1,58 +1,119 @@
-import { TaskStatusEnum, ErrorLevelEnum, TaskStrategyEnum } from '@guanghechen/constant';
-export { TaskStatusEnum, TaskStrategyEnum } from '@guanghechen/constant';
-import { ITaskState, ISoraErrorCollector, ITaskError, ITaskMonitor, IUnMonitorTask, ITask } from '@guanghechen/types';
-export { ITask, ITaskError, ITaskMonitor, ITaskState } from '@guanghechen/types';
+import { IObservable, IObservableNextOptions, Observable } from '@guanghechen/observable';
 
-declare class TaskState implements ITaskState {
+declare enum TaskStrategyEnum {
+    ABORT_ON_ERROR = 1,// Abort the task if any error occurred.
+    CONTINUE_ON_ERROR = 2
+}
+declare enum TaskStatusEnum {
+    PENDING = 1,// Task not start.
+    RUNNING = 2,// Task is running.
+    SUSPENDED = 4,// Task is paused.
+    CANCELLED = 8,// Task is cancelled.
+    FAILED = 16,// Task is failed.
+    COMPLETED = 32,// Task is completed.
+    ATTEMPT_SUSPENDING = 64,// Attempting to suspend the task.
+    ATTEMPT_RESUMING = 128,// Attempting to resume the task.
+    ATTEMPT_CANCELING = 256,// Attempting to cancel the task.
+    ATTEMPT_COMPLETING = 512
+}
+
+interface ITaskStatus extends IObservable<TaskStatusEnum> {
+    /**
+     * Whether the task was alive.
+     */
+    readonly alive: boolean;
+    /**
+     * Whether the task was terminated.
+     */
+    readonly terminated: boolean;
+    /**
+     *
+     * @param nextStatus
+     * @param options
+     */
+    next(nextStatus: TaskStatusEnum, options?: IObservableNextOptions): void;
+}
+interface ITask {
+    /**
+     * Task name.
+     */
     readonly name: string;
-    protected readonly _errorCollector: ISoraErrorCollector;
-    private readonly _monitorAddError;
-    private readonly _monitorStatusChange;
-    private _status;
-    constructor(name: string);
-    get status(): TaskStatusEnum;
-    get active(): boolean;
+    /**
+     * Task status.
+     */
+    readonly status: ITaskStatus;
+    /**
+     * Task strategy.
+     */
+    readonly strategy: TaskStrategyEnum;
+    /**
+     * Errors while run the task.
+     */
+    readonly errors: ReadonlyArray<unknown>;
+    /**
+     * 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.
+     */
+    complete(): Promise<void>;
+}
+
+declare class TaskStatus extends Observable<TaskStatusEnum> implements ITaskStatus {
+    constructor();
     get alive(): boolean;
     get terminated(): boolean;
-    get hasError(): boolean;
-    get error(): ITaskError | undefined;
-    set status(status: TaskStatusEnum);
-    monitor(monitor: Partial<ITaskMonitor>): IUnMonitorTask;
-    check(nextStatus: TaskStatusEnum): boolean;
-    cleanup(): void;
-    protected _addError(type: string, error: unknown, level?: ErrorLevelEnum): void;
+    next(nextStatus: TaskStatusEnum, options?: IObservableNextOptions): void;
+    protected _verifyTransition(curStatus: TaskStatusEnum, nextStatus: TaskStatusEnum): boolean;
 }
 
-declare abstract class AtomicTask extends TaskState implements ITask {
+declare abstract class AtomicTask implements ITask {
+    readonly name: string;
+    readonly status: ITaskStatus;
+    readonly strategy: TaskStrategyEnum;
+    protected readonly _errors: unknown[];
     private _promise;
-    constructor(name: string);
+    constructor(name: string, strategy: TaskStrategyEnum);
+    get errors(): ReadonlyArray<unknown>;
     start(): Promise<void>;
     pause(): Promise<void>;
     resume(): Promise<void>;
     cancel(): Promise<void>;
-    finish(): Promise<void>;
+    complete(): Promise<void>;
     protected abstract run(): Promise<void>;
 }
 
-interface IResumableTaskProps {
-    name: string;
-    strategy: TaskStrategyEnum;
-    pollInterval: number;
-}
-declare abstract class ResumableTask extends TaskState implements ITask {
+declare abstract class ResumableTask implements ITask {
+    readonly name: string;
+    readonly status: ITaskStatus;
     readonly strategy: TaskStrategyEnum;
+    protected readonly _errors: unknown[];
     private readonly _pollInterval;
     private _execution;
     private _step;
-    constructor(props: IResumableTaskProps);
+    constructor(name: string, strategy: TaskStrategyEnum, pollInterval: number);
+    get errors(): ReadonlyArray<unknown>;
     start(): Promise<void>;
     pause(): Promise<void>;
     resume(): Promise<void>;
     cancel(): Promise<void>;
-    finish(): Promise<void>;
+    complete(): Promise<void>;
     protected abstract run(): IterableIterator<Promise<void>>;
-    private launchStep;
-    private queueStep;
+    private _launchStep;
+    private _queueStep;
 }
 
-export { AtomicTask, ResumableTask, TaskState };
+export { AtomicTask, type ITask, type ITaskStatus, ResumableTask, TaskStatus, TaskStatusEnum, TaskStrategyEnum };