@statewalker/webrun-files 0.3.1 → 0.4.0

package/dist/cjs/index.cjs

@@ -0,0 +1,564 @@
+
+//#region src/utils/collect-stream.ts
+/**
+* Stream collection utilities
+*/
+/**
+* Collects all values from an async generator into an array.
+*/
+async function collectGenerator(generator) {
+	const results = [];
+	for await (const item of generator) results.push(item);
+	return results;
+}
+/**
+* Converts a synchronous iterable to an async iterable.
+*/
+async function* toAsyncIterable(iterable) {
+	for (const item of iterable) yield item;
+}
+/**
+* Normalizes BinaryStream to AsyncIterable<Uint8Array>.
+*/
+function toBinaryAsyncIterable(data) {
+	if (Symbol.asyncIterator in data) return data;
+	return toAsyncIterable(data);
+}
+
+//#endregion
+//#region src/utils/normalize-path.ts
+/**
+* Normalizes a file path to a consistent format.
+* - Adds leading slash if missing
+* - Removes trailing slash
+* - Removes `.` segments
+* - Collapses multiple slashes
+*/
+function normalizePath(filePath) {
+	const segments = filePath.split("/").filter((s) => !!s && s !== ".");
+	if (segments.length === 0) return "/";
+	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) {
+	return normalizePath(segments.join("/"));
+}
+/**
+* Returns the directory portion of a path.
+*/
+function dirname(path) {
+	const normalized = normalizePath(path);
+	const lastSlash = normalized.lastIndexOf("/");
+	if (lastSlash <= 0) return "/";
+	return normalized.substring(0, lastSlash);
+}
+/**
+* Returns the filename portion of a path.
+*/
+function basename(path, ext) {
+	const normalized = normalizePath(path);
+	const lastSlash = normalized.lastIndexOf("/");
+	const name = lastSlash === -1 ? normalized : normalized.substring(lastSlash + 1);
+	if (ext && name.endsWith(ext)) return name.substring(0, name.length - ext.length);
+	return name;
+}
+/**
+* Returns the file extension including the dot.
+*/
+function extname(path) {
+	const name = basename(path);
+	const dotIndex = name.lastIndexOf(".");
+	if (dotIndex <= 0) return "";
+	return name.substring(dotIndex);
+}
+
+//#endregion
+//#region src/files-api.ts
+const IGNORE_FILE = ".gitkeep";
+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;
+	}
+};
+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);
+	}
+};
+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 });
+			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.joinPath = joinPath;
+exports.normalizePath = normalizePath;
+exports.resolveFileRef = resolveFileRef;
+exports.toAsyncIterable = toAsyncIterable;
+exports.toBinaryAsyncIterable = toBinaryAsyncIterable;
+exports.toPath = toPath;