atomically 1.7.0 → 2.0.0

package/.editorconfig

@@ -8,6 +8,3 @@ indent_size = 2
 indent_style = space
 insert_final_newline = true
 trim_trailing_whitespace = true
-
-[*.md]
-trim_trailing_whitespace = false

package/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/dist/{consts.d.ts → constants.d.ts}

@@ -3,11 +3,13 @@ declare const DEFAULT_FILE_MODE = 438;
 declare const DEFAULT_FOLDER_MODE = 511;
 declare const DEFAULT_READ_OPTIONS: {};
 declare const DEFAULT_WRITE_OPTIONS: {};
-declare const DEFAULT_TIMEOUT_ASYNC = 5000;
-declare const DEFAULT_TIMEOUT_SYNC = 100;
-declare const IS_POSIX = true;
+declare const DEFAULT_USER_UID: number;
+declare const DEFAULT_USER_GID: number;
+declare const DEFAULT_TIMEOUT_ASYNC = 7500;
+declare const DEFAULT_TIMEOUT_SYNC = 1000;
+declare const IS_POSIX: boolean;
 declare const IS_USER_ROOT: boolean;
 declare const LIMIT_BASENAME_LENGTH = 128;
 declare const LIMIT_FILES_DESCRIPTORS = 10000;
 declare const NOOP: () => void;
-export { DEFAULT_ENCODING, DEFAULT_FILE_MODE, DEFAULT_FOLDER_MODE, DEFAULT_READ_OPTIONS, DEFAULT_WRITE_OPTIONS, DEFAULT_TIMEOUT_ASYNC, DEFAULT_TIMEOUT_SYNC, IS_POSIX, IS_USER_ROOT, LIMIT_BASENAME_LENGTH, LIMIT_FILES_DESCRIPTORS, NOOP };
+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/dist/constants.js

@@ -0,0 +1,19 @@
+/* IMPORT */
+import os from 'node:os';
+/* 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 = 10000; //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/dist/index.d.ts

@@ -1,13 +1,14 @@
 /// <reference types="node" />
-import { Callback, Data, Path, ReadOptions, WriteOptions } from './types';
-declare function readFile(filePath: Path, options: string | ReadOptions & {
+import type { Callback, Data, Encoding, Path, ReadOptions, WriteOptions } from './types';
+declare function readFile(filePath: Path, options: Encoding | ReadOptions & {
     encoding: string;
 }): Promise<string>;
 declare function readFile(filePath: Path, options?: ReadOptions): Promise<Buffer>;
-declare function readFileSync(filePath: Path, options: string | ReadOptions & {
+declare function readFileSync(filePath: Path, options: Encoding | ReadOptions & {
     encoding: string;
 }): string;
 declare function readFileSync(filePath: Path, options?: ReadOptions): Buffer;
-declare const writeFile: (filePath: Path, data: Data, options?: string | WriteOptions | Callback | undefined, callback?: Callback | undefined) => Promise<void>;
-declare const writeFileSync: (filePath: Path, data: Data, options?: string | WriteOptions) => void;
+declare function writeFile(filePath: Path, data: Data, callback?: Callback): Promise<void>;
+declare function writeFile(filePath: Path, data: Data, options?: Encoding | WriteOptions, callback?: Callback): Promise<void>;
+declare const writeFileSync: (filePath: Path, data: Data, options?: Encoding | WriteOptions) => void;
 export { readFile, readFileSync, writeFile, writeFileSync };

package/dist/index.js

@@ -1,177 +1,196 @@
-"use strict";
 /* IMPORT */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeFileSync = exports.writeFile = exports.readFileSync = exports.readFile = void 0;
-const path = require("path");
-const consts_1 = require("./consts");
-const fs_1 = require("./utils/fs");
-const lang_1 = require("./utils/lang");
-const scheduler_1 = require("./utils/scheduler");
-const temp_1 = require("./utils/temp");
-function readFile(filePath, options = consts_1.DEFAULT_READ_OPTIONS) {
-    var _a;
-    if (lang_1.default.isString(options))
+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.js';
+import { isException, isFunction, isString, isUndefined } from './utils/lang.js';
+import Scheduler from './utils/scheduler.js';
+import Temp from './utils/temp.js';
+function readFile(filePath, options = DEFAULT_READ_OPTIONS) {
+    if (isString(options))
         return readFile(filePath, { encoding: options });
-    const timeout = Date.now() + ((_a = options.timeout) !== null && _a !== void 0 ? _a : consts_1.DEFAULT_TIMEOUT_ASYNC);
-    return fs_1.default.readFileRetry(timeout)(filePath, options);
+    const timeout = Date.now() + ((options.timeout ?? DEFAULT_TIMEOUT_ASYNC) || -1);
+    return fs.retry.readFile(timeout)(filePath, options);
 }
-exports.readFile = readFile;
-;
-function readFileSync(filePath, options = consts_1.DEFAULT_READ_OPTIONS) {
-    var _a;
-    if (lang_1.default.isString(options))
+function readFileSync(filePath, options = DEFAULT_READ_OPTIONS) {
+    if (isString(options))
         return readFileSync(filePath, { encoding: options });
-    const timeout = Date.now() + ((_a = options.timeout) !== null && _a !== void 0 ? _a : consts_1.DEFAULT_TIMEOUT_SYNC);
-    return fs_1.default.readFileSyncRetry(timeout)(filePath, options);
+    const timeout = Date.now() + ((options.timeout ?? DEFAULT_TIMEOUT_SYNC) || -1);
+    return fs.retry.readFileSync(timeout)(filePath, options);
 }
-exports.readFileSync = readFileSync;
-;
-const writeFile = (filePath, data, options, callback) => {
-    if (lang_1.default.isFunction(options))
-        return writeFile(filePath, data, consts_1.DEFAULT_WRITE_OPTIONS, options);
+function writeFile(filePath, data, options, callback) {
+    if (isFunction(options))
+        return writeFile(filePath, data, DEFAULT_WRITE_OPTIONS, options);
     const promise = writeFileAsync(filePath, data, options);
     if (callback)
         promise.then(callback, callback);
     return promise;
-};
-exports.writeFile = writeFile;
-const writeFileAsync = async (filePath, data, options = consts_1.DEFAULT_WRITE_OPTIONS) => {
-    var _a;
-    if (lang_1.default.isString(options))
+}
+async function writeFileAsync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
+    if (isString(options))
         return writeFileAsync(filePath, data, { encoding: options });
-    const timeout = Date.now() + ((_a = options.timeout) !== null && _a !== void 0 ? _a : consts_1.DEFAULT_TIMEOUT_ASYNC);
-    let schedulerCustomDisposer = null, schedulerDisposer = null, tempDisposer = null, tempPath = null, fd = null;
+    const timeout = Date.now() + ((options.timeout ?? DEFAULT_TIMEOUT_ASYNC) || -1);
+    let schedulerCustomDisposer = null;
+    let schedulerDisposer = null;
+    let tempDisposer = null;
+    let tempPath = null;
+    let fd = null;
     try {
         if (options.schedule)
             schedulerCustomDisposer = await options.schedule(filePath);
-        schedulerDisposer = await scheduler_1.default.schedule(filePath);
-        filePath = await fs_1.default.realpathAttempt(filePath) || filePath;
-        [tempPath, tempDisposer] = temp_1.default.get(filePath, options.tmpCreate || temp_1.default.create, !(options.tmpPurge === false));
-        const useStatChown = consts_1.IS_POSIX && lang_1.default.isUndefined(options.chown), useStatMode = lang_1.default.isUndefined(options.mode);
-        if (useStatChown || useStatMode) {
-            const stat = await fs_1.default.statAttempt(filePath);
-            if (stat) {
+        schedulerDisposer = await Scheduler.schedule(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 && isUndefined(options.chown);
+        const useStatMode = isUndefined(options.mode);
+        if (filePathExists && (useStatChown || useStatMode)) {
+            const stats = await fs.attempt.stat(filePath);
+            if (stats) {
                 options = { ...options };
-                if (useStatChown)
-                    options.chown = { uid: stat.uid, gid: stat.gid };
-                if (useStatMode)
-                    options.mode = stat.mode;
+                if (useStatChown) {
+                    options.chown = { uid: stats.uid, gid: stats.gid };
+                }
+                if (useStatMode) {
+                    options.mode = stats.mode;
+                }
             }
         }
-        const parentPath = path.dirname(filePath);
-        await fs_1.default.mkdirAttempt(parentPath, {
-            mode: consts_1.DEFAULT_FOLDER_MODE,
-            recursive: true
-        });
-        fd = await fs_1.default.openRetry(timeout)(tempPath, 'w', options.mode || consts_1.DEFAULT_FILE_MODE);
-        if (options.tmpCreated)
+        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);
+        if (options.tmpCreated) {
             options.tmpCreated(tempPath);
-        if (lang_1.default.isString(data)) {
-            await fs_1.default.writeRetry(timeout)(fd, data, 0, options.encoding || consts_1.DEFAULT_ENCODING);
         }
-        else if (!lang_1.default.isUndefined(data)) {
-            await fs_1.default.writeRetry(timeout)(fd, data, 0, data.length, 0);
+        if (isString(data)) {
+            await fs.retry.write(timeout)(fd, data, 0, options.encoding || DEFAULT_ENCODING);
+        }
+        else if (!isUndefined(data)) {
+            await fs.retry.write(timeout)(fd, data, 0, data.length, 0);
         }
         if (options.fsync !== false) {
             if (options.fsyncWait !== false) {
-                await fs_1.default.fsyncRetry(timeout)(fd);
+                await fs.retry.fsync(timeout)(fd);
             }
             else {
-                fs_1.default.fsyncAttempt(fd);
+                fs.attempt.fsync(fd);
             }
         }
-        await fs_1.default.closeRetry(timeout)(fd);
+        await fs.retry.close(timeout)(fd);
         fd = null;
-        if (options.chown)
-            await fs_1.default.chownAttempt(tempPath, options.chown.uid, options.chown.gid);
-        if (options.mode)
-            await fs_1.default.chmodAttempt(tempPath, options.mode);
+        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 && options.mode !== DEFAULT_FILE_MODE) {
+            await fs.attempt.chmod(tempPath, options.mode);
+        }
         try {
-            await fs_1.default.renameRetry(timeout)(tempPath, filePath);
+            await fs.retry.rename(timeout)(tempPath, filePath);
         }
         catch (error) {
+            if (!isException(error))
+                throw error;
             if (error.code !== 'ENAMETOOLONG')
                 throw error;
-            await fs_1.default.renameRetry(timeout)(tempPath, temp_1.default.truncate(filePath));
+            await fs.retry.rename(timeout)(tempPath, Temp.truncate(filePath));
         }
         tempDisposer();
         tempPath = null;
     }
     finally {
         if (fd)
-            await fs_1.default.closeAttempt(fd);
+            await fs.attempt.close(fd);
         if (tempPath)
-            temp_1.default.purge(tempPath);
+            Temp.purge(tempPath);
         if (schedulerCustomDisposer)
             schedulerCustomDisposer();
         if (schedulerDisposer)
             schedulerDisposer();
     }
-};
-const writeFileSync = (filePath, data, options = consts_1.DEFAULT_WRITE_OPTIONS) => {
-    var _a;
-    if (lang_1.default.isString(options))
+}
+const writeFileSync = (filePath, data, options = DEFAULT_WRITE_OPTIONS) => {
+    if (isString(options))
         return writeFileSync(filePath, data, { encoding: options });
-    const timeout = Date.now() + ((_a = options.timeout) !== null && _a !== void 0 ? _a : consts_1.DEFAULT_TIMEOUT_SYNC);
-    let tempDisposer = null, tempPath = null, fd = null;
+    const timeout = Date.now() + ((options.timeout ?? DEFAULT_TIMEOUT_SYNC) || -1);
+    let tempDisposer = null;
+    let tempPath = null;
+    let fd = null;
     try {
-        filePath = fs_1.default.realpathSyncAttempt(filePath) || filePath;
-        [tempPath, tempDisposer] = temp_1.default.get(filePath, options.tmpCreate || temp_1.default.create, !(options.tmpPurge === false));
-        const useStatChown = consts_1.IS_POSIX && lang_1.default.isUndefined(options.chown), useStatMode = lang_1.default.isUndefined(options.mode);
-        if (useStatChown || useStatMode) {
-            const stat = fs_1.default.statSyncAttempt(filePath);
-            if (stat) {
+        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 && isUndefined(options.chown);
+        const useStatMode = isUndefined(options.mode);
+        if (filePathExists && (useStatChown || useStatMode)) {
+            const stats = fs.attempt.statSync(filePath);
+            if (stats) {
                 options = { ...options };
-                if (useStatChown)
-                    options.chown = { uid: stat.uid, gid: stat.gid };
-                if (useStatMode)
-                    options.mode = stat.mode;
+                if (useStatChown) {
+                    options.chown = { uid: stats.uid, gid: stats.gid };
+                }
+                if (useStatMode) {
+                    options.mode = stats.mode;
+                }
             }
         }
-        const parentPath = path.dirname(filePath);
-        fs_1.default.mkdirSyncAttempt(parentPath, {
-            mode: consts_1.DEFAULT_FOLDER_MODE,
-            recursive: true
-        });
-        fd = fs_1.default.openSyncRetry(timeout)(tempPath, 'w', options.mode || consts_1.DEFAULT_FILE_MODE);
-        if (options.tmpCreated)
+        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);
+        if (options.tmpCreated) {
             options.tmpCreated(tempPath);
-        if (lang_1.default.isString(data)) {
-            fs_1.default.writeSyncRetry(timeout)(fd, data, 0, options.encoding || consts_1.DEFAULT_ENCODING);
         }
-        else if (!lang_1.default.isUndefined(data)) {
-            fs_1.default.writeSyncRetry(timeout)(fd, data, 0, data.length, 0);
+        if (isString(data)) {
+            fs.retry.writeSync(timeout)(fd, data, 0, options.encoding || DEFAULT_ENCODING);
+        }
+        else if (!isUndefined(data)) {
+            fs.retry.writeSync(timeout)(fd, data, 0, data.length, 0);
         }
         if (options.fsync !== false) {
             if (options.fsyncWait !== false) {
-                fs_1.default.fsyncSyncRetry(timeout)(fd);
+                fs.retry.fsyncSync(timeout)(fd);
             }
             else {
-                fs_1.default.fsyncAttempt(fd);
+                fs.attempt.fsync(fd);
             }
         }
-        fs_1.default.closeSyncRetry(timeout)(fd);
+        fs.retry.closeSync(timeout)(fd);
         fd = null;
-        if (options.chown)
-            fs_1.default.chownSyncAttempt(tempPath, options.chown.uid, options.chown.gid);
-        if (options.mode)
-            fs_1.default.chmodSyncAttempt(tempPath, options.mode);
+        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 && options.mode !== DEFAULT_FILE_MODE) {
+            fs.attempt.chmodSync(tempPath, options.mode);
+        }
         try {
-            fs_1.default.renameSyncRetry(timeout)(tempPath, filePath);
+            fs.retry.renameSync(timeout)(tempPath, filePath);
         }
         catch (error) {
+            if (!isException(error))
+                throw error;
             if (error.code !== 'ENAMETOOLONG')
                 throw error;
-            fs_1.default.renameSyncRetry(timeout)(tempPath, temp_1.default.truncate(filePath));
+            fs.retry.renameSync(timeout)(tempPath, Temp.truncate(filePath));
         }
         tempDisposer();
         tempPath = null;
     }
     finally {
         if (fd)
-            fs_1.default.closeSyncAttempt(fd);
+            fs.attempt.closeSync(fd);
         if (tempPath)
-            temp_1.default.purge(tempPath);
+            Temp.purge(tempPath);
     }
 };
-exports.writeFileSync = writeFileSync;
+/* EXPORT */
+export { readFile, readFileSync, writeFile, writeFileSync };

package/dist/types.d.ts

@@ -1,12 +1,12 @@
 /// <reference types="node" />
-declare type Callback = (error: Exception | void) => any;
-declare type Data = Buffer | string | undefined;
+declare type Callback = (error: Exception | void) => void;
+declare type Data = Uint8Array | string | undefined;
 declare type Disposer = () => void;
+declare type Encoding = 'ascii' | 'base64' | 'binary' | 'hex' | 'latin1' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2';
 declare type Exception = NodeJS.ErrnoException;
-declare type FN<Arguments extends any[] = any[], Return = any> = (...args: Arguments) => Return;
 declare type Path = string;
 declare type ReadOptions = {
-    encoding?: string | null;
+    encoding?: Encoding | null;
     mode?: string | number | false;
     timeout?: number;
 };
@@ -15,14 +15,14 @@ declare type WriteOptions = {
         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 { Callback, Data, Disposer, Exception, FN, Path, ReadOptions, WriteOptions };
+export type { Callback, Data, Disposer, Encoding, Exception, Path, ReadOptions, WriteOptions };

package/dist/types.js

@@ -1,3 +1,2 @@
-"use strict";
-/* TYPES */
-Object.defineProperty(exports, "__esModule", { value: true });
+/* MAIN */
+export {};

package/dist/utils/lang.d.ts

@@ -1,6 +1,6 @@
-declare const Lang: {
-    isFunction: (x: any) => x is Function;
-    isString: (x: any) => x is string;
-    isUndefined: (x: any) => x is undefined;
-};
-export default Lang;
+/// <reference types="node" />
+declare const isException: (value: unknown) => value is NodeJS.ErrnoException;
+declare const isFunction: (value: unknown) => value is Function;
+declare const isString: (value: unknown) => value is string;
+declare const isUndefined: (value: unknown) => value is undefined;
+export { isException, isFunction, isString, isUndefined };

package/dist/utils/lang.js

@@ -1,16 +1,16 @@
-"use strict";
-/* LANG */
-Object.defineProperty(exports, "__esModule", { value: true });
-const Lang = {
-    isFunction: (x) => {
-        return typeof x === 'function';
-    },
-    isString: (x) => {
-        return typeof x === 'string';
-    },
-    isUndefined: (x) => {
-        return typeof x === 'undefined';
-    }
+/* IMPORT */
+/* MAIN */
+const isException = (value) => {
+    return (value instanceof Error) && ('code' in value);
+};
+const isFunction = (value) => {
+    return (typeof value === 'function');
+};
+const isString = (value) => {
+    return (typeof value === 'string');
+};
+const isUndefined = (value) => {
+    return (value === undefined);
 };
 /* EXPORT */
-exports.default = Lang;
+export { isException, isFunction, isString, isUndefined };

package/dist/utils/scheduler.d.ts

@@ -1,4 +1,4 @@
-import { Disposer } from '../types';
+import type { Disposer } from '../types';
 declare const Scheduler: {
     next: (id: string) => void;
     schedule: (id: string) => Promise<Disposer>;

package/dist/utils/scheduler.js

@@ -1,11 +1,10 @@
-"use strict";
 /* IMPORT */
-Object.defineProperty(exports, "__esModule", { value: true });
-/* VARIABLES */
+/* HELPERS */
 const Queues = {};
-/* SCHEDULER */
+/* MAIN */
 //TODO: Maybe publish this as a standalone package
 const Scheduler = {
+    /* API */
     next: (id) => {
         const queue = Queues[id];
         if (!queue)
@@ -32,4 +31,4 @@ const Scheduler = {
     }
 };
 /* EXPORT */
-exports.default = Scheduler;
+export default Scheduler;

package/dist/utils/temp.d.ts

@@ -1,4 +1,4 @@
-import { Disposer } from '../types';
+import type { Disposer } from '../types';
 declare const Temp: {
     store: Record<string, boolean>;
     create: (filePath: string) => string;

package/dist/utils/temp.js

@@ -1,17 +1,20 @@
-"use strict";
 /* IMPORT */
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const consts_1 = require("../consts");
-const fs_1 = require("./fs");
-/* TEMP */
+import path from 'node:path';
+import fs from 'stubborn-fs';
+import whenExit from 'when-exit';
+import { LIMIT_BASENAME_LENGTH } from '../constants.js';
+/* MAIN */
 //TODO: Maybe publish this as a standalone package
 const Temp = {
+    /* VARIABLES */
     store: {},
+    /* API */
     create: (filePath) => {
-        const randomness = `000000${Math.floor(Math.random() * 16777215).toString(16)}`.slice(-6), // 6 random-enough hex characters
-        timestamp = Date.now().toString().slice(-10), // 10 precise timestamp digits
-        prefix = 'tmp-', suffix = `.${prefix}${timestamp}${randomness}`, tempPath = `${filePath}${suffix}`;
+        const randomness = `000000${Math.floor(Math.random() * 16777215).toString(16)}`.slice(-6); // 6 random-enough hex characters
+        const timestamp = Date.now().toString().slice(-10); // 10 precise timestamp digits
+        const prefix = 'tmp-';
+        const suffix = `.${prefix}${timestamp}${randomness}`;
+        const tempPath = `${filePath}${suffix}`;
         return tempPath;
     },
     get: (filePath, creator, purge = true) => {
@@ -26,13 +29,13 @@ const Temp = {
         if (!Temp.store[filePath])
             return;
         delete Temp.store[filePath];
-        fs_1.default.unlinkAttempt(filePath);
+        fs.attempt.unlink(filePath);
     },
     purgeSync: (filePath) => {
         if (!Temp.store[filePath])
             return;
         delete Temp.store[filePath];
-        fs_1.default.unlinkSyncAttempt(filePath);
+        fs.attempt.unlinkSync(filePath);
     },
     purgeSyncAll: () => {
         for (const filePath in Temp.store) {
@@ -41,16 +44,16 @@ const Temp = {
     },
     truncate: (filePath) => {
         const basename = path.basename(filePath);
-        if (basename.length <= consts_1.LIMIT_BASENAME_LENGTH)
+        if (basename.length <= LIMIT_BASENAME_LENGTH)
             return filePath; //FIXME: Rough and quick attempt at detecting ok lengths
         const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
         if (!truncable)
             return filePath; //FIXME: No truncable part detected, can't really do much without also changing the parent path, which is unsafe, hoping for the best here
-        const truncationLength = basename.length - consts_1.LIMIT_BASENAME_LENGTH;
+        const truncationLength = basename.length - LIMIT_BASENAME_LENGTH;
         return `${filePath.slice(0, -basename.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`; //FIXME: The truncable part might be shorter than needed here
     }
 };
 /* INIT */
-process.on('exit', Temp.purgeSyncAll); // Ensuring purgeable temp files are purged on exit
+whenExit(Temp.purgeSyncAll); // Ensuring purgeable temp files are purged on exit
 /* EXPORT */
-exports.default = Temp;
+export default Temp;