@zenfs/core 0.9.6 → 0.9.7

package/dist/emulation/promises.js

@@ -6,7 +6,7 @@ import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '.
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
 import { dirname, join, parse } from './path.js';
-import { cred, fd2file, fdMap, fixError, getFdForFile, mounts, resolveMount } from './shared.js';
+import { cred, fd2file, fdMap, file2fd, fixError, mounts, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
 export class FileHandle {
@@ -57,6 +57,7 @@ export class FileHandle {
      * @param len If not specified, defaults to `0`.
      */
     truncate(len) {
+        len || (len = 0);
         if (len < 0) {
             throw new ApiError(ErrorCode.EINVAL);
         }
@@ -80,7 +81,7 @@ export class FileHandle {
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'a'` is used.
      */
-    async appendFile(data, _options) {
+    async appendFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = parseFlag(options.flag);
         if (!isAppendable(flag)) {
@@ -106,7 +107,7 @@ export class FileHandle {
         }
         return this.file.read(buffer, offset, length, position);
     }
-    async readFile(_options) {
+    async readFile(_options = {}) {
         const options = normalizeOptions(_options, null, 'r', 0o444);
         const flag = parseFlag(options.flag);
         if (!isReadable(flag)) {
@@ -129,14 +130,14 @@ export class FileHandle {
      * @since v17.0.0
      * @experimental
      */
-    readableWebStream(options) {
+    readableWebStream(options = {}) {
         // Note: using an arrow function to preserve `this`
         const start = async ({ close, enqueue, error }) => {
             try {
                 const chunkSize = 64 * 1024, maxChunks = 1e7;
-                let i = 0, position = 0, result;
-                while (result.bytesRead > 0) {
-                    result = await this.read(new Uint8Array(chunkSize), 0, chunkSize, position);
+                let i = 0, position = 0, bytesRead = NaN;
+                while (bytesRead > 0) {
+                    const result = await this.read(new Uint8Array(chunkSize), 0, chunkSize, position);
                     if (!result.bytesRead) {
                         close();
                         return;
@@ -146,6 +147,7 @@ export class FileHandle {
                     if (++i >= maxChunks) {
                         throw new ApiError(ErrorCode.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
                     }
+                    bytesRead = result.bytesRead;
                 }
             }
             catch (e) {
@@ -165,7 +167,7 @@ export class FileHandle {
         return opts?.bigint ? new BigIntStats(stats) : stats;
     }
     async write(data, posOrOff, lenOrEnc, position) {
-        let buffer, offset = 0, length;
+        let buffer, offset, length;
         if (typeof data === 'string') {
             // Signature 1: (fd, string, [position?, [encoding?]])
             position = typeof posOrOff === 'number' ? posOrOff : null;
@@ -176,7 +178,7 @@ export class FileHandle {
         }
         else {
             // Signature 2: (fd, buffer, offset, length, position?)
-            buffer = data;
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
             offset = posOrOff;
             length = lenOrEnc;
             position = typeof position === 'number' ? position : null;
@@ -196,7 +198,7 @@ export class FileHandle {
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'w'` is used.
      */
-    async writeFile(data, _options) {
+    async writeFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
         const flag = parseFlag(options.flag);
         if (!isWriteable(flag)) {
@@ -248,9 +250,9 @@ export class FileHandle {
      * @returns A `ReadStream` object.
      */
     createReadStream(options) {
-        const streamOptions = {
+        const stream = new ReadStream({
             highWaterMark: options?.highWaterMark || 64 * 1024,
-            encoding: options?.encoding,
+            encoding: options.encoding,
             read: async (size) => {
                 try {
                     const result = await this.read(new Uint8Array(size), 0, size, this.file.position);
@@ -261,8 +263,7 @@ export class FileHandle {
                     stream.destroy(error);
                 }
             },
-        };
-        const stream = new ReadStream(streamOptions);
+        });
         stream.path = this.file.path;
         return stream;
     }
@@ -356,12 +357,12 @@ export async function exists(_path) {
     }
 }
 export async function stat(path, options) {
-    const stats = await doOp('stat', true, path, cred);
+    const stats = await doOp('stat', true, path.toString(), cred);
     return options?.bigint ? new BigIntStats(stats) : stats;
 }
 stat;
 export async function lstat(path, options) {
-    const stats = await doOp('stat', false, path, cred);
+    const stats = await doOp('stat', false, path.toString(), cred);
     return options?.bigint ? new BigIntStats(stats) : stats;
 }
 lstat;
@@ -386,7 +387,7 @@ truncate;
  * @param path
  */
 export async function unlink(path) {
-    return doOp('unlink', false, path, cred);
+    return doOp('unlink', false, path.toString(), cred);
 }
 unlink;
 /**
@@ -442,19 +443,11 @@ async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
  * @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 async function open(path, flag, mode = 0o644) {
+export async function open(path, flag = 'r', mode = 0o644) {
     const file = await _open(path, flag, mode, true);
-    return new FileHandle(getFdForFile(file));
+    return new FileHandle(file2fd(file));
 }
 open;
-/**
- * Opens a file without resolving symlinks
- * @internal
- */
-export async function lopen(path, flag, mode = 0o644) {
-    const file = await _open(path, flag, mode, false);
-    return new FileHandle(getFdForFile(file));
-}
 /**
  * Asynchronously reads the entire contents of a file.
  */
@@ -472,13 +465,14 @@ async function _readFile(fname, flag, resolveSymlinks) {
         throw e;
     }
 }
-export async function readFile(filename, _options) {
+export async function readFile(path, _options) {
     const options = normalizeOptions(_options, null, 'r', 0);
     const flag = parseFlag(options.flag);
     if (!isReadable(flag)) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
     }
-    const data = Buffer.from(await _readFile(filename, options.flag, true));
+    path = path instanceof FileHandle ? path.file.path : path.toString();
+    const data = Buffer.from(await _readFile(path, options.flag, true));
     return options.encoding ? data.toString(options.encoding) : data;
 }
 readFile;
@@ -486,18 +480,22 @@ readFile;
  * Asynchronously writes data to a file, replacing the file if it already exists.
  *
  * The encoding option is ignored if data is a buffer.
- * @param filename
- * @param data
+ * @param path
+ * @param data Note:
  * @param _options
  * @option options encoding Defaults to `'utf8'`.
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'w'`.
  */
-export async function writeFile(filename, data, _options) {
+export async function writeFile(path, data, _options) {
     const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-    const handle = await open(filename, options.flag, options.mode);
+    const handle = path instanceof FileHandle ? path : await open(path.toString(), options.flag, options.mode);
     try {
-        await handle.writeFile(data, options);
+        const _data = typeof data == 'string' ? data : data;
+        if (typeof _data != 'string' && !(_data instanceof Uint8Array)) {
+            throw new ApiError(ErrorCode.EINVAL, 'Iterables and streams not supported', handle.file.path, 'writeFile');
+        }
+        await handle.writeFile(_data, options);
     }
     finally {
         await handle.close();
@@ -508,8 +506,8 @@ writeFile;
  * Asynchronously append data to a file, creating the file if
  * it not yet exists.
  */
-async function _appendFile(fname, data, flag, mode, resolveSymlinks) {
-    const file = await _open(fname, flag, mode, resolveSymlinks);
+async function _appendFile(path, data, flag, mode, resolveSymlinks) {
+    const file = await _open(path, flag, mode, resolveSymlinks);
     try {
         await file.write(data, 0, data.length, null);
     }
@@ -520,14 +518,14 @@ async function _appendFile(fname, data, flag, mode, resolveSymlinks) {
 /**
  * Asynchronously append data to a file, creating the file if it not yet
  * exists.
- * @param filename
+ * @param path
  * @param data
  * @param options
  * @option options encoding Defaults to `'utf8'`.
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export async function appendFile(filename, data, _options) {
+export async function appendFile(path, data, _options) {
     const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
     const flag = parseFlag(options.flag);
     if (!isAppendable(flag)) {
@@ -536,8 +534,8 @@ export async function appendFile(filename, data, _options) {
     if (typeof data != 'string' && !options.encoding) {
         throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
     }
-    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-    await _appendFile(filename, encodedData, options.flag, options.mode, true);
+    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    await _appendFile(path instanceof FileHandle ? path.file.path : path.toString(), encodedData, options.flag, options.mode, true);
 }
 appendFile;
 // DIRECTORY-ONLY METHODS
@@ -546,11 +544,12 @@ appendFile;
  * @param path
  */
 export async function rmdir(path) {
-    return doOp('rmdir', true, path, cred);
+    return doOp('rmdir', true, path.toString(), cred);
 }
 rmdir;
-export async function mkdir(path, mode) {
-    await doOp('mkdir', true, path, normalizeMode(typeof mode == 'object' ? mode?.mode : mode, 0o777), cred);
+export async function mkdir(path, options) {
+    await doOp('mkdir', true, path.toString(), normalizeMode(typeof options == 'object' ? options?.mode : options, 0o777), cred);
+    return;
 }
 mkdir;
 export async function readdir(path, options) {
@@ -582,7 +581,7 @@ readdir;
  */
 export async function link(existing, newpath) {
     newpath = normalizePath(newpath);
-    return doOp('link', false, existing, newpath, cred);
+    return doOp('link', false, existing.toString(), newpath, cred);
 }
 link;
 /**
@@ -596,20 +595,17 @@ export async function symlink(target, path, type = 'file') {
         throw new ApiError(ErrorCode.EINVAL, 'Invalid symlink type: ' + type);
     }
     if (await exists(path)) {
-        throw ApiError.With('EEXIST', path, 'symlink');
+        throw ApiError.With('EEXIST', path.toString(), 'symlink');
     }
-    await writeFile(path, target);
+    await writeFile(path, target.toString());
     const file = await _open(path, 'r+', 0o644, false);
     await file._setType(FileType.SYMLINK);
 }
 symlink;
 export async function readlink(path, options) {
-    const value = Buffer.from(await _readFile(path, 'r', false));
-    const encoding = typeof options == 'object' ? options.encoding : options;
-    if (encoding == 'buffer') {
-        return value;
-    }
-    return value.toString(encoding);
+    const value = Buffer.from(await _readFile(path.toString(), 'r', false));
+    const encoding = typeof options == 'object' ? options?.encoding : options;
+    return encoding == 'buffer' ? value : value.toString(encoding);
 }
 readlink;
 // PROPERTY OPERATIONS
@@ -636,12 +632,12 @@ chown;
  * @param gid
  */
 export async function lchown(path, uid, gid) {
-    const handle = await lopen(path, 'r+');
+    const file = await _open(path, 'r+', 0o644, false);
     try {
-        await handle.chown(uid, gid);
+        await file.chown(uid, gid);
     }
     finally {
-        await handle.close();
+        await file.close();
     }
 }
 lchown;
@@ -666,12 +662,12 @@ chmod;
  * @param mode
  */
 export async function lchmod(path, mode) {
-    const handle = await lopen(path, 'r+');
+    const file = await _open(path, 'r+', 0o644, false);
     try {
-        await handle.chmod(mode);
+        await new FileHandle(file2fd(file)).chmod(mode);
     }
     finally {
-        await handle.close();
+        await file.close();
     }
 }
 lchmod;
@@ -698,12 +694,12 @@ utimes;
  * @param mtime
  */
 export async function lutimes(path, atime, mtime) {
-    const handle = await lopen(path, 'r+');
+    const file = await _open(path, 'r+', 0o644, false);
     try {
-        await handle.utimes(atime, mtime);
+        await file.utimes(new Date(atime), new Date(mtime));
     }
     finally {
-        await handle.close();
+        await file.close();
     }
 }
 lutimes;
@@ -724,8 +720,8 @@ export async function realpath(path, options) {
     }
 }
 realpath;
-export function watch(filename, options) {
-    throw ApiError.With('ENOSYS', filename, 'watch');
+export function watch(filename, options = {}) {
+    throw ApiError.With('ENOSYS', filename.toString(), 'watch');
 }
 watch;
 /**
@@ -770,7 +766,7 @@ export async function rm(path, options) {
 }
 rm;
 export async function mkdtemp(prefix, options) {
-    const encoding = typeof options === 'object' ? options.encoding : options || 'utf8';
+    const encoding = typeof options === 'object' ? options?.encoding : options || 'utf8';
     const fsName = `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const resolvedPath = '/tmp/' + fsName;
     await mkdir(resolvedPath);
@@ -854,5 +850,5 @@ export async function cp(source, destination, opts) {
 }
 cp;
 export async function statfs(path, opts) {
-    throw ApiError.With('ENOSYS', path, 'statfs');
+    throw ApiError.With('ENOSYS', path.toString(), 'statfs');
 }

package/dist/emulation/shared.d.ts

@@ -4,7 +4,7 @@ import { FileSystem } from '../filesystem.js';
 export declare let cred: Cred;
 export declare function setCred(val: Cred): void;
 export declare const fdMap: Map<number, File>;
-export declare function getFdForFile(file: File): number;
+export declare function file2fd(file: File): number;
 export declare function fd2file(fd: number): File;
 export interface MountMapping {
     [point: string]: FileSystem;
@@ -40,9 +40,3 @@ export declare function fixError<E extends Error>(e: E, paths: {
     [from: string]: string;
 }): E;
 export declare function mountMapping(mountMapping: MountMapping): void;
-/**
- * Types supports as path parameters.
- *
- * In the future, maybe support URL?
- */
-export type PathLike = string;

package/dist/emulation/shared.js

@@ -12,7 +12,7 @@ export function setCred(val) {
 // descriptors
 export const fdMap = new Map();
 let nextFd = 100;
-export function getFdForFile(file) {
+export function file2fd(file) {
     const fd = nextFd++;
     fdMap.set(fd, file);
     return fd;

package/dist/emulation/streams.js

@@ -1,4 +1,5 @@
 import { Readable, Writable } from 'readable-stream';
+import { ApiError, ErrorCode } from '../ApiError.js';
 export class ReadStream extends Readable {
     close(callback = () => null) {
         try {
@@ -7,7 +8,7 @@ export class ReadStream extends Readable {
             callback();
         }
         catch (err) {
-            callback(err);
+            callback(new ApiError(ErrorCode.EIO, err.toString()));
         }
     }
 }
@@ -19,7 +20,7 @@ export class WriteStream extends Writable {
             callback();
         }
         catch (err) {
-            callback(err);
+            callback(new ApiError(ErrorCode.EIO, err.toString()));
         }
     }
 }