lazy-js-utils/dist/node/index.cjs

A collection of lazy-loaded JavaScript utilities for efficient development

"use strict";
const require_chunk = require('../chunk-BCwAaXi7.cjs');
const require_parallel = require('../parallel-BSxIacyY.cjs');
const require_isBool = require('../isBool-B9jCuCG_.cjs');
const require_toAbsolutePath = require('../toAbsolutePath-DwpNBNau.cjs');
const require_useNodeWorker = require('../useNodeWorker-ChMLDiEV.cjs');
const node_process = require_chunk.__toESM(require("node:process"));
const node_fs = require_chunk.__toESM(require("node:fs"));
const node_path = require_chunk.__toESM(require("node:path"));
const node_fs_promises = require_chunk.__toESM(require("node:fs/promises"));

//#region src/node/fileCopy.ts
/**
* 将文件拷贝到另一个目录
* @param urls 需要被拷贝的文件路径
* @param destination 目录
* @returns IShellMessage
*/
function fileCopy(urls, destination) {
	return require_useNodeWorker.jsShell(`cp -r {${urls.join(",")}} ${destination}`, "pipe");
}

//#endregion
//#region src/node/getExportBundle.ts
/**
* 获取npm包导出的文件内容
* @param { string } url npm包名
* @returns
*/
async function getExportBundle(url) {
	if (/[./]/.test(url)) throw new Error("module must be a npm module");
	const pkg = node_path.default.resolve(node_process.default.cwd(), "node_modules", url, "package.json");
	const { module: module$1, main } = JSON.parse(await node_fs_promises.default.readFile(pkg, "utf-8"));
	const modulePath = node_path.default.resolve(`./node_modules/${url}`, module$1 || main);
	return node_fs_promises.default.readFile(modulePath, "utf-8");
}

//#endregion
//#region src/string/ensureSuffix.ts
/**
* 确保后缀有这个字符串
* @param { string } suffix 后缀
* @param { string } str 字符串
* @returns string
*/
function ensureSuffix(suffix, str) {
	if (str.endsWith(suffix)) return str;
	return str + suffix;
}

//#endregion
//#region src/node/getPkg.ts
/**
* 获取当前package.json 对象
* @param { string } url 路径 默认 ./package.json
* @returns 返回json格式package.json
*/
async function getPkg(url = "./package.json") {
	const resolvedPath = require_toAbsolutePath.toAbsolutePath(ensureSuffix("/package.json", url));
	if (!require_parallel.isFile(resolvedPath)) throw new Error(`${resolvedPath} is not a file`);
	return JSON.parse(await node_fs_promises.default.readFile(resolvedPath, "utf-8"));
}

//#endregion
//#region src/node/getPkgTool.ts
/**
* 获取当前包管理器 ‘yarn’ | 'pnpm' | 'bun' | 'npm'
* @returns 返回当前package环境 ‘yarn’ | 'pnpm' | 'bun' | 'npm'
*/
async function getPkgTool() {
	const pkg = await getPkg() || {};
	const { packageManager } = pkg;
	if (packageManager) {
		const manager = packageManager.split("@")[0].replace(/[~^]/, "");
		if (packageManager) return manager;
	}
	switch (true) {
		case require_parallel.isFile(require_toAbsolutePath.toAbsolutePath("./bun.lockb")): return "bun";
		case require_parallel.isFile(require_toAbsolutePath.toAbsolutePath("./pnpm-lock.yaml")):
		case require_parallel.isFile(require_toAbsolutePath.toAbsolutePath("./pnpm-workspace.yaml")): return "pnpm";
		case require_parallel.isFile(require_toAbsolutePath.toAbsolutePath("./yarn.lock")):
		case require_parallel.isFile(require_toAbsolutePath.toAbsolutePath("./lerna.json")): return "yarn";
		default: return "npm";
	}
}

//#endregion
//#region src/node/transformArgv.ts
/**
*
* @returns 处理argv --flag如果未设置值默认为true
*/
function transformArgv() {
	var _process$argv;
	return node_process.default === null || node_process.default === void 0 || (_process$argv = node_process.default.argv) === null || _process$argv === void 0 ? void 0 : _process$argv.slice(2).reduce((result, arg) => {
		const [key, value] = arg.split("=");
		result[key.slice(2)] = value || true;
		return result;
	}, {});
}

//#endregion
//#region src/node/withTaskName.ts
/**
* 处理gulp任务
* @param name 任务名
* @param fn 任务函数
* @returns
*/
function withTaskName(name, fn) {
	return Object.assign(fn, { displayName: name });
}

//#endregion
//#region src/node/writeFile.ts
/**
* 重写文件
* @param { string } paths 路径
* @param { (content: string, index: number) => string } callback 回调接收文件字符串将返回的内容重新写入该文件
* @param { string } [encoding] 默认 'utf-8'
*/
function writeFile(paths, callback, encoding = "utf-8") {
	if (require_isBool.isStr(paths)) paths = [paths];
	paths.forEach(async (relativepath, i) => {
		const content = await node_fs_promises.default.readFile(relativepath, encoding);
		const result = (callback === null || callback === void 0 ? void 0 : callback(content, i)) || content;
		node_fs_promises.default.writeFile(relativepath, result).catch((err) => {
			throw err;
		});
	});
}

//#endregion
//#region src/node/hasPkg.ts
/**
* 判断是否存在package.json
* @param { string } rootPath 绝对路径
* @returns boolean
*/
async function hasPkg(rootPath) {
	const url = node_path.default.resolve(rootPath, "package.json");
	const { result } = await require_useNodeWorker.jsShell(`test -f "${url}" && echo "0"|| echo "1"`, "pipe");
	return result === "0";
}

//#endregion
//#region src/node/isInstallPkg.ts
async function isInstallPkg(pkg) {
	const { status } = await require_useNodeWorker.jsShell(`if ! command -v ${pkg} &> /dev/null; then
  exit 1
else
  exit 0
fi`);
	return status === 0;
}

//#endregion
//#region src/node/isExist.ts
/**
* 判断文件是否存在
* @param url
* @returns
*/
function isExist(url) {
	try {
		node_fs.default.accessSync(require_toAbsolutePath.toAbsolutePath(url));
		return true;
	} catch (error) {
		return false;
	}
}

//#endregion
//#region src/node/isGo.ts
/**
* 判断是否是在go环境
* @returns
*/
async function isGo(rootPath = node_process.default.cwd()) {
	const url = node_path.default.resolve(rootPath, "go.mod");
	const { result } = await require_useNodeWorker.jsShell(`(test -f "main.go" || test -f "${url}") && echo "0"|| echo "1"`, "pipe");
	return result === "0";
}

//#endregion
//#region src/node/isRust.ts
/**
* 判断是否是rust环境
*/
async function isRust(rootPath = node_process.default.cwd()) {
	const url = node_path.default.resolve(rootPath, "Cargo.toml");
	const { result } = await require_useNodeWorker.jsShell(`test -f "${url}" && echo "0"|| echo "1"`, "pipe");
	return result === "0";
}

//#endregion
//#region src/node/isWritable.ts
/**
* 同步地测试用户对 path 指定的文件或目录的权限
* @param { string } filename 文件或目录路径
* @returns
*/
function isWritable(filename) {
	try {
		node_fs.default.accessSync(filename, node_fs.default.constants.W_OK);
		return true;
	} catch {
		return false;
	}
}

//#endregion
//#region src/node/isPkg.ts
/**
* 判断路径下是否有package.jsons
* @param { string } rootPath 默认 process.cwd()
*/
async function isPkg(rootPath = node_process.default.cwd()) {
	const url = node_path.default.resolve(rootPath.replace(/package.json$/, ""), "package.json");
	const { result } = await require_useNodeWorker.jsShell(`test -f "${url}" && echo "0"|| echo "1"`, "pipe");
	return result === "0";
}

//#endregion
exports.fileCopy = fileCopy
exports.getExportBundle = getExportBundle
exports.getPkg = getPkg
exports.getPkgTool = getPkgTool
exports.hasPkg = hasPkg
exports.isExist = isExist
exports.isGo = isGo
exports.isInstallPkg = isInstallPkg
exports.isPkg = isPkg
exports.isRust = isRust
exports.isWritable = isWritable
exports.jsShell = require_useNodeWorker.jsShell
exports.transformArgv = transformArgv
exports.useNodeWorker = require_useNodeWorker.useNodeWorker
exports.useProcressNodeWorker = require_useNodeWorker.useProcressNodeWorker
exports.withTaskName = withTaskName
exports.writeFile = writeFile