@zenfs/core 1.11.4 → 2.0.0

package/dist/mixins/readonly.d.ts

@@ -1,11 +1,10 @@
-import type { FileSystem, FileSystemMetadata } from '../internal/filesystem.js';
-import type { StatsLike } from '../stats.js';
+import type { FileSystem } from '../internal/filesystem.js';
+import type { InodeLike } from '../internal/inode.js';
 import type { Mixin } from './shared.js';
 /**
  * @internal
  */
 export interface ReadonlyMixin {
-    metadata(): FileSystemMetadata;
     rename(oldPath: string, newPath: string): Promise<never>;
     renameSync(oldPath: string, newPath: string): never;
     createFile(path: string, flag: string, mode: number): Promise<never>;
@@ -18,10 +17,12 @@ export interface ReadonlyMixin {
     mkdirSync(path: string, mode: number): never;
     link(srcpath: string, dstpath: string): Promise<never>;
     linkSync(srcpath: string, dstpath: string): never;
-    sync(path: string, data: Uint8Array, stats: Readonly<StatsLike<number>>): Promise<never>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<StatsLike<number>>): never;
+    touch(path: string, metadata: Readonly<InodeLike>): Promise<never>;
+    touchSync(path: string, metadata: Readonly<InodeLike>): never;
+    sync(path: string): Promise<never>;
+    syncSync(path: string): never;
     write(path: string, buffer: Uint8Array, offset: number): Promise<never>;
-    writeSync(path: string, buffer: Uint8Array, offset: number): Promise<never>;
+    writeSync(path: string, buffer: Uint8Array, offset: number): never;
 }
 /**
  * Implements the non-readonly methods to throw `EROFS`

package/dist/mixins/readonly.js

@@ -46,6 +46,12 @@ export function Readonly(FS) {
         linkSync() {
             throw new ErrnoError(Errno.EROFS);
         }
+        async touch() {
+            throw new ErrnoError(Errno.EROFS);
+        }
+        touchSync() {
+            throw new ErrnoError(Errno.EROFS);
+        }
         async sync() {
             throw new ErrnoError(Errno.EROFS);
         }

package/dist/mixins/sync.js

@@ -14,11 +14,11 @@ export function Sync(FS) {
         async stat(path) {
             return this.statSync(path);
         }
-        async createFile(path, flag, mode, options) {
-            return this.createFileSync(path, flag, mode, options);
+        async touch(path, metadata) {
+            return this.touchSync(path, metadata);
         }
-        async openFile(path, flag) {
-            return this.openFileSync(path, flag);
+        async createFile(path, options) {
+            return this.createFileSync(path, options);
         }
         async unlink(path) {
             return this.unlinkSync(path);
@@ -26,8 +26,8 @@ export function Sync(FS) {
         async rmdir(path) {
             return this.rmdirSync(path);
         }
-        async mkdir(path, mode, options) {
-            return this.mkdirSync(path, mode, options);
+        async mkdir(path, options) {
+            return this.mkdirSync(path, options);
         }
         async readdir(path) {
             return this.readdirSync(path);
@@ -35,8 +35,8 @@ export function Sync(FS) {
         async link(srcpath, dstpath) {
             return this.linkSync(srcpath, dstpath);
         }
-        async sync(path, data, stats) {
-            return this.syncSync(path, data, stats);
+        async sync(path) {
+            return this.syncSync(path);
         }
         async read(path, buffer, offset, end) {
             return this.readSync(path, buffer, offset, end);

package/dist/{vfs/path.d.ts → path.d.ts}

@@ -1,15 +1,14 @@
 import type { ParsedPath } from 'node:path';
+import type { V_Context } from './context.js';
 export type AbsolutePath = `/${string}`;
-export declare let cwd: string;
-export declare function cd(path: string): void;
 export declare const sep = "/";
 export declare function normalizeString(path: string, allowAboveRoot: boolean): string;
 export declare function formatExt(ext: string): string;
-export declare function resolve(...parts: string[]): AbsolutePath;
+export declare function resolve(this: V_Context, ...parts: (string | undefined)[]): AbsolutePath;
 export declare function normalize(path: string): string;
 export declare function isAbsolute(path: string): path is AbsolutePath;
 export declare function join(...parts: string[]): string;
-export declare function relative(from: string, to: string): string;
+export declare function relative(this: V_Context, from: string, to: string): string;
 export declare function dirname(path: string): string;
 export declare function basename(path: string, suffix?: string): string;
 export declare function extname(path: string): string;

package/dist/{vfs/path.js → path.js}

@@ -20,10 +20,7 @@ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
-export let cwd = '/';
-export function cd(path) {
-    cwd = resolve(cwd, path);
-}
+import { defaultContext } from './internal/contexts.js';
 export const sep = '/';
 function validateObject(str, name) {
     if (typeof str != 'object') {
@@ -103,11 +100,11 @@ export function formatExt(ext) {
     return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';
 }
 export function resolve(...parts) {
+    var _a;
     let resolved = '';
-    for (const part of [...parts.reverse(), cwd]) {
-        if (!part.length) {
+    for (const part of [...parts.reverse(), (_a = this === null || this === void 0 ? void 0 : this.pwd) !== null && _a !== void 0 ? _a : defaultContext.pwd]) {
+        if (!(part === null || part === void 0 ? void 0 : part.length))
             continue;
-        }
         resolved = `${part}/${resolved}`;
         if (part.startsWith('/')) {
             break;
@@ -154,8 +151,8 @@ export function relative(from, to) {
     if (from === to)
         return '';
     // Trim leading forward slashes.
-    from = resolve(from);
-    to = resolve(to);
+    from = resolve.call(this, from);
+    to = resolve.call(this, to);
     if (from === to)
         return '';
     const fromStart = 1;

package/dist/readline.d.ts

@@ -0,0 +1,134 @@
+import { EventEmitter } from 'eventemitter3';
+import type { Abortable } from 'node:events';
+import type * as readline from 'node:readline';
+interface InterfaceEvents {
+    close: [];
+    line: [input: string];
+    pause: [];
+    resume: [];
+    SIGCONT: [];
+    SIGINT: [];
+    SIGTSTP: [];
+    history: [history: string[]];
+}
+export declare class Interface extends EventEmitter<InterfaceEvents> implements readline.Interface {
+    readonly input: NodeJS.ReadableStream;
+    readonly output?: NodeJS.WritableStream | undefined;
+    readonly terminal: boolean;
+    readonly line: string;
+    protected _cursor: number;
+    get cursor(): number;
+    private _buffer;
+    private _closed;
+    private _paused;
+    private _prompt;
+    private _history;
+    private _historyIndex;
+    private _currentLine;
+    constructor(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream | undefined, completer?: readline.Completer | readline.AsyncCompleter, terminal?: boolean);
+    private _onData;
+    /**
+     * Closes the interface and removes all event listeners
+     */
+    close(): void;
+    /**
+     * Pauses the input stream
+     */
+    pause(): this;
+    /**
+     * Resumes the input stream
+     */
+    resume(): this;
+    /**
+     * Sets the prompt text
+     */
+    setPrompt(prompt: string): void;
+    /**
+     * Gets the current prompt text
+     */
+    getPrompt(): string;
+    /**
+     * Displays the prompt to the user
+     */
+    prompt(preserveCursor?: boolean): void;
+    /**
+     * Writes data to the interface and handles key events
+     */
+    write(data: string | Buffer, key?: readline.Key): void;
+    private _renderLine;
+    /**
+     * Asks the user for input with a specified prompt
+     */
+    question(query: string, callback: (answer: string) => void): void;
+    question(query: string, options: Abortable, callback: (answer: string) => void): void;
+    /**
+     * Gets the current cursor position
+     */
+    getCursorPos(): {
+        rows: number;
+        cols: number;
+    };
+    /**
+     * Prepends a listener for the specified event
+     */
+    prependListener(event: keyof InterfaceEvents, listener: (...args: any[]) => void): this;
+    /**
+     * Prepends a one-time listener for the specified event
+     */
+    prependOnceListener(event: keyof InterfaceEvents, listener: (...args: any[]) => void): this;
+    /**
+     * Sets the maximum number of listeners
+     */
+    setMaxListeners(): this;
+    /**
+     * Gets the maximum number of listeners
+     */
+    getMaxListeners(): number;
+    [Symbol.asyncIterator](): AsyncIteratorObject<string>;
+    [Symbol.asyncDispose](): Promise<void>;
+    rawListeners(event: keyof InterfaceEvents): ((...args: any[]) => void)[];
+}
+/**
+ * Creates a readline interface
+ * @param input The readable stream to read from
+ * @param output The writable stream to write to
+ * @param completer The completer function
+ * @param terminal Whether to use terminal features
+ * @returns A readline interface
+ */
+export declare function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: readline.Completer | readline.AsyncCompleter, terminal?: boolean): Interface;
+/**
+ * Creates a readline interface from options
+ * @param options The options for the interface
+ * @returns A readline interface
+ */
+export declare function createInterface(options: readline.ReadLineOptions): Interface;
+/**
+ * Clear the current line in the terminal
+ * @param stream The stream to clear the line on
+ * @param dir The direction to clear: -1 for left, 1 for right, 0 for entire line
+ */
+export declare function clearLine(stream: NodeJS.WritableStream, dir: number): boolean;
+/**
+ * Clear the screen down from the current position
+ * @param stream The stream to clear the screen on
+ */
+export declare function clearScreenDown(stream: NodeJS.WritableStream): boolean;
+/**
+ * Move the cursor in the terminal
+ * @param stream The stream to move the cursor on
+ * @param dx The number of characters to move horizontally
+ * @param dy The number of lines to move vertically
+ */
+export declare function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number): boolean;
+/**
+ * The `readline.emitKeypressEvents()` method causes the given Readable stream to begin emitting `'keypress'` events corresponding to received input.
+ *
+ * Optionally, interface specifies a `readline.Interface` instance for which autocompletion is disabled when copy-pasted input is detected.
+ *
+ * If the `stream` is a TTY, then it must be in raw mode.
+ *
+ * This is automatically called by any readline instance on its `input` if the `input` is a terminal. Closing the `readline` instance does not stop the `input` from emitting `'keypress'` events.
+ */
+export declare function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface | readline.Interface): void;
+export {};