@wener/common 2.0.5 → 2.0.6

package/lib/fs/createSandboxFileSystem.js

@@ -1,108 +1,109 @@
-import { join, normalize, relative, sep } from "pathe";
-import { getPath } from "./utils";
+import { join, normalize, relative, sep } from 'pathe';
+import { getPath } from './utils';
+
 let SandboxSecurityError = class SandboxSecurityError extends Error {
-    constructor(message){
-        super(message);
-        this.name = 'SandboxSecurityError';
-    }
+	constructor(message) {
+		super(message);
+		this.name = 'SandboxSecurityError';
+	}
 };
 export function createSandboxFileSystem(fs, basePath) {
-    return new SandboxFS(fs, basePath);
+	return new SandboxFS(fs, basePath);
 }
 let SandboxFS = class SandboxFS {
-    fs;
-    basePath;
-    constructor(fs, basePath){
-        this.fs = fs;
-        this.basePath = normalize(basePath);
-    }
-    _resolvePath(userPath) {
-        const fullPath = join(this.basePath, userPath);
-        const normalizedFullPath = normalize(fullPath);
-        const rel = relative(this.basePath, normalizedFullPath);
-        if (rel.startsWith('..') || rel === '..') {
-            throw new SandboxSecurityError(`Path traversal attempt detected: ${userPath}`);
-        }
-        return normalizedFullPath;
-    }
-    _stripPath(fullPath) {
-        const relPath = relative(this.basePath, fullPath);
-        // 保证返回的是一个以 '/' 开头的绝对路径（在沙箱内）
-        return sep + relPath.split(sep).join('/');
-    }
-    _processStat(stat) {
-        stat.path = this._stripPath(stat.path);
-        stat.directory = this._stripPath(stat.directory);
-        return stat;
-    }
-    async stat(path, options) {
-        const fullPath = this._resolvePath(path);
-        const result = await this.fs.stat(fullPath, options);
-        return this._processStat(result);
-    }
-    async readdir(dir, options) {
-        const fullPath = this._resolvePath(dir);
-        const results = await this.fs.readdir(fullPath, options);
-        return results.map((stat)=>this._processStat(stat));
-    }
-    async exists(path) {
-        try {
-            const fullPath = this._resolvePath(path);
-            return await this.fs.exists(fullPath);
-        } catch (e) {
-            if (e instanceof SandboxSecurityError) {
-                return false; // 越界访问视为不存在
-            }
-            throw e;
-        }
-    }
-    mkdir(path, options) {
-        const fullPath = this._resolvePath(path);
-        return this.fs.mkdir(fullPath, options);
-    }
-    readFile(path, options) {
-        const fullPath = this._resolvePath(path);
-        return this.fs.readFile(fullPath, options);
-    }
-    writeFile(path, data, options) {
-        const fullPath = this._resolvePath(path);
-        return this.fs.writeFile(fullPath, data, options);
-    }
-    rm(path, options) {
-        const fullPath = this._resolvePath(path);
-        return this.fs.rm(fullPath, options);
-    }
-    rename(oldPath, newPath, options) {
-        const fullOldPath = this._resolvePath(oldPath);
-        const fullNewPath = this._resolvePath(newPath);
-        return this.fs.rename(fullOldPath, fullNewPath, options);
-    }
-    copy(src, dest, options) {
-        const fullSrc = this._resolvePath(src);
-        const fullDest = this._resolvePath(dest);
-        return this.fs.copy(fullSrc, fullDest, options);
-    }
-    createReadStream(path, options) {
-        const fullPath = this._resolvePath(path);
-        if (!this.fs.createReadStream) {
-            throw new Error('Underlying filesystem does not support createReadStream');
-        }
-        return this.fs.createReadStream(fullPath, options);
-    }
-    createWriteStream(path, options) {
-        const fullPath = this._resolvePath(path);
-        if (!this.fs.createWriteStream) {
-            throw new Error('Underlying filesystem does not support createWriteStream');
-        }
-        return this.fs.createWriteStream(fullPath, options);
-    }
-    getUrl(file, options) {
-        let path = this._resolvePath(getPath(file.path));
-        if (this.fs.getUrl) {
-            return this.fs.getUrl(path, options);
-        }
-        return;
-    }
+	fs;
+	basePath;
+	constructor(fs, basePath) {
+		this.fs = fs;
+		this.basePath = normalize(basePath);
+	}
+	_resolvePath(userPath) {
+		const fullPath = join(this.basePath, userPath);
+		const normalizedFullPath = normalize(fullPath);
+		const rel = relative(this.basePath, normalizedFullPath);
+		if (rel.startsWith('..') || rel === '..') {
+			throw new SandboxSecurityError(`Path traversal attempt detected: ${userPath}`);
+		}
+		return normalizedFullPath;
+	}
+	_stripPath(fullPath) {
+		const relPath = relative(this.basePath, fullPath);
+		// 保证返回的是一个以 '/' 开头的绝对路径（在沙箱内）
+		return sep + relPath.split(sep).join('/');
+	}
+	_processStat(stat) {
+		stat.path = this._stripPath(stat.path);
+		stat.directory = this._stripPath(stat.directory);
+		return stat;
+	}
+	async stat(path, options) {
+		const fullPath = this._resolvePath(path);
+		const result = await this.fs.stat(fullPath, options);
+		return this._processStat(result);
+	}
+	async readdir(dir, options) {
+		const fullPath = this._resolvePath(dir);
+		const results = await this.fs.readdir(fullPath, options);
+		return results.map((stat) => this._processStat(stat));
+	}
+	async exists(path) {
+		try {
+			const fullPath = this._resolvePath(path);
+			return await this.fs.exists(fullPath);
+		} catch (e) {
+			if (e instanceof SandboxSecurityError) {
+				return false; // 越界访问视为不存在
+			}
+			throw e;
+		}
+	}
+	mkdir(path, options) {
+		const fullPath = this._resolvePath(path);
+		return this.fs.mkdir(fullPath, options);
+	}
+	readFile(path, options) {
+		const fullPath = this._resolvePath(path);
+		return this.fs.readFile(fullPath, options);
+	}
+	writeFile(path, data, options) {
+		const fullPath = this._resolvePath(path);
+		return this.fs.writeFile(fullPath, data, options);
+	}
+	rm(path, options) {
+		const fullPath = this._resolvePath(path);
+		return this.fs.rm(fullPath, options);
+	}
+	rename(oldPath, newPath, options) {
+		const fullOldPath = this._resolvePath(oldPath);
+		const fullNewPath = this._resolvePath(newPath);
+		return this.fs.rename(fullOldPath, fullNewPath, options);
+	}
+	copy(src, dest, options) {
+		const fullSrc = this._resolvePath(src);
+		const fullDest = this._resolvePath(dest);
+		return this.fs.copy(fullSrc, fullDest, options);
+	}
+	createReadStream(path, options) {
+		const fullPath = this._resolvePath(path);
+		if (!this.fs.createReadStream) {
+			throw new Error('Underlying filesystem does not support createReadStream');
+		}
+		return this.fs.createReadStream(fullPath, options);
+	}
+	createWriteStream(path, options) {
+		const fullPath = this._resolvePath(path);
+		if (!this.fs.createWriteStream) {
+			throw new Error('Underlying filesystem does not support createWriteStream');
+		}
+		return this.fs.createWriteStream(fullPath, options);
+	}
+	getUrl(file, options) {
+		let path = this._resolvePath(getPath(file.path));
+		if (this.fs.getUrl) {
+			return this.fs.getUrl(path, options);
+		}
+		return;
+	}
 };
 
-//# sourceMappingURL=createSandboxFileSystem.js.map
+//# sourceMappingURL=createSandboxFileSystem.js.map

package/lib/fs/createWebDavFileSystem.js

@@ -1,154 +1,167 @@
-import { maybeFunction } from "@wener/utils";
+import { maybeFunction } from '@wener/utils';
 export function createWebDavFileSystem({ client }) {
-    let fs = new WebdavFS({
-        client
-    });
-    return fs;
+	let fs = new WebdavFS({
+		client,
+	});
+	return fs;
 }
 let WebdavFS = class WebdavFS {
-    _client;
-    constructor({ client = ()=>{
-        throw new Error('WebdavFS client not initialized');
-    } }){
-        this._client = client;
-    }
-    set client(client) {
-        this._client = client;
-    }
-    get client() {
-        return maybeFunction(this._client);
-    }
-    toEntry(input) {
-        const { filename: path, basename, lastmod, type: kind, etag, size, mime } = input;
-        let meta = {};
-        if (etag) {
-            meta.etag = etag;
-        }
-        if (mime) {
-            meta.mime = mime;
-        }
-        return {
-            directory: path.substring(0, path.lastIndexOf('/')) || '/',
-            path,
-            name: basename,
-            mtime: +new Date(lastmod),
-            kind,
-            meta,
-            size
-        };
-    }
-    getData(input) {
-        if (input && typeof input === 'object' && 'data' in input && // 'headers' in input &&
-        'status' in input && typeof input.status === 'number') {
-            return input.data;
-        }
-        return input;
-    }
-    async readdir(path, { glob, recursive, depth, kind, hidden, signal } = {}) {
-        // webdav depth 只支持 0,1
-        let o = {};
-        if (recursive) {
-            o.deep = true;
-        }
-        let res = await this.client.getDirectoryContents(path, {
-            deep: recursive,
-            signal
-        });
-        let out = this.getData(res);
-        if (!recursive && typeof depth === 'number' && depth >= 2) {
-            let l = depth;
-            let cur = out;
-            while(l-- > 1){
-                let sub = (await Promise.all(cur.map(async (v)=>{
-                    if (v.type === 'directory') {
-                        return this.getData(await this.client.getDirectoryContents(v.filename, {
-                            signal
-                        }));
-                    }
-                    return [];
-                }))).flat();
-                out = out.concat(...sub);
-                cur = sub;
-            }
-        }
-        if (glob) {
-            const { default: def, matcher = def.matcher } = await import("micromatch");
-            const match = matcher(glob);
-            out = out.filter((v)=>match(v.filename));
-        }
-        if (kind) {
-            out = out.filter((v)=>v.type === kind);
-        }
-        if (!hidden) {
-            out = out.filter((v)=>!v.basename.startsWith('.'));
-        }
-        return out.map((stat)=>this.toEntry(stat));
-    }
-    async stat(path, { signal } = {}) {
-        const res = await this.client.stat(path, {
-            details: true,
-            signal
-        });
-        return this.toEntry(this.getData(res));
-    }
-    async mkdir(path, { recursive, signal } = {}) {
-        await this.client.createDirectory(path, {
-            recursive,
-            signal
-        });
-    }
-    async readFile(path, options = {}) {
-        const format = options.encoding === 'text' ? 'text' : 'binary';
-        const res = await this.client.getFileContents(path, {
-            format,
-            ...options
-        });
-        return this.getData(res);
-    }
-    async writeFile(path, data, options = {}) {
-        // Convert web ReadableStream to something WebDAV client can handle
-        let webdavData = data;
-        if (data instanceof ReadableStream) {
-            // Convert web ReadableStream to Buffer
-            const reader = data.getReader();
-            const chunks = [];
-            while(true){
-                const { done, value } = await reader.read();
-                if (done) break;
-                if (value) chunks.push(value);
-            }
-            webdavData = Buffer.concat(chunks);
-        } else if (ArrayBuffer.isView(data) && !(data instanceof Buffer)) {
-            // Convert ArrayBufferView to Buffer
-            webdavData = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-        }
-        await this.client.putFileContents(path, webdavData, options);
-    }
-    async rm(path, { signal: _signal, force, recursive: _recursive } = {}) {
-        try {
-            await this.client.deleteFile(path);
-        } catch (e) {
-            if (force && e.status === 404) {
-                return;
-            }
-            throw e;
-        }
-    }
-    async rename(oldPath, newPath, options = {}) {
-        await this.client.moveFile(oldPath, newPath, options);
-    }
-    async exists(path) {
-        return await this.client.exists(path);
-    }
-    async copy(src, dest, options = {}) {
-        await this.client.copyFile(src, dest, options);
-    }
-    createReadStream(path, options = {}) {
-        return this.client.createReadStream(path, options);
-    }
-    createWriteStream(path, options = {}) {
-        return this.client.createWriteStream(path, options);
-    }
+	_client;
+	constructor({
+		client = () => {
+			throw new Error('WebdavFS client not initialized');
+		},
+	}) {
+		this._client = client;
+	}
+	set client(client) {
+		this._client = client;
+	}
+	get client() {
+		return maybeFunction(this._client);
+	}
+	toEntry(input) {
+		const { filename: path, basename, lastmod, type: kind, etag, size, mime } = input;
+		let meta = {};
+		if (etag) {
+			meta.etag = etag;
+		}
+		if (mime) {
+			meta.mime = mime;
+		}
+		return {
+			directory: path.substring(0, path.lastIndexOf('/')) || '/',
+			path,
+			name: basename,
+			mtime: +new Date(lastmod),
+			kind,
+			meta,
+			size,
+		};
+	}
+	getData(input) {
+		if (
+			input &&
+			typeof input === 'object' &&
+			'data' in input && // 'headers' in input &&
+			'status' in input &&
+			typeof input.status === 'number'
+		) {
+			return input.data;
+		}
+		return input;
+	}
+	async readdir(path, { glob, recursive, depth, kind, hidden, signal } = {}) {
+		// webdav depth 只支持 0,1
+		let o = {};
+		if (recursive) {
+			o.deep = true;
+		}
+		let res = await this.client.getDirectoryContents(path, {
+			deep: recursive,
+			signal,
+		});
+		let out = this.getData(res);
+		if (!recursive && typeof depth === 'number' && depth >= 2) {
+			let l = depth;
+			let cur = out;
+			while (l-- > 1) {
+				let sub = (
+					await Promise.all(
+						cur.map(async (v) => {
+							if (v.type === 'directory') {
+								return this.getData(
+									await this.client.getDirectoryContents(v.filename, {
+										signal,
+									}),
+								);
+							}
+							return [];
+						}),
+					)
+				).flat();
+				out = out.concat(...sub);
+				cur = sub;
+			}
+		}
+		if (glob) {
+			const { default: def, matcher = def.matcher } = await import('micromatch');
+			const match = matcher(glob);
+			out = out.filter((v) => match(v.filename));
+		}
+		if (kind) {
+			out = out.filter((v) => v.type === kind);
+		}
+		if (!hidden) {
+			out = out.filter((v) => !v.basename.startsWith('.'));
+		}
+		return out.map((stat) => this.toEntry(stat));
+	}
+	async stat(path, { signal } = {}) {
+		const res = await this.client.stat(path, {
+			details: true,
+			signal,
+		});
+		return this.toEntry(this.getData(res));
+	}
+	async mkdir(path, { recursive, signal } = {}) {
+		await this.client.createDirectory(path, {
+			recursive,
+			signal,
+		});
+	}
+	async readFile(path, options = {}) {
+		const format = options.encoding === 'text' ? 'text' : 'binary';
+		const res = await this.client.getFileContents(path, {
+			format,
+			...options,
+		});
+		return this.getData(res);
+	}
+	async writeFile(path, data, options = {}) {
+		// Convert web ReadableStream to something WebDAV client can handle
+		let webdavData = data;
+		if (data instanceof ReadableStream) {
+			// Convert web ReadableStream to Buffer
+			const reader = data.getReader();
+			const chunks = [];
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				if (value) chunks.push(value);
+			}
+			webdavData = Buffer.concat(chunks);
+		} else if (ArrayBuffer.isView(data) && !(data instanceof Buffer)) {
+			// Convert ArrayBufferView to Buffer
+			webdavData = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+		}
+		await this.client.putFileContents(path, webdavData, options);
+	}
+	async rm(path, { signal: _signal, force, recursive: _recursive } = {}) {
+		try {
+			await this.client.deleteFile(path);
+		} catch (e) {
+			if (force && e.status === 404) {
+				return;
+			}
+			throw e;
+		}
+	}
+	async rename(oldPath, newPath, options = {}) {
+		await this.client.moveFile(oldPath, newPath, options);
+	}
+	async exists(path) {
+		return await this.client.exists(path);
+	}
+	async copy(src, dest, options = {}) {
+		await this.client.copyFile(src, dest, options);
+	}
+	createReadStream(path, options = {}) {
+		return this.client.createReadStream(path, options);
+	}
+	createWriteStream(path, options = {}) {
+		return this.client.createWriteStream(path, options);
+	}
 };
 
-//# sourceMappingURL=createWebDavFileSystem.js.map
+//# sourceMappingURL=createWebDavFileSystem.js.map