@zenfs/core 1.9.5 → 1.10.1

package/dist/backends/fetch.d.ts

@@ -16,10 +16,10 @@ export interface FetchOptions extends SharedConfig {
      * Defaults to `index.json`.
      */
     index?: string | IndexData;
-    /** Used as the URL prefix for fetched files.
-     * Default: Fetch files relative to the index.
+    /**
+     * Used as the URL prefix for fetched files.
      */
-    baseUrl?: string;
+    baseUrl: string;
     /**
      * If true, enables writing to the remote (using post and delete)
      * @default false
@@ -56,7 +56,7 @@ declare const _Fetch: {
         };
         readonly baseUrl: {
             readonly type: "string";
-            readonly required: false;
+            readonly required: true;
         };
         readonly requestInit: {
             readonly type: "object";

package/dist/backends/fetch.js

@@ -88,7 +88,7 @@ const _Fetch = {
     name: 'Fetch',
     options: {
         index: { type: ['string', 'object'], required: false },
-        baseUrl: { type: 'string', required: false },
+        baseUrl: { type: 'string', required: true },
         requestInit: { type: 'object', required: false },
         remoteWrite: { type: 'boolean', required: false },
     },
@@ -97,7 +97,7 @@ const _Fetch = {
     },
     async create(options) {
         var _a;
-        const url = new URL(options.baseUrl || '');
+        const url = new URL(options.baseUrl);
         url.pathname = normalizePath(url.pathname);
         let baseUrl = url.toString();
         if (baseUrl.at(-1) == '/')

package/dist/backends/index.d.ts

@@ -4,6 +4,7 @@ export * from './memory.js';
 export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
+export * from './single_buffer.js';
 export * from './store/fs.js';
 export * from './store/map.js';
 export * from './store/store.js';

package/dist/backends/index.js

@@ -4,6 +4,7 @@ export * from './memory.js';
 export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
+export * from './single_buffer.js';
 export * from './store/fs.js';
 export * from './store/map.js';
 export * from './store/store.js';

package/dist/backends/memory.d.ts

@@ -1,3 +1,4 @@
+import type { UsageInfo } from '../internal/filesystem.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
 /**
@@ -5,24 +6,45 @@ import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
  * @category Stores and Transactions
  */
 export declare class InMemoryStore extends Map<number, Uint8Array> implements SyncMapStore {
+    readonly maxSize: number;
     readonly label?: string | undefined;
     readonly flags: readonly [];
     readonly name = "tmpfs";
-    constructor(label?: string | undefined);
+    constructor(maxSize?: number, label?: string | undefined);
     sync(): Promise<void>;
     transaction(): SyncMapTransaction;
+    get bytes(): number;
+    usage(): UsageInfo;
+}
+/**
+ * Options for an in-memory backend
+ * @category Backends and Configuration
+ */
+export interface InMemoryOptions {
+    /** The maximum size of the store. Defaults to 4 GiB */
+    maxSize?: number;
+    /** The label to use for the store and file system */
+    label?: string;
+    /** @deprecated use `label` */
+    name?: string;
 }
 declare const _InMemory: {
     readonly name: "InMemory";
     readonly options: {
+        readonly maxSize: {
+            readonly type: "number";
+            readonly required: false;
+        };
+        readonly label: {
+            readonly type: "string";
+            readonly required: false;
+        };
         readonly name: {
             readonly type: "string";
             readonly required: false;
         };
     };
-    readonly create: ({ name }: {
-        name?: string;
-    }) => StoreFS<InMemoryStore>;
+    readonly create: ({ maxSize, label, name }: InMemoryOptions) => StoreFS<InMemoryStore>;
 };
 type _InMemory = typeof _InMemory;
 export interface InMemory extends _InMemory {

package/dist/backends/memory.js

@@ -1,3 +1,4 @@
+import { size_max } from '../vfs/constants.js';
 import { StoreFS } from './store/fs.js';
 import { SyncMapTransaction } from './store/map.js';
 /**
@@ -5,8 +6,9 @@ import { SyncMapTransaction } from './store/map.js';
  * @category Stores and Transactions
  */
 export class InMemoryStore extends Map {
-    constructor(label) {
+    constructor(maxSize = size_max, label) {
         super();
+        this.maxSize = maxSize;
         this.label = label;
         this.flags = [];
         this.name = 'tmpfs';
@@ -15,14 +17,28 @@ export class InMemoryStore extends Map {
     transaction() {
         return new SyncMapTransaction(this);
     }
+    get bytes() {
+        let size = this.size * 4;
+        for (const data of this.values())
+            size += data.byteLength;
+        return size;
+    }
+    usage() {
+        return {
+            totalSpace: this.maxSize,
+            freeSpace: this.maxSize - this.bytes,
+        };
+    }
 }
 const _InMemory = {
     name: 'InMemory',
     options: {
+        maxSize: { type: 'number', required: false },
+        label: { type: 'string', required: false },
         name: { type: 'string', required: false },
     },
-    create({ name }) {
-        const fs = new StoreFS(new InMemoryStore(name));
+    create({ maxSize, label, name }) {
+        const fs = new StoreFS(new InMemoryStore(maxSize, label !== null && label !== void 0 ? label : name));
         fs.checkRootSync();
         return fs;
     },

package/dist/backends/overlay.d.ts

@@ -1,5 +1,5 @@
 import type { File } from '../internal/file.js';
-import type { CreationOptions } from '../internal/filesystem.js';
+import type { CreationOptions, UsageInfo } from '../internal/filesystem.js';
 import type { Stats } from '../stats.js';
 import type { InodeLike } from '../internal/inode.js';
 import { FileSystem } from '../internal/filesystem.js';
@@ -37,6 +37,10 @@ export declare class OverlayFS extends FileSystem {
     private _deleteLogError?;
     private _ready;
     constructor({ writable, readable }: OverlayOptions);
+    /**
+     * @todo Consider trying to track information on the writable as well
+     */
+    usage(): UsageInfo;
     sync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;

package/dist/backends/overlay.js

@@ -86,10 +86,16 @@ export class OverlayFS extends FileSystem {
         this.writable = writable;
         this.readable = readable;
         if (this.writable.attributes.has('no_write')) {
-            throw err(new ErrnoError(Errno.EINVAL, 'Writable file can not be written to'));
+            throw err(new ErrnoError(Errno.EINVAL, 'Writable file system can not be written to'));
         }
         this._ready = this._initialize();
     }
+    /**
+     * @todo Consider trying to track information on the writable as well
+     */
+    usage() {
+        return this.readable.usage();
+    }
     async sync(path, data, stats) {
         await this.copyForWrite(path);
         await this.writable.sync(path, data, stats);

package/dist/backends/passthrough.d.ts

@@ -1,6 +1,6 @@
 import type * as fs from 'node:fs';
 import { File } from '../internal/file.js';
-import { FileSystem } from '../internal/filesystem.js';
+import { FileSystem, type UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
 import { Stats } from '../stats.js';
 export type NodeFS = typeof fs;
@@ -16,6 +16,7 @@ export declare class PassthroughFS extends FileSystem {
     readonly nodeFS: NodeFS;
     readonly prefix: string;
     constructor(nodeFS: NodeFS, prefix: string);
+    usage(): UsageInfo;
     path(path: string): string;
     error(err: unknown, path: string): never;
     /**

package/dist/backends/passthrough.js

@@ -141,6 +141,13 @@ export class PassthroughFS extends FileSystem {
         this.nodeFS = nodeFS;
         this.prefix = prefix;
     }
+    usage() {
+        const info = this.nodeFS.statfsSync(this.prefix);
+        return {
+            totalSpace: info.bsize * info.blocks,
+            freeSpace: info.bsize * info.bfree,
+        };
+    }
     path(path) {
         return join(this.prefix, path.slice(1));
     }

package/dist/backends/single_buffer.d.ts

@@ -0,0 +1,149 @@
+import type { UsageInfo } from '../internal/filesystem.js';
+import { StoreFS } from './store/fs.js';
+import { SyncMapTransaction, type SyncMapStore } from './store/map.js';
+import type { Store } from './store/store.js';
+declare class MetadataEntry {
+    /** Inode or data ID */
+    id: number;
+    /** Reserved for 64-bit offset expansion */
+    protected offset_: number;
+    /** Offset into the buffer the data is stored at. */
+    offset: number;
+    /** The size of the data */
+    size: number;
+}
+/**
+ * A block of metadata for a single-buffer file system.
+ * This metadata maps IDs (for inodes and data) to actual offsets in the buffer.
+ * This is done since IDs are not guaranteed to be sequential.
+ */
+declare class MetadataBlock {
+    protected readonly superblock: SuperBlock;
+    offset: number;
+    constructor(superblock: SuperBlock, offset?: number);
+    /**
+     * The crc32c checksum for the metadata block.
+     * @privateRemarks Keep this first!
+     */
+    checksum: number;
+    /** The (last) time this metadata block was updated */
+    timestamp: number;
+    /** Reserved for 64-bit offset expansion */
+    protected previous_offset_: number;
+    /** Offset to the previous metadata block */
+    previous_offset: number;
+    protected _previous?: MetadataBlock;
+    get previous(): MetadataBlock | undefined;
+    /** Metadata entries. */
+    entries: MetadataEntry[];
+}
+/**
+ * The super block structure for a single-buffer file system
+ */
+declare class SuperBlock {
+    readonly store: SingleBufferStore;
+    constructor(store: SingleBufferStore);
+    /**
+     * The crc32c checksum for the super block.
+     * @privateRemarks Keep this first!
+     */
+    checksum: number;
+    /** Signature for the superblock. */
+    magic: number;
+    /** The version of the on-disk format */
+    version: number;
+    /** Which format of `Inode` is used */
+    inode_format: number;
+    /** Flags for the file system. Currently unused */
+    flags: number;
+    /** The number of used bytes, including the super block and metadata */
+    used_bytes: bigint;
+    /** The total size of the entire file system, including the super block and metadata */
+    total_bytes: bigint;
+    /** An ID for this file system */
+    id: bigint;
+    /**
+     * The size in bytes of a metadata block.
+     * Not currently configurable.
+     */
+    metadata_block_size: number;
+    /** Reserved for 64-bit offset expansion */
+    protected metadata_offset_: number;
+    /** Offset of the current metadata block */
+    metadata_offset: number;
+    metadata: MetadataBlock;
+    /** An optional label for the file system */
+    label: string;
+    /** Padded to 256 bytes */
+    _padding: number[];
+    /**
+     * Rotate out the current metadata block.
+     * Allocates a new metadata block, moves the current one to backup,
+     * and updates used_bytes accordingly.
+     * @returns the new metadata block
+     */
+    rotateMetadata(): MetadataBlock;
+    /**
+     * Checks to see if `length` bytes are unused, starting at `offset`.
+     * @internal Not for external use!
+     */
+    isUnused(offset: number, length: number): boolean;
+}
+/**
+ *
+ * @category Stores and Transactions
+ */
+export declare class SingleBufferStore implements SyncMapStore {
+    readonly flags: readonly [];
+    readonly name = "sbfs";
+    readonly id = 1935828595;
+    protected superblock: SuperBlock;
+    /**
+     * @internal @hidden
+     */
+    readonly _view: DataView;
+    /**
+     * @internal @hidden
+     */
+    readonly _buffer: Uint8Array;
+    constructor(buffer: ArrayBufferLike | ArrayBufferView);
+    /**
+     * Update a block's checksum and write it to the store's buffer.
+     * @internal @hidden
+     */
+    _write(value: SuperBlock | MetadataBlock): void;
+    keys(): Iterable<number>;
+    get(id: number): Uint8Array | undefined;
+    set(id: number, data: Uint8Array): void;
+    delete(id: number): void;
+    _fs?: StoreFS<Store> | undefined;
+    sync(): Promise<void>;
+    usage(): UsageInfo;
+    transaction(): SyncMapTransaction;
+}
+/**
+ * Options for the `SingleBuffer` backend
+ * @category Backends and Configuration
+ */
+export interface SingleBufferOptions {
+    buffer: ArrayBufferLike | ArrayBufferView;
+}
+declare const _SingleBuffer: {
+    readonly name: "SingleBuffer";
+    readonly options: {
+        readonly buffer: {
+            readonly type: "object";
+            readonly required: true;
+        };
+    };
+    readonly create: ({ buffer }: SingleBufferOptions) => StoreFS<SingleBufferStore>;
+};
+type _SingleBuffer = typeof _SingleBuffer;
+export interface SingleBuffer extends _SingleBuffer {
+}
+/**
+ * A backend that uses a single buffer for storing data
+ * @category Backends and Configuration
+ */
+export declare const SingleBuffer: SingleBuffer;
+export {};