@gjsify/fs 0.0.4 → 0.1.0

package/lib/esm/promises.js

@@ -1,47 +1,98 @@
 import Gio from "@girs/gio-2.0";
 import GLib from "@girs/glib-2.0";
-import { warnNotImplemented } from "@gjsify/utils";
-import { join } from "path";
+import { join, dirname } from "node:path";
 import { getEncodingFromOptions, encodeUint8Array, decode } from "./encoding.js";
-import { writeFileSync, mkdirSync, rmdirSync, unlinkSync } from "./sync.js";
+import { realpathSync, readdirSync as readdirSyncFn, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, truncateSync, chmodSync, chownSync, linkSync } from "./sync.js";
 import { FileHandle } from "./file-handle.js";
 import { tempDirPath } from "./utils.js";
 import { Dirent } from "./dirent.js";
-import { realpathPromise as realpath } from "@gjsify/deno_std/node/_fs/_fs_realpath";
-import { readdirPromise as readdir } from "@gjsify/deno_std/node/_fs/_fs_readdir";
-import { symlinkPromise as symlink } from "@gjsify/deno_std/node/_fs/_fs_symlink";
-import { lstatPromise as lstat } from "@gjsify/deno_std/node/_fs/_fs_lstat";
-import { statPromise as stat } from "@gjsify/deno_std/node/_fs/_fs_stat";
+import { Stats, BigIntStats, STAT_ATTRIBUTES } from "./stats.js";
+import { createNodeError } from "./errors.js";
 async function mkdir(path, options) {
   let recursive;
-  let mode = 511;
+  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;
+    _mode = options;
   }
-  const firstPath = mkdirSync(path, {
-    recursive,
-    mode
+  const pathStr = path.toString();
+  if (recursive) {
+    return mkdirRecursiveAsync(pathStr);
+  }
+  const file = Gio.File.new_for_path(pathStr);
+  return new Promise((resolve, reject) => {
+    file.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+      try {
+        file.make_directory_finish(res);
+        resolve(void 0);
+      } catch (err) {
+        reject(createNodeError(err, "mkdir", path));
+      }
+    });
   });
-  return firstPath;
+}
+async function mkdirRecursiveAsync(pathStr) {
+  const file = Gio.File.new_for_path(pathStr);
+  try {
+    await new Promise((resolve, reject) => {
+      file.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+        try {
+          file.make_directory_finish(res);
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    });
+    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 = dirname(pathStr);
+      if (parentPath === pathStr) {
+        throw createNodeError(err, "mkdir", pathStr);
+      }
+      const firstCreated = await mkdirRecursiveAsync(parentPath);
+      const retryFile = Gio.File.new_for_path(pathStr);
+      await new Promise((resolve, reject) => {
+        retryFile.make_directory_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+          try {
+            retryFile.make_directory_finish(res);
+            resolve();
+          } catch (retryErr) {
+            reject(createNodeError(retryErr, "mkdir", pathStr));
+          }
+        });
+      });
+      return firstCreated ?? pathStr;
+    }
+    throw createNodeError(err, "mkdir", pathStr);
+  }
 }
 async function readFile(path, options = { encoding: null, flag: "r" }) {
   const file = Gio.File.new_for_path(path.toString());
-  const [ok, data] = await new Promise((resolve, reject) => {
-    file.load_contents_async(null, (self, res) => {
-      try {
-        resolve(file.load_contents_finish(res));
-      } catch (error) {
-        reject(error);
-      }
+  let ok;
+  let data;
+  try {
+    [ok, data] = await new Promise((resolve, reject) => {
+      file.load_contents_async(null, (self, res) => {
+        try {
+          resolve(file.load_contents_finish(res));
+        } catch (error) {
+          reject(error);
+        }
+      });
     });
-  });
+  } catch (error) {
+    throw createNodeError(error, "open", path.toString());
+  }
   if (!ok) {
-    throw new Error("failed to read file");
+    throw createNodeError(new Error("failed to read file"), "open", path.toString());
   }
   return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
 }
@@ -55,20 +106,103 @@ async function mkdtemp(prefix, options) {
   return decode(path, encoding);
 }
 async function writeFile(path, data) {
-  return writeFileSync(path, data);
+  const file = Gio.File.new_for_path(path);
+  let bytes;
+  if (typeof data === "string") {
+    bytes = new TextEncoder().encode(data);
+  } else if (data instanceof Uint8Array) {
+    bytes = data;
+  } else {
+    bytes = new TextEncoder().encode(String(data));
+  }
+  const outputStream = await new Promise((resolve, reject) => {
+    file.replace_async(null, false, Gio.FileCreateFlags.REPLACE_DESTINATION, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+      try {
+        resolve(file.replace_finish(res));
+      } catch (err) {
+        reject(createNodeError(err, "open", path));
+      }
+    });
+  });
+  if (bytes.length > 0) {
+    const glibBytes = new GLib.Bytes(bytes);
+    await new Promise((resolve, reject) => {
+      outputStream.write_bytes_async(glibBytes, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+        try {
+          outputStream.write_bytes_finish(res);
+          resolve();
+        } catch (err) {
+          reject(createNodeError(err, "write", path));
+        }
+      });
+    });
+  }
+  await new Promise((resolve, reject) => {
+    outputStream.close_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+      try {
+        outputStream.close_finish(res);
+        resolve();
+      } catch (err) {
+        reject(createNodeError(err, "close", path));
+      }
+    });
+  });
 }
-async function rmdir(path, options) {
-  return rmdirSync(path, options);
+async function rmdir(path, _options) {
+  const file = Gio.File.new_for_path(path.toString());
+  const info = await new Promise((resolve, reject) => {
+    file.query_info_async("standard::type", Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+      try {
+        resolve(file.query_info_finish(res));
+      } catch (err) {
+        reject(createNodeError(err, "rmdir", path));
+      }
+    });
+  });
+  if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
+    const err = Object.assign(new Error(), { code: 4 });
+    throw createNodeError(err, "rmdir", path);
+  }
+  const children = await new Promise((resolve, reject) => {
+    file.enumerate_children_async("standard::name", Gio.FileQueryInfoFlags.NONE, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+      try {
+        resolve(file.enumerate_children_finish(res));
+      } catch (err) {
+        reject(createNodeError(err, "rmdir", path));
+      }
+    });
+  });
+  const firstChild = children.next_file(null);
+  if (firstChild !== null) {
+    const err = Object.assign(new Error(), { code: 5 });
+    throw createNodeError(err, "rmdir", path);
+  }
+  await new Promise((resolve, reject) => {
+    file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+      try {
+        file.delete_finish(res);
+        resolve();
+      } catch (err) {
+        reject(createNodeError(err, "rmdir", path));
+      }
+    });
+  });
 }
 async function unlink(path) {
-  return unlinkSync(path);
+  const file = Gio.File.new_for_path(path);
+  await new Promise((resolve, reject) => {
+    file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+      try {
+        file.delete_finish(res);
+        resolve();
+      } catch (err) {
+        reject(createNodeError(err, "unlink", path));
+      }
+    });
+  });
 }
 async function open(path, flags, mode) {
-  return new FileHandle({
-    path,
-    flags,
-    mode
-  });
+  return new FileHandle({ path, flags, mode });
 }
 async function write(fd, data, positionOrOffset, encodingOrLength, position) {
   if (typeof data === "string") {
@@ -77,53 +211,122 @@ async function write(fd, data, positionOrOffset, encodingOrLength, position) {
   return _writeBuf(fd, data, positionOrOffset, encodingOrLength, position);
 }
 async function _writeBuf(fd, buffer, offset, length, position) {
-  warnNotImplemented("fs.promises.write");
-  return {
-    bytesWritten: 0,
-    buffer
-  };
+  const fileHandle = FileHandle.getInstance(fd);
+  const result = await fileHandle.write(buffer, offset, length, position);
+  return { bytesWritten: result.bytesWritten, buffer };
 }
 async function _writeStr(fd, data, position, encoding) {
-  warnNotImplemented("fs.promises.write");
-  return {
-    bytesWritten: 0,
-    buffer: data
-  };
+  const fileHandle = FileHandle.getInstance(fd);
+  const result = await fileHandle.write(data, position, encoding);
+  return { bytesWritten: result.bytesWritten, buffer: data };
+}
+function queryInfoAsync(path, flags, syscall, options) {
+  return new Promise((resolve, reject) => {
+    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);
+        resolve(options?.bigint ? new BigIntStats(info, path) : new Stats(info, path));
+      } catch (err) {
+        reject(createNodeError(err, syscall, path));
+      }
+    });
+  });
+}
+async function stat(path, options) {
+  return queryInfoAsync(path, Gio.FileQueryInfoFlags.NONE, "stat", options);
+}
+async function lstat(path, options) {
+  return queryInfoAsync(path, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, "lstat", options);
+}
+async function readdir(path, options) {
+  try {
+    return readdirSyncFn(path, options);
+  } catch (error) {
+    throw createNodeError(error, "scandir", path);
+  }
+}
+async function realpath(path) {
+  return realpathSync(path);
+}
+async function symlink(target, path, _type) {
+  return new Promise((resolve, reject) => {
+    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);
+        resolve();
+      } catch (err) {
+        reject(createNodeError(err, "symlink", target, path));
+      }
+    });
+  });
 }
 async function rm(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) return;
+    throw createNodeError(err, "rm", path);
+  }
   if (dirent.isDirectory()) {
     const childFiles = await readdir(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()) {
-        await rmdir(join(path.toString(), childFile.name), options);
-      } else if (childFile.isFile()) {
-        await rm(join(path.toString(), childFile.name), options);
+      if (typeof childFile !== "string") {
+        await rm(join(pathStr, childFile.name), options);
       }
     }
   }
-  const ok = await new Promise((resolve, reject) => {
-    try {
-      file.delete_async(GLib.PRIORITY_DEFAULT, null, (self, res) => {
-        try {
-          resolve(file.delete_finish(res));
-        } catch (error) {
-          reject(error);
+  await new Promise((resolve, reject) => {
+    file.delete_async(GLib.PRIORITY_DEFAULT, null, (_self, res) => {
+      try {
+        file.delete_finish(res);
+        resolve();
+      } catch (err) {
+        if (force) {
+          resolve();
+          return;
         }
-      });
-    } catch (error) {
-      reject(error);
-    }
+        reject(createNodeError(err, "rm", path));
+      }
+    });
   });
-  if (!ok) {
-    const err = new Error("failed to remove file " + path);
-    throw err;
-  }
+}
+async function rename(oldPath, newPath) {
+  renameSync(oldPath, newPath);
+}
+async function copyFile(src, dest, mode) {
+  copyFileSync(src, dest, mode);
+}
+async function access(path, mode) {
+  accessSync(path, mode);
+}
+async function appendFile(path, data, options) {
+  appendFileSync(path, data, options);
+}
+async function readlink(path, options) {
+  return readlinkSync(path, options);
+}
+async function truncate(path, len) {
+  truncateSync(path, len);
+}
+async function chmod(path, mode) {
+  chmodSync(path, mode);
+}
+async function chown(path, uid, gid) {
+  chownSync(path, uid, gid);
+}
+async function link(existingPath, newPath) {
+  linkSync(existingPath, newPath);
 }
 var promises_default = {
   readFile,
@@ -139,21 +342,39 @@ var promises_default = {
   rm,
   lstat,
   symlink,
-  stat
+  stat,
+  rename,
+  copyFile,
+  access,
+  appendFile,
+  readlink,
+  truncate,
+  chmod,
+  chown,
+  link
 };
 export {
+  access,
+  appendFile,
+  chmod,
+  chown,
+  copyFile,
   promises_default as default,
+  link,
   lstat,
   mkdir,
   mkdtemp,
   open,
   readFile,
   readdir,
+  readlink,
   realpath,
+  rename,
   rm,
   rmdir,
   stat,
   symlink,
+  truncate,
   unlink,
   write,
   writeFile

package/lib/esm/read-stream.js

@@ -1,71 +1,97 @@
+import Gio from "@girs/gio-2.0";
 import GLib from "@girs/glib-2.0";
-import { notImplemented } from "@gjsify/utils";
-import { Buffer } from "buffer";
-import { Readable } from "stream";
-import { URL } from "url";
-function fromFileUrl(url) {
-  url = url instanceof URL ? url : new URL(url);
-  if (url.protocol != "file:") {
-    throw new TypeError("Must be a file URL.");
-  }
-  return decodeURIComponent(
-    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25")
-  );
-}
+import { Buffer } from "node:buffer";
+import { Readable } from "node:stream";
+import { URL, fileURLToPath } from "node:url";
 class ReadStream extends Readable {
+  bytesRead = 0;
+  path;
+  pending = true;
+  fd = null;
+  _gioFile;
+  _inputStream = null;
+  _start;
+  _end;
+  _pos;
   close(callback) {
-    callback(notImplemented("ReadStream.close"));
+    if (this._inputStream) {
+      try {
+        this._inputStream.close(null);
+      } catch {
+      }
+      this._inputStream = null;
+    }
+    this.destroy();
+    if (callback) callback(null);
   }
-  /**
-   * The number of bytes that have been read so far.
-   * @since v6.4.0
-   */
-  bytesRead;
-  /**
-   * The path to the file the stream is reading from as specified in the first
-   * argument to `fs.createReadStream()`. If `path` is passed as a string, then`readStream.path` will be a string. If `path` is passed as a `Buffer`, then`readStream.path` will be a
-   * `Buffer`. If `fd` is specified, then`readStream.path` will be `undefined`.
-   * @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, v10.16.0
-   */
-  pending;
   constructor(path, opts) {
-    path = path instanceof URL ? fromFileUrl(path) : path;
-    const hasBadOptions = opts && (opts.start || opts.end);
-    if (hasBadOptions) {
-      notImplemented(
-        `fs.ReadStream.prototype.constructor with unsupported options (${JSON.stringify(opts)})`
-      );
+    if (path instanceof URL) {
+      path = fileURLToPath(path);
     }
-    const file = GLib.IOChannel.new_file(path.toString(), "r");
-    const buffer = "";
     super({
-      autoDestroy: true,
-      emitClose: true,
-      objectMode: false,
-      read: async function(_size) {
+      highWaterMark: opts?.highWaterMark ?? 64 * 1024,
+      encoding: opts?.encoding,
+      objectMode: false
+    });
+    this.path = path.toString();
+    this._gioFile = Gio.File.new_for_path(this.path.toString());
+    this._start = opts?.start ?? 0;
+    this._end = opts?.end ?? Infinity;
+    this._pos = this._start;
+    Promise.resolve().then(() => {
+      if (!this._inputStream && !this.destroyed) {
         try {
-          let n = 0;
-          file.read(buffer, 16 * 1024, n);
-          this.push(n ? Buffer.from(buffer.slice(0, n)) : null);
+          this._inputStream = this._gioFile.read(null);
+          this.pending = false;
+          this.emit("open", 0);
+          this.emit("ready");
+          if (this._start > 0 && this._inputStream.can_seek()) {
+            this._inputStream.seek(this._start, GLib.SeekType.SET, null);
+          }
         } catch (err) {
           this.destroy(err);
         }
-      },
-      destroy: (err, cb) => {
-        try {
-          file.close();
-        } catch {
-        }
-        cb(err);
       }
     });
-    this.path = path.toString();
+  }
+  _read(size) {
+    if (!this._inputStream) {
+      if (this.destroyed) return;
+      Promise.resolve().then(() => this._read(size));
+      return;
+    }
+    let toRead = size;
+    if (this._end !== Infinity) {
+      const remaining = this._end - this._pos + 1;
+      if (remaining <= 0) {
+        this.push(null);
+        return;
+      }
+      toRead = Math.min(size, remaining);
+    }
+    try {
+      const gbytes = this._inputStream.read_bytes(toRead, null);
+      const data = gbytes.get_data();
+      if (!data || data.length === 0) {
+        this.push(null);
+        return;
+      }
+      this.bytesRead += data.length;
+      this._pos += data.length;
+      this.push(Buffer.from(data));
+    } catch (err) {
+      this.destroy(err);
+    }
+  }
+  _destroy(error, callback) {
+    if (this._inputStream) {
+      try {
+        this._inputStream.close(null);
+      } catch {
+      }
+      this._inputStream = null;
+    }
+    callback(error);
   }
 }
 function createReadStream(path, options) {
@@ -73,6 +99,5 @@ function createReadStream(path, options) {
 }
 export {
   ReadStream,
-  createReadStream,
-  fromFileUrl
+  createReadStream
 };