@zenfs/core 0.5.3 → 0.5.5

package/dist/emulation/promises.d.ts

@@ -214,10 +214,9 @@ export declare function lopen(path: PathLike, flag: string, mode?: Node.Mode): P
 export declare function readFile(filename: PathLike, options?: {
     flag?: Node.OpenMode;
 }): Promise<Uint8Array>;
-export declare function readFile(filename: PathLike, options: {
-    encoding?: BufferEncoding;
+export declare function readFile(filename: PathLike, options: (Node.BaseEncodingOptions & {
     flag?: Node.OpenMode;
-} | BufferEncoding): Promise<string>;
+}) | BufferEncoding): Promise<string>;
 /**
  * Synchronously writes data to a file, replacing the file if it already exists.
  *

package/dist/emulation/promises.js

@@ -6,6 +6,7 @@ import { BigIntStats, FileType } from '../stats.js';
 import { decode, encode } from '../utils.js';
 import { Dirent } from './dir.js';
 import { dirname, join } from './path.js';
+import { F_OK } from './constants.js';
 export class FileHandle {
     constructor(
     /**
@@ -98,7 +99,7 @@ export class FileHandle {
         return fd2file(this.fd).read(buffer, offset, length, position);
     }
     async readFile(_options) {
-        const options = normalizeOptions(_options, null, 'r', null);
+        const options = normalizeOptions(_options, null, 'r', 0o444);
         const flag = parseFlag(options.flag);
         if (!isReadable(flag)) {
             throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
@@ -208,15 +209,18 @@ async function doOp(...[name, resolveSymlinks, rawPath, ...args]) {
 export async function rename(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
     newPath = normalizePath(newPath);
-    const { path: old } = resolveFS(oldPath);
-    const { fs, path } = resolveFS(newPath);
+    const src = resolveFS(oldPath);
+    const dst = resolveFS(newPath);
     try {
-        const data = await readFile(oldPath);
-        await writeFile(newPath, data);
+        if (src.mountPoint == dst.mountPoint) {
+            await src.fs.rename(src.path, dst.path, cred);
+            return;
+        }
+        await writeFile(newPath, await readFile(oldPath));
         await unlink(oldPath);
     }
     catch (e) {
-        throw fixError(e, { [old]: oldPath, [path]: newPath });
+        throw fixError(e, { [src.path]: oldPath, [dst.path]: newPath });
     }
 }
 rename;
@@ -279,7 +283,7 @@ async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
     try {
         switch (pathExistsAction(flag)) {
             case ActionType.THROW:
-                throw ApiError.EEXIST(path);
+                throw ApiError.With('EEXIST', path, '_open');
             case ActionType.TRUNCATE:
                 /*
                     In a previous implementation, we deleted the file and
@@ -307,11 +311,11 @@ async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
                 // Ensure parent exists.
                 const parentStats = await doOp('stat', resolveSymlinks, dirname(path), cred);
                 if (parentStats && !parentStats.isDirectory()) {
-                    throw ApiError.ENOTDIR(dirname(path));
+                    throw ApiError.With('ENOTDIR', dirname(path), '_open');
                 }
                 return await doOp('createFile', resolveSymlinks, path, flag, mode, cred);
             case ActionType.THROW:
-                throw ApiError.ENOENT(path);
+                throw ApiError.With('ENOENT', path, '_open');
             default:
                 throw new ApiError(ErrorCode.EINVAL, 'Invalid file flag');
         }
@@ -527,7 +531,7 @@ export async function symlink(target, path, type = 'file') {
         throw new ApiError(ErrorCode.EINVAL, 'Invalid symlink type: ' + type);
     }
     if (await exists(path)) {
-        throw ApiError.EEXIST(path);
+        throw ApiError.With('EEXIST', path, 'symlink');
     }
     await writeFile(path, target);
     const file = await _open(path, 'r+', 0o644, false);
@@ -668,7 +672,7 @@ export async function watch(filename, arg2, listener = nop) {
  * @param path
  * @param mode
  */
-export async function access(path, mode = 0o600) {
+export async function access(path, mode = F_OK) {
     const stats = await stat(path);
     if (!stats.hasAccess(mode, cred)) {
         throw new ApiError(ErrorCode.EACCES);

package/dist/emulation/shared.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { Cred } from '../cred.js';
 import { FileSystem } from '../filesystem.js';
 import type { File } from '../file.js';
+import type { BaseEncodingOptions, OpenMode, WriteFileOptions } from 'node:fs';
 /**
  * converts Date or number to a integer UNIX timestamp
  * Grabbed from NodeJS sources (lib/fs.js)
@@ -26,9 +28,15 @@ export declare function normalizeTime(time: string | number | Date): Date;
 export declare function normalizePath(p: string): string;
 /**
  * Normalizes options
+ * @param options options to normalize
+ * @param encoding default encoding
+ * @param flag default flag
+ * @param mode default mode
  * @internal
  */
-export declare function normalizeOptions(options: unknown, defEnc: string | null, defFlag: string, defMode: number | null): {
+export declare function normalizeOptions(options?: WriteFileOptions | (BaseEncodingOptions & {
+    flag?: OpenMode;
+}), encoding?: BufferEncoding, flag?: string, mode?: number): {
     encoding: BufferEncoding;
     flag: string;
     mode: number;

package/dist/emulation/shared.js

@@ -23,16 +23,14 @@ export function _toUnixTimestamp(time) {
  * @internal
  */
 export function normalizeMode(mode, def) {
-    switch (typeof mode) {
-        case 'number':
-            // (path, flag, mode, cb?)
-            return mode;
-        case 'string':
-            // (path, flag, modeString, cb?)
-            const trueMode = parseInt(mode, 8);
-            if (!isNaN(trueMode)) {
-                return trueMode;
-            }
+    if (typeof mode == 'number') {
+        return mode;
+    }
+    if (typeof mode == 'string') {
+        const parsed = parseInt(mode, 8);
+        if (!isNaN(parsed)) {
+            return parsed;
+        }
     }
     if (typeof def == 'number') {
         return def;
@@ -61,45 +59,35 @@ export function normalizeTime(time) {
  */
 export function normalizePath(p) {
     // Node doesn't allow null characters in paths.
-    if (p.indexOf('\u0000') >= 0) {
+    if (p.includes('\x00')) {
         throw new ApiError(ErrorCode.EINVAL, 'Path must be a string without null bytes.');
     }
-    if (p === '') {
+    if (p.length == 0) {
         throw new ApiError(ErrorCode.EINVAL, 'Path must not be empty.');
     }
-    p = p.replaceAll(/\/+/g, '/');
-    return resolve(p);
+    return resolve(p.replaceAll(/[/\\]+/g, '/'));
 }
 /**
  * Normalizes options
+ * @param options options to normalize
+ * @param encoding default encoding
+ * @param flag default flag
+ * @param mode default mode
  * @internal
  */
-export function normalizeOptions(options, defEnc, defFlag, defMode) {
-    // typeof null === 'object' so special-case handing is needed.
-    switch (options === null ? 'null' : typeof options) {
-        case 'object':
-            return {
-                encoding: typeof options['encoding'] !== 'undefined' ? options['encoding'] : defEnc,
-                flag: typeof options['flag'] !== 'undefined' ? options['flag'] : defFlag,
-                mode: normalizeMode(options['mode'], defMode),
-            };
-        case 'string':
-            return {
-                encoding: options,
-                flag: defFlag,
-                mode: defMode,
-            };
-        case 'null':
-        case 'undefined':
-        case 'function':
-            return {
-                encoding: defEnc,
-                flag: defFlag,
-                mode: defMode,
-            };
-        default:
-            throw new TypeError(`"options" must be a string or an object, got ${typeof options} instead.`);
-    }
+export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
+    if (typeof options != 'object' || options === null) {
+        return {
+            encoding: typeof options == 'string' ? options : encoding,
+            flag,
+            mode,
+        };
+    }
+    return {
+        encoding: typeof options?.encoding == 'string' ? options.encoding : encoding,
+        flag: typeof options?.flag == 'string' ? options.flag : flag,
+        mode: normalizeMode('mode' in options ? options?.mode : null, mode),
+    };
 }
 /**
  * Do nothing

package/dist/emulation/sync.d.ts

@@ -76,11 +76,9 @@ export declare function lopenSync(path: PathLike, flag: string, mode?: Node.Mode
 export declare function readFileSync(filename: string, options?: {
     flag?: string;
 }): Uint8Array;
-export declare function readFileSync(filename: string, options: {
-    encoding: string;
+export declare function readFileSync(filename: string, options: (Node.BaseEncodingOptions & {
     flag?: string;
-}): string;
-export declare function readFileSync(filename: string, encoding: string): string;
+}) | BufferEncoding): string;
 /**
  * Synchronously writes data to a file, replacing the file if it already
  * exists.
@@ -106,8 +104,7 @@ export declare function writeFileSync(filename: string, data: FileContents, enco
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export declare function appendFileSync(filename: string, data: FileContents, options?: Node.WriteFileOptions): void;
-export declare function appendFileSync(filename: string, data: FileContents, encoding?: string): void;
+export declare function appendFileSync(filename: string, data: FileContents, arg3?: Node.WriteFileOptions): void;
 /**
  * Synchronous `fstat`.
  * `fstat()` is identical to `stat()`, except that the file to be stat-ed is

package/dist/emulation/sync.js

@@ -31,8 +31,7 @@ export function renameSync(oldPath, newPath) {
         if (_old === _new) {
             return _old.fs.renameSync(_old.path, _new.path, cred);
         }
-        const data = readFileSync(oldPath);
-        writeFileSync(newPath, data);
+        writeFileSync(newPath, readFileSync(oldPath));
         unlinkSync(oldPath);
     }
     catch (e) {
@@ -105,22 +104,22 @@ function _openSync(_path, _flag, _mode, resolveSymlinks) {
                 // Ensure parent exists.
                 const parentStats = doOp('statSync', resolveSymlinks, dirname(path), cred);
                 if (!parentStats.isDirectory()) {
-                    throw ApiError.ENOTDIR(dirname(path));
+                    throw ApiError.With('ENOTDIR', dirname(path), '_openSync');
                 }
                 return doOp('createFileSync', resolveSymlinks, path, flag, mode, cred);
             case ActionType.THROW:
-                throw ApiError.ENOENT(path);
+                throw ApiError.With('ENOENT', path, '_openSync');
             default:
                 throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
         }
     }
     if (!stats.hasAccess(mode, cred)) {
-        throw ApiError.EACCES(path);
+        throw ApiError.With('EACCES', path, '_openSync');
     }
     // File exists.
     switch (pathExistsAction(flag)) {
         case ActionType.THROW:
-            throw ApiError.EEXIST(path);
+            throw ApiError.With('EEXIST', path, '_openSync');
         case ActionType.TRUNCATE:
             // Delete file.
             doOp('unlinkSync', resolveSymlinks, path, cred);
@@ -228,6 +227,17 @@ function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
         file.closeSync();
     }
 }
+/**
+ * Asynchronously append data to a file, creating the file if it not yet
+ * exists.
+ *
+ * @param filename
+ * @param data
+ * @param options
+ * @option options encoding Defaults to `'utf8'`.
+ * @option options mode Defaults to `0644`.
+ * @option options flag Defaults to `'a'`.
+ */
 export function appendFileSync(filename, data, arg3) {
     const options = normalizeOptions(arg3, 'utf8', 'a', 0o644);
     const flag = parseFlag(options.flag);
@@ -414,7 +424,7 @@ export function symlinkSync(target, path, type = 'file') {
         throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
     }
     if (existsSync(path)) {
-        throw ApiError.EEXIST(path);
+        throw ApiError.With('EEXIST', path, 'symlinkSync');
     }
     writeFileSync(path, target);
     const file = _openSync(path, 'r+', 0o644, false);

package/dist/file.d.ts

@@ -29,6 +29,10 @@ export declare enum ActionType {
 export declare function parseFlag(flag: string | number): string;
 export declare function flagToString(flag: number): string;
 export declare function flagToNumber(flag: string): number;
+/**
+ * Parses a flag as a mode (W_OK, R_OK, and/or X_OK)
+ * @param flag the flag to parse
+ */
 export declare function flagToMode(flag: string): number;
 export declare function isReadable(flag: string): boolean;
 export declare function isWriteable(flag: string): boolean;

package/dist/file.js

@@ -86,6 +86,10 @@ export function flagToNumber(flag) {
             throw new Error('Invalid flag string: ' + flag);
     }
 }
+/**
+ * Parses a flag as a mode (W_OK, R_OK, and/or X_OK)
+ * @param flag the flag to parse
+ */
 export function flagToMode(flag) {
     let mode = 0;
     mode <<= 1;
@@ -323,15 +327,16 @@ export class PreloadFile extends File {
                 }
             }
         }
-        this._buffer.set(buffer.slice(offset, offset + length), position);
-        const len = this._buffer.byteOffset;
+        const slice = buffer.slice(offset, offset + length);
+        this._buffer.set(slice, position);
+        const bytesWritten = slice.byteLength;
         this.stats.mtimeMs = Date.now();
         if (isSynchronous(this.flag)) {
             this.syncSync();
-            return len;
+            return bytesWritten;
         }
-        this.position = position + len;
-        return len;
+        this.position = position + bytesWritten;
+        return bytesWritten;
     }
     /**
      * Read data from the file.
@@ -389,9 +394,6 @@ export class PreloadFile extends File {
      * @param mode
      */
     chmodSync(mode) {
-        if (!this.fs.metadata().supportsProperties) {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        }
         this._dirty = true;
         this.stats.chmod(mode);
         this.syncSync();
@@ -410,9 +412,6 @@ export class PreloadFile extends File {
      * @param gid
      */
     chownSync(uid, gid) {
-        if (!this.fs.metadata().supportsProperties) {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        }
         this._dirty = true;
         this.stats.chown(uid, gid);
         this.syncSync();
@@ -421,9 +420,6 @@ export class PreloadFile extends File {
         this.utimesSync(atime, mtime);
     }
     utimesSync(atime, mtime) {
-        if (!this.fs.metadata().supportsProperties) {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        }
         this._dirty = true;
         this.stats.atime = atime;
         this.stats.mtime = mtime;

package/dist/stats.d.ts

@@ -146,9 +146,8 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     isFIFO(): boolean;
     /**
      * Checks if a given user/group has access to this item
-     * @param mode The request access as 4 bits (unused, read, write, execute)
-     * @param uid The requesting UID
-     * @param gid The requesting GID
+     * @param mode The requested access, combination of W_OK, R_OK, and X_OK
+     * @param cred The requesting credentials
      * @returns True if the request has access, false if the request does not
      * @internal
      */

package/dist/stats.js

@@ -1,4 +1,4 @@
-import { S_IFDIR, S_IFLNK, S_IFMT, S_IFREG } from './emulation/constants.js';
+import { S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, S_IRWXG, S_IRWXO, S_IRWXU } from './emulation/constants.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
  */
@@ -145,9 +145,8 @@ export class StatsCommon {
     }
     /**
      * Checks if a given user/group has access to this item
-     * @param mode The request access as 4 bits (unused, read, write, execute)
-     * @param uid The requesting UID
-     * @param gid The requesting GID
+     * @param mode The requested access, combination of W_OK, R_OK, and X_OK
+     * @param cred The requesting credentials
      * @returns True if the request has access, false if the request does not
      * @internal
      */
@@ -156,24 +155,9 @@ export class StatsCommon {
             //Running as root
             return true;
         }
-        const perms = this.mode & ~S_IFMT;
-        let uMode = 0xf, gMode = 0xf, wMode = 0xf;
-        if (cred.euid == this.uid) {
-            const uPerms = (0xf00 & perms) >> 8;
-            uMode = (mode ^ uPerms) & mode;
-        }
-        if (cred.egid == this.gid) {
-            const gPerms = (0xf0 & perms) >> 4;
-            gMode = (mode ^ gPerms) & mode;
-        }
-        const wPerms = 0xf & perms;
-        wMode = (mode ^ wPerms) & mode;
-        /*
-        Result = 0b0xxx (read, write, execute)
-        If any bits are set that means the request does not have that permission.
-        */
-        const result = uMode & gMode & wMode;
-        return !result;
+        // Mask for
+        const adjusted = (cred.uid == this.uid ? S_IRWXU : 0) | (cred.gid == this.gid ? S_IRWXG : 0) | S_IRWXO;
+        return (mode & this.mode & adjusted) == mode;
     }
     /**
      * Convert the current stats object into a credentials object

package/dist/utils.js

@@ -103,6 +103,7 @@ export function encode(input, encoding = 'utf8') {
     }
     switch (encoding) {
         case 'ascii':
+            return new Uint8Array(Array.from(input).map(char => char.charCodeAt(0) & 0x7f));
         case 'latin1':
         case 'binary':
             return new Uint8Array(Array.from(input).map(char => char.charCodeAt(0)));
@@ -124,7 +125,7 @@ export function encode(input, encoding = 'utf8') {
                 return [(code >> 18) | 0xf0, ((code >> 12) & 0x3f) | 0x80, b, a];
             }));
         case 'base64':
-            return encode(atob(input), 'utf-8');
+            return encode(atob(input), 'binary');
         case 'base64url':
             return encode(input.replace('_', '/').replace('-', '+'), 'base64');
         case 'hex':
@@ -151,6 +152,9 @@ export function decode(input, encoding = 'utf8') {
     }
     switch (encoding) {
         case 'ascii':
+            return Array.from(input)
+                .map(char => String.fromCharCode(char & 0x7f))
+                .join('');
         case 'latin1':
         case 'binary':
             return Array.from(input)
@@ -186,7 +190,7 @@ export function decode(input, encoding = 'utf8') {
             }
             return utf16leString;
         case 'base64':
-            return btoa(decode(input, 'utf-8'));
+            return btoa(decode(input, 'binary'));
         case 'base64url':
             return decode(input, 'base64').replace('/', '_').replace('+', '-');
         case 'hex':

package/package.json

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

package/readme.md

@@ -17,7 +17,7 @@ ZenFS is modular and extensible. The core includes a few built-in backends:
 > [!NOTE]
 > When constructed, `AsyncMirror` loads the entire contents of the async file system into a synchronous backend. It performs operations on the synchronous file system and then queues them to be mirrored onto the asynchronous backend.
 
-ZenFS supports a number of other backends. Many are provided as seperate packages under `@zenfs`. More backends can be defined by separate libraries by extending the `FileSystem` class and/or providing a `Backend` object.
+ZenFS supports a number of other backends. Many are provided as separate packages under `@zenfs`. More backends can be defined by separate libraries by extending the `FileSystem` class and/or providing a `Backend` object.
 
 For more information, see the [docs](https://zen-fs.github.io/core).
 
@@ -110,7 +110,7 @@ if (!exists) {
 > You can import the promises API using `promises`, or using `fs.promises` on the exported `fs`.
 
 > [!IMPORTANT]
-> ZenFS does _not_ provide a seperate public import for importing promises like `fs/promises`. If you are using ESM, you can import promises functions like `fs/promises` from the `dist/emulation/promises.ts` file, though this may change at any time and is **not recommended**.
+> ZenFS does _not_ provide a separate public import for importing promises like `fs/promises`. If you are using ESM, you can import promises functions like `fs/promises` from the `dist/emulation/promises.ts` file, though this may change at any time and is **not recommended**.
 
 #### Using asynchronous backends synchronously