check-disk-space 2.1.0 → 3.2.0

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

@@ -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(['powershell', 'Get-CimInstance -ClassName Win32_LogicalDisk | Select-Object Caption, FreeSpace, Size'], 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.mjs

@@ -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(['powershell', 'Get-CimInstance -ClassName Win32_LogicalDisk | Select-Object Caption, FreeSpace, Size'], 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,27 +1,67 @@
 {
   "name": "check-disk-space",
-  "version": "2.1.0",
+  "version": "3.2.0",
   "description": "Light multi-platform disk space checker without third party for Node.js",
-  "main": "index.js",
-  "engines": {
-    "node": ">=8"
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "./dist/check-disk-space.cjs",
+  "module": "./dist/check-disk-space.mjs",
+  "types": "./dist/check-disk-space.d.ts",
+  "exports": {
+    "import": "./dist/check-disk-space.mjs",
+    "require": "./dist/check-disk-space.cjs"
   },
-  "dependencies": {},
-  "devDependencies": {
-    "ava": "^2.0.0",
-    "eslint": "^5.16.0",
-    "eslint-plugin-ava": "^7.0.0",
-    "npm-run-all": "^4.1.5",
-    "xo": "^0.24.0"
+  "scripts": {
+    "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"
   },
-  "xo": {
-    "space": true,
-    "semicolon": false
+  "ava": {
+    "files": [
+      "test/**",
+      "!test/__helpers__/**"
+    ],
+    "extensions": [
+      "ts"
+    ],
+    "require": [
+      "tsconfig-paths/register",
+      "ts-node/register",
+      "source-map-support/register"
+    ]
   },
-  "scripts": {
-    "unit-test": "ava --color",
-    "lint": "xo",
-    "test": "npm-run-all unit-test lint"
+  "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",
@@ -33,8 +73,7 @@
     "hdd",
     "free"
   ],
-  "types": "./typings/index.d.ts",
-  "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/.github/FUNDING.yml

@@ -1,4 +0,0 @@
-# These are supported funding model platforms
-
-github: [Alex-D]
-patreon: AlexandreDemode

package/.travis.yml

@@ -1,6 +0,0 @@
-sudo: false
-language: node_js
-node_js:
-  - '12'
-  - '10'
-  - '8'

package/index.js

@@ -1,154 +0,0 @@
-'use strict'
-
-const {exec} = require('child_process')
-const fs = require('fs')
-const path = require('path')
-const util = require('util')
-
-// Create some errors
-const InvalidPathError = function (message) {
-  Error.captureStackTrace(this, this.constructor)
-  this.name = 'InvalidPathError'
-  this.message = message || ''
-}
-
-util.inherits(InvalidPathError, Error)
-
-const NoMatchError = function (message) {
-  Error.captureStackTrace(this, this.constructor)
-  this.name = 'NoMatchError'
-  this.message = message || ''
-}
-
-util.inherits(NoMatchError, Error)
-
-/**
- * Maps command output to a normalized object {free, size}
- *
- * @param {String} stdout - The command output
- * @param {Function} filter - To filter drives (only used for win32)
- * @param {Object} mapping - Map between column index and normalized column name
- * @param {Number} coefficient - The size coefficient to get bytes instead of kB
- * @return {Object} - {free, size} normalized object
- */
-function mapOutput(stdout, filter, mapping, coefficient = 1) {
-  const parsed = stdout.trim().split('\n').slice(1).map(line => {
-    return line.trim().split(/\s+(?=[\d/])/)
-  })
-
-  let filtered = parsed.filter(filter)
-
-  if (filtered.length === 0) {
-    throw new NoMatchError()
-  }
-
-  filtered = filtered[0]
-
-  return {
-    diskPath: filtered[mapping.diskPath],
-    free: parseInt(filtered[mapping.free], 10) * coefficient,
-    size: parseInt(filtered[mapping.size], 10) * coefficient
-  }
-}
-
-/**
- * Run the command and do common things between win32 and unix
- *
- * @param {String} cmd - The command to execute
- * @param {Function} filter - To filter drives (only used for win32)
- * @param {Object} mapping - Map between column index and normalized column name
- * @param {Number} coefficient - The size coefficient to get bytes instead of kB
- * @return {Promise} -
- */
-function check(cmd, filter, mapping, coefficient = 1) {
-  return new Promise((resolve, reject) => {
-    exec(cmd, (error, stdout) => {
-      if (error) {
-        reject(error)
-      }
-
-      try {
-        resolve(mapOutput(stdout, filter, mapping, coefficient))
-      } catch (error2) {
-        reject(error2)
-      }
-    })
-  })
-}
-
-/**
- * Build the check call for win32
- *
- * @param {String} directoryPath - The file/folder path from where we want to know disk space
- * @return {Promise} -
- */
-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.startsWith(driveLetter)
-    },
-    {
-      diskPath: 0,
-      free: 1,
-      size: 2
-    }
-  )
-}
-
-/**
- * Build the check call for unix
- *
- * @param {String} directoryPath - The file/folder path from where we want to know disk space
- * @return {Promise} -
- */
-function checkUnix(directoryPath) {
-  if (!path.normalize(directoryPath).startsWith(path.sep)) {
-    return new Promise((resolve, reject) => {
-      reject(new InvalidPathError(`The following path is invalid (should start by ${path.sep}): ${directoryPath}`))
-    })
-  }
-
-  return check(
-    `df -Pk "${module.exports.getFirstExistingParentPath(directoryPath)}"`,
-    () => true, // We should only get one line, so we did not need to filter
-    {
-      diskPath: 5,
-      free: 3,
-      size: 1
-    },
-    1024 // We get sizes in kB, we need to convert that to bytes
-  )
-}
-
-// Inject the right check depending on the OS
-module.exports = (process.platform === 'win32') ? checkWin32 : checkUnix
-
-/**
- * Get the first existing parent path
- *
- * @param {String} directoryPath - The file/folder path from where we want to know disk space
- * @returns {String} - The first existing parent path
- */
-module.exports.getFirstExistingParentPath = directoryPath => {
-  let parentDirectoryPath = directoryPath
-  let parentDirectoryFound = fs.existsSync(parentDirectoryPath)
-
-  while (!parentDirectoryFound) {
-    parentDirectoryPath = path.normalize(parentDirectoryPath + '/..')
-    parentDirectoryFound = fs.existsSync(parentDirectoryPath)
-  }
-
-  return parentDirectoryPath
-}
-
-module.exports.InvalidPathError = InvalidPathError
-module.exports.NoMatchError = NoMatchError

package/test.js

@@ -1,205 +0,0 @@
-'use strict'
-
-import test from 'ava'
-
-const platformFixtures = {
-  win32: [
-    {
-      title: 'Windows XP',
-      path: 'D:/a/long/path',
-      execOutput: `
-          Caption  FreeSpace     Size
-          C:       627703808     10725732352
-          D:       0             699783168
-          E:       25851797504   107496861696
-          F:       834660716544  2000396742656
-      `,
-      result: {
-        diskPath: 'D:',
-        free: 0,
-        size: 699783168
-      }
-    },
-    {
-      title: 'Windows 7',
-      path: 'C:/blah',
-      execOutput: `
-          Caption  FreeSpace  Size
-          C:     1286164480   34359734272
-          D:     1864638464   50925137920
-          E:
-          F:     77553082368  990202818560
-          G:
-          L:
-      `,
-      result: {
-        diskPath: 'C:',
-        free: 1286164480,
-        size: 34359734272
-      }
-    },
-    {
-      title: 'Windows 8',
-      path: 'D:/MyGames',
-      execOutput: `
-          Caption  FreeSpace     Size
-          C:       498562174976  539028877312
-          D:       0             59494400
-      `,
-      result: {
-        diskPath: 'D:',
-        free: 0,
-        size: 59494400
-      }
-    },
-    {
-      title: 'Windows 10',
-      path: 'C:/User/toto',
-      execOutput: `
-          Caption  FreeSpace     Size
-          C:       159345410048  171204145152
-          D:       0             4001759232
-      `,
-      result: {
-        diskPath: 'C:',
-        free: 159345410048,
-        size: 171204145152
-      }
-    }
-  ],
-  linux: [
-    {
-      title: 'bananian',
-      path: '/dev',
-      execOutput: `
-          Filesystem     1K-blocks    Used Available Use% Mounted on
-          devtmpfs          447624       0    447624   0% /dev
-      `,
-      result: {
-        diskPath: '/dev',
-        free: 447624 * 1024,
-        size: 447624 * 1024
-      }
-    },
-    {
-      title: 'Ubuntu',
-      path: '/run/user/1000',
-      execOutput: `
-          Filesystem     1024-blocks    Used Available Capacity Mounted on
-          tmpfs                89884       8     89876       1% /run/user/1000
-      `,
-      result: {
-        diskPath: '/run/user/1000',
-        free: 89876 * 1024,
-        size: 89884 * 1024
-      }
-    },
-    {
-      title: 'Ubuntu: russian locale',
-      path: '/media/Games',
-      execOutput: `
-          Файл.система   1024-блоков Использовано Доступно Вместимость Cмонтировано в
-          /dev/sdc         240234168    188729228 39278628         83% /media/Games
-      `,
-      result: {
-        diskPath: '/media/Games',
-        free: 39278628 * 1024,
-        size: 240234168 * 1024
-      }
-    }
-  ],
-  darwin: [
-    {
-      title: 'macOS',
-      path: '/home/jacquie',
-      execOutput: `
-          Filesystem    1024-blocks     Used Available Capacity  Mounted on
-          /dev/disk0s2    145961032 20678788 125026244    15%    /home
-      `,
-      result: {
-        diskPath: '/home',
-        free: 125026244 * 1024,
-        size: 145961032 * 1024
-      }
-    }
-  ]
-}
-
-function mockCheckDiskSpace(platform, fixture) {
-  // Clean some required paths
-  delete require.cache[require.resolve('.')]
-
-  // Forces the platform for test purposes
-  Object.defineProperty(process, 'platform', {value: platform})
-
-  // Mock child_process.exec
-  require('child_process').exec = (cmd, callback) => {
-    process.nextTick(() => {
-      callback(fixture.execError, fixture.execOutput)
-    })
-  }
-
-  return require('.')
-}
-
-function mockGetFirstExistingParentPath(existingDirectoryPath) {
-  // Clean some required paths
-  delete require.cache[require.resolve('.')]
-
-  // Forces the platform for test purposes
-  Object.defineProperty(process, 'platform', {value: 'linux'})
-
-  // Mock child_process.exec
-  require('fs').existsSync = directoryPath => directoryPath === existingDirectoryPath
-
-  return require('.').getFirstExistingParentPath
-}
-
-Object.keys(platformFixtures).forEach(platform => {
-  platformFixtures[platform].forEach(fixture => {
-    test(`${platform}: ${fixture.title}`, async t => {
-      const checkDiskSpace = mockCheckDiskSpace(platform, fixture)
-
-      t.deepEqual(await checkDiskSpace(fixture.path), fixture.result)
-    })
-  })
-})
-
-test('win32: path did not match any disk', async t => {
-  const checkDiskSpace = mockCheckDiskSpace('win32', platformFixtures.win32[0])
-  const error = await t.throwsAsync(checkDiskSpace('Z:/shouldfail'))
-  t.is(error.name, 'NoMatchError')
-})
-
-test('win32: invalid path', async t => {
-  const checkDiskSpace = mockCheckDiskSpace('win32', platformFixtures.win32[0])
-  const error = await t.throwsAsync(checkDiskSpace('an invalid path'))
-  t.is(error.name, 'InvalidPathError')
-})
-
-test('unix: invalid path', async t => {
-  const checkDiskSpace = mockCheckDiskSpace('linux', platformFixtures.linux[0])
-  const error = await t.throwsAsync(checkDiskSpace('an invalid path'))
-  t.is(error.name, 'InvalidPathError')
-})
-
-test('exec has an error', async t => {
-  const fixture = JSON.parse(JSON.stringify(platformFixtures.win32[0]))
-  fixture.execError = new Error('some error')
-
-  const checkDiskSpace = mockCheckDiskSpace('win32', fixture)
-  const error = await t.throwsAsync(checkDiskSpace('C:/something'))
-  t.is(error.message, 'some error')
-})
-
-test('unix: get first existing parent path', t => {
-  const parentPath = '/home/Lisa'
-  const getFirstExistingParentPath = mockGetFirstExistingParentPath(parentPath)
-  t.is(getFirstExistingParentPath('/home/Lisa/games/Ankama/Dofus'), parentPath)
-})
-
-test('unix: get first parent can be the path itself', t => {
-  const parentPath = '/home/Lisa'
-  const getFirstExistingParentPath = mockGetFirstExistingParentPath(parentPath)
-  t.is(getFirstExistingParentPath(parentPath), parentPath)
-})

package/typings/index.d.ts

@@ -1,77 +0,0 @@
-declare module "check-disk-space" {
-  namespace checkDiskSpace {
-    /**
-     * The result of the disk space check
-     */
-    interface CheckDiskSpaceResult {
-      /**
-       * How much space is left
-       */
-      free: number;
-      /**
-       * The size of the path
-       */
-      size: number;
-    }
-
-    /**
-     * Error for invalid path
-     */
-    class InvalidPathError {
-      constructor(message: string);
-      /**
-       * The name of the error
-       */
-      name: "InvalidPathError";
-      /**
-       * The error message
-       */
-      message: string | "";
-    }
-
-    /**
-     * Error for path which do not match the actual file system
-     */
-    class NoMatchError {
-      constructor(message: any);
-      /**
-       * The name of the error
-       */
-      name: "NoMatchError";
-      /**
-       * The error message
-       */
-      message: string | "";
-    }
-
-    /**
-     * Get the first existing parent path
-     *
-     * @param {string} directoryPath The file/folder path from where we want to know disk space
-     * @returns {string} The first existing parent path
-     */
-    function getFirstExistingParentPath(directoryPath: string): string;
-  }
-
-  /**
-   * Build the check call for unix or win32
-   *
-   * @param {string} directoryPath The file/folder path from where we want to know disk space
-   * @return {Promise<CheckDiskSpaceResult>} The result of the check
-   *
-   * @example
-   * // On Windows
-   * const diskSpace = await checkDiskSpace('C:/blabla/bla');
-   * console.log(diskSpace); // { free: 12345678, size: 98756432 }
-   *
-   * @example
-   * const diskSpace = await checkDiskSpace('/mnt/mygames');
-   * console.log(diskSpace); // { free: 12345678, size: 98756432 }
-   *
-   * @throws {NoMatchError} In case the given path does not match with the actual file system
-   * @throws {InvalidPathError} In case the path is invalid
-   */
-  function checkDiskSpace(directoryPath: string): Promise<checkDiskSpace.CheckDiskSpaceResult>;
-
-  export = checkDiskSpace;
-}

package/typings/index.test.ts

@@ -1,19 +0,0 @@
-import * as checkDiskSpace from 'check-disk-space';
-
-(async () => {
-  try {
-    const diskSpace = await checkDiskSpace('/mnt/mygames');
-    diskSpace.free;
-    diskSpace.size;
-  } catch (err) {
-    if (err instanceof checkDiskSpace.InvalidPathError) {
-      console.error('Invalid Path Error');
-    } else if (err instanceof checkDiskSpace.NoMatchError) {
-      console.error('No Match Error');
-    } else {
-      console.error('Error');
-    }
-  }
-})();
-
-checkDiskSpace.getFirstExistingParentPath('/path');