@idlebox/node 1.4.3 → 1.4.4

package/src/error/nodejs-error-code.generator.ts

@@ -1,7 +1,7 @@
-import * as assert from 'assert';
-import { existsSync } from 'fs';
-import { readFile, writeFile } from 'fs/promises';
-import { resolve } from 'path';
+import * as assert from 'node:assert';
+import { existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import type API_JSON from './cache.generated.json';
 
 const temp = resolve(__dirname, 'cache.generated.json');
@@ -30,9 +30,9 @@ export async function generate() {
 				return section.modules!;
 			}
 		}
-		throw new Error('missing section: ' + id);
+		throw new Error(`missing section: ${id}`);
 	}
-	content += `export enum NodeError {\n`;
+	content += 'export enum NodeError {\n';
 	for (const err of get_id('node.js_error_codes')) {
 		content += line(err.textRaw, err.desc, false);
 	}
@@ -42,7 +42,7 @@ export async function generate() {
 	}
 	content += '}\n\n';
 
-	content += `export enum OpenSSLError {\n`;
+	content += 'export enum OpenSSLError {\n';
 	for (const section of get_id('openssl_error_codes')) {
 		for (const err of (section as any).modules) {
 			content += line(err.textRaw, err.desc, false);

package/src/error/types.ts

@@ -15,7 +15,7 @@ export interface OpenSSLException extends Error {
  * ERR_MODULE_NOT_FOUND: import() not found
  */
 export function isModuleResolutionError(
-	ex: unknown,
+	ex: unknown
 ): ex is NodeException<NodeError.MODULE_NOT_FOUND | NodeError.ERR_MODULE_NOT_FOUND> {
 	return isNodeError(ex) && (ex.code === NodeError.MODULE_NOT_FOUND || ex.code === NodeError.ERR_MODULE_NOT_FOUND);
 }

package/src/events/dumpEventEmitter.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'events';
+import type { EventEmitter } from 'node:events';
 
 export function dumpEventEmitterEmit(ev: EventEmitter) {
 	const real = ev.emit;

package/src/fs/commandExists.ts

@@ -1,5 +1,5 @@
 import { isWindows } from '@idlebox/common';
-import { access, constants, accessSync } from 'fs';
+import { access, constants, accessSync } from 'node:fs';
 import { PathEnvironment } from '../environment/pathEnvironment.js';
 
 const windowsExecExtensions = ['.exe', '.bat', '.cmd', '.com', '.ps1'];
@@ -14,9 +14,8 @@ function exts(alterExt?: string[]) {
 	}
 	if (isWindows) {
 		return windowsExecExtensions;
-	} else {
-		return [''];
 	}
+	return [''];
 }
 
 export async function commandInPath(cmd: string, alterExt?: string[]): Promise<string | undefined> {

package/src/fs/emptyDir.ts

@@ -1,5 +1,5 @@
-import { mkdir, readdir, rm } from 'fs/promises';
-import { resolve } from 'path';
+import { mkdir, readdir, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
 
 /**
  * delete all content in a dir,

package/src/fs/exists.ts

@@ -1,7 +1,7 @@
-import { ObjectEncodingOptions } from 'fs';
-import { access, readFile } from 'fs/promises';
+import type { ObjectEncodingOptions } from 'node:fs';
+import { access, readFile } from 'node:fs/promises';
 import { isNotExistsError } from '../error/types.js';
-export { existsSync } from 'fs';
+export { existsSync } from 'node:fs';
 
 export async function exists(path: string) {
 	try {
@@ -22,9 +22,8 @@ async function _readFileIfExists(file: string, encoding?: NodeJS.BufferEncoding
 		if (isNotExistsError(e)) {
 			if (typeof encoding === 'string' || typeof encoding?.encoding === 'string') {
 				return '';
-			} else {
-				return Buffer.allocUnsafe(0);
 			}
+			return Buffer.allocUnsafe(0);
 		}
 		throw e;
 	}

package/src/fs/tempFolder.ts

@@ -1,14 +1,14 @@
-import { mkdirSync, readdirSync, rmdirSync, statSync, unlinkSync } from 'fs';
-import { resolve } from 'path';
-import { IDisposable } from '@idlebox/common';
+import { mkdirSync, readdirSync, rmdirSync, statSync, unlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { IDisposable } from '@idlebox/common';
 import { existsSync } from './exists.js';
 
-let registered = false;
+const registered = false;
 const tempFolders = new Set<string>();
 
 export function createTempFolder(fullPath: string): IDisposable {
 	if (existsSync(fullPath)) {
-		throw new Error('temp folder already exists: ' + fullPath);
+		throw new Error(`temp folder already exists: ${fullPath}`);
 	}
 	if (!registered) {
 		process.on('beforeExit', onBeforeExit);

package/src/fs/weiteChanged.ts

@@ -1,5 +1,5 @@
-import { readFile as readFileAsync, readFileSync, writeFile as writeFileAsync, writeFileSync } from 'fs';
-import { promisify } from 'util';
+import { readFile as readFileAsync, readFileSync, writeFile as writeFileAsync, writeFileSync } from 'node:fs';
+import { promisify } from 'node:util';
 import { exists, existsSync } from './exists.js';
 
 const readFile = promisify(readFileAsync);

package/src/log/terminal.ts

@@ -1,4 +1,4 @@
-import { WrappedConsole, WrappedConsoleOptions } from '@idlebox/common';
+import { WrappedConsole, type WrappedConsoleOptions } from '@idlebox/common';
 
 interface TerminalConsoleOptions {
 	color?: boolean | Partial<typeof colorMap>;

package/src/path-resolve/findPackageRoot.ts

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

package/src/path-resolve/getAllUp.ts

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

package/src/path-resolve/lrelative.ts

@@ -1,11 +1,11 @@
-import { isAbsolute } from 'path';
+import { isAbsolute } from 'node:path';
 
 export function lrelative(from: string, to: string) {
 	if (!isAbsolute(from)) {
-		throw new Error('lrelative: from is not absolute: ' + from);
+		throw new Error(`lrelative: from is not absolute: ${from}`);
 	}
 	if (!isAbsolute(to)) {
-		throw new Error('lrelative: to is not absolute: ' + 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);

package/src/path-resolve/nodeResolvePathArray.ts

@@ -1,4 +1,4 @@
-import { dirname, resolve } from 'path';
+import { dirname, resolve } from 'node:path';
 
 export function nodeResolvePathArray(from: string, file = 'node_modules') {
 	const ret: string[] = [];

package/src/path-resolve/resolvePath.ts

@@ -1,16 +1,12 @@
 import { isWindows } from '@idlebox/common';
-import { tmpdir } from 'os';
-import { normalize, relative, resolve } from 'path';
+import { tmpdir } from 'node:os';
+import { normalize, relative, resolve } from 'node:path';
 
 const winSlash = /\\/g;
 
-export interface ResolvePathFunction {
-	(...pathSegments: string[]): string;
-}
+export type ResolvePathFunction = (...pathSegments: string[]) => string;
 
-export interface JoinPathFunction {
-	(from: string, to: string): string;
-}
+export type JoinPathFunction = (from: string, to: string) => string;
 
 export const resolvePath: ResolvePathFunction = isWindows ? resolveWindowsPath : resolve;
 
@@ -18,9 +14,7 @@ function resolveWindowsPath(...pathSegments: string[]): string {
 	return resolve(...pathSegments).replace(winSlash, '/');
 }
 
-export interface NormalizePathFunction {
-	(path: string): string;
-}
+export type NormalizePathFunction = (path: string) => string;
 
 export const normalizePath: NormalizePathFunction = isWindows ? normalizeWindowsPath : normalize;
 
@@ -31,9 +25,8 @@ function normalizeWindowsPath(path: string): string {
 export function osTempDir(name?: string) {
 	if (name) {
 		return resolvePath(tmpdir(), name);
-	} else {
-		return resolvePath(tmpdir());
 	}
+	return resolvePath(tmpdir());
 }
 
 function relativeWindowsPath(from: string, to: string) {

package/src/stream/blackHoleStream.ts

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

package/src/stream/collectingStream.ts

@@ -1,14 +1,13 @@
-import { Writable } from "stream";
-import { streamPromise } from "./streamPromise.js";
+import { Writable } from 'node:stream';
+import { streamPromise } from './streamPromise.js';
 
 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();
 	}
+	return new CollectingStream(stream).promise();
 }
 
 export class RawCollectingStream extends Writable {
@@ -19,8 +18,8 @@ export class RawCollectingStream extends Writable {
 		super();
 		if (sourceStream) {
 			sourceStream.pipe(this);
-			sourceStream.on("error", (e) => {
-				this.emit("error", e);
+			sourceStream.on('error', (e) => {
+				this.emit('error', e);
 			});
 		}
 	}
@@ -39,31 +38,31 @@ export class RawCollectingStream extends Writable {
 			? this._promise
 			: (this._promise = streamPromise(this).then(() => {
 					const buffer = this.buffer!;
-					delete this.buffer;
+					this.buffer = undefined;
 					return buffer;
 				}));
 	}
 }
 
 export class CollectingStream extends Writable {
-	private buffer? = "";
+	private buffer? = '';
 	private _promise?: Promise<string>;
 
 	constructor(sourceStream?: NodeJS.ReadableStream) {
 		super();
 		if (sourceStream) {
 			sourceStream.pipe(this);
-			sourceStream.on("error", (e) => {
-				this.emit("error", e);
+			sourceStream.on('error', (e) => {
+				this.emit('error', e);
 			});
 		}
 	}
 
 	override _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";
+			encoding = 'utf8';
+		} else if ((encoding as any) === 'buffer' || encoding === 'binary') {
+			encoding = 'utf8';
 		}
 		this.buffer += chunk.toString(encoding);
 		callback();
@@ -78,7 +77,7 @@ export class CollectingStream extends Writable {
 			? this._promise
 			: (this._promise = streamPromise(this).then(() => {
 					const buffer = this.buffer!;
-					delete this.buffer;
+					this.buffer = undefined;
 					return buffer;
 				}));
 	}

package/src/stream/disposableStream.ts

@@ -1,5 +1,5 @@
-import { Readable, Writable } from 'stream';
-import { IDisposable } from '@idlebox/common';
+import type { Readable, Writable } from 'node:stream';
+import type { IDisposable } from '@idlebox/common';
 
 export function disposableStream<T extends Writable | Readable>(stream: T): T & IDisposable {
 	if ((stream as any).dispose) {

package/src/stream/drainStream.ts

@@ -1,9 +1,4 @@
-export function drainStream(
-	stream: NodeJS.ReadableStream,
-	size: number,
-	start: number = 0,
-	extra: number = 0
-): Promise<Buffer> {
+export function drainStream(stream: NodeJS.ReadableStream, size: number, start = 0, extra = 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;

package/src/stream/loggerStream.ts

@@ -1,13 +1,16 @@
-import { Transform } from 'stream';
+import { Transform } from 'node: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) {
+	constructor(
+		private readonly logFn: LogFunction,
+		prefix?: string
+	) {
 		super();
-		this.prefix = prefix ? prefix + ' %s' : '%s';
+		this.prefix = prefix ? `${prefix} %s` : '%s';
 	}
 
 	override _transform(chunk: Buffer, encoding: BufferEncoding, callback: Function): void {
@@ -28,15 +31,18 @@ export class LoggerStream extends Transform {
 }
 
 function pad2(s: string) {
-	return s.length === 1 ? '0' + s : s;
+	return s.length === 1 ? `0${s}` : s;
 }
 
 export class HexDumpLoggerStream extends Transform {
 	private readonly prefix: string;
 
-	constructor(private readonly logFn: LogFunction, prefix?: string) {
+	constructor(
+		private readonly logFn: LogFunction,
+		prefix?: string
+	) {
 		super();
-		this.prefix = prefix ? prefix + ' ' : '';
+		this.prefix = prefix ? `${prefix} ` : '';
 	}
 
 	override _transform(chunk: Buffer, encoding: BufferEncoding, callback: Function): void {
@@ -52,7 +58,7 @@ export class HexDumpLoggerStream extends Transform {
 				.join(' ');
 			itr += 16;
 
-			this.logFn(this.prefix + l + '  ' + r);
+			this.logFn(`${this.prefix + l}  ${r}`);
 		}
 
 		this.push(chunk, encoding);

package/src/stream/streamPromise.ts

@@ -5,20 +5,17 @@
 export function streamPromise(stream: NodeJS.ReadableStream | NodeJS.WritableStream): Promise<void> {
 	if (streamHasEnd(stream)) {
 		return Promise.resolve();
-	} else {
-		return new Promise((resolve, reject) => {
-			const r = stream as NodeJS.EventEmitter;
-			r.once('end', () => resolve());
-			r.once('finish', () => resolve());
-			r.once('close', () => resolve());
-			r.once('error', reject);
-		});
 	}
+	return new Promise((resolve, reject) => {
+		const r = stream as NodeJS.EventEmitter;
+		r.once('end', () => resolve());
+		r.once('finish', () => resolve());
+		r.once('close', () => resolve());
+		r.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)
-	);
+	return stream._writableState?.ended || stream._readableState?.ended;
 }

package/src/tsconfig.json

@@ -4,9 +4,9 @@
 		"typeRoots": ["../node_modules/@types", "../node_modules"],
 		"outDir": "../lib/esm",
 		"rootDir": "./",
-		"types": ["node"]
+		"types": ["node"],
 	},
 	// "files": ["preload.ts"],
 	// "include": ["**/*.ts"],
-	"exclude": ["**/*.generator.ts"]
+	"exclude": ["**/*.generator.ts"],
 }