@zenfs/core 2.7.5 → 2.7.7

package/dist/node/stats.d.ts

@@ -1,143 +1,71 @@
 import type * as Node from 'node:fs';
 import type { V_Context } from '../context.js';
-import type { InodeFields } from '../internal/inode.js';
-export interface StatsLike<T extends number | bigint = number | bigint> {
-    /**
-     * Size of the item in bytes.
-     * For directories/symlinks, this is normally the size of the struct that represents the item.
-     */
-    size: T;
-    /**
-     * Unix-style file mode (e.g. 0o644) that includes the item type
-     */
-    mode: T;
-    /**
-     * Time of last access, since epoch
-     */
-    atimeMs: T;
-    /**
-     * Time of last modification, since epoch
-     */
-    mtimeMs: T;
-    /**
-     * Time of last time file status was changed, since epoch
-     */
-    ctimeMs: T;
-    /**
-     * Time of file creation, since epoch
-     */
-    birthtimeMs: T;
-    /**
-     * The id of the user that owns the file
-     */
-    uid: T;
-    /**
-     * The id of the group that owns the file
-     */
-    gid: T;
-    /**
-     * Inode number
-     */
-    ino: T;
-    /**
-     * Number of hard links
-     */
-    nlink: T;
+import type { InodeFields, InodeLike, StatsLike } from '../internal/inode.js';
+export interface StatsExtra<T extends number | bigint> {
+    /** ID of device containing file */
+    dev: T;
+    /** Block size for file system I/O */
+    blksize: T;
 }
 /**
  * Provides information about a particular entry in the file system.
  * Common code used by both Stats and BigIntStats.
  */
-export declare abstract class StatsCommon<T extends number | bigint> implements Node.StatsBase<T>, StatsLike {
+export declare abstract class StatsCommon<T extends number | bigint> implements Node.StatsBase<T>, StatsLike<T>, StatsExtra<T> {
     protected abstract _isBigint: T extends bigint ? true : false;
     protected _convert(arg: number | bigint | string | boolean): T;
     get blocks(): T;
     set blocks(value: T);
-    /**
-     * Unix-style file mode (e.g. 0o644) that includes the type of the item.
-     */
+    /** Unix-style file mode (e.g. 0o644) that includes the type of the item. */
     mode: T;
-    /**
-     * ID of device containing file
-     */
+    /** ID of device containing file */
     dev: T;
-    /**
-     * Inode number
-     */
+    /** Inode number */
     ino: T;
-    /**
-     * Device ID (if special file)
-     */
+    /** Device ID (if special file) */
     rdev: T;
-    /**
-     * Number of hard links
-     */
+    /** Number of hard links */
     nlink: T;
-    /**
-     * Block size for file system I/O
-     */
+    /** Block size for file system I/O */
     blksize: T;
-    /**
-     * User ID of owner
-     */
+    /** User ID of owner */
     uid: T;
-    /**
-     * Group ID of owner
-     */
+    /** Group ID of owner */
     gid: T;
-    /**
-     * Time of last access, since epoch
-     */
+    /** Time of last access, since epoch */
     atimeMs: T;
     get atime(): Date;
     set atime(value: Date);
     get atimeInstant(): Temporal.Instant;
     set atimeInstant(value: Temporal.Instant);
-    /**
-     * Time of last modification, since epoch
-     */
+    /** Time of last modification, since epoch */
     mtimeMs: T;
     get mtime(): Date;
     set mtime(value: Date);
     get mtimeInstant(): Temporal.Instant;
     set mtimeInstant(value: Temporal.Instant);
-    /**
-     * Time of last time file status was changed, since epoch
-     */
+    /** Time of last time file status was changed, since epoch */
     ctimeMs: T;
     get ctime(): Date;
     set ctime(value: Date);
     get ctimeInstant(): Temporal.Instant;
     set ctimeInstant(value: Temporal.Instant);
-    /**
-     * Time of file creation, since epoch
-     */
+    /** Time of file creation, since epoch */
     birthtimeMs: T;
     get birthtime(): Date;
     set birthtime(value: Date);
     get birthtimeInstant(): Temporal.Instant;
     set birthtimeInstant(value: Temporal.Instant);
-    /**
-     * Size of the item in bytes.
-     * For directories/symlinks, this is normally the size of the struct that represents the item.
-     */
+    /** Size of the item in bytes. For directories/symlinks, this may be the size of the struct that represents the item. */
     size: T;
-    /**
-     * @internal Used by inodes
-     */
+    /** @internal Used by inodes */
     data?: number;
-    /**
-     * @internal Used by inodes
-     */
+    /** @internal Used by inodes */
     flags?: number;
-    /**
-     * @internal Used by inodes
-     */
+    /** @internal Used by inodes */
     version?: number;
-    /**
-     * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
-     */
-    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, ...rest }?: Partial<StatsLike & InodeFields>);
+    /** Creates a new stats instance from a stats-like object. Can be used to copy stats (note) */
+    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, rdev, dev, blksize, ...rest }?: Partial<InodeLike<number | bigint> & StatsExtra<number | bigint>>);
     isFile(): boolean;
     isDirectory(): boolean;
     isSymbolicLink(): boolean;
@@ -183,8 +111,6 @@ export declare class BigIntStats extends StatsCommon<bigint> implements Node.Big
  * @internal
  */
 export declare function isStatsEqual<T extends number | bigint>(left: StatsCommon<T>, right: StatsCommon<T>): boolean;
-/** @internal */
-export declare const ZenFsType = 525687744115;
 /**
  * @hidden
  */

package/dist/node/stats.js

@@ -15,41 +15,23 @@ export class StatsCommon {
         return this._convert(Math.ceil(Number(this.size) / 512));
     }
     set blocks(value) { }
-    /**
-     * Unix-style file mode (e.g. 0o644) that includes the type of the item.
-     */
+    /** Unix-style file mode (e.g. 0o644) that includes the type of the item. */
     mode;
-    /**
-     * ID of device containing file
-     */
+    /** ID of device containing file */
     dev = this._convert(0);
-    /**
-     * Inode number
-     */
+    /** Inode number */
     ino = this._convert(0);
-    /**
-     * Device ID (if special file)
-     */
+    /** Device ID (if special file) */
     rdev = this._convert(0);
-    /**
-     * Number of hard links
-     */
+    /** Number of hard links */
     nlink = this._convert(1);
-    /**
-     * Block size for file system I/O
-     */
+    /** Block size for file system I/O */
     blksize = this._convert(4096);
-    /**
-     * User ID of owner
-     */
+    /** User ID of owner */
     uid = this._convert(0);
-    /**
-     * Group ID of owner
-     */
+    /** Group ID of owner */
     gid = this._convert(0);
-    /**
-     * Time of last access, since epoch
-     */
+    /** Time of last access, since epoch */
     atimeMs;
     get atime() {
         return new Date(Number(this.atimeMs));
@@ -63,9 +45,7 @@ export class StatsCommon {
     set atimeInstant(value) {
         this.atimeMs = this._convert(value.epochMilliseconds);
     }
-    /**
-     * Time of last modification, since epoch
-     */
+    /** Time of last modification, since epoch */
     mtimeMs;
     get mtime() {
         return new Date(Number(this.mtimeMs));
@@ -79,9 +59,7 @@ export class StatsCommon {
     set mtimeInstant(value) {
         this.mtimeMs = this._convert(value.epochMilliseconds);
     }
-    /**
-     * Time of last time file status was changed, since epoch
-     */
+    /** Time of last time file status was changed, since epoch */
     ctimeMs;
     get ctime() {
         return new Date(Number(this.ctimeMs));
@@ -95,9 +73,7 @@ export class StatsCommon {
     set ctimeInstant(value) {
         this.ctimeMs = this._convert(value.epochMilliseconds);
     }
-    /**
-     * Time of file creation, since epoch
-     */
+    /** Time of file creation, since epoch */
     birthtimeMs;
     get birthtime() {
         return new Date(Number(this.birthtimeMs));
@@ -111,27 +87,16 @@ export class StatsCommon {
     set birthtimeInstant(value) {
         this.birthtimeMs = this._convert(value.epochMilliseconds);
     }
-    /**
-     * Size of the item in bytes.
-     * For directories/symlinks, this is normally the size of the struct that represents the item.
-     */
+    /** Size of the item in bytes. For directories/symlinks, this may be the size of the struct that represents the item. */
     size;
-    /**
-     * @internal Used by inodes
-     */
+    /** @internal Used by inodes */
     data;
-    /**
-     * @internal Used by inodes
-     */
+    /** @internal Used by inodes */
     flags;
-    /**
-     * @internal Used by inodes
-     */
+    /** @internal Used by inodes */
     version;
-    /**
-     * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
-     */
-    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, ...rest } = {}) {
+    /** Creates a new stats instance from a stats-like object. Can be used to copy stats (note) */
+    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, rdev, dev, blksize, ...rest } = {}) {
         const now = Date.now();
         this.atimeMs = this._convert(atimeMs ?? now);
         this.mtimeMs = this._convert(mtimeMs ?? now);
@@ -142,6 +107,9 @@ export class StatsCommon {
         this.size = this._convert(size ?? 0);
         this.ino = this._convert(ino ?? 0);
         this.mode = this._convert(mode ?? 0o644 & c.S_IFREG);
+        this.rdev = this._convert(rdev ?? 0);
+        this.dev = this._convert(dev ?? 0);
+        this.blksize = this._convert(blksize ?? 4096);
         if ((this.mode & c.S_IFMT) == 0) {
             this.mode = (this.mode | this._convert(c.S_IFREG));
         }
@@ -169,7 +137,7 @@ export class StatsCommon {
         return (this.mode & c.S_IFMT) === c.S_IFIFO;
     }
     toJSON() {
-        return pick(this, _inode_fields);
+        return pick(this, ..._inode_fields, 'dev', 'blksize');
     }
     /**
      * Checks if a given user/group has access to this item
@@ -225,8 +193,6 @@ export function isStatsEqual(left, right) {
         && +left.ctime == +right.ctime
         && left.mode == right.mode);
 }
-/** @internal */
-export const ZenFsType = 0x7a656e6673; // 'z' 'e' 'n' 'f' 's'
 /**
  * @hidden
  */

package/dist/node/streams.d.ts

@@ -1,45 +1,10 @@
-import type { Abortable } from 'node:events';
 import type * as fs from 'node:fs';
 import type { CreateReadStreamOptions, CreateWriteStreamOptions } from 'node:fs/promises';
 import type { Callback } from '../utils.js';
 import type { FileHandle } from './promises.js';
 import { Readable } from '@zenfs/streams/readable';
 import { Writable } from '@zenfs/streams/writable';
-interface FSImplementation {
-    open?: (...args: unknown[]) => unknown;
-    close?: (...args: unknown[]) => unknown;
-}
-interface StreamOptions extends Abortable {
-    flags?: string;
-    encoding?: BufferEncoding;
-    fd?: number | FileHandle;
-    mode?: number;
-    autoClose?: boolean;
-    emitClose?: boolean;
-    start?: number;
-    highWaterMark?: number;
-}
-/**
- * This type is from node:fs but not exported.
- * @hidden
- */
-export interface ReadStreamOptions extends StreamOptions {
-    fs?: FSImplementation & {
-        read: (...args: unknown[]) => unknown;
-    };
-    end?: number;
-}
-/**
- * This type is from node:fs but not exported.
- * @hidden
- */
-export interface WriteStreamOptions extends StreamOptions {
-    flush?: boolean;
-    fs?: FSImplementation & {
-        write: (...args: unknown[]) => unknown;
-        writev?: (...args: unknown[]) => unknown;
-    };
-}
+export type { ReadStreamOptions, WriteStreamOptions } from 'node:fs';
 /**
  * A ReadStream implementation that wraps an underlying global ReadableStream.
  */
@@ -76,4 +41,3 @@ export declare class WriteStream extends Writable implements fs.WriteStream {
     get path(): string;
     get bytesWritten(): number;
 }
-export {};

package/dist/node/sync.d.ts

@@ -210,13 +210,8 @@ export declare function mkdtempSync(this: V_Context, prefix: fs.PathLike, option
  * When the object is disposed, the directory and its contents will be removed if it still exists.
  * If the directory cannot be deleted, disposal will throw an error.
  * The object has a `remove()` method which will perform the same task.
- * @todo Add `satisfies` and maybe change return type once @types/node adds this.
  */
-export declare function mkdtempDisposableSync(this: V_Context, prefix: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): {
-    path: string;
-    remove(): void;
-    [Symbol.dispose](): void;
-};
+export declare function mkdtempDisposableSync(this: V_Context, prefix: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): fs.DisposableTempDir;
 /**
  * Synchronous `copyFile`. Copies a file.
  * @param flags Optional flags for the copy operation. Currently supports these flags:

package/dist/node/sync.js

@@ -56,15 +56,14 @@ import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { contextOf } from '../internal/contexts.js';
 import { wrap } from '../internal/error.js';
-import { hasAccess, isDirectory } from '../internal/inode.js';
+import { assertRemovable, hasAccess, isDirectory } from '../internal/inode.js';
 import { dirname, join, matchesGlob, relative, resolve } from '../path.js';
 import { _isNoEntry, _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
 import * as flags from '../vfs/flags.js';
-import { _statfs, resolveMount } from '../vfs/shared.js';
+import { _statfs } from '../vfs/shared.js';
 import * as _sync from '../vfs/sync.js';
-import { cacheOf, lockPathSync } from '../vfs/vcache.js';
 import { emitChange } from '../vfs/watchers.js';
 import { Dir, Dirent } from './dir.js';
 import { BigIntStats, Stats } from './stats.js';
@@ -82,7 +81,7 @@ export function existsSync(path) {
         return fs.existsSync(resolvedPath);
     }
     catch (e) {
-        if (e.errno == Errno.ENOENT)
+        if (e.errno == Errno.ENOENT || e.errno == Errno.ENOTDIR || e.errno == Errno.EACCES)
             return false;
         throw e;
     }
@@ -134,16 +133,14 @@ export function truncateSync(path, len = 0) {
 truncateSync;
 export function unlinkSync(path) {
     path = normalizePath.call(this, path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const { fs, cache, path: resolved } = _sync.resolve(this, path, true, { syscall: 'unlink', path });
     try {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            if (checkAccess && !hasAccess(this, fs.statSync(resolved), constants.W_OK)) {
-                throw UV('EACCES', 'unlink');
-            }
-            const _ = __addDisposableResource(env_2, lockPathSync(fs, dirname(resolved), 'rw'), false);
+            assertRemovable(this, cache.statSync(dirname(resolved)), cache.statSync(resolved));
+            const _ = __addDisposableResource(env_2, cache.lockSync(dirname(resolved), 'rw'), false);
             fs.unlinkSync(resolved);
-            cacheOf(fs).remove(resolved);
+            cache.remove(resolved);
         }
         catch (e_2) {
             env_2.error = e_2;
@@ -372,15 +369,14 @@ export function rmdirSync(path) {
     const env_5 = { stack: [], error: void 0, hasError: false };
     try {
         path = normalizePath.call(this, path);
-        const { fs, path: resolved } = _sync.resolve(this, path);
-        const stats = wrap(fs, 'statSync', { path, syscall: 'rmdir' })(resolved);
+        const { fs, cache, path: resolved } = _sync.resolve(this, path, true);
+        const stats = cache.statSync(resolved, { path, syscall: 'rmdir' });
         if (!isDirectory(stats))
             throw UV('ENOTDIR', 'rmdir', path);
-        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-            throw UV('EACCES', 'rmdir', path);
-        const _ = __addDisposableResource(env_5, lockPathSync(fs, dirname(resolved), 'rw'), false);
+        assertRemovable(this, cache.statSync(dirname(resolved), { path, syscall: 'rmdir' }), stats, { syscall: 'rmdir', path });
+        const _ = __addDisposableResource(env_5, cache.lockSync(dirname(resolved), 'rw'), false);
         wrap(fs, 'rmdirSync', path)(resolved);
-        cacheOf(fs).remove(resolved);
+        cache.remove(resolved);
         emitChange(this, 'rename', path.toString());
     }
     catch (e_5) {
@@ -435,7 +431,7 @@ export function symlinkSync(target, path, type = 'file') {
         path = normalizePath.call(this, path);
         const file = __addDisposableResource(env_6, _sync.open(this, path, { flag: 'wx', mode: 0o644 }), false);
         file.writeSync(encodeUTF8(normalizePath.call(this, target, true)));
-        file.chmodSync(constants.S_IFLNK);
+        file.chmodSync(constants.S_IFLNK | 0o777);
     }
     catch (e_6) {
         env_6.error = e_6;
@@ -541,7 +537,7 @@ export function rmSync(path, options) {
     path = normalizePath.call(this, path);
     let stats;
     try {
-        stats = lstatSync.bind(this)(path);
+        stats = lstatSync.call(this, path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !options?.force)
@@ -583,7 +579,6 @@ mkdtempSync;
  * When the object is disposed, the directory and its contents will be removed if it still exists.
  * If the directory cannot be deleted, disposal will throw an error.
  * The object has a `remove()` method which will perform the same task.
- * @todo Add `satisfies` and maybe change return type once @types/node adds this.
  */
 export function mkdtempDisposableSync(prefix, options) {
     const path = _tempDirName(prefix);
@@ -591,6 +586,7 @@ export function mkdtempDisposableSync(prefix, options) {
     const remove = () => rmSync(path, { recursive: true, force: true });
     return { path, remove, [Symbol.dispose]: remove };
 }
+mkdtempDisposableSync;
 /**
  * Synchronous `copyFile`. Copies a file.
  * @param flags Optional flags for the copy operation. Currently supports these flags:
@@ -706,7 +702,7 @@ export function cpSync(source, destination, opts) {
 cpSync;
 export function statfsSync(path, options) {
     path = normalizePath.call(this, path);
-    const { fs } = resolveMount(path, this);
+    const { fs } = _sync.resolve(this, path);
     return _statfs(fs, options?.bigint);
 }
 export function globSync(pattern, options = {}) {

package/dist/polyfills.js

@@ -57,4 +57,29 @@ Uint8Array.fromHex ??=
             }
             return bytes;
         });
+Array.fromAsync ??=
+    (warn('Using a polyfill of Array.fromAsync'),
+        async function collectAsyncIterator(it) {
+            const results = [];
+            for await (const result of it) {
+                results.push(result);
+            }
+            return results;
+        });
+Map.prototype.getOrInsert ??=
+    (warn('Using a polyfill of Map.prototype.getOrInsert'),
+        function getOrInsert(key, defaultValue) {
+            if (!this.has(key))
+                this.set(key, defaultValue);
+            return this.get(key);
+        });
+Map.prototype.getOrInsertComputed ??=
+    (warn('Using a polyfill of Map.prototype.getOrInsertComputed'),
+        function getOrInsertComputed(key, callback) {
+            if (this.has(key))
+                return this.get(key);
+            const value = callback(key);
+            this.set(key, value);
+            return value;
+        });
 /* node:coverage enable */

package/dist/utils.d.ts

@@ -3,10 +3,6 @@ import type * as fs from 'node:fs';
 import type { Worker as NodeWorker } from 'node:worker_threads';
 import { type OptionalTuple } from 'utilium';
 import type { V_Context } from './internal/contexts.js';
-declare global {
-    function atob(data: string): string;
-    function btoa(data: string): string;
-}
 /**
  * Decodes a directory listing
  * @hidden

package/dist/vfs/acl.d.ts

@@ -12,9 +12,7 @@ export declare const enum Tag {
     Group = 8,
     Mask = 16,
     Other = 32,
-    /**
-     * @internal @hidden
-     */
+    /** @internal @hidden */
     _None = 0
 }
 declare const Entry_base: import("memium").StructConstructor<BufferView<any>>;

package/dist/vfs/acl.js

@@ -62,9 +62,7 @@ export var Tag;
     Tag[Tag["Group"] = 8] = "Group";
     Tag[Tag["Mask"] = 16] = "Mask";
     Tag[Tag["Other"] = 32] = "Other";
-    /**
-     * @internal @hidden
-     */
+    /** @internal @hidden */
     Tag[Tag["_None"] = 0] = "_None";
 })(Tag || (Tag = {}));
 let Entry = (() => {