@idlebox/node 1.2.11 → 1.2.13

package/src/index.generated.ts

@@ -0,0 +1,133 @@
+// DO NOT EDIT THIS FILE
+// @ts-ignore
+/* eslint-disable */
+
+/* preload.ts */
+	// Identifiers
+/* path-resolve/resolvePath.ts */
+	// Identifiers
+		export {ResolvePathFunction} from "./path-resolve/resolvePath";
+		export {JoinPathFunction} from "./path-resolve/resolvePath";
+		export {resolvePath} from "./path-resolve/resolvePath";
+		export {NormalizePathFunction} from "./path-resolve/resolvePath";
+		export {normalizePath} from "./path-resolve/resolvePath";
+		export {osTempDir} from "./path-resolve/resolvePath";
+		export {relativePath} from "./path-resolve/resolvePath";
+/* error/pretty.ts */
+	// Identifiers
+		export {setErrorLogRoot} from "./error/pretty";
+		export {prettyPrintError} from "./error/pretty";
+		export {prettyFormatError} from "./error/pretty";
+/* asyncLoad.ts */
+	// Identifiers
+		export {AsyncMainFunction} from "./asyncLoad";
+		export {ExitError} from "./asyncLoad";
+		export {runMain} from "./asyncLoad";
+/* child_process/error.ts */
+	// Identifiers
+		export {checkChildProcessResult} from "./child_process/error";
+/* child_process/execa.ts */
+	// Identifiers
+		export {Sync} from "./child_process/execa";
+		export {Async} from "./child_process/execa";
+		export {ICommand} from "./child_process/execa";
+		export {spawnWithoutOutput} from "./child_process/execa";
+		export {spawnGetOutput} from "./child_process/execa";
+		export {spawnGetEverything} from "./child_process/execa";
+/* cli-io/output.ts */
+	// Identifiers
+		export {printLine} from "./cli-io/output";
+/* child_process/lateError.ts */
+	// Identifiers
+		export {ISpawnAdditionOptions} from "./child_process/lateError";
+		export {execLazyError} from "./child_process/lateError";
+/* fs/exists.ts */
+	// Identifiers
+		export {existsSync} from "./fs/exists";
+		export {exists} from "./fs/exists";
+/* environment/getEnvironment.ts */
+	// Identifiers
+		export {IEnvironmentResult} from "./environment/getEnvironment";
+		export {getEnvironment} from "./environment/getEnvironment";
+		export {deleteEnvironment} from "./environment/getEnvironment";
+		export {cleanupEnvironment} from "./environment/getEnvironment";
+/* environment/pathEnvironment.ts */
+	// Identifiers
+		export {PATH_SEPARATOR} from "./environment/pathEnvironment";
+		export {PathEnvironment} from "./environment/pathEnvironment";
+/* environment/findBinary.ts */
+	// Identifiers
+		export {findBinary} from "./environment/findBinary";
+/* child_process/respawn.ts */
+	// Identifiers
+		export {spawnRecreateEventHandlers} from "./child_process/respawn";
+		export {trySpawnInScope} from "./child_process/respawn";
+		export {respawnInScope} from "./child_process/respawn";
+/* crypto/md5.ts */
+	// Identifiers
+		export {md5} from "./crypto/md5";
+/* crypto/sha256.ts */
+	// Identifiers
+		export {sha256} from "./crypto/sha256";
+/* environment/npmConfig.ts */
+	// Identifiers
+		export {getNpmConfigValue} from "./environment/npmConfig";
+/* error/code.ts */
+	// Identifiers
+		export {ERRNO_LINUX} from "./error/code";
+/* events/dumpEventEmitter.ts */
+	// Identifiers
+		export {dumpEventEmitterEmit} from "./events/dumpEventEmitter";
+/* fs/commandExists.ts */
+	// Identifiers
+		export {commandInPath} from "./fs/commandExists";
+		export {commmandInPathSync} from "./fs/commandExists";
+/* fs/tempFolder.ts */
+	// Identifiers
+		export {createTempFolder} from "./fs/tempFolder";
+/* fs/weiteChanged.ts */
+	// Identifiers
+		export {writeFileIfChangeSync} from "./fs/weiteChanged";
+		export {writeFileIfChange} from "./fs/weiteChanged";
+/* log/terminal.ts */
+	// Identifiers
+		export {WrappedTerminalConsole} from "./log/terminal";
+/* path-resolve/findUp.ts */
+	// Identifiers
+		export {findUpUntil} from "./path-resolve/findUp";
+		export {findUpUntilSync} from "./path-resolve/findUp";
+/* path-resolve/findPackageRoot.ts */
+	// Identifiers
+		export {findPackageRoot} from "./path-resolve/findPackageRoot";
+/* path-resolve/getAllUp.ts */
+	// Identifiers
+		export {getAllPathUpToRoot} from "./path-resolve/getAllUp";
+/* path-resolve/lrelative.ts */
+	// Identifiers
+		export {lrelative} from "./path-resolve/lrelative";
+/* path-resolve/nodeResolvePathArray.ts */
+	// Identifiers
+		export {nodeResolvePathArray} from "./path-resolve/nodeResolvePathArray";
+/* stream/blackHoleStream.ts */
+	// Identifiers
+		export {BlackHoleStream} from "./stream/blackHoleStream";
+/* stream/streamPromise.ts */
+	// Identifiers
+		export {streamPromise} from "./stream/streamPromise";
+		export {streamHasEnd} from "./stream/streamPromise";
+/* stream/collectingStream.ts */
+	// Identifiers
+		export {streamToBuffer} from "./stream/collectingStream";
+		export {RawCollectingStream} from "./stream/collectingStream";
+		export {CollectingStream} from "./stream/collectingStream";
+/* stream/disposableStream.ts */
+	// Identifiers
+		export {disposableStream} from "./stream/disposableStream";
+/* stream/drainStream.ts */
+	// Identifiers
+		export {drainStream} from "./stream/drainStream";
+/* stream/loggerStream.ts */
+	// Identifiers
+		export {LogFunction} from "./stream/loggerStream";
+		export {LoggerStream} from "./stream/loggerStream";
+		export {HexDumpLoggerStream} from "./stream/loggerStream";

package/src/log/terminal.ts

@@ -0,0 +1,41 @@
+import { WrappedConsole, WrappedConsoleOptions } from '@idlebox/common';
+
+interface TerminalConsoleOptions {
+	color?: boolean | Partial<typeof colorMap>;
+}
+
+const colorMap = {
+	info: '38;5;14',
+	success: '38;5;10',
+	debug: '2',
+	error: '38;5;9',
+	trace: '2',
+	warn: '38;5;11',
+	assert: '38;5;9;7',
+};
+
+export class WrappedTerminalConsole extends WrappedConsole {
+	private readonly colors: Record<string, string> = colorMap;
+
+	constructor(title: string, { color, ...opt }: WrappedConsoleOptions & TerminalConsoleOptions = {}) {
+		super(title, opt);
+		if (color === false) {
+			this.colors = {};
+		} else if (color === undefined) {
+			if (!process.stderr.isTTY || !process.stdout.isTTY) {
+				this.colors = {};
+			}
+		} else if (typeof color === 'object') {
+			this.colors = { ...colorMap, ...color };
+		}
+	}
+
+	protected processColorLabel(msg: any[], pos: number, level: string, prefix: string): void {
+		if (this.colors[level]) {
+			msg[pos] = `\x1B[${this.colors[level]}m${prefix}${msg[pos]}`;
+			msg.push('\x1B[0m');
+		} else {
+			msg[pos] = `${prefix}${msg[pos]}`;
+		}
+	}
+}

package/src/path-resolve/findPackageRoot.ts

@@ -0,0 +1,20 @@
+import { createRequire } from 'module';
+import { dirname } from 'path';
+import { findUpUntilSync } from './findUp';
+
+export function findPackageRoot(packageName: string, require = createRequire(process.cwd())) {
+	try {
+		return dirname(require.resolve(packageName + 'package.json'));
+	} catch (e: any) {
+		if (e.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+			const main = require.resolve(packageName);
+			const pkgJson = findUpUntilSync(main, 'package.json');
+			if (!pkgJson) {
+				throw new Error(`Package ${packageName} do not have a package.json`);
+			}
+			return dirname(pkgJson);
+		} else {
+			throw e;
+		}
+	}
+}

package/src/path-resolve/findUp.ts

@@ -0,0 +1,34 @@
+import { dirname, resolve } from 'path';
+import { exists, existsSync } from '../fs/exists';
+
+export async function findUpUntil(from: string, file: string): Promise<string | null> {
+	for (let _from = resolve(from); _from !== '/'; _from = dirname(_from)) {
+		const want = resolve(_from, file);
+		if (await exists(want)) {
+			return want;
+		}
+	}
+
+	const final = resolve('/', file);
+	if (await exists(final)) {
+		return final;
+	}
+
+	return null;
+}
+
+export function findUpUntilSync(from: string, file: string): string | null {
+	for (let _from = resolve(from); _from !== '/'; _from = dirname(_from)) {
+		const want = resolve(_from, file);
+		if (existsSync(want)) {
+			return want;
+		}
+	}
+
+	const final = resolve('/', file);
+	if (existsSync(final)) {
+		return final;
+	}
+
+	return null;
+}

package/src/path-resolve/getAllUp.ts

@@ -0,0 +1,15 @@
+export function getAllPathUpToRoot(from: string, append: string = '') {
+	const parts = from.split(/\/\\/g).filter((e) => e);
+	const dirs: string[] = [];
+	let p = '';
+
+	if (append) {
+		append = '/' + append;
+	}
+
+	for (const i of parts) {
+		p += '/' + i;
+		dirs.push(p + append);
+	}
+	return dirs;
+}

package/src/path-resolve/lrelative.ts

@@ -0,0 +1,20 @@
+import { isAbsolute } from 'path';
+
+export function lrelative(from: string, to: string) {
+	if (!isAbsolute(from)) {
+		throw new Error('lrelative: from is not absolute: ' + from);
+	}
+	if (!isAbsolute(to)) {
+		throw new Error('lrelative: to is not absolute: ' + to);
+	}
+	const fa = from.split(/[\/\\]/g).filter((e) => e);
+	const ta = to.split(/[\/\\]/g).filter((e) => e);
+	const f = ta.pop();
+	while (fa[0] === ta[0]) {
+		fa.shift();
+		ta.shift();
+	}
+	const ret = fa.length === 0 ? ['.'] : new Array(fa.length).fill('..');
+	ret.push(...ta, f);
+	return ret.join('/');
+}

package/src/path-resolve/nodeResolvePathArray.ts

@@ -0,0 +1,10 @@
+import { dirname, resolve } from 'path';
+
+export function nodeResolvePathArray(from: string, file = 'node_modules') {
+	const ret: string[] = [];
+	do {
+		ret.push(resolve(from, file));
+		from = dirname(from);
+	} while (from !== '/');
+	return ret;
+}

package/src/path-resolve/resolvePath.ts

@@ -0,0 +1,43 @@
+import { isWindows } from '@idlebox/common';
+import { tmpdir } from 'os';
+import { normalize, relative, resolve } from 'path';
+
+const winSlash = /\\/g;
+
+export interface ResolvePathFunction {
+	(...pathSegments: string[]): string;
+}
+
+export interface JoinPathFunction {
+	(from: string, to: string): string;
+}
+
+export const resolvePath: ResolvePathFunction = isWindows ? resolveWindowsPath : resolve;
+
+function resolveWindowsPath(...pathSegments: string[]): string {
+	return resolve(...pathSegments).replace(winSlash, '/');
+}
+
+export interface NormalizePathFunction {
+	(path: string): string;
+}
+
+export const normalizePath: NormalizePathFunction = isWindows ? normalizeWindowsPath : normalize;
+
+function normalizeWindowsPath(path: string): string {
+	return normalize(path).replace(winSlash, '/');
+}
+
+export function osTempDir(name?: string) {
+	if (name) {
+		return resolvePath(tmpdir(), name);
+	} else {
+		return resolvePath(tmpdir());
+	}
+}
+
+function relativeWindowsPath(from: string, to: string) {
+	return relative(normalize(from), normalize(to)).replace(winSlash, '/');
+}
+
+export const relativePath: JoinPathFunction = isWindows ? relativeWindowsPath : relative;

package/src/preload.ts

@@ -0,0 +1 @@
+export {};

package/src/stream/blackHoleStream.ts

@@ -0,0 +1,7 @@
+import { Writable } from 'stream';
+
+export class BlackHoleStream extends Writable {
+	_write(_chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void): void {
+		callback();
+	}
+}

package/src/stream/collectingStream.ts

@@ -0,0 +1,85 @@
+import { Writable } from 'stream';
+import { streamPromise } from './streamPromise';
+
+export function streamToBuffer(stream: NodeJS.ReadableStream, raw: false): Promise<string>;
+export function streamToBuffer(stream: NodeJS.ReadableStream, raw: true): Promise<Buffer>;
+export function streamToBuffer(stream: NodeJS.ReadableStream, raw: boolean): Promise<string | Buffer> {
+	if (raw) {
+		return new RawCollectingStream(stream).promise();
+	} else {
+		return new CollectingStream(stream).promise();
+	}
+}
+
+export class RawCollectingStream extends Writable {
+	private buffer?: Buffer = Buffer.allocUnsafe(0);
+	private _promise?: Promise<Buffer>;
+
+	constructor(sourceStream?: NodeJS.ReadableStream) {
+		super();
+		if (sourceStream) {
+			sourceStream.pipe(this);
+			sourceStream.on('error', (e) => {
+				this.emit('error', e);
+			});
+		}
+	}
+
+	_write(chunk: Buffer, _encoding: string, callback: (error?: Error | null) => void): void {
+		this.buffer = Buffer.concat([this.buffer!, chunk]);
+		callback();
+	}
+
+	getOutput() {
+		return this.buffer!;
+	}
+
+	promise(): Promise<Buffer> {
+		return this._promise
+			? this._promise
+			: (this._promise = streamPromise(this).then(() => {
+					const buffer = this.buffer!;
+					delete this.buffer;
+					return buffer;
+			  }));
+	}
+}
+
+export class CollectingStream extends Writable {
+	private buffer? = '';
+	private _promise?: Promise<string>;
+
+	constructor(sourceStream?: NodeJS.ReadableStream) {
+		super();
+		if (sourceStream) {
+			sourceStream.pipe(this);
+			sourceStream.on('error', (e) => {
+				this.emit('error', e);
+			});
+		}
+	}
+
+	_write(chunk: Buffer, encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+		if (!encoding) {
+			encoding = 'utf8';
+		} else if ((encoding as any) === 'buffer' || encoding === 'binary') {
+			encoding = 'utf8';
+		}
+		this.buffer += chunk.toString(encoding);
+		callback();
+	}
+
+	getOutput() {
+		return this.buffer!;
+	}
+
+	promise(): Promise<string> {
+		return this._promise
+			? this._promise
+			: (this._promise = streamPromise(this).then(() => {
+					const buffer = this.buffer!;
+					delete this.buffer;
+					return buffer;
+			  }));
+	}
+}

package/src/stream/disposableStream.ts

@@ -0,0 +1,24 @@
+import { Readable, Writable } from 'stream';
+import { IDisposable } from '@idlebox/common';
+
+export function disposableStream<T extends Writable | Readable>(stream: T): T & IDisposable {
+	if ((stream as any).dispose) {
+		return stream as any;
+	}
+
+	let closed = false;
+	const handleClose = () => {
+		closed = true;
+	};
+
+	stream.once('close', handleClose);
+
+	return Object.assign(stream, {
+		dispose() {
+			if (!closed) {
+				stream.removeListener('close', handleClose);
+				stream.destroy();
+			}
+		},
+	});
+}

package/src/stream/drainStream.ts

@@ -0,0 +1,19 @@
+export function drainStream(
+	stream: NodeJS.ReadableStream,
+	size: number,
+	start: number = 0,
+	extra: number = 0
+): Promise<Buffer> {
+	// buff will alloc as start+size+extra, but return will always start+RealStreamSize+extra
+	const buff = Buffer.allocUnsafe(start + size + extra);
+	let cur = start;
+	return new Promise<Buffer>((resolve, reject) => {
+		stream.once('error', (err) => reject(err));
+		stream.on('data', (data: Buffer) => {
+			cur += data.copy(buff, cur);
+		});
+		stream.on('close', () => {
+			resolve(buff);
+		});
+	});
+}

package/src/stream/loggerStream.ts

@@ -0,0 +1,61 @@
+import { Transform } from 'stream';
+
+export type LogFunction = (message: string, ...args: any[]) => void;
+
+export class LoggerStream extends Transform {
+	private readonly prefix: string;
+
+	constructor(private readonly logFn: LogFunction, prefix?: string) {
+		super();
+		this.prefix = prefix ? prefix + ' %s' : '%s';
+	}
+
+	_transform(chunk: Buffer, encoding: BufferEncoding, callback: Function): void {
+		if ((encoding as any) === 'buffer' || encoding === 'binary') {
+			encoding = undefined as any;
+		}
+		chunk
+			.toString(encoding)
+			.split(/\n/g)
+			.forEach((l) => {
+				if (l.length) {
+					this.logFn(this.prefix, l);
+				}
+			});
+		this.push(chunk, encoding);
+		callback();
+	}
+}
+
+function pad2(s: string) {
+	return s.length === 1 ? '0' + s : s;
+}
+
+export class HexDumpLoggerStream extends Transform {
+	private readonly prefix: string;
+
+	constructor(private readonly logFn: LogFunction, prefix?: string) {
+		super();
+		this.prefix = prefix ? prefix + ' ' : '';
+	}
+
+	_transform(chunk: Buffer, encoding: BufferEncoding, callback: Function): void {
+		let itr = 0;
+		while (chunk.length - itr > 0) {
+			const l = Array.from(chunk.slice(itr, itr + 16))
+				.map((e) => pad2(e.toString(16)).toUpperCase())
+				.join(' ');
+			itr += 16;
+
+			const r = Array.from(chunk.slice(itr, itr + 16))
+				.map((e) => pad2(e.toString(16)).toUpperCase())
+				.join(' ');
+			itr += 16;
+
+			this.logFn(this.prefix + l + '  ' + r);
+		}
+
+		this.push(chunk, encoding);
+		callback();
+	}
+}

package/src/stream/streamPromise.ts

@@ -0,0 +1,23 @@
+/**
+ * wait read/write stream end/close, as promise
+ * reject when stream emit error
+ */
+export function streamPromise(stream: NodeJS.ReadableStream | NodeJS.WritableStream): Promise<void> {
+	if (streamHasEnd(stream)) {
+		return Promise.resolve();
+	} else {
+		return new Promise((resolve, reject) => {
+			stream.once('end', () => resolve());
+			stream.once('finish', () => resolve());
+			stream.once('close', () => resolve());
+			stream.once('error', reject);
+		});
+	}
+}
+
+export function streamHasEnd(S: NodeJS.ReadableStream | NodeJS.WritableStream) {
+	const stream = S as any;
+	return (
+		(stream._writableState && stream._writableState.ended) || (stream._readableState && stream._readableState.ended)
+	);
+}

package/src/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"extends": "local-rig/profiles/default/tsconfig.json",
+	"compilerOptions": {
+		"typeRoots": ["./node_modules/@types", "./node_modules"],
+		"tsBuildInfoFile": "../temp/tsbuildinfo.json",
+		"outDir": "../lib",
+		"declarationDir": "../temp/dts",
+		"rootDir": "./",
+
+		"types": ["node"]
+	},
+	"files": ["preload.ts"],
+	"include": ["**/*.ts"]
+}