check-disk-space 3.0.0 → 3.0.1

package/README.md

@@ -4,10 +4,22 @@
 [![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)
 
+
+## Introduction
+
+Light multi-platform disk space checker without third party for Node.js.
+
+- Works on Linux, macOS and Windows
+- Take care of mounting points on unix-like systems
+- No dependencies
+- TypeScript support
+
+
 ## Install
 
 `npm install check-disk-space`
 
+
 ## Usage
 
 ```js
@@ -25,6 +37,7 @@ checkDiskSpace('C:/blabla/bla').then((diskSpace) => {
     //     free: 12345678,
     //     size: 98756432
     // }
+    // Note: `free` and `size` are in bytes
 })
 
 // On Linux or macOS
@@ -35,5 +48,6 @@ checkDiskSpace('/mnt/mygames').then((diskSpace) => {
     //     free: 12345678,
     //     size: 98756432
     // }
+    // Note: `free` and `size` are in bytes
 })
 ```

package/dist/check-disk-space.cjs.js

@@ -0,0 +1,157 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var child_process = require('child_process');
+var fs = require('fs');
+var path = require('path');
+
+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);
+    }
+}
+
+/**
+ * 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) {
+    let parentDirectoryPath = directoryPath;
+    let parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath);
+    while (!parentDirectoryFound) {
+        parentDirectoryPath = dependencies.pathNormalize(parentDirectoryPath + '/..');
+        parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath);
+    }
+    return parentDirectoryPath;
+}
+
+/**
+ * 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: process.platform,
+    fsExistsSync: fs.existsSync,
+    pathNormalize: path.normalize,
+    pathSep: path.sep,
+    cpExecFile: child_process.execFile,
+}) {
+    /**
+     * 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.trim().split('\n').slice(1).map(line => {
+            return line.trim().split(/\s+(?=[\d/])/);
+        });
+        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
+     */
+    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('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);
+                }
+            });
+        });
+    }
+    /**
+     * Build the check call for win32
+     *
+     * @param directoryPath - The file/folder path from where we want to know disk space
+     */
+    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 check(['wmic', 'logicaldisk', 'get', 'size,freespace,caption'], 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
+     */
+    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}`));
+            });
+        }
+        const pathToCheck = 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

@@ -0,0 +1,49 @@
+import { ExecFileException, ChildProcess } from 'child_process';
+import { existsSync } from 'fs';
+import { normalize, sep } from 'path';
+
+declare class InvalidPathError extends Error {
+    name: string;
+    constructor(message?: string);
+}
+
+declare class NoMatchError extends Error {
+    name: string;
+    constructor(message?: string);
+}
+
+declare type Dependencies = {
+    platform: NodeJS.Platform;
+    fsExistsSync: typeof existsSync;
+    pathNormalize: typeof normalize;
+    pathSep: typeof sep;
+    cpExecFile: (file: string, args: ReadonlyArray<string> | undefined | null, callback: (error: ExecFileException | null, stdout: string, stderr: string) => void) => ChildProcess;
+};
+
+/**
+ * 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): string;
+
+/**
+ * `free` and `size` are in bytes
+ */
+declare 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 default checkDiskSpace;
+export { Dependencies, DiskSpace, InvalidPathError, NoMatchError, getFirstExistingParentPath };

package/dist/check-disk-space.es.js

@@ -0,0 +1,151 @@
+import { execFile } from 'child_process';
+import { existsSync } from 'fs';
+import { normalize, sep } from 'path';
+
+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);
+    }
+}
+
+/**
+ * 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) {
+    let parentDirectoryPath = directoryPath;
+    let parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath);
+    while (!parentDirectoryFound) {
+        parentDirectoryPath = dependencies.pathNormalize(parentDirectoryPath + '/..');
+        parentDirectoryFound = dependencies.fsExistsSync(parentDirectoryPath);
+    }
+    return parentDirectoryPath;
+}
+
+/**
+ * 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: process.platform,
+    fsExistsSync: existsSync,
+    pathNormalize: normalize,
+    pathSep: sep,
+    cpExecFile: execFile,
+}) {
+    /**
+     * 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.trim().split('\n').slice(1).map(line => {
+            return line.trim().split(/\s+(?=[\d/])/);
+        });
+        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
+     */
+    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('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);
+                }
+            });
+        });
+    }
+    /**
+     * Build the check call for win32
+     *
+     * @param directoryPath - The file/folder path from where we want to know disk space
+     */
+    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 check(['wmic', 'logicaldisk', 'get', 'size,freespace,caption'], 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
+     */
+    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}`));
+            });
+        }
+        const pathToCheck = 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);
+}
+
+export default checkDiskSpace;
+export { InvalidPathError, NoMatchError, getFirstExistingParentPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "check-disk-space",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Light multi-platform disk space checker without third party for Node.js",
   "files": [
     "dist"
@@ -19,26 +19,26 @@
     "build:dts": "rollup --config rollup.dts.config.js",
     "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"
+    "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"
+    ]
   },
-	"ava": {
-		"files": [
-			"test/**",
-			"!test/__helpers__/**"
-		],
-		"extensions": [
-			"ts"
-		],
-		"require": [
-			"tsconfig-paths/register",
-			"ts-node/register",
-			"source-map-support/register"
-		]
-	},
   "engines": {
     "node": ">=12"
   },
@@ -61,6 +61,7 @@
     "source-map-support": "^0.5.19",
     "ts-node": "^10.0.0",
     "tsconfig-paths": "^3.9.0",
+    "tslib": "^2.3.0",
     "typescript": "4.3.2"
   },
   "repository": {