@zenfs/core 0.12.2 → 0.12.3

package/dist/backends/backend.d.ts

@@ -1,5 +1,5 @@
 import type { RequiredKeys } from 'utilium';
-import { FileSystem } from '../filesystem.js';
+import type { FileSystem } from '../filesystem.js';
 type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
 /**
  * Resolves the type of Backend.options from the options interface

package/dist/backends/fetch.d.ts

@@ -1,5 +1,5 @@
 import type { FileSystemMetadata } from '../filesystem.js';
-import { Stats } from '../stats.js';
+import type { Stats } from '../stats.js';
 import { IndexFS } from './index/fs.js';
 import type { IndexData } from './index/index.js';
 /**

package/dist/backends/index/fs.d.ts

@@ -2,7 +2,8 @@ import type { Cred } from '../../cred.js';
 import { NoSyncFile } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
 import type { Stats } from '../../stats.js';
-import { Index, IndexData } from './index.js';
+import type { IndexData } from './index.js';
+import { Index } from './index.js';
 declare const IndexFS_base: (abstract new (...args: any[]) => {
     metadata(): import("../../filesystem.js").FileSystemMetadata;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
@@ -19,7 +20,6 @@ declare const IndexFS_base: (abstract new (...args: any[]) => {
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-    _type?: number | undefined;
     ready(): Promise<void>;
     stat(path: string, cred: Cred): Promise<Stats>;
     statSync(path: string, cred: Cred): Stats;

package/dist/backends/index/index.d.ts

@@ -1,4 +1,5 @@
-import { Stats, StatsLike } from '../../stats.js';
+import type { StatsLike } from '../../stats.js';
+import { Stats } from '../../stats.js';
 /**
  * An Index in JSON form
  * @internal

package/dist/backends/overlay.d.ts

@@ -1,8 +1,9 @@
-import { FileSystem, FileSystemMetadata } from '../filesystem.js';
-import { File } from '../file.js';
+import type { FileSystemMetadata } from '../filesystem.js';
+import { FileSystem } from '../filesystem.js';
+import type { File } from '../file.js';
 import { Stats } from '../stats.js';
 import { LockedFS } from './locked.js';
-import { Cred } from '../cred.js';
+import type { Cred } from '../cred.js';
 /**
  * Configuration options for OverlayFS instances.
  */

package/dist/backends/port/fs.d.ts

@@ -16,6 +16,7 @@ export declare class PortFile extends File {
     position: number;
     constructor(fs: PortFS, fd: number, path: string, position: number);
     rpc<const T extends FileMethod & string>(method: T, ...args: Parameters<FileMethods[T]>): Promise<Awaited<ReturnType<FileMethods[T]>>>;
+    protected _throwNoSync(syscall: string): never;
     stat(): Promise<Stats>;
     statSync(): Stats;
     truncate(len: number): Promise<void>;
@@ -55,14 +56,16 @@ declare const PortFS_base: (abstract new (...args: any[]) => {
     readdirSync(path: string, cred: Cred): string[];
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-    _type?: number | undefined;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     stat(path: string, cred: Cred): Promise<Stats>;
     openFile(path: string, flag: string, cred: Cred): Promise<File>;
     createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
     unlink(path: string, cred: Cred): Promise<void>;
     rmdir(path: string, cred: Cred): Promise<void>;
-    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    mkdir(path: string, mode: number, cred: Cred): Promise<void>; /**
+     * Constructs a new PortFS instance that connects with ZenFS running on
+     * the specified port.
+     */
     readdir(path: string, cred: Cred): Promise<string[]>;
     exists(path: string, cred: Cred): Promise<boolean>;
     existsSync(path: string, cred: Cred): boolean;

package/dist/backends/port/fs.js

@@ -20,66 +20,69 @@ export class PortFile extends File {
             args,
         }, this.fs.options);
     }
+    _throwNoSync(syscall) {
+        throw new ErrnoError(Errno.ENOTSUP, 'Syncrohnous operations not support on PortFile', this.path, syscall);
+    }
     stat() {
         return this.rpc('stat');
     }
     statSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile.stat');
+        this._throwNoSync('stat');
     }
     truncate(len) {
         return this.rpc('truncate', len);
     }
     truncateSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile.truncate');
+        this._throwNoSync('truncate');
     }
     write(buffer, offset, length, position) {
         return this.rpc('write', buffer, offset, length, position);
     }
     writeSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile.write');
+        this._throwNoSync('write');
     }
     async read(buffer, offset, length, position) {
         const result = await this.rpc('read', buffer, offset, length, position);
         return result;
     }
     readSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile.read');
+        this._throwNoSync('read');
     }
     chown(uid, gid) {
         return this.rpc('chown', uid, gid);
     }
     chownSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile.chown');
+        this._throwNoSync('chown');
     }
     chmod(mode) {
         return this.rpc('chmod', mode);
     }
     chmodSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile.chmod');
+        this._throwNoSync('chmod');
     }
     utimes(atime, mtime) {
         return this.rpc('utimes', atime, mtime);
     }
     utimesSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile.utimes');
+        this._throwNoSync('utimes');
     }
     _setType(type) {
         return this.rpc('_setType', type);
     }
     _setTypeSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile._setType');
+        this._throwNoSync('_setType');
     }
     close() {
         return this.rpc('close');
     }
     closeSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile.close');
+        this._throwNoSync('close');
     }
     sync() {
         return this.rpc('sync');
     }
     syncSync() {
-        throw ErrnoError.With('ENOSYS', this.path, 'PortFile.sync');
+        this._throwNoSync('sync');
     }
 }
 /**