@gjsify/fs 0.0.1 → 0.0.3

package/lib/esm/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
+};

package/lib/esm/fs-watcher.js

@@ -0,0 +1,50 @@
+import Gio from "@girs/gio-2.0";
+import { EventEmitter } from "events";
+const privates = /* @__PURE__ */ new WeakMap();
+class FSWatcher extends EventEmitter {
+  constructor(filename, options, listener) {
+    super();
+    if (!options || typeof options !== "object")
+      options = { persistent: true };
+    const cancellable = Gio.Cancellable.new();
+    const file = Gio.File.new_for_path(filename);
+    const watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
+    watcher.connect("changed", changed.bind(this));
+    privates.set(this, {
+      persistent: options.persistent,
+      cancellable,
+      // even if never used later on, the monitor needs to be
+      // attached to this instance or GJS reference counter
+      // will ignore it and no watch will ever happen
+      watcher
+    });
+    if (listener)
+      this.on("change", listener);
+  }
+  close() {
+    const { cancellable, persistent } = privates.get(this);
+    if (!cancellable.is_cancelled()) {
+      cancellable.cancel();
+    }
+  }
+}
+;
+function changed(watcher, file, otherFile, eventType) {
+  switch (eventType) {
+    case Gio.FileMonitorEvent.CHANGES_DONE_HINT:
+      this.emit("change", "change", file.get_basename());
+      break;
+    case Gio.FileMonitorEvent.DELETED:
+    case Gio.FileMonitorEvent.CREATED:
+    case Gio.FileMonitorEvent.RENAMED:
+    case Gio.FileMonitorEvent.MOVED_IN:
+    case Gio.FileMonitorEvent.MOVED_OUT:
+      this.emit("rename", "rename", file.get_basename());
+      break;
+  }
+}
+var fs_watcher_default = FSWatcher;
+export {
+  FSWatcher,
+  fs_watcher_default as default
+};

package/lib/esm/index.js

@@ -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";
+var src_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
+};
+export {
+  FSWatcher,
+  ReadStream,
+  close,
+  createReadStream,
+  src_default as default,
+  existsSync,
+  lstat,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  open,
+  openSync,
+  promises,
+  read,
+  readFileSync,
+  readdir,
+  readdirSync,
+  realpath,
+  realpathSync,
+  rm,
+  rmSync,
+  rmdirSync,
+  statSync,
+  symlink,
+  symlinkSync,
+  unlinkSync,
+  watch,
+  write,
+  writeFileSync
+};