@gjsify/fs 0.0.1 → 0.0.3

package/lib/cjs/write-stream.js

@@ -0,0 +1,116 @@
+import { Writable } from "stream";
+import { fileURLToPath, URL } from "url";
+import { open, write, close } from "./callback.js";
+const kIsPerformingIO = Symbol("kIsPerformingIO");
+const kIoDone = Symbol("kIoDone");
+function toPathIfFileURL(fileURLOrPath) {
+  if (!(fileURLOrPath instanceof URL)) {
+    return fileURLOrPath;
+  }
+  return fileURLToPath(fileURLOrPath);
+}
+class WriteStream extends Writable {
+  /**
+   * Closes `writeStream`. Optionally accepts a
+   * callback that will be executed once the `writeStream`is closed.
+   * @since v0.9.4
+   */
+  close(callback, err = null) {
+    if (!this.fd) {
+      callback(err);
+    } else {
+      close(this.fd, (er) => {
+        callback(er || err);
+      });
+      this.fd = null;
+    }
+  }
+  /**
+  * The number of bytes written so far. Does not include data that is still queued
+  * for writing.
+  * @since v0.4.7
+  */
+  bytesWritten = 0;
+  /**
+  * The path to the file the stream is writing to as specified in the first
+  * argument to {@link createWriteStream}. If `path` is passed as a string, then`writeStream.path` will be a string. If `path` is passed as a `Buffer`, then`writeStream.path` will be a
+  * `Buffer`.
+  * @since v0.1.93
+  */
+  path;
+  /**
+  * 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
+  */
+  pending;
+  fd = null;
+  flags = "w";
+  mode = 438;
+  pos = 0;
+  [kIsPerformingIO] = false;
+  constructor(path, opts = {}) {
+    super(opts);
+    this.path = toPathIfFileURL(path);
+    if (opts.encoding) {
+      this.setDefaultEncoding(opts.encoding);
+    }
+  }
+  _construct(callback) {
+    open(
+      this.path.toString(),
+      this.flags,
+      this.mode,
+      (err, fd) => {
+        if (err) {
+          callback(err);
+          return;
+        }
+        this.fd = fd;
+        callback();
+        this.emit("open", this.fd);
+        this.emit("ready");
+      }
+    );
+  }
+  _write(data, _encoding, cb) {
+    this[kIsPerformingIO] = true;
+    write(
+      this.fd,
+      data,
+      0,
+      data.length,
+      this.pos,
+      (er, bytes) => {
+        this[kIsPerformingIO] = false;
+        if (this.destroyed) {
+          cb(er);
+          return this.emit(kIoDone, er);
+        }
+        if (er) {
+          return cb(er);
+        }
+        this.bytesWritten += bytes;
+        cb();
+      }
+    );
+    if (this.pos !== void 0) {
+      this.pos += data.length;
+    }
+  }
+  _destroy(err, cb) {
+    if (this[kIsPerformingIO]) {
+      this.once(kIoDone, (er) => this.close(cb, err || er));
+    } else {
+      this.close(cb, err);
+    }
+  }
+}
+function createWriteStream(path, opts) {
+  return new WriteStream(path, opts);
+}
+export {
+  WriteStream,
+  createWriteStream,
+  toPathIfFileURL
+};

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