lazy-js-utils/dist/useNodeWorker-CooJWnAZ.js

A collection of lazy-loaded JavaScript utilities for efficient development

import { isPlainObject$1 as isPlainObject, parallel$1 as parallel } from "./parallel-DHAKJPw_.js";
import { isArray$1 as isArray, isStr$1 as isStr } from "./isBool-Bi9uSocl.js";
import process from "node:process";
import fs from "node:fs";
import path from "node:path";
import child_process from "node:child_process";
import worker_threads from "node:worker_threads";

//#region src/node/jsShell.ts
function jsShell(commander, options) {
	let args = [];
	let stdio;
	let errorExit = true;
	let isLog = false;
	let cwd;
	let _options = {};
	if (isPlainObject(options)) {
		args = options.args ?? [];
		stdio = options.stdio;
		errorExit = options.errorExit ?? true;
		isLog = options.isLog ?? false;
		cwd = options.cwd;
		_options = options.options ?? {};
	} else if (options) stdio = options;
	return isArray(commander) ? Promise.all(commander.map((command) => executor(command))) : executor(commander);
	function executor(commander$1) {
		return new Promise((resolve, reject) => {
			var _child$stdout, _child$stderr;
			const child = child_process.spawn(commander$1, args, {
				shell: true,
				stdio,
				cwd,
				..._options
			});
			const pid = child.pid;
			let result = "";
			let errorOutput = "";
			(_child$stdout = child.stdout) === null || _child$stdout === void 0 || _child$stdout.on("data", (data) => {
				result += data.toString();
			});
			(_child$stderr = child.stderr) === null || _child$stderr === void 0 || _child$stderr.on("data", (data) => {
				if (isLog) console.error(data.toString());
				errorOutput += data.toString();
			});
			child.on("close", (status) => {
				result = result.trim();
				if (status === 130) {
					if (isLog) console.log("已取消...");
					resolve({
						status,
						result,
						pid
					});
				} else if (status !== 0) {
					if (isLog) console.error(`Command failed with status ${status}`);
					if (errorExit) {
						reject(new Error(result || errorOutput));
						process.exit(1);
					} else resolve({
						status,
						result: result || errorOutput,
						pid
					});
				} else resolve({
					status,
					result,
					pid
				});
			});
			child.on("error", (error) => {
				if (isLog) console.error(error.message);
				if (errorExit) {
					reject(new Error(error.message));
					process.exit(1);
				} else resolve({
					status: null,
					result: error.message,
					pid
				});
			});
		});
	}
}

//#endregion
//#region src/node/useNodeWorker.ts
/**
* 这个api需要 dependencies 中安装lazy-js-utils
* @param { string | NodeWorkerPayload } payload 字符串 ｜ {
params: string[]
stdio?: 'inherit' | 'pipe'
}
* @param { string } [url] 自定义worker路径
* @returns
*/
async function useNodeWorker(payload, url) {
	if (!url) {
		url = path.resolve(__dirname, "../node_modules/lazy-js-utils/dist/worker/useNodeWorkerThread.js");
		if (!fs.existsSync(url)) url = path.resolve(__dirname, "./worker/useNodeWorkerThread.js");
	}
	const { params } = isStr(payload) ? payload = { params: payload } : payload;
	const commands = isArray(params) ? params : params.split("&&");
	const result = await parallel(commands, (params$1) => createWorker(Object.assign(payload, { params: params$1 })));
	setTimeout(process.exit);
	return result.length === 1 ? result[0] : result;
	function createWorker(payload$1) {
		const { Worker } = worker_threads;
		return new Promise((resolve) => {
			const seprateThread = new Worker(url);
			seprateThread.on("message", resolve);
			seprateThread.postMessage(payload$1);
		});
	}
}
function useProcressNodeWorker(callback) {
	const { parentPort } = worker_threads;
	parentPort.on("message", async (data) => parentPort === null || parentPort === void 0 ? void 0 : parentPort.postMessage(await (callback === null || callback === void 0 ? void 0 : callback(data)) || (() => "")));
}

//#endregion
export { jsShell, useNodeWorker, useProcressNodeWorker };