Initial commit

node_modules/memfs/lib/fsa-to-node/worker/FsaNodeSyncAdapterWorker.d.ts

@@ -0,0 +1,10 @@
+import { SyncMessenger } from './SyncMessenger';
+import type * as fsa from '../../fsa/types';
+import type { FsaNodeSyncAdapter, FsaNodeSyncAdapterApi } from '../types';
+export declare class FsaNodeSyncAdapterWorker implements FsaNodeSyncAdapter {
+    protected readonly messenger: SyncMessenger;
+    protected readonly root: fsa.IFileSystemDirectoryHandle;
+    static start(url: string, dir: fsa.IFileSystemDirectoryHandle | Promise<fsa.IFileSystemDirectoryHandle>): Promise<FsaNodeSyncAdapterWorker>;
+    constructor(messenger: SyncMessenger, root: fsa.IFileSystemDirectoryHandle);
+    call<K extends keyof FsaNodeSyncAdapterApi>(method: K, payload: Parameters<FsaNodeSyncAdapterApi[K]>[0]): ReturnType<FsaNodeSyncAdapterApi[K]>;
+}

node_modules/memfs/lib/fsa-to-node/worker/FsaNodeSyncAdapterWorker.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeSyncAdapterWorker = void 0;
+const Defer_1 = require("../../thingies/Defer");
+const SyncMessenger_1 = require("./SyncMessenger");
+const json_1 = require("../json");
+let rootId = 0;
+class FsaNodeSyncAdapterWorker {
+    static async start(url, dir) {
+        const worker = new Worker(url);
+        const future = new Defer_1.Defer();
+        let id = rootId++;
+        let messenger = undefined;
+        const _dir = await dir;
+        worker.onmessage = e => {
+            const data = e.data;
+            if (!Array.isArray(data))
+                return;
+            const msg = data;
+            const code = msg[0];
+            switch (code) {
+                case 0 /* FsaNodeWorkerMessageCode.Init */: {
+                    const [, sab] = msg;
+                    messenger = new SyncMessenger_1.SyncMessenger(sab);
+                    const setRootMessage = [1 /* FsaNodeWorkerMessageCode.SetRoot */, id, _dir];
+                    worker.postMessage(setRootMessage);
+                    break;
+                }
+                case 2 /* FsaNodeWorkerMessageCode.RootSet */: {
+                    const [, rootId] = msg;
+                    if (id !== rootId)
+                        return;
+                    const adapter = new FsaNodeSyncAdapterWorker(messenger, _dir);
+                    future.resolve(adapter);
+                    break;
+                }
+            }
+        };
+        return await future.promise;
+    }
+    constructor(messenger, root) {
+        this.messenger = messenger;
+        this.root = root;
+    }
+    call(method, payload) {
+        const request = [3 /* FsaNodeWorkerMessageCode.Request */, method, payload];
+        const encoded = json_1.encoder.encode(request);
+        const encodedResponse = this.messenger.callSync(encoded);
+        const [code, data] = json_1.decoder.decode(encodedResponse);
+        switch (code) {
+            case 4 /* FsaNodeWorkerMessageCode.Response */:
+                return data;
+            case 5 /* FsaNodeWorkerMessageCode.ResponseError */:
+                throw data;
+            default: {
+                throw new Error('Invalid response message code');
+            }
+        }
+    }
+}
+exports.FsaNodeSyncAdapterWorker = FsaNodeSyncAdapterWorker;
+//# sourceMappingURL=FsaNodeSyncAdapterWorker.js.map

node_modules/memfs/lib/fsa-to-node/worker/FsaNodeSyncAdapterWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FsaNodeSyncAdapterWorker.js","sourceRoot":"","sources":["../../../src/fsa-to-node/worker/FsaNodeSyncAdapterWorker.ts"],"names":[],"mappings":";;;AAAA,gDAA6C;AAE7C,mDAAgD;AAChD,kCAA2C;AAa3C,IAAI,MAAM,GAAG,CAAC,CAAC;AAEf,MAAa,wBAAwB;IAC5B,MAAM,CAAC,KAAK,CAAC,KAAK,CACvB,GAAW,EACX,GAA6E;QAE7E,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;QAC/B,MAAM,MAAM,GAAG,IAAI,aAAK,EAA4B,CAAC;QACrD,IAAI,EAAE,GAAG,MAAM,EAAE,CAAC;QAClB,IAAI,SAAS,GAA8B,SAAS,CAAC;QACrD,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC;QACvB,MAAM,CAAC,SAAS,GAAG,CAAC,CAAC,EAAE;YACrB,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC;YACpB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;gBAAE,OAAO;YACjC,MAAM,GAAG,GAAG,IAAwB,CAAC;YACrC,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,CAA6B,CAAC;YAChD,QAAQ,IAAI,EAAE,CAAC;gBACb,0CAAkC,CAAC,CAAC,CAAC;oBACnC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,GAA2B,CAAC;oBAC5C,SAAS,GAAG,IAAI,6BAAa,CAAC,GAAG,CAAC,CAAC;oBACnC,MAAM,cAAc,GAA4B,2CAAmC,EAAE,EAAE,IAAI,CAAC,CAAC;oBAC7F,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;oBACnC,MAAM;gBACR,CAAC;gBACD,6CAAqC,CAAC,CAAC,CAAC;oBACtC,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,GAA8B,CAAC;oBAClD,IAAI,EAAE,KAAK,MAAM;wBAAE,OAAO;oBAC1B,MAAM,OAAO,GAAG,IAAI,wBAAwB,CAAC,SAAU,EAAE,IAAI,CAAC,CAAC;oBAC/D,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;oBACxB,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC,CAAC;QACF,OAAO,MAAM,MAAM,CAAC,OAAO,CAAC;IAC9B,CAAC;IAED,YACqB,SAAwB,EACxB,IAAoC;QADpC,cAAS,GAAT,SAAS,CAAe;QACxB,SAAI,GAAJ,IAAI,CAAgC;IACtD,CAAC;IAEG,IAAI,CACT,MAAS,EACT,OAAgD;QAEhD,MAAM,OAAO,GAA4B,2CAAmC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC7F,MAAM,OAAO,GAAG,cAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACxC,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAEzD,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,cAAO,CAAC,MAAM,CAAC,eAAe,CAAY,CAAC;QAChE,QAAQ,IAAI,EAAE,CAAC;YACb;gBACE,OAAO,IAAW,CAAC;YACrB;gBACE,MAAM,IAAI,CAAC;YACb,OAAO,CAAC,CAAC,CAAC;gBACR,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;YACnD,CAAC;QACH,CAAC;IACH,CAAC;CACF;AA3DD,4DA2DC"}

node_modules/memfs/lib/fsa-to-node/worker/FsaNodeSyncWorker.d.ts

@@ -0,0 +1,20 @@
+import { AsyncCallback, SyncMessenger } from './SyncMessenger';
+import { FsaNodeFs } from '../FsaNodeFs';
+import type * as fsa from '../../fsa/types';
+import type { FsaNodeWorkerMsg } from './types';
+import type { FsaNodeSyncAdapterApi } from '../types';
+export declare class FsaNodeSyncWorker {
+    protected readonly sab: SharedArrayBuffer;
+    protected readonly messenger: SyncMessenger;
+    protected root: fsa.IFileSystemDirectoryHandle;
+    protected fs: FsaNodeFs;
+    start(): void;
+    protected onPostMessage: (msg: FsaNodeWorkerMsg) => void;
+    protected readonly onRequest: AsyncCallback;
+    protected getDir(path: string[], create: boolean, funcName?: string): Promise<fsa.IFileSystemDirectoryHandle>;
+    protected getFile(path: string[], name: string, funcName?: string, create?: boolean): Promise<fsa.IFileSystemFileHandle>;
+    protected getFileOrDir(path: string[], name: string, funcName?: string, create?: boolean): Promise<fsa.IFileSystemFileHandle | fsa.IFileSystemDirectoryHandle>;
+    protected handlers: {
+        [K in keyof FsaNodeSyncAdapterApi]: (request: Parameters<FsaNodeSyncAdapterApi[K]>[0]) => Promise<ReturnType<FsaNodeSyncAdapterApi[K]>>;
+    };
+}

node_modules/memfs/lib/fsa-to-node/worker/FsaNodeSyncWorker.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeSyncWorker = void 0;
+const SyncMessenger_1 = require("./SyncMessenger");
+const FsaNodeFs_1 = require("../FsaNodeFs");
+const json_1 = require("../json");
+class FsaNodeSyncWorker {
+    constructor() {
+        this.sab = new SharedArrayBuffer(1024 * 1024);
+        this.messenger = new SyncMessenger_1.SyncMessenger(this.sab);
+        this.onPostMessage = (msg) => {
+            switch (msg[0]) {
+                case 1 /* FsaNodeWorkerMessageCode.SetRoot */: {
+                    const [, id, dir] = msg;
+                    this.root = dir;
+                    this.fs = new FsaNodeFs_1.FsaNodeFs(this.root);
+                    const response = [2 /* FsaNodeWorkerMessageCode.RootSet */, id];
+                    postMessage(response);
+                    this.messenger.serveAsync(this.onRequest);
+                    break;
+                }
+            }
+        };
+        this.onRequest = async (request) => {
+            try {
+                const message = json_1.decoder.decode(request);
+                if (!Array.isArray(message))
+                    throw new Error('Invalid message format');
+                const code = message[0];
+                if (code !== 3 /* FsaNodeWorkerMessageCode.Request */)
+                    throw new Error('Invalid message code');
+                const [, method, payload] = message;
+                const handler = this.handlers[method];
+                if (!handler)
+                    throw new Error(`Unknown method ${method}`);
+                const response = await handler(payload);
+                return json_1.encoder.encode([4 /* FsaNodeWorkerMessageCode.Response */, response]);
+            }
+            catch (err) {
+                const message = err && typeof err === 'object' && err.message ? err.message : 'Unknown error';
+                const error = { message };
+                if (err && typeof err === 'object' && (err.code || err.name))
+                    error.code = err.code || err.name;
+                return json_1.encoder.encode([5 /* FsaNodeWorkerMessageCode.ResponseError */, error]);
+            }
+        };
+        this.handlers = {
+            stat: async (location) => {
+                const handle = await this.getFileOrDir(location[0], location[1], 'statSync');
+                return {
+                    kind: handle.kind,
+                };
+            },
+            access: async ([filename, mode]) => {
+                await this.fs.promises.access(filename, mode);
+            },
+            readFile: async ([filename, opts]) => {
+                const buf = (await this.fs.promises.readFile(filename, Object.assign(Object.assign({}, opts), { encoding: 'buffer' })));
+                const uint8 = new Uint8Array(buf, buf.byteOffset, buf.byteLength);
+                return uint8;
+            },
+            writeFile: async ([filename, data, opts]) => {
+                await this.fs.promises.writeFile(filename, data, Object.assign(Object.assign({}, opts), { encoding: 'buffer' }));
+            },
+            appendFile: async ([filename, data, opts]) => {
+                await this.fs.promises.appendFile(filename, data, Object.assign(Object.assign({}, opts), { encoding: 'buffer' }));
+            },
+            copy: async ([src, dst, flags]) => {
+                await this.fs.promises.copyFile(src, dst, flags);
+            },
+            move: async ([src, dst]) => {
+                await this.fs.promises.rename(src, dst);
+            },
+            rmdir: async ([filename, options]) => {
+                await this.fs.promises.rmdir(filename, options);
+            },
+            rm: async ([filename, options]) => {
+                await this.fs.promises.rm(filename, options);
+            },
+            mkdir: async ([filename, options]) => {
+                return await this.fs.promises.mkdir(filename, options);
+            },
+            mkdtemp: async ([filename]) => {
+                return (await this.fs.promises.mkdtemp(filename, { encoding: 'utf8' }));
+            },
+            trunc: async ([filename, len]) => {
+                await this.fs.promises.truncate(filename, len);
+            },
+            unlink: async ([filename]) => {
+                await this.fs.promises.unlink(filename);
+            },
+            readdir: async ([filename]) => {
+                const list = (await this.fs.promises.readdir(filename, { withFileTypes: true, encoding: 'utf8' }));
+                const res = list.map(entry => ({
+                    kind: entry.isDirectory() ? 'directory' : 'file',
+                    name: entry.name,
+                }));
+                return res;
+            },
+            read: async ([filename, position, length]) => {
+                let uint8 = new Uint8Array(length);
+                const handle = await this.fs.promises.open(filename, 'r');
+                const bytesRead = await new Promise((resolve, reject) => {
+                    this.fs.read(handle.fd, uint8, 0, length, position, (err, bytesRead) => {
+                        if (err)
+                            return reject(err);
+                        resolve(bytesRead || length);
+                    });
+                });
+                if (bytesRead < length)
+                    uint8 = uint8.slice(0, bytesRead);
+                return uint8;
+            },
+            write: async ([filename, data, position]) => {
+                const handle = await this.fs.promises.open(filename, 'a');
+                const { bytesWritten } = await handle.write(data, 0, data.length, position || undefined);
+                return bytesWritten;
+            },
+            open: async ([filename, flags, mode]) => {
+                const handle = await this.fs.promises.open(filename, flags, mode);
+                const file = await this.fs.__getFileById(handle.fd);
+                await handle.close();
+                return file;
+            },
+        };
+    }
+    start() {
+        onmessage = e => {
+            if (!Array.isArray(e.data))
+                return;
+            this.onPostMessage(e.data);
+        };
+        const initMsg = [0 /* FsaNodeWorkerMessageCode.Init */, this.sab];
+        postMessage(initMsg);
+    }
+    async getDir(path, create, funcName) {
+        let curr = this.root;
+        const options = { create };
+        try {
+            for (const name of path) {
+                curr = await curr.getDirectoryHandle(name, options);
+            }
+        }
+        catch (error) {
+            // if (error && typeof error === 'object' && error.name === 'TypeMismatchError')
+            //   throw createError('ENOTDIR', funcName, path.join(FsaToNodeConstants.Separator));
+            throw error;
+        }
+        return curr;
+    }
+    async getFile(path, name, funcName, create) {
+        const dir = await this.getDir(path, false, funcName);
+        const file = await dir.getFileHandle(name, { create });
+        return file;
+    }
+    async getFileOrDir(path, name, funcName, create) {
+        const dir = await this.getDir(path, false, funcName);
+        try {
+            const file = await dir.getFileHandle(name);
+            return file;
+        }
+        catch (error) {
+            if (error && typeof error === 'object') {
+                switch (error.name) {
+                    case 'TypeMismatchError':
+                        return await dir.getDirectoryHandle(name);
+                    // case 'NotFoundError':
+                    //   throw createError('ENOENT', funcName, path.join(FsaToNodeConstants.Separator));
+                }
+            }
+            throw error;
+        }
+    }
+}
+exports.FsaNodeSyncWorker = FsaNodeSyncWorker;
+//# sourceMappingURL=FsaNodeSyncWorker.js.map

node_modules/memfs/lib/fsa-to-node/worker/SyncMessenger.d.ts

@@ -0,0 +1,24 @@
+export type AsyncCallback = (request: Uint8Array) => Promise<Uint8Array>;
+/**
+ * `SyncMessenger` allows to execute asynchronous code synchronously. The
+ * asynchronous code is executed in a Worker thread, while the main thread is
+ * blocked until the asynchronous code is finished.
+ *
+ * First four 4-byte words is the header, where the first word is used for Atomics
+ * notifications. The second word is used for spin-locking the main thread until
+ * the asynchronous code is finished. The third word is used to specify payload
+ * length. The fourth word is currently unused.
+ *
+ * The maximum payload size is the size of the SharedArrayBuffer minus the
+ * header size.
+ */
+export declare class SyncMessenger {
+    protected readonly sab: SharedArrayBuffer;
+    protected readonly int32: Int32Array;
+    protected readonly uint8: Uint8Array;
+    protected readonly headerSize: any;
+    protected readonly dataSize: any;
+    constructor(sab: SharedArrayBuffer);
+    callSync(data: Uint8Array): Uint8Array;
+    serveAsync(callback: AsyncCallback): void;
+}

node_modules/memfs/lib/fsa-to-node/worker/SyncMessenger.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncMessenger = void 0;
+/**
+ * @param condition Condition to wait for, when true, the function returns.
+ * @param ms Maximum time to wait in milliseconds.
+ */
+const sleepUntil = (condition, ms = 100) => {
+    const start = Date.now();
+    while (!condition()) {
+        const now = Date.now();
+        if (now - start > ms)
+            throw new Error('Timeout');
+    }
+};
+/**
+ * `SyncMessenger` allows to execute asynchronous code synchronously. The
+ * asynchronous code is executed in a Worker thread, while the main thread is
+ * blocked until the asynchronous code is finished.
+ *
+ * First four 4-byte words is the header, where the first word is used for Atomics
+ * notifications. The second word is used for spin-locking the main thread until
+ * the asynchronous code is finished. The third word is used to specify payload
+ * length. The fourth word is currently unused.
+ *
+ * The maximum payload size is the size of the SharedArrayBuffer minus the
+ * header size.
+ */
+class SyncMessenger {
+    constructor(sab) {
+        this.sab = sab;
+        this.int32 = new Int32Array(sab);
+        this.uint8 = new Uint8Array(sab);
+        this.headerSize = 4 * 4;
+        this.dataSize = sab.byteLength - this.headerSize;
+    }
+    callSync(data) {
+        const requestLength = data.length;
+        const headerSize = this.headerSize;
+        const int32 = this.int32;
+        int32[1] = 0;
+        int32[2] = requestLength;
+        this.uint8.set(data, headerSize);
+        Atomics.notify(int32, 0);
+        sleepUntil(() => int32[1] === 1);
+        const responseLength = int32[2];
+        const response = this.uint8.slice(headerSize, headerSize + responseLength);
+        return response;
+    }
+    serveAsync(callback) {
+        const headerSize = this.headerSize;
+        (async () => {
+            try {
+                const int32 = this.int32;
+                const res = Atomics.wait(int32, 0, 0);
+                if (res !== 'ok')
+                    throw new Error(`Unexpected Atomics.wait result: ${res}`);
+                const requestLength = this.int32[2];
+                const request = this.uint8.slice(headerSize, headerSize + requestLength);
+                const response = await callback(request);
+                const responseLength = response.length;
+                int32[2] = responseLength;
+                this.uint8.set(response, headerSize);
+                int32[1] = 1;
+            }
+            catch (_a) { }
+            this.serveAsync(callback);
+        })().catch(() => { });
+    }
+}
+exports.SyncMessenger = SyncMessenger;
+//# sourceMappingURL=SyncMessenger.js.map

node_modules/memfs/lib/fsa-to-node/worker/SyncMessenger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncMessenger.js","sourceRoot":"","sources":["../../../src/fsa-to-node/worker/SyncMessenger.ts"],"names":[],"mappings":"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"}

node_modules/memfs/lib/fsa-to-node/worker/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const enum FsaNodeWorkerMessageCode {
+    Init = 0,
+    SetRoot = 1,
+    RootSet = 2,
+    Request = 3,
+    Response = 4,
+    ResponseError = 5
+}

node_modules/memfs/lib/fsa-to-node/worker/constants.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=constants.js.map

node_modules/memfs/lib/fsa-to-node/worker/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/fsa-to-node/worker/constants.ts"],"names":[],"mappings":""}

node_modules/memfs/lib/fsa-to-node/worker/types.d.ts

@@ -0,0 +1,17 @@
+import type { IFileSystemDirectoryHandle } from '../../fsa/types';
+import type { FsaNodeWorkerMessageCode } from './constants';
+export type FsaNodeWorkerMsgInit = [type: FsaNodeWorkerMessageCode.Init, sab: SharedArrayBuffer];
+export type FsaNodeWorkerMsgSetRoot = [
+    type: FsaNodeWorkerMessageCode.SetRoot,
+    id: number,
+    dir: IFileSystemDirectoryHandle
+];
+export type FsaNodeWorkerMsgRootSet = [type: FsaNodeWorkerMessageCode.RootSet, id: number];
+export type FsaNodeWorkerMsgRequest = [type: FsaNodeWorkerMessageCode.Request, method: string, data: unknown];
+export type FsaNodeWorkerMsgResponse = [type: FsaNodeWorkerMessageCode.Response, data: unknown];
+export type FsaNodeWorkerMsgResponseError = [type: FsaNodeWorkerMessageCode.ResponseError, data: unknown];
+export interface FsaNodeWorkerError {
+    message: string;
+    code?: string;
+}
+export type FsaNodeWorkerMsg = FsaNodeWorkerMsgInit | FsaNodeWorkerMsgSetRoot | FsaNodeWorkerMsgRootSet | FsaNodeWorkerMsgRequest | FsaNodeWorkerMsgResponse | FsaNodeWorkerMsgResponseError;

node_modules/memfs/lib/fsa-to-node/worker/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

node_modules/memfs/lib/fsa-to-node/worker/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/fsa-to-node/worker/types.ts"],"names":[],"mappings":""}