@photostructure/fs-metadata 1.0.1 → 1.2.0

package/dist/index.mjs

@@ -388,7 +388,7 @@ function toError(cause) {
 }
 
 // src/path.ts
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { dirname as dirname2, resolve as resolve2, sep } from "path";
 function normalizePath(mountPoint) {
   if (isBlank(mountPoint)) return void 0;
   if (mountPoint.includes("..")) {
@@ -417,6 +417,11 @@ function isRootDirectory(path2) {
   const n = normalizePath(path2);
   return n == null ? false : isWindows ? dirname2(n) === n : n === "/";
 }
+function isAncestorOrSelf(ancestor, descendant) {
+  if (ancestor === descendant) return true;
+  const prefix = isRootDirectory(ancestor) ? ancestor : ancestor + sep;
+  return descendant.startsWith(prefix);
+}
 
 // src/hidden.ts
 var HiddenSupportByPlatform = {
@@ -581,6 +586,74 @@ async function setHiddenImpl(pathname, hide, method, nativeFn2) {
   return { pathname: norm, actions };
 }
 
+// src/mount_point_for_path.ts
+import { realpath as realpath2 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+
+// src/volume_metadata.ts
+import { realpath } from "fs/promises";
+import { dirname as dirname4 } from "path";
+
+// src/linux/dev_disk.ts
+import { readdir, readlink } from "fs/promises";
+import { join as join3, resolve as resolve3 } from "path";
+async function getUuidFromDevDisk(devicePath) {
+  try {
+    const result = await getBasenameLinkedTo(
+      "/dev/disk/by-uuid",
+      resolve3(devicePath)
+    );
+    debug("[getUuidFromDevDisk] result: %o", result);
+    return result;
+  } catch (error) {
+    debug("[getUuidFromDevDisk] failed: " + error);
+    return;
+  }
+}
+async function getLabelFromDevDisk(devicePath) {
+  try {
+    const result = await getBasenameLinkedTo(
+      "/dev/disk/by-label",
+      resolve3(devicePath)
+    );
+    debug("[getLabelFromDevDisk] result: %o", result);
+    return result;
+  } catch (error) {
+    debug("[getLabelFromDevDisk] failed: " + error);
+    return;
+  }
+}
+async function getBasenameLinkedTo(linkDir, linkPath) {
+  for await (const ea of readLinks(linkDir)) {
+    if (ea.linkTarget === linkPath) {
+      return decodeEscapeSequences(ea.dirent.name);
+    }
+  }
+  return;
+}
+async function* readLinks(directory) {
+  for (const dirent of await readdir(directory, { withFileTypes: true })) {
+    if (dirent.isSymbolicLink()) {
+      try {
+        const linkTarget = resolve3(
+          directory,
+          await readlink(join3(directory, dirent.name))
+        );
+        yield { dirent, linkTarget };
+      } catch {
+      }
+    }
+  }
+}
+
+// src/linux/mount_points.ts
+import { readFile } from "fs/promises";
+
+// src/mount_point.ts
+function isMountPoint(obj) {
+  return isObject(obj) && "mountPoint" in obj && isNotBlank(obj.mountPoint);
+}
+
 // src/options.ts
 import { availableParallelism as availableParallelism2 } from "os";
 import { env as env2 } from "process";
@@ -643,23 +716,13 @@ var SystemPathPatternsDefault = [
   "/mnt/wslg/doc",
   "/mnt/wslg/versions.txt",
   "/usr/lib/wsl/drivers",
-  // macOS system paths:
-  "/private/var/vm",
-  // macOS swap
-  "/System/Volumes/Hardware",
-  "/System/Volumes/iSCPreboot",
-  "/System/Volumes/Preboot",
-  "/System/Volumes/Recovery",
-  "/System/Volumes/Reserved",
-  "/System/Volumes/Update",
-  "/System/Volumes/VM",
-  "/System/Volumes/xarts",
-  // macOS per-volume metadata (Spotlight, FSEvents, versioning, Trash):
-  // https://eclecticlight.co/2021/01/28/spotlight-on-search-how-spotlight-works/
-  "**/.DocumentRevisions-V100",
-  "**/.fseventsd",
-  "**/.Spotlight-V100",
-  "**/.Trashes"
+  // macOS system volumes are detected natively via APFS volume roles
+  // (IOKit IOMedia "Role" property) with MNT_SNAPSHOT as a fallback.
+  // No path patterns needed. See src/darwin/system_volume.h.
+  //
+  // /private/var/vm is the macOS swap directory (not a mount point on most
+  // systems, but included for completeness if it appears as one).
+  "/private/var/vm"
 ];
 var SystemFsTypesDefault = [
   "autofs",
@@ -791,109 +854,6 @@ function optionsWithDefaults(overrides = {}) {
   };
 }
 
-// src/string_enum.ts
-function stringEnum(...o) {
-  const set = new Set(o);
-  const dict = {};
-  for (const key of o) {
-    dict[key] = key;
-  }
-  return {
-    ...dict,
-    values: Object.freeze([...set]),
-    size: set.size,
-    get: (s) => s != null && set.has(s) ? s : void 0
-  };
-}
-
-// src/volume_health_status.ts
-var VolumeHealthStatuses = stringEnum(
-  "healthy",
-  "timeout",
-  "inaccessible",
-  "disconnected",
-  "unknown"
-);
-async function directoryStatus(dir, timeoutMs, canReaddirImpl = canReaddir) {
-  try {
-    if (await canReaddirImpl(dir, timeoutMs)) {
-      return { status: VolumeHealthStatuses.healthy };
-    }
-  } catch (error) {
-    debug("[directoryStatus] %s: %s", dir, error);
-    let status = VolumeHealthStatuses.unknown;
-    if (error instanceof TimeoutError) {
-      status = VolumeHealthStatuses.timeout;
-    } else if (isObject(error) && error instanceof Error && "code" in error) {
-      if (error.code === "EPERM" || error.code === "EACCES") {
-        status = VolumeHealthStatuses.inaccessible;
-      }
-    }
-    return { status, error: toError(error) };
-  }
-  return { status: VolumeHealthStatuses.unknown };
-}
-
-// src/linux/dev_disk.ts
-import { readdir, readlink } from "fs/promises";
-import { join as join3, resolve as resolve3 } from "path";
-async function getUuidFromDevDisk(devicePath) {
-  try {
-    const result = await getBasenameLinkedTo(
-      "/dev/disk/by-uuid",
-      resolve3(devicePath)
-    );
-    debug("[getUuidFromDevDisk] result: %o", result);
-    return result;
-  } catch (error) {
-    debug("[getUuidFromDevDisk] failed: " + error);
-    return;
-  }
-}
-async function getLabelFromDevDisk(devicePath) {
-  try {
-    const result = await getBasenameLinkedTo(
-      "/dev/disk/by-label",
-      resolve3(devicePath)
-    );
-    debug("[getLabelFromDevDisk] result: %o", result);
-    return result;
-  } catch (error) {
-    debug("[getLabelFromDevDisk] failed: " + error);
-    return;
-  }
-}
-async function getBasenameLinkedTo(linkDir, linkPath) {
-  for await (const ea of readLinks(linkDir)) {
-    if (ea.linkTarget === linkPath) {
-      return decodeEscapeSequences(ea.dirent.name);
-    }
-  }
-  return;
-}
-async function* readLinks(directory) {
-  for (const dirent of await readdir(directory, { withFileTypes: true })) {
-    if (dirent.isSymbolicLink()) {
-      try {
-        const linkTarget = resolve3(
-          directory,
-          await readlink(join3(directory, dirent.name))
-        );
-        yield { dirent, linkTarget };
-      } catch {
-      }
-    }
-  }
-}
-
-// src/linux/mount_points.ts
-import { readFile } from "fs/promises";
-
-// src/mount_point.ts
-function isMountPoint(obj) {
-  return isObject(obj) && "mountPoint" in obj && isNotBlank(obj.mountPoint);
-}
-
 // src/remote_info.ts
 function isRemoteInfo(obj) {
   if (!isObject(obj)) return false;
@@ -1118,20 +1078,20 @@ function isSystemVolume(mountPoint, fstype, config = {}) {
 }
 function assignSystemVolume(mp, config) {
   const result = isSystemVolume(mp.mountPoint, mp.fstype, config);
-  if (isWindows) {
-    mp.isSystemVolume ??= result;
-  } else {
-    mp.isSystemVolume = result;
-  }
+  mp.isSystemVolume = mp.isSystemVolume || result;
 }
 
 // src/linux/mtab.ts
+function isReadOnlyMount(fs_mntops) {
+  return fs_mntops?.split(",").includes("ro") ?? false;
+}
 function mountEntryToMountPoint(entry) {
   const mountPoint = normalizePosixPath(entry.fs_file);
   const fstype = toNotBlank(entry.fs_vfstype) ?? toNotBlank(entry.fs_spec);
   return mountPoint == null || fstype == null ? void 0 : {
     mountPoint,
-    fstype
+    fstype,
+    isReadOnly: isReadOnlyMount(entry.fs_mntops)
   };
 }
 function mountEntryToPartialVolumeMetadata(entry, options = {}) {
@@ -1141,6 +1101,7 @@ function mountEntryToPartialVolumeMetadata(entry, options = {}) {
     fstype: entry.fs_vfstype,
     mountFrom: entry.fs_spec,
     isSystemVolume: isSystemVolume(entry.fs_file, entry.fs_vfstype, options),
+    isReadOnly: isReadOnlyMount(entry.fs_mntops),
     remote: false,
     // < default to false, but it may be overridden by extractRemoteInfo
     ...extractRemoteInfo(entry.fs_spec, networkFsTypes)
@@ -1274,6 +1235,49 @@ function extractUUID(uuid) {
   return toS(uuid).match(uuidRegex)?.[0];
 }
 
+// src/string_enum.ts
+function stringEnum(...o) {
+  const set = new Set(o);
+  const dict = {};
+  for (const key of o) {
+    dict[key] = key;
+  }
+  return {
+    ...dict,
+    values: Object.freeze([...set]),
+    size: set.size,
+    get: (s) => s != null && set.has(s) ? s : void 0
+  };
+}
+
+// src/volume_health_status.ts
+var VolumeHealthStatuses = stringEnum(
+  "healthy",
+  "timeout",
+  "inaccessible",
+  "disconnected",
+  "unknown"
+);
+async function directoryStatus(dir, timeoutMs, canReaddirImpl = canReaddir) {
+  try {
+    if (await canReaddirImpl(dir, timeoutMs)) {
+      return { status: VolumeHealthStatuses.healthy };
+    }
+  } catch (error) {
+    debug("[directoryStatus] %s: %s", dir, error);
+    let status = VolumeHealthStatuses.unknown;
+    if (error instanceof TimeoutError) {
+      status = VolumeHealthStatuses.timeout;
+    } else if (isObject(error) && error instanceof Error && "code" in error) {
+      if (error.code === "EPERM" || error.code === "EACCES") {
+        status = VolumeHealthStatuses.inaccessible;
+      }
+    }
+    return { status, error: toError(error) };
+  }
+  return { status: VolumeHealthStatuses.unknown };
+}
+
 // src/array.ts
 function uniqBy(arr, keyFn) {
   const seen = /* @__PURE__ */ new Set();
@@ -1424,6 +1428,63 @@ async function _getVolumeMetadata(o, nativeFn2) {
   debug("[getVolumeMetadata] final result for %s: %o", o.mountPoint, result);
   return compactValues(result);
 }
+async function getVolumeMetadataForPathImpl(pathname, opts, nativeFn2) {
+  if (isBlank(pathname)) {
+    throw new TypeError("Invalid pathname: got " + JSON.stringify(pathname));
+  }
+  const resolved = await realpath(pathname);
+  const resolvedStat = await statAsync(resolved);
+  const dir = resolvedStat.isDirectory() ? resolved : dirname4(resolved);
+  if (isMacOS) {
+    const probe = await getVolumeMetadataImpl(
+      { ...opts, mountPoint: dir },
+      nativeFn2
+    );
+    const canonicalMountPoint = isNotBlank(probe.mountName) ? probe.mountName : dir;
+    if (canonicalMountPoint === dir) return probe;
+    return getVolumeMetadataImpl(
+      { ...opts, mountPoint: canonicalMountPoint },
+      nativeFn2
+    );
+  }
+  const mountPoint = await findMountPointByDeviceId(
+    resolved,
+    resolvedStat,
+    opts,
+    nativeFn2
+  );
+  return getVolumeMetadataImpl({ ...opts, mountPoint }, nativeFn2);
+}
+async function findMountPointByDeviceId(resolved, resolvedStat, opts, nativeFn2) {
+  const targetDev = resolvedStat.dev;
+  const mountPoints = await getVolumeMountPointsImpl(
+    { ...opts, includeSystemVolumes: true },
+    nativeFn2
+  );
+  const prefixMatches = [];
+  const deviceMatches = [];
+  await Promise.all(
+    mountPoints.map(async ({ mountPoint }) => {
+      try {
+        const mpDev = (await statAsync(mountPoint)).dev;
+        if (mpDev !== targetDev) return;
+        if (isAncestorOrSelf(mountPoint, resolved)) {
+          prefixMatches.push(mountPoint);
+        } else {
+          deviceMatches.push(mountPoint);
+        }
+      } catch {
+      }
+    })
+  );
+  const candidates = prefixMatches.length > 0 ? prefixMatches : deviceMatches;
+  if (candidates.length === 0) {
+    throw new Error(
+      "No mount point found for path: " + JSON.stringify(resolved)
+    );
+  }
+  return candidates.reduce((a, b) => a.length >= b.length ? a : b);
+}
 async function getAllVolumeMetadataImpl(opts, nativeFn2) {
   const o = optionsWithDefaults(opts);
   debug("[getAllVolumeMetadata] starting with options: %o", o);
@@ -1475,15 +1536,44 @@ async function getAllVolumeMetadataImpl(opts, nativeFn2) {
   );
 }
 
+// src/mount_point_for_path.ts
+async function getMountPointForPathImpl(pathname, opts, nativeFn2) {
+  if (isBlank(pathname)) {
+    throw new TypeError("Invalid pathname: got " + JSON.stringify(pathname));
+  }
+  const resolved = await realpath2(pathname);
+  const resolvedStat = await statAsync(resolved);
+  const dir = resolvedStat.isDirectory() ? resolved : dirname5(resolved);
+  if (isMacOS) {
+    const native = await nativeFn2();
+    if (native.getMountPoint) {
+      debug("[getMountPointForPath] using native getMountPoint for %s", dir);
+      const p = native.getMountPoint(dir);
+      const mountPoint = await withTimeout({
+        desc: "getMountPoint()",
+        timeoutMs: opts.timeoutMs,
+        promise: p
+      });
+      if (isNotBlank(mountPoint)) {
+        debug("[getMountPointForPath] resolved to %s", mountPoint);
+        return mountPoint;
+      }
+    }
+    throw new Error("getMountPoint native function unavailable");
+  }
+  debug("[getMountPointForPath] using device matching for %s", resolved);
+  return findMountPointByDeviceId(resolved, resolvedStat, opts, nativeFn2);
+}
+
 // src/index.ts
 var nativeFn = defer2(async () => {
   const start = Date.now();
   try {
-    const dirname4 = _dirname();
-    const dir = await findAncestorDir(dirname4, "binding.gyp");
+    const dirname6 = _dirname();
+    const dir = await findAncestorDir(dirname6, "binding.gyp");
     if (dir == null) {
       throw new Error(
-        "Could not find bindings.gyp in any ancestor directory of " + dirname4
+        "Could not find bindings.gyp in any ancestor directory of " + dirname6
       );
     }
     const bindings = NodeGypBuild(dir);
@@ -1506,6 +1596,20 @@ function getVolumeMetadata(mountPoint, opts) {
     nativeFn
   );
 }
+function getVolumeMetadataForPath(pathname, opts) {
+  return getVolumeMetadataForPathImpl(
+    pathname,
+    optionsWithDefaults(opts),
+    nativeFn
+  );
+}
+function getMountPointForPath(pathname, opts) {
+  return getMountPointForPathImpl(
+    pathname,
+    optionsWithDefaults(opts),
+    nativeFn
+  );
+}
 function getAllVolumeMetadata(opts) {
   return getAllVolumeMetadataImpl(optionsWithDefaults(opts), nativeFn);
 }
@@ -1532,8 +1636,10 @@ export {
   VolumeHealthStatuses,
   getAllVolumeMetadata,
   getHiddenMetadata,
+  getMountPointForPath,
   getTimeoutMsDefault,
   getVolumeMetadata,
+  getVolumeMetadataForPath,
   getVolumeMountPoints,
   isHidden,
   isHiddenRecursive,