atomically 1.7.0 → 2.0.1

package/package.json

@@ -1,30 +1,23 @@
 {
   "name": "atomically",
+  "repository": "github:fabiospampinato/atomically",
   "description": "Read and write files atomically and reliably.",
-  "version": "1.7.0",
+  "version": "2.0.1",
+  "type": "module",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "benchmark": "node ./tasks/benchmark.js",
-    "clean": "rimraf dist",
-    "compile": "tsc --skipLibCheck && tstei",
-    "compile:watch": "tsc --skipLibCheck --watch",
-    "test": "tap --no-coverage-report",
-    "test:watch": "tap --no-coverage-report --watch",
+    "benchmark": "tsex benchmark",
+    "benchmarkLwatch": "tsex benchmark --watch",
+    "clean": "tsex clean",
+    "compile": "tsex compile",
+    "compile:watch": "tsex compile --watch",
+    "test:init": "esbuild --bundle --target=es2020 --platform=node --format=cjs src/index.ts > test/atomically.cjs",
+    "test": "npm run test:init && tap --no-check-coverage --no-coverage-report",
+    "test:watch": "npm run test:init && tap --no-check-coverage --no-coverage-report --watch",
     "prepublishOnly": "npm run clean && npm run compile && npm run test"
   },
-  "bugs": {
-    "url": "https://github.com/fabiospampinato/atomically/issues"
-  },
-  "license": "MIT",
-  "author": {
-    "name": "Fabio Spampinato",
-    "email": "spampinabio@gmail.com"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/fabiospampinato/atomically.git"
-  },
   "keywords": [
     "atomic",
     "read",
@@ -32,20 +25,17 @@
     "file",
     "reliable"
   ],
-  "engines": {
-    "node": ">=10.12.0"
+  "dependencies": {
+    "stubborn-fs": "^1.2.4",
+    "when-exit": "^2.0.0"
   },
-  "dependencies": {},
   "devDependencies": {
-    "@types/node": "^12.7.2",
-    "lodash": "^4.17.19",
-    "mkdirp": "^1.0.4",
-    "promise-resolve-timeout": "^1.2.1",
+    "@types/node": "^18.13.0",
+    "esbuild": "^0.17.7",
     "require-inject": "^1.4.4",
-    "rimraf": "^3.0.2",
-    "tap": "^14.10.7",
-    "typescript": "^3.5.3",
-    "typescript-transform-export-interop": "^1.0.2",
-    "write-file-atomic": "^3.0.3"
+    "tap": "^16.3.4",
+    "tsex": "^2.1.0",
+    "typescript": "^4.9.5",
+    "write-file-atomic": "^5.0.0"
   }
 }

package/{README.md → readme.md}

@@ -8,7 +8,7 @@ Read and write files atomically and reliably.
   - This library is a rewrite of [`write-file-atomic`](https://github.com/npm/write-file-atomic), with some important enhancements on top, you can largely use this as a drop-in replacement.
   - This library is written in TypeScript, so types aren't an afterthought but come with library.
   - This library is slightly faster than [`write-file-atomic`](https://github.com/npm/write-file-atomic), and it can be 10x faster, while being essentially just as safe, by using the `fsyncWait` option.
-  - This library has 0 dependencies, so there's less code to vet and the entire thing is roughly 20% smaller than [`write-file-atomic`](https://github.com/npm/write-file-atomic).
+  - This library has 0 third-party dependencies, so there's less code to vet and the entire thing is roughly 20% smaller than [`write-file-atomic`](https://github.com/npm/write-file-atomic).
   - This library tries harder to write files on disk than [`write-file-atomic`](https://github.com/npm/write-file-atomic) does, by default retrying some failed operations and handling some more errors.
 - Reliability:
   - Reads are retried, when appropriate, until they succeed or the timeout is reached.
@@ -49,8 +49,8 @@ Read and write files atomically and reliably.
   - `schedule`: it's a function that returns a promise that resolves to a disposer function, basically it allows you to provide some custom queueing logic for the writing operation, allowing you to perhaps wire `atomically` with your app's main filesystem job scheduler:
     - even when a custom `schedule` function is provided write operations will still be queued internally by the library too.
   - `timeout`: it allows you to specify the amount of maximum milliseconds within which the library will retry some failed operations:
-    - when writing asynchronously by default it will keep retrying for 5000 milliseconds.
-    - when writing synchronously by default it will keep retrying for 100 milliseconds.
+    - when writing asynchronously by default it will keep retrying for 7500 milliseconds.
+    - when writing synchronously by default it will keep retrying for 1000 milliseconds.
     - if `0` or `-1` no failed operations will be retried.
     - if another number is provided that will be the timeout interval.
   - `tmpCreate`: it's a function that will be used to create the custom temporary file path in place of the default one:

package/src/constants.ts

@@ -0,0 +1,39 @@
+
+/* IMPORT */
+
+import os from 'node:os';
+import process from 'node:process';
+
+/* MAIN */
+
+const DEFAULT_ENCODING = 'utf8';
+
+const DEFAULT_FILE_MODE = 0o666;
+
+const DEFAULT_FOLDER_MODE = 0o777;
+
+const DEFAULT_READ_OPTIONS = {};
+
+const DEFAULT_WRITE_OPTIONS = {};
+
+const DEFAULT_USER_UID = os.userInfo ().uid;
+
+const DEFAULT_USER_GID = os.userInfo ().gid;
+
+const DEFAULT_TIMEOUT_ASYNC = 7500;
+
+const DEFAULT_TIMEOUT_SYNC = 1000;
+
+const IS_POSIX = !!process.getuid;
+
+const IS_USER_ROOT = process.getuid ? !process.getuid () : false;
+
+const LIMIT_BASENAME_LENGTH = 128; //TODO: Fetch the real limit from the filesystem //TODO: Fetch the whole-path length limit too
+
+const LIMIT_FILES_DESCRIPTORS = 10_000; //TODO: Fetch the real limit from the filesystem
+
+const NOOP = () => {};
+
+/* EXPORT */
+
+export {DEFAULT_ENCODING, DEFAULT_FILE_MODE, DEFAULT_FOLDER_MODE, DEFAULT_READ_OPTIONS, DEFAULT_WRITE_OPTIONS, DEFAULT_USER_UID, DEFAULT_USER_GID, DEFAULT_TIMEOUT_ASYNC, DEFAULT_TIMEOUT_SYNC, IS_POSIX, IS_USER_ROOT, LIMIT_BASENAME_LENGTH, LIMIT_FILES_DESCRIPTORS, NOOP};

package/src/index.ts

@@ -1,43 +1,45 @@
 
 /* IMPORT */
 
-import * as path from 'path';
-import {DEFAULT_ENCODING, DEFAULT_FILE_MODE, DEFAULT_FOLDER_MODE, DEFAULT_READ_OPTIONS, DEFAULT_WRITE_OPTIONS, DEFAULT_TIMEOUT_ASYNC, DEFAULT_TIMEOUT_SYNC, IS_POSIX} from './consts';
-import FS from './utils/fs';
-import Lang from './utils/lang';
+import path from 'node:path';
+import fs from 'stubborn-fs';
+import {DEFAULT_ENCODING, DEFAULT_FILE_MODE, DEFAULT_FOLDER_MODE, DEFAULT_READ_OPTIONS, DEFAULT_WRITE_OPTIONS, DEFAULT_USER_UID, DEFAULT_USER_GID, DEFAULT_TIMEOUT_ASYNC, DEFAULT_TIMEOUT_SYNC, IS_POSIX} from './constants';
+import {isException, isFunction, isString, isUndefined} from './utils/lang';
 import Scheduler from './utils/scheduler';
 import Temp from './utils/temp';
-import {Callback, Data, Disposer, Path, ReadOptions, WriteOptions} from './types';
+import type {Callback, Data, Disposer, Encoding, Path, ReadOptions, WriteOptions} from './types';
 
-/* ATOMICALLY */
+/* MAIN */
 
-function readFile ( filePath: Path, options: string | ReadOptions & { encoding: string } ): Promise<string>;
+function readFile ( filePath: Path, options: Encoding | ReadOptions & { encoding: string } ): Promise<string>;
 function readFile ( filePath: Path, options?: ReadOptions ): Promise<Buffer>;
-function readFile ( filePath: Path, options: string | ReadOptions = DEFAULT_READ_OPTIONS ): Promise<Buffer | string> {
+function readFile ( filePath: Path, options: Encoding | ReadOptions = DEFAULT_READ_OPTIONS ): Promise<Buffer | string> {
 
-  if ( Lang.isString ( options ) ) return readFile ( filePath, { encoding: options } );
+  if ( isString ( options ) ) return readFile ( filePath, { encoding: options } );
 
-  const timeout = Date.now () + ( options.timeout ?? DEFAULT_TIMEOUT_ASYNC );
+  const timeout = Date.now () + ( ( options.timeout ?? DEFAULT_TIMEOUT_ASYNC ) || -1 );
 
-  return FS.readFileRetry ( timeout )( filePath, options );
+  return fs.retry.readFile ( timeout )( filePath, options );
 
-};
+}
 
-function readFileSync ( filePath: Path, options: string | ReadOptions & { encoding: string } ): string;
+function readFileSync ( filePath: Path, options: Encoding | ReadOptions & { encoding: string } ): string;
 function readFileSync ( filePath: Path, options?: ReadOptions ): Buffer;
-function readFileSync ( filePath: Path, options: string | ReadOptions = DEFAULT_READ_OPTIONS ): Buffer | string {
+function readFileSync ( filePath: Path, options: Encoding | ReadOptions = DEFAULT_READ_OPTIONS ): Buffer | string {
 
-  if ( Lang.isString ( options ) ) return readFileSync ( filePath, { encoding: options } );
+  if ( isString ( options ) ) return readFileSync ( filePath, { encoding: options } );
 
-  const timeout = Date.now () + ( options.timeout ?? DEFAULT_TIMEOUT_SYNC );
+  const timeout = Date.now () + ( ( options.timeout ?? DEFAULT_TIMEOUT_SYNC ) || -1 );
 
-  return FS.readFileSyncRetry ( timeout )( filePath, options );
+  return fs.retry.readFileSync ( timeout )( filePath, options );
 
-};
+}
 
-const writeFile = ( filePath: Path, data: Data, options?: string | WriteOptions | Callback, callback?: Callback ): Promise<void> => {
+function writeFile ( filePath: Path, data: Data, callback?: Callback ): Promise<void>;
+function writeFile ( filePath: Path, data: Data, options?: Encoding | WriteOptions, callback?: Callback ): Promise<void>;
+function writeFile ( filePath: Path, data: Data, options?: Encoding | WriteOptions | Callback, callback?: Callback ): Promise<void> {
 
-  if ( Lang.isFunction ( options ) ) return writeFile ( filePath, data, DEFAULT_WRITE_OPTIONS, options );
+  if ( isFunction ( options ) ) return writeFile ( filePath, data, DEFAULT_WRITE_OPTIONS, options );
 
   const promise = writeFileAsync ( filePath, data, options );
 
@@ -45,19 +47,19 @@ const writeFile = ( filePath: Path, data: Data, options?: string | WriteOptions
 
   return promise;
 
-};
+}
 
-const writeFileAsync = async ( filePath: Path, data: Data, options: string | WriteOptions = DEFAULT_WRITE_OPTIONS ): Promise<void> => {
+async function writeFileAsync ( filePath: Path, data: Data, options: Encoding | WriteOptions = DEFAULT_WRITE_OPTIONS ): Promise<void> {
 
-  if ( Lang.isString ( options ) ) return writeFileAsync ( filePath, data, { encoding: options } );
+  if ( isString ( options ) ) return writeFileAsync ( filePath, data, { encoding: options } );
 
-  const timeout = Date.now () + ( options.timeout ?? DEFAULT_TIMEOUT_ASYNC );
+  const timeout = Date.now () + ( ( options.timeout ?? DEFAULT_TIMEOUT_ASYNC ) || -1 );
 
-  let schedulerCustomDisposer: Disposer | null = null,
-      schedulerDisposer: Disposer | null = null,
-      tempDisposer: Disposer | null = null,
-      tempPath: string | null = null,
-      fd: number | null = null;
+  let schedulerCustomDisposer: Disposer | null = null;
+  let schedulerDisposer: Disposer | null = null;
+  let tempDisposer: Disposer | null = null;
+  let tempPath: string | null = null;
+  let fd: number | null = null;
 
   try {
 
@@ -65,47 +67,66 @@ const writeFileAsync = async ( filePath: Path, data: Data, options: string | Wri
 
     schedulerDisposer = await Scheduler.schedule ( filePath );
 
-    filePath = await FS.realpathAttempt ( filePath ) || filePath;
+    const filePathReal = await fs.attempt.realpath ( filePath );
+    const filePathExists = !!filePathReal;
+
+    filePath = filePathReal || filePath;
 
     [tempPath, tempDisposer] = Temp.get ( filePath, options.tmpCreate || Temp.create, !( options.tmpPurge === false ) );
 
-    const useStatChown = IS_POSIX && Lang.isUndefined ( options.chown ),
-          useStatMode = Lang.isUndefined ( options.mode );
+    const useStatChown = IS_POSIX && isUndefined ( options.chown );
+    const useStatMode = isUndefined ( options.mode );
 
-    if ( useStatChown || useStatMode ) {
+    if ( filePathExists && ( useStatChown || useStatMode ) ) {
 
-      const stat = await FS.statAttempt ( filePath );
+      const stats = await fs.attempt.stat ( filePath );
 
-      if ( stat ) {
+      if ( stats ) {
 
         options = { ...options };
 
-        if ( useStatChown ) options.chown = { uid: stat.uid, gid: stat.gid };
+        if ( useStatChown ) {
+
+          options.chown = { uid: stats.uid, gid: stats.gid };
+
+        }
+
+        if ( useStatMode ) {
+
+          options.mode = stats.mode;
 
-        if ( useStatMode ) options.mode = stat.mode;
+        }
 
       }
 
     }
 
-    const parentPath = path.dirname ( filePath );
+    if ( !filePathExists ) {
+
+      const parentPath = path.dirname ( filePath );
+
+      await fs.attempt.mkdir ( parentPath, {
+        mode: DEFAULT_FOLDER_MODE,
+        recursive: true
+      });
+
+    }
+
+    fd = await fs.retry.open ( timeout )( tempPath, 'w', options.mode || DEFAULT_FILE_MODE );
 
-    await FS.mkdirAttempt ( parentPath, {
-      mode: DEFAULT_FOLDER_MODE,
-      recursive: true
-    });
+    if ( options.tmpCreated ) {
 
-    fd = await FS.openRetry ( timeout )( tempPath, 'w', options.mode || DEFAULT_FILE_MODE );
+      options.tmpCreated ( tempPath );
 
-    if ( options.tmpCreated ) options.tmpCreated ( tempPath );
+    }
 
-    if ( Lang.isString ( data ) ) {
+    if ( isString ( data ) ) {
 
-      await FS.writeRetry ( timeout )( fd, data, 0, options.encoding || DEFAULT_ENCODING );
+      await fs.retry.write ( timeout )( fd, data, 0, options.encoding || DEFAULT_ENCODING );
 
-    } else if ( !Lang.isUndefined ( data ) ) {
+    } else if ( !isUndefined ( data ) ) {
 
-      await FS.writeRetry ( timeout )( fd, data, 0, data.length, 0 );
+      await fs.retry.write ( timeout )( fd, data, 0, data.length, 0 );
 
     }
 
@@ -113,33 +134,43 @@ const writeFileAsync = async ( filePath: Path, data: Data, options: string | Wri
 
       if ( options.fsyncWait !== false ) {
 
-        await FS.fsyncRetry ( timeout )( fd );
+        await fs.retry.fsync ( timeout )( fd );
 
       } else {
 
-        FS.fsyncAttempt ( fd );
+        fs.attempt.fsync ( fd );
 
       }
 
     }
 
-    await FS.closeRetry ( timeout )( fd );
+    await fs.retry.close ( timeout )( fd );
 
     fd = null;
 
-    if ( options.chown ) await FS.chownAttempt ( tempPath, options.chown.uid, options.chown.gid );
+    if ( options.chown && ( options.chown.uid !== DEFAULT_USER_UID || options.chown.gid !== DEFAULT_USER_GID ) ) {
+
+      await fs.attempt.chown ( tempPath, options.chown.uid, options.chown.gid );
+
+    }
 
-    if ( options.mode ) await FS.chmodAttempt ( tempPath, options.mode );
+    if ( options.mode && options.mode !== DEFAULT_FILE_MODE ) {
+
+      await fs.attempt.chmod ( tempPath, options.mode );
+
+    }
 
     try {
 
-      await FS.renameRetry ( timeout )( tempPath, filePath );
+      await fs.retry.rename ( timeout )( tempPath, filePath );
+
+    } catch ( error: unknown ) {
 
-    } catch ( error ) {
+      if ( !isException ( error ) ) throw error;
 
       if ( error.code !== 'ENAMETOOLONG' ) throw error;
 
-      await FS.renameRetry ( timeout )( tempPath, Temp.truncate ( filePath ) );
+      await fs.retry.rename ( timeout )( tempPath, Temp.truncate ( filePath ) );
 
     }
 
@@ -149,7 +180,7 @@ const writeFileAsync = async ( filePath: Path, data: Data, options: string | Wri
 
   } finally {
 
-    if ( fd ) await FS.closeAttempt ( fd );
+    if ( fd ) await fs.attempt.close ( fd );
 
     if ( tempPath ) Temp.purge ( tempPath );
 
@@ -159,61 +190,80 @@ const writeFileAsync = async ( filePath: Path, data: Data, options: string | Wri
 
   }
 
-};
+}
 
-const writeFileSync = ( filePath: Path, data: Data, options: string | WriteOptions = DEFAULT_WRITE_OPTIONS ): void => {
+function writeFileSync ( filePath: Path, data: Data, options: Encoding | WriteOptions = DEFAULT_WRITE_OPTIONS ): void {
 
-  if ( Lang.isString ( options ) ) return writeFileSync ( filePath, data, { encoding: options } );
+  if ( isString ( options ) ) return writeFileSync ( filePath, data, { encoding: options } );
 
-  const timeout = Date.now () + ( options.timeout ?? DEFAULT_TIMEOUT_SYNC );
+  const timeout = Date.now () + ( ( options.timeout ?? DEFAULT_TIMEOUT_SYNC ) || -1 );
 
-  let tempDisposer: Disposer | null = null,
-      tempPath: string | null = null,
-      fd: number | null = null;
+  let tempDisposer: Disposer | null = null;
+  let tempPath: string | null = null;
+  let fd: number | null = null;
 
   try {
 
-    filePath = FS.realpathSyncAttempt ( filePath ) || filePath;
+    const filePathReal = fs.attempt.realpathSync ( filePath );
+    const filePathExists = !!filePathReal;
+
+    filePath = filePathReal || filePath;
 
     [tempPath, tempDisposer] = Temp.get ( filePath, options.tmpCreate || Temp.create, !( options.tmpPurge === false ) );
 
-    const useStatChown = IS_POSIX && Lang.isUndefined ( options.chown ),
-          useStatMode = Lang.isUndefined ( options.mode );
+    const useStatChown = IS_POSIX && isUndefined ( options.chown );
+    const useStatMode = isUndefined ( options.mode );
 
-    if ( useStatChown || useStatMode ) {
+    if ( filePathExists && ( useStatChown || useStatMode ) ) {
 
-      const stat = FS.statSyncAttempt ( filePath );
+      const stats = fs.attempt.statSync ( filePath );
 
-      if ( stat ) {
+      if ( stats ) {
 
         options = { ...options };
 
-        if ( useStatChown ) options.chown = { uid: stat.uid, gid: stat.gid };
+        if ( useStatChown ) {
+
+          options.chown = { uid: stats.uid, gid: stats.gid };
+
+        }
+
+        if ( useStatMode ) {
+
+          options.mode = stats.mode;
 
-        if ( useStatMode ) options.mode = stat.mode;
+        }
 
       }
 
     }
 
-    const parentPath = path.dirname ( filePath );
+    if ( !filePathExists ) {
+
+      const parentPath = path.dirname ( filePath );
+
+      fs.attempt.mkdirSync ( parentPath, {
+        mode: DEFAULT_FOLDER_MODE,
+        recursive: true
+      });
+
+    }
+
+    fd = fs.retry.openSync ( timeout )( tempPath, 'w', options.mode || DEFAULT_FILE_MODE );
 
-    FS.mkdirSyncAttempt ( parentPath, {
-      mode: DEFAULT_FOLDER_MODE,
-      recursive: true
-    });
+    if ( options.tmpCreated ) {
 
-    fd = FS.openSyncRetry ( timeout )( tempPath, 'w', options.mode || DEFAULT_FILE_MODE );
+      options.tmpCreated ( tempPath );
 
-    if ( options.tmpCreated ) options.tmpCreated ( tempPath );
+    }
 
-    if ( Lang.isString ( data ) ) {
+    if ( isString ( data ) ) {
 
-      FS.writeSyncRetry ( timeout )( fd, data, 0, options.encoding || DEFAULT_ENCODING );
+      fs.retry.writeSync ( timeout )( fd, data, 0, options.encoding || DEFAULT_ENCODING );
 
-    } else if ( !Lang.isUndefined ( data ) ) {
+    } else if ( !isUndefined ( data ) ) {
 
-      FS.writeSyncRetry ( timeout )( fd, data, 0, data.length, 0 );
+      fs.retry.writeSync ( timeout )( fd, data, 0, data.length, 0 );
 
     }
 
@@ -221,33 +271,43 @@ const writeFileSync = ( filePath: Path, data: Data, options: string | WriteOptio
 
       if ( options.fsyncWait !== false ) {
 
-        FS.fsyncSyncRetry ( timeout )( fd );
+        fs.retry.fsyncSync ( timeout )( fd );
 
       } else {
 
-        FS.fsyncAttempt ( fd );
+        fs.attempt.fsync ( fd );
 
       }
 
     }
 
-    FS.closeSyncRetry ( timeout )( fd );
+    fs.retry.closeSync ( timeout )( fd );
 
     fd = null;
 
-    if ( options.chown ) FS.chownSyncAttempt ( tempPath, options.chown.uid, options.chown.gid );
+    if ( options.chown && ( options.chown.uid !== DEFAULT_USER_UID || options.chown.gid !== DEFAULT_USER_GID ) ) {
+
+      fs.attempt.chownSync ( tempPath, options.chown.uid, options.chown.gid );
+
+    }
 
-    if ( options.mode ) FS.chmodSyncAttempt ( tempPath, options.mode );
+    if ( options.mode && options.mode !== DEFAULT_FILE_MODE ) {
+
+      fs.attempt.chmodSync ( tempPath, options.mode );
+
+    }
 
     try {
 
-      FS.renameSyncRetry ( timeout )( tempPath, filePath );
+      fs.retry.renameSync ( timeout )( tempPath, filePath );
+
+    } catch ( error: unknown ) {
 
-    } catch ( error ) {
+      if ( !isException ( error ) ) throw error;
 
       if ( error.code !== 'ENAMETOOLONG' ) throw error;
 
-      FS.renameSyncRetry ( timeout )( tempPath, Temp.truncate ( filePath ) );
+      fs.retry.renameSync ( timeout )( tempPath, Temp.truncate ( filePath ) );
 
     }
 
@@ -257,13 +317,13 @@ const writeFileSync = ( filePath: Path, data: Data, options: string | WriteOptio
 
   } finally {
 
-    if ( fd ) FS.closeSyncAttempt ( fd );
+    if ( fd ) fs.attempt.closeSync ( fd );
 
     if ( tempPath ) Temp.purge ( tempPath );
 
   }
 
-};
+}
 
 /* EXPORT */
 

package/src/types.ts

@@ -1,37 +1,37 @@
 
-/* TYPES */
+/* MAIN */
 
-type Callback = ( error: Exception | void ) => any;
+type Callback = ( error: Exception | void ) => void;
 
-type Data = Buffer | string | undefined;
+type Data = Uint8Array | string | undefined;
 
 type Disposer = () => void;
 
-type Exception = NodeJS.ErrnoException;
+type Encoding = 'ascii' | 'base64' | 'binary' | 'hex' | 'latin1' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2';
 
-type FN<Arguments extends any[] = any[], Return = any> = ( ...args: Arguments ) => Return;
+type Exception = NodeJS.ErrnoException;
 
 type Path = string;
 
 type ReadOptions = {
-  encoding?: string | null,
+  encoding?: Encoding | null,
   mode?: string | number | false,
   timeout?: number
 };
 
 type WriteOptions = {
   chown?: { gid: number, uid: number } | false,
-  encoding?: string | null,
+  encoding?: Encoding | null,
   fsync?: boolean,
   fsyncWait?: boolean,
   mode?: string | number | false,
   schedule?: ( filePath: string ) => Promise<Disposer>,
   timeout?: number,
   tmpCreate?: ( filePath: string ) => string,
-  tmpCreated?: ( filePath: string ) => any,
+  tmpCreated?: ( filePath: string ) => void,
   tmpPurge?: boolean
 };
 
 /* EXPORT */
 
-export {Callback, Data, Disposer, Exception, FN, Path, ReadOptions, WriteOptions};
+export type {Callback, Data, Disposer, Encoding, Exception, Path, ReadOptions, WriteOptions};

package/src/utils/lang.ts

@@ -1,28 +1,34 @@
 
-/* LANG */
+/* IMPORT */
 
-const Lang = {
+import type {Exception} from '../types';
 
-  isFunction: ( x: any ): x is Function => {
+/* MAIN */
 
-    return typeof x === 'function';
+const isException = ( value: unknown ): value is Exception => {
 
-  },
+  return ( value instanceof Error ) && ( 'code' in value );
 
-  isString: ( x: any ): x is string => {
+};
+
+const isFunction = ( value: unknown ): value is Function => {
+
+  return ( typeof value === 'function' );
 
-    return typeof x === 'string';
+};
+
+const isString = ( value: unknown ): value is string => {
 
-  },
+  return ( typeof value === 'string' );
 
-  isUndefined: ( x: any ): x is undefined => {
+};
 
-    return typeof x === 'undefined';
+const isUndefined = ( value: unknown ): value is undefined => {
 
-  }
+  return ( value === undefined );
 
 };
 
 /* EXPORT */
 
-export default Lang;
+export {isException, isFunction, isString, isUndefined};

package/src/utils/scheduler.ts

@@ -1,18 +1,20 @@
 
 /* IMPORT */
 
-import {Disposer} from '../types';
+import type {Disposer} from '../types';
 
-/* VARIABLES */
+/* HELPERS */
 
 const Queues: Record<string, Function[] | undefined> = {};
 
-/* SCHEDULER */
+/* MAIN */
 
 //TODO: Maybe publish this as a standalone package
 
 const Scheduler = {
 
+  /* API */
+
   next: ( id: string ): void => {
 
     const queue = Queues[id];