@gjsify/fs 0.3.13 → 0.3.14

package/lib/esm/read-stream.js

@@ -1,113 +1,109 @@
-import Gio from "@girs/gio-2.0";
+import { normalizePath } from "./utils.js";
 import GLib from "@girs/glib-2.0";
+import Gio from "@girs/gio-2.0";
 import { Buffer } from "node:buffer";
 import { Readable } from "node:stream";
-import { normalizePath } from "./utils.js";
-class ReadStream extends Readable {
-  bytesRead = 0;
-  path;
-  pending = true;
-  fd = null;
-  _gioFile;
-  _inputStream = null;
-  _cancellable = new Gio.Cancellable();
-  _start;
-  _end;
-  _pos;
-  close(callback) {
-    this._cancellable.cancel();
-    if (this._inputStream) {
-      this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {
-      });
-      this._inputStream = null;
-    }
-    this.destroy();
-    if (callback) callback(null);
-  }
-  constructor(path, opts) {
-    const pathStr = normalizePath(path);
-    super({
-      highWaterMark: opts?.highWaterMark ?? 64 * 1024,
-      encoding: opts?.encoding,
-      objectMode: false
-    });
-    this.path = pathStr;
-    this._gioFile = Gio.File.new_for_path(pathStr);
-    this._start = opts?.start ?? 0;
-    this._end = opts?.end ?? Infinity;
-    this._pos = this._start;
-  }
-  // Use _construct() for async file opening so the stream machinery defers
-  // _read() until the file is open. This avoids the fragile _pendingReadSize
-  // pattern and correctly handles backpressure via the constructed flag.
-  _construct(callback) {
-    this._gioFile.read_async(GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
-      if (this.destroyed) {
-        callback();
-        return;
-      }
-      try {
-        this._inputStream = this._gioFile.read_finish(asyncResult);
-        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);
-        }
-        callback();
-      } catch (err) {
-        if (!this._cancellable.is_cancelled()) {
-          callback(err);
-        }
-      }
-    });
-  }
-  _read(size) {
-    this._doRead(size);
-  }
-  _doRead(size) {
-    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);
-    }
-    const stream = this._inputStream;
-    stream.read_bytes_async(toRead, GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
-      try {
-        const gbytes = stream.read_bytes_finish(asyncResult);
-        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) {
-        if (!this._cancellable.is_cancelled()) {
-          this.destroy(err);
-        }
-      }
-    });
-  }
-  _destroy(error, callback) {
-    this._cancellable.cancel();
-    if (this._inputStream) {
-      this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {
-      });
-      this._inputStream = null;
-    }
-    callback(error);
-  }
-}
+
+//#region src/read-stream.ts
+var ReadStream = class extends Readable {
+	bytesRead = 0;
+	path;
+	pending = true;
+	fd = null;
+	_gioFile;
+	_inputStream = null;
+	_cancellable = new Gio.Cancellable();
+	_start;
+	_end;
+	_pos;
+	close(callback) {
+		this._cancellable.cancel();
+		if (this._inputStream) {
+			this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {});
+			this._inputStream = null;
+		}
+		this.destroy();
+		if (callback) callback(null);
+	}
+	constructor(path, opts) {
+		const pathStr = normalizePath(path);
+		super({
+			highWaterMark: opts?.highWaterMark ?? 64 * 1024,
+			encoding: opts?.encoding,
+			objectMode: false
+		});
+		this.path = pathStr;
+		this._gioFile = Gio.File.new_for_path(pathStr);
+		this._start = opts?.start ?? 0;
+		this._end = opts?.end ?? Infinity;
+		this._pos = this._start;
+	}
+	_construct(callback) {
+		this._gioFile.read_async(GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
+			if (this.destroyed) {
+				callback();
+				return;
+			}
+			try {
+				this._inputStream = this._gioFile.read_finish(asyncResult);
+				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);
+				}
+				callback();
+			} catch (err) {
+				if (!this._cancellable.is_cancelled()) {
+					callback(err);
+				}
+			}
+		});
+	}
+	_read(size) {
+		this._doRead(size);
+	}
+	_doRead(size) {
+		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);
+		}
+		const stream = this._inputStream;
+		stream.read_bytes_async(toRead, GLib.PRIORITY_DEFAULT, this._cancellable, (_source, asyncResult) => {
+			try {
+				const gbytes = stream.read_bytes_finish(asyncResult);
+				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) {
+				if (!this._cancellable.is_cancelled()) {
+					this.destroy(err);
+				}
+			}
+		});
+	}
+	_destroy(error, callback) {
+		this._cancellable.cancel();
+		if (this._inputStream) {
+			this._inputStream.close_async(GLib.PRIORITY_DEFAULT, null, () => {});
+			this._inputStream = null;
+		}
+		callback(error);
+	}
+};
 function createReadStream(path, options) {
-  return new ReadStream(path, options);
+	return new ReadStream(path, options);
 }
-export {
-  ReadStream,
-  createReadStream
-};
+
+//#endregion
+export { ReadStream, createReadStream };

package/lib/esm/stat-watcher.js

@@ -1,121 +1,120 @@
-import { EventEmitter } from "node:events";
 import { statSync } from "./sync.js";
+import { EventEmitter } from "node:events";
+
+//#region src/stat-watcher.ts
 function zeroedStat() {
-  return {
-    dev: 0,
-    ino: 0,
-    mode: 0,
-    nlink: 0,
-    uid: 0,
-    gid: 0,
-    rdev: 0,
-    size: 0,
-    blksize: 0,
-    blocks: 0,
-    atimeMs: 0,
-    mtimeMs: 0,
-    ctimeMs: 0,
-    birthtimeMs: 0,
-    atime: /* @__PURE__ */ new Date(0),
-    mtime: /* @__PURE__ */ new Date(0),
-    ctime: /* @__PURE__ */ new Date(0),
-    birthtime: /* @__PURE__ */ new Date(0),
-    isFile: () => false,
-    isDirectory: () => false,
-    isBlockDevice: () => false,
-    isCharacterDevice: () => false,
-    isSymbolicLink: () => false,
-    isFIFO: () => false,
-    isSocket: () => false
-  };
-}
-class StatWatcher extends EventEmitter {
-  _path;
-  _interval;
-  _timerId = null;
-  _prev;
-  _changeCount = 0;
-  constructor(path, interval) {
-    super();
-    this._path = path;
-    this._interval = interval;
-    this._prev = zeroedStat();
-  }
-  start() {
-    try {
-      this._prev = statSync(this._path);
-    } catch {
-    }
-    this._timerId = setInterval(() => {
-      let curr;
-      try {
-        curr = statSync(this._path);
-      } catch {
-        curr = zeroedStat();
-      }
-      const prev = this._prev;
-      if (curr.mtimeMs !== prev.mtimeMs || curr.size !== prev.size || curr.ino !== prev.ino) {
-        this._prev = curr;
-        this.emit("change", curr, prev);
-      }
-    }, this._interval);
-  }
-  stop() {
-    if (this._timerId !== null) {
-      clearInterval(this._timerId);
-      this._timerId = null;
-    }
-    this.emit("stop");
-  }
-  addChangeListener(listener) {
-    this._changeCount++;
-    this.on("change", listener);
-  }
-  removeChangeListener(listener) {
-    this._changeCount--;
-    this.removeListener("change", listener);
-  }
-  removeAllChangeListeners() {
-    this._changeCount = 0;
-    this.removeAllListeners("change");
-  }
-  get changeListenerCount() {
-    return this._changeCount;
-  }
+	return {
+		dev: 0,
+		ino: 0,
+		mode: 0,
+		nlink: 0,
+		uid: 0,
+		gid: 0,
+		rdev: 0,
+		size: 0,
+		blksize: 0,
+		blocks: 0,
+		atimeMs: 0,
+		mtimeMs: 0,
+		ctimeMs: 0,
+		birthtimeMs: 0,
+		atime: new Date(0),
+		mtime: new Date(0),
+		ctime: new Date(0),
+		birthtime: new Date(0),
+		isFile: () => false,
+		isDirectory: () => false,
+		isBlockDevice: () => false,
+		isCharacterDevice: () => false,
+		isSymbolicLink: () => false,
+		isFIFO: () => false,
+		isSocket: () => false
+	};
 }
-const statWatchers = /* @__PURE__ */ new Map();
+var StatWatcher = class extends EventEmitter {
+	_path;
+	_interval;
+	_timerId = null;
+	_prev;
+	_changeCount = 0;
+	constructor(path, interval) {
+		super();
+		this._path = path;
+		this._interval = interval;
+		this._prev = zeroedStat();
+	}
+	start() {
+		try {
+			this._prev = statSync(this._path);
+		} catch {}
+		this._timerId = setInterval(() => {
+			let curr;
+			try {
+				curr = statSync(this._path);
+			} catch {
+				curr = zeroedStat();
+			}
+			const prev = this._prev;
+			if (curr.mtimeMs !== prev.mtimeMs || curr.size !== prev.size || curr.ino !== prev.ino) {
+				this._prev = curr;
+				this.emit("change", curr, prev);
+			}
+		}, this._interval);
+	}
+	stop() {
+		if (this._timerId !== null) {
+			clearInterval(this._timerId);
+			this._timerId = null;
+		}
+		this.emit("stop");
+	}
+	addChangeListener(listener) {
+		this._changeCount++;
+		this.on("change", listener);
+	}
+	removeChangeListener(listener) {
+		this._changeCount--;
+		this.removeListener("change", listener);
+	}
+	removeAllChangeListeners() {
+		this._changeCount = 0;
+		this.removeAllListeners("change");
+	}
+	get changeListenerCount() {
+		return this._changeCount;
+	}
+};
+const statWatchers = new Map();
 function watchFile(filename, options, listener) {
-  if (typeof options === "function") {
-    listener = options;
-    options = {};
-  }
-  const interval = options.interval ?? 5007;
-  const resolved = filename.toString();
-  let watcher = statWatchers.get(resolved);
-  if (!watcher) {
-    watcher = new StatWatcher(resolved, interval);
-    watcher.start();
-    statWatchers.set(resolved, watcher);
-  }
-  if (listener) watcher.addChangeListener(listener);
-  return watcher;
+	if (typeof options === "function") {
+		listener = options;
+		options = {};
+	}
+	const interval = options.interval ?? 5007;
+	const resolved = filename.toString();
+	let watcher = statWatchers.get(resolved);
+	if (!watcher) {
+		watcher = new StatWatcher(resolved, interval);
+		watcher.start();
+		statWatchers.set(resolved, watcher);
+	}
+	if (listener) watcher.addChangeListener(listener);
+	return watcher;
 }
 function unwatchFile(filename, listener) {
-  const resolved = filename.toString();
-  const watcher = statWatchers.get(resolved);
-  if (!watcher) return;
-  if (listener) {
-    watcher.removeChangeListener(listener);
-  } else {
-    watcher.removeAllChangeListeners();
-  }
-  if (watcher.changeListenerCount === 0) {
-    watcher.stop();
-    statWatchers.delete(resolved);
-  }
+	const resolved = filename.toString();
+	const watcher = statWatchers.get(resolved);
+	if (!watcher) return;
+	if (listener) {
+		watcher.removeChangeListener(listener);
+	} else {
+		watcher.removeAllChangeListeners();
+	}
+	if (watcher.changeListenerCount === 0) {
+		watcher.stop();
+		statWatchers.delete(resolved);
+	}
 }
-export {
-  StatWatcher,
-  unwatchFile,
-  watchFile
-};
+
+//#endregion
+export { StatWatcher, unwatchFile, watchFile };

package/lib/esm/statfs.js

@@ -1,57 +1,70 @@
-import Gio from "@girs/gio-2.0";
-import GLib from "@girs/glib-2.0";
 import { normalizePath } from "./utils.js";
-const FS_INFO_ATTRS = [
-  "filesystem::size",
-  "filesystem::free"
-].join(",");
+import GLib from "@girs/glib-2.0";
+import Gio from "@girs/gio-2.0";
+
+//#region src/statfs.ts
+const FS_INFO_ATTRS = ["filesystem::size", "filesystem::free"].join(",");
 const BSIZE = 4096;
 function buildStatFs(info) {
-  const totalBytes = Number(info.get_attribute_uint64("filesystem::size") ?? 0);
-  const freeBytes = Number(info.get_attribute_uint64("filesystem::free") ?? 0);
-  const blocks = Math.floor(totalBytes / BSIZE);
-  const bfree = Math.floor(freeBytes / BSIZE);
-  return { type: 0, bsize: BSIZE, blocks, bfree, bavail: bfree, files: 0, ffree: 0 };
+	const totalBytes = Number(info.get_attribute_uint64("filesystem::size") ?? 0);
+	const freeBytes = Number(info.get_attribute_uint64("filesystem::free") ?? 0);
+	const blocks = Math.floor(totalBytes / BSIZE);
+	const bfree = Math.floor(freeBytes / BSIZE);
+	return {
+		type: 0,
+		bsize: BSIZE,
+		blocks,
+		bfree,
+		bavail: bfree,
+		files: 0,
+		ffree: 0
+	};
 }
 function buildBigIntStatFs(info) {
-  const totalBytes = BigInt(info.get_attribute_uint64("filesystem::size") ?? 0);
-  const freeBytes = BigInt(info.get_attribute_uint64("filesystem::free") ?? 0);
-  const bsize = BigInt(BSIZE);
-  const blocks = totalBytes / bsize;
-  const bfree = freeBytes / bsize;
-  return { type: 0n, bsize, blocks, bfree, bavail: bfree, files: 0n, ffree: 0n };
+	const totalBytes = BigInt(info.get_attribute_uint64("filesystem::size") ?? 0);
+	const freeBytes = BigInt(info.get_attribute_uint64("filesystem::free") ?? 0);
+	const bsize = BigInt(BSIZE);
+	const blocks = totalBytes / bsize;
+	const bfree = freeBytes / bsize;
+	return {
+		type: 0n,
+		bsize,
+		blocks,
+		bfree,
+		bavail: bfree,
+		files: 0n,
+		ffree: 0n
+	};
 }
 function statfsSync(path, options) {
-  const file = Gio.File.new_for_path(normalizePath(path));
-  const info = file.query_filesystem_info(FS_INFO_ATTRS, null);
-  return options?.bigint === true ? buildBigIntStatFs(info) : buildStatFs(info);
+	const file = Gio.File.new_for_path(normalizePath(path));
+	const info = file.query_filesystem_info(FS_INFO_ATTRS, null);
+	return options?.bigint === true ? buildBigIntStatFs(info) : buildStatFs(info);
 }
 function queryFsInfoAsync(path, useBigInt) {
-  return new Promise((resolve, reject) => {
-    const file = Gio.File.new_for_path(normalizePath(path));
-    file.query_filesystem_info_async(FS_INFO_ATTRS, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
-      try {
-        const info = file.query_filesystem_info_finish(res);
-        resolve(useBigInt ? buildBigIntStatFs(info) : buildStatFs(info));
-      } catch (err) {
-        reject(err);
-      }
-    });
-  });
+	return new Promise((resolve, reject) => {
+		const file = Gio.File.new_for_path(normalizePath(path));
+		file.query_filesystem_info_async(FS_INFO_ATTRS, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
+			try {
+				const info = file.query_filesystem_info_finish(res);
+				resolve(useBigInt ? buildBigIntStatFs(info) : buildStatFs(info));
+			} catch (err) {
+				reject(err);
+			}
+		});
+	});
 }
 function statfs(path, optionsOrCb, callback) {
-  if (typeof optionsOrCb === "function") {
-    callback = optionsOrCb;
-    optionsOrCb = {};
-  }
-  const useBigInt = optionsOrCb?.bigint === true;
-  queryFsInfoAsync(path, useBigInt).then((result) => callback(null, result), (err) => callback(err, null));
+	if (typeof optionsOrCb === "function") {
+		callback = optionsOrCb;
+		optionsOrCb = {};
+	}
+	const useBigInt = optionsOrCb?.bigint === true;
+	queryFsInfoAsync(path, useBigInt).then((result) => callback(null, result), (err) => callback(err, null));
 }
 async function statfsAsync(path, options) {
-  return queryFsInfoAsync(path, options?.bigint === true);
+	return queryFsInfoAsync(path, options?.bigint === true);
 }
-export {
-  statfs,
-  statfsAsync,
-  statfsSync
-};
+
+//#endregion
+export { statfs, statfsAsync, statfsSync };