@gjsify/fs 0.0.3 → 0.1.0

package/README.md

@@ -1,7 +1,36 @@
 # @gjsify/fs
 
-## Inspirations
+GJS implementation of the Node.js `fs` module using Gio. Supports sync, callback, and promises APIs, streams, and FSWatcher.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/fs
+# or
+yarn add @gjsify/fs
+```
+
+## Usage
+
+```typescript
+import { readFileSync, writeFileSync } from '@gjsify/fs';
+import { readFile } from '@gjsify/fs/promises';
+
+const content = readFileSync('/path/to/file', 'utf-8');
+writeFileSync('/path/to/output', 'hello world');
+
+const data = await readFile('/path/to/file', 'utf-8');
+```
+
+## Inspirations and credits
+
 - 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
+- https://github.com/denoland/deno_std/blob/main/node/fs.ts
+
+## License
+
+MIT

package/lib/esm/callback.js

@@ -1,12 +1,68 @@
+import GLib from "@girs/glib-2.0";
+import Gio from "@girs/gio-2.0";
 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";
+import { Buffer } from "node:buffer";
+import { Stats, BigIntStats, STAT_ATTRIBUTES } from "./stats.js";
+import { createNodeError } from "./errors.js";
+import { realpathSync, readdirSync, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, truncateSync, chmodSync, chownSync, mkdirSync, rmdirSync, readFileSync, writeFileSync } from "./sync.js";
+function parseOptsCb(optionsOrCallback, maybeCallback) {
+  return typeof optionsOrCallback === "function" ? { options: {}, callback: optionsOrCallback } : { options: optionsOrCallback ?? {}, callback: maybeCallback };
+}
+function statImpl(path, flags, syscall, options, callback) {
+  const file = Gio.File.new_for_path(path.toString());
+  file.query_info_async(STAT_ATTRIBUTES, flags, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+    try {
+      const info = file.query_info_finish(res);
+      callback(null, options?.bigint ? new BigIntStats(info, path) : new Stats(info, path));
+    } catch (err) {
+      callback(createNodeError(err, syscall, path));
+    }
+  });
+}
+function stat(path, optionsOrCallback, maybeCallback) {
+  const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+  statImpl(path, Gio.FileQueryInfoFlags.NONE, "stat", options, callback);
+}
+function lstat(path, optionsOrCallback, maybeCallback) {
+  const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+  statImpl(path, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, "lstat", options, callback);
+}
+function readdir(path, optionsOrCallback, maybeCallback) {
+  const { options, callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+  Promise.resolve().then(() => {
+    try {
+      callback(null, readdirSync(path, options));
+    } catch (err) {
+      callback(createNodeError(err, "readdir", path));
+    }
+  });
+}
+function realpath(path, optionsOrCallback, maybeCallback) {
+  const { callback } = parseOptsCb(optionsOrCallback, maybeCallback);
+  Promise.resolve().then(() => {
+    try {
+      callback(null, realpathSync(path));
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function symlink(target, path, typeOrCallback, maybeCallback) {
+  const callback = typeof typeOrCallback === "function" ? typeOrCallback : maybeCallback;
+  if (typeof callback !== "function") {
+    throw new TypeError("Callback must be a function. Received " + typeof callback);
+  }
+  const file = Gio.File.new_for_path(path.toString());
+  file.make_symbolic_link_async(target.toString(), GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+    try {
+      file.make_symbolic_link_finish(res);
+      callback(null);
+    } catch (err) {
+      callback(createNodeError(err, "symlink", target, path));
+    }
+  });
+}
 function open(path, ...args) {
   let flags;
   let mode;
@@ -36,8 +92,10 @@ function open(path, ...args) {
 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) => {
+    const callback2 = args.pop();
+    const position2 = args[0];
+    const encoding = args[1];
+    fileHandle.write(data, position2, encoding).then((res) => {
       callback2(null, res.bytesWritten, res.buffer);
     }).catch((err) => {
       callback2(err, 0, "");
@@ -57,13 +115,12 @@ function write(fd, data, ...args) {
 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") {
+  if (args.length <= 1) {
+  } else if (typeof args[0] === "object" && !ArrayBuffer.isView(args[0])) {
     const options = args[0];
     buffer = options.buffer;
     offset = options.offset;
@@ -77,8 +134,8 @@ function read(fd, ...args) {
   }
   fileHandle.read(buffer, offset, length, position).then((res) => {
     callback(null, res.bytesRead, res.buffer);
-  }).catch((err2) => {
-    callback(err2, 0, Buffer.from([]));
+  }).catch((err) => {
+    callback(err, 0, Buffer.from([]));
   });
 }
 function close(fd, callback) {
@@ -98,15 +155,194 @@ function rm(path, ...args) {
     callback(err);
   });
 }
+function rename(oldPath, newPath, callback) {
+  Promise.resolve().then(() => {
+    try {
+      renameSync(oldPath, newPath);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function copyFile(src, dest, modeOrCb, maybeCb) {
+  const mode = typeof modeOrCb === "function" ? 0 : modeOrCb;
+  const callback = typeof modeOrCb === "function" ? modeOrCb : maybeCb;
+  Promise.resolve().then(() => {
+    try {
+      copyFileSync(src, dest, mode);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function access(path, modeOrCb, maybeCb) {
+  const mode = typeof modeOrCb === "function" ? void 0 : modeOrCb;
+  const callback = typeof modeOrCb === "function" ? modeOrCb : maybeCb;
+  Promise.resolve().then(() => {
+    try {
+      accessSync(path, mode);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function appendFile(path, data, optsOrCb, maybeCb) {
+  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      appendFileSync(path, data, options);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function readlink(path, optsOrCb, maybeCb) {
+  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      callback(null, readlinkSync(path, options));
+    } catch (err) {
+      callback(err, "");
+    }
+  });
+}
+function truncate(path, lenOrCb, maybeCb) {
+  const len = typeof lenOrCb === "function" ? 0 : lenOrCb;
+  const callback = typeof lenOrCb === "function" ? lenOrCb : maybeCb;
+  Promise.resolve().then(() => {
+    try {
+      truncateSync(path, len);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function chmod(path, mode, callback) {
+  Promise.resolve().then(() => {
+    try {
+      chmodSync(path, mode);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function chown(path, uid, gid, callback) {
+  Promise.resolve().then(() => {
+    try {
+      chownSync(path, uid, gid);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function mkdir(path, optsOrCb, maybeCb) {
+  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      mkdirSync(path, options);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function rmdir(path, optsOrCb, maybeCb) {
+  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      rmdirSync(path, options);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function readFile(path, optsOrCb, maybeCb) {
+  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+  const options = typeof optsOrCb === "function" ? void 0 : optsOrCb;
+  Promise.resolve().then(() => {
+    try {
+      const readOpts = typeof options === "string" ? { encoding: options, flag: "r" } : { encoding: options?.encoding ?? null, flag: options?.flag ?? "r" };
+      callback(null, readFileSync(path.toString(), readOpts));
+    } catch (err) {
+      callback(err, null);
+    }
+  });
+}
+function writeFile(path, data, optsOrCb, maybeCb) {
+  const callback = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+  Promise.resolve().then(() => {
+    try {
+      writeFileSync(path.toString(), data);
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function link(existingPath, newPath, callback) {
+  Promise.resolve().then(() => {
+    try {
+      const result = GLib.spawn_command_line_sync(`ln ${existingPath.toString()} ${newPath.toString()}`);
+      if (!result[0]) {
+        throw Object.assign(new Error(`EPERM: operation not permitted, link '${existingPath}' -> '${newPath}'`), {
+          code: "EPERM",
+          errno: -1,
+          syscall: "link",
+          path: existingPath.toString(),
+          dest: newPath.toString()
+        });
+      }
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
+function unlink(path, callback) {
+  Promise.resolve().then(() => {
+    try {
+      GLib.unlink(path.toString());
+      callback(null);
+    } catch (err) {
+      callback(err);
+    }
+  });
+}
 export {
+  access,
+  appendFile,
+  chmod,
+  chown,
   close,
+  copyFile,
+  link,
   lstat,
+  mkdir,
   open,
   read,
+  readFile,
   readdir,
+  readlink,
   realpath,
+  rename,
   rm,
+  rmdir,
   stat,
   symlink,
-  write
+  truncate,
+  unlink,
+  write,
+  writeFile
 };

package/lib/esm/dirent.js

@@ -1,5 +1,13 @@
 import Gio from "@girs/gio-2.0";
-import { basename } from "path";
+import { basename, dirname } from "node:path";
+const S_IFMT = 61440;
+const S_IFSOCK = 49152;
+const S_IFLNK = 40960;
+const S_IFREG = 32768;
+const S_IFBLK = 24576;
+const S_IFDIR = 16384;
+const S_IFCHR = 8192;
+const S_IFIFO = 4096;
 class Dirent {
   /**
    * The file name that this `fs.Dirent` object refers to. The type of this
@@ -7,6 +15,11 @@ class Dirent {
    * @since v10.10.0
    */
   name;
+  /**
+   * The path to the parent directory of the file this `fs.Dirent` object refers to.
+   * @since v20.12.0, v18.20.0
+   */
+  parentPath;
   _isFile = false;
   _isDirectory = false;
   _isBlockDevice = false;
@@ -17,12 +30,12 @@ class Dirent {
   /** 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);
+  constructor(path, filename, fileType) {
+    if (!filename) filename = basename(path);
     this.name = filename;
+    this.parentPath = dirname(path);
     this._file = Gio.File.new_for_path(path);
-    const type = this._file.query_file_type(Gio.FileQueryInfoFlags.NONE, null);
+    const type = fileType ?? this._file.query_file_type(Gio.FileQueryInfoFlags.NONE, null);
     switch (type) {
       case Gio.FileType.DIRECTORY:
         this._isDirectory = true;
@@ -37,10 +50,38 @@ class Dirent {
         this._isSymbolicLink = true;
         break;
       case Gio.FileType.SPECIAL:
-        this._isBlockDevice = Gio.unix_is_system_device_path(path);
+        this._classifySpecialFile(path);
         break;
     }
   }
+  /**
+   * Classify a SPECIAL file type using the unix::mode attribute from Gio.FileInfo.
+   * Falls back to marking nothing if the mode attribute is unavailable.
+   */
+  _classifySpecialFile(path) {
+    try {
+      const file = Gio.File.new_for_path(path);
+      const info = file.query_info("unix::mode", Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+      const mode = info.get_attribute_uint32("unix::mode");
+      if (mode === 0) return;
+      const fmt = mode & S_IFMT;
+      switch (fmt) {
+        case S_IFBLK:
+          this._isBlockDevice = true;
+          break;
+        case S_IFCHR:
+          this._isCharacterDevice = true;
+          break;
+        case S_IFSOCK:
+          this._isSocket = true;
+          break;
+        case S_IFIFO:
+          this._isFIFO = true;
+          break;
+      }
+    } catch {
+    }
+  }
   /**
    * Returns `true` if the `fs.Dirent` object describes a regular file.
    * @since v10.10.0

package/lib/esm/encoding.js

@@ -1,4 +1,4 @@
-import { Buffer } from "buffer";
+import { Buffer } from "node:buffer";
 function getEncodingFromOptions(options = { encoding: null, flag: "r" }, defaultEncoding = "utf8") {
   if (options === null) {
     return defaultEncoding;
@@ -19,8 +19,7 @@ function encodeUint8Array(encoding, data) {
   return decoder.decode(data);
 }
 function decode(str, encoding) {
-  if (!encoding)
-    return str;
+  if (!encoding) return str;
   else {
     const decoder = new TextDecoder(encoding);
     const encoder = new TextEncoder();

package/lib/esm/errors.js

@@ -0,0 +1,13 @@
+import { createNodeError as createNodeErrorGeneric, isNotFoundError } from "@gjsify/utils";
+function createNodeError(err, syscall, path, dest) {
+  const pathStr = path.toString();
+  const error = createNodeErrorGeneric(err, syscall, {
+    path: pathStr,
+    dest: dest?.toString()
+  });
+  return error;
+}
+export {
+  createNodeError,
+  isNotFoundError
+};