@zenfs/core 1.1.6 → 1.2.0

package/src/backends/file_index.ts

@@ -0,0 +1,206 @@
+/* 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, isWriteable } from '../file.js';
+import { FileSystem } from '../filesystem.js';
+import { Readonly } from '../mixins/readonly.js';
+import type { StatsLike } from '../stats.js';
+import { Stats } from '../stats.js';
+import { decodeUTF8, encodeUTF8 } from '../utils.js';
+
+/**
+ * An Index in JSON form
+ * @internal
+ */
+export interface IndexData {
+	version: 1;
+	entries: Record<string, StatsLike<number>>;
+}
+
+export const version = 1;
+
+/**
+ * An index of files
+ * @internal
+ */
+export class Index extends Map<string, Stats> {
+	/**
+	 * Convenience method
+	 */
+	public files(): Map<string, Stats> {
+		const files = new Map<string, Stats>();
+		for (const [path, stats] of this) {
+			if (stats.isFile()) {
+				files.set(path, stats);
+			}
+		}
+		return files;
+	}
+
+	/**
+	 * Converts the index to JSON
+	 */
+	public toJSON(): IndexData {
+		return {
+			version,
+			entries: Object.fromEntries(this),
+		};
+	}
+
+	/**
+	 * Converts the index to a string
+	 */
+	public toString(): string {
+		return JSON.stringify(this.toJSON());
+	}
+
+	/**
+	 * Returns the files in the directory `dir`.
+	 * This is expensive so it is only called once per directory.
+	 */
+	protected dirEntries(dir: string): string[] {
+		const entries = [];
+		for (const entry of this.keys()) {
+			if (dirname(entry) == dir) {
+				entries.push(basename(entry));
+			}
+		}
+		return entries;
+	}
+
+	/**
+	 * Loads the index from JSON data
+	 */
+	public fromJSON(json: IndexData): void {
+		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 = encodeUTF8(JSON.stringify(this.dirEntries(path)));
+			}
+			this.set(path, stats);
+		}
+	}
+
+	/**
+	 * Parses an index from a string
+	 */
+	public static parse(data: string): Index {
+		if (!isJSON(data)) {
+			throw new ErrnoError(Errno.EINVAL, 'Invalid JSON');
+		}
+
+		const json = JSON.parse(data) as IndexData;
+		const index = new Index();
+		index.fromJSON(json);
+		return index;
+	}
+}
+
+export abstract class IndexFS extends Readonly(FileSystem) {
+	protected index: Index = new Index();
+
+	protected _isInitialized: boolean = false;
+
+	public async ready(): Promise<void> {
+		await super.ready();
+		if (this._isInitialized) {
+			return;
+		}
+		this.index.fromJSON(await this.indexData);
+		this._isInitialized = true;
+	}
+
+	public constructor(private indexData: IndexData | Promise<IndexData>) {
+		super();
+	}
+
+	public async reloadFiles(): Promise<void> {
+		for (const [path, stats] of this.index.files()) {
+			delete stats.fileData;
+			stats.fileData = await this.getData(path, stats);
+		}
+	}
+
+	public reloadFilesSync(): void {
+		for (const [path, stats] of this.index.files()) {
+			delete stats.fileData;
+			stats.fileData = this.getDataSync(path, stats);
+		}
+	}
+
+	public stat(path: string): Promise<Stats> {
+		return Promise.resolve(this.statSync(path));
+	}
+
+	public statSync(path: string): Stats {
+		if (!this.index.has(path)) {
+			throw ErrnoError.With('ENOENT', path, 'stat');
+		}
+
+		return this.index.get(path)!;
+	}
+
+	public async openFile(path: string, flag: string): Promise<NoSyncFile<this>> {
+		if (isWriteable(flag)) {
+			// You can't write to files on this file system.
+			throw new ErrnoError(Errno.EPERM, path);
+		}
+
+		// Check if the path exists, and is a file.
+		const stats = this.index.get(path);
+
+		if (!stats) {
+			throw ErrnoError.With('ENOENT', path, 'openFile');
+		}
+
+		return new NoSyncFile(this, path, flag, stats, stats.isDirectory() ? stats.fileData : await this.getData(path, stats));
+	}
+
+	public openFileSync(path: string, flag: string): NoSyncFile<this> {
+		if (isWriteable(flag)) {
+			// You can't write to files on this file system.
+			throw new ErrnoError(Errno.EPERM, path);
+		}
+
+		// Check if the path exists, and is a file.
+		const stats = this.index.get(path);
+
+		if (!stats) {
+			throw ErrnoError.With('ENOENT', path, 'openFile');
+		}
+
+		return new NoSyncFile(this, path, flag, stats, stats.isDirectory() ? stats.fileData : this.getDataSync(path, stats));
+	}
+
+	public readdir(path: string): Promise<string[]> {
+		return Promise.resolve(this.readdirSync(path));
+	}
+
+	public readdirSync(path: string): string[] {
+		// Check if it exists.
+		const stats = this.index.get(path);
+		if (!stats) {
+			throw ErrnoError.With('ENOENT', path, 'readdir');
+		}
+
+		const content: unknown = JSON.parse(decodeUTF8(stats.fileData));
+		if (!Array.isArray(content)) {
+			throw ErrnoError.With('ENODATA', path, 'readdir');
+		}
+		if (!content.every(item => typeof item == 'string')) {
+			throw ErrnoError.With('ENODATA', path, 'readdir');
+		}
+		return content;
+	}
+
+	protected abstract getData(path: string, stats: Stats): Promise<Uint8Array>;
+	protected abstract getDataSync(path: string, stats: Stats): Uint8Array;
+}

package/src/backends/memory.ts

@@ -0,0 +1,50 @@
+import type { Ino } from '../inode.js';
+import type { Backend } from './backend.js';
+import { StoreFS } from './store/fs.js';
+import { SimpleTransaction, type SimpleSyncStore } from './store/simple.js';
+
+/**
+ * A simple in-memory store
+ */
+export class InMemoryStore extends Map<Ino, Uint8Array> implements SimpleSyncStore {
+	public constructor(public name: string = 'tmp') {
+		super();
+	}
+
+	public async sync(): Promise<void> {}
+
+	public clearSync(): void {
+		this.clear();
+	}
+
+	public transaction(): SimpleTransaction {
+		return new SimpleTransaction(this);
+	}
+}
+
+/**
+ * A simple in-memory file system backed by an InMemoryStore.
+ * Files are not persisted across page loads.
+ */
+const _InMemory = {
+	name: 'InMemory',
+	isAvailable(): boolean {
+		return true;
+	},
+	options: {
+		name: {
+			type: 'string',
+			required: false,
+			description: 'The name of the store',
+		},
+	},
+	create({ name }: { name?: string }) {
+		const fs = new StoreFS(new InMemoryStore(name));
+		fs.checkRootSync();
+		return fs;
+	},
+} as const satisfies Backend<StoreFS<InMemoryStore>, { name?: string }>;
+type _InMemory = typeof _InMemory;
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface InMemory extends _InMemory {}
+export const InMemory: InMemory = _InMemory;