@guanghechen/task 1.0.0-alpha.1

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Change Log
+
+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.1 (2023-08-27)
+
+
+### Features
+
+* ✨ add @guanghechen/task ([83b66a5](https://github.com/guanghechen/sora/commit/83b66a52d84dd43e4125ca40bc297a511f5712f1))
+
+
+### Performance Improvements
+
+* 🔧 update path alias ([c396ec3](https://github.com/guanghechen/sora/commit/c396ec3316b2b19a69ba0234cc7a9d86edd9fac2))
+* ⬆️ upgrade devDependencies ([2b70a3f](https://github.com/guanghechen/sora/commit/2b70a3f5b895ed51de035b962d843661475663d6))

package/lib/cjs/index.cjs

@@ -0,0 +1,301 @@
+'use strict';
+
+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;
+
+const noop = () => { };
+class TaskState {
+    name;
+    _monitors;
+    _errorDetails;
+    _status;
+    constructor(name) {
+        this.name = name;
+        this._monitors = {
+            onAddError: new monitor.Monitor('onAddError'),
+            onStatusChange: new monitor.Monitor('onStatusChange'),
+        };
+        this._errorDetails = [];
+        this._status = exports.TaskStatus.PENDING;
+    }
+    get status() {
+        return this._status;
+    }
+    get active() {
+        return (this._status & active) > 0;
+    }
+    get alive() {
+        return (this._status & alive) > 0;
+    }
+    get terminated() {
+        return (this._status & terminated) > 0;
+    }
+    get hasError() {
+        return this._errorDetails.length > 0;
+    }
+    get error() {
+        if (this._errorDetails.length === 0)
+            return undefined;
+        return { from: this.name, details: this._errorDetails.slice() };
+    }
+    set status(status) {
+        const curStatus = this._status;
+        if (status !== curStatus) {
+            const accepted = this.check(status);
+            if (accepted) {
+                this._status = status;
+                this._monitors.onStatusChange.notify(status, curStatus);
+            }
+            else {
+                throw new TypeError(`[transit] unexpected status: task(${this.name}) cur(${curStatus}) next(${status})`);
+            }
+        }
+    }
+    monitor(monitor) {
+        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;
+        return () => {
+            unsubscribeOnAddError();
+            unsubscribeOnStatusChange();
+        };
+    }
+    check(nextStatus) {
+        const status = this._status;
+        switch (nextStatus) {
+            case exports.TaskStatus.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 &&
+                    (status & terminated) === 0);
+            case exports.TaskStatus.FINISHED:
+                return (status !== exports.TaskStatus.PENDING &&
+                    status !== exports.TaskStatus.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:
+                return (status & alive) > 0;
+            case exports.TaskStatus.ATTEMPT_FINISHING:
+                return status !== exports.TaskStatus.PENDING && (status & alive) > 0;
+            default:
+                return false;
+        }
+    }
+    cleanup() {
+        if (!this.terminated)
+            throw new Error(`[cleanup] task(${this.name}) is not terminated`);
+        this._errorDetails.length = 0;
+        this._monitors.onStatusChange.destroy();
+        this._monitors.onAddError.destroy();
+    }
+    _addError(type, error) {
+        this._errorDetails.push({ type, error });
+        this._monitors.onAddError.notify(type, error);
+    }
+}
+
+class AtomicTask extends TaskState {
+    _promise;
+    constructor(name) {
+        super(name);
+        this._promise = undefined;
+    }
+    async start() {
+        if (this.status === exports.TaskStatus.PENDING) {
+            this.status = exports.TaskStatus.RUNNING;
+            this._promise = this.run()
+                .then(() => {
+                this.status = exports.TaskStatus.FINISHED;
+            })
+                .catch(error => {
+                this.status = exports.TaskStatus.FAILED;
+                this._addError('AtomicTaskError', error);
+            });
+        }
+        return this._promise;
+    }
+    async pause() {
+        await this._promise;
+    }
+    async resume() {
+        await this._promise;
+    }
+    async cancel() {
+        if (this.status === exports.TaskStatus.PENDING) {
+            this.status = exports.TaskStatus.ATTEMPT_CANCELING;
+            this.status = exports.TaskStatus.CANCELLED;
+            return;
+        }
+        if (this.alive)
+            this.status = exports.TaskStatus.ATTEMPT_CANCELING;
+        await this._promise;
+    }
+    async finish() {
+        if (this.status === exports.TaskStatus.PENDING)
+            await this.start();
+        if (this.alive)
+            this.status = exports.TaskStatus.ATTEMPT_FINISHING;
+        await this._promise;
+    }
+}
+
+class ResumableTask extends TaskState {
+    strategy;
+    _pollInterval;
+    _execution;
+    _step;
+    constructor(props) {
+        super(props.name);
+        this.strategy = props.strategy;
+        this._pollInterval = Math.max(0, props.pollInterval);
+        this._execution = undefined;
+        this._step = undefined;
+    }
+    async start() {
+        if (this.status === exports.TaskStatus.PENDING) {
+            this.status = exports.TaskStatus.RUNNING;
+            this._execution = this.run();
+            this.launchStep();
+            await this._step;
+        }
+    }
+    async pause() {
+        if (this.status === exports.TaskStatus.RUNNING) {
+            this.status = exports.TaskStatus.ATTEMPT_SUSPENDING;
+            await this._step;
+            if (this.status === exports.TaskStatus.ATTEMPT_SUSPENDING) {
+                this.status = exports.TaskStatus.SUSPENDED;
+            }
+        }
+    }
+    async resume() {
+        if (this.status === exports.TaskStatus.SUSPENDED) {
+            this.status = exports.TaskStatus.ATTEMPT_RESUMING;
+            await this._step;
+            if (this.status === exports.TaskStatus.ATTEMPT_RESUMING) {
+                this.status = exports.TaskStatus.RUNNING;
+                this.queueStep();
+            }
+        }
+    }
+    async cancel() {
+        if (this.alive) {
+            this.status = exports.TaskStatus.ATTEMPT_CANCELING;
+            await this._step;
+            if (this.status === exports.TaskStatus.ATTEMPT_CANCELING) {
+                this.status = exports.TaskStatus.CANCELLED;
+            }
+        }
+    }
+    async finish() {
+        if (this.status === exports.TaskStatus.PENDING)
+            await this.start();
+        if (this.alive) {
+            this.status = exports.TaskStatus.ATTEMPT_FINISHING;
+            await this._step;
+            const execution = this._execution;
+            if (execution) {
+                while (this.status === exports.TaskStatus.ATTEMPT_FINISHING) {
+                    const step = execution.next();
+                    if (step.done) {
+                        this.status = this.hasError ? exports.TaskStatus.FAILED : exports.TaskStatus.FINISHED;
+                        break;
+                    }
+                    await step.value.catch(error => {
+                        this._addError('ResumableTaskError', error);
+                        switch (this.strategy) {
+                            case exports.TaskStrategy.ABORT_ON_ERROR:
+                                if (!this.terminated)
+                                    this.status = exports.TaskStatus.FAILED;
+                                break;
+                            case exports.TaskStrategy.CONTINUE_ON_ERROR:
+                                break;
+                        }
+                    });
+                }
+            }
+        }
+    }
+    launchStep() {
+        if (this.status === exports.TaskStatus.RUNNING && this._step === undefined && this._execution) {
+            const step = this._execution.next();
+            if (step.done) {
+                this.status = this.hasError ? exports.TaskStatus.FAILED : exports.TaskStatus.FINISHED;
+                return;
+            }
+            this._step = step.value
+                .then(() => {
+                this._step = undefined;
+                this.queueStep();
+            })
+                .catch(error => {
+                this._step = undefined;
+                this._addError('ResumableTaskError', error);
+                switch (this.strategy) {
+                    case exports.TaskStrategy.ABORT_ON_ERROR:
+                        if (!this.terminated)
+                            this.status = exports.TaskStatus.FAILED;
+                        break;
+                    case exports.TaskStrategy.CONTINUE_ON_ERROR:
+                        this.queueStep();
+                        break;
+                }
+            });
+        }
+    }
+    queueStep() {
+        setTimeout(() => this.launchStep(), this._pollInterval);
+    }
+}
+
+exports.AtomicTask = AtomicTask;
+exports.ResumableTask = ResumableTask;
+exports.TaskState = TaskState;
+exports.active = active;
+exports.alive = alive;
+exports.terminated = terminated;

package/lib/esm/index.mjs

@@ -0,0 +1,294 @@
+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;
+
+const noop = () => { };
+class TaskState {
+    name;
+    _monitors;
+    _errorDetails;
+    _status;
+    constructor(name) {
+        this.name = name;
+        this._monitors = {
+            onAddError: new Monitor('onAddError'),
+            onStatusChange: new Monitor('onStatusChange'),
+        };
+        this._errorDetails = [];
+        this._status = TaskStatus.PENDING;
+    }
+    get status() {
+        return this._status;
+    }
+    get active() {
+        return (this._status & active) > 0;
+    }
+    get alive() {
+        return (this._status & alive) > 0;
+    }
+    get terminated() {
+        return (this._status & terminated) > 0;
+    }
+    get hasError() {
+        return this._errorDetails.length > 0;
+    }
+    get error() {
+        if (this._errorDetails.length === 0)
+            return undefined;
+        return { from: this.name, details: this._errorDetails.slice() };
+    }
+    set status(status) {
+        const curStatus = this._status;
+        if (status !== curStatus) {
+            const accepted = this.check(status);
+            if (accepted) {
+                this._status = status;
+                this._monitors.onStatusChange.notify(status, curStatus);
+            }
+            else {
+                throw new TypeError(`[transit] unexpected status: task(${this.name}) cur(${curStatus}) next(${status})`);
+            }
+        }
+    }
+    monitor(monitor) {
+        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;
+        return () => {
+            unsubscribeOnAddError();
+            unsubscribeOnStatusChange();
+        };
+    }
+    check(nextStatus) {
+        const status = this._status;
+        switch (nextStatus) {
+            case TaskStatus.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 &&
+                    (status & terminated) === 0);
+            case TaskStatus.FINISHED:
+                return (status !== TaskStatus.PENDING &&
+                    status !== TaskStatus.SUSPENDED &&
+                    (status & terminated) === 0);
+            case TaskStatus.ATTEMPT_SUSPENDING:
+                return status === TaskStatus.RUNNING;
+            case TaskStatus.ATTEMPT_RESUMING:
+                return status === TaskStatus.SUSPENDED;
+            case TaskStatus.ATTEMPT_CANCELING:
+                return (status & alive) > 0;
+            case TaskStatus.ATTEMPT_FINISHING:
+                return status !== TaskStatus.PENDING && (status & alive) > 0;
+            default:
+                return false;
+        }
+    }
+    cleanup() {
+        if (!this.terminated)
+            throw new Error(`[cleanup] task(${this.name}) is not terminated`);
+        this._errorDetails.length = 0;
+        this._monitors.onStatusChange.destroy();
+        this._monitors.onAddError.destroy();
+    }
+    _addError(type, error) {
+        this._errorDetails.push({ type, error });
+        this._monitors.onAddError.notify(type, error);
+    }
+}
+
+class AtomicTask extends TaskState {
+    _promise;
+    constructor(name) {
+        super(name);
+        this._promise = undefined;
+    }
+    async start() {
+        if (this.status === TaskStatus.PENDING) {
+            this.status = TaskStatus.RUNNING;
+            this._promise = this.run()
+                .then(() => {
+                this.status = TaskStatus.FINISHED;
+            })
+                .catch(error => {
+                this.status = TaskStatus.FAILED;
+                this._addError('AtomicTaskError', error);
+            });
+        }
+        return this._promise;
+    }
+    async pause() {
+        await this._promise;
+    }
+    async resume() {
+        await this._promise;
+    }
+    async cancel() {
+        if (this.status === TaskStatus.PENDING) {
+            this.status = TaskStatus.ATTEMPT_CANCELING;
+            this.status = TaskStatus.CANCELLED;
+            return;
+        }
+        if (this.alive)
+            this.status = TaskStatus.ATTEMPT_CANCELING;
+        await this._promise;
+    }
+    async finish() {
+        if (this.status === TaskStatus.PENDING)
+            await this.start();
+        if (this.alive)
+            this.status = TaskStatus.ATTEMPT_FINISHING;
+        await this._promise;
+    }
+}
+
+class ResumableTask extends TaskState {
+    strategy;
+    _pollInterval;
+    _execution;
+    _step;
+    constructor(props) {
+        super(props.name);
+        this.strategy = props.strategy;
+        this._pollInterval = Math.max(0, props.pollInterval);
+        this._execution = undefined;
+        this._step = undefined;
+    }
+    async start() {
+        if (this.status === TaskStatus.PENDING) {
+            this.status = TaskStatus.RUNNING;
+            this._execution = this.run();
+            this.launchStep();
+            await this._step;
+        }
+    }
+    async pause() {
+        if (this.status === TaskStatus.RUNNING) {
+            this.status = TaskStatus.ATTEMPT_SUSPENDING;
+            await this._step;
+            if (this.status === TaskStatus.ATTEMPT_SUSPENDING) {
+                this.status = TaskStatus.SUSPENDED;
+            }
+        }
+    }
+    async resume() {
+        if (this.status === TaskStatus.SUSPENDED) {
+            this.status = TaskStatus.ATTEMPT_RESUMING;
+            await this._step;
+            if (this.status === TaskStatus.ATTEMPT_RESUMING) {
+                this.status = TaskStatus.RUNNING;
+                this.queueStep();
+            }
+        }
+    }
+    async cancel() {
+        if (this.alive) {
+            this.status = TaskStatus.ATTEMPT_CANCELING;
+            await this._step;
+            if (this.status === TaskStatus.ATTEMPT_CANCELING) {
+                this.status = TaskStatus.CANCELLED;
+            }
+        }
+    }
+    async finish() {
+        if (this.status === TaskStatus.PENDING)
+            await this.start();
+        if (this.alive) {
+            this.status = TaskStatus.ATTEMPT_FINISHING;
+            await this._step;
+            const execution = this._execution;
+            if (execution) {
+                while (this.status === TaskStatus.ATTEMPT_FINISHING) {
+                    const step = execution.next();
+                    if (step.done) {
+                        this.status = this.hasError ? TaskStatus.FAILED : TaskStatus.FINISHED;
+                        break;
+                    }
+                    await step.value.catch(error => {
+                        this._addError('ResumableTaskError', error);
+                        switch (this.strategy) {
+                            case TaskStrategy.ABORT_ON_ERROR:
+                                if (!this.terminated)
+                                    this.status = TaskStatus.FAILED;
+                                break;
+                            case TaskStrategy.CONTINUE_ON_ERROR:
+                                break;
+                        }
+                    });
+                }
+            }
+        }
+    }
+    launchStep() {
+        if (this.status === TaskStatus.RUNNING && this._step === undefined && this._execution) {
+            const step = this._execution.next();
+            if (step.done) {
+                this.status = this.hasError ? TaskStatus.FAILED : TaskStatus.FINISHED;
+                return;
+            }
+            this._step = step.value
+                .then(() => {
+                this._step = undefined;
+                this.queueStep();
+            })
+                .catch(error => {
+                this._step = undefined;
+                this._addError('ResumableTaskError', error);
+                switch (this.strategy) {
+                    case TaskStrategy.ABORT_ON_ERROR:
+                        if (!this.terminated)
+                            this.status = TaskStatus.FAILED;
+                        break;
+                    case TaskStrategy.CONTINUE_ON_ERROR:
+                        this.queueStep();
+                        break;
+                }
+            });
+        }
+    }
+    queueStep() {
+        setTimeout(() => this.launchStep(), this._pollInterval);
+    }
+}
+
+export { AtomicTask, ResumableTask, TaskState, TaskStatus, TaskStrategy, active, alive, terminated };

package/lib/types/index.d.ts

@@ -0,0 +1,136 @@
+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;
+}
+
+declare class TaskState implements ITaskState {
+    readonly name: string;
+    private readonly _monitors;
+    private readonly _errorDetails;
+    private _status;
+    constructor(name: string);
+    get status(): TaskStatus;
+    get active(): boolean;
+    get alive(): boolean;
+    get terminated(): boolean;
+    get hasError(): boolean;
+    get error(): ITaskError | undefined;
+    set status(status: TaskStatus);
+    monitor(monitor: Partial<ITaskMonitor>): IUnMonitorTask;
+    check(nextStatus: TaskStatus): boolean;
+    cleanup(): void;
+    protected _addError(type: string, error: unknown): void;
+}
+
+declare abstract class AtomicTask extends TaskState implements ITask {
+    private _promise;
+    constructor(name: string);
+    start(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    cancel(): Promise<void>;
+    finish(): Promise<void>;
+    protected abstract run(): Promise<void>;
+}
+
+interface IResumableTaskProps {
+    name: string;
+    strategy: TaskStrategy;
+    pollInterval: number;
+}
+declare abstract class ResumableTask extends TaskState implements ITask {
+    readonly strategy: TaskStrategy;
+    private readonly _pollInterval;
+    private _execution;
+    private _step;
+    constructor(props: IResumableTaskProps);
+    start(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    cancel(): Promise<void>;
+    finish(): Promise<void>;
+    protected abstract run(): IterableIterator<Promise<void>>;
+    private launchStep;
+    private queueStep;
+}
+
+export { AtomicTask, type ITask, type ITaskError, type ITaskErrorDetail, type ITaskMonitor, type ITaskState, type IUnMonitorTask, ResumableTask, TaskState, TaskStatus, TaskStrategy, active, alive, terminated };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@guanghechen/task",
+  "version": "1.0.0-alpha.1",
+  "description": "Atomic and resumable tasks",
+  "author": {
+    "name": "guanghechen",
+    "url": "https://github.com/guanghechen/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/guanghechen/sora/tree/@guanghechen/task@5.1.0",
+    "directory": "packages/task"
+  },
+  "homepage": "https://github.com/guanghechen/sora/tree/@guanghechen/task@5.1.0/packages/task#readme",
+  "type": "module",
+  "main": "./lib/cjs/index.cjs",
+  "module": "./lib/esm/index.mjs",
+  "exports": {
+    "import": "./lib/esm/index.mjs",
+    "require": "./lib/cjs/index.cjs"
+  },
+  "types": "lib/types/index.d.ts",
+  "source": "src/index.ts",
+  "license": "MIT",
+  "engines": {
+    "node": ">= 16.0.0"
+  },
+  "files": [
+    "lib/",
+    "!lib/**/*.map",
+    "package.json",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rimraf lib/ && cross-env NODE_ENV=production rollup -c ../../rollup.config.mjs",
+    "prepublishOnly": "yarn build",
+    "test": "node --experimental-vm-modules ../../node_modules/.bin/jest --config ../../jest.config.mjs --rootDir ."
+  },
+  "dependencies": {
+    "@guanghechen/monitor": "^1.0.0-alpha.1"
+  },
+  "devDependencies": {
+    "cross-env": "^7.0.3",
+    "jest": "^29.6.4",
+    "rimraf": "^5.0.1",
+    "rollup": "^3.28.1"
+  },
+  "gitHead": "39cf17711022736f580c1dff68a535cea6ffa3ef"
+}