@statewalker/webrun-files 0.5.0 → 0.7.0

package/dist/cjs/index.cjs

@@ -1,47 +1,100 @@
 
-//#region src/utils/collect-stream.ts
+//#region src/file-utils.ts
 /**
-* Stream collection utilities
+* Collect async iterable chunks into a single Uint8Array.
 */
+async function collectChunks(chunks) {
+	const parts = [];
+	let totalLength = 0;
+	for await (const chunk of chunks) {
+		parts.push(chunk);
+		totalLength += chunk.length;
+	}
+	if (parts.length === 0) return new Uint8Array(0);
+	if (parts.length === 1) return parts[0];
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const chunk of parts) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
 /**
-* Collects all values from an async generator into an array.
+* Read entire file content into a Uint8Array.
+* Returns empty array if file doesn't exist.
 */
-async function collectGenerator(generator) {
-	const results = [];
-	for await (const item of generator) results.push(item);
-	return results;
+async function readFile(files, path) {
+	return collectChunks(files.read(path));
 }
 /**
-* Converts a synchronous iterable to an async iterable.
+* Read entire file content as a UTF-8 string.
+* Returns empty string if file doesn't exist.
 */
-async function* toAsyncIterable(iterable) {
-	for (const item of iterable) yield item;
+async function readText(files, path) {
+	const data = await readFile(files, path);
+	return new TextDecoder().decode(data);
 }
 /**
-* Normalizes BinaryStream to AsyncIterable<Uint8Array>.
+* Read file content, returning undefined if file doesn't exist.
 */
-function toBinaryAsyncIterable(data) {
-	if (Symbol.asyncIterator in data) return data;
-	return toAsyncIterable(data);
+async function tryReadFile(files, path) {
+	if (!await files.exists(path)) return void 0;
+	return readFile(files, path);
+}
+/**
+* Read file content as string, returning undefined if file doesn't exist.
+*/
+async function tryReadText(files, path) {
+	const data = await tryReadFile(files, path);
+	return data ? new TextDecoder().decode(data) : void 0;
+}
+/**
+* Read a specific byte range from a file.
+*
+* @param files - FilesApi instance
+* @param path - File path
+* @param position - Starting byte position
+* @param length - Number of bytes to read
+* @returns Uint8Array with requested bytes (may be shorter if EOF reached)
+*/
+async function readRange(files, path, position, length) {
+	return collectChunks(files.read(path, {
+		start: position,
+		length
+	}));
 }
-
-//#endregion
-//#region src/utils/file-info-utils.ts
 /**
-* Check if FileInfo represents a directory
+* Read bytes from a file into a buffer at a specific offset.
+* Similar to Node.js fs.read() signature.
+*
+* @param files - FilesApi instance
+* @param path - File path
+* @param buffer - Target buffer to write into
+* @param bufferOffset - Offset in buffer where to start writing
+* @param length - Number of bytes to read
+* @param position - Position in file where to start reading
+* @returns Number of bytes actually read
 */
-function isDirectory(info) {
-	return info?.kind === "directory";
+async function readAt(files, path, buffer, bufferOffset, length, position) {
+	const data = await readRange(files, path, position, length);
+	const bytesToCopy = Math.min(data.length, buffer.length - bufferOffset);
+	buffer.set(data.subarray(0, bytesToCopy), bufferOffset);
+	return bytesToCopy;
 }
 /**
-* Check if FileInfo represents a file
+* Write a string to a file as UTF-8.
 */
-function isFile(info) {
-	return info?.kind === "file";
+async function writeText(files, path, content) {
+	await files.write(path, [new TextEncoder().encode(content)]);
 }
 
 //#endregion
-//#region src/utils/normalize-path.ts
+//#region src/path-utils.ts
+/**
+* Path manipulation utilities for virtual filesystem paths.
+* All paths use forward slashes and start with "/".
+*/
 /**
 * Normalizes a file path to a consistent format.
 * - Adds leading slash if missing
@@ -55,24 +108,6 @@ function normalizePath(filePath) {
 	return `/${segments.join("/")}`;
 }
 /**
-* Extracts path string from FileRef.
-*/
-function toPath(file) {
-	return typeof file === "object" ? file.path : String(file);
-}
-/**
-* Normalizes FileRef to a path string.
-*/
-function resolveFileRef(file) {
-	return normalizePath(toPath(file));
-}
-
-//#endregion
-//#region src/utils/path-utils.ts
-/**
-* Path manipulation utilities
-*/
-/**
 * Joins path segments with proper normalization.
 */
 function joinPath(...segments) {
@@ -108,492 +143,15 @@ function extname(path) {
 }
 
 //#endregion
-//#region src/files-api.ts
-const IGNORE_FILE = ".ignore";
-var FilesApi = class {
-	constructor(fs) {
-		this.fs = fs;
-	}
-	list(file, options) {
-		return this.fs.list(file, options);
-	}
-	stats(file) {
-		return this.fs.stats(file);
-	}
-	remove(file) {
-		return this.fs.remove(file);
-	}
-	open(file) {
-		return this.fs.open(file);
-	}
-	/**
-	* Checks if a file or directory exists.
-	*/
-	async exists(file) {
-		return await this.stats(file) !== void 0;
-	}
-	/**
-	* Reads file content as a stream.
-	*/
-	async *read(file, options = {}) {
-		const handle = await this.open(file);
-		try {
-			yield* handle.createReadStream(options);
-		} finally {
-			await handle.close();
-		}
-	}
-	/**
-	* Writes content to a file.
-	*/
-	async write(file, content) {
-		const handle = await this.open(file);
-		try {
-			await handle.createWriteStream(toBinaryAsyncIterable(content));
-		} finally {
-			await handle.close();
-		}
-	}
-	/**
-	* Reads entire file into a single buffer.
-	*/
-	async readFile(file) {
-		const chunks = [];
-		let totalLength = 0;
-		for await (const chunk of this.read(file)) {
-			chunks.push(chunk);
-			totalLength += chunk.length;
-		}
-		if (chunks.length === 0) return new Uint8Array(0);
-		if (chunks.length === 1) return chunks[0];
-		const result = new Uint8Array(totalLength);
-		let offset = 0;
-		for (const chunk of chunks) {
-			result.set(chunk, offset);
-			offset += chunk.length;
-		}
-		return result;
-	}
-	/**
-	* Copies file or directory.
-	* Uses native implementation if available, otherwise falls back to read/write.
-	*/
-	async copy(source, target, options = {}) {
-		if (this.fs.copy) return this.fs.copy(source, target, options);
-		const sourceInfo = await this.stats(source);
-		if (!sourceInfo) return false;
-		const sourcePath = resolveFileRef(source);
-		const targetPath = resolveFileRef(target);
-		const recursive = options.recursive ?? true;
-		if (sourceInfo.kind === "directory") for await (const entry of this.list(source, { recursive })) {
-			if (entry.kind === "directory") continue;
-			const newTargetPath = targetPath + entry.path.substring(sourcePath.length);
-			await this.write(newTargetPath, this.read(entry.path));
-		}
-		else await this.write(targetPath, this.read(sourcePath));
-		return true;
-	}
-	/**
-	* Moves file or directory.
-	* Uses native implementation if available, otherwise falls back to copy+delete.
-	*/
-	async move(source, target) {
-		if (this.fs.move) return this.fs.move(source, target);
-		if (!await this.copy(source, target)) return false;
-		await this.remove(source);
-		return true;
-	}
-	/**
-	* Creates a directory.
-	* Uses native implementation if available, otherwise creates a placeholder file.
-	*/
-	async mkdir(file) {
-		if (this.fs.mkdir) return this.fs.mkdir(file);
-		const placeholderPath = joinPath(resolveFileRef(file), IGNORE_FILE);
-		await this.write(placeholderPath, [new Uint8Array(0)]);
-	}
-};
-
-//#endregion
-//#region src/impl/mem-files-api.ts
-var MemFileHandle = class {
-	constructor(store, path) {
-		this.store = store;
-		this.path = path;
-	}
-	get size() {
-		const entry = this.store.get(this.path);
-		if (entry?.kind === "file") return entry.content.length;
-		return 0;
-	}
-	getOrCreateFile() {
-		let entry = this.store.get(this.path);
-		if (!entry || entry.kind !== "file") {
-			entry = {
-				kind: "file",
-				content: new Uint8Array(0),
-				lastModified: Date.now()
-			};
-			this.store.set(this.path, entry);
-		}
-		return entry;
-	}
-	async close() {}
-	async appendFile(data, options = {}) {
-		const file = this.getOrCreateFile();
-		const chunks = [file.content];
-		let bytesWritten = 0;
-		for await (const chunk of toBinaryAsyncIterable(data)) {
-			if (options.signal?.aborted) throw new Error("Operation aborted");
-			chunks.push(chunk);
-			bytesWritten += chunk.length;
-		}
-		const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
-		const merged = new Uint8Array(totalLength);
-		let offset = 0;
-		for (const chunk of chunks) {
-			merged.set(chunk, offset);
-			offset += chunk.length;
-		}
-		file.content = merged;
-		file.lastModified = Date.now();
-		return bytesWritten;
-	}
-	async *createReadStream(options = {}) {
-		const entry = this.store.get(this.path);
-		if (!entry || entry.kind !== "file") return;
-		const { start = 0, end = Infinity, signal } = options;
-		const bufferSize = 8192;
-		const content = entry.content;
-		const actualEnd = Math.min(end, content.length);
-		let position = start;
-		while (position < actualEnd) {
-			if (signal?.aborted) throw new Error("Operation aborted");
-			const remaining = actualEnd - position;
-			const toRead = Math.min(bufferSize, remaining);
-			yield content.subarray(position, position + toRead);
-			position += toRead;
-		}
-	}
-	async createWriteStream(data, options = {}) {
-		const { start = 0, signal } = options;
-		const file = this.getOrCreateFile();
-		const chunks = [];
-		let bytesWritten = 0;
-		if (start > 0 && file.content.length > 0) chunks.push(file.content.subarray(0, Math.min(start, file.content.length)));
-		if (start > file.content.length) chunks.push(new Uint8Array(start - file.content.length));
-		for await (const chunk of toBinaryAsyncIterable(data)) {
-			if (signal?.aborted) throw new Error("Operation aborted");
-			chunks.push(chunk);
-			bytesWritten += chunk.length;
-		}
-		const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
-		const merged = new Uint8Array(totalLength);
-		let offset = 0;
-		for (const chunk of chunks) {
-			merged.set(chunk, offset);
-			offset += chunk.length;
-		}
-		file.content = merged;
-		file.lastModified = Date.now();
-		return bytesWritten;
-	}
-	async read(buffer, offset, length, position) {
-		const entry = this.store.get(this.path);
-		if (!entry || entry.kind !== "file") return 0;
-		const content = entry.content;
-		const available = content.length - position;
-		if (available <= 0) return 0;
-		const bytesToRead = Math.min(length, available, buffer.length - offset);
-		buffer.set(content.subarray(position, position + bytesToRead), offset);
-		return bytesToRead;
-	}
-};
-var MemFilesApi = class {
-	store = /* @__PURE__ */ new Map();
-	async *list(file, options = {}) {
-		const normalized = resolveFileRef(file);
-		const prefix = normalized === "/" ? "/" : `${normalized}/`;
-		const { recursive = false } = options;
-		const seen = /* @__PURE__ */ new Set();
-		for (const [path, entry] of this.store.entries()) {
-			if (!path.startsWith(prefix)) continue;
-			const segments = path.substring(prefix.length).split("/");
-			if (segments.length === 0 || segments[0] === "") continue;
-			if (segments.length === 1) {
-				if (seen.has(path)) continue;
-				seen.add(path);
-				const info = {
-					kind: entry.kind,
-					name: basename(path),
-					path,
-					lastModified: entry.lastModified
-				};
-				if (entry.kind === "file") info.size = entry.content.length;
-				yield info;
-			} else if (recursive) {
-				if (seen.has(path)) continue;
-				seen.add(path);
-				const info = {
-					kind: entry.kind,
-					name: basename(path),
-					path,
-					lastModified: entry.lastModified
-				};
-				if (entry.kind === "file") info.size = entry.content.length;
-				yield info;
-			} else {
-				const dirName = segments[0];
-				const dirPath = joinPath(normalized, dirName);
-				if (!seen.has(dirPath)) {
-					seen.add(dirPath);
-					yield {
-						kind: "directory",
-						name: dirName,
-						path: dirPath,
-						lastModified: 0
-					};
-				}
-			}
-		}
-	}
-	async stats(file) {
-		const normalized = resolveFileRef(file);
-		const entry = this.store.get(normalized);
-		if (entry) {
-			const info = {
-				kind: entry.kind,
-				name: basename(normalized),
-				path: normalized,
-				lastModified: entry.lastModified
-			};
-			if (entry.kind === "file") info.size = entry.content.length;
-			return info;
-		}
-		if (normalized === "/") return {
-			kind: "directory",
-			name: "",
-			path: "/",
-			lastModified: 0
-		};
-		const prefix = `${normalized}/`;
-		for (const path of this.store.keys()) if (path.startsWith(prefix)) return {
-			kind: "directory",
-			name: basename(normalized),
-			path: normalized,
-			lastModified: 0
-		};
-	}
-	async remove(file) {
-		const normalized = resolveFileRef(file);
-		const prefix = `${normalized}/`;
-		let removed = false;
-		if (this.store.delete(normalized)) removed = true;
-		for (const path of [...this.store.keys()]) if (path.startsWith(prefix)) {
-			this.store.delete(path);
-			removed = true;
-		}
-		return removed;
-	}
-	async open(file) {
-		const normalized = resolveFileRef(file);
-		return new MemFileHandle(this.store, normalized);
-	}
-	async mkdir(file) {
-		const normalized = resolveFileRef(file);
-		if (!this.store.has(normalized)) this.store.set(normalized, {
-			kind: "directory",
-			lastModified: Date.now()
-		});
-	}
-};
-
-//#endregion
-//#region src/impl/node-files-api.ts
-/**
-* Wraps Node.js FileHandle to implement our FileHandle interface.
-*/
-var NodeFileHandleWrapper = class {
-	constructor(handle, _size) {
-		this.handle = handle;
-		this._size = _size;
-	}
-	get size() {
-		return this._size;
-	}
-	async close() {
-		await this.handle.close();
-	}
-	async appendFile(data, options = {}) {
-		let bytesWritten = 0;
-		const asyncData = toBinaryAsyncIterable(data);
-		for await (const chunk of asyncData) {
-			if (options.signal?.aborted) throw new Error("Operation aborted");
-			await this.handle.appendFile(chunk);
-			bytesWritten += chunk.length;
-		}
-		this._size = (await this.handle.stat()).size;
-		return bytesWritten;
-	}
-	async *createReadStream(options = {}) {
-		const { start = 0, end = Infinity, signal } = options;
-		const bufferSize = 8192;
-		let position = start;
-		const actualEnd = Math.min(end, this._size);
-		while (position < actualEnd) {
-			if (signal?.aborted) throw new Error("Operation aborted");
-			const remaining = actualEnd - position;
-			const toRead = Math.min(bufferSize, remaining);
-			const buffer = new Uint8Array(toRead);
-			const { bytesRead } = await this.handle.read(buffer, 0, toRead, position);
-			if (bytesRead === 0) break;
-			yield buffer.subarray(0, bytesRead);
-			position += bytesRead;
-		}
-	}
-	async createWriteStream(data, options = {}) {
-		const { start = 0, signal } = options;
-		let position = start;
-		let bytesWritten = 0;
-		const asyncData = toBinaryAsyncIterable(data);
-		await this.handle.truncate(start);
-		for await (const chunk of asyncData) {
-			if (signal?.aborted) throw new Error("Operation aborted");
-			const { bytesWritten: written } = await this.handle.write(chunk, 0, chunk.length, position);
-			position += written;
-			bytesWritten += written;
-		}
-		this._size = (await this.handle.stat()).size;
-		return bytesWritten;
-	}
-	async chmod(mode) {
-		await this.handle.chmod(mode);
-	}
-	async chown(uid, gid) {
-		await this.handle.chown(uid, gid);
-	}
-	async read(buffer, offset, length, position) {
-		const actualLength = Math.min(length, buffer.length - offset);
-		if (actualLength <= 0) return 0;
-		return (await this.handle.read(buffer, offset, actualLength, position)).bytesRead;
-	}
-};
-var NodeFilesApi = class {
-	fs;
-	rootDir;
-	constructor(options) {
-		this.fs = options.fs;
-		this.rootDir = options.rootDir ?? "";
-	}
-	resolvePath(file) {
-		const normalized = resolveFileRef(file);
-		return this.rootDir + normalized;
-	}
-	async *list(file, options = {}) {
-		const dirPath = this.resolvePath(file);
-		const { recursive = false } = options;
-		try {
-			const entries = await this.fs.readdir(dirPath, { withFileTypes: true });
-			for (const entry of entries) {
-				const entryPath = joinPath(resolveFileRef(file), entry.name);
-				const fullPath = this.rootDir + entryPath;
-				const info = {
-					kind: entry.isDirectory() ? "directory" : "file",
-					name: entry.name,
-					path: entryPath,
-					lastModified: 0
-				};
-				try {
-					const stat = await this.fs.stat(fullPath);
-					info.size = stat.size;
-					info.lastModified = stat.mtimeMs;
-				} catch {}
-				yield info;
-				if (recursive && entry.isDirectory()) yield* this.list(entryPath, options);
-			}
-		} catch {}
-	}
-	async stats(file) {
-		const fullPath = this.resolvePath(file);
-		const normalized = resolveFileRef(file);
-		try {
-			const stat = await this.fs.stat(fullPath);
-			return {
-				kind: stat.isDirectory() ? "directory" : "file",
-				name: basename(normalized),
-				path: normalized,
-				size: stat.size,
-				lastModified: stat.mtimeMs
-			};
-		} catch {
-			return;
-		}
-	}
-	async remove(file) {
-		const fullPath = this.resolvePath(file);
-		try {
-			if ((await this.fs.stat(fullPath)).isDirectory()) await this.fs.rm(fullPath, {
-				recursive: true,
-				force: true
-			});
-			else await this.fs.unlink(fullPath);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	async open(file) {
-		const fullPath = this.resolvePath(file);
-		const normalized = resolveFileRef(file);
-		const dir = this.rootDir + dirname(normalized);
-		await this.fs.mkdir(dir, { recursive: true });
-		const handle = await this.fs.open(fullPath, "a+");
-		return new NodeFileHandleWrapper(handle, (await handle.stat()).size);
-	}
-	async move(source, target) {
-		const sourcePath = this.resolvePath(source);
-		const targetPath = this.resolvePath(target);
-		try {
-			const targetDir = dirname(targetPath);
-			await this.fs.mkdir(targetDir, { recursive: true });
-			await this.fs.rename(sourcePath, targetPath);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	async copy(source, target, options = {}) {
-		const sourcePath = this.resolvePath(source);
-		const targetPath = this.resolvePath(target);
-		const { recursive = true } = options;
-		try {
-			const targetDir = dirname(targetPath);
-			await this.fs.mkdir(targetDir, { recursive: true });
-			await this.fs.cp(sourcePath, targetPath, { recursive });
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	async mkdir(file) {
-		const fullPath = this.resolvePath(file);
-		await this.fs.mkdir(fullPath, { recursive: true });
-	}
-};
-
-//#endregion
-exports.FilesApi = FilesApi;
-exports.MemFilesApi = MemFilesApi;
-exports.NodeFilesApi = NodeFilesApi;
 exports.basename = basename;
-exports.collectGenerator = collectGenerator;
 exports.dirname = dirname;
 exports.extname = extname;
-exports.isDirectory = isDirectory;
-exports.isFile = isFile;
 exports.joinPath = joinPath;
 exports.normalizePath = normalizePath;
-exports.resolveFileRef = resolveFileRef;
-exports.toAsyncIterable = toAsyncIterable;
-exports.toBinaryAsyncIterable = toBinaryAsyncIterable;
-exports.toPath = toPath;
+exports.readAt = readAt;
+exports.readFile = readFile;
+exports.readRange = readRange;
+exports.readText = readText;
+exports.tryReadFile = tryReadFile;
+exports.tryReadText = tryReadText;
+exports.writeText = writeText;