@gjsify/fs 0.0.1 → 0.0.2

package/src/stat.spec.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect } from '@gjsify/unit';
+// import { join, dirname } from 'path';
+// import { fileURLToPath } from "url";
+
+// const __filename = fileURLToPath(import.meta.url)
+// const __dirname = dirname(__filename)
+
+import { statSync } from 'fs';
+import { stat } from 'fs/promises';
+
+export default async () => {
+	await describe('fs.statSync', async () => {
+
+		await it('Should return the file stat', async () => {
+
+            const s = statSync('tsconfig.json');
+
+            expect(s.atime instanceof Date).toBeTruthy();
+            expect(s.atimeMs).toBeGreaterThan(0);
+            expect(s.birthtime instanceof Date).toBeTruthy();
+            expect(s.birthtimeMs).toBeGreaterThan(0);
+            expect(s.blksize).toBeGreaterThan(0);
+            expect(s.blocks).toBeGreaterThan(0);
+            expect(s.ctime instanceof Date).toBeTruthy();
+            expect(s.ctimeMs).toBeGreaterThan(0);
+            expect(s.dev).toBeGreaterThan(0);
+            expect(s.gid).toBeGreaterThan(0);
+            expect(s.ino).toBeGreaterThan(0);
+            expect(s.mode).toBeGreaterThan(0);
+            expect(s.mtime instanceof Date).toBeTruthy();
+            expect(s.mtimeMs).toBeGreaterThan(0);
+            expect(s.nlink).toBeGreaterThan(0);
+            expect(s.rdev).toBeGreaterThan(-1);
+            expect(s.size).toBeGreaterThan(0);
+            expect(s.uid).toBeGreaterThan(0);
+            expect(s.isBlockDevice()).toBeFalsy();
+            expect(s.isCharacterDevice()).toBeFalsy();
+            expect(s.isDirectory()).toBeFalsy();
+            expect(s.isFIFO()).toBeFalsy();
+            expect(s.isFile()).toBeTruthy();
+            expect(s.isSocket()).toBeFalsy();
+            expect(s.isSymbolicLink()).toBeFalsy();
+		});
+	});
+
+	await describe('fs.stat (promise)', async () => {
+
+		await it('Should return the file stat', async () => {
+
+            const s = await stat('tsconfig.json');
+
+            expect(s.atime instanceof Date).toBeTruthy();
+            expect(s.atimeMs).toBeGreaterThan(0);
+            expect(s.birthtime instanceof Date).toBeTruthy();
+            expect(s.birthtimeMs).toBeGreaterThan(0);
+            expect(s.blksize).toBeGreaterThan(0);
+            expect(s.blocks).toBeGreaterThan(0);
+            expect(s.ctime instanceof Date).toBeTruthy();
+            expect(s.ctimeMs).toBeGreaterThan(0);
+            expect(s.dev).toBeGreaterThan(0);
+            expect(s.gid).toBeGreaterThan(0);
+            expect(s.ino).toBeGreaterThan(0);
+            expect(s.mode).toBeGreaterThan(0);
+            expect(s.mtime instanceof Date).toBeTruthy();
+            expect(s.mtimeMs).toBeGreaterThan(0);
+            expect(s.nlink).toBeGreaterThan(0);
+            expect(s.rdev).toBeGreaterThan(-1);
+            expect(s.size).toBeGreaterThan(0);
+            expect(s.uid).toBeGreaterThan(0);
+            expect(s.isBlockDevice()).toBeFalsy();
+            expect(s.isCharacterDevice()).toBeFalsy();
+            expect(s.isDirectory()).toBeFalsy();
+            expect(s.isFIFO()).toBeFalsy();
+            expect(s.isFile()).toBeTruthy();
+            expect(s.isSocket()).toBeFalsy();
+            expect(s.isSymbolicLink()).toBeFalsy();
+		});
+	});
+}

package/src/stats.ts

@@ -0,0 +1,106 @@
+import Gio from '@girs/gio-2.0';
+import { Dirent } from './dirent.js';
+import { basename } from 'path';
+
+import type { Stats as NodeStats, PathLike } from 'fs';
+
+/**
+ * A `fs.Stats` object provides information about a file.
+ *
+ * Objects returned from {@link stat}, {@link lstat} and {@link fstat} and
+ * their synchronous counterparts are of this type.
+ * If `bigint` in the `options` passed to those methods is true, the numeric values
+ * will be `bigint` instead of `number`, and the object will contain additional
+ * nanosecond-precision properties suffixed with `Ns`.
+ *
+ * ```console
+ * Stats {
+ *   dev: 2114,
+ *   ino: 48064969,
+ *   mode: 33188,
+ *   nlink: 1,
+ *   uid: 85,
+ *   gid: 100,
+ *   rdev: 0,
+ *   size: 527,
+ *   blksize: 4096,
+ *   blocks: 8,
+ *   atimeMs: 1318289051000.1,
+ *   mtimeMs: 1318289051000.1,
+ *   ctimeMs: 1318289051000.1,
+ *   birthtimeMs: 1318289051000.1,
+ *   atime: Mon, 10 Oct 2011 23:24:11 GMT,
+ *   mtime: Mon, 10 Oct 2011 23:24:11 GMT,
+ *   ctime: Mon, 10 Oct 2011 23:24:11 GMT,
+ *   birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
+ * ```
+ *
+ * `bigint` version:
+ *
+ * ```console
+ * BigIntStats {
+ *   dev: 2114n,
+ *   ino: 48064969n,
+ *   mode: 33188n,
+ *   nlink: 1n,
+ *   uid: 85n,
+ *   gid: 100n,
+ *   rdev: 0n,
+ *   size: 527n,
+ *   blksize: 4096n,
+ *   blocks: 8n,
+ *   atimeMs: 1318289051000n,
+ *   mtimeMs: 1318289051000n,
+ *   ctimeMs: 1318289051000n,
+ *   birthtimeMs: 1318289051000n,
+ *   atimeNs: 1318289051000000000n,
+ *   mtimeNs: 1318289051000000000n,
+ *   ctimeNs: 1318289051000000000n,
+ *   birthtimeNs: 1318289051000000000n,
+ *   atime: Mon, 10 Oct 2011 23:24:11 GMT,
+ *   mtime: Mon, 10 Oct 2011 23:24:11 GMT,
+ *   ctime: Mon, 10 Oct 2011 23:24:11 GMT,
+ *   birthtime: Mon, 10 Oct 2011 23:24:11 GMT }
+ * ```
+ * @since v0.1.21
+ */
+export class Stats extends Dirent implements NodeStats {
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    blksize: number;
+    blocks: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    /** The timestamp indicating the creation time of this file expressed in milliseconds since the POSIX Epoch. */
+    get birthtimeMs(): number {
+        const creationDateTime = this._info.get_creation_date_time();
+        return creationDateTime.get_microsecond() * 1000;
+    }
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    /** The timestamp indicating the creation time of this file. */
+    get birthtime(): Date {
+        const creationDateTime = this._info.get_creation_date_time();
+        return new Date(creationDateTime.format_iso8601());
+    }
+
+    protected _info: Gio.FileInfo;
+
+    constructor(path: PathLike, filename?: string) {
+        const pathStr = path.toString();
+        if (!filename) filename = basename(pathStr);
+        super(pathStr, filename);
+        if(!this._file) {
+            throw new TypeError('this._file is not defined!');
+        }
+        this._info = this._file.query_info('standard::', Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+    }
+}

package/src/symlink.spec.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from '@gjsify/unit';
+// import { join, dirname } from 'path';
+// import { fileURLToPath } from "url";
+
+// const __filename = fileURLToPath(import.meta.url)
+// const __dirname = dirname(__filename)
+
+import { symlink as symlinkCb, mkdtempSync, lstatSync } from 'fs';
+import { symlink, rmdir, unlink } from 'fs/promises';
+
+export default async () => {
+	await describe('fs.symlink', async () => {
+
+		await it('ASYNC: no callback function results in Error', () => {
+			expect(() => {
+                // @ts-ignore
+                symlinkCb("some/path", "some/other/path", "dir");
+            }).toThrow(Error)
+		});
+
+        // TODO FIXME
+		// await it('ASYNC: create symlink point to a dir', async () => {
+
+        //     const tmpDir = mkdtempSync('test_tmp_');
+        //     const linkedTmpDir = tmpDir + ".link";
+
+        //     await symlink(tmpDir, linkedTmpDir)
+        //     const stat = lstatSync(linkedTmpDir);
+
+        //     expect(stat.isSymbolicLink).toBeTruthy();
+
+        //     await rmdir(tmpDir);
+        //     await unlink(linkedTmpDir);
+		// });
+	});
+
+
+}

package/src/sync.spec.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect } from '@gjsify/unit';
+import { join, dirname } from 'path';
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+import { existsSync, readdirSync, readFileSync, mkdirSync, rmdirSync, writeFileSync, unlinkSync, watch, mkdtempSync, rmSync, realpathSync, symlinkSync } from 'fs';
+import { Buffer } from 'buffer';
+
+export default async () => {
+	await describe('fs.existsSync', async () => {
+
+		const existingFiles = ['tsconfig.json', 'package.json', 'README.md'];
+		const nonExistingFiles = ['asdasd', '/asdasd', ''];
+
+		await it('should return true for existing files', () => {
+			for (const file of existingFiles) {
+				const result = existsSync(file);
+				expect(result).toBe(true)
+			}
+		});
+
+		await it('should return false for non existing files', () => {
+			for (const file of nonExistingFiles) {
+				const result = existsSync(file);
+				expect(result).toBe(false)
+			}
+		});
+	});
+
+	await describe('fs.readdirSync', async () => {
+		await it('should return no files for an empty directory', () => {
+			const dir = mkdtempSync('fs-test-');
+			const files = readdirSync(dir);
+			expect(files.length).toBe(0);
+
+			// Clear
+			rmdirSync(dir);
+		});
+
+		await it('should return the files for non-empty directory', () => {
+			const dir = mkdtempSync('fs-test-');
+			const txt1 = join(dir, 'test1.txt');
+			const txt2 = join(dir, 'test2.txt');
+			const dir1 = join(dir, 'empty-dir');
+			writeFileSync(txt1, '');
+			writeFileSync(txt2, '');
+			mkdirSync(dir1);
+			const files = readdirSync(dir);
+			expect(files.length).toEqual(3);
+
+			// Clear
+			rmSync(txt1);
+			rmSync(txt2);
+			rmdirSync(dir1);
+			rmdirSync(dir);
+		});
+
+		await it('should return the file with the name "file.txt"', () => {
+			const dir = mkdtempSync('fs-test-');
+			const expectedFileName = 'file.txt';
+			const file = join(dir, expectedFileName);
+
+			writeFileSync(file, '');
+
+			const files = readdirSync(dir);
+			expect(files[0]).toEqual(expectedFileName);
+
+			// Clear
+			rmSync(file);
+			rmdirSync(dir);
+		});
+
+		await it('should return with file types if option "withFileTypes" is `true`', () => {
+			const dir = mkdtempSync('fs-test-');
+			const expectedFile = 'file.txt';
+			const expectedDir = 'subdir';
+			const file = join(dir, expectedFile);
+			const subdir = join(dir, expectedDir);
+
+			writeFileSync(file, '');
+			mkdirSync(subdir);
+
+			const files = readdirSync(dir, { withFileTypes: true });
+
+			expect(files.length).toBe(2);
+
+			const fileWithTypes = files.find((f) => f.name === expectedFile);
+			const dirWithTypes = files.find((f) => f.name === expectedDir);
+
+			expect(fileWithTypes.isFile()).toBeTruthy();
+			expect(fileWithTypes.isDirectory()).toBeFalsy();
+
+			expect(dirWithTypes.isFile()).toBeFalsy();
+			expect(dirWithTypes.isDirectory()).toBeTruthy();
+
+			// Clear
+			rmSync(file);
+			rmdirSync(subdir);
+			rmdirSync(dir);
+		});
+	});
+
+	await describe('fs.readFileSync', async () => {
+		await it('should return a Buffer if no encoding was specified', () => {
+			const bufferData = readFileSync('package.json');
+			expect(bufferData instanceof Buffer).toBeTruthy();
+		});
+
+		await it('should return a string when encoding is utf-8', () => {
+			const utf8Data = readFileSync('./test/file.txt', 'utf-8');
+			expect(typeof utf8Data === 'string').toBeTruthy();
+		});
+
+		await it('should return a string with "Hello World"', () => {
+			const utf8Data = readFileSync('./test/file.txt', 'utf-8');
+			expect(utf8Data).toBe('Hello World');
+		});
+	});
+
+	await describe('fs.mkdirSync', async () => {
+		const dir = './foobar';
+
+		await it(`should create the directory "${dir}" without error`, () => {
+			mkdirSync(dir);
+		});
+
+		await it(`${dir} should exists`, () => {
+			expect(existsSync(dir)).toBeTruthy();
+		});
+	});
+
+	await describe('fs.rmdirSync', async () => {
+		const dir = './foobar';
+
+		await it(`should be remove the directory "${dir}" without error`, () => {
+			rmdirSync(dir);
+		});
+
+		await it(`"${dir}" should not exists (anymore)`, () => {
+			expect(existsSync(dir)).toBeFalsy();
+		});
+	});
+
+	await describe('fs.writeFileSync', async () => {
+		const watchMe = join(__dirname, 'test/watch.js');
+
+		await it(`should be executed without error`, () => {
+			writeFileSync(watchMe, '// test');
+		});
+
+		await it(`fs.watch should watch ${watchMe} for changes`, () => {
+			const watcher = watch(watchMe, {persistent: true}, console.log);
+
+			watcher.on('change', console.log).on('rename', console.log);
+
+			setTimeout(() => { watcher.close(); }, 1000);
+
+			setTimeout(() => {
+				writeFileSync(watchMe, '// test');
+				setTimeout(() => {
+					unlinkSync(watchMe);
+				}, 100);
+			}, 100);
+		});
+	});
+
+	await describe('fs.mkdtempSync', async () => {
+
+		await it('should be a function', () => {
+			expect(typeof mkdtempSync).toBe("function");
+		});
+
+		await it('should create a new directory', () => {
+			const directory = mkdtempSync('fs-test-');
+			expect(existsSync(directory)).toBeTruthy();
+			rmdirSync(directory);
+		});
+	});
+
+	await describe('fs.realpathSync', async () => {
+
+		await it('should be a function', () => {
+			expect(typeof realpathSync).toBe("function");
+		});
+
+		await it('should return the real and absolute path', () => {
+			const tsConfig = "./tsconfig.json";
+			const tsConfigSymlink = "./symlink_tsconfig.json";
+
+			if(!existsSync(tsConfigSymlink)) {
+				symlinkSync(tsConfig, tsConfigSymlink);
+
+				const realPath = realpathSync(tsConfig);
+				const realSymLinkPath = realpathSync(tsConfigSymlink);
+
+				// Should point to the real file, not the symlink
+				expect(realSymLinkPath).toBe(realPath);
+			}
+
+			unlinkSync(tsConfigSymlink);
+		});
+	});
+}

package/src/sync.ts

@@ -0,0 +1,239 @@
+import GLib from '@girs/glib-2.0';
+import Gio from '@girs/gio-2.0';
+import { existsSync } from '@gjsify/utils';
+import { Buffer } from 'buffer';
+import { join } from 'path';
+
+import FSWatcher from './fs-watcher.js';
+import { getEncodingFromOptions, encodeUint8Array, decode } from './encoding.js';
+import { FileHandle } from './file-handle.js';
+import { Dirent } from './dirent.js';
+import { tempDirPath } from './utils.js';
+
+export { realpathSync } from '@gjsify/deno_std/node/_fs/_fs_realpath';
+import { readdirSync } from '@gjsify/deno_std/node/_fs/_fs_readdir';
+export { symlinkSync } from '@gjsify/deno_std/node/_fs/_fs_symlink';
+export { lstatSync } from '@gjsify/deno_std/node/_fs/_fs_lstat';
+export { statSync } from '@gjsify/deno_std/node/_fs/_fs_stat';
+
+
+
+import type { OpenFlags, EncodingOption } from './types/index.js';
+import type {
+  PathLike,
+  Mode,
+  MakeDirectoryOptions,
+  BufferEncodingOption,
+  RmOptions,
+  RmDirOptions,
+} from 'fs'; // Types from @types/node
+
+export { existsSync, readdirSync }
+
+export function readFileSync(path: string, options = { encoding: null, flag: 'r' }) {
+  const file = Gio.File.new_for_path(path);
+
+  const [ok, data] = file.load_contents(null);
+
+  if (!ok) {
+    // TODO: throw a better error
+    throw new Error('failed to read file');
+  }
+
+  return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
+}
+
+/**
+ * Synchronously creates a directory. Returns `undefined`, or if `recursive` is`true`, the first directory path created.
+ * This is the synchronous version of {@link mkdir}.
+ *
+ * See the POSIX [`mkdir(2)`](http://man7.org/linux/man-pages/man2/mkdir.2.html) documentation for more details.
+ * @since v0.1.21
+ */
+export function mkdirSync(
+  path: PathLike,
+  options: MakeDirectoryOptions & {
+      recursive: true;
+  }
+): string | undefined;
+/**
+ * Synchronous mkdir(2) - create a directory.
+ * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+ * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
+ * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
+ */
+export function mkdirSync(
+  path: PathLike,
+  options?:
+      | Mode
+      | (MakeDirectoryOptions & {
+            recursive?: false | undefined;
+        })
+      | null
+): void;
+/**
+ * Synchronous mkdir(2) - create a directory.
+ * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+ * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
+ * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
+ */
+export function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions | null): string | undefined | void
+/**
+ * Synchronous mkdir(2) - create a directory.
+ * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+ * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
+ * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
+ */
+export function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions | null): string | undefined | void {
+
+  let recursive = false
+  let mode: Mode | undefined = 0o777;
+
+  if (typeof options === 'object') {
+    if(options?.recursive) recursive = options.recursive;
+    if(options?.mode) mode = options.mode;
+  } else {
+    mode = options || 0o777;
+  }
+
+  if (typeof path !== 'string') {
+    path = path.toString();
+  }
+
+  if(typeof mode === 'string') {
+    throw new TypeError("mode as string is currently not supported!");
+  }
+
+  if (GLib.mkdir_with_parents(path, mode) !== 0) {
+    // TODO: throw a better error
+    throw new Error(`failed to make ${path} directory`);
+  }
+
+  if (recursive) {
+    // TODO: Returns `undefined`, or if `recursive` is`true`, the first directory path created.
+    return path.split('/')[0];
+  }
+  return undefined;
+}
+
+/**
+ * Synchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). Returns `undefined`.
+ *
+ * Using `fs.rmdirSync()` on a file (not a directory) results in an `ENOENT` error
+ * on Windows and an `ENOTDIR` error on POSIX.
+ *
+ * To get a behavior similar to the `rm -rf` Unix command, use {@link rmSync} with options `{ recursive: true, force: true }`.
+ * @since v0.1.21
+ */
+export function rmdirSync(path: PathLike, options?: RmDirOptions): void {
+
+  const recursive = options?.recursive || false;
+
+  const childFiles = readdirSync(path, { withFileTypes: true });
+
+  if (!recursive && childFiles.length) {
+    throw new Error('Dir is not empty!');
+  }
+
+  for (const childFile of childFiles) {
+    if (childFile.isDirectory()) {
+      rmdirSync(join(path.toString(), childFile.name));
+    } else if (childFile.isFile()) {
+      rmSync(join(path.toString(), childFile.name));
+    }
+  }
+
+  const result = GLib.rmdir(path.toString());
+
+  if (result !== 0) {
+    // TODO: throw a better error
+    throw new Error(`Failed to remove ${path} directory`);
+  }
+}
+
+export function unlinkSync(path: string) {
+  GLib.unlink(path);
+}
+
+export function writeFileSync(path: string, data: any) {
+  GLib.file_set_contents(path, data);
+}
+
+export function watch(filename: string, options, listener) {
+  return new FSWatcher(filename, options, listener);
+}
+
+export function openSync(path: PathLike, flags?: OpenFlags, mode?: Mode): FileHandle {
+  return new FileHandle({ path, flags, mode });
+}
+
+/**
+ * Returns the created directory path.
+ *
+ * For detailed information, see the documentation of the asynchronous version of
+ * this API: {@link mkdtemp}.
+ *
+ * The optional `options` argument can be a string specifying an encoding, or an
+ * object with an `encoding` property specifying the character encoding to use.
+ * @since v5.10.0
+ */
+export function mkdtempSync(prefix: string, options?: EncodingOption): string;
+/**
+ * Synchronously creates a unique temporary directory.
+ * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
+ * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
+ */
+export function mkdtempSync(prefix: string, options: BufferEncodingOption): Buffer;
+/**
+ * Synchronously creates a unique temporary directory.
+ * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
+ * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
+ */
+export function mkdtempSync(prefix: string, options?: EncodingOption): string | Buffer;
+
+export function mkdtempSync(prefix: string, options?: EncodingOption | BufferEncodingOption): string | Buffer {
+  const encoding: string | undefined = getEncodingFromOptions(options);
+  const path = tempDirPath(prefix);
+
+  mkdirSync(
+    path,
+    { recursive: false, mode: 0o777 }
+  )
+
+  return decode(path, encoding);
+}
+
+/**
+ * Synchronously removes files and directories (modeled on the standard POSIX `rm`utility). Returns `undefined`.
+ * @since v14.14.0
+ */
+export function rmSync(path: PathLike, options?: RmOptions): void {
+  const file = Gio.File.new_for_path(path.toString());
+  const recursive = options?.recursive || false;
+
+  const dirent = new Dirent(path.toString());
+
+  if (dirent.isDirectory()) {
+    const childFiles = readdirSync(path, { withFileTypes: true });
+
+    if (!recursive && childFiles.length) {
+      throw new Error('Dir is not empty!');
+    }
+  
+    for (const childFile of childFiles) {
+      if (childFile.isDirectory()) {
+        rmdirSync(join(path.toString(), childFile.name), options);
+      } else if (childFile.isFile()) {
+        rmSync(join(path.toString(), childFile.name), options);
+      }
+    }
+  }
+
+  const ok = file.delete(null);
+
+  if (!ok) {
+    // TODO: throw a better error
+    const err = new Error('failed to remove file ' + path);
+    throw err;
+  }
+}

package/src/test.mts

@@ -0,0 +1,11 @@
+
+import { run } from '@gjsify/unit';
+
+import testSuiteCallback from './callback.spec.js';
+import testSuiteFileHandle from './file-handle.spec.js';
+import testSuitePromise from './promises.spec.js';
+import testSuiteSync from './sync.spec.js';
+import testSuiteSymlink from './symlink.spec.js';
+import testSuiteStat from './stat.spec.js';
+
+run({testSuiteCallback, testSuiteFileHandle, testSuitePromise, testSuiteSync, testSuiteSymlink, testSuiteStat});

package/src/types/encoding-option.ts

@@ -0,0 +1,3 @@
+import type { ObjectEncodingOptions } from 'fs'; // Types from @types/node
+
+export type EncodingOption = ObjectEncodingOptions | BufferEncoding | undefined | null;

package/src/types/file-read-options.ts

@@ -0,0 +1,15 @@
+export interface FileReadOptions<T extends NodeJS.ArrayBufferView = Buffer> {
+    /**
+     * @default `Buffer.alloc(0xffff)`
+     */
+    buffer?: T;
+    /**
+     * @default 0
+     */
+    offset?: number | null;
+    /**
+     * @default `buffer.byteLength`
+     */
+    length?: number | null;
+    position?: number | null;
+}