@node-core/utils 7.2.0 → 7.2.2

package/node_modules/listr2/node_modules/wrap-ansi/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrap-ansi",
-	"version": "9.0.0",
+	"version": "10.0.1",
 	"description": "Wordwrap a string with ANSI escape codes",
 	"license": "MIT",
 	"repository": "chalk/wrap-ansi",
@@ -16,10 +16,10 @@
 		"default": "./index.js"
 	},
 	"engines": {
-		"node": ">=18"
+		"node": ">=20"
 	},
 	"scripts": {
-		"test": "xo && nyc ava && tsd"
+		"test": "xo && node --test && tsd"
 	},
 	"files": [
 		"index.js",
@@ -53,17 +53,14 @@
 		"text"
 	],
 	"dependencies": {
-		"ansi-styles": "^6.2.1",
-		"string-width": "^7.0.0",
-		"strip-ansi": "^7.1.0"
+		"ansi-styles": "^6.2.3",
+		"string-width": "^8.2.0"
 	},
 	"devDependencies": {
-		"ava": "^5.3.1",
-		"chalk": "^5.3.0",
-		"coveralls": "^3.1.1",
-		"has-ansi": "^5.0.1",
-		"nyc": "^15.1.0",
-		"tsd": "^0.29.0",
-		"xo": "^0.56.0"
+		"chalk": "^5.6.2",
+		"has-ansi": "^6.0.2",
+		"strip-ansi": "^7.1.2",
+		"tsd": "^0.33.0",
+		"xo": "^1.2.3"
 	}
 }

package/node_modules/listr2/node_modules/wrap-ansi/readme.md

@@ -36,6 +36,8 @@ A string with ANSI escape codes, like one styled by [`chalk`](https://github.com
 
 Newline characters will be normalized to `\n`.
 
+Tab characters are expanded to spaces using 8-column tab stops before wrapping.
+
 #### columns
 
 Type: `number`

package/node_modules/listr2/package.json

@@ -1,22 +1,22 @@
 {
   "name": "listr2",
-  "version": "9.0.5",
+  "version": "11.1.0",
   "description": "Terminal task list reborn! Create beautiful CLI interfaces via easy and logical to implement task lists that feel alive and interactive.",
   "license": "MIT",
   "repository": "https://github.com/listr2/listr2",
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
       "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       },
       "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       }
     },
     "./package.json": "./package.json"
@@ -30,21 +30,21 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.13.0"
   },
   "scripts": {
     "build": "tsdown",
     "dev:start": "tsdown --watch",
     "format": "prettier --log-level warn --write src/ tests/ && pnpm run lint --fix",
-    "lint": "eslint --flag v10_config_lookup_from_file src/ tests/",
-    "test": "NO_COLOR=1 TS_NODE_PROJECT=tests/tsconfig.json NODE_OPTIONS='--no-warnings --experimental-specifier-resolution=node --experimental-vm-modules' jest --config tests/jest.config.ts",
+    "lint": "eslint src/ tests/",
+    "test": "NODE_OPTIONS='--no-warnings --experimental-vm-modules' jest --config tests/jest.config.ts",
     "test:cov": "pnpm run test --coverage",
-    "test:dev": "NODE_OPTIONS='--no-warnings --experimental-specifier-resolution=node --experimental-vm-modules --inspect=0.0.0.0:9229' pnpm run test --verbose --watchAll"
+    "test:dev": "NODE_OPTIONS='--no-warnings --experimental-vm-modules --inspect=0.0.0.0:9229' pnpm run test --verbose --watchAll"
   },
   "lint-staged": {
     "{src,tests}/**/*.{ts,js,tsx,jsx,spec.ts}": [
       "prettier --log-level warn --write",
-      "eslint --flag v10_config_lookup_from_file --fix"
+      "eslint --fix"
     ],
     "*.{json,md}": [
       "prettier --log-level warn --write"
@@ -70,12 +70,9 @@
     "idle"
   ],
   "dependencies": {
-    "cli-truncate": "^5.0.0",
-    "colorette": "^2.0.20",
-    "eventemitter3": "^5.0.1",
-    "log-update": "^6.1.0",
-    "rfdc": "^1.4.1",
-    "wrap-ansi": "^9.0.0"
+    "cli-truncate": "^6.1.1",
+    "log-update": "^8.0.0",
+    "wrap-ansi": "^10.0.1"
   },
   "devDependencies": {
     "@types/zen-observable": "^0.8.7",

package/node_modules/log-update/index.d.ts

@@ -13,6 +13,44 @@ export type Options = {
 	```
 	*/
 	readonly showCursor?: boolean;
+
+	/**
+	The width to use when the stream doesn't provide a `columns` property. Defaults to `80`.
+
+	This is useful when the output is piped, redirected, or in environments where the terminal size is not available.
+
+	@default 80
+
+	@example
+	```
+	import {createLogUpdate} from 'log-update';
+
+	// Use custom width when the stream doesn't provide columns
+	const log = createLogUpdate(process.stdout, {
+		defaultWidth: 120
+	});
+	```
+	*/
+	readonly defaultWidth?: number;
+
+	/**
+	The height to use when the stream doesn't provide a `rows` property. Defaults to `24`.
+
+	This is useful when the output is piped, redirected, or in environments where the terminal size is not available.
+
+	@default 24
+
+	@example
+	```
+	import {createLogUpdate} from 'log-update';
+
+	// Use custom height when the stream doesn't provide rows
+	const log = createLogUpdate(process.stdout, {
+		defaultHeight: 50
+	});
+	```
+	*/
+	readonly defaultHeight?: number;
 };
 
 type LogUpdateMethods = {
@@ -25,6 +63,31 @@ type LogUpdateMethods = {
 	Persist the logged output. Useful if you want to start a new log session below the current one.
 	*/
 	done(): void;
+
+	/**
+	Write text to the terminal that persists in the scrollback buffer.
+
+	Unlike the main log function which updates in place, this method writes output that remains in the terminal history, similar to `console.log()`. This is useful for displaying permanent results, status messages, or logs that users need to scroll back and review.
+
+	@param text - The text to persist to the terminal.
+
+	@example
+	```
+	import logUpdate from 'log-update';
+
+	// Update in place
+	logUpdate('Processing...');
+	logUpdate('Still processing...');
+
+	// Write permanent output
+	logUpdate.persist('✓ Task complete');
+	logUpdate.persist('✓ All tests passed');
+
+	// Continue with updates
+	logUpdate('Starting next task...');
+	```
+	*/
+	persist(...text: string[]): void;
 };
 
 /**
@@ -100,5 +163,5 @@ const log = createLogUpdate(process.stdout);
 */
 export function createLogUpdate(
 	stream: NodeJS.WritableStream,
-	options?: Options
+	options?: Options,
 ): typeof logUpdate;

package/node_modules/log-update/index.js

@@ -4,26 +4,200 @@ import cliCursor from 'cli-cursor';
 import wrapAnsi from 'wrap-ansi';
 import sliceAnsi from 'slice-ansi';
 import stripAnsi from 'strip-ansi';
+import stringWidth from 'string-width';
 
-const defaultTerminalHeight = 24;
+const getWidth = (stream, defaultWidth) => stream.columns ?? defaultWidth ?? 80;
+const SYNCHRONIZED_OUTPUT_ENABLE = '\u001B[?2026h';
+const SYNCHRONIZED_OUTPUT_DISABLE = '\u001B[?2026l';
+const countLines = text => text.split('\n').length;
+const getFrameHeight = text => {
+	const unstyledText = stripAnsi(text);
+	return unstyledText === '' ? 0 : unstyledText.split('\n').length;
+};
+
+const fitToTerminalHeight = (stream, wrappedText, defaultHeight) => {
+	const terminalHeight = stream.rows ?? defaultHeight ?? 24;
 
-const getWidth = ({columns = 80}) => columns;
+	// Zero height: intentionally produce no output
+	if (terminalHeight === 0) {
+		return {text: '', wasClipped: wrappedText !== ''};
+	}
 
-const fitToTerminalHeight = (stream, text) => {
-	const terminalHeight = stream.rows ?? defaultTerminalHeight;
-	const lines = text.split('\n');
+	const unstyled = stripAnsi(wrappedText);
+	const lines = unstyled.split('\n');
 	const toRemove = Math.max(0, lines.length - terminalHeight);
-	return toRemove ? sliceAnsi(text, stripAnsi(lines.slice(0, toRemove).join('\n')).length + 1) : text;
+	if (toRemove === 0) {
+		return {text: wrappedText, wasClipped: false};
+	}
+
+	// Compute visible-column cut to match sliceAnsi's position tracking.
+	// sliceAnsi counts each \n as 1 column, but stringWidth returns 0 for \n.
+	let cut = 0;
+	for (let index = 0; index < toRemove; index++) {
+		cut += stringWidth(lines[index]) + 1;
+	}
+
+	let clippedText = sliceAnsi(wrappedText, cut);
+	let clippedLineCount = getFrameHeight(clippedText);
+
+	// Normalize the estimated cut so it matches sliceAnsi's width model.
+	while (clippedLineCount > terminalHeight) {
+		cut++;
+		clippedText = sliceAnsi(wrappedText, cut);
+		clippedLineCount = getFrameHeight(clippedText);
+	}
+
+	while (cut > 0) {
+		const previousClippedText = sliceAnsi(wrappedText, cut - 1);
+		if (getFrameHeight(previousClippedText) > terminalHeight) {
+			break;
+		}
+
+		cut--;
+		clippedText = previousClippedText;
+	}
+
+	return {text: clippedText, wasClipped: cut > 0};
 };
 
-export function createLogUpdate(stream, {showCursor = false} = {}) {
+/**
+Find common prefix and suffix between frames.
+*/
+const diffFrames = (previousLines, nextLines) => {
+	let start = 0;
+	for (; start < previousLines.length && start < nextLines.length; start++) {
+		if (previousLines[start] !== nextLines[start]) {
+			break;
+		}
+	}
+
+	let endPrevious = previousLines.length - 1;
+	let endNext = nextLines.length - 1;
+	while (endPrevious >= start && endNext >= start && previousLines[endPrevious] === nextLines[endNext]) {
+		endPrevious--;
+		endNext--;
+	}
+
+	return {start, endPrevious, endNext};
+};
+
+/**
+Build a single escape sequence patch to transform previous -> next.
+*/
+const buildPatch = ({
+	prevCount,
+	start,
+	endPrevious,
+	endNext,
+	nextLines,
+	nextWrappedEndsWithNewline,
+}) => {
+	let sequence = '';
+
+	// Move cursor from the trailing blank line to the first changed line.
+	const cursorLine = prevCount - 1;
+	const cursorLineDelta = start - cursorLine;
+	if (cursorLineDelta > 0) {
+		sequence += ansiEscapes.cursorDown(cursorLineDelta);
+	}
+
+	if (cursorLineDelta < 0) {
+		sequence += ansiEscapes.cursorUp(-cursorLineDelta);
+	}
+
+	sequence += ansiEscapes.cursorLeft;
+
+	// Clear the changed block from the previous frame.
+	const linesToClear = Math.max(0, endPrevious - start + 1);
+	for (let index = 0; index < linesToClear; index++) {
+		sequence += ansiEscapes.eraseLine;
+
+		if (index < linesToClear - 1) {
+			sequence += ansiEscapes.cursorDown();
+		}
+	}
+
+	if (linesToClear > 1) {
+		sequence += ansiEscapes.cursorUp(linesToClear - 1);
+	}
+
+	sequence += ansiEscapes.cursorLeft;
+
+	// Write the new changed block.
+	const wroteSlice = nextLines.slice(start, endNext + 1);
+	let writtenLineBreakCount = 0;
+	if (wroteSlice.length > 0) {
+		const chunk = wroteSlice.join('\n');
+		const shouldWriteTrailingNewline = nextWrappedEndsWithNewline
+			&& endNext < nextLines.length - 1
+			&& !chunk.endsWith('\n');
+
+		sequence += chunk;
+		writtenLineBreakCount = countLines(chunk) - 1;
+
+		// Ensure we do not leave trailing characters on the last written line
+		sequence += ansiEscapes.eraseEndLine;
+
+		if (shouldWriteTrailingNewline) {
+			sequence += '\n';
+			writtenLineBreakCount++;
+		}
+	}
+
+	// Reposition cursor to the final trailing blank line for the next call
+	const currentLine = start + writtenLineBreakCount;
+	const finalLine = nextLines.length - 1;
+	const lineDelta = finalLine - currentLine;
+	if (lineDelta > 0) {
+		sequence += ansiEscapes.cursorDown(lineDelta);
+	}
+
+	if (lineDelta < 0) {
+		sequence += ansiEscapes.cursorUp(-lineDelta);
+	}
+
+	return sequence;
+};
+
+export function createLogUpdate(stream, {showCursor = false, defaultWidth, defaultHeight} = {}) {
 	let previousLineCount = 0;
-	let previousWidth = getWidth(stream);
+	let previousWidth = getWidth(stream, defaultWidth);
 	let previousOutput = '';
+	const useSynchronizedOutput = stream.isTTY === true;
+
+	const write = output => {
+		if (output === '') {
+			return;
+		}
+
+		if (useSynchronizedOutput) {
+			stream.write(SYNCHRONIZED_OUTPUT_ENABLE + output + SYNCHRONIZED_OUTPUT_DISABLE);
+			return;
+		}
+
+		stream.write(output);
+	};
+
+	/**
+	Normalize, wrap, and height-clip into a concrete frame.
+
+	Returns both the wrapped string and an array of lines, where an empty frame (for `rows === 0`) is represented by `lines.length === 0`.
+	*/
+	const computeFrame = (text, width, clipToHeight = true) => {
+		// Preserve user's trailing newlines, ensure at least one
+		const textString = String(text);
+		const raw = textString.endsWith('\n') ? textString : `${textString}\n`;
+		const wrapped = wrapAnsi(raw, width, {trim: false, hard: true, wordWrap: false});
+		const {text: frameText, wasClipped} = clipToHeight ? fitToTerminalHeight(stream, wrapped, defaultHeight) : {text: wrapped, wasClipped: false};
+
+		// Derive lines. Special-case empty string to represent 0 lines.
+		const lines = frameText === '' ? [] : frameText.split('\n');
+		return {wrapped: frameText, lines, wasClipped};
+	};
 
 	const reset = () => {
 		previousOutput = '';
-		previousWidth = getWidth(stream);
+		previousWidth = getWidth(stream, defaultWidth);
 		previousLineCount = 0;
 	};
 
@@ -32,23 +206,89 @@ export function createLogUpdate(stream, {showCursor = false} = {}) {
 			cliCursor.hide();
 		}
 
-		let output = fitToTerminalHeight(stream, arguments_.join(' ') + '\n');
-		const width = getWidth(stream);
+		const width = getWidth(stream, defaultWidth);
+		const {wrapped, lines, wasClipped} = computeFrame(arguments_.join(' '), width);
+
+		// If nothing would be written (rows === 0 after clipping), erase previous output and update state.
+		if (lines.length === 0) {
+			if (previousLineCount > 0) {
+				write(ansiEscapes.eraseLines(previousLineCount));
+			}
 
-		if (output === previousOutput && previousWidth === width) {
+			previousOutput = wrapped;
+			previousWidth = width;
+			previousLineCount = 0;
 			return;
 		}
 
-		previousOutput = output;
-		previousWidth = width;
-		output = wrapAnsi(output, width, {trim: false, hard: true, wordWrap: false});
+		// Fast no-op path
+		if (wrapped === previousOutput && previousWidth === width) {
+			return;
+		}
+
+		// First frame: just write
+		if (previousLineCount === 0) {
+			write(wrapped);
+
+			previousOutput = wrapped;
+			previousWidth = width;
+			previousLineCount = lines.length;
+			return;
+		}
+
+		// Width changed or content clipped: full erase + write (diffing is invalid across wraps/clips)
+		if (previousWidth !== width || wasClipped) {
+			write(ansiEscapes.eraseLines(previousLineCount) + wrapped);
+
+			previousOutput = wrapped;
+			previousWidth = width;
+			previousLineCount = lines.length;
+			return;
+		}
 
-		stream.write(ansiEscapes.eraseLines(previousLineCount) + output);
-		previousLineCount = output.split('\n').length;
+		const previousLines = previousOutput === '' ? [] : previousOutput.split('\n');
+		let {start, endPrevious, endNext} = diffFrames(previousLines, lines);
+
+		// When lines are inserted or removed, the suffix shifts position.
+		// Include it in the rewrite so it renders at the correct row.
+		if (previousLines.length !== lines.length) {
+			endPrevious = previousLines.length - 1;
+			endNext = lines.length - 1;
+		}
+
+		// If nothing changed (including trailing blank logic), bail
+		if (start === lines.length && previousLineCount === lines.length) {
+			return;
+		}
+
+		// If common prefix length is zero, simpler and correct to full erase.
+		if (start === 0) {
+			write(ansiEscapes.eraseLines(previousLineCount) + wrapped);
+
+			previousOutput = wrapped;
+			previousWidth = width;
+			previousLineCount = lines.length;
+			return;
+		}
+
+		const patch = buildPatch({
+			prevCount: previousLineCount,
+			start,
+			endPrevious,
+			endNext,
+			nextLines: lines,
+			nextWrappedEndsWithNewline: wrapped.endsWith('\n'),
+		});
+
+		write(patch);
+
+		previousOutput = wrapped;
+		previousWidth = width;
+		previousLineCount = lines.length;
 	};
 
 	render.clear = () => {
-		stream.write(ansiEscapes.eraseLines(previousLineCount));
+		write(ansiEscapes.eraseLines(previousLineCount));
 		reset();
 	};
 
@@ -59,10 +299,20 @@ export function createLogUpdate(stream, {showCursor = false} = {}) {
 		}
 	};
 
+	render.persist = (...arguments_) => {
+		const erasePrevious = previousLineCount > 0 ? ansiEscapes.eraseLines(previousLineCount) : '';
+		const width = getWidth(stream, defaultWidth);
+		const {wrapped: wrappedText} = computeFrame(arguments_.join(' '), width, false);
+		write(erasePrevious + wrappedText);
+
+		reset();
+	};
+
 	return render;
 }
 
 const logUpdate = createLogUpdate(process.stdout);
+
 export default logUpdate;
 
 export const logUpdateStderr = createLogUpdate(process.stderr);

package/node_modules/log-update/node_modules/string-width/index.d.ts

@@ -0,0 +1,39 @@
+export type Options = {
+	/**
+	Count [ambiguous width characters](https://www.unicode.org/reports/tr11/#Ambiguous) as having narrow width (count of 1) instead of wide width (count of 2).
+
+	@default true
+
+	> Ambiguous characters behave like wide or narrow characters depending on the context (language tag, script identification, associated font, source of data, or explicit markup; all can provide the context). __If the context cannot be established reliably, they should be treated as narrow characters by default.__
+	> - http://www.unicode.org/reports/tr11/
+	*/
+	readonly ambiguousIsNarrow?: boolean;
+
+	/**
+	Whether [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) should be counted.
+
+	@default false
+	*/
+	readonly countAnsiEscapeCodes?: boolean;
+};
+
+/**
+Get the visual width of a string - the number of columns required to display it.
+
+Some Unicode characters are [fullwidth](https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms) and use double the normal width. [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) are stripped and doesn't affect the width.
+
+@example
+```
+import stringWidth from 'string-width';
+
+stringWidth('a');
+//=> 1
+
+stringWidth('古');
+//=> 2
+
+stringWidth('\u001B[1m古\u001B[22m');
+//=> 2
+```
+*/
+export default function stringWidth(string: string, options?: Options): number;