Refactor WSL implementation

Author: sindresorhus

index.js

@@ -77,7 +77,7 @@ async function platformSpecificImplementation() {
 		}
 
 		case 'linux': {
-			const {default: isWsl} = await import('is-wsl');
+			const {isWsl} = await import('wsl-utils');
 			if (isWsl) {
 				return import('./lib/wsl.js');
 			}

lib/wsl.js

@@ -1,131 +1,51 @@
 import {Buffer} from 'node:buffer';
-import {execFile} from 'node:child_process';
-import {promisify} from 'node:util';
 import chunkify from '@sindresorhus/chunkify';
-
-const execFilePromise = promisify(execFile);
-
-// TODO: I plan to move these to wsl-extras at some point.
-
-/**
-Convert WSL paths to Windows paths using `wslpath`.
-
-@param {string[]} paths - Array of WSL/Linux paths..
-@returns {Promise<string[]>} Array of Windows paths.
-*/
-async function wslPathToWindows(paths) {
-	try {
-		const {stdout} = await execFilePromise('wslpath', ['-w', '-a', ...paths]);
-		return stdout.split(/\r?\n/).filter(Boolean);
-	} catch (error) {
-		error.message = `Failed to convert paths with "wslpath": ${error.message}`;
-		throw error;
-	}
-}
-
-/**
-Check if a Windows path is a UNC path (\\wsl$\...).
-
-@param {string} path - Windows path to check.
-@returns {boolean} True if path is UNC.
-*/
-function isUncPath(path) {
-	return /^\\\\/u.test(path);
-}
-
-/**
-Partition paths into local Windows paths and UNC WSL paths.
-
-@param {string[]} windowsPaths - Array of Windows paths.
-@param {string[]} originalPaths - Corresponding original Linux paths.g
-@returns {{localPaths: string[], uncPaths: string[]}} Partitioned paths.
-*/
-function partitionWindowsPaths(windowsPaths, originalPaths) {
-	const localPaths = [];
-	const uncPaths = [];
-
-	for (const [index, windowsPath] of windowsPaths.entries()) {
-		if (isUncPath(windowsPath)) {
-			uncPaths.push(originalPaths[index]);
-		} else {
-			localPaths.push(windowsPath);
-		}
-	}
-
-	return {localPaths, uncPaths};
-}
-
-/**
-Execute a PowerShell script using -EncodedCommand for safety.
-
-@param {string} script - PowerShell script to execute.
-@returns {Promise<{stdout: string, stderr: string}>} Execution result.
-*/
-async function executePowerShellScript(script) {
-	const encodedCommand = Buffer.from(script, 'utf16le').toString('base64');
-	return execFilePromise('powershell.exe', [
-		'-NoProfile',
-		'-NonInteractive',
-		'-ExecutionPolicy',
-		'Bypass',
-		'-EncodedCommand',
-		encodedCommand,
-	]);
-}
-
-/**
-Check if WSL interop is enabled by testing PowerShell availability.
-
-@returns {Promise<boolean>} True if interop is enabled
-*/
-async function isWslInteropEnabled() {
-	try {
-		await execFilePromise('powershell.exe', [
-			'-NoProfile',
-			'-NonInteractive',
-			'-Command',
-			'$PSVersionTable.PSVersion',
-		]);
-		return true;
-	} catch (error) {
-		if (error.code === 'ENOENT') {
-			return false;
-		}
-
-		throw error;
-	}
-}
+import {canAccessPowerShell, convertWslPathToWindows, isUncPath} from 'wsl-utils';
+import {executePowerShell} from 'powershell-utils';
 
 /**
 WSL implementation:
-- Converts WSL paths to Windows paths with `wslpath -w -a`
+- Converts WSL paths to Windows paths
 - For Windows-local paths (e.g., `C:\…`), uses PowerShell to send to Recycle Bin
 - For UNC `\\wsl$\…` paths (Linux filesystem), falls back to the Linux trash implementation
 - Processes inputs in chunks to avoid command-line length limits
 - Uses `-LiteralPath` to avoid wildcard expansion
 - Uses `-EncodedCommand` with UTF-16LE to avoid quoting/length issues
 */
 export default async function wsl(paths) {
-	// Check interop availability once
-	const interopEnabled = await isWslInteropEnabled();
+	const interopEnabled = await canAccessPowerShell();
 	if (!interopEnabled) {
 		const error = new Error('WSL interop is disabled. Enable it or use Linux trash implementation.');
 		error.code = 'WSL_INTEROP_DISABLED';
 		throw error;
 	}
 
+	let linuxTrash;
+
 	for (const chunk of chunkify(paths, 400)) {
-		// Resolve to Windows paths
 		// eslint-disable-next-line no-await-in-loop
-		const windowsPathsRaw = await wslPathToWindows(chunk);
+		const windowsPaths = await convertWslPathToWindows(chunk);
 
 		// Partition into local drive paths and UNC \\wsl$ paths
-		const {localPaths: localWindowsPaths, uncPaths: uncLinuxPaths} = partitionWindowsPaths(windowsPathsRaw, chunk);
+		const localWindowsPaths = [];
+		const uncLinuxPaths = [];
+
+		for (const [index, windowsPath] of windowsPaths.entries()) {
+			if (isUncPath(windowsPath)) {
+				uncLinuxPaths.push(chunk[index]);
+			} else {
+				localWindowsPaths.push(windowsPath);
+			}
+		}
 
 		// Fallback to Linux trash for files that live on the Linux filesystem (UNC \\wsl$)
 		if (uncLinuxPaths.length > 0) {
-			// eslint-disable-next-line no-await-in-loop
-			const {default: linuxTrash} = await import('./linux.js');
+			if (!linuxTrash) {
+				// eslint-disable-next-line no-await-in-loop
+				const {default: linuxTrashImport} = await import('./linux.js');
+				linuxTrash = linuxTrashImport;
+			}
+
 			// eslint-disable-next-line no-await-in-loop
 			await linuxTrash(uncLinuxPaths);
 		}
@@ -157,8 +77,7 @@ foreach ($p in $paths) {
 }
 `.trim();
 
-		// Execute PowerShell
 		// eslint-disable-next-line no-await-in-loop
-		await executePowerShellScript(psScript);
+		await executePowerShell(psScript);
 	}
 }

package.json

@@ -50,9 +50,10 @@
 		"chunkify": "^5.0.0",
 		"globby": "^14.1.0",
 		"is-path-inside": "^4.0.0",
-		"is-wsl": "^3.1.0",
 		"move-file": "^3.1.0",
 		"p-map": "^7.0.3",
+		"powershell-utils": "^0.2.0",
+		"wsl-utils": "^0.4.0",
 		"xdg-trashdir": "^3.1.0"
 	},
 	"devDependencies": {