@warlock.js/fs 4.1.1

package/esm/dirs.mjs

@@ -0,0 +1,18 @@
+import { mkdir } from "node:fs/promises";
+import { mkdirSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/dirs.ts
+/**
+* Ensure a directory exists (recursively creating parents).
+* Idempotent — no error if the directory already exists.
+*/
+async function ensureDirectoryAsync(path) {
+	await mkdir(path, { recursive: true });
+}
+function ensureDirectory(path) {
+	mkdirSync(path, { recursive: true });
+}
+
+//#endregion
+export { ensureDirectory, ensureDirectoryAsync };
+//# sourceMappingURL=dirs.mjs.map

package/esm/dirs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dirs.mjs","names":[],"sources":["../../../../../@warlock.js/fs/src/dirs.ts"],"sourcesContent":["import { mkdir } from \"node:fs/promises\";\nimport { mkdirSync } from \"node:fs\";\n\n/**\n * Ensure a directory exists (recursively creating parents).\n * Idempotent — no error if the directory already exists.\n */\nexport async function ensureDirectoryAsync(path: string): Promise<void> {\n  await mkdir(path, { recursive: true });\n}\n\nexport function ensureDirectory(path: string): void {\n  mkdirSync(path, { recursive: true });\n}\n"],"mappings":";;;;;;;;AAOA,eAAsB,qBAAqB,MAA6B;CACtE,MAAM,MAAM,MAAM,EAAE,WAAW,KAAK,CAAC;AACvC;AAEA,SAAgB,gBAAgB,MAAoB;CAClD,UAAU,MAAM,EAAE,WAAW,KAAK,CAAC;AACrC"}

package/esm/exists.d.mts

@@ -0,0 +1,44 @@
+//#region ../../@warlock.js/fs/src/exists.d.ts
+/**
+ * Check whether a path exists, REGARDLESS of type — resolves `true` for both
+ * files and directories, `false` only when nothing is there (ENOENT).
+ *
+ * Pick the right check for the job:
+ *   - `pathExistsAsync`      — anything at this path (file OR directory).
+ *   - `fileExistsAsync`      — exists AND is a regular file.
+ *   - `directoryExistsAsync` — exists AND is a directory.
+ *
+ * @example
+ * if (await pathExistsAsync("/var/data")) {
+ *   // something is there — could be a file or a folder
+ * }
+ */
+declare function pathExistsAsync(path: string): Promise<boolean>;
+declare function pathExists(path: string): boolean;
+/**
+ * Check whether a path exists AND is a regular file. Resolves `false` for a
+ * directory — use `directoryExistsAsync` for folders, or `pathExistsAsync`
+ * when the type does not matter.
+ *
+ * @example
+ * if (await fileExistsAsync("/etc/config.json")) {
+ *   const raw = await readFile("/etc/config.json", "utf8");
+ * }
+ */
+declare function fileExistsAsync(path: string): Promise<boolean>;
+declare function fileExists(path: string): boolean;
+/**
+ * Check whether a path exists AND is a directory. Resolves `false` for a
+ * regular file — use `fileExistsAsync` for files, or `pathExistsAsync` when
+ * the type does not matter.
+ *
+ * @example
+ * if (await directoryExistsAsync("/var/uploads")) {
+ *   const entries = await readdir("/var/uploads");
+ * }
+ */
+declare function directoryExistsAsync(path: string): Promise<boolean>;
+declare function directoryExists(path: string): boolean;
+//#endregion
+export { directoryExists, directoryExistsAsync, fileExists, fileExistsAsync, pathExists, pathExistsAsync };
+//# sourceMappingURL=exists.d.mts.map

package/esm/exists.mjs

@@ -0,0 +1,86 @@
+import { access, stat } from "node:fs/promises";
+import { accessSync, statSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/exists.ts
+/**
+* Check whether a path exists, REGARDLESS of type — resolves `true` for both
+* files and directories, `false` only when nothing is there (ENOENT).
+*
+* Pick the right check for the job:
+*   - `pathExistsAsync`      — anything at this path (file OR directory).
+*   - `fileExistsAsync`      — exists AND is a regular file.
+*   - `directoryExistsAsync` — exists AND is a directory.
+*
+* @example
+* if (await pathExistsAsync("/var/data")) {
+*   // something is there — could be a file or a folder
+* }
+*/
+async function pathExistsAsync(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function pathExists(path) {
+	try {
+		accessSync(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Check whether a path exists AND is a regular file. Resolves `false` for a
+* directory — use `directoryExistsAsync` for folders, or `pathExistsAsync`
+* when the type does not matter.
+*
+* @example
+* if (await fileExistsAsync("/etc/config.json")) {
+*   const raw = await readFile("/etc/config.json", "utf8");
+* }
+*/
+async function fileExistsAsync(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch {
+		return false;
+	}
+}
+function fileExists(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Check whether a path exists AND is a directory. Resolves `false` for a
+* regular file — use `fileExistsAsync` for files, or `pathExistsAsync` when
+* the type does not matter.
+*
+* @example
+* if (await directoryExistsAsync("/var/uploads")) {
+*   const entries = await readdir("/var/uploads");
+* }
+*/
+async function directoryExistsAsync(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function directoryExists(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { directoryExists, directoryExistsAsync, fileExists, fileExistsAsync, pathExists, pathExistsAsync };
+//# sourceMappingURL=exists.mjs.map

package/esm/exists.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"exists.mjs","names":[],"sources":["../../../../../@warlock.js/fs/src/exists.ts"],"sourcesContent":["import { access, stat } from \"node:fs/promises\";\nimport { accessSync, statSync } from \"node:fs\";\n\n/**\n * Check whether a path exists, REGARDLESS of type — resolves `true` for both\n * files and directories, `false` only when nothing is there (ENOENT).\n *\n * Pick the right check for the job:\n *   - `pathExistsAsync`      — anything at this path (file OR directory).\n *   - `fileExistsAsync`      — exists AND is a regular file.\n *   - `directoryExistsAsync` — exists AND is a directory.\n *\n * @example\n * if (await pathExistsAsync(\"/var/data\")) {\n *   // something is there — could be a file or a folder\n * }\n */\nexport async function pathExistsAsync(path: string): Promise<boolean> {\n  try {\n    await access(path);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport function pathExists(path: string): boolean {\n  try {\n    accessSync(path);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check whether a path exists AND is a regular file. Resolves `false` for a\n * directory — use `directoryExistsAsync` for folders, or `pathExistsAsync`\n * when the type does not matter.\n *\n * @example\n * if (await fileExistsAsync(\"/etc/config.json\")) {\n *   const raw = await readFile(\"/etc/config.json\", \"utf8\");\n * }\n */\nexport async function fileExistsAsync(path: string): Promise<boolean> {\n  try {\n    return (await stat(path)).isFile();\n  } catch {\n    return false;\n  }\n}\n\nexport function fileExists(path: string): boolean {\n  try {\n    return statSync(path).isFile();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check whether a path exists AND is a directory. Resolves `false` for a\n * regular file — use `fileExistsAsync` for files, or `pathExistsAsync` when\n * the type does not matter.\n *\n * @example\n * if (await directoryExistsAsync(\"/var/uploads\")) {\n *   const entries = await readdir(\"/var/uploads\");\n * }\n */\nexport async function directoryExistsAsync(path: string): Promise<boolean> {\n  try {\n    return (await stat(path)).isDirectory();\n  } catch {\n    return false;\n  }\n}\n\nexport function directoryExists(path: string): boolean {\n  try {\n    return statSync(path).isDirectory();\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,eAAsB,gBAAgB,MAAgC;CACpE,IAAI;EACF,MAAM,OAAO,IAAI;EACjB,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAgB,WAAW,MAAuB;CAChD,IAAI;EACF,WAAW,IAAI;EACf,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;AAYA,eAAsB,gBAAgB,MAAgC;CACpE,IAAI;EACF,QAAQ,MAAM,KAAK,IAAI,GAAG,OAAO;CACnC,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAgB,WAAW,MAAuB;CAChD,IAAI;EACF,OAAO,SAAS,IAAI,EAAE,OAAO;CAC/B,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;AAYA,eAAsB,qBAAqB,MAAgC;CACzE,IAAI;EACF,QAAQ,MAAM,KAAK,IAAI,GAAG,YAAY;CACxC,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAgB,gBAAgB,MAAuB;CACrD,IAAI;EACF,OAAO,SAAS,IAAI,EAAE,YAAY;CACpC,QAAQ;EACN,OAAO;CACT;AACF"}

package/esm/hash.d.mts

@@ -0,0 +1,32 @@
+//#region ../../@warlock.js/fs/src/hash.d.ts
+type HashAlgorithm = "sha256" | "sha1" | "md5" | "sha512";
+/**
+ * Compute a hex digest of a file's contents. Uses streaming for large
+ * files so memory doesn't spike when hashing big assets.
+ *
+ * @param path - File to hash.
+ * @param algorithm - Hash algorithm (default `sha256`).
+ *
+ * @example
+ *   const fingerprint = await hashFile("./bundle.js");
+ *   const quick = await hashFile("./small.txt", "md5");
+ */
+declare function hashFileAsync(path: string, algorithm?: HashAlgorithm): Promise<string>;
+declare function hashFile(path: string, algorithm?: HashAlgorithm): string;
+/**
+ * Hash an in-memory string without touching disk. Convenient when the
+ * caller already has the content loaded (e.g. file watcher diffing).
+ */
+declare function hashString(content: string, algorithm?: HashAlgorithm): string;
+/**
+ * Hash an arbitrary buffer.
+ */
+declare function hashBuffer(content: Buffer | Uint8Array, algorithm?: HashAlgorithm): string;
+/**
+ * Like `hashFileAsync` but reads the file in one go. Slightly faster for
+ * small files; use the streaming variant for anything > ~1 MB.
+ */
+declare function hashFileSmallAsync(path: string, algorithm?: HashAlgorithm): Promise<string>;
+//#endregion
+export { HashAlgorithm, hashBuffer, hashFile, hashFileAsync, hashFileSmallAsync, hashString };
+//# sourceMappingURL=hash.d.mts.map

package/esm/hash.mjs

@@ -0,0 +1,52 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { createReadStream, readFileSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/hash.ts
+/**
+* Compute a hex digest of a file's contents. Uses streaming for large
+* files so memory doesn't spike when hashing big assets.
+*
+* @param path - File to hash.
+* @param algorithm - Hash algorithm (default `sha256`).
+*
+* @example
+*   const fingerprint = await hashFile("./bundle.js");
+*   const quick = await hashFile("./small.txt", "md5");
+*/
+function hashFileAsync(path, algorithm = "sha256") {
+	return new Promise((resolve, reject) => {
+		const hash = createHash(algorithm);
+		const stream = createReadStream(path);
+		stream.on("data", (chunk) => hash.update(chunk));
+		stream.on("end", () => resolve(hash.digest("hex")));
+		stream.on("error", reject);
+	});
+}
+function hashFile(path, algorithm = "sha256") {
+	return createHash(algorithm).update(readFileSync(path)).digest("hex");
+}
+/**
+* Hash an in-memory string without touching disk. Convenient when the
+* caller already has the content loaded (e.g. file watcher diffing).
+*/
+function hashString(content, algorithm = "sha256") {
+	return createHash(algorithm).update(content).digest("hex");
+}
+/**
+* Hash an arbitrary buffer.
+*/
+function hashBuffer(content, algorithm = "sha256") {
+	return createHash(algorithm).update(content).digest("hex");
+}
+/**
+* Like `hashFileAsync` but reads the file in one go. Slightly faster for
+* small files; use the streaming variant for anything > ~1 MB.
+*/
+async function hashFileSmallAsync(path, algorithm = "sha256") {
+	return createHash(algorithm).update(await readFile(path)).digest("hex");
+}
+
+//#endregion
+export { hashBuffer, hashFile, hashFileAsync, hashFileSmallAsync, hashString };
+//# sourceMappingURL=hash.mjs.map

package/esm/hash.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.mjs","names":[],"sources":["../../../../../@warlock.js/fs/src/hash.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { createReadStream } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport { readFileSync } from \"node:fs\";\n\nexport type HashAlgorithm = \"sha256\" | \"sha1\" | \"md5\" | \"sha512\";\n\n/**\n * Compute a hex digest of a file's contents. Uses streaming for large\n * files so memory doesn't spike when hashing big assets.\n *\n * @param path - File to hash.\n * @param algorithm - Hash algorithm (default `sha256`).\n *\n * @example\n *   const fingerprint = await hashFile(\"./bundle.js\");\n *   const quick = await hashFile(\"./small.txt\", \"md5\");\n */\nexport function hashFileAsync(\n  path: string,\n  algorithm: HashAlgorithm = \"sha256\",\n): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const hash = createHash(algorithm);\n    const stream = createReadStream(path);\n    stream.on(\"data\", chunk => hash.update(chunk));\n    stream.on(\"end\", () => resolve(hash.digest(\"hex\")));\n    stream.on(\"error\", reject);\n  });\n}\n\nexport function hashFile(path: string, algorithm: HashAlgorithm = \"sha256\"): string {\n  return createHash(algorithm).update(readFileSync(path)).digest(\"hex\");\n}\n\n/**\n * Hash an in-memory string without touching disk. Convenient when the\n * caller already has the content loaded (e.g. file watcher diffing).\n */\nexport function hashString(content: string, algorithm: HashAlgorithm = \"sha256\"): string {\n  return createHash(algorithm).update(content).digest(\"hex\");\n}\n\n/**\n * Hash an arbitrary buffer.\n */\nexport function hashBuffer(\n  content: Buffer | Uint8Array,\n  algorithm: HashAlgorithm = \"sha256\",\n): string {\n  return createHash(algorithm).update(content).digest(\"hex\");\n}\n\n/**\n * Like `hashFileAsync` but reads the file in one go. Slightly faster for\n * small files; use the streaming variant for anything > ~1 MB.\n */\nexport async function hashFileSmallAsync(\n  path: string,\n  algorithm: HashAlgorithm = \"sha256\",\n): Promise<string> {\n  return createHash(algorithm).update(await readFile(path)).digest(\"hex\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAgB,cACd,MACA,YAA2B,UACV;CACjB,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,OAAO,WAAW,SAAS;EACjC,MAAM,SAAS,iBAAiB,IAAI;EACpC,OAAO,GAAG,SAAQ,UAAS,KAAK,OAAO,KAAK,CAAC;EAC7C,OAAO,GAAG,aAAa,QAAQ,KAAK,OAAO,KAAK,CAAC,CAAC;EAClD,OAAO,GAAG,SAAS,MAAM;CAC3B,CAAC;AACH;AAEA,SAAgB,SAAS,MAAc,YAA2B,UAAkB;CAClF,OAAO,WAAW,SAAS,EAAE,OAAO,aAAa,IAAI,CAAC,EAAE,OAAO,KAAK;AACtE;;;;;AAMA,SAAgB,WAAW,SAAiB,YAA2B,UAAkB;CACvF,OAAO,WAAW,SAAS,EAAE,OAAO,OAAO,EAAE,OAAO,KAAK;AAC3D;;;;AAKA,SAAgB,WACd,SACA,YAA2B,UACnB;CACR,OAAO,WAAW,SAAS,EAAE,OAAO,OAAO,EAAE,OAAO,KAAK;AAC3D;;;;;AAMA,eAAsB,mBACpB,MACA,YAA2B,UACV;CACjB,OAAO,WAAW,SAAS,EAAE,OAAO,MAAM,SAAS,IAAI,CAAC,EAAE,OAAO,KAAK;AACxE"}

package/esm/index.d.mts

@@ -0,0 +1,12 @@
+import { atomicWriteAsync, atomicWriteJsonAsync } from "./atomic.mjs";
+import { copyDirectory, copyDirectoryAsync, copyFile, copyFileAsync } from "./copy.mjs";
+import { ensureDirectory, ensureDirectoryAsync } from "./dirs.mjs";
+import { directoryExists, directoryExistsAsync, fileExists, fileExistsAsync, pathExists, pathExistsAsync } from "./exists.mjs";
+import { HashAlgorithm, hashBuffer, hashFile, hashFileAsync, hashFileSmallAsync, hashString } from "./hash.mjs";
+import { list, listAsync, listDirectories, listDirectoriesAsync, listFiles, listFilesAsync } from "./list.mjs";
+import { getFile, getFileAsync, getJsonFile, getJsonFileAsync } from "./read.mjs";
+import { removeDirectory, removeDirectoryAsync, unlink, unlinkAsync } from "./remove.mjs";
+import { renameFile, renameFileAsync } from "./rename.mjs";
+import { lastModified, lastModifiedAsync, stats, statsAsync } from "./stats.mjs";
+import { putFile, putFileAsync, putJsonFile, putJsonFileAsync } from "./write.mjs";
+export { HashAlgorithm, atomicWriteAsync, atomicWriteJsonAsync, copyDirectory, copyDirectoryAsync, copyFile, copyFileAsync, directoryExists, directoryExistsAsync, ensureDirectory, ensureDirectoryAsync, fileExists, fileExistsAsync, getFile, getFileAsync, getJsonFile, getJsonFileAsync, hashBuffer, hashFile, hashFileAsync, hashFileSmallAsync, hashString, lastModified, lastModifiedAsync, list, listAsync, listDirectories, listDirectoriesAsync, listFiles, listFilesAsync, pathExists, pathExistsAsync, putFile, putFileAsync, putJsonFile, putJsonFileAsync, removeDirectory, removeDirectoryAsync, renameFile, renameFileAsync, stats, statsAsync, unlink, unlinkAsync };

package/esm/index.mjs

@@ -0,0 +1,13 @@
+import { atomicWriteAsync, atomicWriteJsonAsync } from "./atomic.mjs";
+import { copyDirectory, copyDirectoryAsync, copyFile, copyFileAsync } from "./copy.mjs";
+import { ensureDirectory, ensureDirectoryAsync } from "./dirs.mjs";
+import { directoryExists, directoryExistsAsync, fileExists, fileExistsAsync, pathExists, pathExistsAsync } from "./exists.mjs";
+import { hashBuffer, hashFile, hashFileAsync, hashFileSmallAsync, hashString } from "./hash.mjs";
+import { list, listAsync, listDirectories, listDirectoriesAsync, listFiles, listFilesAsync } from "./list.mjs";
+import { getFile, getFileAsync, getJsonFile, getJsonFileAsync } from "./read.mjs";
+import { removeDirectory, removeDirectoryAsync, unlink, unlinkAsync } from "./remove.mjs";
+import { renameFile, renameFileAsync } from "./rename.mjs";
+import { lastModified, lastModifiedAsync, stats, statsAsync } from "./stats.mjs";
+import { putFile, putFileAsync, putJsonFile, putJsonFileAsync } from "./write.mjs";
+
+export { atomicWriteAsync, atomicWriteJsonAsync, copyDirectory, copyDirectoryAsync, copyFile, copyFileAsync, directoryExists, directoryExistsAsync, ensureDirectory, ensureDirectoryAsync, fileExists, fileExistsAsync, getFile, getFileAsync, getJsonFile, getJsonFileAsync, hashBuffer, hashFile, hashFileAsync, hashFileSmallAsync, hashString, lastModified, lastModifiedAsync, list, listAsync, listDirectories, listDirectoriesAsync, listFiles, listFilesAsync, pathExists, pathExistsAsync, putFile, putFileAsync, putJsonFile, putJsonFileAsync, removeDirectory, removeDirectoryAsync, renameFile, renameFileAsync, stats, statsAsync, unlink, unlinkAsync };

package/esm/list.d.mts

@@ -0,0 +1,20 @@
+//#region ../../@warlock.js/fs/src/list.d.ts
+/**
+ * List immediate children of a directory (files + subdirs), returning
+ * full paths.
+ */
+declare function listAsync(directoryPath: string): Promise<string[]>;
+declare function list(directoryPath: string): string[];
+/**
+ * List only files (not subdirectories) directly inside a directory.
+ */
+declare function listFilesAsync(directoryPath: string): Promise<string[]>;
+declare function listFiles(directoryPath: string): string[];
+/**
+ * List only subdirectories directly inside a directory.
+ */
+declare function listDirectoriesAsync(directoryPath: string): Promise<string[]>;
+declare function listDirectories(directoryPath: string): string[];
+//#endregion
+export { list, listAsync, listDirectories, listDirectoriesAsync, listFiles, listFilesAsync };
+//# sourceMappingURL=list.d.mts.map

package/esm/list.mjs

@@ -0,0 +1,39 @@
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { readdirSync, statSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/list.ts
+/**
+* List immediate children of a directory (files + subdirs), returning
+* full paths.
+*/
+async function listAsync(directoryPath) {
+	return (await readdir(directoryPath)).map((entry) => path.join(directoryPath, entry));
+}
+function list(directoryPath) {
+	return readdirSync(directoryPath).map((entry) => path.join(directoryPath, entry));
+}
+/**
+* List only files (not subdirectories) directly inside a directory.
+*/
+async function listFilesAsync(directoryPath) {
+	const entries = await listAsync(directoryPath);
+	return (await Promise.all(entries.map(async (entry) => (await stat(entry)).isFile() ? entry : null))).filter((entry) => entry !== null);
+}
+function listFiles(directoryPath) {
+	return list(directoryPath).filter((entry) => statSync(entry).isFile());
+}
+/**
+* List only subdirectories directly inside a directory.
+*/
+async function listDirectoriesAsync(directoryPath) {
+	const entries = await listAsync(directoryPath);
+	return (await Promise.all(entries.map(async (entry) => (await stat(entry)).isDirectory() ? entry : null))).filter((entry) => entry !== null);
+}
+function listDirectories(directoryPath) {
+	return list(directoryPath).filter((entry) => statSync(entry).isDirectory());
+}
+
+//#endregion
+export { list, listAsync, listDirectories, listDirectoriesAsync, listFiles, listFilesAsync };
+//# sourceMappingURL=list.mjs.map

package/esm/list.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.mjs","names":[],"sources":["../../../../../@warlock.js/fs/src/list.ts"],"sourcesContent":["import { readdir, stat } from \"node:fs/promises\";\nimport { readdirSync, statSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/**\n * List immediate children of a directory (files + subdirs), returning\n * full paths.\n */\nexport async function listAsync(directoryPath: string): Promise<string[]> {\n  const entries = await readdir(directoryPath);\n  return entries.map(entry => path.join(directoryPath, entry));\n}\n\nexport function list(directoryPath: string): string[] {\n  return readdirSync(directoryPath).map(entry => path.join(directoryPath, entry));\n}\n\n/**\n * List only files (not subdirectories) directly inside a directory.\n */\nexport async function listFilesAsync(directoryPath: string): Promise<string[]> {\n  const entries = await listAsync(directoryPath);\n  const checks = await Promise.all(\n    entries.map(async entry => ((await stat(entry)).isFile() ? entry : null)),\n  );\n  return checks.filter((entry): entry is string => entry !== null);\n}\n\nexport function listFiles(directoryPath: string): string[] {\n  return list(directoryPath).filter(entry => statSync(entry).isFile());\n}\n\n/**\n * List only subdirectories directly inside a directory.\n */\nexport async function listDirectoriesAsync(directoryPath: string): Promise<string[]> {\n  const entries = await listAsync(directoryPath);\n  const checks = await Promise.all(\n    entries.map(async entry => ((await stat(entry)).isDirectory() ? entry : null)),\n  );\n  return checks.filter((entry): entry is string => entry !== null);\n}\n\nexport function listDirectories(directoryPath: string): string[] {\n  return list(directoryPath).filter(entry => statSync(entry).isDirectory());\n}\n"],"mappings":";;;;;;;;;AAQA,eAAsB,UAAU,eAA0C;CAExE,QAAO,MADe,QAAQ,aAAa,GAC5B,KAAI,UAAS,KAAK,KAAK,eAAe,KAAK,CAAC;AAC7D;AAEA,SAAgB,KAAK,eAAiC;CACpD,OAAO,YAAY,aAAa,EAAE,KAAI,UAAS,KAAK,KAAK,eAAe,KAAK,CAAC;AAChF;;;;AAKA,eAAsB,eAAe,eAA0C;CAC7E,MAAM,UAAU,MAAM,UAAU,aAAa;CAI7C,QAAO,MAHc,QAAQ,IAC3B,QAAQ,IAAI,OAAM,WAAW,MAAM,KAAK,KAAK,GAAG,OAAO,IAAI,QAAQ,IAAK,CAC1E,GACc,QAAQ,UAA2B,UAAU,IAAI;AACjE;AAEA,SAAgB,UAAU,eAAiC;CACzD,OAAO,KAAK,aAAa,EAAE,QAAO,UAAS,SAAS,KAAK,EAAE,OAAO,CAAC;AACrE;;;;AAKA,eAAsB,qBAAqB,eAA0C;CACnF,MAAM,UAAU,MAAM,UAAU,aAAa;CAI7C,QAAO,MAHc,QAAQ,IAC3B,QAAQ,IAAI,OAAM,WAAW,MAAM,KAAK,KAAK,GAAG,YAAY,IAAI,QAAQ,IAAK,CAC/E,GACc,QAAQ,UAA2B,UAAU,IAAI;AACjE;AAEA,SAAgB,gBAAgB,eAAiC;CAC/D,OAAO,KAAK,aAAa,EAAE,QAAO,UAAS,SAAS,KAAK,EAAE,YAAY,CAAC;AAC1E"}

package/esm/read.d.mts

@@ -0,0 +1,16 @@
+//#region ../../@warlock.js/fs/src/read.d.ts
+/**
+ * Read a file as UTF-8 text.
+ */
+declare function getFileAsync(path: string): Promise<string>;
+declare function getFile(path: string): string;
+/**
+ * Read a JSON file and parse it.
+ *
+ * @throws if the file does not exist or contains invalid JSON.
+ */
+declare function getJsonFileAsync<T = unknown>(path: string): Promise<T>;
+declare function getJsonFile<T = unknown>(path: string): T;
+//#endregion
+export { getFile, getFileAsync, getJsonFile, getJsonFileAsync };
+//# sourceMappingURL=read.d.mts.map

package/esm/read.mjs

@@ -0,0 +1,28 @@
+import { readFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/read.ts
+/**
+* Read a file as UTF-8 text.
+*/
+async function getFileAsync(path) {
+	return readFile(path, "utf-8");
+}
+function getFile(path) {
+	return readFileSync(path, "utf-8");
+}
+/**
+* Read a JSON file and parse it.
+*
+* @throws if the file does not exist or contains invalid JSON.
+*/
+async function getJsonFileAsync(path) {
+	return JSON.parse(await getFileAsync(path));
+}
+function getJsonFile(path) {
+	return JSON.parse(getFile(path));
+}
+
+//#endregion
+export { getFile, getFileAsync, getJsonFile, getJsonFileAsync };
+//# sourceMappingURL=read.mjs.map

package/esm/read.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.mjs","names":[],"sources":["../../../../../@warlock.js/fs/src/read.ts"],"sourcesContent":["import { readFile } from \"node:fs/promises\";\nimport { readFileSync } from \"node:fs\";\n\n/**\n * Read a file as UTF-8 text.\n */\nexport async function getFileAsync(path: string): Promise<string> {\n  return readFile(path, \"utf-8\");\n}\n\nexport function getFile(path: string): string {\n  return readFileSync(path, \"utf-8\");\n}\n\n/**\n * Read a JSON file and parse it.\n *\n * @throws if the file does not exist or contains invalid JSON.\n */\nexport async function getJsonFileAsync<T = unknown>(path: string): Promise<T> {\n  return JSON.parse(await getFileAsync(path)) as T;\n}\n\nexport function getJsonFile<T = unknown>(path: string): T {\n  return JSON.parse(getFile(path)) as T;\n}\n"],"mappings":";;;;;;;AAMA,eAAsB,aAAa,MAA+B;CAChE,OAAO,SAAS,MAAM,OAAO;AAC/B;AAEA,SAAgB,QAAQ,MAAsB;CAC5C,OAAO,aAAa,MAAM,OAAO;AACnC;;;;;;AAOA,eAAsB,iBAA8B,MAA0B;CAC5E,OAAO,KAAK,MAAM,MAAM,aAAa,IAAI,CAAC;AAC5C;AAEA,SAAgB,YAAyB,MAAiB;CACxD,OAAO,KAAK,MAAM,QAAQ,IAAI,CAAC;AACjC"}

package/esm/remove.d.mts

@@ -0,0 +1,14 @@
+//#region ../../@warlock.js/fs/src/remove.d.ts
+/**
+ * Delete a single file. No error if the file doesn't exist.
+ */
+declare function unlinkAsync(path: string): Promise<void>;
+declare function unlink(path: string): void;
+/**
+ * Recursively delete a directory and its contents. No error if missing.
+ */
+declare function removeDirectoryAsync(path: string): Promise<void>;
+declare function removeDirectory(path: string): void;
+//#endregion
+export { removeDirectory, removeDirectoryAsync, unlink, unlinkAsync };
+//# sourceMappingURL=remove.d.mts.map

package/esm/remove.mjs

@@ -0,0 +1,40 @@
+import { rm, unlink } from "node:fs/promises";
+import { rmSync, unlinkSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/remove.ts
+/**
+* Delete a single file. No error if the file doesn't exist.
+*/
+async function unlinkAsync(path) {
+	try {
+		await unlink(path);
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error;
+	}
+}
+function unlink$1(path) {
+	try {
+		unlinkSync(path);
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error;
+	}
+}
+/**
+* Recursively delete a directory and its contents. No error if missing.
+*/
+async function removeDirectoryAsync(path) {
+	await rm(path, {
+		recursive: true,
+		force: true
+	});
+}
+function removeDirectory(path) {
+	rmSync(path, {
+		recursive: true,
+		force: true
+	});
+}
+
+//#endregion
+export { removeDirectory, removeDirectoryAsync, unlink$1 as unlink, unlinkAsync };
+//# sourceMappingURL=remove.mjs.map

package/esm/remove.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove.mjs","names":["unlinkPromise","unlink"],"sources":["../../../../../@warlock.js/fs/src/remove.ts"],"sourcesContent":["import { rm, unlink as unlinkPromise } from \"node:fs/promises\";\nimport { rmSync, unlinkSync } from \"node:fs\";\n\n/**\n * Delete a single file. No error if the file doesn't exist.\n */\nexport async function unlinkAsync(path: string): Promise<void> {\n  try {\n    await unlinkPromise(path);\n  } catch (error: any) {\n    if (error?.code !== \"ENOENT\") throw error;\n  }\n}\n\nexport function unlink(path: string): void {\n  try {\n    unlinkSync(path);\n  } catch (error: any) {\n    if (error?.code !== \"ENOENT\") throw error;\n  }\n}\n\n/**\n * Recursively delete a directory and its contents. No error if missing.\n */\nexport async function removeDirectoryAsync(path: string): Promise<void> {\n  await rm(path, { recursive: true, force: true });\n}\n\nexport function removeDirectory(path: string): void {\n  rmSync(path, { recursive: true, force: true });\n}\n"],"mappings":";;;;;;;AAMA,eAAsB,YAAY,MAA6B;CAC7D,IAAI;EACF,MAAMA,OAAc,IAAI;CAC1B,SAAS,OAAY;EACnB,IAAI,OAAO,SAAS,UAAU,MAAM;CACtC;AACF;AAEA,SAAgBC,SAAO,MAAoB;CACzC,IAAI;EACF,WAAW,IAAI;CACjB,SAAS,OAAY;EACnB,IAAI,OAAO,SAAS,UAAU,MAAM;CACtC;AACF;;;;AAKA,eAAsB,qBAAqB,MAA6B;CACtE,MAAM,GAAG,MAAM;EAAE,WAAW;EAAM,OAAO;CAAK,CAAC;AACjD;AAEA,SAAgB,gBAAgB,MAAoB;CAClD,OAAO,MAAM;EAAE,WAAW;EAAM,OAAO;CAAK,CAAC;AAC/C"}

package/esm/rename.d.mts

@@ -0,0 +1,9 @@
+//#region ../../@warlock.js/fs/src/rename.d.ts
+/**
+ * Rename / move a file or directory.
+ */
+declare function renameFileAsync(from: string, to: string): Promise<void>;
+declare function renameFile(from: string, to: string): void;
+//#endregion
+export { renameFile, renameFileAsync };
+//# sourceMappingURL=rename.d.mts.map

package/esm/rename.mjs

@@ -0,0 +1,17 @@
+import { rename } from "node:fs/promises";
+import { renameSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/rename.ts
+/**
+* Rename / move a file or directory.
+*/
+async function renameFileAsync(from, to) {
+	await rename(from, to);
+}
+function renameFile(from, to) {
+	renameSync(from, to);
+}
+
+//#endregion
+export { renameFile, renameFileAsync };
+//# sourceMappingURL=rename.mjs.map

package/esm/rename.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename.mjs","names":["renamePromise"],"sources":["../../../../../@warlock.js/fs/src/rename.ts"],"sourcesContent":["import { rename as renamePromise } from \"node:fs/promises\";\nimport { renameSync } from \"node:fs\";\n\n/**\n * Rename / move a file or directory.\n */\nexport async function renameFileAsync(from: string, to: string): Promise<void> {\n  await renamePromise(from, to);\n}\n\nexport function renameFile(from: string, to: string): void {\n  renameSync(from, to);\n}\n"],"mappings":";;;;;;;AAMA,eAAsB,gBAAgB,MAAc,IAA2B;CAC7E,MAAMA,OAAc,MAAM,EAAE;AAC9B;AAEA,SAAgB,WAAW,MAAc,IAAkB;CACzD,WAAW,MAAM,EAAE;AACrB"}

package/esm/stats.d.mts

@@ -0,0 +1,16 @@
+//#region ../../@warlock.js/fs/src/stats.d.ts
+/**
+ * Get last-modified time of a path. Returns a Date.
+ *
+ * @throws if the path does not exist.
+ */
+declare function lastModifiedAsync(path: string): Promise<Date>;
+declare function lastModified(path: string): Date;
+/**
+ * Return raw fs.Stats for a path.
+ */
+declare function statsAsync(path: string): Promise<import("fs").Stats>;
+declare function stats(path: string): import("fs").Stats;
+//#endregion
+export { lastModified, lastModifiedAsync, stats, statsAsync };
+//# sourceMappingURL=stats.d.mts.map

package/esm/stats.mjs

@@ -0,0 +1,28 @@
+import { stat } from "node:fs/promises";
+import { statSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/stats.ts
+/**
+* Get last-modified time of a path. Returns a Date.
+*
+* @throws if the path does not exist.
+*/
+async function lastModifiedAsync(path) {
+	return (await stat(path)).mtime;
+}
+function lastModified(path) {
+	return statSync(path).mtime;
+}
+/**
+* Return raw fs.Stats for a path.
+*/
+async function statsAsync(path) {
+	return stat(path);
+}
+function stats(path) {
+	return statSync(path);
+}
+
+//#endregion
+export { lastModified, lastModifiedAsync, stats, statsAsync };
+//# sourceMappingURL=stats.mjs.map

package/esm/stats.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.mjs","names":["statPromise"],"sources":["../../../../../@warlock.js/fs/src/stats.ts"],"sourcesContent":["import { stat as statPromise } from \"node:fs/promises\";\nimport { statSync } from \"node:fs\";\n\n/**\n * Get last-modified time of a path. Returns a Date.\n *\n * @throws if the path does not exist.\n */\nexport async function lastModifiedAsync(path: string): Promise<Date> {\n  return (await statPromise(path)).mtime;\n}\n\nexport function lastModified(path: string): Date {\n  return statSync(path).mtime;\n}\n\n/**\n * Return raw fs.Stats for a path.\n */\nexport async function statsAsync(path: string) {\n  return statPromise(path);\n}\n\nexport function stats(path: string) {\n  return statSync(path);\n}\n"],"mappings":";;;;;;;;;AAQA,eAAsB,kBAAkB,MAA6B;CACnE,QAAQ,MAAMA,KAAY,IAAI,GAAG;AACnC;AAEA,SAAgB,aAAa,MAAoB;CAC/C,OAAO,SAAS,IAAI,EAAE;AACxB;;;;AAKA,eAAsB,WAAW,MAAc;CAC7C,OAAOA,KAAY,IAAI;AACzB;AAEA,SAAgB,MAAM,MAAc;CAClC,OAAO,SAAS,IAAI;AACtB"}

package/esm/write.d.mts

@@ -0,0 +1,14 @@
+//#region ../../@warlock.js/fs/src/write.d.ts
+/**
+ * Write a UTF-8 string to disk, creating any missing parent directories.
+ */
+declare function putFileAsync(filePath: string, content: string): Promise<void>;
+declare function putFile(filePath: string, content: string): void;
+/**
+ * Write a JSON-serialisable value to disk (pretty-printed, 2-space indent).
+ */
+declare function putJsonFileAsync(filePath: string, value: unknown): Promise<void>;
+declare function putJsonFile(filePath: string, value: unknown): void;
+//#endregion
+export { putFile, putFileAsync, putJsonFile, putJsonFileAsync };
+//# sourceMappingURL=write.d.mts.map

package/esm/write.mjs

@@ -0,0 +1,29 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/write.ts
+/**
+* Write a UTF-8 string to disk, creating any missing parent directories.
+*/
+async function putFileAsync(filePath, content) {
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, content, "utf-8");
+}
+function putFile(filePath, content) {
+	mkdirSync(path.dirname(filePath), { recursive: true });
+	writeFileSync(filePath, content, "utf-8");
+}
+/**
+* Write a JSON-serialisable value to disk (pretty-printed, 2-space indent).
+*/
+async function putJsonFileAsync(filePath, value) {
+	await putFileAsync(filePath, JSON.stringify(value, null, 2));
+}
+function putJsonFile(filePath, value) {
+	putFile(filePath, JSON.stringify(value, null, 2));
+}
+
+//#endregion
+export { putFile, putFileAsync, putJsonFile, putJsonFileAsync };
+//# sourceMappingURL=write.mjs.map

package/esm/write.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.mjs","names":[],"sources":["../../../../../@warlock.js/fs/src/write.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport { mkdirSync, writeFileSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/**\n * Write a UTF-8 string to disk, creating any missing parent directories.\n */\nexport async function putFileAsync(filePath: string, content: string): Promise<void> {\n  await mkdir(path.dirname(filePath), { recursive: true });\n  await writeFile(filePath, content, \"utf-8\");\n}\n\nexport function putFile(filePath: string, content: string): void {\n  mkdirSync(path.dirname(filePath), { recursive: true });\n  writeFileSync(filePath, content, \"utf-8\");\n}\n\n/**\n * Write a JSON-serialisable value to disk (pretty-printed, 2-space indent).\n */\nexport async function putJsonFileAsync(filePath: string, value: unknown): Promise<void> {\n  await putFileAsync(filePath, JSON.stringify(value, null, 2));\n}\n\nexport function putJsonFile(filePath: string, value: unknown): void {\n  putFile(filePath, JSON.stringify(value, null, 2));\n}\n"],"mappings":";;;;;;;;AAOA,eAAsB,aAAa,UAAkB,SAAgC;CACnF,MAAM,MAAM,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;CACvD,MAAM,UAAU,UAAU,SAAS,OAAO;AAC5C;AAEA,SAAgB,QAAQ,UAAkB,SAAuB;CAC/D,UAAU,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;CACrD,cAAc,UAAU,SAAS,OAAO;AAC1C;;;;AAKA,eAAsB,iBAAiB,UAAkB,OAA+B;CACtF,MAAM,aAAa,UAAU,KAAK,UAAU,OAAO,MAAM,CAAC,CAAC;AAC7D;AAEA,SAAgB,YAAY,UAAkB,OAAsB;CAClE,QAAQ,UAAU,KAAK,UAAU,OAAO,MAAM,CAAC,CAAC;AAClD"}