@zenfs/core 0.11.2 → 0.12.0

package/dist/file.d.ts

@@ -357,7 +357,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
  * For the filesystems which do not sync to anything..
  */
 export declare class NoSyncFile<T extends FileSystem> extends PreloadFile<T> {
-    constructor(_fs: T, _path: string, _flag: string, _stat: Stats, contents?: Uint8Array);
+    constructor(fs: T, path: string, flag: string, stats: Stats, contents?: Uint8Array);
     /**
      * Asynchronous sync. Doesn't do anything, simply calls the cb.
      */

package/dist/file.js

@@ -474,8 +474,8 @@ export class PreloadFile extends File {
  * For the filesystems which do not sync to anything..
  */
 export class NoSyncFile extends PreloadFile {
-    constructor(_fs, _path, _flag, _stat, contents) {
-        super(_fs, _path, _flag, _stat, contents);
+    constructor(fs, path, flag, stats, contents) {
+        super(fs, path, flag, stats, contents);
     }
     /**
      * Asynchronous sync. Doesn't do anything, simply calls the cb.

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export * from './error.js';
 export * from './backends/port/fs.js';
 export * from './backends/fetch.js';
 export * from './backends/memory.js';
-export * from './backends/Index.js';
+export * from './backends/index/fs.js';
 export * from './backends/locked.js';
 export * from './backends/overlay.js';
 export * from './backends/store/fs.js';

package/dist/index.js

@@ -2,7 +2,7 @@ export * from './error.js';
 export * from './backends/port/fs.js';
 export * from './backends/fetch.js';
 export * from './backends/memory.js';
-export * from './backends/Index.js';
+export * from './backends/index/fs.js';
 export * from './backends/locked.js';
 export * from './backends/overlay.js';
 export * from './backends/store/fs.js';

package/dist/stats.d.ts

@@ -12,45 +12,45 @@ export declare enum FileType {
 /**
  *
  */
-export interface StatsLike {
+export interface StatsLike<T extends number | bigint = number | bigint> {
     /**
      * Size of the item in bytes.
      * For directories/symlinks, this is normally the size of the struct that represents the item.
      */
-    size: number | bigint;
+    size: T;
     /**
      * Unix-style file mode (e.g. 0o644) that includes the item type
      * Type of the item can be FILE, DIRECTORY, SYMLINK, or SOCKET
      */
-    mode: number | bigint;
+    mode: T;
     /**
      * time of last access, in milliseconds since epoch
      */
-    atimeMs: number | bigint;
+    atimeMs: T;
     /**
      * time of last modification, in milliseconds since epoch
      */
-    mtimeMs: number | bigint;
+    mtimeMs: T;
     /**
      * time of last time file status was changed, in milliseconds since epoch
      */
-    ctimeMs: number | bigint;
+    ctimeMs: T;
     /**
      * time of file creation, in milliseconds since epoch
      */
-    birthtimeMs: number | bigint;
+    birthtimeMs: T;
     /**
      * the id of the user that owns the file
      */
-    uid: number | bigint;
+    uid: T;
     /**
      * the id of the group that owns the file
      */
-    gid: number | bigint;
+    gid: T;
     /**
      * the ino
      */
-    ino: number | bigint;
+    ino: T;
 }
 /**
  * Provides information about a particular entry in the file system.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.11.2",
+	"version": "0.12.0",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "src/index.ts",

package/scripts/make-index.js

@@ -2,7 +2,7 @@
 import { parseArgs } from 'util';
 import { statSync, readdirSync, writeFileSync } from 'fs';
 import { join } from 'path/posix';
-import { resolve } from 'path';
+import { relative, resolve } from 'path';
 import { minimatch } from 'minimatch';
 
 const { values: options, positionals } = parseArgs({
@@ -38,10 +38,12 @@ if (options.quiet && options.verbose) {
 	process.exit();
 }
 
-function pathToPosix(path) {
+function fixSlash(path) {
 	return path.replaceAll('\\', '/');
 }
 
+const resolvedRoot = root || '.';
+
 const colors = {
 	reset: 0,
 	black: 30,
@@ -66,28 +68,31 @@ function color(color, text) {
 	return `\x1b[${colors[color]}m${text}\x1b[0m`;
 }
 
-function listing(path, seen = new Set()) {
+const entries = new Map();
+
+function computeEntries(path) {
 	try {
-		if (options.verbose) console.log(`${color('blue', 'list')} ${path}`);
+		if (options.ignore.some(pattern => minimatch(path, pattern))) {
+			if (!options.quiet) console.log(`${color('yellow', 'skip')} ${path}`);
+			return;
+		}
+
 		const stats = statSync(path);
+		entries.set('/' + relative(resolvedRoot, path), stats);
 
 		if (stats.isFile()) {
-			if (options.verbose) console.log(`${color('green', 'file')} ${path}`);
-			return null;
+			if (options.verbose) {
+				console.log(`${color('green', 'file')} ${path}`);
+			}
+			return;
 		}
 
-		const entries = {};
 		for (const file of readdirSync(path)) {
-			const full = join(path, file);
-			if (options.ignore.some(pattern => minimatch(full, pattern))) {
-				if (!options.quiet) console.log(`${color('yellow', 'skip')} ${full}`);
-				continue;
-			}
-
-			entries[file] = listing(full, seen);
+			computeEntries(join(path, file));
+		}
+		if (options.verbose) {
+			console.log(`${color('bright_green', ' dir')} ${path}`);
 		}
-		if (options.verbose) console.log(`${color('bright_green', ' dir')} ${path}`);
-		return entries;
 	} catch (e) {
 		if (!options.quiet) {
 			console.log(`${color('red', 'fail')} ${path}: ${e.message}`);
@@ -95,7 +100,14 @@ function listing(path, seen = new Set()) {
 	}
 }
 
-const rootListing = listing(pathToPosix(root));
-if (!options.quiet) console.log('Generated listing for ' + pathToPosix(resolve(root)));
+computeEntries(resolvedRoot);
+if (!options.quiet) {
+	console.log('Generated listing for ' + fixSlash(resolve(root)));
+}
+
+const index = {
+	version: 1,
+	entries: Object.fromEntries(entries),
+};
 
-writeFileSync(options.output, JSON.stringify(rootListing));
+writeFileSync(options.output, JSON.stringify(index));

package/src/backends/fetch.ts

@@ -1,9 +1,9 @@
-import { ErrnoError, Errno } from '../error.js';
-import { NoSyncFile } from '../file.js';
+import { Errno, ErrnoError } from '../error.js';
 import type { FileSystemMetadata } from '../filesystem.js';
 import { Stats } from '../stats.js';
-import { type ListingTree, FileIndex, type IndexFileInode, AsyncIndexFS } from './Index.js';
 import type { Backend } from './backend.js';
+import { IndexFS } from './index/fs.js';
+import type { IndexData } from './index/index.js';
 
 /**
  * Asynchronously download a file as a buffer or a JSON object.
@@ -37,20 +37,6 @@ async function fetchFile<T extends object>(path: string, type: 'buffer' | 'json'
 	}
 }
 
-/**
- * Asynchronously retrieves the size of the given file in bytes.
- * @hidden
- */
-async function fetchSize(path: string): Promise<number> {
-	const response = await fetch(path, { method: 'HEAD' }).catch(e => {
-		throw new ErrnoError(Errno.EIO, e.message);
-	});
-	if (!response.ok) {
-		throw new ErrnoError(Errno.EIO, 'fetch failed: HEAD response returned code ' + response.status);
-	}
-	return parseInt(response.headers.get('Content-Length') || '-1', 10);
-}
-
 /**
  * Configuration options for FetchFS.
  */
@@ -59,7 +45,7 @@ export interface FetchOptions {
 	 * URL to a file index as a JSON file or the file index object itself.
 	 * Defaults to `index.json`.
 	 */
-	index?: string | ListingTree;
+	index?: string | IndexData;
 
 	/** Used as the URL prefix for fetched files.
 	 * Default: Fetch files relative to the index.
@@ -68,59 +54,48 @@ export interface FetchOptions {
 }
 
 /**
- * A simple filesystem backed by HTTP using the fetch API.
+ * A simple filesystem backed by HTTP using the `fetch` API.
  *
  *
- * Listings objects look like the following:
+ * Index objects look like the following:
  *
  * ```json
  * {
- *   "home": {
- *     "jvilk": {
- *       "someFile.txt": null,
- *       "someDir": {
- *         // Empty directory
- *       }
- *     }
- *   }
+ * 	"version": 1,
+ * 	"entries": {
+ * 		"/home": { ... },
+ * 		"/home/jvilk": { ... },
+ * 		"/home/james": { ... }
+ * 	}
  * }
  * ```
  *
- * This example has the folder `/home/jvilk` with subfile `someFile.txt` and subfolder `someDir`.
+ * Each entry contains the stats associated with the file.
  */
-export class FetchFS extends AsyncIndexFS<Stats> {
-	public readonly prefixUrl: string;
+export class FetchFS extends IndexFS {
+	public readonly baseUrl: string;
 
-	protected _init: Promise<void>;
-
-	protected async _initialize(index: string | ListingTree): Promise<void> {
-		if (typeof index != 'string') {
-			this._index = FileIndex.FromListing(index);
+	public async ready(): Promise<void> {
+		if (this._isInitialized) {
 			return;
 		}
-
-		try {
-			const response = await fetch(index);
-			this._index = FileIndex.FromListing((await response.json()) as ListingTree);
-		} catch (e) {
-			throw new ErrnoError(Errno.EINVAL, 'Invalid or unavailable file listing tree');
+		await super.ready();
+		/**
+		 * Iterate over all of the files and cache their contents
+		 */
+		for (const [path, stats] of this.index.files()) {
+			await this.getData(path, stats);
 		}
 	}
 
-	public async ready(): Promise<void> {
-		await this._init;
-	}
-
 	constructor({ index = 'index.json', baseUrl = '' }: FetchOptions) {
-		super({});
+		super(typeof index != 'string' ? index : fetchFile<IndexData>(index, 'json'));
 
 		// prefix url must end in a directory separator.
 		if (baseUrl.at(-1) != '/') {
 			baseUrl += '/';
 		}
-		this.prefixUrl = baseUrl;
-
-		this._init = this._initialize(index);
+		this.baseUrl = baseUrl;
 	}
 
 	public metadata(): FileSystemMetadata {
@@ -131,76 +106,42 @@ export class FetchFS extends AsyncIndexFS<Stats> {
 		};
 	}
 
-	public empty(): void {
-		for (const file of this._index.files()) {
-			delete file.data!.fileData;
-		}
-	}
-
 	/**
-	 * Special function: Preload the given file into the index.
+	 * Preload the given file into the index.
 	 * @param path
 	 * @param buffer
 	 */
-	public preloadFile(path: string, buffer: Uint8Array): void {
-		const inode = this._index.get(path)!;
-		if (!inode) {
+	public preload(path: string, buffer: Uint8Array): void {
+		const stats = this.index.get(path);
+		if (!stats) {
 			throw ErrnoError.With('ENOENT', path, 'preloadFile');
 		}
-		if (!inode.isFile()) {
+		if (!stats.isFile()) {
 			throw ErrnoError.With('EISDIR', path, 'preloadFile');
 		}
-		const stats = inode.data!;
 		stats.size = buffer.length;
 		stats.fileData = buffer;
 	}
 
-	protected async statFileInode(inode: IndexFileInode<Stats>, path: string): Promise<Stats> {
-		const stats = inode.data!;
-		// At this point, a non-opened file will still have default stats from the listing.
-		if (stats.size < 0) {
-			stats.size = await this._fetchSize(path);
-		}
-
-		return stats;
-	}
-
-	protected async openFileInode(inode: IndexFileInode<Stats>, path: string, flag: string): Promise<NoSyncFile<this>> {
-		const stats = inode.data!;
-		// Use existing file contents. This maintains the previously-used flag.
+	/**
+	 * @todo Be lazier about actually requesting the data?
+	 */
+	protected async getData(path: string, stats: Stats): Promise<Uint8Array> {
 		if (stats.fileData) {
-			return new NoSyncFile(this, path, flag, new Stats(stats), stats.fileData);
+			return stats.fileData;
 		}
-		// @todo be lazier about actually requesting the file
-		const data = await this._fetchFile(path, 'buffer');
-		// we don't initially have file sizes
-		stats.size = data.length;
+
+		const data = await fetchFile(this.baseUrl + (path.startsWith('/') ? path.slice(1) : path), 'buffer');
 		stats.fileData = data;
-		return new NoSyncFile(this, path, flag, new Stats(stats), data);
+		return data;
 	}
 
-	private _getRemotePath(filePath: string): string {
-		if (filePath.charAt(0) === '/') {
-			filePath = filePath.slice(1);
+	protected getDataSync(path: string, stats: Stats): Uint8Array {
+		if (stats.fileData) {
+			return stats.fileData;
 		}
-		return this.prefixUrl + filePath;
-	}
-
-	/**
-	 * Asynchronously download the given file.
-	 */
-	protected _fetchFile(path: string, type: 'buffer'): Promise<Uint8Array>;
-	protected _fetchFile(path: string, type: 'json'): Promise<object>;
-	protected _fetchFile(path: string, type: 'buffer' | 'json'): Promise<object>;
-	protected _fetchFile(path: string, type: 'buffer' | 'json'): Promise<object> {
-		return fetchFile(this._getRemotePath(path), type);
-	}
 
-	/**
-	 * Only requests the HEAD content, for the file size.
-	 */
-	protected _fetchSize(path: string): Promise<number> {
-		return fetchSize(this._getRemotePath(path));
+		throw new ErrnoError(Errno.ENODATA, '', path, 'getData');
 	}
 }
 

package/src/backends/index/fs.ts

@@ -0,0 +1,113 @@
+import type { Cred } from '../../cred.js';
+import { ErrnoError, Errno } from '../../error.js';
+import { NoSyncFile, isWriteable, flagToMode } from '../../file.js';
+import { Readonly, FileSystem } from '../../filesystem.js';
+import type { Stats } from '../../stats.js';
+import { decode } from '../../utils.js';
+import { Index, IndexData } from './index.js';
+
+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;
+	}
+
+	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 async stat(path: string): Promise<Stats> {
+		return 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, cred: Cred): 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');
+		}
+
+		if (!stats.hasAccess(flagToMode(flag), cred)) {
+			throw ErrnoError.With('EACCES', path, 'openFile');
+		}
+
+		return new NoSyncFile(this, path, flag, stats, stats.isDirectory() ? stats.fileData : await this.getData(path, stats));
+	}
+
+	public openFileSync(path: string, flag: string, cred: Cred): 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');
+		}
+
+		if (!stats.hasAccess(flagToMode(flag), cred)) {
+			throw ErrnoError.With('EACCES', path, 'openFile');
+		}
+
+		return new NoSyncFile(this, path, flag, stats, stats.isDirectory() ? stats.fileData : this.getDataSync(path, stats));
+	}
+
+	public async readdir(path: string): Promise<string[]> {
+		return 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');
+		}
+
+		if (!stats.isDirectory()) {
+			throw ErrnoError.With('ENOTDIR', path, 'readdir');
+		}
+
+		return JSON.parse(decode(stats.fileData));
+	}
+
+	protected abstract getData(path: string, stats: Stats): Promise<Uint8Array>;
+	protected abstract getDataSync(path: string, stats: Stats): Uint8Array;
+}

package/src/backends/index/index.ts

@@ -0,0 +1,98 @@
+import { isJSON } from 'utilium';
+import { Errno, ErrnoError } from '../../error.js';
+import { Stats, StatsLike } from '../../stats.js';
+import { encode } from '../../utils.js';
+import { basename, dirname } from '../../emulation/path.js';
+
+export interface IndexData {
+	version: 1;
+	entries: Record<string, StatsLike<number>>;
+}
+
+export const version = 1;
+
+/**
+ * An index of files
+ */
+export class Index extends Map<string, Stats> {
+	public constructor() {
+		super();
+	}
+
+	/**
+	 * Convience 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 = encode(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);
+		const index = new Index();
+		index.fromJSON(json);
+		return index;
+	}
+}

package/src/backends/index/readme.md

@@ -0,0 +1,3 @@
+# IndexFS
+
+The `IndexFS` class is a base class for other backends that uses an `Index` to store stats for files and directories. The `Index` class inherits from `Map` and stores information about files and directories in a file system.

package/src/file.ts

@@ -701,8 +701,8 @@ export class PreloadFile<FS extends FileSystem> extends File {
  * For the filesystems which do not sync to anything..
  */
 export class NoSyncFile<T extends FileSystem> extends PreloadFile<T> {
-	constructor(_fs: T, _path: string, _flag: string, _stat: Stats, contents?: Uint8Array) {
-		super(_fs, _path, _flag, _stat, contents);
+	constructor(fs: T, path: string, flag: string, stats: Stats, contents?: Uint8Array) {
+		super(fs, path, flag, stats, contents);
 	}
 	/**
 	 * Asynchronous sync. Doesn't do anything, simply calls the cb.

package/src/index.ts

@@ -2,7 +2,7 @@ export * from './error.js';
 export * from './backends/port/fs.js';
 export * from './backends/fetch.js';
 export * from './backends/memory.js';
-export * from './backends/Index.js';
+export * from './backends/index/fs.js';
 export * from './backends/locked.js';
 export * from './backends/overlay.js';
 export * from './backends/store/fs.js';