check-disk-space 1.5.0 → 3.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 Alexandre Demode
+Copyright (c) 2017-2019 Alexandre Demode
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,33 +1,53 @@
 # Check disk space
 
-[![Travis](https://img.shields.io/travis/Alex-D/check-disk-space.svg)](https://travis-ci.org/Alex-D/check-disk-space)
-[![License MIT](https://img.shields.io/github/license/Alex-D/check-disk-space.svg)](LICENCE)
-[![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/sindresorhus/xo)
+[![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)
+
+
+## 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
-const checkDiskSpace = require('check-disk-space')
+// ES
+import checkDiskSpace from 'check-disk-space'
+
+// CommonJS
+const checkDiskSpace = require('check-disk-space').default
 
 // On Windows
 checkDiskSpace('C:/blabla/bla').then((diskSpace) => {
     console.log(diskSpace)
     // {
+    //     diskPath: 'C:',
     //     free: 12345678,
     //     size: 98756432
     // }
+    // Note: `free` and `size` are in bytes
 })
 
 // On Linux or macOS
 checkDiskSpace('/mnt/mygames').then((diskSpace) => {
     console.log(diskSpace)
     // {
+    //     diskPath: '/',
     //     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,23 +1,68 @@
 {
   "name": "check-disk-space",
-  "version": "1.5.0",
-  "description": "Light multiplartform disk space checker without third party for Node.js",
-  "main": "index.js",
-  "dependencies": {},
-  "devDependencies": {
-    "ava": "0.22.0",
-    "eslint-plugin-ava": "^4.2.2",
-    "npm-run-all": "^4.1.1",
-    "xo": "^0.18.2"
-  },
-  "xo": {
-    "space": true,
-    "semicolon": false
+  "version": "3.0.1",
+  "description": "Light multi-platform disk space checker without third party for Node.js",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/check-disk-space.cjs.js",
+  "module": "./dist/check-disk-space.es.js",
+  "types": "./dist/check-disk-space.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/check-disk-space.es.js",
+      "require": "./dist/check-disk-space.cjs.js"
+    }
   },
   "scripts": {
-    "unit-test": "ava --color",
-    "lint": "xo",
-    "test": "npm-run-all unit-test lint"
+    "build:lib": "rollup --config",
+    "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"
+  },
+  "ava": {
+    "files": [
+      "test/**",
+      "!test/__helpers__/**"
+    ],
+    "extensions": [
+      "ts"
+    ],
+    "require": [
+      "tsconfig-paths/register",
+      "ts-node/register",
+      "source-map-support/register"
+    ]
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "devDependencies": {
+    "@alex-d/eslint-config": "1.0.3",
+    "@istanbuljs/nyc-config-typescript": "^1.0.1",
+    "@rollup/plugin-typescript": "8.2.1",
+    "@types/node": "15.12.2",
+    "@typescript-eslint/eslint-plugin": "4.26.1",
+    "@typescript-eslint/parser": "4.26.1",
+    "ava": "3.15.0",
+    "eslint": "7.28.0",
+    "eslint-plugin-ava": "12.0.0",
+    "eslint-plugin-import": "2.23.4",
+    "eslint-plugin-simple-import-sort": "7.0.0",
+    "npm-run-all": "4.1.5",
+    "nyc": "^15.1.0",
+    "rollup": "2.51.2",
+    "rollup-plugin-dts": "3.0.2",
+    "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": {
     "type": "git",
@@ -29,7 +74,7 @@
     "hdd",
     "free"
   ],
-  "author": "Alex-D <contact@alex-d.fr> (http://alex-d.fr)",
+  "author": "Alex-D <contact@alex-d.fr> (https://alex-d.fr)",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/Alex-D/check-disk-space/issues"

package/.editorconfig

@@ -1,14 +0,0 @@
-# EditorConfig is awesome: http://EditorConfig.org
-root = true
-
-# Unix-style newlines with a newline ending every file
-[*]
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-charset = utf-8
-indent_style = space
-indent_size = 2
-
-[*.md]
-trim_trailing_whitespace = false

package/.idea/check-disk-space.iml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/jsLibraryMappings.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JavaScriptLibraryMappings">
-    <includedPredefinedLibrary name="Node.js Core" />
-  </component>
-</project>

package/.idea/misc.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JavaScriptSettings">
-    <option name="languageLevel" value="ES6" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/check-disk-space.iml" filepath="$PROJECT_DIR$/.idea/check-disk-space.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>