@gjsify/fs 0.0.1 → 0.0.3

package/README.md

@@ -1,9 +1,7 @@
-# @gjsify/fs [![License: ISC](https://img.shields.io/badge/License-ISC-yellow.svg)](https://opensource.org/licenses/ISC)
+# @gjsify/fs
 
-fs core module for [gjs](https://gitlab.gnome.org/GNOME/gjs) forked from [@cgjs/fs](https://github.com/cgjs/cgjs/tree/master/packages/fs)
-
-* [x] existsSync
-* [x] readdirSync
-* [x] readFileSync
-* [x] mkdirSync
-* [x] rmdirSync
+## Inspirations
+- https://github.com/cgjs/cgjs/blob/master/packages/fs/index.js
+- https://github.com/geut/brode/blob/main/packages/browser-node-core/src/fs.js
+- https://github.com/mafintosh/level-filesystem/blob/master/index.js
+- https://github.com/denoland/deno_std/blob/main/node/fs.ts

package/lib/cjs/callback.js

@@ -0,0 +1,112 @@
+import { open as openP, rm as rmP } from "./promises.js";
+import { warnNotImplemented } from "@gjsify/utils";
+import { FileHandle } from "./file-handle.js";
+import { Buffer } from "buffer";
+import { realpath } from "@gjsify/deno_std/node/_fs/_fs_realpath";
+import { readdir } from "@gjsify/deno_std/node/_fs/_fs_readdir";
+import { symlink } from "@gjsify/deno_std/node/_fs/_fs_symlink";
+import { lstat } from "@gjsify/deno_std/node/_fs/_fs_lstat";
+import { stat } from "@gjsify/deno_std/node/_fs/_fs_stat";
+function open(path, ...args) {
+  let flags;
+  let mode;
+  let callback;
+  switch (args.length) {
+    case 1:
+      callback = args[0];
+      break;
+    case 2:
+      flags = args[0];
+      callback = args[1];
+      break;
+    case 3:
+      flags = args[0];
+      mode = args[1];
+      callback = args[2];
+      break;
+    default:
+      break;
+  }
+  openP(path, flags, mode).then((fileHandle) => {
+    callback(null, fileHandle.fd);
+  }).catch((err) => {
+    callback(err, -1);
+  });
+}
+function write(fd, data, ...args) {
+  const fileHandle = FileHandle.getInstance(fd);
+  if (typeof data === "string") {
+    const callback2 = args[args.length - 1];
+    fileHandle.write(data, ...args.pop()).then((res) => {
+      callback2(null, res.bytesWritten, res.buffer);
+    }).catch((err) => {
+      callback2(err, 0, "");
+    });
+    return;
+  }
+  const callback = args[args.length - 1];
+  const offset = args[0];
+  const length = args[1];
+  const position = args[2];
+  fileHandle.write(data, offset, length, position).then((res) => {
+    callback(null, res.bytesWritten, res.buffer);
+  }).catch((err) => {
+    callback(err, 0, Buffer.from([]));
+  });
+}
+function read(fd, ...args) {
+  const fileHandle = FileHandle.getInstance(fd);
+  const callback = args[args.length - 1];
+  const err = new Error(warnNotImplemented("fs.read"));
+  callback(err, 0, Buffer.from(""));
+  let buffer;
+  let offset;
+  let length;
+  let position;
+  if (typeof args[0] === "object") {
+    const options = args[0];
+    buffer = options.buffer;
+    offset = options.offset;
+    length = options.length;
+    position = options.position;
+  } else {
+    buffer = args[0];
+    offset = args[1];
+    length = args[2];
+    position = args[3];
+  }
+  fileHandle.read(buffer, offset, length, position).then((res) => {
+    callback(null, res.bytesRead, res.buffer);
+  }).catch((err2) => {
+    callback(err2, 0, Buffer.from([]));
+  });
+}
+function close(fd, callback) {
+  FileHandle.getInstance(fd).close().then(() => {
+    callback(null);
+  }).catch((err) => callback(err));
+}
+function rm(path, ...args) {
+  let options = {};
+  let callback = args[args.length - 1];
+  if (args.length >= 2) {
+    options = args[0];
+  }
+  rmP(path, options).then(() => {
+    callback(null);
+  }).catch((err) => {
+    callback(err);
+  });
+}
+export {
+  close,
+  lstat,
+  open,
+  read,
+  readdir,
+  realpath,
+  rm,
+  stat,
+  symlink,
+  write
+};

package/lib/cjs/dirent.js

@@ -0,0 +1,98 @@
+import Gio from "@girs/gio-2.0";
+import { basename } from "path";
+class Dirent {
+  /**
+   * The file name that this `fs.Dirent` object refers to. The type of this
+   * value is determined by the `options.encoding` passed to {@link readdir} or {@link readdirSync}.
+   * @since v10.10.0
+   */
+  name;
+  _isFile = false;
+  _isDirectory = false;
+  _isBlockDevice = false;
+  _isCharacterDevice = false;
+  _isSymbolicLink = false;
+  _isFIFO = false;
+  _isSocket = false;
+  /** This is not part of node.fs and is used internal by gjsify */
+  _file;
+  /** This is not part of node.fs and is used internal by gjsify */
+  constructor(path, filename) {
+    if (!filename)
+      filename = basename(path);
+    this.name = filename;
+    this._file = Gio.File.new_for_path(path);
+    const type = this._file.query_file_type(Gio.FileQueryInfoFlags.NONE, null);
+    switch (type) {
+      case Gio.FileType.DIRECTORY:
+        this._isDirectory = true;
+        break;
+      case Gio.FileType.MOUNTABLE:
+        break;
+      case Gio.FileType.REGULAR:
+        this._isFile = true;
+        break;
+      case Gio.FileType.SYMBOLIC_LINK:
+      case Gio.FileType.SHORTCUT:
+        this._isSymbolicLink = true;
+        break;
+      case Gio.FileType.SPECIAL:
+        this._isBlockDevice = Gio.unix_is_system_device_path(path);
+        break;
+    }
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a regular file.
+   * @since v10.10.0
+   */
+  isFile() {
+    return this._isFile;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a file system
+   * directory.
+   * @since v10.10.0
+   */
+  isDirectory() {
+    return this._isDirectory;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a block device.
+   * @since v10.10.0
+   */
+  isBlockDevice() {
+    return this._isBlockDevice;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a character device.
+   * @since v10.10.0
+   */
+  isCharacterDevice() {
+    return this._isCharacterDevice;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a symbolic link.
+   * @since v10.10.0
+   */
+  isSymbolicLink() {
+    return this._isSymbolicLink;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a first-in-first-out
+   * (FIFO) pipe.
+   * @since v10.10.0
+   */
+  isFIFO() {
+    return this._isFIFO;
+  }
+  /**
+   * Returns `true` if the `fs.Dirent` object describes a socket.
+   * @since v10.10.0
+   */
+  isSocket() {
+    return this._isSocket;
+  }
+}
+export {
+  Dirent
+};

package/lib/cjs/encoding.js

@@ -0,0 +1,34 @@
+import { Buffer } from "buffer";
+function getEncodingFromOptions(options = { encoding: null, flag: "r" }, defaultEncoding = "utf8") {
+  if (options === null) {
+    return defaultEncoding;
+  }
+  if (typeof options === "string") {
+    return options;
+  }
+  if (typeof options === "object" && typeof options.encoding === "string") {
+    return options.encoding;
+  }
+  return defaultEncoding;
+}
+function encodeUint8Array(encoding, data) {
+  if (encoding === "buffer") {
+    return Buffer.from(data);
+  }
+  const decoder = new TextDecoder(encoding);
+  return decoder.decode(data);
+}
+function decode(str, encoding) {
+  if (!encoding)
+    return str;
+  else {
+    const decoder = new TextDecoder(encoding);
+    const encoder = new TextEncoder();
+    return decoder.decode(encoder.encode(str));
+  }
+}
+export {
+  decode,
+  encodeUint8Array,
+  getEncodingFromOptions
+};

package/lib/cjs/file-handle.js

@@ -0,0 +1,444 @@
+import { warnNotImplemented, notImplemented } from "@gjsify/utils";
+import { ReadStream } from "./read-stream.js";
+import { WriteStream } from "./write-stream.js";
+import { Stats } from "./stats.js";
+import { getEncodingFromOptions, encodeUint8Array } from "./encoding.js";
+import GLib from "@girs/glib-2.0";
+import { ReadableStream } from "stream/web";
+import { Buffer } from "buffer";
+class FileHandle {
+  constructor(options) {
+    this.options = options;
+    this.options.flags ||= "r";
+    this.options.mode ||= 438;
+    this._file = GLib.IOChannel.new_file(options.path.toString(), this.options.flags);
+    this.fd = this._file.unix_get_fd();
+    FileHandle.instances[this.fd] = this;
+    return FileHandle.getInstance(this.fd);
+  }
+  /** Not part of the default implementation, used internal by gjsify */
+  _file;
+  /** Not part of the default implementation, used internal by gjsify */
+  static instances = {};
+  /**
+   * The numeric file descriptor managed by the {FileHandle} object.
+   * @since v10.0.0
+   */
+  fd;
+  /** Not part of the default implementation, used internal by gjsify */
+  static getInstance(fd) {
+    const instance = FileHandle.instances[fd];
+    if (!instance) {
+      throw new Error("No instance found for fd!");
+    }
+    return FileHandle.instances[fd];
+  }
+  /**
+   * Alias of `filehandle.writeFile()`.
+   *
+   * When operating on file handles, the mode cannot be changed from what it was set
+   * to with `fsPromises.open()`. Therefore, this is equivalent to `filehandle.writeFile()`.
+   * @since v10.0.0
+   * @return Fulfills with `undefined` upon success.
+   */
+  async appendFile(data, options) {
+    const encoding = getEncodingFromOptions(options);
+    if (typeof data === "string") {
+      data = Buffer.from(data);
+    }
+    if (encoding)
+      this._file.set_encoding(encoding);
+    const [status, written] = this._file.write_chars(data, data.length);
+    if (status === GLib.IOStatus.ERROR) {
+      throw new Error("Error on append to file!");
+    }
+  }
+  /**
+   * Changes the ownership of the file. A wrapper for [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html).
+   * @since v10.0.0
+   * @param uid The file's new owner's user id.
+   * @param gid The file's new group's group id.
+   * @return Fulfills with `undefined` upon success.
+   */
+  async chown(uid, gid) {
+    warnNotImplemented("fs.FileHandle.chown");
+  }
+  /**
+   * Modifies the permissions on the file. See [`chmod(2)`](http://man7.org/linux/man-pages/man2/chmod.2.html).
+   * @since v10.0.0
+   * @param mode the file mode bit mask.
+   * @return Fulfills with `undefined` upon success.
+   */
+  async chmod(mode) {
+    warnNotImplemented("fs.FileHandle.chmod");
+  }
+  /**
+   * Unlike the 16 kb default `highWaterMark` for a `stream.Readable`, the stream
+   * returned by this method has a default `highWaterMark` of 64 kb.
+   *
+   * `options` can include `start` and `end` values to read a range of bytes from
+   * the file instead of the entire file. Both `start` and `end` are inclusive and
+   * start counting at 0, allowed values are in the
+   * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. If `start` is
+   * omitted or `undefined`, `filehandle.createReadStream()` reads sequentially from
+   * the current file position. The `encoding` can be any one of those accepted by `Buffer`.
+   *
+   * If the `FileHandle` points to a character device that only supports blocking
+   * reads (such as keyboard or sound card), read operations do not finish until data
+   * is available. This can prevent the process from exiting and the stream from
+   * closing naturally.
+   *
+   * By default, the stream will emit a `'close'` event after it has been
+   * destroyed.  Set the `emitClose` option to `false` to change this behavior.
+   *
+   * ```js
+   * import { open } from 'fs/promises';
+   *
+   * const fd = await open('/dev/input/event0');
+   * // Create a stream from some character device.
+   * const stream = fd.createReadStream();
+   * setTimeout(() => {
+   *   stream.close(); // This may not close the stream.
+   *   // Artificially marking end-of-stream, as if the underlying resource had
+   *   // indicated end-of-file by itself, allows the stream to close.
+   *   // This does not cancel pending read operations, and if there is such an
+   *   // operation, the process may still not be able to exit successfully
+   *   // until it finishes.
+   *   stream.push(null);
+   *   stream.read(0);
+   * }, 100);
+   * ```
+   *
+   * If `autoClose` is false, then the file descriptor won't be closed, even if
+   * there's an error. It is the application's responsibility to close it and make
+   * sure there's no file descriptor leak. If `autoClose` is set to true (default
+   * behavior), on `'error'` or `'end'` the file descriptor will be closed
+   * automatically.
+   *
+   * An example to read the last 10 bytes of a file which is 100 bytes long:
+   *
+   * ```js
+   * import { open } from 'fs/promises';
+   *
+   * const fd = await open('sample.txt');
+   * fd.createReadStream({ start: 90, end: 99 });
+   * ```
+   * @since v16.11.0
+   */
+  createReadStream(options) {
+    return new ReadStream(this.options.path, options);
+  }
+  /**
+   * `options` may also include a `start` option to allow writing data at some
+   * position past the beginning of the file, allowed values are in the
+   * \[0, [`Number.MAX_SAFE_INTEGER`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER)\] range. Modifying a file rather than
+   * replacing it may require the `flags` `open` option to be set to `r+` rather than
+   * the default `r`. The `encoding` can be any one of those accepted by `Buffer`.
+   *
+   * If `autoClose` is set to true (default behavior) on `'error'` or `'finish'`the file descriptor will be closed automatically. If `autoClose` is false,
+   * then the file descriptor won't be closed, even if there's an error.
+   * It is the application's responsibility to close it and make sure there's no
+   * file descriptor leak.
+   *
+   * By default, the stream will emit a `'close'` event after it has been
+   * destroyed.  Set the `emitClose` option to `false` to change this behavior.
+   * @since v16.11.0
+   */
+  createWriteStream(options) {
+    return new WriteStream(this.options.path, options);
+  }
+  /**
+   * Forces all currently queued I/O operations associated with the file to the
+   * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details.
+   *
+   * Unlike `filehandle.sync` this method does not flush modified metadata.
+   * @since v10.0.0
+   * @return Fulfills with `undefined` upon success.
+   */
+  async datasync() {
+    warnNotImplemented("fs.FileHandle.datasync");
+  }
+  /**
+   * Request that all data for the open file descriptor is flushed to the storage
+   * device. The specific implementation is operating system and device specific.
+   * Refer to the POSIX [`fsync(2)`](http://man7.org/linux/man-pages/man2/fsync.2.html) documentation for more detail.
+   * @since v10.0.0
+   * @return Fufills with `undefined` upon success.
+   */
+  async sync() {
+    warnNotImplemented("fs.FileHandle.sync");
+  }
+  async read(args) {
+    let buffer;
+    let offset;
+    let length;
+    let position;
+    if (typeof args[0] === "object") {
+      const options = args[0];
+      buffer = options.buffer;
+      offset = options.offset;
+      length = options.length;
+      position = options.position;
+    } else {
+      buffer = args[0];
+      offset = args[1];
+      length = args[2];
+      position = args[3];
+    }
+    if (offset) {
+      const status2 = this._file.seek_position(offset, GLib.SeekType.CUR);
+      if (status2 === GLib.IOStatus.ERROR) {
+        throw new Error("Error on set offset!");
+      }
+    }
+    if (length)
+      this._file.set_buffer_size(length);
+    if (position) {
+      const status2 = this._file.seek_position(position, GLib.SeekType.SET);
+      if (status2 === GLib.IOStatus.ERROR) {
+        throw new Error("Error on set position!");
+      }
+    }
+    const [status, buf, bytesRead] = this._file.read_chars();
+    if (status === GLib.IOStatus.ERROR) {
+      throw new Error("Error on read!");
+    }
+    buffer = buf;
+    return {
+      bytesRead,
+      buffer
+    };
+  }
+  /**
+   * Returns a `ReadableStream` that may be used to read the files data.
+   *
+   * An error will be thrown if this method is called more than once or is called after the `FileHandle` is closed
+   * or closing.
+   *
+   * ```js
+   * import { open } from 'fs/promises';
+   *
+   * const file = await open('./some/file/to/read');
+   *
+   * for await (const chunk of file.readableWebStream())
+   *   console.log(chunk);
+   *
+   * await file.close();
+   * ```
+   *
+   * While the `ReadableStream` will read the file to completion, it will not close the `FileHandle` automatically. User code must still call the `fileHandle.close()` method.
+   *
+   * @since v17.0.0
+   * @experimental
+   */
+  readableWebStream() {
+    return new ReadableStream();
+  }
+  /**
+   * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
+   * The `FileHandle` must have been opened for reading.
+   * @param options An object that may contain an optional flag.
+   * If a flag is not provided, it defaults to `'r'`.
+   */
+  async readFile(options) {
+    const encoding = getEncodingFromOptions(options, "buffer");
+    if (encoding)
+      this._file.set_encoding(encoding);
+    const [status, buf] = this._file.read_to_end();
+    if (status === GLib.IOStatus.ERROR) {
+      throw new Error("Error on read from file!");
+    }
+    const res = encodeUint8Array(encoding, buf);
+    return res;
+  }
+  /**
+   * Convenience method to create a `readline` interface and stream over the file. For example:
+   *
+   * ```js
+   * import { open } from 'node:fs/promises';
+   *
+   * const file = await open('./some/file/to/read');
+   *
+   * for await (const line of file.readLines()) {
+   *   console.log(line);
+   * }
+   * ```
+   *
+   * @since v18.11.0
+   * @param options See `filehandle.createReadStream()` for the options.
+   */
+  readLines(options) {
+    notImplemented("fs.FileHandle.readLines");
+  }
+  async stat(opts) {
+    warnNotImplemented("fs.FileHandle.stat");
+    return new Stats(this.options.path.toString());
+  }
+  /**
+   * Truncates the file.
+   *
+   * If the file was larger than `len` bytes, only the first `len` bytes will be
+   * retained in the file.
+   *
+   * The following example retains only the first four bytes of the file:
+   *
+   * ```js
+   * import { open } from 'fs/promises';
+   *
+   * let filehandle = null;
+   * try {
+   *   filehandle = await open('temp.txt', 'r+');
+   *   await filehandle.truncate(4);
+   * } finally {
+   *   await filehandle?.close();
+   * }
+   * ```
+   *
+   * If the file previously was shorter than `len` bytes, it is extended, and the
+   * extended part is filled with null bytes (`'\0'`):
+   *
+   * If `len` is negative then `0` will be used.
+   * @since v10.0.0
+   * @param [len=0]
+   * @return Fulfills with `undefined` upon success.
+   */
+  async truncate(len) {
+    warnNotImplemented("fs.FileHandle.truncate");
+  }
+  /**
+   * Change the file system timestamps of the object referenced by the `FileHandle` then resolves the promise with no arguments upon success.
+   * @since v10.0.0
+   */
+  async utimes(atime, mtime) {
+    warnNotImplemented("fs.FileHandle.utimes");
+  }
+  /**
+   * Asynchronously writes data to a file, replacing the file if it already exists.`data` can be a string, a buffer, an
+   * [AsyncIterable](https://tc39.github.io/ecma262/#sec-asynciterable-interface) or
+   * [Iterable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol) object.
+   * The promise is resolved with no arguments upon success.
+   *
+   * If `options` is a string, then it specifies the `encoding`.
+   *
+   * The `FileHandle` has to support writing.
+   *
+   * It is unsafe to use `filehandle.writeFile()` multiple times on the same file
+   * without waiting for the promise to be resolved (or rejected).
+   *
+   * If one or more `filehandle.write()` calls are made on a file handle and then a`filehandle.writeFile()` call is made, the data will be written from the
+   * current position till the end of the file. It doesn't always write from the
+   * beginning of the file.
+   * @since v10.0.0
+   */
+  async writeFile(data, options) {
+    warnNotImplemented("fs.FileHandle.writeFile");
+  }
+  async write(data, ...args) {
+    let position = null;
+    let encoding = null;
+    let offset = null;
+    let length = null;
+    if (typeof data === "string") {
+      position = args[0];
+      encoding = args[1];
+    } else {
+      offset = args[0];
+      length = args[1];
+      position = args[2];
+    }
+    encoding = getEncodingFromOptions(encoding, typeof data === "string" ? "utf8" : null);
+    if (encoding) {
+      console.log("set_encoding", encoding, this._file.get_encoding(), typeof data);
+      this._file.set_encoding(encoding === "buffer" ? null : encoding);
+    }
+    if (offset) {
+      const status2 = this._file.seek_position(offset, GLib.SeekType.CUR);
+      if (status2 === GLib.IOStatus.ERROR) {
+        throw new Error("Error on set offset!");
+      }
+    }
+    if (length)
+      this._file.set_buffer_size(length);
+    if (position) {
+      const status2 = this._file.seek_position(position, GLib.SeekType.SET);
+      if (status2 === GLib.IOStatus.ERROR) {
+        throw new Error("Error on set position!");
+      }
+    }
+    let bytesWritten = 0;
+    let status;
+    if (typeof data === "string") {
+      status = this._file.write_unichar(data);
+      bytesWritten = data.length;
+    } else {
+      const [_status, _bytesWritten] = this._file.write_chars(data, length);
+      bytesWritten = _bytesWritten;
+      status = _status;
+    }
+    if (status === GLib.IOStatus.ERROR) {
+      throw new Error("Error on write to file!");
+    }
+    return {
+      bytesWritten,
+      buffer: data
+    };
+  }
+  /**
+   * Write an array of [ArrayBufferView](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView) s to the file.
+   *
+   * The promise is resolved with an object containing a two properties:
+   *
+   * It is unsafe to call `writev()` multiple times on the same file without waiting
+   * for the promise to be resolved (or rejected).
+   *
+   * On Linux, positional writes don't work when the file is opened in append mode.
+   * The kernel ignores the position argument and always appends the data to
+   * the end of the file.
+   * @since v12.9.0
+   * @param position The offset from the beginning of the file where the data from `buffers` should be written. If `position` is not a `number`, the data will be written at the current
+   * position.
+   */
+  async writev(buffers, position) {
+    warnNotImplemented("fs.FileHandle.writev");
+    return {
+      bytesWritten: 0,
+      buffers: []
+    };
+  }
+  /**
+   * Read from a file and write to an array of [ArrayBufferView](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView) s
+   * @since v13.13.0, v12.17.0
+   * @param position The offset from the beginning of the file where the data should be read from. If `position` is not a `number`, the data will be read from the current position.
+   * @return Fulfills upon success an object containing two properties:
+   */
+  async readv(buffers, position) {
+    warnNotImplemented("fs.FileHandle.readv");
+    return {
+      bytesRead: 0,
+      buffers: []
+    };
+  }
+  /**
+   * Closes the file handle after waiting for any pending operation on the handle to
+   * complete.
+   *
+   * ```js
+   * import { open } from 'fs/promises';
+   *
+   * let filehandle;
+   * try {
+   *   filehandle = await open('thefile.txt', 'r');
+   * } finally {
+   *   await filehandle?.close();
+   * }
+   * ```
+   * @since v10.0.0
+   * @return Fulfills with `undefined` upon success.
+   */
+  async close() {
+    this._file.close();
+  }
+}
+export {
+  FileHandle
+};