@zenfs/core 0.0.12 → 0.1.0

package/dist/filesystem.js

@@ -1,14 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 // disable no-unused-vars since BaseFileSystem uses them a lot
-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 { ApiError, ErrorCode } from './ApiError.js';
 import { FileFlag, ActionType } from './file.js';
@@ -60,83 +51,71 @@ export class BaseFileSystem extends FileSystem {
      * @param p The path to open.
      * @param flag The flag to use when opening the file.
      */
-    openFile(p, flag, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async openFile(p, flag, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     /**
      * Create the file at path p with the given mode. Then, open it with the given
      * flag.
      */
-    createFile(p, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
-    }
-    open(p, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const stats = yield this.stat(p, cred);
-                switch (flag.pathExistsAction()) {
-                    case ActionType.THROW_EXCEPTION:
-                        throw ApiError.EEXIST(p);
-                    case ActionType.TRUNCATE_FILE:
-                        // NOTE: In a previous implementation, we deleted the file and
-                        // re-created it. However, this created a race condition if another
-                        // asynchronous request was trying to read the file, as the file
-                        // would not exist for a small period of time.
-                        const fd = yield this.openFile(p, flag, cred);
-                        if (!fd)
-                            throw new Error('BFS has reached an impossible code path; please file a bug.');
-                        yield fd.truncate(0);
-                        yield fd.sync();
-                        return fd;
-                    case ActionType.NOP:
-                        return this.openFile(p, flag, cred);
-                    default:
-                        throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
-                }
-                // File exists.
+    async createFile(p, flag, mode, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
+    async open(p, flag, mode, cred) {
+        try {
+            const stats = await this.stat(p, cred);
+            switch (flag.pathExistsAction()) {
+                case ActionType.THROW_EXCEPTION:
+                    throw ApiError.EEXIST(p);
+                case ActionType.TRUNCATE_FILE:
+                    // NOTE: In a previous implementation, we deleted the file and
+                    // re-created it. However, this created a race condition if another
+                    // asynchronous request was trying to read the file, as the file
+                    // would not exist for a small period of time.
+                    const fd = await this.openFile(p, flag, cred);
+                    if (!fd)
+                        throw new Error('BFS has reached an impossible code path; please file a bug.');
+                    await fd.truncate(0);
+                    await fd.sync();
+                    return fd;
+                case ActionType.NOP:
+                    return this.openFile(p, flag, cred);
+                default:
+                    throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
             }
-            catch (e) {
-                // File does not exist.
-                switch (flag.pathNotExistsAction()) {
-                    case ActionType.CREATE_FILE:
-                        // Ensure parent exists.
-                        const parentStats = yield this.stat(path.dirname(p), cred);
-                        if (parentStats && !parentStats.isDirectory()) {
-                            throw ApiError.ENOTDIR(path.dirname(p));
-                        }
-                        return this.createFile(p, flag, mode, cred);
-                    case ActionType.THROW_EXCEPTION:
-                        throw ApiError.ENOENT(p);
-                    default:
-                        throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
-                }
+            // File exists.
+        }
+        catch (e) {
+            // File does not exist.
+            switch (flag.pathNotExistsAction()) {
+                case ActionType.CREATE_FILE:
+                    // Ensure parent exists.
+                    const parentStats = await this.stat(path.dirname(p), cred);
+                    if (parentStats && !parentStats.isDirectory()) {
+                        throw ApiError.ENOTDIR(path.dirname(p));
+                    }
+                    return this.createFile(p, flag, mode, cred);
+                case ActionType.THROW_EXCEPTION:
+                    throw ApiError.ENOENT(p);
+                default:
+                    throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
             }
-        });
+        }
     }
-    access(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async access(p, mode, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     accessSync(p, mode, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    rename(oldPath, newPath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async rename(oldPath, newPath, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     renameSync(oldPath, newPath, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    stat(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async stat(p, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     statSync(p, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
@@ -200,48 +179,38 @@ export class BaseFileSystem extends FileSystem {
                 throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
         }
     }
-    unlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async unlink(p, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     unlinkSync(p, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    rmdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async rmdir(p, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     rmdirSync(p, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    mkdir(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async mkdir(p, mode, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     mkdirSync(p, mode, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    readdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async readdir(p, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     readdirSync(p, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    exists(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.stat(p, cred);
-                return true;
-            }
-            catch (e) {
-                return false;
-            }
-        });
+    async exists(p, cred) {
+        try {
+            await this.stat(p, cred);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
     }
     existsSync(p, cred) {
         try {
@@ -252,27 +221,25 @@ export class BaseFileSystem extends FileSystem {
             return false;
         }
     }
-    realpath(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.metadata.supportsLinks) {
-                // The path could contain symlinks. Split up the path,
-                // resolve any symlinks, return the resolved string.
-                const splitPath = p.split(path.sep);
-                // TODO: Simpler to just pass through file, find sep and such.
-                for (let i = 0; i < splitPath.length; i++) {
-                    const addPaths = splitPath.slice(0, i + 1);
-                    splitPath[i] = path.join(...addPaths);
-                }
-                return splitPath.join(path.sep);
+    async realpath(p, cred) {
+        if (this.metadata.supportsLinks) {
+            // The path could contain symlinks. Split up the path,
+            // resolve any symlinks, return the resolved string.
+            const splitPath = p.split(path.sep);
+            // TODO: Simpler to just pass through file, find sep and such.
+            for (let i = 0; i < splitPath.length; i++) {
+                const addPaths = splitPath.slice(0, i + 1);
+                splitPath[i] = path.join(...addPaths);
             }
-            else {
-                // No symlinks. We just need to verify that it exists.
-                if (!(yield this.exists(p, cred))) {
-                    throw ApiError.ENOENT(p);
-                }
-                return p;
+            return splitPath.join(path.sep);
+        }
+        else {
+            // No symlinks. We just need to verify that it exists.
+            if (!(await this.exists(p, cred))) {
+                throw ApiError.ENOENT(p);
             }
-        });
+            return p;
+        }
     }
     realpathSync(p, cred) {
         if (this.metadata.supportsLinks) {
@@ -296,16 +263,14 @@ export class BaseFileSystem extends FileSystem {
             }
         }
     }
-    truncate(p, len, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fd = yield this.open(p, FileFlag.getFileFlag('r+'), 0o644, cred);
-            try {
-                yield fd.truncate(len);
-            }
-            finally {
-                yield fd.close();
-            }
-        });
+    async truncate(p, len, cred) {
+        const fd = await this.open(p, FileFlag.getFileFlag('r+'), 0o644, cred);
+        try {
+            await fd.truncate(len);
+        }
+        finally {
+            await fd.close();
+        }
     }
     truncateSync(p, len, cred) {
         const fd = this.openSync(p, FileFlag.getFileFlag('r+'), 0o644, cred);
@@ -317,22 +282,20 @@ export class BaseFileSystem extends FileSystem {
             fd.closeSync();
         }
     }
-    readFile(fname, flag, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Get file.
-            const fd = yield this.open(fname, flag, 0o644, cred);
-            try {
-                const stat = yield fd.stat();
-                // Allocate buffer.
-                const buf = new Uint8Array(stat.size);
-                yield fd.read(buf, 0, stat.size, 0);
-                yield fd.close();
-                return buf;
-            }
-            finally {
-                yield fd.close();
-            }
-        });
+    async readFile(fname, flag, cred) {
+        // Get file.
+        const fd = await this.open(fname, flag, 0o644, cred);
+        try {
+            const stat = await fd.stat();
+            // Allocate buffer.
+            const buf = new Uint8Array(stat.size);
+            await fd.read(buf, 0, stat.size, 0);
+            await fd.close();
+            return buf;
+        }
+        finally {
+            await fd.close();
+        }
     }
     readFileSync(fname, flag, cred) {
         // Get file.
@@ -349,21 +312,19 @@ export class BaseFileSystem extends FileSystem {
             fd.closeSync();
         }
     }
-    writeFile(fname, data, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Get file.
-            const fd = yield this.open(fname, flag, mode, cred);
-            try {
-                if (typeof data === 'string') {
-                    data = encode(data);
-                }
-                // Write into file.
-                yield fd.write(data, 0, data.length, 0);
-            }
-            finally {
-                yield fd.close();
+    async writeFile(fname, data, flag, mode, cred) {
+        // Get file.
+        const fd = await this.open(fname, flag, mode, cred);
+        try {
+            if (typeof data === 'string') {
+                data = encode(data);
             }
-        });
+            // Write into file.
+            await fd.write(data, 0, data.length, 0);
+        }
+        finally {
+            await fd.close();
+        }
     }
     writeFileSync(fname, data, flag, mode, cred) {
         // Get file.
@@ -379,19 +340,17 @@ export class BaseFileSystem extends FileSystem {
             fd.closeSync();
         }
     }
-    appendFile(fname, data, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fd = yield this.open(fname, flag, mode, cred);
-            try {
-                if (typeof data === 'string') {
-                    data = encode(data);
-                }
-                yield fd.write(data, 0, data.length, null);
-            }
-            finally {
-                yield fd.close();
+    async appendFile(fname, data, flag, mode, cred) {
+        const fd = await this.open(fname, flag, mode, cred);
+        try {
+            if (typeof data === 'string') {
+                data = encode(data);
             }
-        });
+            await fd.write(data, 0, data.length, null);
+        }
+        finally {
+            await fd.close();
+        }
     }
     appendFileSync(fname, data, flag, mode, cred) {
         const fd = this.openSync(fname, flag, mode, cred);
@@ -405,50 +364,38 @@ export class BaseFileSystem extends FileSystem {
             fd.closeSync();
         }
     }
-    chmod(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async chmod(p, mode, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     chmodSync(p, mode, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    chown(p, new_uid, new_gid, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async chown(p, new_uid, new_gid, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     chownSync(p, new_uid, new_gid, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    utimes(p, atime, mtime, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async utimes(p, atime, mtime, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     utimesSync(p, atime, mtime, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    link(srcpath, dstpath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async link(srcpath, dstpath, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     linkSync(srcpath, dstpath, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    symlink(srcpath, dstpath, type, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async symlink(srcpath, dstpath, type, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     symlinkSync(srcpath, dstpath, type, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    readlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async readlink(p, cred) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     readlinkSync(p, cred) {
         throw new ApiError(ErrorCode.ENOTSUP);
@@ -461,76 +408,48 @@ BaseFileSystem.Name = _a.name;
  */
 export class SynchronousFileSystem extends BaseFileSystem {
     get metadata() {
-        return Object.assign(Object.assign({}, super.metadata), { synchronous: true });
-    }
-    access(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.accessSync(p, mode, cred);
-        });
-    }
-    rename(oldPath, newPath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.renameSync(oldPath, newPath, cred);
-        });
-    }
-    stat(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.statSync(p, cred);
-        });
-    }
-    open(p, flags, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.openSync(p, flags, mode, cred);
-        });
-    }
-    unlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.unlinkSync(p, cred);
-        });
-    }
-    rmdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.rmdirSync(p, cred);
-        });
-    }
-    mkdir(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.mkdirSync(p, mode, cred);
-        });
-    }
-    readdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.readdirSync(p, cred);
-        });
-    }
-    chmod(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.chmodSync(p, mode, cred);
-        });
-    }
-    chown(p, new_uid, new_gid, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.chownSync(p, new_uid, new_gid, cred);
-        });
-    }
-    utimes(p, atime, mtime, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.utimesSync(p, atime, mtime, cred);
-        });
-    }
-    link(srcpath, dstpath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.linkSync(srcpath, dstpath, cred);
-        });
-    }
-    symlink(srcpath, dstpath, type, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.symlinkSync(srcpath, dstpath, type, cred);
-        });
-    }
-    readlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.readlinkSync(p, cred);
-        });
+        return { ...super.metadata, synchronous: true };
+    }
+    async access(p, mode, cred) {
+        return this.accessSync(p, mode, cred);
+    }
+    async rename(oldPath, newPath, cred) {
+        return this.renameSync(oldPath, newPath, cred);
+    }
+    async stat(p, cred) {
+        return this.statSync(p, cred);
+    }
+    async open(p, flags, mode, cred) {
+        return this.openSync(p, flags, mode, cred);
+    }
+    async unlink(p, cred) {
+        return this.unlinkSync(p, cred);
+    }
+    async rmdir(p, cred) {
+        return this.rmdirSync(p, cred);
+    }
+    async mkdir(p, mode, cred) {
+        return this.mkdirSync(p, mode, cred);
+    }
+    async readdir(p, cred) {
+        return this.readdirSync(p, cred);
+    }
+    async chmod(p, mode, cred) {
+        return this.chmodSync(p, mode, cred);
+    }
+    async chown(p, new_uid, new_gid, cred) {
+        return this.chownSync(p, new_uid, new_gid, cred);
+    }
+    async utimes(p, atime, mtime, cred) {
+        return this.utimesSync(p, atime, mtime, cred);
+    }
+    async link(srcpath, dstpath, cred) {
+        return this.linkSync(srcpath, dstpath, cred);
+    }
+    async symlink(srcpath, dstpath, type, cred) {
+        return this.symlinkSync(srcpath, dstpath, type, cred);
+    }
+    async readlink(p, cred) {
+        return this.readlinkSync(p, cred);
     }
 }

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * ZenFS's main module. This is exposed in the browser via the ZenFS global.
  */
 import fs from './emulation/fs.js';
-import { FileSystem, type BFSOneArgCallback, type BFSCallback } from './filesystem.js';
+import { FileSystem, type NoArgCallback, type TwoArgCallback } from './filesystem.js';
 import { backends } from './backends/index.js';
 /**
  * Initializes ZenFS with the given file systems.
@@ -25,7 +25,7 @@ export type Configuration = FileSystem | FileSystemConfiguration | ConfigMapping
  * See the FileSystemConfiguration type for more info on the configuration object.
  */
 export declare function configure(config: Configuration): Promise<void>;
-export declare function configure(config: Configuration, cb: BFSOneArgCallback): void;
+export declare function configure(config: Configuration, cb: NoArgCallback): void;
 /**
  * Asynchronously creates a file system with the given configuration, and initializes ZenFS with it.
  * See the FileSystemConfiguration type for more info on the configuration object.
@@ -62,7 +62,7 @@ export interface FileSystemConfiguration {
  * @param cb Called when the file system is constructed, or when an error occurs.
  */
 export declare function getFileSystem(config: FileSystemConfiguration): Promise<FileSystem>;
-export declare function getFileSystem(config: FileSystemConfiguration, cb: BFSCallback<FileSystem>): void;
+export declare function getFileSystem(config: FileSystemConfiguration, cb: TwoArgCallback<FileSystem>): void;
 export * from './backends/index.js';
 export * from './backends/AsyncStore.js';
 export * from './backends/SyncStore.js';