@zenfs/core 0.2.2 → 0.3.0

package/dist/file.d.ts

@@ -1,5 +1,5 @@
+import type { FileSystem } from './filesystem.js';
 import { Stats, type FileType } from './stats.js';
-import { FileSystem, type SyncFileSystem } from './filesystem.js';
 declare global {
     interface ArrayBuffer {
         readonly resizable: boolean;
@@ -419,7 +419,7 @@ export declare abstract class PreloadFile<T extends FileSystem> extends File {
 /**
  * For synchronous file systems
  */
-export declare class SyncFile<FS extends SyncFileSystem> extends PreloadFile<FS> {
+export declare class SyncFile<FS extends FileSystem> extends PreloadFile<FS> {
     constructor(_fs: FS, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
     sync(): Promise<void>;
     syncSync(): void;

package/dist/file.js

@@ -1,7 +1,7 @@
 import { ApiError, ErrorCode } from './ApiError.js';
-import { Stats } from './stats.js';
-import { O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_EXCL, O_TRUNC, O_APPEND, O_SYNC, S_IFMT } from './emulation/constants.js';
+import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT } from './emulation/constants.js';
 import { size_max } from './inode.js';
+import { Stats } from './stats.js';
 export var ActionType;
 (function (ActionType) {
     // Indicates that the code should not do anything.

package/dist/filesystem.d.ts

@@ -46,7 +46,6 @@ export interface FileSystemMetadata {
  * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
  */
 export declare abstract class FileSystem {
-    static get Name(): string;
     get metadata(): FileSystemMetadata;
     constructor(options?: object);
     abstract ready(): Promise<this>;
@@ -156,10 +155,15 @@ export declare abstract class FileSystem {
 }
 /**
  * Implements the asynchronous API in terms of the synchronous API.
+ *
+ * @example ```ts
+ * class SyncFS extends Sync(FileSystem) {}
+ * ```
  */
-export declare abstract class SyncFileSystem extends FileSystem {
-    get metadata(): FileSystemMetadata;
-    ready(): Promise<this>;
+export declare function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => {
+    readonly metadata: FileSystemMetadata;
+    ready(): Promise<any>;
+    exists(path: string, cred: Cred): Promise<boolean>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     stat(path: string, cred: Cred): Promise<Stats>;
     createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
@@ -170,21 +174,61 @@ export declare abstract class SyncFileSystem extends FileSystem {
     readdir(path: string, cred: Cred): Promise<string[]>;
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-}
-export declare abstract class ReadonlySyncFileSystem extends SyncFileSystem {
+    /**
+     * Synchronous rename.
+     */
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
+    /**
+     * Synchronous `stat`.
+     */
+    statSync(path: string, cred: Cred): Stats;
+    /**
+     * Opens the file at path p with the given flag. The file must exist.
+     * @param p The path to open.
+     * @param flag The flag to use when opening the file.
+     * @return A File object corresponding to the opened file.
+     */
+    openFileSync(path: string, flag: FileFlag, cred: Cred): File;
+    /**
+     * Create the file at path p with the given mode. Then, open it with the given
+     * flag.
+     */
     createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
+    /**
+     * Synchronous `unlink`.
+     */
     unlinkSync(path: string, cred: Cred): void;
+    /**
+     * Synchronous `rmdir`.
+     */
     rmdirSync(path: string, cred: Cred): void;
+    /**
+     * Synchronous `mkdir`.
+     * @param mode Mode to make the directory using. Can be ignored if
+     *   the filesystem doesn't support permissions.
+     */
     mkdirSync(path: string, mode: number, cred: Cred): void;
+    /**
+     * Synchronous `readdir`. Reads the contents of a directory.
+     */
+    readdirSync(path: string, cred: Cred): string[];
+    /**
+     * Test whether or not the given path exists by checking with the file system.
+     */
+    existsSync(path: string, cred: Cred): boolean;
+    /**
+     * Synchronous `link`.
+     */
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
+    /**
+     * Synchronize the data and stats for path synchronously
+     */
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}
-export declare abstract class AsyncFileSystem extends FileSystem {
+}) & T;
+export declare function Async<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => {
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(path: string, cred: Cred): Stats;
     createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
-    openSync(path: string, flags: FileFlag, mode: number, cred: Cred): File;
     openFileSync(path: string, flag: FileFlag, cred: Cred): File;
     unlinkSync(path: string, cred: Cred): void;
     rmdirSync(path: string, cred: Cred): void;
@@ -192,13 +236,121 @@ export declare abstract class AsyncFileSystem extends FileSystem {
     readdirSync(path: string, cred: Cred): string[];
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}
-export declare abstract class ReadonlyAsyncFileSystem extends AsyncFileSystem {
+    readonly metadata: FileSystemMetadata;
+    ready(): Promise<any>;
+    /**
+     * Asynchronous rename. No arguments other than a possible exception
+     * are given to the completion callback.
+     */
+    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    /**
+     * Asynchronous `stat`.
+     */
+    stat(path: string, cred: Cred): Promise<Stats>;
+    /**
+     * Opens the file at path p with the given flag. The file must exist.
+     * @param p The path to open.
+     * @param flag The flag to use when opening the file.
+     */
+    openFile(path: string, flag: FileFlag, cred: Cred): Promise<File>;
+    /**
+     * Create the file at path p with the given mode. Then, open it with the given
+     * flag.
+     */
+    createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    /**
+     * Asynchronous `unlink`.
+     */
+    unlink(path: string, cred: Cred): Promise<void>;
+    /**
+     * Asynchronous `rmdir`.
+     */
+    rmdir(path: string, cred: Cred): Promise<void>;
+    /**
+     * Asynchronous `mkdir`.
+     * @param mode Mode to make the directory using. Can be ignored if
+     *   the filesystem doesn't support permissions.
+     */
+    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    /**
+     * Asynchronous `readdir`. Reads the contents of a directory.
+     *
+     * The callback gets two arguments `(err, files)` where `files` is an array of
+     * the names of the files in the directory excluding `'.'` and `'..'`.
+     */
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    /**
+     * Test whether or not the given path exists by checking with the file system.
+     */
+    exists(path: string, cred: Cred): Promise<boolean>;
+    /**
+     * Test whether or not the given path exists by checking with the file system.
+     */
+    existsSync(path: string, cred: Cred): boolean;
+    /**
+     * Asynchronous `link`.
+     */
+    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    /**
+     * Synchronize the data and stats for path asynchronously
+     */
+    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+}) & T;
+export declare function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => {
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    renameSync(oldPath: string, newPath: string, cred: Cred): void;
     createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
     unlink(path: string, cred: Cred): Promise<void>;
+    unlinkSync(path: string, cred: Cred): void;
     rmdir(path: string, cred: Cred): Promise<void>;
+    rmdirSync(path: string, cred: Cred): void;
     mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    mkdirSync(path: string, mode: number, cred: Cred): void;
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    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;
+    readonly metadata: FileSystemMetadata;
+    ready(): Promise<any>;
+    /**
+     * Asynchronous `stat`.
+     */
+    stat(path: string, cred: Cred): Promise<Stats>;
+    /**
+     * Synchronous `stat`.
+     */
+    statSync(path: string, cred: Cred): Stats;
+    /**
+     * Opens the file at path p with the given flag. The file must exist.
+     * @param p The path to open.
+     * @param flag The flag to use when opening the file.
+     */
+    openFile(path: string, flag: FileFlag, cred: Cred): Promise<File>;
+    /**
+     * Opens the file at path p with the given flag. The file must exist.
+     * @param p The path to open.
+     * @param flag The flag to use when opening the file.
+     * @return A File object corresponding to the opened file.
+     */
+    openFileSync(path: string, flag: FileFlag, cred: Cred): File;
+    /**
+     * Asynchronous `readdir`. Reads the contents of a directory.
+     *
+     * The callback gets two arguments `(err, files)` where `files` is an array of
+     * the names of the files in the directory excluding `'.'` and `'..'`.
+     */
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    /**
+     * Synchronous `readdir`. Reads the contents of a directory.
+     */
+    readdirSync(path: string, cred: Cred): string[];
+    /**
+     * Test whether or not the given path exists by checking with the file system.
+     */
+    exists(path: string, cred: Cred): Promise<boolean>;
+    /**
+     * Test whether or not the given path exists by checking with the file system.
+     */
+    existsSync(path: string, cred: Cred): boolean;
+}) & T;

package/dist/filesystem.js

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-// disable no-unused-vars since BaseFileSystem uses them a lot
 import { ApiError, ErrorCode } from './ApiError.js';
 /**
  * Structure for a filesystem. All ZenFS FileSystems must implement this.
@@ -12,9 +10,6 @@ import { ApiError, ErrorCode } from './ApiError.js';
  * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
  */
 export class FileSystem {
-    static get Name() {
-        return this.name;
-    }
     get metadata() {
         return {
             name: this.constructor.name,
@@ -25,6 +20,7 @@ export class FileSystem {
             freeSpace: 0,
         };
     }
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
     constructor(options) {
         // unused
     }
@@ -55,123 +51,140 @@ export class FileSystem {
 }
 /**
  * Implements the asynchronous API in terms of the synchronous API.
+ *
+ * @example ```ts
+ * class SyncFS extends Sync(FileSystem) {}
+ * ```
  */
-export class SyncFileSystem extends FileSystem {
-    get metadata() {
-        return { ...super.metadata, synchronous: true };
-    }
-    async ready() {
-        return this;
-    }
-    async rename(oldPath, newPath, cred) {
-        return this.renameSync(oldPath, newPath, cred);
-    }
-    async stat(path, cred) {
-        return this.statSync(path, cred);
-    }
-    async createFile(path, flag, mode, cred) {
-        return this.createFileSync(path, flag, mode, cred);
-    }
-    async openFile(path, flag, cred) {
-        return this.openFileSync(path, flag, cred);
-    }
-    async unlink(path, cred) {
-        return this.unlinkSync(path, cred);
-    }
-    async rmdir(path, cred) {
-        return this.rmdirSync(path, cred);
-    }
-    async mkdir(path, mode, cred) {
-        return this.mkdirSync(path, mode, cred);
-    }
-    async readdir(path, cred) {
-        return this.readdirSync(path, cred);
-    }
-    async link(srcpath, dstpath, cred) {
-        return this.linkSync(srcpath, dstpath, cred);
-    }
-    async sync(path, data, stats) {
-        return this.syncSync(path, data, stats);
-    }
-}
-export class ReadonlySyncFileSystem extends SyncFileSystem {
-    renameSync(oldPath, newPath, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    createFileSync(path, flag, mode, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    unlinkSync(path, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    rmdirSync(path, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    mkdirSync(path, mode, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    linkSync(srcpath, dstpath, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    syncSync(path, data, stats) {
-        throw new ApiError(ErrorCode.EROFS);
+export function Sync(FS) {
+    /**
+     * Implements the asynchronous API in terms of the synchronous API.
+     */
+    class SyncFileSystem extends FS {
+        get metadata() {
+            return { ...super.metadata, synchronous: true };
+        }
+        async ready() {
+            return this;
+        }
+        async exists(path, cred) {
+            return this.existsSync(path, cred);
+        }
+        async rename(oldPath, newPath, cred) {
+            return this.renameSync(oldPath, newPath, cred);
+        }
+        async stat(path, cred) {
+            return this.statSync(path, cred);
+        }
+        async createFile(path, flag, mode, cred) {
+            return this.createFileSync(path, flag, mode, cred);
+        }
+        async openFile(path, flag, cred) {
+            return this.openFileSync(path, flag, cred);
+        }
+        async unlink(path, cred) {
+            return this.unlinkSync(path, cred);
+        }
+        async rmdir(path, cred) {
+            return this.rmdirSync(path, cred);
+        }
+        async mkdir(path, mode, cred) {
+            return this.mkdirSync(path, mode, cred);
+        }
+        async readdir(path, cred) {
+            return this.readdirSync(path, cred);
+        }
+        async link(srcpath, dstpath, cred) {
+            return this.linkSync(srcpath, dstpath, cred);
+        }
+        async sync(path, data, stats) {
+            return this.syncSync(path, data, stats);
+        }
     }
+    return SyncFileSystem;
 }
-export class AsyncFileSystem extends FileSystem {
-    renameSync(oldPath, newPath, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    statSync(path, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    createFileSync(path, flag, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    openSync(path, flags, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    openFileSync(path, flag, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    unlinkSync(path, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    rmdirSync(path, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    mkdirSync(path, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    readdirSync(path, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    linkSync(srcpath, dstpath, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    syncSync(path, data, stats) {
-        throw new ApiError(ErrorCode.ENOTSUP);
+export function Async(FS) {
+    class AsyncFileSystem extends FS {
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        renameSync(oldPath, newPath, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        statSync(path, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        createFileSync(path, flag, mode, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        openFileSync(path, flag, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        unlinkSync(path, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        rmdirSync(path, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        mkdirSync(path, mode, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        readdirSync(path, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        linkSync(srcpath, dstpath, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        syncSync(path, data, stats) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
     }
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+    return AsyncFileSystem;
 }
-export class ReadonlyAsyncFileSystem extends AsyncFileSystem {
-    async rename(oldPath, newPath, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async createFile(path, flag, mode, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async unlink(path, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async rmdir(path, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async mkdir(path, mode, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async link(srcpath, dstpath, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async sync(path, data, stats) {
-        throw new ApiError(ErrorCode.EROFS);
+export function Readonly(FS) {
+    class ReadonlyFileSystem extends FS {
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        async rename(oldPath, newPath, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        renameSync(oldPath, newPath, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async createFile(path, flag, mode, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        createFileSync(path, flag, mode, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async unlink(path, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        unlinkSync(path, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async rmdir(path, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        rmdirSync(path, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async mkdir(path, mode, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        mkdirSync(path, mode, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async link(srcpath, dstpath, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        linkSync(srcpath, dstpath, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async sync(path, data, stats) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        syncSync(path, data, stats) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
     }
+    return ReadonlyFileSystem;
 }

package/dist/utils.d.ts

@@ -1,14 +1,9 @@
 /// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import { FileSystem } from './filesystem.js';
 import { Cred } from './cred.js';
-import type { TextDecoder as _TextDecoder, TextEncoder as _TextEncoder } from 'node:util';
 declare global {
-    function setImmediate(callback: () => unknown): void;
     function atob(data: string): string;
     function btoa(data: string): string;
-    const TextDecoder: typeof _TextDecoder;
-    const TextEncoder: typeof _TextEncoder;
 }
 /**
  * Synchronous recursive makedir.
@@ -30,7 +25,7 @@ export declare function toPromise(fn: (...fnArgs: unknown[]) => unknown): (...ar
 /**
  * @internal
  */
-export declare const setImmediate: typeof globalThis.setImmediate | ((cb: any) => NodeJS.Timeout);
+export declare const setImmediate: (callback: () => unknown) => void;
 /**
  * Encodes a string into a buffer
  * @internal

package/dist/utils.js

@@ -123,7 +123,7 @@ export const setImmediate = typeof globalThis.setImmediate == 'function' ? globa
 export function encode(input, encoding = 'utf8') {
     switch (encoding) {
         case 'ascii':
-            return new TextEncoder().encode(input).map(v => v & 0x7f);
+            return new globalThis.TextEncoder().encode(input).map(v => v & 0x7f);
         case 'latin1':
         case 'binary':
         case 'utf8':
@@ -131,11 +131,11 @@ export function encode(input, encoding = 'utf8') {
         case 'base64':
         case 'base64url':
         case 'hex':
-            return new TextEncoder().encode(input);
+            return new globalThis.TextEncoder().encode(input);
         case 'utf16le':
         case 'ucs2':
         case 'ucs-2':
-            return new TextEncoder().encode(input).slice(0, -1);
+            return new globalThis.TextEncoder().encode(input).slice(0, -1);
         default:
             throw new ApiError(ErrorCode.EINVAL, 'Invalid encoding: ' + encoding);
     }
@@ -149,10 +149,10 @@ export function decode(input, encoding = 'utf8') {
         case 'ascii':
         case 'utf8':
         case 'utf-8':
-            return new TextDecoder().decode(input);
+            return new globalThis.TextDecoder().decode(input);
         case 'latin1':
         case 'binary':
-            return new TextDecoder('latin1').decode(input);
+            return new globalThis.TextDecoder('latin1').decode(input);
         case 'utf16le':
         case 'ucs2':
         case 'ucs-2':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenfs/core",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "A filesystem in your browser",
   "main": "dist/index.js",
   "types": "dist",