typescript-virtual-container 1.2.9 → 1.3.1

package/src/VirtualFileSystem/binaryPack.ts

@@ -31,19 +31,25 @@
  *   Binary pack :  ~1.00 MB + ~40 bytes/node header  → ~27% smaller, no string parsing
  */
 
-import type { InternalDirectoryNode, InternalFileNode, InternalNode } from "./internalTypes";
+import type {
+	InternalDirectoryNode,
+	InternalFileNode,
+	InternalNode,
+} from "./internalTypes";
 
 const MAGIC = Buffer.from([0x56, 0x46, 0x53, 0x21]); // "VFS!"
 const VERSION = 0x01;
 const TYPE_FILE = 0x01;
-const TYPE_DIR  = 0x02;
+const TYPE_DIR = 0x02;
 
 // ── Encoder ───────────────────────────────────────────────────────────────────
 
 class Encoder {
 	private chunks: Buffer[] = [];
 
-	write(buf: Buffer): void { this.chunks.push(buf); }
+	write(buf: Buffer): void {
+		this.chunks.push(buf);
+	}
 
 	writeUint8(n: number): void {
 		const b = Buffer.allocUnsafe(1);
@@ -80,7 +86,9 @@ class Encoder {
 		this.chunks.push(bytes);
 	}
 
-	toBuffer(): Buffer { return Buffer.concat(this.chunks); }
+	toBuffer(): Buffer {
+		return Buffer.concat(this.chunks);
+	}
 }
 
 function encodeNode(enc: Encoder, node: InternalNode): void {
@@ -124,7 +132,9 @@ class Decoder {
 	private pos = 0;
 	constructor(private readonly buf: Buffer) {}
 
-	readUint8(): number { return this.buf.readUInt8(this.pos++); }
+	readUint8(): number {
+		return this.buf.readUInt8(this.pos++);
+	}
 
 	readUint16(): number {
 		const v = this.buf.readUInt16LE(this.pos);
@@ -158,7 +168,9 @@ class Decoder {
 		return b;
 	}
 
-	remaining(): number { return this.buf.length - this.pos; }
+	remaining(): number {
+		return this.buf.length - this.pos;
+	}
 }
 
 function decodeNode(dec: Decoder): InternalNode {
@@ -171,7 +183,15 @@ function decodeNode(dec: Decoder): InternalNode {
 	if (type === TYPE_FILE) {
 		const compressed = dec.readUint8() === 0x01;
 		const content = dec.readBytes();
-		return { type: "file", name, mode, createdAt, updatedAt, compressed, content } satisfies InternalFileNode;
+		return {
+			type: "file",
+			name,
+			mode,
+			createdAt,
+			updatedAt,
+			compressed,
+			content,
+		} satisfies InternalFileNode;
 	}
 
 	if (type === TYPE_DIR) {
@@ -181,7 +201,14 @@ function decodeNode(dec: Decoder): InternalNode {
 			const child = decodeNode(dec);
 			children.set(child.name, child);
 		}
-		return { type: "directory", name, mode, createdAt, updatedAt, children } satisfies InternalDirectoryNode;
+		return {
+			type: "directory",
+			name,
+			mode,
+			createdAt,
+			updatedAt,
+			children,
+		} satisfies InternalDirectoryNode;
 	}
 
 	throw new Error(`[VFS binary] Unknown node type: 0x${type.toString(16)}`);

package/src/VirtualFileSystem/index.ts

@@ -172,7 +172,9 @@ class VirtualFileSystem extends EventEmitter {
 				// Legacy JSON fallback — auto-migrates on next flushMirror()
 				const snapshot: VfsSnapshot = JSON.parse(raw.toString("utf8"));
 				this.root = this.deserializeDir(snapshot.root, "");
-				console.info("[VirtualFileSystem] Migrating legacy JSON snapshot to binary format.");
+				console.info(
+					"[VirtualFileSystem] Migrating legacy JSON snapshot to binary format.",
+				);
 			}
 			this.emit("snapshot:restore", { path: this.snapshotFile });
 		} catch (err) {
@@ -220,7 +222,11 @@ class VirtualFileSystem extends EventEmitter {
 	public mkdir(targetPath: string, mode: number = 0o755): void {
 		const normalized = normalizePath(targetPath);
 		const existing = (() => {
-			try { return getNode(this.root, normalized); } catch { return null; }
+			try {
+				return getNode(this.root, normalized);
+			} catch {
+				return null;
+			}
 		})();
 		if (existing && existing.type !== "directory") {
 			throw new Error(
@@ -311,7 +317,9 @@ class VirtualFileSystem extends EventEmitter {
 		try {
 			getNode(this.root, normalizePath(targetPath));
 			return true;
-		} catch { return false; }
+		} catch {
+			return false;
+		}
 	}
 
 	/** Updates mode bits on a node. */
@@ -327,15 +335,24 @@ class VirtualFileSystem extends EventEmitter {
 		if (node.type === "file") {
 			const f = node as InternalFileNode;
 			return {
-				type: "file", name, path: normalized, mode: f.mode,
-				createdAt: f.createdAt, updatedAt: f.updatedAt,
-				compressed: f.compressed, size: f.content.length,
+				type: "file",
+				name,
+				path: normalized,
+				mode: f.mode,
+				createdAt: f.createdAt,
+				updatedAt: f.updatedAt,
+				compressed: f.compressed,
+				size: f.content.length,
 			};
 		}
 		const d = node as InternalDirectoryNode;
 		return {
-			type: "directory", name, path: normalized, mode: d.mode,
-			createdAt: d.createdAt, updatedAt: d.updatedAt,
+			type: "directory",
+			name,
+			path: normalized,
+			mode: d.mode,
+			createdAt: d.createdAt,
+			updatedAt: d.updatedAt,
 			childrenCount: d.children.size,
 		};
 	}
@@ -355,9 +372,7 @@ class VirtualFileSystem extends EventEmitter {
 		const normalized = normalizePath(dirPath);
 		const node = getNode(this.root, normalized);
 		if (node.type !== "directory") {
-			throw new Error(
-				`Cannot render tree for '${dirPath}': not a directory.`,
-			);
+			throw new Error(`Cannot render tree for '${dirPath}': not a directory.`);
 		}
 		const label = dirPath === "/" ? "/" : path.posix.basename(normalized);
 		return this.renderTreeLines(node as InternalDirectoryNode, label);
@@ -375,7 +390,8 @@ class VirtualFileSystem extends EventEmitter {
 			lines.push(`${connector}${name}`);
 			if (child.type === "directory") {
 				const sub = this.renderTreeLines(child as InternalDirectoryNode, "")
-					.split("\n").slice(1)
+					.split("\n")
+					.slice(1)
 					.map((l) => `${nextPrefix}${l}`);
 				lines.push(...sub);
 			}
@@ -400,7 +416,8 @@ class VirtualFileSystem extends EventEmitter {
 	/** Compresses a file's content with gzip in place. */
 	public compressFile(targetPath: string): void {
 		const node = getNode(this.root, normalizePath(targetPath));
-		if (node.type !== "file") throw new Error(`Cannot compress '${targetPath}': not a file.`);
+		if (node.type !== "file")
+			throw new Error(`Cannot compress '${targetPath}': not a file.`);
 		const f = node as InternalFileNode;
 		if (!f.compressed) {
 			f.content = gzipSync(f.content);
@@ -412,7 +429,8 @@ class VirtualFileSystem extends EventEmitter {
 	/** Decompresses a gzip-compressed file in place. */
 	public decompressFile(targetPath: string): void {
 		const node = getNode(this.root, normalizePath(targetPath));
-		if (node.type !== "file") throw new Error(`Cannot decompress '${targetPath}': not a file.`);
+		if (node.type !== "file")
+			throw new Error(`Cannot decompress '${targetPath}': not a file.`);
 		const f = node as InternalFileNode;
 		if (f.compressed) {
 			f.content = gunzipSync(f.content);
@@ -431,18 +449,25 @@ class VirtualFileSystem extends EventEmitter {
 			? normalizePath(targetPath)
 			: targetPath;
 		const { parent, name } = getParentDirectory(
-			this.root, normalizedLink, true,
+			this.root,
+			normalizedLink,
+			true,
 			(p) => this.mkdirRecursive(p, 0o755),
 		);
 		const symNode: InternalFileNode = {
-			type: "file", name,
+			type: "file",
+			name,
 			content: Buffer.from(normalizedTarget, "utf8"),
 			mode: 0o120777,
 			compressed: false,
-			createdAt: new Date(), updatedAt: new Date(),
+			createdAt: new Date(),
+			updatedAt: new Date(),
 		};
 		parent.children.set(name, symNode);
-		this.emit("symlink:create", { link: normalizedLink, target: normalizedTarget });
+		this.emit("symlink:create", {
+			link: normalizedLink,
+			target: normalizedTarget,
+		});
 	}
 
 	/** Returns true when the path is a symbolic link node. */
@@ -450,7 +475,9 @@ class VirtualFileSystem extends EventEmitter {
 		try {
 			const node = getNode(this.root, normalizePath(targetPath));
 			return node.type === "file" && node.mode === 0o120777;
-		} catch { return false; }
+		} catch {
+			return false;
+		}
 	}
 
 	/**
@@ -466,10 +493,14 @@ class VirtualFileSystem extends EventEmitter {
 					const target = (node as InternalFileNode).content.toString("utf8");
 					current = target.startsWith("/")
 						? target
-						: normalizePath(path.posix.join(path.posix.dirname(current), target));
+						: normalizePath(
+								path.posix.join(path.posix.dirname(current), target),
+							);
 					continue;
 				}
-			} catch { break; }
+			} catch {
+				break;
+			}
 			return current;
 		}
 		throw new Error(`Too many levels of symbolic links: ${linkPath}`);
@@ -488,7 +519,12 @@ class VirtualFileSystem extends EventEmitter {
 				);
 			}
 		}
-		const { parent, name } = getParentDirectory(this.root, normalized, false, () => {});
+		const { parent, name } = getParentDirectory(
+			this.root,
+			normalized,
+			false,
+			() => {},
+		);
 		parent.children.delete(name);
 		this.emit("node:remove", { path: normalized });
 	}
@@ -506,10 +542,16 @@ class VirtualFileSystem extends EventEmitter {
 		}
 		this.mkdirRecursive(path.posix.dirname(toNormalized), 0o755);
 		const { parent: destParent, name: destName } = getParentDirectory(
-			this.root, toNormalized, false, () => {},
+			this.root,
+			toNormalized,
+			false,
+			() => {},
 		);
 		const { parent: srcParent, name: srcName } = getParentDirectory(
-			this.root, fromNormalized, false, () => {},
+			this.root,
+			fromNormalized,
+			false,
+			() => {},
 		);
 		srcParent.children.delete(srcName);
 		node.name = destName;
@@ -538,7 +580,9 @@ class VirtualFileSystem extends EventEmitter {
 			);
 		}
 		return {
-			type: "directory", name: dir.name, mode: dir.mode,
+			type: "directory",
+			name: dir.name,
+			mode: dir.mode,
 			createdAt: dir.createdAt.toISOString(),
 			updatedAt: dir.updatedAt.toISOString(),
 			children,
@@ -547,7 +591,9 @@ class VirtualFileSystem extends EventEmitter {
 
 	private serializeFile(file: InternalFileNode): VfsSnapshotFileNode {
 		return {
-			type: "file", name: file.name, mode: file.mode,
+			type: "file",
+			name: file.name,
+			mode: file.mode,
 			createdAt: file.createdAt.toISOString(),
 			updatedAt: file.updatedAt.toISOString(),
 			compressed: file.compressed,
@@ -588,7 +634,9 @@ class VirtualFileSystem extends EventEmitter {
 		name: string,
 	): InternalDirectoryNode {
 		const dir: InternalDirectoryNode = {
-			type: "directory", name, mode: snap.mode,
+			type: "directory",
+			name,
+			mode: snap.mode,
 			createdAt: new Date(snap.createdAt),
 			updatedAt: new Date(snap.updatedAt),
 			children: new Map(),
@@ -597,7 +645,9 @@ class VirtualFileSystem extends EventEmitter {
 			if (child.type === "file") {
 				const f = child as VfsSnapshotFileNode;
 				dir.children.set(f.name, {
-					type: "file", name: f.name, mode: f.mode,
+					type: "file",
+					name: f.name,
+					mode: f.mode,
 					createdAt: new Date(f.createdAt),
 					updatedAt: new Date(f.updatedAt),
 					compressed: f.compressed,