check-disk-space 3.3.1 → 3.4.0

package/dist/check-disk-space.cjs

@@ -2,10 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var child_process = require('child_process');
-var fs = require('fs');
-var os = require('os');
-var path = require('path');
+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) {
@@ -25,18 +27,34 @@ class NoMatchError extends Error {
     }
 }
 
+/**
+ * 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
  */
-function getFirstExistingParentPath(directoryPath, dependencies) {
+async function getFirstExistingParentPath(directoryPath, dependencies) {
     let parentDirectoryPath = directoryPath;
-    let parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath);
+    let parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
     while (!parentDirectoryFound) {
         parentDirectoryPath = dependencies.pathNormalize(parentDirectoryPath + '/..');
-        parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath);
+        parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
     }
     return parentDirectoryPath;
 }
@@ -47,20 +65,18 @@ function getFirstExistingParentPath(directoryPath, dependencies) {
  * Note: 6.* is Windows 7
  * Note: PowerShell 3 is natively available since Windows 8
  *
- * @param release - OS Release number
+ * @param dependencies - Dependencies Injection Container
  */
-function hasPowerShell3(dependencies) {
+async function hasPowerShell3(dependencies) {
     const major = parseInt(dependencies.release.split('.')[0], 10);
-    if (major > 6) {
-        try {
-            dependencies.cpExecFileSync('powershell');
-            return true;
-        }
-        catch (err) {
-            return false;
-        }
+    if (major <= 6) {
+        return false;
+    }
+    try {
+        await dependencies.cpExecFile('where', ['powershell'], { windowsHide: true });
+        return true;
     }
-    else {
+    catch (error) {
         return false;
     }
 }
@@ -72,13 +88,12 @@ function hasPowerShell3(dependencies) {
  * @param dependencies - Dependencies container
  */
 function checkDiskSpace(directoryPath, dependencies = {
-    platform: process.platform,
-    release: os.release(),
-    fsExistsSync: fs.existsSync,
-    pathNormalize: path.normalize,
-    pathSep: path.sep,
-    cpExecFile: child_process.execFile,
-    cpExecFileSync: child_process.execFileSync,
+    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
@@ -91,9 +106,12 @@ function checkDiskSpace(directoryPath, dependencies = {
      * @param coefficient - The size coefficient to get bytes instead of kB
      */
     function mapOutput(stdout, filter, mapping, coefficient) {
-        const parsed = stdout.trim().split('\n').slice(1).map(line => {
-            return line.trim().split(/\s+(?=[\d/])/);
-        });
+        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();
@@ -113,36 +131,28 @@ function checkDiskSpace(directoryPath, dependencies = {
      * @param mapping - Map between column index and normalized column name
      * @param coefficient - The size coefficient to get bytes instead of kB
      */
-    function check(cmd, filter, mapping, coefficient = 1) {
-        return new Promise((resolve, reject) => {
-            const [file, ...args] = cmd;
-            /* istanbul ignore if */
-            if (file === undefined) {
-                return Promise.reject(new Error('cmd must contain at least one item'));
-            }
-            dependencies.cpExecFile(file, args, (error, stdout) => {
-                if (error) {
-                    reject(error);
-                }
-                try {
-                    resolve(mapOutput(stdout, filter, mapping, coefficient));
-                }
-                catch (error2) {
-                    reject(error2);
-                }
-            });
-        });
+    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
      */
-    function checkWin32(directoryPath) {
+    async function checkWin32(directoryPath) {
         if (directoryPath.charAt(1) !== ':') {
-            return new Promise((resolve, reject) => {
-                reject(new InvalidPathError(`The following path is invalid (should be X:\\...): ${directoryPath}`));
-            });
+            return Promise.reject(new InvalidPathError(`The following path is invalid (should be X:\\...): ${directoryPath}`));
         }
         const powershellCmd = [
             'powershell',
@@ -154,7 +164,7 @@ function checkDiskSpace(directoryPath, dependencies = {
             'get',
             'size,freespace,caption',
         ];
-        const cmd = hasPowerShell3(dependencies) ? powershellCmd : wmicCmd;
+        const cmd = await hasPowerShell3(dependencies) ? powershellCmd : wmicCmd;
         return check(cmd, driveData => {
             // Only get the drive which match the path
             const driveLetter = driveData[0];
@@ -170,13 +180,11 @@ function checkDiskSpace(directoryPath, dependencies = {
      *
      * @param directoryPath - The file/folder path from where we want to know disk space
      */
-    function checkUnix(directoryPath) {
+    async function checkUnix(directoryPath) {
         if (!dependencies.pathNormalize(directoryPath).startsWith(dependencies.pathSep)) {
-            return new Promise((resolve, reject) => {
-                reject(new InvalidPathError(`The following path is invalid (should start by ${dependencies.pathSep}): ${directoryPath}`));
-            });
+            return Promise.reject(new InvalidPathError(`The following path is invalid (should start by ${dependencies.pathSep}): ${directoryPath}`));
         }
-        const pathToCheck = getFirstExistingParentPath(directoryPath, dependencies);
+        const pathToCheck = await getFirstExistingParentPath(directoryPath, dependencies);
         return check([
             'df',
             '-Pk',
@@ -198,5 +206,5 @@ function checkDiskSpace(directoryPath, dependencies = {
 
 exports.InvalidPathError = InvalidPathError;
 exports.NoMatchError = NoMatchError;
-exports["default"] = checkDiskSpace;
+exports.default = checkDiskSpace;
 exports.getFirstExistingParentPath = getFirstExistingParentPath;

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

@@ -1,6 +1,5 @@
-import { ChildProcess, ExecException } from 'child_process';
-import { existsSync } from 'fs';
-import { normalize, sep } from 'path';
+import { access } from 'node:fs/promises';
+import { normalize, sep } from 'node:path';
 
 declare class InvalidPathError extends Error {
     name: string;
@@ -12,15 +11,18 @@ declare class NoMatchError extends Error {
     constructor(message?: string);
 }
 
-declare type ExecFileException = ExecException & NodeJS.ErrnoException;
-declare type Dependencies = {
+type Dependencies = {
     platform: NodeJS.Platform;
     release: string;
-    fsExistsSync: typeof existsSync;
+    fsAccess: typeof access;
     pathNormalize: typeof normalize;
     pathSep: typeof sep;
-    cpExecFile: (file: string, args: ReadonlyArray<string> | undefined | null, callback: (error: ExecFileException | null, stdout: string, stderr: string) => void) => ChildProcess;
-    cpExecFileSync: (command: string) => Buffer;
+    cpExecFile: (file: string, args: ReadonlyArray<string> | undefined | null, options: {
+        windowsHide: true;
+    }) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
 };
 
 /**
@@ -29,12 +31,12 @@ declare type Dependencies = {
  * @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): string;
+declare function getFirstExistingParentPath(directoryPath: string, dependencies: Dependencies): Promise<string>;
 
 /**
  * `free` and `size` are in bytes
  */
-declare type DiskSpace = {
+type DiskSpace = {
     diskPath: string;
     free: number;
     size: number;

package/dist/check-disk-space.mjs

@@ -1,7 +1,9 @@
-import { execFile, execFileSync } from 'child_process';
-import { existsSync } from 'fs';
-import { release } from 'os';
-import { normalize, sep } from 'path';
+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) {
@@ -21,18 +23,34 @@ class NoMatchError extends Error {
     }
 }
 
+/**
+ * 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
  */
-function getFirstExistingParentPath(directoryPath, dependencies) {
+async function getFirstExistingParentPath(directoryPath, dependencies) {
     let parentDirectoryPath = directoryPath;
-    let parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath);
+    let parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
     while (!parentDirectoryFound) {
         parentDirectoryPath = dependencies.pathNormalize(parentDirectoryPath + '/..');
-        parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath);
+        parentDirectoryFound = await isDirectoryExisting(parentDirectoryPath, dependencies);
     }
     return parentDirectoryPath;
 }
@@ -43,20 +61,18 @@ function getFirstExistingParentPath(directoryPath, dependencies) {
  * Note: 6.* is Windows 7
  * Note: PowerShell 3 is natively available since Windows 8
  *
- * @param release - OS Release number
+ * @param dependencies - Dependencies Injection Container
  */
-function hasPowerShell3(dependencies) {
+async function hasPowerShell3(dependencies) {
     const major = parseInt(dependencies.release.split('.')[0], 10);
-    if (major > 6) {
-        try {
-            dependencies.cpExecFileSync('powershell');
-            return true;
-        }
-        catch (err) {
-            return false;
-        }
+    if (major <= 6) {
+        return false;
+    }
+    try {
+        await dependencies.cpExecFile('where', ['powershell'], { windowsHide: true });
+        return true;
     }
-    else {
+    catch (error) {
         return false;
     }
 }
@@ -68,13 +84,12 @@ function hasPowerShell3(dependencies) {
  * @param dependencies - Dependencies container
  */
 function checkDiskSpace(directoryPath, dependencies = {
-    platform: process.platform,
+    platform,
     release: release(),
-    fsExistsSync: existsSync,
+    fsAccess: access,
     pathNormalize: normalize,
     pathSep: sep,
-    cpExecFile: execFile,
-    cpExecFileSync: execFileSync,
+    cpExecFile: promisify(execFile),
 }) {
     // Note: This function contains other functions in order
     //       to wrap them in a common context and make unit tests easier
@@ -87,9 +102,12 @@ function checkDiskSpace(directoryPath, dependencies = {
      * @param coefficient - The size coefficient to get bytes instead of kB
      */
     function mapOutput(stdout, filter, mapping, coefficient) {
-        const parsed = stdout.trim().split('\n').slice(1).map(line => {
-            return line.trim().split(/\s+(?=[\d/])/);
-        });
+        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();
@@ -109,36 +127,28 @@ function checkDiskSpace(directoryPath, dependencies = {
      * @param mapping - Map between column index and normalized column name
      * @param coefficient - The size coefficient to get bytes instead of kB
      */
-    function check(cmd, filter, mapping, coefficient = 1) {
-        return new Promise((resolve, reject) => {
-            const [file, ...args] = cmd;
-            /* istanbul ignore if */
-            if (file === undefined) {
-                return Promise.reject(new Error('cmd must contain at least one item'));
-            }
-            dependencies.cpExecFile(file, args, (error, stdout) => {
-                if (error) {
-                    reject(error);
-                }
-                try {
-                    resolve(mapOutput(stdout, filter, mapping, coefficient));
-                }
-                catch (error2) {
-                    reject(error2);
-                }
-            });
-        });
+    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
      */
-    function checkWin32(directoryPath) {
+    async function checkWin32(directoryPath) {
         if (directoryPath.charAt(1) !== ':') {
-            return new Promise((resolve, reject) => {
-                reject(new InvalidPathError(`The following path is invalid (should be X:\\...): ${directoryPath}`));
-            });
+            return Promise.reject(new InvalidPathError(`The following path is invalid (should be X:\\...): ${directoryPath}`));
         }
         const powershellCmd = [
             'powershell',
@@ -150,7 +160,7 @@ function checkDiskSpace(directoryPath, dependencies = {
             'get',
             'size,freespace,caption',
         ];
-        const cmd = hasPowerShell3(dependencies) ? powershellCmd : wmicCmd;
+        const cmd = await hasPowerShell3(dependencies) ? powershellCmd : wmicCmd;
         return check(cmd, driveData => {
             // Only get the drive which match the path
             const driveLetter = driveData[0];
@@ -166,13 +176,11 @@ function checkDiskSpace(directoryPath, dependencies = {
      *
      * @param directoryPath - The file/folder path from where we want to know disk space
      */
-    function checkUnix(directoryPath) {
+    async function checkUnix(directoryPath) {
         if (!dependencies.pathNormalize(directoryPath).startsWith(dependencies.pathSep)) {
-            return new Promise((resolve, reject) => {
-                reject(new InvalidPathError(`The following path is invalid (should start by ${dependencies.pathSep}): ${directoryPath}`));
-            });
+            return Promise.reject(new InvalidPathError(`The following path is invalid (should start by ${dependencies.pathSep}): ${directoryPath}`));
         }
-        const pathToCheck = getFirstExistingParentPath(directoryPath, dependencies);
+        const pathToCheck = await getFirstExistingParentPath(directoryPath, dependencies);
         return check([
             'df',
             '-Pk',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "check-disk-space",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "description": "Light multi-platform disk space checker without third party for Node.js",
   "files": [
     "dist",
@@ -11,11 +11,12 @@
   "types": "./dist/check-disk-space.d.ts",
   "exports": {
     "import": "./dist/check-disk-space.mjs",
-    "require": "./dist/check-disk-space.cjs"
+    "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.js",
+    "build:dts": "rollup --config rollup.dts.config.mjs",
     "build": "npm-run-all build:lib build:dts",
     "lint": "eslint . --cache",
     "lint:fix": "eslint --fix .",
@@ -39,29 +40,29 @@
     ]
   },
   "engines": {
-    "node": ">=12"
+    "node": ">=16"
   },
   "devDependencies": {
-    "@alex-d/eslint-config": "2.0.0",
+    "@alex-d/eslint-config": "2.2.0",
     "@istanbuljs/nyc-config-typescript": "1.0.2",
-    "@rollup/plugin-typescript": "8.3.1",
-    "@types/node": "12.20.46",
-    "@typescript-eslint/eslint-plugin": "5.13.0",
-    "@typescript-eslint/parser": "5.13.0",
-    "ava": "4.1.0",
-    "eslint": "8.10.0",
-    "eslint-plugin-ava": "13.2.0",
-    "eslint-plugin-import": "2.25.4",
-    "eslint-plugin-simple-import-sort": "7.0.0",
+    "@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": "2.69.2",
-    "rollup-plugin-dts": "4.2.0",
+    "rollup": "3.22.0",
+    "rollup-plugin-dts": "5.3.0",
     "source-map-support": "0.5.21",
-    "ts-node": "10.7.0",
-    "tsconfig-paths": "3.13.0",
-    "tslib": "2.3.1",
-    "typescript": "4.6.2"
+    "ts-node": "10.9.1",
+    "tsconfig-paths": "4.2.0",
+    "tslib": "2.5.2",
+    "typescript": "5.0.4"
   },
   "repository": {
     "type": "git",