@gjsify/fs 0.3.12 → 0.3.14

package/lib/esm/fs-watcher.js

@@ -1,171 +1,163 @@
+import { normalizePath } from "./utils.js";
 import GLib from "@girs/glib-2.0";
 import Gio from "@girs/gio-2.0";
 import { EventEmitter } from "node:events";
-import { normalizePath } from "./utils.js";
-const privates = /* @__PURE__ */ new WeakMap();
-class FSWatcher extends EventEmitter {
-  constructor(filename, options, listener) {
-    super();
-    if (!options || typeof options !== "object")
-      options = { persistent: true };
-    const persistent = options.persistent !== false;
-    const cancellable = Gio.Cancellable.new();
-    const pathStr = normalizePath(filename);
-    const file = Gio.File.new_for_path(pathStr);
-    const watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
-    watcher.connect("changed", changed.bind(this));
-    let sourceId = null;
-    if (persistent) {
-      sourceId = GLib.timeout_add(
-        GLib.PRIORITY_LOW,
-        2147483647,
-        () => GLib.SOURCE_CONTINUE
-      );
-    }
-    privates.set(this, {
-      persistent,
-      cancellable,
-      sourceId,
-      // even if never used later on, the monitor needs to be
-      // attached to this instance or GJS reference counter
-      // will ignore it and no watch will ever happen
-      watcher
-    });
-    if (listener) this.on("change", listener);
-  }
-  close() {
-    const priv = privates.get(this);
-    if (!priv.cancellable.is_cancelled()) {
-      priv.cancellable.cancel();
-      if (priv.sourceId !== null) {
-        GLib.source_remove(priv.sourceId);
-        priv.sourceId = null;
-      }
-    }
-  }
-  /**
-   * When called, requests that the Node.js event loop not exit so long as the
-   * FSWatcher is active. Calling ref() multiple times has no effect.
-   */
-  ref() {
-    const priv = privates.get(this);
-    if (!priv.persistent && !priv.cancellable.is_cancelled()) {
-      priv.persistent = true;
-      priv.sourceId = GLib.timeout_add(
-        GLib.PRIORITY_LOW,
-        2147483647,
-        () => GLib.SOURCE_CONTINUE
-      );
-    }
-    return this;
-  }
-  /**
-   * When called, the active FSWatcher will not require the Node.js event loop
-   * to remain active. Calling unref() multiple times has no effect.
-   */
-  unref() {
-    const priv = privates.get(this);
-    if (priv.persistent) {
-      priv.persistent = false;
-      if (priv.sourceId !== null) {
-        GLib.source_remove(priv.sourceId);
-        priv.sourceId = null;
-      }
-    }
-    return this;
-  }
-}
+
+//#region src/fs-watcher.ts
+const privates = new WeakMap();
+var FSWatcher = class extends EventEmitter {
+	constructor(filename, options, listener) {
+		super();
+		if (!options || typeof options !== "object") options = { persistent: true };
+		const persistent = options.persistent !== false;
+		const cancellable = Gio.Cancellable.new();
+		const pathStr = normalizePath(filename);
+		const file = Gio.File.new_for_path(pathStr);
+		const watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
+		watcher.connect("changed", changed.bind(this));
+		let sourceId = null;
+		if (persistent) {
+			sourceId = GLib.timeout_add(GLib.PRIORITY_LOW, 2147483647, () => GLib.SOURCE_CONTINUE);
+		}
+		privates.set(this, {
+			persistent,
+			cancellable,
+			sourceId,
+			watcher
+		});
+		if (listener) this.on("change", listener);
+	}
+	close() {
+		const priv = privates.get(this);
+		if (!priv.cancellable.is_cancelled()) {
+			priv.cancellable.cancel();
+			if (priv.sourceId !== null) {
+				GLib.source_remove(priv.sourceId);
+				priv.sourceId = null;
+			}
+		}
+	}
+	/**
+	* When called, requests that the Node.js event loop not exit so long as the
+	* FSWatcher is active. Calling ref() multiple times has no effect.
+	*/
+	ref() {
+		const priv = privates.get(this);
+		if (!priv.persistent && !priv.cancellable.is_cancelled()) {
+			priv.persistent = true;
+			priv.sourceId = GLib.timeout_add(GLib.PRIORITY_LOW, 2147483647, () => GLib.SOURCE_CONTINUE);
+		}
+		return this;
+	}
+	/**
+	* When called, the active FSWatcher will not require the Node.js event loop
+	* to remain active. Calling unref() multiple times has no effect.
+	*/
+	unref() {
+		const priv = privates.get(this);
+		if (priv.persistent) {
+			priv.persistent = false;
+			if (priv.sourceId !== null) {
+				GLib.source_remove(priv.sourceId);
+				priv.sourceId = null;
+			}
+		}
+		return this;
+	}
+};
 ;
 function changed(watcher, file, otherFile, eventType) {
-  switch (eventType) {
-    case Gio.FileMonitorEvent.CHANGES_DONE_HINT:
-      this.emit("change", "change", file.get_basename());
-      break;
-    case Gio.FileMonitorEvent.DELETED:
-    case Gio.FileMonitorEvent.CREATED:
-    case Gio.FileMonitorEvent.RENAMED:
-    case Gio.FileMonitorEvent.MOVED_IN:
-    case Gio.FileMonitorEvent.MOVED_OUT:
-      this.emit("rename", "rename", file.get_basename());
-      break;
-  }
+	switch (eventType) {
+		case Gio.FileMonitorEvent.CHANGES_DONE_HINT:
+			this.emit("change", "change", file.get_basename());
+			break;
+		case Gio.FileMonitorEvent.DELETED:
+		case Gio.FileMonitorEvent.CREATED:
+		case Gio.FileMonitorEvent.RENAMED:
+		case Gio.FileMonitorEvent.MOVED_IN:
+		case Gio.FileMonitorEvent.MOVED_OUT:
+			this.emit("rename", "rename", file.get_basename());
+			break;
+	}
 }
-var fs_watcher_default = FSWatcher;
 function gioEventToNodeType(eventType) {
-  switch (eventType) {
-    case Gio.FileMonitorEvent.CHANGES_DONE_HINT:
-      return "change";
-    case Gio.FileMonitorEvent.DELETED:
-    case Gio.FileMonitorEvent.CREATED:
-    case Gio.FileMonitorEvent.RENAMED:
-    case Gio.FileMonitorEvent.MOVED_IN:
-    case Gio.FileMonitorEvent.MOVED_OUT:
-      return "rename";
-    default:
-      return null;
-  }
+	switch (eventType) {
+		case Gio.FileMonitorEvent.CHANGES_DONE_HINT: return "change";
+		case Gio.FileMonitorEvent.DELETED:
+		case Gio.FileMonitorEvent.CREATED:
+		case Gio.FileMonitorEvent.RENAMED:
+		case Gio.FileMonitorEvent.MOVED_IN:
+		case Gio.FileMonitorEvent.MOVED_OUT: return "rename";
+		default: return null;
+	}
 }
 async function* watchAsync(filename, options) {
-  const signal = options?.signal;
-  if (signal?.aborted) return;
-  const pathStr = normalizePath(filename);
-  const file = Gio.File.new_for_path(pathStr);
-  const cancellable = Gio.Cancellable.new();
-  let watcher;
-  try {
-    watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
-  } catch {
-    return;
-  }
-  const eventQueue = [];
-  const waiterQueue = [];
-  let finished = false;
-  function enqueue(event) {
-    if (finished) return;
-    if (waiterQueue.length > 0) {
-      waiterQueue.shift().resolve({ value: event, done: false });
-    } else {
-      eventQueue.push(event);
-    }
-  }
-  function terminate() {
-    if (finished) return;
-    finished = true;
-    if (!cancellable.is_cancelled()) cancellable.cancel();
-    while (waiterQueue.length > 0) {
-      waiterQueue.shift().resolve({ value: void 0, done: true });
-    }
-  }
-  const signalId = watcher.connect("changed", (_mon, changedFile, _otherFile, eventType) => {
-    const type = gioEventToNodeType(eventType);
-    if (type === null) return;
-    enqueue({ eventType: type, filename: changedFile?.get_basename() ?? null });
-  });
-  const abortHandler = () => terminate();
-  signal?.addEventListener("abort", abortHandler);
-  try {
-    while (!finished) {
-      if (eventQueue.length > 0) {
-        yield eventQueue.shift();
-        continue;
-      }
-      const result = await new Promise((resolve) => {
-        waiterQueue.push({ resolve });
-      });
-      if (result.done) break;
-      yield result.value;
-    }
-  } finally {
-    signal?.removeEventListener("abort", abortHandler);
-    try {
-      watcher.disconnect(signalId);
-    } catch {
-    }
-    if (!cancellable.is_cancelled()) cancellable.cancel();
-  }
+	const signal = options?.signal;
+	if (signal?.aborted) return;
+	const pathStr = normalizePath(filename);
+	const file = Gio.File.new_for_path(pathStr);
+	const cancellable = Gio.Cancellable.new();
+	let watcher;
+	try {
+		watcher = file.monitor(Gio.FileMonitorFlags.NONE, cancellable);
+	} catch {
+		return;
+	}
+	const eventQueue = [];
+	const waiterQueue = [];
+	let finished = false;
+	function enqueue(event) {
+		if (finished) return;
+		if (waiterQueue.length > 0) {
+			waiterQueue.shift().resolve({
+				value: event,
+				done: false
+			});
+		} else {
+			eventQueue.push(event);
+		}
+	}
+	function terminate() {
+		if (finished) return;
+		finished = true;
+		if (!cancellable.is_cancelled()) cancellable.cancel();
+		while (waiterQueue.length > 0) {
+			waiterQueue.shift().resolve({
+				value: undefined,
+				done: true
+			});
+		}
+	}
+	const signalId = watcher.connect("changed", (_mon, changedFile, _otherFile, eventType) => {
+		const type = gioEventToNodeType(eventType);
+		if (type === null) return;
+		enqueue({
+			eventType: type,
+			filename: changedFile?.get_basename() ?? null
+		});
+	});
+	const abortHandler = () => terminate();
+	signal?.addEventListener("abort", abortHandler);
+	try {
+		while (!finished) {
+			if (eventQueue.length > 0) {
+				yield eventQueue.shift();
+				continue;
+			}
+			const result = await new Promise((resolve) => {
+				waiterQueue.push({ resolve });
+			});
+			if (result.done) break;
+			yield result.value;
+		}
+	} finally {
+		signal?.removeEventListener("abort", abortHandler);
+		try {
+			watcher.disconnect(signalId);
+		} catch {}
+		if (!cancellable.is_cancelled()) cancellable.cancel();
+	}
 }
-export {
-  FSWatcher,
-  fs_watcher_default as default,
-  watchAsync
-};
+
+//#endregion
+export { FSWatcher, FSWatcher as default, watchAsync };

package/lib/esm/glob.js

@@ -1,164 +1,163 @@
-import { readdirSync } from "./sync.js";
 import { normalizePath } from "./utils.js";
+import { readdirSync } from "./sync.js";
+
+//#region src/glob.ts
+/** Convert a single glob segment (no `/`) to a regex source string */
 function segmentToRegexSrc(seg) {
-  const extglob = /^([!*+?@])\((.+)\)$/.exec(seg);
-  if (extglob) {
-    const [, type, inner] = extglob;
-    const parts = inner.split("|").map((p) => segmentToRegexSrc(p));
-    const group = "(?:" + parts.join("|") + ")";
-    switch (type) {
-      case "!":
-        return "(?!(?:" + parts.join("|") + "))[^/]*";
-      case "*":
-        return group + "*";
-      case "+":
-        return group + "+";
-      case "?":
-        return group + "?";
-      case "@":
-        return group;
-    }
-  }
-  let result = "";
-  let i = 0;
-  while (i < seg.length) {
-    const c = seg[i];
-    if (c === "*") {
-      result += "[^/]*";
-      i++;
-      continue;
-    }
-    if (c === "?") {
-      result += "[^/]";
-      i++;
-      continue;
-    }
-    if (c === "[") {
-      const end = seg.indexOf("]", i + 1);
-      if (end === -1) {
-        result += "\\[";
-        i++;
-        continue;
-      }
-      result += seg.slice(i, end + 1);
-      i = end + 1;
-      continue;
-    }
-    if (c === "{") {
-      const end = seg.indexOf("}", i + 1);
-      if (end === -1) {
-        result += "\\{";
-        i++;
-        continue;
-      }
-      const alts = seg.slice(i + 1, end).split(",").map((a) => segmentToRegexSrc(a.trim()));
-      result += "(?:" + alts.join("|") + ")";
-      i = end + 1;
-      continue;
-    }
-    if (".+^$|()[]{}".includes(c)) {
-      result += "\\" + c;
-    } else {
-      result += c;
-    }
-    i++;
-  }
-  return result;
+	const extglob = /^([!*+?@])\((.+)\)$/.exec(seg);
+	if (extglob) {
+		const [, type, inner] = extglob;
+		const parts = inner.split("|").map((p) => segmentToRegexSrc(p));
+		const group = "(?:" + parts.join("|") + ")";
+		switch (type) {
+			case "!": return "(?!(?:" + parts.join("|") + "))[^/]*";
+			case "*": return group + "*";
+			case "+": return group + "+";
+			case "?": return group + "?";
+			case "@": return group;
+		}
+	}
+	let result = "";
+	let i = 0;
+	while (i < seg.length) {
+		const c = seg[i];
+		if (c === "*") {
+			result += "[^/]*";
+			i++;
+			continue;
+		}
+		if (c === "?") {
+			result += "[^/]";
+			i++;
+			continue;
+		}
+		if (c === "[") {
+			const end = seg.indexOf("]", i + 1);
+			if (end === -1) {
+				result += "\\[";
+				i++;
+				continue;
+			}
+			result += seg.slice(i, end + 1);
+			i = end + 1;
+			continue;
+		}
+		if (c === "{") {
+			const end = seg.indexOf("}", i + 1);
+			if (end === -1) {
+				result += "\\{";
+				i++;
+				continue;
+			}
+			const alts = seg.slice(i + 1, end).split(",").map((a) => segmentToRegexSrc(a.trim()));
+			result += "(?:" + alts.join("|") + ")";
+			i = end + 1;
+			continue;
+		}
+		if (".+^$|()[]{}".includes(c)) {
+			result += "\\" + c;
+		} else {
+			result += c;
+		}
+		i++;
+	}
+	return result;
 }
+/**
+* Convert a glob pattern to a RegExp that matches relative POSIX paths.
+*/
 function globToRegex(pattern) {
-  pattern = pattern.replace(/\/+/g, "/").replace(/^\.\//, "");
-  const segments = pattern.split("/");
-  const parts = [];
-  for (let si = 0; si < segments.length; si++) {
-    const seg = segments[si];
-    const isLast = si === segments.length - 1;
-    if (seg === "**") {
-      if (isLast) {
-        if (parts.length > 0 && parts[parts.length - 1] === "/") {
-          parts.pop();
-          parts.push("(?:/.+)?");
-        } else {
-          parts.push("(?:.+)?");
-        }
-      } else {
-        parts.push("(?:[^/]+/)*");
-      }
-    } else {
-      parts.push(segmentToRegexSrc(seg));
-      if (!isLast) parts.push("/");
-    }
-  }
-  return new RegExp("^(?:" + parts.join("") + ")$");
+	pattern = pattern.replace(/\/+/g, "/").replace(/^\.\//, "");
+	const segments = pattern.split("/");
+	const parts = [];
+	for (let si = 0; si < segments.length; si++) {
+		const seg = segments[si];
+		const isLast = si === segments.length - 1;
+		if (seg === "**") {
+			if (isLast) {
+				if (parts.length > 0 && parts[parts.length - 1] === "/") {
+					parts.pop();
+					parts.push("(?:/.+)?");
+				} else {
+					parts.push("(?:.+)?");
+				}
+			} else {
+				parts.push("(?:[^/]+/)*");
+			}
+		} else {
+			parts.push(segmentToRegexSrc(seg));
+			if (!isLast) parts.push("/");
+		}
+	}
+	return new RegExp("^(?:" + parts.join("") + ")$");
 }
 function buildExcludePredicate(exclude) {
-  if (!exclude) return null;
-  if (typeof exclude === "function") return exclude;
-  const patterns = Array.isArray(exclude) ? exclude : [exclude];
-  const regexes = patterns.map((p) => globToRegex(p));
-  return (path) => regexes.some((rx) => rx.test(path));
+	if (!exclude) return null;
+	if (typeof exclude === "function") return exclude;
+	const patterns = Array.isArray(exclude) ? exclude : [exclude];
+	const regexes = patterns.map((p) => globToRegex(p));
+	return (path) => regexes.some((rx) => rx.test(path));
 }
 function matchAll(pattern, cwd, exclude) {
-  const regex = globToRegex(pattern);
-  const isExcluded = buildExcludePredicate(exclude);
-  let allEntries;
-  try {
-    allEntries = readdirSync(cwd, { recursive: true });
-  } catch {
-    return [];
-  }
-  const candidates = [".", ...allEntries];
-  const results = [];
-  for (const entry of candidates) {
-    const normalized = entry.replace(/\\/g, "/");
-    if (!regex.test(normalized)) continue;
-    if (isExcluded && isExcluded(normalized)) continue;
-    results.push(entry);
-  }
-  return results;
+	const regex = globToRegex(pattern);
+	const isExcluded = buildExcludePredicate(exclude);
+	let allEntries;
+	try {
+		allEntries = readdirSync(cwd, { recursive: true });
+	} catch {
+		return [];
+	}
+	const candidates = [".", ...allEntries];
+	const results = [];
+	for (const entry of candidates) {
+		const normalized = entry.replace(/\\/g, "/");
+		if (!regex.test(normalized)) continue;
+		if (isExcluded && isExcluded(normalized)) continue;
+		results.push(entry);
+	}
+	return results;
 }
 function globSync(pattern, options) {
-  const patterns = Array.isArray(pattern) ? pattern : [pattern];
-  const cwd = options?.cwd ? normalizePath(options.cwd) : globalThis.process?.cwd?.() ?? "/";
-  const exclude = options?.exclude;
-  const seen = /* @__PURE__ */ new Set();
-  const results = [];
-  for (const p of patterns) {
-    for (const match of matchAll(p, cwd, exclude)) {
-      if (!seen.has(match)) {
-        seen.add(match);
-        results.push(match);
-      }
-    }
-  }
-  return results;
+	const patterns = Array.isArray(pattern) ? pattern : [pattern];
+	const cwd = options?.cwd ? normalizePath(options.cwd) : globalThis.process?.cwd?.() ?? "/";
+	const exclude = options?.exclude;
+	const seen = new Set();
+	const results = [];
+	for (const p of patterns) {
+		for (const match of matchAll(p, cwd, exclude)) {
+			if (!seen.has(match)) {
+				seen.add(match);
+				results.push(match);
+			}
+		}
+	}
+	return results;
 }
 function glob(pattern, options, callback) {
-  let opts;
-  let cb;
-  if (typeof options === "function") {
-    cb = options;
-    opts = {};
-  } else {
-    cb = callback;
-    opts = options || {};
-  }
-  Promise.resolve().then(() => {
-    try {
-      const matches = globSync(pattern, opts);
-      cb(null, matches);
-    } catch (err) {
-      cb(err, []);
-    }
-  });
+	let opts;
+	let cb;
+	if (typeof options === "function") {
+		cb = options;
+		opts = {};
+	} else {
+		cb = callback;
+		opts = options || {};
+	}
+	Promise.resolve().then(() => {
+		try {
+			const matches = globSync(pattern, opts);
+			cb(null, matches);
+		} catch (err) {
+			cb(err, []);
+		}
+	});
 }
 async function* globAsync(pattern, options) {
-  const matches = globSync(pattern, options);
-  for (const m of matches) {
-    yield m;
-  }
+	const matches = globSync(pattern, options);
+	for (const m of matches) {
+		yield m;
+	}
 }
-export {
-  glob,
-  globAsync,
-  globSync
-};
+
+//#endregion
+export { glob, globAsync, globSync };