@zenfs/core 0.5.2 → 0.5.3

package/dist/emulation/promises.d.ts

@@ -49,13 +49,13 @@ export declare class FileHandle implements BufferToUint8Array<Node.promises.File
      * Asynchronously append data to a file, creating the file if it does not exist. The underlying file will _not_ be closed automatically.
      * The `FileHandle` must have been opened for appending.
      * @param data The data to write. If something other than a `Buffer` or `Uint8Array` is provided, the value is coerced to a string.
-     * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
+     * @param _options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
      * If `encoding` is not supplied, the default of `'utf8'` is used.
      * If `mode` is not supplied, the default of `0o666` is used.
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'a'` is used.
      */
-    appendFile(data: string | Uint8Array, options?: {
+    appendFile(data: string | Uint8Array, _options?: {
         encoding?: BufferEncoding;
         mode?: Node.Mode;
         flag?: Node.OpenMode;
@@ -75,13 +75,13 @@ export declare class FileHandle implements BufferToUint8Array<Node.promises.File
     /**
      * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
      * The `FileHandle` must have been opened for reading.
-     * @param options An object that may contain an optional flag.
+     * @param _options An object that may contain an optional flag.
      * If a flag is not provided, it defaults to `'r'`.
      */
-    readFile(options?: {
+    readFile(_options?: {
         flag?: Node.OpenMode;
     }): Promise<Uint8Array>;
-    readFile(options: {
+    readFile(_options: {
         encoding: BufferEncoding;
         flag?: Node.OpenMode;
     } | BufferEncoding): Promise<string>;
@@ -126,13 +126,13 @@ export declare class FileHandle implements BufferToUint8Array<Node.promises.File
      * The `FileHandle` must have been opened for writing.
      * It is unsafe to call `writeFile()` multiple times on the same file without waiting for the `Promise` to be resolved (or rejected).
      * @param data The data to write. If something other than a `Buffer` or `Uint8Array` is provided, the value is coerced to a string.
-     * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
+     * @param _options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
      * If `encoding` is not supplied, the default of `'utf8'` is used.
      * If `mode` is not supplied, the default of `0o666` is used.
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'w'` is used.
      */
-    writeFile(data: string | Uint8Array, options?: Node.WriteFileOptions): Promise<void>;
+    writeFile(data: string | Uint8Array, _options?: Node.WriteFileOptions): Promise<void>;
     /**
      * See `fs.writev` promisified version.
      */

package/dist/emulation/promises.js

@@ -65,14 +65,23 @@ export class FileHandle {
      * Asynchronously append data to a file, creating the file if it does not exist. The underlying file will _not_ be closed automatically.
      * The `FileHandle` must have been opened for appending.
      * @param data The data to write. If something other than a `Buffer` or `Uint8Array` is provided, the value is coerced to a string.
-     * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
+     * @param _options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
      * If `encoding` is not supplied, the default of `'utf8'` is used.
      * If `mode` is not supplied, the default of `0o666` is used.
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'a'` is used.
      */
-    appendFile(data, options) {
-        return appendFile(fd2file(this.fd).path, data, options);
+    async appendFile(data, _options) {
+        const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
+        const flag = parseFlag(options.flag);
+        if (!isAppendable(flag)) {
+            throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
+        }
+        if (typeof data != 'string' && !options.encoding) {
+            throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+        }
+        const encodedData = typeof data == 'string' ? encode(data) : data;
+        await fd2file(this.fd).write(encodedData, 0, encodedData.length, null);
     }
     /**
      * Asynchronously reads data from the file.
@@ -88,11 +97,20 @@ export class FileHandle {
         }
         return fd2file(this.fd).read(buffer, offset, length, position);
     }
-    readFile(options) {
-        return readFile(fd2file(this.fd).path, options);
+    async readFile(_options) {
+        const options = normalizeOptions(_options, null, 'r', null);
+        const flag = parseFlag(options.flag);
+        if (!isReadable(flag)) {
+            throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
+        }
+        const { size } = await this.stat();
+        const data = new Uint8Array(size);
+        await fd2file(this.fd).read(data, 0, size, 0);
+        return options.encoding ? decode(data, options.encoding) : data;
     }
-    stat(opts) {
-        return stat(fd2file(this.fd).path, opts);
+    async stat(opts) {
+        const stats = await fd2file(this.fd).stat();
+        return opts?.bigint ? new BigIntStats(stats) : stats;
     }
     async write(data, posOrOff, lenOrEnc, position) {
         let buffer, offset = 0, length;
@@ -120,14 +138,23 @@ export class FileHandle {
      * The `FileHandle` must have been opened for writing.
      * It is unsafe to call `writeFile()` multiple times on the same file without waiting for the `Promise` to be resolved (or rejected).
      * @param data The data to write. If something other than a `Buffer` or `Uint8Array` is provided, the value is coerced to a string.
-     * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
+     * @param _options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
      * If `encoding` is not supplied, the default of `'utf8'` is used.
      * If `mode` is not supplied, the default of `0o666` is used.
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'w'` is used.
      */
-    writeFile(data, options) {
-        return writeFile(fd2file(this.fd).path, data, options);
+    async writeFile(data, _options) {
+        const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
+        const flag = parseFlag(options.flag);
+        if (!isWriteable(flag)) {
+            throw new ApiError(ErrorCode.EINVAL, 'Flag passed 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, options.encoding) : data;
+        await fd2file(this.fd).write(encodedData, 0, encodedData.length, 0);
     }
     /**
      * See `fs.writev` promisified version.
@@ -323,6 +350,7 @@ async function _readFile(fname, flag, resolveSymlinks) {
     }
     catch (e) {
         await file.close();
+        throw e;
     }
 }
 export async function readFile(filename, _options) {
@@ -335,21 +363,6 @@ export async function readFile(filename, _options) {
     return options.encoding ? decode(data, options.encoding) : data;
 }
 readFile;
-/**
- * Asynchronously writes data to a file, replacing the file
- * if it already exists.
- *
- * The encoding option is ignored if data is a buffer.
- */
-async function _writeFile(fname, data, flag, mode, resolveSymlinks) {
-    const file = await _open(fname, flag, mode, resolveSymlinks);
-    try {
-        await file.write(data, 0, data.length, 0);
-    }
-    finally {
-        await file.close();
-    }
-}
 /**
  * Synchronously writes data to a file, replacing the file if it already exists.
  *
@@ -363,15 +376,13 @@ async function _writeFile(fname, data, flag, mode, resolveSymlinks) {
  */
 export async function writeFile(filename, data, _options) {
     const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
-    const flag = parseFlag(options.flag);
-    if (!isWriteable(flag)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for writing.');
+    const handle = await open(filename, options.flag, options.mode);
+    try {
+        await handle.writeFile(data, options);
     }
-    if (typeof data != 'string' && !options.encoding) {
-        throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+    finally {
+        await handle.close();
     }
-    const encodedData = typeof data == 'string' ? encode(data, options.encoding) : data;
-    await _writeFile(filename, encodedData, options.flag, options.mode, true);
 }
 writeFile;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.5.2",
+	"version": "0.5.3",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "dist",