@zenfs/core 2.6.2 → 2.6.4

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, resolve } 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;
@@ -677,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(/[*?[\]{]/);
@@ -688,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 {};