@zenfs/core 0.16.4 → 0.17.0

package/dist/backends/backend.d.ts

@@ -54,12 +54,11 @@ export interface Backend<FS extends FileSystem = FileSystem, TOptions extends ob
     /**
      * Whether the backend is available in the current environment.
      * It supports checking synchronously and asynchronously
-     * Sync:
+     *
      * Returns 'true' if this backend is available in the current
-     * environment. For example, a `localStorage`-backed filesystem will return
-     * 'false' if the browser does not support that API.
+     * environment. For example, a backend using a browser API will return
+     * 'false' if the API is unavailable
      *
-     * Defaults to 'false', as the FileSystem base class isn't usable alone.
      */
     isAvailable(): boolean | Promise<boolean>;
 }

package/dist/backends/fetch.d.ts

@@ -1,7 +1,7 @@
 import type { FileSystemMetadata } from '../filesystem.js';
 import type { Stats } from '../stats.js';
-import { IndexFS } from './index/fs.js';
-import type { IndexData } from './index/index.js';
+import { IndexFS } from './file_index.js';
+import type { IndexData } from './file_index.js';
 /**
  * Configuration options for FetchFS.
  */
@@ -52,7 +52,7 @@ export declare class FetchFS extends IndexFS {
     protected getData(path: string, stats: Stats): Promise<Uint8Array>;
     protected getDataSync(path: string, stats: Stats): Uint8Array;
 }
-export declare const Fetch: {
+declare const _Fetch: {
     readonly name: "Fetch";
     readonly options: {
         readonly index: {
@@ -69,3 +69,8 @@ export declare const Fetch: {
     readonly isAvailable: () => boolean;
     readonly create: (options: FetchOptions) => FetchFS;
 };
+type _fetch = typeof _Fetch;
+interface Fetch extends _fetch {
+}
+export declare const Fetch: Fetch;
+export {};

package/dist/backends/fetch.js

@@ -1,5 +1,5 @@
 import { Errno, ErrnoError } from '../error.js';
-import { IndexFS } from './index/fs.js';
+import { IndexFS } from './file_index.js';
 async function fetchFile(path, type) {
     const response = await fetch(path).catch((e) => {
         throw new ErrnoError(Errno.EIO, e.message);
@@ -106,7 +106,7 @@ export class FetchFS extends IndexFS {
         throw new ErrnoError(Errno.ENODATA, '', path, 'getData');
     }
 }
-export const Fetch = {
+const _Fetch = {
     name: 'Fetch',
     options: {
         index: {
@@ -127,3 +127,4 @@ export const Fetch = {
         return new FetchFS(options);
     },
 };
+export const Fetch = _Fetch;

package/dist/backends/{index/fs.d.ts → file_index.d.ts}

@@ -1,15 +1,54 @@
-import type { Cred } from '../../cred.js';
-import { NoSyncFile } from '../../file.js';
-import { FileSystem } from '../../filesystem.js';
-import type { Stats } from '../../stats.js';
-import type { IndexData } from './index.js';
-import { Index } from './index.js';
-declare const IndexFS_base: import("../../filesystem.js").Mixin<typeof FileSystem, {
-    metadata(): import("../../filesystem.js").FileSystemMetadata;
+import type { Cred } from '../cred.js';
+import { NoSyncFile } from '../file.js';
+import { FileSystem } from '../filesystem.js';
+import type { StatsLike } from '../stats.js';
+import { Stats } from '../stats.js';
+/**
+ * An Index in JSON form
+ * @internal
+ */
+export interface IndexData {
+    version: 1;
+    entries: Record<string, StatsLike<number>>;
+}
+export declare const version = 1;
+/**
+ * An index of files
+ * @internal
+ */
+export declare class Index extends Map<string, Stats> {
+    /**
+     * Convience method
+     */
+    files(): Map<string, Stats>;
+    /**
+     * Converts the index to JSON
+     */
+    toJSON(): IndexData;
+    /**
+     * Converts the index to a string
+     */
+    toString(): string;
+    /**
+     * Returns the files in the directory `dir`.
+     * This is expensive so it is only called once per directory.
+     */
+    protected dirEntries(dir: string): string[];
+    /**
+     * Loads the index from JSON data
+     */
+    fromJSON(json: IndexData): void;
+    /**
+     * Parses an index from a string
+     */
+    static parse(data: string): Index;
+}
+declare const IndexFS_base: import("../mixins/shared.js").Mixin<typeof FileSystem, {
+    metadata(): import("../filesystem.js").FileSystemMetadata;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<import("../../file.js").File>;
-    createFileSync(path: string, flag: string, mode: number, cred: Cred): import("../../file.js").File;
+    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<import("../file.js").File>;
+    createFileSync(path: string, flag: string, mode: number, cred: Cred): import("../file.js").File;
     unlink(path: string, cred: Cred): Promise<void>;
     unlinkSync(path: string, cred: Cred): void;
     rmdir(path: string, cred: Cred): Promise<void>;

package/dist/backends/{index/fs.js → file_index.js}

@@ -1,8 +1,87 @@
-import { ErrnoError, Errno } from '../../error.js';
-import { NoSyncFile, isWriteable, flagToMode } from '../../file.js';
-import { Readonly, FileSystem } from '../../filesystem.js';
-import { decode } from '../../utils.js';
-import { Index } from './index.js';
+/* Note: this file is named file_index.ts because Typescript has special behavior regarding index.ts which can't be disabled. */
+import { isJSON } from 'utilium';
+import { basename, dirname } from '../emulation/path.js';
+import { Errno, ErrnoError } from '../error.js';
+import { NoSyncFile, flagToMode, isWriteable } from '../file.js';
+import { FileSystem } from '../filesystem.js';
+import { Readonly } from '../mixins/readonly.js';
+import { Stats } from '../stats.js';
+import { decode, encode } from '../utils.js';
+export const version = 1;
+/**
+ * An index of files
+ * @internal
+ */
+export class Index extends Map {
+    /**
+     * Convience method
+     */
+    files() {
+        const files = new Map();
+        for (const [path, stats] of this) {
+            if (stats.isFile()) {
+                files.set(path, stats);
+            }
+        }
+        return files;
+    }
+    /**
+     * Converts the index to JSON
+     */
+    toJSON() {
+        return {
+            version,
+            entries: Object.fromEntries(this),
+        };
+    }
+    /**
+     * Converts the index to a string
+     */
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+    /**
+     * Returns the files in the directory `dir`.
+     * This is expensive so it is only called once per directory.
+     */
+    dirEntries(dir) {
+        const entries = [];
+        for (const entry of this.keys()) {
+            if (dirname(entry) == dir) {
+                entries.push(basename(entry));
+            }
+        }
+        return entries;
+    }
+    /**
+     * Loads the index from JSON data
+     */
+    fromJSON(json) {
+        if (json.version != version) {
+            throw new ErrnoError(Errno.EINVAL, 'Index version mismatch');
+        }
+        this.clear();
+        for (const [path, data] of Object.entries(json.entries)) {
+            const stats = new Stats(data);
+            if (stats.isDirectory()) {
+                stats.fileData = encode(JSON.stringify(this.dirEntries(path)));
+            }
+            this.set(path, stats);
+        }
+    }
+    /**
+     * Parses an index from a string
+     */
+    static parse(data) {
+        if (!isJSON(data)) {
+            throw new ErrnoError(Errno.EINVAL, 'Invalid JSON');
+        }
+        const json = JSON.parse(data);
+        const index = new Index();
+        index.fromJSON(json);
+        return index;
+    }
+}
 export class IndexFS extends Readonly(FileSystem) {
     async ready() {
         await super.ready();

package/dist/backends/memory.d.ts

@@ -15,7 +15,7 @@ export declare class InMemoryStore extends Map<Ino, Uint8Array> implements Simpl
  * A simple in-memory file system backed by an InMemoryStore.
  * Files are not persisted across page loads.
  */
-export declare const InMemory: {
+export declare const _InMemory: {
     readonly name: "InMemory";
     readonly isAvailable: () => boolean;
     readonly options: {
@@ -29,3 +29,8 @@ export declare const InMemory: {
         name?: string;
     }) => StoreFS<InMemoryStore>;
 };
+type _inmemory = typeof _InMemory;
+interface InMemory extends _inmemory {
+}
+export declare const InMemory: InMemory;
+export {};

package/dist/backends/memory.js

@@ -20,7 +20,7 @@ export class InMemoryStore extends Map {
  * A simple in-memory file system backed by an InMemoryStore.
  * Files are not persisted across page loads.
  */
-export const InMemory = {
+export const _InMemory = {
     name: 'InMemory',
     isAvailable() {
         return true;
@@ -38,3 +38,4 @@ export const InMemory = {
         return fs;
     },
 };
+export const InMemory = _InMemory;

package/dist/backends/overlay.d.ts

@@ -2,7 +2,6 @@ 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 type { Cred } from '../cred.js';
 /**
  * Configuration options for OverlayFS instances.
@@ -21,14 +20,14 @@ export interface OverlayOptions {
  * OverlayFS makes a read-only filesystem writable by storing writes on a second, writable file system.
  * Deletes are persisted via metadata stored on the writable file system.
  *
- * This class contains no locking whatsoever. It is wrapped in a LockedFS to prevent races.
+ * This class contains no locking whatsoever. It is mutexed to prevent races.
  *
  * @internal
  */
-export declare class UnlockedOverlayFS extends FileSystem {
+export declare class UnmutexedOverlayFS extends FileSystem {
     ready(): Promise<void>;
-    private _writable;
-    private _readable;
+    readonly writable: FileSystem;
+    readonly readable: FileSystem;
     private _isInitialized;
     private _deletedFiles;
     private _deleteLog;
@@ -38,7 +37,6 @@ export declare class UnlockedOverlayFS extends FileSystem {
     private _ready;
     constructor({ writable, readable }: OverlayOptions);
     metadata(): FileSystemMetadata;
-    getOverlayedFileSystems(): OverlayOptions;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
     /**
@@ -91,23 +89,20 @@ export declare class UnlockedOverlayFS extends FileSystem {
     private copyToWritableSync;
     private copyToWritable;
 }
+declare const OverlayFS_base: import("../mixins/shared.js").Mixin<typeof UnmutexedOverlayFS, {
+    lock(path: string): Promise<import("../mixins/mutexed.js").MutexLock>;
+    lockSync(path: string): import("../mixins/mutexed.js").MutexLock;
+    isLocked(path: string): boolean;
+}>;
 /**
  * OverlayFS makes a read-only filesystem writable by storing writes on a second,
  * writable file system. Deletes are persisted via metadata stored on the writable
  * file system.
  * @internal
  */
-export declare class OverlayFS extends LockedFS<UnlockedOverlayFS> {
-    /**
-     * @param options The options to initialize the OverlayFS with
-     */
-    constructor(options: OverlayOptions);
-    getOverlayedFileSystems(): OverlayOptions;
-    getDeletionLog(): string;
-    resDeletionLog(): string;
-    unwrap(): UnlockedOverlayFS;
+export declare class OverlayFS extends OverlayFS_base {
 }
-export declare const Overlay: {
+declare const _Overlay: {
     readonly name: "Overlay";
     readonly options: {
         readonly writable: {
@@ -124,3 +119,8 @@ export declare const Overlay: {
     readonly isAvailable: () => boolean;
     readonly create: (options: OverlayOptions) => OverlayFS;
 };
+type _overlay = typeof _Overlay;
+interface Overlay extends _overlay {
+}
+export declare const Overlay: Overlay;
+export {};