@zenfs/core 0.12.1 → 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>;

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/overlay.js

@@ -166,7 +166,7 @@ export class UnlockedOverlayFS extends FileSystem {
         }
         // Create an OverlayFile.
         const file = this._readable.openFileSync(path, parseFlag('r'), cred);
-        const stats = Stats.clone(file.statSync());
+        const stats = new Stats(file.statSync());
         const data = new Uint8Array(stats.size);
         file.readSync(data);
         return new PreloadFile(this, path, flag, stats, data);

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>;
@@ -61,7 +62,10 @@ declare const PortFS_base: (abstract new (...args: any[]) => {
     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');
     }
 }
 /**