@zenfs/core 0.0.12 → 0.1.0

package/dist/emulation/shared.d.ts

@@ -60,3 +60,17 @@ export declare function fixError<E extends Error>(e: E, paths: {
     [from: string]: string;
 }): E;
 export declare function initialize(mountMapping: MountMapping): void;
+/**
+ * Types supports as path parameters.
+ *
+ * In the future, maybe support URL?
+ */
+export type PathLike = string;
+/**
+ * @internal
+ *
+ * Converts any Buffer in T to Uint8Array
+ */
+export type BufferToUint8Array<T> = T extends Buffer ? Uint8Array : T extends (...args: any[]) => unknown ? (...args: Parameters<T>) => BufferToUint8Array<ReturnType<T>> : T extends object ? {
+    [K in keyof T]: BufferToUint8Array<T[K]>;
+} : T;

package/dist/emulation/shared.js

@@ -2,7 +2,6 @@
 import { resolve } from './path.js';
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { Cred } from '../cred.js';
-//import { BackendConstructor } from '../backends.js';
 import { InMemoryFileSystem } from '../backends/InMemory.js';
 /**
  * converts Date or number to a fractional UNIX timestamp
@@ -170,12 +169,14 @@ export function resolveFS(path) {
  */
 export function fixPaths(text, paths) {
     for (const [from, to] of Object.entries(paths)) {
-        text = text.replaceAll(from, to);
+        text = text?.replaceAll(from, to);
     }
     return text;
 }
 export function fixError(e, paths) {
-    e.stack = fixPaths(e.stack, paths);
+    if (typeof e.stack == 'string') {
+        e.stack = fixPaths(e.stack, paths);
+    }
     e.message = fixPaths(e.message, paths);
     return e;
 }

package/dist/emulation/streams.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type * as Node from 'fs';
+import { Readable, Writable } from 'readable-stream';
+import { NoArgCallback } from '../filesystem.js';
+export declare class ReadStream extends Readable implements Node.ReadStream {
+    close(callback?: NoArgCallback): void;
+    bytesRead: number;
+    path: string | Buffer;
+    pending: boolean;
+    addListener(event: 'close', listener: () => void): this;
+    addListener(event: 'data', listener: (chunk: Buffer | string) => void): this;
+    addListener(event: 'end', listener: () => void): this;
+    addListener(event: 'error', listener: (err: Error) => void): this;
+    addListener(event: 'open', listener: (fd: number) => void): this;
+    addListener(event: 'pause', listener: () => void): this;
+    addListener(event: 'readable', listener: () => void): this;
+    addListener(event: 'ready', listener: () => void): this;
+    addListener(event: 'resume', listener: () => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'data', listener: (chunk: Buffer | string) => void): this;
+    on(event: 'end', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'open', listener: (fd: number) => void): this;
+    on(event: 'pause', listener: () => void): this;
+    on(event: 'readable', listener: () => void): this;
+    on(event: 'ready', listener: () => void): this;
+    on(event: 'resume', listener: () => void): this;
+    once(event: 'close', listener: () => void): this;
+    once(event: 'data', listener: (chunk: Buffer | string) => void): this;
+    once(event: 'end', listener: () => void): this;
+    once(event: 'error', listener: (err: Error) => void): this;
+    once(event: 'open', listener: (fd: number) => void): this;
+    once(event: 'pause', listener: () => void): this;
+    once(event: 'readable', listener: () => void): this;
+    once(event: 'ready', listener: () => void): this;
+    once(event: 'resume', listener: () => void): this;
+    prependListener(event: 'close', listener: () => void): this;
+    prependListener(event: 'data', listener: (chunk: Buffer | string) => void): this;
+    prependListener(event: 'end', listener: () => void): this;
+    prependListener(event: 'error', listener: (err: Error) => void): this;
+    prependListener(event: 'open', listener: (fd: number) => void): this;
+    prependListener(event: 'pause', listener: () => void): this;
+    prependListener(event: 'readable', listener: () => void): this;
+    prependListener(event: 'ready', listener: () => void): this;
+    prependListener(event: 'resume', listener: () => void): this;
+    prependOnceListener(event: 'close', listener: () => void): this;
+    prependOnceListener(event: 'data', listener: (chunk: Buffer | string) => void): this;
+    prependOnceListener(event: 'end', listener: () => void): this;
+    prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+    prependOnceListener(event: 'open', listener: (fd: number) => void): this;
+    prependOnceListener(event: 'pause', listener: () => void): this;
+    prependOnceListener(event: 'readable', listener: () => void): this;
+    prependOnceListener(event: 'ready', listener: () => void): this;
+    prependOnceListener(event: 'resume', listener: () => void): this;
+}
+export declare class WriteStream extends Writable implements Node.WriteStream {
+    close(callback?: NoArgCallback): void;
+    bytesWritten: number;
+    path: string | Buffer;
+    pending: boolean;
+    addListener(event: 'close', listener: () => void): this;
+    addListener(event: 'drain', listener: () => void): this;
+    addListener(event: 'error', listener: (err: Error) => void): this;
+    addListener(event: 'finish', listener: () => void): this;
+    addListener(event: 'open', listener: (fd: number) => void): this;
+    addListener(event: 'pipe', listener: (src: Readable) => void): this;
+    addListener(event: 'ready', listener: () => void): this;
+    addListener(event: 'unpipe', listener: (src: Readable) => void): this;
+    on(event: 'close', listener: () => void): this;
+    on(event: 'drain', listener: () => void): this;
+    on(event: 'error', listener: (err: Error) => void): this;
+    on(event: 'finish', listener: () => void): this;
+    on(event: 'open', listener: (fd: number) => void): this;
+    on(event: 'pipe', listener: (src: Readable) => void): this;
+    on(event: 'ready', listener: () => void): this;
+    on(event: 'unpipe', listener: (src: Readable) => void): this;
+    once(event: 'close', listener: () => void): this;
+    once(event: 'drain', listener: () => void): this;
+    once(event: 'error', listener: (err: Error) => void): this;
+    once(event: 'finish', listener: () => void): this;
+    once(event: 'open', listener: (fd: number) => void): this;
+    once(event: 'pipe', listener: (src: Readable) => void): this;
+    once(event: 'ready', listener: () => void): this;
+    once(event: 'unpipe', listener: (src: Readable) => void): this;
+    prependListener(event: 'close', listener: () => void): this;
+    prependListener(event: 'drain', listener: () => void): this;
+    prependListener(event: 'error', listener: (err: Error) => void): this;
+    prependListener(event: 'finish', listener: () => void): this;
+    prependListener(event: 'open', listener: (fd: number) => void): this;
+    prependListener(event: 'pipe', listener: (src: Readable) => void): this;
+    prependListener(event: 'ready', listener: () => void): this;
+    prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
+    prependOnceListener(event: 'close', listener: () => void): this;
+    prependOnceListener(event: 'drain', listener: () => void): this;
+    prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+    prependOnceListener(event: 'finish', listener: () => void): this;
+    prependOnceListener(event: 'open', listener: (fd: number) => void): this;
+    prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
+    prependOnceListener(event: 'ready', listener: () => void): this;
+    prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
+}

package/dist/emulation/streams.js

@@ -0,0 +1,55 @@
+import { Readable, Writable } from 'readable-stream';
+export class ReadStream extends Readable {
+    close(callback = () => null) {
+        try {
+            super.destroy();
+            super.emit('close');
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    addListener(event, listener) {
+        return super.addListener(event, listener);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    prependListener(event, listener) {
+        return super.prependListener(event, listener);
+    }
+    prependOnceListener(event, listener) {
+        return super.prependOnceListener(event, listener);
+    }
+}
+export class WriteStream extends Writable {
+    close(callback = () => null) {
+        try {
+            super.destroy();
+            super.emit('close');
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    addListener(event, listener) {
+        return super.addListener(event, listener);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+    prependListener(event, listener) {
+        return super.prependListener(event, listener);
+    }
+    prependOnceListener(event, listener) {
+        return super.prependOnceListener(event, listener);
+    }
+}

package/dist/emulation/sync.d.ts

@@ -1,60 +1,72 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import { FileContents } from '../filesystem.js';
-import { Stats } from '../stats.js';
-import type { symlink, ReadSyncOptions } from 'fs';
+import { BigIntStats, Stats } from '../stats.js';
+import type { symlink, ReadSyncOptions, BaseEncodingOptions, BufferEncodingOption } from 'fs';
+import type * as Node from 'fs';
+import { PathLike } from './shared.js';
+import { Dir, Dirent } from './dir.js';
 /**
  * Synchronous rename.
  * @param oldPath
  * @param newPath
  */
-export declare function renameSync(oldPath: string, newPath: string): void;
+export declare function renameSync(oldPath: PathLike, newPath: PathLike): void;
 /**
  * Test whether or not the given path exists by checking with the file system.
  * @param path
  */
-export declare function existsSync(path: string): boolean;
+export declare function existsSync(path: PathLike): boolean;
 /**
  * Synchronous `stat`.
  * @param path
  * @returns Stats
  */
-export declare function statSync(path: string): Stats;
+export declare function statSync(path: PathLike, options?: {
+    bigint: false;
+}): Stats;
+export declare function statSync(path: PathLike, options: {
+    bigint: true;
+}): BigIntStats;
 /**
  * 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.
  * @param path
- * @return [ZenFS.node.fs.Stats]
  */
-export declare function lstatSync(path: string): Stats;
+export declare function lstatSync(path: PathLike, options?: {
+    bigint: false;
+}): Stats;
+export declare function lstatSync(path: PathLike, options: {
+    bigint: true;
+}): BigIntStats;
 /**
  * Synchronous `truncate`.
  * @param path
  * @param len
  */
-export declare function truncateSync(path: string, len?: number): void;
+export declare function truncateSync(path: PathLike, len?: number): void;
 /**
  * Synchronous `unlink`.
  * @param path
  */
-export declare function unlinkSync(path: string): void;
+export declare function unlinkSync(path: PathLike): void;
 /**
  * Synchronous file open.
  * @see http://www.manpagez.com/man/2/open/
  * @param path
  * @param flags
  * @param mode defaults to `0644`
- * @return [ZenFS.File]
+ * @returns file descriptor
  */
-export declare function openSync(path: string, flag: string, mode?: number | string): number;
+export declare function openSync(path: PathLike, flag: string, mode?: number | string): number;
 /**
  * Synchronously reads the entire contents of a file.
  * @param filename
  * @param options
- * @option options [String] encoding The string encoding for the file contents. Defaults to `null`.
- * @option options [String] flag Defaults to `'r'`.
- * @return [String | ZenFS.node.Uint8Array]
+ * @option options encoding The string encoding for the file contents. Defaults to `null`.
+ * @option options flag Defaults to `'r'`.
+ * @returns file contents
  */
 export declare function readFileSync(filename: string, options?: {
     flag?: string;
@@ -72,15 +84,11 @@ export declare function readFileSync(filename: string, encoding: string): string
  * @param filename
  * @param data
  * @param options
- * @option options [String] encoding Defaults to `'utf8'`.
- * @option options [Number] mode Defaults to `0644`.
- * @option options [String] flag Defaults to `'w'`.
+ * @option options encoding Defaults to `'utf8'`.
+ * @option options mode Defaults to `0644`.
+ * @option options flag Defaults to `'w'`.
  */
-export declare function writeFileSync(filename: string, data: FileContents, options?: {
-    encoding?: string;
-    mode?: number | string;
-    flag?: string;
-}): void;
+export declare function writeFileSync(filename: string, data: FileContents, options?: Node.WriteFileOptions): void;
 export declare function writeFileSync(filename: string, data: FileContents, encoding?: string): void;
 /**
  * Asynchronously append data to a file, creating the file if it not yet
@@ -94,24 +102,24 @@ export declare function writeFileSync(filename: string, data: FileContents, enco
  * @param filename
  * @param data
  * @param options
- * @option options [String] encoding Defaults to `'utf8'`.
- * @option options [Number] mode Defaults to `0644`.
- * @option options [String] flag Defaults to `'a'`.
+ * @option options encoding Defaults to `'utf8'`.
+ * @option options mode Defaults to `0644`.
+ * @option options flag Defaults to `'a'`.
  */
-export declare function appendFileSync(filename: string, data: FileContents, options?: {
-    encoding?: string;
-    mode?: number | string;
-    flag?: string;
-}): void;
+export declare function appendFileSync(filename: string, data: FileContents, options?: Node.WriteFileOptions): void;
 export declare function appendFileSync(filename: string, data: FileContents, encoding?: string): void;
 /**
  * Synchronous `fstat`.
  * `fstat()` is identical to `stat()`, except that the file to be stat-ed is
  * specified by the file descriptor `fd`.
  * @param fd
- * @return [ZenFS.node.fs.Stats]
  */
-export declare function fstatSync(fd: number): Stats;
+export declare function fstatSync(fd: number, options?: {
+    bigint?: false;
+}): Stats;
+export declare function fstatSync(fd: number, options: {
+    bigint: true;
+}): BigIntStats;
 /**
  * Synchronous close.
  * @param fd
@@ -187,92 +195,113 @@ export declare function futimesSync(fd: number, atime: number | Date, mtime: num
  * Synchronous `rmdir`.
  * @param path
  */
-export declare function rmdirSync(path: string): void;
+export declare function rmdirSync(path: PathLike): void;
 /**
  * Synchronous `mkdir`.
  * @param path
- * @param mode defaults to `0777`
+ * @param mode defaults to o777
+ * @todo Implement recursion
  */
-export declare function mkdirSync(path: string, mode?: number | string): void;
+export declare function mkdirSync(path: PathLike, options: Node.MakeDirectoryOptions & {
+    recursive: true;
+}): string;
+export declare function mkdirSync(path: PathLike, options?: Node.Mode | (Node.MakeDirectoryOptions & {
+    recursive?: false;
+})): void;
 /**
  * Synchronous `readdir`. Reads the contents of a directory.
  * @param path
- * @return [String[]]
  */
-export declare function readdirSync(path: string): string[];
+export declare function readdirSync(path: PathLike, options: {
+    encoding?: BufferEncoding;
+    withFileTypes?: false;
+} | BufferEncoding): string[];
+export declare function readdirSync(path: PathLike, options: {
+    encoding: 'buffer';
+    withFileTypes?: false;
+} | 'buffer'): Uint8Array[];
+export declare function readdirSync(path: PathLike, options: {
+    withFileTypes: true;
+}): Dirent[];
 /**
  * Synchronous `link`.
  * @param srcpath
  * @param dstpath
  */
-export declare function linkSync(srcpath: string, dstpath: string): void;
+export declare function linkSync(srcpath: PathLike, dstpath: PathLike): void;
 /**
  * Synchronous `symlink`.
  * @param srcpath
  * @param dstpath
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
-export declare function symlinkSync(srcpath: string, dstpath: string, type?: symlink.Type): void;
+export declare function symlinkSync(srcpath: PathLike, dstpath: PathLike, type?: symlink.Type): void;
 /**
  * Synchronous readlink.
  * @param path
- * @return [String]
  */
-export declare function readlinkSync(path: string): string;
+export declare function readlinkSync(path: PathLike, options?: BufferEncodingOption): Uint8Array;
+export declare function readlinkSync(path: PathLike, options: BaseEncodingOptions | BufferEncoding): string;
 /**
  * Synchronous `chown`.
  * @param path
  * @param uid
  * @param gid
  */
-export declare function chownSync(path: string, uid: number, gid: number): void;
+export declare function chownSync(path: PathLike, uid: number, gid: number): void;
 /**
  * Synchronous `lchown`.
  * @param path
  * @param uid
  * @param gid
  */
-export declare function lchownSync(path: string, uid: number, gid: number): void;
+export declare function lchownSync(path: PathLike, uid: number, gid: number): void;
 /**
  * Synchronous `chmod`.
  * @param path
  * @param mode
  */
-export declare function chmodSync(path: string, mode: string | number): void;
+export declare function chmodSync(path: PathLike, mode: string | number): void;
 /**
  * Synchronous `lchmod`.
  * @param path
  * @param mode
  */
-export declare function lchmodSync(path: string, mode: number | string): void;
+export declare function lchmodSync(path: PathLike, mode: number | string): void;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
  * @param atime
  * @param mtime
  */
-export declare function utimesSync(path: string, atime: number | Date, mtime: number | Date): void;
+export declare function utimesSync(path: PathLike, atime: number | Date, mtime: number | Date): void;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
  * @param atime
  * @param mtime
  */
-export declare function lutimesSync(path: string, atime: number | Date, mtime: number | Date): void;
+export declare function lutimesSync(path: PathLike, atime: number | Date, mtime: number | Date): void;
 /**
  * Synchronous `realpath`.
  * @param path
  * @param cache An object literal of mapped paths that can be used to
  *   force a specific path resolution or avoid additional `fs.stat` calls for
  *   known real paths.
- * @return [String]
+ * @returns the real path
  */
-export declare function realpathSync(path: string, cache?: {
-    [path: string]: string;
-}): string;
+export declare function realpathSync(path: PathLike, options: BufferEncodingOption): Uint8Array;
+export declare function realpathSync(path: PathLike, options?: BaseEncodingOptions | BufferEncoding): string;
 /**
  * Synchronous `access`.
  * @param path
  * @param mode
  */
-export declare function accessSync(path: string, mode?: number): void;
+export declare function accessSync(path: PathLike, mode?: number): void;
+export declare function rmSync(path: PathLike): void;
+export declare function mkdtempSync(prefix: string, options: BufferEncodingOption): Uint8Array;
+export declare function mkdtempSync(prefix: string, options?: BaseEncodingOptions | BufferEncoding): string;
+export declare function copyFileSync(src: string, dest: string, flags?: number): void;
+export declare function readvSync(fd: number, buffers: readonly Uint8Array[], position?: number): number;
+export declare function writevSync(fd: number, buffers: readonly Uint8Array[], position?: number): number;
+export declare function opendirSync(path: PathLike, options?: Node.OpenDirOptions): Dir;