@zenfs/dom 0.0.3 → 0.0.5

package/dist/backends/HTTPRequest.js

@@ -1,12 +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 _a;
 import { BaseFileSystem } from '@zenfs/core/filesystem.js';
 import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
@@ -16,7 +7,6 @@ import { fetchIsAvailable, fetchFile, fetchFileSize } from '../fetch.js';
 import { FileIndex, isIndexFileInode, isIndexDirInode } from '@zenfs/core/FileIndex.js';
 import { CreateBackend } from '@zenfs/core/backends/backend.js';
 import { R_OK } from '@zenfs/core/emulation/constants.js';
-import { Buffer } from 'buffer';
 /**
  * A simple filesystem backed by HTTP downloads. You must create a directory listing using the
  * `make_http_index` tool provided by ZenFS.
@@ -64,11 +54,13 @@ export class HTTPRequest extends BaseFileSystem {
             baseUrl = baseUrl + '/';
         }
         this.prefixUrl = baseUrl;
-        this._requestFileInternal = fetchFile;
-        this._requestFileSizeInternal = fetchFileSize;
     }
     get metadata() {
-        return Object.assign(Object.assign({}, super.metadata), { name: _a.Name, readonly: true });
+        return {
+            ...super.metadata,
+            name: _a.Name,
+            readonly: true,
+        };
     }
     empty() {
         this._index.fileIterator(function (file) {
@@ -77,8 +69,8 @@ export class HTTPRequest extends BaseFileSystem {
     }
     /**
      * Special HTTPFS function: Preload the given file into the index.
-     * @param [String] path
-     * @param [ZenFS.Buffer] buffer
+     * @param path
+     * @param buffer
      */
     preloadFile(path, buffer) {
         const inode = this._index.getInode(path);
@@ -94,101 +86,88 @@ export class HTTPRequest extends BaseFileSystem {
             throw ApiError.EISDIR(path);
         }
     }
-    stat(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inode = this._index.getInode(path);
-            if (inode === null) {
-                throw ApiError.ENOENT(path);
-            }
-            if (!inode.toStats().hasAccess(R_OK, cred)) {
-                throw ApiError.EACCES(path);
-            }
-            let stats;
-            if (isIndexFileInode(inode)) {
-                stats = inode.getData();
-                // At this point, a non-opened file will still have default stats from the listing.
-                if (stats.size < 0) {
-                    stats.size = yield this._requestFileSize(path);
-                }
-            }
-            else if (isIndexDirInode(inode)) {
-                stats = inode.getStats();
-            }
-            else {
-                throw ApiError.FileError(ErrorCode.EINVAL, path);
+    async stat(path, cred) {
+        const inode = this._index.getInode(path);
+        if (inode === null) {
+            throw ApiError.ENOENT(path);
+        }
+        if (!inode.toStats().hasAccess(R_OK, cred)) {
+            throw ApiError.EACCES(path);
+        }
+        let stats;
+        if (isIndexFileInode(inode)) {
+            stats = inode.getData();
+            // At this point, a non-opened file will still have default stats from the listing.
+            if (stats.size < 0) {
+                stats.size = await this._requestFileSize(path);
             }
-            return stats;
-        });
+        }
+        else if (isIndexDirInode(inode)) {
+            stats = inode.getStats();
+        }
+        else {
+            throw ApiError.FileError(ErrorCode.EINVAL, path);
+        }
+        return stats;
     }
-    open(path, flags, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // INVARIANT: You can't write to files on this file system.
-            if (flags.isWriteable()) {
-                throw new ApiError(ErrorCode.EPERM, path);
-            }
-            // Check if the path exists, and is a file.
-            const inode = this._index.getInode(path);
-            if (inode === null) {
-                throw ApiError.ENOENT(path);
-            }
-            if (!inode.toStats().hasAccess(flags.getMode(), cred)) {
-                throw ApiError.EACCES(path);
-            }
-            if (isIndexFileInode(inode) || isIndexDirInode(inode)) {
-                switch (flags.pathExistsAction()) {
-                    case ActionType.THROW_EXCEPTION:
-                    case ActionType.TRUNCATE_FILE:
-                        throw ApiError.EEXIST(path);
-                    case ActionType.NOP:
-                        if (isIndexDirInode(inode)) {
-                            const stats = inode.getStats();
-                            return new NoSyncFile(this, path, flags, stats, stats.fileData || undefined);
-                        }
-                        const stats = inode.getData();
-                        // Use existing file contents.
-                        // XXX: Uh, this maintains the previously-used flag.
-                        if (stats.fileData) {
-                            return new NoSyncFile(this, path, flags, Stats.clone(stats), stats.fileData);
-                        }
-                        // @todo be lazier about actually requesting the file
-                        const buffer = yield this._requestFile(path, 'buffer');
-                        // we don't initially have file sizes
-                        stats.size = buffer.length;
-                        stats.fileData = buffer;
-                        return new NoSyncFile(this, path, flags, Stats.clone(stats), buffer);
-                    default:
-                        throw new ApiError(ErrorCode.EINVAL, 'Invalid FileMode object.');
-                }
-            }
-            else {
-                throw ApiError.EPERM(path);
+    async open(path, flags, mode, cred) {
+        // INVARIANT: You can't write to files on this file system.
+        if (flags.isWriteable()) {
+            throw new ApiError(ErrorCode.EPERM, path);
+        }
+        // Check if the path exists, and is a file.
+        const inode = this._index.getInode(path);
+        if (inode === null) {
+            throw ApiError.ENOENT(path);
+        }
+        if (!inode.toStats().hasAccess(flags.getMode(), cred)) {
+            throw ApiError.EACCES(path);
+        }
+        if (isIndexFileInode(inode) || isIndexDirInode(inode)) {
+            switch (flags.pathExistsAction()) {
+                case ActionType.THROW_EXCEPTION:
+                case ActionType.TRUNCATE_FILE:
+                    throw ApiError.EEXIST(path);
+                case ActionType.NOP:
+                    if (isIndexDirInode(inode)) {
+                        const stats = inode.getStats();
+                        return new NoSyncFile(this, path, flags, stats, stats.fileData || undefined);
+                    }
+                    const stats = inode.getData();
+                    // Use existing file contents.
+                    // XXX: Uh, this maintains the previously-used flag.
+                    if (stats.fileData) {
+                        return new NoSyncFile(this, path, flags, Stats.clone(stats), stats.fileData);
+                    }
+                    // @todo be lazier about actually requesting the file
+                    const buffer = await this._requestFile(path, 'buffer');
+                    // we don't initially have file sizes
+                    stats.size = buffer.length;
+                    stats.fileData = buffer;
+                    return new NoSyncFile(this, path, flags, Stats.clone(stats), buffer);
+                default:
+                    throw new ApiError(ErrorCode.EINVAL, 'Invalid FileMode object.');
             }
-        });
+        }
+        else {
+            throw ApiError.EPERM(path);
+        }
     }
-    readdir(path, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.readdirSync(path, cred);
-        });
+    async readdir(path, cred) {
+        return this.readdirSync(path, cred);
     }
     /**
      * We have the entire file as a buffer; optimize readFile.
      */
-    readFile(fname, encoding, flag, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Get file.
-            const fd = yield this.open(fname, flag, 0o644, cred);
-            try {
-                const fdCast = fd;
-                const fdBuff = fdCast.getBuffer();
-                if (encoding === null) {
-                    return Buffer.from(fdBuff);
-                }
-                return fdBuff.toString(encoding);
-            }
-            finally {
-                yield fd.close();
-            }
-        });
+    async readFile(fname, flag, cred) {
+        // Get file.
+        const fd = await this.open(fname, flag, 0o644, cred);
+        try {
+            return fd.getBuffer();
+        }
+        finally {
+            await fd.close();
+        }
     }
     _getHTTPPath(filePath) {
         if (filePath.charAt(0) === '/') {
@@ -197,13 +176,13 @@ export class HTTPRequest extends BaseFileSystem {
         return this.prefixUrl + filePath;
     }
     _requestFile(p, type) {
-        return this._requestFileInternal(this._getHTTPPath(p), type);
+        return fetchFile(this._getHTTPPath(p), type);
     }
     /**
      * Only requests the HEAD content, for the file size.
      */
     _requestFileSize(path) {
-        return this._requestFileSizeInternal(this._getHTTPPath(path));
+        return fetchFileSize(this._getHTTPPath(path));
     }
 }
 _a = HTTPRequest;

package/dist/backends/IndexedDB.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { AsyncKeyValueROTransaction, AsyncKeyValueRWTransaction, AsyncKeyValueStore, AsyncKeyValueFileSystem } from '@zenfs/core/backends/AsyncStore.js';
 import { type BackendOptions } from '@zenfs/core/backends/backend.js';
 /**
@@ -8,7 +7,7 @@ export declare class IndexedDBROTransaction implements AsyncKeyValueROTransactio
     tx: IDBTransaction;
     store: IDBObjectStore;
     constructor(tx: IDBTransaction, store: IDBObjectStore);
-    get(key: string): Promise<Buffer>;
+    get(key: string): Promise<Uint8Array>;
 }
 /**
  * @hidden
@@ -18,7 +17,7 @@ export declare class IndexedDBRWTransaction extends IndexedDBROTransaction imple
     /**
      * @todo return false when add has a key conflict (no error)
      */
-    put(key: string, data: Buffer, overwrite: boolean): Promise<boolean>;
+    put(key: string, data: Uint8Array, overwrite: boolean): Promise<boolean>;
     del(key: string): Promise<void>;
     commit(): Promise<void>;
     abort(): Promise<void>;

package/dist/backends/IndexedDB.js

@@ -1,7 +1,6 @@
 var _a;
 import { AsyncKeyValueFileSystem } from '@zenfs/core/backends/AsyncStore.js';
 import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
-import { Buffer } from 'buffer';
 import { CreateBackend } from '@zenfs/core/backends/backend.js';
 /**
  * Converts a DOMException or a DOMError from an IndexedDB event into a
@@ -53,8 +52,8 @@ export class IndexedDBROTransaction {
                         resolve(result);
                     }
                     else {
-                        // IDB data is stored as an ArrayBuffer
-                        resolve(Buffer.from(result));
+                        // IDB data is stored as an ArrayUint8Array
+                        resolve(Uint8Array.from(result));
                     }
                 };
             }

package/dist/backends/Storage.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { SyncKeyValueStore, SimpleSyncStore, SyncKeyValueFileSystem, SyncKeyValueRWTransaction } from '@zenfs/core/backends/SyncStore.js';
 import { type BackendOptions } from '@zenfs/core/backends/backend.js';
 /**
@@ -10,8 +9,8 @@ export declare class StorageStore implements SyncKeyValueStore, SimpleSyncStore
     constructor(_storage: Storage);
     clear(): void;
     beginTransaction(type: string): SyncKeyValueRWTransaction;
-    get(key: string): Buffer | undefined;
-    put(key: string, data: Buffer, overwrite: boolean): boolean;
+    get(key: string): Uint8Array | undefined;
+    put(key: string, data: Uint8Array, overwrite: boolean): boolean;
     del(key: string): void;
 }
 export declare namespace StorageFileSystem {

package/dist/backends/Storage.js

@@ -2,7 +2,7 @@ var _a;
 import { SyncKeyValueFileSystem, SimpleSyncRWTransaction } from '@zenfs/core/backends/SyncStore.js';
 import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
 import { CreateBackend } from '@zenfs/core/backends/backend.js';
-import { Buffer } from 'buffer';
+import { encode } from '@zenfs/core/utils.js';
 /**
  * A synchronous key-value store backed by Storage.
  */
@@ -25,7 +25,7 @@ export class StorageStore {
         if (typeof data != 'string') {
             return;
         }
-        return Buffer.from(data);
+        return encode(data);
     }
     put(key, data, overwrite) {
         try {

package/dist/backends/Worker.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-import { BaseFileSystem, FileContents, FileSystemMetadata } from '@zenfs/core/filesystem.js';
+import { BaseFileSystem, FileSystemMetadata } from '@zenfs/core/filesystem.js';
 import { File, FileFlag } from '@zenfs/core/file.js';
 import { Stats } from '@zenfs/core/stats.js';
 import { Cred } from '@zenfs/core/cred.js';
@@ -66,9 +65,9 @@ export declare class WorkerFS extends BaseFileSystem {
     exists(p: string, cred: Cred): Promise<boolean>;
     realpath(p: string, cred: Cred): Promise<string>;
     truncate(p: string, len: number, cred: Cred): Promise<void>;
-    readFile(fname: string, encoding: BufferEncoding, flag: FileFlag, cred: Cred): Promise<FileContents>;
-    writeFile(fname: string, data: FileContents, encoding: BufferEncoding, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
-    appendFile(fname: string, data: FileContents, encoding: BufferEncoding, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
+    readFile(fname: string, flag: FileFlag, cred: Cred): Promise<Uint8Array>;
+    writeFile(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
+    appendFile(fname: string, data: Uint8Array, flag: FileFlag, mode: number, cred: Cred): Promise<void>;
     chmod(p: string, mode: number, cred: Cred): Promise<void>;
     chown(p: string, new_uid: number, new_gid: number, cred: Cred): Promise<void>;
     utimes(p: string, atime: Date, mtime: Date, cred: Cred): Promise<void>;

package/dist/backends/Worker.js

@@ -1,12 +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 _a;
 import { BaseFileSystem } from '@zenfs/core/filesystem.js';
 import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
@@ -75,19 +66,22 @@ export class WorkerFS extends BaseFileSystem {
         };
     }
     get metadata() {
-        return Object.assign(Object.assign(Object.assign({}, super.metadata), this._metadata), { name: _a.Name, synchronous: false });
-    }
-    _rpc(method, ...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const id = this._currentID++;
-                this._requests.set(id, { resolve, reject });
-                this._worker.postMessage({
-                    isBFS: true,
-                    id,
-                    method,
-                    args,
-                });
+        return {
+            ...super.metadata,
+            ...this._metadata,
+            name: _a.Name,
+            synchronous: false,
+        };
+    }
+    async _rpc(method, ...args) {
+        return new Promise((resolve, reject) => {
+            const id = this._currentID++;
+            this._requests.set(id, { resolve, reject });
+            this._worker.postMessage({
+                isBFS: true,
+                id,
+                method,
+                args,
             });
         });
     }
@@ -121,14 +115,14 @@ export class WorkerFS extends BaseFileSystem {
     truncate(p, len, cred) {
         return this._rpc('truncate', p, len, cred);
     }
-    readFile(fname, encoding, flag, cred) {
-        return this._rpc('readFile', fname, encoding, flag, cred);
+    readFile(fname, flag, cred) {
+        return this._rpc('readFile', fname, flag, cred);
     }
-    writeFile(fname, data, encoding, flag, mode, cred) {
-        return this._rpc('writeFile', fname, data, encoding, flag, mode, cred);
+    writeFile(fname, data, flag, mode, cred) {
+        return this._rpc('writeFile', fname, data, flag, mode, cred);
     }
-    appendFile(fname, data, encoding, flag, mode, cred) {
-        return this._rpc('appendFile', fname, data, encoding, flag, mode, cred);
+    appendFile(fname, data, flag, mode, cred) {
+        return this._rpc('appendFile', fname, data, flag, mode, cred);
     }
     chmod(p, mode, cred) {
         return this._rpc('chmod', p, mode, cred);
@@ -159,11 +153,11 @@ WorkerFS.Options = {
     worker: {
         type: 'object',
         description: 'The target worker that you want to connect to, or the current worker if in a worker context.',
-        validator: (v) => __awaiter(void 0, void 0, void 0, function* () {
+        validator(worker) {
             // Check for a `postMessage` function.
-            if (typeof (v === null || v === void 0 ? void 0 : v.postMessage) != 'function') {
-                throw new ApiError(ErrorCode.EINVAL, `option must be a Web Worker instance.`);
+            if (typeof worker?.postMessage != 'function') {
+                throw new ApiError(ErrorCode.EINVAL, 'option must be a Web Worker instance.');
             }
-        }),
+        },
     },
 };