@zenfs/core 0.1.0 → 0.2.0

package/dist/FileIndex.js

@@ -10,65 +10,63 @@ import * as path from './emulation/path.js';
 export class FileIndex {
     /**
      * Static method for constructing indices from a JSON listing.
-     * @param listing Directory listing generated by tools/XHRIndexer.coffee
+     * @param listing Directory listing generated by tools
      * @return A new FileIndex object.
      */
     static fromListing(listing) {
-        const idx = new FileIndex();
+        const index = new FileIndex();
         // Add a root DirNode.
         const rootInode = new IndexDirInode();
-        idx._index['/'] = rootInode;
-        const queue = [['', listing, rootInode]];
+        index._index.set('/', rootInode);
+        const queue = [{ pwd: '', tree: listing, parent: rootInode }];
         while (queue.length > 0) {
             let inode;
-            const next = queue.pop();
-            const pwd = next[0];
-            const tree = next[1];
-            const parent = next[2];
+            const { tree, pwd, parent } = queue.pop();
             for (const node in tree) {
-                if (Object.prototype.hasOwnProperty.call(tree, node)) {
-                    const children = tree[node];
-                    const name = `${pwd}/${node}`;
-                    if (children) {
-                        idx._index[name] = inode = new IndexDirInode();
-                        queue.push([name, children, inode]);
-                    }
-                    else {
-                        // This inode doesn't have correct size information, noted with -1.
-                        inode = new IndexFileInode(new Stats(FileType.FILE, -1, 0x16d));
-                    }
-                    if (parent) {
-                        parent._ls[node] = inode;
-                    }
+                if (!Object.hasOwn(tree, node)) {
+                    continue;
                 }
+                const children = tree[node];
+                if (children) {
+                    const path = `${pwd}/${node}`;
+                    inode = new IndexDirInode();
+                    index._index.set(path, inode);
+                    queue.push({ pwd: path, tree: children, parent: inode });
+                }
+                else {
+                    // This inode doesn't have correct size information, noted with -1.
+                    inode = new IndexFileInode(new Stats(FileType.FILE, -1, 0o555));
+                }
+                if (!parent) {
+                    continue;
+                }
+                parent._listing.set(node, inode);
             }
         }
-        return idx;
+        return index;
     }
     /**
      * Constructs a new FileIndex.
      */
     constructor() {
+        // Maps directory paths to directory inodes, which contain files.
+        this._index = new Map();
         // _index is a single-level key,value store that maps *directory* paths to
         // DirInodes. File information is only contained in DirInodes themselves.
-        this._index = {};
         // Create the root directory.
         this.addPath('/', new IndexDirInode());
     }
     /**
      * Runs the given function over all files in the index.
      */
-    fileIterator(cb) {
-        for (const path in this._index) {
-            if (Object.prototype.hasOwnProperty.call(this._index, path)) {
-                const dir = this._index[path];
-                const files = dir.getListing();
-                for (const file of files) {
-                    const item = dir.getItem(file);
-                    if (isIndexFileInode(item)) {
-                        cb(item.getData());
-                    }
+    forEachFile(cb) {
+        for (const dir of this._index.values()) {
+            for (const file of dir.listing) {
+                const item = dir.get(file);
+                if (!item?.isFile()) {
+                    continue;
                 }
+                cb(item.data);
             }
         }
     }
@@ -92,15 +90,15 @@ export class FileIndex {
             throw new Error('Path must be absolute, got: ' + path);
         }
         // Check if it already exists.
-        if (Object.prototype.hasOwnProperty.call(this._index, path)) {
-            return this._index[path] === inode;
+        if (this._index.has(path)) {
+            return this._index.get(path) === inode;
         }
-        const splitPath = this._split_path(path);
+        const splitPath = this.splitPath(path);
         const dirpath = splitPath[0];
         const itemname = splitPath[1];
         // Try to add to its parent directory first.
-        let parent = this._index[dirpath];
-        if (parent === undefined && path !== '/') {
+        let parent = this._index.get(dirpath);
+        if (!parent && path !== '/') {
             // Create parent.
             parent = new IndexDirInode();
             if (!this.addPath(dirpath, parent)) {
@@ -109,7 +107,7 @@ export class FileIndex {
         }
         // Add myself to my parent.
         if (path !== '/') {
-            if (!parent.addItem(itemname, inode)) {
+            if (!parent.add(itemname, inode)) {
                 return false;
             }
         }
@@ -137,13 +135,13 @@ export class FileIndex {
         const parentPath = itemNameMark === 0 ? '/' : path.substring(0, itemNameMark);
         const itemName = path.substring(itemNameMark + 1);
         // Try to add to its parent directory first.
-        let parent = this._index[parentPath];
-        if (parent === undefined) {
+        let parent = this._index.get(parentPath);
+        if (!parent) {
             // Create parent.
             parent = new IndexDirInode();
             this.addPathFast(parentPath, parent);
         }
-        if (!parent.addItem(itemName, inode)) {
+        if (!parent.add(itemName, inode)) {
             return false;
         }
         // If adding a directory, add to the index as well.
@@ -158,90 +156,81 @@ export class FileIndex {
      *   or null if it did not exist.
      */
     removePath(path) {
-        const splitPath = this._split_path(path);
+        const splitPath = this.splitPath(path);
         const dirpath = splitPath[0];
         const itemname = splitPath[1];
         // Try to remove it from its parent directory first.
         const parent = this._index[dirpath];
-        if (parent === undefined) {
-            return null;
+        if (!parent) {
+            return;
         }
         // Remove myself from my parent.
-        const inode = parent.remItem(itemname);
-        if (inode === null) {
-            return null;
+        const inode = parent.remove(itemname);
+        if (!inode) {
+            return;
         }
         // If I'm a directory, remove myself from the index, and remove my children.
-        if (isIndexDirInode(inode)) {
-            const children = inode.getListing();
-            for (const child of children) {
-                this.removePath(path + '/' + child);
-            }
-            // Remove the directory from the index, unless it's the root.
-            if (path !== '/') {
-                delete this._index[path];
-            }
+        if (!isIndexDirInode(inode)) {
+            return inode;
+        }
+        const children = inode.listing;
+        for (const child of children) {
+            this.removePath(path + '/' + child);
+        }
+        // Remove the directory from the index, unless it's the root.
+        if (path !== '/') {
+            this._index.delete(path);
         }
-        return inode;
     }
     /**
      * 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) {
-        const item = this._index[path];
-        if (item === undefined) {
-            return null;
-        }
-        return item.getListing();
+        return this._index.get(path)?.listing;
     }
     /**
      * Returns the inode of the given item.
      * @return Returns null if the item does not exist.
      */
     getInode(path) {
-        const splitPath = this._split_path(path);
-        const dirpath = splitPath[0];
-        const itemname = splitPath[1];
+        const [dirpath, itemname] = this.splitPath(path);
         // Retrieve from its parent directory.
-        const parent = this._index[dirpath];
-        if (parent === undefined) {
-            return null;
-        }
+        const parent = this._index.get(dirpath);
         // Root case
         if (dirpath === path) {
             return parent;
         }
-        return parent.getItem(itemname);
+        return parent?.get(itemname);
     }
     /**
      * Split into a (directory path, item name) pair
      */
-    _split_path(p) {
+    splitPath(p) {
         const dirpath = path.dirname(p);
         const itemname = p.slice(dirpath.length + (dirpath === '/' ? 0 : 1));
         return [dirpath, itemname];
     }
 }
 /**
- * Inode for a file. Stores an arbitrary (filesystem-specific) data payload.
+ * Generic interface for file/directory inodes.
+ * Note that Stats objects are what we use for file inodes.
  */
-export class IndexFileInode {
+export class IndexInode {
     constructor(data) {
         this.data = data;
     }
+}
+/**
+ * Inode for a file. Stores an arbitrary (filesystem-specific) data payload.
+ */
+export class IndexFileInode extends IndexInode {
     isFile() {
         return true;
     }
     isDir() {
         return false;
     }
-    getData() {
-        return this.data;
-    }
-    setData(data) {
-        this.data = data;
-    }
     toStats() {
         return new Stats(FileType.FILE, 4096, 0o666);
     }
@@ -249,13 +238,13 @@ export class IndexFileInode {
 /**
  * Inode for a directory. Currently only contains the directory listing.
  */
-export class IndexDirInode {
-    /**
-     * Constructs an inode for a directory.
-     */
-    constructor(data = null) {
-        this.data = data;
-        this._ls = {};
+export class IndexDirInode extends IndexInode {
+    constructor() {
+        super(...arguments);
+        /**
+         * @internal
+         */
+        this._listing = new Map();
     }
     isFile() {
         return false;
@@ -263,39 +252,34 @@ export class IndexDirInode {
     isDir() {
         return true;
     }
-    getData() {
-        return this.data;
-    }
     /**
      * Return a Stats object for this inode.
-     * @todo Should probably remove this at some point. This isn't the
-     *       responsibility of the FileIndex.
+     * @todo Should probably remove this at some point. This isn't the responsibility of the FileIndex.
      */
-    getStats() {
+    get stats() {
         return new Stats(FileType.DIRECTORY, 4096, 0o555);
     }
     /**
      * Alias of getStats()
-     * @todo Remove this at some point. This isn't the
-     *       responsibility of the FileIndex.
+     * @todo Remove this at some point. This isn't the responsibility of the FileIndex.
      */
     toStats() {
-        return this.getStats();
+        return this.stats;
     }
     /**
      * Returns the directory listing for this directory. Paths in the directory are
      * relative to the directory's path.
      * @return The directory listing for this directory.
      */
-    getListing() {
-        return Object.keys(this._ls);
+    get listing() {
+        return Object.keys(this._listing);
     }
     /**
      * Returns the inode for the indicated item, or null if it does not exist.
      * @param p Name of item in this directory.
      */
-    getItem(p) {
-        const item = this._ls[p];
+    get(p) {
+        const item = this._listing[p];
         return item ? item : null;
     }
     /**
@@ -306,11 +290,11 @@ export class IndexDirInode {
      *   item to add to the directory inode.
      * @return True if it was added, false if it already existed.
      */
-    addItem(p, inode) {
-        if (p in this._ls) {
+    add(p, inode) {
+        if (p in this._listing) {
             return false;
         }
-        this._ls[p] = inode;
+        this._listing[p] = inode;
         return true;
     }
     /**
@@ -319,12 +303,12 @@ export class IndexDirInode {
      * @return Returns the item
      *   removed, or null if the item did not exist.
      */
-    remItem(p) {
-        const item = this._ls[p];
+    remove(p) {
+        const item = this._listing[p];
         if (item === undefined) {
             return null;
         }
-        delete this._ls[p];
+        delete this._listing[p];
         return item;
     }
 }
@@ -332,11 +316,11 @@ export class IndexDirInode {
  * @hidden
  */
 export function isIndexFileInode(inode) {
-    return !!inode && inode.isFile();
+    return inode?.isFile();
 }
 /**
  * @hidden
  */
 export function isIndexDirInode(inode) {
-    return !!inode && inode.isDir();
+    return inode?.isDir();
 }

package/dist/backends/AsyncMirror.d.ts

@@ -1,8 +1,18 @@
-import { type FileSystem, SynchronousFileSystem, FileSystemMetadata } from '../filesystem.js';
+import { type FileSystem, SyncFileSystem, FileSystemMetadata } from '../filesystem.js';
 import { File, FileFlag, PreloadFile } from '../file.js';
 import { Stats } from '../stats.js';
 import { Cred } from '../cred.js';
-import { type BackendOptions } from './backend.js';
+import type { Backend } from './backend.js';
+/**
+ * We define our own file to interpose on syncSync() for mirroring purposes.
+ */
+declare class MirrorFile extends PreloadFile<AsyncMirrorFS> {
+    constructor(fs: AsyncMirrorFS, path: string, flag: FileFlag, stat: Stats, data: Uint8Array);
+    sync(): Promise<void>;
+    syncSync(): void;
+    close(): Promise<void>;
+    closeSync(): void;
+}
 export declare namespace AsyncMirror {
     /**
      * Configuration options for the AsyncMirror file system.
@@ -30,40 +40,8 @@ export declare namespace AsyncMirror {
  * The two stores will be kept in sync. The most common use-case is to pair a synchronous
  * in-memory filesystem with an asynchronous backing store.
  *
- * Example: Mirroring an IndexedDB file system to an in memory file system. Now, you can use
- * IndexedDB synchronously.
- *
- * ```javascript
- * ZenFS.configure({
- *   fs: "AsyncMirror",
- *   options: {
- *     sync: { fs: "InMemory" },
- *     async: { fs: "IndexedDB" }
- *   }
- * }, function(e) {
- *   // ZenFS is initialized and ready-to-use!
- * });
- * ```
- *
- * Or, alternatively:
- *
- * ```javascript
- * ZenFS.Backend.IndexedDB.Create(function(e, idbfs) {
- *   ZenFS.Backend.InMemory.Create(function(e, inMemory) {
- *     ZenFS.Backend.AsyncMirror({
- *       sync: inMemory, async: idbfs
- *     }, function(e, mirrored) {
- *       ZenFS.initialize(mirrored);
- *     });
- *   });
- * });
- * ```
  */
-export declare class AsyncMirror extends SynchronousFileSystem {
-    static readonly Name = "AsyncMirror";
-    static Create: any;
-    static readonly Options: BackendOptions;
-    static isAvailable(): boolean;
+export declare class AsyncMirrorFS extends SyncFileSystem {
     /**
      * Queue of pending asynchronous operations.
      */
@@ -72,7 +50,8 @@ export declare class AsyncMirror extends SynchronousFileSystem {
     private _sync;
     private _async;
     private _isInitialized;
-    private _initializeCallbacks;
+    private _ready;
+    ready(): Promise<this>;
     /**
      *
      * Mirrors the synchronous file system into the asynchronous file system.
@@ -82,21 +61,41 @@ export declare class AsyncMirror extends SynchronousFileSystem {
      */
     constructor({ sync, async }: AsyncMirror.Options);
     get metadata(): FileSystemMetadata;
-    _syncSync(fd: PreloadFile<AsyncMirror>): void;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    openFileSync(path: string, flag: FileFlag, cred: Cred): File;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): MirrorFile;
+    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(p: string, cred: Cred): Stats;
-    openSync(p: string, flag: FileFlag, mode: number, cred: Cred): File;
     unlinkSync(p: string, cred: Cred): void;
     rmdirSync(p: string, cred: Cred): void;
     mkdirSync(p: string, mode: number, cred: Cred): void;
     readdirSync(p: string, cred: Cred): string[];
     existsSync(p: string, cred: Cred): boolean;
-    chmodSync(p: string, mode: number, cred: Cred): void;
-    chownSync(p: string, new_uid: number, new_gid: number, cred: Cred): void;
-    utimesSync(p: string, atime: Date, mtime: Date, cred: Cred): void;
+    /**
+     * @internal
+     */
+    protected crossCopyDirectory(p: string, mode: number): Promise<void>;
+    /**
+     * @internal
+     */
+    protected crossCopyFile(p: string, mode: number): Promise<void>;
+    /**
+     * @internal
+     */
+    protected crossCopy(p: string): Promise<void>;
     /**
      * Called once to load up files from async storage into sync storage.
      */
-    private _initialize;
-    private enqueueOp;
+    protected _initialize(): Promise<void>;
+    /**
+     * @internal
+     */
+    private _next;
+    /**
+     * @internal
+     */
+    private enqueue;
 }
+export declare const AsyncMirror: Backend;
+export {};