@gjsify/fs 0.0.1 → 0.0.2

package/src/index.ts

@@ -0,0 +1,95 @@
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  rmdirSync,
+  unlinkSync,
+  watch,
+  mkdtempSync,
+  rmSync,
+  statSync,
+  openSync,
+  realpathSync,
+  symlinkSync,
+  lstatSync,
+} from './sync.js';
+import { open,
+  close,
+  read,
+  write,
+  rm,
+  realpath,
+  readdir,
+  symlink,
+  lstat,
+} from './callback.js';
+import FSWatcher from './fs-watcher.js';
+import {
+  createReadStream,
+  ReadStream
+} from './read-stream.js';
+import * as promises from './promises.js';
+
+export {
+  FSWatcher,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  rmdirSync,
+  unlinkSync,
+  mkdtempSync,
+  rmSync,
+  statSync,
+  openSync,
+  realpathSync,
+  symlinkSync,
+  lstatSync,
+  watch,
+  createReadStream,
+  ReadStream,
+  promises,
+  open,
+  close,
+  read,
+  write,
+  rm,
+  realpath,
+  readdir,
+  symlink,
+  lstat,
+};
+
+export default {
+  FSWatcher,
+  existsSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  rmdirSync,
+  unlinkSync,
+  mkdtempSync,
+  rmSync,
+  statSync,
+  openSync,
+  realpathSync,
+  symlinkSync,
+  lstatSync,
+  watch,
+  createReadStream,
+  ReadStream,
+  promises,
+  open,
+  close,
+  read,
+  write,
+  rm,
+  realpath,
+  readdir,
+  symlink,
+  lstat,
+};

package/src/promises.spec.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect } from '@gjsify/unit';
+import { promises, existsSync } from 'fs';
+import { mkdir, readdir, mkdtemp, writeFile, rm, rmdir } from 'fs/promises';
+import { join } from 'path';
+import { Buffer } from 'buffer';
+
+export default async () => {
+
+	await describe('fs/promises', async () => {
+		await it('import over "fs/should" should be work', async () => {
+			expect(typeof mkdir).toBe("function");
+		});
+	});
+
+	await describe('fs.promises.readdir', async () => {
+		await it('should return no files for an empty directory', async () => {
+			const dir = await mkdtemp('fs-test-');
+			const files = await readdir(dir);
+			expect(files.length).toBe(0);
+
+			// Clear
+			await rmdir(dir);
+		});
+
+		await it('should return the files for non-empty directory', async () => {
+			const dir = await mkdtemp('fs-test-');
+			const txt1 = join(dir, 'test1.txt');
+			const txt2 = join(dir, 'test2.txt');
+			const dir1 = join(dir, 'empty-dir');
+			await writeFile(txt1, '');
+			await writeFile(txt2, '');
+			await mkdir(dir1);
+			const files = await readdir(dir);
+			expect(files.length).toEqual(3);
+
+			// Clear
+			await rm(txt1);
+			await rm(txt2);
+			await rmdir(dir1);
+			await rmdir(dir);
+		});
+
+		await it('should return the file with the name "file.txt"', async () => {
+			const dir = await mkdtemp('fs-test-');
+			const expectedFileName = 'file.txt';
+			const file = join(dir, expectedFileName);
+
+			await writeFile(file, '');
+
+			const files = await readdir(dir);
+			expect(files[0]).toEqual(expectedFileName);
+
+			// Clear
+			await rm(file);
+			await rmdir(dir);
+		});
+
+		await it('should return with file types if option "withFileTypes" is `true`', async () => {
+			const dir = await mkdtemp('fs-test-');
+			const expectedFile = 'file.txt';
+			const expectedDir = 'subdir';
+			const file = join(dir, expectedFile);
+			const subdir = join(dir, expectedDir);
+
+			await writeFile(file, '');
+			await mkdir(subdir);
+
+			const files = await readdir(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
+			await rm(file);
+			await rmdir(subdir);
+			await rmdir(dir);
+		});
+	});
+
+	await describe('fs.promises.readFile', async () => {
+
+		await it('should be a function', async () => {
+			expect(typeof promises.readFile).toBe("function");
+		});
+
+		await it('should be a promise', async () => {
+			expect(promises.readFile('./test/file.txt', 'utf-8') instanceof Promise).toBeTruthy();
+		});
+
+		await it('should return a Buffer if no encoding was specified', async () => {
+			const bufferData = await promises.readFile('package.json');
+			expect(bufferData instanceof Buffer).toBeTruthy();
+		});
+
+		await it('should return a string when encoding is utf-8', async () => {
+			const utf8Data = await promises.readFile('./test/file.txt', 'utf-8');
+			expect(typeof utf8Data === 'string').toBeTruthy();
+		});
+
+		await it('should return a string with "Hello World"', async () => {
+			const utf8Data = await promises.readFile('./test/file.txt', 'utf-8');
+			expect(utf8Data).toBe('Hello World');
+		});
+	});
+
+	await describe('fs.promises.mkdtemp', async () => {
+		await it('should be a function', async () => {
+			expect(typeof promises.mkdtemp).toBe("function");
+		});
+
+		await it('should create a new directory', async () => {
+			const directory = await promises.mkdtemp('fs-test-');
+			expect(existsSync(directory)).toBeTruthy();
+			await promises.rmdir(directory);
+		});
+	});
+
+	await describe('fs.promises.rm', async () => {
+		await it('should be a function', async () => {
+			expect(typeof promises.rm).toBe("function");
+		});
+
+		await it('should remove an text file', async () => {
+
+			const dir = await promises.mkdtemp('fs-test-');
+			const txt1 = join(dir, 'file1.txt');
+			await promises.writeFile(txt1, '');
+
+
+			expect(existsSync(txt1)).toBeTruthy();
+			await promises.rm(txt1);
+			expect(existsSync(txt1)).toBeFalsy();
+			
+			// Clear
+			await promises.rmdir(dir);
+		});
+
+		await it('should not remove an non-empty folder if recursive option is false and should remove an non-empty folder if recursive option is true', async () => {
+
+			const dir = await promises.mkdtemp('fs-test-');
+
+			await promises.writeFile(join(dir, "file1.txt"), "");
+			await promises.writeFile(join(dir, "file2.txt"), "");
+			await promises.mkdir(join(dir, "some_dir"));
+			await promises.mkdir(join(dir, "some_dir", "file.txt"));
+
+			expect(existsSync(dir)).toBeTruthy();
+
+			try {
+				await promises.rm(dir, { recursive: false });
+			} catch (error) {
+				expect(error).toBeDefined();
+			}
+
+			// Dir should still exists because recursive was `false`
+			expect(existsSync(dir)).toBeTruthy();
+
+			await promises.rm(dir, { recursive: true });
+
+			// Dir should not exists anymore because recursive was `true`
+			expect(existsSync(dir)).toBeFalsy();
+		});
+	});
+}

package/src/promises.ts

@@ -0,0 +1,349 @@
+import Gio from '@girs/gio-2.0';
+import GLib from '@girs/glib-2.0';
+import { warnNotImplemented } from '@gjsify/utils';
+import { join } from 'path';
+import { getEncodingFromOptions, encodeUint8Array, decode } from './encoding.js';
+import { writeFileSync, mkdirSync, rmdirSync, unlinkSync } from './sync.js';
+import { FileHandle } from './file-handle.js';
+import { tempDirPath } from './utils.js';
+import { Dirent } from './dirent.js';
+
+import { realpathPromise as realpath } from '@gjsify/deno_std/node/_fs/_fs_realpath';
+import { readdirPromise as readdir } from '@gjsify/deno_std/node/_fs/_fs_readdir';
+import { symlinkPromise as symlink } from '@gjsify/deno_std/node/_fs/_fs_symlink';
+import { lstatPromise as lstat } from '@gjsify/deno_std/node/_fs/_fs_lstat';
+import { statPromise as stat } from '@gjsify/deno_std/node/_fs/_fs_stat';
+
+import type { 
+  OpenFlags,
+  ReadOptions,
+} from './types/index.js';
+import type {
+  PathLike,
+  Mode,
+  RmOptions,
+  ObjectEncodingOptions,
+  BufferEncodingOption,
+  MakeDirectoryOptions,
+  RmDirOptions
+} from 'fs';
+
+/**
+ * Asynchronously creates a directory.
+ *
+ * The optional `options` argument can be an integer specifying `mode` (permission
+ * and sticky bits), or an object with a `mode` property and a `recursive`property indicating whether parent directories should be created. Calling`fsPromises.mkdir()` when `path` is a directory
+ * that exists results in a
+ * rejection only when `recursive` is false.
+ * @since v10.0.0
+ * @return Upon success, fulfills with `undefined` if `recursive` is `false`, or the first directory path created if `recursive` is `true`.
+ */
+async function mkdir(
+  path: PathLike,
+  options: MakeDirectoryOptions & {
+    recursive: true;
+  }
+): Promise<string | undefined>;
+/**
+ * Asynchronous 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`.
+ */
+async function mkdir(
+  path: PathLike,
+  options?:
+      | Mode
+      | (MakeDirectoryOptions & {
+            recursive?: false | undefined;
+        })
+      | null
+): Promise<void>;
+/**
+ * Asynchronous 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`.
+ */
+async function mkdir(path: PathLike, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined> 
+
+async function mkdir(path: PathLike, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined | void> {
+
+  let recursive: boolean | undefined;
+  let mode: Mode | undefined = 0o777;
+
+  if (typeof options === 'object') {
+    if(options.recursive) recursive = options.recursive;
+    if(options.mode) mode = options.mode
+  } else {
+    mode = options;
+  }
+
+  // TODO async
+  const firstPath = mkdirSync(path, {
+    recursive,
+    mode
+  });
+  return firstPath;
+}
+
+async function readFile(path: PathLike | FileHandle, options: ReadOptions = { encoding: null, flag: 'r' }) {
+  const file = Gio.File.new_for_path(path.toString());
+
+  const [ok, data] = await new Promise<[boolean, Uint8Array, string]>((resolve, reject) => {
+    file.load_contents_async(null, (self, res) => {
+      try {
+        resolve(file.load_contents_finish(res));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+
+  if (!ok) {
+    // TODO: throw a better error
+    throw new Error('failed to read file');
+  }
+
+  return encodeUint8Array(getEncodingFromOptions(options, 'buffer'), data);
+}
+
+/**
+ * Creates a unique temporary directory. A unique directory name is generated by
+ * appending six random characters to the end of the provided `prefix`. Due to
+ * platform inconsistencies, avoid trailing `X` characters in `prefix`. Some
+ * platforms, notably the BSDs, can return more than six random characters, and
+ * replace trailing `X` characters in `prefix` with random characters.
+ *
+ * The optional `options` argument can be a string specifying an encoding, or an
+ * object with an `encoding` property specifying the character encoding to use.
+ *
+ * ```js
+ * import { mkdtemp } from 'fs/promises';
+ *
+ * try {
+ *   await mkdtemp(path.join(os.tmpdir(), 'foo-'));
+ * } catch (err) {
+ *   console.error(err);
+ * }
+ * ```
+ *
+ * The `fsPromises.mkdtemp()` method will append the six randomly selected
+ * characters directly to the `prefix` string. For instance, given a directory`/tmp`, if the intention is to create a temporary directory _within_`/tmp`, the`prefix` must end with a trailing
+ * platform-specific path separator
+ * (`require('path').sep`).
+ * @since v10.0.0
+ * @return Fulfills with a string containing the filesystem path of the newly created temporary directory.
+ */
+ async function mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string>;
+/**
+ * Asynchronously 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.
+ */
+async function mkdtemp(prefix: string, options: BufferEncodingOption): Promise<Buffer>;
+/**
+ * Asynchronously 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.
+ */
+async function mkdtemp(prefix: string, options?: ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer>;
+
+async function mkdtemp(prefix: string, options?: BufferEncodingOption | ObjectEncodingOptions | BufferEncoding | null): Promise<string | Buffer> {
+  const encoding: string | undefined = getEncodingFromOptions(options);
+  const path = tempDirPath(prefix);
+
+  await mkdir(
+    path,
+    { recursive: false, mode: 0o700 }
+  )
+
+  return decode(path, encoding);
+}
+
+async function writeFile(path: string, data: any) {
+  // TODO async
+  return writeFileSync(path, data);
+}
+
+/**
+ * Removes the directory identified by `path`.
+ *
+ * Using `fsPromises.rmdir()` on a file (not a directory) results in the
+ * promise being rejected with an `ENOENT` error on Windows and an `ENOTDIR`error on POSIX.
+ *
+ * To get a behavior similar to the `rm -rf` Unix command, use `fsPromises.rm()` with options `{ recursive: true, force: true }`.
+ * @since v10.0.0
+ * @return Fulfills with `undefined` upon success.
+ */
+async function rmdir(path: PathLike, options?: RmDirOptions): Promise<void> {
+  // TODO async
+  return rmdirSync(path, options);
+}
+
+async function unlink(path: string) {
+  // TODO async
+  return unlinkSync(path);
+}
+
+async function open(path: PathLike, flags?: OpenFlags, mode?: Mode): Promise<FileHandle> {
+  return new FileHandle({
+    path,
+    flags,
+    mode,
+  });
+}
+
+async function write<TBuffer extends Uint8Array>(
+  fd: number,
+  buffer: TBuffer,
+  offset?: number | null,
+  length?: number | null,
+  position?: number | null
+): Promise<{
+  bytesWritten: number;
+  buffer: TBuffer;
+}>
+
+async function write(
+  fd: number,
+  data: string,
+  position?: number | null,
+  encoding?: BufferEncoding | null
+): Promise<{
+  bytesWritten: number;
+  buffer: string;
+}>
+
+async function write<TBuffer extends Uint8Array>(
+  fd: number,
+  data: string | TBuffer,
+  positionOrOffset?: number | null,
+  encodingOrLength?: BufferEncoding | null | number,
+  position?: number | null
+): Promise<{
+  bytesWritten: number;
+  buffer: string;
+}> {
+  if(typeof data === 'string') {
+    return _writeStr(fd, data, positionOrOffset, encodingOrLength as BufferEncoding | null);
+  }
+  return _writeBuf<any>(fd, data, positionOrOffset as number | null, encodingOrLength as  null | number, position);
+}
+
+async function _writeBuf<TBuffer extends Uint8Array>(
+  fd: number,
+  buffer: TBuffer,
+  offset?: number | null,
+  length?: number | null,
+  position?: number | null
+): Promise<{
+  bytesWritten: number;
+  buffer: TBuffer;
+}> {
+  warnNotImplemented("fs.promises.write");
+  return {
+    bytesWritten: 0,
+    buffer
+  }
+}
+
+async function _writeStr(
+  fd: number,
+  data: string,
+  position?: number | null,
+  encoding?: BufferEncoding | null
+): Promise<{
+  bytesWritten: number;
+  buffer: string;
+}> {
+  warnNotImplemented("fs.promises.write");
+  return {
+    bytesWritten: 0,
+    buffer: data,
+  }
+}
+
+/**
+ * Removes files and directories (modeled on the standard POSIX `rm` utility).
+ * @since v14.14.0
+ * @return Fulfills with `undefined` upon success.
+ */
+async function rm(path: PathLike, options?: RmOptions): Promise<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 = await readdir(path, { withFileTypes: true });
+
+    if (!recursive && childFiles.length) {
+      throw new Error('Dir is not empty!');
+    }
+  
+    for (const childFile of childFiles) {
+      if (childFile.isDirectory()) {
+        await rmdir(join(path.toString(), childFile.name), options);
+      } else if (childFile.isFile()) {
+        await rm(join(path.toString(), childFile.name), options);
+      }
+    }
+  }
+
+  const ok = await new Promise<boolean>((resolve, reject) => {
+    try {
+      file.delete_async(GLib.PRIORITY_DEFAULT, null, (self, res) => {
+        try {
+          resolve(file.delete_finish(res));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    } catch (error) {
+      reject(error);
+    }
+
+  });
+
+  if (!ok) {
+    // TODO: throw a better error
+    const err = new Error('failed to remove file ' + path);
+    throw err;
+  }
+}
+
+export {
+  readFile,
+  mkdir,
+  mkdtemp,
+  realpath,
+  readdir,
+  writeFile,
+  rmdir,
+  unlink,
+  open,
+  write,
+  rm,
+  lstat,
+  symlink,
+  stat,
+};
+
+export default {
+  readFile,
+  mkdir,
+  mkdtemp,
+  realpath,
+  readdir,
+  writeFile,
+  rmdir,
+  unlink,
+  open,
+  write,
+  rm,
+  lstat,
+  symlink,
+  stat,
+};

package/src/read-stream.ts

@@ -0,0 +1,98 @@
+// Credits https://github.com/denoland/deno_std/blob/main/node/_fs/_fs_streams.ts
+import GLib from '@girs/glib-2.0';
+import { notImplemented } from "@gjsify/utils";
+import { Buffer } from "buffer";
+import { Readable } from "stream";
+import { URL } from "url";
+
+import type { CreateReadStreamOptions } from 'fs/promises'; // Types from @types/node
+import type { PathLike, ReadStream as IReadStream } from 'fs'; // Types from @types/node
+
+/**
+ * Converts a file URL to a path string.
+ *
+ * ```ts
+ *      import { fromFileUrl } from "./posix.ts";
+ *      fromFileUrl("file:///home/foo"); // "/home/foo"
+ * ```
+ * @param url of a file URL
+ * @credits https://github.com/denoland/deno_std/blob/44d05e7a8d445888d989d49eb3e59eee3055f2c5/node/path/posix.ts#L486
+ */
+export function fromFileUrl(url: string | URL): string {
+  url = url instanceof URL ? url : new URL(url);
+  if (url.protocol != "file:") {
+    throw new TypeError("Must be a file URL.");
+  }
+  return decodeURIComponent(
+    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"),
+  );
+}
+
+export class ReadStream extends Readable implements IReadStream {
+  close(callback?: (err?: NodeJS.ErrnoException | null) => void): void {
+    // TODO
+    callback(notImplemented('ReadStream.close'));
+  }
+  /**
+   * The number of bytes that have been read so far.
+   * @since v6.4.0
+   */
+  bytesRead: number;
+  /**
+   * The path to the file the stream is reading from as specified in the first
+   * argument to `fs.createReadStream()`. If `path` is passed as a string, then`readStream.path` will be a string. If `path` is passed as a `Buffer`, then`readStream.path` will be a
+   * `Buffer`. If `fd` is specified, then`readStream.path` will be `undefined`.
+   * @since v0.1.93
+   */
+  path: string | Buffer;
+  /**
+   * This property is `true` if the underlying file has not been opened yet,
+   * i.e. before the `'ready'` event is emitted.
+   * @since v11.2.0, v10.16.0
+   */
+  pending: boolean;
+
+  constructor(path: PathLike, opts?: CreateReadStreamOptions) {
+    path = path instanceof URL ? fromFileUrl(path) : path;
+    const hasBadOptions = opts && (
+      opts.start || opts.end
+    );
+    if (hasBadOptions) {
+      notImplemented(
+        `fs.ReadStream.prototype.constructor with unsupported options (${
+          JSON.stringify(opts)
+        })`,
+      );
+    }
+    const file = GLib.IOChannel.new_file(path.toString(), "r")
+    const buffer = "";
+    super({
+      autoDestroy: true,
+      emitClose: true,
+      objectMode: false,
+      read: async function (_size) {
+        try {
+          let n = 0
+          file.read(buffer, 16 * 1024, n);
+          this.push(n ? Buffer.from(buffer.slice(0, n)) : null);
+        } catch (err) {
+          this.destroy(err as Error);
+        }
+      },
+      destroy: (err, cb) => {
+        try {
+          file.close();
+        } catch {}
+        cb(err);
+      },
+    });
+    this.path = path.toString();
+  }
+}
+
+export function createReadStream(
+  path: string | URL,
+  options?: CreateReadStreamOptions,
+): ReadStream {
+  return new ReadStream(path, options);
+}