@statewalker/webrun-files 0.3.1 → 0.4.0

package/dist/esm/index.js

@@ -0,0 +1,551 @@
+//#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
+export { FilesApi, MemFilesApi, NodeFilesApi, basename, collectGenerator, dirname, extname, joinPath, normalizePath, resolveFileRef, toAsyncIterable, toBinaryAsyncIterable, toPath };

package/dist/files-api.d.ts

@@ -0,0 +1,44 @@
+/**
+ * FilesApi wrapper class providing convenience methods on top of IFilesApi
+ */
+import type { BinaryStream, CopyOptions, FileHandle, FileInfo, FileRef, IFilesApi, ListOptions, ReadStreamOptions } from "./types.js";
+export declare class FilesApi implements IFilesApi {
+    private fs;
+    constructor(fs: IFilesApi);
+    list(file: FileRef, options?: ListOptions): AsyncGenerator<FileInfo>;
+    stats(file: FileRef): Promise<FileInfo | undefined>;
+    remove(file: FileRef): Promise<boolean>;
+    open(file: FileRef): Promise<FileHandle>;
+    /**
+     * Checks if a file or directory exists.
+     */
+    exists(file: FileRef): Promise<boolean>;
+    /**
+     * Reads file content as a stream.
+     */
+    read(file: FileRef, options?: ReadStreamOptions): AsyncGenerator<Uint8Array>;
+    /**
+     * Writes content to a file.
+     */
+    write(file: FileRef, content: BinaryStream): Promise<void>;
+    /**
+     * Reads entire file into a single buffer.
+     */
+    readFile(file: FileRef): Promise<Uint8Array>;
+    /**
+     * Copies file or directory.
+     * Uses native implementation if available, otherwise falls back to read/write.
+     */
+    copy(source: FileRef, target: FileRef, options?: CopyOptions): Promise<boolean>;
+    /**
+     * Moves file or directory.
+     * Uses native implementation if available, otherwise falls back to copy+delete.
+     */
+    move(source: FileRef, target: FileRef): Promise<boolean>;
+    /**
+     * Creates a directory.
+     * Uses native implementation if available, otherwise creates a placeholder file.
+     */
+    mkdir(file: FileRef): Promise<void>;
+}
+//# sourceMappingURL=files-api.d.ts.map

package/dist/files-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files-api.d.ts","sourceRoot":"","sources":["../src/files-api.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,WAAW,EACX,UAAU,EACV,QAAQ,EACR,OAAO,EACP,SAAS,EACT,WAAW,EACX,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAMpB,qBAAa,QAAS,YAAW,SAAS;IAC5B,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,SAAS;IAMjC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,cAAc,CAAC,QAAQ,CAAC;IAIpE,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAInD,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAIvC,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IAQxC;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAK7C;;OAEG;IACI,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,iBAAsB,GAAG,cAAc,CAAC,UAAU,CAAC;IASvF;;OAEG;IACG,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAShE;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IAqBlD;;;OAGG;IACG,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IA4BzF;;;OAGG;IACG,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAa9D;;;OAGG;IACG,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAW1C"}

package/dist/impl/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * IFilesApi implementations
+ */
+export * from "./mem-files-api.js";
+export * from "./node-files-api.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/impl/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/impl/mem-files-api.d.ts

@@ -0,0 +1,13 @@
+/**
+ * In-memory implementation of IFilesApi for testing
+ */
+import type { FileHandle, FileInfo, FileRef, IFilesApi, ListOptions } from "../types.js";
+export declare class MemFilesApi implements IFilesApi {
+    private store;
+    list(file: FileRef, options?: ListOptions): AsyncGenerator<FileInfo>;
+    stats(file: FileRef): Promise<FileInfo | undefined>;
+    remove(file: FileRef): Promise<boolean>;
+    open(file: FileRef): Promise<FileHandle>;
+    mkdir(file: FileRef): Promise<void>;
+}
+//# sourceMappingURL=mem-files-api.d.ts.map

package/dist/impl/mem-files-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mem-files-api.d.ts","sourceRoot":"","sources":["../../src/impl/mem-files-api.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAGV,UAAU,EACV,QAAQ,EACR,OAAO,EACP,SAAS,EACT,WAAW,EAGZ,MAAM,aAAa,CAAC;AA6IrB,qBAAa,WAAY,YAAW,SAAS;IAC3C,OAAO,CAAC,KAAK,CAA4B;IAElC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,cAAc,CAAC,QAAQ,CAAC;IAqEzE,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IA0CnD,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAsBvC,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IAKxC,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAS1C"}

package/dist/impl/node-files-api.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Node.js implementation of IFilesApi
+ */
+import type * as NodeFS from "node:fs/promises";
+import type { CopyOptions, FileHandle, FileInfo, FileRef, IFilesApi, ListOptions } from "../types.js";
+interface NodeFilesApiOptions {
+    fs: typeof NodeFS;
+    rootDir?: string;
+}
+export declare class NodeFilesApi implements IFilesApi {
+    private fs;
+    private rootDir;
+    constructor(options: NodeFilesApiOptions);
+    private resolvePath;
+    list(file: FileRef, options?: ListOptions): AsyncGenerator<FileInfo>;
+    stats(file: FileRef): Promise<FileInfo | undefined>;
+    remove(file: FileRef): Promise<boolean>;
+    open(file: FileRef): Promise<FileHandle>;
+    move(source: FileRef, target: FileRef): Promise<boolean>;
+    copy(source: FileRef, target: FileRef, options?: CopyOptions): Promise<boolean>;
+    mkdir(file: FileRef): Promise<void>;
+}
+export {};
+//# sourceMappingURL=node-files-api.d.ts.map

package/dist/impl/node-files-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-files-api.d.ts","sourceRoot":"","sources":["../../src/impl/node-files-api.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAEhD,OAAO,KAAK,EAGV,WAAW,EACX,UAAU,EACV,QAAQ,EACR,OAAO,EACP,SAAS,EACT,WAAW,EAGZ,MAAM,aAAa,CAAC;AAIrB,UAAU,mBAAmB;IAC3B,EAAE,EAAE,OAAO,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAkGD,qBAAa,YAAa,YAAW,SAAS;IAC5C,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,EAAE,mBAAmB;IAKxC,OAAO,CAAC,WAAW;IAKZ,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,cAAc,CAAC,QAAQ,CAAC;IAsCzE,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC;IAkBnD,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBvC,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC;IAexC,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBxD,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBnF,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAI1C"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * webrun-files - Cross-platform filesystem API
+ */
+export { FilesApi } from "./files-api.js";
+export { MemFilesApi } from "./impl/mem-files-api.js";
+export { NodeFilesApi } from "./impl/node-files-api.js";
+export type { AppendOptions, BinaryStream, CopyOptions, FileHandle, FileInfo, FileKind, FileRef, IFilesApi, ListOptions, ReadStreamOptions, WriteStreamOptions, } from "./types.js";
+export { collectGenerator, toAsyncIterable, toBinaryAsyncIterable, } from "./utils/collect-stream.js";
+export { normalizePath, resolveFileRef, toPath, } from "./utils/normalize-path.js";
+export { basename, dirname, extname, joinPath } from "./utils/path-utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,YAAY,EACV,aAAa,EACb,YAAY,EACZ,WAAW,EACX,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,SAAS,EACT,WAAW,EACX,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,qBAAqB,GACtB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,aAAa,EACb,cAAc,EACd,MAAM,GACP,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC"}