@gjsify/fs 0.1.13 → 0.2.0

package/lib/esm/glob.js

@@ -0,0 +1,164 @@
+import { readdirSync } from "./sync.js";
+import { normalizePath } from "./utils.js";
+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;
+}
+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("") + ")$");
+}
+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));
+}
+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;
+}
+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;
+}
+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, []);
+    }
+  });
+}
+async function* globAsync(pattern, options) {
+  const matches = globSync(pattern, options);
+  for (const m of matches) {
+    yield m;
+  }
+}
+export {
+  glob,
+  globAsync,
+  globSync
+};

package/lib/esm/index.js

@@ -60,8 +60,48 @@ import {
   WriteStream
 } from "./write-stream.js";
 import * as promises from "./promises.js";
+import { cpSync, cp } from "./cp.js";
+import { Dir, opendir, opendirSync } from "./dir.js";
+import { glob, globSync } from "./glob.js";
+import { StatWatcher, watchFile, unwatchFile } from "./stat-watcher.js";
+import { statfsSync, statfs } from "./statfs.js";
 import { Stats, BigIntStats } from "./stats.js";
 import { Dirent } from "./dirent.js";
+import {
+  utimesSync,
+  utimes,
+  lutimesSync,
+  lutimes,
+  lchownSync,
+  lchown,
+  lchmodSync,
+  lchmod
+} from "./utimes.js";
+import {
+  fstatSync,
+  fstat,
+  ftruncateSync,
+  ftruncate,
+  fdatasyncSync,
+  fdatasync,
+  fsyncSync,
+  fsync,
+  fchmodSync,
+  fchmod,
+  fchownSync,
+  fchown,
+  futimesSync,
+  futimes,
+  closeSync,
+  readSync,
+  writeSync,
+  readvSync,
+  readv,
+  writevSync,
+  writev,
+  exists,
+  openAsBlob
+} from "./fd-ops.js";
 const constants = {
   // File access constants
   F_OK: 0,
@@ -109,9 +149,11 @@ const constants = {
 };
 var index_default = {
   FSWatcher,
+  StatWatcher,
   Stats,
   BigIntStats,
   Dirent,
+  Dir,
   constants,
   existsSync,
   readdirSync,
@@ -136,7 +178,46 @@ var index_default = {
   truncateSync,
   chmodSync,
   chownSync,
+  cpSync,
+  opendirSync,
+  globSync,
+  glob,
   watch,
+  watchFile,
+  unwatchFile,
+  statfsSync,
+  statfs,
+  utimesSync,
+  utimes,
+  lutimesSync,
+  lutimes,
+  lchownSync,
+  lchown,
+  lchmodSync,
+  lchmod,
+  fstatSync,
+  fstat,
+  ftruncateSync,
+  ftruncate,
+  fdatasyncSync,
+  fdatasync,
+  fsyncSync,
+  fsync,
+  fchmodSync,
+  fchmod,
+  fchownSync,
+  fchown,
+  futimesSync,
+  futimes,
+  closeSync,
+  readSync,
+  writeSync,
+  readvSync,
+  readv,
+  writevSync,
+  writev,
+  exists,
+  openAsBlob,
   createReadStream,
   ReadStream,
   createWriteStream,
@@ -154,6 +235,7 @@ var index_default = {
   stat,
   rename,
   copyFile,
+  cp,
   access,
   appendFile,
   readlink,
@@ -165,13 +247,16 @@ var index_default = {
   readFile,
   writeFile,
   unlink,
-  link
+  link,
+  opendir
 };
 export {
   BigIntStats,
+  Dir,
   Dirent,
   FSWatcher,
   ReadStream,
+  StatWatcher,
   Stats,
   WriteStream,
   access,
@@ -183,30 +268,62 @@ export {
   chown,
   chownSync,
   close,
+  closeSync,
   constants,
   copyFile,
   copyFileSync,
+  cp,
+  cpSync,
   createReadStream,
   createWriteStream,
   index_default as default,
+  exists,
   existsSync,
+  fchmod,
+  fchmodSync,
+  fchown,
+  fchownSync,
+  fdatasync,
+  fdatasyncSync,
+  fstat,
+  fstatSync,
+  fsync,
+  fsyncSync,
+  ftruncate,
+  ftruncateSync,
+  futimes,
+  futimesSync,
+  glob,
+  globSync,
+  lchmod,
+  lchmodSync,
+  lchown,
+  lchownSync,
   link,
   linkSync,
   lstat,
   lstatSync,
+  lutimes,
+  lutimesSync,
   mkdir,
   mkdirSync,
   mkdtempSync,
   open,
+  openAsBlob,
   openSync,
+  opendir,
+  opendirSync,
   promises,
   read,
   readFile,
   readFileSync,
+  readSync,
   readdir,
   readdirSync,
   readlink,
   readlinkSync,
+  readv,
+  readvSync,
   realpath,
   realpathSync,
   rename,
@@ -217,14 +334,23 @@ export {
   rmdirSync,
   stat,
   statSync,
+  statfs,
+  statfsSync,
   symlink,
   symlinkSync,
   truncate,
   truncateSync,
   unlink,
   unlinkSync,
+  unwatchFile,
+  utimes,
+  utimesSync,
   watch,
+  watchFile,
   write,
   writeFile,
-  writeFileSync
+  writeFileSync,
+  writeSync,
+  writev,
+  writevSync
 };

package/lib/esm/promises.js

@@ -3,8 +3,26 @@ import GLib from "@girs/glib-2.0";
 import { join, dirname } from "node:path";
 import { getEncodingFromOptions, encodeUint8Array, decode } from "./encoding.js";
 import { realpathSync, readdirSync as readdirSyncFn, renameSync, copyFileSync, accessSync, appendFileSync, readlinkSync, truncateSync, chmodSync, chownSync, linkSync } from "./sync.js";
+import { cpAsync } from "./cp.js";
+import { opendirAsync } from "./dir.js";
+import { globAsync } from "./glob.js";
+import { watchAsync } from "./fs-watcher.js";
+import { statfsAsync } from "./statfs.js";
+import { utimesAsync, lutimesAsync, lchownAsync, lchmodAsync } from "./utimes.js";
+import {
+  fstatAsync,
+  ftruncateAsync,
+  fdatasyncAsync,
+  fsyncAsync,
+  fchmodAsync,
+  fchownAsync,
+  futimesAsync,
+  readvAsync,
+  writevAsync,
+  openAsBlob
+} from "./fd-ops.js";
 import { FileHandle } from "./file-handle.js";
-import { tempDirPath } from "./utils.js";
+import { tempDirPath, normalizePath } from "./utils.js";
 import { Dirent } from "./dirent.js";
 import { Stats, BigIntStats, STAT_ATTRIBUTES } from "./stats.js";
 import { createNodeError } from "./errors.js";
@@ -17,7 +35,7 @@ async function mkdir(path, options) {
   } else {
     _mode = options;
   }
-  const pathStr = path.toString();
+  const pathStr = normalizePath(path);
   if (recursive) {
     return mkdirRecursiveAsync(pathStr);
   }
@@ -28,7 +46,7 @@ async function mkdir(path, options) {
         file.make_directory_finish(res);
         resolve(void 0);
       } catch (err) {
-        reject(createNodeError(err, "mkdir", path));
+        reject(createNodeError(err, "mkdir", pathStr));
       }
     });
   });
@@ -75,7 +93,8 @@ async function mkdirRecursiveAsync(pathStr) {
   }
 }
 async function readFile(path, options = { encoding: null, flag: "r" }) {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   let ok;
   let data;
   try {
@@ -89,10 +108,10 @@ async function readFile(path, options = { encoding: null, flag: "r" }) {
       });
     });
   } catch (error) {
-    throw createNodeError(error, "open", path.toString());
+    throw createNodeError(error, "open", pathStr);
   }
   if (!ok) {
-    throw createNodeError(new Error("failed to read file"), "open", path.toString());
+    throw createNodeError(new Error("failed to read file"), "open", pathStr);
   }
   return encodeUint8Array(getEncodingFromOptions(options, "buffer"), data);
 }
@@ -106,7 +125,8 @@ async function mkdtemp(prefix, options) {
   return decode(path, encoding);
 }
 async function writeFile(path, data) {
-  const file = Gio.File.new_for_path(path);
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   let bytes;
   if (typeof data === "string") {
     bytes = new TextEncoder().encode(data);
@@ -120,7 +140,7 @@ async function writeFile(path, data) {
       try {
         resolve(file.replace_finish(res));
       } catch (err) {
-        reject(createNodeError(err, "open", path));
+        reject(createNodeError(err, "open", pathStr));
       }
     });
   });
@@ -132,7 +152,7 @@ async function writeFile(path, data) {
           outputStream.write_bytes_finish(res);
           resolve();
         } catch (err) {
-          reject(createNodeError(err, "write", path));
+          reject(createNodeError(err, "write", pathStr));
         }
       });
     });
@@ -143,39 +163,40 @@ async function writeFile(path, data) {
         outputStream.close_finish(res);
         resolve();
       } catch (err) {
-        reject(createNodeError(err, "close", path));
+        reject(createNodeError(err, "close", pathStr));
       }
     });
   });
 }
 async function rmdir(path, _options) {
-  const file = Gio.File.new_for_path(path.toString());
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   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));
+        reject(createNodeError(err, "rmdir", pathStr));
       }
     });
   });
   if (info.get_file_type() !== Gio.FileType.DIRECTORY) {
     const err = Object.assign(new Error(), { code: 4 });
-    throw createNodeError(err, "rmdir", path);
+    throw createNodeError(err, "rmdir", pathStr);
   }
   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));
+        reject(createNodeError(err, "rmdir", pathStr));
       }
     });
   });
   const firstChild = children.next_file(null);
   if (firstChild !== null) {
     const err = Object.assign(new Error(), { code: 5 });
-    throw createNodeError(err, "rmdir", path);
+    throw createNodeError(err, "rmdir", pathStr);
   }
   await new Promise((resolve, reject) => {
     file.delete_async(GLib.PRIORITY_DEFAULT, null, (_s, res) => {
@@ -183,20 +204,21 @@ async function rmdir(path, _options) {
         file.delete_finish(res);
         resolve();
       } catch (err) {
-        reject(createNodeError(err, "rmdir", path));
+        reject(createNodeError(err, "rmdir", pathStr));
       }
     });
   });
 }
 async function unlink(path) {
-  const file = Gio.File.new_for_path(path);
+  const pathStr = normalizePath(path);
+  const file = Gio.File.new_for_path(pathStr);
   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));
+        reject(createNodeError(err, "unlink", pathStr));
       }
     });
   });
@@ -221,14 +243,15 @@ async function _writeStr(fd, data, position, encoding) {
   return { bytesWritten: result.bytesWritten, buffer: data };
 }
 function queryInfoAsync(path, flags, syscall, options) {
+  const pathStr = normalizePath(path);
   return new Promise((resolve, reject) => {
-    const file = Gio.File.new_for_path(path.toString());
+    const file = Gio.File.new_for_path(pathStr);
     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));
+        resolve(options?.bigint ? new BigIntStats(info, pathStr) : new Stats(info, pathStr));
       } catch (err) {
-        reject(createNodeError(err, syscall, path));
+        reject(createNodeError(err, syscall, pathStr));
       }
     });
   });
@@ -250,20 +273,22 @@ async function realpath(path) {
   return realpathSync(path);
 }
 async function symlink(target, path, _type) {
+  const pathStr = normalizePath(path);
+  const targetStr = normalizePath(target);
   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) => {
+    const file = Gio.File.new_for_path(pathStr);
+    file.make_symbolic_link_async(targetStr, GLib.PRIORITY_DEFAULT, null, (_s, res) => {
       try {
         file.make_symbolic_link_finish(res);
         resolve();
       } catch (err) {
-        reject(createNodeError(err, "symlink", target, path));
+        reject(createNodeError(err, "symlink", targetStr, pathStr));
       }
     });
   });
 }
 async function rm(path, options) {
-  const pathStr = path.toString();
+  const pathStr = normalizePath(path);
   const file = Gio.File.new_for_path(pathStr);
   const recursive = options?.recursive || false;
   const force = options?.force || false;
@@ -351,7 +376,26 @@ var promises_default = {
   truncate,
   chmod,
   chown,
-  link
+  link,
+  cp: cpAsync,
+  opendir: opendirAsync,
+  glob: globAsync,
+  watch: watchAsync,
+  statfs: statfsAsync,
+  utimes: utimesAsync,
+  lutimes: lutimesAsync,
+  lchown: lchownAsync,
+  lchmod: lchmodAsync,
+  fstat: fstatAsync,
+  ftruncate: ftruncateAsync,
+  fdatasync: fdatasyncAsync,
+  fsync: fsyncAsync,
+  fchmod: fchmodAsync,
+  fchown: fchownAsync,
+  futimes: futimesAsync,
+  readv: readvAsync,
+  writev: writevAsync,
+  openAsBlob
 };
 export {
   access,
@@ -359,23 +403,42 @@ export {
   chmod,
   chown,
   copyFile,
+  cpAsync as cp,
   promises_default as default,
+  fchmodAsync as fchmod,
+  fchownAsync as fchown,
+  fdatasyncAsync as fdatasync,
+  fstatAsync as fstat,
+  fsyncAsync as fsync,
+  ftruncateAsync as ftruncate,
+  futimesAsync as futimes,
+  globAsync as glob,
+  lchmodAsync as lchmod,
+  lchownAsync as lchown,
   link,
   lstat,
+  lutimesAsync as lutimes,
   mkdir,
   mkdtemp,
   open,
+  openAsBlob,
+  opendirAsync as opendir,
   readFile,
   readdir,
   readlink,
+  readvAsync as readv,
   realpath,
   rename,
   rm,
   rmdir,
   stat,
+  statfsAsync as statfs,
   symlink,
   truncate,
   unlink,
+  utimesAsync as utimes,
+  watchAsync as watch,
   write,
-  writeFile
+  writeFile,
+  writevAsync as writev
 };