memfs 4.0.0 → 4.1.0

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

@@ -0,0 +1,168 @@
+"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.FsaNodeCore = void 0;
+const util_1 = require("../node/util");
+const util_2 = require("./util");
+const constants_1 = require("../node/constants");
+const FsaNodeFsOpenFile_1 = require("./FsaNodeFsOpenFile");
+class FsaNodeCore {
+    constructor(root, syncAdapter) {
+        this.root = root;
+        this.syncAdapter = syncAdapter;
+        this.fds = new Map();
+        /**
+         * A list of reusable (opened and closed) file descriptors, that should be
+         * used first before creating a new file descriptor.
+         */
+        this.releasedFds = [];
+        if (root instanceof Promise) {
+            root
+                .then(root => {
+                this.root = root;
+            })
+                .catch(error => { });
+        }
+    }
+    getSyncAdapter() {
+        const adapter = this.syncAdapter;
+        if (!adapter)
+            throw new Error('No sync adapter');
+        return adapter;
+    }
+    newFdNumber() {
+        const releasedFd = this.releasedFds.pop();
+        return typeof releasedFd === 'number' ? releasedFd : FsaNodeCore.fd--;
+    }
+    /**
+     * @param path Path from root to the new folder.
+     * @param create Whether to create the folders if they don't exist.
+     */
+    getDir(path, create, funcName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let curr = yield this.root;
+            const options = { create };
+            try {
+                for (const name of path) {
+                    curr = yield curr.getDirectoryHandle(name, options);
+                }
+            }
+            catch (error) {
+                if (error && typeof error === 'object') {
+                    switch (error.name) {
+                        case 'TypeMismatchError':
+                            throw (0, util_1.createError)('ENOTDIR', funcName, path.join("/" /* FsaToNodeConstants.Separator */));
+                        case 'NotFoundError':
+                            throw (0, util_1.createError)('ENOENT', funcName, path.join("/" /* FsaToNodeConstants.Separator */));
+                    }
+                }
+                throw error;
+            }
+            return curr;
+        });
+    }
+    getFile(path, name, funcName, create) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dir = yield this.getDir(path, false, funcName);
+            const file = yield dir.getFileHandle(name, { create });
+            return file;
+        });
+    }
+    getFileOrDir(path, name, funcName, create) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dir = yield this.getDir(path, false, funcName);
+            try {
+                const file = yield dir.getFileHandle(name);
+                return file;
+            }
+            catch (error) {
+                if (error && typeof error === 'object') {
+                    switch (error.name) {
+                        case 'TypeMismatchError':
+                            try {
+                                return yield dir.getDirectoryHandle(name);
+                            }
+                            catch (error2) {
+                                if (error2 && typeof error2 === 'object') {
+                                    switch (error2.name) {
+                                        case 'TypeMismatchError':
+                                            throw (0, util_1.createError)('ENOTDIR', funcName, path.join("/" /* FsaToNodeConstants.Separator */));
+                                        case 'NotFoundError':
+                                            throw (0, util_1.createError)('ENOENT', funcName, path.join("/" /* FsaToNodeConstants.Separator */));
+                                    }
+                                }
+                            }
+                        case 'NotFoundError':
+                            throw (0, util_1.createError)('ENOENT', funcName, path.join("/" /* FsaToNodeConstants.Separator */));
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+    getFileByFd(fd, funcName) {
+        if (!(0, util_1.isFd)(fd))
+            throw TypeError(constants_1.ERRSTR.FD);
+        const file = this.fds.get(fd);
+        if (!file)
+            throw (0, util_1.createError)('EBADF', funcName);
+        return file;
+    }
+    getFileByFdAsync(fd, funcName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getFileByFd(fd, funcName);
+        });
+    }
+    __getFileById(id, funcName, create) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof id === 'number')
+                return (yield this.getFileByFd(id, funcName)).file;
+            const filename = (0, util_1.pathToFilename)(id);
+            const [folder, name] = (0, util_2.pathToLocation)(filename);
+            return yield this.getFile(folder, name, funcName, create);
+        });
+    }
+    getFileByIdOrCreate(id, funcName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof id === 'number')
+                return (yield this.getFileByFd(id, funcName)).file;
+            const filename = (0, util_1.pathToFilename)(id);
+            const [folder, name] = (0, util_2.pathToLocation)(filename);
+            const dir = yield this.getDir(folder, false, funcName);
+            return yield dir.getFileHandle(name, { create: true });
+        });
+    }
+    __open(filename, flags, mode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [folder, name] = (0, util_2.pathToLocation)(filename);
+            const createIfMissing = !!(flags & 64 /* FLAG.O_CREAT */);
+            const fsaFile = yield this.getFile(folder, name, 'open', createIfMissing);
+            return this.__open2(fsaFile, filename, flags, mode);
+        });
+    }
+    __open2(fsaFile, filename, flags, mode) {
+        const fd = this.newFdNumber();
+        const file = new FsaNodeFsOpenFile_1.FsaNodeFsOpenFile(fd, mode, flags, fsaFile, filename);
+        this.fds.set(fd, file);
+        return file;
+    }
+    getFileName(id) {
+        if (typeof id === 'number') {
+            const openFile = this.fds.get(id);
+            if (!openFile)
+                throw (0, util_1.createError)('EBADF', 'readFile');
+            return openFile.filename;
+        }
+        return (0, util_1.pathToFilename)(id);
+    }
+}
+exports.FsaNodeCore = FsaNodeCore;
+FsaNodeCore.fd = 0x7fffffff;

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

@@ -0,0 +1,13 @@
+import type { IDirent, TDataOut } from '../node/types/misc';
+export declare class FsaNodeDirent implements IDirent {
+    readonly name: TDataOut;
+    protected readonly kind: 'file' | 'directory';
+    constructor(name: TDataOut, kind: 'file' | 'directory');
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeDirent = void 0;
+class FsaNodeDirent {
+    constructor(name, kind) {
+        this.name = name;
+        this.kind = kind;
+    }
+    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.FsaNodeDirent = FsaNodeDirent;

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

@@ -0,0 +1,171 @@
+import { FsaNodeDirent } from './FsaNodeDirent';
+import { FsaNodeStats } from './FsaNodeStats';
+import { FsSynchronousApi } from '../node/types/FsSynchronousApi';
+import { FsaNodeWriteStream } from './FsaNodeWriteStream';
+import { FsaNodeReadStream } from './FsaNodeReadStream';
+import { FsaNodeCore } from './FsaNodeCore';
+import type { FsCallbackApi, FsPromisesApi } from '../node/types';
+import type { FsCommonObjects } from '../node/types/FsCommonObjects';
+/**
+ * Constructs a Node.js `fs` API from a File System Access API
+ * [`FileSystemDirectoryHandle` object](https://developer.mozilla.org/en-US/docs/Web/API/FileSystemDirectoryHandle).
+ */
+export declare class FsaNodeFs extends FsaNodeCore implements FsCallbackApi, FsSynchronousApi, FsCommonObjects {
+    readonly promises: FsPromisesApi;
+    readonly open: FsCallbackApi['open'];
+    readonly close: FsCallbackApi['close'];
+    readonly read: FsCallbackApi['read'];
+    readonly readFile: FsCallbackApi['readFile'];
+    readonly write: FsCallbackApi['write'];
+    readonly writev: FsCallbackApi['writev'];
+    readonly writeFile: FsCallbackApi['writeFile'];
+    readonly copyFile: FsCallbackApi['copyFile'];
+    /**
+     * @todo There is a proposal for native "self remove" operation.
+     * @see https://github.com/whatwg/fs/blob/main/proposals/Remove.md
+     */
+    readonly unlink: FsCallbackApi['unlink'];
+    readonly realpath: FsCallbackApi['realpath'];
+    readonly stat: FsCallbackApi['stat'];
+    readonly lstat: FsCallbackApi['lstat'];
+    readonly fstat: FsCallbackApi['fstat'];
+    private getHandleStats;
+    /**
+     * @todo There is a proposal for native move support.
+     * @see https://github.com/whatwg/fs/blob/main/proposals/MovingNonOpfsFiles.md
+     */
+    readonly rename: FsCallbackApi['rename'];
+    readonly exists: FsCallbackApi['exists'];
+    readonly access: FsCallbackApi['access'];
+    readonly appendFile: FsCallbackApi['appendFile'];
+    readonly readdir: FsCallbackApi['readdir'];
+    readonly readlink: FsCallbackApi['readlink'];
+    /** @todo Could this use `FileSystemSyncAccessHandle.flush` through a Worker thread? */
+    readonly fsync: FsCallbackApi['fsync'];
+    readonly fdatasync: FsCallbackApi['fdatasync'];
+    readonly ftruncate: FsCallbackApi['ftruncate'];
+    readonly truncate: FsCallbackApi['truncate'];
+    readonly futimes: FsCallbackApi['futimes'];
+    readonly utimes: FsCallbackApi['utimes'];
+    readonly mkdir: FsCallbackApi['mkdir'];
+    readonly mkdtemp: FsCallbackApi['mkdtemp'];
+    private rmAll;
+    readonly rmdir: FsCallbackApi['rmdir'];
+    readonly rm: FsCallbackApi['rm'];
+    readonly fchmod: FsCallbackApi['fchmod'];
+    readonly chmod: FsCallbackApi['chmod'];
+    readonly lchmod: FsCallbackApi['lchmod'];
+    readonly fchown: FsCallbackApi['fchown'];
+    readonly chown: FsCallbackApi['chown'];
+    readonly lchown: FsCallbackApi['lchown'];
+    readonly createWriteStream: FsCallbackApi['createWriteStream'];
+    readonly createReadStream: FsCallbackApi['createReadStream'];
+    readonly symlink: FsCallbackApi['symlink'];
+    readonly link: FsCallbackApi['link'];
+    /**
+     * @todo Watchers could be implemented in the future on top of `FileSystemObserver`,
+     * which is currently a proposal.
+     * @see https://github.com/whatwg/fs/blob/main/proposals/FileSystemObserver.md
+     */
+    readonly watchFile: FsCallbackApi['watchFile'];
+    readonly unwatchFile: FsCallbackApi['unwatchFile'];
+    readonly watch: FsCallbackApi['watch'];
+    readonly statSync: FsSynchronousApi['statSync'];
+    readonly lstatSync: FsSynchronousApi['lstatSync'];
+    readonly fstatSync: FsSynchronousApi['fstatSync'];
+    readonly accessSync: FsSynchronousApi['accessSync'];
+    readonly readFileSync: FsSynchronousApi['readFileSync'];
+    readonly writeFileSync: FsSynchronousApi['writeFileSync'];
+    readonly appendFileSync: FsSynchronousApi['appendFileSync'];
+    readonly closeSync: FsSynchronousApi['closeSync'];
+    readonly existsSync: FsSynchronousApi['existsSync'];
+    readonly copyFileSync: FsSynchronousApi['copyFileSync'];
+    readonly renameSync: FsSynchronousApi['renameSync'];
+    readonly rmdirSync: FsSynchronousApi['rmdirSync'];
+    readonly rmSync: FsSynchronousApi['rmSync'];
+    readonly mkdirSync: FsSynchronousApi['mkdirSync'];
+    readonly mkdtempSync: FsSynchronousApi['mkdtempSync'];
+    readonly readlinkSync: FsSynchronousApi['readlinkSync'];
+    readonly truncateSync: FsSynchronousApi['truncateSync'];
+    readonly ftruncateSync: FsSynchronousApi['ftruncateSync'];
+    readonly unlinkSync: FsSynchronousApi['unlinkSync'];
+    readonly readdirSync: FsSynchronousApi['readdirSync'];
+    readonly realpathSync: FsSynchronousApi['realpathSync'];
+    readonly readSync: FsSynchronousApi['readSync'];
+    readonly writeSync: FsSynchronousApi['writeSync'];
+    readonly openSync: FsSynchronousApi['openSync'];
+    readonly fdatasyncSync: FsSynchronousApi['fdatasyncSync'];
+    readonly fsyncSync: FsSynchronousApi['fsyncSync'];
+    readonly chmodSync: FsSynchronousApi['chmodSync'];
+    readonly chownSync: FsSynchronousApi['chownSync'];
+    readonly fchmodSync: FsSynchronousApi['fchmodSync'];
+    readonly fchownSync: FsSynchronousApi['fchownSync'];
+    readonly futimesSync: FsSynchronousApi['futimesSync'];
+    readonly lchmodSync: FsSynchronousApi['lchmodSync'];
+    readonly lchownSync: FsSynchronousApi['lchownSync'];
+    readonly utimesSync: FsSynchronousApi['utimesSync'];
+    readonly symlinkSync: FsSynchronousApi['symlinkSync'];
+    readonly linkSync: FsSynchronousApi['linkSync'];
+    readonly F_OK: number;
+    readonly R_OK: number;
+    readonly W_OK: number;
+    readonly X_OK: number;
+    readonly constants: {
+        O_RDONLY: number;
+        O_WRONLY: number;
+        O_RDWR: number;
+        S_IFMT: number;
+        S_IFREG: number;
+        S_IFDIR: number;
+        S_IFCHR: number;
+        S_IFBLK: number;
+        S_IFIFO: number;
+        S_IFLNK: number;
+        S_IFSOCK: number;
+        O_CREAT: number;
+        O_EXCL: number;
+        O_NOCTTY: number;
+        O_TRUNC: number;
+        O_APPEND: number;
+        O_DIRECTORY: number;
+        O_NOATIME: number;
+        O_NOFOLLOW: number;
+        O_SYNC: number;
+        O_DIRECT: number;
+        O_NONBLOCK: number;
+        S_IRWXU: number;
+        S_IRUSR: number;
+        S_IWUSR: number;
+        S_IXUSR: number;
+        S_IRWXG: number;
+        S_IRGRP: number;
+        S_IWGRP: number;
+        S_IXGRP: number;
+        S_IRWXO: number;
+        S_IROTH: number;
+        S_IWOTH: number;
+        S_IXOTH: number;
+        F_OK: number;
+        R_OK: number;
+        W_OK: number;
+        X_OK: number;
+        UV_FS_SYMLINK_DIR: number;
+        UV_FS_SYMLINK_JUNCTION: number;
+        UV_FS_COPYFILE_EXCL: number;
+        UV_FS_COPYFILE_FICLONE: number;
+        UV_FS_COPYFILE_FICLONE_FORCE: number;
+        COPYFILE_EXCL: number;
+        COPYFILE_FICLONE: number;
+        COPYFILE_FICLONE_FORCE: number;
+    };
+    readonly Dirent: typeof FsaNodeDirent;
+    readonly Stats: {
+        new (isBigInt: boolean, size: any, kind: "file" | "directory"): FsaNodeStats<any>;
+    };
+    readonly WriteStream: typeof FsaNodeWriteStream;
+    readonly ReadStream: typeof FsaNodeReadStream;
+    readonly StatFs: any;
+    readonly Dir: any;
+    readonly StatsWatcher: any;
+    readonly FSWatcher: any;
+}