~

src/base.ts

@@ -1,15 +0,0 @@
-import { Events } from 'events';
-
-export class DPBase extends Events {
-	constructor() {
-		super();
-	}
-
-	init() {
-		console.log('init');
-	}
-
-	start() {
-		console.log('start');
-	}
-}

src/base/base.ts

@@ -0,0 +1,118 @@
+import { DPEvent } from './event';
+
+type DPStarterEvents = {
+	over: () => DPTask;
+	exit: () => void;
+};
+
+export abstract class DPStarter extends DPEvent<DPStarterEvents> {
+	private _tasks: DPTask[] = [];
+
+	get tasks() {
+		return this._tasks;
+	}
+
+	init() {
+		console.log('init');
+		this.doInit();
+	}
+
+	abstract doInit(): void;
+
+	start() {
+		console.log('start');
+		this.on('over', (task: DPTask) => {
+			const index = this._tasks.indexOf(task);
+			if (index < this._tasks.length - 1) {
+				this._tasks[index + 1].start();
+			}
+
+			if (index === this._tasks.length - 1) {
+				this.emit('exit');
+			}
+
+			task.removeAllListeners();
+			this.removeTask(task);
+		});
+	}
+
+	addTask(task: DPTask) {
+		this._tasks.push(task);
+	}
+
+	removeTask(task: DPTask) {
+		const index = this._tasks.indexOf(task);
+		if (index >= 0) {
+			this._tasks.splice(index, 1);
+		}
+	}
+
+	clearTasks() {
+		this._tasks = [];
+	}
+}
+
+export enum TaskStatus {
+	Init = 'init',
+	Running = 'running',
+	Paused = 'paused',
+	Stopped = 'stopped',
+	Finished = 'finished'
+}
+
+export class DPTask extends DPEvent {
+	// 任务状态
+	private _status: TaskStatus = TaskStatus.Init;
+
+	private owner: DPStarter;
+
+	get status() {
+		return this._status;
+	}
+
+	set status(status: TaskStatus) {
+		this._status = status;
+		(status === TaskStatus.Finished || status === TaskStatus.Stopped) && this.owner.emit('over', this);
+	}
+
+	// 任务名称
+	private _name = '';
+
+	get name() {
+		return this._name;
+	}
+
+	set name(name: string) {
+		this._name = name;
+	}
+
+	constructor(owner: DPStarter) {
+		super();
+		this.owner = owner;
+	}
+
+	init() {
+		console.log('init');
+		this.status = TaskStatus.Init;
+	}
+
+	start() {
+		console.log('start');
+		this.status = TaskStatus.Running;
+	}
+
+	pause() {
+		console.log('pause');
+		this.status = TaskStatus.Paused;
+	}
+
+	stop() {
+		console.log('stop');
+		this.status = TaskStatus.Stopped;
+	}
+
+	restart() {
+		console.log('restart');
+		this.status = TaskStatus.Running;
+	}
+}

src/base/event.ts

@@ -0,0 +1,26 @@
+import { EventEmitter, Events } from 'events';
+type DPEventsDefinition = { [event: string]: (...args: any[]) => void };
+type DPAny<T> = {
+	[key: string]: T;
+};
+type DPValueType<T> = T extends DPAny<infer U> ? U : never;
+type DPUnionToIntersection<Union> = (Union extends any ? (argument: Union) => void : never) extends (argument: infer Intersection) => void
+	? Intersection
+	: never;
+type DPEventsWithoutAny<T extends { [event: string]: (...args: any[]) => void }> = {
+	on: DPUnionToIntersection<DPValueType<{ [K in keyof T]: (event: K, listener: T[K]) => any }>>;
+	emit: DPUnionToIntersection<DPValueType<{ [K in keyof T]: (event: K, ...args: Parameters<T[K]>) => boolean }>>;
+};
+
+type DPEvents<T extends DPEventsDefinition> = DPEventsWithoutAny<T> & {
+	on(event: string, listener: (...args: any[]) => void): any;
+	emit(event: string, ...args: any[]): any;
+};
+export abstract class DPEvent<T extends DPEventsDefinition = {}> extends EventEmitter {
+	declare on: DPEvents<T>['on'];
+	declare off: DPEvents<T>['on'];
+	declare once: DPEvents<T>['on'];
+	declare addListener: DPEvents<T>['on'];
+	declare removeListener: DPEvents<T>['on'];
+	declare emit: DPEvents<T>['emit'];
+}

src/index.ts

@@ -1,9 +1,10 @@
-import { DPBase } from './base';
+import { DPStarter, DPTask } from './base/base';
 
-class Hongguo extends DPBase {
+class Hongguo extends DPStarter {
-	constructor() {
+	doInit() {
-		super();
+		launchApp('com.hongguo.app');
 	}
 }
 
-const hongguo = new Hongguo().start();
+const hongguo = new Hongguo();
+hongguo.start();