@zenfs/core 1.7.2 → 1.8.1

package/dist/backends/file_index.d.ts

@@ -1,63 +0,0 @@
-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: number;
-    entries: Record<string, StatsLike<number>>;
-}
-export declare const version = 1;
-/**
- * An index of files
- * @internal
- */
-export declare class Index extends Map<string, Stats> {
-    /**
-     * Convenience 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("../index.js").Mixin<typeof FileSystem, import("../mixins/readonly.js").ReadonlyMixin>;
-export declare abstract class IndexFS extends IndexFS_base {
-    private indexData;
-    protected index: Index;
-    protected _isInitialized: boolean;
-    ready(): Promise<void>;
-    constructor(indexData: IndexData | Promise<IndexData>);
-    reloadFiles(): Promise<void>;
-    reloadFilesSync(): void;
-    stat(path: string): Promise<Stats>;
-    statSync(path: string): Stats;
-    openFile(path: string, flag: string): Promise<NoSyncFile<this>>;
-    openFileSync(path: string, flag: string): NoSyncFile<this>;
-    readdir(path: string): Promise<string[]>;
-    readdirSync(path: string): string[];
-    protected abstract getData(path: string, stats: Stats): Promise<Uint8Array>;
-    protected abstract getDataSync(path: string, stats: Stats): Uint8Array;
-}
-export {};

package/dist/backends/file_index.js

@@ -1,163 +0,0 @@
-/* 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 { Errno, ErrnoError } from '../error.js';
-import { NoSyncFile, isWriteable } from '../file.js';
-import { FileSystem } from '../filesystem.js';
-import { Readonly } from '../mixins/readonly.js';
-import { Stats } from '../stats.js';
-import { decodeUTF8, encodeUTF8 } from '../utils.js';
-import { basename, dirname } from '../vfs/path.js';
-export const version = 1;
-/**
- * An index of files
- * @internal
- */
-export class Index extends Map {
-    /**
-     * Convenience 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 = encodeUTF8(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();
-        if (this._isInitialized) {
-            return;
-        }
-        this.index.fromJSON(await this.indexData);
-        this._isInitialized = true;
-    }
-    constructor(indexData) {
-        super();
-        this.indexData = indexData;
-        this.index = new Index();
-        this._isInitialized = false;
-    }
-    async reloadFiles() {
-        for (const [path, stats] of this.index.files()) {
-            delete stats.fileData;
-            stats.fileData = await this.getData(path, stats);
-        }
-    }
-    reloadFilesSync() {
-        for (const [path, stats] of this.index.files()) {
-            delete stats.fileData;
-            stats.fileData = this.getDataSync(path, stats);
-        }
-    }
-    stat(path) {
-        return Promise.resolve(this.statSync(path));
-    }
-    statSync(path) {
-        if (!this.index.has(path)) {
-            throw ErrnoError.With('ENOENT', path, 'stat');
-        }
-        return this.index.get(path);
-    }
-    async openFile(path, flag) {
-        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));
-    }
-    openFileSync(path, flag) {
-        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));
-    }
-    readdir(path) {
-        return Promise.resolve(this.readdirSync(path));
-    }
-    readdirSync(path) {
-        // Check if it exists.
-        const stats = this.index.get(path);
-        if (!stats) {
-            throw ErrnoError.With('ENOENT', path, 'readdir');
-        }
-        const content = 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;
-    }
-}

package/tests/common/async.test.ts

@@ -1,31 +0,0 @@
-import assert from 'node:assert';
-import { suite, test } from 'node:test';
-import { configure } from '../../dist/config.js';
-import * as fs from '../../dist/vfs/index.js';
-import { InMemoryStore, StoreFS } from '../../dist/index.js';
-import { Async } from '../../dist/mixins/async.js';
-
-class ExampleAsyncFS extends Async(StoreFS) {
-	_sync = new StoreFS(new InMemoryStore('cache'));
-
-	public constructor() {
-		super(new InMemoryStore('test'));
-	}
-}
-
-const asyncFS = new ExampleAsyncFS();
-
-await configure({ mounts: { '/': asyncFS } });
-
-suite('Async Mixin', () => {
-	test('async -> cache syncing', async () => {
-		await fs.promises.writeFile('test', 'test');
-		assert.strictEqual(fs.readFileSync('test', 'utf8'), 'test');
-	});
-
-	test('cache -> async syncing', async () => {
-		fs.unlinkSync('test');
-		await asyncFS.queueDone();
-		assert(!(await fs.promises.exists('test')));
-	});
-});

package/tests/setup/cow+fetch.ts

@@ -1,45 +0,0 @@
-import { execSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { createServer } from 'node:http';
-import { join } from 'node:path';
-import { configureSingle, Fetch, InMemory, Overlay } from '../../dist/index.js';
-import { data, tmp } from '../setup.js';
-
-const port = 26514,
-	index = tmp + '/index.json';
-
-const statusCodes = {
-	ENOENT: 404,
-};
-
-execSync(`npm exec make-index -- ${data} --output ${index} --quiet`, { stdio: 'inherit' });
-
-const server = createServer((request, response) => {
-	const path = request.url == '/.index.json' ? index : join(data, request.url?.slice(1) || '');
-	try {
-		response.statusCode = 200;
-		response.end(readFileSync(path));
-	} catch (e: any) {
-		response.statusCode = statusCodes[e.code as keyof typeof statusCodes] || 400;
-		response.end();
-	}
-});
-
-server
-	.once('error', (error: NodeJS.ErrnoException) => {
-		if (error.code == 'EADDRINUSE') return;
-		throw error;
-	})
-	.listen(port)
-	.unref();
-
-const baseUrl = 'http://localhost:' + port;
-
-await configureSingle({
-	backend: Overlay,
-	readable: Fetch.create({
-		baseUrl,
-		index: baseUrl + '/.index.json',
-	}),
-	writable: InMemory.create({ name: 'cow' }),
-});