@zenfs/core 0.9.5 → 0.9.7

package/dist/ApiError.d.ts

@@ -175,11 +175,12 @@ interface ApiErrorJSON {
  */
 export declare class ApiError extends Error implements NodeJS.ErrnoException {
     errno: ErrorCode;
-    path?: string;
+    path?: string | undefined;
     syscall: string;
     static fromJSON(json: ApiErrorJSON): ApiError;
-    static With(code: keyof typeof ErrorCode, path: string, syscall?: string): ApiError;
+    static With(code: keyof typeof ErrorCode, path?: string, syscall?: string): ApiError;
     code: keyof typeof ErrorCode;
+    stack: string;
     /**
      * Represents a ZenFS error. Passed back to applications after a failed
      * call to the ZenFS API.
@@ -190,7 +191,7 @@ export declare class ApiError extends Error implements NodeJS.ErrnoException {
      * @param type The type of the error.
      * @param message A descriptive error message.
      */
-    constructor(errno: ErrorCode, message?: string, path?: string, syscall?: string);
+    constructor(errno: ErrorCode, message?: string, path?: string | undefined, syscall?: string);
     /**
      * @return A friendly error message.
      */

package/dist/ApiError.js

@@ -153,7 +153,7 @@ export var ErrorCode;
     ErrorCode[ErrorCode["EREMOTEIO"] = 121] = "EREMOTEIO";
     /** Disk quota exceeded */
     ErrorCode[ErrorCode["EDQUOT"] = 122] = "EDQUOT";
-})(ErrorCode = ErrorCode || (ErrorCode = {}));
+})(ErrorCode || (ErrorCode = {}));
 /**
  * Strings associated with each error code.
  * @internal

package/dist/backends/AsyncStore.d.ts

@@ -11,7 +11,7 @@ declare class LRUCache<K, V> {
     private cache;
     constructor(limit: number);
     set(key: K, value: V): void;
-    get(key: K): V | null;
+    get(key: K): V | void;
     remove(key: K): void;
     reset(): void;
 }
@@ -113,7 +113,8 @@ declare const AsyncStoreFS_base: (abstract new (...args: any[]) => {
  */
 export declare class AsyncStoreFS extends AsyncStoreFS_base {
     protected _options: AsyncStoreOptions;
-    protected store: AsyncStore;
+    protected _store?: AsyncStore;
+    protected get store(): AsyncStore;
     protected _cache?: LRUCache<string, Ino>;
     private _initialized;
     _sync: FileSystem;

package/dist/backends/AsyncStore.js

@@ -51,16 +51,22 @@ class LRUCache {
  * @internal
  */
 export class AsyncStoreFS extends Async(FileSystem) {
+    get store() {
+        if (!this._store) {
+            throw new ReferenceError('AsyncStoreFS not attached to a store');
+        }
+        return this._store;
+    }
     async ready() {
         if (this._initialized) {
             return this;
         }
         this._initialized = true;
-        if (this._options.lruCacheSize > 0) {
+        if (this._options.lruCacheSize) {
             this._cache = new LRUCache(this._options.lruCacheSize);
         }
-        this.store = await this._options.store;
-        this._sync = this._options.sync || InMemory.create({ name: 'test' });
+        this._store = await this._options.store;
+        this._sync = this._options.sync || this._sync;
         await this.makeRootDirectory();
         await super.ready();
         return this;
@@ -75,6 +81,7 @@ export class AsyncStoreFS extends Async(FileSystem) {
         super();
         this._options = _options;
         this._initialized = false;
+        this._sync = InMemory.create({ name: 'test' });
     }
     /**
      * Delete all contents stored in the file system.
@@ -95,8 +102,8 @@ export class AsyncStoreFS extends Async(FileSystem) {
         const c = this._cache;
         if (this._cache) {
             // Clear and disable cache during renaming process.
-            this._cache = null;
-            c.reset();
+            delete this._cache;
+            c?.reset();
         }
         try {
             const tx = this.store.beginTransaction(), oldParent = dirname(oldPath), oldName = basename(oldPath), newParent = dirname(newPath), newName = basename(newPath), 

package/dist/backends/InMemory.d.ts

@@ -9,7 +9,7 @@ export declare class InMemoryStore implements SyncStore, SimpleSyncStore {
     constructor(name?: string);
     clear(): void;
     beginTransaction(): SyncTransaction;
-    get(key: Ino): Uint8Array;
+    get(key: Ino): Uint8Array | undefined;
     put(key: Ino, data: Uint8Array, overwrite: boolean): boolean;
     remove(key: Ino): void;
 }

package/dist/backends/Index.d.ts

@@ -68,25 +68,25 @@ export declare class FileIndex<TData> {
      * @return The removed item,
      *   or null if it did not exist.
      */
-    remove(path: string): IndexInode<TData> | null;
+    remove(path: string): IndexInode<TData> | void;
     /**
      * Retrieves the directory listing of the given path.
      * @return An array of files in the given path, or 'null' if it does not exist.
      */
-    ls(path: string): string[] | null;
+    ls(path: string): string[] | void;
     /**
      * Returns the inode of the given item.
      * @return Returns null if the item does not exist.
      */
-    get(path: string): IndexInode<TData> | null;
+    get(path: string): IndexInode<TData> | void | null;
 }
 /**
  * Generic interface for file/directory inodes.
  * Note that Stats objects are what we use for file inodes.
  */
 export declare abstract class IndexInode<TData> {
-    data?: TData;
-    constructor(data?: TData);
+    data?: TData | undefined;
+    constructor(data?: TData | undefined);
     /**
      * Whether this inode is for a file
      */
@@ -135,7 +135,7 @@ export declare class IndexDirInode<TData> extends IndexInode<TData> {
      * Returns the inode for the indicated item, or null if it does not exist.
      * @param path Name of item in this directory.
      */
-    get(path: string): IndexInode<TData> | null;
+    get(path: string): IndexInode<TData> | void;
     /**
      * Add the given item to the directory listing. Note that the given inode is
      * not copied, and will be mutated by the DirInode if it is a DirInode.
@@ -151,7 +151,7 @@ export declare class IndexDirInode<TData> extends IndexInode<TData> {
      * @return Returns the item
      *   removed, or null if the item did not exist.
      */
-    remove(p: string): IndexInode<TData> | null;
+    remove(p: string): IndexInode<TData> | void;
 }
 declare const IndexFS_base: (abstract new (...args: any[]) => {
     metadata(): import("../filesystem.js").FileSystemMetadata;
@@ -173,9 +173,6 @@ declare const IndexFS_base: (abstract new (...args: any[]) => {
     stat(path: string, cred: Cred): Promise<Stats>;
     statSync(path: string, cred: Cred): Stats;
     openFile(path: string, flag: string, cred: Cred): Promise<import("../file.js").File>;
-    /**
-     * Constructs a new FileIndex.
-     */
     openFileSync(path: string, flag: string, cred: Cred): import("../file.js").File;
     readdir(path: string, cred: Cred): Promise<string[]>;
     readdirSync(path: string, cred: Cred): string[];

package/dist/backends/Index.js

@@ -66,7 +66,10 @@ export class FileIndex {
         for (const dir of this._index.values()) {
             for (const file of dir.listing) {
                 const item = dir.get(file);
-                if (!item?.isFile()) {
+                if (!item) {
+                    continue;
+                }
+                if (!item.isFile()) {
                     continue;
                 }
                 files.push(item);
@@ -98,11 +101,10 @@ export class FileIndex {
             return this._index.get(path) === inode;
         }
         const dirpath = dirname(path);
+        const hasParent = this._index.has(dirpath);
+        const parent = hasParent ? this._index.get(dirpath) : new IndexDirInode();
         // Try to add to its parent directory first.
-        let parent = this._index.get(dirpath);
-        if (!parent && path != '/') {
-            // Create parent.
-            parent = new IndexDirInode();
+        if (!hasParent && path != '/') {
             if (!this.add(dirpath, parent)) {
                 return false;
             }

package/dist/backends/Overlay.js

@@ -370,7 +370,7 @@ export class UnlockedOverlayFS extends FileSystem {
             return;
         }
         const error = this._deleteLogError;
-        this._deleteLogError = null;
+        delete this._deleteLogError;
         throw error;
     }
     checkPath(path) {

package/dist/backends/SyncStore.d.ts

@@ -30,7 +30,7 @@ export interface SyncTransaction {
      * @param ino The key to look under for data.
      * @return The data stored under the key, or undefined if not present.
      */
-    get(ino: Ino): Uint8Array | undefined;
+    get(ino: Ino): Uint8Array | void;
     /**
      * Adds the data to the store under the given key.
      * @param ino The key to add the data under.
@@ -72,13 +72,13 @@ export declare class SimpleSyncTransaction implements SyncTransaction {
      * Stores data in the keys we modify prior to modifying them.
      * Allows us to roll back commits.
      */
-    protected originalData: Map<Ino, Uint8Array>;
+    protected originalData: Map<Ino, Uint8Array | void>;
     /**
      * List of keys modified in this transaction, if any.
      */
     protected modifiedKeys: Set<Ino>;
     constructor(store: SimpleSyncStore);
-    get(ino: Ino): Uint8Array | undefined;
+    get(ino: Ino): Uint8Array | void;
     put(ino: Ino, data: Uint8Array, overwrite: boolean): boolean;
     remove(ino: Ino): void;
     commit(): void;
@@ -89,7 +89,7 @@ export declare class SimpleSyncTransaction implements SyncTransaction {
      * prevent needless `get` requests if the program modifies the data later
      * on during the transaction.
      */
-    protected stashOldValue(ino: Ino, value: Uint8Array | undefined): void;
+    protected stashOldValue(ino: Ino, value?: Uint8Array): void;
     /**
      * Marks the given key as modified, and stashes its value if it has not been
      * stashed already.
@@ -176,10 +176,10 @@ export declare class SyncStoreFS extends SyncStoreFS_base {
     /**
      * Given the ID of a node, retrieves the corresponding Inode.
      * @param tx The transaction to use.
-     * @param p The corresponding path to the file (used for error messages).
+     * @param path The corresponding path to the file (used for error messages).
      * @param id The ID to look up.
      */
-    protected getINode(tx: SyncTransaction, id: Ino, p?: string): Inode;
+    protected getINode(tx: SyncTransaction, id: Ino, path?: string): Inode;
     /**
      * Given the Inode of a directory, retrieves the corresponding directory listing.
      */

package/dist/backends/SyncStore.js

@@ -183,7 +183,7 @@ export class SyncStoreFS extends Sync(FileSystem) {
         if (!node.toStats().hasAccess(flagToMode(flag), cred)) {
             throw ApiError.With('EACCES', p, 'openFile');
         }
-        if (data === null) {
+        if (!data) {
             throw ApiError.With('ENOENT', p, 'openFile');
         }
         return new PreloadFile(this, p, flag, node.toStats(), data);
@@ -318,13 +318,13 @@ export class SyncStoreFS extends Sync(FileSystem) {
     /**
      * Given the ID of a node, retrieves the corresponding Inode.
      * @param tx The transaction to use.
-     * @param p The corresponding path to the file (used for error messages).
+     * @param path The corresponding path to the file (used for error messages).
      * @param id The ID to look up.
      */
-    getINode(tx, id, p) {
+    getINode(tx, id, path) {
         const data = tx.get(id);
         if (!data) {
-            throw ApiError.With('ENOENT', p, 'getINode');
+            throw ApiError.With('ENOENT', path, 'getINode');
         }
         const inode = new Inode(data.buffer);
         return inode;

package/dist/backends/backend.d.ts

@@ -54,6 +54,7 @@ export interface Backend<FS extends FileSystem = FileSystem, TOptions extends ob
      */
     isAvailable(): boolean | Promise<boolean>;
 }
+type OptionsOf<T extends Backend> = T extends Backend<FileSystem, infer TOptions> ? TOptions : never;
 /**
  * @internal
  */
@@ -62,8 +63,8 @@ export declare function isBackend(arg: unknown): arg is Backend;
  * Checks that the given options object is valid for the file system options.
  * @internal
  */
-export declare function checkOptions<T extends Backend>(backend: T, opts: object): Promise<void>;
-export declare function createBackend<B extends Backend>(backend: B, options?: object): Promise<ReturnType<B['create']>>;
+export declare function checkOptions<T extends Backend>(backend: T, opts: Partial<OptionsOf<T>> & Record<string, unknown>): Promise<void>;
+export declare function createBackend<B extends Backend>(backend: B, options?: Partial<OptionsOf<B>>): Promise<ReturnType<B['create']>>;
 /**
  * Specifies a file system backend type and its options.
  *
@@ -72,8 +73,8 @@ export declare function createBackend<B extends Backend>(backend: B, options?: o
  *
  * The option object for each file system corresponds to that file system's option object passed to its `Create()` method.
  */
-export type BackendConfiguration<FS extends FileSystem = FileSystem, TOptions extends object = object> = TOptions & {
-    backend: Backend<FS, TOptions>;
+export type BackendConfiguration<T extends Backend = Backend> = OptionsOf<T> & {
+    backend: T;
 };
 /**
  * @internal

package/dist/backends/backend.js

@@ -44,8 +44,8 @@ export async function checkOptions(backend, opts) {
         // Otherwise: All good!
     }
 }
-export function createBackend(backend, options) {
-    checkOptions(backend, options);
+export async function createBackend(backend, options = {}) {
+    await checkOptions(backend, options);
     const fs = backend.create(options);
     return fs.ready();
 }