@zenfs/core 0.0.12 → 0.2.0

package/dist/emulation/sync.js

@@ -1,7 +1,10 @@
 import { ApiError, ErrorCode } from '../ApiError.js';
-import { FileFlag } from '../file.js';
-import { normalizePath, cred, getFdForFile, normalizeMode, normalizeOptions, fdMap, fd2file, normalizeTime, resolveFS, fixError, mounts } from './shared.js';
+import { ActionType, FileFlag } from '../file.js';
+import { BigIntStats, FileType } from '../stats.js';
+import { normalizePath, cred, getFdForFile, normalizeMode, normalizeOptions, fdMap, fd2file, normalizeTime, resolveFS, fixError, mounts, } from './shared.js';
 import { decode, encode } from '../utils.js';
+import { Dirent } from './dir.js';
+import { dirname, join } from './path.js';
 function doOp(...[name, resolveSymlinks, path, ...args]) {
     path = normalizePath(path);
     const { fs, path: resolvedPath } = resolveFS(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
@@ -36,6 +39,7 @@ export function renameSync(oldPath, newPath) {
         throw fixError(e, paths);
     }
 }
+renameSync;
 /**
  * Test whether or not the given path exists by checking with the file system.
  * @param path
@@ -53,35 +57,32 @@ export function existsSync(path) {
         throw e;
     }
 }
-/**
- * Synchronous `stat`.
- * @param path
- * @returns Stats
- */
-export function statSync(path) {
-    return doOp('statSync', true, path, cred);
+existsSync;
+export function statSync(path, options) {
+    const stats = doOp('statSync', true, path, cred);
+    return options?.bigint ? BigIntStats.clone(stats) : stats;
 }
-/**
- * Synchronous `lstat`.
- * `lstat()` is identical to `stat()`, except that if path is a symbolic link,
- * then the link itself is stat-ed, not the file that it refers to.
- * @param path
- * @return [ZenFS.node.fs.Stats]
- */
-export function lstatSync(path) {
-    return doOp('statSync', false, path, cred);
+statSync;
+export function lstatSync(path, options) {
+    const stats = doOp('statSync', false, path, cred);
+    return options?.bigint ? BigIntStats.clone(stats) : stats;
 }
+lstatSync;
 /**
  * Synchronous `truncate`.
  * @param path
  * @param len
  */
 export function truncateSync(path, len = 0) {
-    if (len < 0) {
-        throw new ApiError(ErrorCode.EINVAL);
+    const fd = openSync(path, 'r+');
+    try {
+        ftruncateSync(fd, len);
+    }
+    finally {
+        closeSync(fd);
     }
-    return doOp('truncateSync', true, path, len, cred);
 }
+truncateSync;
 /**
  * Synchronous `unlink`.
  * @param path
@@ -89,48 +90,147 @@ export function truncateSync(path, len = 0) {
 export function unlinkSync(path) {
     return doOp('unlinkSync', false, path, cred);
 }
+unlinkSync;
+function _openSync(_path, _flag, _mode, resolveSymlinks) {
+    const path = normalizePath(_path), mode = normalizeMode(_mode, 0o644), flag = FileFlag.FromString(_flag);
+    // Check if the path exists, and is a file.
+    let stats;
+    try {
+        stats = doOp('statSync', resolveSymlinks, path, cred);
+    }
+    catch (e) {
+        // File does not exist.
+        switch (flag.pathNotExistsAction()) {
+            case ActionType.CREATE:
+                // Ensure parent exists.
+                const parentStats = doOp('statSync', resolveSymlinks, dirname(path), cred);
+                if (!parentStats.isDirectory()) {
+                    throw ApiError.ENOTDIR(dirname(path));
+                }
+                return doOp('createFileSync', resolveSymlinks, path, flag, mode, cred);
+            case ActionType.THROW:
+                throw ApiError.ENOENT(path);
+            default:
+                throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
+        }
+    }
+    if (!stats.hasAccess(mode, cred)) {
+        throw ApiError.EACCES(path);
+    }
+    // File exists.
+    switch (flag.pathExistsAction()) {
+        case ActionType.THROW:
+            throw ApiError.EEXIST(path);
+        case ActionType.TRUNCATE:
+            // Delete file.
+            doOp('unlinkSync', resolveSymlinks, path, cred);
+            /*
+                Create file. Use the same mode as the old file.
+                Node itself modifies the ctime when this occurs, so this action
+                will preserve that behavior if the underlying file system
+                supports those properties.
+            */
+            return doOp('createFileSync', resolveSymlinks, path, flag, stats.mode, cred);
+        case ActionType.NOP:
+            return doOp('openFileSync', resolveSymlinks, path, flag, cred);
+        default:
+            throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
+    }
+}
 /**
  * Synchronous file open.
  * @see http://www.manpagez.com/man/2/open/
- * @param path
- * @param flags
- * @param mode defaults to `0644`
- * @return [ZenFS.File]
+ * @param flags Handles the complexity of the various file
+ *   modes. See its API for more details.
+ * @param mode Mode to use to open the file. Can be ignored if the
+ *   filesystem doesn't support permissions.
+ */
+export function openSync(path, flag, mode) {
+    return getFdForFile(_openSync(path, flag, mode, true));
+}
+openSync;
+/**
+ * Opens a file or symlink
+ * @internal
  */
-export function openSync(path, flag, mode = 0o644) {
-    const file = doOp('openSync', true, path, FileFlag.getFileFlag(flag), normalizeMode(mode, 0o644), cred);
-    return getFdForFile(file);
+export function lopenSync(path, flag, mode) {
+    return getFdForFile(_openSync(path, flag, mode, false));
+}
+/**
+ * Synchronously reads the entire contents of a file.
+ */
+function _readFileSync(fname, flag, resolveSymlinks) {
+    // Get file.
+    const file = _openSync(fname, flag, 0o644, resolveSymlinks);
+    try {
+        const stat = file.statSync();
+        // Allocate buffer.
+        const data = new Uint8Array(stat.size);
+        file.readSync(data, 0, stat.size, 0);
+        file.closeSync();
+        return data;
+    }
+    finally {
+        file.closeSync();
+    }
 }
 export function readFileSync(filename, arg2 = {}) {
-    const options = normalizeOptions(arg2, null, 'r', null);
-    const flag = FileFlag.getFileFlag(options.flag);
+    const options = normalizeOptions(arg2, null, 'r', 0o644);
+    const flag = FileFlag.FromString(options.flag);
     if (!flag.isReadable()) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed to readFile must allow for reading.');
     }
-    const data = doOp('readFileSync', true, filename, flag, cred);
-    switch (options.encoding) {
-        case 'utf8':
-        case 'utf-8':
-            return decode(data);
-        default:
-            return data;
+    const data = _readFileSync(filename, options.flag, true);
+    return options.encoding ? decode(data, options.encoding) : data;
+}
+readFileSync;
+/**
+ * Synchronously writes data to a file, replacing the file
+ * if it already exists.
+ *
+ * The encoding option is ignored if data is a buffer.
+ */
+function _writeFileSync(fname, data, flag, mode, resolveSymlinks) {
+    const file = _openSync(fname, flag, mode, resolveSymlinks);
+    try {
+        file.writeSync(data, 0, data.length, 0);
+    }
+    finally {
+        file.closeSync();
     }
 }
-export function writeFileSync(filename, data, arg3) {
-    const options = normalizeOptions(arg3, 'utf8', 'w', 0o644);
-    const flag = FileFlag.getFileFlag(options.flag);
+export function writeFileSync(filename, data, _options) {
+    const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
+    const flag = FileFlag.FromString(options.flag);
     if (!flag.isWriteable()) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed to writeFile must allow for writing.');
     }
     if (typeof data != 'string' && !options.encoding) {
         throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
     }
-    const encodedData = typeof data == 'string' ? encode(data) : data;
-    return doOp('writeFileSync', true, filename, encodedData, flag, options.mode, cred);
+    const encodedData = typeof data == 'string' ? encode(data, options.encoding) : data;
+    if (encodedData === undefined) {
+        throw new ApiError(ErrorCode.EINVAL, 'Data not specified');
+    }
+    _writeFileSync(filename, encodedData, options.flag, options.mode, true);
+}
+writeFileSync;
+/**
+ * Synchronously append data to a file, creating the file if
+ * it not yet exists.
+ */
+function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
+    const file = _openSync(fname, flag, mode, resolveSymlinks);
+    try {
+        file.writeSync(data, 0, data.length, null);
+    }
+    finally {
+        file.closeSync();
+    }
 }
 export function appendFileSync(filename, data, arg3) {
     const options = normalizeOptions(arg3, 'utf8', 'a', 0o644);
-    const flag = FileFlag.getFileFlag(options.flag);
+    const flag = FileFlag.FromString(options.flag);
     if (!flag.isAppendable()) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
     }
@@ -138,18 +238,14 @@ export function appendFileSync(filename, data, arg3) {
         throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
     }
     const encodedData = typeof data == 'string' ? encode(data) : data;
-    return doOp('appendFileSync', true, filename, encodedData, flag, options.mode, cred);
+    _appendFileSync(filename, encodedData, options.flag, options.mode, true);
 }
-/**
- * Synchronous `fstat`.
- * `fstat()` is identical to `stat()`, except that the file to be stat-ed is
- * specified by the file descriptor `fd`.
- * @param fd
- * @return [ZenFS.node.fs.Stats]
- */
-export function fstatSync(fd) {
-    return fd2file(fd).statSync();
+appendFileSync;
+export function fstatSync(fd, options) {
+    const stats = fd2file(fd).statSync();
+    return options?.bigint ? BigIntStats.clone(stats) : stats;
 }
+fstatSync;
 /**
  * Synchronous close.
  * @param fd
@@ -158,18 +254,19 @@ export function closeSync(fd) {
     fd2file(fd).closeSync();
     fdMap.delete(fd);
 }
+closeSync;
 /**
  * Synchronous ftruncate.
  * @param fd
  * @param len
  */
 export function ftruncateSync(fd, len = 0) {
-    const file = fd2file(fd);
     if (len < 0) {
         throw new ApiError(ErrorCode.EINVAL);
     }
-    file.truncateSync(len);
+    fd2file(fd).truncateSync(len);
 }
+ftruncateSync;
 /**
  * Synchronous fsync.
  * @param fd
@@ -177,6 +274,7 @@ export function ftruncateSync(fd, len = 0) {
 export function fsyncSync(fd) {
     fd2file(fd).syncSync();
 }
+fsyncSync;
 /**
  * Synchronous fdatasync.
  * @param fd
@@ -184,29 +282,31 @@ export function fsyncSync(fd) {
 export function fdatasyncSync(fd) {
     fd2file(fd).datasyncSync();
 }
-export function writeSync(fd, arg2, arg3, arg4, arg5) {
+fdatasyncSync;
+export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
     let buffer, offset = 0, length, position;
-    if (typeof arg2 === 'string') {
+    if (typeof data === 'string') {
         // Signature 1: (fd, string, [position?, [encoding?]])
-        position = typeof arg3 === 'number' ? arg3 : null;
-        const encoding = (typeof arg4 === 'string' ? arg4 : 'utf8');
+        position = typeof posOrOff === 'number' ? posOrOff : null;
+        const encoding = (typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
         offset = 0;
-        buffer = encode(arg2);
+        buffer = encode(data, encoding);
         length = buffer.length;
     }
     else {
         // Signature 2: (fd, buffer, offset, length, position?)
-        buffer = arg2;
-        offset = arg3;
-        length = arg4;
-        position = typeof arg5 === 'number' ? arg5 : null;
+        buffer = data;
+        offset = posOrOff;
+        length = lenOrEnc;
+        position = typeof pos === 'number' ? pos : null;
     }
     const file = fd2file(fd);
     if (position === undefined || position === null) {
-        position = file.getPos();
+        position = file.position;
     }
     return file.writeSync(buffer, offset, length, position);
 }
+writeSync;
 export function readSync(fd, buffer, opts, length, position) {
     const file = fd2file(fd);
     let offset = opts;
@@ -214,10 +314,11 @@ export function readSync(fd, buffer, opts, length, position) {
         ({ offset, length, position } = opts);
     }
     if (isNaN(+position)) {
-        position = file.getPos();
+        position = file.position;
     }
     return file.readSync(buffer, offset, length, position);
 }
+readSync;
 /**
  * Synchronous `fchown`.
  * @param fd
@@ -227,15 +328,20 @@ export function readSync(fd, buffer, opts, length, position) {
 export function fchownSync(fd, uid, gid) {
     fd2file(fd).chownSync(uid, gid);
 }
+fchownSync;
 /**
  * Synchronous `fchmod`.
  * @param fd
  * @param mode
  */
 export function fchmodSync(fd, mode) {
-    const numMode = typeof mode === 'string' ? parseInt(mode, 8) : mode;
+    const numMode = normalizeMode(mode, -1);
+    if (numMode < 0) {
+        throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
+    }
     fd2file(fd).chmodSync(numMode);
 }
+fchmodSync;
 /**
  * Change the file timestamps of a file referenced by the supplied file
  * descriptor.
@@ -246,7 +352,7 @@ export function fchmodSync(fd, mode) {
 export function futimesSync(fd, atime, mtime) {
     fd2file(fd).utimesSync(normalizeTime(atime), normalizeTime(mtime));
 }
-// DIRECTORY-ONLY METHODS
+futimesSync;
 /**
  * Synchronous `rmdir`.
  * @param path
@@ -254,66 +360,76 @@ export function futimesSync(fd, atime, mtime) {
 export function rmdirSync(path) {
     return doOp('rmdirSync', true, path, cred);
 }
-/**
- * Synchronous `mkdir`.
- * @param path
- * @param mode defaults to `0777`
- */
-export function mkdirSync(path, mode) {
+rmdirSync;
+export function mkdirSync(path, options) {
+    const mode = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
+    const recursive = typeof options == 'object' && options?.recursive;
     doOp('mkdirSync', true, path, normalizeMode(mode, 0o777), cred);
 }
-/**
- * Synchronous `readdir`. Reads the contents of a directory.
- * @param path
- * @return [String[]]
- */
-export function readdirSync(path) {
+mkdirSync;
+export function readdirSync(path, options) {
     path = normalizePath(path);
     const entries = doOp('readdirSync', true, path, cred);
-    const points = [...mounts.keys()];
-    for (const point of points) {
-        if (point.startsWith(path)) {
-            const entry = point.slice(path.length);
-            if (entry.includes('/') || entry.length == 0) {
-                // ignore FSs mounted in subdirectories and any FS mounted to `path`.
-                continue;
-            }
-            entries.push(entry);
+    for (const mount of mounts.keys()) {
+        if (!mount.startsWith(path)) {
+            continue;
+        }
+        const entry = mount.slice(path.length);
+        if (entry.includes('/') || entry.length == 0) {
+            // ignore FSs mounted in subdirectories and any FS mounted to `path`.
+            continue;
         }
+        entries.push(entry);
     }
-    return entries;
+    return entries.map((entry) => {
+        if (typeof options == 'object' && options?.withFileTypes) {
+            return new Dirent(entry, statSync(join(path, entry)));
+        }
+        if (options == 'buffer' || (typeof options == 'object' && options.encoding == 'buffer')) {
+            return encode(entry);
+        }
+        return entry;
+    });
 }
+readdirSync;
 // SYMLINK METHODS
 /**
  * Synchronous `link`.
- * @param srcpath
- * @param dstpath
+ * @param existing
+ * @param newpath
  */
-export function linkSync(srcpath, dstpath) {
-    dstpath = normalizePath(dstpath);
-    return doOp('linkSync', false, srcpath, dstpath, cred);
+export function linkSync(existing, newpath) {
+    newpath = normalizePath(newpath);
+    return doOp('linkSync', false, existing, newpath, cred);
 }
+linkSync;
 /**
  * Synchronous `symlink`.
- * @param srcpath
- * @param dstpath
+ * @param target target path
+ * @param path link path
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
-export function symlinkSync(srcpath, dstpath, type) {
+export function symlinkSync(target, path, type = 'file') {
     if (!['file', 'dir', 'junction'].includes(type)) {
         throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
     }
-    dstpath = normalizePath(dstpath);
-    return doOp('symlinkSync', false, srcpath, dstpath, type, cred);
-}
-/**
- * Synchronous readlink.
- * @param path
- * @return [String]
- */
-export function readlinkSync(path) {
-    return doOp('readlinkSync', false, path, cred);
+    if (existsSync(path)) {
+        throw ApiError.EEXIST(path);
+    }
+    writeFileSync(path, target);
+    const file = _openSync(path, 'r+', 0o644, false);
+    file._setTypeSync(FileType.SYMLINK);
+}
+symlinkSync;
+export function readlinkSync(path, options) {
+    const value = _readFileSync(path, 'r', false);
+    const encoding = typeof options == 'object' ? options.encoding : options;
+    if (encoding == 'buffer') {
+        return value;
+    }
+    return decode(value, encoding);
 }
+readlinkSync;
 // PROPERTY OPERATIONS
 /**
  * Synchronous `chown`.
@@ -322,8 +438,11 @@ export function readlinkSync(path) {
  * @param gid
  */
 export function chownSync(path, uid, gid) {
-    doOp('chownSync', true, path, uid, gid, cred);
+    const fd = openSync(path, 'r+');
+    fchownSync(fd, uid, gid);
+    closeSync(fd);
 }
+chownSync;
 /**
  * Synchronous `lchown`.
  * @param path
@@ -331,32 +450,33 @@ export function chownSync(path, uid, gid) {
  * @param gid
  */
 export function lchownSync(path, uid, gid) {
-    doOp('chownSync', false, path, uid, gid, cred);
+    const fd = lopenSync(path, 'r+');
+    fchownSync(fd, uid, gid);
+    closeSync(fd);
 }
+lchownSync;
 /**
  * Synchronous `chmod`.
  * @param path
  * @param mode
  */
 export function chmodSync(path, mode) {
-    const numMode = normalizeMode(mode, -1);
-    if (numMode < 0) {
-        throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
-    }
-    doOp('chmodSync', true, path, numMode, cred);
+    const fd = openSync(path, 'r+');
+    fchmodSync(fd, mode);
+    closeSync(fd);
 }
+chmodSync;
 /**
  * Synchronous `lchmod`.
  * @param path
  * @param mode
  */
 export function lchmodSync(path, mode) {
-    const numMode = normalizeMode(mode, -1);
-    if (numMode < 1) {
-        throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
-    }
-    doOp('chmodSync', false, path, numMode, cred);
+    const fd = lopenSync(path, 'r+');
+    fchmodSync(fd, mode);
+    closeSync(fd);
 }
+lchmodSync;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
@@ -364,8 +484,11 @@ export function lchmodSync(path, mode) {
  * @param mtime
  */
 export function utimesSync(path, atime, mtime) {
-    doOp('utimesSync', true, path, normalizeTime(atime), normalizeTime(mtime), cred);
+    const fd = openSync(path, 'r+');
+    futimesSync(fd, atime, mtime);
+    closeSync(fd);
 }
+utimesSync;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
@@ -373,17 +496,12 @@ export function utimesSync(path, atime, mtime) {
  * @param mtime
  */
 export function lutimesSync(path, atime, mtime) {
-    doOp('utimesSync', false, path, normalizeTime(atime), normalizeTime(mtime), cred);
+    const fd = lopenSync(path, 'r+');
+    futimesSync(fd, atime, mtime);
+    closeSync(fd);
 }
-/**
- * Synchronous `realpath`.
- * @param path
- * @param cache An object literal of mapped paths that can be used to
- *   force a specific path resolution or avoid additional `fs.stat` calls for
- *   known real paths.
- * @return [String]
- */
-export function realpathSync(path, cache = {}) {
+lutimesSync;
+export function realpathSync(path, options) {
     path = normalizePath(path);
     const { fs, path: resolvedPath, mountPoint } = resolveFS(path);
     try {
@@ -391,18 +509,47 @@ export function realpathSync(path, cache = {}) {
         if (!stats.isSymbolicLink()) {
             return path;
         }
-        const dst = normalizePath(mountPoint + fs.readlinkSync(resolvedPath, cred));
+        const dst = normalizePath(mountPoint + decode(_readFileSync(resolvedPath, 'r+', false)));
         return realpathSync(dst);
     }
     catch (e) {
         throw fixError(e, { [resolvedPath]: path });
     }
 }
+realpathSync;
 /**
  * Synchronous `access`.
  * @param path
  * @param mode
  */
 export function accessSync(path, mode = 0o600) {
-    return doOp('accessSync', true, path, mode, cred);
+    const stats = statSync(path);
+    if (!stats.hasAccess(mode, cred)) {
+        throw new ApiError(ErrorCode.EACCES);
+    }
+}
+accessSync;
+export function rmSync(path) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+rmSync;
+export function mkdtempSync(prefix, options) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+mkdtempSync;
+export function copyFileSync(src, dest, flags) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+copyFileSync;
+export function readvSync(fd, buffers, position) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+readvSync;
+export function writevSync(fd, buffers, position) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+writevSync;
+export function opendirSync(path, options) {
+    throw new ApiError(ErrorCode.ENOTSUP);
 }
+opendirSync;