memfs 3.6.0 → 4.1.0

package/lib/fsa-to-node/FsaNodeFsOpenFile.d.ts

@@ -0,0 +1,24 @@
+import type * as fsa from '../fsa/types';
+import type * as misc from '../node/types/misc';
+/**
+ * Represents an open file. Stores additional metadata about the open file, such
+ * as the seek position.
+ */
+export declare class FsaNodeFsOpenFile {
+    readonly fd: number;
+    readonly createMode: misc.TMode;
+    readonly flags: number;
+    readonly file: fsa.IFileSystemFileHandle;
+    readonly filename: string;
+    protected seek: number;
+    /**
+     * This influences the behavior of the next write operation. On the first
+     * write we want to overwrite the file or keep the existing data, depending
+     * with which flags the file was opened. On subsequent writes we want to
+     * append to the file.
+     */
+    protected keepExistingData: boolean;
+    constructor(fd: number, createMode: misc.TMode, flags: number, file: fsa.IFileSystemFileHandle, filename: string);
+    close(): Promise<void>;
+    write(data: ArrayBufferView, seek: number | null): Promise<void>;
+}

package/lib/fsa-to-node/FsaNodeFsOpenFile.js

@@ -0,0 +1,46 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeFsOpenFile = void 0;
+/**
+ * Represents an open file. Stores additional metadata about the open file, such
+ * as the seek position.
+ */
+class FsaNodeFsOpenFile {
+    constructor(fd, createMode, flags, file, filename) {
+        this.fd = fd;
+        this.createMode = createMode;
+        this.flags = flags;
+        this.file = file;
+        this.filename = filename;
+        this.seek = 0;
+        this.keepExistingData = !!(flags & 1024 /* FLAG.O_APPEND */);
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    write(data, seek) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof seek !== 'number')
+                seek = this.seek;
+            const writer = yield this.file.createWritable({ keepExistingData: this.keepExistingData });
+            yield writer.write({
+                type: 'write',
+                data,
+                position: seek,
+            });
+            yield writer.close();
+            this.keepExistingData = true;
+            this.seek += data.byteLength;
+        });
+    }
+}
+exports.FsaNodeFsOpenFile = FsaNodeFsOpenFile;

package/lib/fsa-to-node/FsaNodeReadStream.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { Defer } from 'thingies/es6/Defer';
+import type { FsaNodeFsOpenFile } from './FsaNodeFsOpenFile';
+import type { IReadStream } from '../node/types/misc';
+import type { IReadStreamOptions } from '../node/types/options';
+import type { FsaNodeFs } from './FsaNodeFs';
+export declare class FsaNodeReadStream extends Readable implements IReadStream {
+    protected readonly fs: FsaNodeFs;
+    protected readonly handle: Promise<FsaNodeFsOpenFile>;
+    readonly path: string;
+    protected readonly options: IReadStreamOptions;
+    protected __pending__: boolean;
+    protected __closed__: boolean;
+    protected __bytes__: number;
+    protected readonly __mutex__: <T = unknown>(code: import("thingies/es6/types").Code<T>) => Promise<T>;
+    protected readonly __file__: Defer<FsaNodeFsOpenFile>;
+    constructor(fs: FsaNodeFs, handle: Promise<FsaNodeFsOpenFile>, path: string, options: IReadStreamOptions);
+    private __read__;
+    private __close__;
+    get bytesRead(): number;
+    get pending(): boolean;
+    _read(): void;
+}

package/lib/fsa-to-node/FsaNodeReadStream.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeReadStream = void 0;
+const stream_1 = require("stream");
+const Defer_1 = require("thingies/es6/Defer");
+const concurrency_1 = require("thingies/es6/concurrency");
+class FsaNodeReadStream extends stream_1.Readable {
+    constructor(fs, handle, path, options) {
+        super();
+        this.fs = fs;
+        this.handle = handle;
+        this.path = path;
+        this.options = options;
+        this.__pending__ = true;
+        this.__closed__ = false;
+        this.__bytes__ = 0;
+        this.__mutex__ = (0, concurrency_1.concurrency)(1);
+        this.__file__ = new Defer_1.Defer();
+        handle
+            .then(file => {
+            if (this.__closed__)
+                return;
+            this.__file__.resolve(file);
+            if (this.options.fd !== undefined)
+                this.emit('open', file.fd);
+            this.emit('ready');
+        })
+            .catch(error => {
+            this.__file__.reject(error);
+        })
+            .finally(() => {
+            this.__pending__ = false;
+        });
+    }
+    __read__() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.__mutex__(() => __awaiter(this, void 0, void 0, function* () {
+                if (this.__closed__)
+                    return;
+                const { file } = yield this.__file__.promise;
+                const blob = yield file.getFile();
+                const buffer = yield blob.arrayBuffer();
+                const start = this.options.start || 0;
+                let end = typeof this.options.end === 'number' ? this.options.end + 1 : buffer.byteLength;
+                if (end > buffer.byteLength)
+                    end = buffer.byteLength;
+                const uint8 = new Uint8Array(buffer, start, end - start);
+                return uint8;
+            }));
+        });
+    }
+    __close__() {
+        if (this.__closed__)
+            return;
+        this.__closed__ = true;
+        if (this.options.autoClose) {
+            this.__file__.promise
+                .then(file => {
+                this.fs.close(file.fd, () => {
+                    this.emit('close');
+                });
+                return file.close();
+            })
+                .catch(error => { });
+        }
+    }
+    // -------------------------------------------------------------- IReadStream
+    get bytesRead() {
+        return this.__bytes__;
+    }
+    get pending() {
+        return this.__pending__;
+    }
+    // ----------------------------------------------------------------- Readable
+    _read() {
+        this.__read__().then((uint8) => {
+            if (this.__closed__)
+                return;
+            if (!uint8)
+                return this.push(null);
+            this.__bytes__ += uint8.length;
+            this.__close__();
+            this.push(uint8);
+            this.push(null);
+        }, error => {
+            this.__close__();
+            this.destroy(error);
+        });
+    }
+}
+exports.FsaNodeReadStream = FsaNodeReadStream;

package/lib/fsa-to-node/FsaNodeStats.d.ts

@@ -0,0 +1,30 @@
+import type * as misc from '../node/types/misc';
+export declare class FsaNodeStats<T = misc.TStatNumber> implements misc.IStats<T> {
+    protected readonly kind: 'file' | 'directory';
+    readonly uid: T;
+    readonly gid: T;
+    readonly rdev: T;
+    readonly blksize: T;
+    readonly ino: T;
+    readonly size: T;
+    readonly blocks: T;
+    readonly atime: Date;
+    readonly mtime: Date;
+    readonly ctime: Date;
+    readonly birthtime: Date;
+    readonly atimeMs: T;
+    readonly mtimeMs: T;
+    readonly ctimeMs: T;
+    readonly birthtimeMs: T;
+    readonly dev: T;
+    readonly mode: T;
+    readonly nlink: T;
+    constructor(isBigInt: boolean, size: T, kind: 'file' | 'directory');
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}

package/lib/fsa-to-node/FsaNodeStats.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeStats = void 0;
+const time = 0;
+const timex = typeof BigInt === 'function' ? BigInt(time) : time;
+const date = new Date(time);
+class FsaNodeStats {
+    constructor(isBigInt, size, kind) {
+        this.kind = kind;
+        const dummy = (isBigInt ? timex : time);
+        this.uid = dummy;
+        this.gid = dummy;
+        this.rdev = dummy;
+        this.blksize = dummy;
+        this.ino = dummy;
+        this.size = size;
+        this.blocks = dummy;
+        this.atime = date;
+        this.mtime = date;
+        this.ctime = date;
+        this.birthtime = date;
+        this.atimeMs = dummy;
+        this.mtimeMs = dummy;
+        this.ctimeMs = dummy;
+        this.birthtimeMs = dummy;
+        this.dev = dummy;
+        this.mode = dummy;
+        this.nlink = dummy;
+    }
+    isDirectory() {
+        return this.kind === 'directory';
+    }
+    isFile() {
+        return this.kind === 'file';
+    }
+    isBlockDevice() {
+        return false;
+    }
+    isCharacterDevice() {
+        return false;
+    }
+    isSymbolicLink() {
+        return false;
+    }
+    isFIFO() {
+        return false;
+    }
+    isSocket() {
+        return false;
+    }
+}
+exports.FsaNodeStats = FsaNodeStats;

package/lib/fsa-to-node/FsaNodeWriteStream.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+import { FsaNodeFsOpenFile } from './FsaNodeFsOpenFile';
+import type { IFileSystemWritableFileStream } from '../fsa/types';
+import type { IWriteStream } from '../node/types/misc';
+import type { IWriteStreamOptions } from '../node/types/options';
+/**
+ * This WriteStream implementation does not build on top of the `fs` module,
+ * but instead uses the lower-level `FileSystemFileHandle` interface. The reason
+ * is the different semantics in `fs` and FSA (File System Access API) write streams.
+ *
+ * When data is written to an FSA file, a new FSA stream is created, it copies
+ * the file to a temporary swap file. After each written chunk, that swap file
+ * is closed and the original file is replaced with the swap file. This means,
+ * if WriteStream was built on top of `fs`, each chunk write would result in
+ * a file copy, write, close, rename operations, which is not what we want.
+ *
+ * Instead this implementation hooks into the lower-level and closes the swap
+ * file only once the stream is closed. The downside is that the written data
+ * is not immediately visible to other processes (because it is written to the
+ * swap file), but that is the trade-off we have to make.
+ *
+ * @todo Could make this flush the data to the original file periodically, so that
+ *       the data is visible to other processes.
+ * @todo This stream could work through `FileSystemSyncAccessHandle.write` in a
+ *       Worker thread instead.
+ */
+export declare class FsaNodeWriteStream extends Writable implements IWriteStream {
+    readonly path: string;
+    protected readonly options: IWriteStreamOptions;
+    protected __pending__: boolean;
+    protected __closed__: boolean;
+    protected __bytes__: number;
+    protected readonly __stream__: Promise<IFileSystemWritableFileStream>;
+    protected readonly __mutex__: <T = unknown>(code: import("thingies/es6/types").Code<T>) => Promise<T>;
+    constructor(handle: Promise<FsaNodeFsOpenFile>, path: string, options: IWriteStreamOptions);
+    private ___write___;
+    private __close__;
+    get bytesWritten(): number;
+    get pending(): boolean;
+    close(cb: any): void;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    _writev(chunks: Array<{
+        chunk: any;
+        encoding: string;
+    }>, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+}

package/lib/fsa-to-node/FsaNodeWriteStream.js

@@ -0,0 +1,162 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeWriteStream = void 0;
+const stream_1 = require("stream");
+const Defer_1 = require("thingies/es6/Defer");
+const concurrency_1 = require("thingies/es6/concurrency");
+const util_1 = require("../node/util");
+/**
+ * This WriteStream implementation does not build on top of the `fs` module,
+ * but instead uses the lower-level `FileSystemFileHandle` interface. The reason
+ * is the different semantics in `fs` and FSA (File System Access API) write streams.
+ *
+ * When data is written to an FSA file, a new FSA stream is created, it copies
+ * the file to a temporary swap file. After each written chunk, that swap file
+ * is closed and the original file is replaced with the swap file. This means,
+ * if WriteStream was built on top of `fs`, each chunk write would result in
+ * a file copy, write, close, rename operations, which is not what we want.
+ *
+ * Instead this implementation hooks into the lower-level and closes the swap
+ * file only once the stream is closed. The downside is that the written data
+ * is not immediately visible to other processes (because it is written to the
+ * swap file), but that is the trade-off we have to make.
+ *
+ * @todo Could make this flush the data to the original file periodically, so that
+ *       the data is visible to other processes.
+ * @todo This stream could work through `FileSystemSyncAccessHandle.write` in a
+ *       Worker thread instead.
+ */
+class FsaNodeWriteStream extends stream_1.Writable {
+    constructor(handle, path, options) {
+        super();
+        this.path = path;
+        this.options = options;
+        this.__pending__ = true;
+        this.__closed__ = false;
+        this.__bytes__ = 0;
+        this.__mutex__ = (0, concurrency_1.concurrency)(1);
+        if (options.start !== undefined) {
+            if (typeof options.start !== 'number') {
+                throw new TypeError('"start" option must be a Number');
+            }
+            if (options.start < 0) {
+                throw new TypeError('"start" must be >= zero');
+            }
+        }
+        const stream = new Defer_1.Defer();
+        this.__stream__ = stream.promise;
+        (() => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const fsaHandle = yield handle;
+            const fileWasOpened = !options.fd;
+            if (fileWasOpened)
+                this.emit('open', fsaHandle.fd);
+            const flags = (0, util_1.flagsToNumber)((_a = options.flags) !== null && _a !== void 0 ? _a : 'w');
+            const keepExistingData = flags & 1024 /* FLAG.O_APPEND */ ? true : false;
+            const writable = yield fsaHandle.file.createWritable({ keepExistingData });
+            if (keepExistingData) {
+                const start = Number((_b = options.start) !== null && _b !== void 0 ? _b : 0);
+                if (start)
+                    yield writable.seek(start);
+            }
+            this.__pending__ = false;
+            stream.resolve(writable);
+        }))().catch(error => {
+            stream.reject(error);
+        });
+    }
+    ___write___(buffers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.__mutex__(() => __awaiter(this, void 0, void 0, function* () {
+                if (this.__closed__)
+                    return;
+                // if (this.__closed__) throw new Error('WriteStream is closed');
+                const writable = yield this.__stream__;
+                for (const buffer of buffers) {
+                    yield writable.write(buffer);
+                    this.__bytes__ += buffer.byteLength;
+                }
+            }));
+        });
+    }
+    __close__() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emitClose = this.options.emitClose;
+            yield this.__mutex__(() => __awaiter(this, void 0, void 0, function* () {
+                if (this.__closed__ && emitClose) {
+                    process.nextTick(() => this.emit('close'));
+                    return;
+                }
+                try {
+                    const writable = yield this.__stream__;
+                    this.__closed__ = true;
+                    yield writable.close();
+                    if (emitClose)
+                        this.emit('close');
+                }
+                catch (error) {
+                    this.emit('error', error);
+                    if (emitClose)
+                        this.emit('close', error);
+                }
+            }));
+        });
+    }
+    // ------------------------------------------------------------- IWriteStream
+    get bytesWritten() {
+        return this.__bytes__;
+    }
+    get pending() {
+        return this.__pending__;
+    }
+    close(cb) {
+        if (cb)
+            this.once('close', cb);
+        this.__close__().catch(() => { });
+    }
+    // ----------------------------------------------------------------- Writable
+    _write(chunk, encoding, callback) {
+        this.___write___([chunk])
+            .then(() => {
+            if (callback)
+                callback(null);
+        })
+            .catch(error => {
+            if (callback)
+                callback(error);
+        });
+    }
+    _writev(chunks, callback) {
+        const buffers = chunks.map(({ chunk }) => chunk);
+        this.___write___(buffers)
+            .then(() => {
+            if (callback)
+                callback(null);
+        })
+            .catch(error => {
+            if (callback)
+                callback(error);
+        });
+    }
+    _final(callback) {
+        this.__close__()
+            .then(() => {
+            if (callback)
+                callback(null);
+        })
+            .catch(error => {
+            if (callback)
+                callback(error);
+        });
+    }
+}
+exports.FsaNodeWriteStream = FsaNodeWriteStream;

package/lib/fsa-to-node/__tests__/FsaNodeFs.test.d.ts

@@ -0,0 +1 @@
+export {};