@photostructure/fs-metadata 0.1.6 → 0.3.0

package/dist/index.mjs

@@ -462,20 +462,6 @@ async function setHidden(pathname, hide, method, nativeFn) {
   return { pathname: norm, actions };
 }
 
-// src/array.ts
-function uniqBy(arr, keyFn) {
-  const seen = /* @__PURE__ */ new Set();
-  return arr.filter((item) => {
-    const key = keyFn(item);
-    if (key == null || seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-// src/linux/mount_points.ts
-import { readFile } from "node:fs/promises";
-
 // src/options.ts
 import { availableParallelism as availableParallelism2 } from "node:os";
 var TimeoutMsDefault = 5e3;
@@ -493,6 +479,8 @@ var SystemPathPatternsDefault = [
   "/run/user/*/gvfs",
   "/snap/**",
   "/sys/**",
+  "**/#snapshot",
+  // Synology and Kubernetes volume snapshots
   // windows for linux:
   "/mnt/wslg/distro",
   "/mnt/wslg/doc",
@@ -510,7 +498,7 @@ var SystemPathPatternsDefault = [
   "/System/Volumes/VM",
   "/System/Volumes/xarts"
 ];
-var SystemFsTypesDefault = /* @__PURE__ */ new Set([
+var SystemFsTypesDefault = [
   "autofs",
   "binfmt_misc",
   "cgroup",
@@ -533,7 +521,7 @@ var SystemFsTypesDefault = /* @__PURE__ */ new Set([
   "squashfs",
   "sysfs",
   "tmpfs"
-]);
+];
 var LinuxMountTablePathsDefault = [
   "/proc/self/mounts",
   "/proc/mounts",
@@ -544,8 +532,8 @@ var OptionsDefault = {
   timeoutMs: TimeoutMsDefault,
   maxConcurrency: availableParallelism2(),
   systemPathPatterns: [...SystemPathPatternsDefault],
-  systemFsTypes: new Set(SystemFsTypesDefault),
-  linuxMountTablePaths: LinuxMountTablePathsDefault,
+  systemFsTypes: [...SystemFsTypesDefault],
+  linuxMountTablePaths: [...LinuxMountTablePathsDefault],
   includeSystemVolumes: IncludeSystemVolumesDefault
 };
 function optionsWithDefaults(overrides = {}) {
@@ -560,116 +548,65 @@ function optionsWithDefaults(overrides = {}) {
   };
 }
 
-// src/glob.ts
-var cache = /* @__PURE__ */ new Map();
-function compileGlob(patterns) {
-  if (patterns == null || patterns.length === 0) {
-    return NeverMatchRE;
+// src/linux/dev_disk.ts
+import { readdir, readlink } from "node:fs/promises";
+import { join as join3, resolve as resolve3 } from "node: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;
   }
-  const patternsKey = JSON.stringify(patterns);
-  {
-    const prior = cache.get(patternsKey);
-    if (prior != null) {
-      return prior;
-    }
+}
+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;
   }
-  const sorted = patterns.slice().filter(isNotBlank).sort();
-  const sortedKey = JSON.stringify(sorted);
-  {
-    const prior = cache.get(sortedKey);
-    if (prior != null) {
-      cache.set(patternsKey, prior);
-      return prior;
+}
+async function getBasenameLinkedTo(linkDir, linkPath) {
+  for await (const ea of readLinks(linkDir)) {
+    if (ea.linkTarget === linkPath) {
+      return decodeEscapeSequences(ea.dirent.name);
     }
   }
-  const result = _compileGlob(sorted);
-  if (cache.size > 256) {
-    cache.clear();
-  }
-  cache.set(patternsKey, result);
-  cache.set(sortedKey, result);
-  return result;
+  return;
 }
-function _compileGlob(patterns) {
-  const regexPatterns = patterns.map((pattern) => {
-    let regex = "";
-    let i = 0;
-    while (i < pattern.length) {
-      if (pattern[i] === "*" && pattern[i + 1] === "*") {
-        regex += ".*";
-        i += 2;
-        if (pattern[i] === "/") {
-          i++;
-        }
-        continue;
-      }
-      if (pattern[i] === "*") {
-        regex += "[^/]*";
-        i++;
-        continue;
-      }
-      if (pattern[i] === "?") {
-        regex += "[^/]";
-        i++;
-        continue;
-      }
-      if (pattern[i] === ".") {
-        regex += "\\.";
-        i++;
-        continue;
-      }
-      if (pattern[i] === "/") {
-        if (i === pattern.length - 1) {
-          regex += "(?:/|$)";
-          i++;
-          continue;
-        } else if (isWindows) {
-          regex += "[\\/\\\\]";
-          i++;
-          continue;
-        }
-      }
-      if (/[+^${}()|[\]\\]/.test(pattern[i])) {
-        regex += "\\" + pattern[i];
-        i++;
-        continue;
+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 {
       }
-      regex += pattern[i];
-      i++;
-    }
-    return regex;
-  });
-  const final = regexPatterns.filter((ea) => ea.length > 0);
-  return final.length === 0 ? (
-    // Empty pattern matches nothing
-    NeverMatchRE
-  ) : new RegExp(`^(?:${final.join("|")})$`, "i");
-}
-var NeverMatchRE = /(?!)/;
-
-// src/system_volume.ts
-function isSystemVolume(mountPoint, fstype, config = {}) {
-  debug("[isSystemVolume] checking %s (fstype: %s)", mountPoint, fstype);
-  if (isWindows) {
-    const systemDrive = normalizePath(process.env["SystemDrive"]);
-    if (systemDrive != null && mountPoint === systemDrive) {
-      debug("[isSystemVolume] %s is the Windows system drive", mountPoint);
-      return true;
     }
   }
-  const result = isNotBlank(fstype) && (config.systemFsTypes ?? SystemFsTypesDefault).has(fstype) || compileGlob(config.systemPathPatterns ?? SystemPathPatternsDefault).test(
-    mountPoint
-  );
-  debug("[isSystemVolume] %s -> %s", mountPoint, result);
-  return result;
 }
-function assignSystemVolume(mp, config) {
-  const result = isSystemVolume(mp.mountPoint, mp.fstype, config);
-  if (isWindows) {
-    mp.isSystemVolume ??= result;
-  } else {
-    mp.isSystemVolume = result;
-  }
+
+// src/linux/mount_points.ts
+import { readFile } from "node:fs/promises";
+
+// src/mount_point.ts
+function isMountPoint(obj) {
+  if (!isObject(obj)) return false;
+  return "mountPoint" in obj && isNotBlank(obj.mountPoint);
 }
 
 // src/remote_info.ts
@@ -775,6 +712,127 @@ function extractRemoteInfo(fsSpec) {
   return;
 }
 
+// src/glob.ts
+var cache = /* @__PURE__ */ new Map();
+function compileGlob(patterns) {
+  if (patterns == null || patterns.length === 0) {
+    return NeverMatchRE;
+  }
+  const patternsKey = JSON.stringify(patterns);
+  {
+    const prior = cache.get(patternsKey);
+    if (prior != null) {
+      return prior;
+    }
+  }
+  const sorted = patterns.slice().filter(isNotBlank).sort();
+  const sortedKey = JSON.stringify(sorted);
+  {
+    const prior = cache.get(sortedKey);
+    if (prior != null) {
+      cache.set(patternsKey, prior);
+      return prior;
+    }
+  }
+  const result = _compileGlob(sorted);
+  if (cache.size > 256) {
+    cache.clear();
+  }
+  cache.set(patternsKey, result);
+  cache.set(sortedKey, result);
+  return result;
+}
+function _compileGlob(patterns) {
+  const regexPatterns = patterns.map((pattern) => {
+    let regex = "";
+    let i = 0;
+    while (i < pattern.length) {
+      if (pattern[i] === "*" && pattern[i + 1] === "*") {
+        regex += ".*";
+        i += 2;
+        if (pattern[i] === "/") {
+          i++;
+        }
+        continue;
+      }
+      if (pattern[i] === "*") {
+        regex += "[^/]*";
+        i++;
+        continue;
+      }
+      if (pattern[i] === "?") {
+        regex += "[^/]";
+        i++;
+        continue;
+      }
+      if (pattern[i] === ".") {
+        regex += "\\.";
+        i++;
+        continue;
+      }
+      if (pattern[i] === "/") {
+        if (i === pattern.length - 1) {
+          regex += "(?:/|$)";
+          i++;
+          continue;
+        } else if (isWindows) {
+          regex += "[\\/\\\\]";
+          i++;
+          continue;
+        }
+      }
+      if (/[+^${}()|[\]\\]/.test(pattern[i])) {
+        regex += "\\" + pattern[i];
+        i++;
+        continue;
+      }
+      regex += pattern[i];
+      i++;
+    }
+    return regex;
+  });
+  const final = regexPatterns.filter((ea) => ea.length > 0);
+  return final.length === 0 ? (
+    // Empty pattern matches nothing
+    NeverMatchRE
+  ) : new RegExp(`^(?:${final.join("|")})$`, "i");
+}
+var NeverMatchRE = /(?!)/;
+
+// src/system_volume.ts
+function isSystemVolume(mountPoint, fstype, config = {}) {
+  if (isWindows) {
+    const systemDrive = normalizePath(process.env["SystemDrive"]);
+    if (systemDrive != null && mountPoint === systemDrive) {
+      debug("[isSystemVolume] %s is the Windows system drive", mountPoint);
+      return true;
+    }
+  }
+  const isSystemFsType = isNotBlank(fstype) && (config.systemFsTypes ?? SystemFsTypesDefault).includes(
+    fstype
+  );
+  const hasSystemPath = compileGlob(
+    config.systemPathPatterns ?? SystemPathPatternsDefault
+  ).test(mountPoint);
+  const result = isSystemFsType || hasSystemPath;
+  debug("[isSystemVolume]", {
+    mountPoint,
+    fstype,
+    result,
+    isSystemFsType,
+    hasSystemPath
+  });
+  return result;
+}
+function assignSystemVolume(mp, config) {
+  const result = isSystemVolume(mp.mountPoint, mp.fstype, config);
+  if (isWindows) {
+    mp.isSystemVolume ??= result;
+  } else {
+    mp.isSystemVolume = result;
+  }
+}
+
 // src/linux/mtab.ts
 function mountEntryToMountPoint(entry) {
   const mountPoint = normalizePosixPath(entry.fs_file);
@@ -852,7 +910,6 @@ async function getLinuxMountPoints(native, opts) {
     const prior = byMountPoint.get(ea.mountPoint);
     const merged = { ...compactValues(prior), ...compactValues(ea) };
     if (isMountPoint(merged)) {
-      assignSystemVolume(merged, o);
       byMountPoint.set(merged.mountPoint, merged);
     }
   }
@@ -863,8 +920,10 @@ async function getLinuxMountPoints(native, opts) {
     );
   }
   const results = [...byMountPoint.values()];
-  debug("[getLinuxMountPoints] found %d mount points", results.length);
-  return o.includeSystemVolumes ? results : results.filter((ea) => !ea.isSystemVolume);
+  debug("[getLinuxMountPoints] %o", {
+    results: results.map((ea) => ea.mountPoint)
+  });
+  return results;
 }
 async function getLinuxMtabMetadata(mountPoint, opts) {
   let caughtError;
@@ -887,6 +946,41 @@ async function getLinuxMtabMetadata(mountPoint, opts) {
   );
 }
 
+// src/unc.ts
+function parseUNCPath(path) {
+  if (path == null || isBlank(path) || !isString(path)) {
+    return;
+  }
+  if (!path.startsWith("\\\\") && !path.startsWith("//")) {
+    return;
+  }
+  const isForwardSlash = path.startsWith("//");
+  const slashChar = isForwardSlash ? "/" : "\\";
+  const parts = path.slice(2).split(slashChar);
+  if (parts.length < 2) {
+    return;
+  }
+  const [remoteHost, remoteShare] = parts;
+  if (remoteHost == null || isBlank(remoteHost) || remoteShare == null || isBlank(remoteShare)) {
+    return;
+  }
+  const invalidChars = /[<>:"|?*]/;
+  if (invalidChars.test(remoteHost) || invalidChars.test(remoteShare)) {
+    return;
+  }
+  const wrongSlash = isForwardSlash ? "\\" : "/";
+  if (path.includes(wrongSlash)) {
+    return;
+  }
+  return { remoteHost, remoteShare, remote: true };
+}
+
+// src/uuid.ts
+var uuidRegex = /[a-z0-9][a-z0-9-]{7,}/i;
+function extractUUID(uuid) {
+  return toS(uuid).match(uuidRegex)?.[0];
+}
+
 // src/string_enum.ts
 function stringEnum(...o) {
   const set = new Set(o);
@@ -930,18 +1024,25 @@ async function directoryStatus(dir, timeoutMs, canReaddirImpl = canReaddir) {
   return { status: VolumeHealthStatuses.unknown };
 }
 
-// src/mount_point.ts
-function isMountPoint(obj) {
-  if (!isObject(obj)) return false;
-  return "mountPoint" in obj && isNotBlank(obj.mountPoint);
+// src/array.ts
+function uniqBy(arr, keyFn) {
+  const seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    const key = keyFn(item);
+    if (key == null || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
 }
+
+// src/volume_mount_points.ts
 async function getVolumeMountPoints(opts, nativeFn) {
   const p2 = _getVolumeMountPoints(opts, nativeFn);
   return isWindows ? p2 : withTimeout({ desc: "getVolumeMountPoints", ...opts, promise: p2 });
 }
 async function _getVolumeMountPoints(o, nativeFn) {
   debug("[getVolumeMountPoints] gathering mount points with options: %o", o);
-  const result = await (isWindows || isMacOS ? (async () => {
+  const raw = await (isWindows || isMacOS ? (async () => {
     debug("[getVolumeMountPoints] using native implementation");
     const points = await (await nativeFn()).getVolumeMountPoints(o);
     debug(
@@ -950,8 +1051,11 @@ async function _getVolumeMountPoints(o, nativeFn) {
     );
     return points;
   })() : getLinuxMountPoints(nativeFn, o));
-  debug("[getVolumeMountPoints] raw mount points: %o", result);
-  const compacted = result.map((ea) => compactValues(ea)).filter((ea) => isNotBlank(ea.mountPoint));
+  debug("[getVolumeMountPoints] raw mount points: %o", raw);
+  const compacted = raw.map((ea) => compactValues(ea)).filter((ea) => isNotBlank(ea.mountPoint));
+  for (const ea of compacted) {
+    assignSystemVolume(ea, o);
+  }
   const filtered = o.includeSystemVolumes ? compacted : compacted.filter((ea) => !ea.isSystemVolume);
   const uniq = uniqBy(filtered, (ea) => toNotBlank(ea.mountPoint));
   debug("[getVolumeMountPoints] found %d unique mount points", uniq.length);
@@ -962,18 +1066,18 @@ async function _getVolumeMountPoints(o, nativeFn) {
   );
   await mapConcurrent({
     maxConcurrency: o.maxConcurrency,
-    items: results,
+    items: results.filter(
+      // trust but verify
+      (ea) => isBlank(ea.status) || ea.status === "healthy"
+    ),
     fn: async (mp) => {
-      assignSystemVolume(mp, o);
-      if ((toNotBlank(mp.status) ?? "healthy") === "healthy") {
-        debug("[getVolumeMountPoints] checking status of %s", mp.mountPoint);
-        mp.status = (await directoryStatus(mp.mountPoint, o.timeoutMs)).status;
-        debug(
-          "[getVolumeMountPoints] status for %s: %s",
-          mp.mountPoint,
-          mp.status
-        );
-      }
+      debug("[getVolumeMountPoints] checking status of %s", mp.mountPoint);
+      mp.status = (await directoryStatus(mp.mountPoint, o.timeoutMs)).status;
+      debug(
+        "[getVolumeMountPoints] status for %s: %s",
+        mp.mountPoint,
+        mp.status
+      );
     }
   });
   debug(
@@ -983,93 +1087,6 @@ async function _getVolumeMountPoints(o, nativeFn) {
   return results;
 }
 
-// src/linux/dev_disk.ts
-import { readdir, readlink } from "node:fs/promises";
-import { join as join3, resolve as resolve3 } from "node: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/unc.ts
-function parseUNCPath(path) {
-  if (path == null || isBlank(path) || !isString(path)) {
-    return;
-  }
-  if (!path.startsWith("\\\\") && !path.startsWith("//")) {
-    return;
-  }
-  const isForwardSlash = path.startsWith("//");
-  const slashChar = isForwardSlash ? "/" : "\\";
-  const parts = path.slice(2).split(slashChar);
-  if (parts.length < 2) {
-    return;
-  }
-  const [remoteHost, remoteShare] = parts;
-  if (remoteHost == null || isBlank(remoteHost) || remoteShare == null || isBlank(remoteShare)) {
-    return;
-  }
-  const invalidChars = /[<>:"|?*]/;
-  if (invalidChars.test(remoteHost) || invalidChars.test(remoteShare)) {
-    return;
-  }
-  const wrongSlash = isForwardSlash ? "\\" : "/";
-  if (path.includes(wrongSlash)) {
-    return;
-  }
-  return { remoteHost, remoteShare, remote: true };
-}
-
-// src/uuid.ts
-var uuidRegex = /[a-z0-9][a-z0-9-]{7,}/i;
-function extractUUID(uuid) {
-  return toS(uuid).match(uuidRegex)?.[0];
-}
-
 // src/volume_metadata.ts
 async function getVolumeMetadata(o, nativeFn) {
   if (isBlank(o.mountPoint)) {
@@ -1268,3 +1285,4 @@ export {
   optionsWithDefaults,
   setHidden2 as setHidden
 };
+//# sourceMappingURL=index.mjs.map