@zenfs/core 0.0.12 → 0.1.0

package/dist/backends/FolderAdapter.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 '../filesystem.js';
 import { relative, join } from '../emulation/path.js';
@@ -42,21 +33,19 @@ export class FolderAdapter extends BaseFileSystem {
         this._ready = this._initialize();
     }
     get metadata() {
-        return Object.assign(Object.assign(Object.assign({}, super.metadata), this._wrapped.metadata), { supportsLinks: false });
+        return { ...super.metadata, ...this._wrapped.metadata, supportsLinks: false };
     }
     /**
      * Initialize the file system. Ensures that the wrapped file system
      * has the given folder.
      */
-    _initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const exists = yield this._wrapped.exists(this._folder, Cred.Root);
-            if (!exists && this._wrapped.metadata.readonly) {
-                throw ApiError.ENOENT(this._folder);
-            }
-            yield this._wrapped.mkdir(this._folder, 0o777, Cred.Root);
-            return this;
-        });
+    async _initialize() {
+        const exists = await this._wrapped.exists(this._folder, Cred.Root);
+        if (!exists && this._wrapped.metadata.readonly) {
+            throw ApiError.ENOENT(this._folder);
+        }
+        await this._wrapped.mkdir(this._folder, 0o777, Cred.Root);
+        return this;
     }
 }
 _a = FolderAdapter;

package/dist/backends/Locked.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());
-    });
-};
 import Mutex from '../mutex.js';
 /**
  * This class serializes access to an underlying async filesystem.
@@ -27,17 +18,18 @@ export default class LockedFS {
         return this._ready;
     }
     get metadata() {
-        return Object.assign(Object.assign({}, this._fs.metadata), { name: 'LockedFS<' + this._fs.metadata.name + '>' });
+        return {
+            ...this._fs.metadata,
+            name: 'LockedFS<' + this._fs.metadata.name + '>',
+        };
     }
     get fs() {
         return this._fs;
     }
-    rename(oldPath, newPath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(oldPath);
-            yield this._fs.rename(oldPath, newPath, cred);
-            this._mu.unlock(oldPath);
-        });
+    async rename(oldPath, newPath, cred) {
+        await this._mu.lock(oldPath);
+        await this._fs.rename(oldPath, newPath, cred);
+        this._mu.unlock(oldPath);
     }
     renameSync(oldPath, newPath, cred) {
         if (this._mu.isLocked(oldPath)) {
@@ -45,13 +37,11 @@ export default class LockedFS {
         }
         return this._fs.renameSync(oldPath, newPath, cred);
     }
-    stat(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const stats = yield this._fs.stat(p, cred);
-            this._mu.unlock(p);
-            return stats;
-        });
+    async stat(p, cred) {
+        await this._mu.lock(p);
+        const stats = await this._fs.stat(p, cred);
+        this._mu.unlock(p);
+        return stats;
     }
     statSync(p, cred) {
         if (this._mu.isLocked(p)) {
@@ -59,12 +49,10 @@ export default class LockedFS {
         }
         return this._fs.statSync(p, cred);
     }
-    access(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.access(p, mode, cred);
-            this._mu.unlock(p);
-        });
+    async access(p, mode, cred) {
+        await this._mu.lock(p);
+        await this._fs.access(p, mode, cred);
+        this._mu.unlock(p);
     }
     accessSync(p, mode, cred) {
         if (this._mu.isLocked(p)) {
@@ -72,13 +60,11 @@ export default class LockedFS {
         }
         return this._fs.accessSync(p, mode, cred);
     }
-    open(p, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const fd = yield this._fs.open(p, flag, mode, cred);
-            this._mu.unlock(p);
-            return fd;
-        });
+    async open(p, flag, mode, cred) {
+        await this._mu.lock(p);
+        const fd = await this._fs.open(p, flag, mode, cred);
+        this._mu.unlock(p);
+        return fd;
     }
     openSync(p, flag, mode, cred) {
         if (this._mu.isLocked(p)) {
@@ -86,12 +72,10 @@ export default class LockedFS {
         }
         return this._fs.openSync(p, flag, mode, cred);
     }
-    unlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.unlink(p, cred);
-            this._mu.unlock(p);
-        });
+    async unlink(p, cred) {
+        await this._mu.lock(p);
+        await this._fs.unlink(p, cred);
+        this._mu.unlock(p);
     }
     unlinkSync(p, cred) {
         if (this._mu.isLocked(p)) {
@@ -99,12 +83,10 @@ export default class LockedFS {
         }
         return this._fs.unlinkSync(p, cred);
     }
-    rmdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.rmdir(p, cred);
-            this._mu.unlock(p);
-        });
+    async rmdir(p, cred) {
+        await this._mu.lock(p);
+        await this._fs.rmdir(p, cred);
+        this._mu.unlock(p);
     }
     rmdirSync(p, cred) {
         if (this._mu.isLocked(p)) {
@@ -112,12 +94,10 @@ export default class LockedFS {
         }
         return this._fs.rmdirSync(p, cred);
     }
-    mkdir(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.mkdir(p, mode, cred);
-            this._mu.unlock(p);
-        });
+    async mkdir(p, mode, cred) {
+        await this._mu.lock(p);
+        await this._fs.mkdir(p, mode, cred);
+        this._mu.unlock(p);
     }
     mkdirSync(p, mode, cred) {
         if (this._mu.isLocked(p)) {
@@ -125,13 +105,11 @@ export default class LockedFS {
         }
         return this._fs.mkdirSync(p, mode, cred);
     }
-    readdir(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const files = yield this._fs.readdir(p, cred);
-            this._mu.unlock(p);
-            return files;
-        });
+    async readdir(p, cred) {
+        await this._mu.lock(p);
+        const files = await this._fs.readdir(p, cred);
+        this._mu.unlock(p);
+        return files;
     }
     readdirSync(p, cred) {
         if (this._mu.isLocked(p)) {
@@ -139,13 +117,11 @@ export default class LockedFS {
         }
         return this._fs.readdirSync(p, cred);
     }
-    exists(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const exists = yield this._fs.exists(p, cred);
-            this._mu.unlock(p);
-            return exists;
-        });
+    async exists(p, cred) {
+        await this._mu.lock(p);
+        const exists = await this._fs.exists(p, cred);
+        this._mu.unlock(p);
+        return exists;
     }
     existsSync(p, cred) {
         if (this._mu.isLocked(p)) {
@@ -153,13 +129,11 @@ export default class LockedFS {
         }
         return this._fs.existsSync(p, cred);
     }
-    realpath(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const resolvedPath = yield this._fs.realpath(p, cred);
-            this._mu.unlock(p);
-            return resolvedPath;
-        });
+    async realpath(p, cred) {
+        await this._mu.lock(p);
+        const resolvedPath = await this._fs.realpath(p, cred);
+        this._mu.unlock(p);
+        return resolvedPath;
     }
     realpathSync(p, cred) {
         if (this._mu.isLocked(p)) {
@@ -167,12 +141,10 @@ export default class LockedFS {
         }
         return this._fs.realpathSync(p, cred);
     }
-    truncate(p, len, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.truncate(p, len, cred);
-            this._mu.unlock(p);
-        });
+    async truncate(p, len, cred) {
+        await this._mu.lock(p);
+        await this._fs.truncate(p, len, cred);
+        this._mu.unlock(p);
     }
     truncateSync(p, len, cred) {
         if (this._mu.isLocked(p)) {
@@ -180,13 +152,11 @@ export default class LockedFS {
         }
         return this._fs.truncateSync(p, len, cred);
     }
-    readFile(fname, flag, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(fname);
-            const data = yield this._fs.readFile(fname, flag, cred);
-            this._mu.unlock(fname);
-            return data;
-        });
+    async readFile(fname, flag, cred) {
+        await this._mu.lock(fname);
+        const data = await this._fs.readFile(fname, flag, cred);
+        this._mu.unlock(fname);
+        return data;
     }
     readFileSync(fname, flag, cred) {
         if (this._mu.isLocked(fname)) {
@@ -194,12 +164,10 @@ export default class LockedFS {
         }
         return this._fs.readFileSync(fname, flag, cred);
     }
-    writeFile(fname, data, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(fname);
-            yield this._fs.writeFile(fname, data, flag, mode, cred);
-            this._mu.unlock(fname);
-        });
+    async writeFile(fname, data, flag, mode, cred) {
+        await this._mu.lock(fname);
+        await this._fs.writeFile(fname, data, flag, mode, cred);
+        this._mu.unlock(fname);
     }
     writeFileSync(fname, data, flag, mode, cred) {
         if (this._mu.isLocked(fname)) {
@@ -207,12 +175,10 @@ export default class LockedFS {
         }
         return this._fs.writeFileSync(fname, data, flag, mode, cred);
     }
-    appendFile(fname, data, flag, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(fname);
-            yield this._fs.appendFile(fname, data, flag, mode, cred);
-            this._mu.unlock(fname);
-        });
+    async appendFile(fname, data, flag, mode, cred) {
+        await this._mu.lock(fname);
+        await this._fs.appendFile(fname, data, flag, mode, cred);
+        this._mu.unlock(fname);
     }
     appendFileSync(fname, data, flag, mode, cred) {
         if (this._mu.isLocked(fname)) {
@@ -220,12 +186,10 @@ export default class LockedFS {
         }
         return this._fs.appendFileSync(fname, data, flag, mode, cred);
     }
-    chmod(p, mode, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.chmod(p, mode, cred);
-            this._mu.unlock(p);
-        });
+    async chmod(p, mode, cred) {
+        await this._mu.lock(p);
+        await this._fs.chmod(p, mode, cred);
+        this._mu.unlock(p);
     }
     chmodSync(p, mode, cred) {
         if (this._mu.isLocked(p)) {
@@ -233,12 +197,10 @@ export default class LockedFS {
         }
         return this._fs.chmodSync(p, mode, cred);
     }
-    chown(p, new_uid, new_gid, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.chown(p, new_uid, new_gid, cred);
-            this._mu.unlock(p);
-        });
+    async chown(p, new_uid, new_gid, cred) {
+        await this._mu.lock(p);
+        await this._fs.chown(p, new_uid, new_gid, cred);
+        this._mu.unlock(p);
     }
     chownSync(p, new_uid, new_gid, cred) {
         if (this._mu.isLocked(p)) {
@@ -246,12 +208,10 @@ export default class LockedFS {
         }
         return this._fs.chownSync(p, new_uid, new_gid, cred);
     }
-    utimes(p, atime, mtime, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            yield this._fs.utimes(p, atime, mtime, cred);
-            this._mu.unlock(p);
-        });
+    async utimes(p, atime, mtime, cred) {
+        await this._mu.lock(p);
+        await this._fs.utimes(p, atime, mtime, cred);
+        this._mu.unlock(p);
     }
     utimesSync(p, atime, mtime, cred) {
         if (this._mu.isLocked(p)) {
@@ -259,12 +219,10 @@ export default class LockedFS {
         }
         return this._fs.utimesSync(p, atime, mtime, cred);
     }
-    link(srcpath, dstpath, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(srcpath);
-            yield this._fs.link(srcpath, dstpath, cred);
-            this._mu.unlock(srcpath);
-        });
+    async link(srcpath, dstpath, cred) {
+        await this._mu.lock(srcpath);
+        await this._fs.link(srcpath, dstpath, cred);
+        this._mu.unlock(srcpath);
     }
     linkSync(srcpath, dstpath, cred) {
         if (this._mu.isLocked(srcpath)) {
@@ -272,12 +230,10 @@ export default class LockedFS {
         }
         return this._fs.linkSync(srcpath, dstpath, cred);
     }
-    symlink(srcpath, dstpath, type, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(srcpath);
-            yield this._fs.symlink(srcpath, dstpath, type, cred);
-            this._mu.unlock(srcpath);
-        });
+    async symlink(srcpath, dstpath, type, cred) {
+        await this._mu.lock(srcpath);
+        await this._fs.symlink(srcpath, dstpath, type, cred);
+        this._mu.unlock(srcpath);
     }
     symlinkSync(srcpath, dstpath, type, cred) {
         if (this._mu.isLocked(srcpath)) {
@@ -285,13 +241,11 @@ export default class LockedFS {
         }
         return this._fs.symlinkSync(srcpath, dstpath, type, cred);
     }
-    readlink(p, cred) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this._mu.lock(p);
-            const linkString = yield this._fs.readlink(p, cred);
-            this._mu.unlock(p);
-            return linkString;
-        });
+    async readlink(p, cred) {
+        await this._mu.lock(p);
+        const linkString = await this._fs.readlink(p, cred);
+        this._mu.unlock(p);
+        return linkString;
     }
     readlinkSync(p, cred) {
         if (this._mu.isLocked(p)) {