@zenfs/dom 0.0.3 → 0.0.5

package/dist/backends/FileSystemAccess.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
 import { Cred } from '@zenfs/core/cred.js';
-import { File, FileFlag, PreloadFile } from '@zenfs/core/file.js';
+import { FileFlag, PreloadFile } from '@zenfs/core/file.js';
 import { BaseFileSystem, FileSystemMetadata } from '@zenfs/core/filesystem.js';
 import { Stats } from '@zenfs/core/stats.js';
 import { type BackendOptions } from '@zenfs/core/backends/backend.js';
@@ -15,8 +14,8 @@ declare global {
 interface FileSystemAccessFileSystemOptions {
     handle: FileSystemDirectoryHandle;
 }
-export declare class FileSystemAccessFile extends PreloadFile<FileSystemAccessFileSystem> implements File {
-    constructor(_fs: FileSystemAccessFileSystem, _path: string, _flag: FileFlag, _stat: Stats, contents?: Buffer);
+export declare class FileSystemAccessFile extends PreloadFile<FileSystemAccessFileSystem> {
+    constructor(_fs: FileSystemAccessFileSystem, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
     sync(): Promise<void>;
     close(): Promise<void>;
 }
@@ -28,13 +27,13 @@ export declare class FileSystemAccessFileSystem extends BaseFileSystem {
     private _handles;
     constructor({ handle }: FileSystemAccessFileSystemOptions);
     get metadata(): FileSystemMetadata;
-    _sync(p: string, data: Buffer, stats: Stats, cred: Cred): Promise<void>;
+    _sync(p: string, data: Uint8Array, stats: Stats, cred: Cred): Promise<void>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-    writeFile(fname: string, data: any, encoding: string | null, flag: FileFlag, mode: number, cred: Cred, createFile?: boolean): Promise<void>;
-    createFile(p: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    writeFile(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred, createFile?: boolean): Promise<void>;
+    createFile(p: string, flag: FileFlag, mode: number, cred: Cred): Promise<FileSystemAccessFile>;
     stat(path: string, cred: Cred): Promise<Stats>;
     exists(p: string, cred: Cred): Promise<boolean>;
-    openFile(path: string, flags: FileFlag, cred: Cred): Promise<File>;
+    openFile(path: string, flags: FileFlag, cred: Cred): Promise<FileSystemAccessFile>;
     unlink(path: string, cred: Cred): Promise<void>;
     rmdir(path: string, cred: Cred): Promise<void>;
     mkdir(p: string, mode: any, cred: Cred): Promise<void>;

package/dist/backends/FileSystemAccess.js

@@ -1,19 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 var _a;
 import { basename, dirname, join } from '@zenfs/core/emulation/path.js';
 import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
@@ -22,7 +6,6 @@ import { FileFlag, PreloadFile } from '@zenfs/core/file.js';
 import { BaseFileSystem } from '@zenfs/core/filesystem.js';
 import { Stats, FileType } from '@zenfs/core/stats.js';
 import { CreateBackend } from '@zenfs/core/backends/backend.js';
-import { Buffer } from 'buffer';
 const handleError = (path = '', error) => {
     if (error.name === 'NotFoundError') {
         throw ApiError.ENOENT(path);
@@ -33,18 +16,14 @@ export class FileSystemAccessFile extends PreloadFile {
     constructor(_fs, _path, _flag, _stat, contents) {
         super(_fs, _path, _flag, _stat, contents);
     }
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isDirty()) {
-                yield this._fs._sync(this.getPath(), this.getBuffer(), this.getStats(), Cred.Root);
-                this.resetDirty();
-            }
-        });
+    async sync() {
+        if (this.isDirty()) {
+            await this._fs._sync(this.getPath(), this.getBuffer(), this.getStats(), Cred.Root);
+            this.resetDirty();
+        }
     }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sync();
-        });
+    async close() {
+        await this.sync();
     }
 }
 export class FileSystemAccessFileSystem extends BaseFileSystem {
@@ -57,204 +36,170 @@ export class FileSystemAccessFileSystem extends BaseFileSystem {
         this._handles.set('/', handle);
     }
     get metadata() {
-        return Object.assign(Object.assign({}, super.metadata), { name: _a.Name });
-    }
-    _sync(p, data, stats, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentStats = yield this.stat(p, cred);
-            if (stats.mtime !== currentStats.mtime) {
-                yield this.writeFile(p, data, null, FileFlag.getFileFlag('w'), currentStats.mode, cred);
-            }
-        });
-    }
-    rename(oldPath, newPath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const handle = yield this.getHandle(oldPath);
-                if (handle instanceof FileSystemDirectoryHandle) {
-                    const files = yield this.readdir(oldPath, cred);
-                    yield this.mkdir(newPath, 'wx', cred);
-                    if (files.length === 0) {
-                        yield this.unlink(oldPath, cred);
-                    }
-                    else {
-                        for (const file of files) {
-                            yield this.rename(join(oldPath, file), join(newPath, file), cred);
-                            yield this.unlink(oldPath, cred);
-                        }
-                    }
+        return {
+            ...super.metadata,
+            name: _a.Name,
+        };
+    }
+    async _sync(p, data, stats, cred) {
+        const currentStats = await this.stat(p, cred);
+        if (stats.mtime !== currentStats.mtime) {
+            await this.writeFile(p, data, FileFlag.getFileFlag('w'), currentStats.mode, cred);
+        }
+    }
+    async rename(oldPath, newPath, cred) {
+        try {
+            const handle = await this.getHandle(oldPath);
+            if (handle instanceof FileSystemDirectoryHandle) {
+                const files = await this.readdir(oldPath, cred);
+                await this.mkdir(newPath, 'wx', cred);
+                if (files.length === 0) {
+                    await this.unlink(oldPath, cred);
                 }
-                if (handle instanceof FileSystemFileHandle) {
-                    const oldFile = yield handle.getFile(), destFolder = yield this.getHandle(dirname(newPath));
-                    if (destFolder instanceof FileSystemDirectoryHandle) {
-                        const newFile = yield destFolder.getFileHandle(basename(newPath), { create: true });
-                        const writable = yield newFile.createWritable();
-                        const buffer = yield oldFile.arrayBuffer();
-                        yield writable.write(buffer);
-                        writable.close();
-                        yield this.unlink(oldPath, cred);
+                else {
+                    for (const file of files) {
+                        await this.rename(join(oldPath, file), join(newPath, file), cred);
+                        await this.unlink(oldPath, cred);
                     }
                 }
             }
-            catch (err) {
-                handleError(oldPath, err);
-            }
-        });
-    }
-    writeFile(fname, data, encoding, flag, mode, cred, createFile) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(dirname(fname));
-            if (handle instanceof FileSystemDirectoryHandle) {
-                const file = yield handle.getFileHandle(basename(fname), { create: true });
-                const writable = yield file.createWritable();
-                yield writable.write(data);
-                yield writable.close();
-                //return createFile ? this.newFile(fname, flag, data) : undefined;
-            }
-        });
-    }
-    createFile(p, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.writeFile(p, Buffer.alloc(0), null, flag, mode, cred, true);
-            return this.openFile(p, flag, cred);
-        });
-    }
-    stat(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(path);
-            if (!handle) {
-                throw ApiError.FileError(ErrorCode.EINVAL, path);
-            }
-            if (handle instanceof FileSystemDirectoryHandle) {
-                return new Stats(FileType.DIRECTORY, 4096);
-            }
             if (handle instanceof FileSystemFileHandle) {
-                const { lastModified, size } = yield handle.getFile();
-                return new Stats(FileType.FILE, size, undefined, undefined, lastModified);
+                const oldFile = await handle.getFile(), destFolder = await this.getHandle(dirname(newPath));
+                if (destFolder instanceof FileSystemDirectoryHandle) {
+                    const newFile = await destFolder.getFileHandle(basename(newPath), { create: true });
+                    const writable = await newFile.createWritable();
+                    const buffer = await oldFile.arrayBuffer();
+                    await writable.write(buffer);
+                    writable.close();
+                    await this.unlink(oldPath, cred);
+                }
             }
-        });
-    }
-    exists(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
+        }
+        catch (err) {
+            handleError(oldPath, err);
+        }
+    }
+    async writeFile(fname, data, flag, mode, cred, createFile) {
+        const handle = await this.getHandle(dirname(fname));
+        if (handle instanceof FileSystemDirectoryHandle) {
+            const file = await handle.getFileHandle(basename(fname), { create: true });
+            const writable = await file.createWritable();
+            await writable.write(data);
+            await writable.close();
+            //return createFile ? this.newFile(fname, flag, data) : undefined;
+        }
+    }
+    async createFile(p, flag, mode, cred) {
+        await this.writeFile(p, new Uint8Array(), flag, mode, cred, true);
+        return this.openFile(p, flag, cred);
+    }
+    async stat(path, cred) {
+        const handle = await this.getHandle(path);
+        if (!handle) {
+            throw ApiError.FileError(ErrorCode.EINVAL, path);
+        }
+        if (handle instanceof FileSystemDirectoryHandle) {
+            return new Stats(FileType.DIRECTORY, 4096);
+        }
+        if (handle instanceof FileSystemFileHandle) {
+            const { lastModified, size } = await handle.getFile();
+            return new Stats(FileType.FILE, size, undefined, undefined, lastModified);
+        }
+    }
+    async exists(p, cred) {
+        try {
+            await this.getHandle(p);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async openFile(path, flags, cred) {
+        const handle = await this.getHandle(path);
+        if (handle instanceof FileSystemFileHandle) {
+            const file = await handle.getFile();
+            const buffer = await file.arrayBuffer();
+            return this.newFile(path, flags, buffer, file.size, file.lastModified);
+        }
+    }
+    async unlink(path, cred) {
+        const handle = await this.getHandle(dirname(path));
+        if (handle instanceof FileSystemDirectoryHandle) {
             try {
-                yield this.getHandle(p);
-                return true;
+                await handle.removeEntry(basename(path), { recursive: true });
             }
             catch (e) {
-                return false;
-            }
-        });
-    }
-    openFile(path, flags, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(path);
-            if (handle instanceof FileSystemFileHandle) {
-                const file = yield handle.getFile();
-                const buffer = yield file.arrayBuffer();
-                return this.newFile(path, flags, buffer, file.size, file.lastModified);
-            }
-        });
+                handleError(path, e);
+            }
+        }
+    }
+    async rmdir(path, cred) {
+        return this.unlink(path, cred);
+    }
+    async mkdir(p, mode, cred) {
+        const overwrite = mode && mode.flag && mode.flag.includes('w') && !mode.flag.includes('x');
+        const existingHandle = await this.getHandle(p);
+        if (existingHandle && !overwrite) {
+            throw ApiError.EEXIST(p);
+        }
+        const handle = await this.getHandle(dirname(p));
+        if (handle instanceof FileSystemDirectoryHandle) {
+            await handle.getDirectoryHandle(basename(p), { create: true });
+        }
+    }
+    async readdir(path, cred) {
+        const handle = await this.getHandle(path);
+        if (!(handle instanceof FileSystemDirectoryHandle)) {
+            throw ApiError.ENOTDIR(path);
+        }
+        const _keys = [];
+        for await (const key of handle.keys()) {
+            _keys.push(join(path, key));
+        }
+        return _keys;
     }
-    unlink(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(dirname(path));
-            if (handle instanceof FileSystemDirectoryHandle) {
-                try {
-                    yield handle.removeEntry(basename(path), { recursive: true });
-                }
-                catch (e) {
-                    handleError(path, e);
+    newFile(path, flag, data, size, lastModified) {
+        return new FileSystemAccessFile(this, path, flag, new Stats(FileType.FILE, size || 0, undefined, undefined, lastModified || new Date().getTime()), new Uint8Array(data));
+    }
+    async getHandle(path) {
+        if (this._handles.has(path)) {
+            return this._handles.get(path);
+        }
+        let walkedPath = '/';
+        const [, ...pathParts] = path.split('/');
+        const getHandleParts = async ([pathPart, ...remainingPathParts]) => {
+            const walkingPath = join(walkedPath, pathPart);
+            const continueWalk = (handle) => {
+                walkedPath = walkingPath;
+                this._handles.set(walkedPath, handle);
+                if (remainingPathParts.length === 0) {
+                    return this._handles.get(path);
                 }
-            }
-        });
-    }
-    rmdir(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.unlink(path, cred);
-        });
-    }
-    mkdir(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const overwrite = mode && mode.flag && mode.flag.includes('w') && !mode.flag.includes('x');
-            const existingHandle = yield this.getHandle(p);
-            if (existingHandle && !overwrite) {
-                throw ApiError.EEXIST(p);
-            }
-            const handle = yield this.getHandle(dirname(p));
-            if (handle instanceof FileSystemDirectoryHandle) {
-                yield handle.getDirectoryHandle(basename(p), { create: true });
-            }
-        });
-    }
-    readdir(path, cred) {
-        var _b, e_1, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const handle = yield this.getHandle(path);
-            if (!(handle instanceof FileSystemDirectoryHandle)) {
-                throw ApiError.ENOTDIR(path);
-            }
-            const _keys = [];
+                getHandleParts(remainingPathParts);
+            };
+            const handle = this._handles.get(walkedPath);
             try {
-                for (var _e = true, _f = __asyncValues(handle.keys()), _g; _g = yield _f.next(), _b = _g.done, !_b; _e = true) {
-                    _d = _g.value;
-                    _e = false;
-                    const key = _d;
-                    _keys.push(join(path, key));
-                }
+                return await continueWalk(await handle.getDirectoryHandle(pathPart));
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_e && !_b && (_c = _f.return)) yield _c.call(_f);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            return _keys;
-        });
-    }
-    newFile(path, flag, data, size, lastModified) {
-        return new FileSystemAccessFile(this, path, flag, new Stats(FileType.FILE, size || 0, undefined, undefined, lastModified || new Date().getTime()), Buffer.from(data));
-    }
-    getHandle(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._handles.has(path)) {
-                return this._handles.get(path);
-            }
-            let walkedPath = '/';
-            const [, ...pathParts] = path.split('/');
-            const getHandleParts = ([pathPart, ...remainingPathParts]) => __awaiter(this, void 0, void 0, function* () {
-                const walkingPath = join(walkedPath, pathPart);
-                const continueWalk = (handle) => {
-                    walkedPath = walkingPath;
-                    this._handles.set(walkedPath, handle);
-                    if (remainingPathParts.length === 0) {
-                        return this._handles.get(path);
+            catch (error) {
+                if (error.name === 'TypeMismatchError') {
+                    try {
+                        return await continueWalk(await handle.getFileHandle(pathPart));
                     }
-                    getHandleParts(remainingPathParts);
-                };
-                const handle = this._handles.get(walkedPath);
-                try {
-                    return yield continueWalk(yield handle.getDirectoryHandle(pathPart));
-                }
-                catch (error) {
-                    if (error.name === 'TypeMismatchError') {
-                        try {
-                            return yield continueWalk(yield handle.getFileHandle(pathPart));
-                        }
-                        catch (err) {
-                            handleError(walkingPath, err);
-                        }
-                    }
-                    else if (error.message === 'Name is not allowed.') {
-                        throw new ApiError(ErrorCode.ENOENT, error.message, walkingPath);
-                    }
-                    else {
-                        handleError(walkingPath, error);
+                    catch (err) {
+                        handleError(walkingPath, err);
                     }
                 }
-            });
-            yield getHandleParts(pathParts);
-        });
+                else if (error.message === 'Name is not allowed.') {
+                    throw new ApiError(ErrorCode.ENOENT, error.message, walkingPath);
+                }
+                else {
+                    handleError(walkingPath, error);
+                }
+            }
+        };
+        await getHandleParts(pathParts);
     }
 }
 _a = FileSystemAccessFileSystem;

package/dist/backends/HTTPRequest.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-import { BaseFileSystem, FileContents, FileSystemMetadata } from '@zenfs/core/filesystem.js';
-import { File, FileFlag } from '@zenfs/core/file.js';
+import { BaseFileSystem, FileSystemMetadata } from '@zenfs/core/filesystem.js';
+import { FileFlag, NoSyncFile } from '@zenfs/core/file.js';
 import { Stats } from '@zenfs/core/stats.js';
 import { Cred } from '@zenfs/core/cred.js';
 import { type BackendOptions } from '@zenfs/core/backends/backend.js';
@@ -58,24 +57,22 @@ export declare class HTTPRequest extends BaseFileSystem {
     static isAvailable(): boolean;
     readonly prefixUrl: string;
     private _index;
-    private _requestFileInternal;
-    private _requestFileSizeInternal;
     constructor({ index, baseUrl }: HTTPRequest.Options);
     get metadata(): FileSystemMetadata;
     empty(): void;
     /**
      * Special HTTPFS function: Preload the given file into the index.
-     * @param [String] path
-     * @param [ZenFS.Buffer] buffer
+     * @param path
+     * @param buffer
      */
-    preloadFile(path: string, buffer: Buffer): void;
+    preloadFile(path: string, buffer: Uint8Array): void;
     stat(path: string, cred: Cred): Promise<Stats>;
-    open(path: string, flags: FileFlag, mode: number, cred: Cred): Promise<File>;
+    open(path: string, flags: FileFlag, mode: number, cred: Cred): Promise<NoSyncFile<this>>;
     readdir(path: string, cred: Cred): Promise<string[]>;
     /**
      * We have the entire file as a buffer; optimize readFile.
      */
-    readFile(fname: string, encoding: BufferEncoding, flag: FileFlag, cred: Cred): Promise<FileContents>;
+    readFile(fname: string, flag: FileFlag, cred: Cred): Promise<Uint8Array>;
     private _getHTTPPath;
     /**
      * Asynchronously download the given file.