@zenfs/core 0.0.11 → 0.1.0

package/dist/ApiError.d.ts

@@ -26,7 +26,7 @@ export declare enum ErrorCode {
  * @internal
  */
 export declare const ErrorStrings: {
-    [code: string | number]: string;
+    [code in ErrorCode]: string;
 };
 interface ApiErrorJSON {
     errno: ErrorCode;

package/dist/ApiError.js

@@ -26,22 +26,23 @@ export var ErrorCode;
  * Strings associated with each error code.
  * @internal
  */
-export const ErrorStrings = {};
-ErrorStrings[ErrorCode.EPERM] = 'Operation not permitted.';
-ErrorStrings[ErrorCode.ENOENT] = 'No such file or directory.';
-ErrorStrings[ErrorCode.EIO] = 'Input/output error.';
-ErrorStrings[ErrorCode.EBADF] = 'Bad file descriptor.';
-ErrorStrings[ErrorCode.EACCES] = 'Permission denied.';
-ErrorStrings[ErrorCode.EBUSY] = 'Resource busy or locked.';
-ErrorStrings[ErrorCode.EEXIST] = 'File exists.';
-ErrorStrings[ErrorCode.ENOTDIR] = 'File is not a directory.';
-ErrorStrings[ErrorCode.EISDIR] = 'File is a directory.';
-ErrorStrings[ErrorCode.EINVAL] = 'Invalid argument.';
-ErrorStrings[ErrorCode.EFBIG] = 'File is too big.';
-ErrorStrings[ErrorCode.ENOSPC] = 'No space left on disk.';
-ErrorStrings[ErrorCode.EROFS] = 'Cannot modify a read-only file system.';
-ErrorStrings[ErrorCode.ENOTEMPTY] = 'Directory is not empty.';
-ErrorStrings[ErrorCode.ENOTSUP] = 'Operation is not supported.';
+export const ErrorStrings = {
+    [ErrorCode.EPERM]: 'Operation not permitted.',
+    [ErrorCode.ENOENT]: 'No such file or directory.',
+    [ErrorCode.EIO]: 'Input/output error.',
+    [ErrorCode.EBADF]: 'Bad file descriptor.',
+    [ErrorCode.EACCES]: 'Permission denied.',
+    [ErrorCode.EBUSY]: 'Resource busy or locked.',
+    [ErrorCode.EEXIST]: 'File exists.',
+    [ErrorCode.ENOTDIR]: 'File is not a directory.',
+    [ErrorCode.EISDIR]: 'File is a directory.',
+    [ErrorCode.EINVAL]: 'Invalid argument.',
+    [ErrorCode.EFBIG]: 'File is too big.',
+    [ErrorCode.ENOSPC]: 'No space left on disk.',
+    [ErrorCode.EROFS]: 'Cannot modify a read-only file system.',
+    [ErrorCode.ENOTEMPTY]: 'Directory is not empty.',
+    [ErrorCode.ENOTSUP]: 'Operation is not supported.',
+};
 /**
  * Represents a ZenFS error. Passed back to applications after a failed
  * call to the ZenFS API.

package/dist/backends/AsyncMirror.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 { SynchronousFileSystem } from '../filesystem.js';
 import { ApiError, ErrorCode } from '../ApiError.js';
@@ -97,14 +88,19 @@ export class AsyncMirror extends SynchronousFileSystem {
         this._ready = this._initialize();
     }
     get metadata() {
-        return Object.assign(Object.assign({}, super.metadata), { name: AsyncMirror.Name, synchronous: true, supportsProperties: this._sync.metadata.supportsProperties && this._async.metadata.supportsProperties });
+        return {
+            ...super.metadata,
+            name: AsyncMirror.Name,
+            synchronous: true,
+            supportsProperties: this._sync.metadata.supportsProperties && this._async.metadata.supportsProperties,
+        };
     }
     _syncSync(fd) {
         const stats = fd.getStats();
-        this._sync.writeFileSync(fd.getPath(), fd.getBuffer(), null, FileFlag.getFileFlag('w'), stats.mode, stats.getCred(0, 0));
+        this._sync.writeFileSync(fd.getPath(), fd.getBuffer(), FileFlag.getFileFlag('w'), stats.mode, stats.getCred(0, 0));
         this.enqueueOp({
             apiMethod: 'writeFile',
-            arguments: [fd.getPath(), fd.getBuffer(), null, fd.getFlag(), stats.mode, stats.getCred(0, 0)],
+            arguments: [fd.getPath(), fd.getBuffer(), fd.getFlag(), stats.mode, stats.getCred(0, 0)],
         });
     }
     renameSync(oldPath, newPath, cred) {
@@ -121,7 +117,7 @@ export class AsyncMirror extends SynchronousFileSystem {
         // Sanity check: Is this open/close permitted?
         const fd = this._sync.openSync(p, flag, mode, cred);
         fd.closeSync();
-        return new MirrorFile(this, p, flag, this._sync.statSync(p, cred), this._sync.readFileSync(p, null, FileFlag.getFileFlag('r'), cred));
+        return new MirrorFile(this, p, flag, this._sync.statSync(p, cred), this._sync.readFileSync(p, FileFlag.getFileFlag('r'), cred));
     }
     unlinkSync(p, cred) {
         this._sync.unlinkSync(p, cred);
@@ -174,42 +170,40 @@ export class AsyncMirror extends SynchronousFileSystem {
     /**
      * Called once to load up files from async storage into sync storage.
      */
-    _initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._isInitialized) {
-                // First call triggers initialization, the rest wait.
-                const copyDirectory = (p, mode) => __awaiter(this, void 0, void 0, function* () {
-                    if (p !== '/') {
-                        const stats = yield this._async.stat(p, Cred.Root);
-                        this._sync.mkdirSync(p, mode, stats.getCred());
-                    }
-                    const files = yield this._async.readdir(p, Cred.Root);
-                    for (const file of files) {
-                        yield copyItem(join(p, file));
-                    }
-                }), copyFile = (p, mode) => __awaiter(this, void 0, void 0, function* () {
-                    const data = yield this._async.readFile(p, null, FileFlag.getFileFlag('r'), Cred.Root);
-                    this._sync.writeFileSync(p, data, null, FileFlag.getFileFlag('w'), mode, Cred.Root);
-                }), copyItem = (p) => __awaiter(this, void 0, void 0, function* () {
-                    const stats = yield this._async.stat(p, Cred.Root);
-                    if (stats.isDirectory()) {
-                        yield copyDirectory(p, stats.mode);
-                    }
-                    else {
-                        yield copyFile(p, stats.mode);
-                    }
-                });
-                try {
-                    yield copyDirectory('/', 0);
-                    this._isInitialized = true;
+    async _initialize() {
+        if (!this._isInitialized) {
+            // First call triggers initialization, the rest wait.
+            const copyDirectory = async (p, mode) => {
+                if (p !== '/') {
+                    const stats = await this._async.stat(p, Cred.Root);
+                    this._sync.mkdirSync(p, mode, stats.getCred());
+                }
+                const files = await this._async.readdir(p, Cred.Root);
+                for (const file of files) {
+                    await copyItem(join(p, file));
                 }
-                catch (e) {
-                    this._isInitialized = false;
-                    throw e;
+            }, copyFile = async (p, mode) => {
+                const data = await this._async.readFile(p, FileFlag.getFileFlag('r'), Cred.Root);
+                this._sync.writeFileSync(p, data, FileFlag.getFileFlag('w'), mode, Cred.Root);
+            }, copyItem = async (p) => {
+                const stats = await this._async.stat(p, Cred.Root);
+                if (stats.isDirectory()) {
+                    await copyDirectory(p, stats.mode);
+                }
+                else {
+                    await copyFile(p, stats.mode);
                 }
+            };
+            try {
+                await copyDirectory('/', 0);
+                this._isInitialized = true;
             }
-            return this;
-        });
+            catch (e) {
+                this._isInitialized = false;
+                throw e;
+            }
+        }
+        return this;
     }
     enqueueOp(op) {
         this._queue.push(op);
@@ -239,11 +233,11 @@ AsyncMirror.Options = {
     sync: {
         type: 'object',
         description: 'The synchronous file system to mirror the asynchronous file system to.',
-        validator: (v) => __awaiter(void 0, void 0, void 0, function* () {
-            if (!(v === null || v === void 0 ? void 0 : v.metadata.synchronous)) {
+        validator: async (v) => {
+            if (!v?.metadata.synchronous) {
                 throw new ApiError(ErrorCode.EINVAL, `'sync' option must be a file system that supports synchronous operations`);
             }
-        }),
+        },
     },
     async: {
         type: 'object',