memfs 4.0.0 → 4.1.0

package/lib/node-to-fsa/__tests__/NodeFileSystemFileHandle.test.js

@@ -0,0 +1,191 @@
+"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 });
+const __1 = require("../..");
+const NodeFileSystemDirectoryHandle_1 = require("../NodeFileSystemDirectoryHandle");
+const util_1 = require("../../__tests__/util");
+const setup = (json = {}) => {
+    const fs = (0, __1.memfs)(json, '/');
+    const dir = new NodeFileSystemDirectoryHandle_1.NodeFileSystemDirectoryHandle(fs, '/', { mode: 'readwrite' });
+    return { dir, fs };
+};
+(0, util_1.onlyOnNode20)('NodeFileSystemFileHandle', () => {
+    describe('.getFile()', () => {
+        test('can read file contents', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir, fs } = setup({
+                'file.txt': 'Hello, world!',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const file = yield entry.getFile();
+            const contents = yield file.text();
+            expect(entry.name).toBe('file.txt');
+            expect(file).toBeInstanceOf(File);
+            expect(file.name).toBe('file.txt');
+            expect(file.lastModified).toBe(fs.statSync('/file.txt').mtime.getTime());
+            expect(contents).toBe('Hello, world!');
+        }));
+    });
+    describe('.createWritable()', () => {
+        test('throws if not in "readwrite" mode', () => __awaiter(void 0, void 0, void 0, function* () {
+            const fs = (0, __1.memfs)({ 'file.txt': 'abc' }, '/');
+            const dir = new NodeFileSystemDirectoryHandle_1.NodeFileSystemDirectoryHandle(fs, '/', { mode: 'read' });
+            const entry = yield dir.getFileHandle('file.txt');
+            try {
+                yield entry.createWritable();
+                throw new Error('Not this error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DOMException);
+                expect(error.name).toBe('NotAllowedError');
+                expect(error.message).toBe('The request is not allowed by the user agent or the platform in the current context.');
+            }
+        }));
+        describe('.truncate()', () => {
+            test('can truncate file', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '012345',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable({ keepExistingData: true });
+                yield writable.truncate(3);
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('012');
+            }));
+            test('can truncate file - 2', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '012345',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable({ keepExistingData: true });
+                yield writable.write({ type: 'truncate', size: 3 });
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('012');
+            }));
+            test('can truncate up', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '012345',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable({ keepExistingData: true });
+                yield writable.write({ type: 'truncate', size: 10 });
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt').length).toBe(10);
+                expect(fs.readFileSync('/file.txt')[8]).toBe(0);
+            }));
+            test('on up truncation bytes are nulled', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '012345',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable({ keepExistingData: true });
+                yield writable.write({ type: 'truncate', size: 10 });
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt')[8]).toBe(0);
+            }));
+        });
+        describe('.write(chunk)', () => {
+            test('overwrites the file when write is being executed', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': 'Hello, world!',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable();
+                yield writable.write('...');
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('...');
+            }));
+            test('writes at file start', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '...',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable({ keepExistingData: true });
+                yield writable.write('1');
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('1..');
+            }));
+            test('can seek and then write', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '...',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable({ keepExistingData: true });
+                writable.seek(1);
+                yield writable.write('1');
+                yield writable.write('2');
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('...');
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('.12');
+            }));
+            test('does not commit changes before .close() is called', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '...',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable();
+                yield writable.write('1');
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('...');
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('1');
+            }));
+            test('does not commit changes if .abort() is called and removes the swap file', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '...',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable();
+                yield writable.write('1');
+                expect(fs.__vol.toJSON()).toStrictEqual({
+                    '/file.txt': '...',
+                    '/file.txt.crswap': '1',
+                });
+                yield writable.abort();
+                expect(fs.__vol.toJSON()).toStrictEqual({
+                    '/file.txt': '...',
+                });
+            }));
+        });
+        describe('.write(options)', () => {
+            test('can write at offset, when providing position in write call', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '...',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable({ keepExistingData: true });
+                yield writable.write({ type: 'write', position: 1, data: '1' });
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('.1.');
+            }));
+            test('can seek and then write', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '...',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable({ keepExistingData: true });
+                yield writable.write({ type: 'seek', position: 1 });
+                yield writable.write({ type: 'write', data: Buffer.from('1') });
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('.1.');
+            }));
+            test('can seek and then write', () => __awaiter(void 0, void 0, void 0, function* () {
+                const { dir, fs } = setup({
+                    'file.txt': '...',
+                });
+                const entry = yield dir.getFileHandle('file.txt');
+                const writable = yield entry.createWritable({ keepExistingData: true });
+                yield writable.write({ type: 'seek', position: 1 });
+                yield writable.write({ type: 'write', data: Buffer.from('1') });
+                yield writable.close();
+                expect(fs.readFileSync('/file.txt', 'utf8')).toBe('.1.');
+            }));
+        });
+    });
+});

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

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

package/lib/node-to-fsa/__tests__/NodeFileSystemHandle.test.js

@@ -0,0 +1,49 @@
+"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 });
+const __1 = require("../..");
+const NodeFileSystemDirectoryHandle_1 = require("../NodeFileSystemDirectoryHandle");
+const util_1 = require("../../__tests__/util");
+const setup = (json = {}) => {
+    const fs = (0, __1.memfs)(json, '/');
+    const dir = new NodeFileSystemDirectoryHandle_1.NodeFileSystemDirectoryHandle(fs, '/', { mode: 'readwrite' });
+    return { dir, fs };
+};
+(0, util_1.onlyOnNode20)('NodeFileSystemHandle', () => {
+    test('can instantiate', () => {
+        const { dir } = setup();
+        expect(dir).toBeInstanceOf(NodeFileSystemDirectoryHandle_1.NodeFileSystemDirectoryHandle);
+    });
+    describe('.isSameEntry()', () => {
+        test('returns true for the same root entry', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup();
+            expect(dir.isSameEntry(dir)).toBe(true);
+        }));
+        test('returns true for two different instances of the same entry', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                subdir: null,
+            });
+            const subdir = yield dir.getDirectoryHandle('subdir');
+            expect(subdir.isSameEntry(subdir)).toBe(true);
+            expect(dir.isSameEntry(dir)).toBe(true);
+            expect(dir.isSameEntry(subdir)).toBe(false);
+            expect(subdir.isSameEntry(dir)).toBe(false);
+        }));
+        test('returns false when comparing file with a directory', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                file: 'lala',
+            });
+            const file = yield dir.getFileHandle('file');
+            expect(file.isSameEntry(dir)).toBe(false);
+            expect(dir.isSameEntry(file)).toBe(false);
+        }));
+    });
+});

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

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

package/lib/node-to-fsa/__tests__/NodeFileSystemSyncAccessHandle.test.js

@@ -0,0 +1,183 @@
+"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 });
+const __1 = require("../..");
+const NodeFileSystemDirectoryHandle_1 = require("../NodeFileSystemDirectoryHandle");
+const NodeFileSystemSyncAccessHandle_1 = require("../NodeFileSystemSyncAccessHandle");
+const util_1 = require("../../__tests__/util");
+const setup = (json = {}) => {
+    const fs = (0, __1.memfs)(json, '/');
+    const dir = new NodeFileSystemDirectoryHandle_1.NodeFileSystemDirectoryHandle(fs, '/', { syncHandleAllowed: true, mode: 'readwrite' });
+    return { dir, fs };
+};
+(0, util_1.onlyOnNode20)('NodeFileSystemSyncAccessHandle', () => {
+    describe('.close()', () => {
+        test('can close the file', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                'file.txt': 'Hello, world!',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            expect(sync).toBeInstanceOf(NodeFileSystemSyncAccessHandle_1.NodeFileSystemSyncAccessHandle);
+            yield sync.close();
+            // ...
+        }));
+    });
+    describe('.flush()', () => {
+        test('can flush', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                'file.txt': 'Hello, world!',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            yield sync.flush();
+        }));
+    });
+    describe('.getSize()', () => {
+        test('can get file size', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                'file.txt': 'Hello, world!',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            const size = yield sync.getSize();
+            expect(size).toBe(13);
+        }));
+    });
+    describe('.getSize()', () => {
+        test('can get file size', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                'file.txt': 'Hello, world!',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            const size = yield sync.getSize();
+            expect(size).toBe(13);
+        }));
+    });
+    describe('.read()', () => {
+        test('can read from beginning', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                'file.txt': '0123456789',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            const buf = new Uint8Array(5);
+            const size = yield sync.read(buf);
+            expect(size).toBe(5);
+            expect(Buffer.from(buf).toString()).toBe('01234');
+        }));
+        test('can read at offset', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                'file.txt': '0123456789',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            const buf = new Uint8Array(3);
+            const size = yield sync.read(buf, { at: 3 });
+            expect(size).toBe(3);
+            expect(Buffer.from(buf).toString()).toBe('345');
+        }));
+        test('can read into buffer larger than file', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                'file.txt': '0123456789',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            const buf = new Uint8Array(25);
+            const size = yield sync.read(buf);
+            expect(size).toBe(10);
+            expect(Buffer.from(buf).slice(0, 10).toString()).toBe('0123456789');
+        }));
+        test('throws "InvalidStateError" DOMException if handle is closed', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                'file.txt': '0123456789',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            yield sync.close();
+            const buf = new Uint8Array(25);
+            try {
+                const size = yield sync.read(buf);
+                throw new Error('No error was thrown');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DOMException);
+                expect(error.name).toBe('InvalidStateError');
+            }
+        }));
+    });
+    describe('.truncate()', () => {
+        test('can read from beginning', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir } = setup({
+                'file.txt': '0123456789',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            const res = yield sync.truncate(5);
+            expect(res).toBe(undefined);
+        }));
+    });
+    describe('.write()', () => {
+        test('can write to the file', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir, fs } = setup({
+                'file.txt': '0123456789',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            const res = yield sync.write(Buffer.from('Hello'));
+            expect(res).toBe(5);
+            expect(fs.readFileSync('/file.txt', 'utf8')).toBe('Hello56789');
+        }));
+        test('can write at an offset', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir, fs } = setup({
+                'file.txt': '0123456789',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            const res = yield sync.write(Buffer.from('Hello'), { at: 7 });
+            expect(res).toBe(5);
+            expect(fs.readFileSync('/file.txt', 'utf8')).toBe('0123456Hello');
+        }));
+        test('throws "InvalidStateError" DOMException if file descriptor is already closed', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir, fs } = setup({
+                'file.txt': '0123456789',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            yield sync.write(Buffer.from('a'));
+            yield sync.close();
+            try {
+                yield sync.write(Buffer.from('b'));
+                throw new Error('No error was thrown');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DOMException);
+                expect(error.name).toBe('InvalidStateError');
+            }
+        }));
+        // TODO: Need to find out what is the correct behavior here.
+        xtest('writing at offset past file size', () => __awaiter(void 0, void 0, void 0, function* () {
+            const { dir, fs } = setup({
+                'file.txt': '0123456789',
+            });
+            const entry = yield dir.getFileHandle('file.txt');
+            const sync = yield entry.createSyncAccessHandle();
+            try {
+                yield sync.write(Buffer.from('a'), { at: 100 });
+                // ?
+            }
+            catch (error) {
+                // ?
+            }
+        }));
+    });
+});

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

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

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

@@ -0,0 +1,106 @@
+"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 });
+const __1 = require("../..");
+const FileHandle_1 = require("../../node/FileHandle");
+const NodeFileSystemWritableFileStream_1 = require("../NodeFileSystemWritableFileStream");
+describe('createSwapFile()', () => {
+    test('can create a swap file', () => __awaiter(void 0, void 0, void 0, function* () {
+        const fs = (0, __1.memfs)({
+            '/file.txt': 'Hello, world!',
+        }, '/');
+        const [handle, path] = yield (0, NodeFileSystemWritableFileStream_1.createSwapFile)(fs, '/file.txt', false);
+        expect(handle).toBeInstanceOf(FileHandle_1.FileHandle);
+        expect(path).toBe('/file.txt.crswap');
+        expect(fs.__vol.toJSON()).toStrictEqual({
+            '/file.txt': 'Hello, world!',
+            '/file.txt.crswap': '',
+        });
+    }));
+    test('can create a swap file at subfolder', () => __awaiter(void 0, void 0, void 0, function* () {
+        const fs = (0, __1.memfs)({
+            '/foo/file.txt': 'Hello, world!',
+        }, '/');
+        const [handle, path] = yield (0, NodeFileSystemWritableFileStream_1.createSwapFile)(fs, '/foo/file.txt', false);
+        expect(handle).toBeInstanceOf(FileHandle_1.FileHandle);
+        expect(path).toBe('/foo/file.txt.crswap');
+        expect(fs.__vol.toJSON()).toStrictEqual({
+            '/foo/file.txt': 'Hello, world!',
+            '/foo/file.txt.crswap': '',
+        });
+    }));
+    test('can create a swap file when the default swap file name is in use', () => __awaiter(void 0, void 0, void 0, function* () {
+        const fs = (0, __1.memfs)({
+            '/foo/file.txt': 'Hello, world!',
+            '/foo/file.txt.crswap': 'lala',
+        }, '/');
+        const [handle, path] = yield (0, NodeFileSystemWritableFileStream_1.createSwapFile)(fs, '/foo/file.txt', false);
+        expect(handle).toBeInstanceOf(FileHandle_1.FileHandle);
+        expect(path).toBe('/foo/file.txt.1.crswap');
+        expect(fs.__vol.toJSON()).toStrictEqual({
+            '/foo/file.txt': 'Hello, world!',
+            '/foo/file.txt.crswap': 'lala',
+            '/foo/file.txt.1.crswap': '',
+        });
+    }));
+    test('can create a swap file when the first two names are already taken', () => __awaiter(void 0, void 0, void 0, function* () {
+        const fs = (0, __1.memfs)({
+            '/foo/file.txt': 'Hello, world!',
+            '/foo/file.txt.crswap': 'lala',
+            '/foo/file.txt.1.crswap': 'blah',
+        }, '/');
+        const [handle, path] = yield (0, NodeFileSystemWritableFileStream_1.createSwapFile)(fs, '/foo/file.txt', false);
+        expect(handle).toBeInstanceOf(FileHandle_1.FileHandle);
+        expect(path).toBe('/foo/file.txt.2.crswap');
+        expect(fs.__vol.toJSON()).toStrictEqual({
+            '/foo/file.txt': 'Hello, world!',
+            '/foo/file.txt.crswap': 'lala',
+            '/foo/file.txt.1.crswap': 'blah',
+            '/foo/file.txt.2.crswap': '',
+        });
+    }));
+    test('can create a swap file when the first three names are already taken', () => __awaiter(void 0, void 0, void 0, function* () {
+        const fs = (0, __1.memfs)({
+            '/foo/file.txt': 'Hello, world!',
+            '/foo/file.txt.crswap': 'lala',
+            '/foo/file.txt.1.crswap': 'blah',
+            '/foo/file.txt.2.crswap': 'brawo',
+        }, '/');
+        const [handle, path] = yield (0, NodeFileSystemWritableFileStream_1.createSwapFile)(fs, '/foo/file.txt', false);
+        expect(handle).toBeInstanceOf(FileHandle_1.FileHandle);
+        expect(path).toBe('/foo/file.txt.3.crswap');
+        expect(fs.__vol.toJSON()).toStrictEqual({
+            '/foo/file.txt': 'Hello, world!',
+            '/foo/file.txt.crswap': 'lala',
+            '/foo/file.txt.1.crswap': 'blah',
+            '/foo/file.txt.2.crswap': 'brawo',
+            '/foo/file.txt.3.crswap': '',
+        });
+    }));
+    test('can copy existing data into the swap file', () => __awaiter(void 0, void 0, void 0, function* () {
+        const fs = (0, __1.memfs)({
+            '/foo/file.txt': 'Hello, world!',
+            '/foo/file.txt.crswap': 'lala',
+            '/foo/file.txt.1.crswap': 'blah',
+            '/foo/file.txt.2.crswap': 'brawo',
+        }, '/');
+        const [handle, path] = yield (0, NodeFileSystemWritableFileStream_1.createSwapFile)(fs, '/foo/file.txt', true);
+        expect(handle).toBeInstanceOf(FileHandle_1.FileHandle);
+        expect(path).toBe('/foo/file.txt.3.crswap');
+        expect(fs.__vol.toJSON()).toStrictEqual({
+            '/foo/file.txt': 'Hello, world!',
+            '/foo/file.txt.crswap': 'lala',
+            '/foo/file.txt.1.crswap': 'blah',
+            '/foo/file.txt.2.crswap': 'brawo',
+            '/foo/file.txt.3.crswap': 'Hello, world!',
+        });
+    }));
+});

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

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

package/lib/node-to-fsa/__tests__/scenarios.test.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 });
+const __1 = require("..");
+const __2 = require("../..");
+const util_1 = require("../../__tests__/util");
+(0, util_1.onlyOnNode20)('scenarios', () => {
+    test('can init FSA from an arbitrary FS folder and execute operations', () => __awaiter(void 0, void 0, void 0, function* () {
+        const fs = (0, __2.memfs)({
+            '/tmp': null,
+            '/etc': null,
+            '/bin': null,
+            '/Users/kasper/Documents/shopping-list.txt': 'Milk, Eggs, Bread',
+        });
+        const dir = (0, __1.nodeToFsa)(fs, '/Users/kasper/Documents', { mode: 'readwrite' });
+        const shoppingListFile = yield dir.getFileHandle('shopping-list.txt');
+        const shoppingList = yield shoppingListFile.getFile();
+        expect(yield shoppingList.text()).toBe('Milk, Eggs, Bread');
+        const backupsDir = yield dir.getDirectoryHandle('backups', { create: true });
+        const backupFile = yield backupsDir.getFileHandle('shopping-list.txt', { create: true });
+        const writable = yield backupFile.createWritable();
+        yield writable.write(yield shoppingList.arrayBuffer());
+        yield writable.close();
+        const logsFileHandle = yield dir.getFileHandle('logs.csv', { create: true });
+        const logsWritable = yield logsFileHandle.createWritable();
+        yield logsWritable.write('timestamp,level,message\n');
+        yield logsWritable.write({ type: 'write', data: '2021-01-01T00:00:00Z,INFO,Hello World\n' });
+        yield logsWritable.close();
+        expect(fs.__vol.toJSON()).toStrictEqual({
+            '/tmp': null,
+            '/etc': null,
+            '/bin': null,
+            '/Users/kasper/Documents/shopping-list.txt': 'Milk, Eggs, Bread',
+            '/Users/kasper/Documents/backups/shopping-list.txt': 'Milk, Eggs, Bread',
+            '/Users/kasper/Documents/logs.csv': 'timestamp,level,message\n2021-01-01T00:00:00Z,INFO,Hello World\n',
+        });
+    }));
+});

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

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

package/lib/node-to-fsa/__tests__/util.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+describe('basename()', () => {
+    test('handles empty string', () => {
+        expect((0, util_1.basename)('', '/')).toBe('');
+    });
+    test('return the same string if there is no nesting', () => {
+        expect((0, util_1.basename)('scary.exe', '/')).toBe('scary.exe');
+    });
+    test('returns last step in path', () => {
+        expect((0, util_1.basename)('/gg/wp/hf/gl.txt', '/')).toBe('gl.txt');
+        expect((0, util_1.basename)('gg/wp/hf/gl.txt', '/')).toBe('gl.txt');
+        expect((0, util_1.basename)('/wp/hf/gl.txt', '/')).toBe('gl.txt');
+        expect((0, util_1.basename)('wp/hf/gl.txt', '/')).toBe('gl.txt');
+        expect((0, util_1.basename)('/hf/gl.txt', '/')).toBe('gl.txt');
+        expect((0, util_1.basename)('hf/gl.txt', '/')).toBe('gl.txt');
+        expect((0, util_1.basename)('/gl.txt', '/')).toBe('gl.txt');
+        expect((0, util_1.basename)('gl.txt', '/')).toBe('gl.txt');
+    });
+    test('handles double slashes', () => {
+        expect((0, util_1.basename)('/gg/wp/hf//gl.txt', '/')).toBe('gl.txt');
+        expect((0, util_1.basename)('//gl.txt', '/')).toBe('gl.txt');
+    });
+});

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

@@ -0,0 +1,7 @@
+import { NodeFileSystemDirectoryHandle } from './NodeFileSystemDirectoryHandle';
+import { NodeFsaContext, NodeFsaFs } from './types';
+export * from './types';
+export * from './NodeFileSystemHandle';
+export * from './NodeFileSystemDirectoryHandle';
+export * from './NodeFileSystemFileHandle';
+export declare const nodeToFsa: (fs: NodeFsaFs, dirPath: string, ctx?: Partial<NodeFsaContext>) => NodeFileSystemDirectoryHandle;

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

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeToFsa = void 0;
+const NodeFileSystemDirectoryHandle_1 = require("./NodeFileSystemDirectoryHandle");
+__exportStar(require("./types"), exports);
+__exportStar(require("./NodeFileSystemHandle"), exports);
+__exportStar(require("./NodeFileSystemDirectoryHandle"), exports);
+__exportStar(require("./NodeFileSystemFileHandle"), exports);
+const nodeToFsa = (fs, dirPath, ctx) => {
+    return new NodeFileSystemDirectoryHandle_1.NodeFileSystemDirectoryHandle(fs, dirPath, ctx);
+};
+exports.nodeToFsa = nodeToFsa;