@zenfs/dom 0.0.2 → 0.0.4

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>;
+    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

@@ -15,14 +15,13 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     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 'path';
+import { basename, dirname, join } from '@zenfs/core/emulation/path.js';
 import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
 import { Cred } from '@zenfs/core/cred.js';
 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);
@@ -115,7 +114,7 @@ export class FileSystemAccessFileSystem extends BaseFileSystem {
     }
     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);
+            yield this.writeFile(p, new Uint8Array(), null, flag, mode, cred, true);
             return this.openFile(p, flag, cred);
         });
     }
@@ -213,7 +212,7 @@ export class FileSystemAccessFileSystem extends BaseFileSystem {
         });
     }
     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));
+        return new FileSystemAccessFile(this, path, flag, new Stats(FileType.FILE, size || 0, undefined, undefined, lastModified || new Date().getTime()), new Uint8Array(data));
     }
     getHandle(path) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/backends/HTTPRequest.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import { BaseFileSystem, FileContents, FileSystemMetadata } from '@zenfs/core/filesystem.js';
-import { File, FileFlag } from '@zenfs/core/file.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,19 +58,17 @@ 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 [ZenFS.Uint8Array] 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.

package/dist/backends/HTTPRequest.js

@@ -10,13 +10,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a;
 import { BaseFileSystem } from '@zenfs/core/filesystem.js';
 import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
-import { copyingSlice } from '@zenfs/core/utils.js';
 import { ActionType, NoSyncFile } from '@zenfs/core/file.js';
 import { Stats } from '@zenfs/core/stats.js';
 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 { decode } from '@zenfs/core/utils.js';
 /**
  * A simple filesystem backed by HTTP downloads. You must create a directory listing using the
  * `make_http_index` tool provided by ZenFS.
@@ -64,8 +64,6 @@ 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 });
@@ -78,7 +76,7 @@ export class HTTPRequest extends BaseFileSystem {
     /**
      * Special HTTPFS function: Preload the given file into the index.
      * @param [String] path
-     * @param [ZenFS.Buffer] buffer
+     * @param [ZenFS.Uint8Array] buffer
      */
     preloadFile(path, buffer) {
         const inode = this._index.getInode(path);
@@ -180,10 +178,7 @@ export class HTTPRequest extends BaseFileSystem {
             try {
                 const fdCast = fd;
                 const fdBuff = fdCast.getBuffer();
-                if (encoding === null) {
-                    return copyingSlice(fdBuff);
-                }
-                return fdBuff.toString(encoding);
+                return encoding ? decode(fdBuff) : fdBuff;
             }
             finally {
                 yield fd.close();
@@ -197,13 +192,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,20 +1,7 @@
 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';
-/**
- * Get the indexedDB constructor for the current browser.
- * @hidden
- */
-const indexedDB = (() => {
-    try {
-        return globalThis.indexedDB || globalThis.mozIndexedDB || globalThis.webkitIndexedDB || globalThis.msIndexedDB;
-    }
-    catch (_b) {
-        return null;
-    }
-})();
 /**
  * Converts a DOMException or a DOMError from an IndexedDB event into a
  * standardized ZenFS API error.
@@ -65,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));
                     }
                 };
             }
@@ -195,7 +182,7 @@ export class IndexedDBFileSystem extends AsyncKeyValueFileSystem {
             if (!(idbFactory instanceof IDBFactory)) {
                 return false;
             }
-            const req = indexedDB.open('__zenfs_test__');
+            const req = idbFactory.open('__zenfs_test__');
             if (!req) {
                 return false;
             }

package/dist/backends/Storage.d.ts

@@ -1,17 +1,16 @@
-/// <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';
 /**
  * A synchronous key-value store backed by Storage.
  */
 export declare class StorageStore implements SyncKeyValueStore, SimpleSyncStore {
-    protected _storage: any;
+    protected _storage: Storage;
     name(): string;
-    constructor(_storage: any);
+    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.js

@@ -159,11 +159,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 === null || worker === void 0 ? void 0 : worker.postMessage) != 'function') {
+                throw new ApiError(ErrorCode.EINVAL, 'option must be a Web Worker instance.');
             }
-        }),
+        },
     },
 };