check-disk-space 3.4.0 → 4.0.0

package/README.md

@@ -1,53 +1,113 @@
-# Check disk space
+<h1 align="center">Check disk space</h1>
 
-[![Continue Integration](https://img.shields.io/github/workflow/status/Alex-D/check-disk-space/Continuous%20Integration?style=for-the-badge)](https://github.com/Alex-D/check-disk-space/actions/workflows/ci.yml)
-[![check-disk-space on npm](https://img.shields.io/npm/v/check-disk-space?style=for-the-badge)](https://www.npmjs.com/package/check-disk-space)
-[![License MIT](https://img.shields.io/github/license/Alex-D/check-disk-space.svg?style=for-the-badge)](LICENSE)
+<p align="center">
+    <a href="https://github.com/Alex-D/check-disk-space/actions/workflows/test.yml"><img src="https://img.shields.io/github/actions/workflow/status/Alex-D/check-disk-space/test.yml?style=for-the-badge" alt="Minimized & gzipped size ~1kb" /></a>
+    <a href="https://bundlejs.com/?q=check-disk-space"><img src="https://img.shields.io/bundlejs/size/check-disk-space.svg?style=for-the-badge" alt="Minimized & gzipped size ~1kb" /></a>
+    <a href="https://npmx.dev/package/check-disk-space"><img src="https://img.shields.io/npm/dm/check-disk-space.svg?color=blue&label=npm%20downloads&style=for-the-badge" alt="Downloads" /></a>
+    <a href="https://github.com/Alex-D/check-disk-space/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/check-disk-space.svg?color=blue&style=for-the-badge" alt="MIT Licence" /></a>
+</p>
 
+<h2 align="center">Supporting check-disk-space</h2>
+
+`check-disk-space` is an MIT-licensed open source project and completely free to use.
+You can support its ongoing development by being a backer or a sponsor:
+
+- [Become a backer or sponsor on Patreon](https://www.patreon.com/alexandredemode)
+- [One-time donation via PayPal](https://www.paypal.me/demodealexandre/20eur)
+
+---
 
 ## Introduction
 
-Light multi-platform disk space checker without third party for Node.js.
+A light multi-platform disk space checker without any third party compatible with Node.js, Bun and Deno.
 
-- Works on Linux, macOS and Windows
+- Works on **Linux**, **macOS** and **Windows**
 - Take care of mounting points on unix-like systems
-- No dependencies
+- Zero dependencies
 - TypeScript support
 
-
 ## Install
 
-`npm install check-disk-space`
-
+| Package manager | Command                               |
+| --------------- | ------------------------------------- |
+| Vite+           | `vp add check-disk-space`             |
+| pnpm            | `pnpm add check-disk-space`           |
+| npm             | `npm install check-disk-space --save` |
+| yarn            | `yarn add check-disk-space`           |
+| bun             | `bun add check-disk-space`            |
+| deno            | `deno add npm:check-disk-space`       |
 
 ## Usage
 
 ```js
-// ES
-import checkDiskSpace from 'check-disk-space'
+import { checkDiskSpace } from "check-disk-space";
+// Or with require
+const { checkDiskSpace } = require("check-disk-space");
 
-// CommonJS
-const checkDiskSpace = require('check-disk-space').default
+let yourPath = "";
 
 // On Windows
-checkDiskSpace('C:/blabla/bla').then((diskSpace) => {
-    console.log(diskSpace)
-    // {
-    //     diskPath: 'C:',
-    //     free: 12345678,
-    //     size: 98756432
-    // }
-    // Note: `free` and `size` are in bytes
-})
+yourPath = "C:/your/path";
 
 // On Linux or macOS
-checkDiskSpace('/mnt/mygames').then((diskSpace) => {
-    console.log(diskSpace)
-    // {
-    //     diskPath: '/',
-    //     free: 12345678,
-    //     size: 98756432
-    // }
-    // Note: `free` and `size` are in bytes
-})
+yourPath = "/mnt/mydisk";
+
+checkDiskSpace(yourPath).then((diskSpace) => {
+	console.log(diskSpace);
+	// {
+	//     diskPath: 'C:', (or '/' on Linux/macOS)
+	//     free: 12345678,
+	//     size: 98756432
+	// }
+	// Note: `free` and `size` are in bytes
+});
+```
+
+### Input
+
+- `directoryPath` (string)
+  - Must be a valid path depending on the OS
+  - Can be a non-existent directory: the lib will automatically search the first existing parent folder to find the right disk to check
+
+### Output
+
+- `diskPath` (string)
+  - on Windows, it's always the disk letter
+  - on UNIX like, it depends on the mount path of the disk, so it's not necessarily `'/'`
+- `free` (number)
+  - in bytes
+  - available space on the disk on which the path to check is stored on
+- `size` (number)
+  - in bytes
+  - total size of the disk on which the path to check is stored on
+
+## Migrating from v3.x
+
+Migrates to ESM and does not use `default` export anymore.
+
+```diff
+- import checkDiskSpace from "check-disk-space";
++ import { checkDiskSpace } from "check-disk-space";
 ```
+
+```diff
+- const checkDiskSpace = require("check-disk-space").default;
++ import { checkDiskSpace } from "check-disk-space";
+```
+
+## Compatibility
+
+All of this is fully tested in the CI.
+
+### Supported engines
+
+- Node 18+
+- Bun 1.3+
+- Deno 2.5+ (needs `sys`, `read`, `env` and `run` access)
+
+### Operating Systems
+
+- UNIX like, based on the `df` output
+  - Linux
+  - macOS
+- Windows 7+, based on PowerShell 3 or `wmic` depending on the version and user's rights

package/dist/check-disk-space.d.mts

@@ -0,0 +1,58 @@
+import { access } from "node:fs/promises";
+import { normalize, sep } from "node:path";
+//#region src/errors/invalidPathError.d.ts
+declare class InvalidPathError extends Error {
+  name: string;
+  constructor(message?: string);
+}
+//#endregion
+//#region src/errors/noMatchError.d.ts
+declare class NoMatchError extends Error {
+  name: string;
+  constructor(message?: string);
+}
+//#endregion
+//#region src/types/dependencies.d.ts
+type Dependencies = {
+  platform: NodeJS.Platform;
+  release: string;
+  fsAccess: typeof access;
+  pathNormalize: typeof normalize;
+  pathSep: typeof sep;
+  cpExecFile: (file: string, args: ReadonlyArray<string> | undefined | null, options: {
+    windowsHide: true;
+  }) => Promise<{
+    stdout: string;
+    stderr: string;
+  }>;
+};
+//#endregion
+//#region src/functions/getFirstExistingParentPath.d.ts
+/**
+ * Get the first existing parent path
+ *
+ * @param directoryPath - The file/folder path from where we want to know disk space
+ * @param dependencies - Dependencies container
+ */
+declare function getFirstExistingParentPath(directoryPath: string, dependencies: Dependencies): Promise<string>;
+//#endregion
+//#region src/types/diskSpace.d.ts
+/**
+ * `free` and `size` are in bytes
+ */
+type DiskSpace = {
+  diskPath: string;
+  free: number;
+  size: number;
+};
+//#endregion
+//#region src/index.d.ts
+/**
+ * Check disk space
+ *
+ * @param directoryPath - The file/folder path from where we want to know disk space
+ * @param dependencies - Dependencies container
+ */
+declare function checkDiskSpace(directoryPath: string, dependencies?: Dependencies): Promise<DiskSpace>;
+//#endregion
+export { type Dependencies, type DiskSpace, InvalidPathError, NoMatchError, checkDiskSpace, getFirstExistingParentPath };

package/dist/check-disk-space.mjs

@@ -1,203 +1,183 @@
-import { execFile } from 'node:child_process';
-import { access } from 'node:fs/promises';
-import { release } from 'node:os';
-import { normalize, sep } from 'node:path';
-import { platform } from 'node:process';
-import { promisify } from 'node:util';
-
-class InvalidPathError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'InvalidPathError';
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, InvalidPathError.prototype);
-    }
-}
-
-class NoMatchError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NoMatchError';
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, NoMatchError.prototype);
-    }
-}
-
+import { execFile } from "node:child_process";
+import { access } from "node:fs/promises";
+import { release } from "node:os";
+import { normalize, sep } from "node:path";
+import { platform } from "node:process";
+import { promisify } from "node:util";
+//#region src/errors/invalidPathError.ts
+var InvalidPathError = class InvalidPathError extends Error {
+	name = "InvalidPathError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, InvalidPathError.prototype);
+	}
+};
+//#endregion
+//#region src/errors/noMatchError.ts
+var NoMatchError = class NoMatchError extends Error {
+	name = "NoMatchError";
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, NoMatchError.prototype);
+	}
+};
+//#endregion
+//#region src/functions/isDirectoryExisting.ts
 /**
- * Tells if directory exists
- *
- * @param directoryPath - The file/folder path
- * @param dependencies - Dependencies container
- */
+* Tells if directory exists
+*
+* @param directoryPath - The file/folder path
+* @param dependencies - Dependencies container
+*/
 async function isDirectoryExisting(directoryPath, dependencies) {
-    try {
-        await dependencies.fsAccess(directoryPath);
-        return Promise.resolve(true);
-    }
-    catch (error) {
-        return Promise.resolve(false);
-    }
+	try {
+		await dependencies.fsAccess(directoryPath);
+		return Promise.resolve(true);
+	} catch (_error) {
+		return Promise.resolve(false);
+	}
 }
-
+//#endregion
+//#region src/functions/getFirstExistingParentPath.ts
 /**
- * Get the first existing parent path
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
+* Get the first existing parent path
+*
+* @param directoryPath - The file/folder path from where we want to know disk space
+* @param dependencies - Dependencies container
+*/
 async function getFirstExistingParentPath(directoryPath, dependencies) {
-    let parentDirectoryPath = directoryPath;
-    let parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
-    while (!parentDirectoryFound) {
-        parentDirectoryPath = dependencies.pathNormalize(parentDirectoryPath + '/..');
-        parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
-    }
-    return parentDirectoryPath;
+	let parentDirectoryPath = directoryPath;
+	let parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
+	while (!parentDirectoryFound) {
+		const newParentDirectoryPath = dependencies.pathNormalize(parentDirectoryPath + "/..");
+		if (parentDirectoryPath === newParentDirectoryPath || newParentDirectoryPath === ".") return Promise.reject(new NoMatchError("Unable to find an existing parent path."));
+		parentDirectoryPath = newParentDirectoryPath;
+		parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
+	}
+	return parentDirectoryPath;
 }
-
+//#endregion
+//#region src/functions/hasPowerShell3.ts
 /**
- * Tell if PowerShell 3 is available based on Windows version
- *
- * Note: 6.* is Windows 7
- * Note: PowerShell 3 is natively available since Windows 8
- *
- * @param dependencies - Dependencies Injection Container
- */
+* Tell if PowerShell 3 is available based on Windows version
+*
+* Note: 6.* is Windows 7
+* Note: PowerShell 3 is natively available since Windows 8
+*
+* @param dependencies - Dependencies Injection Container
+*/
 async function hasPowerShell3(dependencies) {
-    const major = parseInt(dependencies.release.split('.')[0], 10);
-    if (major <= 6) {
-        return false;
-    }
-    try {
-        await dependencies.cpExecFile('where', ['powershell'], { windowsHide: true });
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
+	if (parseInt(dependencies.release.split(".")[0], 10) <= 6) return false;
+	try {
+		await dependencies.cpExecFile("where", ["powershell"], { windowsHide: true });
+		return true;
+	} catch (_error) {
+		return false;
+	}
 }
-
+//#endregion
+//#region src/index.ts
 /**
- * Check disk space
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
+* Check disk space
+*
+* @param directoryPath - The file/folder path from where we want to know disk space
+* @param dependencies - Dependencies container
+*/
 function checkDiskSpace(directoryPath, dependencies = {
-    platform,
-    release: release(),
-    fsAccess: access,
-    pathNormalize: normalize,
-    pathSep: sep,
-    cpExecFile: promisify(execFile),
+	platform,
+	release: release(),
+	fsAccess: access,
+	pathNormalize: normalize,
+	pathSep: sep,
+	cpExecFile: promisify(execFile)
 }) {
-    // Note: This function contains other functions in order
-    //       to wrap them in a common context and make unit tests easier
-    /**
-     * Maps command output to a normalized object {diskPath, free, size}
-     *
-     * @param stdout - The command output
-     * @param filter - To filter drives (only used for win32)
-     * @param mapping - Map between column index and normalized column name
-     * @param coefficient - The size coefficient to get bytes instead of kB
-     */
-    function mapOutput(stdout, filter, mapping, coefficient) {
-        const parsed = stdout
-            .split('\n') // Split lines
-            .map(line => line.trim()) // Trim all lines
-            .filter(line => line.length !== 0) // Remove empty lines
-            .slice(1) // Remove header
-            .map(line => line.split(/\s+(?=[\d/])/)); // Split on spaces to get columns
-        const filtered = parsed.filter(filter);
-        if (filtered.length === 0) {
-            throw new NoMatchError();
-        }
-        const diskData = filtered[0];
-        return {
-            diskPath: diskData[mapping.diskPath],
-            free: parseInt(diskData[mapping.free], 10) * coefficient,
-            size: parseInt(diskData[mapping.size], 10) * coefficient,
-        };
-    }
-    /**
-     * Run the command and do common things between win32 and unix
-     *
-     * @param cmd - The command to execute
-     * @param filter - To filter drives (only used for win32)
-     * @param mapping - Map between column index and normalized column name
-     * @param coefficient - The size coefficient to get bytes instead of kB
-     */
-    async function check(cmd, filter, mapping, coefficient = 1) {
-        const [file, ...args] = cmd;
-        /* istanbul ignore if */
-        if (file === undefined) {
-            return Promise.reject(new Error('cmd must contain at least one item'));
-        }
-        try {
-            const { stdout } = await dependencies.cpExecFile(file, args, { windowsHide: true });
-            return mapOutput(stdout, filter, mapping, coefficient);
-        }
-        catch (error) {
-            return Promise.reject(error);
-        }
-    }
-    /**
-     * Build the check call for win32
-     *
-     * @param directoryPath - The file/folder path from where we want to know disk space
-     */
-    async function checkWin32(directoryPath) {
-        if (directoryPath.charAt(1) !== ':') {
-            return Promise.reject(new InvalidPathError(`The following path is invalid (should be X:\\...): ${directoryPath}`));
-        }
-        const powershellCmd = [
-            'powershell',
-            'Get-CimInstance -ClassName Win32_LogicalDisk | Select-Object Caption, FreeSpace, Size',
-        ];
-        const wmicCmd = [
-            'wmic',
-            'logicaldisk',
-            'get',
-            'size,freespace,caption',
-        ];
-        const cmd = await hasPowerShell3(dependencies) ? powershellCmd : wmicCmd;
-        return check(cmd, driveData => {
-            // Only get the drive which match the path
-            const driveLetter = driveData[0];
-            return directoryPath.toUpperCase().startsWith(driveLetter.toUpperCase());
-        }, {
-            diskPath: 0,
-            free: 1,
-            size: 2,
-        });
-    }
-    /**
-     * Build the check call for unix
-     *
-     * @param directoryPath - The file/folder path from where we want to know disk space
-     */
-    async function checkUnix(directoryPath) {
-        if (!dependencies.pathNormalize(directoryPath).startsWith(dependencies.pathSep)) {
-            return Promise.reject(new InvalidPathError(`The following path is invalid (should start by ${dependencies.pathSep}): ${directoryPath}`));
-        }
-        const pathToCheck = await getFirstExistingParentPath(directoryPath, dependencies);
-        return check([
-            'df',
-            '-Pk',
-            '--',
-            pathToCheck,
-        ], () => true, // We should only get one line, so we did not need to filter
-        {
-            diskPath: 5,
-            free: 3,
-            size: 1,
-        }, 1024);
-    }
-    // Call the right check depending on the OS
-    if (dependencies.platform === 'win32') {
-        return checkWin32(directoryPath);
-    }
-    return checkUnix(directoryPath);
+	/**
+	* Maps command output to a normalized object {diskPath, free, size}
+	*
+	* @param stdout - The command output
+	* @param filter - To filter drives (only used for win32)
+	* @param mapping - Map between column index and normalized column name
+	* @param coefficient - The size coefficient to get bytes instead of kB
+	*/
+	function mapOutput(stdout, filter, mapping, coefficient) {
+		const parsed = stdout.split("\n").map((line) => line.trim()).filter((line) => line.length !== 0).slice(1).map((line) => line.split(/\s+(?=[\d/])/));
+		const filtered = parsed.filter(filter);
+		if (filtered.length === 0) {
+			let errorContext = "No disk matches the path.";
+			if (parsed.length === 0) errorContext = "Nothing was returned by the command.";
+			throw new NoMatchError(errorContext);
+		}
+		const columnsCount = parsed.reduce((maxColumnCount, currentLine) => {
+			return Math.max(currentLine.length, maxColumnCount);
+		}, 0);
+		const diskData = filtered[0];
+		const indexOffset = diskData.length - columnsCount;
+		return {
+			diskPath: diskData[mapping.diskPath + indexOffset],
+			free: parseInt(diskData[mapping.free + indexOffset], 10) * coefficient,
+			size: parseInt(diskData[mapping.size + indexOffset], 10) * coefficient
+		};
+	}
+	/**
+	* Run the command and do common things between win32 and Unix
+	*
+	* @param cmd - The command to execute
+	* @param filter - To filter drives (only used for win32)
+	* @param mapping - Map between column index and normalized column name
+	* @param coefficient - The size coefficient to get bytes instead of kB
+	*/
+	async function check(cmd, filter, mapping, coefficient = 1) {
+		const [file, ...args] = cmd;
+		/* istanbul ignore if */
+		if (file === void 0) return Promise.reject(/* @__PURE__ */ new Error("cmd must contain at least one item"));
+		try {
+			const { stdout } = await dependencies.cpExecFile(file, args, { windowsHide: true });
+			return mapOutput(stdout, filter, mapping, coefficient);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+	/**
+	* Build the check call for win32
+	*
+	* @param directoryPath - The file/folder path from where we want to know disk space
+	*/
+	async function checkWin32(directoryPath) {
+		if (directoryPath.charAt(1) !== ":") return Promise.reject(new InvalidPathError(`The following path is invalid (should be X:\\...): ${directoryPath}`));
+		return check(await hasPowerShell3(dependencies) ? ["powershell", "Get-CimInstance -ClassName Win32_LogicalDisk | Select-Object Caption, FreeSpace, Size"] : [
+			"wmic",
+			"logicaldisk",
+			"get",
+			"size,freespace,caption"
+		], (driveData) => {
+			const driveLetter = driveData[0];
+			return directoryPath.toUpperCase().startsWith(driveLetter.toUpperCase());
+		}, {
+			diskPath: 0,
+			free: 1,
+			size: 2
+		});
+	}
+	/**
+	* Build the check call for Unix
+	*
+	* @param directoryPath - The file/folder path from where we want to know disk space
+	*/
+	async function checkUnix(directoryPath) {
+		if (!dependencies.pathNormalize(directoryPath).startsWith(dependencies.pathSep)) return Promise.reject(new InvalidPathError(`The following path is invalid (should start by ${dependencies.pathSep}): ${directoryPath}`));
+		return check([
+			"df",
+			"-Pk",
+			"--",
+			await getFirstExistingParentPath(directoryPath, dependencies)
+		], () => true, {
+			diskPath: 5,
+			free: 3,
+			size: 1
+		}, 1024);
+	}
+	if (dependencies.platform === "win32") return checkWin32(directoryPath);
+	return checkUnix(directoryPath);
 }
-
-export { InvalidPathError, NoMatchError, checkDiskSpace as default, getFirstExistingParentPath };
+//#endregion
+export { InvalidPathError, NoMatchError, checkDiskSpace, getFirstExistingParentPath };

package/package.json

@@ -1,83 +1,55 @@
 {
   "name": "check-disk-space",
-  "version": "3.4.0",
+  "version": "4.0.0",
   "description": "Light multi-platform disk space checker without third party for Node.js",
+  "keywords": [
+    "disk",
+    "free",
+    "hdd",
+    "space"
+  ],
+  "homepage": "https://github.com/Alex-D/check-disk-space#readme",
+  "bugs": {
+    "url": "https://github.com/Alex-D/check-disk-space/issues"
+  },
+  "license": "MIT",
+  "author": "Alex-D <contact@alex-d.fr> (https://alex-d.fr)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Alex-D/check-disk-space.git"
+  },
   "files": [
     "dist",
     "README.md"
   ],
-  "main": "./dist/check-disk-space.cjs",
-  "module": "./dist/check-disk-space.mjs",
-  "types": "./dist/check-disk-space.d.ts",
+  "type": "module",
   "exports": {
-    "import": "./dist/check-disk-space.mjs",
-    "require": "./dist/check-disk-space.cjs",
-    "types": "./dist/check-disk-space.d.ts"
-  },
-  "scripts": {
-    "build:lib": "rollup --config",
-    "build:dts": "rollup --config rollup.dts.config.mjs",
-    "build": "npm-run-all build:lib build:dts",
-    "lint": "eslint . --cache",
-    "lint:fix": "eslint --fix .",
-    "typecheck": "tsc --noEmit",
-    "test": "npm-run-all test:coverage lint typecheck",
-    "test:unit": "NODE_ENV=test TS_NODE_PROJECT='tsconfig.test.json' ava",
-    "test:coverage": "nyc --reporter=lcov --reporter=text npm run test:unit --silent"
-  },
-  "ava": {
-    "files": [
-      "test/**",
-      "!test/__helpers__/**"
-    ],
-    "extensions": [
-      "ts"
-    ],
-    "require": [
-      "tsconfig-paths/register",
-      "ts-node/register",
-      "source-map-support/register"
-    ]
-  },
-  "engines": {
-    "node": ">=16"
+    ".": {
+      "import": "./dist/check-disk-space.mjs",
+      "types": "./dist/check-disk-space.d.mts"
+    },
+    "./package.json": "./package.json"
   },
   "devDependencies": {
-    "@alex-d/eslint-config": "2.2.0",
-    "@istanbuljs/nyc-config-typescript": "1.0.2",
-    "@rollup/plugin-typescript": "11.1.1",
-    "@types/node": "16.11.7",
-    "@typescript-eslint/eslint-plugin": "5.59.6",
-    "@typescript-eslint/parser": "5.59.6",
-    "ava": "5.2.0",
-    "eslint": "8.41.0",
-    "eslint-plugin-ava": "14.0.0",
-    "eslint-plugin-import": "2.27.5",
-    "eslint-plugin-simple-import-sort": "10.0.0",
-    "npm-run-all": "4.1.5",
-    "nyc": "15.1.0",
-    "rollup": "3.22.0",
-    "rollup-plugin-dts": "5.3.0",
-    "source-map-support": "0.5.21",
-    "ts-node": "10.9.1",
-    "tsconfig-paths": "4.2.0",
-    "tslib": "2.5.2",
-    "typescript": "5.0.4"
+    "@types/node": "^26.6.5",
+    "@vitest/coverage-istanbul": "^5.0.5",
+    "bumpp": "^12.3.0",
+    "typescript": "npm:typescript-native-bridge@^6.0.3-bridge.18.tsgo.7.0.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.3.0",
+    "vite-plus": "1.3.0"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Alex-D/check-disk-space.git"
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "12.3.4",
+      "onFail": "download"
+    }
   },
-  "keywords": [
-    "disk",
-    "space",
-    "hdd",
-    "free"
-  ],
-  "author": "Alex-D <contact@alex-d.fr> (https://alex-d.fr)",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/Alex-D/check-disk-space/issues"
-  },
-  "homepage": "https://github.com/Alex-D/check-disk-space#readme"
-}
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "dev:all": "pnpm -r --include-workspace-root --parallel dev",
+    "test": "vp tests",
+    "check": "vp check"
+  }
+}

package/dist/check-disk-space.cjs

@@ -1,210 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var node_child_process = require('node:child_process');
-var promises = require('node:fs/promises');
-var node_os = require('node:os');
-var node_path = require('node:path');
-var node_process = require('node:process');
-var node_util = require('node:util');
-
-class InvalidPathError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'InvalidPathError';
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, InvalidPathError.prototype);
-    }
-}
-
-class NoMatchError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NoMatchError';
-        // Set the prototype explicitly.
-        Object.setPrototypeOf(this, NoMatchError.prototype);
-    }
-}
-
-/**
- * Tells if directory exists
- *
- * @param directoryPath - The file/folder path
- * @param dependencies - Dependencies container
- */
-async function isDirectoryExisting(directoryPath, dependencies) {
-    try {
-        await dependencies.fsAccess(directoryPath);
-        return Promise.resolve(true);
-    }
-    catch (error) {
-        return Promise.resolve(false);
-    }
-}
-
-/**
- * Get the first existing parent path
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
-async function getFirstExistingParentPath(directoryPath, dependencies) {
-    let parentDirectoryPath = directoryPath;
-    let parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
-    while (!parentDirectoryFound) {
-        parentDirectoryPath = dependencies.pathNormalize(parentDirectoryPath + '/..');
-        parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
-    }
-    return parentDirectoryPath;
-}
-
-/**
- * Tell if PowerShell 3 is available based on Windows version
- *
- * Note: 6.* is Windows 7
- * Note: PowerShell 3 is natively available since Windows 8
- *
- * @param dependencies - Dependencies Injection Container
- */
-async function hasPowerShell3(dependencies) {
-    const major = parseInt(dependencies.release.split('.')[0], 10);
-    if (major <= 6) {
-        return false;
-    }
-    try {
-        await dependencies.cpExecFile('where', ['powershell'], { windowsHide: true });
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-
-/**
- * Check disk space
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
-function checkDiskSpace(directoryPath, dependencies = {
-    platform: node_process.platform,
-    release: node_os.release(),
-    fsAccess: promises.access,
-    pathNormalize: node_path.normalize,
-    pathSep: node_path.sep,
-    cpExecFile: node_util.promisify(node_child_process.execFile),
-}) {
-    // Note: This function contains other functions in order
-    //       to wrap them in a common context and make unit tests easier
-    /**
-     * Maps command output to a normalized object {diskPath, free, size}
-     *
-     * @param stdout - The command output
-     * @param filter - To filter drives (only used for win32)
-     * @param mapping - Map between column index and normalized column name
-     * @param coefficient - The size coefficient to get bytes instead of kB
-     */
-    function mapOutput(stdout, filter, mapping, coefficient) {
-        const parsed = stdout
-            .split('\n') // Split lines
-            .map(line => line.trim()) // Trim all lines
-            .filter(line => line.length !== 0) // Remove empty lines
-            .slice(1) // Remove header
-            .map(line => line.split(/\s+(?=[\d/])/)); // Split on spaces to get columns
-        const filtered = parsed.filter(filter);
-        if (filtered.length === 0) {
-            throw new NoMatchError();
-        }
-        const diskData = filtered[0];
-        return {
-            diskPath: diskData[mapping.diskPath],
-            free: parseInt(diskData[mapping.free], 10) * coefficient,
-            size: parseInt(diskData[mapping.size], 10) * coefficient,
-        };
-    }
-    /**
-     * Run the command and do common things between win32 and unix
-     *
-     * @param cmd - The command to execute
-     * @param filter - To filter drives (only used for win32)
-     * @param mapping - Map between column index and normalized column name
-     * @param coefficient - The size coefficient to get bytes instead of kB
-     */
-    async function check(cmd, filter, mapping, coefficient = 1) {
-        const [file, ...args] = cmd;
-        /* istanbul ignore if */
-        if (file === undefined) {
-            return Promise.reject(new Error('cmd must contain at least one item'));
-        }
-        try {
-            const { stdout } = await dependencies.cpExecFile(file, args, { windowsHide: true });
-            return mapOutput(stdout, filter, mapping, coefficient);
-        }
-        catch (error) {
-            return Promise.reject(error);
-        }
-    }
-    /**
-     * Build the check call for win32
-     *
-     * @param directoryPath - The file/folder path from where we want to know disk space
-     */
-    async function checkWin32(directoryPath) {
-        if (directoryPath.charAt(1) !== ':') {
-            return Promise.reject(new InvalidPathError(`The following path is invalid (should be X:\\...): ${directoryPath}`));
-        }
-        const powershellCmd = [
-            'powershell',
-            'Get-CimInstance -ClassName Win32_LogicalDisk | Select-Object Caption, FreeSpace, Size',
-        ];
-        const wmicCmd = [
-            'wmic',
-            'logicaldisk',
-            'get',
-            'size,freespace,caption',
-        ];
-        const cmd = await hasPowerShell3(dependencies) ? powershellCmd : wmicCmd;
-        return check(cmd, driveData => {
-            // Only get the drive which match the path
-            const driveLetter = driveData[0];
-            return directoryPath.toUpperCase().startsWith(driveLetter.toUpperCase());
-        }, {
-            diskPath: 0,
-            free: 1,
-            size: 2,
-        });
-    }
-    /**
-     * Build the check call for unix
-     *
-     * @param directoryPath - The file/folder path from where we want to know disk space
-     */
-    async function checkUnix(directoryPath) {
-        if (!dependencies.pathNormalize(directoryPath).startsWith(dependencies.pathSep)) {
-            return Promise.reject(new InvalidPathError(`The following path is invalid (should start by ${dependencies.pathSep}): ${directoryPath}`));
-        }
-        const pathToCheck = await getFirstExistingParentPath(directoryPath, dependencies);
-        return check([
-            'df',
-            '-Pk',
-            '--',
-            pathToCheck,
-        ], () => true, // We should only get one line, so we did not need to filter
-        {
-            diskPath: 5,
-            free: 3,
-            size: 1,
-        }, 1024);
-    }
-    // Call the right check depending on the OS
-    if (dependencies.platform === 'win32') {
-        return checkWin32(directoryPath);
-    }
-    return checkUnix(directoryPath);
-}
-
-exports.InvalidPathError = InvalidPathError;
-exports.NoMatchError = NoMatchError;
-exports.default = checkDiskSpace;
-exports.getFirstExistingParentPath = getFirstExistingParentPath;

package/dist/check-disk-space.d.ts

@@ -1,53 +0,0 @@
-import { access } from 'node:fs/promises';
-import { normalize, sep } from 'node:path';
-
-declare class InvalidPathError extends Error {
-    name: string;
-    constructor(message?: string);
-}
-
-declare class NoMatchError extends Error {
-    name: string;
-    constructor(message?: string);
-}
-
-type Dependencies = {
-    platform: NodeJS.Platform;
-    release: string;
-    fsAccess: typeof access;
-    pathNormalize: typeof normalize;
-    pathSep: typeof sep;
-    cpExecFile: (file: string, args: ReadonlyArray<string> | undefined | null, options: {
-        windowsHide: true;
-    }) => Promise<{
-        stdout: string;
-        stderr: string;
-    }>;
-};
-
-/**
- * Get the first existing parent path
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
-declare function getFirstExistingParentPath(directoryPath: string, dependencies: Dependencies): Promise<string>;
-
-/**
- * `free` and `size` are in bytes
- */
-type DiskSpace = {
-    diskPath: string;
-    free: number;
-    size: number;
-};
-
-/**
- * Check disk space
- *
- * @param directoryPath - The file/folder path from where we want to know disk space
- * @param dependencies - Dependencies container
- */
-declare function checkDiskSpace(directoryPath: string, dependencies?: Dependencies): Promise<DiskSpace>;
-
-export { Dependencies, DiskSpace, InvalidPathError, NoMatchError, checkDiskSpace as default, getFirstExistingParentPath };