@wener/common 2.0.5 → 2.0.6

package/lib/fs/createWebFileSystem.js

@@ -1,225 +1,202 @@
-import { basename, dirname, join, normalize } from "pathe";
-import { FileSystemError } from "./FileSystemError.js";
+import { basename, dirname, join, normalize } from 'pathe';
+import { FileSystemError } from './FileSystemError.js';
 export function createWebFileSystem(options) {
-    return new WebFileSystem(options);
+	return new WebFileSystem(options);
 }
 let WebFileSystem = class WebFileSystem {
-    root;
-    constructor({ root }) {
-        this.root = root;
-    }
-    async _getHandle(path) {
-        const parts = normalize(path).split("/").filter(Boolean);
-        if (parts.length === 0)
-            return this.root;
-        let current = this.root;
-        for (let i = 0; i < parts.length; i++) {
-            const part = parts[i];
-            const isLast = i === parts.length - 1;
-            try {
-                // Try to get as directory first
-                current = await current.getDirectoryHandle(part);
-            }
-            catch (e) {
-                if (e.name === "TypeMismatchError" || e.name === "NotFoundError") {
-                    if (isLast) {
-                        // Might be a file
-                        try {
-                            return await current.getFileHandle(part);
-                        }
-                        catch (_e2) {
-                            throw new FileSystemError(`File not found: ${path}`, "ENOENT");
-                        }
-                    }
-                }
-                if (e.name === "NotFoundError") {
-                    throw new FileSystemError(`Path not found: ${path}`, "ENOENT");
-                }
-                throw e;
-            }
-        }
-        return current;
-    }
-    async _getParent(path) {
-        const normalized = normalize(path);
-        const parentPath = dirname(normalized);
-        const name = basename(normalized);
-        if (!name)
-            throw new FileSystemError("Invalid path", "EINVAL");
-        const parentHandle = await this._getHandle(parentPath);
-        if (parentHandle.kind !== "directory") {
-            throw new FileSystemError(`Parent is not a directory: ${parentPath}`, "ENOTDIR");
-        }
-        return {
-            parent: parentHandle,
-            name
-        };
-    }
-    async stat(path, options) {
-        if (options?.signal?.aborted)
-            throw new FileSystemError("Operation aborted", "ABORT_ERR");
-        const handle = await this._getHandle(path);
-        return this._handleToStat(handle, path);
-    }
-    async _handleToStat(handle, path) {
-        let size = 0;
-        let mtime = 0;
-        if (handle.kind === "file") {
-            const file = await handle.getFile();
-            size = file.size;
-            mtime = file.lastModified;
-        }
-        return {
-            path,
-            directory: dirname(path),
-            name: handle.name,
-            kind: handle.kind,
-            size,
-            mtime,
-            meta: {}
-        };
-    }
-    async exists(path) {
-        try {
-            await this._getHandle(path);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async readdir(path, options) {
-        if (options?.signal?.aborted)
-            throw new FileSystemError("Operation aborted", "ABORT_ERR");
-        const handle = await this._getHandle(path);
-        if (handle.kind !== "directory") {
-            throw new FileSystemError(`Not a directory: ${path}`, "ENOTDIR");
-        }
-        const entries = [];
-        // @ts-expect-error - FileSystemDirectoryHandle is async iterable in modern browsers
-        for await (const entry of handle.values()) {
-            entries.push(await this._handleToStat(entry, join(path, entry.name)));
-        }
-        return entries;
-    }
-    async mkdir(path, options) {
-        if (options?.signal?.aborted)
-            throw new FileSystemError("Operation aborted", "ABORT_ERR");
-        const normalized = normalize(path);
-        const parts = normalized.split("/").filter(Boolean);
-        let current = this.root;
-        if (options?.recursive) {
-            for (const part of parts) {
-                current = await current.getDirectoryHandle(part, {
-                    create: true
-                });
-            }
-        }
-        else {
-            const parentPath = dirname(normalized);
-            const name = basename(normalized);
-            try {
-                const parent = await this._getHandle(parentPath);
-                if (parent.kind !== "directory")
-                    throw new FileSystemError(`Parent not a directory: ${parentPath}`, "ENOTDIR");
-                await parent.getDirectoryHandle(name, {
-                    create: true
-                });
-            }
-            catch (e) {
-                if (e.code === "ENOENT" || e.name === "NotFoundError") {
-                    throw new FileSystemError(`Parent does not exist: ${parentPath}`, "ENOENT");
-                }
-                throw e;
-            }
-        }
-    }
-    async readFile(path, options) {
-        if (options?.signal?.aborted)
-            throw new FileSystemError("Operation aborted", "ABORT_ERR");
-        const handle = await this._getHandle(path);
-        if (handle.kind !== "file")
-            throw new FileSystemError(`Is a directory: ${path}`, "EISDIR");
-        const file = await handle.getFile();
-        if (options?.encoding === "text") {
-            return await file.text();
-        }
-        else {
-            const buffer = await file.arrayBuffer();
-            return new Uint8Array(buffer);
-        }
-    }
-    async writeFile(path, data, options) {
-        if (options?.signal?.aborted)
-            throw new FileSystemError("Operation aborted", "ABORT_ERR");
-        if (options?.overwrite === false) {
-            if (await this.exists(path)) {
-                throw new FileSystemError(`File already exists: ${path}`, "EEXIST");
-            }
-        }
-        const { parent, name } = await this._getParent(path);
-        const handle = await parent.getFileHandle(name, {
-            create: true
-        });
-        const writable = await handle.createWritable();
-        await writable.write(data);
-        await writable.close();
-    }
-    async rm(path, options) {
-        if (options?.signal?.aborted)
-            throw new FileSystemError("Operation aborted", "ABORT_ERR");
-        const { parent, name } = await this._getParent(path);
-        try {
-            await parent.removeEntry(name, {
-                recursive: options?.recursive
-            });
-        }
-        catch (e) {
-            if (e.name === "NotFoundError") {
-                if (!options?.force)
-                    throw new FileSystemError(`File not found: ${path}`, "ENOENT");
-            }
-            else if (e.name === "InvalidModificationError") {
-                throw new FileSystemError(`Directory not empty: ${path}`, "ENOTEMPTY");
-            }
-            else {
-                throw e;
-            }
-        }
-    }
-    async rename(oldPath, newPath, options) {
-        if (options?.signal?.aborted)
-            throw new FileSystemError("Operation aborted", "ABORT_ERR");
-        // File System Access API doesn't support move/rename directly
-        // Fallback to copy + delete
-        await this.copy(oldPath, newPath, {
-            overwrite: options?.overwrite
-        });
-        await this.rm(oldPath, {
-            recursive: true
-        });
-    }
-    async copy(src, dest, options) {
-        if (options?.signal?.aborted)
-            throw new FileSystemError("Operation aborted", "ABORT_ERR");
-        const srcHandle = await this._getHandle(src);
-        if (srcHandle.kind === "file") {
-            const file = await srcHandle.getFile();
-            await this.writeFile(dest, await file.arrayBuffer(), {
-                overwrite: options?.overwrite
-            });
-        }
-        else {
-            // Directory copy
-            await this.mkdir(dest);
-            const entries = await this.readdir(src);
-            for (const entry of entries) {
-                await this.copy(entry.path, join(dest, entry.name), options);
-            }
-        }
-    }
-    getUrl(_file) {
-        return undefined;
-    }
+	root;
+	constructor({ root }) {
+		this.root = root;
+	}
+	async _getHandle(path) {
+		const parts = normalize(path).split('/').filter(Boolean);
+		if (parts.length === 0) return this.root;
+		let current = this.root;
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			const isLast = i === parts.length - 1;
+			try {
+				// Try to get as directory first
+				current = await current.getDirectoryHandle(part);
+			} catch (e) {
+				if (e.name === 'TypeMismatchError' || e.name === 'NotFoundError') {
+					if (isLast) {
+						// Might be a file
+						try {
+							return await current.getFileHandle(part);
+						} catch (_e2) {
+							throw new FileSystemError(`File not found: ${path}`, 'ENOENT');
+						}
+					}
+				}
+				if (e.name === 'NotFoundError') {
+					throw new FileSystemError(`Path not found: ${path}`, 'ENOENT');
+				}
+				throw e;
+			}
+		}
+		return current;
+	}
+	async _getParent(path) {
+		const normalized = normalize(path);
+		const parentPath = dirname(normalized);
+		const name = basename(normalized);
+		if (!name) throw new FileSystemError('Invalid path', 'EINVAL');
+		const parentHandle = await this._getHandle(parentPath);
+		if (parentHandle.kind !== 'directory') {
+			throw new FileSystemError(`Parent is not a directory: ${parentPath}`, 'ENOTDIR');
+		}
+		return {
+			parent: parentHandle,
+			name,
+		};
+	}
+	async stat(path, options) {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+		const handle = await this._getHandle(path);
+		return this._handleToStat(handle, path);
+	}
+	async _handleToStat(handle, path) {
+		let size = 0;
+		let mtime = 0;
+		if (handle.kind === 'file') {
+			const file = await handle.getFile();
+			size = file.size;
+			mtime = file.lastModified;
+		}
+		return {
+			path,
+			directory: dirname(path),
+			name: handle.name,
+			kind: handle.kind,
+			size,
+			mtime,
+			meta: {},
+		};
+	}
+	async exists(path) {
+		try {
+			await this._getHandle(path);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async readdir(path, options) {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+		const handle = await this._getHandle(path);
+		if (handle.kind !== 'directory') {
+			throw new FileSystemError(`Not a directory: ${path}`, 'ENOTDIR');
+		}
+		const entries = [];
+		// @ts-expect-error - FileSystemDirectoryHandle is async iterable in modern browsers
+		for await (const entry of handle.values()) {
+			entries.push(await this._handleToStat(entry, join(path, entry.name)));
+		}
+		return entries;
+	}
+	async mkdir(path, options) {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+		const normalized = normalize(path);
+		const parts = normalized.split('/').filter(Boolean);
+		let current = this.root;
+		if (options?.recursive) {
+			for (const part of parts) {
+				current = await current.getDirectoryHandle(part, {
+					create: true,
+				});
+			}
+		} else {
+			const parentPath = dirname(normalized);
+			const name = basename(normalized);
+			try {
+				const parent = await this._getHandle(parentPath);
+				if (parent.kind !== 'directory') throw new FileSystemError(`Parent not a directory: ${parentPath}`, 'ENOTDIR');
+				await parent.getDirectoryHandle(name, {
+					create: true,
+				});
+			} catch (e) {
+				if (e.code === 'ENOENT' || e.name === 'NotFoundError') {
+					throw new FileSystemError(`Parent does not exist: ${parentPath}`, 'ENOENT');
+				}
+				throw e;
+			}
+		}
+	}
+	async readFile(path, options) {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+		const handle = await this._getHandle(path);
+		if (handle.kind !== 'file') throw new FileSystemError(`Is a directory: ${path}`, 'EISDIR');
+		const file = await handle.getFile();
+		if (options?.encoding === 'text') {
+			return await file.text();
+		} else {
+			const buffer = await file.arrayBuffer();
+			return new Uint8Array(buffer);
+		}
+	}
+	async writeFile(path, data, options) {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+		if (options?.overwrite === false) {
+			if (await this.exists(path)) {
+				throw new FileSystemError(`File already exists: ${path}`, 'EEXIST');
+			}
+		}
+		const { parent, name } = await this._getParent(path);
+		const handle = await parent.getFileHandle(name, {
+			create: true,
+		});
+		const writable = await handle.createWritable();
+		await writable.write(data);
+		await writable.close();
+	}
+	async rm(path, options) {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+		const { parent, name } = await this._getParent(path);
+		try {
+			await parent.removeEntry(name, {
+				recursive: options?.recursive,
+			});
+		} catch (e) {
+			if (e.name === 'NotFoundError') {
+				if (!options?.force) throw new FileSystemError(`File not found: ${path}`, 'ENOENT');
+			} else if (e.name === 'InvalidModificationError') {
+				throw new FileSystemError(`Directory not empty: ${path}`, 'ENOTEMPTY');
+			} else {
+				throw e;
+			}
+		}
+	}
+	async rename(oldPath, newPath, options) {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+		// File System Access API doesn't support move/rename directly
+		// Fallback to copy + delete
+		await this.copy(oldPath, newPath, {
+			overwrite: options?.overwrite,
+		});
+		await this.rm(oldPath, {
+			recursive: true,
+		});
+	}
+	async copy(src, dest, options) {
+		if (options?.signal?.aborted) throw new FileSystemError('Operation aborted', 'ABORT_ERR');
+		const srcHandle = await this._getHandle(src);
+		if (srcHandle.kind === 'file') {
+			const file = await srcHandle.getFile();
+			await this.writeFile(dest, await file.arrayBuffer(), {
+				overwrite: options?.overwrite,
+			});
+		} else {
+			// Directory copy
+			await this.mkdir(dest);
+			const entries = await this.readdir(src);
+			for (const entry of entries) {
+				await this.copy(entry.path, join(dest, entry.name), options);
+			}
+		}
+	}
+	getUrl(_file) {
+		return undefined;
+	}
 };
 //# sourceMappingURL=createWebFileSystem.js.map

package/lib/fs/findMimeType.js

@@ -1,17 +1,17 @@
-import { types } from "mime-types";
-import pathe from "pathe";
+import { types } from 'mime-types';
+import pathe from 'pathe';
 export function findMimeType(path) {
-    // fix extname error
-    // https://github.com/jshttp/mime-types/issues/111
-    if (!path || typeof path !== 'string') {
-        return false;
-    }
-    // get the extension ("ext" or ".ext" or full path)
-    const extension = pathe.extname(`x.${path}`).toLowerCase().slice(1);
-    if (!extension) {
-        return false;
-    }
-    return types[extension] || false;
+	// fix extname error
+	// https://github.com/jshttp/mime-types/issues/111
+	if (!path || typeof path !== 'string') {
+		return false;
+	}
+	// get the extension ("ext" or ".ext" or full path)
+	const extension = pathe.extname(`x.${path}`).toLowerCase().slice(1);
+	if (!extension) {
+		return false;
+	}
+	return types[extension] || false;
 }
 
-//# sourceMappingURL=findMimeType.js.map
+//# sourceMappingURL=findMimeType.js.map

package/lib/fs/index.js

@@ -1,8 +1,8 @@
-export { createSandboxFileSystem } from "./createSandboxFileSystem.js";
-export { createMemoryFileSystem } from "./createMemoryFileSystem.js";
-export { createBrowserFileSystem } from "./createBrowserFileSystem.js";
-export { createWebFileSystem } from "./createWebFileSystem.js";
-export { findMimeType } from "./findMimeType.js";
-export { FileUrlOptionsSchema } from "./types.js";
-export { FileSystemError, FileSystemErrorCode } from "./FileSystemError.js";
+export { createBrowserFileSystem } from './createBrowserFileSystem.js';
+export { createMemoryFileSystem } from './createMemoryFileSystem.js';
+export { createSandboxFileSystem } from './createSandboxFileSystem.js';
+export { createWebFileSystem } from './createWebFileSystem.js';
+export { FileSystemError, FileSystemErrorCode } from './FileSystemError.js';
+export { findMimeType } from './findMimeType.js';
+export { FileUrlOptionsSchema } from './types.js';
 //# sourceMappingURL=index.js.map