@gjsify/fs 0.0.4 → 0.1.0

package/lib/esm/stats.js

@@ -1,6 +1,41 @@
 import Gio from "@girs/gio-2.0";
 import { Dirent } from "./dirent.js";
-import { basename } from "path";
+import { basename } from "node:path";
+const STAT_ATTRIBUTES = "standard::*,time::*,unix::*";
+function populateFromInfo(info) {
+  const atimeSec = info.get_attribute_uint64("time::access");
+  const atimeUsec = info.get_attribute_uint32("time::access-usec") || 0;
+  const mtimeSec = info.get_attribute_uint64("time::modified");
+  const mtimeUsec = info.get_attribute_uint32("time::modified-usec") || 0;
+  const ctimeSec = info.get_attribute_uint64("time::changed");
+  const ctimeUsec = info.get_attribute_uint32("time::changed-usec") || 0;
+  const createdSec = info.get_attribute_uint64("time::created");
+  const createdUsec = info.get_attribute_uint32("time::created-usec") || 0;
+  const atimeMs = atimeSec * 1e3 + atimeUsec / 1e3;
+  const mtimeMs = mtimeSec * 1e3 + mtimeUsec / 1e3;
+  const ctimeMs = ctimeSec ? ctimeSec * 1e3 + ctimeUsec / 1e3 : mtimeMs;
+  const birthtimeMs = createdSec ? createdSec * 1e3 + createdUsec / 1e3 : ctimeMs;
+  return {
+    dev: info.get_attribute_uint32("unix::device") || 0,
+    ino: Number(info.get_attribute_uint64("unix::inode") || 0),
+    mode: info.get_attribute_uint32("unix::mode") || 0,
+    nlink: info.get_attribute_uint32("unix::nlink") || 0,
+    uid: info.get_attribute_uint32("unix::uid") || 0,
+    gid: info.get_attribute_uint32("unix::gid") || 0,
+    rdev: info.get_attribute_uint32("unix::rdev") || 0,
+    size: Number(info.get_size() || 0),
+    blksize: info.get_attribute_uint32("unix::block-size") || 4096,
+    blocks: Number(info.get_attribute_uint64("unix::blocks") || 0),
+    atimeMs,
+    mtimeMs,
+    ctimeMs,
+    birthtimeMs,
+    atime: new Date(atimeMs),
+    mtime: new Date(mtimeMs),
+    ctime: new Date(ctimeMs),
+    birthtime: new Date(birthtimeMs)
+  };
+}
 class Stats extends Dirent {
   dev;
   ino;
@@ -15,31 +50,116 @@ class Stats extends Dirent {
   atimeMs;
   mtimeMs;
   ctimeMs;
-  /** The timestamp indicating the creation time of this file expressed in milliseconds since the POSIX Epoch. */
-  get birthtimeMs() {
-    const creationDateTime = this._info.get_creation_date_time();
-    return creationDateTime.get_microsecond() * 1e3;
-  }
+  birthtimeMs;
   atime;
   mtime;
   ctime;
-  /** The timestamp indicating the creation time of this file. */
-  get birthtime() {
-    const creationDateTime = this._info.get_creation_date_time();
-    return new Date(creationDateTime.format_iso8601());
+  birthtime;
+  _info;
+  constructor(infoOrPath, pathOrFilename, filename) {
+    let info;
+    let pathStr;
+    if (infoOrPath instanceof Gio.FileInfo) {
+      info = infoOrPath;
+      pathStr = pathOrFilename.toString();
+      if (!filename) filename = basename(pathStr);
+    } else {
+      pathStr = infoOrPath.toString();
+      if (typeof pathOrFilename === "string") filename = pathOrFilename;
+      if (!filename) filename = basename(pathStr);
+      const file = Gio.File.new_for_path(pathStr);
+      info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+    }
+    super(pathStr, filename, info.get_file_type());
+    this._info = info;
+    const data = populateFromInfo(info);
+    this.dev = data.dev;
+    this.ino = data.ino;
+    this.mode = data.mode;
+    this.nlink = data.nlink;
+    this.uid = data.uid;
+    this.gid = data.gid;
+    this.rdev = data.rdev;
+    this.size = data.size;
+    this.blksize = data.blksize;
+    this.blocks = data.blocks;
+    this.atimeMs = data.atimeMs;
+    this.mtimeMs = data.mtimeMs;
+    this.ctimeMs = data.ctimeMs;
+    this.birthtimeMs = data.birthtimeMs;
+    this.atime = data.atime;
+    this.mtime = data.mtime;
+    this.ctime = data.ctime;
+    this.birthtime = data.birthtime;
   }
+}
+class BigIntStats extends Dirent {
+  dev;
+  ino;
+  mode;
+  nlink;
+  uid;
+  gid;
+  rdev;
+  size;
+  blksize;
+  blocks;
+  atimeMs;
+  mtimeMs;
+  ctimeMs;
+  birthtimeMs;
+  atimeNs;
+  mtimeNs;
+  ctimeNs;
+  birthtimeNs;
+  atime;
+  mtime;
+  ctime;
+  birthtime;
   _info;
-  constructor(path, filename) {
-    const pathStr = path.toString();
-    if (!filename)
-      filename = basename(pathStr);
-    super(pathStr, filename);
-    if (!this._file) {
-      throw new TypeError("this._file is not defined!");
+  constructor(infoOrPath, pathOrFilename, filename) {
+    let info;
+    let pathStr;
+    if (infoOrPath instanceof Gio.FileInfo) {
+      info = infoOrPath;
+      pathStr = pathOrFilename.toString();
+      if (!filename) filename = basename(pathStr);
+    } else {
+      pathStr = infoOrPath.toString();
+      if (typeof pathOrFilename === "string") filename = pathOrFilename;
+      if (!filename) filename = basename(pathStr);
+      const file = Gio.File.new_for_path(pathStr);
+      info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
     }
-    this._info = this._file.query_info("standard::", Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+    super(pathStr, filename, info.get_file_type());
+    this._info = info;
+    const data = populateFromInfo(info);
+    this.dev = BigInt(data.dev);
+    this.ino = BigInt(data.ino);
+    this.mode = BigInt(data.mode);
+    this.nlink = BigInt(data.nlink);
+    this.uid = BigInt(data.uid);
+    this.gid = BigInt(data.gid);
+    this.rdev = BigInt(data.rdev);
+    this.size = BigInt(data.size);
+    this.blksize = BigInt(data.blksize);
+    this.blocks = BigInt(data.blocks);
+    this.atimeMs = BigInt(Math.trunc(data.atimeMs));
+    this.mtimeMs = BigInt(Math.trunc(data.mtimeMs));
+    this.ctimeMs = BigInt(Math.trunc(data.ctimeMs));
+    this.birthtimeMs = BigInt(Math.trunc(data.birthtimeMs));
+    this.atimeNs = this.atimeMs * 1000000n;
+    this.mtimeNs = this.mtimeMs * 1000000n;
+    this.ctimeNs = this.ctimeMs * 1000000n;
+    this.birthtimeNs = this.birthtimeMs * 1000000n;
+    this.atime = data.atime;
+    this.mtime = data.mtime;
+    this.ctime = data.ctime;
+    this.birthtime = data.birthtime;
   }
 }
 export {
+  BigIntStats,
+  STAT_ATTRIBUTES,
   Stats
 };

package/lib/esm/sync.js

@@ -1,33 +1,112 @@
 import GLib from "@girs/glib-2.0";
 import Gio from "@girs/gio-2.0";
 import { existsSync } from "@gjsify/utils";
-import { join } from "path";
+import { Buffer } from "node:buffer";
+import { join } from "node:path";
 import FSWatcher from "./fs-watcher.js";
 import { getEncodingFromOptions, encodeUint8Array, decode } from "./encoding.js";
 import { FileHandle } from "./file-handle.js";
 import { Dirent } from "./dirent.js";
+import { Stats, BigIntStats, STAT_ATTRIBUTES } from "./stats.js";
+import { createNodeError, isNotFoundError } from "./errors.js";
 import { tempDirPath } from "./utils.js";
-import { realpathSync } from "@gjsify/deno_std/node/_fs/_fs_realpath";
-import { readdirSync } from "@gjsify/deno_std/node/_fs/_fs_readdir";
-import { symlinkSync } from "@gjsify/deno_std/node/_fs/_fs_symlink";
-import { lstatSync } from "@gjsify/deno_std/node/_fs/_fs_lstat";
-import { statSync } from "@gjsify/deno_std/node/_fs/_fs_stat";
+function statSync(path, options) {
+  try {
+    const file = Gio.File.new_for_path(path.toString());
+    const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NONE, null);
+    return options?.bigint ? new BigIntStats(info, path) : new Stats(info, path);
+  } catch (err) {
+    if (options?.throwIfNoEntry === false && isNotFoundError(err)) return void 0;
+    throw createNodeError(err, "stat", path);
+  }
+}
+function lstatSync(path, options) {
+  try {
+    const file = Gio.File.new_for_path(path.toString());
+    const info = file.query_info(STAT_ATTRIBUTES, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+    return options?.bigint ? new BigIntStats(info, path) : new Stats(info, path);
+  } catch (err) {
+    if (options?.throwIfNoEntry === false && isNotFoundError(err)) return void 0;
+    throw createNodeError(err, "lstat", path);
+  }
+}
+function readdirSync(path, options) {
+  const pathStr = path.toString();
+  const file = Gio.File.new_for_path(pathStr);
+  const enumerator = file.enumerate_children(
+    "standard::name,standard::type",
+    Gio.FileQueryInfoFlags.NONE,
+    null
+  );
+  const result = [];
+  let info = enumerator.next_file(null);
+  while (info !== null) {
+    const childName = info.get_name();
+    const childPath = join(pathStr, childName);
+    if (options?.withFileTypes) {
+      result.push(new Dirent(childPath, childName));
+    } else {
+      result.push(childName);
+    }
+    if (options?.recursive && info.get_file_type() === Gio.FileType.DIRECTORY) {
+      const subEntries = readdirSync(childPath, options);
+      for (const entry of subEntries) {
+        if (typeof entry === "string") {
+          result.push(join(childName, entry));
+        } else {
+          result.push(entry);
+        }
+      }
+    }
+    info = enumerator.next_file(null);
+  }
+  return result;
+}
+const MAX_SYMLINK_DEPTH = 40;
+function realpathSync(path) {
+  let current = Gio.File.new_for_path(path.toString());
+  let depth = 0;
+  while (true) {
+    const info = current.query_info(
+      "standard::is-symlink,standard::symlink-target",
+      Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+      null
+    );
+    if (!info.get_is_symlink()) {
+      return current.get_path();
+    }
+    const target = info.get_symlink_target();
+    const parent = current.get_parent();
+    current = parent ? parent.resolve_relative_path(target) : Gio.File.new_for_path(target);
+    if (++depth > MAX_SYMLINK_DEPTH) {
+      throw new Error(`ELOOP: too many levels of symbolic links, realpath '${path}'`);
+    }
+  }
+}
+realpathSync.native = realpathSync;
+function symlinkSync(target, path, _type) {
+  const file = Gio.File.new_for_path(path.toString());
+  file.make_symbolic_link(target.toString(), null);
+}
 function readFileSync(path, options = { encoding: null, flag: "r" }) {
   const file = Gio.File.new_for_path(path);
-  const [ok, data] = file.load_contents(null);
-  if (!ok) {
-    throw new Error("failed to read file");
+  try {
+    const [ok, data] = file.load_contents(null);
+    if (!ok) {
+      throw createNodeError(new Error("failed to read file"), "read", path);
+    }
+    return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
+  } catch (err) {
+    if (err.code && typeof err.code === "string") throw err;
+    throw createNodeError(err, "read", path);
   }
-  return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
 }
 function mkdirSync(path, options) {
   let recursive = false;
   let mode = 511;
   if (typeof options === "object") {
-    if (options?.recursive)
-      recursive = options.recursive;
-    if (options?.mode)
-      mode = options.mode;
+    if (options?.recursive) recursive = options.recursive;
+    if (options?.mode) mode = options.mode;
   } else {
     mode = options || 511;
   }
@@ -37,38 +116,191 @@ function mkdirSync(path, options) {
   if (typeof mode === "string") {
     throw new TypeError("mode as string is currently not supported!");
   }
-  if (GLib.mkdir_with_parents(path, mode) !== 0) {
-    throw new Error(`failed to make ${path} directory`);
-  }
   if (recursive) {
-    return path.split("/")[0];
+    return mkdirSyncRecursive(path, mode);
+  }
+  const file = Gio.File.new_for_path(path);
+  try {
+    file.make_directory(null);
+  } catch (err) {
+    throw createNodeError(err, "mkdir", path);
   }
   return void 0;
 }
-function rmdirSync(path, options) {
-  const recursive = options?.recursive || false;
-  const childFiles = readdirSync(path, { withFileTypes: true });
-  if (!recursive && childFiles.length) {
-    throw new Error("Dir is not empty!");
-  }
-  for (const childFile of childFiles) {
-    if (childFile.isDirectory()) {
-      rmdirSync(join(path.toString(), childFile.name));
-    } else if (childFile.isFile()) {
-      rmSync(join(path.toString(), childFile.name));
+function mkdirSyncRecursive(pathStr, mode) {
+  const file = Gio.File.new_for_path(pathStr);
+  try {
+    file.make_directory(null);
+    return pathStr;
+  } catch (err) {
+    const gErr = err;
+    if (gErr.code === Gio.IOErrorEnum.EXISTS) {
+      return void 0;
     }
+    if (gErr.code === Gio.IOErrorEnum.NOT_FOUND) {
+      const parentPath = join(pathStr, "..");
+      const resolvedParent = Gio.File.new_for_path(parentPath).get_path();
+      if (resolvedParent === pathStr) {
+        throw createNodeError(err, "mkdir", pathStr);
+      }
+      const firstCreated = mkdirSyncRecursive(resolvedParent, mode);
+      const retryFile = Gio.File.new_for_path(pathStr);
+      try {
+        retryFile.make_directory(null);
+      } catch (retryErr) {
+        throw createNodeError(retryErr, "mkdir", pathStr);
+      }
+      return firstCreated ?? pathStr;
+    }
+    throw createNodeError(err, "mkdir", pathStr);
   }
-  const result = GLib.rmdir(path.toString());
-  if (result !== 0) {
-    throw new Error(`Failed to remove ${path} directory`);
+}
+function rmdirSync(path, _options) {
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    const info = file.query_info("standard::type", Gio.FileQueryInfoFlags.NONE, null);
+    if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
+      const err = Object.assign(new Error(), { code: 4 });
+      throw createNodeError(err, "rmdir", path);
+    }
+    const enumerator = file.enumerate_children("standard::name", Gio.FileQueryInfoFlags.NONE, null);
+    if (enumerator.next_file(null) !== null) {
+      const err = Object.assign(new Error(), { code: 5 });
+      throw createNodeError(err, "rmdir", path);
+    }
+    file.delete(null);
+  } catch (err) {
+    if (err.code && typeof err.code === "string") throw err;
+    throw createNodeError(err, "rmdir", path);
   }
 }
 function unlinkSync(path) {
-  GLib.unlink(path);
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    file.delete(null);
+  } catch (err) {
+    throw createNodeError(err, "unlink", path);
+  }
 }
 function writeFileSync(path, data) {
   GLib.file_set_contents(path, data);
 }
+function renameSync(oldPath, newPath) {
+  const src = Gio.File.new_for_path(oldPath.toString());
+  const dest = Gio.File.new_for_path(newPath.toString());
+  try {
+    src.move(dest, Gio.FileCopyFlags.OVERWRITE, null, null);
+  } catch (err) {
+    throw createNodeError(err, "rename", oldPath, newPath);
+  }
+}
+function copyFileSync(src, dest, mode) {
+  const srcFile = Gio.File.new_for_path(src.toString());
+  const destFile = Gio.File.new_for_path(dest.toString());
+  let flags = Gio.FileCopyFlags.NONE;
+  if (mode && (mode & 1) === 0) {
+    flags = Gio.FileCopyFlags.OVERWRITE;
+  } else if (!mode) {
+    flags = Gio.FileCopyFlags.OVERWRITE;
+  }
+  try {
+    srcFile.copy(destFile, flags, null, null);
+  } catch (err) {
+    throw createNodeError(err, "copyfile", src, dest);
+  }
+}
+function accessSync(path, mode) {
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    const info = file.query_info("access::*", Gio.FileQueryInfoFlags.NONE, null);
+    if (mode !== void 0 && mode !== 0) {
+      const permErr = { code: 14, message: `permission denied, access '${path}'` };
+      if (mode & 4 && !info.get_attribute_boolean("access::can-read")) {
+        throw createNodeError(permErr, "access", path);
+      }
+      if (mode & 2 && !info.get_attribute_boolean("access::can-write")) {
+        throw createNodeError(permErr, "access", path);
+      }
+      if (mode & 1 && !info.get_attribute_boolean("access::can-execute")) {
+        throw createNodeError(permErr, "access", path);
+      }
+    }
+  } catch (err) {
+    if (err.code && typeof err.code === "string") throw err;
+    throw createNodeError(err, "access", path);
+  }
+}
+function appendFileSync(path, data, options) {
+  const file = Gio.File.new_for_path(path.toString());
+  let bytes;
+  if (typeof data === "string") {
+    bytes = new TextEncoder().encode(data);
+  } else {
+    bytes = data;
+  }
+  try {
+    const stream = file.append_to(Gio.FileCreateFlags.NONE, null);
+    if (bytes.length > 0) {
+      stream.write_bytes(new GLib.Bytes(bytes), null);
+    }
+    stream.close(null);
+  } catch (err) {
+    throw createNodeError(err, "appendfile", path);
+  }
+}
+function readlinkSync(path, options) {
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    const info = file.query_info("standard::symlink-target", Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+    const target = info.get_symlink_target();
+    if (!target) {
+      throw Object.assign(new Error(`EINVAL: invalid argument, readlink '${path}'`), { code: "EINVAL", errno: -22, syscall: "readlink", path: path.toString() });
+    }
+    const encoding = typeof options === "string" ? options : options?.encoding;
+    if (encoding === "buffer") {
+      return Buffer.from(target);
+    }
+    return target;
+  } catch (err) {
+    if (typeof err.code === "string") throw err;
+    throw createNodeError(err, "readlink", path);
+  }
+}
+function linkSync(existingPath, newPath) {
+  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() });
+  }
+}
+function truncateSync(path, len) {
+  const file = Gio.File.new_for_path(path.toString());
+  try {
+    const stream = file.replace(null, false, Gio.FileCreateFlags.NONE, null);
+    if (len && len > 0) {
+      const [, data] = file.load_contents(null);
+      const truncated = data.slice(0, len);
+      if (truncated.length > 0) {
+        stream.write_bytes(new GLib.Bytes(truncated), null);
+      }
+    }
+    stream.close(null);
+  } catch (err) {
+    throw createNodeError(err, "truncate", path);
+  }
+}
+function chmodSync(path, mode) {
+  const modeNum = typeof mode === "string" ? parseInt(mode, 8) : mode;
+  const result = GLib.spawn_command_line_sync(`chmod ${modeNum.toString(8)} ${path.toString()}`);
+  if (!result[0]) {
+    throw Object.assign(new Error(`EPERM: operation not permitted, chmod '${path}'`), { code: "EPERM", errno: -1, syscall: "chmod", path: path.toString() });
+  }
+}
+function chownSync(path, uid, gid) {
+  const result = GLib.spawn_command_line_sync(`chown ${uid}:${gid} ${path.toString()}`);
+  if (!result[0]) {
+    throw Object.assign(new Error(`EPERM: operation not permitted, chown '${path}'`), { code: "EPERM", errno: -1, syscall: "chown", path: path.toString() });
+  }
+}
 function watch(filename, options, listener) {
   return new FSWatcher(filename, options, listener);
 }
@@ -85,41 +317,58 @@ function mkdtempSync(prefix, options) {
   return decode(path, encoding);
 }
 function rmSync(path, options) {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = path.toString();
+  const file = Gio.File.new_for_path(pathStr);
   const recursive = options?.recursive || false;
-  const dirent = new Dirent(path.toString());
+  const force = options?.force || false;
+  let dirent;
+  try {
+    dirent = new Dirent(pathStr);
+  } catch (err) {
+    if (force && isNotFoundError(err)) return;
+    throw createNodeError(err, "rm", path);
+  }
   if (dirent.isDirectory()) {
     const childFiles = readdirSync(path, { withFileTypes: true });
     if (!recursive && childFiles.length) {
-      throw new Error("Dir is not empty!");
+      const err = Object.assign(new Error(), { code: 5 });
+      throw createNodeError(err, "rm", path);
     }
     for (const childFile of childFiles) {
-      if (childFile.isDirectory()) {
-        rmdirSync(join(path.toString(), childFile.name), options);
-      } else if (childFile.isFile()) {
-        rmSync(join(path.toString(), childFile.name), options);
+      if (typeof childFile !== "string") {
+        rmSync(join(pathStr, childFile.name), options);
       }
     }
   }
-  const ok = file.delete(null);
-  if (!ok) {
-    const err = new Error("failed to remove file " + path);
-    throw err;
+  try {
+    file.delete(null);
+  } catch (err) {
+    if (force && isNotFoundError(err)) return;
+    throw createNodeError(err, "rm", path);
   }
 }
 export {
+  accessSync,
+  appendFileSync,
+  chmodSync,
+  chownSync,
+  copyFileSync,
   existsSync,
+  linkSync,
   lstatSync,
   mkdirSync,
   mkdtempSync,
   openSync,
   readFileSync,
   readdirSync,
+  readlinkSync,
   realpathSync,
+  renameSync,
   rmSync,
   rmdirSync,
   statSync,
   symlinkSync,
+  truncateSync,
   unlinkSync,
   watch,
   writeFileSync

package/lib/esm/write-stream.js

@@ -1,8 +1,8 @@
-import { Writable } from "stream";
-import { fileURLToPath, URL } from "url";
+import { Writable } from "node:stream";
+import { fileURLToPath, URL } from "node:url";
 import { open, write, close } from "./callback.js";
-const kIsPerformingIO = Symbol("kIsPerformingIO");
-const kIoDone = Symbol("kIoDone");
+const kIsPerformingIO = /* @__PURE__ */ Symbol("kIsPerformingIO");
+const kIoDone = /* @__PURE__ */ Symbol("kIoDone");
 function toPathIfFileURL(fileURLOrPath) {
   if (!(fileURLOrPath instanceof URL)) {
     return fileURLOrPath;