@eggjs/cluster 4.0.0-beta.34 → 4.0.0-beta.36

package/dist/utils/mode/base/agent.js

@@ -1,65 +1,63 @@
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { EventEmitter } from 'node:events';
-export class BaseAgentWorker {
-    instance;
-    #instanceId;
-    #instanceStatus;
-    constructor(instance) {
-        this.instance = instance;
-    }
-    get id() {
-        return this.#instanceId;
-    }
-    set id(id) {
-        this.#instanceId = id;
-    }
-    get status() {
-        return this.#instanceStatus;
-    }
-    set status(status) {
-        this.#instanceStatus = status;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    static send(_message) {
-        throw new Error('BaseAgentWorker should implement send.');
-    }
-    static kill() {
-        throw new Error('BaseAgentWorker should implement kill.');
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    static gracefulExit(_options) {
-        throw new Error('BaseAgentWorker should implement gracefulExit.');
-    }
-}
-export class BaseAgentUtils extends EventEmitter {
-    options;
-    messenger;
-    log;
-    logger;
-    // public attrs
-    startTime = 0;
-    constructor(options, { log, logger, messenger, }) {
-        super();
-        this.options = options;
-        this.log = log;
-        this.logger = logger;
-        this.messenger = messenger;
-        // this.instance = null;
-    }
-    getAgentWorkerFile() {
-        const srcDirname = path.join(import.meta.dirname, '../../..');
-        let agentWorkerFile = path.join(srcDirname, 'agent_worker.js');
-        if (!existsSync(agentWorkerFile)) {
-            agentWorkerFile = path.join(srcDirname, 'agent_worker.ts');
-        }
-        return agentWorkerFile;
-    }
-    fork() {
-        throw new Error('BaseAgent should implement fork.');
-    }
-    clean() {
-        throw new Error('BaseAgent should implement clean.');
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+
+//#region src/utils/mode/base/agent.ts
+var BaseAgentWorker = class {
+	instance;
+	#instanceId;
+	#instanceStatus;
+	constructor(instance) {
+		this.instance = instance;
+	}
+	get id() {
+		return this.#instanceId;
+	}
+	set id(id) {
+		this.#instanceId = id;
+	}
+	get status() {
+		return this.#instanceStatus;
+	}
+	set status(status) {
+		this.#instanceStatus = status;
+	}
+	static send(_message) {
+		throw new Error("BaseAgentWorker should implement send.");
+	}
+	static kill() {
+		throw new Error("BaseAgentWorker should implement kill.");
+	}
+	static gracefulExit(_options) {
+		throw new Error("BaseAgentWorker should implement gracefulExit.");
+	}
+};
+var BaseAgentUtils = class extends EventEmitter {
+	options;
+	messenger;
+	log;
+	logger;
+	startTime = 0;
+	constructor(options, { log, logger, messenger }) {
+		super();
+		this.options = options;
+		this.log = log;
+		this.logger = logger;
+		this.messenger = messenger;
+	}
+	getAgentWorkerFile() {
+		const srcDirname = path.join(import.meta.dirname, "../../..");
+		let agentWorkerFile = path.join(srcDirname, "agent_worker.js");
+		if (!existsSync(agentWorkerFile)) agentWorkerFile = path.join(srcDirname, "agent_worker.ts");
+		return agentWorkerFile;
+	}
+	fork() {
+		throw new Error("BaseAgent should implement fork.");
+	}
+	clean() {
+		throw new Error("BaseAgent should implement clean.");
+	}
+};
+
+//#endregion
+export { BaseAgentUtils, BaseAgentWorker };

package/dist/utils/mode/base/app.d.ts

@@ -1,48 +1,56 @@
-import { EventEmitter } from 'node:events';
-import type { Worker as ClusterProcessWorker } from 'node:cluster';
-import type { Worker as ThreadWorker } from 'node:worker_threads';
-import type { Logger } from 'egg-logger';
-import type { MessageBody, Messenger } from '../../messenger.ts';
-import type { MasterOptions } from '../../../master.ts';
-export declare abstract class BaseAppWorker<T = ThreadWorker | ClusterProcessWorker> {
-    instance: T;
-    constructor(instance: T);
-    abstract get workerId(): number;
-    abstract get id(): number;
-    get state(): string;
-    set state(state: string);
-    abstract get exitedAfterDisconnect(): boolean;
-    abstract get exitCode(): number;
-    get disableRefork(): boolean;
-    set disableRefork(disableRefork: boolean);
-    get isDevReload(): boolean;
-    set isDevReload(isDevReload: boolean);
-    abstract send(data: MessageBody): void;
-    clean(): void;
-    static get workerId(): number;
-    static on(..._args: any[]): void;
-    static send(_message: MessageBody): void;
-    static kill(): void;
-    static gracefulExit(_options: any): void;
+import { MessageBody, Messenger } from "../../messenger.js";
+import { MasterOptions } from "../../../master.js";
+import { Logger } from "egg-logger";
+import { Worker } from "node:worker_threads";
+import { EventEmitter } from "node:events";
+import { Worker as Worker$1 } from "node:cluster";
+
+//#region src/utils/mode/base/app.d.ts
+declare abstract class BaseAppWorker<T = Worker | Worker$1> {
+  instance: T;
+  constructor(instance: T);
+  abstract get workerId(): number;
+  abstract get id(): number;
+  get state(): string;
+  set state(state: string);
+  abstract get exitedAfterDisconnect(): boolean;
+  abstract get exitCode(): number;
+  get disableRefork(): boolean;
+  set disableRefork(disableRefork: boolean);
+  get isDevReload(): boolean;
+  set isDevReload(isDevReload: boolean);
+  abstract send(data: MessageBody): void;
+  clean(): void;
+  static get workerId(): number;
+  static on(..._args: any[]): void;
+  static send(_message: MessageBody): void;
+  static kill(): void;
+  static gracefulExit(_options: any): void;
 }
 type LogFun = (msg: any, ...args: any[]) => void;
-export declare abstract class BaseAppUtils extends EventEmitter {
-    options: MasterOptions;
-    protected messenger: Messenger;
-    protected log: LogFun;
-    protected logger: Logger;
-    protected isProduction: boolean;
-    startTime: number;
-    startSuccessCount: number;
-    isAllWorkerStarted: boolean;
-    constructor(options: MasterOptions, { log, logger, messenger, isProduction, }: {
-        log: LogFun;
-        logger: Logger;
-        messenger: Messenger;
-        isProduction: boolean;
-    });
-    getAppWorkerFile(): string;
-    fork(): void;
-    abstract kill(timeout: number): Promise<void>;
+declare abstract class BaseAppUtils extends EventEmitter {
+  options: MasterOptions;
+  protected messenger: Messenger;
+  protected log: LogFun;
+  protected logger: Logger;
+  protected isProduction: boolean;
+  startTime: number;
+  startSuccessCount: number;
+  isAllWorkerStarted: boolean;
+  constructor(options: MasterOptions, {
+    log,
+    logger,
+    messenger,
+    isProduction
+  }: {
+    log: LogFun;
+    logger: Logger;
+    messenger: Messenger;
+    isProduction: boolean;
+  });
+  getAppWorkerFile(): string;
+  fork(): void;
+  abstract kill(timeout: number): Promise<void>;
 }
-export {};
+//#endregion
+export { BaseAppUtils, BaseAppWorker };

package/dist/utils/mode/base/app.js

@@ -1,80 +1,77 @@
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { EventEmitter } from 'node:events';
-export class BaseAppWorker {
-    instance;
-    constructor(instance) {
-        this.instance = instance;
-    }
-    get state() {
-        return Reflect.get(this.instance, 'state');
-    }
-    set state(state) {
-        Reflect.set(this.instance, 'state', state);
-    }
-    get disableRefork() {
-        return Reflect.get(this.instance, 'disableRefork');
-    }
-    set disableRefork(disableRefork) {
-        Reflect.set(this.instance, 'disableRefork', disableRefork);
-    }
-    get isDevReload() {
-        return Reflect.get(this.instance, 'isDevReload');
-    }
-    set isDevReload(isDevReload) {
-        Reflect.set(this.instance, 'isDevReload', isDevReload);
-    }
-    clean() {
-        throw new Error('BaseAppWorker should implement clean.');
-    }
-    // static methods use on src/app_worker.ts
-    static get workerId() {
-        throw new Error('BaseAppWorker should implement workerId.');
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    static on(..._args) {
-        throw new Error('BaseAppWorker should implement on.');
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    static send(_message) {
-        throw new Error('BaseAgentWorker should implement send.');
-    }
-    static kill() {
-        throw new Error('BaseAppWorker should implement kill.');
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    static gracefulExit(_options) {
-        throw new Error('BaseAgentWorker should implement gracefulExit.');
-    }
-}
-export class BaseAppUtils extends EventEmitter {
-    options;
-    messenger;
-    log;
-    logger;
-    isProduction;
-    // public attrs
-    startTime = 0;
-    startSuccessCount = 0;
-    isAllWorkerStarted = false;
-    constructor(options, { log, logger, messenger, isProduction, }) {
-        super();
-        this.options = options;
-        this.log = log;
-        this.logger = logger;
-        this.messenger = messenger;
-        this.isProduction = isProduction;
-    }
-    getAppWorkerFile() {
-        const srcDirname = path.join(import.meta.dirname, '../../..');
-        let appWorkerFile = path.join(srcDirname, 'app_worker.js');
-        if (!existsSync(appWorkerFile)) {
-            appWorkerFile = path.join(srcDirname, 'app_worker.ts');
-        }
-        return appWorkerFile;
-    }
-    fork() {
-        throw new Error('BaseApp should implement fork.');
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+
+//#region src/utils/mode/base/app.ts
+var BaseAppWorker = class {
+	instance;
+	constructor(instance) {
+		this.instance = instance;
+	}
+	get state() {
+		return Reflect.get(this.instance, "state");
+	}
+	set state(state) {
+		Reflect.set(this.instance, "state", state);
+	}
+	get disableRefork() {
+		return Reflect.get(this.instance, "disableRefork");
+	}
+	set disableRefork(disableRefork) {
+		Reflect.set(this.instance, "disableRefork", disableRefork);
+	}
+	get isDevReload() {
+		return Reflect.get(this.instance, "isDevReload");
+	}
+	set isDevReload(isDevReload) {
+		Reflect.set(this.instance, "isDevReload", isDevReload);
+	}
+	clean() {
+		throw new Error("BaseAppWorker should implement clean.");
+	}
+	static get workerId() {
+		throw new Error("BaseAppWorker should implement workerId.");
+	}
+	static on(..._args) {
+		throw new Error("BaseAppWorker should implement on.");
+	}
+	static send(_message) {
+		throw new Error("BaseAgentWorker should implement send.");
+	}
+	static kill() {
+		throw new Error("BaseAppWorker should implement kill.");
+	}
+	static gracefulExit(_options) {
+		throw new Error("BaseAgentWorker should implement gracefulExit.");
+	}
+};
+var BaseAppUtils = class extends EventEmitter {
+	options;
+	messenger;
+	log;
+	logger;
+	isProduction;
+	startTime = 0;
+	startSuccessCount = 0;
+	isAllWorkerStarted = false;
+	constructor(options, { log, logger, messenger, isProduction }) {
+		super();
+		this.options = options;
+		this.log = log;
+		this.logger = logger;
+		this.messenger = messenger;
+		this.isProduction = isProduction;
+	}
+	getAppWorkerFile() {
+		const srcDirname = path.join(import.meta.dirname, "../../..");
+		let appWorkerFile = path.join(srcDirname, "app_worker.js");
+		if (!existsSync(appWorkerFile)) appWorkerFile = path.join(srcDirname, "app_worker.ts");
+		return appWorkerFile;
+	}
+	fork() {
+		throw new Error("BaseApp should implement fork.");
+	}
+};
+
+//#endregion
+export { BaseAppUtils, BaseAppWorker };

package/dist/utils/mode/impl/process/agent.d.ts

@@ -1,18 +1,22 @@
-import { type ChildProcess } from 'node:child_process';
-import { type Options as gracefulExitOptions } from 'graceful-process';
-import { BaseAgentWorker, BaseAgentUtils } from '../../base/agent.ts';
-import type { MessageBody } from '../../../messenger.ts';
-export declare class AgentProcessWorker extends BaseAgentWorker<ChildProcess> {
-    get workerId(): number;
-    send(message: MessageBody): void;
-    static send(message: MessageBody): void;
-    static kill(): void;
-    static gracefulExit(options: gracefulExitOptions): void;
+import { BaseAgentUtils, BaseAgentWorker } from "../../base/agent.js";
+import { MessageBody } from "../../../messenger.js";
+import { ChildProcess } from "node:child_process";
+import { Options } from "graceful-process";
+
+//#region src/utils/mode/impl/process/agent.d.ts
+declare class AgentProcessWorker extends BaseAgentWorker<ChildProcess> {
+  get workerId(): number;
+  send(message: MessageBody): void;
+  static send(message: MessageBody): void;
+  static kill(): void;
+  static gracefulExit(options: Options): void;
 }
-export declare class AgentProcessUtils extends BaseAgentUtils {
-    #private;
-    instance: AgentProcessWorker;
-    fork(): this;
-    clean(): void;
-    kill(timeout: number): Promise<void>;
+declare class AgentProcessUtils extends BaseAgentUtils {
+  #private;
+  instance: AgentProcessWorker;
+  fork(): this;
+  clean(): void;
+  kill(timeout: number): Promise<void>;
 }
+//#endregion
+export { AgentProcessUtils };