@zenfs/core 2.6.1 → 2.6.3

package/dist/node/stats.js

@@ -1,7 +1,8 @@
 import { pick } from 'utilium';
-import { _inode_fields, hasAccess } from '../internal/inode.js';
 import * as c from '../constants.js';
-const n1000 = BigInt(1000);
+import { _inode_fields, hasAccess } from '../internal/inode.js';
+import { _temporal } from '../utils.js';
+const _nsMultiplier = BigInt(1_000_000);
 /**
  * Provides information about a particular entry in the file system.
  * Common code used by both Stats and BigIntStats.
@@ -56,6 +57,12 @@ export class StatsCommon {
     set atime(value) {
         this.atimeMs = this._convert(value.getTime());
     }
+    get atimeInstant() {
+        return _temporal().Instant.fromEpochMilliseconds(Number(this.atimeMs));
+    }
+    set atimeInstant(value) {
+        this.atimeMs = this._convert(value.epochMilliseconds);
+    }
     /**
      * Time of last modification, since epoch
      */
@@ -66,6 +73,12 @@ export class StatsCommon {
     set mtime(value) {
         this.mtimeMs = this._convert(value.getTime());
     }
+    get mtimeInstant() {
+        return _temporal().Instant.fromEpochMilliseconds(Number(this.mtimeMs));
+    }
+    set mtimeInstant(value) {
+        this.mtimeMs = this._convert(value.epochMilliseconds);
+    }
     /**
      * Time of last time file status was changed, since epoch
      */
@@ -76,6 +89,12 @@ export class StatsCommon {
     set ctime(value) {
         this.ctimeMs = this._convert(value.getTime());
     }
+    get ctimeInstant() {
+        return _temporal().Instant.fromEpochMilliseconds(Number(this.ctimeMs));
+    }
+    set ctimeInstant(value) {
+        this.ctimeMs = this._convert(value.epochMilliseconds);
+    }
     /**
      * Time of file creation, since epoch
      */
@@ -86,6 +105,12 @@ export class StatsCommon {
     set birthtime(value) {
         this.birthtimeMs = this._convert(value.getTime());
     }
+    get birthtimeInstant() {
+        return _temporal().Instant.fromEpochMilliseconds(Number(this.birthtimeMs));
+    }
+    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.
@@ -156,16 +181,16 @@ export class StatsCommon {
         return hasAccess(context, this._isBigint ? new Stats(this) : this, mode);
     }
     get atimeNs() {
-        return BigInt(this.atimeMs) * n1000;
+        return BigInt(this.atimeMs) * _nsMultiplier;
     }
     get mtimeNs() {
-        return BigInt(this.mtimeMs) * n1000;
+        return BigInt(this.mtimeMs) * _nsMultiplier;
     }
     get ctimeNs() {
-        return BigInt(this.ctimeMs) * n1000;
+        return BigInt(this.ctimeMs) * _nsMultiplier;
     }
     get birthtimeNs() {
-        return BigInt(this.birthtimeMs) * n1000;
+        return BigInt(this.birthtimeMs) * _nsMultiplier;
     }
 }
 /**
@@ -218,6 +243,8 @@ export class StatsFs {
     bavail = 0;
     /** Total file nodes in file system. */
     files = c.size_max;
+    /** Fundamental file system block size. */
+    frsize = 4096;
     /** Free file nodes in file system. */
     ffree = c.size_max;
 }
@@ -237,6 +264,8 @@ export class BigIntStatsFs {
     bavail = BigInt(0);
     /** Total file nodes in file system. */
     files = BigInt(c.size_max);
+    /** Fundamental file system block size. */
+    frsize = BigInt(4096);
     /** Free file nodes in file system. */
     ffree = BigInt(c.size_max);
 }

package/dist/node/sync.d.ts

@@ -10,23 +10,51 @@ export declare function renameSync(this: V_Context, oldPath: fs.PathLike, newPat
  * Test whether or not `path` exists by checking with the file system.
  */
 export declare function existsSync(this: V_Context, path: fs.PathLike): boolean;
-export declare function statSync(this: V_Context, path: fs.PathLike, options?: {
-    bigint?: boolean;
+export declare function statSync(this: V_Context, path: fs.PathLike, options?: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry?: true;
 }): Stats;
-export declare function statSync(this: V_Context, path: fs.PathLike, options: {
+export declare function statSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
     bigint: true;
+    throwIfNoEntry?: true;
 }): BigIntStats;
+export declare function statSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry: false;
+}): Stats | undefined;
+export declare function statSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint: true;
+    throwIfNoEntry: false;
+}): BigIntStats | undefined;
+export declare function statSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    throwIfNoEntry?: true;
+}): Stats | BigIntStats;
+export declare function statSync(this: V_Context, path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats | undefined;
 /**
  * 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.
  */
-export declare function lstatSync(this: V_Context, path: fs.PathLike, options?: {
-    bigint?: boolean;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options?: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry?: true;
 }): Stats;
-export declare function lstatSync(this: V_Context, path: fs.PathLike, options: {
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
     bigint: true;
+    throwIfNoEntry?: true;
 }): BigIntStats;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry: false;
+}): Stats | undefined;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint: true;
+    throwIfNoEntry: false;
+}): BigIntStats | undefined;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    throwIfNoEntry?: true;
+}): Stats | BigIntStats;
+export declare function lstatSync(this: V_Context, path: fs.PathLike, options?: fs.StatOptions): Stats | BigIntStats | undefined;
 export declare function truncateSync(this: V_Context, path: fs.PathLike, len?: number | null): void;
 export declare function unlinkSync(this: V_Context, path: fs.PathLike): void;
 /**
@@ -94,7 +122,7 @@ export declare function fdatasyncSync(this: V_Context, fd: number): void;
  */
 export declare function writeSync(this: V_Context, fd: number, data: ArrayBufferView, offset?: number | null, length?: number | null, position?: number | null): number;
 export declare function writeSync(this: V_Context, fd: number, data: string, position?: number | null, encoding?: BufferEncoding | null): number;
-export declare function readSync(this: V_Context, fd: number, buffer: ArrayBufferView, options?: fs.ReadSyncOptions): number;
+export declare function readSync(this: V_Context, fd: number, buffer: ArrayBufferView, options?: fs.ReadOptions): number;
 export declare function readSync(this: V_Context, fd: number, buffer: ArrayBufferView, offset: number, length: number, position?: fs.ReadPosition | null): number;
 export declare function fchownSync(this: V_Context, fd: number, uid: number, gid: number): void;
 export declare function fchmodSync(this: V_Context, fd: number, mode: number | string): void;
@@ -246,7 +274,7 @@ export declare function statfsSync(this: V_Context, path: fs.PathLike, options?:
 /**
  * Retrieves the files matching the specified pattern.
  */
-export declare function globSync(pattern: string | readonly string[]): string[];
-export declare function globSync(pattern: string | readonly string[], options: fs.GlobOptionsWithFileTypes): Dirent[];
-export declare function globSync(pattern: string | readonly string[], options: fs.GlobOptionsWithoutFileTypes): string[];
-export declare function globSync(pattern: string | readonly string[], options: fs.GlobOptions): Dirent[] | string[];
+export declare function globSync(this: V_Context, pattern: string | readonly string[]): string[];
+export declare function globSync(this: V_Context, pattern: string | readonly string[], options: fs.GlobOptionsWithFileTypes): Dirent[];
+export declare function globSync(this: V_Context, pattern: string | readonly string[], options: fs.GlobOptionsWithoutFileTypes): string[];
+export declare function globSync(this: V_Context, pattern: string | readonly string[], options: fs.GlobOptions): Dirent[] | string[];

package/dist/node/sync.js

@@ -54,10 +54,11 @@ import { Buffer } from 'buffer';
 import { Errno, Exception, setUVMessage, UV } from 'kerium';
 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 { dirname, join, matchesGlob } from '../path.js';
-import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.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';
@@ -88,12 +89,28 @@ export function existsSync(path) {
 }
 existsSync;
 export function statSync(path, options) {
-    const stats = _sync.stat.call(this, path, false);
+    let stats;
+    try {
+        stats = _sync.stat.call(this, path, false);
+    }
+    catch (e) {
+        if (options?.throwIfNoEntry === false && _isNoEntry(e))
+            return;
+        throw e;
+    }
     return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 statSync;
 export function lstatSync(path, options) {
-    const stats = _sync.stat.call(this, path, true);
+    let stats;
+    try {
+        stats = _sync.stat.call(this, path, true);
+    }
+    catch (e) {
+        if (options?.throwIfNoEntry === false && _isNoEntry(e))
+            return;
+        throw e;
+    }
     return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 lstatSync;
@@ -202,7 +219,6 @@ export function writeFileSync(path, data, _options = {}) {
             : _sync.open.call(this, path.toString(), {
                 flag,
                 mode: options.mode,
-                preserveSymlinks: true,
             }), false);
         file.writeSync(encodedData, 0, encodedData.byteLength, 0);
         emitChange(this, 'change', path.toString());
@@ -237,7 +253,6 @@ export function appendFileSync(filename, data, _options = {}) {
         : _sync.open.call(this, normalizePath(filename), {
             flag,
             mode: options.mode,
-            preserveSymlinks: true,
         });
     file.writeSync(encodedData, 0, encodedData.byteLength);
     if (typeof file != 'number')
@@ -567,9 +582,9 @@ export function mkdtempDisposableSync(prefix, options) {
 export function copyFileSync(source, destination, flags) {
     source = normalizePath(source);
     destination = normalizePath(destination);
-    if (flags && flags & constants.COPYFILE_EXCL && existsSync(destination))
+    if (flags && flags & constants.COPYFILE_EXCL && existsSync.call(this, destination))
         throw UV('EEXIST', 'copyFile', destination);
-    writeFileSync.call(this, destination, readFileSync(source));
+    writeFileSync.call(this, destination, readFileSync.call(this, source));
     emitChange(this, 'rename', destination.toString());
 }
 copyFileSync;
@@ -647,8 +662,16 @@ export function cpSync(source, destination, opts) {
                 cpSync.call(this, join(source, dirent.name), join(destination, dirent.name), opts);
             }
             break;
-        case constants.S_IFREG:
         case constants.S_IFLNK:
+            if (opts?.dereference) {
+                copyFileSync.call(this, source, destination);
+            }
+            else {
+                const link = readlinkSync.call(this, source, 'utf8');
+                symlinkSync.call(this, opts?.verbatimSymlinks ? link : resolve.call(this, dirname(source), link), destination);
+            }
+            break;
+        case constants.S_IFREG:
             copyFileSync.call(this, source, destination);
             break;
         case constants.S_IFBLK:
@@ -671,8 +694,10 @@ export function statfsSync(path, options) {
 }
 export function globSync(pattern, options = {}) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
-    const { cwd = '/', withFileTypes = false, exclude = () => false } = options;
-    const normalizedPatterns = pattern.map(p => p.replace(/^\/+/g, ''));
+    const $ = contextOf(this);
+    const { cwd = $.pwd, withFileTypes = false, exclude = () => false, followSymlinks = false } = options;
+    const base = resolve.call($, cwd instanceof URL ? cwd.pathname : cwd);
+    const normalizedPatterns = pattern.map(p => (p.startsWith('/') ? relative.call($, base, p) : p));
     const hasGlobStar = normalizedPatterns.some(p => p.includes('**'));
     const patternBases = normalizedPatterns.map(p => {
         const firstGlob = p.search(/[*?[\]{]/);
@@ -682,25 +707,30 @@ export function globSync(pattern, options = {}) {
         return lastSlash === -1 ? '' : p.slice(0, lastSlash);
     });
     const regexPatterns = normalizedPatterns.map(globToRegex);
+    function shouldDescend(path, relativePath) {
+        const isNamed = patternBases.some(base => relativePath === base || base.startsWith(relativePath + '/'));
+        const inScope = hasGlobStar || isNamed;
+        const stats = lstatSync.call($, path);
+        if (!stats.isSymbolicLink())
+            return inScope && stats.isDirectory();
+        return inScope && (followSymlinks || isNamed) && !!statSync.call($, path, { throwIfNoEntry: false })?.isDirectory();
+    }
     const results = [];
     function recursiveList(dir) {
-        const entries = readdirSync(dir, { withFileTypes, encoding: 'utf8' });
+        const entries = readdirSync.call($, dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
             const fullPath = join(dir, withFileTypes ? entry.name : entry);
-            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
+            const relPath = relative.call($, base, fullPath);
+            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, relPath)) : exclude((withFileTypes ? entry : relPath)))
                 continue;
-            const relativePath = fullPath.replace(/^\/+/g, '');
-            if (statSync(fullPath).isDirectory()) {
-                if (hasGlobStar || patternBases.some(base => relativePath === base || base.startsWith(relativePath + '/'))) {
-                    recursiveList(fullPath);
-                }
-            }
-            if (regexPatterns.some(rx => rx.test(relativePath))) {
-                results.push(withFileTypes ? entry : relativePath);
+            if (shouldDescend(fullPath, relPath))
+                recursiveList(fullPath);
+            if (regexPatterns.some(rx => rx.test(relPath))) {
+                results.push(withFileTypes ? entry : relPath);
             }
         }
     }
-    recursiveList(cwd instanceof URL ? cwd.pathname : cwd);
+    recursiveList(base);
     return results;
 }
 globSync;

package/dist/node/utf8stream.d.ts

@@ -0,0 +1,99 @@
+import { Buffer } from 'buffer';
+import { EventEmitter } from 'eventemitter3';
+import type { EventEmitter as NodeEventEmitter } from 'node:events';
+import type * as fs from 'node:fs';
+import { type FSContext } from '../internal/contexts.js';
+interface FS {
+    open(path: string, flags: string, mode: fs.Mode, cb: (err: Error | null, fd: number) => void): void;
+    openSync(path: string, flags: string, mode: fs.Mode): number;
+    close(fd: number, cb: (err: Error | null) => void): void;
+    write(fd: number, data: Buffer, cb: (err: Error | null, n: number) => void): void;
+    write(fd: number, data: string, encoding: BufferEncoding, cb: (err: Error | null, n: number) => void): void;
+    writeSync(fd: number, data: Buffer): number;
+    writeSync(fd: number, data: string, encoding: BufferEncoding): number;
+    fsync(fd: number, cb: (err: Error | null) => void): void;
+    fsyncSync(fd: number): void;
+    mkdir(path: string, options: {
+        recursive: true;
+    }, cb: (err: Error | null) => void): void;
+    mkdirSync(path: string, options: {
+        recursive: true;
+    }): void;
+}
+declare const kUtf8StreamFS: unique symbol;
+/**
+ * An optimized UTF-8 stream writer that allows for flushing all of the internal buffering on demand.
+ */
+export declare class Utf8Stream extends EventEmitter<fs.Utf8StreamEventMap> implements NodeEventEmitter, fs.Utf8Stream {
+    #private;
+    ['constructor']: typeof Utf8Stream;
+    static [kUtf8StreamFS]: FS;
+    /** @hidden @internal */
+    static _withContext(ctx: FSContext): typeof Utf8Stream;
+    constructor(options?: fs.Utf8StreamOptions);
+    /**
+     * When `contentMode` is `utf8`, `data` must be a string. When it is `buffer`, `data` must be a `Buffer`.
+     * @returns Whether the internal buffer is below the high water mark
+     */
+    write(data: string | Buffer): boolean;
+    /**
+     * Writes the current buffer to the file if a write was not in progress.
+     * Does nothing if `minLength` is zero or if it is already writing.
+     */
+    flush(cb?: ((err: Error | null) => void) | null): void;
+    /**
+     * Flushes the buffered data synchronously. This is a costly operation.
+     */
+    flushSync(): void;
+    /**
+     * Reopen the file in place, useful for log rotation.
+     */
+    reopen(file?: fs.PathLike): void;
+    /**
+     * Close the stream gracefully, flushing the internal buffer before closing.
+     */
+    end(): void;
+    /**
+     * Close the stream immediately, without flushing the internal buffer.
+     */
+    destroy(): void;
+    /** The mode of the file that is being written to */
+    get mode(): fs.Mode;
+    /** The file that is being written to */
+    get file(): string;
+    /** The file descriptor that is being written to */
+    get fd(): number;
+    /** The minimum length of the internal buffer that is required to be full before flushing */
+    get minLength(): number;
+    /**
+     * The maximum length of the internal buffer.
+     * If a write would cause the buffer to exceed this, the data is dropped and a `drop` event is emitted with it.
+     */
+    get maxLength(): number;
+    /** Whether the stream is currently writing data to the file */
+    get writing(): boolean;
+    /** Whether the stream is writing synchronously or asynchronously */
+    get sync(): boolean;
+    /** Whether the stream performs a `fsyncSync` after every write */
+    get fsync(): boolean;
+    /** Whether the stream is appending to the file or truncating it */
+    get append(): boolean;
+    /** The number of milliseconds between flushes. `0` means no periodic flushes are performed. */
+    get periodicFlush(): number;
+    /** The type of data that can be written to the stream */
+    get contentMode(): 'utf8' | 'buffer';
+    /** Whether the directory for `file` is created if it does not exist */
+    get mkdir(): boolean;
+    [Symbol.dispose](): void;
+    on<T extends keyof fs.Utf8StreamEventMap>(event: T, fn: (...args: fs.Utf8StreamEventMap[T]) => void, context?: any): this;
+    addListener<T extends keyof fs.Utf8StreamEventMap>(event: T, fn: (...args: fs.Utf8StreamEventMap[T]) => void, context?: any): this;
+    once<T extends keyof fs.Utf8StreamEventMap>(event: T, fn: (...args: fs.Utf8StreamEventMap[T]) => void, context?: any): this;
+    off<T extends keyof fs.Utf8StreamEventMap>(event: T, fn?: (...args: any[]) => void, context?: any, once?: boolean): this;
+    removeListener<T extends keyof fs.Utf8StreamEventMap>(event: T, fn?: (...args: any[]) => void, context?: any, once?: boolean): this;
+    setMaxListeners(): never;
+    getMaxListeners(): never;
+    prependListener(): never;
+    prependOnceListener(): never;
+    rawListeners(): never;
+}
+export {};