memfs 4.0.0 → 4.1.0

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

@@ -0,0 +1,195 @@
+"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.NodeFileSystemWritableFileStream = exports.createSwapFile = void 0;
+/**
+ * When Chrome writes to the file, it creates a copy of the file with extension
+ * `.crswap` and then replaces the original file with the copy only when the
+ * `close()` method is called. If the `abort()` method is called, the `.crswap`
+ * file is deleted.
+ *
+ * If a file name with with extension `.crswap` is already taken, it
+ * creates a new swap file with extension `.1.crswap` and so on.
+ */
+const createSwapFile = (fs, path, keepExistingData) => __awaiter(void 0, void 0, void 0, function* () {
+    let handle;
+    let swapPath = path + '.crswap';
+    try {
+        handle = yield fs.promises.open(swapPath, 'ax');
+    }
+    catch (error) {
+        if (!error || typeof error !== 'object' || error.code !== 'EEXIST')
+            throw error;
+    }
+    if (!handle) {
+        for (let i = 1; i < 1000; i++) {
+            try {
+                swapPath = `${path}.${i}.crswap`;
+                handle = yield fs.promises.open(swapPath, 'ax');
+                break;
+            }
+            catch (error) {
+                if (!error || typeof error !== 'object' || error.code !== 'EEXIST')
+                    throw error;
+            }
+        }
+    }
+    if (!handle)
+        throw new Error(`Could not create a swap file for "${path}".`);
+    if (keepExistingData)
+        yield fs.promises.copyFile(path, swapPath, fs.constants.COPYFILE_FICLONE);
+    return [handle, swapPath];
+});
+exports.createSwapFile = createSwapFile;
+/**
+ * Is a WritableStream object with additional convenience methods, which
+ * operates on a single file on disk. The interface is accessed through the
+ * `FileSystemFileHandle.createWritable()` method.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream
+ */
+class NodeFileSystemWritableFileStream extends WritableStream {
+    constructor(fs, path, keepExistingData) {
+        const swap = { handle: undefined, path: '', offset: 0 };
+        super({
+            start() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const promise = (0, exports.createSwapFile)(fs, path, keepExistingData);
+                    swap.ready = promise.then(() => undefined);
+                    const [handle, swapPath] = yield promise;
+                    swap.handle = handle;
+                    swap.path = swapPath;
+                });
+            },
+            write(chunk) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    yield swap.ready;
+                    const handle = swap.handle;
+                    if (!handle)
+                        throw new Error('Invalid state');
+                    const buffer = Buffer.from(typeof chunk === 'string' ? chunk : chunk instanceof Blob ? yield chunk.arrayBuffer() : chunk);
+                    const { bytesWritten } = yield handle.write(buffer, 0, buffer.length, swap.offset);
+                    swap.offset += bytesWritten;
+                });
+            },
+            close() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    yield swap.ready;
+                    const handle = swap.handle;
+                    if (!handle)
+                        return;
+                    yield handle.close();
+                    yield fs.promises.rename(swap.path, path);
+                });
+            },
+            abort() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    yield swap.ready;
+                    const handle = swap.handle;
+                    if (!handle)
+                        return;
+                    yield handle.close();
+                    yield fs.promises.unlink(swap.path);
+                });
+            },
+        });
+        this.fs = fs;
+        this.path = path;
+        this.swap = swap;
+    }
+    /**
+     * @sse https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/seek
+     * @param position An `unsigned long` describing the byte position from the top
+     *                 (beginning) of the file.
+     */
+    seek(position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.swap.offset = position;
+        });
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream/truncate
+     * @param size An `unsigned long` of the amount of bytes to resize the stream to.
+     */
+    truncate(size) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.swap.ready;
+            const handle = this.swap.handle;
+            if (!handle)
+                throw new Error('Invalid state');
+            yield handle.truncate(size);
+            if (this.swap.offset > size)
+                this.swap.offset = size;
+        });
+    }
+    writeBase(chunk) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const writer = this.getWriter();
+            try {
+                yield writer.write(chunk);
+            }
+            finally {
+                writer.releaseLock();
+            }
+        });
+    }
+    write(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!params)
+                throw new TypeError('Missing required argument: params');
+            switch (typeof params) {
+                case 'string': {
+                    return this.writeBase(params);
+                }
+                case 'object': {
+                    const constructor = params.constructor;
+                    switch (constructor) {
+                        case ArrayBuffer:
+                        case Blob:
+                        case DataView:
+                            return this.writeBase(params);
+                        default: {
+                            if (ArrayBuffer.isView(params)) {
+                                return this.writeBase(params);
+                            }
+                            else {
+                                const options = params;
+                                switch (options.type) {
+                                    case 'write': {
+                                        if (typeof options.position === 'number')
+                                            yield this.seek(options.position);
+                                        return this.writeBase(params.data);
+                                    }
+                                    case 'truncate': {
+                                        if (typeof params.size !== 'number')
+                                            throw new TypeError('Missing required argument: size');
+                                        if (this.swap.offset > params.size)
+                                            this.swap.offset = params.size;
+                                        return this.truncate(params.size);
+                                    }
+                                    case 'seek':
+                                        if (typeof params.position !== 'number')
+                                            throw new TypeError('Missing required argument: position');
+                                        return this.seek(params.position);
+                                    default:
+                                        throw new TypeError('Invalid argument: params');
+                                }
+                            }
+                        }
+                    }
+                }
+                default:
+                    throw new TypeError('Invalid argument: params');
+            }
+        });
+    }
+}
+exports.NodeFileSystemWritableFileStream = NodeFileSystemWritableFileStream;

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

@@ -0,0 +1,8 @@
+/**
+ * @see [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/PermissionStatus)
+ */
+export declare class NodePermissionStatus {
+    readonly name: string;
+    readonly state: 'granted' | 'denied' | 'prompt';
+    constructor(name: string, state: 'granted' | 'denied' | 'prompt');
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodePermissionStatus = void 0;
+/**
+ * @see [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/PermissionStatus)
+ */
+class NodePermissionStatus {
+    constructor(name, state) {
+        this.name = name;
+        this.state = state;
+    }
+}
+exports.NodePermissionStatus = NodePermissionStatus;

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

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